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