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