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