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