Return to gestion_objets.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.4 ! bertrand 3: RPL/2 (R) version 4.0.11
1.1 bertrand 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Routine de gestion du nombre d'occurrences comme grandeur atomique
29: ================================================================================
30: entrées : structure sur l'état du processus et objet à afficher
31: --------------------------------------------------------------------------------
32: sorties : chaine de caractères
33: --------------------------------------------------------------------------------
34: effets de bord : néant
35: ================================================================================
36: */
37:
38: static inline void
39: incrementation_atomique(struct_objet *s_objet)
40: {
41: // Le mutex est sur l'objet.
42:
43: (*s_objet).nombre_occurrences++;
44:
45: BUG((*s_objet).nombre_occurrences <= 0,
46: uprintf("Capacity exceeded %ld\n", (*s_objet).nombre_occurrences));
47:
48: return;
49: }
50:
51: static inline long
52: decrementation_atomique(struct_objet *s_objet)
53: {
54: // Le mutex est sur l'objet.
55:
56: (*s_objet).nombre_occurrences--;
57: return((*s_objet).nombre_occurrences);
58: }
59:
60: inline void
61: initialisation_objet(struct_objet *s_objet)
62: {
63: pthread_mutexattr_t attributs_mutex;
64:
65: pthread_mutexattr_init(&attributs_mutex);
66: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
67: pthread_mutex_init(&((*s_objet).mutex), &attributs_mutex);
68: pthread_mutexattr_destroy(&attributs_mutex);
69:
70: (*s_objet).nombre_occurrences = 1;
71:
72: return;
73: }
74:
75:
76: /*
77: ================================================================================
78: Routines d'initialisation et de purge de l'allocateur
79: ================================================================================
80: Entrées : structure sur l'état du processus et objet à afficher
81: --------------------------------------------------------------------------------
82: Sorties : chaine de caractères
83: --------------------------------------------------------------------------------
84: Effets de bord : néant
85: ================================================================================
86: */
87:
88: void
89: initialisation_allocateur(struct_processus *s_etat_processus)
90: {
91: (*s_etat_processus).estimation_taille_pile_tampon = 0;
92: (*s_etat_processus).taille_pile_tampon = 0;
93: (*s_etat_processus).pile_tampon = NULL;
94:
95: (*s_etat_processus).estimation_taille_pile_systeme_tampon = 0;
96: (*s_etat_processus).taille_pile_systeme_tampon = 0;
97: (*s_etat_processus).pile_systeme_tampon = NULL;
98:
99: (*s_etat_processus).taille_pile_objets = 0;
100: (*s_etat_processus).pile_objets = NULL;
101:
102: (*s_etat_processus).pointeur_adr = 0;
103: (*s_etat_processus).pointeur_bin = 0;
104: (*s_etat_processus).pointeur_cpl = 0;
105: (*s_etat_processus).pointeur_fct = 0;
106: (*s_etat_processus).pointeur_int = 0;
107: (*s_etat_processus).pointeur_mat = 0;
108: (*s_etat_processus).pointeur_nom = 0;
109: (*s_etat_processus).pointeur_rel = 0;
110: (*s_etat_processus).pointeur_tab = 0;
111: (*s_etat_processus).pointeur_vec = 0;
112: (*s_etat_processus).pointeur_maillons = 0;
113:
114: return;
115: }
116:
117:
118: void
119: liberation_allocateur(struct_processus *s_etat_processus)
120: {
121: int i;
122:
123: for(i = 0; i < (*s_etat_processus).pointeur_adr;
124: free((*s_etat_processus).objets_adr[i++]));
125: for(i = 0; i < (*s_etat_processus).pointeur_bin;
126: free((*s_etat_processus).objets_bin[i++]));
127: for(i = 0; i < (*s_etat_processus).pointeur_cpl;
128: free((*s_etat_processus).objets_cpl[i++]));
129: for(i = 0; i < (*s_etat_processus).pointeur_fct;
130: free((*s_etat_processus).objets_fct[i++]));
131: for(i = 0; i < (*s_etat_processus).pointeur_int;
132: free((*s_etat_processus).objets_int[i++]));
133: for(i = 0; i < (*s_etat_processus).pointeur_mat;
134: free((*s_etat_processus).objets_mat[i++]));
135: for(i = 0; i < (*s_etat_processus).pointeur_nom;
136: free((*s_etat_processus).objets_nom[i++]));
137: for(i = 0; i < (*s_etat_processus).pointeur_rel;
138: free((*s_etat_processus).objets_rel[i++]));
139: for(i = 0; i < (*s_etat_processus).pointeur_tab;
140: free((*s_etat_processus).objets_tab[i++]));
141: for(i = 0; i < (*s_etat_processus).pointeur_vec;
142: free((*s_etat_processus).objets_vec[i++]));
143: for(i = 0; i < (*s_etat_processus).pointeur_maillons;
144: free((*s_etat_processus).maillons[i++]));
145:
146: {
147: struct_liste_chainee *l_element_courant;
148: struct_liste_chainee *l_element_suivant;
149:
150: l_element_courant = (*s_etat_processus).pile_tampon;
151:
152: while(l_element_courant != NULL)
153: {
154: l_element_suivant = (*l_element_courant).suivant;
155: liberation(s_etat_processus, (*l_element_courant).donnee);
156: free(l_element_courant);
157: l_element_courant = l_element_suivant;
158: }
159: }
160:
161: {
162: struct_liste_pile_systeme *l_element_courant;
163: struct_liste_pile_systeme *l_element_suivant;
164:
165: l_element_courant = (*s_etat_processus).pile_systeme_tampon;
166:
167: while(l_element_courant != NULL)
168: {
169: l_element_suivant = (*l_element_courant).suivant;
170: free(l_element_courant);
171: l_element_courant = l_element_suivant;
172: }
173: }
174:
175: {
176: struct_objet *l_element_courant;
177: struct_objet *l_element_suivant;
178:
179: l_element_courant = (*s_etat_processus).pile_objets;
180:
181: while(l_element_courant != NULL)
182: {
183: l_element_suivant = (*l_element_courant).objet;
184:
185: if (pthread_mutex_destroy(&((*l_element_courant).mutex)) != 0)
186: {
187: (*s_etat_processus).erreur_systeme = d_es_processus;
188: BUG(1, printf("Mutex error\n"));
189: return;
190: }
191:
192: free(l_element_courant);
193: l_element_courant = l_element_suivant;
194: }
195: }
196:
197: return;
198: }
199:
200:
201: /*
202: ================================================================================
203: Routine d'allocation d'un maillon d'un objet (liste, expression...)
204: ================================================================================
205: Entrées : structure sur l'état du processus et objet à afficher
206: --------------------------------------------------------------------------------
207: Sorties : chaine de caractères
208: --------------------------------------------------------------------------------
209: Effets de bord : néant
210: ================================================================================
211: */
212:
213: void *
214: allocation_maillon(struct_processus *s_etat_processus)
215: {
216: struct_liste_chainee *s_maillon;
217:
218: if ((*s_etat_processus).pointeur_maillons > 0)
219: {
220: s_maillon = (*s_etat_processus).maillons
221: [--(*s_etat_processus).pointeur_maillons];
222: }
223: else
224: {
225: if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL)
226: {
227: return(NULL);
228: }
229: }
230:
231: return(s_maillon);
232: }
233:
234:
235: /*
236: ================================================================================
237: Routine d'allocation d'un maillon d'un objet (liste, expression...)
238: ================================================================================
239: Entrées : structure sur l'état du processus et objet à afficher
240: --------------------------------------------------------------------------------
241: Sorties : chaine de caractères
242: --------------------------------------------------------------------------------
243: Effets de bord : néant
244: ================================================================================
245: */
246:
247: void
248: liberation_maillon(struct_processus *s_etat_processus,
249: struct_liste_chainee *maillon)
250: {
251: if ((*s_etat_processus).pointeur_maillons < TAILLE_CACHE)
252: {
253: (*s_etat_processus).maillons
254: [(*s_etat_processus).pointeur_maillons++] = maillon;
255: }
256: else
257: {
258: free(maillon);
259: }
260:
261: return;
262: }
263:
264:
265: /*
266: ================================================================================
267: Routine d'allocation d'une structure *s_objet
268: ================================================================================
269: Entrées : structure sur l'état du processus et objet à afficher
270: --------------------------------------------------------------------------------
271: Sorties : chaine de caractères
272: --------------------------------------------------------------------------------
273: Effets de bord : néant
274: ================================================================================
275: */
276:
277: void *
278: allocation(struct_processus *s_etat_processus, enum t_type type)
279: {
280: struct_objet *s_objet;
281:
282: if ((*s_etat_processus).pile_objets == NULL)
283: {
284: // Il n'existe aucune structure struct_objet disponible dans le cache.
285:
286: if ((s_objet = malloc(sizeof(struct_objet))) == NULL)
287: {
288: return(NULL);
289: }
290:
291: initialisation_objet(s_objet);
292: }
293: else
294: {
295: // Récupération d'une structure dans le cache.
296:
297: s_objet = (*s_etat_processus).pile_objets;
298: (*s_etat_processus).pile_objets = (*s_objet).objet;
299: (*s_etat_processus).taille_pile_objets--;
300:
301: (*s_objet).nombre_occurrences = 1;
302: }
303:
304: (*s_objet).type = type;
305:
306: switch(type)
307: {
308: case ADR :
309: {
310: if ((*s_etat_processus).pointeur_adr > 0)
311: {
312: (*s_objet).objet = (*s_etat_processus).objets_adr
313: [--(*s_etat_processus).pointeur_adr];
314: }
315: else
316: {
317: if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL)
318: {
319: free(s_objet);
320: return(NULL);
321: }
322: }
323:
324: break;
325: }
326:
327: case ALG :
328: {
329: (*s_objet).objet = NULL;
330: break;
331: }
332:
333: case BIN :
334: {
335: if ((*s_etat_processus).pointeur_bin > 0)
336: {
337: (*s_objet).objet = (*s_etat_processus).objets_bin
338: [--(*s_etat_processus).pointeur_bin];
339: }
340: else
341: {
342: if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL)
343: {
344: free(s_objet);
345: return(NULL);
346: }
347: }
348:
349: break;
350: }
351:
352: case CHN :
353: {
354: (*s_objet).objet = NULL;
355: break;
356: }
357:
358: case CPL :
359: {
360: if ((*s_etat_processus).pointeur_cpl > 0)
361: {
362: (*s_objet).objet = (*s_etat_processus).objets_cpl
363: [--(*s_etat_processus).pointeur_cpl];
364: }
365: else
366: {
367: if (((*s_objet).objet = malloc(sizeof(struct_complexe16)))
368: == NULL)
369: {
370: free(s_objet);
371: return(NULL);
372: }
373: }
374:
375: break;
376: }
377:
378: case FCH :
379: {
380: if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL)
381: {
382: free(s_objet);
383: return(NULL);
384: }
385:
386: break;
387: }
388:
389: case FCT :
390: {
391: if ((*s_etat_processus).pointeur_fct > 0)
392: {
393: (*s_objet).objet = (*s_etat_processus).objets_fct
394: [--(*s_etat_processus).pointeur_fct];
395: }
396: else
397: {
398: if (((*s_objet).objet = malloc(sizeof(struct_fonction)))
399: == NULL)
400: {
401: free(s_objet);
402: return(NULL);
403: }
404: }
405:
406: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
407: break;
408: }
409:
410: case INT :
411: {
412: if ((*s_etat_processus).pointeur_int > 0)
413: {
414: (*s_objet).objet = (*s_etat_processus).objets_int
415: [--(*s_etat_processus).pointeur_int];
416: }
417: else
418: {
419: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
420: {
421: free(s_objet);
422: return(NULL);
423: }
424: }
425:
426: break;
427: }
428:
429: case LST :
430: {
431: (*s_objet).objet = NULL;
432: break;
433: }
434:
435: case MCX :
436: {
437: if ((*s_etat_processus).pointeur_mat > 0)
438: {
439: (*s_objet).objet = (*s_etat_processus).objets_mat
440: [--(*s_etat_processus).pointeur_mat];
441: }
442: else
443: {
444: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
445: {
446: free(s_objet);
447: return(NULL);
448: }
449: }
450:
451: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
452: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
453: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
454: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
455: break;
456: }
457:
458: case MIN :
459: {
460: if ((*s_etat_processus).pointeur_mat > 0)
461: {
462: (*s_objet).objet = (*s_etat_processus).objets_mat
463: [--(*s_etat_processus).pointeur_mat];
464: }
465: else
466: {
467: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
468: {
469: free(s_objet);
470: return(NULL);
471: }
472: }
473:
474: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
475: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
476: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
477: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
478: break;
479: }
480:
481: case MRL :
482: {
483: if ((*s_etat_processus).pointeur_mat > 0)
484: {
485: (*s_objet).objet = (*s_etat_processus).objets_mat
486: [--(*s_etat_processus).pointeur_mat];
487: }
488: else
489: {
490: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
491: {
492: free(s_objet);
493: return(NULL);
494: }
495: }
496:
497: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
498: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
499: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
500: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
501: break;
502: }
503:
504: case MTX :
505: {
506: if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
507: {
508: free(s_objet);
509: return(NULL);
510: }
511:
512: break;
513: }
514:
515: case NOM :
516: {
517: if ((*s_etat_processus).pointeur_nom > 0)
518: {
519: (*s_objet).objet = (*s_etat_processus).objets_nom
520: [--(*s_etat_processus).pointeur_nom];
521: }
522: else
523: {
524: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
525: {
526: free(s_objet);
527: return(NULL);
528: }
529: }
530:
531: break;
532: }
533:
534: case NON :
535: {
536: (*s_objet).objet = NULL;
537: break;
538: }
539:
540: case PRC :
541: {
542: if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
543: == NULL)
544: {
545: free(s_objet);
546: return(NULL);
547: }
548:
549: break;
550: }
551:
552: case REL :
553: {
554: if ((*s_etat_processus).pointeur_rel > 0)
555: {
556: (*s_objet).objet = (*s_etat_processus).objets_rel
557: [--(*s_etat_processus).pointeur_rel];
558: }
559: else
560: {
561: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
562: {
563: free(s_objet);
564: return(NULL);
565: }
566: }
567:
568: break;
569: }
570:
571: case RPN :
572: {
573: (*s_objet).objet = NULL;
574: break;
575: }
576:
577: case SCK :
578: {
579: if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
580: {
581: free(s_objet);
582: return(NULL);
583: }
584:
585: break;
586: }
587:
588: case SLB :
589: {
590: if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
591: == NULL)
592: {
593: free(s_objet);
594: return(NULL);
595: }
596:
597: break;
598: }
599:
600: case SPH :
601: {
602: if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
603: {
604: free(s_objet);
605: return(NULL);
606: }
607:
608: break;
609: }
610:
611: case SQL :
612: {
613: if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
614: == NULL)
615: {
616: free(s_objet);
617: return(NULL);
618: }
619:
620: break;
621: }
622:
623: case TBL :
624: {
625: if ((*s_etat_processus).pointeur_tab > 0)
626: {
627: (*s_objet).objet = (*s_etat_processus).objets_tab
628: [--(*s_etat_processus).pointeur_tab];
629: }
630: else
631: {
632: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
633: {
634: free(s_objet);
635: return(NULL);
636: }
637: }
638:
639: (*((struct_tableau *) (*s_objet).objet)).nombre_elements = 0;
640: (*((struct_tableau *) (*s_objet).objet)).elements = NULL;
641: break;
642: }
643:
644: case VCX :
645: {
646: if ((*s_etat_processus).pointeur_vec > 0)
647: {
648: (*s_objet).objet = (*s_etat_processus).objets_vec
649: [--(*s_etat_processus).pointeur_vec];
650: }
651: else
652: {
653: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
654: {
655: free(s_objet);
656: return(NULL);
657: }
658: }
659:
660: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
661: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
662: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
663: break;
664: }
665:
666: case VIN :
667: {
668: if ((*s_etat_processus).pointeur_vec > 0)
669: {
670: (*s_objet).objet = (*s_etat_processus).objets_vec
671: [--(*s_etat_processus).pointeur_vec];
672: }
673: else
674: {
675: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
676: {
677: free(s_objet);
678: return(NULL);
679: }
680: }
681:
682: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
683: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
684: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
685: break;
686: }
687:
688: case VRL :
689: {
690: if ((*s_etat_processus).pointeur_vec > 0)
691: {
692: (*s_objet).objet = (*s_etat_processus).objets_vec
693: [--(*s_etat_processus).pointeur_vec];
694: }
695: else
696: {
697: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
698: {
699: free(s_objet);
700: return(NULL);
701: }
702: }
703:
704: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
705: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
706: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
707: break;
708: }
709:
710: default :
711: {
712: free(s_objet);
713: BUG(1, printf("Allocation failure (type %d)\n", type));
714:
715: return(NULL);
716: }
717: }
718:
719: return(s_objet);
720: }
721:
722:
723: /*
724: ================================================================================
725: Routine de libération d'une structure *s_objet
726: ================================================================================
727: Entrées : structure sur l'état du processus et objet à afficher
728: --------------------------------------------------------------------------------
729: Sorties : chaine de caractères
730: --------------------------------------------------------------------------------
731: Effets de bord : néant
732: ================================================================================
733: */
734:
735: void
736: liberation(struct_processus *s_etat_processus, struct_objet *s_objet)
737: {
738: logical1 drapeau;
739:
740: struct_liste_chainee *l_element_courant;
741: struct_liste_chainee *l_element_suivant;
742:
743: unsigned long i;
744:
745: if (s_objet == NULL)
746: {
747: return;
748: }
749:
750: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
751: {
752: (*s_etat_processus).erreur_systeme = d_es_processus;
753: return;
754: }
755:
756: #define return \
757: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) \
758: { (*s_etat_processus).erreur_systeme = d_es_processus; return; } \
759: return
760:
761: BUG((*s_objet).nombre_occurrences <= 0,
762: pthread_mutex_unlock(&((*s_objet).mutex)),
763: printf("(*s_objet).nombre_occurrences=%ld\n",
764: (*s_objet).nombre_occurrences));
765:
766: switch((*s_objet).type)
767: {
768: case ADR :
769: {
770: if (decrementation_atomique(s_objet) > 0)
771: {
772: return;
773: }
774:
775: if ((*s_etat_processus).pointeur_adr < TAILLE_CACHE)
776: {
777: (*s_etat_processus).objets_adr
778: [(*s_etat_processus).pointeur_adr++] = (*s_objet).objet;
779: }
780: else
781: {
782: free((unsigned long *) ((*s_objet).objet));
783: }
784:
785: break;
786: }
787:
788: case ALG :
789: {
790: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
791:
792: if (decrementation_atomique(s_objet) > 0)
793: { // Il reste un pointeur sur l'objet.
794: while(l_element_courant != NULL)
795: {
796: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
797: pthread_mutex_unlock(&((*s_objet).mutex)),
798: printf("(*(*l_element_courant).donnee)"
799: ".nombre_occurrences=%ld\n",
800: (*(*l_element_courant).donnee).nombre_occurrences));
801:
802: liberation(s_etat_processus, (*l_element_courant).donnee);
803: l_element_courant = (*l_element_courant).suivant;
804: }
805:
806: return;
807: }
808: else
809: { // Il ne reste plus aucun pointeur sur l'objet.
810: while(l_element_courant != NULL)
811: {
812: l_element_suivant = (*l_element_courant).suivant;
813: liberation(s_etat_processus, (*l_element_courant).donnee);
814: liberation_maillon(s_etat_processus, l_element_courant);
815: l_element_courant = l_element_suivant;
816: }
817: }
818:
819: break;
820: }
821:
822: case BIN :
823: {
824: if (decrementation_atomique(s_objet) > 0)
825: {
826: return;
827: }
828:
829: if ((*s_etat_processus).pointeur_bin < TAILLE_CACHE)
830: {
831: (*s_etat_processus).objets_bin
832: [(*s_etat_processus).pointeur_bin++] = (*s_objet).objet;
833: }
834: else
835: {
836: free((logical8 *) ((*s_objet).objet));
837: }
838:
839: break;
840: }
841:
842: case CHN :
843: {
844: if (decrementation_atomique(s_objet) > 0)
845: {
846: return;
847: }
848:
849: free((unsigned char *) ((*s_objet).objet));
850: break;
851: }
852:
853: case CPL :
854: {
855: if (decrementation_atomique(s_objet) > 0)
856: {
857: return;
858: }
859:
860: if ((*s_etat_processus).pointeur_cpl < TAILLE_CACHE)
861: {
862: (*s_etat_processus).objets_cpl
863: [(*s_etat_processus).pointeur_cpl++] = (*s_objet).objet;
864: }
865: else
866: {
867: free((struct_complexe16 *) ((*s_objet).objet));
868: }
869:
870: break;
871: }
872:
873: case FCH :
874: {
875: if (decrementation_atomique(s_objet) > 0)
876: {
877: return;
878: }
879:
880: liberation(s_etat_processus,
881: (*((struct_fichier *) (*s_objet).objet)).format);
882:
883: free((unsigned char *) (*((struct_fichier *)
884: (*s_objet).objet)).nom);
885: free((struct_fichier *) ((*s_objet).objet));
886: break;
887: }
888:
889: case FCT :
890: {
891: if (decrementation_atomique(s_objet) > 0)
892: {
893: return;
894: }
895:
896: free((unsigned char *) (*((struct_fonction *)
897: (*s_objet).objet)).nom_fonction);
898:
899: if ((*s_etat_processus).pointeur_fct < TAILLE_CACHE)
900: {
901: (*s_etat_processus).objets_fct
902: [(*s_etat_processus).pointeur_fct++] = (*s_objet).objet;
903: }
904: else
905: {
906: free((struct_fonction *) (*s_objet).objet);
907: }
908:
909: break;
910: }
911:
912: case INT :
913: {
914: if (decrementation_atomique(s_objet) > 0)
915: {
916: return;
917: }
918:
919: if ((*s_etat_processus).pointeur_int < TAILLE_CACHE)
920: {
921: (*s_etat_processus).objets_int
922: [(*s_etat_processus).pointeur_int++] = (*s_objet).objet;
923: }
924: else
925: {
926: free((integer8 *) ((*s_objet).objet));
927: }
928:
929: break;
930: }
931:
932: case LST :
933: {
934: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
935:
936: if (decrementation_atomique(s_objet) > 0)
937: { // Il reste un pointeur sur l'objet.
938: while(l_element_courant != NULL)
939: {
940: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
941: pthread_mutex_unlock(&((*s_objet).mutex)),
942: printf("(*(*l_element_courant).donnee)"
943: ".nombre_occurrences=%ld\n",
944: (*(*l_element_courant).donnee).nombre_occurrences));
945:
946: liberation(s_etat_processus, (*l_element_courant).donnee);
947: l_element_courant = (*l_element_courant).suivant;
948: }
949:
950: return;
951: }
952: else
953: { // Il ne reste plus aucun pointeur sur l'objet.
954: while(l_element_courant != NULL)
955: {
956: l_element_suivant = (*l_element_courant).suivant;
957: liberation(s_etat_processus, (*l_element_courant).donnee);
958: liberation_maillon(s_etat_processus, l_element_courant);
959: l_element_courant = l_element_suivant;
960: }
961: }
962:
963: break;
964: }
965:
966: case MIN :
967: {
968: if (decrementation_atomique(s_objet) > 0)
969: {
970: return;
971: }
972:
973: for(i = 0; i < (*((struct_matrice *)
974: ((*s_objet).objet))).nombre_lignes; i++)
975: {
976: free(((integer8 **) (*((struct_matrice *)
977: (*s_objet).objet)).tableau)[i]);
978: }
979:
980: free((integer8 **) (*((struct_matrice *)
981: (*s_objet).objet)).tableau);
982:
983: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
984: {
985: (*s_etat_processus).objets_mat
986: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
987: }
988: else
989: {
990: free((struct_matrice *) (*s_objet).objet);
991: }
992:
993: break;
994: }
995:
996: case MCX :
997: {
998: if (decrementation_atomique(s_objet) > 0)
999: {
1000: return;
1001: }
1002:
1003: for(i = 0; i < (*((struct_matrice *)
1004: ((*s_objet).objet))).nombre_lignes; i++)
1005: {
1006: free(((struct_complexe16 **) (*((struct_matrice *)
1007: (*s_objet).objet)).tableau)[i]);
1008: }
1009:
1010: free((struct_complexe16 **) (*((struct_matrice *)
1011: (*s_objet).objet)).tableau);
1012:
1013: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1014: {
1015: (*s_etat_processus).objets_mat
1016: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1017: }
1018: else
1019: {
1020: free((struct_matrice *) (*s_objet).objet);
1021: }
1022:
1023: break;
1024: }
1025:
1026: case MRL :
1027: {
1028: if (decrementation_atomique(s_objet) > 0)
1029: {
1030: return;
1031: }
1032:
1033: for(i = 0; i < (*((struct_matrice *)
1034: ((*s_objet).objet))).nombre_lignes; i++)
1035: {
1036: free(((real8 **) (*((struct_matrice *)
1037: (*s_objet).objet)).tableau)[i]);
1038: }
1039:
1040: free((real8 **) (*((struct_matrice *) (*s_objet).objet)).tableau);
1041:
1042: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1043: {
1044: (*s_etat_processus).objets_mat
1045: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1046: }
1047: else
1048: {
1049: free((struct_matrice *) (*s_objet).objet);
1050: }
1051:
1052: break;
1053: }
1054:
1055: case MTX :
1056: {
1057: if (decrementation_atomique(s_objet) > 0)
1058: {
1059: return;
1060: }
1061:
1062: free((struct_mutex *) (*s_objet).objet);
1063: break;
1064: }
1065:
1066: case NOM :
1067: {
1068: if (decrementation_atomique(s_objet) > 0)
1069: {
1070: return;
1071: }
1072:
1073: free((*((struct_nom *) (*s_objet).objet)).nom);
1074:
1075: if ((*s_etat_processus).pointeur_nom < TAILLE_CACHE)
1076: {
1077: (*s_etat_processus).objets_nom
1078: [(*s_etat_processus).pointeur_nom++] = (*s_objet).objet;
1079: }
1080: else
1081: {
1082: free((struct_nom *) (*s_objet).objet);
1083: }
1084:
1085: break;
1086: }
1087:
1088: case NON :
1089: {
1090: if (decrementation_atomique(s_objet) > 0)
1091: {
1092: return;
1093: }
1094:
1095: free(s_objet);
1096: break;
1097: }
1098:
1099: case PRC :
1100: {
1101: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1102: (*s_objet).objet)).thread).mutex)) != 0)
1103: {
1104: (*s_etat_processus).erreur_systeme = d_es_processus;
1105: return;
1106: }
1107:
1108: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1109: .nombre_references--;
1110:
1111: BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1112: .nombre_references < 0, printf("(*(*((struct_processus_fils"
1113: " *) (*s_objet).objet)).thread).nombre_references = %d\n",
1114: (int) (*(*((struct_processus_fils *) (*s_objet).objet))
1115: .thread).nombre_references));
1116:
1117: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1118: .nombre_references == 0)
1119: {
1120: drapeau = d_vrai;
1121: }
1122: else
1123: {
1124: drapeau = d_faux;
1125: }
1126:
1127: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1128: (*s_objet).objet)).thread).mutex)) != 0)
1129: {
1130: (*s_etat_processus).erreur_systeme = d_es_processus;
1131: return;
1132: }
1133:
1134: if (drapeau == d_vrai)
1135: {
1136: pthread_mutex_destroy(&((*(*((struct_processus_fils *)
1137: (*s_objet).objet)).thread).mutex));
1138: free((*((struct_processus_fils *) (*s_objet).objet)).thread);
1139: }
1140:
1141: if (decrementation_atomique(s_objet) > 0)
1142: {
1143: return;
1144: }
1145:
1146: free((struct_processus_fils *) ((*s_objet).objet));
1147: break;
1148: }
1149:
1150: case REL :
1151: {
1152: if (decrementation_atomique(s_objet) > 0)
1153: {
1154: return;
1155: }
1156:
1157: if ((*s_etat_processus).pointeur_rel < TAILLE_CACHE)
1158: {
1159: (*s_etat_processus).objets_rel
1160: [(*s_etat_processus).pointeur_rel++] = (*s_objet).objet;
1161: }
1162: else
1163: {
1164: free((real8 *) ((*s_objet).objet));
1165: }
1166:
1167: break;
1168: }
1169:
1170: case RPN :
1171: {
1172: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1173:
1174: if (decrementation_atomique(s_objet) > 0)
1175: { // Il reste un pointeur sur l'objet.
1176: while(l_element_courant != NULL)
1177: {
1178: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
1179: pthread_mutex_unlock(&((*s_objet).mutex)),
1180: printf("(*(*l_element_courant).donnee)"
1181: ".nombre_occurrences=%ld\n",
1182: (*(*l_element_courant).donnee).nombre_occurrences));
1183:
1184: liberation(s_etat_processus, (*l_element_courant).donnee);
1185: l_element_courant = (*l_element_courant).suivant;
1186: }
1187:
1188: return;
1189: }
1190: else
1191: { // Il ne reste plus aucun pointeur sur l'objet.
1192: while(l_element_courant != NULL)
1193: {
1194: l_element_suivant = (*l_element_courant).suivant;
1195: liberation(s_etat_processus, (*l_element_courant).donnee);
1196: liberation_maillon(s_etat_processus, l_element_courant);
1197: l_element_courant = l_element_suivant;
1198: }
1199: }
1200:
1201: break;
1202: }
1203:
1204: case SCK :
1205: {
1206: if (decrementation_atomique(s_objet) > 0)
1207: {
1208: return;
1209: }
1210:
1211: liberation(s_etat_processus, (*((struct_socket *)
1212: (*s_objet).objet)).format);
1213: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1214: .adresse);
1215: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1216: .adresse_distante);
1217: free((struct_socket *) ((*s_objet).objet));
1218: break;
1219: }
1220:
1221: case SLB :
1222: {
1223: if (decrementation_atomique(s_objet) > 0)
1224: {
1225: return;
1226: }
1227:
1228: free((*((struct_bibliotheque *) (*s_objet).objet)).nom);
1229: free((struct_bibliotheque *) (*s_objet).objet);
1230: break;
1231: }
1232:
1233: case SPH :
1234: {
1235: if (decrementation_atomique(s_objet) > 0)
1236: {
1237: return;
1238: }
1239:
1240: free((*((struct_semaphore *) (*s_objet).objet)).nom);
1241: free((struct_bibliotheque *) (*s_objet).objet);
1242: break;
1243: }
1244:
1245: case SQL :
1246: {
1247: if (decrementation_atomique(s_objet) > 0)
1248: {
1249: return;
1250: }
1251:
1252: free((*((struct_connecteur_sql *) (*s_objet).objet)).type);
1253: free((*((struct_connecteur_sql *) (*s_objet).objet)).locale);
1254: free((struct_connecteur_sql *) (*s_objet).objet);
1255: break;
1256: }
1257:
1258: case TBL :
1259: {
1260: if (decrementation_atomique(s_objet) > 0)
1261: {
1262: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1263: .nombre_elements; i++)
1264: {
1265: BUG((*((*((struct_tableau *)
1266: (*s_objet).objet)).elements[i]))
1267: .nombre_occurrences <= 1,
1268: pthread_mutex_unlock(&((*s_objet).mutex)),
1269: printf("(*((*((struct_tableau *) (*s_objet).objet))"
1270: ".element[%lu])).nombre_occurrences=%ld\n", i,
1271: (*((*((struct_tableau *) (*s_objet).objet))
1272: .elements[i])).nombre_occurrences));
1273: liberation(s_etat_processus, (*((struct_tableau *)
1274: (*s_objet).objet)).elements[i]);
1275: }
1276:
1277: return;
1278: }
1279:
1280: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1281: .nombre_elements; i++)
1282: {
1283: liberation(s_etat_processus, (*((struct_tableau *)
1284: (*s_objet).objet)).elements[i]);
1285: }
1286:
1287: free((*((struct_tableau *) (*s_objet).objet)).elements);
1288:
1289: if ((*s_etat_processus).pointeur_tab < TAILLE_CACHE)
1290: {
1291: (*s_etat_processus).objets_tab
1292: [(*s_etat_processus).pointeur_tab++] = (*s_objet).objet;
1293: }
1294: else
1295: {
1296: free((struct_tableau *) (*s_objet).objet);
1297: }
1298:
1299: break;
1300: }
1301:
1302: case VIN :
1303: {
1304: if (decrementation_atomique(s_objet) > 0)
1305: {
1306: return;
1307: }
1308:
1309: free((integer8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1310:
1311: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1312: {
1313: (*s_etat_processus).objets_vec
1314: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1315: }
1316: else
1317: {
1318: free((struct_vecteur *) (*s_objet).objet);
1319: }
1320:
1321: break;
1322: }
1323:
1324: case VCX :
1325: {
1326: if (decrementation_atomique(s_objet) > 0)
1327: {
1328: return;
1329: }
1330:
1331: free((struct_complexe16 *) (*((struct_vecteur *)
1332: (*s_objet).objet)).tableau);
1333:
1334: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1335: {
1336: (*s_etat_processus).objets_vec
1337: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1338: }
1339: else
1340: {
1341: free((struct_vecteur *) (*s_objet).objet);
1342: }
1343:
1344: break;
1345: }
1346:
1347: case VRL :
1348: {
1349: if (decrementation_atomique(s_objet) > 0)
1350: {
1351: return;
1352: }
1353:
1354: free((real8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1355:
1356: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1357: {
1358: (*s_etat_processus).objets_vec
1359: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1360: }
1361: else
1362: {
1363: free((struct_vecteur *) (*s_objet).objet);
1364: }
1365:
1366: break;
1367: }
1368:
1369: default :
1370: {
1371: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1372: {
1373: (*s_etat_processus).erreur_systeme = d_es_processus;
1374: return;
1375: }
1376:
1377: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1378: {
1379: (*s_etat_processus).erreur_systeme = d_es_processus;
1380: return;
1381: }
1382:
1383: BUG(1, printf("Free failure (type %d)\n", (*s_objet).type));
1384: return;
1385: }
1386: }
1387:
1388: #undef return
1389:
1390: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1391: {
1392: (*s_etat_processus).erreur_systeme = d_es_processus;
1393: return;
1394: }
1395:
1396: if (s_etat_processus != NULL)
1397: {
1398: if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
1399: {
1400: (*s_objet).objet = (*s_etat_processus).pile_objets;
1401: (*s_etat_processus).pile_objets = s_objet;
1402: (*s_etat_processus).taille_pile_objets++;
1403: }
1404: else
1405: {
1406: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1407: {
1408: (*s_etat_processus).erreur_systeme = d_es_processus;
1409: return;
1410: }
1411:
1412: free(s_objet);
1413: }
1414: }
1415: else
1416: {
1417: free(s_objet);
1418: }
1419:
1420: return;
1421: }
1422:
1423:
1424: /*
1425: ================================================================================
1426: Routine de copie d'une structure *s_objet
1427: ================================================================================
1428: Entrées : structure *s_objet à copier
1429: type :
1430: 'P' : renvoie le même objet en incrémentant le nombre
1431: d'occurrence de chaque objet élémentaire ;
1432: 'O' : crée un nouvel objet en copiant chaque objet élémentaire ;
1433: 'N' : crée un nouvel objet mais les objets élémentaires
1434: sont réutilisés (voir 'P'). Dans le cas d'un objet
1435: élémentaire, 'N' et 'P' sont identiques.
1436: 'Q' : 'P' si nombre_occurrences vaut 1, 'O' sinon.
1437: 'R' : 'P' si nombre_occurrences vaut 1, 'N' sinon.
1438: --------------------------------------------------------------------------------
1439: Sorties : structure identique (tous les objets sont copiés)
1440: --------------------------------------------------------------------------------
1441: Effets de bord : néant
1442: ================================================================================
1443: */
1444:
1445: struct_objet *
1446: copie_objet(struct_processus *s_etat_processus,
1447: struct_objet *s_objet, unsigned char type)
1448: {
1449: struct_liste_chainee *l_element_base;
1450: struct_liste_chainee *l_element_courant;
1451: struct_liste_chainee *l_element_courant_ecriture;
1452: struct_liste_chainee *l_element_courant_lecture;
1453: struct_liste_chainee *l_element_suivant_ecriture;
1454: struct_liste_chainee *l_element_suivant_lecture;
1455:
1456: struct_objet *s_nouvel_objet;
1457: struct_objet *s_objet_tampon;
1458:
1459: unsigned long i;
1460: unsigned long j;
1461:
1462: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
1463: {
1464: (*s_etat_processus).erreur_systeme = d_es_processus;
1465: return(NULL);
1466: }
1467:
1468: if (type == 'Q')
1469: {
1470: if ((*s_objet).nombre_occurrences == 1)
1471: {
1472: type = 'P';
1473: }
1474: else
1475: {
1476: type = 'O';
1477: }
1478: }
1479: else if (type == 'R')
1480: {
1481: if ((*s_objet).nombre_occurrences == 1)
1482: {
1483: type = 'P';
1484: }
1485: else
1486: {
1487: type = 'N';
1488: }
1489: }
1490:
1491: #define return(pointeur) \
1492: if (pthread_mutex_unlock(&((*s_objet).mutex))) \
1493: { (*s_etat_processus).erreur_systeme = d_es_processus; return(NULL); } \
1494: return(pointeur)
1495:
1496: switch((*s_objet).type)
1497: {
1498: case ADR :
1499: {
1500: if (type != 'O')
1501: {
1502: incrementation_atomique(s_objet);
1503: return(s_objet);
1504: }
1505:
1506: if ((s_nouvel_objet = allocation(s_etat_processus, ADR)) == NULL)
1507: {
1508: return(NULL);
1509: }
1510:
1511: (*((unsigned long *) ((*s_nouvel_objet).objet))) =
1512: (*((unsigned long *) ((*s_objet).objet)));
1513: break;
1514: }
1515:
1516: case ALG :
1517: {
1518: if (type != 'P')
1519: {
1520: if ((s_nouvel_objet = allocation(s_etat_processus, ALG))
1521: == NULL)
1522: {
1523: return(NULL);
1524: }
1525:
1526: l_element_courant_lecture = (struct_liste_chainee *)
1527: ((*s_objet).objet);
1528:
1529: l_element_base = NULL;
1530: l_element_courant_ecriture = l_element_base;
1531:
1532: while(l_element_courant_lecture != NULL)
1533: {
1534: s_objet_tampon = copie_objet(s_etat_processus,
1535: (*l_element_courant_lecture).donnee, type);
1536: l_element_suivant_ecriture = (struct_liste_chainee *)
1537: malloc(sizeof(struct_liste_chainee));
1538:
1539: if ((s_objet_tampon == NULL) ||
1540: (l_element_suivant_ecriture == NULL))
1541: {
1542: l_element_courant_lecture = (struct_liste_chainee *)
1543: ((*s_nouvel_objet).objet);
1544:
1545: while(l_element_courant_lecture != NULL)
1546: {
1547: l_element_suivant_lecture =
1548: (*l_element_courant_lecture).suivant;
1549: liberation(s_etat_processus,
1550: (*l_element_courant_lecture).donnee);
1551: free(l_element_courant_lecture);
1552: l_element_courant_lecture =
1553: l_element_suivant_lecture;
1554: }
1555:
1556: return(NULL);
1557: }
1558:
1559: if (l_element_courant_ecriture == NULL)
1560: {
1561: l_element_base = l_element_suivant_ecriture;
1562: }
1563: else
1564: {
1565: (*l_element_courant_ecriture).suivant =
1566: l_element_suivant_ecriture;
1567: }
1568:
1569: l_element_courant_ecriture = l_element_suivant_ecriture;
1570:
1571: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1572: (*l_element_courant_ecriture).suivant = NULL;
1573: l_element_courant_lecture =
1574: (*l_element_courant_lecture).suivant;
1575: }
1576:
1577: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1578: l_element_base);
1579: }
1580: else // type == 'P'
1581: {
1582: incrementation_atomique(s_objet);
1583: l_element_courant = (*s_objet).objet;
1584:
1585: while(l_element_courant != NULL)
1586: {
1587: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1588: (*l_element_courant).donnee, 'P');
1589: l_element_courant = (*l_element_courant).suivant;
1590: }
1591:
1592: return(s_objet);
1593: }
1594:
1595: break;
1596: }
1597:
1598: case BIN :
1599: {
1600: if (type != 'O')
1601: {
1602: incrementation_atomique(s_objet);
1603: return(s_objet);
1604: }
1605:
1606: if ((s_nouvel_objet = allocation(s_etat_processus, BIN)) == NULL)
1607: {
1608: return(NULL);
1609: }
1610:
1611: (*((logical8 *) ((*s_nouvel_objet).objet))) =
1612: (*((logical8 *) ((*s_objet).objet)));
1613: break;
1614: }
1615:
1616: case CHN :
1617: {
1618: if (type != 'O')
1619: {
1620: incrementation_atomique(s_objet);
1621: return(s_objet);
1622: }
1623:
1624: if ((s_nouvel_objet = allocation(s_etat_processus, CHN)) == NULL)
1625: {
1626: return(NULL);
1627: }
1628:
1629: (*s_nouvel_objet).objet = (void *) ((unsigned char *)
1630: malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
1631: * sizeof(unsigned char)));
1632:
1633: if ((*s_nouvel_objet).objet == NULL)
1634: {
1635: free(s_nouvel_objet);
1636: return(NULL);
1637: }
1638:
1639: strcpy((unsigned char *) ((*s_nouvel_objet).objet),
1640: (unsigned char *) ((*s_objet).objet));
1641: break;
1642: }
1643:
1644: case CPL :
1645: {
1646: if (type != 'O')
1647: {
1648: incrementation_atomique(s_objet);
1649: return(s_objet);
1650: }
1651:
1652: if ((s_nouvel_objet = allocation(s_etat_processus, CPL)) == NULL)
1653: {
1654: return(NULL);
1655: }
1656:
1657: (*((struct_complexe16 *) ((*s_nouvel_objet).objet))) =
1658: (*((struct_complexe16 *) ((*s_objet).objet)));
1659: break;
1660: }
1661:
1662: case RPN :
1663: {
1664: if (type != 'P')
1665: {
1666: if ((s_nouvel_objet = allocation(s_etat_processus, RPN))
1667: == NULL)
1668: {
1669: return(NULL);
1670: }
1671:
1672: l_element_courant_lecture = (struct_liste_chainee *)
1673: ((*s_objet).objet);
1674:
1675: l_element_base = NULL;
1676: l_element_courant_ecriture = l_element_base;
1677:
1678: while(l_element_courant_lecture != NULL)
1679: {
1680: s_objet_tampon = copie_objet(s_etat_processus,
1681: (*l_element_courant_lecture).donnee, type);
1682: l_element_suivant_ecriture = (struct_liste_chainee *)
1683: malloc(sizeof(struct_liste_chainee));
1684:
1685: if ((s_objet_tampon == NULL) ||
1686: (l_element_suivant_ecriture == NULL))
1687: {
1688: l_element_courant_lecture = (struct_liste_chainee *)
1689: ((*s_nouvel_objet).objet);
1690:
1691: while(l_element_courant_lecture != NULL)
1692: {
1693: l_element_suivant_lecture =
1694: (*l_element_courant_lecture).suivant;
1695: liberation(s_etat_processus,
1696: (*l_element_courant_lecture).donnee);
1697: free(l_element_courant_lecture);
1698: l_element_courant_lecture =
1699: l_element_suivant_lecture;
1700: }
1701:
1702: return(NULL);
1703: }
1704:
1705: if (l_element_courant_ecriture == NULL)
1706: {
1707: l_element_base = l_element_suivant_ecriture;
1708: }
1709: else
1710: {
1711: (*l_element_courant_ecriture).suivant =
1712: l_element_suivant_ecriture;
1713: }
1714:
1715: l_element_courant_ecriture = l_element_suivant_ecriture;
1716:
1717: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1718: (*l_element_courant_ecriture).suivant = NULL;
1719: l_element_courant_lecture =
1720: (*l_element_courant_lecture).suivant;
1721: }
1722:
1723: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1724: l_element_base);
1725: }
1726: else // type == 'P'
1727: {
1728: incrementation_atomique(s_objet);
1729: l_element_courant = (*s_objet).objet;
1730:
1731: while(l_element_courant != NULL)
1732: {
1733: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1734: (*l_element_courant).donnee, 'P');
1735: l_element_courant = (*l_element_courant).suivant;
1736: }
1737:
1738: return(s_objet);
1739: }
1740:
1741: break;
1742: }
1743:
1744: case FCH :
1745: {
1746: if (type == 'P')
1747: {
1748: incrementation_atomique(s_objet);
1749: return(s_objet);
1750: }
1751:
1752: if ((s_nouvel_objet = allocation(s_etat_processus, FCH)) == NULL)
1753: {
1754: return(NULL);
1755: }
1756:
1757: (*((struct_fichier *) ((*s_nouvel_objet).objet))).descripteur =
1758: (*((struct_fichier *) ((*s_objet).objet))).descripteur;
1759: (*((struct_fichier *) ((*s_nouvel_objet).objet))).acces =
1760: (*((struct_fichier *) ((*s_objet).objet))).acces;
1761: (*((struct_fichier *) ((*s_nouvel_objet).objet))).binaire =
1762: (*((struct_fichier *) ((*s_objet).objet))).binaire;
1763: (*((struct_fichier *) ((*s_nouvel_objet).objet))).ouverture =
1764: (*((struct_fichier *) ((*s_objet).objet))).ouverture;
1765: (*((struct_fichier *) ((*s_nouvel_objet).objet))).protection =
1766: (*((struct_fichier *) ((*s_objet).objet))).protection;
1767: (*((struct_fichier *) ((*s_nouvel_objet).objet)))
1768: .position_clef = (*((struct_fichier *)
1769: ((*s_objet).objet))).position_clef;
1770: (*((struct_fichier *) ((*s_nouvel_objet).objet))).pid =
1771: (*((struct_fichier *) ((*s_objet).objet))).pid;
1772: (*((struct_fichier *) ((*s_nouvel_objet).objet))).tid =
1773: (*((struct_fichier *) ((*s_objet).objet))).tid;
1774:
1775: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).format =
1776: copie_objet(s_etat_processus, (*((struct_fichier *)
1777: ((*s_objet).objet))).format, type)) == NULL)
1778: {
1779: free((*s_nouvel_objet).objet);
1780: free(s_nouvel_objet);
1781: return(NULL);
1782: }
1783:
1784: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom =
1785: (unsigned char *) malloc((strlen((*((struct_fichier *)
1786: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
1787: == NULL)
1788: {
1789: liberation(s_etat_processus, (*((struct_fichier *)
1790: (*s_nouvel_objet).objet)).format);
1791: free((*s_nouvel_objet).objet);
1792: free(s_nouvel_objet);
1793: return(NULL);
1794: }
1795:
1796: strcpy((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom,
1797: (*((struct_fichier *) ((*s_objet).objet))).nom);
1798: break;
1799: }
1800:
1801: case FCT :
1802: {
1803: if (type != 'O')
1804: {
1805: /*
1806: * Remise à zéro de la prédiction pour respecter la cohérence
1807: * du saut dans les cas EXSUB et OBSUB.
1808: */
1809:
1810: (*((struct_fonction *) ((*s_objet).objet)))
1811: .prediction_saut = NULL;
1812: incrementation_atomique(s_objet);
1813: return(s_objet);
1814: }
1815:
1816: if ((s_nouvel_objet = allocation(s_etat_processus, FCT)) == NULL)
1817: {
1818: return(NULL);
1819: }
1820:
1821: if (((*((struct_fonction *) ((*s_nouvel_objet).objet)))
1822: .nom_fonction = (unsigned char *)
1823: malloc((strlen((*((struct_fonction *)
1824: ((*s_objet).objet))).nom_fonction) + 1) *
1825: sizeof(unsigned char))) == NULL)
1826: {
1827: free(s_nouvel_objet);
1828: return(NULL);
1829: }
1830:
1831: strcpy((unsigned char *) (*((struct_fonction *)
1832: ((*s_nouvel_objet).objet))).nom_fonction,
1833: (unsigned char *) (*((struct_fonction *)
1834: ((*s_objet).objet))).nom_fonction);
1835: (*((struct_fonction *) ((*s_nouvel_objet).objet)))
1836: .nombre_arguments = (*((struct_fonction *)
1837: ((*s_objet).objet))).nombre_arguments;
1838: (*((struct_fonction *) ((*s_nouvel_objet).objet))).fonction =
1839: (*((struct_fonction *) ((*s_objet).objet))).fonction;
1840: break;
1841: }
1842:
1843: case INT :
1844: {
1845: if (type != 'O')
1846: {
1847: incrementation_atomique(s_objet);
1848: return(s_objet);
1849: }
1850:
1851: if ((s_nouvel_objet = allocation(s_etat_processus, INT)) == NULL)
1852: {
1853: return(NULL);
1854: }
1855:
1856: (*((integer8 *) ((*s_nouvel_objet).objet))) =
1857: (*((integer8 *) ((*s_objet).objet)));
1858: break;
1859: }
1860:
1861: case LST :
1862: {
1863: if (type != 'P')
1864: {
1865: if ((s_nouvel_objet = allocation(s_etat_processus, LST))
1866: == NULL)
1867: {
1868: return(NULL);
1869: }
1870:
1871: l_element_courant_lecture = (struct_liste_chainee *)
1872: ((*s_objet).objet);
1873:
1874: l_element_base = NULL;
1875: l_element_courant_ecriture = l_element_base;
1876:
1877: while(l_element_courant_lecture != NULL)
1878: {
1879: s_objet_tampon = copie_objet(s_etat_processus,
1880: (*l_element_courant_lecture).donnee, type);
1881: l_element_suivant_ecriture = (struct_liste_chainee *)
1882: malloc(sizeof(struct_liste_chainee));
1883:
1884: if ((s_objet_tampon == NULL) ||
1885: (l_element_suivant_ecriture == NULL))
1886: {
1887: l_element_courant_lecture = (struct_liste_chainee *)
1888: ((*s_nouvel_objet).objet);
1889:
1890: while(l_element_courant_lecture != NULL)
1891: {
1892: l_element_suivant_lecture =
1893: (*l_element_courant_lecture).suivant;
1894: liberation(s_etat_processus,
1895: (*l_element_courant_lecture).donnee);
1896: free(l_element_courant_lecture);
1897: l_element_courant_lecture =
1898: l_element_suivant_lecture;
1899: }
1900:
1901: return(NULL);
1902: }
1903:
1904: if (l_element_courant_ecriture == NULL)
1905: {
1906: l_element_base = l_element_suivant_ecriture;
1907: }
1908: else
1909: {
1910: (*l_element_courant_ecriture).suivant =
1911: l_element_suivant_ecriture;
1912: }
1913:
1914: l_element_courant_ecriture = l_element_suivant_ecriture;
1915:
1916: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1917: (*l_element_courant_ecriture).suivant = NULL;
1918: l_element_courant_lecture =
1919: (*l_element_courant_lecture).suivant;
1920: }
1921:
1922: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1923: l_element_base);
1924: }
1925: else
1926: {
1927: incrementation_atomique(s_objet);
1928: l_element_courant = (*s_objet).objet;
1929:
1930: while(l_element_courant != NULL)
1931: {
1932: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1933: (*l_element_courant).donnee, 'P');
1934: l_element_courant = (*l_element_courant).suivant;
1935: }
1936:
1937: return(s_objet);
1938: }
1939:
1940: break;
1941: }
1942:
1943: case MIN :
1944: {
1945: if (type != 'O')
1946: {
1947: incrementation_atomique(s_objet);
1948: return(s_objet);
1949: }
1950:
1951: if ((s_nouvel_objet = allocation(s_etat_processus, MIN)) == NULL)
1952: {
1953: return(NULL);
1954: }
1955:
1956: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
1957: (void **) ((integer8 **) malloc(
1958: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
1959: * sizeof(integer8 *)));
1960:
1961: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
1962: == NULL)
1963: {
1964: free((*s_nouvel_objet).objet);
1965: free(s_nouvel_objet);
1966: return(NULL);
1967: }
1968:
1969: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
1970: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
1971: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
1972: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
1973: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
1974: (*((struct_matrice *) ((*s_objet).objet))).type;
1975:
1976: for(i = 0; i < (*((struct_matrice *)
1977: ((*s_objet).objet))).nombre_lignes; i++)
1978: {
1979: if ((((integer8 **) ((*((struct_matrice *)
1980: ((*s_nouvel_objet).objet))).tableau))[i] =
1981: (void *) ((integer8 *) malloc(
1982: ((*((struct_matrice *) ((*s_objet).objet)))
1983: .nombre_colonnes) * sizeof(integer8)))) == NULL)
1984: {
1985: for(j = 0; j < i; j++)
1986: {
1987: free(((integer8 **) ((*((struct_matrice *)
1988: ((*s_nouvel_objet).objet))).tableau))[j]);
1989: }
1990:
1991: free((*s_nouvel_objet).objet);
1992: free(s_nouvel_objet);
1993: return(NULL);
1994: }
1995:
1996: for(j = 0; j < (*((struct_matrice *)
1997: ((*s_objet).objet))).nombre_colonnes; j++)
1998: {
1999: ((integer8 **) ((*((struct_matrice *)
2000: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2001: ((integer8 **) ((*((struct_matrice *)
2002: ((*s_objet).objet))).tableau))[i][j];
2003: }
2004: }
2005:
2006: break;
2007: }
2008:
2009: case MCX :
2010: {
2011: if (type != 'O')
2012: {
2013: incrementation_atomique(s_objet);
2014: return(s_objet);
2015: }
2016:
2017: if ((s_nouvel_objet = allocation(s_etat_processus, MCX))
2018: == NULL)
2019: {
2020: return(NULL);
2021: }
2022:
2023: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2024: (void **) ((struct_complexe16 **) malloc(
2025: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2026: * sizeof(struct_complexe16 *)));
2027:
2028: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2029: == NULL)
2030: {
2031: free((*s_nouvel_objet).objet);
2032: free(s_nouvel_objet);
2033: return(NULL);
2034: }
2035:
2036: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2037: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2038: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2039: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2040: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2041: (*((struct_matrice *) ((*s_objet).objet))).type;
2042:
2043: for(i = 0; i < (*((struct_matrice *)
2044: ((*s_objet).objet))).nombre_lignes; i++)
2045: {
2046: if ((((struct_complexe16 **) ((*((struct_matrice *)
2047: ((*s_nouvel_objet).objet))).tableau))[i] =
2048: (void *) ((struct_complexe16 *) malloc(
2049: ((*((struct_matrice *) ((*s_objet).objet)))
2050: .nombre_colonnes) * sizeof(struct_complexe16))))
2051: == NULL)
2052: {
2053: for(j = 0; j < i; j++)
2054: {
2055: free(((struct_complexe16 **) ((*((struct_matrice *)
2056: ((*s_nouvel_objet).objet))).tableau))[j]);
2057: }
2058:
2059: free((*s_nouvel_objet).objet);
2060: free(s_nouvel_objet);
2061: return(NULL);
2062: }
2063:
2064: for(j = 0; j < (*((struct_matrice *)
2065: ((*s_objet).objet))).nombre_colonnes; j++)
2066: {
2067: ((struct_complexe16 **) ((*((struct_matrice *)
2068: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2069: ((struct_complexe16 **) ((*((struct_matrice *)
2070: ((*s_objet).objet))).tableau))[i][j];
2071: }
2072: }
2073:
2074: break;
2075: }
2076:
2077: case MRL :
2078: {
2079: if (type != 'O')
2080: {
2081: incrementation_atomique(s_objet);
2082: return(s_objet);
2083: }
2084:
2085: if ((s_nouvel_objet = allocation(s_etat_processus, MRL)) == NULL)
2086: {
2087: return(NULL);
2088: }
2089:
2090: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2091: (void **) ((real8 **) malloc(
2092: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2093: * sizeof(real8 *)));
2094:
2095: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2096: == NULL)
2097: {
2098: free((*s_nouvel_objet).objet);
2099: free(s_nouvel_objet);
2100: return(NULL);
2101: }
2102:
2103: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2104: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2105: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2106: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2107: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2108: (*((struct_matrice *) ((*s_objet).objet))).type;
2109:
2110: for(i = 0; i < (*((struct_matrice *)
2111: ((*s_objet).objet))).nombre_lignes; i++)
2112: {
2113: if ((((real8 **) ((*((struct_matrice *)
2114: ((*s_nouvel_objet).objet))).tableau))[i] =
2115: (void *) ((real8 *) malloc(
2116: ((*((struct_matrice *) ((*s_objet).objet)))
2117: .nombre_colonnes) * sizeof(real8)))) == NULL)
2118: {
2119: for(j = 0; j < i; j++)
2120: {
2121: free(((real8 **) ((*((struct_matrice *)
2122: ((*s_nouvel_objet).objet))).tableau))[j]);
2123: }
2124:
2125: free((*s_nouvel_objet).objet);
2126: free(s_nouvel_objet);
2127: return(NULL);
2128: }
2129:
2130: for(j = 0; j < (*((struct_matrice *)
2131: ((*s_objet).objet))).nombre_colonnes; j++)
2132: {
2133: ((real8 **) ((*((struct_matrice *)
2134: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2135: ((real8 **) ((*((struct_matrice *)
2136: ((*s_objet).objet))).tableau))[i][j];
2137: }
2138: }
2139:
2140: break;
2141: }
2142:
2143: case MTX :
2144: {
2145: if (type != 'O')
2146: {
2147: incrementation_atomique(s_objet);
2148: return(s_objet);
2149: }
2150:
2151: if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
2152: {
2153: return(NULL);
2154: }
2155:
2156: (*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex =
2157: (*((struct_mutex *) ((*s_objet).objet))).mutex;
2158: break;
2159: }
2160:
2161: case NOM :
2162: {
2163: if (type != 'O')
2164: {
2165: incrementation_atomique(s_objet);
2166: return(s_objet);
2167: }
2168:
2169: if ((s_nouvel_objet = allocation(s_etat_processus, NOM)) == NULL)
2170: {
2171: return(NULL);
2172: }
2173:
2174: (*((struct_nom *) (*s_nouvel_objet).objet)).nom = malloc((
2175: strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) *
2176: sizeof(unsigned char));
2177:
2178: if ((*((struct_nom *) (*s_nouvel_objet).objet)).nom == NULL)
2179: {
2180: free((*s_nouvel_objet).objet);
2181: free(s_nouvel_objet);
2182: return(NULL);
2183: }
2184:
2185: strcpy((*((struct_nom *) (*s_nouvel_objet).objet)).nom,
2186: (*((struct_nom *) (*s_objet).objet)).nom);
2187: (*((struct_nom *) (*s_nouvel_objet).objet)).symbole =
2188: (*((struct_nom *) (*s_objet).objet)).symbole;
2189: break;
2190: }
2191:
2192: case NON :
2193: {
2194: if (type != 'O')
2195: {
2196: incrementation_atomique(s_objet);
2197: return(s_objet);
2198: }
2199:
2200: if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)
2201: {
2202: return(NULL);
2203: }
2204:
2205: (*s_nouvel_objet).objet = NULL;
2206: break;
2207: }
2208:
2209: case PRC :
2210: {
2211: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2212: (*s_objet).objet)).thread).mutex)) != 0)
2213: {
2214: return(NULL);
2215: }
2216:
2217: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
2218: .nombre_references++;
2219:
2220: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2221: (*s_objet).objet)).thread).mutex)) != 0)
2222: {
2223: return(NULL);
2224: }
2225:
2226: if (type != 'O')
2227: {
2228: incrementation_atomique(s_objet);
2229: return(s_objet);
2230: }
2231:
2232: if ((s_nouvel_objet = allocation(s_etat_processus, PRC)) == NULL)
2233: {
2234: return(NULL);
2235: }
2236:
2237: (*((struct_processus_fils *) (*s_nouvel_objet).objet)) =
2238: (*((struct_processus_fils *) (*s_objet).objet));
2239: break;
2240: }
2241:
2242: case REL :
2243: {
2244: if (type != 'O')
2245: {
2246: incrementation_atomique(s_objet);
2247: return(s_objet);
2248: }
2249:
2250: if ((s_nouvel_objet = allocation(s_etat_processus, REL)) == NULL)
2251: {
2252: return(NULL);
2253: }
2254:
2255: (*((real8 *) ((*s_nouvel_objet).objet))) =
2256: (*((real8 *) ((*s_objet).objet)));
2257: break;
2258: }
2259:
2260: case SCK :
2261: {
2262: if (type == 'P')
2263: {
2264: incrementation_atomique(s_objet);
2265: return(s_objet);
2266: }
2267:
2268: if ((s_nouvel_objet = allocation(s_etat_processus, SCK)) == NULL)
2269: {
2270: return(NULL);
2271: }
2272:
2273: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket =
2274: (*((struct_socket *) ((*s_objet).objet))).socket;
2275: (*((struct_socket *) ((*s_nouvel_objet).objet))).domaine =
2276: (*((struct_socket *) ((*s_objet).objet))).domaine;
2277: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_en_ecoute =
2278: (*((struct_socket *) ((*s_objet).objet))).socket_en_ecoute;
2279: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_connectee =
2280: (*((struct_socket *) ((*s_objet).objet))).socket_connectee;
2281: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2282: (*((struct_socket *) ((*s_objet).objet))).pid;
2283: (*((struct_socket *) ((*s_nouvel_objet).objet))).binaire =
2284: (*((struct_socket *) ((*s_objet).objet))).binaire;
2285: (*((struct_socket *) ((*s_nouvel_objet).objet))).effacement =
2286: (*((struct_socket *) ((*s_objet).objet))).effacement;
2287: (*((struct_socket *) ((*s_nouvel_objet).objet))).protection =
2288: (*((struct_socket *) ((*s_objet).objet))).protection;
2289: (*((struct_socket *) ((*s_nouvel_objet).objet))).localisation =
2290: (*((struct_socket *) ((*s_objet).objet))).localisation;
2291: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2292: (*((struct_socket *) ((*s_objet).objet))).pid;
2293: (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
2294: (*((struct_socket *) ((*s_objet).objet))).tid;
2295:
2296: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
2297: copie_objet(s_etat_processus, (*((struct_socket *)
2298: ((*s_objet).objet))).format, type)) == NULL)
2299: {
2300: free((*s_nouvel_objet).objet);
2301: free(s_nouvel_objet);
2302: return(NULL);
2303: }
2304:
2305: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).adresse =
2306: (unsigned char *) malloc((strlen((*((struct_socket *)
2307: ((*s_objet).objet))).adresse) + 1) * sizeof(unsigned char)))
2308: == NULL)
2309: {
2310: liberation(s_etat_processus, (*((struct_fichier *)
2311: (*s_nouvel_objet).objet)).format);
2312: free((*s_nouvel_objet).objet);
2313: free(s_nouvel_objet);
2314: return(NULL);
2315: }
2316:
2317: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2318: .adresse, (*((struct_socket *) ((*s_objet).objet)))
2319: .adresse);
2320:
2321: if (((*((struct_socket *) ((*s_nouvel_objet).objet)))
2322: .adresse_distante = malloc((strlen((*((struct_socket *)
2323: ((*s_objet).objet))).adresse_distante) + 1) *
2324: sizeof(unsigned char))) == NULL)
2325: {
2326: liberation(s_etat_processus, (*((struct_fichier *)
2327: (*s_nouvel_objet).objet)).format);
2328: free((*s_nouvel_objet).objet);
2329: free(s_nouvel_objet);
2330: return(NULL);
2331: }
2332:
2333: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2334: .adresse_distante, (*((struct_socket *) ((*s_objet).objet)))
2335: .adresse_distante);
2336:
2337: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))).type,
2338: (*((struct_socket *) ((*s_objet).objet))).type);
2339: break;
2340: }
2341:
2342: case SLB :
2343: {
2344: if (type != 'O')
2345: {
2346: incrementation_atomique(s_objet);
2347: return(s_objet);
2348: }
2349:
2350: if ((s_nouvel_objet = allocation(s_etat_processus, SLB)) == NULL)
2351: {
2352: return(NULL);
2353: }
2354:
2355: if (((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom =
2356: (unsigned char *) malloc((strlen((*((struct_bibliotheque *)
2357: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
2358: == NULL)
2359: {
2360: free((*s_nouvel_objet).objet);
2361: free(s_nouvel_objet);
2362: return(NULL);
2363: }
2364:
2365: strcpy((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom,
2366: (*((struct_bibliotheque *) ((*s_objet).objet))).nom);
2367:
2368: /*
2369: * C'est objet est non modifiable et est un pointeur
2370: * sur un objet système. Seul la référence est copiée.
2371: */
2372:
2373: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).descripteur =
2374: (*((struct_bibliotheque *) (*s_objet).objet)).descripteur;
2375: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).pid =
2376: (*((struct_bibliotheque *) (*s_objet).objet)).pid;
2377: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).tid =
2378: (*((struct_bibliotheque *) (*s_objet).objet)).tid;
2379: break;
2380: }
2381:
2382: case SPH :
2383: {
2384: if (type != 'O')
2385: {
2386: incrementation_atomique(s_objet);
2387: return(s_objet);
2388: }
2389:
2390: if ((s_nouvel_objet = allocation(s_etat_processus, SPH)) == NULL)
2391: {
2392: return(NULL);
2393: }
2394:
2395: if (((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom =
2396: malloc((strlen((*((struct_semaphore *) (*s_objet).objet))
2397: .nom) + 1) * sizeof(unsigned char))) == NULL)
2398: {
2399: free((*s_nouvel_objet).objet);
2400: free(s_nouvel_objet);
2401: return(NULL);
2402: }
2403:
2404: strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom,
2405: (*((struct_semaphore *) (*s_objet).objet)).nom);
2406: break;
2407: }
2408:
2409: case SQL :
2410: {
2411: if (type != 'O')
2412: {
2413: incrementation_atomique(s_objet);
2414: return(s_objet);
2415: }
2416:
2417: if ((s_nouvel_objet = allocation(s_etat_processus, SQL)) == NULL)
2418: {
2419: return(NULL);
2420: }
2421:
2422: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).pid =
2423: (*((struct_connecteur_sql *) (*s_objet).objet)).pid;
2424: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).tid =
2425: (*((struct_connecteur_sql *) (*s_objet).objet)).tid;
2426: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).descripteur =
2427: (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur;
2428:
2429: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type =
2430: malloc((strlen((*((struct_connecteur_sql *)
2431: (*s_objet).objet)).type) + 1) * sizeof(unsigned char)))
2432: == NULL)
2433: {
2434: free(s_nouvel_objet);
2435: return(NULL);
2436: }
2437:
2438: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type,
2439: (*((struct_connecteur_sql *) (*s_objet).objet)).type);
2440:
2441: if ((*((struct_connecteur_sql *) (*s_objet).objet)).locale != NULL)
2442: {
2443: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2444: .locale = malloc((strlen((*((struct_connecteur_sql *)
2445: (*s_objet).objet)).locale) + 1) *
2446: sizeof(unsigned char))) == NULL)
2447: {
2448: free((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2449: .locale);
2450: free(s_nouvel_objet);
2451: return(NULL);
2452: }
2453:
2454: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2455: .locale, (*((struct_connecteur_sql *)
2456: (*s_objet).objet)).locale);
2457: }
2458: else
2459: {
2460: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).locale
2461: = NULL;
2462: }
2463:
2464: break;
2465: }
2466:
2467: case TBL :
2468: {
2469: if (type != 'P')
2470: {
2471: if ((s_nouvel_objet = allocation(s_etat_processus, TBL))
2472: == NULL)
2473: {
2474: return(NULL);
2475: }
2476:
2477: (*((struct_tableau *) (*s_nouvel_objet).objet))
2478: .nombre_elements = (*((struct_tableau *)
2479: (*s_objet).objet)).nombre_elements;
2480:
2481: if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
2482: malloc((*((struct_tableau *) (*s_objet).objet))
2483: .nombre_elements * sizeof(struct_objet *))) == NULL)
2484: {
2485: return(NULL);
2486: }
2487:
2488: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2489: .nombre_elements; i++)
2490: {
2491: if (((*((struct_tableau *) (*s_nouvel_objet).objet))
2492: .elements[i] = copie_objet(s_etat_processus,
2493: (*((struct_tableau *) (*s_objet).objet))
2494: .elements[i], type)) == NULL)
2495: {
2496: for(j = 0; j < i; j++)
2497: {
2498: liberation(s_etat_processus, (*((struct_tableau *)
2499: (*s_nouvel_objet).objet)).elements[j]);
2500: }
2501:
2502: free((*((struct_tableau *) (*s_nouvel_objet).objet))
2503: .elements);
2504: free((*s_nouvel_objet).objet);
2505: free(s_nouvel_objet);
2506:
2507: return(NULL);
2508: }
2509: }
2510: }
2511: else
2512: {
2513: incrementation_atomique(s_objet);
2514:
2515: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2516: .nombre_elements; i++)
2517: {
2518: (*((struct_tableau *) (*s_objet).objet)).elements[i] =
2519: copie_objet(s_etat_processus, (*((struct_tableau *)
2520: (*s_objet).objet)).elements[i], 'P');
2521: }
2522:
2523: return(s_objet);
2524: }
2525:
2526: break;
2527: }
2528:
2529: case VIN :
2530: {
2531: if (type != 'O')
2532: {
2533: incrementation_atomique(s_objet);
2534: return(s_objet);
2535: }
2536:
2537: if ((s_nouvel_objet = allocation(s_etat_processus, VIN)) == NULL)
2538: {
2539: return(NULL);
2540: }
2541:
2542: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2543: (void *) ((integer8 *) malloc(
2544: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2545: * sizeof(integer8)));
2546:
2547: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2548: == NULL)
2549: {
2550: free((*s_nouvel_objet).objet);
2551: free(s_nouvel_objet);
2552: return(NULL);
2553: }
2554:
2555: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2556: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2557: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2558: (*((struct_vecteur *) ((*s_objet).objet))).type;
2559:
2560: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2561: i++)
2562: {
2563: ((integer8 *) ((*((struct_vecteur *)
2564: ((*s_nouvel_objet).objet))).tableau))[i] =
2565: ((integer8 *) ((*((struct_vecteur *)
2566: ((*s_objet).objet))).tableau))[i];
2567: }
2568:
2569: break;
2570: }
2571:
2572: case VCX :
2573: {
2574: if (type != 'O')
2575: {
2576: incrementation_atomique(s_objet);
2577: return(s_objet);
2578: }
2579:
2580: if ((s_nouvel_objet = allocation(s_etat_processus, VCX)) == NULL)
2581: {
2582: return(NULL);
2583: }
2584:
2585: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2586: (void *) ((struct_complexe16 *) malloc(
2587: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2588: * sizeof(struct_complexe16)));
2589:
2590: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2591: == NULL)
2592: {
2593: free((*s_nouvel_objet).objet);
2594: free(s_nouvel_objet);
2595: return(NULL);
2596: }
2597:
2598: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2599: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2600: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2601: (*((struct_vecteur *) ((*s_objet).objet))).type;
2602:
2603: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2604: i++)
2605: {
2606: ((struct_complexe16 *) ((*((struct_vecteur *)
2607: ((*s_nouvel_objet).objet))).tableau))[i] =
2608: ((struct_complexe16 *) ((*((struct_vecteur *)
2609: ((*s_objet).objet))).tableau))[i];
2610: }
2611:
2612: break;
2613: }
2614:
2615: case VRL :
2616: {
2617: if (type != 'O')
2618: {
2619: incrementation_atomique(s_objet);
2620: return(s_objet);
2621: }
2622:
2623: if ((s_nouvel_objet = allocation(s_etat_processus, VRL)) == NULL)
2624: {
2625: return(NULL);
2626: }
2627:
2628: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2629: (void *) ((real8 *) malloc(
2630: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2631: * sizeof(real8)));
2632:
2633: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2634: == NULL)
2635: {
2636: free((*s_nouvel_objet).objet);
2637: free(s_nouvel_objet);
2638: return(NULL);
2639: }
2640:
2641: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2642: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2643: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2644: (*((struct_vecteur *) ((*s_objet).objet))).type;
2645:
2646: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2647: i++)
2648: {
2649: ((real8 *) ((*((struct_vecteur *)
2650: ((*s_nouvel_objet).objet))).tableau))[i] =
2651: ((real8 *) ((*((struct_vecteur *)
2652: ((*s_objet).objet))).tableau))[i];
2653: }
2654:
2655: break;
2656: }
2657:
2658: default :
2659: {
2660: return(NULL);
2661: }
2662: }
2663:
2664: return(s_nouvel_objet);
2665:
2666: #undef return
2667: }
2668:
2669:
2670: /*
2671: ================================================================================
2672: Routine de copie d'une structure de description d'un processus
2673: ================================================================================
2674: Entrées : pointeur sur la structure de description d'un processus
2675: --------------------------------------------------------------------------------
2676: Sorties : structure identique (tous les objets sont copiés)
2677: --------------------------------------------------------------------------------
2678: Effets de bord : néant
2679: ================================================================================
2680: */
2681:
2682: struct_processus *
2683: copie_etat_processus(struct_processus *s_etat_processus)
2684: {
2685: pthread_mutexattr_t attributs_mutex;
2686:
2687: struct_liste_chainee *l_element_lecture;
2688: struct_liste_chainee *l_element_precedent;
2689: struct_liste_chainee *l_element_suivant;
2690:
2691: struct_processus *s_nouvel_etat_processus;
2692:
2693: unsigned long i;
2694:
2695: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2696: {
2697: (*s_etat_processus).erreur_systeme = d_es_processus;
2698: return(NULL);
2699: }
2700:
2701: if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)
2702: {
2703: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2704: return(NULL);
2705: }
2706:
2707: (*s_nouvel_etat_processus) = (*s_etat_processus);
2708:
2709: // On réinitialise l'allocateur.
2710:
2711: initialisation_allocateur(s_nouvel_etat_processus);
2712:
2713: /*
2714: * (*s_etat_processus).definition_chainee,
2715: * (*s_etat_processus).nom_fichier_source,
2716: * (*s_etat_processus).nom_fichier_historique et
2717: * (*s_etat_processus).chemin_fichier_temporaires
2718: * n'ont aucune raison de changer.
2719: */
2720:
2721: sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
2722:
2723: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
2724: (*s_nouvel_etat_processus).fichiers_graphiques = NULL;
2725: (*s_nouvel_etat_processus).entree_standard = NULL;
2726: (*s_nouvel_etat_processus).s_marques = NULL;
2727: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai;
2728: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux;
2729: (*s_nouvel_etat_processus).nom_fichier_impression = NULL;
2730: (*s_nouvel_etat_processus).expression_courante = NULL;
2731: (*s_nouvel_etat_processus).objet_courant = NULL;
2732: (*s_nouvel_etat_processus).processus_detache = d_faux;
1.3 bertrand 2733: (*s_nouvel_etat_processus).evaluation_forcee = 'N';
1.1 bertrand 2734:
2735: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
2736: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
2737: (*s_nouvel_etat_processus).presence_fusible = d_faux;
2738: (*s_nouvel_etat_processus).thread_fusible = 0;
2739: (*s_nouvel_etat_processus).niveau_initial =
2740: (*s_etat_processus).niveau_courant;
2741: (*s_nouvel_etat_processus).presence_pipes = d_faux;
2742: (*s_nouvel_etat_processus).debug_programme = d_faux;
2743: (*s_nouvel_etat_processus).s_fichiers = NULL;
2744: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL;
2745:
2746: // On réinitialise toutes les interruptions.
2747:
2748: (*s_nouvel_etat_processus).traitement_interruption = 'N';
2749: (*s_nouvel_etat_processus).traitement_interruptible = 'Y';
2750: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
2751: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
2752:
2753: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2754: {
2755: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
2756: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N';
2757: (*s_nouvel_etat_processus).queue_interruptions[i] = 0;
2758: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL;
2759: }
2760:
2761: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
2762: {
2763: (*s_nouvel_etat_processus).generateur_aleatoire = NULL;
2764: }
2765:
2766: (*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;
2767:
2768: // Copie de la localisation
2769:
2770: if (((*s_nouvel_etat_processus).localisation = malloc((strlen(
2771: (*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))
2772: == NULL)
2773: {
2774: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2775: return(NULL);
2776: }
2777:
2778: strcpy((*s_nouvel_etat_processus).localisation,
2779: (*s_etat_processus).localisation);
2780:
2781: if ((*s_etat_processus).indep != NULL)
2782: {
2783: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
2784: (*s_etat_processus).indep, 'P')) == NULL)
2785: {
2786: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2787: {
2788: (*s_etat_processus).erreur_systeme = d_es_processus;
2789: return(NULL);
2790: }
2791:
2792: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2793: return(NULL);
2794: }
2795: }
2796: else
2797: {
2798: (*s_nouvel_etat_processus).indep = NULL;
2799: }
2800:
2801: if ((*s_etat_processus).depend != NULL)
2802: {
2803: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
2804: (*s_etat_processus).depend, 'P')) == NULL)
2805: {
2806: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2807: {
2808: (*s_etat_processus).erreur_systeme = d_es_processus;
2809: return(NULL);
2810: }
2811:
2812: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2813: return(NULL);
2814: }
2815: }
2816: else
2817: {
2818: (*s_nouvel_etat_processus).depend = NULL;
2819: }
2820:
2821: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL)
2822: {
2823: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau =
2824: copie_objet(s_etat_processus, (*s_etat_processus)
2825: .parametres_courbes_de_niveau, 'P')) == NULL)
2826: {
2827: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2828: {
2829: (*s_etat_processus).erreur_systeme = d_es_processus;
2830: return(NULL);
2831: }
2832:
2833: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2834: return(NULL);
2835: }
2836: }
2837: else
2838: {
2839: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL;
2840: }
2841:
2842: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL;
2843:
2844: if (((*s_etat_processus).instruction_courante != NULL) &&
2845: (*s_etat_processus).evaluation_expression_compilee == 'N')
2846: {
2847: if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(
2848: (*s_etat_processus).instruction_courante) + 1) *
2849: sizeof(unsigned char))) == NULL)
2850: {
2851: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2852: {
2853: (*s_etat_processus).erreur_systeme = d_es_processus;
2854: return(NULL);
2855: }
2856:
2857: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2858: return(NULL);
2859: }
2860:
2861: strcpy((*s_nouvel_etat_processus).instruction_courante,
2862: (*s_etat_processus).instruction_courante);
2863: }
2864: else
2865: {
2866: (*s_nouvel_etat_processus).instruction_courante = NULL;
2867: }
2868:
2869: if ((*s_etat_processus).label_x != NULL)
2870: {
2871: if (((*s_nouvel_etat_processus).label_x = malloc((strlen(
2872: (*s_etat_processus).label_x) + 1) *
2873: sizeof(unsigned char))) == NULL)
2874: {
2875: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2876: {
2877: (*s_etat_processus).erreur_systeme = d_es_processus;
2878: return(NULL);
2879: }
2880:
2881: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2882: return(NULL);
2883: }
2884:
2885: strcpy((*s_nouvel_etat_processus).label_x,
2886: (*s_etat_processus).label_x);
2887: }
2888: else
2889: {
2890: (*s_nouvel_etat_processus).label_x = NULL;
2891: }
2892:
2893: if ((*s_etat_processus).label_y != NULL)
2894: {
2895: if (((*s_nouvel_etat_processus).label_y = malloc((strlen(
2896: (*s_etat_processus).label_y) + 1) *
2897: sizeof(unsigned char))) == NULL)
2898: {
2899: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2900: {
2901: (*s_etat_processus).erreur_systeme = d_es_processus;
2902: return(NULL);
2903: }
2904:
2905: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2906: return(NULL);
2907: }
2908:
2909: strcpy((*s_nouvel_etat_processus).label_y,
2910: (*s_etat_processus).label_y);
2911: }
2912: else
2913: {
2914: (*s_nouvel_etat_processus).label_y = NULL;
2915: }
2916:
2917: if ((*s_etat_processus).label_z != NULL)
2918: {
2919: if (((*s_nouvel_etat_processus).label_z = malloc((strlen(
2920: (*s_etat_processus).label_z) + 1) *
2921: sizeof(unsigned char))) == NULL)
2922: {
2923: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2924: {
2925: (*s_etat_processus).erreur_systeme = d_es_processus;
2926: return(NULL);
2927: }
2928:
2929: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2930: return(NULL);
2931: }
2932:
2933: strcpy((*s_nouvel_etat_processus).label_z,
2934: (*s_etat_processus).label_z);
2935: }
2936: else
2937: {
2938: (*s_nouvel_etat_processus).label_z = NULL;
2939: }
2940:
2941: if ((*s_etat_processus).titre != NULL)
2942: {
2943: if (((*s_nouvel_etat_processus).titre = malloc((strlen(
2944: (*s_etat_processus).titre) + 1) *
2945: sizeof(unsigned char))) == NULL)
2946: {
2947: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2948: {
2949: (*s_etat_processus).erreur_systeme = d_es_processus;
2950: return(NULL);
2951: }
2952:
2953: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2954: return(NULL);
2955: }
2956:
2957: strcpy((*s_nouvel_etat_processus).titre,
2958: (*s_etat_processus).titre);
2959: }
2960: else
2961: {
2962: (*s_nouvel_etat_processus).titre = NULL;
2963: }
2964:
2965: if ((*s_etat_processus).legende != NULL)
2966: {
2967: if (((*s_nouvel_etat_processus).legende = malloc((strlen(
2968: (*s_etat_processus).legende) + 1) *
2969: sizeof(unsigned char))) == NULL)
2970: {
2971: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2972: {
2973: (*s_etat_processus).erreur_systeme = d_es_processus;
2974: return(NULL);
2975: }
2976:
2977: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2978: return(NULL);
2979: }
2980:
2981: strcpy((*s_nouvel_etat_processus).legende,
2982: (*s_etat_processus).legende);
2983: }
2984: else
2985: {
2986: (*s_nouvel_etat_processus).legende = NULL;
2987: }
2988:
2989: /*
2990: * Copie de la table des variables
2991: */
2992:
2993: if (((*s_nouvel_etat_processus).s_liste_variables =
2994: malloc((*s_etat_processus).nombre_variables_allouees *
2995: sizeof(struct_variable))) == NULL)
2996: {
2997: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2998: {
2999: (*s_etat_processus).erreur_systeme = d_es_processus;
3000: return(NULL);
3001: }
3002:
3003: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3004: return(NULL);
3005: }
3006:
3007: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
3008: {
3009: if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
3010: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
3011: + 1) * sizeof(unsigned char))) == NULL)
3012: {
3013: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3014: {
3015: (*s_etat_processus).erreur_systeme = d_es_processus;
3016: return(NULL);
3017: }
3018:
3019: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3020: return(NULL);
3021: }
3022:
3023: strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
3024: (*s_etat_processus).s_liste_variables[i].nom);
3025:
3026: (*s_nouvel_etat_processus).s_liste_variables[i].origine =
3027: (*s_etat_processus).s_liste_variables[i].origine;
3028: (*s_nouvel_etat_processus).s_liste_variables[i].niveau =
3029: (*s_etat_processus).s_liste_variables[i].niveau;
3030: (*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
3031: (*s_etat_processus).s_liste_variables[i].variable_statique;
3032: (*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
3033: (*s_etat_processus).s_liste_variables[i].variable_verrouillee;
3034:
3035: // Les définitions sont partagées entre tous les threads.
3036:
3037: if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
3038: {
3039: (*s_nouvel_etat_processus).s_liste_variables[i].objet =
3040: (*s_etat_processus).s_liste_variables[i].objet;
3041: }
3042: else
3043: {
3044: if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
3045: copie_objet(s_etat_processus,
3046: (*s_etat_processus).s_liste_variables[i]
3047: .objet, 'P')) == NULL)
3048: {
3049: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3050: {
3051: (*s_etat_processus).erreur_systeme = d_es_processus;
3052: return(NULL);
3053: }
3054:
3055: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3056: return(NULL);
3057: }
3058: }
3059: }
3060:
3061: /*
3062: * Copie de la table des variables statiques
3063: */
3064:
3065: if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
3066: malloc((*s_etat_processus).nombre_variables_statiques_allouees *
3067: sizeof(struct_variable_statique))) == NULL)
3068: {
3069: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3070: {
3071: (*s_etat_processus).erreur_systeme = d_es_processus;
3072: return(NULL);
3073: }
3074:
3075: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3076: return(NULL);
3077: }
3078:
3079: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
3080: {
3081: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =
3082: malloc((strlen((*s_etat_processus).s_liste_variables_statiques
3083: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3084: {
3085: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3086: {
3087: (*s_etat_processus).erreur_systeme = d_es_processus;
3088: return(NULL);
3089: }
3090:
3091: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3092: return(NULL);
3093: }
3094:
3095: strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
3096: (*s_etat_processus).s_liste_variables_statiques[i].nom);
3097:
3098: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
3099: (*s_etat_processus).s_liste_variables_statiques[i].origine;
3100: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
3101: (*s_etat_processus).s_liste_variables_statiques[i].niveau;
3102: (*s_nouvel_etat_processus).s_liste_variables_statiques[i]
3103: .variable_statique = (*s_etat_processus)
3104: .s_liste_variables_statiques[i].variable_statique;
3105:
3106: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
3107: copie_objet(s_etat_processus, (*s_etat_processus)
3108: .s_liste_variables_statiques[i].objet, 'P')) == NULL)
3109: {
3110: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3111: {
3112: (*s_etat_processus).erreur_systeme = d_es_processus;
3113: return(NULL);
3114: }
3115:
3116: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3117: return(NULL);
3118: }
3119: }
3120:
3121: /*
3122: * Copie de la pile opérationnelle
3123: */
3124:
3125: (*s_nouvel_etat_processus).l_base_pile = NULL;
3126: l_element_lecture = (*s_etat_processus).l_base_pile;
3127: l_element_precedent = NULL;
3128:
3129: while(l_element_lecture != NULL)
3130: {
3131: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3132: {
3133: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3134: {
3135: (*s_etat_processus).erreur_systeme = d_es_processus;
3136: return(NULL);
3137: }
3138:
3139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3140: return(NULL);
3141: }
3142:
3143: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3144: (*l_element_lecture).donnee, 'P')) == NULL)
3145: {
3146: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3147: {
3148: (*s_etat_processus).erreur_systeme = d_es_processus;
3149: return(NULL);
3150: }
3151:
3152: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3153: return(NULL);
3154: }
3155:
3156: (*l_element_suivant).suivant = NULL;
3157:
3158: if ((*s_nouvel_etat_processus).l_base_pile == NULL)
3159: {
3160: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant;
3161: }
3162: else
3163: {
3164: (*l_element_precedent).suivant = l_element_suivant;
3165: }
3166:
3167: l_element_precedent = l_element_suivant;
3168: l_element_lecture = (*l_element_lecture).suivant;
3169: }
3170:
3171: /*
3172: * Copie de la pile système
3173: */
3174:
3175: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL;
3176: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0;
3177:
3178: empilement_pile_systeme(s_nouvel_etat_processus);
3179:
3180: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3181: {
3182: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3183: {
3184: (*s_etat_processus).erreur_systeme = d_es_processus;
3185: return(NULL);
3186: }
3187:
3188: (*s_etat_processus).erreur_systeme =
3189: (*s_nouvel_etat_processus).erreur_systeme;
3190: return(NULL);
3191: }
3192:
3193: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3194:
3195: /*
3196: * On empile deux valeurs retour_definition pour pouvoir récupérer
3197: * les variables dans le cas d'un programme compilé.
3198: */
3199:
3200: empilement_pile_systeme(s_nouvel_etat_processus);
3201:
3202: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3203: {
3204: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3205: {
3206: (*s_etat_processus).erreur_systeme = d_es_processus;
3207: return(NULL);
3208: }
3209:
3210: (*s_etat_processus).erreur_systeme =
3211: (*s_nouvel_etat_processus).erreur_systeme;
3212: return(NULL);
3213: }
3214:
3215: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3216:
3217: /*
3218: * Destruction de la pile last pour le thread en cours.
3219: */
3220:
3221: (*s_nouvel_etat_processus).l_base_pile_last = NULL;
3222: (*s_nouvel_etat_processus).l_base_pile_processus = NULL;
3223:
3224: /*
3225: * Copie des différents contextes
3226: */
3227:
3228: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
3229: l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
3230:
3231: while(l_element_lecture != NULL)
3232: {
3233: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3234: {
3235: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3236: {
3237: (*s_etat_processus).erreur_systeme = d_es_processus;
3238: return(NULL);
3239: }
3240:
3241: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3242: return(NULL);
3243: }
3244:
3245: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3246: (*l_element_lecture).donnee, 'P')) == NULL)
3247: {
3248: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3249: {
3250: (*s_etat_processus).erreur_systeme = d_es_processus;
3251: return(NULL);
3252: }
3253:
3254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3255: return(NULL);
3256: }
3257:
3258: (*l_element_suivant).suivant = NULL;
3259:
3260: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL)
3261: {
3262: (*s_nouvel_etat_processus).l_base_pile_contextes =
3263: l_element_suivant;
3264: }
3265: else
3266: {
3267: (*l_element_precedent).suivant = l_element_suivant;
3268: }
3269:
3270: l_element_precedent = l_element_suivant;
3271: l_element_lecture = (*l_element_lecture).suivant;
3272: }
3273:
3274: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL;
3275: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes;
3276:
3277: while(l_element_lecture != NULL)
3278: {
3279: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3280: {
3281: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3282: {
3283: (*s_etat_processus).erreur_systeme = d_es_processus;
3284: return(NULL);
3285: }
3286:
3287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3288: return(NULL);
3289: }
3290:
3291: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3292: (*l_element_lecture).donnee, 'P')) == NULL)
3293: {
3294: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3295: {
3296: (*s_etat_processus).erreur_systeme = d_es_processus;
3297: return(NULL);
3298: }
3299:
3300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3301: return(NULL);
3302: }
3303:
3304: (*l_element_suivant).suivant = NULL;
3305:
3306: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL)
3307: {
3308: (*s_nouvel_etat_processus).l_base_pile_taille_contextes =
3309: l_element_suivant;
3310: }
3311: else
3312: {
3313: (*l_element_precedent).suivant = l_element_suivant;
3314: }
3315:
3316: l_element_precedent = l_element_suivant;
3317: l_element_lecture = (*l_element_lecture).suivant;
3318: }
3319:
3320: /*
3321: * Copies des piles s_sockets, s_bibliotheques et
3322: * s_instructions_externes.
3323: */
3324:
3325: (*s_nouvel_etat_processus).s_sockets = NULL;
3326: l_element_lecture = (*s_etat_processus).s_sockets;
3327:
3328: while(l_element_lecture != NULL)
3329: {
3330: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3331: {
3332: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3333: {
3334: (*s_etat_processus).erreur_systeme = d_es_processus;
3335: return(NULL);
3336: }
3337:
3338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3339: return(NULL);
3340: }
3341:
3342: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3343: (*l_element_lecture).donnee, 'P')) == NULL)
3344: {
3345: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3346: {
3347: (*s_etat_processus).erreur_systeme = d_es_processus;
3348: return(NULL);
3349: }
3350:
3351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3352: return(NULL);
3353: }
3354:
3355: (*l_element_suivant).suivant = NULL;
3356:
3357: if ((*s_nouvel_etat_processus).s_sockets == NULL)
3358: {
3359: (*s_nouvel_etat_processus).s_sockets = l_element_suivant;
3360: }
3361: else
3362: {
3363: (*l_element_precedent).suivant = l_element_suivant;
3364: }
3365:
3366: l_element_precedent = l_element_suivant;
3367: l_element_lecture = (*l_element_lecture).suivant;
3368: }
3369:
3370: (*s_nouvel_etat_processus).s_bibliotheques = NULL;
3371: l_element_precedent = NULL;
3372: l_element_lecture = (*s_etat_processus).s_bibliotheques;
3373:
3374: while(l_element_lecture != NULL)
3375: {
3376: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3377: {
3378: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3379: {
3380: (*s_etat_processus).erreur_systeme = d_es_processus;
3381: return(NULL);
3382: }
3383:
3384: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3385: return(NULL);
3386: }
3387:
3388: if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))
3389: == NULL)
3390: {
3391: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3392: return(NULL);
3393: }
3394:
3395: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur
3396: = (*((struct_bibliotheque *) (*l_element_lecture).donnee))
3397: .descripteur;
3398: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid
3399: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid;
3400: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid
3401: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
3402:
3403: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
3404: malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)
3405: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
3406: {
3407: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3408: {
3409: (*s_etat_processus).erreur_systeme = d_es_processus;
3410: return(NULL);
3411: }
3412:
3413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3414: return(NULL);
3415: }
3416:
3417: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom,
3418: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom);
3419:
3420: (*l_element_suivant).suivant = NULL;
3421:
3422: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL)
3423: {
3424: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant;
3425: }
3426: else
3427: {
3428: (*l_element_precedent).suivant = l_element_suivant;
3429: }
3430:
3431: l_element_precedent = l_element_suivant;
3432: l_element_lecture = (*l_element_lecture).suivant;
3433: }
3434:
3435: if ((*s_etat_processus).nombre_instructions_externes != 0)
3436: {
3437: if (((*s_nouvel_etat_processus).s_instructions_externes =
3438: malloc((*s_etat_processus).nombre_instructions_externes *
3439: sizeof(struct_instruction_externe))) == NULL)
3440: {
3441: (*s_etat_processus).erreur_systeme = d_es_processus;
3442: return(NULL);
3443: }
3444:
3445: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
3446: {
3447: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
3448: malloc((strlen((*s_etat_processus).s_instructions_externes
3449: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3450: {
3451: (*s_etat_processus).erreur_systeme = d_es_processus;
3452: return(NULL);
3453: }
3454:
3455: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom,
3456: (*s_etat_processus).s_instructions_externes[i].nom);
3457:
3458: if (((*s_nouvel_etat_processus).s_instructions_externes[i]
3459: .nom_bibliotheque = malloc((strlen((*s_etat_processus)
3460: .s_instructions_externes[i].nom_bibliotheque) + 1) *
3461: sizeof(unsigned char))) == NULL)
3462: {
3463: (*s_etat_processus).erreur_systeme = d_es_processus;
3464: return(NULL);
3465: }
3466:
3467: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i]
3468: .nom_bibliotheque, (*s_etat_processus)
3469: .s_instructions_externes[i].nom_bibliotheque);
3470:
3471: (*s_nouvel_etat_processus).s_instructions_externes[i]
3472: .descripteur_bibliotheque = (*s_etat_processus)
3473: .s_instructions_externes[i].descripteur_bibliotheque;
3474: }
3475: }
3476: else
3477: {
3478: (*s_nouvel_etat_processus).s_instructions_externes = NULL;
3479: }
3480:
3481: pthread_mutexattr_init(&attributs_mutex);
3482: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3483: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);
3484: pthread_mutexattr_destroy(&attributs_mutex);
3485:
3486: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3487: {
3488: (*s_etat_processus).erreur_systeme = d_es_processus;
3489: return(NULL);
3490: }
3491:
3492: return(s_nouvel_etat_processus);
3493:
3494: #undef return
3495: }
3496:
3497: // vim: ts=4