1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.27
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 duplication associée à l'objet
1514: // externe. Le descripteur de bibliothèque est directement
1515: // associé à la structure objet.
1516:
1517: if ((__type_drop = dlsym((*s_objet).descripteur_bibliotheque,
1518: "__type_drop")) == NULL)
1519: {
1520: // La fonction de duplication n'existe pas dans la
1521: // bibliothèque.
1522:
1523: (*s_etat_processus).erreur_execution = d_ex_type_externe_drop;
1524: }
1525: else
1526: {
1527: if (__type_drop(s_etat_processus, (void **) &s_objet) == 0)
1528: {
1529: (*s_etat_processus).erreur_execution =
1530: d_ex_type_externe_drop;
1531: }
1532: }
1533:
1534: break;
1535: }
1536:
1537: default :
1538: {
1539: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1540: {
1541: (*s_etat_processus).erreur_systeme = d_es_processus;
1542: return;
1543: }
1544:
1545: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1546: {
1547: (*s_etat_processus).erreur_systeme = d_es_processus;
1548: return;
1549: }
1550:
1551: BUG(1, printf("Free failure (type %d)\n", (*s_objet).type));
1552: return;
1553: }
1554: }
1555:
1556: #undef return
1557:
1558: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1559: {
1560: (*s_etat_processus).erreur_systeme = d_es_processus;
1561: return;
1562: }
1563:
1564: if (pthread_mutex_lock(&((*s_etat_processus).mutex_allocation)) != 0)
1565: {
1566: (*s_etat_processus).erreur_systeme = d_es_processus;
1567: return;
1568: }
1569:
1570: if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
1571: {
1572: (*s_objet).objet = (*s_etat_processus).pile_objets;
1573: (*s_etat_processus).pile_objets = s_objet;
1574: (*s_etat_processus).taille_pile_objets++;
1575: }
1576: else
1577: {
1578: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1579: {
1580: pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation));
1581: (*s_etat_processus).erreur_systeme = d_es_processus;
1582: return;
1583: }
1584:
1585: free(s_objet);
1586: }
1587:
1588: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_allocation)) != 0)
1589: {
1590: (*s_etat_processus).erreur_systeme = d_es_processus;
1591: return;
1592: }
1593:
1594: return;
1595: }
1596:
1597:
1598: /*
1599: ================================================================================
1600: Routine de copie d'une structure *s_objet
1601: ================================================================================
1602: Entrées : structure *s_objet à copier
1603: type :
1604: 'P' : renvoie le même objet en incrémentant le nombre
1605: d'occurrence de chaque objet élémentaire ;
1606: 'O' : crée un nouvel objet en copiant chaque objet élémentaire ;
1607: 'N' : crée un nouvel objet mais les objets élémentaires
1608: sont réutilisés (voir 'P'). Dans le cas d'un objet
1609: élémentaire, 'N' et 'P' sont identiques.
1610: 'Q' : 'P' si nombre_occurrences vaut 1, 'O' sinon.
1611: 'R' : 'P' si nombre_occurrences vaut 1, 'N' sinon.
1612: --------------------------------------------------------------------------------
1613: Sorties : structure identique (tous les objets sont copiés)
1614: --------------------------------------------------------------------------------
1615: Effets de bord : néant
1616: ================================================================================
1617: */
1618:
1619: struct_objet *
1620: copie_objet(struct_processus *s_etat_processus,
1621: struct_objet *s_objet, unsigned char type)
1622: {
1623: struct_liste_chainee *l_element_base;
1624: struct_liste_chainee *l_element_courant;
1625: struct_liste_chainee *l_element_courant_ecriture;
1626: struct_liste_chainee *l_element_courant_lecture;
1627: struct_liste_chainee *l_element_suivant_ecriture;
1628: struct_liste_chainee *l_element_suivant_lecture;
1629:
1630: struct_objet *s_nouvel_objet;
1631: struct_objet *s_objet_tampon;
1632:
1633: integer8 i;
1634: integer8 j;
1635: integer8 (*__type_dup)(struct_processus *, void **);
1636:
1637: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
1638: {
1639: (*s_etat_processus).erreur_systeme = d_es_processus;
1640: return(NULL);
1641: }
1642:
1643: if (type == 'Q')
1644: {
1645: if ((*s_objet).nombre_occurrences == 1)
1646: {
1647: type = 'P';
1648: }
1649: else
1650: {
1651: type = 'O';
1652: }
1653: }
1654: else if (type == 'R')
1655: {
1656: if ((*s_objet).nombre_occurrences == 1)
1657: {
1658: type = 'P';
1659: }
1660: else
1661: {
1662: type = 'N';
1663: }
1664: }
1665:
1666: #define return(pointeur) \
1667: if (pthread_mutex_unlock(&((*s_objet).mutex))) \
1668: { (*s_etat_processus).erreur_systeme = d_es_processus; return(NULL); } \
1669: return(pointeur)
1670:
1671: switch((*s_objet).type)
1672: {
1673: case ADR :
1674: {
1675: if (type != 'O')
1676: {
1677: incrementation_atomique(s_objet);
1678: return(s_objet);
1679: }
1680:
1681: if ((s_nouvel_objet = allocation(s_etat_processus, ADR)) == NULL)
1682: {
1683: return(NULL);
1684: }
1685:
1686: (*((integer8 *) ((*s_nouvel_objet).objet))) =
1687: (*((integer8 *) ((*s_objet).objet)));
1688: break;
1689: }
1690:
1691: case ALG :
1692: {
1693: if (type != 'P')
1694: {
1695: if ((s_nouvel_objet = allocation(s_etat_processus, ALG))
1696: == NULL)
1697: {
1698: return(NULL);
1699: }
1700:
1701: l_element_courant_lecture = (struct_liste_chainee *)
1702: ((*s_objet).objet);
1703:
1704: l_element_base = NULL;
1705: l_element_courant_ecriture = l_element_base;
1706:
1707: while(l_element_courant_lecture != NULL)
1708: {
1709: s_objet_tampon = copie_objet(s_etat_processus,
1710: (*l_element_courant_lecture).donnee, type);
1711: l_element_suivant_ecriture = (struct_liste_chainee *)
1712: malloc(sizeof(struct_liste_chainee));
1713:
1714: if ((s_objet_tampon == NULL) ||
1715: (l_element_suivant_ecriture == NULL))
1716: {
1717: l_element_courant_lecture = (struct_liste_chainee *)
1718: ((*s_nouvel_objet).objet);
1719:
1720: while(l_element_courant_lecture != NULL)
1721: {
1722: l_element_suivant_lecture =
1723: (*l_element_courant_lecture).suivant;
1724: liberation(s_etat_processus,
1725: (*l_element_courant_lecture).donnee);
1726: free(l_element_courant_lecture);
1727: l_element_courant_lecture =
1728: l_element_suivant_lecture;
1729: }
1730:
1731: return(NULL);
1732: }
1733:
1734: if (l_element_courant_ecriture == NULL)
1735: {
1736: l_element_base = l_element_suivant_ecriture;
1737: }
1738: else
1739: {
1740: (*l_element_courant_ecriture).suivant =
1741: l_element_suivant_ecriture;
1742: }
1743:
1744: l_element_courant_ecriture = l_element_suivant_ecriture;
1745:
1746: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1747: (*l_element_courant_ecriture).suivant = NULL;
1748: l_element_courant_lecture =
1749: (*l_element_courant_lecture).suivant;
1750: }
1751:
1752: (*s_nouvel_objet).objet = ((struct_liste_chainee *)
1753: l_element_base);
1754: }
1755: else // type == 'P'
1756: {
1757: incrementation_atomique(s_objet);
1758: l_element_courant = (*s_objet).objet;
1759:
1760: while(l_element_courant != NULL)
1761: {
1762: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1763: (*l_element_courant).donnee, 'P');
1764: l_element_courant = (*l_element_courant).suivant;
1765: }
1766:
1767: return(s_objet);
1768: }
1769:
1770: break;
1771: }
1772:
1773: case BIN :
1774: {
1775: if (type != 'O')
1776: {
1777: incrementation_atomique(s_objet);
1778: return(s_objet);
1779: }
1780:
1781: if ((s_nouvel_objet = allocation(s_etat_processus, BIN)) == NULL)
1782: {
1783: return(NULL);
1784: }
1785:
1786: (*((logical8 *) ((*s_nouvel_objet).objet))) =
1787: (*((logical8 *) ((*s_objet).objet)));
1788: break;
1789: }
1790:
1791: case CHN :
1792: {
1793: if (type != 'O')
1794: {
1795: incrementation_atomique(s_objet);
1796: return(s_objet);
1797: }
1798:
1799: if ((s_nouvel_objet = allocation(s_etat_processus, CHN)) == NULL)
1800: {
1801: return(NULL);
1802: }
1803:
1804: (*s_nouvel_objet).objet = ((unsigned char *)
1805: malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
1806: * sizeof(unsigned char)));
1807:
1808: if ((*s_nouvel_objet).objet == NULL)
1809: {
1810: free(s_nouvel_objet);
1811: return(NULL);
1812: }
1813:
1814: strcpy((unsigned char *) ((*s_nouvel_objet).objet),
1815: (unsigned char *) ((*s_objet).objet));
1816: break;
1817: }
1818:
1819: case CPL :
1820: {
1821: if (type != 'O')
1822: {
1823: incrementation_atomique(s_objet);
1824: return(s_objet);
1825: }
1826:
1827: if ((s_nouvel_objet = allocation(s_etat_processus, CPL)) == NULL)
1828: {
1829: return(NULL);
1830: }
1831:
1832: (*((struct_complexe16 *) ((*s_nouvel_objet).objet))) =
1833: (*((struct_complexe16 *) ((*s_objet).objet)));
1834: break;
1835: }
1836:
1837: case RPN :
1838: {
1839: if (type != 'P')
1840: {
1841: if ((s_nouvel_objet = allocation(s_etat_processus, RPN))
1842: == NULL)
1843: {
1844: return(NULL);
1845: }
1846:
1847: l_element_courant_lecture = (struct_liste_chainee *)
1848: ((*s_objet).objet);
1849:
1850: l_element_base = NULL;
1851: l_element_courant_ecriture = l_element_base;
1852:
1853: while(l_element_courant_lecture != NULL)
1854: {
1855: s_objet_tampon = copie_objet(s_etat_processus,
1856: (*l_element_courant_lecture).donnee, type);
1857: l_element_suivant_ecriture = (struct_liste_chainee *)
1858: malloc(sizeof(struct_liste_chainee));
1859:
1860: if ((s_objet_tampon == NULL) ||
1861: (l_element_suivant_ecriture == NULL))
1862: {
1863: l_element_courant_lecture = (struct_liste_chainee *)
1864: ((*s_nouvel_objet).objet);
1865:
1866: while(l_element_courant_lecture != NULL)
1867: {
1868: l_element_suivant_lecture =
1869: (*l_element_courant_lecture).suivant;
1870: liberation(s_etat_processus,
1871: (*l_element_courant_lecture).donnee);
1872: free(l_element_courant_lecture);
1873: l_element_courant_lecture =
1874: l_element_suivant_lecture;
1875: }
1876:
1877: return(NULL);
1878: }
1879:
1880: if (l_element_courant_ecriture == NULL)
1881: {
1882: l_element_base = l_element_suivant_ecriture;
1883: }
1884: else
1885: {
1886: (*l_element_courant_ecriture).suivant =
1887: l_element_suivant_ecriture;
1888: }
1889:
1890: l_element_courant_ecriture = l_element_suivant_ecriture;
1891:
1892: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1893: (*l_element_courant_ecriture).suivant = NULL;
1894: l_element_courant_lecture =
1895: (*l_element_courant_lecture).suivant;
1896: }
1897:
1898: (*s_nouvel_objet).objet = ((struct_liste_chainee *)
1899: l_element_base);
1900: }
1901: else // type == 'P'
1902: {
1903: incrementation_atomique(s_objet);
1904: l_element_courant = (*s_objet).objet;
1905:
1906: while(l_element_courant != NULL)
1907: {
1908: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1909: (*l_element_courant).donnee, 'P');
1910: l_element_courant = (*l_element_courant).suivant;
1911: }
1912:
1913: return(s_objet);
1914: }
1915:
1916: break;
1917: }
1918:
1919: case FCH :
1920: {
1921: if (type == 'P')
1922: {
1923: incrementation_atomique(s_objet);
1924:
1925: if (((*((struct_fichier *) ((*s_objet).objet))).format =
1926: copie_objet(s_etat_processus, (*((struct_fichier *)
1927: ((*s_objet).objet))).format, 'P')) == NULL)
1928: {
1929: return(NULL);
1930: }
1931:
1932: return(s_objet);
1933: }
1934:
1935: if ((s_nouvel_objet = allocation(s_etat_processus, FCH)) == NULL)
1936: {
1937: return(NULL);
1938: }
1939:
1940: (*((struct_fichier *) ((*s_nouvel_objet).objet))).descripteur =
1941: (*((struct_fichier *) ((*s_objet).objet))).descripteur;
1942: (*((struct_fichier *) ((*s_nouvel_objet).objet))).acces =
1943: (*((struct_fichier *) ((*s_objet).objet))).acces;
1944: (*((struct_fichier *) ((*s_nouvel_objet).objet))).binaire =
1945: (*((struct_fichier *) ((*s_objet).objet))).binaire;
1946: (*((struct_fichier *) ((*s_nouvel_objet).objet))).ouverture =
1947: (*((struct_fichier *) ((*s_objet).objet))).ouverture;
1948: (*((struct_fichier *) ((*s_nouvel_objet).objet))).protection =
1949: (*((struct_fichier *) ((*s_objet).objet))).protection;
1950: (*((struct_fichier *) ((*s_nouvel_objet).objet)))
1951: .position_clef = (*((struct_fichier *)
1952: ((*s_objet).objet))).position_clef;
1953: (*((struct_fichier *) ((*s_nouvel_objet).objet))).pid =
1954: (*((struct_fichier *) ((*s_objet).objet))).pid;
1955: (*((struct_fichier *) ((*s_nouvel_objet).objet))).tid =
1956: (*((struct_fichier *) ((*s_objet).objet))).tid;
1957:
1958: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).format =
1959: copie_objet(s_etat_processus, (*((struct_fichier *)
1960: ((*s_objet).objet))).format, type)) == NULL)
1961: {
1962: free((*s_nouvel_objet).objet);
1963: free(s_nouvel_objet);
1964: return(NULL);
1965: }
1966:
1967: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom =
1968: (unsigned char *) malloc((strlen((*((struct_fichier *)
1969: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
1970: == NULL)
1971: {
1972: liberation(s_etat_processus, (*((struct_fichier *)
1973: (*s_nouvel_objet).objet)).format);
1974: free((*s_nouvel_objet).objet);
1975: free(s_nouvel_objet);
1976: return(NULL);
1977: }
1978:
1979: strcpy((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom,
1980: (*((struct_fichier *) ((*s_objet).objet))).nom);
1981: break;
1982: }
1983:
1984: case FCT :
1985: {
1986: if (type != 'O')
1987: {
1988: /*
1989: * Remise à zéro de la prédiction pour respecter la cohérence
1990: * du saut dans les cas EXSUB et OBSUB.
1991: */
1992:
1993: (*((struct_fonction *) ((*s_objet).objet)))
1994: .prediction_saut = NULL;
1995: incrementation_atomique(s_objet);
1996: return(s_objet);
1997: }
1998:
1999: if ((s_nouvel_objet = allocation(s_etat_processus, FCT)) == NULL)
2000: {
2001: return(NULL);
2002: }
2003:
2004: if (((*((struct_fonction *) ((*s_nouvel_objet).objet)))
2005: .nom_fonction = (unsigned char *)
2006: malloc((strlen((*((struct_fonction *)
2007: ((*s_objet).objet))).nom_fonction) + 1) *
2008: sizeof(unsigned char))) == NULL)
2009: {
2010: free(s_nouvel_objet);
2011: return(NULL);
2012: }
2013:
2014: strcpy((unsigned char *) (*((struct_fonction *)
2015: ((*s_nouvel_objet).objet))).nom_fonction,
2016: (unsigned char *) (*((struct_fonction *)
2017: ((*s_objet).objet))).nom_fonction);
2018: (*((struct_fonction *) ((*s_nouvel_objet).objet)))
2019: .nombre_arguments = (*((struct_fonction *)
2020: ((*s_objet).objet))).nombre_arguments;
2021: (*((struct_fonction *) ((*s_nouvel_objet).objet))).fonction =
2022: (*((struct_fonction *) ((*s_objet).objet))).fonction;
2023: break;
2024: }
2025:
2026: case INT :
2027: {
2028: if (type != 'O')
2029: {
2030: incrementation_atomique(s_objet);
2031: return(s_objet);
2032: }
2033:
2034: if ((s_nouvel_objet = allocation(s_etat_processus, INT)) == NULL)
2035: {
2036: return(NULL);
2037: }
2038:
2039: (*((integer8 *) ((*s_nouvel_objet).objet))) =
2040: (*((integer8 *) ((*s_objet).objet)));
2041: break;
2042: }
2043:
2044: case LST :
2045: {
2046: if (type != 'P')
2047: {
2048: if ((s_nouvel_objet = allocation(s_etat_processus, LST))
2049: == NULL)
2050: {
2051: return(NULL);
2052: }
2053:
2054: l_element_courant_lecture = (struct_liste_chainee *)
2055: ((*s_objet).objet);
2056:
2057: l_element_base = NULL;
2058: l_element_courant_ecriture = l_element_base;
2059:
2060: while(l_element_courant_lecture != NULL)
2061: {
2062: s_objet_tampon = copie_objet(s_etat_processus,
2063: (*l_element_courant_lecture).donnee, type);
2064: l_element_suivant_ecriture = (struct_liste_chainee *)
2065: malloc(sizeof(struct_liste_chainee));
2066:
2067: if ((s_objet_tampon == NULL) ||
2068: (l_element_suivant_ecriture == NULL))
2069: {
2070: l_element_courant_lecture = (struct_liste_chainee *)
2071: ((*s_nouvel_objet).objet);
2072:
2073: while(l_element_courant_lecture != NULL)
2074: {
2075: l_element_suivant_lecture =
2076: (*l_element_courant_lecture).suivant;
2077: liberation(s_etat_processus,
2078: (*l_element_courant_lecture).donnee);
2079: free(l_element_courant_lecture);
2080: l_element_courant_lecture =
2081: l_element_suivant_lecture;
2082: }
2083:
2084: return(NULL);
2085: }
2086:
2087: if (l_element_courant_ecriture == NULL)
2088: {
2089: l_element_base = l_element_suivant_ecriture;
2090: }
2091: else
2092: {
2093: (*l_element_courant_ecriture).suivant =
2094: l_element_suivant_ecriture;
2095: }
2096:
2097: l_element_courant_ecriture = l_element_suivant_ecriture;
2098:
2099: (*l_element_courant_ecriture).donnee = s_objet_tampon;
2100: (*l_element_courant_ecriture).suivant = NULL;
2101: l_element_courant_lecture =
2102: (*l_element_courant_lecture).suivant;
2103: }
2104:
2105: (*s_nouvel_objet).objet = ((struct_liste_chainee *)
2106: l_element_base);
2107: }
2108: else
2109: {
2110: incrementation_atomique(s_objet);
2111: l_element_courant = (*s_objet).objet;
2112:
2113: while(l_element_courant != NULL)
2114: {
2115: (*l_element_courant).donnee = copie_objet(s_etat_processus,
2116: (*l_element_courant).donnee, 'P');
2117: l_element_courant = (*l_element_courant).suivant;
2118: }
2119:
2120: return(s_objet);
2121: }
2122:
2123: break;
2124: }
2125:
2126: case MIN :
2127: {
2128: if (type != 'O')
2129: {
2130: incrementation_atomique(s_objet);
2131: return(s_objet);
2132: }
2133:
2134: if ((s_nouvel_objet = allocation(s_etat_processus, MIN)) == NULL)
2135: {
2136: return(NULL);
2137: }
2138:
2139: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2140: malloc(((size_t) ((*((struct_matrice *)
2141: ((*s_objet).objet))).nombre_lignes)) * sizeof(integer8 *));
2142:
2143: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2144: == NULL)
2145: {
2146: free((*s_nouvel_objet).objet);
2147: free(s_nouvel_objet);
2148: return(NULL);
2149: }
2150:
2151: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2152: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2153: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2154: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2155: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2156: (*((struct_matrice *) ((*s_objet).objet))).type;
2157:
2158: for(i = 0; i < (*((struct_matrice *)
2159: ((*s_objet).objet))).nombre_lignes; i++)
2160: {
2161: if ((((integer8 **) ((*((struct_matrice *)
2162: ((*s_nouvel_objet).objet))).tableau))[i] =
2163: ((integer8 *) malloc(((size_t)
2164: ((*((struct_matrice *) ((*s_objet).objet)))
2165: .nombre_colonnes)) * sizeof(integer8)))) == NULL)
2166: {
2167: for(j = 0; j < i; j++)
2168: {
2169: free(((integer8 **) ((*((struct_matrice *)
2170: ((*s_nouvel_objet).objet))).tableau))[j]);
2171: }
2172:
2173: free((*s_nouvel_objet).objet);
2174: free(s_nouvel_objet);
2175: return(NULL);
2176: }
2177:
2178: for(j = 0; j < (*((struct_matrice *)
2179: ((*s_objet).objet))).nombre_colonnes; j++)
2180: {
2181: ((integer8 **) ((*((struct_matrice *)
2182: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2183: ((integer8 **) ((*((struct_matrice *)
2184: ((*s_objet).objet))).tableau))[i][j];
2185: }
2186: }
2187:
2188: break;
2189: }
2190:
2191: case MCX :
2192: {
2193: if (type != 'O')
2194: {
2195: incrementation_atomique(s_objet);
2196: return(s_objet);
2197: }
2198:
2199: if ((s_nouvel_objet = allocation(s_etat_processus, MCX))
2200: == NULL)
2201: {
2202: return(NULL);
2203: }
2204:
2205: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2206: malloc(((size_t) ((*((struct_matrice *)
2207: ((*s_objet).objet))).nombre_lignes))
2208: * sizeof(struct_complexe16 *));
2209:
2210: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2211: == NULL)
2212: {
2213: free((*s_nouvel_objet).objet);
2214: free(s_nouvel_objet);
2215: return(NULL);
2216: }
2217:
2218: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2219: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2220: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2221: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2222: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2223: (*((struct_matrice *) ((*s_objet).objet))).type;
2224:
2225: for(i = 0; i < (*((struct_matrice *)
2226: ((*s_objet).objet))).nombre_lignes; i++)
2227: {
2228: if ((((struct_complexe16 **) ((*((struct_matrice *)
2229: ((*s_nouvel_objet).objet))).tableau))[i] =
2230: ((struct_complexe16 *) malloc(((size_t)
2231: ((*((struct_matrice *) ((*s_objet).objet)))
2232: .nombre_colonnes)) * sizeof(struct_complexe16))))
2233: == NULL)
2234: {
2235: for(j = 0; j < i; j++)
2236: {
2237: free(((struct_complexe16 **) ((*((struct_matrice *)
2238: ((*s_nouvel_objet).objet))).tableau))[j]);
2239: }
2240:
2241: free((*s_nouvel_objet).objet);
2242: free(s_nouvel_objet);
2243: return(NULL);
2244: }
2245:
2246: for(j = 0; j < (*((struct_matrice *)
2247: ((*s_objet).objet))).nombre_colonnes; j++)
2248: {
2249: ((struct_complexe16 **) ((*((struct_matrice *)
2250: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2251: ((struct_complexe16 **) ((*((struct_matrice *)
2252: ((*s_objet).objet))).tableau))[i][j];
2253: }
2254: }
2255:
2256: break;
2257: }
2258:
2259: case MRL :
2260: {
2261: if (type != 'O')
2262: {
2263: incrementation_atomique(s_objet);
2264: return(s_objet);
2265: }
2266:
2267: if ((s_nouvel_objet = allocation(s_etat_processus, MRL)) == NULL)
2268: {
2269: return(NULL);
2270: }
2271:
2272: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2273: malloc(((size_t) ((*((struct_matrice *)
2274: ((*s_objet).objet))).nombre_lignes)) * sizeof(real8 *));
2275:
2276: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2277: == NULL)
2278: {
2279: free((*s_nouvel_objet).objet);
2280: free(s_nouvel_objet);
2281: return(NULL);
2282: }
2283:
2284: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2285: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2286: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2287: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2288: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2289: (*((struct_matrice *) ((*s_objet).objet))).type;
2290:
2291: for(i = 0; i < (*((struct_matrice *)
2292: ((*s_objet).objet))).nombre_lignes; i++)
2293: {
2294: if ((((real8 **) ((*((struct_matrice *)
2295: ((*s_nouvel_objet).objet))).tableau))[i] =
2296: ((real8 *) malloc(((size_t)
2297: ((*((struct_matrice *) ((*s_objet).objet)))
2298: .nombre_colonnes)) * sizeof(real8)))) == NULL)
2299: {
2300: for(j = 0; j < i; j++)
2301: {
2302: free(((real8 **) ((*((struct_matrice *)
2303: ((*s_nouvel_objet).objet))).tableau))[j]);
2304: }
2305:
2306: free((*s_nouvel_objet).objet);
2307: free(s_nouvel_objet);
2308: return(NULL);
2309: }
2310:
2311: for(j = 0; j < (*((struct_matrice *)
2312: ((*s_objet).objet))).nombre_colonnes; j++)
2313: {
2314: ((real8 **) ((*((struct_matrice *)
2315: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2316: ((real8 **) ((*((struct_matrice *)
2317: ((*s_objet).objet))).tableau))[i][j];
2318: }
2319: }
2320:
2321: break;
2322: }
2323:
2324: case MTX :
2325: {
2326: // La duplication d'un mutex renvoie le même objet.
2327: incrementation_atomique(s_objet);
2328: return(s_objet);
2329: }
2330:
2331: case NOM :
2332: {
2333: if (type != 'O')
2334: {
2335: incrementation_atomique(s_objet);
2336: return(s_objet);
2337: }
2338:
2339: if ((s_nouvel_objet = allocation(s_etat_processus, NOM)) == NULL)
2340: {
2341: return(NULL);
2342: }
2343:
2344: (*((struct_nom *) (*s_nouvel_objet).objet)).nom = malloc((
2345: strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) *
2346: sizeof(unsigned char));
2347:
2348: if ((*((struct_nom *) (*s_nouvel_objet).objet)).nom == NULL)
2349: {
2350: free((*s_nouvel_objet).objet);
2351: free(s_nouvel_objet);
2352: return(NULL);
2353: }
2354:
2355: strcpy((*((struct_nom *) (*s_nouvel_objet).objet)).nom,
2356: (*((struct_nom *) (*s_objet).objet)).nom);
2357: (*((struct_nom *) (*s_nouvel_objet).objet)).symbole =
2358: (*((struct_nom *) (*s_objet).objet)).symbole;
2359: break;
2360: }
2361:
2362: case NON :
2363: {
2364: if (type != 'O')
2365: {
2366: incrementation_atomique(s_objet);
2367: return(s_objet);
2368: }
2369:
2370: // Un objet de type NON est un objet encapsulé dans une
2371: // structure de type struct_objet. Elle peut très bien contenir
2372: // une donnée, mais c'est à l'utilisateur de la libérer
2373: // explicitement avec un free().
2374:
2375: if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)
2376: {
2377: return(NULL);
2378: }
2379:
2380: (*s_nouvel_objet).objet = (*s_objet).objet;
2381: break;
2382: }
2383:
2384: case PRC :
2385: {
2386: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2387: (*s_objet).objet)).thread).mutex_nombre_references)) != 0)
2388: {
2389: return(NULL);
2390: }
2391:
2392: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
2393: .nombre_references++;
2394:
2395: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2396: (*s_objet).objet)).thread).mutex_nombre_references)) != 0)
2397: {
2398: return(NULL);
2399: }
2400:
2401: if (type != 'O')
2402: {
2403: incrementation_atomique(s_objet);
2404: return(s_objet);
2405: }
2406:
2407: if ((s_nouvel_objet = allocation(s_etat_processus, PRC)) == NULL)
2408: {
2409: return(NULL);
2410: }
2411:
2412: (*((struct_processus_fils *) (*s_nouvel_objet).objet)) =
2413: (*((struct_processus_fils *) (*s_objet).objet));
2414: break;
2415: }
2416:
2417: case REL :
2418: {
2419: if (type != 'O')
2420: {
2421: incrementation_atomique(s_objet);
2422: return(s_objet);
2423: }
2424:
2425: if ((s_nouvel_objet = allocation(s_etat_processus, REL)) == NULL)
2426: {
2427: return(NULL);
2428: }
2429:
2430: (*((real8 *) ((*s_nouvel_objet).objet))) =
2431: (*((real8 *) ((*s_objet).objet)));
2432: break;
2433: }
2434:
2435: case SCK :
2436: {
2437: if (type == 'P')
2438: {
2439: incrementation_atomique(s_objet);
2440:
2441: if (((*((struct_socket *) ((*s_objet).objet)))
2442: .format = copie_objet(s_etat_processus,
2443: (*((struct_socket *) ((*s_objet).objet))).format, 'P'))
2444: == NULL)
2445: {
2446: return(NULL);
2447: }
2448:
2449: return(s_objet);
2450: }
2451:
2452: if ((s_nouvel_objet = allocation(s_etat_processus, SCK)) == NULL)
2453: {
2454: return(NULL);
2455: }
2456:
2457: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket =
2458: (*((struct_socket *) ((*s_objet).objet))).socket;
2459: (*((struct_socket *) ((*s_nouvel_objet).objet))).domaine =
2460: (*((struct_socket *) ((*s_objet).objet))).domaine;
2461: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_en_ecoute =
2462: (*((struct_socket *) ((*s_objet).objet))).socket_en_ecoute;
2463: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_connectee =
2464: (*((struct_socket *) ((*s_objet).objet))).socket_connectee;
2465: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2466: (*((struct_socket *) ((*s_objet).objet))).pid;
2467: (*((struct_socket *) ((*s_nouvel_objet).objet))).binaire =
2468: (*((struct_socket *) ((*s_objet).objet))).binaire;
2469: (*((struct_socket *) ((*s_nouvel_objet).objet))).effacement =
2470: (*((struct_socket *) ((*s_objet).objet))).effacement;
2471: (*((struct_socket *) ((*s_nouvel_objet).objet))).protection =
2472: (*((struct_socket *) ((*s_objet).objet))).protection;
2473: (*((struct_socket *) ((*s_nouvel_objet).objet))).localisation =
2474: (*((struct_socket *) ((*s_objet).objet))).localisation;
2475: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2476: (*((struct_socket *) ((*s_objet).objet))).pid;
2477: (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
2478: (*((struct_socket *) ((*s_objet).objet))).tid;
2479: (*((struct_socket *) ((*s_nouvel_objet).objet))).options =
2480: (*((struct_socket *) ((*s_objet).objet))).options;
2481: (*((struct_socket *) ((*s_nouvel_objet).objet))).priorite =
2482: (*((struct_socket *) ((*s_objet).objet))).priorite;
2483: (*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_reception =
2484: (*((struct_socket *) ((*s_objet).objet))).buffer_reception;
2485: (*((struct_socket *) ((*s_nouvel_objet).objet))).buffer_emission =
2486: (*((struct_socket *) ((*s_objet).objet))).buffer_emission;
2487: (*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_reception =
2488: (*((struct_socket *) ((*s_objet).objet))).timeout_reception;
2489: (*((struct_socket *) ((*s_nouvel_objet).objet))).timeout_emission =
2490: (*((struct_socket *) ((*s_objet).objet))).timeout_emission;
2491:
2492: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
2493: copie_objet(s_etat_processus, (*((struct_socket *)
2494: ((*s_objet).objet))).format, type)) == NULL)
2495: {
2496: free((*s_nouvel_objet).objet);
2497: free(s_nouvel_objet);
2498: return(NULL);
2499: }
2500:
2501: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).adresse =
2502: (unsigned char *) malloc((strlen((*((struct_socket *)
2503: ((*s_objet).objet))).adresse) + 1) * sizeof(unsigned char)))
2504: == NULL)
2505: {
2506: liberation(s_etat_processus, (*((struct_fichier *)
2507: (*s_nouvel_objet).objet)).format);
2508: free((*s_nouvel_objet).objet);
2509: free(s_nouvel_objet);
2510: return(NULL);
2511: }
2512:
2513: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2514: .adresse, (*((struct_socket *) ((*s_objet).objet)))
2515: .adresse);
2516:
2517: if (((*((struct_socket *) ((*s_nouvel_objet).objet)))
2518: .adresse_distante = malloc((strlen((*((struct_socket *)
2519: ((*s_objet).objet))).adresse_distante) + 1) *
2520: sizeof(unsigned char))) == NULL)
2521: {
2522: liberation(s_etat_processus, (*((struct_fichier *)
2523: (*s_nouvel_objet).objet)).format);
2524: free((*s_nouvel_objet).objet);
2525: free(s_nouvel_objet);
2526: return(NULL);
2527: }
2528:
2529: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2530: .adresse_distante, (*((struct_socket *) ((*s_objet).objet)))
2531: .adresse_distante);
2532:
2533: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))).type,
2534: (*((struct_socket *) ((*s_objet).objet))).type);
2535: break;
2536: }
2537:
2538: case SLB :
2539: {
2540: if (type != 'O')
2541: {
2542: incrementation_atomique(s_objet);
2543: return(s_objet);
2544: }
2545:
2546: if ((s_nouvel_objet = allocation(s_etat_processus, SLB)) == NULL)
2547: {
2548: return(NULL);
2549: }
2550:
2551: if (((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom =
2552: (unsigned char *) malloc((strlen((*((struct_bibliotheque *)
2553: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
2554: == NULL)
2555: {
2556: free((*s_nouvel_objet).objet);
2557: free(s_nouvel_objet);
2558: return(NULL);
2559: }
2560:
2561: strcpy((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom,
2562: (*((struct_bibliotheque *) ((*s_objet).objet))).nom);
2563:
2564: /*
2565: * C'est objet est non modifiable et est un pointeur
2566: * sur un objet système. Seul la référence est copiée.
2567: */
2568:
2569: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).descripteur =
2570: (*((struct_bibliotheque *) (*s_objet).objet)).descripteur;
2571: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).pid =
2572: (*((struct_bibliotheque *) (*s_objet).objet)).pid;
2573: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).tid =
2574: (*((struct_bibliotheque *) (*s_objet).objet)).tid;
2575: break;
2576: }
2577:
2578: case SPH :
2579: {
2580: if (type != 'O')
2581: {
2582: incrementation_atomique(s_objet);
2583: return(s_objet);
2584: }
2585:
2586: if ((s_nouvel_objet = allocation(s_etat_processus, SPH)) == NULL)
2587: {
2588: return(NULL);
2589: }
2590:
2591: if (((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom =
2592: malloc((strlen((*((struct_semaphore *) (*s_objet).objet))
2593: .nom) + 1) * sizeof(unsigned char))) == NULL)
2594: {
2595: free((*s_nouvel_objet).objet);
2596: free(s_nouvel_objet);
2597: return(NULL);
2598: }
2599:
2600: (*((struct_semaphore *) (*s_nouvel_objet).objet)).semaphore =
2601: (*((struct_semaphore *) (*s_objet).objet)).semaphore;
2602: strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom,
2603: (*((struct_semaphore *) (*s_objet).objet)).nom);
2604: break;
2605: }
2606:
2607: case SQL :
2608: {
2609: if (type != 'O')
2610: {
2611: incrementation_atomique(s_objet);
2612: return(s_objet);
2613: }
2614:
2615: if ((s_nouvel_objet = allocation(s_etat_processus, SQL)) == NULL)
2616: {
2617: return(NULL);
2618: }
2619:
2620: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).pid =
2621: (*((struct_connecteur_sql *) (*s_objet).objet)).pid;
2622: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).tid =
2623: (*((struct_connecteur_sql *) (*s_objet).objet)).tid;
2624: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).descripteur =
2625: (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur;
2626:
2627: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type =
2628: malloc((strlen((*((struct_connecteur_sql *)
2629: (*s_objet).objet)).type) + 1) * sizeof(unsigned char)))
2630: == NULL)
2631: {
2632: free(s_nouvel_objet);
2633: return(NULL);
2634: }
2635:
2636: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type,
2637: (*((struct_connecteur_sql *) (*s_objet).objet)).type);
2638:
2639: if ((*((struct_connecteur_sql *) (*s_objet).objet)).locale != NULL)
2640: {
2641: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2642: .locale = malloc((strlen((*((struct_connecteur_sql *)
2643: (*s_objet).objet)).locale) + 1) *
2644: sizeof(unsigned char))) == NULL)
2645: {
2646: free((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2647: .locale);
2648: free(s_nouvel_objet);
2649: return(NULL);
2650: }
2651:
2652: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2653: .locale, (*((struct_connecteur_sql *)
2654: (*s_objet).objet)).locale);
2655: }
2656: else
2657: {
2658: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).locale
2659: = NULL;
2660: }
2661:
2662: break;
2663: }
2664:
2665: case TBL :
2666: {
2667: if (type != 'P')
2668: {
2669: if ((s_nouvel_objet = allocation(s_etat_processus, TBL))
2670: == NULL)
2671: {
2672: return(NULL);
2673: }
2674:
2675: (*((struct_tableau *) (*s_nouvel_objet).objet))
2676: .nombre_elements = (*((struct_tableau *)
2677: (*s_objet).objet)).nombre_elements;
2678:
2679: if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
2680: malloc(((size_t) (*((struct_tableau *)
2681: (*s_objet).objet)).nombre_elements)
2682: * sizeof(struct_objet *))) == NULL)
2683: {
2684: return(NULL);
2685: }
2686:
2687: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2688: .nombre_elements; i++)
2689: {
2690: if (((*((struct_tableau *) (*s_nouvel_objet).objet))
2691: .elements[i] = copie_objet(s_etat_processus,
2692: (*((struct_tableau *) (*s_objet).objet))
2693: .elements[i], type)) == NULL)
2694: {
2695: for(j = 0; j < i; j++)
2696: {
2697: liberation(s_etat_processus, (*((struct_tableau *)
2698: (*s_nouvel_objet).objet)).elements[j]);
2699: }
2700:
2701: free((*((struct_tableau *) (*s_nouvel_objet).objet))
2702: .elements);
2703: free((*s_nouvel_objet).objet);
2704: free(s_nouvel_objet);
2705:
2706: return(NULL);
2707: }
2708: }
2709: }
2710: else
2711: {
2712: incrementation_atomique(s_objet);
2713:
2714: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2715: .nombre_elements; i++)
2716: {
2717: (*((struct_tableau *) (*s_objet).objet)).elements[i] =
2718: copie_objet(s_etat_processus, (*((struct_tableau *)
2719: (*s_objet).objet)).elements[i], 'P');
2720: }
2721:
2722: return(s_objet);
2723: }
2724:
2725: break;
2726: }
2727:
2728: case VIN :
2729: {
2730: if (type != 'O')
2731: {
2732: incrementation_atomique(s_objet);
2733: return(s_objet);
2734: }
2735:
2736: if ((s_nouvel_objet = allocation(s_etat_processus, VIN)) == NULL)
2737: {
2738: return(NULL);
2739: }
2740:
2741: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2742: ((integer8 *) malloc(((size_t)
2743: ((*((struct_vecteur *) ((*s_objet).objet))).taille))
2744: * sizeof(integer8)));
2745:
2746: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2747: == NULL)
2748: {
2749: free((*s_nouvel_objet).objet);
2750: free(s_nouvel_objet);
2751: return(NULL);
2752: }
2753:
2754: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2755: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2756: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2757: (*((struct_vecteur *) ((*s_objet).objet))).type;
2758:
2759: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2760: i++)
2761: {
2762: ((integer8 *) ((*((struct_vecteur *)
2763: ((*s_nouvel_objet).objet))).tableau))[i] =
2764: ((integer8 *) ((*((struct_vecteur *)
2765: ((*s_objet).objet))).tableau))[i];
2766: }
2767:
2768: break;
2769: }
2770:
2771: case VCX :
2772: {
2773: if (type != 'O')
2774: {
2775: incrementation_atomique(s_objet);
2776: return(s_objet);
2777: }
2778:
2779: if ((s_nouvel_objet = allocation(s_etat_processus, VCX)) == NULL)
2780: {
2781: return(NULL);
2782: }
2783:
2784: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2785: ((struct_complexe16 *) malloc(((size_t)
2786: ((*((struct_vecteur *) ((*s_objet).objet))).taille))
2787: * sizeof(struct_complexe16)));
2788:
2789: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2790: == NULL)
2791: {
2792: free((*s_nouvel_objet).objet);
2793: free(s_nouvel_objet);
2794: return(NULL);
2795: }
2796:
2797: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2798: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2799: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2800: (*((struct_vecteur *) ((*s_objet).objet))).type;
2801:
2802: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2803: i++)
2804: {
2805: ((struct_complexe16 *) ((*((struct_vecteur *)
2806: ((*s_nouvel_objet).objet))).tableau))[i] =
2807: ((struct_complexe16 *) ((*((struct_vecteur *)
2808: ((*s_objet).objet))).tableau))[i];
2809: }
2810:
2811: break;
2812: }
2813:
2814: case VRL :
2815: {
2816: if (type != 'O')
2817: {
2818: incrementation_atomique(s_objet);
2819: return(s_objet);
2820: }
2821:
2822: if ((s_nouvel_objet = allocation(s_etat_processus, VRL)) == NULL)
2823: {
2824: return(NULL);
2825: }
2826:
2827: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2828: ((real8 *) malloc(((size_t)
2829: ((*((struct_vecteur *) ((*s_objet).objet))).taille))
2830: * sizeof(real8)));
2831:
2832: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2833: == NULL)
2834: {
2835: free((*s_nouvel_objet).objet);
2836: free(s_nouvel_objet);
2837: return(NULL);
2838: }
2839:
2840: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2841: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2842: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2843: (*((struct_vecteur *) ((*s_objet).objet))).type;
2844:
2845: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2846: i++)
2847: {
2848: ((real8 *) ((*((struct_vecteur *)
2849: ((*s_nouvel_objet).objet))).tableau))[i] =
2850: ((real8 *) ((*((struct_vecteur *)
2851: ((*s_objet).objet))).tableau))[i];
2852: }
2853:
2854: break;
2855: }
2856:
2857: case EXT:
2858: {
2859: if (type != 'O')
2860: {
2861: incrementation_atomique(s_objet);
2862: return(s_objet);
2863: }
2864:
2865: // Appel de la fonction de duplication associée à l'objet
2866: // externe. Le descripteur de bibliothèque est directement
2867: // associé à la structure objet.
2868:
2869: if ((__type_dup = dlsym((*s_objet).descripteur_bibliotheque,
2870: "__type_dup")) == NULL)
2871: {
2872: // La fonction de duplication n'existe pas dans la
2873: // bibliothèque.
2874:
2875: (*s_etat_processus).erreur_execution = d_ex_type_externe_dup;
2876: return(NULL);
2877: }
2878:
2879: s_nouvel_objet = s_objet;
2880:
2881: if (__type_dup(s_etat_processus, (void **) &s_nouvel_objet) == 0)
2882: {
2883: return(NULL);
2884: }
2885:
2886: break;
2887: }
2888:
2889: default :
2890: {
2891: return(NULL);
2892: }
2893: }
2894:
2895: return(s_nouvel_objet);
2896:
2897: #undef return
2898: }
2899:
2900:
2901: /*
2902: ================================================================================
2903: Routine de copie d'une structure de description d'un processus
2904: ================================================================================
2905: Entrées : pointeur sur la structure de description d'un processus
2906: --------------------------------------------------------------------------------
2907: Sorties : structure identique (tous les objets sont copiés)
2908: --------------------------------------------------------------------------------
2909: Effets de bord : néant
2910: ================================================================================
2911: */
2912:
2913: struct_processus *
2914: copie_etat_processus(struct_processus *s_etat_processus)
2915: {
2916: pthread_mutexattr_t attributs_mutex;
2917:
2918: struct_liste_chainee *l_element_lecture;
2919: struct_liste_chainee *l_element_precedent;
2920: struct_liste_chainee *l_element_suivant;
2921:
2922: struct_processus *s_nouvel_etat_processus;
2923:
2924: integer8 i;
2925:
2926: if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus)) != 0)
2927: {
2928: (*s_etat_processus).erreur_systeme = d_es_processus;
2929: return(NULL);
2930: }
2931:
2932: if ((s_nouvel_etat_processus = sys_malloc(sizeof(struct_processus)))
2933: == NULL)
2934: {
2935: if (pthread_mutex_unlock(&((*s_etat_processus)
2936: .mutex_pile_processus)) != 0)
2937: {
2938: (*s_etat_processus).erreur_systeme = d_es_processus;
2939: return(NULL);
2940: }
2941:
2942: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2943: return(NULL);
2944: }
2945:
2946: (*s_nouvel_etat_processus) = (*s_etat_processus);
2947:
2948: // On réinitialise les allocateurs.
2949:
2950: pthread_mutexattr_init(&attributs_mutex);
2951: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
2952: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation_buffer),
2953: &attributs_mutex);
2954: pthread_mutexattr_destroy(&attributs_mutex);
2955:
2956: pthread_mutexattr_init(&attributs_mutex);
2957: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
2958: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_allocation),
2959: &attributs_mutex);
2960: pthread_mutexattr_destroy(&attributs_mutex);
2961:
2962: initialisation_allocateur(s_nouvel_etat_processus);
2963: initialisation_allocateur_buffer(s_nouvel_etat_processus);
2964:
2965: /*
2966: * (*s_etat_processus).definition_chainee,
2967: * (*s_etat_processus).nom_fichier_source,
2968: * (*s_etat_processus).nom_fichier_historique et
2969: * (*s_etat_processus).chemin_fichier_temporaires
2970: * n'ont aucune raison de changer.
2971: */
2972:
2973: (*s_nouvel_etat_processus).sections_critiques = 0;
2974: (*s_nouvel_etat_processus).initialisation_scheduler = d_faux;
2975:
2976: // Les sémaphores sont initialisés dans le nouveau thread. Il
2977: // s'agit d'une limitation de l'implantation de l'émulation
2978: // de sem_init().
2979:
2980: initialisation_contexte_cas(s_etat_processus);
2981:
2982: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
2983: (*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
2984: (*s_nouvel_etat_processus).fichiers_graphiques = NULL;
2985: (*s_nouvel_etat_processus).entree_standard = NULL;
2986: (*s_nouvel_etat_processus).s_marques = NULL;
2987: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai;
2988: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux;
2989: (*s_nouvel_etat_processus).nom_fichier_impression = NULL;
2990: (*s_nouvel_etat_processus).expression_courante = NULL;
2991: (*s_nouvel_etat_processus).objet_courant = NULL;
2992: (*s_nouvel_etat_processus).processus_detache = d_faux;
2993: (*s_nouvel_etat_processus).evaluation_forcee = 'N';
2994:
2995: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
2996: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
2997: (*s_nouvel_etat_processus).presence_fusible = d_faux;
2998: (*s_nouvel_etat_processus).thread_fusible = 0;
2999: (*s_nouvel_etat_processus).niveau_initial =
3000: (*s_etat_processus).niveau_courant;
3001: (*s_nouvel_etat_processus).presence_pipes = d_faux;
3002: (*s_nouvel_etat_processus).debug_programme = d_faux;
3003: (*s_nouvel_etat_processus).s_fichiers = NULL;
3004: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL;
3005:
3006: // On réinitialise toutes les interruptions.
3007:
3008: (*s_nouvel_etat_processus).traitement_interruption = 'N';
3009: (*s_nouvel_etat_processus).traitement_interruptible = 'Y';
3010: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
3011: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
3012:
3013: (*s_nouvel_etat_processus).at_exit = NULL;
3014: (*s_nouvel_etat_processus).at_poke = NULL;
3015: (*s_nouvel_etat_processus).traitement_at_poke = 'N';
3016:
3017: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
3018: {
3019: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
3020: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N';
3021: (*s_nouvel_etat_processus).queue_interruptions[i] = 0;
3022: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL;
3023: }
3024:
3025: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
3026: {
3027: if (((*s_nouvel_etat_processus).generateur_aleatoire =
3028: gsl_rng_clone((*s_etat_processus).generateur_aleatoire))
3029: == NULL)
3030: {
3031: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3032: return(NULL);
3033: }
3034:
3035: gsl_rng_set((*s_nouvel_etat_processus).generateur_aleatoire,
3036: gsl_rng_get((*s_etat_processus).generateur_aleatoire));
3037: }
3038:
3039: // Copie de la localisation
3040:
3041: if (((*s_nouvel_etat_processus).localisation = rpl_malloc(
3042: s_nouvel_etat_processus, (strlen((*s_etat_processus).localisation)
3043: + 1) * sizeof(unsigned char))) == NULL)
3044: {
3045: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3046: return(NULL);
3047: }
3048:
3049: strcpy((*s_nouvel_etat_processus).localisation,
3050: (*s_etat_processus).localisation);
3051:
3052: if ((*s_etat_processus).indep != NULL)
3053: {
3054: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
3055: (*s_etat_processus).indep, 'P')) == NULL)
3056: {
3057: if (pthread_mutex_unlock(&((*s_etat_processus)
3058: .mutex_pile_processus)) != 0)
3059: {
3060: (*s_etat_processus).erreur_systeme = d_es_processus;
3061: return(NULL);
3062: }
3063:
3064: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3065: return(NULL);
3066: }
3067: }
3068: else
3069: {
3070: (*s_nouvel_etat_processus).indep = NULL;
3071: }
3072:
3073: if ((*s_etat_processus).depend != NULL)
3074: {
3075: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
3076: (*s_etat_processus).depend, 'P')) == NULL)
3077: {
3078: if (pthread_mutex_unlock(&((*s_etat_processus)
3079: .mutex_pile_processus)) != 0)
3080: {
3081: (*s_etat_processus).erreur_systeme = d_es_processus;
3082: return(NULL);
3083: }
3084:
3085: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3086: return(NULL);
3087: }
3088: }
3089: else
3090: {
3091: (*s_nouvel_etat_processus).depend = NULL;
3092: }
3093:
3094: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL)
3095: {
3096: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau =
3097: copie_objet(s_etat_processus, (*s_etat_processus)
3098: .parametres_courbes_de_niveau, 'P')) == NULL)
3099: {
3100: if (pthread_mutex_unlock(&((*s_etat_processus)
3101: .mutex_pile_processus)) != 0)
3102: {
3103: (*s_etat_processus).erreur_systeme = d_es_processus;
3104: return(NULL);
3105: }
3106:
3107: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3108: return(NULL);
3109: }
3110: }
3111: else
3112: {
3113: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL;
3114: }
3115:
3116: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL;
3117:
3118: if (((*s_etat_processus).instruction_courante != NULL) &&
3119: (*s_etat_processus).evaluation_expression_compilee == 'N')
3120: {
3121: if (((*s_nouvel_etat_processus).instruction_courante = rpl_malloc(
3122: s_nouvel_etat_processus, (strlen(
3123: (*s_etat_processus).instruction_courante) + 1) *
3124: sizeof(unsigned char))) == NULL)
3125: {
3126: if (pthread_mutex_unlock(&((*s_etat_processus)
3127: .mutex_pile_processus)) != 0)
3128: {
3129: (*s_etat_processus).erreur_systeme = d_es_processus;
3130: return(NULL);
3131: }
3132:
3133: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3134: return(NULL);
3135: }
3136:
3137: strcpy((*s_nouvel_etat_processus).instruction_courante,
3138: (*s_etat_processus).instruction_courante);
3139: }
3140: else
3141: {
3142: (*s_nouvel_etat_processus).instruction_courante = NULL;
3143: }
3144:
3145: if ((*s_etat_processus).label_x != NULL)
3146: {
3147: if (((*s_nouvel_etat_processus).label_x = rpl_malloc(
3148: s_nouvel_etat_processus, (strlen(
3149: (*s_etat_processus).label_x) + 1) *
3150: sizeof(unsigned char))) == NULL)
3151: {
3152: if (pthread_mutex_unlock(&((*s_etat_processus)
3153: .mutex_pile_processus)) != 0)
3154: {
3155: (*s_etat_processus).erreur_systeme = d_es_processus;
3156: return(NULL);
3157: }
3158:
3159: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3160: return(NULL);
3161: }
3162:
3163: strcpy((*s_nouvel_etat_processus).label_x,
3164: (*s_etat_processus).label_x);
3165: }
3166: else
3167: {
3168: (*s_nouvel_etat_processus).label_x = NULL;
3169: }
3170:
3171: if ((*s_etat_processus).label_y != NULL)
3172: {
3173: if (((*s_nouvel_etat_processus).label_y = rpl_malloc(
3174: s_nouvel_etat_processus, (strlen((*s_etat_processus).label_y)
3175: + 1) * sizeof(unsigned char))) == NULL)
3176: {
3177: if (pthread_mutex_unlock(&((*s_etat_processus)
3178: .mutex_pile_processus)) != 0)
3179: {
3180: (*s_etat_processus).erreur_systeme = d_es_processus;
3181: return(NULL);
3182: }
3183:
3184: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3185: return(NULL);
3186: }
3187:
3188: strcpy((*s_nouvel_etat_processus).label_y,
3189: (*s_etat_processus).label_y);
3190: }
3191: else
3192: {
3193: (*s_nouvel_etat_processus).label_y = NULL;
3194: }
3195:
3196: if ((*s_etat_processus).label_z != NULL)
3197: {
3198: if (((*s_nouvel_etat_processus).label_z = rpl_malloc(
3199: s_nouvel_etat_processus, (strlen((*s_etat_processus).label_z)
3200: + 1) * sizeof(unsigned char))) == NULL)
3201: {
3202: if (pthread_mutex_unlock(&((*s_etat_processus)
3203: .mutex_pile_processus)) != 0)
3204: {
3205: (*s_etat_processus).erreur_systeme = d_es_processus;
3206: return(NULL);
3207: }
3208:
3209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3210: return(NULL);
3211: }
3212:
3213: strcpy((*s_nouvel_etat_processus).label_z,
3214: (*s_etat_processus).label_z);
3215: }
3216: else
3217: {
3218: (*s_nouvel_etat_processus).label_z = NULL;
3219: }
3220:
3221: if ((*s_etat_processus).titre != NULL)
3222: {
3223: if (((*s_nouvel_etat_processus).titre = rpl_malloc(
3224: s_nouvel_etat_processus, (strlen((*s_etat_processus).titre) + 1)
3225: * sizeof(unsigned char))) == NULL)
3226: {
3227: if (pthread_mutex_unlock(&((*s_etat_processus)
3228: .mutex_pile_processus)) != 0)
3229: {
3230: (*s_etat_processus).erreur_systeme = d_es_processus;
3231: return(NULL);
3232: }
3233:
3234: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3235: return(NULL);
3236: }
3237:
3238: strcpy((*s_nouvel_etat_processus).titre,
3239: (*s_etat_processus).titre);
3240: }
3241: else
3242: {
3243: (*s_nouvel_etat_processus).titre = NULL;
3244: }
3245:
3246: if ((*s_etat_processus).legende != NULL)
3247: {
3248: if (((*s_nouvel_etat_processus).legende = rpl_malloc(
3249: s_nouvel_etat_processus, (strlen((*s_etat_processus).legende)
3250: + 1) * sizeof(unsigned char))) == NULL)
3251: {
3252: if (pthread_mutex_unlock(&((*s_etat_processus)
3253: .mutex_pile_processus)) != 0)
3254: {
3255: (*s_etat_processus).erreur_systeme = d_es_processus;
3256: return(NULL);
3257: }
3258:
3259: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3260: return(NULL);
3261: }
3262:
3263: strcpy((*s_nouvel_etat_processus).legende,
3264: (*s_etat_processus).legende);
3265: }
3266: else
3267: {
3268: (*s_nouvel_etat_processus).legende = NULL;
3269: }
3270:
3271: /*
3272: * Copie de la table des variables
3273: */
3274:
3275: (*s_nouvel_etat_processus).l_liste_variables_statiques = NULL;
3276: copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
3277:
3278: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3279: {
3280: return(NULL);
3281: }
3282:
3283: (*(*s_nouvel_etat_processus).l_liste_variables_partagees) =
3284: (*(*s_etat_processus).l_liste_variables_partagees);
3285: (*(*s_nouvel_etat_processus).s_arbre_variables_partagees) =
3286: (*(*s_etat_processus).s_arbre_variables_partagees);
3287:
3288: /*
3289: * Copie de la pile opérationnelle
3290: */
3291:
3292: (*s_nouvel_etat_processus).l_base_pile = NULL;
3293: l_element_lecture = (*s_etat_processus).l_base_pile;
3294: l_element_precedent = NULL;
3295:
3296: while(l_element_lecture != NULL)
3297: {
3298: if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
3299: sizeof(struct_liste_chainee))) == NULL)
3300: {
3301: if (pthread_mutex_unlock(&((*s_etat_processus)
3302: .mutex_pile_processus)) != 0)
3303: {
3304: (*s_etat_processus).erreur_systeme = d_es_processus;
3305: return(NULL);
3306: }
3307:
3308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3309: return(NULL);
3310: }
3311:
3312: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3313: (*l_element_lecture).donnee, 'P')) == NULL)
3314: {
3315: if (pthread_mutex_unlock(&((*s_etat_processus)
3316: .mutex_pile_processus)) != 0)
3317: {
3318: (*s_etat_processus).erreur_systeme = d_es_processus;
3319: return(NULL);
3320: }
3321:
3322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3323: return(NULL);
3324: }
3325:
3326: (*l_element_suivant).suivant = NULL;
3327:
3328: if ((*s_nouvel_etat_processus).l_base_pile == NULL)
3329: {
3330: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant;
3331: }
3332: else
3333: {
3334: (*l_element_precedent).suivant = l_element_suivant;
3335: }
3336:
3337: l_element_precedent = l_element_suivant;
3338: l_element_lecture = (*l_element_lecture).suivant;
3339: }
3340:
3341: /*
3342: * Copie de la pile système
3343: */
3344:
3345: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL;
3346: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0;
3347:
3348: empilement_pile_systeme(s_nouvel_etat_processus);
3349:
3350: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3351: {
3352: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
3353: != 0)
3354: {
3355: (*s_etat_processus).erreur_systeme = d_es_processus;
3356: return(NULL);
3357: }
3358:
3359: (*s_etat_processus).erreur_systeme =
3360: (*s_nouvel_etat_processus).erreur_systeme;
3361: return(NULL);
3362: }
3363:
3364: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3365:
3366: /*
3367: * On empile deux valeurs retour_definition pour pouvoir récupérer
3368: * les variables dans le cas d'un programme compilé.
3369: */
3370:
3371: empilement_pile_systeme(s_nouvel_etat_processus);
3372:
3373: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3374: {
3375: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
3376: != 0)
3377: {
3378: (*s_etat_processus).erreur_systeme = d_es_processus;
3379: return(NULL);
3380: }
3381:
3382: (*s_etat_processus).erreur_systeme =
3383: (*s_nouvel_etat_processus).erreur_systeme;
3384: return(NULL);
3385: }
3386:
3387: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3388:
3389: /*
3390: * Destruction de la pile last pour le thread en cours.
3391: */
3392:
3393: (*s_nouvel_etat_processus).l_base_pile_last = NULL;
3394: (*s_nouvel_etat_processus).l_base_pile_processus = NULL;
3395:
3396: /*
3397: * Copie des différents contextes
3398: */
3399:
3400: (*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
3401: (*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;
3402:
3403: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
3404: l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
3405:
3406: while(l_element_lecture != NULL)
3407: {
3408: if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
3409: sizeof(struct_liste_chainee))) == NULL)
3410: {
3411: if (pthread_mutex_unlock(&((*s_etat_processus)
3412: .mutex_pile_processus)) != 0)
3413: {
3414: (*s_etat_processus).erreur_systeme = d_es_processus;
3415: return(NULL);
3416: }
3417:
3418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3419: return(NULL);
3420: }
3421:
3422: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3423: (*l_element_lecture).donnee, 'P')) == NULL)
3424: {
3425: if (pthread_mutex_unlock(&((*s_etat_processus)
3426: .mutex_pile_processus)) != 0)
3427: {
3428: (*s_etat_processus).erreur_systeme = d_es_processus;
3429: return(NULL);
3430: }
3431:
3432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3433: return(NULL);
3434: }
3435:
3436: (*l_element_suivant).suivant = NULL;
3437:
3438: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL)
3439: {
3440: (*s_nouvel_etat_processus).l_base_pile_contextes =
3441: l_element_suivant;
3442: }
3443: else
3444: {
3445: (*l_element_precedent).suivant = l_element_suivant;
3446: }
3447:
3448: l_element_precedent = l_element_suivant;
3449: l_element_lecture = (*l_element_lecture).suivant;
3450: }
3451:
3452: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL;
3453: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes;
3454:
3455: while(l_element_lecture != NULL)
3456: {
3457: if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
3458: sizeof(struct_liste_chainee))) == NULL)
3459: {
3460: if (pthread_mutex_unlock(&((*s_etat_processus)
3461: .mutex_pile_processus)) != 0)
3462: {
3463: (*s_etat_processus).erreur_systeme = d_es_processus;
3464: return(NULL);
3465: }
3466:
3467: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3468: return(NULL);
3469: }
3470:
3471: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3472: (*l_element_lecture).donnee, 'P')) == NULL)
3473: {
3474: if (pthread_mutex_unlock(&((*s_etat_processus)
3475: .mutex_pile_processus)) != 0)
3476: {
3477: (*s_etat_processus).erreur_systeme = d_es_processus;
3478: return(NULL);
3479: }
3480:
3481: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3482: return(NULL);
3483: }
3484:
3485: (*l_element_suivant).suivant = NULL;
3486:
3487: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL)
3488: {
3489: (*s_nouvel_etat_processus).l_base_pile_taille_contextes =
3490: l_element_suivant;
3491: }
3492: else
3493: {
3494: (*l_element_precedent).suivant = l_element_suivant;
3495: }
3496:
3497: l_element_precedent = l_element_suivant;
3498: l_element_lecture = (*l_element_lecture).suivant;
3499: }
3500:
3501: /*
3502: * Copies des piles s_sockets, s_bibliotheques et
3503: * s_instructions_externes.
3504: */
3505:
3506: (*s_nouvel_etat_processus).s_sockets = NULL;
3507: l_element_lecture = (*s_etat_processus).s_sockets;
3508:
3509: while(l_element_lecture != NULL)
3510: {
3511: if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
3512: sizeof(struct_liste_chainee))) == NULL)
3513: {
3514: if (pthread_mutex_unlock(&((*s_etat_processus)
3515: .mutex_pile_processus)) != 0)
3516: {
3517: (*s_etat_processus).erreur_systeme = d_es_processus;
3518: return(NULL);
3519: }
3520:
3521: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3522: return(NULL);
3523: }
3524:
3525: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3526: (*l_element_lecture).donnee, 'P')) == NULL)
3527: {
3528: if (pthread_mutex_unlock(&((*s_etat_processus)
3529: .mutex_pile_processus)) != 0)
3530: {
3531: (*s_etat_processus).erreur_systeme = d_es_processus;
3532: return(NULL);
3533: }
3534:
3535: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3536: return(NULL);
3537: }
3538:
3539: (*l_element_suivant).suivant = NULL;
3540:
3541: if ((*s_nouvel_etat_processus).s_sockets == NULL)
3542: {
3543: (*s_nouvel_etat_processus).s_sockets = l_element_suivant;
3544: }
3545: else
3546: {
3547: (*l_element_precedent).suivant = l_element_suivant;
3548: }
3549:
3550: l_element_precedent = l_element_suivant;
3551: l_element_lecture = (*l_element_lecture).suivant;
3552: }
3553:
3554: (*s_nouvel_etat_processus).s_bibliotheques = NULL;
3555: l_element_precedent = NULL;
3556: l_element_lecture = (*s_etat_processus).s_bibliotheques;
3557:
3558: while(l_element_lecture != NULL)
3559: {
3560: if ((l_element_suivant = rpl_malloc(s_nouvel_etat_processus,
3561: sizeof(struct_liste_chainee))) == NULL)
3562: {
3563: if (pthread_mutex_unlock(&((*s_etat_processus)
3564: .mutex_pile_processus)) != 0)
3565: {
3566: (*s_etat_processus).erreur_systeme = d_es_processus;
3567: return(NULL);
3568: }
3569:
3570: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3571: return(NULL);
3572: }
3573:
3574: if (((*l_element_suivant).donnee = rpl_malloc(s_nouvel_etat_processus,
3575: sizeof(struct_bibliotheque))) == NULL)
3576: {
3577: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3578: return(NULL);
3579: }
3580:
3581: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur
3582: = (*((struct_bibliotheque *) (*l_element_lecture).donnee))
3583: .descripteur;
3584: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid
3585: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid;
3586: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid
3587: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
3588:
3589: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
3590: rpl_malloc(s_nouvel_etat_processus,
3591: (strlen((*((struct_bibliotheque *) (*l_element_lecture)
3592: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
3593: {
3594: if (pthread_mutex_unlock(&((*s_etat_processus)
3595: .mutex_pile_processus)) != 0)
3596: {
3597: (*s_etat_processus).erreur_systeme = d_es_processus;
3598: return(NULL);
3599: }
3600:
3601: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3602: return(NULL);
3603: }
3604:
3605: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom,
3606: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom);
3607:
3608: (*l_element_suivant).suivant = NULL;
3609:
3610: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL)
3611: {
3612: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant;
3613: }
3614: else
3615: {
3616: (*l_element_precedent).suivant = l_element_suivant;
3617: }
3618:
3619: l_element_precedent = l_element_suivant;
3620: l_element_lecture = (*l_element_lecture).suivant;
3621: }
3622:
3623: if ((*s_etat_processus).nombre_instructions_externes != 0)
3624: {
3625: if (((*s_nouvel_etat_processus).s_instructions_externes =
3626: rpl_malloc(s_nouvel_etat_processus, ((size_t)
3627: (*s_etat_processus).nombre_instructions_externes) *
3628: sizeof(struct_instruction_externe))) == NULL)
3629: {
3630: (*s_etat_processus).erreur_systeme = d_es_processus;
3631: return(NULL);
3632: }
3633:
3634: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
3635: {
3636: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
3637: rpl_malloc(s_nouvel_etat_processus,
3638: (strlen((*s_etat_processus).s_instructions_externes
3639: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3640: {
3641: (*s_etat_processus).erreur_systeme = d_es_processus;
3642: return(NULL);
3643: }
3644:
3645: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom,
3646: (*s_etat_processus).s_instructions_externes[i].nom);
3647:
3648: if (((*s_nouvel_etat_processus).s_instructions_externes[i]
3649: .nom_bibliotheque = rpl_malloc(s_nouvel_etat_processus,
3650: (strlen((*s_etat_processus).s_instructions_externes[i]
3651: .nom_bibliotheque) + 1) * sizeof(unsigned char))) == NULL)
3652: {
3653: (*s_etat_processus).erreur_systeme = d_es_processus;
3654: return(NULL);
3655: }
3656:
3657: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i]
3658: .nom_bibliotheque, (*s_etat_processus)
3659: .s_instructions_externes[i].nom_bibliotheque);
3660:
3661: (*s_nouvel_etat_processus).s_instructions_externes[i]
3662: .descripteur_bibliotheque = (*s_etat_processus)
3663: .s_instructions_externes[i].descripteur_bibliotheque;
3664: }
3665: }
3666: else
3667: {
3668: (*s_nouvel_etat_processus).s_instructions_externes = NULL;
3669: }
3670:
3671: pthread_mutexattr_init(&attributs_mutex);
3672: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3673: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_pile_processus),
3674: &attributs_mutex);
3675: pthread_mutexattr_destroy(&attributs_mutex);
3676:
3677: pthread_mutexattr_init(&attributs_mutex);
3678: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3679: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_interruptions),
3680: &attributs_mutex);
3681: pthread_mutexattr_destroy(&attributs_mutex);
3682:
3683: pthread_mutexattr_init(&attributs_mutex);
3684: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3685: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex_signaux),
3686: &attributs_mutex);
3687: pthread_mutexattr_destroy(&attributs_mutex);
3688:
3689: pthread_mutexattr_init(&attributs_mutex);
3690: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3691: pthread_mutex_init(&((*s_nouvel_etat_processus).protection_liste_mutexes),
3692: &attributs_mutex);
3693: pthread_mutexattr_destroy(&attributs_mutex);
3694:
3695: if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus)) != 0)
3696: {
3697: (*s_etat_processus).erreur_systeme = d_es_processus;
3698: return(NULL);
3699: }
3700:
3701: return(s_nouvel_etat_processus);
3702:
3703: #undef return
3704: }
3705:
3706:
3707: /*
3708: ================================================================================
3709: Routines de debug
3710: ================================================================================
3711: entrées :
3712: --------------------------------------------------------------------------------
3713: sorties :
3714: --------------------------------------------------------------------------------
3715: effets de bord : néant
3716: ================================================================================
3717: */
3718:
3719: #ifdef DEBUG_MEMOIRE
3720:
3721: #undef malloc
3722: #undef realloc
3723: #undef free
3724: #undef fork
3725:
3726: #ifdef return
3727: # undef return
3728: #endif
3729:
3730: #ifdef __BACKTRACE
3731: #define PROFONDEUR_PILE 64
3732: #define return(a) { if (a == NULL) \
3733: { BACKTRACE(PROFONDEUR_PILE); \
3734: fprintf(stderr, ">>> MEDITATION %d\n", __LINE__); } \
3735: return(a); } while(0)
3736: #endif
3737:
3738: #undef fprintf
3739: #define check(a, b) ((strcmp(#a, fonction) == 0) && (ligne == b))
3740: #undef CORE_DUMP
3741:
3742: typedef struct memoire
3743: {
3744: void *pointeur;
3745: unsigned char *fonction;
3746: unsigned char *argument;
3747: unsigned long ligne;
3748: size_t taille;
3749: unsigned long long ordre;
3750: # ifdef __BACKTRACE
3751: void *pile[PROFONDEUR_PILE];
3752: int profondeur;
3753: # endif
3754: struct memoire *suivant;
3755: } struct_memoire;
3756:
3757: static struct_memoire *debug = NULL;
3758: static unsigned long long ordre = 0;
3759: static pthread_mutex_t mutex_allocation;
3760:
3761: void
3762: debug_memoire_initialisation()
3763: {
3764: pthread_mutexattr_t attributs_mutex;
3765:
3766: pthread_mutexattr_init(&attributs_mutex);
3767: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
3768: pthread_mutex_init(&mutex_allocation, &attributs_mutex);
3769: pthread_mutexattr_destroy(&attributs_mutex);
3770:
3771: return;
3772: }
3773:
3774: void *
3775: debug_memoire_ajout(size_t taille, const unsigned char *fonction,
3776: unsigned long ligne, const unsigned char *argument)
3777: {
3778: struct_memoire *ancienne_base;
3779:
3780: void *pointeur;
3781:
3782: pthread_mutex_lock(&mutex_allocation);
3783:
3784: ancienne_base = debug;
3785:
3786: if ((debug = malloc(sizeof(struct_memoire))) == NULL)
3787: {
3788: pthread_mutex_unlock(&mutex_allocation);
3789: return(NULL);
3790: }
3791:
3792: if (((*debug).pointeur = malloc(taille)) == NULL)
3793: {
3794: pthread_mutex_unlock(&mutex_allocation);
3795: return(NULL);
3796: }
3797:
3798: (*debug).suivant = ancienne_base;
3799: (*debug).ligne = ligne;
3800: (*debug).taille = taille;
3801: (*debug).ordre = ordre;
3802:
3803: pointeur = (*debug).pointeur;
3804:
3805: # ifdef __BACKTRACE
3806: (*debug).profondeur = backtrace((*debug).pile, PROFONDEUR_PILE);
3807: # endif
3808:
3809: if (((*debug).fonction = malloc((strlen(fonction) + 1) *
3810: sizeof(unsigned char))) == NULL)
3811: {
3812: pthread_mutex_unlock(&mutex_allocation);
3813: return(NULL);
3814: }
3815:
3816: if (((*debug).argument = malloc((strlen(argument) + 1) *
3817: sizeof(unsigned char))) == NULL)
3818: {
3819: pthread_mutex_unlock(&mutex_allocation);
3820: return(NULL);
3821: }
3822:
3823: strcpy((*debug).fonction, fonction);
3824: strcpy((*debug).argument, argument);
3825:
3826: memset((*debug).pointeur, 0, (*debug).taille);
3827:
3828: pthread_mutex_unlock(&mutex_allocation);
3829: ordre++;
3830:
3831: return(pointeur);
3832: }
3833:
3834: void *
3835: debug_memoire_modification(void *pointeur, size_t taille,
3836: const unsigned char *fonction, unsigned long ligne,
3837: const unsigned char *argument)
3838: {
3839: struct_memoire *element_courant;
3840:
3841: if (pointeur != NULL)
3842: {
3843: if (taille == 0)
3844: {
3845: // Revient à free(). Il n'y a pas de parenthèses car on ne veut
3846: // pas utiliser la macro return().
3847:
3848: debug_memoire_retrait(pointeur);
3849: return NULL ;
3850: }
3851: else
3852: {
3853: // Réallocation réelle
3854:
3855: pthread_mutex_lock(&mutex_allocation);
3856:
3857: element_courant = debug;
3858:
3859: while(element_courant != NULL)
3860: {
3861: if ((*element_courant).pointeur == pointeur)
3862: {
3863: break;
3864: }
3865:
3866: element_courant = (*element_courant).suivant;
3867: }
3868:
3869: if (element_courant == NULL)
3870: {
3871: pthread_mutex_unlock(&mutex_allocation);
3872:
3873: uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
3874: getpid(), (unsigned long long) pthread_self());
3875: # ifdef __BACKTRACE
3876: BACKTRACE(PROFONDEUR_PILE);
3877: # endif
3878:
3879: return(realloc(pointeur, taille));
3880: }
3881: else
3882: {
3883: if (((*element_courant).pointeur = realloc(pointeur, taille))
3884: == NULL)
3885: {
3886: pthread_mutex_unlock(&mutex_allocation);
3887: return(NULL);
3888: }
3889:
3890: (*element_courant).ligne = ligne;
3891: (*element_courant).taille = taille;
3892: free((*element_courant).fonction);
3893: free((*element_courant).argument);
3894:
3895: if (((*element_courant).fonction = malloc((strlen(fonction)
3896: + 1) * sizeof(unsigned char))) == NULL)
3897: {
3898: pthread_mutex_unlock(&mutex_allocation);
3899: return(NULL);
3900: }
3901:
3902: if (((*element_courant).argument = malloc((strlen(argument)
3903: + 1) * sizeof(unsigned char))) == NULL)
3904: {
3905: pthread_mutex_unlock(&mutex_allocation);
3906: return(NULL);
3907: }
3908:
3909: strcpy((*element_courant).fonction, fonction);
3910: strcpy((*element_courant).argument, argument);
3911:
3912: pthread_mutex_unlock(&mutex_allocation);
3913:
3914: return((*element_courant).pointeur);
3915: }
3916: }
3917: }
3918: else
3919: {
3920: // Revient à malloc()
3921: pointeur = debug_memoire_ajout(taille, fonction, ligne, argument);
3922: return(pointeur);
3923: }
3924: }
3925:
3926: void
3927: debug_memoire_retrait(void *pointeur)
3928: {
3929: struct_memoire *element_courant;
3930: struct_memoire *element_precedent;
3931:
3932: pthread_mutex_lock(&mutex_allocation);
3933:
3934: element_courant = debug;
3935: element_precedent = NULL;
3936:
3937: while(element_courant != NULL)
3938: {
3939: if ((*element_courant).pointeur == pointeur)
3940: {
3941: if (element_precedent == NULL)
3942: {
3943: debug = (*debug).suivant;
3944: }
3945: else
3946: {
3947: (*element_precedent).suivant = (*element_courant).suivant;
3948: }
3949:
3950: if (pointeur != NULL)
3951: {
3952: memset(pointeur, 0, (*element_courant).taille);
3953: }
3954:
3955: free((*element_courant).fonction);
3956: free((*element_courant).argument);
3957: free(element_courant);
3958:
3959: break;
3960: }
3961:
3962: element_precedent = element_courant;
3963: element_courant = (*element_courant).suivant;
3964: }
3965:
3966: pthread_mutex_unlock(&mutex_allocation);
3967:
3968: if (element_courant == NULL)
3969: {
3970: uprintf("[%d-%llu] ILLEGAL POINTER (free)\n",
3971: getpid(), (unsigned long long) pthread_self());
3972: # ifdef __BACKTRACE
3973: BACKTRACE(PROFONDEUR_PILE);
3974: # endif
3975: }
3976:
3977: free(pointeur);
3978: return;
3979: }
3980:
3981: void
3982: debug_memoire_verification()
3983: {
3984: # ifdef __BACKTRACE
3985: char **appels;
3986:
3987: int j;
3988: # endif
3989:
3990: integer8 i;
3991:
3992: struct_memoire *element_courant;
3993: struct_memoire *element_suivant;
3994:
3995: fprintf(stderr, "[%d-%llu] LIST OF MEMORY LEAKS\n",
3996: getpid(), (unsigned long long) pthread_self());
3997:
3998: pthread_mutex_lock(&mutex_allocation);
3999:
4000: element_courant = debug;
4001: i = 1;
4002:
4003: while(element_courant != NULL)
4004: {
4005: fprintf(stderr, "[%d-%llu] MEDITATION %lld (%llu)\n", getpid(),
4006: (unsigned long long) pthread_self(), i,
4007: (*element_courant).ordre);
4008: fprintf(stderr, "[%d-%llu] P: %p, F: %s(), L: %lu, S: %d\n",
4009: getpid(), (unsigned long long) pthread_self(),
4010: (*element_courant).pointeur,
4011: (*element_courant).fonction, (*element_courant).ligne,
4012: (int) (*element_courant).taille);
4013: fprintf(stderr, "[%d-%llu] A: %s\n", getpid(),
4014: (unsigned long long) pthread_self(),
4015: (*element_courant).argument);
4016:
4017: if (strstr((*element_courant).argument, "sizeof(unsigned char)")
4018: != NULL)
4019: {
4020: fprintf(stderr, "[%d-%llu] ", getpid(),
4021: (unsigned long long) pthread_self());
4022: fprintf(stderr, "O: %s\n", (unsigned char *)
4023: (*element_courant).pointeur);
4024: }
4025: else if (strcmp((*element_courant).argument, "sizeof(struct_objet)")
4026: == 0)
4027: {
4028: fprintf(stderr, "[%d-%llu] ", getpid(),
4029: (unsigned long long) pthread_self());
4030: fprintf(stderr, "O: %d\n", (*((struct_objet *)
4031: (*element_courant).pointeur)).type);
4032: }
4033: else if (strcmp((*element_courant).argument,
4034: "sizeof(struct_liste_chainee)") == 0)
4035: {
4036: fprintf(stderr, "[%d-%llu] ", getpid(),
4037: (unsigned long long) pthread_self());
4038: fprintf(stderr, "O: data=%p next=%p\n", (*((struct_liste_chainee *)
4039: (*element_courant).pointeur)).donnee,
4040: (*((struct_liste_chainee *) (*element_courant).pointeur))
4041: .suivant);
4042: }
4043:
4044: # ifdef __BACKTRACE
4045: appels = backtrace_symbols((*element_courant).pile,
4046: (*element_courant).profondeur);
4047:
4048: fprintf(stderr, "[%d-%llu] BACKTRACE\n",
4049: getpid(), (unsigned long long) pthread_self());
4050:
4051: if (appels != NULL)
4052: {
4053: for(j = 0; j < (*element_courant).profondeur; j++)
4054: {
4055: fprintf(stderr, "[%d-%llu] %s\n", getpid(),
4056: (unsigned long long) pthread_self(), appels[j]);
4057: }
4058:
4059: free(appels);
4060: }
4061: # endif
4062:
4063: fprintf(stderr, "\n");
4064:
4065: i++;
4066:
4067: element_suivant = (*element_courant).suivant;
4068:
4069: # ifndef CORE_DUMP
4070: free((*element_courant).fonction);
4071: free((*element_courant).argument);
4072: free(element_courant);
4073: # endif
4074:
4075: element_courant = element_suivant;
4076: }
4077:
4078: pthread_mutex_unlock(&mutex_allocation);
4079: pthread_mutex_destroy(&mutex_allocation);
4080:
4081: fprintf(stderr, "[%d-%llu] END OF LIST\n", getpid(),
4082: (unsigned long long) pthread_self());
4083:
4084: return;
4085: }
4086:
4087: pid_t
4088: debug_fork()
4089: {
4090: pid_t pid;
4091:
4092: pthread_mutex_lock(&mutex_allocation);
4093: pid = fork();
4094:
4095: if (pid == 0)
4096: {
4097: liberation_queue_signaux(s_etat_processus);
4098: creation_queue_signaux(s_etat_processus);
4099:
4100: pthread_mutex_destroy(&mutex_allocation);
4101: debug_memoire_initialisation();
4102: }
4103: else
4104: {
4105: pthread_mutex_unlock(&mutex_allocation);
4106: }
4107:
4108: // Pas de parenthèses pour ne pas remplacer return par sa macro.
4109: return pid;
4110: }
4111:
4112: void
4113: analyse_post_mortem()
4114: {
4115: # ifdef CORE_DUMP
4116: BUG(debug != NULL, uprintf("[%d-%llu] CREATE CORE DUMP FILE FOR "
4117: "POST MORTEM ANALYZE\n", getpid(),
4118: (unsigned long long) pthread_self()));
4119: # endif
4120:
4121: return;
4122: }
4123:
4124: #endif
4125:
4126: // 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