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