![[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: ================================================================================
3: RPL/2 (R) version 4.0.9
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: ================================================================================
28: Routine de gestion du nombre d'occurrences comme grandeur atomique
29: ================================================================================
30: entrées : structure sur l'état du processus et objet à afficher
31: --------------------------------------------------------------------------------
32: sorties : chaine de caractères
33: --------------------------------------------------------------------------------
34: effets de bord : néant
35: ================================================================================
36: */
37:
38: static inline void
39: incrementation_atomique(struct_objet *s_objet)
40: {
41: // Le mutex est sur l'objet.
42:
43: (*s_objet).nombre_occurrences++;
44:
45: BUG((*s_objet).nombre_occurrences <= 0,
46: uprintf("Capacity exceeded %ld\n", (*s_objet).nombre_occurrences));
47:
48: return;
49: }
50:
51: static inline long
52: decrementation_atomique(struct_objet *s_objet)
53: {
54: // Le mutex est sur l'objet.
55:
56: (*s_objet).nombre_occurrences--;
57: return((*s_objet).nombre_occurrences);
58: }
59:
60: 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:
406: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
407: break;
408: }
409:
410: case INT :
411: {
412: if ((*s_etat_processus).pointeur_int > 0)
413: {
414: (*s_objet).objet = (*s_etat_processus).objets_int
415: [--(*s_etat_processus).pointeur_int];
416: }
417: else
418: {
419: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
420: {
421: free(s_objet);
422: return(NULL);
423: }
424: }
425:
426: break;
427: }
428:
429: case LST :
430: {
431: (*s_objet).objet = NULL;
432: break;
433: }
434:
435: case MCX :
436: {
437: if ((*s_etat_processus).pointeur_mat > 0)
438: {
439: (*s_objet).objet = (*s_etat_processus).objets_mat
440: [--(*s_etat_processus).pointeur_mat];
441: }
442: else
443: {
444: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
445: {
446: free(s_objet);
447: return(NULL);
448: }
449: }
450:
451: (*((struct_matrice *) (*s_objet).objet)).type = 'C';
452: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
453: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
454: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
455: break;
456: }
457:
458: case MIN :
459: {
460: if ((*s_etat_processus).pointeur_mat > 0)
461: {
462: (*s_objet).objet = (*s_etat_processus).objets_mat
463: [--(*s_etat_processus).pointeur_mat];
464: }
465: else
466: {
467: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
468: {
469: free(s_objet);
470: return(NULL);
471: }
472: }
473:
474: (*((struct_matrice *) (*s_objet).objet)).type = 'I';
475: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
476: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
477: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
478: break;
479: }
480:
481: case MRL :
482: {
483: if ((*s_etat_processus).pointeur_mat > 0)
484: {
485: (*s_objet).objet = (*s_etat_processus).objets_mat
486: [--(*s_etat_processus).pointeur_mat];
487: }
488: else
489: {
490: if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
491: {
492: free(s_objet);
493: return(NULL);
494: }
495: }
496:
497: (*((struct_matrice *) (*s_objet).objet)).type = 'R';
498: (*((struct_matrice *) (*s_objet).objet)).nombre_lignes = 0;
499: (*((struct_matrice *) (*s_objet).objet)).nombre_colonnes = 0;
500: (*((struct_matrice *) (*s_objet).objet)).tableau = NULL;
501: break;
502: }
503:
504: case MTX :
505: {
506: if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
507: {
508: free(s_objet);
509: return(NULL);
510: }
511:
512: break;
513: }
514:
515: case NOM :
516: {
517: if ((*s_etat_processus).pointeur_nom > 0)
518: {
519: (*s_objet).objet = (*s_etat_processus).objets_nom
520: [--(*s_etat_processus).pointeur_nom];
521: }
522: else
523: {
524: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
525: {
526: free(s_objet);
527: return(NULL);
528: }
529: }
530:
531: break;
532: }
533:
534: case NON :
535: {
536: (*s_objet).objet = NULL;
537: break;
538: }
539:
540: case PRC :
541: {
542: if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
543: == NULL)
544: {
545: free(s_objet);
546: return(NULL);
547: }
548:
549: break;
550: }
551:
552: case REL :
553: {
554: if ((*s_etat_processus).pointeur_rel > 0)
555: {
556: (*s_objet).objet = (*s_etat_processus).objets_rel
557: [--(*s_etat_processus).pointeur_rel];
558: }
559: else
560: {
561: if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
562: {
563: free(s_objet);
564: return(NULL);
565: }
566: }
567:
568: break;
569: }
570:
571: case RPN :
572: {
573: (*s_objet).objet = NULL;
574: break;
575: }
576:
577: case SCK :
578: {
579: if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
580: {
581: free(s_objet);
582: return(NULL);
583: }
584:
585: break;
586: }
587:
588: case SLB :
589: {
590: if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
591: == NULL)
592: {
593: free(s_objet);
594: return(NULL);
595: }
596:
597: break;
598: }
599:
600: case SPH :
601: {
602: if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
603: {
604: free(s_objet);
605: return(NULL);
606: }
607:
608: break;
609: }
610:
611: case SQL :
612: {
613: if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
614: == NULL)
615: {
616: free(s_objet);
617: return(NULL);
618: }
619:
620: break;
621: }
622:
623: case TBL :
624: {
625: if ((*s_etat_processus).pointeur_tab > 0)
626: {
627: (*s_objet).objet = (*s_etat_processus).objets_tab
628: [--(*s_etat_processus).pointeur_tab];
629: }
630: else
631: {
632: if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
633: {
634: free(s_objet);
635: return(NULL);
636: }
637: }
638:
639: (*((struct_tableau *) (*s_objet).objet)).nombre_elements = 0;
640: (*((struct_tableau *) (*s_objet).objet)).elements = NULL;
641: break;
642: }
643:
644: case VCX :
645: {
646: if ((*s_etat_processus).pointeur_vec > 0)
647: {
648: (*s_objet).objet = (*s_etat_processus).objets_vec
649: [--(*s_etat_processus).pointeur_vec];
650: }
651: else
652: {
653: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
654: {
655: free(s_objet);
656: return(NULL);
657: }
658: }
659:
660: (*((struct_vecteur *) (*s_objet).objet)).type = 'C';
661: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
662: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
663: break;
664: }
665:
666: case VIN :
667: {
668: if ((*s_etat_processus).pointeur_vec > 0)
669: {
670: (*s_objet).objet = (*s_etat_processus).objets_vec
671: [--(*s_etat_processus).pointeur_vec];
672: }
673: else
674: {
675: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
676: {
677: free(s_objet);
678: return(NULL);
679: }
680: }
681:
682: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
683: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
684: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
685: break;
686: }
687:
688: case VRL :
689: {
690: if ((*s_etat_processus).pointeur_vec > 0)
691: {
692: (*s_objet).objet = (*s_etat_processus).objets_vec
693: [--(*s_etat_processus).pointeur_vec];
694: }
695: else
696: {
697: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
698: {
699: free(s_objet);
700: return(NULL);
701: }
702: }
703:
704: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
705: (*((struct_vecteur *) (*s_objet).objet)).taille = 0;
706: (*((struct_vecteur *) (*s_objet).objet)).tableau = NULL;
707: break;
708: }
709:
710: default :
711: {
712: free(s_objet);
713: BUG(1, printf("Allocation failure (type %d)\n", type));
714:
715: return(NULL);
716: }
717: }
718:
719: return(s_objet);
720: }
721:
722:
723: /*
724: ================================================================================
725: Routine de libération d'une structure *s_objet
726: ================================================================================
727: Entrées : structure sur l'état du processus et objet à afficher
728: --------------------------------------------------------------------------------
729: Sorties : chaine de caractères
730: --------------------------------------------------------------------------------
731: Effets de bord : néant
732: ================================================================================
733: */
734:
735: void
736: liberation(struct_processus *s_etat_processus, struct_objet *s_objet)
737: {
738: logical1 drapeau;
739:
740: struct_liste_chainee *l_element_courant;
741: struct_liste_chainee *l_element_suivant;
742:
743: unsigned long i;
744:
745: if (s_objet == NULL)
746: {
747: return;
748: }
749:
750: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
751: {
752: (*s_etat_processus).erreur_systeme = d_es_processus;
753: return;
754: }
755:
756: #define return \
757: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0) \
758: { (*s_etat_processus).erreur_systeme = d_es_processus; return; } \
759: return
760:
761: BUG((*s_objet).nombre_occurrences <= 0,
762: pthread_mutex_unlock(&((*s_objet).mutex)),
763: printf("(*s_objet).nombre_occurrences=%ld\n",
764: (*s_objet).nombre_occurrences));
765:
766: switch((*s_objet).type)
767: {
768: case ADR :
769: {
770: if (decrementation_atomique(s_objet) > 0)
771: {
772: return;
773: }
774:
775: if ((*s_etat_processus).pointeur_adr < TAILLE_CACHE)
776: {
777: (*s_etat_processus).objets_adr
778: [(*s_etat_processus).pointeur_adr++] = (*s_objet).objet;
779: }
780: else
781: {
782: free((unsigned long *) ((*s_objet).objet));
783: }
784:
785: break;
786: }
787:
788: case ALG :
789: {
790: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
791:
792: if (decrementation_atomique(s_objet) > 0)
793: { // Il reste un pointeur sur l'objet.
794: while(l_element_courant != NULL)
795: {
796: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
797: pthread_mutex_unlock(&((*s_objet).mutex)),
798: printf("(*(*l_element_courant).donnee)"
799: ".nombre_occurrences=%ld\n",
800: (*(*l_element_courant).donnee).nombre_occurrences));
801:
802: liberation(s_etat_processus, (*l_element_courant).donnee);
803: l_element_courant = (*l_element_courant).suivant;
804: }
805:
806: return;
807: }
808: else
809: { // Il ne reste plus aucun pointeur sur l'objet.
810: while(l_element_courant != NULL)
811: {
812: l_element_suivant = (*l_element_courant).suivant;
813: liberation(s_etat_processus, (*l_element_courant).donnee);
814: liberation_maillon(s_etat_processus, l_element_courant);
815: l_element_courant = l_element_suivant;
816: }
817: }
818:
819: break;
820: }
821:
822: case BIN :
823: {
824: if (decrementation_atomique(s_objet) > 0)
825: {
826: return;
827: }
828:
829: if ((*s_etat_processus).pointeur_bin < TAILLE_CACHE)
830: {
831: (*s_etat_processus).objets_bin
832: [(*s_etat_processus).pointeur_bin++] = (*s_objet).objet;
833: }
834: else
835: {
836: free((logical8 *) ((*s_objet).objet));
837: }
838:
839: break;
840: }
841:
842: case CHN :
843: {
844: if (decrementation_atomique(s_objet) > 0)
845: {
846: return;
847: }
848:
849: free((unsigned char *) ((*s_objet).objet));
850: break;
851: }
852:
853: case CPL :
854: {
855: if (decrementation_atomique(s_objet) > 0)
856: {
857: return;
858: }
859:
860: if ((*s_etat_processus).pointeur_cpl < TAILLE_CACHE)
861: {
862: (*s_etat_processus).objets_cpl
863: [(*s_etat_processus).pointeur_cpl++] = (*s_objet).objet;
864: }
865: else
866: {
867: free((struct_complexe16 *) ((*s_objet).objet));
868: }
869:
870: break;
871: }
872:
873: case FCH :
874: {
875: if (decrementation_atomique(s_objet) > 0)
876: {
877: return;
878: }
879:
880: liberation(s_etat_processus,
881: (*((struct_fichier *) (*s_objet).objet)).format);
882:
883: free((unsigned char *) (*((struct_fichier *)
884: (*s_objet).objet)).nom);
885: free((struct_fichier *) ((*s_objet).objet));
886: break;
887: }
888:
889: case FCT :
890: {
891: if (decrementation_atomique(s_objet) > 0)
892: {
893: return;
894: }
895:
896: free((unsigned char *) (*((struct_fonction *)
897: (*s_objet).objet)).nom_fonction);
898:
899: if ((*s_etat_processus).pointeur_fct < TAILLE_CACHE)
900: {
901: (*s_etat_processus).objets_fct
902: [(*s_etat_processus).pointeur_fct++] = (*s_objet).objet;
903: }
904: else
905: {
906: free((struct_fonction *) (*s_objet).objet);
907: }
908:
909: break;
910: }
911:
912: case INT :
913: {
914: if (decrementation_atomique(s_objet) > 0)
915: {
916: return;
917: }
918:
919: if ((*s_etat_processus).pointeur_int < TAILLE_CACHE)
920: {
921: (*s_etat_processus).objets_int
922: [(*s_etat_processus).pointeur_int++] = (*s_objet).objet;
923: }
924: else
925: {
926: free((integer8 *) ((*s_objet).objet));
927: }
928:
929: break;
930: }
931:
932: case LST :
933: {
934: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
935:
936: if (decrementation_atomique(s_objet) > 0)
937: { // Il reste un pointeur sur l'objet.
938: while(l_element_courant != NULL)
939: {
940: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
941: pthread_mutex_unlock(&((*s_objet).mutex)),
942: printf("(*(*l_element_courant).donnee)"
943: ".nombre_occurrences=%ld\n",
944: (*(*l_element_courant).donnee).nombre_occurrences));
945:
946: liberation(s_etat_processus, (*l_element_courant).donnee);
947: l_element_courant = (*l_element_courant).suivant;
948: }
949:
950: return;
951: }
952: else
953: { // Il ne reste plus aucun pointeur sur l'objet.
954: while(l_element_courant != NULL)
955: {
956: l_element_suivant = (*l_element_courant).suivant;
957: liberation(s_etat_processus, (*l_element_courant).donnee);
958: liberation_maillon(s_etat_processus, l_element_courant);
959: l_element_courant = l_element_suivant;
960: }
961: }
962:
963: break;
964: }
965:
966: case MIN :
967: {
968: if (decrementation_atomique(s_objet) > 0)
969: {
970: return;
971: }
972:
973: for(i = 0; i < (*((struct_matrice *)
974: ((*s_objet).objet))).nombre_lignes; i++)
975: {
976: free(((integer8 **) (*((struct_matrice *)
977: (*s_objet).objet)).tableau)[i]);
978: }
979:
980: free((integer8 **) (*((struct_matrice *)
981: (*s_objet).objet)).tableau);
982:
983: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
984: {
985: (*s_etat_processus).objets_mat
986: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
987: }
988: else
989: {
990: free((struct_matrice *) (*s_objet).objet);
991: }
992:
993: break;
994: }
995:
996: case MCX :
997: {
998: if (decrementation_atomique(s_objet) > 0)
999: {
1000: return;
1001: }
1002:
1003: for(i = 0; i < (*((struct_matrice *)
1004: ((*s_objet).objet))).nombre_lignes; i++)
1005: {
1006: free(((struct_complexe16 **) (*((struct_matrice *)
1007: (*s_objet).objet)).tableau)[i]);
1008: }
1009:
1010: free((struct_complexe16 **) (*((struct_matrice *)
1011: (*s_objet).objet)).tableau);
1012:
1013: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1014: {
1015: (*s_etat_processus).objets_mat
1016: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1017: }
1018: else
1019: {
1020: free((struct_matrice *) (*s_objet).objet);
1021: }
1022:
1023: break;
1024: }
1025:
1026: case MRL :
1027: {
1028: if (decrementation_atomique(s_objet) > 0)
1029: {
1030: return;
1031: }
1032:
1033: for(i = 0; i < (*((struct_matrice *)
1034: ((*s_objet).objet))).nombre_lignes; i++)
1035: {
1036: free(((real8 **) (*((struct_matrice *)
1037: (*s_objet).objet)).tableau)[i]);
1038: }
1039:
1040: free((real8 **) (*((struct_matrice *) (*s_objet).objet)).tableau);
1041:
1042: if ((*s_etat_processus).pointeur_mat < TAILLE_CACHE)
1043: {
1044: (*s_etat_processus).objets_mat
1045: [(*s_etat_processus).pointeur_mat++] = (*s_objet).objet;
1046: }
1047: else
1048: {
1049: free((struct_matrice *) (*s_objet).objet);
1050: }
1051:
1052: break;
1053: }
1054:
1055: case MTX :
1056: {
1057: if (decrementation_atomique(s_objet) > 0)
1058: {
1059: return;
1060: }
1061:
1062: free((struct_mutex *) (*s_objet).objet);
1063: break;
1064: }
1065:
1066: case NOM :
1067: {
1068: if (decrementation_atomique(s_objet) > 0)
1069: {
1070: return;
1071: }
1072:
1073: free((*((struct_nom *) (*s_objet).objet)).nom);
1074:
1075: if ((*s_etat_processus).pointeur_nom < TAILLE_CACHE)
1076: {
1077: (*s_etat_processus).objets_nom
1078: [(*s_etat_processus).pointeur_nom++] = (*s_objet).objet;
1079: }
1080: else
1081: {
1082: free((struct_nom *) (*s_objet).objet);
1083: }
1084:
1085: break;
1086: }
1087:
1088: case NON :
1089: {
1090: if (decrementation_atomique(s_objet) > 0)
1091: {
1092: return;
1093: }
1094:
1095: free(s_objet);
1096: break;
1097: }
1098:
1099: case PRC :
1100: {
1101: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
1102: (*s_objet).objet)).thread).mutex)) != 0)
1103: {
1104: (*s_etat_processus).erreur_systeme = d_es_processus;
1105: return;
1106: }
1107:
1108: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1109: .nombre_references--;
1110:
1111: BUG((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1112: .nombre_references < 0, printf("(*(*((struct_processus_fils"
1113: " *) (*s_objet).objet)).thread).nombre_references = %d\n",
1114: (int) (*(*((struct_processus_fils *) (*s_objet).objet))
1115: .thread).nombre_references));
1116:
1117: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
1118: .nombre_references == 0)
1119: {
1120: drapeau = d_vrai;
1121: }
1122: else
1123: {
1124: drapeau = d_faux;
1125: }
1126:
1127: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
1128: (*s_objet).objet)).thread).mutex)) != 0)
1129: {
1130: (*s_etat_processus).erreur_systeme = d_es_processus;
1131: return;
1132: }
1133:
1134: if (drapeau == d_vrai)
1135: {
1136: pthread_mutex_destroy(&((*(*((struct_processus_fils *)
1137: (*s_objet).objet)).thread).mutex));
1138: free((*((struct_processus_fils *) (*s_objet).objet)).thread);
1139: }
1140:
1141: if (decrementation_atomique(s_objet) > 0)
1142: {
1143: return;
1144: }
1145:
1146: free((struct_processus_fils *) ((*s_objet).objet));
1147: break;
1148: }
1149:
1150: case REL :
1151: {
1152: if (decrementation_atomique(s_objet) > 0)
1153: {
1154: return;
1155: }
1156:
1157: if ((*s_etat_processus).pointeur_rel < TAILLE_CACHE)
1158: {
1159: (*s_etat_processus).objets_rel
1160: [(*s_etat_processus).pointeur_rel++] = (*s_objet).objet;
1161: }
1162: else
1163: {
1164: free((real8 *) ((*s_objet).objet));
1165: }
1166:
1167: break;
1168: }
1169:
1170: case RPN :
1171: {
1172: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
1173:
1174: if (decrementation_atomique(s_objet) > 0)
1175: { // Il reste un pointeur sur l'objet.
1176: while(l_element_courant != NULL)
1177: {
1178: BUG((*(*l_element_courant).donnee).nombre_occurrences <= 1,
1179: pthread_mutex_unlock(&((*s_objet).mutex)),
1180: printf("(*(*l_element_courant).donnee)"
1181: ".nombre_occurrences=%ld\n",
1182: (*(*l_element_courant).donnee).nombre_occurrences));
1183:
1184: liberation(s_etat_processus, (*l_element_courant).donnee);
1185: l_element_courant = (*l_element_courant).suivant;
1186: }
1187:
1188: return;
1189: }
1190: else
1191: { // Il ne reste plus aucun pointeur sur l'objet.
1192: while(l_element_courant != NULL)
1193: {
1194: l_element_suivant = (*l_element_courant).suivant;
1195: liberation(s_etat_processus, (*l_element_courant).donnee);
1196: liberation_maillon(s_etat_processus, l_element_courant);
1197: l_element_courant = l_element_suivant;
1198: }
1199: }
1200:
1201: break;
1202: }
1203:
1204: case SCK :
1205: {
1206: if (decrementation_atomique(s_objet) > 0)
1207: {
1208: return;
1209: }
1210:
1211: liberation(s_etat_processus, (*((struct_socket *)
1212: (*s_objet).objet)).format);
1213: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1214: .adresse);
1215: free((unsigned char *) (*((struct_socket *) (*s_objet).objet))
1216: .adresse_distante);
1217: free((struct_socket *) ((*s_objet).objet));
1218: break;
1219: }
1220:
1221: case SLB :
1222: {
1223: if (decrementation_atomique(s_objet) > 0)
1224: {
1225: return;
1226: }
1227:
1228: free((*((struct_bibliotheque *) (*s_objet).objet)).nom);
1229: free((struct_bibliotheque *) (*s_objet).objet);
1230: break;
1231: }
1232:
1233: case SPH :
1234: {
1235: if (decrementation_atomique(s_objet) > 0)
1236: {
1237: return;
1238: }
1239:
1240: free((*((struct_semaphore *) (*s_objet).objet)).nom);
1241: free((struct_bibliotheque *) (*s_objet).objet);
1242: break;
1243: }
1244:
1245: case SQL :
1246: {
1247: if (decrementation_atomique(s_objet) > 0)
1248: {
1249: return;
1250: }
1251:
1252: free((*((struct_connecteur_sql *) (*s_objet).objet)).type);
1253: free((*((struct_connecteur_sql *) (*s_objet).objet)).locale);
1254: free((struct_connecteur_sql *) (*s_objet).objet);
1255: break;
1256: }
1257:
1258: case TBL :
1259: {
1260: if (decrementation_atomique(s_objet) > 0)
1261: {
1262: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1263: .nombre_elements; i++)
1264: {
1265: BUG((*((*((struct_tableau *)
1266: (*s_objet).objet)).elements[i]))
1267: .nombre_occurrences <= 1,
1268: pthread_mutex_unlock(&((*s_objet).mutex)),
1269: printf("(*((*((struct_tableau *) (*s_objet).objet))"
1270: ".element[%lu])).nombre_occurrences=%ld\n", i,
1271: (*((*((struct_tableau *) (*s_objet).objet))
1272: .elements[i])).nombre_occurrences));
1273: liberation(s_etat_processus, (*((struct_tableau *)
1274: (*s_objet).objet)).elements[i]);
1275: }
1276:
1277: return;
1278: }
1279:
1280: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
1281: .nombre_elements; i++)
1282: {
1283: liberation(s_etat_processus, (*((struct_tableau *)
1284: (*s_objet).objet)).elements[i]);
1285: }
1286:
1287: free((*((struct_tableau *) (*s_objet).objet)).elements);
1288:
1289: if ((*s_etat_processus).pointeur_tab < TAILLE_CACHE)
1290: {
1291: (*s_etat_processus).objets_tab
1292: [(*s_etat_processus).pointeur_tab++] = (*s_objet).objet;
1293: }
1294: else
1295: {
1296: free((struct_tableau *) (*s_objet).objet);
1297: }
1298:
1299: break;
1300: }
1301:
1302: case VIN :
1303: {
1304: if (decrementation_atomique(s_objet) > 0)
1305: {
1306: return;
1307: }
1308:
1309: free((integer8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1310:
1311: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1312: {
1313: (*s_etat_processus).objets_vec
1314: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1315: }
1316: else
1317: {
1318: free((struct_vecteur *) (*s_objet).objet);
1319: }
1320:
1321: break;
1322: }
1323:
1324: case VCX :
1325: {
1326: if (decrementation_atomique(s_objet) > 0)
1327: {
1328: return;
1329: }
1330:
1331: free((struct_complexe16 *) (*((struct_vecteur *)
1332: (*s_objet).objet)).tableau);
1333:
1334: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1335: {
1336: (*s_etat_processus).objets_vec
1337: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1338: }
1339: else
1340: {
1341: free((struct_vecteur *) (*s_objet).objet);
1342: }
1343:
1344: break;
1345: }
1346:
1347: case VRL :
1348: {
1349: if (decrementation_atomique(s_objet) > 0)
1350: {
1351: return;
1352: }
1353:
1354: free((real8 *) (*((struct_vecteur *) (*s_objet).objet)).tableau);
1355:
1356: if ((*s_etat_processus).pointeur_vec < TAILLE_CACHE)
1357: {
1358: (*s_etat_processus).objets_vec
1359: [(*s_etat_processus).pointeur_vec++] = (*s_objet).objet;
1360: }
1361: else
1362: {
1363: free((struct_vecteur *) (*s_objet).objet);
1364: }
1365:
1366: break;
1367: }
1368:
1369: default :
1370: {
1371: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1372: {
1373: (*s_etat_processus).erreur_systeme = d_es_processus;
1374: return;
1375: }
1376:
1377: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1378: {
1379: (*s_etat_processus).erreur_systeme = d_es_processus;
1380: return;
1381: }
1382:
1383: BUG(1, printf("Free failure (type %d)\n", (*s_objet).type));
1384: return;
1385: }
1386: }
1387:
1388: #undef return
1389:
1390: if (pthread_mutex_unlock(&((*s_objet).mutex)) != 0)
1391: {
1392: (*s_etat_processus).erreur_systeme = d_es_processus;
1393: return;
1394: }
1395:
1396: if (s_etat_processus != NULL)
1397: {
1398: if ((*s_etat_processus).taille_pile_objets < TAILLE_CACHE)
1399: {
1400: (*s_objet).objet = (*s_etat_processus).pile_objets;
1401: (*s_etat_processus).pile_objets = s_objet;
1402: (*s_etat_processus).taille_pile_objets++;
1403: }
1404: else
1405: {
1406: if (pthread_mutex_destroy(&((*s_objet).mutex)) != 0)
1407: {
1408: (*s_etat_processus).erreur_systeme = d_es_processus;
1409: return;
1410: }
1411:
1412: free(s_objet);
1413: }
1414: }
1415: else
1416: {
1417: free(s_objet);
1418: }
1419:
1420: return;
1421: }
1422:
1423:
1424: /*
1425: ================================================================================
1426: Routine de copie d'une structure *s_objet
1427: ================================================================================
1428: Entrées : structure *s_objet à copier
1429: type :
1430: 'P' : renvoie le même objet en incrémentant le nombre
1431: d'occurrence de chaque objet élémentaire ;
1432: 'O' : crée un nouvel objet en copiant chaque objet élémentaire ;
1433: 'N' : crée un nouvel objet mais les objets élémentaires
1434: sont réutilisés (voir 'P'). Dans le cas d'un objet
1435: élémentaire, 'N' et 'P' sont identiques.
1436: 'Q' : 'P' si nombre_occurrences vaut 1, 'O' sinon.
1437: 'R' : 'P' si nombre_occurrences vaut 1, 'N' sinon.
1438: --------------------------------------------------------------------------------
1439: Sorties : structure identique (tous les objets sont copiés)
1440: --------------------------------------------------------------------------------
1441: Effets de bord : néant
1442: ================================================================================
1443: */
1444:
1445: struct_objet *
1446: copie_objet(struct_processus *s_etat_processus,
1447: struct_objet *s_objet, unsigned char type)
1448: {
1449: struct_liste_chainee *l_element_base;
1450: struct_liste_chainee *l_element_courant;
1451: struct_liste_chainee *l_element_courant_ecriture;
1452: struct_liste_chainee *l_element_courant_lecture;
1453: struct_liste_chainee *l_element_suivant_ecriture;
1454: struct_liste_chainee *l_element_suivant_lecture;
1455:
1456: struct_objet *s_nouvel_objet;
1457: struct_objet *s_objet_tampon;
1458:
1459: unsigned long i;
1460: unsigned long j;
1461:
1462: if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
1463: {
1464: (*s_etat_processus).erreur_systeme = d_es_processus;
1465: return(NULL);
1466: }
1467:
1468: if (type == 'Q')
1469: {
1470: if ((*s_objet).nombre_occurrences == 1)
1471: {
1472: type = 'P';
1473: }
1474: else
1475: {
1476: type = 'O';
1477: }
1478: }
1479: else if (type == 'R')
1480: {
1481: if ((*s_objet).nombre_occurrences == 1)
1482: {
1483: type = 'P';
1484: }
1485: else
1486: {
1487: type = 'N';
1488: }
1489: }
1490:
1491: #define return(pointeur) \
1492: if (pthread_mutex_unlock(&((*s_objet).mutex))) \
1493: { (*s_etat_processus).erreur_systeme = d_es_processus; return(NULL); } \
1494: return(pointeur)
1495:
1496: switch((*s_objet).type)
1497: {
1498: case ADR :
1499: {
1500: if (type != 'O')
1501: {
1502: incrementation_atomique(s_objet);
1503: return(s_objet);
1504: }
1505:
1506: if ((s_nouvel_objet = allocation(s_etat_processus, ADR)) == NULL)
1507: {
1508: return(NULL);
1509: }
1510:
1511: (*((unsigned long *) ((*s_nouvel_objet).objet))) =
1512: (*((unsigned long *) ((*s_objet).objet)));
1513: break;
1514: }
1515:
1516: case ALG :
1517: {
1518: if (type != 'P')
1519: {
1520: if ((s_nouvel_objet = allocation(s_etat_processus, ALG))
1521: == NULL)
1522: {
1523: return(NULL);
1524: }
1525:
1526: l_element_courant_lecture = (struct_liste_chainee *)
1527: ((*s_objet).objet);
1528:
1529: l_element_base = NULL;
1530: l_element_courant_ecriture = l_element_base;
1531:
1532: while(l_element_courant_lecture != NULL)
1533: {
1534: s_objet_tampon = copie_objet(s_etat_processus,
1535: (*l_element_courant_lecture).donnee, type);
1536: l_element_suivant_ecriture = (struct_liste_chainee *)
1537: malloc(sizeof(struct_liste_chainee));
1538:
1539: if ((s_objet_tampon == NULL) ||
1540: (l_element_suivant_ecriture == NULL))
1541: {
1542: l_element_courant_lecture = (struct_liste_chainee *)
1543: ((*s_nouvel_objet).objet);
1544:
1545: while(l_element_courant_lecture != NULL)
1546: {
1547: l_element_suivant_lecture =
1548: (*l_element_courant_lecture).suivant;
1549: liberation(s_etat_processus,
1550: (*l_element_courant_lecture).donnee);
1551: free(l_element_courant_lecture);
1552: l_element_courant_lecture =
1553: l_element_suivant_lecture;
1554: }
1555:
1556: return(NULL);
1557: }
1558:
1559: if (l_element_courant_ecriture == NULL)
1560: {
1561: l_element_base = l_element_suivant_ecriture;
1562: }
1563: else
1564: {
1565: (*l_element_courant_ecriture).suivant =
1566: l_element_suivant_ecriture;
1567: }
1568:
1569: l_element_courant_ecriture = l_element_suivant_ecriture;
1570:
1571: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1572: (*l_element_courant_ecriture).suivant = NULL;
1573: l_element_courant_lecture =
1574: (*l_element_courant_lecture).suivant;
1575: }
1576:
1577: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1578: l_element_base);
1579: }
1580: else // type == 'P'
1581: {
1582: incrementation_atomique(s_objet);
1583: l_element_courant = (*s_objet).objet;
1584:
1585: while(l_element_courant != NULL)
1586: {
1587: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1588: (*l_element_courant).donnee, 'P');
1589: l_element_courant = (*l_element_courant).suivant;
1590: }
1591:
1592: return(s_objet);
1593: }
1594:
1595: break;
1596: }
1597:
1598: case BIN :
1599: {
1600: if (type != 'O')
1601: {
1602: incrementation_atomique(s_objet);
1603: return(s_objet);
1604: }
1605:
1606: if ((s_nouvel_objet = allocation(s_etat_processus, BIN)) == NULL)
1607: {
1608: return(NULL);
1609: }
1610:
1611: (*((logical8 *) ((*s_nouvel_objet).objet))) =
1612: (*((logical8 *) ((*s_objet).objet)));
1613: break;
1614: }
1615:
1616: case CHN :
1617: {
1618: if (type != 'O')
1619: {
1620: incrementation_atomique(s_objet);
1621: return(s_objet);
1622: }
1623:
1624: if ((s_nouvel_objet = allocation(s_etat_processus, CHN)) == NULL)
1625: {
1626: return(NULL);
1627: }
1628:
1629: (*s_nouvel_objet).objet = (void *) ((unsigned char *)
1630: malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
1631: * sizeof(unsigned char)));
1632:
1633: if ((*s_nouvel_objet).objet == NULL)
1634: {
1635: free(s_nouvel_objet);
1636: return(NULL);
1637: }
1638:
1639: strcpy((unsigned char *) ((*s_nouvel_objet).objet),
1640: (unsigned char *) ((*s_objet).objet));
1641: break;
1642: }
1643:
1644: case CPL :
1645: {
1646: if (type != 'O')
1647: {
1648: incrementation_atomique(s_objet);
1649: return(s_objet);
1650: }
1651:
1652: if ((s_nouvel_objet = allocation(s_etat_processus, CPL)) == NULL)
1653: {
1654: return(NULL);
1655: }
1656:
1657: (*((struct_complexe16 *) ((*s_nouvel_objet).objet))) =
1658: (*((struct_complexe16 *) ((*s_objet).objet)));
1659: break;
1660: }
1661:
1662: case RPN :
1663: {
1664: if (type != 'P')
1665: {
1666: if ((s_nouvel_objet = allocation(s_etat_processus, RPN))
1667: == NULL)
1668: {
1669: return(NULL);
1670: }
1671:
1672: l_element_courant_lecture = (struct_liste_chainee *)
1673: ((*s_objet).objet);
1674:
1675: l_element_base = NULL;
1676: l_element_courant_ecriture = l_element_base;
1677:
1678: while(l_element_courant_lecture != NULL)
1679: {
1680: s_objet_tampon = copie_objet(s_etat_processus,
1681: (*l_element_courant_lecture).donnee, type);
1682: l_element_suivant_ecriture = (struct_liste_chainee *)
1683: malloc(sizeof(struct_liste_chainee));
1684:
1685: if ((s_objet_tampon == NULL) ||
1686: (l_element_suivant_ecriture == NULL))
1687: {
1688: l_element_courant_lecture = (struct_liste_chainee *)
1689: ((*s_nouvel_objet).objet);
1690:
1691: while(l_element_courant_lecture != NULL)
1692: {
1693: l_element_suivant_lecture =
1694: (*l_element_courant_lecture).suivant;
1695: liberation(s_etat_processus,
1696: (*l_element_courant_lecture).donnee);
1697: free(l_element_courant_lecture);
1698: l_element_courant_lecture =
1699: l_element_suivant_lecture;
1700: }
1701:
1702: return(NULL);
1703: }
1704:
1705: if (l_element_courant_ecriture == NULL)
1706: {
1707: l_element_base = l_element_suivant_ecriture;
1708: }
1709: else
1710: {
1711: (*l_element_courant_ecriture).suivant =
1712: l_element_suivant_ecriture;
1713: }
1714:
1715: l_element_courant_ecriture = l_element_suivant_ecriture;
1716:
1717: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1718: (*l_element_courant_ecriture).suivant = NULL;
1719: l_element_courant_lecture =
1720: (*l_element_courant_lecture).suivant;
1721: }
1722:
1723: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1724: l_element_base);
1725: }
1726: else // type == 'P'
1727: {
1728: incrementation_atomique(s_objet);
1729: l_element_courant = (*s_objet).objet;
1730:
1731: while(l_element_courant != NULL)
1732: {
1733: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1734: (*l_element_courant).donnee, 'P');
1735: l_element_courant = (*l_element_courant).suivant;
1736: }
1737:
1738: return(s_objet);
1739: }
1740:
1741: break;
1742: }
1743:
1744: case FCH :
1745: {
1746: if (type == 'P')
1747: {
1748: incrementation_atomique(s_objet);
1749: return(s_objet);
1750: }
1751:
1752: if ((s_nouvel_objet = allocation(s_etat_processus, FCH)) == NULL)
1753: {
1754: return(NULL);
1755: }
1756:
1757: (*((struct_fichier *) ((*s_nouvel_objet).objet))).descripteur =
1758: (*((struct_fichier *) ((*s_objet).objet))).descripteur;
1759: (*((struct_fichier *) ((*s_nouvel_objet).objet))).acces =
1760: (*((struct_fichier *) ((*s_objet).objet))).acces;
1761: (*((struct_fichier *) ((*s_nouvel_objet).objet))).binaire =
1762: (*((struct_fichier *) ((*s_objet).objet))).binaire;
1763: (*((struct_fichier *) ((*s_nouvel_objet).objet))).ouverture =
1764: (*((struct_fichier *) ((*s_objet).objet))).ouverture;
1765: (*((struct_fichier *) ((*s_nouvel_objet).objet))).protection =
1766: (*((struct_fichier *) ((*s_objet).objet))).protection;
1767: (*((struct_fichier *) ((*s_nouvel_objet).objet)))
1768: .position_clef = (*((struct_fichier *)
1769: ((*s_objet).objet))).position_clef;
1770: (*((struct_fichier *) ((*s_nouvel_objet).objet))).pid =
1771: (*((struct_fichier *) ((*s_objet).objet))).pid;
1772: (*((struct_fichier *) ((*s_nouvel_objet).objet))).tid =
1773: (*((struct_fichier *) ((*s_objet).objet))).tid;
1774:
1775: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).format =
1776: copie_objet(s_etat_processus, (*((struct_fichier *)
1777: ((*s_objet).objet))).format, type)) == NULL)
1778: {
1779: free((*s_nouvel_objet).objet);
1780: free(s_nouvel_objet);
1781: return(NULL);
1782: }
1783:
1784: if (((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom =
1785: (unsigned char *) malloc((strlen((*((struct_fichier *)
1786: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
1787: == NULL)
1788: {
1789: liberation(s_etat_processus, (*((struct_fichier *)
1790: (*s_nouvel_objet).objet)).format);
1791: free((*s_nouvel_objet).objet);
1792: free(s_nouvel_objet);
1793: return(NULL);
1794: }
1795:
1796: strcpy((*((struct_fichier *) ((*s_nouvel_objet).objet))).nom,
1797: (*((struct_fichier *) ((*s_objet).objet))).nom);
1798: break;
1799: }
1800:
1801: case FCT :
1802: {
1803: if (type != 'O')
1804: {
1805: /*
1806: * Remise à zéro de la prédiction pour respecter la cohérence
1807: * du saut dans les cas EXSUB et OBSUB.
1808: */
1809:
1810: (*((struct_fonction *) ((*s_objet).objet)))
1811: .prediction_saut = NULL;
1812: incrementation_atomique(s_objet);
1813: return(s_objet);
1814: }
1815:
1816: if ((s_nouvel_objet = allocation(s_etat_processus, FCT)) == NULL)
1817: {
1818: return(NULL);
1819: }
1820:
1821: if (((*((struct_fonction *) ((*s_nouvel_objet).objet)))
1822: .nom_fonction = (unsigned char *)
1823: malloc((strlen((*((struct_fonction *)
1824: ((*s_objet).objet))).nom_fonction) + 1) *
1825: sizeof(unsigned char))) == NULL)
1826: {
1827: free(s_nouvel_objet);
1828: return(NULL);
1829: }
1830:
1831: strcpy((unsigned char *) (*((struct_fonction *)
1832: ((*s_nouvel_objet).objet))).nom_fonction,
1833: (unsigned char *) (*((struct_fonction *)
1834: ((*s_objet).objet))).nom_fonction);
1835: (*((struct_fonction *) ((*s_nouvel_objet).objet)))
1836: .nombre_arguments = (*((struct_fonction *)
1837: ((*s_objet).objet))).nombre_arguments;
1838: (*((struct_fonction *) ((*s_nouvel_objet).objet))).fonction =
1839: (*((struct_fonction *) ((*s_objet).objet))).fonction;
1840: break;
1841: }
1842:
1843: case INT :
1844: {
1845: if (type != 'O')
1846: {
1847: incrementation_atomique(s_objet);
1848: return(s_objet);
1849: }
1850:
1851: if ((s_nouvel_objet = allocation(s_etat_processus, INT)) == NULL)
1852: {
1853: return(NULL);
1854: }
1855:
1856: (*((integer8 *) ((*s_nouvel_objet).objet))) =
1857: (*((integer8 *) ((*s_objet).objet)));
1858: break;
1859: }
1860:
1861: case LST :
1862: {
1863: if (type != 'P')
1864: {
1865: if ((s_nouvel_objet = allocation(s_etat_processus, LST))
1866: == NULL)
1867: {
1868: return(NULL);
1869: }
1870:
1871: l_element_courant_lecture = (struct_liste_chainee *)
1872: ((*s_objet).objet);
1873:
1874: l_element_base = NULL;
1875: l_element_courant_ecriture = l_element_base;
1876:
1877: while(l_element_courant_lecture != NULL)
1878: {
1879: s_objet_tampon = copie_objet(s_etat_processus,
1880: (*l_element_courant_lecture).donnee, type);
1881: l_element_suivant_ecriture = (struct_liste_chainee *)
1882: malloc(sizeof(struct_liste_chainee));
1883:
1884: if ((s_objet_tampon == NULL) ||
1885: (l_element_suivant_ecriture == NULL))
1886: {
1887: l_element_courant_lecture = (struct_liste_chainee *)
1888: ((*s_nouvel_objet).objet);
1889:
1890: while(l_element_courant_lecture != NULL)
1891: {
1892: l_element_suivant_lecture =
1893: (*l_element_courant_lecture).suivant;
1894: liberation(s_etat_processus,
1895: (*l_element_courant_lecture).donnee);
1896: free(l_element_courant_lecture);
1897: l_element_courant_lecture =
1898: l_element_suivant_lecture;
1899: }
1900:
1901: return(NULL);
1902: }
1903:
1904: if (l_element_courant_ecriture == NULL)
1905: {
1906: l_element_base = l_element_suivant_ecriture;
1907: }
1908: else
1909: {
1910: (*l_element_courant_ecriture).suivant =
1911: l_element_suivant_ecriture;
1912: }
1913:
1914: l_element_courant_ecriture = l_element_suivant_ecriture;
1915:
1916: (*l_element_courant_ecriture).donnee = s_objet_tampon;
1917: (*l_element_courant_ecriture).suivant = NULL;
1918: l_element_courant_lecture =
1919: (*l_element_courant_lecture).suivant;
1920: }
1921:
1922: (*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
1923: l_element_base);
1924: }
1925: else
1926: {
1927: incrementation_atomique(s_objet);
1928: l_element_courant = (*s_objet).objet;
1929:
1930: while(l_element_courant != NULL)
1931: {
1932: (*l_element_courant).donnee = copie_objet(s_etat_processus,
1933: (*l_element_courant).donnee, 'P');
1934: l_element_courant = (*l_element_courant).suivant;
1935: }
1936:
1937: return(s_objet);
1938: }
1939:
1940: break;
1941: }
1942:
1943: case MIN :
1944: {
1945: if (type != 'O')
1946: {
1947: incrementation_atomique(s_objet);
1948: return(s_objet);
1949: }
1950:
1951: if ((s_nouvel_objet = allocation(s_etat_processus, MIN)) == NULL)
1952: {
1953: return(NULL);
1954: }
1955:
1956: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
1957: (void **) ((integer8 **) malloc(
1958: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
1959: * sizeof(integer8 *)));
1960:
1961: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
1962: == NULL)
1963: {
1964: free((*s_nouvel_objet).objet);
1965: free(s_nouvel_objet);
1966: return(NULL);
1967: }
1968:
1969: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
1970: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
1971: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
1972: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
1973: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
1974: (*((struct_matrice *) ((*s_objet).objet))).type;
1975:
1976: for(i = 0; i < (*((struct_matrice *)
1977: ((*s_objet).objet))).nombre_lignes; i++)
1978: {
1979: if ((((integer8 **) ((*((struct_matrice *)
1980: ((*s_nouvel_objet).objet))).tableau))[i] =
1981: (void *) ((integer8 *) malloc(
1982: ((*((struct_matrice *) ((*s_objet).objet)))
1983: .nombre_colonnes) * sizeof(integer8)))) == NULL)
1984: {
1985: for(j = 0; j < i; j++)
1986: {
1987: free(((integer8 **) ((*((struct_matrice *)
1988: ((*s_nouvel_objet).objet))).tableau))[j]);
1989: }
1990:
1991: free((*s_nouvel_objet).objet);
1992: free(s_nouvel_objet);
1993: return(NULL);
1994: }
1995:
1996: for(j = 0; j < (*((struct_matrice *)
1997: ((*s_objet).objet))).nombre_colonnes; j++)
1998: {
1999: ((integer8 **) ((*((struct_matrice *)
2000: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2001: ((integer8 **) ((*((struct_matrice *)
2002: ((*s_objet).objet))).tableau))[i][j];
2003: }
2004: }
2005:
2006: break;
2007: }
2008:
2009: case MCX :
2010: {
2011: if (type != 'O')
2012: {
2013: incrementation_atomique(s_objet);
2014: return(s_objet);
2015: }
2016:
2017: if ((s_nouvel_objet = allocation(s_etat_processus, MCX))
2018: == NULL)
2019: {
2020: return(NULL);
2021: }
2022:
2023: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2024: (void **) ((struct_complexe16 **) malloc(
2025: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2026: * sizeof(struct_complexe16 *)));
2027:
2028: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2029: == NULL)
2030: {
2031: free((*s_nouvel_objet).objet);
2032: free(s_nouvel_objet);
2033: return(NULL);
2034: }
2035:
2036: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2037: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2038: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2039: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2040: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2041: (*((struct_matrice *) ((*s_objet).objet))).type;
2042:
2043: for(i = 0; i < (*((struct_matrice *)
2044: ((*s_objet).objet))).nombre_lignes; i++)
2045: {
2046: if ((((struct_complexe16 **) ((*((struct_matrice *)
2047: ((*s_nouvel_objet).objet))).tableau))[i] =
2048: (void *) ((struct_complexe16 *) malloc(
2049: ((*((struct_matrice *) ((*s_objet).objet)))
2050: .nombre_colonnes) * sizeof(struct_complexe16))))
2051: == NULL)
2052: {
2053: for(j = 0; j < i; j++)
2054: {
2055: free(((struct_complexe16 **) ((*((struct_matrice *)
2056: ((*s_nouvel_objet).objet))).tableau))[j]);
2057: }
2058:
2059: free((*s_nouvel_objet).objet);
2060: free(s_nouvel_objet);
2061: return(NULL);
2062: }
2063:
2064: for(j = 0; j < (*((struct_matrice *)
2065: ((*s_objet).objet))).nombre_colonnes; j++)
2066: {
2067: ((struct_complexe16 **) ((*((struct_matrice *)
2068: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2069: ((struct_complexe16 **) ((*((struct_matrice *)
2070: ((*s_objet).objet))).tableau))[i][j];
2071: }
2072: }
2073:
2074: break;
2075: }
2076:
2077: case MRL :
2078: {
2079: if (type != 'O')
2080: {
2081: incrementation_atomique(s_objet);
2082: return(s_objet);
2083: }
2084:
2085: if ((s_nouvel_objet = allocation(s_etat_processus, MRL)) == NULL)
2086: {
2087: return(NULL);
2088: }
2089:
2090: (*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
2091: (void **) ((real8 **) malloc(
2092: ((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
2093: * sizeof(real8 *)));
2094:
2095: if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
2096: == NULL)
2097: {
2098: free((*s_nouvel_objet).objet);
2099: free(s_nouvel_objet);
2100: return(NULL);
2101: }
2102:
2103: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_colonnes =
2104: (*((struct_matrice *) ((*s_objet).objet))).nombre_colonnes;
2105: (*((struct_matrice *) ((*s_nouvel_objet).objet))).nombre_lignes =
2106: (*((struct_matrice *) ((*s_objet).objet))).nombre_lignes;
2107: (*((struct_matrice *) ((*s_nouvel_objet).objet))).type =
2108: (*((struct_matrice *) ((*s_objet).objet))).type;
2109:
2110: for(i = 0; i < (*((struct_matrice *)
2111: ((*s_objet).objet))).nombre_lignes; i++)
2112: {
2113: if ((((real8 **) ((*((struct_matrice *)
2114: ((*s_nouvel_objet).objet))).tableau))[i] =
2115: (void *) ((real8 *) malloc(
2116: ((*((struct_matrice *) ((*s_objet).objet)))
2117: .nombre_colonnes) * sizeof(real8)))) == NULL)
2118: {
2119: for(j = 0; j < i; j++)
2120: {
2121: free(((real8 **) ((*((struct_matrice *)
2122: ((*s_nouvel_objet).objet))).tableau))[j]);
2123: }
2124:
2125: free((*s_nouvel_objet).objet);
2126: free(s_nouvel_objet);
2127: return(NULL);
2128: }
2129:
2130: for(j = 0; j < (*((struct_matrice *)
2131: ((*s_objet).objet))).nombre_colonnes; j++)
2132: {
2133: ((real8 **) ((*((struct_matrice *)
2134: ((*s_nouvel_objet).objet))).tableau))[i][j] =
2135: ((real8 **) ((*((struct_matrice *)
2136: ((*s_objet).objet))).tableau))[i][j];
2137: }
2138: }
2139:
2140: break;
2141: }
2142:
2143: case MTX :
2144: {
2145: if (type != 'O')
2146: {
2147: incrementation_atomique(s_objet);
2148: return(s_objet);
2149: }
2150:
2151: if ((s_nouvel_objet = allocation(s_etat_processus, MTX)) == NULL)
2152: {
2153: return(NULL);
2154: }
2155:
2156: (*((struct_mutex *) ((*s_nouvel_objet).objet))).mutex =
2157: (*((struct_mutex *) ((*s_objet).objet))).mutex;
2158: break;
2159: }
2160:
2161: case NOM :
2162: {
2163: if (type != 'O')
2164: {
2165: incrementation_atomique(s_objet);
2166: return(s_objet);
2167: }
2168:
2169: if ((s_nouvel_objet = allocation(s_etat_processus, NOM)) == NULL)
2170: {
2171: return(NULL);
2172: }
2173:
2174: (*((struct_nom *) (*s_nouvel_objet).objet)).nom = malloc((
2175: strlen((*((struct_nom *) (*s_objet).objet)).nom) + 1) *
2176: sizeof(unsigned char));
2177:
2178: if ((*((struct_nom *) (*s_nouvel_objet).objet)).nom == NULL)
2179: {
2180: free((*s_nouvel_objet).objet);
2181: free(s_nouvel_objet);
2182: return(NULL);
2183: }
2184:
2185: strcpy((*((struct_nom *) (*s_nouvel_objet).objet)).nom,
2186: (*((struct_nom *) (*s_objet).objet)).nom);
2187: (*((struct_nom *) (*s_nouvel_objet).objet)).symbole =
2188: (*((struct_nom *) (*s_objet).objet)).symbole;
2189: break;
2190: }
2191:
2192: case NON :
2193: {
2194: if (type != 'O')
2195: {
2196: incrementation_atomique(s_objet);
2197: return(s_objet);
2198: }
2199:
2200: if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL)
2201: {
2202: return(NULL);
2203: }
2204:
2205: (*s_nouvel_objet).objet = NULL;
2206: break;
2207: }
2208:
2209: case PRC :
2210: {
2211: if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
2212: (*s_objet).objet)).thread).mutex)) != 0)
2213: {
2214: return(NULL);
2215: }
2216:
2217: (*(*((struct_processus_fils *) (*s_objet).objet)).thread)
2218: .nombre_references++;
2219:
2220: if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
2221: (*s_objet).objet)).thread).mutex)) != 0)
2222: {
2223: return(NULL);
2224: }
2225:
2226: if (type != 'O')
2227: {
2228: incrementation_atomique(s_objet);
2229: return(s_objet);
2230: }
2231:
2232: if ((s_nouvel_objet = allocation(s_etat_processus, PRC)) == NULL)
2233: {
2234: return(NULL);
2235: }
2236:
2237: (*((struct_processus_fils *) (*s_nouvel_objet).objet)) =
2238: (*((struct_processus_fils *) (*s_objet).objet));
2239: break;
2240: }
2241:
2242: case REL :
2243: {
2244: if (type != 'O')
2245: {
2246: incrementation_atomique(s_objet);
2247: return(s_objet);
2248: }
2249:
2250: if ((s_nouvel_objet = allocation(s_etat_processus, REL)) == NULL)
2251: {
2252: return(NULL);
2253: }
2254:
2255: (*((real8 *) ((*s_nouvel_objet).objet))) =
2256: (*((real8 *) ((*s_objet).objet)));
2257: break;
2258: }
2259:
2260: case SCK :
2261: {
2262: if (type == 'P')
2263: {
2264: incrementation_atomique(s_objet);
2265: return(s_objet);
2266: }
2267:
2268: if ((s_nouvel_objet = allocation(s_etat_processus, SCK)) == NULL)
2269: {
2270: return(NULL);
2271: }
2272:
2273: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket =
2274: (*((struct_socket *) ((*s_objet).objet))).socket;
2275: (*((struct_socket *) ((*s_nouvel_objet).objet))).domaine =
2276: (*((struct_socket *) ((*s_objet).objet))).domaine;
2277: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_en_ecoute =
2278: (*((struct_socket *) ((*s_objet).objet))).socket_en_ecoute;
2279: (*((struct_socket *) ((*s_nouvel_objet).objet))).socket_connectee =
2280: (*((struct_socket *) ((*s_objet).objet))).socket_connectee;
2281: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2282: (*((struct_socket *) ((*s_objet).objet))).pid;
2283: (*((struct_socket *) ((*s_nouvel_objet).objet))).binaire =
2284: (*((struct_socket *) ((*s_objet).objet))).binaire;
2285: (*((struct_socket *) ((*s_nouvel_objet).objet))).effacement =
2286: (*((struct_socket *) ((*s_objet).objet))).effacement;
2287: (*((struct_socket *) ((*s_nouvel_objet).objet))).protection =
2288: (*((struct_socket *) ((*s_objet).objet))).protection;
2289: (*((struct_socket *) ((*s_nouvel_objet).objet))).localisation =
2290: (*((struct_socket *) ((*s_objet).objet))).localisation;
2291: (*((struct_socket *) ((*s_nouvel_objet).objet))).pid =
2292: (*((struct_socket *) ((*s_objet).objet))).pid;
2293: (*((struct_socket *) ((*s_nouvel_objet).objet))).tid =
2294: (*((struct_socket *) ((*s_objet).objet))).tid;
2295:
2296: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).format =
2297: copie_objet(s_etat_processus, (*((struct_socket *)
2298: ((*s_objet).objet))).format, type)) == NULL)
2299: {
2300: free((*s_nouvel_objet).objet);
2301: free(s_nouvel_objet);
2302: return(NULL);
2303: }
2304:
2305: if (((*((struct_socket *) ((*s_nouvel_objet).objet))).adresse =
2306: (unsigned char *) malloc((strlen((*((struct_socket *)
2307: ((*s_objet).objet))).adresse) + 1) * sizeof(unsigned char)))
2308: == NULL)
2309: {
2310: liberation(s_etat_processus, (*((struct_fichier *)
2311: (*s_nouvel_objet).objet)).format);
2312: free((*s_nouvel_objet).objet);
2313: free(s_nouvel_objet);
2314: return(NULL);
2315: }
2316:
2317: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2318: .adresse, (*((struct_socket *) ((*s_objet).objet)))
2319: .adresse);
2320:
2321: if (((*((struct_socket *) ((*s_nouvel_objet).objet)))
2322: .adresse_distante = malloc((strlen((*((struct_socket *)
2323: ((*s_objet).objet))).adresse_distante) + 1) *
2324: sizeof(unsigned char))) == NULL)
2325: {
2326: liberation(s_etat_processus, (*((struct_fichier *)
2327: (*s_nouvel_objet).objet)).format);
2328: free((*s_nouvel_objet).objet);
2329: free(s_nouvel_objet);
2330: return(NULL);
2331: }
2332:
2333: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet)))
2334: .adresse_distante, (*((struct_socket *) ((*s_objet).objet)))
2335: .adresse_distante);
2336:
2337: strcpy((*((struct_socket *) ((*s_nouvel_objet).objet))).type,
2338: (*((struct_socket *) ((*s_objet).objet))).type);
2339: break;
2340: }
2341:
2342: case SLB :
2343: {
2344: if (type != 'O')
2345: {
2346: incrementation_atomique(s_objet);
2347: return(s_objet);
2348: }
2349:
2350: if ((s_nouvel_objet = allocation(s_etat_processus, SLB)) == NULL)
2351: {
2352: return(NULL);
2353: }
2354:
2355: if (((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom =
2356: (unsigned char *) malloc((strlen((*((struct_bibliotheque *)
2357: ((*s_objet).objet))).nom) + 1) * sizeof(unsigned char)))
2358: == NULL)
2359: {
2360: free((*s_nouvel_objet).objet);
2361: free(s_nouvel_objet);
2362: return(NULL);
2363: }
2364:
2365: strcpy((*((struct_bibliotheque *) ((*s_nouvel_objet).objet))).nom,
2366: (*((struct_bibliotheque *) ((*s_objet).objet))).nom);
2367:
2368: /*
2369: * C'est objet est non modifiable et est un pointeur
2370: * sur un objet système. Seul la référence est copiée.
2371: */
2372:
2373: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).descripteur =
2374: (*((struct_bibliotheque *) (*s_objet).objet)).descripteur;
2375: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).pid =
2376: (*((struct_bibliotheque *) (*s_objet).objet)).pid;
2377: (*((struct_bibliotheque *) (*s_nouvel_objet).objet)).tid =
2378: (*((struct_bibliotheque *) (*s_objet).objet)).tid;
2379: break;
2380: }
2381:
2382: case SPH :
2383: {
2384: if (type != 'O')
2385: {
2386: incrementation_atomique(s_objet);
2387: return(s_objet);
2388: }
2389:
2390: if ((s_nouvel_objet = allocation(s_etat_processus, SPH)) == NULL)
2391: {
2392: return(NULL);
2393: }
2394:
2395: if (((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom =
2396: malloc((strlen((*((struct_semaphore *) (*s_objet).objet))
2397: .nom) + 1) * sizeof(unsigned char))) == NULL)
2398: {
2399: free((*s_nouvel_objet).objet);
2400: free(s_nouvel_objet);
2401: return(NULL);
2402: }
2403:
2404: strcpy((*((struct_semaphore *) (*s_nouvel_objet).objet)).nom,
2405: (*((struct_semaphore *) (*s_objet).objet)).nom);
2406: break;
2407: }
2408:
2409: case SQL :
2410: {
2411: if (type != 'O')
2412: {
2413: incrementation_atomique(s_objet);
2414: return(s_objet);
2415: }
2416:
2417: if ((s_nouvel_objet = allocation(s_etat_processus, SQL)) == NULL)
2418: {
2419: return(NULL);
2420: }
2421:
2422: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).pid =
2423: (*((struct_connecteur_sql *) (*s_objet).objet)).pid;
2424: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).tid =
2425: (*((struct_connecteur_sql *) (*s_objet).objet)).tid;
2426: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).descripteur =
2427: (*((struct_connecteur_sql *) (*s_objet).objet)).descripteur;
2428:
2429: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type =
2430: malloc((strlen((*((struct_connecteur_sql *)
2431: (*s_objet).objet)).type) + 1) * sizeof(unsigned char)))
2432: == NULL)
2433: {
2434: free(s_nouvel_objet);
2435: return(NULL);
2436: }
2437:
2438: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).type,
2439: (*((struct_connecteur_sql *) (*s_objet).objet)).type);
2440:
2441: if ((*((struct_connecteur_sql *) (*s_objet).objet)).locale != NULL)
2442: {
2443: if (((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2444: .locale = malloc((strlen((*((struct_connecteur_sql *)
2445: (*s_objet).objet)).locale) + 1) *
2446: sizeof(unsigned char))) == NULL)
2447: {
2448: free((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2449: .locale);
2450: free(s_nouvel_objet);
2451: return(NULL);
2452: }
2453:
2454: strcpy((*((struct_connecteur_sql *) (*s_nouvel_objet).objet))
2455: .locale, (*((struct_connecteur_sql *)
2456: (*s_objet).objet)).locale);
2457: }
2458: else
2459: {
2460: (*((struct_connecteur_sql *) (*s_nouvel_objet).objet)).locale
2461: = NULL;
2462: }
2463:
2464: break;
2465: }
2466:
2467: case TBL :
2468: {
2469: if (type != 'P')
2470: {
2471: if ((s_nouvel_objet = allocation(s_etat_processus, TBL))
2472: == NULL)
2473: {
2474: return(NULL);
2475: }
2476:
2477: (*((struct_tableau *) (*s_nouvel_objet).objet))
2478: .nombre_elements = (*((struct_tableau *)
2479: (*s_objet).objet)).nombre_elements;
2480:
2481: if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
2482: malloc((*((struct_tableau *) (*s_objet).objet))
2483: .nombre_elements * sizeof(struct_objet *))) == NULL)
2484: {
2485: return(NULL);
2486: }
2487:
2488: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2489: .nombre_elements; i++)
2490: {
2491: if (((*((struct_tableau *) (*s_nouvel_objet).objet))
2492: .elements[i] = copie_objet(s_etat_processus,
2493: (*((struct_tableau *) (*s_objet).objet))
2494: .elements[i], type)) == NULL)
2495: {
2496: for(j = 0; j < i; j++)
2497: {
2498: liberation(s_etat_processus, (*((struct_tableau *)
2499: (*s_nouvel_objet).objet)).elements[j]);
2500: }
2501:
2502: free((*((struct_tableau *) (*s_nouvel_objet).objet))
2503: .elements);
2504: free((*s_nouvel_objet).objet);
2505: free(s_nouvel_objet);
2506:
2507: return(NULL);
2508: }
2509: }
2510: }
2511: else
2512: {
2513: incrementation_atomique(s_objet);
2514:
2515: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
2516: .nombre_elements; i++)
2517: {
2518: (*((struct_tableau *) (*s_objet).objet)).elements[i] =
2519: copie_objet(s_etat_processus, (*((struct_tableau *)
2520: (*s_objet).objet)).elements[i], 'P');
2521: }
2522:
2523: return(s_objet);
2524: }
2525:
2526: break;
2527: }
2528:
2529: case VIN :
2530: {
2531: if (type != 'O')
2532: {
2533: incrementation_atomique(s_objet);
2534: return(s_objet);
2535: }
2536:
2537: if ((s_nouvel_objet = allocation(s_etat_processus, VIN)) == NULL)
2538: {
2539: return(NULL);
2540: }
2541:
2542: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2543: (void *) ((integer8 *) malloc(
2544: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2545: * sizeof(integer8)));
2546:
2547: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2548: == NULL)
2549: {
2550: free((*s_nouvel_objet).objet);
2551: free(s_nouvel_objet);
2552: return(NULL);
2553: }
2554:
2555: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2556: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2557: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2558: (*((struct_vecteur *) ((*s_objet).objet))).type;
2559:
2560: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2561: i++)
2562: {
2563: ((integer8 *) ((*((struct_vecteur *)
2564: ((*s_nouvel_objet).objet))).tableau))[i] =
2565: ((integer8 *) ((*((struct_vecteur *)
2566: ((*s_objet).objet))).tableau))[i];
2567: }
2568:
2569: break;
2570: }
2571:
2572: case VCX :
2573: {
2574: if (type != 'O')
2575: {
2576: incrementation_atomique(s_objet);
2577: return(s_objet);
2578: }
2579:
2580: if ((s_nouvel_objet = allocation(s_etat_processus, VCX)) == NULL)
2581: {
2582: return(NULL);
2583: }
2584:
2585: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2586: (void *) ((struct_complexe16 *) malloc(
2587: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2588: * sizeof(struct_complexe16)));
2589:
2590: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2591: == NULL)
2592: {
2593: free((*s_nouvel_objet).objet);
2594: free(s_nouvel_objet);
2595: return(NULL);
2596: }
2597:
2598: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2599: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2600: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2601: (*((struct_vecteur *) ((*s_objet).objet))).type;
2602:
2603: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2604: i++)
2605: {
2606: ((struct_complexe16 *) ((*((struct_vecteur *)
2607: ((*s_nouvel_objet).objet))).tableau))[i] =
2608: ((struct_complexe16 *) ((*((struct_vecteur *)
2609: ((*s_objet).objet))).tableau))[i];
2610: }
2611:
2612: break;
2613: }
2614:
2615: case VRL :
2616: {
2617: if (type != 'O')
2618: {
2619: incrementation_atomique(s_objet);
2620: return(s_objet);
2621: }
2622:
2623: if ((s_nouvel_objet = allocation(s_etat_processus, VRL)) == NULL)
2624: {
2625: return(NULL);
2626: }
2627:
2628: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau =
2629: (void *) ((real8 *) malloc(
2630: ((*((struct_vecteur *) ((*s_objet).objet))).taille)
2631: * sizeof(real8)));
2632:
2633: if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
2634: == NULL)
2635: {
2636: free((*s_nouvel_objet).objet);
2637: free(s_nouvel_objet);
2638: return(NULL);
2639: }
2640:
2641: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).taille =
2642: (*((struct_vecteur *) ((*s_objet).objet))).taille;
2643: (*((struct_vecteur *) ((*s_nouvel_objet).objet))).type =
2644: (*((struct_vecteur *) ((*s_objet).objet))).type;
2645:
2646: for(i = 0; i < (*((struct_vecteur *) ((*s_objet).objet))).taille;
2647: i++)
2648: {
2649: ((real8 *) ((*((struct_vecteur *)
2650: ((*s_nouvel_objet).objet))).tableau))[i] =
2651: ((real8 *) ((*((struct_vecteur *)
2652: ((*s_objet).objet))).tableau))[i];
2653: }
2654:
2655: break;
2656: }
2657:
2658: default :
2659: {
2660: return(NULL);
2661: }
2662: }
2663:
2664: return(s_nouvel_objet);
2665:
2666: #undef return
2667: }
2668:
2669:
2670: /*
2671: ================================================================================
2672: Routine de copie d'une structure de description d'un processus
2673: ================================================================================
2674: Entrées : pointeur sur la structure de description d'un processus
2675: --------------------------------------------------------------------------------
2676: Sorties : structure identique (tous les objets sont copiés)
2677: --------------------------------------------------------------------------------
2678: Effets de bord : néant
2679: ================================================================================
2680: */
2681:
2682: struct_processus *
2683: copie_etat_processus(struct_processus *s_etat_processus)
2684: {
2685: pthread_mutexattr_t attributs_mutex;
2686:
2687: struct_liste_chainee *l_element_lecture;
2688: struct_liste_chainee *l_element_precedent;
2689: struct_liste_chainee *l_element_suivant;
2690:
2691: struct_processus *s_nouvel_etat_processus;
2692:
2693: unsigned long i;
2694:
2695: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
2696: {
2697: (*s_etat_processus).erreur_systeme = d_es_processus;
2698: return(NULL);
2699: }
2700:
2701: if ((s_nouvel_etat_processus = malloc(sizeof(struct_processus))) == NULL)
2702: {
2703: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2704: return(NULL);
2705: }
2706:
2707: (*s_nouvel_etat_processus) = (*s_etat_processus);
2708:
2709: // On réinitialise l'allocateur.
2710:
2711: initialisation_allocateur(s_nouvel_etat_processus);
2712:
2713: /*
2714: * (*s_etat_processus).definition_chainee,
2715: * (*s_etat_processus).nom_fichier_source,
2716: * (*s_etat_processus).nom_fichier_historique et
2717: * (*s_etat_processus).chemin_fichier_temporaires
2718: * n'ont aucune raison de changer.
2719: */
2720:
2721: sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
2722:
2723: (*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
2724: (*s_nouvel_etat_processus).fichiers_graphiques = NULL;
2725: (*s_nouvel_etat_processus).entree_standard = NULL;
2726: (*s_nouvel_etat_processus).s_marques = NULL;
2727: (*s_nouvel_etat_processus).requete_nouveau_plan = d_vrai;
2728: (*s_nouvel_etat_processus).mise_a_jour_trace_requise = d_faux;
2729: (*s_nouvel_etat_processus).nom_fichier_impression = NULL;
2730: (*s_nouvel_etat_processus).expression_courante = NULL;
2731: (*s_nouvel_etat_processus).objet_courant = NULL;
2732: (*s_nouvel_etat_processus).processus_detache = d_faux;
2733:
2734: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
2735: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
2736: (*s_nouvel_etat_processus).presence_fusible = d_faux;
2737: (*s_nouvel_etat_processus).thread_fusible = 0;
2738: (*s_nouvel_etat_processus).niveau_initial =
2739: (*s_etat_processus).niveau_courant;
2740: (*s_nouvel_etat_processus).presence_pipes = d_faux;
2741: (*s_nouvel_etat_processus).debug_programme = d_faux;
2742: (*s_nouvel_etat_processus).s_fichiers = NULL;
2743: (*s_nouvel_etat_processus).s_connecteurs_sql = NULL;
2744:
2745: // On réinitialise toutes les interruptions.
2746:
2747: (*s_nouvel_etat_processus).traitement_interruption = 'N';
2748: (*s_nouvel_etat_processus).traitement_interruptible = 'Y';
2749: (*s_nouvel_etat_processus).nombre_interruptions_en_queue = 0;
2750: (*s_nouvel_etat_processus).nombre_interruptions_non_affectees = 0;
2751:
2752: for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
2753: {
2754: (*s_nouvel_etat_processus).corps_interruptions[i] = NULL;
2755: (*s_nouvel_etat_processus).masque_interruptions[i] = 'N';
2756: (*s_nouvel_etat_processus).queue_interruptions[i] = 0;
2757: (*s_nouvel_etat_processus).pile_origine_interruptions[i] = NULL;
2758: }
2759:
2760: if ((*s_nouvel_etat_processus).generateur_aleatoire != NULL)
2761: {
2762: (*s_nouvel_etat_processus).generateur_aleatoire = NULL;
2763: }
2764:
2765: (*s_nouvel_etat_processus).type_generateur_aleatoire = NULL;
2766:
2767: // Copie de la localisation
2768:
2769: if (((*s_nouvel_etat_processus).localisation = malloc((strlen(
2770: (*s_etat_processus).localisation) + 1) * sizeof(unsigned char)))
2771: == NULL)
2772: {
2773: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2774: return(NULL);
2775: }
2776:
2777: strcpy((*s_nouvel_etat_processus).localisation,
2778: (*s_etat_processus).localisation);
2779:
2780: if ((*s_etat_processus).indep != NULL)
2781: {
2782: if (((*s_nouvel_etat_processus).indep = copie_objet(s_etat_processus,
2783: (*s_etat_processus).indep, 'P')) == NULL)
2784: {
2785: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2786: {
2787: (*s_etat_processus).erreur_systeme = d_es_processus;
2788: return(NULL);
2789: }
2790:
2791: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2792: return(NULL);
2793: }
2794: }
2795: else
2796: {
2797: (*s_nouvel_etat_processus).indep = NULL;
2798: }
2799:
2800: if ((*s_etat_processus).depend != NULL)
2801: {
2802: if (((*s_nouvel_etat_processus).depend = copie_objet(s_etat_processus,
2803: (*s_etat_processus).depend, 'P')) == NULL)
2804: {
2805: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2806: {
2807: (*s_etat_processus).erreur_systeme = d_es_processus;
2808: return(NULL);
2809: }
2810:
2811: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2812: return(NULL);
2813: }
2814: }
2815: else
2816: {
2817: (*s_nouvel_etat_processus).depend = NULL;
2818: }
2819:
2820: if ((*s_etat_processus).parametres_courbes_de_niveau != NULL)
2821: {
2822: if (((*s_nouvel_etat_processus).parametres_courbes_de_niveau =
2823: copie_objet(s_etat_processus, (*s_etat_processus)
2824: .parametres_courbes_de_niveau, 'P')) == NULL)
2825: {
2826: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2827: {
2828: (*s_etat_processus).erreur_systeme = d_es_processus;
2829: return(NULL);
2830: }
2831:
2832: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2833: return(NULL);
2834: }
2835: }
2836: else
2837: {
2838: (*s_nouvel_etat_processus).parametres_courbes_de_niveau = NULL;
2839: }
2840:
2841: (*s_nouvel_etat_processus).instruction_derniere_erreur = NULL;
2842:
2843: if (((*s_etat_processus).instruction_courante != NULL) &&
2844: (*s_etat_processus).evaluation_expression_compilee == 'N')
2845: {
2846: if (((*s_nouvel_etat_processus).instruction_courante = malloc((strlen(
2847: (*s_etat_processus).instruction_courante) + 1) *
2848: sizeof(unsigned char))) == NULL)
2849: {
2850: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2851: {
2852: (*s_etat_processus).erreur_systeme = d_es_processus;
2853: return(NULL);
2854: }
2855:
2856: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2857: return(NULL);
2858: }
2859:
2860: strcpy((*s_nouvel_etat_processus).instruction_courante,
2861: (*s_etat_processus).instruction_courante);
2862: }
2863: else
2864: {
2865: (*s_nouvel_etat_processus).instruction_courante = NULL;
2866: }
2867:
2868: if ((*s_etat_processus).label_x != NULL)
2869: {
2870: if (((*s_nouvel_etat_processus).label_x = malloc((strlen(
2871: (*s_etat_processus).label_x) + 1) *
2872: sizeof(unsigned char))) == NULL)
2873: {
2874: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2875: {
2876: (*s_etat_processus).erreur_systeme = d_es_processus;
2877: return(NULL);
2878: }
2879:
2880: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2881: return(NULL);
2882: }
2883:
2884: strcpy((*s_nouvel_etat_processus).label_x,
2885: (*s_etat_processus).label_x);
2886: }
2887: else
2888: {
2889: (*s_nouvel_etat_processus).label_x = NULL;
2890: }
2891:
2892: if ((*s_etat_processus).label_y != NULL)
2893: {
2894: if (((*s_nouvel_etat_processus).label_y = malloc((strlen(
2895: (*s_etat_processus).label_y) + 1) *
2896: sizeof(unsigned char))) == NULL)
2897: {
2898: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2899: {
2900: (*s_etat_processus).erreur_systeme = d_es_processus;
2901: return(NULL);
2902: }
2903:
2904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2905: return(NULL);
2906: }
2907:
2908: strcpy((*s_nouvel_etat_processus).label_y,
2909: (*s_etat_processus).label_y);
2910: }
2911: else
2912: {
2913: (*s_nouvel_etat_processus).label_y = NULL;
2914: }
2915:
2916: if ((*s_etat_processus).label_z != NULL)
2917: {
2918: if (((*s_nouvel_etat_processus).label_z = malloc((strlen(
2919: (*s_etat_processus).label_z) + 1) *
2920: sizeof(unsigned char))) == NULL)
2921: {
2922: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2923: {
2924: (*s_etat_processus).erreur_systeme = d_es_processus;
2925: return(NULL);
2926: }
2927:
2928: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2929: return(NULL);
2930: }
2931:
2932: strcpy((*s_nouvel_etat_processus).label_z,
2933: (*s_etat_processus).label_z);
2934: }
2935: else
2936: {
2937: (*s_nouvel_etat_processus).label_z = NULL;
2938: }
2939:
2940: if ((*s_etat_processus).titre != NULL)
2941: {
2942: if (((*s_nouvel_etat_processus).titre = malloc((strlen(
2943: (*s_etat_processus).titre) + 1) *
2944: sizeof(unsigned char))) == NULL)
2945: {
2946: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2947: {
2948: (*s_etat_processus).erreur_systeme = d_es_processus;
2949: return(NULL);
2950: }
2951:
2952: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2953: return(NULL);
2954: }
2955:
2956: strcpy((*s_nouvel_etat_processus).titre,
2957: (*s_etat_processus).titre);
2958: }
2959: else
2960: {
2961: (*s_nouvel_etat_processus).titre = NULL;
2962: }
2963:
2964: if ((*s_etat_processus).legende != NULL)
2965: {
2966: if (((*s_nouvel_etat_processus).legende = malloc((strlen(
2967: (*s_etat_processus).legende) + 1) *
2968: sizeof(unsigned char))) == NULL)
2969: {
2970: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2971: {
2972: (*s_etat_processus).erreur_systeme = d_es_processus;
2973: return(NULL);
2974: }
2975:
2976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2977: return(NULL);
2978: }
2979:
2980: strcpy((*s_nouvel_etat_processus).legende,
2981: (*s_etat_processus).legende);
2982: }
2983: else
2984: {
2985: (*s_nouvel_etat_processus).legende = NULL;
2986: }
2987:
2988: /*
2989: * Copie de la table des variables
2990: */
2991:
2992: if (((*s_nouvel_etat_processus).s_liste_variables =
2993: malloc((*s_etat_processus).nombre_variables_allouees *
2994: sizeof(struct_variable))) == NULL)
2995: {
2996: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
2997: {
2998: (*s_etat_processus).erreur_systeme = d_es_processus;
2999: return(NULL);
3000: }
3001:
3002: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3003: return(NULL);
3004: }
3005:
3006: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
3007: {
3008: if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =
3009: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
3010: + 1) * sizeof(unsigned char))) == NULL)
3011: {
3012: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3013: {
3014: (*s_etat_processus).erreur_systeme = d_es_processus;
3015: return(NULL);
3016: }
3017:
3018: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3019: return(NULL);
3020: }
3021:
3022: strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
3023: (*s_etat_processus).s_liste_variables[i].nom);
3024:
3025: (*s_nouvel_etat_processus).s_liste_variables[i].origine =
3026: (*s_etat_processus).s_liste_variables[i].origine;
3027: (*s_nouvel_etat_processus).s_liste_variables[i].niveau =
3028: (*s_etat_processus).s_liste_variables[i].niveau;
3029: (*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
3030: (*s_etat_processus).s_liste_variables[i].variable_statique;
3031: (*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
3032: (*s_etat_processus).s_liste_variables[i].variable_verrouillee;
3033:
3034: // Les définitions sont partagées entre tous les threads.
3035:
3036: if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
3037: {
3038: (*s_nouvel_etat_processus).s_liste_variables[i].objet =
3039: (*s_etat_processus).s_liste_variables[i].objet;
3040: }
3041: else
3042: {
3043: if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
3044: copie_objet(s_etat_processus,
3045: (*s_etat_processus).s_liste_variables[i]
3046: .objet, 'P')) == NULL)
3047: {
3048: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3049: {
3050: (*s_etat_processus).erreur_systeme = d_es_processus;
3051: return(NULL);
3052: }
3053:
3054: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3055: return(NULL);
3056: }
3057: }
3058: }
3059:
3060: /*
3061: * Copie de la table des variables statiques
3062: */
3063:
3064: if (((*s_nouvel_etat_processus).s_liste_variables_statiques =
3065: malloc((*s_etat_processus).nombre_variables_statiques_allouees *
3066: sizeof(struct_variable_statique))) == NULL)
3067: {
3068: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3069: {
3070: (*s_etat_processus).erreur_systeme = d_es_processus;
3071: return(NULL);
3072: }
3073:
3074: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3075: return(NULL);
3076: }
3077:
3078: for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
3079: {
3080: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom =
3081: malloc((strlen((*s_etat_processus).s_liste_variables_statiques
3082: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3083: {
3084: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3085: {
3086: (*s_etat_processus).erreur_systeme = d_es_processus;
3087: return(NULL);
3088: }
3089:
3090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3091: return(NULL);
3092: }
3093:
3094: strcpy((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom,
3095: (*s_etat_processus).s_liste_variables_statiques[i].nom);
3096:
3097: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine =
3098: (*s_etat_processus).s_liste_variables_statiques[i].origine;
3099: (*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau =
3100: (*s_etat_processus).s_liste_variables_statiques[i].niveau;
3101: (*s_nouvel_etat_processus).s_liste_variables_statiques[i]
3102: .variable_statique = (*s_etat_processus)
3103: .s_liste_variables_statiques[i].variable_statique;
3104:
3105: if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet =
3106: copie_objet(s_etat_processus, (*s_etat_processus)
3107: .s_liste_variables_statiques[i].objet, 'P')) == NULL)
3108: {
3109: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3110: {
3111: (*s_etat_processus).erreur_systeme = d_es_processus;
3112: return(NULL);
3113: }
3114:
3115: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3116: return(NULL);
3117: }
3118: }
3119:
3120: /*
3121: * Copie de la pile opérationnelle
3122: */
3123:
3124: (*s_nouvel_etat_processus).l_base_pile = NULL;
3125: l_element_lecture = (*s_etat_processus).l_base_pile;
3126: l_element_precedent = NULL;
3127:
3128: while(l_element_lecture != NULL)
3129: {
3130: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3131: {
3132: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3133: {
3134: (*s_etat_processus).erreur_systeme = d_es_processus;
3135: return(NULL);
3136: }
3137:
3138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3139: return(NULL);
3140: }
3141:
3142: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3143: (*l_element_lecture).donnee, 'P')) == NULL)
3144: {
3145: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3146: {
3147: (*s_etat_processus).erreur_systeme = d_es_processus;
3148: return(NULL);
3149: }
3150:
3151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3152: return(NULL);
3153: }
3154:
3155: (*l_element_suivant).suivant = NULL;
3156:
3157: if ((*s_nouvel_etat_processus).l_base_pile == NULL)
3158: {
3159: (*s_nouvel_etat_processus).l_base_pile = l_element_suivant;
3160: }
3161: else
3162: {
3163: (*l_element_precedent).suivant = l_element_suivant;
3164: }
3165:
3166: l_element_precedent = l_element_suivant;
3167: l_element_lecture = (*l_element_lecture).suivant;
3168: }
3169:
3170: /*
3171: * Copie de la pile système
3172: */
3173:
3174: (*s_nouvel_etat_processus).l_base_pile_systeme = NULL;
3175: (*s_nouvel_etat_processus).hauteur_pile_systeme = 0;
3176:
3177: empilement_pile_systeme(s_nouvel_etat_processus);
3178:
3179: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3180: {
3181: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3182: {
3183: (*s_etat_processus).erreur_systeme = d_es_processus;
3184: return(NULL);
3185: }
3186:
3187: (*s_etat_processus).erreur_systeme =
3188: (*s_nouvel_etat_processus).erreur_systeme;
3189: return(NULL);
3190: }
3191:
3192: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3193:
3194: /*
3195: * On empile deux valeurs retour_definition pour pouvoir récupérer
3196: * les variables dans le cas d'un programme compilé.
3197: */
3198:
3199: empilement_pile_systeme(s_nouvel_etat_processus);
3200:
3201: if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
3202: {
3203: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3204: {
3205: (*s_etat_processus).erreur_systeme = d_es_processus;
3206: return(NULL);
3207: }
3208:
3209: (*s_etat_processus).erreur_systeme =
3210: (*s_nouvel_etat_processus).erreur_systeme;
3211: return(NULL);
3212: }
3213:
3214: (*(*s_nouvel_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
3215:
3216: /*
3217: * Destruction de la pile last pour le thread en cours.
3218: */
3219:
3220: (*s_nouvel_etat_processus).l_base_pile_last = NULL;
3221: (*s_nouvel_etat_processus).l_base_pile_processus = NULL;
3222:
3223: /*
3224: * Copie des différents contextes
3225: */
3226:
3227: (*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
3228: l_element_lecture = (*s_etat_processus).l_base_pile_contextes;
3229:
3230: while(l_element_lecture != NULL)
3231: {
3232: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3233: {
3234: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3235: {
3236: (*s_etat_processus).erreur_systeme = d_es_processus;
3237: return(NULL);
3238: }
3239:
3240: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3241: return(NULL);
3242: }
3243:
3244: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3245: (*l_element_lecture).donnee, 'P')) == NULL)
3246: {
3247: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3248: {
3249: (*s_etat_processus).erreur_systeme = d_es_processus;
3250: return(NULL);
3251: }
3252:
3253: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3254: return(NULL);
3255: }
3256:
3257: (*l_element_suivant).suivant = NULL;
3258:
3259: if ((*s_nouvel_etat_processus).l_base_pile_contextes == NULL)
3260: {
3261: (*s_nouvel_etat_processus).l_base_pile_contextes =
3262: l_element_suivant;
3263: }
3264: else
3265: {
3266: (*l_element_precedent).suivant = l_element_suivant;
3267: }
3268:
3269: l_element_precedent = l_element_suivant;
3270: l_element_lecture = (*l_element_lecture).suivant;
3271: }
3272:
3273: (*s_nouvel_etat_processus).l_base_pile_taille_contextes = NULL;
3274: l_element_lecture = (*s_etat_processus).l_base_pile_taille_contextes;
3275:
3276: while(l_element_lecture != NULL)
3277: {
3278: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3279: {
3280: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3281: {
3282: (*s_etat_processus).erreur_systeme = d_es_processus;
3283: return(NULL);
3284: }
3285:
3286: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3287: return(NULL);
3288: }
3289:
3290: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3291: (*l_element_lecture).donnee, 'P')) == NULL)
3292: {
3293: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3294: {
3295: (*s_etat_processus).erreur_systeme = d_es_processus;
3296: return(NULL);
3297: }
3298:
3299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3300: return(NULL);
3301: }
3302:
3303: (*l_element_suivant).suivant = NULL;
3304:
3305: if ((*s_nouvel_etat_processus).l_base_pile_taille_contextes == NULL)
3306: {
3307: (*s_nouvel_etat_processus).l_base_pile_taille_contextes =
3308: l_element_suivant;
3309: }
3310: else
3311: {
3312: (*l_element_precedent).suivant = l_element_suivant;
3313: }
3314:
3315: l_element_precedent = l_element_suivant;
3316: l_element_lecture = (*l_element_lecture).suivant;
3317: }
3318:
3319: /*
3320: * Copies des piles s_sockets, s_bibliotheques et
3321: * s_instructions_externes.
3322: */
3323:
3324: (*s_nouvel_etat_processus).s_sockets = NULL;
3325: l_element_lecture = (*s_etat_processus).s_sockets;
3326:
3327: while(l_element_lecture != NULL)
3328: {
3329: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3330: {
3331: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3332: {
3333: (*s_etat_processus).erreur_systeme = d_es_processus;
3334: return(NULL);
3335: }
3336:
3337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3338: return(NULL);
3339: }
3340:
3341: if (((*l_element_suivant).donnee = copie_objet(s_etat_processus,
3342: (*l_element_lecture).donnee, 'P')) == NULL)
3343: {
3344: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3345: {
3346: (*s_etat_processus).erreur_systeme = d_es_processus;
3347: return(NULL);
3348: }
3349:
3350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3351: return(NULL);
3352: }
3353:
3354: (*l_element_suivant).suivant = NULL;
3355:
3356: if ((*s_nouvel_etat_processus).s_sockets == NULL)
3357: {
3358: (*s_nouvel_etat_processus).s_sockets = l_element_suivant;
3359: }
3360: else
3361: {
3362: (*l_element_precedent).suivant = l_element_suivant;
3363: }
3364:
3365: l_element_precedent = l_element_suivant;
3366: l_element_lecture = (*l_element_lecture).suivant;
3367: }
3368:
3369: (*s_nouvel_etat_processus).s_bibliotheques = NULL;
3370: l_element_precedent = NULL;
3371: l_element_lecture = (*s_etat_processus).s_bibliotheques;
3372:
3373: while(l_element_lecture != NULL)
3374: {
3375: if ((l_element_suivant = malloc(sizeof(struct_liste_chainee))) == NULL)
3376: {
3377: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3378: {
3379: (*s_etat_processus).erreur_systeme = d_es_processus;
3380: return(NULL);
3381: }
3382:
3383: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3384: return(NULL);
3385: }
3386:
3387: if (((*l_element_suivant).donnee = malloc(sizeof(struct_bibliotheque)))
3388: == NULL)
3389: {
3390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3391: return(NULL);
3392: }
3393:
3394: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).descripteur
3395: = (*((struct_bibliotheque *) (*l_element_lecture).donnee))
3396: .descripteur;
3397: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).pid
3398: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).pid;
3399: (*((struct_bibliotheque *) (*l_element_suivant).donnee)).tid
3400: = (*((struct_bibliotheque *) (*l_element_lecture).donnee)).tid;
3401:
3402: if (((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom =
3403: malloc((strlen((*((struct_bibliotheque *) (*l_element_lecture)
3404: .donnee)).nom) + 1) * sizeof(unsigned char))) == NULL)
3405: {
3406: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3407: {
3408: (*s_etat_processus).erreur_systeme = d_es_processus;
3409: return(NULL);
3410: }
3411:
3412: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3413: return(NULL);
3414: }
3415:
3416: strcpy((*((struct_bibliotheque *) (*l_element_suivant).donnee)).nom,
3417: (*((struct_bibliotheque *) (*l_element_lecture).donnee)).nom);
3418:
3419: (*l_element_suivant).suivant = NULL;
3420:
3421: if ((*s_nouvel_etat_processus).s_bibliotheques == NULL)
3422: {
3423: (*s_nouvel_etat_processus).s_bibliotheques = l_element_suivant;
3424: }
3425: else
3426: {
3427: (*l_element_precedent).suivant = l_element_suivant;
3428: }
3429:
3430: l_element_precedent = l_element_suivant;
3431: l_element_lecture = (*l_element_lecture).suivant;
3432: }
3433:
3434: if ((*s_etat_processus).nombre_instructions_externes != 0)
3435: {
3436: if (((*s_nouvel_etat_processus).s_instructions_externes =
3437: malloc((*s_etat_processus).nombre_instructions_externes *
3438: sizeof(struct_instruction_externe))) == NULL)
3439: {
3440: (*s_etat_processus).erreur_systeme = d_es_processus;
3441: return(NULL);
3442: }
3443:
3444: for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
3445: {
3446: if (((*s_nouvel_etat_processus).s_instructions_externes[i].nom =
3447: malloc((strlen((*s_etat_processus).s_instructions_externes
3448: [i].nom) + 1) * sizeof(unsigned char))) == NULL)
3449: {
3450: (*s_etat_processus).erreur_systeme = d_es_processus;
3451: return(NULL);
3452: }
3453:
3454: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i].nom,
3455: (*s_etat_processus).s_instructions_externes[i].nom);
3456:
3457: if (((*s_nouvel_etat_processus).s_instructions_externes[i]
3458: .nom_bibliotheque = malloc((strlen((*s_etat_processus)
3459: .s_instructions_externes[i].nom_bibliotheque) + 1) *
3460: sizeof(unsigned char))) == NULL)
3461: {
3462: (*s_etat_processus).erreur_systeme = d_es_processus;
3463: return(NULL);
3464: }
3465:
3466: strcpy((*s_nouvel_etat_processus).s_instructions_externes[i]
3467: .nom_bibliotheque, (*s_etat_processus)
3468: .s_instructions_externes[i].nom_bibliotheque);
3469:
3470: (*s_nouvel_etat_processus).s_instructions_externes[i]
3471: .descripteur_bibliotheque = (*s_etat_processus)
3472: .s_instructions_externes[i].descripteur_bibliotheque;
3473: }
3474: }
3475: else
3476: {
3477: (*s_nouvel_etat_processus).s_instructions_externes = NULL;
3478: }
3479:
3480: pthread_mutexattr_init(&attributs_mutex);
3481: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
3482: pthread_mutex_init(&((*s_nouvel_etat_processus).mutex), &attributs_mutex);
3483: pthread_mutexattr_destroy(&attributs_mutex);
3484:
3485: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
3486: {
3487: (*s_etat_processus).erreur_systeme = d_es_processus;
3488: return(NULL);
3489: }
3490:
3491: return(s_nouvel_etat_processus);
3492:
3493: #undef return
3494: }
3495:
3496: // vim: ts=4