![[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.9 bertrand 3: RPL/2 (R) version 4.0.14
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:
1.10 ! bertrand 2724: # ifndef SEMAPHORES_NOMMES
1.1 bertrand 2725: sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
1.10 ! bertrand 2726: # else
! 2727: if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork))
! 2728: == SEM_FAILED)
! 2729: {
! 2730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2731: return(NULL);
! 2732: }
! 2733: # endif
1.1 bertrand 2734:
2735: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
2736: (*s_nouvel_etat_processus).fichiers_graphiques = NULL;
2737: (*s_nouvel_etat_processus).entree_standard = NULL;
2738: (*s_nouvel_etat_processus).s_marques = NULL;
2739: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai;
2740: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux;
2741: (*s_nouvel_etat_processus).nom_fichier_impression = NULL;
2742: (*s_nouvel_etat_processus).expression_courante = NULL;
2743: (*s_nouvel_etat_processus).objet_courant = NULL;
2744: (*s_nouvel_etat_processus).processus_detache = d_faux;
1.3 bertrand 2745: (*s_nouvel_etat_processus).evaluation_forcee = 'N';
1.1 bertrand 2746:
2747: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
2748: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
2749: (*s_nouvel_etat_processus).presence_fusible = d_faux;
2750: (*s_nouvel_etat_processus).thread_fusible = 0;
2751: (*s_nouvel_etat_processus).niveau_initial =
2752: (*s_etat_processus).niveau_courant;
2753: (*s_nouvel_etat_processus).presence_pipes = d_faux;
2754: (*s_nouvel_etat_processus).debug_programme = d_faux;
2755: (*s_nouvel_etat_processus).s_fichiers = NULL;
2756: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL;
2757:
2758: // On réinitialise toutes les interruptions.
2759:
2760: (*s_nouvel_etat_processus).traitement_interruption = 'N';
2761: (*s_nouvel_etat_processus).traitement_interruptible = 'Y';
2762: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
2763: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
2764:
2765: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2766: {
2767: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
2768: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N';
2769: (*s_nouvel_etat_processus).queue_interruptions[i] = 0;
2770: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL;
2771: }
2772:
2773: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
2774: {
2775: (*s_nouvel_etat_processus).generateur_aleatoire = NULL;
2776: }
2777:
2778: (*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;
2779:
2780: // Copie de la localisation
2781:
2782: if (((*s_nouvel_etat_processus).localisation = malloc((strlen(
2783: (*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))
2784: == NULL)
2785: {
2786: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2787: return(NULL);
2788: }
2789:
2790: strcpy((*s_nouvel_etat_processus).localisation,
2791: (*s_etat_processus).localisation);
2792:
2793: if ((*s_etat_processus).indep != NULL)
2794: {
2795: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
2796: (*s_etat_processus).indep, 'P')) == NULL)
2797: {
2798: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2799: {
2800: (*s_etat_processus).erreur_systeme = d_es_processus;
2801: return(NULL);
2802: }
2803:
2804: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2805: return(NULL);
2806: }
2807: }
2808: else
2809: {
2810: (*s_nouvel_etat_processus).indep = NULL;
2811: }
2812:
2813: if ((*s_etat_processus).depend != NULL)
2814: {
2815: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
2816: (*s_etat_processus).depend, 'P')) == NULL)
2817: {
2818: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2819: {
2820: (*s_etat_processus).erreur_systeme = d_es_processus;
2821: return(NULL);
2822: }
2823:
2824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2825: return(NULL);
2826: }
2827: }
2828: else
2829: {
2830: (*s_nouvel_etat_processus).depend = NULL;
2831: }
2832:
2833: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL)
2834: {
2835: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau =
2836: copie_objet(s_etat_processus, (*s_etat_processus)
2837: .parametres_courbes_de_niveau, 'P')) == NULL)
2838: {
2839: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2840: {
2841: (*s_etat_processus).erreur_systeme = d_es_processus;
2842: return(NULL);
2843: }
2844:
2845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2846: return(NULL);
2847: }
2848: }
2849: else
2850: {
2851: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL;
2852: }
2853:
2854: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL;
2855:
2856: if (((*s_etat_processus).instruction_courante != NULL) &&
2857: (*s_etat_processus).evaluation_expression_compilee == 'N')
2858: {
2859: if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(
2860: (*s_etat_processus).instruction_courante) + 1) *
2861: sizeof(unsigned char))) == NULL)
2862: {
2863: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2864: {
2865: (*s_etat_processus).erreur_systeme = d_es_processus;
2866: return(NULL);
2867: }
2868:
2869: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2870: return(NULL);
2871: }
2872:
2873: strcpy((*s_nouvel_etat_processus).instruction_courante,
2874: (*s_etat_processus).instruction_courante);
2875: }
2876: else
2877: {
2878: (*s_nouvel_etat_processus).instruction_courante = NULL;
2879: }
2880:
2881: if ((*s_etat_processus).label_x != NULL)
2882: {
2883: if (((*s_nouvel_etat_processus).label_x = malloc((strlen(
2884: (*s_etat_processus).label_x) + 1) *
2885: sizeof(unsigned char))) == NULL)
2886: {
2887: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2888: {
2889: (*s_etat_processus).erreur_systeme = d_es_processus;
2890: return(NULL);
2891: }
2892:
2893: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2894: return(NULL);
2895: }
2896:
2897: strcpy((*s_nouvel_etat_processus).label_x,
2898: (*s_etat_processus).label_x);
2899: }
2900: else
2901: {
2902: (*s_nouvel_etat_processus).label_x = NULL;
2903: }
2904:
2905: if ((*s_etat_processus).label_y != NULL)
2906: {
2907: if (((*s_nouvel_etat_processus).label_y = malloc((strlen(
2908: (*s_etat_processus).label_y) + 1) *
2909: sizeof(unsigned char))) == NULL)
2910: {
2911: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2912: {
2913: (*s_etat_processus).erreur_systeme = d_es_processus;
2914: return(NULL);
2915: }
2916:
2917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2918: return(NULL);
2919: }
2920:
2921: strcpy((*s_nouvel_etat_processus).label_y,
2922: (*s_etat_processus).label_y);
2923: }
2924: else
2925: {
2926: (*s_nouvel_etat_processus).label_y = NULL;
2927: }
2928:
2929: if ((*s_etat_processus).label_z != NULL)
2930: {
2931: if (((*s_nouvel_etat_processus).label_z = malloc((strlen(
2932: (*s_etat_processus).label_z) + 1) *
2933: sizeof(unsigned char))) == NULL)
2934: {
2935: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2936: {
2937: (*s_etat_processus).erreur_systeme = d_es_processus;
2938: return(NULL);
2939: }
2940:
2941: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2942: return(NULL);
2943: }
2944:
2945: strcpy((*s_nouvel_etat_processus).label_z,
2946: (*s_etat_processus).label_z);
2947: }
2948: else
2949: {
2950: (*s_nouvel_etat_processus).label_z = NULL;
2951: }
2952:
2953: if ((*s_etat_processus).titre != NULL)
2954: {
2955: if (((*s_nouvel_etat_processus).titre = malloc((strlen(
2956: (*s_etat_processus).titre) + 1) *
2957: sizeof(unsigned char))) == NULL)
2958: {
2959: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2960: {
2961: (*s_etat_processus).erreur_systeme = d_es_processus;
2962: return(NULL);
2963: }
2964:
2965: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2966: return(NULL);
2967: }
2968:
2969: strcpy((*s_nouvel_etat_processus).titre,
2970: (*s_etat_processus).titre);
2971: }
2972: else
2973: {
2974: (*s_nouvel_etat_processus).titre = NULL;
2975: }
2976:
2977: if ((*s_etat_processus).legende != NULL)
2978: {
2979: if (((*s_nouvel_etat_processus).legende = malloc((strlen(
2980: (*s_etat_processus).legende) + 1) *
2981: sizeof(unsigned char))) == NULL)
2982: {
2983: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2984: {
2985: (*s_etat_processus).erreur_systeme = d_es_processus;
2986: return(NULL);
2987: }
2988:
2989: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2990: return(NULL);
2991: }
2992:
2993: strcpy((*s_nouvel_etat_processus).legende,
2994: (*s_etat_processus).legende);
2995: }
2996: else
2997: {
2998: (*s_nouvel_etat_processus).legende = NULL;
2999: }
3000:
3001: /*
3002: * Copie de la table des variables
3003: */
3004:
3005: if (((*s_nouvel_etat_processus).s_liste_variables =
3006: malloc((*s_etat_processus).nombre_variables_allouees *
3007: sizeof(struct_variable))) == NULL)
3008: {
3009: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3010: {
3011: (*s_etat_processus).erreur_systeme = d_es_processus;
3012: return(NULL);
3013: }
3014:
3015: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3016: return(NULL);
3017: }
3018:
3019: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
3020: {
3021: if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
3022: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
3023: + 1) * sizeof(unsigned char))) == NULL)
3024: {
3025: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3026: {
3027: (*s_etat_processus).erreur_systeme = d_es_processus;
3028: return(NULL);
3029: }
3030:
3031: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3032: return(NULL);
3033: }
3034:
3035: strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
3036: (*s_etat_processus).s_liste_variables[i].nom);
3037:
3038: (*s_nouvel_etat_processus).s_liste_variables[i].origine =
3039: (*s_etat_processus).s_liste_variables[i].origine;
3040: (*s_nouvel_etat_processus).s_liste_variables[i].niveau =
3041: (*s_etat_processus).s_liste_variables[i].niveau;
3042: (*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
3043: (*s_etat_processus).s_liste_variables[i].variable_statique;
3044: (*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
3045: (*s_etat_processus).s_liste_variables[i].variable_verrouillee;
3046:
3047: // Les définitions sont partagées entre tous les threads.
3048:
3049: if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
3050: {
3051: (*s_nouvel_etat_processus).s_liste_variables[i].objet =
3052: (*s_etat_processus).s_liste_variables[i].objet;
3053: }
3054: else
3055: {
3056: if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
3057: copie_objet(s_etat_processus,
3058: (*s_etat_processus).s_liste_variables[i]
3059: .objet, 'P')) == NULL)
3060: {
3061: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3062: {
3063: (*s_etat_processus).erreur_systeme = d_es_processus;
3064: return(NULL);
3065: }
3066:
3067: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3068: return(NULL);
3069: }
3070: }
3071: }
3072:
3073: /*
3074: * Copie de la table des variables statiques
3075: */
3076:
3077: if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
3078: malloc((*s_etat_processus).nombre_variables_statiques_allouees *
3079: sizeof(struct_variable_statique))) == NULL)
3080: {
3081: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3082: {
3083: (*s_etat_processus).erreur_systeme = d_es_processus;
3084: return(NULL);
3085: }
3086:
3087: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3088: return(NULL);
3089: }
3090:
3091: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
3092: {
3093: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =
3094: malloc((strlen((*s_etat_processus).s_liste_variables_statiques
3095: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3096: {
3097: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3098: {
3099: (*s_etat_processus).erreur_systeme = d_es_processus;
3100: return(NULL);
3101: }
3102:
3103: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3104: return(NULL);
3105: }
3106:
3107: strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
3108: (*s_etat_processus).s_liste_variables_statiques[i].nom);
3109:
3110: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
3111: (*s_etat_processus).s_liste_variables_statiques[i].origine;
3112: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
3113: (*s_etat_processus).s_liste_variables_statiques[i].niveau;
3114: (*s_nouvel_etat_processus).s_liste_variables_statiques[i]
3115: .variable_statique = (*s_etat_processus)
3116: .s_liste_variables_statiques[i].variable_statique;
3117:
3118: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
3119: copie_objet(s_etat_processus, (*s_etat_processus)
3120: .s_liste_variables_statiques[i].objet, 'P')) == NULL)
3121: {
3122: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3123: {
3124: (*s_etat_processus).erreur_systeme = d_es_processus;
3125: return(NULL);
3126: }
3127:
3128: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3129: return(NULL);
3130: }
3131: }
3132:
3133: /*
3134: * Copie de la pile opérationnelle
3135: */
3136:
3137: (*s_nouvel_etat_processus).l_base_pile = NULL;
3138: l_element_lecture = (*s_etat_processus).l_base_pile;
3139: l_element_precedent = NULL;
3140:
3141: while(l_element_lecture != NULL)
3142: {
3143: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3144: {
3145: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3146: {
3147: (*s_etat_processus).erreur_systeme = d_es_processus;
3148: return(NULL);
3149: }
3150:
3151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3152: return(NULL);
3153: }
3154:
3155: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3156: (*l_element_lecture).donnee, 'P')) == NULL)
3157: {
3158: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3159: {
3160: (*s_etat_processus).erreur_systeme = d_es_processus;
3161: return(NULL);
3162: }
3163:
3164: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3165: return(NULL);
3166: }
3167:
3168: (*l_element_suivant).suivant = NULL;
3169:
3170: if ((*s_nouvel_etat_processus).l_base_pile == NULL)
3171: {
3172: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant;
3173: }
3174: else
3175: {
3176: (*l_element_precedent).suivant = l_element_suivant;
3177: }
3178:
3179: l_element_precedent = l_element_suivant;
3180: l_element_lecture = (*l_element_lecture).suivant;
3181: }
3182:
3183: /*
3184: * Copie de la pile système
3185: */
3186:
3187: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL;
3188: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0;
3189:
3190: empilement_pile_systeme(s_nouvel_etat_processus);
3191:
3192: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3193: {
3194: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3195: {
3196: (*s_etat_processus).erreur_systeme = d_es_processus;
3197: return(NULL);
3198: }
3199:
3200: (*s_etat_processus).erreur_systeme =
3201: (*s_nouvel_etat_processus).erreur_systeme;
3202: return(NULL);
3203: }
3204:
3205: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3206:
3207: /*
3208: * On empile deux valeurs retour_definition pour pouvoir récupérer
3209: * les variables dans le cas d'un programme compilé.
3210: */
3211:
3212: empilement_pile_systeme(s_nouvel_etat_processus);
3213:
3214: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3215: {
3216: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3217: {
3218: (*s_etat_processus).erreur_systeme = d_es_processus;
3219: return(NULL);
3220: }
3221:
3222: (*s_etat_processus).erreur_systeme =
3223: (*s_nouvel_etat_processus).erreur_systeme;
3224: return(NULL);
3225: }
3226:
3227: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3228:
3229: /*
3230: * Destruction de la pile last pour le thread en cours.
3231: */
3232:
3233: (*s_nouvel_etat_processus).l_base_pile_last = NULL;
3234: (*s_nouvel_etat_processus).l_base_pile_processus = NULL;
3235:
3236: /*
3237: * Copie des différents contextes
3238: */
3239:
3240: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
3241: l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
3242:
3243: while(l_element_lecture != NULL)
3244: {
3245: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3246: {
3247: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3248: {
3249: (*s_etat_processus).erreur_systeme = d_es_processus;
3250: return(NULL);
3251: }
3252:
3253: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3254: return(NULL);
3255: }
3256:
3257: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3258: (*l_element_lecture).donnee, 'P')) == NULL)
3259: {
3260: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3261: {
3262: (*s_etat_processus).erreur_systeme = d_es_processus;
3263: return(NULL);
3264: }
3265:
3266: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3267: return(NULL);
3268: }
3269:
3270: (*l_element_suivant).suivant = NULL;
3271:
3272: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL)
3273: {
3274: (*s_nouvel_etat_processus).l_base_pile_contextes =
3275: l_element_suivant;
3276: }
3277: else
3278: {
3279: (*l_element_precedent).suivant = l_element_suivant;
3280: }
3281:
3282: l_element_precedent = l_element_suivant;
3283: l_element_lecture = (*l_element_lecture).suivant;
3284: }
3285:
3286: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL;
3287: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes;
3288:
3289: while(l_element_lecture != NULL)
3290: {
3291: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3292: {
3293: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3294: {
3295: (*s_etat_processus).erreur_systeme = d_es_processus;
3296: return(NULL);
3297: }
3298:
3299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3300: return(NULL);
3301: }
3302:
3303: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3304: (*l_element_lecture).donnee, 'P')) == NULL)
3305: {
3306: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3307: {
3308: (*s_etat_processus).erreur_systeme = d_es_processus;
3309: return(NULL);
3310: }
3311:
3312: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3313: return(NULL);
3314: }
3315:
3316: (*l_element_suivant).suivant = NULL;
3317:
3318: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL)
3319: {
3320: (*s_nouvel_etat_processus).l_base_pile_taille_contextes =
3321: l_element_suivant;
3322: }
3323: else
3324: {
3325: (*l_element_precedent).suivant = l_element_suivant;
3326: }
3327:
3328: l_element_precedent = l_element_suivant;
3329: l_element_lecture = (*l_element_lecture).suivant;
3330: }
3331:
3332: /*
3333: * Copies des piles s_sockets, s_bibliotheques et
3334: * s_instructions_externes.
3335: */
3336:
3337: (*s_nouvel_etat_processus).s_sockets = NULL;
3338: l_element_lecture = (*s_etat_processus).s_sockets;
3339:
3340: while(l_element_lecture != NULL)
3341: {
3342: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3343: {
3344: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3345: {
3346: (*s_etat_processus).erreur_systeme = d_es_processus;
3347: return(NULL);
3348: }
3349:
3350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3351: return(NULL);
3352: }
3353:
3354: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3355: (*l_element_lecture).donnee, 'P')) == NULL)
3356: {
3357: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3358: {
3359: (*s_etat_processus).erreur_systeme = d_es_processus;
3360: return(NULL);
3361: }
3362:
3363: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3364: return(NULL);
3365: }
3366:
3367: (*l_element_suivant).suivant = NULL;
3368:
3369: if ((*s_nouvel_etat_processus).s_sockets == NULL)
3370: {
3371: (*s_nouvel_etat_processus).s_sockets = l_element_suivant;
3372: }
3373: else
3374: {
3375: (*l_element_precedent).suivant = l_element_suivant;
3376: }
3377:
3378: l_element_precedent = l_element_suivant;
3379: l_element_lecture = (*l_element_lecture).suivant;
3380: }
3381:
3382: (*s_nouvel_etat_processus).s_bibliotheques = NULL;
3383: l_element_precedent = NULL;
3384: l_element_lecture = (*s_etat_processus).s_bibliotheques;
3385:
3386: while(l_element_lecture != NULL)
3387: {
3388: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3389: {
3390: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3391: {
3392: (*s_etat_processus).erreur_systeme = d_es_processus;
3393: return(NULL);
3394: }
3395:
3396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3397: return(NULL);
3398: }
3399:
3400: if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))
3401: == NULL)
3402: {
3403: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3404: return(NULL);
3405: }
3406:
3407: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur
3408: = (*((struct_bibliotheque *) (*l_element_lecture).donnee))
3409: .descripteur;
3410: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid
3411: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid;
3412: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid
3413: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
3414:
3415: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
3416: malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)
3417: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
3418: {
3419: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3420: {
3421: (*s_etat_processus).erreur_systeme = d_es_processus;
3422: return(NULL);
3423: }
3424:
3425: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3426: return(NULL);
3427: }
3428:
3429: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom,
3430: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom);
3431:
3432: (*l_element_suivant).suivant = NULL;
3433:
3434: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL)
3435: {
3436: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant;
3437: }
3438: else
3439: {
3440: (*l_element_precedent).suivant = l_element_suivant;
3441: }
3442:
3443: l_element_precedent = l_element_suivant;
3444: l_element_lecture = (*l_element_lecture).suivant;
3445: }
3446:
3447: if ((*s_etat_processus).nombre_instructions_externes != 0)
3448: {
3449: if (((*s_nouvel_etat_processus).s_instructions_externes =
3450: malloc((*s_etat_processus).nombre_instructions_externes *
3451: sizeof(struct_instruction_externe))) == NULL)
3452: {
3453: (*s_etat_processus).erreur_systeme = d_es_processus;
3454: return(NULL);
3455: }
3456:
3457: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
3458: {
3459: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
3460: malloc((strlen((*s_etat_processus).s_instructions_externes
3461: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3462: {
3463: (*s_etat_processus).erreur_systeme = d_es_processus;
3464: return(NULL);
3465: }
3466:
3467: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom,
3468: (*s_etat_processus).s_instructions_externes[i].nom);
3469:
3470: if (((*s_nouvel_etat_processus).s_instructions_externes[i]
3471: .nom_bibliotheque = malloc((strlen((*s_etat_processus)
3472: .s_instructions_externes[i].nom_bibliotheque) + 1) *
3473: sizeof(unsigned char))) == NULL)
3474: {
3475: (*s_etat_processus).erreur_systeme = d_es_processus;
3476: return(NULL);
3477: }
3478:
3479: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i]
3480: .nom_bibliotheque, (*s_etat_processus)
3481: .s_instructions_externes[i].nom_bibliotheque);
3482:
3483: (*s_nouvel_etat_processus).s_instructions_externes[i]
3484: .descripteur_bibliotheque = (*s_etat_processus)
3485: .s_instructions_externes[i].descripteur_bibliotheque;
3486: }
3487: }
3488: else
3489: {
3490: (*s_nouvel_etat_processus).s_instructions_externes = NULL;
3491: }
3492:
3493: pthread_mutexattr_init(&attributs_mutex);
3494: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3495: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);
3496: pthread_mutexattr_destroy(&attributs_mutex);
3497:
3498: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3499: {
3500: (*s_etat_processus).erreur_systeme = d_es_processus;
3501: return(NULL);
3502: }
3503:
3504: return(s_nouvel_etat_processus);
3505:
3506: #undef return
3507: }
3508:
1.6 bertrand 3509:
3510: /*
3511: ================================================================================
3512: Routines de debug
3513: ================================================================================
3514: entrées :
3515: --------------------------------------------------------------------------------
3516: sorties :
3517: --------------------------------------------------------------------------------
3518: effets de bord : néant
3519: ================================================================================
3520: */
3521:
3522: #ifdef DEBUG_MEMOIRE
3523:
3524: #undef malloc
3525: #undef realloc
3526: #undef free
3527:
3528: #ifdef return
3529: # undef return
3530: #endif
3531:
3532: #undef fprintf
3533:
3534: #define return(a) { if (a == NULL) \
3535: { BACKTRACE(20); fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
3536: return(a); } while(0)
3537:
3538: typedef struct memoire
3539: {
3540: void *pointeur;
3541: unsigned char *fonction;
3542: unsigned char *argument;
3543: unsigned long ligne;
3544: size_t taille;
3545: unsigned long long ordre;
3546: struct memoire *suivant;
3547: } struct_memoire;
3548:
3549: static struct_memoire *debug = NULL;
3550: static unsigned long long ordre = 0;
3551: static pthread_mutex_t mutex_allocation = PTHREAD_MUTEX_INITIALIZER;
3552:
3553: #define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
3554:
3555: void *
3556: debug_memoire_ajout(size_t taille, const unsigned char *fonction,
3557: unsigned long ligne, const unsigned char *argument)
3558: {
3559: struct_memoire *ancienne_base;
3560:
3561: pthread_mutex_lock(&mutex_allocation);
3562:
3563: ancienne_base = debug;
3564:
3565: if ((debug = malloc(sizeof(struct_memoire))) == NULL)
3566: {
3567: pthread_mutex_unlock(&mutex_allocation);
3568: return(NULL);
3569: }
3570:
3571: if (((*debug).pointeur = malloc(taille)) == NULL)
3572: {
3573: pthread_mutex_unlock(&mutex_allocation);
3574: return(NULL);
3575: }
3576:
3577: (*debug).suivant = ancienne_base;
3578: (*debug).ligne = ligne;
3579: (*debug).taille = taille;
3580: (*debug).ordre = ordre;
3581:
3582: pthread_mutex_unlock(&mutex_allocation);
3583:
3584: if (((*debug).fonction = malloc((strlen(fonction) + 1) *
3585: sizeof(unsigned char))) == NULL)
3586: {
3587: return(NULL);
3588: }
3589:
3590: if (((*debug).argument = malloc((strlen(argument) + 1) *
3591: sizeof(unsigned char))) == NULL)
3592: {
3593: return(NULL);
3594: }
3595:
3596: strcpy((*debug).fonction, fonction);
3597: strcpy((*debug).argument, argument);
3598:
3599: ordre++;
3600:
3601: return((*debug).pointeur);
3602: }
3603:
3604: void *
3605: debug_memoire_modification(void *pointeur, size_t taille,
3606: const unsigned char *fonction, unsigned long ligne,
3607: const unsigned char *argument)
3608: {
3609: struct_memoire *element_courant;
3610:
3611: if (pointeur != NULL)
3612: {
3613: if (taille == 0)
3614: {
3615: // Revient à free()
3616: debug_memoire_retrait(pointeur);
3617: return(NULL);
3618: }
3619: else
3620: {
3621: // Réallocation réelle
3622:
3623: pthread_mutex_lock(&mutex_allocation);
3624:
3625: element_courant = debug;
3626:
3627: while(element_courant != NULL)
3628: {
3629: if ((*element_courant).pointeur == pointeur)
3630: {
3631: break;
3632: }
3633:
3634: element_courant = (*element_courant).suivant;
3635: }
3636:
3637: if (element_courant == NULL)
3638: {
3639: pthread_mutex_unlock(&mutex_allocation);
3640: return(NULL);
3641: }
3642:
3643: pthread_mutex_unlock(&mutex_allocation);
3644:
3645: if (((*element_courant).pointeur = realloc(pointeur, taille))
3646: == NULL)
3647: {
3648: return(NULL);
3649: }
3650:
3651: (*element_courant).ligne = ligne;
3652: (*element_courant).taille = taille;
3653: free((*element_courant).fonction);
3654: free((*element_courant).argument);
3655:
3656: if (((*element_courant).fonction = malloc((strlen(fonction) + 1) *
3657: sizeof(unsigned char))) == NULL)
3658: {
3659: return(NULL);
3660: }
3661:
3662: if (((*element_courant).argument = malloc((strlen(argument) + 1) *
3663: sizeof(unsigned char))) == NULL)
3664: {
3665: return(NULL);
3666: }
3667:
3668: strcpy((*element_courant).fonction, fonction);
3669: strcpy((*element_courant).argument, argument);
3670:
3671: return((*element_courant).pointeur);
3672: }
3673: }
3674: else
3675: {
3676: // Revient à malloc()
3677: pointeur = debug_memoire_ajout(taille, fonction, ligne, argument);
3678: return(pointeur);
3679: }
3680: }
3681:
3682: void
3683: debug_memoire_retrait(void *pointeur)
3684: {
3685: struct_memoire *element_courant;
3686: struct_memoire *element_precedent;
3687:
3688: pthread_mutex_lock(&mutex_allocation);
3689:
3690: element_courant = debug;
3691: element_precedent = NULL;
3692:
3693: while(element_courant != NULL)
3694: {
3695: if ((*element_courant).pointeur == pointeur)
3696: {
3697: if (element_precedent == NULL)
3698: {
3699: debug = (*debug).suivant;
3700: }
3701: else
3702: {
3703: (*element_precedent).suivant = (*element_courant).suivant;
3704: }
3705:
3706: free((*element_courant).fonction);
3707: free((*element_courant).argument);
3708: free(element_courant);
3709:
3710: break;
3711: }
3712:
3713: element_precedent = element_courant;
3714: element_courant = (*element_courant).suivant;
3715: }
3716:
3717: pthread_mutex_unlock(&mutex_allocation);
3718:
3719: free(pointeur);
3720:
3721: return;
3722: }
3723:
3724: void
3725: debug_memoire_verification(struct_processus *s_etat_processus)
3726: {
3727: integer8 i;
3728:
3729: struct_memoire *element_courant;
3730: struct_memoire *element_suivant;
3731:
3732: fprintf(stderr, "[%d-%llu] MEMORY LEAK\n",
3733: getpid(), (unsigned long long) pthread_self());
3734:
3735: pthread_mutex_lock(&mutex_allocation);
3736:
3737: element_courant = debug;
3738: i = 1;
3739:
3740: while(element_courant != NULL)
3741: {
3742: fprintf(stderr, "[%d-%llu] MEDITATION %lld (%llu)\n", getpid(),
3743: (unsigned long long) pthread_self(), i,
3744: (*element_courant).ordre);
3745: fprintf(stderr, "[%d-%llu] P: %p, F: %s(), L: %lu, S: %d\n",
3746: getpid(), (unsigned long long) pthread_self(),
3747: (*element_courant).pointeur,
3748: (*element_courant).fonction, (*element_courant).ligne,
3749: (int) (*element_courant).taille);
3750: fprintf(stderr, "[%d-%llu] A: %s\n", getpid(),
3751: (unsigned long long) pthread_self(),
3752: (*element_courant).argument);
3753:
3754: switch(i)
3755: {
3756: // Affichage des méditations
3757: case 1:
3758: {
3759: break;
3760: }
3761: }
3762:
3763: i++;
3764:
3765: element_suivant = (*element_courant).suivant;
3766: free((*element_courant).fonction);
3767: free((*element_courant).argument);
3768: free(element_courant);
3769: element_courant = element_suivant;
3770: }
3771:
3772: pthread_mutex_unlock(&mutex_allocation);
3773:
3774: fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
3775: (unsigned long long) pthread_self());
3776:
3777: return;
3778: }
3779:
3780: #endif
3781:
1.1 bertrand 3782: // vim: ts=4