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