1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.16
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: Routines 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)).fonction = NULL;
407: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
408: (*((struct_fonction *) (*s_objet).objet)).prediction_execution
409: = d_faux;
410: break;
411: }
412:
413: case INT :
414: {
415: if ((*s_etat_processus).pointeur_int > 0)
416: {
417: (*s_objet).objet = (*s_etat_processus).objets_int
418: [--(*s_etat_processus).pointeur_int];
419: }
420: else
421: {
422: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
423: {
424: free(s_objet);
425: return(NULL);
426: }
427: }
428:
429: break;
430: }
431:
432: case LST :
433: {
434: (*s_objet).objet = NULL;
435: break;
436: }
437:
438: case MCX :
439: {
440: if ((*s_etat_processus).pointeur_mat > 0)
441: {
442: (*s_objet).objet = (*s_etat_processus).objets_mat
443: [--(*s_etat_processus).pointeur_mat];
444: }
445: else
446: {
447: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
448: {
449: free(s_objet);
450: return(NULL);
451: }
452: }
453:
454: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
455: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
456: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
457: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
458: break;
459: }
460:
461: case MIN :
462: {
463: if ((*s_etat_processus).pointeur_mat > 0)
464: {
465: (*s_objet).objet = (*s_etat_processus).objets_mat
466: [--(*s_etat_processus).pointeur_mat];
467: }
468: else
469: {
470: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
471: {
472: free(s_objet);
473: return(NULL);
474: }
475: }
476:
477: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
478: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
479: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
480: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
481: break;
482: }
483:
484: case MRL :
485: {
486: if ((*s_etat_processus).pointeur_mat > 0)
487: {
488: (*s_objet).objet = (*s_etat_processus).objets_mat
489: [--(*s_etat_processus).pointeur_mat];
490: }
491: else
492: {
493: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
494: {
495: free(s_objet);
496: return(NULL);
497: }
498: }
499:
500: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
501: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
502: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
503: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
504: break;
505: }
506:
507: case MTX :
508: {
509: if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
510: {
511: free(s_objet);
512: return(NULL);
513: }
514:
515: break;
516: }
517:
518: case NOM :
519: {
520: if ((*s_etat_processus).pointeur_nom > 0)
521: {
522: (*s_objet).objet = (*s_etat_processus).objets_nom
523: [--(*s_etat_processus).pointeur_nom];
524: }
525: else
526: {
527: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
528: {
529: free(s_objet);
530: return(NULL);
531: }
532: }
533:
534: break;
535: }
536:
537: case NON :
538: {
539: (*s_objet).objet = NULL;
540: break;
541: }
542:
543: case PRC :
544: {
545: if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
546: == NULL)
547: {
548: free(s_objet);
549: return(NULL);
550: }
551:
552: break;
553: }
554:
555: case REL :
556: {
557: if ((*s_etat_processus).pointeur_rel > 0)
558: {
559: (*s_objet).objet = (*s_etat_processus).objets_rel
560: [--(*s_etat_processus).pointeur_rel];
561: }
562: else
563: {
564: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
565: {
566: free(s_objet);
567: return(NULL);
568: }
569: }
570:
571: break;
572: }
573:
574: case RPN :
575: {
576: (*s_objet).objet = NULL;
577: break;
578: }
579:
580: case SCK :
581: {
582: if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
583: {
584: free(s_objet);
585: return(NULL);
586: }
587:
588: break;
589: }
590:
591: case SLB :
592: {
593: if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
594: == NULL)
595: {
596: free(s_objet);
597: return(NULL);
598: }
599:
600: break;
601: }
602:
603: case SPH :
604: {
605: if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
606: {
607: free(s_objet);
608: return(NULL);
609: }
610:
611: break;
612: }
613:
614: case SQL :
615: {
616: if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
617: == NULL)
618: {
619: free(s_objet);
620: return(NULL);
621: }
622:
623: break;
624: }
625:
626: case TBL :
627: {
628: if ((*s_etat_processus).pointeur_tab > 0)
629: {
630: (*s_objet).objet = (*s_etat_processus).objets_tab
631: [--(*s_etat_processus).pointeur_tab];
632: }
633: else
634: {
635: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
636: {
637: free(s_objet);
638: return(NULL);
639: }
640: }
641:
642: (*((struct_tableau *) (*s_objet).objet)).nombre_elements = 0;
643: (*((struct_tableau *) (*s_objet).objet)).elements = NULL;
644: break;
645: }
646:
647: case VCX :
648: {
649: if ((*s_etat_processus).pointeur_vec > 0)
650: {
651: (*s_objet).objet = (*s_etat_processus).objets_vec
652: [--(*s_etat_processus).pointeur_vec];
653: }
654: else
655: {
656: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
657: {
658: free(s_objet);
659: return(NULL);
660: }
661: }
662:
663: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
664: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
665: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
666: break;
667: }
668:
669: case VIN :
670: {
671: if ((*s_etat_processus).pointeur_vec > 0)
672: {
673: (*s_objet).objet = (*s_etat_processus).objets_vec
674: [--(*s_etat_processus).pointeur_vec];
675: }
676: else
677: {
678: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
679: {
680: free(s_objet);
681: return(NULL);
682: }
683: }
684:
685: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
686: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
687: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
688: break;
689: }
690:
691: case VRL :
692: {
693: if ((*s_etat_processus).pointeur_vec > 0)
694: {
695: (*s_objet).objet = (*s_etat_processus).objets_vec
696: [--(*s_etat_processus).pointeur_vec];
697: }
698: else
699: {
700: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
701: {
702: free(s_objet);
703: return(NULL);
704: }
705: }
706:
707: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
708: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
709: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
710: break;
711: }
712:
713: default :
714: {
715: free(s_objet);
716: BUG(1, printf("Allocation failure (type %d)\n", type));
717:
718: return(NULL);
719: }
720: }
721:
722: return(s_objet);
723: }
724:
725:
726: /*
727: ================================================================================
728: Routine de libération d'une structure *s_objet
729: ================================================================================
730: Entrées : structure sur l'état du processus et objet à afficher
731: --------------------------------------------------------------------------------
732: Sorties : chaine de caractères
733: --------------------------------------------------------------------------------
734: Effets de bord : néant
735: ================================================================================
736: */
737:
738: void
739: liberation(struct_processus *s_etat_processus, struct_objet *s_objet)
740: {
741: logical1 drapeau;
742:
743: struct_liste_chainee *l_element_courant;
744: struct_liste_chainee *l_element_suivant;
745:
746: unsigned long i;
747:
748: if (s_objet == NULL)
749: {
750: return;
751: }
752:
753: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
754: {
755: (*s_etat_processus).erreur_systeme = d_es_processus;
756: return;
757: }
758:
759: #define return \
760: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) \
761: { (*s_etat_processus).erreur_systeme = d_es_processus; return; } \
762: return
763:
764: BUG((*s_objet).nombre_occurrences <= 0,
765: pthread_mutex_unlock(&((*s_objet).mutex)),
766: printf("(*s_objet).nombre_occurrences=%ld\n",
767: (*s_objet).nombre_occurrences));
768:
769: switch((*s_objet).type)
770: {
771: case ADR :
772: {
773: if (decrementation_atomique(s_objet) > 0)
774: {
775: return;
776: }
777:
778: if ((*s_etat_processus).pointeur_adr < TAILLE_CACHE)
779: {
780: (*s_etat_processus).objets_adr
781: [(*s_etat_processus).pointeur_adr++] = (*s_objet).objet;
782: }
783: else
784: {
785: free((unsigned long *) ((*s_objet).objet));
786: }
787:
788: break;
789: }
790:
791: case ALG :
792: {
793: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
794:
795: if (decrementation_atomique(s_objet) > 0)
796: { // Il reste un pointeur sur l'objet.
797: while(l_element_courant != NULL)
798: {
799: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
800: pthread_mutex_unlock(&((*s_objet).mutex)),
801: printf("(*(*l_element_courant).donnee)"
802: ".nombre_occurrences=%ld\n",
803: (*(*l_element_courant).donnee).nombre_occurrences));
804:
805: liberation(s_etat_processus, (*l_element_courant).donnee);
806: l_element_courant = (*l_element_courant).suivant;
807: }
808:
809: return;
810: }
811: else
812: { // Il ne reste plus aucun pointeur sur l'objet.
813: while(l_element_courant != NULL)
814: {
815: l_element_suivant = (*l_element_courant).suivant;
816: liberation(s_etat_processus, (*l_element_courant).donnee);
817: liberation_maillon(s_etat_processus, l_element_courant);
818: l_element_courant = l_element_suivant;
819: }
820: }
821:
822: break;
823: }
824:
825: case BIN :
826: {
827: if (decrementation_atomique(s_objet) > 0)
828: {
829: return;
830: }
831:
832: if ((*s_etat_processus).pointeur_bin < TAILLE_CACHE)
833: {
834: (*s_etat_processus).objets_bin
835: [(*s_etat_processus).pointeur_bin++] = (*s_objet).objet;
836: }
837: else
838: {
839: free((logical8 *) ((*s_objet).objet));
840: }
841:
842: break;
843: }
844:
845: case CHN :
846: {
847: if (decrementation_atomique(s_objet) > 0)
848: {
849: return;
850: }
851:
852: free((unsigned char *) ((*s_objet).objet));
853: break;
854: }
855:
856: case CPL :
857: {
858: if (decrementation_atomique(s_objet) > 0)
859: {
860: return;
861: }
862:
863: if ((*s_etat_processus).pointeur_cpl < TAILLE_CACHE)
864: {
865: (*s_etat_processus).objets_cpl
866: [(*s_etat_processus).pointeur_cpl++] = (*s_objet).objet;
867: }
868: else
869: {
870: free((struct_complexe16 *) ((*s_objet).objet));
871: }
872:
873: break;
874: }
875:
876: case FCH :
877: {
878: if (decrementation_atomique(s_objet) > 0)
879: {
880: BUG((*(*((struct_fichier *) (*s_objet).objet)).format)
881: .nombre_occurrences <= 1,
882: pthread_mutex_unlock(&((*s_objet).mutex)),
883: printf("(*(*((struct_fichier *) (*s_objet).objet))"
884: ".format).nombre_occurrences=%ld\n",
885: (*(*((struct_fichier *) (*s_objet).objet)).format)
886: .nombre_occurrences));
887:
888: liberation(s_etat_processus,
889: (*((struct_fichier *) (*s_objet).objet)).format);
890: return;
891: }
892:
893: liberation(s_etat_processus,
894: (*((struct_fichier *) (*s_objet).objet)).format);
895: free((unsigned char *) (*((struct_fichier *)
896: (*s_objet).objet)).nom);
897: free((struct_fichier *) ((*s_objet).objet));
898: break;
899: }
900:
901: case FCT :
902: {
903: if (decrementation_atomique(s_objet) > 0)
904: {
905: return;
906: }
907:
908: free((unsigned char *) (*((struct_fonction *)
909: (*s_objet).objet)).nom_fonction);
910:
911: if ((*s_etat_processus).pointeur_fct < TAILLE_CACHE)
912: {
913: (*s_etat_processus).objets_fct
914: [(*s_etat_processus).pointeur_fct++] = (*s_objet).objet;
915: }
916: else
917: {
918: free((struct_fonction *) (*s_objet).objet);
919: }
920:
921: break;
922: }
923:
924: case INT :
925: {
926: if (decrementation_atomique(s_objet) > 0)
927: {
928: return;
929: }
930:
931: if ((*s_etat_processus).pointeur_int < TAILLE_CACHE)
932: {
933: (*s_etat_processus).objets_int
934: [(*s_etat_processus).pointeur_int++] = (*s_objet).objet;
935: }
936: else
937: {
938: free((integer8 *) ((*s_objet).objet));
939: }
940:
941: break;
942: }
943:
944: case LST :
945: {
946: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
947:
948: if (decrementation_atomique(s_objet) > 0)
949: { // Il reste un pointeur sur l'objet.
950: while(l_element_courant != NULL)
951: {
952: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
953: pthread_mutex_unlock(&((*s_objet).mutex)),
954: printf("(*(*l_element_courant).donnee)"
955: ".nombre_occurrences=%ld\n",
956: (*(*l_element_courant).donnee).nombre_occurrences));
957:
958: liberation(s_etat_processus, (*l_element_courant).donnee);
959: l_element_courant = (*l_element_courant).suivant;
960: }
961:
962: return;
963: }
964: else
965: { // Il ne reste plus aucun pointeur sur l'objet.
966: while(l_element_courant != NULL)
967: {
968: l_element_suivant = (*l_element_courant).suivant;
969: liberation(s_etat_processus, (*l_element_courant).donnee);
970: liberation_maillon(s_etat_processus, l_element_courant);
971: l_element_courant = l_element_suivant;
972: }
973: }
974:
975: break;
976: }
977:
978: case MIN :
979: {
980: if (decrementation_atomique(s_objet) > 0)
981: {
982: return;
983: }
984:
985: for(i = 0; i < (*((struct_matrice *)
986: ((*s_objet).objet))).nombre_lignes; i++)
987: {
988: free(((integer8 **) (*((struct_matrice *)
989: (*s_objet).objet)).tableau)[i]);
990: }
991:
992: free((integer8 **) (*((struct_matrice *)
993: (*s_objet).objet)).tableau);
994:
995: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
996: {
997: (*s_etat_processus).objets_mat
998: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
999: }
1000: else
1001: {
1002: free((struct_matrice *) (*s_objet).objet);
1003: }
1004:
1005: break;
1006: }
1007:
1008: case MCX :
1009: {
1010: if (decrementation_atomique(s_objet) > 0)
1011: {
1012: return;
1013: }
1014:
1015: for(i = 0; i < (*((struct_matrice *)
1016: ((*s_objet).objet))).nombre_lignes; i++)
1017: {
1018: free(((struct_complexe16 **) (*((struct_matrice *)
1019: (*s_objet).objet)).tableau)[i]);
1020: }
1021:
1022: free((struct_complexe16 **) (*((struct_matrice *)
1023: (*s_objet).objet)).tableau);
1024:
1025: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1026: {
1027: (*s_etat_processus).objets_mat
1028: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1029: }
1030: else
1031: {
1032: free((struct_matrice *) (*s_objet).objet);
1033: }
1034:
1035: break;
1036: }
1037:
1038: case MRL :
1039: {
1040: if (decrementation_atomique(s_objet) > 0)
1041: {
1042: return;
1043: }
1044:
1045: for(i = 0; i < (*((struct_matrice *)
1046: ((*s_objet).objet))).nombre_lignes; i++)
1047: {
1048: free(((real8 **) (*((struct_matrice *)
1049: (*s_objet).objet)).tableau)[i]);
1050: }
1051:
1052: free((real8 **) (*((struct_matrice *) (*s_objet).objet)).tableau);
1053:
1054: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1055: {
1056: (*s_etat_processus).objets_mat
1057: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1058: }
1059: else
1060: {
1061: free((struct_matrice *) (*s_objet).objet);
1062: }
1063:
1064: break;
1065: }
1066:
1067: case MTX :
1068: {
1069: if (decrementation_atomique(s_objet) > 0)
1070: {
1071: return;
1072: }
1073:
1074: free((struct_mutex *) (*s_objet).objet);
1075: break;
1076: }
1077:
1078: case NOM :
1079: {
1080: if (decrementation_atomique(s_objet) > 0)
1081: {
1082: return;
1083: }
1084:
1085: free((*((struct_nom *) (*s_objet).objet)).nom);
1086:
1087: if ((*s_etat_processus).pointeur_nom < TAILLE_CACHE)
1088: {
1089: (*s_etat_processus).objets_nom
1090: [(*s_etat_processus).pointeur_nom++] = (*s_objet).objet;
1091: }
1092: else
1093: {
1094: free((struct_nom *) (*s_objet).objet);
1095: }
1096:
1097: break;
1098: }
1099:
1100: case NON :
1101: {
1102: if (decrementation_atomique(s_objet) > 0)
1103: {
1104: return;
1105: }
1106:
1107: free(s_objet);
1108: break;
1109: }
1110:
1111: case PRC :
1112: {
1113: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1114: (*s_objet).objet)).thread).mutex)) != 0)
1115: {
1116: (*s_etat_processus).erreur_systeme = d_es_processus;
1117: return;
1118: }
1119:
1120: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1121: .nombre_references--;
1122:
1123: BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1124: .nombre_references < 0, printf("(*(*((struct_processus_fils"
1125: " *) (*s_objet).objet)).thread).nombre_references = %d\n",
1126: (int) (*(*((struct_processus_fils *) (*s_objet).objet))
1127: .thread).nombre_references));
1128:
1129: printf("liberation : %d\n", (*(*((struct_processus_fils *) (*s_objet).objet)).thread).nombre_references);
1130: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1131: .nombre_references == 0)
1132: {
1133: drapeau = d_vrai;
1134: }
1135: else
1136: {
1137: drapeau = d_faux;
1138: }
1139:
1140: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1141: (*s_objet).objet)).thread).mutex)) != 0)
1142: {
1143: (*s_etat_processus).erreur_systeme = d_es_processus;
1144: return;
1145: }
1146:
1147: if (drapeau == d_vrai)
1148: {
1149: pthread_mutex_destroy(&((*(*((struct_processus_fils *)
1150: (*s_objet).objet)).thread).mutex));
1151: free((*((struct_processus_fils *) (*s_objet).objet)).thread);
1152: }
1153:
1154: if (decrementation_atomique(s_objet) > 0)
1155: {
1156: return;
1157: }
1158:
1159: free((struct_processus_fils *) ((*s_objet).objet));
1160: break;
1161: }
1162:
1163: case REL :
1164: {
1165: if (decrementation_atomique(s_objet) > 0)
1166: {
1167: return;
1168: }
1169:
1170: if ((*s_etat_processus).pointeur_rel < TAILLE_CACHE)
1171: {
1172: (*s_etat_processus).objets_rel
1173: [(*s_etat_processus).pointeur_rel++] = (*s_objet).objet;
1174: }
1175: else
1176: {
1177: free((real8 *) ((*s_objet).objet));
1178: }
1179:
1180: break;
1181: }
1182:
1183: case RPN :
1184: {
1185: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1186:
1187: if (decrementation_atomique(s_objet) > 0)
1188: { // Il reste un pointeur sur l'objet.
1189: while(l_element_courant != NULL)
1190: {
1191: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
1192: pthread_mutex_unlock(&((*s_objet).mutex)),
1193: printf("(*(*l_element_courant).donnee)"
1194: ".nombre_occurrences=%ld\n",
1195: (*(*l_element_courant).donnee).nombre_occurrences));
1196:
1197: liberation(s_etat_processus, (*l_element_courant).donnee);
1198: l_element_courant = (*l_element_courant).suivant;
1199: }
1200:
1201: return;
1202: }
1203: else
1204: { // Il ne reste plus aucun pointeur sur l'objet.
1205: while(l_element_courant != NULL)
1206: {
1207: l_element_suivant = (*l_element_courant).suivant;
1208: liberation(s_etat_processus, (*l_element_courant).donnee);
1209: liberation_maillon(s_etat_processus, l_element_courant);
1210: l_element_courant = l_element_suivant;
1211: }
1212: }
1213:
1214: break;
1215: }
1216:
1217: case SCK :
1218: {
1219: if (decrementation_atomique(s_objet) > 0)
1220: {
1221: BUG((*(*((struct_socket *) (*s_objet).objet)).format)
1222: .nombre_occurrences <= 1,
1223: pthread_mutex_unlock(&((*s_objet).mutex)),
1224: printf("(*(*((struct_socket *) (*s_objet).objet))"
1225: ".format).nombre_occurrences=%ld\n",
1226: (*(*((struct_socket *) (*s_objet).objet)).format)
1227: .nombre_occurrences));
1228:
1229: liberation(s_etat_processus, (*((struct_socket *)
1230: (*s_objet).objet)).format);
1231: return;
1232: }
1233:
1234: liberation(s_etat_processus, (*((struct_socket *)
1235: (*s_objet).objet)).format);
1236:
1237: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1238: .adresse);
1239: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1240: .adresse_distante);
1241: free((struct_socket *) ((*s_objet).objet));
1242: break;
1243: }
1244:
1245: case SLB :
1246: {
1247: if (decrementation_atomique(s_objet) > 0)
1248: {
1249: return;
1250: }
1251:
1252: free((*((struct_bibliotheque *) (*s_objet).objet)).nom);
1253: free((struct_bibliotheque *) (*s_objet).objet);
1254: break;
1255: }
1256:
1257: case SPH :
1258: {
1259: if (decrementation_atomique(s_objet) > 0)
1260: {
1261: return;
1262: }
1263:
1264: free((*((struct_semaphore *) (*s_objet).objet)).nom);
1265: free((struct_bibliotheque *) (*s_objet).objet);
1266: break;
1267: }
1268:
1269: case SQL :
1270: {
1271: if (decrementation_atomique(s_objet) > 0)
1272: {
1273: return;
1274: }
1275:
1276: free((*((struct_connecteur_sql *) (*s_objet).objet)).type);
1277: free((*((struct_connecteur_sql *) (*s_objet).objet)).locale);
1278: free((struct_connecteur_sql *) (*s_objet).objet);
1279: break;
1280: }
1281:
1282: case TBL :
1283: {
1284: if (decrementation_atomique(s_objet) > 0)
1285: {
1286: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1287: .nombre_elements; i++)
1288: {
1289: BUG((*((*((struct_tableau *)
1290: (*s_objet).objet)).elements[i]))
1291: .nombre_occurrences <= 1,
1292: pthread_mutex_unlock(&((*s_objet).mutex)),
1293: printf("(*((*((struct_tableau *) (*s_objet).objet))"
1294: ".element[%lu])).nombre_occurrences=%ld\n", i,
1295: (*((*((struct_tableau *) (*s_objet).objet))
1296: .elements[i])).nombre_occurrences));
1297: liberation(s_etat_processus, (*((struct_tableau *)
1298: (*s_objet).objet)).elements[i]);
1299: }
1300:
1301: return;
1302: }
1303:
1304: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1305: .nombre_elements; i++)
1306: {
1307: liberation(s_etat_processus, (*((struct_tableau *)
1308: (*s_objet).objet)).elements[i]);
1309: }
1310:
1311: free((*((struct_tableau *) (*s_objet).objet)).elements);
1312:
1313: if ((*s_etat_processus).pointeur_tab < TAILLE_CACHE)
1314: {
1315: (*s_etat_processus).objets_tab
1316: [(*s_etat_processus).pointeur_tab++] = (*s_objet).objet;
1317: }
1318: else
1319: {
1320: free((struct_tableau *) (*s_objet).objet);
1321: }
1322:
1323: break;
1324: }
1325:
1326: case VIN :
1327: {
1328: if (decrementation_atomique(s_objet) > 0)
1329: {
1330: return;
1331: }
1332:
1333: free((integer8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1334:
1335: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1336: {
1337: (*s_etat_processus).objets_vec
1338: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1339: }
1340: else
1341: {
1342: free((struct_vecteur *) (*s_objet).objet);
1343: }
1344:
1345: break;
1346: }
1347:
1348: case VCX :
1349: {
1350: if (decrementation_atomique(s_objet) > 0)
1351: {
1352: return;
1353: }
1354:
1355: free((struct_complexe16 *) (*((struct_vecteur *)
1356: (*s_objet).objet)).tableau);
1357:
1358: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1359: {
1360: (*s_etat_processus).objets_vec
1361: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1362: }
1363: else
1364: {
1365: free((struct_vecteur *) (*s_objet).objet);
1366: }
1367:
1368: break;
1369: }
1370:
1371: case VRL :
1372: {
1373: if (decrementation_atomique(s_objet) > 0)
1374: {
1375: return;
1376: }
1377:
1378: free((real8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1379:
1380: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1381: {
1382: (*s_etat_processus).objets_vec
1383: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1384: }
1385: else
1386: {
1387: free((struct_vecteur *) (*s_objet).objet);
1388: }
1389:
1390: break;
1391: }
1392:
1393: default :
1394: {
1395: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1396: {
1397: (*s_etat_processus).erreur_systeme = d_es_processus;
1398: return;
1399: }
1400:
1401: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1402: {
1403: (*s_etat_processus).erreur_systeme = d_es_processus;
1404: return;
1405: }
1406:
1407: BUG(1, printf("Free failure (type %d)\n", (*s_objet).type));
1408: return;
1409: }
1410: }
1411:
1412: #undef return
1413:
1414: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1415: {
1416: (*s_etat_processus).erreur_systeme = d_es_processus;
1417: return;
1418: }
1419:
1420: if (s_etat_processus != NULL)
1421: {
1422: if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
1423: {
1424: (*s_objet).objet = (*s_etat_processus).pile_objets;
1425: (*s_etat_processus).pile_objets = s_objet;
1426: (*s_etat_processus).taille_pile_objets++;
1427: }
1428: else
1429: {
1430: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1431: {
1432: (*s_etat_processus).erreur_systeme = d_es_processus;
1433: return;
1434: }
1435:
1436: free(s_objet);
1437: }
1438: }
1439: else
1440: {
1441: free(s_objet);
1442: }
1443:
1444: return;
1445: }
1446:
1447:
1448: /*
1449: ================================================================================
1450: Routine de copie d'une structure *s_objet
1451: ================================================================================
1452: Entrées : structure *s_objet à copier
1453: type :
1454: 'P' : renvoie le même objet en incrémentant le nombre
1455: d'occurrence de chaque objet élémentaire ;
1456: 'O' : crée un nouvel objet en copiant chaque objet élémentaire ;
1457: 'N' : crée un nouvel objet mais les objets élémentaires
1458: sont réutilisés (voir 'P'). Dans le cas d'un objet
1459: élémentaire, 'N' et 'P' sont identiques.
1460: 'Q' : 'P' si nombre_occurrences vaut 1, 'O' sinon.
1461: 'R' : 'P' si nombre_occurrences vaut 1, 'N' sinon.
1462: --------------------------------------------------------------------------------
1463: Sorties : structure identique (tous les objets sont copiés)
1464: --------------------------------------------------------------------------------
1465: Effets de bord : néant
1466: ================================================================================
1467: */
1468:
1469: struct_objet *
1470: copie_objet(struct_processus *s_etat_processus,
1471: struct_objet *s_objet, unsigned char type)
1472: {
1473: struct_liste_chainee *l_element_base;
1474: struct_liste_chainee *l_element_courant;
1475: struct_liste_chainee *l_element_courant_ecriture;
1476: struct_liste_chainee *l_element_courant_lecture;
1477: struct_liste_chainee *l_element_suivant_ecriture;
1478: struct_liste_chainee *l_element_suivant_lecture;
1479:
1480: struct_objet *s_nouvel_objet;
1481: struct_objet *s_objet_tampon;
1482:
1483: unsigned long i;
1484: unsigned long j;
1485:
1486: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
1487: {
1488: (*s_etat_processus).erreur_systeme = d_es_processus;
1489: return(NULL);
1490: }
1491:
1492: if (type == 'Q')
1493: {
1494: if ((*s_objet).nombre_occurrences == 1)
1495: {
1496: type = 'P';
1497: }
1498: else
1499: {
1500: type = 'O';
1501: }
1502: }
1503: else if (type == 'R')
1504: {
1505: if ((*s_objet).nombre_occurrences == 1)
1506: {
1507: type = 'P';
1508: }
1509: else
1510: {
1511: type = 'N';
1512: }
1513: }
1514:
1515: #define return(pointeur) \
1516: if (pthread_mutex_unlock(&((*s_objet).mutex))) \
1517: { (*s_etat_processus).erreur_systeme = d_es_processus; return(NULL); } \
1518: return(pointeur)
1519:
1520: switch((*s_objet).type)
1521: {
1522: case ADR :
1523: {
1524: if (type != 'O')
1525: {
1526: incrementation_atomique(s_objet);
1527: return(s_objet);
1528: }
1529:
1530: if ((s_nouvel_objet = allocation(s_etat_processus, ADR)) == NULL)
1531: {
1532: return(NULL);
1533: }
1534:
1535: (*((unsigned long *) ((*s_nouvel_objet).objet))) =
1536: (*((unsigned long *) ((*s_objet).objet)));
1537: break;
1538: }
1539:
1540: case ALG :
1541: {
1542: if (type != 'P')
1543: {
1544: if ((s_nouvel_objet = allocation(s_etat_processus, ALG))
1545: == NULL)
1546: {
1547: return(NULL);
1548: }
1549:
1550: l_element_courant_lecture = (struct_liste_chainee *)
1551: ((*s_objet).objet);
1552:
1553: l_element_base = NULL;
1554: l_element_courant_ecriture = l_element_base;
1555:
1556: while(l_element_courant_lecture != NULL)
1557: {
1558: s_objet_tampon = copie_objet(s_etat_processus,
1559: (*l_element_courant_lecture).donnee, type);
1560: l_element_suivant_ecriture = (struct_liste_chainee *)
1561: malloc(sizeof(struct_liste_chainee));
1562:
1563: if ((s_objet_tampon == NULL) ||
1564: (l_element_suivant_ecriture == NULL))
1565: {
1566: l_element_courant_lecture = (struct_liste_chainee *)
1567: ((*s_nouvel_objet).objet);
1568:
1569: while(l_element_courant_lecture != NULL)
1570: {
1571: l_element_suivant_lecture =
1572: (*l_element_courant_lecture).suivant;
1573: liberation(s_etat_processus,
1574: (*l_element_courant_lecture).donnee);
1575: free(l_element_courant_lecture);
1576: l_element_courant_lecture =
1577: l_element_suivant_lecture;
1578: }
1579:
1580: return(NULL);
1581: }
1582:
1583: if (l_element_courant_ecriture == NULL)
1584: {
1585: l_element_base = l_element_suivant_ecriture;
1586: }
1587: else
1588: {
1589: (*l_element_courant_ecriture).suivant =
1590: l_element_suivant_ecriture;
1591: }
1592:
1593: l_element_courant_ecriture = l_element_suivant_ecriture;
1594:
1595: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1596: (*l_element_courant_ecriture).suivant = NULL;
1597: l_element_courant_lecture =
1598: (*l_element_courant_lecture).suivant;
1599: }
1600:
1601: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1602: l_element_base);
1603: }
1604: else // type == 'P'
1605: {
1606: incrementation_atomique(s_objet);
1607: l_element_courant = (*s_objet).objet;
1608:
1609: while(l_element_courant != NULL)
1610: {
1611: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1612: (*l_element_courant).donnee, 'P');
1613: l_element_courant = (*l_element_courant).suivant;
1614: }
1615:
1616: return(s_objet);
1617: }
1618:
1619: break;
1620: }
1621:
1622: case BIN :
1623: {
1624: if (type != 'O')
1625: {
1626: incrementation_atomique(s_objet);
1627: return(s_objet);
1628: }
1629:
1630: if ((s_nouvel_objet = allocation(s_etat_processus, BIN)) == NULL)
1631: {
1632: return(NULL);
1633: }
1634:
1635: (*((logical8 *) ((*s_nouvel_objet).objet))) =
1636: (*((logical8 *) ((*s_objet).objet)));
1637: break;
1638: }
1639:
1640: case CHN :
1641: {
1642: if (type != 'O')
1643: {
1644: incrementation_atomique(s_objet);
1645: return(s_objet);
1646: }
1647:
1648: if ((s_nouvel_objet = allocation(s_etat_processus, CHN)) == NULL)
1649: {
1650: return(NULL);
1651: }
1652:
1653: (*s_nouvel_objet).objet = (void *) ((unsigned char *)
1654: malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
1655: * sizeof(unsigned char)));
1656:
1657: if ((*s_nouvel_objet).objet == NULL)
1658: {
1659: free(s_nouvel_objet);
1660: return(NULL);
1661: }
1662:
1663: strcpy((unsigned char *) ((*s_nouvel_objet).objet),
1664: (unsigned char *) ((*s_objet).objet));
1665: break;
1666: }
1667:
1668: case CPL :
1669: {
1670: if (type != 'O')
1671: {
1672: incrementation_atomique(s_objet);
1673: return(s_objet);
1674: }
1675:
1676: if ((s_nouvel_objet = allocation(s_etat_processus, CPL)) == NULL)
1677: {
1678: return(NULL);
1679: }
1680:
1681: (*((struct_complexe16 *) ((*s_nouvel_objet).objet))) =
1682: (*((struct_complexe16 *) ((*s_objet).objet)));
1683: break;
1684: }
1685:
1686: case RPN :
1687: {
1688: if (type != 'P')
1689: {
1690: if ((s_nouvel_objet = allocation(s_etat_processus, RPN))
1691: == NULL)
1692: {
1693: return(NULL);
1694: }
1695:
1696: l_element_courant_lecture = (struct_liste_chainee *)
1697: ((*s_objet).objet);
1698:
1699: l_element_base = NULL;
1700: l_element_courant_ecriture = l_element_base;
1701:
1702: while(l_element_courant_lecture != NULL)
1703: {
1704: s_objet_tampon = copie_objet(s_etat_processus,
1705: (*l_element_courant_lecture).donnee, type);
1706: l_element_suivant_ecriture = (struct_liste_chainee *)
1707: malloc(sizeof(struct_liste_chainee));
1708:
1709: if ((s_objet_tampon == NULL) ||
1710: (l_element_suivant_ecriture == NULL))
1711: {
1712: l_element_courant_lecture = (struct_liste_chainee *)
1713: ((*s_nouvel_objet).objet);
1714:
1715: while(l_element_courant_lecture != NULL)
1716: {
1717: l_element_suivant_lecture =
1718: (*l_element_courant_lecture).suivant;
1719: liberation(s_etat_processus,
1720: (*l_element_courant_lecture).donnee);
1721: free(l_element_courant_lecture);
1722: l_element_courant_lecture =
1723: l_element_suivant_lecture;
1724: }
1725:
1726: return(NULL);
1727: }
1728:
1729: if (l_element_courant_ecriture == NULL)
1730: {
1731: l_element_base = l_element_suivant_ecriture;
1732: }
1733: else
1734: {
1735: (*l_element_courant_ecriture).suivant =
1736: l_element_suivant_ecriture;
1737: }
1738:
1739: l_element_courant_ecriture = l_element_suivant_ecriture;
1740:
1741: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1742: (*l_element_courant_ecriture).suivant = NULL;
1743: l_element_courant_lecture =
1744: (*l_element_courant_lecture).suivant;
1745: }
1746:
1747: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1748: l_element_base);
1749: }
1750: else // type == 'P'
1751: {
1752: incrementation_atomique(s_objet);
1753: l_element_courant = (*s_objet).objet;
1754:
1755: while(l_element_courant != NULL)
1756: {
1757: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1758: (*l_element_courant).donnee, 'P');
1759: l_element_courant = (*l_element_courant).suivant;
1760: }
1761:
1762: return(s_objet);
1763: }
1764:
1765: break;
1766: }
1767:
1768: case FCH :
1769: {
1770: if (type == 'P')
1771: {
1772: incrementation_atomique(s_objet);
1773:
1774: if (((*((struct_fichier *) ((*s_objet).objet))).format =
1775: copie_objet(s_etat_processus, (*((struct_fichier *)
1776: ((*s_objet).objet))).format, 'P')) == NULL)
1777: {
1778: return(NULL);
1779: }
1780:
1781: return(s_objet);
1782: }
1783:
1784: if ((s_nouvel_objet = allocation(s_etat_processus, FCH)) == NULL)
1785: {
1786: return(NULL);
1787: }
1788:
1789: (*((struct_fichier *) ((*s_nouvel_objet).objet))).descripteur =
1790: (*((struct_fichier *) ((*s_objet).objet))).descripteur;
1791: (*((struct_fichier *) ((*s_nouvel_objet).objet))).acces =
1792: (*((struct_fichier *) ((*s_objet).objet))).acces;
1793: (*((struct_fichier *) ((*s_nouvel_objet).objet))).binaire =
1794: (*((struct_fichier *) ((*s_objet).objet))).binaire;
1795: (*((struct_fichier *) ((*s_nouvel_objet).objet))).ouverture =
1796: (*((struct_fichier *) ((*s_objet).objet))).ouverture;
1797: (*((struct_fichier *) ((*s_nouvel_objet).objet))).protection =
1798: (*((struct_fichier *) ((*s_objet).objet))).protection;
1799: (*((struct_fichier *) ((*s_nouvel_objet).objet)))
1800: .position_clef = (*((struct_fichier *)
1801: ((*s_objet).objet))).position_clef;
1802: (*((struct_fichier *) ((*s_nouvel_objet).objet))).pid =
1803: (*((struct_fichier *) ((*s_objet).objet))).pid;
1804: (*((struct_fichier *) ((*s_nouvel_objet).objet))).tid =
1805: (*((struct_fichier *) ((*s_objet).objet))).tid;
1806:
1807: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).format =
1808: copie_objet(s_etat_processus, (*((struct_fichier *)
1809: ((*s_objet).objet))).format, type)) == NULL)
1810: {
1811: free((*s_nouvel_objet).objet);
1812: free(s_nouvel_objet);
1813: return(NULL);
1814: }
1815:
1816: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom =
1817: (unsigned char *) malloc((strlen((*((struct_fichier *)
1818: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
1819: == NULL)
1820: {
1821: liberation(s_etat_processus, (*((struct_fichier *)
1822: (*s_nouvel_objet).objet)).format);
1823: free((*s_nouvel_objet).objet);
1824: free(s_nouvel_objet);
1825: return(NULL);
1826: }
1827:
1828: strcpy((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom,
1829: (*((struct_fichier *) ((*s_objet).objet))).nom);
1830: break;
1831: }
1832:
1833: case FCT :
1834: {
1835: if (type != 'O')
1836: {
1837: /*
1838: * Remise à zéro de la prédiction pour respecter la cohérence
1839: * du saut dans les cas EXSUB et OBSUB.
1840: */
1841:
1842: (*((struct_fonction *) ((*s_objet).objet)))
1843: .prediction_saut = NULL;
1844: incrementation_atomique(s_objet);
1845: return(s_objet);
1846: }
1847:
1848: if ((s_nouvel_objet = allocation(s_etat_processus, FCT)) == NULL)
1849: {
1850: return(NULL);
1851: }
1852:
1853: if (((*((struct_fonction *) ((*s_nouvel_objet).objet)))
1854: .nom_fonction = (unsigned char *)
1855: malloc((strlen((*((struct_fonction *)
1856: ((*s_objet).objet))).nom_fonction) + 1) *
1857: sizeof(unsigned char))) == NULL)
1858: {
1859: free(s_nouvel_objet);
1860: return(NULL);
1861: }
1862:
1863: strcpy((unsigned char *) (*((struct_fonction *)
1864: ((*s_nouvel_objet).objet))).nom_fonction,
1865: (unsigned char *) (*((struct_fonction *)
1866: ((*s_objet).objet))).nom_fonction);
1867: (*((struct_fonction *) ((*s_nouvel_objet).objet)))
1868: .nombre_arguments = (*((struct_fonction *)
1869: ((*s_objet).objet))).nombre_arguments;
1870: (*((struct_fonction *) ((*s_nouvel_objet).objet))).fonction =
1871: (*((struct_fonction *) ((*s_objet).objet))).fonction;
1872: break;
1873: }
1874:
1875: case INT :
1876: {
1877: if (type != 'O')
1878: {
1879: incrementation_atomique(s_objet);
1880: return(s_objet);
1881: }
1882:
1883: if ((s_nouvel_objet = allocation(s_etat_processus, INT)) == NULL)
1884: {
1885: return(NULL);
1886: }
1887:
1888: (*((integer8 *) ((*s_nouvel_objet).objet))) =
1889: (*((integer8 *) ((*s_objet).objet)));
1890: break;
1891: }
1892:
1893: case LST :
1894: {
1895: if (type != 'P')
1896: {
1897: if ((s_nouvel_objet = allocation(s_etat_processus, LST))
1898: == NULL)
1899: {
1900: return(NULL);
1901: }
1902:
1903: l_element_courant_lecture = (struct_liste_chainee *)
1904: ((*s_objet).objet);
1905:
1906: l_element_base = NULL;
1907: l_element_courant_ecriture = l_element_base;
1908:
1909: while(l_element_courant_lecture != NULL)
1910: {
1911: s_objet_tampon = copie_objet(s_etat_processus,
1912: (*l_element_courant_lecture).donnee, type);
1913: l_element_suivant_ecriture = (struct_liste_chainee *)
1914: malloc(sizeof(struct_liste_chainee));
1915:
1916: if ((s_objet_tampon == NULL) ||
1917: (l_element_suivant_ecriture == NULL))
1918: {
1919: l_element_courant_lecture = (struct_liste_chainee *)
1920: ((*s_nouvel_objet).objet);
1921:
1922: while(l_element_courant_lecture != NULL)
1923: {
1924: l_element_suivant_lecture =
1925: (*l_element_courant_lecture).suivant;
1926: liberation(s_etat_processus,
1927: (*l_element_courant_lecture).donnee);
1928: free(l_element_courant_lecture);
1929: l_element_courant_lecture =
1930: l_element_suivant_lecture;
1931: }
1932:
1933: return(NULL);
1934: }
1935:
1936: if (l_element_courant_ecriture == NULL)
1937: {
1938: l_element_base = l_element_suivant_ecriture;
1939: }
1940: else
1941: {
1942: (*l_element_courant_ecriture).suivant =
1943: l_element_suivant_ecriture;
1944: }
1945:
1946: l_element_courant_ecriture = l_element_suivant_ecriture;
1947:
1948: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1949: (*l_element_courant_ecriture).suivant = NULL;
1950: l_element_courant_lecture =
1951: (*l_element_courant_lecture).suivant;
1952: }
1953:
1954: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1955: l_element_base);
1956: }
1957: else
1958: {
1959: incrementation_atomique(s_objet);
1960: l_element_courant = (*s_objet).objet;
1961:
1962: while(l_element_courant != NULL)
1963: {
1964: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1965: (*l_element_courant).donnee, 'P');
1966: l_element_courant = (*l_element_courant).suivant;
1967: }
1968:
1969: return(s_objet);
1970: }
1971:
1972: break;
1973: }
1974:
1975: case MIN :
1976: {
1977: if (type != 'O')
1978: {
1979: incrementation_atomique(s_objet);
1980: return(s_objet);
1981: }
1982:
1983: if ((s_nouvel_objet = allocation(s_etat_processus, MIN)) == NULL)
1984: {
1985: return(NULL);
1986: }
1987:
1988: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
1989: (void **) ((integer8 **) malloc(
1990: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
1991: * sizeof(integer8 *)));
1992:
1993: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
1994: == NULL)
1995: {
1996: free((*s_nouvel_objet).objet);
1997: free(s_nouvel_objet);
1998: return(NULL);
1999: }
2000:
2001: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2002: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2003: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2004: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2005: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2006: (*((struct_matrice *) ((*s_objet).objet))).type;
2007:
2008: for(i = 0; i < (*((struct_matrice *)
2009: ((*s_objet).objet))).nombre_lignes; i++)
2010: {
2011: if ((((integer8 **) ((*((struct_matrice *)
2012: ((*s_nouvel_objet).objet))).tableau))[i] =
2013: (void *) ((integer8 *) malloc(
2014: ((*((struct_matrice *) ((*s_objet).objet)))
2015: .nombre_colonnes) * sizeof(integer8)))) == NULL)
2016: {
2017: for(j = 0; j < i; j++)
2018: {
2019: free(((integer8 **) ((*((struct_matrice *)
2020: ((*s_nouvel_objet).objet))).tableau))[j]);
2021: }
2022:
2023: free((*s_nouvel_objet).objet);
2024: free(s_nouvel_objet);
2025: return(NULL);
2026: }
2027:
2028: for(j = 0; j < (*((struct_matrice *)
2029: ((*s_objet).objet))).nombre_colonnes; j++)
2030: {
2031: ((integer8 **) ((*((struct_matrice *)
2032: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2033: ((integer8 **) ((*((struct_matrice *)
2034: ((*s_objet).objet))).tableau))[i][j];
2035: }
2036: }
2037:
2038: break;
2039: }
2040:
2041: case MCX :
2042: {
2043: if (type != 'O')
2044: {
2045: incrementation_atomique(s_objet);
2046: return(s_objet);
2047: }
2048:
2049: if ((s_nouvel_objet = allocation(s_etat_processus, MCX))
2050: == NULL)
2051: {
2052: return(NULL);
2053: }
2054:
2055: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2056: (void **) ((struct_complexe16 **) malloc(
2057: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2058: * sizeof(struct_complexe16 *)));
2059:
2060: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2061: == NULL)
2062: {
2063: free((*s_nouvel_objet).objet);
2064: free(s_nouvel_objet);
2065: return(NULL);
2066: }
2067:
2068: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2069: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2070: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2071: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2072: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2073: (*((struct_matrice *) ((*s_objet).objet))).type;
2074:
2075: for(i = 0; i < (*((struct_matrice *)
2076: ((*s_objet).objet))).nombre_lignes; i++)
2077: {
2078: if ((((struct_complexe16 **) ((*((struct_matrice *)
2079: ((*s_nouvel_objet).objet))).tableau))[i] =
2080: (void *) ((struct_complexe16 *) malloc(
2081: ((*((struct_matrice *) ((*s_objet).objet)))
2082: .nombre_colonnes) * sizeof(struct_complexe16))))
2083: == NULL)
2084: {
2085: for(j = 0; j < i; j++)
2086: {
2087: free(((struct_complexe16 **) ((*((struct_matrice *)
2088: ((*s_nouvel_objet).objet))).tableau))[j]);
2089: }
2090:
2091: free((*s_nouvel_objet).objet);
2092: free(s_nouvel_objet);
2093: return(NULL);
2094: }
2095:
2096: for(j = 0; j < (*((struct_matrice *)
2097: ((*s_objet).objet))).nombre_colonnes; j++)
2098: {
2099: ((struct_complexe16 **) ((*((struct_matrice *)
2100: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2101: ((struct_complexe16 **) ((*((struct_matrice *)
2102: ((*s_objet).objet))).tableau))[i][j];
2103: }
2104: }
2105:
2106: break;
2107: }
2108:
2109: case MRL :
2110: {
2111: if (type != 'O')
2112: {
2113: incrementation_atomique(s_objet);
2114: return(s_objet);
2115: }
2116:
2117: if ((s_nouvel_objet = allocation(s_etat_processus, MRL)) == NULL)
2118: {
2119: return(NULL);
2120: }
2121:
2122: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2123: (void **) ((real8 **) malloc(
2124: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2125: * sizeof(real8 *)));
2126:
2127: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2128: == NULL)
2129: {
2130: free((*s_nouvel_objet).objet);
2131: free(s_nouvel_objet);
2132: return(NULL);
2133: }
2134:
2135: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2136: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2137: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2138: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2139: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2140: (*((struct_matrice *) ((*s_objet).objet))).type;
2141:
2142: for(i = 0; i < (*((struct_matrice *)
2143: ((*s_objet).objet))).nombre_lignes; i++)
2144: {
2145: if ((((real8 **) ((*((struct_matrice *)
2146: ((*s_nouvel_objet).objet))).tableau))[i] =
2147: (void *) ((real8 *) malloc(
2148: ((*((struct_matrice *) ((*s_objet).objet)))
2149: .nombre_colonnes) * sizeof(real8)))) == NULL)
2150: {
2151: for(j = 0; j < i; j++)
2152: {
2153: free(((real8 **) ((*((struct_matrice *)
2154: ((*s_nouvel_objet).objet))).tableau))[j]);
2155: }
2156:
2157: free((*s_nouvel_objet).objet);
2158: free(s_nouvel_objet);
2159: return(NULL);
2160: }
2161:
2162: for(j = 0; j < (*((struct_matrice *)
2163: ((*s_objet).objet))).nombre_colonnes; j++)
2164: {
2165: ((real8 **) ((*((struct_matrice *)
2166: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2167: ((real8 **) ((*((struct_matrice *)
2168: ((*s_objet).objet))).tableau))[i][j];
2169: }
2170: }
2171:
2172: break;
2173: }
2174:
2175: case MTX :
2176: {
2177: if (type != 'O')
2178: {
2179: incrementation_atomique(s_objet);
2180: return(s_objet);
2181: }
2182:
2183: if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
2184: {
2185: return(NULL);
2186: }
2187:
2188: (*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex =
2189: (*((struct_mutex *) ((*s_objet).objet))).mutex;
2190: break;
2191: }
2192:
2193: case NOM :
2194: {
2195: if (type != 'O')
2196: {
2197: incrementation_atomique(s_objet);
2198: return(s_objet);
2199: }
2200:
2201: if ((s_nouvel_objet = allocation(s_etat_processus, NOM)) == NULL)
2202: {
2203: return(NULL);
2204: }
2205:
2206: (*((struct_nom *) (*s_nouvel_objet).objet)).nom = malloc((
2207: strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) *
2208: sizeof(unsigned char));
2209:
2210: if ((*((struct_nom *) (*s_nouvel_objet).objet)).nom == NULL)
2211: {
2212: free((*s_nouvel_objet).objet);
2213: free(s_nouvel_objet);
2214: return(NULL);
2215: }
2216:
2217: strcpy((*((struct_nom *) (*s_nouvel_objet).objet)).nom,
2218: (*((struct_nom *) (*s_objet).objet)).nom);
2219: (*((struct_nom *) (*s_nouvel_objet).objet)).symbole =
2220: (*((struct_nom *) (*s_objet).objet)).symbole;
2221: break;
2222: }
2223:
2224: case NON :
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, NON)) == NULL)
2233: {
2234: return(NULL);
2235: }
2236:
2237: (*s_nouvel_objet).objet = NULL;
2238: break;
2239: }
2240:
2241: case PRC :
2242: {
2243: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2244: (*s_objet).objet)).thread).mutex)) != 0)
2245: {
2246: return(NULL);
2247: }
2248:
2249: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
2250: .nombre_references++;
2251: printf("<2> +1 %d\n", (*(*((struct_processus_fils *) (*s_objet).objet)).thread).nombre_references);
2252:
2253: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2254: (*s_objet).objet)).thread).mutex)) != 0)
2255: {
2256: return(NULL);
2257: }
2258:
2259: if (type != 'O')
2260: {
2261: incrementation_atomique(s_objet);
2262: return(s_objet);
2263: }
2264:
2265: if ((s_nouvel_objet = allocation(s_etat_processus, PRC)) == NULL)
2266: {
2267: return(NULL);
2268: }
2269:
2270: (*((struct_processus_fils *) (*s_nouvel_objet).objet)) =
2271: (*((struct_processus_fils *) (*s_objet).objet));
2272: break;
2273: }
2274:
2275: case REL :
2276: {
2277: if (type != 'O')
2278: {
2279: incrementation_atomique(s_objet);
2280: return(s_objet);
2281: }
2282:
2283: if ((s_nouvel_objet = allocation(s_etat_processus, REL)) == NULL)
2284: {
2285: return(NULL);
2286: }
2287:
2288: (*((real8 *) ((*s_nouvel_objet).objet))) =
2289: (*((real8 *) ((*s_objet).objet)));
2290: break;
2291: }
2292:
2293: case SCK :
2294: {
2295: if (type == 'P')
2296: {
2297: incrementation_atomique(s_objet);
2298:
2299: if (((*((struct_socket *) ((*s_objet).objet)))
2300: .format = copie_objet(s_etat_processus,
2301: (*((struct_socket *) ((*s_objet).objet))).format, 'P'))
2302: == NULL)
2303: {
2304: return(NULL);
2305: }
2306:
2307: return(s_objet);
2308: }
2309:
2310: if ((s_nouvel_objet = allocation(s_etat_processus, SCK)) == NULL)
2311: {
2312: return(NULL);
2313: }
2314:
2315: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket =
2316: (*((struct_socket *) ((*s_objet).objet))).socket;
2317: (*((struct_socket *) ((*s_nouvel_objet).objet))).domaine =
2318: (*((struct_socket *) ((*s_objet).objet))).domaine;
2319: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_en_ecoute =
2320: (*((struct_socket *) ((*s_objet).objet))).socket_en_ecoute;
2321: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_connectee =
2322: (*((struct_socket *) ((*s_objet).objet))).socket_connectee;
2323: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2324: (*((struct_socket *) ((*s_objet).objet))).pid;
2325: (*((struct_socket *) ((*s_nouvel_objet).objet))).binaire =
2326: (*((struct_socket *) ((*s_objet).objet))).binaire;
2327: (*((struct_socket *) ((*s_nouvel_objet).objet))).effacement =
2328: (*((struct_socket *) ((*s_objet).objet))).effacement;
2329: (*((struct_socket *) ((*s_nouvel_objet).objet))).protection =
2330: (*((struct_socket *) ((*s_objet).objet))).protection;
2331: (*((struct_socket *) ((*s_nouvel_objet).objet))).localisation =
2332: (*((struct_socket *) ((*s_objet).objet))).localisation;
2333: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2334: (*((struct_socket *) ((*s_objet).objet))).pid;
2335: (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
2336: (*((struct_socket *) ((*s_objet).objet))).tid;
2337:
2338: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
2339: copie_objet(s_etat_processus, (*((struct_socket *)
2340: ((*s_objet).objet))).format, type)) == NULL)
2341: {
2342: free((*s_nouvel_objet).objet);
2343: free(s_nouvel_objet);
2344: return(NULL);
2345: }
2346:
2347: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).adresse =
2348: (unsigned char *) malloc((strlen((*((struct_socket *)
2349: ((*s_objet).objet))).adresse) + 1) * sizeof(unsigned char)))
2350: == NULL)
2351: {
2352: liberation(s_etat_processus, (*((struct_fichier *)
2353: (*s_nouvel_objet).objet)).format);
2354: free((*s_nouvel_objet).objet);
2355: free(s_nouvel_objet);
2356: return(NULL);
2357: }
2358:
2359: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2360: .adresse, (*((struct_socket *) ((*s_objet).objet)))
2361: .adresse);
2362:
2363: if (((*((struct_socket *) ((*s_nouvel_objet).objet)))
2364: .adresse_distante = malloc((strlen((*((struct_socket *)
2365: ((*s_objet).objet))).adresse_distante) + 1) *
2366: sizeof(unsigned char))) == NULL)
2367: {
2368: liberation(s_etat_processus, (*((struct_fichier *)
2369: (*s_nouvel_objet).objet)).format);
2370: free((*s_nouvel_objet).objet);
2371: free(s_nouvel_objet);
2372: return(NULL);
2373: }
2374:
2375: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2376: .adresse_distante, (*((struct_socket *) ((*s_objet).objet)))
2377: .adresse_distante);
2378:
2379: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))).type,
2380: (*((struct_socket *) ((*s_objet).objet))).type);
2381: break;
2382: }
2383:
2384: case SLB :
2385: {
2386: if (type != 'O')
2387: {
2388: incrementation_atomique(s_objet);
2389: return(s_objet);
2390: }
2391:
2392: if ((s_nouvel_objet = allocation(s_etat_processus, SLB)) == NULL)
2393: {
2394: return(NULL);
2395: }
2396:
2397: if (((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom =
2398: (unsigned char *) malloc((strlen((*((struct_bibliotheque *)
2399: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
2400: == NULL)
2401: {
2402: free((*s_nouvel_objet).objet);
2403: free(s_nouvel_objet);
2404: return(NULL);
2405: }
2406:
2407: strcpy((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom,
2408: (*((struct_bibliotheque *) ((*s_objet).objet))).nom);
2409:
2410: /*
2411: * C'est objet est non modifiable et est un pointeur
2412: * sur un objet système. Seul la référence est copiée.
2413: */
2414:
2415: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).descripteur =
2416: (*((struct_bibliotheque *) (*s_objet).objet)).descripteur;
2417: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).pid =
2418: (*((struct_bibliotheque *) (*s_objet).objet)).pid;
2419: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).tid =
2420: (*((struct_bibliotheque *) (*s_objet).objet)).tid;
2421: break;
2422: }
2423:
2424: case SPH :
2425: {
2426: if (type != 'O')
2427: {
2428: incrementation_atomique(s_objet);
2429: return(s_objet);
2430: }
2431:
2432: if ((s_nouvel_objet = allocation(s_etat_processus, SPH)) == NULL)
2433: {
2434: return(NULL);
2435: }
2436:
2437: if (((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom =
2438: malloc((strlen((*((struct_semaphore *) (*s_objet).objet))
2439: .nom) + 1) * sizeof(unsigned char))) == NULL)
2440: {
2441: free((*s_nouvel_objet).objet);
2442: free(s_nouvel_objet);
2443: return(NULL);
2444: }
2445:
2446: strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom,
2447: (*((struct_semaphore *) (*s_objet).objet)).nom);
2448: break;
2449: }
2450:
2451: case SQL :
2452: {
2453: if (type != 'O')
2454: {
2455: incrementation_atomique(s_objet);
2456: return(s_objet);
2457: }
2458:
2459: if ((s_nouvel_objet = allocation(s_etat_processus, SQL)) == NULL)
2460: {
2461: return(NULL);
2462: }
2463:
2464: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).pid =
2465: (*((struct_connecteur_sql *) (*s_objet).objet)).pid;
2466: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).tid =
2467: (*((struct_connecteur_sql *) (*s_objet).objet)).tid;
2468: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).descripteur =
2469: (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur;
2470:
2471: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type =
2472: malloc((strlen((*((struct_connecteur_sql *)
2473: (*s_objet).objet)).type) + 1) * sizeof(unsigned char)))
2474: == NULL)
2475: {
2476: free(s_nouvel_objet);
2477: return(NULL);
2478: }
2479:
2480: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type,
2481: (*((struct_connecteur_sql *) (*s_objet).objet)).type);
2482:
2483: if ((*((struct_connecteur_sql *) (*s_objet).objet)).locale != NULL)
2484: {
2485: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2486: .locale = malloc((strlen((*((struct_connecteur_sql *)
2487: (*s_objet).objet)).locale) + 1) *
2488: sizeof(unsigned char))) == NULL)
2489: {
2490: free((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2491: .locale);
2492: free(s_nouvel_objet);
2493: return(NULL);
2494: }
2495:
2496: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2497: .locale, (*((struct_connecteur_sql *)
2498: (*s_objet).objet)).locale);
2499: }
2500: else
2501: {
2502: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).locale
2503: = NULL;
2504: }
2505:
2506: break;
2507: }
2508:
2509: case TBL :
2510: {
2511: if (type != 'P')
2512: {
2513: if ((s_nouvel_objet = allocation(s_etat_processus, TBL))
2514: == NULL)
2515: {
2516: return(NULL);
2517: }
2518:
2519: (*((struct_tableau *) (*s_nouvel_objet).objet))
2520: .nombre_elements = (*((struct_tableau *)
2521: (*s_objet).objet)).nombre_elements;
2522:
2523: if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
2524: malloc((*((struct_tableau *) (*s_objet).objet))
2525: .nombre_elements * sizeof(struct_objet *))) == NULL)
2526: {
2527: return(NULL);
2528: }
2529:
2530: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2531: .nombre_elements; i++)
2532: {
2533: if (((*((struct_tableau *) (*s_nouvel_objet).objet))
2534: .elements[i] = copie_objet(s_etat_processus,
2535: (*((struct_tableau *) (*s_objet).objet))
2536: .elements[i], type)) == NULL)
2537: {
2538: for(j = 0; j < i; j++)
2539: {
2540: liberation(s_etat_processus, (*((struct_tableau *)
2541: (*s_nouvel_objet).objet)).elements[j]);
2542: }
2543:
2544: free((*((struct_tableau *) (*s_nouvel_objet).objet))
2545: .elements);
2546: free((*s_nouvel_objet).objet);
2547: free(s_nouvel_objet);
2548:
2549: return(NULL);
2550: }
2551: }
2552: }
2553: else
2554: {
2555: incrementation_atomique(s_objet);
2556:
2557: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2558: .nombre_elements; i++)
2559: {
2560: (*((struct_tableau *) (*s_objet).objet)).elements[i] =
2561: copie_objet(s_etat_processus, (*((struct_tableau *)
2562: (*s_objet).objet)).elements[i], 'P');
2563: }
2564:
2565: return(s_objet);
2566: }
2567:
2568: break;
2569: }
2570:
2571: case VIN :
2572: {
2573: if (type != 'O')
2574: {
2575: incrementation_atomique(s_objet);
2576: return(s_objet);
2577: }
2578:
2579: if ((s_nouvel_objet = allocation(s_etat_processus, VIN)) == NULL)
2580: {
2581: return(NULL);
2582: }
2583:
2584: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2585: (void *) ((integer8 *) malloc(
2586: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2587: * sizeof(integer8)));
2588:
2589: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2590: == NULL)
2591: {
2592: free((*s_nouvel_objet).objet);
2593: free(s_nouvel_objet);
2594: return(NULL);
2595: }
2596:
2597: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2598: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2599: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2600: (*((struct_vecteur *) ((*s_objet).objet))).type;
2601:
2602: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2603: i++)
2604: {
2605: ((integer8 *) ((*((struct_vecteur *)
2606: ((*s_nouvel_objet).objet))).tableau))[i] =
2607: ((integer8 *) ((*((struct_vecteur *)
2608: ((*s_objet).objet))).tableau))[i];
2609: }
2610:
2611: break;
2612: }
2613:
2614: case VCX :
2615: {
2616: if (type != 'O')
2617: {
2618: incrementation_atomique(s_objet);
2619: return(s_objet);
2620: }
2621:
2622: if ((s_nouvel_objet = allocation(s_etat_processus, VCX)) == NULL)
2623: {
2624: return(NULL);
2625: }
2626:
2627: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2628: (void *) ((struct_complexe16 *) malloc(
2629: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2630: * sizeof(struct_complexe16)));
2631:
2632: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2633: == NULL)
2634: {
2635: free((*s_nouvel_objet).objet);
2636: free(s_nouvel_objet);
2637: return(NULL);
2638: }
2639:
2640: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2641: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2642: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2643: (*((struct_vecteur *) ((*s_objet).objet))).type;
2644:
2645: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2646: i++)
2647: {
2648: ((struct_complexe16 *) ((*((struct_vecteur *)
2649: ((*s_nouvel_objet).objet))).tableau))[i] =
2650: ((struct_complexe16 *) ((*((struct_vecteur *)
2651: ((*s_objet).objet))).tableau))[i];
2652: }
2653:
2654: break;
2655: }
2656:
2657: case VRL :
2658: {
2659: if (type != 'O')
2660: {
2661: incrementation_atomique(s_objet);
2662: return(s_objet);
2663: }
2664:
2665: if ((s_nouvel_objet = allocation(s_etat_processus, VRL)) == NULL)
2666: {
2667: return(NULL);
2668: }
2669:
2670: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2671: (void *) ((real8 *) malloc(
2672: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2673: * sizeof(real8)));
2674:
2675: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2676: == NULL)
2677: {
2678: free((*s_nouvel_objet).objet);
2679: free(s_nouvel_objet);
2680: return(NULL);
2681: }
2682:
2683: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2684: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2685: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2686: (*((struct_vecteur *) ((*s_objet).objet))).type;
2687:
2688: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2689: i++)
2690: {
2691: ((real8 *) ((*((struct_vecteur *)
2692: ((*s_nouvel_objet).objet))).tableau))[i] =
2693: ((real8 *) ((*((struct_vecteur *)
2694: ((*s_objet).objet))).tableau))[i];
2695: }
2696:
2697: break;
2698: }
2699:
2700: default :
2701: {
2702: return(NULL);
2703: }
2704: }
2705:
2706: return(s_nouvel_objet);
2707:
2708: #undef return
2709: }
2710:
2711:
2712: /*
2713: ================================================================================
2714: Routine de copie d'une structure de description d'un processus
2715: ================================================================================
2716: Entrées : pointeur sur la structure de description d'un processus
2717: --------------------------------------------------------------------------------
2718: Sorties : structure identique (tous les objets sont copiés)
2719: --------------------------------------------------------------------------------
2720: Effets de bord : néant
2721: ================================================================================
2722: */
2723:
2724: struct_processus *
2725: copie_etat_processus(struct_processus *s_etat_processus)
2726: {
2727: pthread_mutexattr_t attributs_mutex;
2728:
2729: struct_liste_chainee *l_element_lecture;
2730: struct_liste_chainee *l_element_precedent;
2731: struct_liste_chainee *l_element_suivant;
2732:
2733: struct_processus *s_nouvel_etat_processus;
2734:
2735: unsigned long i;
2736:
2737: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2738: {
2739: (*s_etat_processus).erreur_systeme = d_es_processus;
2740: return(NULL);
2741: }
2742:
2743: if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)
2744: {
2745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2746: return(NULL);
2747: }
2748:
2749: (*s_nouvel_etat_processus) = (*s_etat_processus);
2750:
2751: // On réinitialise l'allocateur.
2752:
2753: initialisation_allocateur(s_nouvel_etat_processus);
2754:
2755: /*
2756: * (*s_etat_processus).definition_chainee,
2757: * (*s_etat_processus).nom_fichier_source,
2758: * (*s_etat_processus).nom_fichier_historique et
2759: * (*s_etat_processus).chemin_fichier_temporaires
2760: * n'ont aucune raison de changer.
2761: */
2762:
2763: # ifndef SEMAPHORES_NOMMES
2764: sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
2765: # else
2766: if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork))
2767: == SEM_FAILED)
2768: {
2769: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2770: return(NULL);
2771: }
2772: # endif
2773:
2774: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
2775: (*s_nouvel_etat_processus).fichiers_graphiques = NULL;
2776: (*s_nouvel_etat_processus).entree_standard = NULL;
2777: (*s_nouvel_etat_processus).s_marques = NULL;
2778: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai;
2779: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux;
2780: (*s_nouvel_etat_processus).nom_fichier_impression = NULL;
2781: (*s_nouvel_etat_processus).expression_courante = NULL;
2782: (*s_nouvel_etat_processus).objet_courant = NULL;
2783: (*s_nouvel_etat_processus).processus_detache = d_faux;
2784: (*s_nouvel_etat_processus).evaluation_forcee = 'N';
2785:
2786: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
2787: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
2788: (*s_nouvel_etat_processus).presence_fusible = d_faux;
2789: (*s_nouvel_etat_processus).thread_fusible = 0;
2790: (*s_nouvel_etat_processus).niveau_initial =
2791: (*s_etat_processus).niveau_courant;
2792: (*s_nouvel_etat_processus).presence_pipes = d_faux;
2793: (*s_nouvel_etat_processus).debug_programme = d_faux;
2794: (*s_nouvel_etat_processus).s_fichiers = NULL;
2795: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL;
2796:
2797: // On réinitialise toutes les interruptions.
2798:
2799: (*s_nouvel_etat_processus).traitement_interruption = 'N';
2800: (*s_nouvel_etat_processus).traitement_interruptible = 'Y';
2801: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
2802: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
2803:
2804: (*s_nouvel_etat_processus).at_exit = NULL;
2805:
2806: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2807: {
2808: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
2809: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N';
2810: (*s_nouvel_etat_processus).queue_interruptions[i] = 0;
2811: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL;
2812: }
2813:
2814: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
2815: {
2816: (*s_nouvel_etat_processus).generateur_aleatoire = NULL;
2817: }
2818:
2819: (*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;
2820:
2821: // Copie de la localisation
2822:
2823: if (((*s_nouvel_etat_processus).localisation = malloc((strlen(
2824: (*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))
2825: == NULL)
2826: {
2827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2828: return(NULL);
2829: }
2830:
2831: strcpy((*s_nouvel_etat_processus).localisation,
2832: (*s_etat_processus).localisation);
2833:
2834: if ((*s_etat_processus).indep != NULL)
2835: {
2836: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
2837: (*s_etat_processus).indep, 'P')) == NULL)
2838: {
2839: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2840: {
2841: (*s_etat_processus).erreur_systeme = d_es_processus;
2842: return(NULL);
2843: }
2844:
2845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2846: return(NULL);
2847: }
2848: }
2849: else
2850: {
2851: (*s_nouvel_etat_processus).indep = NULL;
2852: }
2853:
2854: if ((*s_etat_processus).depend != NULL)
2855: {
2856: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
2857: (*s_etat_processus).depend, 'P')) == NULL)
2858: {
2859: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2860: {
2861: (*s_etat_processus).erreur_systeme = d_es_processus;
2862: return(NULL);
2863: }
2864:
2865: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2866: return(NULL);
2867: }
2868: }
2869: else
2870: {
2871: (*s_nouvel_etat_processus).depend = NULL;
2872: }
2873:
2874: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL)
2875: {
2876: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau =
2877: copie_objet(s_etat_processus, (*s_etat_processus)
2878: .parametres_courbes_de_niveau, 'P')) == NULL)
2879: {
2880: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2881: {
2882: (*s_etat_processus).erreur_systeme = d_es_processus;
2883: return(NULL);
2884: }
2885:
2886: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2887: return(NULL);
2888: }
2889: }
2890: else
2891: {
2892: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL;
2893: }
2894:
2895: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL;
2896:
2897: if (((*s_etat_processus).instruction_courante != NULL) &&
2898: (*s_etat_processus).evaluation_expression_compilee == 'N')
2899: {
2900: if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(
2901: (*s_etat_processus).instruction_courante) + 1) *
2902: sizeof(unsigned char))) == NULL)
2903: {
2904: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2905: {
2906: (*s_etat_processus).erreur_systeme = d_es_processus;
2907: return(NULL);
2908: }
2909:
2910: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2911: return(NULL);
2912: }
2913:
2914: strcpy((*s_nouvel_etat_processus).instruction_courante,
2915: (*s_etat_processus).instruction_courante);
2916: }
2917: else
2918: {
2919: (*s_nouvel_etat_processus).instruction_courante = NULL;
2920: }
2921:
2922: if ((*s_etat_processus).label_x != NULL)
2923: {
2924: if (((*s_nouvel_etat_processus).label_x = malloc((strlen(
2925: (*s_etat_processus).label_x) + 1) *
2926: sizeof(unsigned char))) == NULL)
2927: {
2928: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2929: {
2930: (*s_etat_processus).erreur_systeme = d_es_processus;
2931: return(NULL);
2932: }
2933:
2934: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2935: return(NULL);
2936: }
2937:
2938: strcpy((*s_nouvel_etat_processus).label_x,
2939: (*s_etat_processus).label_x);
2940: }
2941: else
2942: {
2943: (*s_nouvel_etat_processus).label_x = NULL;
2944: }
2945:
2946: if ((*s_etat_processus).label_y != NULL)
2947: {
2948: if (((*s_nouvel_etat_processus).label_y = malloc((strlen(
2949: (*s_etat_processus).label_y) + 1) *
2950: sizeof(unsigned char))) == NULL)
2951: {
2952: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2953: {
2954: (*s_etat_processus).erreur_systeme = d_es_processus;
2955: return(NULL);
2956: }
2957:
2958: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2959: return(NULL);
2960: }
2961:
2962: strcpy((*s_nouvel_etat_processus).label_y,
2963: (*s_etat_processus).label_y);
2964: }
2965: else
2966: {
2967: (*s_nouvel_etat_processus).label_y = NULL;
2968: }
2969:
2970: if ((*s_etat_processus).label_z != NULL)
2971: {
2972: if (((*s_nouvel_etat_processus).label_z = malloc((strlen(
2973: (*s_etat_processus).label_z) + 1) *
2974: sizeof(unsigned char))) == NULL)
2975: {
2976: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2977: {
2978: (*s_etat_processus).erreur_systeme = d_es_processus;
2979: return(NULL);
2980: }
2981:
2982: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2983: return(NULL);
2984: }
2985:
2986: strcpy((*s_nouvel_etat_processus).label_z,
2987: (*s_etat_processus).label_z);
2988: }
2989: else
2990: {
2991: (*s_nouvel_etat_processus).label_z = NULL;
2992: }
2993:
2994: if ((*s_etat_processus).titre != NULL)
2995: {
2996: if (((*s_nouvel_etat_processus).titre = malloc((strlen(
2997: (*s_etat_processus).titre) + 1) *
2998: sizeof(unsigned char))) == NULL)
2999: {
3000: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3001: {
3002: (*s_etat_processus).erreur_systeme = d_es_processus;
3003: return(NULL);
3004: }
3005:
3006: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3007: return(NULL);
3008: }
3009:
3010: strcpy((*s_nouvel_etat_processus).titre,
3011: (*s_etat_processus).titre);
3012: }
3013: else
3014: {
3015: (*s_nouvel_etat_processus).titre = NULL;
3016: }
3017:
3018: if ((*s_etat_processus).legende != NULL)
3019: {
3020: if (((*s_nouvel_etat_processus).legende = malloc((strlen(
3021: (*s_etat_processus).legende) + 1) *
3022: sizeof(unsigned char))) == NULL)
3023: {
3024: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3025: {
3026: (*s_etat_processus).erreur_systeme = d_es_processus;
3027: return(NULL);
3028: }
3029:
3030: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3031: return(NULL);
3032: }
3033:
3034: strcpy((*s_nouvel_etat_processus).legende,
3035: (*s_etat_processus).legende);
3036: }
3037: else
3038: {
3039: (*s_nouvel_etat_processus).legende = NULL;
3040: }
3041:
3042: /*
3043: * Copie de la table des variables
3044: */
3045:
3046: if (((*s_nouvel_etat_processus).s_liste_variables =
3047: malloc((*s_etat_processus).nombre_variables_allouees *
3048: sizeof(struct_variable))) == NULL)
3049: {
3050: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3051: {
3052: (*s_etat_processus).erreur_systeme = d_es_processus;
3053: return(NULL);
3054: }
3055:
3056: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3057: return(NULL);
3058: }
3059:
3060: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
3061: {
3062: if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
3063: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
3064: + 1) * sizeof(unsigned char))) == NULL)
3065: {
3066: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3067: {
3068: (*s_etat_processus).erreur_systeme = d_es_processus;
3069: return(NULL);
3070: }
3071:
3072: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3073: return(NULL);
3074: }
3075:
3076: strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
3077: (*s_etat_processus).s_liste_variables[i].nom);
3078:
3079: (*s_nouvel_etat_processus).s_liste_variables[i].origine =
3080: (*s_etat_processus).s_liste_variables[i].origine;
3081: (*s_nouvel_etat_processus).s_liste_variables[i].niveau =
3082: (*s_etat_processus).s_liste_variables[i].niveau;
3083: (*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
3084: (*s_etat_processus).s_liste_variables[i].variable_statique;
3085: (*s_nouvel_etat_processus).s_liste_variables[i].variable_partagee =
3086: (*s_etat_processus).s_liste_variables[i].variable_partagee;
3087: (*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
3088: (*s_etat_processus).s_liste_variables[i].variable_verrouillee;
3089:
3090: // Les définitions sont partagées entre tous les threads.
3091:
3092: if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
3093: {
3094: (*s_nouvel_etat_processus).s_liste_variables[i].objet =
3095: (*s_etat_processus).s_liste_variables[i].objet;
3096: }
3097: else
3098: {
3099: if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
3100: copie_objet(s_etat_processus,
3101: (*s_etat_processus).s_liste_variables[i]
3102: .objet, 'P')) == NULL)
3103: {
3104: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3105: {
3106: (*s_etat_processus).erreur_systeme = d_es_processus;
3107: return(NULL);
3108: }
3109:
3110: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3111: return(NULL);
3112: }
3113: }
3114: }
3115:
3116: /*
3117: * Copie de la table des variables statiques
3118: */
3119:
3120: if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
3121: malloc((*s_etat_processus).nombre_variables_statiques_allouees *
3122: sizeof(struct_variable_statique))) == NULL)
3123: {
3124: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3125: {
3126: (*s_etat_processus).erreur_systeme = d_es_processus;
3127: return(NULL);
3128: }
3129:
3130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3131: return(NULL);
3132: }
3133:
3134: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
3135: {
3136: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =
3137: malloc((strlen((*s_etat_processus).s_liste_variables_statiques
3138: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3139: {
3140: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3141: {
3142: (*s_etat_processus).erreur_systeme = d_es_processus;
3143: return(NULL);
3144: }
3145:
3146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3147: return(NULL);
3148: }
3149:
3150: strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
3151: (*s_etat_processus).s_liste_variables_statiques[i].nom);
3152:
3153: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
3154: (*s_etat_processus).s_liste_variables_statiques[i].origine;
3155: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
3156: (*s_etat_processus).s_liste_variables_statiques[i].niveau;
3157: (*s_nouvel_etat_processus).s_liste_variables_statiques[i]
3158: .variable_statique = (*s_etat_processus)
3159: .s_liste_variables_statiques[i].variable_statique;
3160:
3161: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
3162: copie_objet(s_etat_processus, (*s_etat_processus)
3163: .s_liste_variables_statiques[i].objet, 'P')) == NULL)
3164: {
3165: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3166: {
3167: (*s_etat_processus).erreur_systeme = d_es_processus;
3168: return(NULL);
3169: }
3170:
3171: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3172: return(NULL);
3173: }
3174: }
3175:
3176: /*
3177: * Copie de la pile opérationnelle
3178: */
3179:
3180: (*s_nouvel_etat_processus).l_base_pile = NULL;
3181: l_element_lecture = (*s_etat_processus).l_base_pile;
3182: l_element_precedent = NULL;
3183:
3184: while(l_element_lecture != NULL)
3185: {
3186: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3187: {
3188: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3189: {
3190: (*s_etat_processus).erreur_systeme = d_es_processus;
3191: return(NULL);
3192: }
3193:
3194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3195: return(NULL);
3196: }
3197:
3198: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3199: (*l_element_lecture).donnee, 'P')) == NULL)
3200: {
3201: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3202: {
3203: (*s_etat_processus).erreur_systeme = d_es_processus;
3204: return(NULL);
3205: }
3206:
3207: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3208: return(NULL);
3209: }
3210:
3211: (*l_element_suivant).suivant = NULL;
3212:
3213: if ((*s_nouvel_etat_processus).l_base_pile == NULL)
3214: {
3215: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant;
3216: }
3217: else
3218: {
3219: (*l_element_precedent).suivant = l_element_suivant;
3220: }
3221:
3222: l_element_precedent = l_element_suivant;
3223: l_element_lecture = (*l_element_lecture).suivant;
3224: }
3225:
3226: /*
3227: * Copie de la pile système
3228: */
3229:
3230: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL;
3231: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0;
3232:
3233: empilement_pile_systeme(s_nouvel_etat_processus);
3234:
3235: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3236: {
3237: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3238: {
3239: (*s_etat_processus).erreur_systeme = d_es_processus;
3240: return(NULL);
3241: }
3242:
3243: (*s_etat_processus).erreur_systeme =
3244: (*s_nouvel_etat_processus).erreur_systeme;
3245: return(NULL);
3246: }
3247:
3248: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3249:
3250: /*
3251: * On empile deux valeurs retour_definition pour pouvoir récupérer
3252: * les variables dans le cas d'un programme compilé.
3253: */
3254:
3255: empilement_pile_systeme(s_nouvel_etat_processus);
3256:
3257: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3258: {
3259: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3260: {
3261: (*s_etat_processus).erreur_systeme = d_es_processus;
3262: return(NULL);
3263: }
3264:
3265: (*s_etat_processus).erreur_systeme =
3266: (*s_nouvel_etat_processus).erreur_systeme;
3267: return(NULL);
3268: }
3269:
3270: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3271:
3272: /*
3273: * Destruction de la pile last pour le thread en cours.
3274: */
3275:
3276: (*s_nouvel_etat_processus).l_base_pile_last = NULL;
3277: (*s_nouvel_etat_processus).l_base_pile_processus = NULL;
3278:
3279: /*
3280: * Copie des différents contextes
3281: */
3282:
3283: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
3284: l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
3285:
3286: while(l_element_lecture != NULL)
3287: {
3288: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3289: {
3290: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3291: {
3292: (*s_etat_processus).erreur_systeme = d_es_processus;
3293: return(NULL);
3294: }
3295:
3296: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3297: return(NULL);
3298: }
3299:
3300: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3301: (*l_element_lecture).donnee, 'P')) == NULL)
3302: {
3303: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3304: {
3305: (*s_etat_processus).erreur_systeme = d_es_processus;
3306: return(NULL);
3307: }
3308:
3309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3310: return(NULL);
3311: }
3312:
3313: (*l_element_suivant).suivant = NULL;
3314:
3315: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL)
3316: {
3317: (*s_nouvel_etat_processus).l_base_pile_contextes =
3318: l_element_suivant;
3319: }
3320: else
3321: {
3322: (*l_element_precedent).suivant = l_element_suivant;
3323: }
3324:
3325: l_element_precedent = l_element_suivant;
3326: l_element_lecture = (*l_element_lecture).suivant;
3327: }
3328:
3329: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL;
3330: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes;
3331:
3332: while(l_element_lecture != NULL)
3333: {
3334: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3335: {
3336: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3337: {
3338: (*s_etat_processus).erreur_systeme = d_es_processus;
3339: return(NULL);
3340: }
3341:
3342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3343: return(NULL);
3344: }
3345:
3346: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3347: (*l_element_lecture).donnee, 'P')) == NULL)
3348: {
3349: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3350: {
3351: (*s_etat_processus).erreur_systeme = d_es_processus;
3352: return(NULL);
3353: }
3354:
3355: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3356: return(NULL);
3357: }
3358:
3359: (*l_element_suivant).suivant = NULL;
3360:
3361: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL)
3362: {
3363: (*s_nouvel_etat_processus).l_base_pile_taille_contextes =
3364: l_element_suivant;
3365: }
3366: else
3367: {
3368: (*l_element_precedent).suivant = l_element_suivant;
3369: }
3370:
3371: l_element_precedent = l_element_suivant;
3372: l_element_lecture = (*l_element_lecture).suivant;
3373: }
3374:
3375: /*
3376: * Copies des piles s_sockets, s_bibliotheques et
3377: * s_instructions_externes.
3378: */
3379:
3380: (*s_nouvel_etat_processus).s_sockets = NULL;
3381: l_element_lecture = (*s_etat_processus).s_sockets;
3382:
3383: while(l_element_lecture != NULL)
3384: {
3385: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3386: {
3387: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3388: {
3389: (*s_etat_processus).erreur_systeme = d_es_processus;
3390: return(NULL);
3391: }
3392:
3393: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3394: return(NULL);
3395: }
3396:
3397: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3398: (*l_element_lecture).donnee, 'P')) == NULL)
3399: {
3400: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3401: {
3402: (*s_etat_processus).erreur_systeme = d_es_processus;
3403: return(NULL);
3404: }
3405:
3406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3407: return(NULL);
3408: }
3409:
3410: (*l_element_suivant).suivant = NULL;
3411:
3412: if ((*s_nouvel_etat_processus).s_sockets == NULL)
3413: {
3414: (*s_nouvel_etat_processus).s_sockets = l_element_suivant;
3415: }
3416: else
3417: {
3418: (*l_element_precedent).suivant = l_element_suivant;
3419: }
3420:
3421: l_element_precedent = l_element_suivant;
3422: l_element_lecture = (*l_element_lecture).suivant;
3423: }
3424:
3425: (*s_nouvel_etat_processus).s_bibliotheques = NULL;
3426: l_element_precedent = NULL;
3427: l_element_lecture = (*s_etat_processus).s_bibliotheques;
3428:
3429: while(l_element_lecture != NULL)
3430: {
3431: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3432: {
3433: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3434: {
3435: (*s_etat_processus).erreur_systeme = d_es_processus;
3436: return(NULL);
3437: }
3438:
3439: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3440: return(NULL);
3441: }
3442:
3443: if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))
3444: == NULL)
3445: {
3446: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3447: return(NULL);
3448: }
3449:
3450: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur
3451: = (*((struct_bibliotheque *) (*l_element_lecture).donnee))
3452: .descripteur;
3453: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid
3454: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid;
3455: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid
3456: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
3457:
3458: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
3459: malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)
3460: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
3461: {
3462: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3463: {
3464: (*s_etat_processus).erreur_systeme = d_es_processus;
3465: return(NULL);
3466: }
3467:
3468: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3469: return(NULL);
3470: }
3471:
3472: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom,
3473: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom);
3474:
3475: (*l_element_suivant).suivant = NULL;
3476:
3477: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL)
3478: {
3479: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant;
3480: }
3481: else
3482: {
3483: (*l_element_precedent).suivant = l_element_suivant;
3484: }
3485:
3486: l_element_precedent = l_element_suivant;
3487: l_element_lecture = (*l_element_lecture).suivant;
3488: }
3489:
3490: if ((*s_etat_processus).nombre_instructions_externes != 0)
3491: {
3492: if (((*s_nouvel_etat_processus).s_instructions_externes =
3493: malloc((*s_etat_processus).nombre_instructions_externes *
3494: sizeof(struct_instruction_externe))) == NULL)
3495: {
3496: (*s_etat_processus).erreur_systeme = d_es_processus;
3497: return(NULL);
3498: }
3499:
3500: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
3501: {
3502: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
3503: malloc((strlen((*s_etat_processus).s_instructions_externes
3504: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3505: {
3506: (*s_etat_processus).erreur_systeme = d_es_processus;
3507: return(NULL);
3508: }
3509:
3510: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom,
3511: (*s_etat_processus).s_instructions_externes[i].nom);
3512:
3513: if (((*s_nouvel_etat_processus).s_instructions_externes[i]
3514: .nom_bibliotheque = malloc((strlen((*s_etat_processus)
3515: .s_instructions_externes[i].nom_bibliotheque) + 1) *
3516: sizeof(unsigned char))) == NULL)
3517: {
3518: (*s_etat_processus).erreur_systeme = d_es_processus;
3519: return(NULL);
3520: }
3521:
3522: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i]
3523: .nom_bibliotheque, (*s_etat_processus)
3524: .s_instructions_externes[i].nom_bibliotheque);
3525:
3526: (*s_nouvel_etat_processus).s_instructions_externes[i]
3527: .descripteur_bibliotheque = (*s_etat_processus)
3528: .s_instructions_externes[i].descripteur_bibliotheque;
3529: }
3530: }
3531: else
3532: {
3533: (*s_nouvel_etat_processus).s_instructions_externes = NULL;
3534: }
3535:
3536: pthread_mutexattr_init(&attributs_mutex);
3537: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3538: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);
3539: pthread_mutexattr_destroy(&attributs_mutex);
3540:
3541: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3542: {
3543: (*s_etat_processus).erreur_systeme = d_es_processus;
3544: return(NULL);
3545: }
3546:
3547: return(s_nouvel_etat_processus);
3548:
3549: #undef return
3550: }
3551:
3552:
3553: /*
3554: ================================================================================
3555: Routines de debug
3556: ================================================================================
3557: entrées :
3558: --------------------------------------------------------------------------------
3559: sorties :
3560: --------------------------------------------------------------------------------
3561: effets de bord : néant
3562: ================================================================================
3563: */
3564:
3565: #ifdef DEBUG_MEMOIRE
3566:
3567: #undef malloc
3568: #undef realloc
3569: #undef free
3570: #undef fork
3571:
3572: #ifdef return
3573: # undef return
3574: #endif
3575:
3576: #ifdef __BACKTRACE
3577: #define PROFONDEUR_PILE 64
3578: #define return(a) { if (a == NULL) \
3579: { BACKTRACE(PROFONDEUR_PILE); \
3580: fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
3581: return(a); } while(0)
3582: #endif
3583:
3584: #undef fprintf
3585: #define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
3586: #undef CORE_DUMP
3587:
3588: typedef struct memoire
3589: {
3590: void *pointeur;
3591: unsigned char *fonction;
3592: unsigned char *argument;
3593: unsigned long ligne;
3594: size_t taille;
3595: unsigned long long ordre;
3596: # ifdef __BACKTRACE
3597: void *pile[PROFONDEUR_PILE];
3598: int profondeur;
3599: # endif
3600: struct memoire *suivant;
3601: } struct_memoire;
3602:
3603: static struct_memoire *debug = NULL;
3604: static unsigned long long ordre = 0;
3605: static pthread_mutex_t mutex_allocation;
3606:
3607: void
3608: debug_memoire_initialisation()
3609: {
3610: pthread_mutexattr_t attributs_mutex;
3611:
3612: pthread_mutexattr_init(&attributs_mutex);
3613: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
3614: pthread_mutex_init(&mutex_allocation, &attributs_mutex);
3615: pthread_mutexattr_destroy(&attributs_mutex);
3616:
3617: return;
3618: }
3619:
3620: void *
3621: debug_memoire_ajout(size_t taille, const unsigned char *fonction,
3622: unsigned long ligne, const unsigned char *argument)
3623: {
3624: struct_memoire *ancienne_base;
3625:
3626: void *pointeur;
3627:
3628: pthread_mutex_lock(&mutex_allocation);
3629:
3630: ancienne_base = debug;
3631:
3632: if ((debug = malloc(sizeof(struct_memoire))) == NULL)
3633: {
3634: pthread_mutex_unlock(&mutex_allocation);
3635: return(NULL);
3636: }
3637:
3638: if (((*debug).pointeur = malloc(taille)) == NULL)
3639: {
3640: pthread_mutex_unlock(&mutex_allocation);
3641: return(NULL);
3642: }
3643:
3644: (*debug).suivant = ancienne_base;
3645: (*debug).ligne = ligne;
3646: (*debug).taille = taille;
3647: (*debug).ordre = ordre;
3648:
3649: pointeur = (*debug).pointeur;
3650:
3651: # ifdef __BACKTRACE
3652: (*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE);
3653: # endif
3654:
3655: if (((*debug).fonction = malloc((strlen(fonction) + 1) *
3656: sizeof(unsigned char))) == NULL)
3657: {
3658: pthread_mutex_unlock(&mutex_allocation);
3659: return(NULL);
3660: }
3661:
3662: if (((*debug).argument = malloc((strlen(argument) + 1) *
3663: sizeof(unsigned char))) == NULL)
3664: {
3665: pthread_mutex_unlock(&mutex_allocation);
3666: return(NULL);
3667: }
3668:
3669: strcpy((*debug).fonction, fonction);
3670: strcpy((*debug).argument, argument);
3671:
3672: memset((*debug).pointeur, 0, (*debug).taille);
3673:
3674: pthread_mutex_unlock(&mutex_allocation);
3675: ordre++;
3676:
3677: return(pointeur);
3678: }
3679:
3680: void *
3681: debug_memoire_modification(void *pointeur, size_t taille,
3682: const unsigned char *fonction, unsigned long ligne,
3683: const unsigned char *argument)
3684: {
3685: struct_memoire *element_courant;
3686:
3687: if (pointeur != NULL)
3688: {
3689: if (taille == 0)
3690: {
3691: // Revient à free(). Il n'y a pas de parenthèses car on ne veut
3692: // pas utiliser la macro return().
3693:
3694: debug_memoire_retrait(pointeur);
3695: return NULL ;
3696: }
3697: else
3698: {
3699: // Réallocation réelle
3700:
3701: pthread_mutex_lock(&mutex_allocation);
3702:
3703: element_courant = debug;
3704:
3705: while(element_courant != NULL)
3706: {
3707: if ((*element_courant).pointeur == pointeur)
3708: {
3709: break;
3710: }
3711:
3712: element_courant = (*element_courant).suivant;
3713: }
3714:
3715: if (element_courant == NULL)
3716: {
3717: pthread_mutex_unlock(&mutex_allocation);
3718:
3719: uprintf("[%d-%llu] ILLEGAL POINTER\n",
3720: getpid(), (unsigned long long) pthread_self());
3721: # ifdef __BACKTRACE
3722: BACKTRACE(PROFONDEUR_PILE);
3723: # endif
3724:
3725: return(realloc(pointeur, taille));
3726: }
3727: else
3728: {
3729: if (((*element_courant).pointeur = realloc(pointeur, taille))
3730: == NULL)
3731: {
3732: pthread_mutex_unlock(&mutex_allocation);
3733: return(NULL);
3734: }
3735:
3736: (*element_courant).ligne = ligne;
3737: (*element_courant).taille = taille;
3738: free((*element_courant).fonction);
3739: free((*element_courant).argument);
3740:
3741: if (((*element_courant).fonction = malloc((strlen(fonction)
3742: + 1) * sizeof(unsigned char))) == NULL)
3743: {
3744: pthread_mutex_unlock(&mutex_allocation);
3745: return(NULL);
3746: }
3747:
3748: if (((*element_courant).argument = malloc((strlen(argument)
3749: + 1) * sizeof(unsigned char))) == NULL)
3750: {
3751: pthread_mutex_unlock(&mutex_allocation);
3752: return(NULL);
3753: }
3754:
3755: strcpy((*element_courant).fonction, fonction);
3756: strcpy((*element_courant).argument, argument);
3757:
3758: pthread_mutex_unlock(&mutex_allocation);
3759:
3760: return((*element_courant).pointeur);
3761: }
3762: }
3763: }
3764: else
3765: {
3766: // Revient à malloc()
3767: pointeur = debug_memoire_ajout(taille, fonction, ligne, argument);
3768: return(pointeur);
3769: }
3770: }
3771:
3772: void
3773: debug_memoire_retrait(void *pointeur)
3774: {
3775: struct_memoire *element_courant;
3776: struct_memoire *element_precedent;
3777:
3778: pthread_mutex_lock(&mutex_allocation);
3779:
3780: element_courant = debug;
3781: element_precedent = NULL;
3782:
3783: while(element_courant != NULL)
3784: {
3785: if ((*element_courant).pointeur == pointeur)
3786: {
3787: if (element_precedent == NULL)
3788: {
3789: debug = (*debug).suivant;
3790: }
3791: else
3792: {
3793: (*element_precedent).suivant = (*element_courant).suivant;
3794: }
3795:
3796: if (pointeur != NULL)
3797: {
3798: memset(pointeur, 0, (*element_courant).taille);
3799: }
3800:
3801: free((*element_courant).fonction);
3802: free((*element_courant).argument);
3803: free(element_courant);
3804:
3805: break;
3806: }
3807:
3808: element_precedent = element_courant;
3809: element_courant = (*element_courant).suivant;
3810: }
3811:
3812: pthread_mutex_unlock(&mutex_allocation);
3813:
3814: if (element_courant == NULL)
3815: {
3816: uprintf("[%d-%llu] ILLEGAL POINTER\n",
3817: getpid(), (unsigned long long) pthread_self());
3818: # ifdef __BACKTRACE
3819: BACKTRACE(PROFONDEUR_PILE);
3820: # endif
3821: }
3822:
3823: free(pointeur);
3824: return;
3825: }
3826:
3827: void
3828: debug_memoire_verification()
3829: {
3830: # ifdef __BACKTRACE
3831: char **appels;
3832:
3833: int j;
3834: # endif
3835:
3836: integer8 i;
3837:
3838: struct_memoire *element_courant;
3839: struct_memoire *element_suivant;
3840:
3841: fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n",
3842: getpid(), (unsigned long long) pthread_self());
3843:
3844: pthread_mutex_lock(&mutex_allocation);
3845:
3846: element_courant = debug;
3847: i = 1;
3848:
3849: while(element_courant != NULL)
3850: {
3851: fprintf(stderr, "[%d-%llu] MEDITATION %lld (%llu)\n", getpid(),
3852: (unsigned long long) pthread_self(), i,
3853: (*element_courant).ordre);
3854: fprintf(stderr, "[%d-%llu] P: %p, F: %s(), L: %lu, S: %d\n",
3855: getpid(), (unsigned long long) pthread_self(),
3856: (*element_courant).pointeur,
3857: (*element_courant).fonction, (*element_courant).ligne,
3858: (int) (*element_courant).taille);
3859: fprintf(stderr, "[%d-%llu] A: %s\n", getpid(),
3860: (unsigned long long) pthread_self(),
3861: (*element_courant).argument);
3862:
3863: if (strstr((*element_courant).argument, "sizeof(unsigned char)")
3864: != NULL)
3865: {
3866: fprintf(stderr, "[%d-%llu] ", getpid(),
3867: (unsigned long long) pthread_self());
3868: fprintf(stderr, "O: %s\n", (unsigned char *)
3869: (*element_courant).pointeur);
3870: }
3871: else if (strcmp((*element_courant).argument, "sizeof(struct_objet)")
3872: == 0)
3873: {
3874: fprintf(stderr, "[%d-%llu] ", getpid(),
3875: (unsigned long long) pthread_self());
3876: fprintf(stderr, "O: %d\n", (*((struct_objet *)
3877: (*element_courant).pointeur)).type);
3878: }
3879: else if (strcmp((*element_courant).argument,
3880: "sizeof(struct_liste_chainee)") == 0)
3881: {
3882: fprintf(stderr, "[%d-%llu] ", getpid(),
3883: (unsigned long long) pthread_self());
3884: fprintf(stderr, "O: data=%p next=%p\n", (*((struct_liste_chainee *)
3885: (*element_courant).pointeur)).donnee,
3886: (*((struct_liste_chainee *) (*element_courant).pointeur))
3887: .suivant);
3888: }
3889:
3890: # ifdef __BACKTRACE
3891: appels = backtrace_symbols((*element_courant).pile,
3892: (*element_courant).profondeur);
3893:
3894: fprintf(stderr, "[%d-%llu] BACKTRACE\n",
3895: getpid(), (unsigned long long) pthread_self());
3896:
3897: if (appels != NULL)
3898: {
3899: for(j = 0; j < (*element_courant).profondeur; j++)
3900: {
3901: fprintf(stderr, "[%d-%llu] %s\n", getpid(),
3902: (unsigned long long) pthread_self(), appels[j]);
3903: }
3904:
3905: free(appels);
3906: }
3907: # endif
3908:
3909: fprintf(stderr, "\n");
3910:
3911: i++;
3912:
3913: element_suivant = (*element_courant).suivant;
3914:
3915: # ifndef CORE_DUMP
3916: free((*element_courant).fonction);
3917: free((*element_courant).argument);
3918: free(element_courant);
3919: # endif
3920:
3921: element_courant = element_suivant;
3922: }
3923:
3924: pthread_mutex_unlock(&mutex_allocation);
3925: pthread_mutex_destroy(&mutex_allocation);
3926:
3927: fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
3928: (unsigned long long) pthread_self());
3929:
3930: return;
3931: }
3932:
3933: pid_t
3934: debug_fork()
3935: {
3936: pid_t pid;
3937:
3938: pthread_mutex_lock(&mutex_allocation);
3939: pid = fork();
3940:
3941: if (pid == 0)
3942: {
3943: pthread_mutex_destroy(&mutex_allocation);
3944: debug_memoire_initialisation();
3945: }
3946: else
3947: {
3948: pthread_mutex_unlock(&mutex_allocation);
3949: }
3950:
3951: // Pas de parenthèses pour ne pas remplacer return par sa macro.
3952: return pid;
3953: }
3954:
3955: void
3956: analyse_post_mortem()
3957: {
3958: # ifdef CORE_DUMP
3959: BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR "
3960: "POST MORTEM ANALYZE\n", getpid(),
3961: (unsigned long long) pthread_self()));
3962: # endif
3963:
3964: return;
3965: }
3966:
3967: #endif
3968:
3969: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_objets.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src