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