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