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