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