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