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