1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.19
4: Copyright (C) 1989-2015 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'var'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_var(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_statistique;
42: struct_objet *s_objet_resultat;
43: struct_objet *s_objet_temporaire;
44:
45: integer8 nombre_colonnes;
46:
47: (*s_etat_processus).erreur_execution = d_ex;
48:
49: if ((*s_etat_processus).affichage_arguments == 'Y')
50: {
51: printf("\n VAR ");
52:
53: if ((*s_etat_processus).langue == 'F')
54: {
55: printf("(variance)\n\n");
56: }
57: else
58: {
59: printf("(variance)\n\n");
60: }
61:
62: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: /*
81: * Recherche d'une variable globale référencée par SIGMA
82: */
83:
84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
85: {
86: /*
87: * Aucune variable SIGMA
88: */
89:
90: (*s_etat_processus).erreur_systeme = d_es;
91:
92: if ((*s_etat_processus).erreur_execution == d_ex)
93: {
94: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
95: }
96:
97: return;
98: }
99: else
100: {
101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
102: .type != MIN) && ((*(*(*s_etat_processus)
103: .pointeur_variable_courante).objet).type != MRL))
104: {
105: (*s_etat_processus).erreur_execution =
106: d_ex_matrice_statistique_invalide;
107: return;
108: }
109:
110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
111: .pointeur_variable_courante).objet).objet))
112: .nombre_colonnes;
113: }
114:
115: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
116: .objet;
117:
118: if (((*s_objet_statistique).type == MIN) ||
119: ((*s_objet_statistique).type == MRL))
120: {
121: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
122: <= 1)
123: {
124: (*s_etat_processus).erreur_execution =
125: d_ex_statistiques_echantillon;
126: return;
127: }
128:
129: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
130: {
131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
132: return;
133: }
134:
135: if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *)
136: (*s_objet_statistique).objet, 'E')) == NULL)
137: {
138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
139: return;
140: }
141:
142: if (nombre_colonnes == 1)
143: {
144: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
145: {
146: (*s_objet_resultat).type = VIN;
147: s_objet_temporaire = s_objet_resultat;
148:
149: if ((s_objet_resultat = allocation(s_etat_processus, INT))
150: == NULL)
151: {
152: (*s_etat_processus).erreur_systeme =
153: d_es_allocation_memoire;
154: return;
155: }
156:
157: (*((integer8 *) (*s_objet_resultat).objet)) =
158: ((integer8 *) (*((struct_vecteur *)
159: (*s_objet_temporaire).objet)).tableau)[0];
160:
161: liberation(s_etat_processus, s_objet_temporaire);
162: }
163: else
164: {
165: (*s_objet_resultat).type = VRL;
166: s_objet_temporaire = s_objet_resultat;
167:
168: if ((s_objet_resultat = allocation(s_etat_processus, REL))
169: == NULL)
170: {
171: (*s_etat_processus).erreur_systeme =
172: d_es_allocation_memoire;
173: return;
174: }
175:
176: (*((real8 *) (*s_objet_resultat).objet)) =
177: ((real8 *) (*((struct_vecteur *)
178: (*s_objet_temporaire).objet)).tableau)[0];
179:
180: liberation(s_etat_processus, s_objet_temporaire);
181: }
182: }
183: else
184: {
185: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
186: {
187: (*s_objet_resultat).type = VIN;
188: }
189: else
190: {
191: (*s_objet_resultat).type = VRL;
192: }
193: }
194:
195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
196: s_objet_resultat) == d_erreur)
197: {
198: return;
199: }
200: }
201: else
202: {
203: (*s_etat_processus).erreur_execution =
204: d_ex_matrice_statistique_invalide;
205: return;
206: }
207:
208: return;
209: }
210:
211:
212: /*
213: ================================================================================
214: Fonction 'version'
215: ================================================================================
216: Entrées :
217: --------------------------------------------------------------------------------
218: Sorties :
219: --------------------------------------------------------------------------------
220: Effets de bord : néant
221: ================================================================================
222: */
223:
224: void
225: instruction_version(struct_processus *s_etat_processus)
226: {
227: int nombre_champs;
228:
229: integer8 i1;
230: integer8 i2;
231: integer8 i3;
232: integer8 i4;
233:
234: struct_liste_chainee *l_element_courant;
235: struct_liste_chainee *l_element_interne_courant;
236:
237: struct_objet *s_objet_resultat;
238:
239: unsigned char texte[] = "RPL/2 version ";
240: unsigned char tampon[256 + 1];
241:
242: (*s_etat_processus).erreur_execution = d_ex;
243:
244: if ((*s_etat_processus).affichage_arguments == 'Y')
245: {
246: printf("\n VERSION ");
247:
248: if ((*s_etat_processus).langue == 'F')
249: {
250: printf("(version du séquenceur)\n\n");
251: }
252: else
253: {
254: printf("(sequencer version)\n\n");
255: }
256:
257: printf("-> 1: %s\n", d_LST);
258:
259: return;
260: }
261: else if ((*s_etat_processus).test_instruction == 'Y')
262: {
263: (*s_etat_processus).nombre_arguments = -1;
264: return;
265: }
266:
267: if (test_cfsf(s_etat_processus, 31) == d_vrai)
268: {
269: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
270: {
271: return;
272: }
273: }
274:
275: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
276: {
277: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
278: return;
279: }
280:
281: if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus))
282: == NULL)
283: {
284: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
285: return;
286: }
287:
288: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
289: (*l_element_courant).suivant = NULL;
290:
291: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
292: == NULL)
293: {
294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
295: return;
296: }
297:
298: if (((*(*l_element_courant).donnee).objet = malloc((strlen(texte)
299: + strlen(d_version_rpl) + 1) * sizeof(unsigned char))) == NULL)
300: {
301: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
302: return;
303: }
304:
305: sprintf((unsigned char *) (*(*l_element_courant).donnee).objet, "%s%s",
306: texte, d_version_rpl);
307:
308: /*
309: * Ajout des versions X.Y.Z sous forme d'entiers
310: */
311:
312: i1 = 0;
313: i2 = 0;
314: i3 = 0;
315: i4 = 0;
316:
317: nombre_champs = sscanf(d_version_rpl, "%lld.%lld.%lld.prerelease.%lld",
318: &i1, &i2, &i3, &i4);
319:
320: if (((*l_element_courant).suivant =
321: allocation_maillon(s_etat_processus)) == NULL)
322: {
323: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
324: return;
325: }
326:
327: l_element_courant = (*l_element_courant).suivant;
328: (*l_element_courant).suivant = NULL;
329:
330: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
331: == NULL)
332: {
333: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
334: return;
335: }
336:
337: if (((*(*l_element_courant).donnee).objet =
338: allocation_maillon(s_etat_processus)) == NULL)
339: {
340: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
341: return;
342: }
343:
344: l_element_interne_courant = (struct_liste_chainee *)
345: (*(*l_element_courant).donnee).objet;
346:
347: (*l_element_interne_courant).suivant = NULL;
348:
349: if (((*l_element_interne_courant).donnee =
350: allocation(s_etat_processus, INT)) == NULL)
351: {
352: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
353: return;
354: }
355:
356: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i1;
357:
358: if (((*l_element_interne_courant).suivant =
359: allocation_maillon(s_etat_processus)) == NULL)
360: {
361: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
362: return;
363: }
364:
365: l_element_interne_courant = (*l_element_interne_courant).suivant;
366: (*l_element_interne_courant).suivant = NULL;
367:
368: if (((*l_element_interne_courant).donnee =
369: allocation(s_etat_processus, INT)) == NULL)
370: {
371: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
372: return;
373: }
374:
375: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i2;
376:
377: if (((*l_element_interne_courant).suivant =
378: allocation_maillon(s_etat_processus)) == NULL)
379: {
380: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
381: return;
382: }
383:
384: l_element_interne_courant = (*l_element_interne_courant).suivant;
385: (*l_element_interne_courant).suivant = NULL;
386:
387: if (((*l_element_interne_courant).donnee =
388: allocation(s_etat_processus, INT)) == NULL)
389: {
390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
391: return;
392: }
393:
394: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i3;
395:
396: /*
397: * Ajout de "PRERELEASE" suivi d'un entier ou de "RELEASE"
398: */
399:
400: if (nombre_champs == 3)
401: {
402: // Version "RELEASE"
403:
404: if (((*l_element_interne_courant).suivant =
405: allocation_maillon(s_etat_processus)) == NULL)
406: {
407: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
408: return;
409: }
410:
411: l_element_interne_courant = (*l_element_interne_courant).suivant;
412: (*l_element_interne_courant).suivant = NULL;
413:
414: if (((*l_element_interne_courant).donnee =
415: allocation(s_etat_processus, CHN)) == NULL)
416: {
417: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
418: return;
419: }
420:
421: if (((*(*l_element_interne_courant).donnee).objet = malloc(8 *
422: sizeof(unsigned char))) == NULL)
423: {
424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
425: return;
426: }
427:
428: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
429: "RELEASE");
430: }
431: else
432: {
433: // Version "PRERELEASE"
434:
435: if (((*l_element_interne_courant).suivant =
436: allocation_maillon(s_etat_processus)) == NULL)
437: {
438: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
439: return;
440: }
441:
442: l_element_interne_courant = (*l_element_interne_courant).suivant;
443: (*l_element_interne_courant).suivant = NULL;
444:
445: if (((*l_element_interne_courant).donnee =
446: allocation(s_etat_processus, CHN)) == NULL)
447: {
448: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
449: return;
450: }
451:
452: if (((*(*l_element_interne_courant).donnee).objet = malloc(11 *
453: sizeof(unsigned char))) == NULL)
454: {
455: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
456: return;
457: }
458:
459: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
460: "PRERELEASE");
461:
462: if (((*l_element_interne_courant).suivant =
463: allocation_maillon(s_etat_processus)) == NULL)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
466: return;
467: }
468:
469: l_element_interne_courant = (*l_element_interne_courant).suivant;
470: (*l_element_interne_courant).suivant = NULL;
471:
472: if (((*l_element_interne_courant).donnee =
473: allocation(s_etat_processus, INT)) == NULL)
474: {
475: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
476: return;
477: }
478:
479: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i4;
480: }
481:
482: /*
483: * Ajout de la date de compilation
484: */
485:
486: if (((*l_element_courant).suivant =
487: allocation_maillon(s_etat_processus)) == NULL)
488: {
489: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
490: return;
491: }
492:
493: l_element_courant = (*l_element_courant).suivant;
494: (*l_element_courant).suivant = NULL;
495:
496: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
497: == NULL)
498: {
499: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
500: return;
501: }
502:
503: if (((*(*l_element_courant).donnee).objet = date_compilation()) == NULL)
504: {
505: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
506: return;
507: }
508:
509: /*
510: * Ajout des options de compilation
511: */
512:
513: if (((*l_element_courant).suivant =
514: allocation_maillon(s_etat_processus)) == NULL)
515: {
516: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
517: return;
518: }
519:
520: l_element_courant = (*l_element_courant).suivant;
521: (*l_element_courant).suivant = NULL;
522:
523: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
524: == NULL)
525: {
526: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
527: return;
528: }
529:
530: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path)
531: + 1) * sizeof(unsigned char))) == NULL)
532: {
533: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
534: return;
535: }
536:
537: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
538: d_exec_path);
539:
540: if (((*l_element_courant).suivant =
541: allocation_maillon(s_etat_processus)) == NULL)
542: {
543: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
544: return;
545: }
546:
547: l_element_courant = (*l_element_courant).suivant;
548: (*l_element_courant).suivant = NULL;
549:
550: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
551: == NULL)
552: {
553: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
554: return;
555: }
556:
557: #ifdef GNUPLOT_SUPPORT
558: if (((*(*l_element_courant).donnee).objet = malloc(8 *
559: sizeof(unsigned char))) == NULL)
560: {
561: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
562: return;
563: }
564:
565: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
566: "GNUPLOT");
567: #else
568: if (((*(*l_element_courant).donnee).objet = malloc(17 *
569: sizeof(unsigned char))) == NULL)
570: {
571: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
572: return;
573: }
574:
575: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
576: "GNUPLOT DISABLED");
577: #endif
578:
579: if (((*l_element_courant).suivant =
580: allocation_maillon(s_etat_processus)) == NULL)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
583: return;
584: }
585:
586: l_element_courant = (*l_element_courant).suivant;
587: (*l_element_courant).suivant = NULL;
588:
589: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
590: == NULL)
591: {
592: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
593: return;
594: }
595:
596: #ifdef FORCE_GNUPLOT_PATH
597: if (((*(*l_element_courant).donnee).objet = malloc(19 *
598: sizeof(unsigned char))) == NULL)
599: {
600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
601: return;
602: }
603:
604: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
605: "FORCE GNUPLOT PATH");
606: #else
607: if (((*(*l_element_courant).donnee).objet = malloc(21 *
608: sizeof(unsigned char))) == NULL)
609: {
610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
611: return;
612: }
613:
614: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
615: "DEFAULT GNUPLOT PATH");
616: #endif
617:
618: if (((*l_element_courant).suivant =
619: allocation_maillon(s_etat_processus)) == NULL)
620: {
621: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
622: return;
623: }
624:
625: l_element_courant = (*l_element_courant).suivant;
626: (*l_element_courant).suivant = NULL;
627:
628: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
629: == NULL)
630: {
631: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
632: return;
633: }
634:
635: #ifdef POSTSCRIPT_SUPPORT
636: if (((*(*l_element_courant).donnee).objet = malloc(11 *
637: sizeof(unsigned char))) == NULL)
638: {
639: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
640: return;
641: }
642:
643: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
644: "POSTSCRIPT");
645: #else
646: if (((*(*l_element_courant).donnee).objet = malloc(20 *
647: sizeof(unsigned char))) == NULL)
648: {
649: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
650: return;
651: }
652:
653: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
654: "POSTSCRIPT DISABLED");
655: #endif
656:
657: if (((*l_element_courant).suivant =
658: allocation_maillon(s_etat_processus)) == NULL)
659: {
660: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
661: return;
662: }
663:
664: l_element_courant = (*l_element_courant).suivant;
665: (*l_element_courant).suivant = NULL;
666:
667: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
668: == NULL)
669: {
670: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
671: return;
672: }
673:
674: #ifdef VIM_SUPPORT
675: if (((*(*l_element_courant).donnee).objet = malloc(4 *
676: sizeof(unsigned char))) == NULL)
677: {
678: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
679: return;
680: }
681:
682: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
683: "VIM");
684: #else
685: if (((*(*l_element_courant).donnee).objet = malloc(13 *
686: sizeof(unsigned char))) == NULL)
687: {
688: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
689: return;
690: }
691:
692: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
693: "VIM DISABLED");
694: #endif
695:
696: if (((*l_element_courant).suivant =
697: allocation_maillon(s_etat_processus)) == NULL)
698: {
699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
700: return;
701: }
702:
703: l_element_courant = (*l_element_courant).suivant;
704: (*l_element_courant).suivant = NULL;
705:
706: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
707: == NULL)
708: {
709: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
710: return;
711: }
712:
713: #ifdef MYSQL_SUPPORT
714: if (((*(*l_element_courant).donnee).objet = malloc(6 *
715: sizeof(unsigned char))) == NULL)
716: {
717: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
718: return;
719: }
720:
721: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
722: "MYSQL");
723: #else
724: if (((*(*l_element_courant).donnee).objet = malloc(15 *
725: sizeof(unsigned char))) == NULL)
726: {
727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
728: return;
729: }
730:
731: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
732: "MYSQL DISABLED");
733: #endif
734:
735: if (((*l_element_courant).suivant =
736: allocation_maillon(s_etat_processus)) == NULL)
737: {
738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
739: return;
740: }
741:
742: l_element_courant = (*l_element_courant).suivant;
743: (*l_element_courant).suivant = NULL;
744:
745: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
746: == NULL)
747: {
748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
749: return;
750: }
751:
752: #ifdef POSTGRESQL_SUPPORT
753: if (((*(*l_element_courant).donnee).objet = malloc(11 *
754: sizeof(unsigned char))) == NULL)
755: {
756: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
757: return;
758: }
759:
760: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
761: "POSTGRESQL");
762: #else
763: if (((*(*l_element_courant).donnee).objet = malloc(20 *
764: sizeof(unsigned char))) == NULL)
765: {
766: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
767: return;
768: }
769:
770: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
771: "POSTGRESQL DISABLED");
772: #endif
773:
774: if (((*l_element_courant).suivant =
775: allocation_maillon(s_etat_processus)) == NULL)
776: {
777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
778: return;
779: }
780:
781: l_element_courant = (*l_element_courant).suivant;
782: (*l_element_courant).suivant = NULL;
783:
784: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
785: == NULL)
786: {
787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
788: return;
789: }
790:
791: #ifdef MOTIF_SUPPORT
792: if (((*(*l_element_courant).donnee).objet = malloc(6 *
793: sizeof(unsigned char))) == NULL)
794: {
795: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
796: return;
797: }
798:
799: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
800: "MOTIF");
801: #else
802: if (((*(*l_element_courant).donnee).objet = malloc(15 *
803: sizeof(unsigned char))) == NULL)
804: {
805: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
806: return;
807: }
808:
809: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
810: "MOTIF DISABLED");
811: #endif
812:
813: if (((*l_element_courant).suivant =
814: allocation_maillon(s_etat_processus)) == NULL)
815: {
816: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
817: return;
818: }
819:
820: l_element_courant = (*l_element_courant).suivant;
821: (*l_element_courant).suivant = NULL;
822:
823: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
824: == NULL)
825: {
826: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
827: return;
828: }
829:
830: #ifdef RPLCAS
831: if (((*(*l_element_courant).donnee).objet = malloc(8 *
832: sizeof(unsigned char))) == NULL)
833: {
834: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
835: return;
836: }
837:
838: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
839: "RPL/CAS");
840: #else
841: if (((*(*l_element_courant).donnee).objet = malloc(17 *
842: sizeof(unsigned char))) == NULL)
843: {
844: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
845: return;
846: }
847:
848: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
849: "RPL/CAS DISABLED");
850: #endif
851:
852: if (((*l_element_courant).suivant =
853: allocation_maillon(s_etat_processus)) == NULL)
854: {
855: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
856: return;
857: }
858:
859: l_element_courant = (*l_element_courant).suivant;
860: (*l_element_courant).suivant = NULL;
861:
862: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
863: == NULL)
864: {
865: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
866: return;
867: }
868:
869: #ifdef EXPERIMENTAL_CODE
870: if (((*(*l_element_courant).donnee).objet = malloc(18 *
871: sizeof(unsigned char))) == NULL)
872: {
873: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
874: return;
875: }
876:
877: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
878: "EXPERIMENTAL CODE");
879: #else
880: if (((*(*l_element_courant).donnee).objet = malloc(27 *
881: sizeof(unsigned char))) == NULL)
882: {
883: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
884: return;
885: }
886:
887: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
888: "EXPERIMENTAL CODE DISABLED");
889: #endif
890:
891: if (((*l_element_courant).suivant =
892: allocation_maillon(s_etat_processus)) == NULL)
893: {
894: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
895: return;
896: }
897:
898: l_element_courant = (*l_element_courant).suivant;
899: (*l_element_courant).suivant = NULL;
900:
901: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
902: == NULL)
903: {
904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
905: return;
906: }
907:
908: sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);
909:
910: if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
911: * sizeof(unsigned char))) == NULL)
912: {
913: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
914: return;
915: }
916:
917: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tampon);
918:
919: if (((*l_element_courant).suivant =
920: allocation_maillon(s_etat_processus)) == NULL)
921: {
922: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
923: return;
924: }
925:
926: l_element_courant = (*l_element_courant).suivant;
927: (*l_element_courant).suivant = NULL;
928:
929: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
930: == NULL)
931: {
932: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
933: return;
934: }
935:
936: if (((*(*l_element_courant).donnee).objet = conversion_majuscule(HOST))
937: == NULL)
938: {
939: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
940: return;
941: }
942:
943: /*
944: * Empilement du résultat
945: */
946:
947: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
948: s_objet_resultat) == d_erreur)
949: {
950: return;
951: }
952:
953: return;
954: }
955:
956:
957: /*
958: ================================================================================
959: Fonction 'vars'
960: ================================================================================
961: Entrées :
962: --------------------------------------------------------------------------------
963: Sorties :
964: --------------------------------------------------------------------------------
965: Effets de bord : néant
966: ================================================================================
967: */
968:
969: void
970: instruction_vars(struct_processus *s_etat_processus)
971: {
972: integer8 i;
973: integer8 nb_variables;
974:
975: logical1 variable_partagee;
976:
977: struct_liste_chainee *l_element_courant;
978: struct_liste_chainee *l_element_precedent;
979:
980: struct_objet *s_objet_resultat;
981:
982: struct_tableau_variables *tableau;
983:
984: (*s_etat_processus).erreur_execution = d_ex;
985:
986: if ((*s_etat_processus).affichage_arguments == 'Y')
987: {
988: printf("\n VARS ");
989:
990: if ((*s_etat_processus).langue == 'F')
991: {
992: printf("(liste des variables)\n\n");
993: }
994: else
995: {
996: printf("(list of variables)\n\n");
997: }
998:
999: printf("-> 1: %s\n", d_LST);
1000:
1001: return;
1002: }
1003: else if ((*s_etat_processus).test_instruction == 'Y')
1004: {
1005: (*s_etat_processus).nombre_arguments = -1;
1006: return;
1007: }
1008:
1009: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1010: {
1011: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1012: {
1013: return;
1014: }
1015: }
1016:
1017: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1018: {
1019: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1020: return;
1021: }
1022:
1023: (*s_objet_resultat).objet = NULL;
1024: l_element_precedent = NULL;
1025:
1026: nb_variables = nombre_variables(s_etat_processus);
1027:
1028: if ((tableau = malloc(((size_t) nb_variables) *
1029: sizeof(struct_tableau_variables))) == NULL)
1030: {
1031: liberation_mutexes_arbre_variables_partagees(s_etat_processus,
1032: (*(*s_etat_processus).s_arbre_variables_partagees));
1033: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1034: return;
1035: }
1036:
1037: nb_variables = liste_variables(s_etat_processus, tableau);
1038:
1039: for(i = 0; i < nb_variables; i++)
1040: {
1041: if (l_element_precedent == NULL)
1042: {
1043: if (((*s_objet_resultat).objet =
1044: allocation_maillon(s_etat_processus)) == NULL)
1045: {
1046: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1047: return;
1048: }
1049:
1050: l_element_courant = (struct_liste_chainee *)
1051: (*s_objet_resultat).objet;
1052: (*l_element_courant).suivant = NULL;
1053: }
1054: else
1055: {
1056: if (((*l_element_precedent).suivant =
1057: allocation_maillon(s_etat_processus)) == NULL)
1058: {
1059: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1060: return;
1061: }
1062:
1063: l_element_courant = (*l_element_precedent).suivant;
1064: (*l_element_courant).suivant = NULL;
1065: }
1066:
1067: /*
1068: * Allocation de la liste incluse
1069: */
1070:
1071: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
1072: == NULL)
1073: {
1074: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1075: return;
1076: }
1077:
1078: if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
1079: allocation_maillon(s_etat_processus)) == NULL)
1080: {
1081: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1082: return;
1083: }
1084:
1085: /*
1086: * Mise en place d'un verrou si la variable est partagée.
1087: */
1088:
1089: if (tableau[i].objet == NULL)
1090: {
1091: if (recherche_variable_partagee(s_etat_processus,
1092: tableau[i].nom, tableau[i].variable_partagee,
1093: tableau[i].origine) == NULL)
1094: {
1095: // La variable partagée n'existe plus.
1096: continue;
1097: }
1098:
1099: variable_partagee = d_vrai;
1100: }
1101: else
1102: {
1103: variable_partagee = d_faux;
1104: }
1105:
1106: /*
1107: * Mise en place du nom de la variable
1108: */
1109:
1110: if (((*((struct_liste_chainee *) (*((struct_objet *)
1111: (*l_element_courant).donnee)).objet)).donnee =
1112: allocation(s_etat_processus, NOM)) == NULL)
1113: {
1114: if (variable_partagee == d_vrai)
1115: {
1116: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1117: .pointeur_variable_partagee_courante).mutex)) != 0)
1118: {
1119: (*s_etat_processus).erreur_systeme = d_es_processus;
1120: return;
1121: }
1122: }
1123:
1124: if (tableau[i].mutex != NULL)
1125: {
1126: // La variable est une variable partagée. On libère le mutex.
1127: pthread_mutex_unlock(tableau[i].mutex);
1128: }
1129:
1130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1131: return;
1132: }
1133:
1134: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1135: (*l_element_courant).donnee)).objet)).donnee).objet))
1136: .symbole = d_vrai;
1137:
1138: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1139: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
1140: malloc((strlen(tableau[i].nom)
1141: + 1) * sizeof(unsigned char))) == NULL)
1142: {
1143: if (variable_partagee == d_vrai)
1144: {
1145: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1146: .pointeur_variable_partagee_courante).mutex)) != 0)
1147: {
1148: (*s_etat_processus).erreur_systeme = d_es_processus;
1149: return;
1150: }
1151: }
1152:
1153: if (tableau[i].mutex != NULL)
1154: {
1155: // La variable est une variable partagée. On libère le mutex.
1156: pthread_mutex_unlock(tableau[i].mutex);
1157: }
1158:
1159: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1160: return;
1161: }
1162:
1163: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
1164: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1165: .donnee).objet)).nom, tableau[i].nom);
1166:
1167: /*
1168: * Préparation du niveau
1169: */
1170:
1171: if (((*((struct_liste_chainee *) (*((struct_objet *)
1172: (*l_element_courant).donnee)).objet)).suivant =
1173: allocation_maillon(s_etat_processus)) == NULL)
1174: {
1175: if (variable_partagee == d_vrai)
1176: {
1177: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1178: .pointeur_variable_partagee_courante).mutex)) != 0)
1179: {
1180: (*s_etat_processus).erreur_systeme = d_es_processus;
1181: return;
1182: }
1183: }
1184:
1185: if (tableau[i].mutex != NULL)
1186: {
1187: // La variable est une variable partagée. On libère le mutex.
1188: pthread_mutex_unlock(tableau[i].mutex);
1189: }
1190:
1191: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1192: return;
1193: }
1194:
1195: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1196: (*l_element_courant).donnee)).objet)).suivant).donnee =
1197: allocation(s_etat_processus, INT)) == NULL)
1198: {
1199: if (variable_partagee == d_vrai)
1200: {
1201: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1202: .pointeur_variable_partagee_courante).mutex)) != 0)
1203: {
1204: (*s_etat_processus).erreur_systeme = d_es_processus;
1205: return;
1206: }
1207: }
1208:
1209: if (tableau[i].mutex != NULL)
1210: {
1211: // La variable est une variable partagée. On libère le mutex.
1212: pthread_mutex_unlock(tableau[i].mutex);
1213: }
1214:
1215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1216: return;
1217: }
1218:
1219: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
1220: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
1221: (integer8) tableau[i].niveau;
1222:
1223: /*
1224: * Préparation du contenu de la variable
1225: */
1226:
1227: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1228: (*l_element_courant).donnee)).objet)).suivant).suivant =
1229: allocation_maillon(s_etat_processus)) == NULL)
1230: {
1231: if (variable_partagee == d_vrai)
1232: {
1233: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1234: .pointeur_variable_partagee_courante).mutex)) != 0)
1235: {
1236: (*s_etat_processus).erreur_systeme = d_es_processus;
1237: return;
1238: }
1239: }
1240:
1241: if (tableau[i].mutex != NULL)
1242: {
1243: // La variable est une variable partagée. On libère le mutex.
1244: pthread_mutex_unlock(tableau[i].mutex);
1245: }
1246:
1247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1248: return;
1249: }
1250:
1251: if (tableau[i].objet == NULL)
1252: {
1253: // Variable partagée
1254:
1255: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1256: (*l_element_courant).donnee)).objet)).suivant).suivant)
1257: .donnee = copie_objet(s_etat_processus,
1258: (*(*s_etat_processus).pointeur_variable_partagee_courante)
1259: .objet, 'P')) == NULL)
1260: {
1261: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1262: .pointeur_variable_partagee_courante).mutex)) != 0)
1263: {
1264: (*s_etat_processus).erreur_systeme = d_es_processus;
1265: return;
1266: }
1267:
1268: if (tableau[i].mutex != NULL)
1269: {
1270: // La variable est une variable partagée. On libère
1271: // le mutex.
1272: pthread_mutex_unlock(tableau[i].mutex);
1273: }
1274:
1275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1276: return;
1277: }
1278:
1279: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1280: .pointeur_variable_partagee_courante).mutex)) != 0)
1281: {
1282: if (tableau[i].mutex != NULL)
1283: {
1284: // La variable est une variable partagée. On libère
1285: // le mutex.
1286: pthread_mutex_unlock(tableau[i].mutex);
1287: }
1288:
1289: (*s_etat_processus).erreur_systeme = d_es_processus;
1290: return;
1291: }
1292: }
1293: else
1294: {
1295: // Variable privée
1296:
1297: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1298: (*l_element_courant).donnee)).objet)).suivant).suivant)
1299: .donnee = copie_objet(s_etat_processus, tableau[i].objet,
1300: 'P')) == NULL)
1301: {
1302: if (tableau[i].mutex != NULL)
1303: {
1304: // La variable est une variable partagée. On libère
1305: // le mutex.
1306: pthread_mutex_unlock(tableau[i].mutex);
1307: }
1308:
1309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1310: return;
1311: }
1312: }
1313:
1314: /*
1315: * Préparation du drapeau STATIC/VOLATILE
1316: */
1317:
1318: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1319: (*l_element_courant).donnee)).objet)).suivant).suivant)
1320: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1321: {
1322: if (tableau[i].mutex != NULL)
1323: {
1324: // La variable est une variable partagée. On libère le mutex.
1325: pthread_mutex_unlock(tableau[i].mutex);
1326: }
1327:
1328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1329: return;
1330: }
1331:
1332: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1333: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1334: .donnee = allocation(s_etat_processus, CHN)) == NULL)
1335: {
1336: if (tableau[i].mutex != NULL)
1337: {
1338: // La variable est une variable partagée. On libère le mutex.
1339: pthread_mutex_unlock(tableau[i].mutex);
1340: }
1341:
1342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1343: return;
1344: }
1345:
1346: if ((tableau[i].origine == 'P')
1347: ? (tableau[i].variable_statique.adresse != 0)
1348: : (tableau[i].variable_statique.pointeur != NULL))
1349: {
1350: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1351: (*l_element_courant).donnee)).objet)).suivant).suivant)
1352: .suivant).donnee).objet = malloc(7 *
1353: sizeof(unsigned char))) == NULL)
1354: {
1355: if (tableau[i].mutex != NULL)
1356: {
1357: // La variable est une variable partagée. On libère
1358: // le mutex.
1359: pthread_mutex_unlock(tableau[i].mutex);
1360: }
1361:
1362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1363: return;
1364: }
1365:
1366: if (tableau[i].variable_masquee == d_vrai)
1367: {
1368: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1369: (*((struct_objet *) (*l_element_courant).donnee))
1370: .objet)).suivant).suivant).suivant).donnee).objet,
1371: "SHADOW");
1372: }
1373: else
1374: {
1375: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1376: (*((struct_objet *) (*l_element_courant).donnee))
1377: .objet)).suivant).suivant).suivant).donnee).objet,
1378: "STATIC");
1379: }
1380: }
1381: else
1382: {
1383: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1384: (*l_element_courant).donnee)).objet)).suivant).suivant)
1385: .suivant).donnee).objet = malloc(9 *
1386: sizeof(unsigned char))) == NULL)
1387: {
1388: if (tableau[i].mutex != NULL)
1389: {
1390: // La variable est une variable partagée. On libère
1391: // le mutex.
1392: pthread_mutex_unlock(tableau[i].mutex);
1393: }
1394:
1395: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1396: return;
1397: }
1398:
1399: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1400: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1401: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
1402: }
1403:
1404: /*
1405: * Préparation du drapeau LOCKED/UNLOCKED
1406: */
1407:
1408: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1409: (*l_element_courant).donnee)).objet)).suivant).suivant)
1410: .suivant).suivant = allocation_maillon(s_etat_processus))
1411: == NULL)
1412: {
1413: if (tableau[i].mutex != NULL)
1414: {
1415: // La variable est une variable partagée. On libère le mutex.
1416: pthread_mutex_unlock(tableau[i].mutex);
1417: }
1418:
1419: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1420: return;
1421: }
1422:
1423: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1424: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1425: .suivant).donnee = allocation(s_etat_processus, CHN))
1426: == NULL)
1427: {
1428: if (tableau[i].mutex != NULL)
1429: {
1430: // La variable est une variable partagée. On libère le mutex.
1431: pthread_mutex_unlock(tableau[i].mutex);
1432: }
1433:
1434: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1435: return;
1436: }
1437:
1438: if (tableau[i].variable_verrouillee == d_vrai)
1439: {
1440: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1441: (*l_element_courant).donnee)).objet)).suivant).suivant)
1442: .suivant).suivant).donnee).objet = malloc(7 *
1443: sizeof(unsigned char))) == NULL)
1444: {
1445: if (tableau[i].mutex != NULL)
1446: {
1447: // La variable est une variable partagée. On libère
1448: // le mutex.
1449: pthread_mutex_unlock(tableau[i].mutex);
1450: }
1451:
1452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1453: return;
1454: }
1455:
1456: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1457: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1458: .suivant).suivant).suivant).suivant).donnee).objet,
1459: "LOCKED");
1460: }
1461: else
1462: {
1463: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1464: (*l_element_courant).donnee)).objet)).suivant).suivant)
1465: .suivant).suivant).donnee).objet = malloc(9 *
1466: sizeof(unsigned char))) == NULL)
1467: {
1468: if (tableau[i].mutex != NULL)
1469: {
1470: // La variable est une variable partagée. On libère
1471: // le mutex.
1472: pthread_mutex_unlock(tableau[i].mutex);
1473: }
1474:
1475: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1476: return;
1477: }
1478:
1479: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1480: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1481: .suivant).suivant).suivant).suivant).donnee).objet,
1482: "UNLOCKED");
1483: }
1484:
1485: /*
1486: * Préparation du drapeau PRIVATE/SHARED/MAPPED
1487: */
1488:
1489: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1490: (*l_element_courant).donnee)).objet)).suivant).suivant)
1491: .suivant).suivant).suivant =
1492: allocation_maillon(s_etat_processus)) == NULL)
1493: {
1494: if (tableau[i].mutex != NULL)
1495: {
1496: // La variable est une variable partagée. On libère le mutex.
1497: pthread_mutex_unlock(tableau[i].mutex);
1498: }
1499:
1500: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1501: return;
1502: }
1503:
1504: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1505: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1506: .suivant).suivant).donnee = allocation(s_etat_processus,
1507: CHN)) == NULL)
1508: {
1509: if (tableau[i].mutex != NULL)
1510: {
1511: // La variable est une variable partagée. On libère le mutex.
1512: pthread_mutex_unlock(tableau[i].mutex);
1513: }
1514:
1515: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1516: return;
1517: }
1518:
1519: if (variable_partagee == d_vrai)
1520: {
1521: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1522: (*l_element_courant).donnee)).objet)).suivant).suivant)
1523: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1524: sizeof(unsigned char))) == NULL)
1525: {
1526: if (tableau[i].mutex != NULL)
1527: {
1528: // La variable est une variable partagée. On libère
1529: // le mutex.
1530: pthread_mutex_unlock(tableau[i].mutex);
1531: }
1532:
1533: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1534: return;
1535: }
1536:
1537: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1538: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1539: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1540: "MAPPED");
1541: }
1542: else if (tableau[i].mutex != NULL)
1543: {
1544: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1545: (*l_element_courant).donnee)).objet)).suivant).suivant)
1546: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1547: sizeof(unsigned char))) == NULL)
1548: {
1549: if (tableau[i].mutex != NULL)
1550: {
1551: // La variable est une variable partagée. On libère
1552: // le mutex.
1553: pthread_mutex_unlock(tableau[i].mutex);
1554: }
1555:
1556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1557: return;
1558: }
1559:
1560: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1561: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1562: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1563: "SHARED");
1564: }
1565: else
1566: {
1567: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1568: (*l_element_courant).donnee)).objet)).suivant).suivant)
1569: .suivant).suivant).suivant).donnee).objet = malloc(8 *
1570: sizeof(unsigned char))) == NULL)
1571: {
1572: if (tableau[i].mutex != NULL)
1573: {
1574: // La variable est une variable partagée. On libère
1575: // le mutex.
1576: pthread_mutex_unlock(tableau[i].mutex);
1577: }
1578:
1579: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1580: return;
1581: }
1582:
1583: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1584: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1585: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1586: "PRIVATE");
1587: }
1588:
1589: /*
1590: * Fermeture de la liste incluse
1591: */
1592:
1593: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1594: (*l_element_courant).donnee)).objet)).suivant).suivant)
1595: .suivant).suivant).suivant).suivant = NULL;
1596:
1597: l_element_precedent = l_element_courant;
1598:
1599: if (tableau[i].mutex != NULL)
1600: {
1601: // La variable est une variable partagée. On libère
1602: // le mutex.
1603: pthread_mutex_unlock(tableau[i].mutex);
1604: }
1605: }
1606:
1607: free(tableau);
1608:
1609: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1610: s_objet_resultat) == d_erreur)
1611: {
1612: return;
1613: }
1614:
1615: return;
1616: }
1617:
1618:
1619: /*
1620: ================================================================================
1621: Fonction 'visit'
1622: ================================================================================
1623: Entrées :
1624: --------------------------------------------------------------------------------
1625: Sorties :
1626: --------------------------------------------------------------------------------
1627: Effets de bord : néant
1628: ================================================================================
1629: */
1630:
1631: void
1632: instruction_visit(struct_processus *s_etat_processus)
1633: {
1634: struct_liste_chainee *registre_pile_last;
1635:
1636: struct_objet *s_objet;
1637:
1638: integer8 profondeur_initiale;
1639:
1640: (*s_etat_processus).erreur_execution = d_ex;
1641:
1642: if ((*s_etat_processus).affichage_arguments == 'Y')
1643: {
1644: printf("\n VISIT ");
1645:
1646: if ((*s_etat_processus).langue == 'F')
1647: {
1648: printf("(édition d'une variable)\n\n");
1649: }
1650: else
1651: {
1652: printf("(edit variable)\n\n");
1653: }
1654:
1655: printf(" 1: %s\n", d_NOM);
1656:
1657: return;
1658: }
1659: else if ((*s_etat_processus).test_instruction == 'Y')
1660: {
1661: (*s_etat_processus).nombre_arguments = -1;
1662: return;
1663: }
1664:
1665: registre_pile_last = NULL;
1666:
1667: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1668: {
1669: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1670: {
1671: return;
1672: }
1673:
1674: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1675: (*s_etat_processus).l_base_pile_last = NULL;
1676: }
1677:
1678: if ((*s_etat_processus).l_base_pile == NULL)
1679: {
1680: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1681: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1682: return;
1683: }
1684:
1685: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1686: {
1687: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1688: &s_objet) == d_erreur)
1689: {
1690: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1691: return;
1692: }
1693:
1694: liberation(s_etat_processus, s_objet);
1695:
1696: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1697: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1698: return;
1699: }
1700:
1701: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1702: instruction_dup(s_etat_processus);
1703:
1704: if (((*s_etat_processus).erreur_systeme != d_es) ||
1705: ((*s_etat_processus).erreur_execution != d_ex) ||
1706: ((*s_etat_processus).exception != d_ep))
1707: {
1708: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1709: {
1710: return;
1711: }
1712:
1713: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1714:
1715: return;
1716: }
1717:
1718: instruction_rcl(s_etat_processus);
1719:
1720: if (((*s_etat_processus).erreur_systeme != d_es) ||
1721: ((*s_etat_processus).erreur_execution != d_ex) ||
1722: ((*s_etat_processus).exception != d_ep))
1723: {
1724: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1725: &s_objet) == d_erreur)
1726: {
1727: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1728: return;
1729: }
1730:
1731: liberation(s_etat_processus, s_objet);
1732:
1733: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1734: {
1735: return;
1736: }
1737:
1738: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1739:
1740: return;
1741: }
1742:
1743: instruction_edit(s_etat_processus);
1744:
1745: if (((*s_etat_processus).erreur_systeme != d_es) ||
1746: ((*s_etat_processus).erreur_execution != d_ex) ||
1747: ((*s_etat_processus).exception != d_ep))
1748: {
1749: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1750: {
1751: return;
1752: }
1753:
1754: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1755:
1756: return;
1757: }
1758:
1759: while(profondeur_initiale != ((*s_etat_processus)
1760: .hauteur_pile_operationnelle - 1))
1761: {
1762: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1763: &s_objet) == d_erreur)
1764: {
1765: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1766: return;
1767: }
1768:
1769: liberation(s_etat_processus, s_objet);
1770: }
1771:
1772: instruction_swap(s_etat_processus);
1773:
1774: if (((*s_etat_processus).erreur_systeme != d_es) ||
1775: ((*s_etat_processus).erreur_execution != d_ex) ||
1776: ((*s_etat_processus).exception != d_ep))
1777: {
1778: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1779: {
1780: return;
1781: }
1782:
1783: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1784:
1785: return;
1786: }
1787:
1788: instruction_sto(s_etat_processus);
1789:
1790: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1791: {
1792: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1793: {
1794: return;
1795: }
1796:
1797: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1798: }
1799:
1800: return;
1801: }
1802:
1803:
1804: /*
1805: ================================================================================
1806: Fonction 'variable'
1807: ================================================================================
1808: Entrées :
1809: --------------------------------------------------------------------------------
1810: Sorties :
1811: --------------------------------------------------------------------------------
1812: Effets de bord : néant
1813: ================================================================================
1814: */
1815:
1816: void
1817: instruction_variable(struct_processus *s_etat_processus)
1818: {
1819: struct_liste_chainee *l_element_courant;
1820:
1821: struct_objet *s_objet;
1822:
1823: (*s_etat_processus).erreur_execution = d_ex;
1824:
1825: if ((*s_etat_processus).affichage_arguments == 'Y')
1826: {
1827: printf("\n VARIABLE ");
1828:
1829: if ((*s_etat_processus).langue == 'F')
1830: {
1831: printf("(déverrouille une variable globale)\n\n");
1832: }
1833: else
1834: {
1835: printf("(unlock a global variable)\n\n");
1836: }
1837:
1838: printf(" 1: %s, %s\n", d_NOM, d_LST);
1839:
1840: return;
1841: }
1842: else if ((*s_etat_processus).test_instruction == 'Y')
1843: {
1844: (*s_etat_processus).nombre_arguments = -1;
1845: return;
1846: }
1847:
1848: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1849: {
1850: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1851: {
1852: return;
1853: }
1854: }
1855:
1856: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1857: &s_objet) == d_erreur)
1858: {
1859: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1860: return;
1861: }
1862:
1863: if ((*s_objet).type == NOM)
1864: {
1865: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1866: (*s_objet).objet)).nom)) == d_faux)
1867: {
1868: liberation(s_etat_processus, s_objet);
1869:
1870: (*s_etat_processus).erreur_systeme = d_es;
1871: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1872: return;
1873: }
1874:
1875: (*(*s_etat_processus).pointeur_variable_courante)
1876: .variable_verrouillee = d_faux;
1877: }
1878: else if ((*s_objet).type == LST)
1879: {
1880: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1881:
1882: while(l_element_courant != NULL)
1883: {
1884: if ((*(*l_element_courant).donnee).type != NOM)
1885: {
1886: liberation(s_etat_processus, s_objet);
1887:
1888: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1889: return;
1890: }
1891:
1892: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1893: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1894: {
1895: liberation(s_etat_processus, s_objet);
1896:
1897: (*s_etat_processus).erreur_systeme = d_es;
1898: (*s_etat_processus).erreur_execution =
1899: d_ex_variable_non_definie;
1900: return;
1901: }
1902:
1903: (*(*s_etat_processus).pointeur_variable_courante)
1904: .variable_verrouillee = d_faux;
1905:
1906: l_element_courant = (*l_element_courant).suivant;
1907: }
1908: }
1909: else
1910: {
1911: liberation(s_etat_processus, s_objet);
1912:
1913: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1914: return;
1915: }
1916:
1917: liberation(s_etat_processus, s_objet);
1918:
1919: return;
1920: }
1921:
1922: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_v1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src