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