1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.32
4: Copyright (C) 1989-2020 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(s_etat_processus,
136: (struct_matrice *) (*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 =
504: date_compilation(s_etat_processus)) == NULL)
505: {
506: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
507: return;
508: }
509:
510: /*
511: * Ajout des options de compilation
512: */
513:
514: if (((*l_element_courant).suivant =
515: allocation_maillon(s_etat_processus)) == NULL)
516: {
517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
518: return;
519: }
520:
521: l_element_courant = (*l_element_courant).suivant;
522: (*l_element_courant).suivant = NULL;
523:
524: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
525: == NULL)
526: {
527: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
528: return;
529: }
530:
531: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path)
532: + 1) * sizeof(unsigned char))) == NULL)
533: {
534: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
535: return;
536: }
537:
538: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
539: d_exec_path);
540:
541: if (((*l_element_courant).suivant =
542: allocation_maillon(s_etat_processus)) == NULL)
543: {
544: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
545: return;
546: }
547:
548: l_element_courant = (*l_element_courant).suivant;
549: (*l_element_courant).suivant = NULL;
550:
551: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
552: == NULL)
553: {
554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
555: return;
556: }
557:
558: #ifdef GNUPLOT_SUPPORT
559: if (((*(*l_element_courant).donnee).objet = malloc(8 *
560: sizeof(unsigned char))) == NULL)
561: {
562: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
563: return;
564: }
565:
566: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
567: "GNUPLOT");
568: #else
569: if (((*(*l_element_courant).donnee).objet = malloc(17 *
570: sizeof(unsigned char))) == NULL)
571: {
572: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
573: return;
574: }
575:
576: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
577: "GNUPLOT DISABLED");
578: #endif
579:
580: if (((*l_element_courant).suivant =
581: allocation_maillon(s_etat_processus)) == NULL)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
584: return;
585: }
586:
587: l_element_courant = (*l_element_courant).suivant;
588: (*l_element_courant).suivant = NULL;
589:
590: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
591: == NULL)
592: {
593: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
594: return;
595: }
596:
597: #ifdef FORCE_GNUPLOT_PATH
598: if (((*(*l_element_courant).donnee).objet = malloc(19 *
599: sizeof(unsigned char))) == NULL)
600: {
601: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
602: return;
603: }
604:
605: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
606: "FORCE GNUPLOT PATH");
607: #else
608: if (((*(*l_element_courant).donnee).objet = malloc(21 *
609: sizeof(unsigned char))) == NULL)
610: {
611: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
612: return;
613: }
614:
615: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
616: "DEFAULT GNUPLOT PATH");
617: #endif
618:
619: if (((*l_element_courant).suivant =
620: allocation_maillon(s_etat_processus)) == NULL)
621: {
622: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
623: return;
624: }
625:
626: l_element_courant = (*l_element_courant).suivant;
627: (*l_element_courant).suivant = NULL;
628:
629: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
630: == NULL)
631: {
632: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
633: return;
634: }
635:
636: #ifdef POSTSCRIPT_SUPPORT
637: if (((*(*l_element_courant).donnee).objet = malloc(11 *
638: sizeof(unsigned char))) == NULL)
639: {
640: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
641: return;
642: }
643:
644: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
645: "POSTSCRIPT");
646: #else
647: if (((*(*l_element_courant).donnee).objet = malloc(20 *
648: sizeof(unsigned char))) == NULL)
649: {
650: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
651: return;
652: }
653:
654: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
655: "POSTSCRIPT DISABLED");
656: #endif
657:
658: if (((*l_element_courant).suivant =
659: allocation_maillon(s_etat_processus)) == NULL)
660: {
661: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
662: return;
663: }
664:
665: l_element_courant = (*l_element_courant).suivant;
666: (*l_element_courant).suivant = NULL;
667:
668: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
669: == NULL)
670: {
671: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
672: return;
673: }
674:
675: #ifdef VIM_SUPPORT
676: if (((*(*l_element_courant).donnee).objet = malloc(4 *
677: sizeof(unsigned char))) == NULL)
678: {
679: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
680: return;
681: }
682:
683: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
684: "VIM");
685: #else
686: if (((*(*l_element_courant).donnee).objet = malloc(13 *
687: sizeof(unsigned char))) == NULL)
688: {
689: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
690: return;
691: }
692:
693: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
694: "VIM DISABLED");
695: #endif
696:
697: if (((*l_element_courant).suivant =
698: allocation_maillon(s_etat_processus)) == NULL)
699: {
700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
701: return;
702: }
703:
704: l_element_courant = (*l_element_courant).suivant;
705: (*l_element_courant).suivant = NULL;
706:
707: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
708: == NULL)
709: {
710: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
711: return;
712: }
713:
714: #ifdef MYSQL_SUPPORT
715: if (((*(*l_element_courant).donnee).objet = malloc(6 *
716: sizeof(unsigned char))) == NULL)
717: {
718: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
719: return;
720: }
721:
722: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
723: "MYSQL");
724: #else
725: if (((*(*l_element_courant).donnee).objet = malloc(15 *
726: sizeof(unsigned char))) == NULL)
727: {
728: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
729: return;
730: }
731:
732: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
733: "MYSQL DISABLED");
734: #endif
735:
736: if (((*l_element_courant).suivant =
737: allocation_maillon(s_etat_processus)) == NULL)
738: {
739: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
740: return;
741: }
742:
743: l_element_courant = (*l_element_courant).suivant;
744: (*l_element_courant).suivant = NULL;
745:
746: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
747: == NULL)
748: {
749: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
750: return;
751: }
752:
753: #ifdef POSTGRESQL_SUPPORT
754: if (((*(*l_element_courant).donnee).objet = malloc(11 *
755: sizeof(unsigned char))) == NULL)
756: {
757: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
758: return;
759: }
760:
761: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
762: "POSTGRESQL");
763: #else
764: if (((*(*l_element_courant).donnee).objet = malloc(20 *
765: sizeof(unsigned char))) == NULL)
766: {
767: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
768: return;
769: }
770:
771: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
772: "POSTGRESQL DISABLED");
773: #endif
774:
775: if (((*l_element_courant).suivant =
776: allocation_maillon(s_etat_processus)) == NULL)
777: {
778: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
779: return;
780: }
781:
782: l_element_courant = (*l_element_courant).suivant;
783: (*l_element_courant).suivant = NULL;
784:
785: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
786: == NULL)
787: {
788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
789: return;
790: }
791:
792: #ifdef MOTIF_SUPPORT
793: if (((*(*l_element_courant).donnee).objet = malloc(6 *
794: sizeof(unsigned char))) == NULL)
795: {
796: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
797: return;
798: }
799:
800: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
801: "MOTIF");
802: #else
803: if (((*(*l_element_courant).donnee).objet = malloc(15 *
804: sizeof(unsigned char))) == NULL)
805: {
806: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
807: return;
808: }
809:
810: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
811: "MOTIF DISABLED");
812: #endif
813:
814: if (((*l_element_courant).suivant =
815: allocation_maillon(s_etat_processus)) == NULL)
816: {
817: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
818: return;
819: }
820:
821: l_element_courant = (*l_element_courant).suivant;
822: (*l_element_courant).suivant = NULL;
823:
824: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
825: == NULL)
826: {
827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
828: return;
829: }
830:
831: #ifdef RPLCAS
832: if (((*(*l_element_courant).donnee).objet = malloc(8 *
833: sizeof(unsigned char))) == NULL)
834: {
835: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
836: return;
837: }
838:
839: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
840: "RPL/CAS");
841: #else
842: if (((*(*l_element_courant).donnee).objet = malloc(17 *
843: sizeof(unsigned char))) == NULL)
844: {
845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
846: return;
847: }
848:
849: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
850: "RPL/CAS DISABLED");
851: #endif
852:
853: if (((*l_element_courant).suivant =
854: allocation_maillon(s_etat_processus)) == NULL)
855: {
856: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
857: return;
858: }
859:
860: l_element_courant = (*l_element_courant).suivant;
861: (*l_element_courant).suivant = NULL;
862:
863: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
864: == NULL)
865: {
866: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
867: return;
868: }
869:
870: #ifdef EXPERIMENTAL_CODE
871: if (((*(*l_element_courant).donnee).objet = malloc(18 *
872: sizeof(unsigned char))) == NULL)
873: {
874: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
875: return;
876: }
877:
878: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
879: "EXPERIMENTAL CODE");
880: #else
881: if (((*(*l_element_courant).donnee).objet = malloc(27 *
882: sizeof(unsigned char))) == NULL)
883: {
884: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
885: return;
886: }
887:
888: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
889: "EXPERIMENTAL CODE DISABLED");
890: #endif
891:
892: if (((*l_element_courant).suivant =
893: allocation_maillon(s_etat_processus)) == NULL)
894: {
895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
896: return;
897: }
898:
899: l_element_courant = (*l_element_courant).suivant;
900: (*l_element_courant).suivant = NULL;
901:
902: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
903: == NULL)
904: {
905: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
906: return;
907: }
908:
909: sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);
910:
911: if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
912: * sizeof(unsigned char))) == NULL)
913: {
914: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
915: return;
916: }
917:
918: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tampon);
919:
920: if (((*l_element_courant).suivant =
921: allocation_maillon(s_etat_processus)) == NULL)
922: {
923: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
924: return;
925: }
926:
927: l_element_courant = (*l_element_courant).suivant;
928: (*l_element_courant).suivant = NULL;
929:
930: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
931: == NULL)
932: {
933: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
934: return;
935: }
936:
937: if (((*(*l_element_courant).donnee).objet = conversion_majuscule(
938: s_etat_processus, HOST)) == NULL)
939: {
940: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
941: return;
942: }
943:
944: /*
945: * Empilement du résultat
946: */
947:
948: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
949: s_objet_resultat) == d_erreur)
950: {
951: return;
952: }
953:
954: return;
955: }
956:
957:
958: /*
959: ================================================================================
960: Fonction 'vars'
961: ================================================================================
962: Entrées :
963: --------------------------------------------------------------------------------
964: Sorties :
965: --------------------------------------------------------------------------------
966: Effets de bord : néant
967: ================================================================================
968: */
969:
970: void
971: instruction_vars(struct_processus *s_etat_processus)
972: {
973: integer8 i;
974: integer8 nb_variables;
975:
976: logical1 variable_partagee;
977:
978: struct_liste_chainee *l_element_courant;
979: struct_liste_chainee *l_element_precedent;
980:
981: struct_objet *s_objet_resultat;
982:
983: struct_tableau_variables *tableau;
984:
985: (*s_etat_processus).erreur_execution = d_ex;
986:
987: if ((*s_etat_processus).affichage_arguments == 'Y')
988: {
989: printf("\n VARS ");
990:
991: if ((*s_etat_processus).langue == 'F')
992: {
993: printf("(liste des variables)\n\n");
994: }
995: else
996: {
997: printf("(list of variables)\n\n");
998: }
999:
1000: printf("-> 1: %s\n", d_LST);
1001:
1002: return;
1003: }
1004: else if ((*s_etat_processus).test_instruction == 'Y')
1005: {
1006: (*s_etat_processus).nombre_arguments = -1;
1007: return;
1008: }
1009:
1010: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1011: {
1012: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1013: {
1014: return;
1015: }
1016: }
1017:
1018: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
1019: {
1020: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1021: return;
1022: }
1023:
1024: (*s_objet_resultat).objet = NULL;
1025: l_element_precedent = NULL;
1026:
1027: nb_variables = nombre_variables(s_etat_processus);
1028:
1029: if ((tableau = malloc(((size_t) nb_variables) *
1030: sizeof(struct_tableau_variables))) == NULL)
1031: {
1032: liberation_mutexes_arbre_variables_partagees(s_etat_processus,
1033: (*(*s_etat_processus).s_arbre_variables_partagees));
1034: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1035: return;
1036: }
1037:
1038: nb_variables = liste_variables(s_etat_processus, tableau);
1039:
1040: for(i = 0; i < nb_variables; i++)
1041: {
1042: if (l_element_precedent == NULL)
1043: {
1044: if (((*s_objet_resultat).objet =
1045: allocation_maillon(s_etat_processus)) == NULL)
1046: {
1047: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1048: return;
1049: }
1050:
1051: l_element_courant = (struct_liste_chainee *)
1052: (*s_objet_resultat).objet;
1053: (*l_element_courant).suivant = NULL;
1054: }
1055: else
1056: {
1057: if (((*l_element_precedent).suivant =
1058: allocation_maillon(s_etat_processus)) == NULL)
1059: {
1060: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1061: return;
1062: }
1063:
1064: l_element_courant = (*l_element_precedent).suivant;
1065: (*l_element_courant).suivant = NULL;
1066: }
1067:
1068: /*
1069: * Allocation de la liste incluse
1070: */
1071:
1072: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
1073: == NULL)
1074: {
1075: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1076: return;
1077: }
1078:
1079: if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
1080: allocation_maillon(s_etat_processus)) == NULL)
1081: {
1082: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1083: return;
1084: }
1085:
1086: /*
1087: * Mise en place d'un verrou si la variable est partagée.
1088: */
1089:
1090: if (tableau[i].objet == NULL)
1091: {
1092: if (recherche_variable_partagee(s_etat_processus,
1093: tableau[i].nom, tableau[i].variable_partagee,
1094: tableau[i].origine) == NULL)
1095: {
1096: // La variable partagée n'existe plus.
1097: continue;
1098: }
1099:
1100: variable_partagee = d_vrai;
1101: }
1102: else
1103: {
1104: variable_partagee = d_faux;
1105: }
1106:
1107: /*
1108: * Mise en place du nom de la variable
1109: */
1110:
1111: if (((*((struct_liste_chainee *) (*((struct_objet *)
1112: (*l_element_courant).donnee)).objet)).donnee =
1113: allocation(s_etat_processus, NOM)) == NULL)
1114: {
1115: if (variable_partagee == d_vrai)
1116: {
1117: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1118: .pointeur_variable_partagee_courante).mutex)) != 0)
1119: {
1120: (*s_etat_processus).erreur_systeme = d_es_processus;
1121: return;
1122: }
1123: }
1124:
1125: if (tableau[i].mutex != NULL)
1126: {
1127: // La variable est une variable partagée. On libère le mutex.
1128: pthread_mutex_unlock(tableau[i].mutex);
1129: }
1130:
1131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1132: return;
1133: }
1134:
1135: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1136: (*l_element_courant).donnee)).objet)).donnee).objet))
1137: .symbole = d_vrai;
1138:
1139: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1140: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
1141: malloc((strlen(tableau[i].nom)
1142: + 1) * sizeof(unsigned char))) == NULL)
1143: {
1144: if (variable_partagee == d_vrai)
1145: {
1146: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1147: .pointeur_variable_partagee_courante).mutex)) != 0)
1148: {
1149: (*s_etat_processus).erreur_systeme = d_es_processus;
1150: return;
1151: }
1152: }
1153:
1154: if (tableau[i].mutex != NULL)
1155: {
1156: // La variable est une variable partagée. On libère le mutex.
1157: pthread_mutex_unlock(tableau[i].mutex);
1158: }
1159:
1160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1161: return;
1162: }
1163:
1164: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
1165: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1166: .donnee).objet)).nom, tableau[i].nom);
1167:
1168: /*
1169: * Préparation du niveau
1170: */
1171:
1172: if (((*((struct_liste_chainee *) (*((struct_objet *)
1173: (*l_element_courant).donnee)).objet)).suivant =
1174: allocation_maillon(s_etat_processus)) == NULL)
1175: {
1176: if (variable_partagee == d_vrai)
1177: {
1178: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1179: .pointeur_variable_partagee_courante).mutex)) != 0)
1180: {
1181: (*s_etat_processus).erreur_systeme = d_es_processus;
1182: return;
1183: }
1184: }
1185:
1186: if (tableau[i].mutex != NULL)
1187: {
1188: // La variable est une variable partagée. On libère le mutex.
1189: pthread_mutex_unlock(tableau[i].mutex);
1190: }
1191:
1192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1193: return;
1194: }
1195:
1196: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1197: (*l_element_courant).donnee)).objet)).suivant).donnee =
1198: allocation(s_etat_processus, INT)) == NULL)
1199: {
1200: if (variable_partagee == d_vrai)
1201: {
1202: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1203: .pointeur_variable_partagee_courante).mutex)) != 0)
1204: {
1205: (*s_etat_processus).erreur_systeme = d_es_processus;
1206: return;
1207: }
1208: }
1209:
1210: if (tableau[i].mutex != NULL)
1211: {
1212: // La variable est une variable partagée. On libère le mutex.
1213: pthread_mutex_unlock(tableau[i].mutex);
1214: }
1215:
1216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1217: return;
1218: }
1219:
1220: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
1221: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
1222: (integer8) tableau[i].niveau;
1223:
1224: /*
1225: * Préparation du contenu de la variable
1226: */
1227:
1228: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1229: (*l_element_courant).donnee)).objet)).suivant).suivant =
1230: allocation_maillon(s_etat_processus)) == NULL)
1231: {
1232: if (variable_partagee == d_vrai)
1233: {
1234: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1235: .pointeur_variable_partagee_courante).mutex)) != 0)
1236: {
1237: (*s_etat_processus).erreur_systeme = d_es_processus;
1238: return;
1239: }
1240: }
1241:
1242: if (tableau[i].mutex != NULL)
1243: {
1244: // La variable est une variable partagée. On libère le mutex.
1245: pthread_mutex_unlock(tableau[i].mutex);
1246: }
1247:
1248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1249: return;
1250: }
1251:
1252: if (tableau[i].objet == NULL)
1253: {
1254: // Variable partagée
1255:
1256: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1257: (*l_element_courant).donnee)).objet)).suivant).suivant)
1258: .donnee = copie_objet(s_etat_processus,
1259: (*(*s_etat_processus).pointeur_variable_partagee_courante)
1260: .objet, 'P')) == NULL)
1261: {
1262: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1263: .pointeur_variable_partagee_courante).mutex)) != 0)
1264: {
1265: (*s_etat_processus).erreur_systeme = d_es_processus;
1266: return;
1267: }
1268:
1269: if (tableau[i].mutex != NULL)
1270: {
1271: // La variable est une variable partagée. On libère
1272: // le mutex.
1273: pthread_mutex_unlock(tableau[i].mutex);
1274: }
1275:
1276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1277: return;
1278: }
1279:
1280: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1281: .pointeur_variable_partagee_courante).mutex)) != 0)
1282: {
1283: if (tableau[i].mutex != NULL)
1284: {
1285: // La variable est une variable partagée. On libère
1286: // le mutex.
1287: pthread_mutex_unlock(tableau[i].mutex);
1288: }
1289:
1290: (*s_etat_processus).erreur_systeme = d_es_processus;
1291: return;
1292: }
1293: }
1294: else
1295: {
1296: // Variable privée
1297:
1298: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1299: (*l_element_courant).donnee)).objet)).suivant).suivant)
1300: .donnee = copie_objet(s_etat_processus, tableau[i].objet,
1301: 'P')) == NULL)
1302: {
1303: if (tableau[i].mutex != NULL)
1304: {
1305: // La variable est une variable partagée. On libère
1306: // le mutex.
1307: pthread_mutex_unlock(tableau[i].mutex);
1308: }
1309:
1310: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1311: return;
1312: }
1313: }
1314:
1315: /*
1316: * Préparation du drapeau STATIC/VOLATILE
1317: */
1318:
1319: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1320: (*l_element_courant).donnee)).objet)).suivant).suivant)
1321: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1322: {
1323: if (tableau[i].mutex != NULL)
1324: {
1325: // La variable est une variable partagée. On libère le mutex.
1326: pthread_mutex_unlock(tableau[i].mutex);
1327: }
1328:
1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1334: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1335: .donnee = allocation(s_etat_processus, CHN)) == NULL)
1336: {
1337: if (tableau[i].mutex != NULL)
1338: {
1339: // La variable est une variable partagée. On libère le mutex.
1340: pthread_mutex_unlock(tableau[i].mutex);
1341: }
1342:
1343: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1344: return;
1345: }
1346:
1347: if ((tableau[i].origine == 'P')
1348: ? (tableau[i].variable_statique.adresse != 0)
1349: : (tableau[i].variable_statique.pointeur != NULL))
1350: {
1351: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1352: (*l_element_courant).donnee)).objet)).suivant).suivant)
1353: .suivant).donnee).objet = malloc(7 *
1354: sizeof(unsigned char))) == NULL)
1355: {
1356: if (tableau[i].mutex != NULL)
1357: {
1358: // La variable est une variable partagée. On libère
1359: // le mutex.
1360: pthread_mutex_unlock(tableau[i].mutex);
1361: }
1362:
1363: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1364: return;
1365: }
1366:
1367: if (tableau[i].variable_masquee == d_vrai)
1368: {
1369: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1370: (*((struct_objet *) (*l_element_courant).donnee))
1371: .objet)).suivant).suivant).suivant).donnee).objet,
1372: "SHADOW");
1373: }
1374: else
1375: {
1376: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1377: (*((struct_objet *) (*l_element_courant).donnee))
1378: .objet)).suivant).suivant).suivant).donnee).objet,
1379: "STATIC");
1380: }
1381: }
1382: else
1383: {
1384: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1385: (*l_element_courant).donnee)).objet)).suivant).suivant)
1386: .suivant).donnee).objet = malloc(9 *
1387: sizeof(unsigned char))) == NULL)
1388: {
1389: if (tableau[i].mutex != NULL)
1390: {
1391: // La variable est une variable partagée. On libère
1392: // le mutex.
1393: pthread_mutex_unlock(tableau[i].mutex);
1394: }
1395:
1396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1397: return;
1398: }
1399:
1400: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1401: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1402: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
1403: }
1404:
1405: /*
1406: * Préparation du drapeau LOCKED/UNLOCKED
1407: */
1408:
1409: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1410: (*l_element_courant).donnee)).objet)).suivant).suivant)
1411: .suivant).suivant = allocation_maillon(s_etat_processus))
1412: == NULL)
1413: {
1414: if (tableau[i].mutex != NULL)
1415: {
1416: // La variable est une variable partagée. On libère le mutex.
1417: pthread_mutex_unlock(tableau[i].mutex);
1418: }
1419:
1420: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1421: return;
1422: }
1423:
1424: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1425: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1426: .suivant).donnee = allocation(s_etat_processus, CHN))
1427: == NULL)
1428: {
1429: if (tableau[i].mutex != NULL)
1430: {
1431: // La variable est une variable partagée. On libère le mutex.
1432: pthread_mutex_unlock(tableau[i].mutex);
1433: }
1434:
1435: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1436: return;
1437: }
1438:
1439: if (tableau[i].variable_verrouillee == d_vrai)
1440: {
1441: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1442: (*l_element_courant).donnee)).objet)).suivant).suivant)
1443: .suivant).suivant).donnee).objet = malloc(7 *
1444: sizeof(unsigned char))) == NULL)
1445: {
1446: if (tableau[i].mutex != NULL)
1447: {
1448: // La variable est une variable partagée. On libère
1449: // le mutex.
1450: pthread_mutex_unlock(tableau[i].mutex);
1451: }
1452:
1453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1454: return;
1455: }
1456:
1457: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1458: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1459: .suivant).suivant).suivant).suivant).donnee).objet,
1460: "LOCKED");
1461: }
1462: else
1463: {
1464: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1465: (*l_element_courant).donnee)).objet)).suivant).suivant)
1466: .suivant).suivant).donnee).objet = malloc(9 *
1467: sizeof(unsigned char))) == NULL)
1468: {
1469: if (tableau[i].mutex != NULL)
1470: {
1471: // La variable est une variable partagée. On libère
1472: // le mutex.
1473: pthread_mutex_unlock(tableau[i].mutex);
1474: }
1475:
1476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1477: return;
1478: }
1479:
1480: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1481: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1482: .suivant).suivant).suivant).suivant).donnee).objet,
1483: "UNLOCKED");
1484: }
1485:
1486: /*
1487: * Préparation du drapeau PRIVATE/SHARED/MAPPED
1488: */
1489:
1490: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1491: (*l_element_courant).donnee)).objet)).suivant).suivant)
1492: .suivant).suivant).suivant =
1493: allocation_maillon(s_etat_processus)) == NULL)
1494: {
1495: if (tableau[i].mutex != NULL)
1496: {
1497: // La variable est une variable partagée. On libère le mutex.
1498: pthread_mutex_unlock(tableau[i].mutex);
1499: }
1500:
1501: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1502: return;
1503: }
1504:
1505: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1506: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1507: .suivant).suivant).donnee = allocation(s_etat_processus,
1508: CHN)) == NULL)
1509: {
1510: if (tableau[i].mutex != NULL)
1511: {
1512: // La variable est une variable partagée. On libère le mutex.
1513: pthread_mutex_unlock(tableau[i].mutex);
1514: }
1515:
1516: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1517: return;
1518: }
1519:
1520: if (variable_partagee == d_vrai)
1521: {
1522: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1523: (*l_element_courant).donnee)).objet)).suivant).suivant)
1524: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1525: sizeof(unsigned char))) == NULL)
1526: {
1527: if (tableau[i].mutex != NULL)
1528: {
1529: // La variable est une variable partagée. On libère
1530: // le mutex.
1531: pthread_mutex_unlock(tableau[i].mutex);
1532: }
1533:
1534: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1535: return;
1536: }
1537:
1538: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1539: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1540: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1541: "MAPPED");
1542: }
1543: else if (tableau[i].mutex != NULL)
1544: {
1545: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1546: (*l_element_courant).donnee)).objet)).suivant).suivant)
1547: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1548: sizeof(unsigned char))) == NULL)
1549: {
1550: if (tableau[i].mutex != NULL)
1551: {
1552: // La variable est une variable partagée. On libère
1553: // le mutex.
1554: pthread_mutex_unlock(tableau[i].mutex);
1555: }
1556:
1557: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1558: return;
1559: }
1560:
1561: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1562: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1563: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1564: "SHARED");
1565: }
1566: else
1567: {
1568: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1569: (*l_element_courant).donnee)).objet)).suivant).suivant)
1570: .suivant).suivant).suivant).donnee).objet = malloc(8 *
1571: sizeof(unsigned char))) == NULL)
1572: {
1573: if (tableau[i].mutex != NULL)
1574: {
1575: // La variable est une variable partagée. On libère
1576: // le mutex.
1577: pthread_mutex_unlock(tableau[i].mutex);
1578: }
1579:
1580: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1581: return;
1582: }
1583:
1584: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1585: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1586: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1587: "PRIVATE");
1588: }
1589:
1590: /*
1591: * Fermeture de la liste incluse
1592: */
1593:
1594: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1595: (*l_element_courant).donnee)).objet)).suivant).suivant)
1596: .suivant).suivant).suivant).suivant = NULL;
1597:
1598: l_element_precedent = l_element_courant;
1599:
1600: if (tableau[i].mutex != NULL)
1601: {
1602: // La variable est une variable partagée. On libère
1603: // le mutex.
1604: pthread_mutex_unlock(tableau[i].mutex);
1605: }
1606: }
1607:
1608: free(tableau);
1609:
1610: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1611: s_objet_resultat) == d_erreur)
1612: {
1613: return;
1614: }
1615:
1616: return;
1617: }
1618:
1619:
1620: /*
1621: ================================================================================
1622: Fonction 'visit'
1623: ================================================================================
1624: Entrées :
1625: --------------------------------------------------------------------------------
1626: Sorties :
1627: --------------------------------------------------------------------------------
1628: Effets de bord : néant
1629: ================================================================================
1630: */
1631:
1632: void
1633: instruction_visit(struct_processus *s_etat_processus)
1634: {
1635: struct_liste_chainee *registre_pile_last;
1636:
1637: struct_objet *s_objet;
1638:
1639: integer8 profondeur_initiale;
1640:
1641: (*s_etat_processus).erreur_execution = d_ex;
1642:
1643: if ((*s_etat_processus).affichage_arguments == 'Y')
1644: {
1645: printf("\n VISIT ");
1646:
1647: if ((*s_etat_processus).langue == 'F')
1648: {
1649: printf("(édition d'une variable)\n\n");
1650: }
1651: else
1652: {
1653: printf("(edit variable)\n\n");
1654: }
1655:
1656: printf(" 1: %s\n", d_NOM);
1657:
1658: return;
1659: }
1660: else if ((*s_etat_processus).test_instruction == 'Y')
1661: {
1662: (*s_etat_processus).nombre_arguments = -1;
1663: return;
1664: }
1665:
1666: registre_pile_last = NULL;
1667:
1668: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1669: {
1670: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1671: {
1672: return;
1673: }
1674:
1675: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1676: (*s_etat_processus).l_base_pile_last = NULL;
1677: }
1678:
1679: if ((*s_etat_processus).l_base_pile == NULL)
1680: {
1681: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1682: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1683: return;
1684: }
1685:
1686: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1687: {
1688: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1689: &s_objet) == d_erreur)
1690: {
1691: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1692: return;
1693: }
1694:
1695: liberation(s_etat_processus, s_objet);
1696:
1697: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1698: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1699: return;
1700: }
1701:
1702: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1703: instruction_dup(s_etat_processus);
1704:
1705: if (((*s_etat_processus).erreur_systeme != d_es) ||
1706: ((*s_etat_processus).erreur_execution != d_ex) ||
1707: ((*s_etat_processus).exception != d_ep))
1708: {
1709: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1710: {
1711: return;
1712: }
1713:
1714: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1715:
1716: return;
1717: }
1718:
1719: instruction_rcl(s_etat_processus);
1720:
1721: if (((*s_etat_processus).erreur_systeme != d_es) ||
1722: ((*s_etat_processus).erreur_execution != d_ex) ||
1723: ((*s_etat_processus).exception != d_ep))
1724: {
1725: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1726: &s_objet) == d_erreur)
1727: {
1728: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1729: return;
1730: }
1731:
1732: liberation(s_etat_processus, s_objet);
1733:
1734: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1735: {
1736: return;
1737: }
1738:
1739: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1740:
1741: return;
1742: }
1743:
1744: instruction_edit(s_etat_processus);
1745:
1746: if (((*s_etat_processus).erreur_systeme != d_es) ||
1747: ((*s_etat_processus).erreur_execution != d_ex) ||
1748: ((*s_etat_processus).exception != d_ep))
1749: {
1750: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1751: {
1752: return;
1753: }
1754:
1755: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1756:
1757: return;
1758: }
1759:
1760: while(profondeur_initiale != ((*s_etat_processus)
1761: .hauteur_pile_operationnelle - 1))
1762: {
1763: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1764: &s_objet) == d_erreur)
1765: {
1766: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1767: return;
1768: }
1769:
1770: liberation(s_etat_processus, s_objet);
1771: }
1772:
1773: instruction_swap(s_etat_processus);
1774:
1775: if (((*s_etat_processus).erreur_systeme != d_es) ||
1776: ((*s_etat_processus).erreur_execution != d_ex) ||
1777: ((*s_etat_processus).exception != d_ep))
1778: {
1779: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1780: {
1781: return;
1782: }
1783:
1784: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1785:
1786: return;
1787: }
1788:
1789: instruction_sto(s_etat_processus);
1790:
1791: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1792: {
1793: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1794: {
1795: return;
1796: }
1797:
1798: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1799: }
1800:
1801: return;
1802: }
1803:
1804:
1805: /*
1806: ================================================================================
1807: Fonction 'variable'
1808: ================================================================================
1809: Entrées :
1810: --------------------------------------------------------------------------------
1811: Sorties :
1812: --------------------------------------------------------------------------------
1813: Effets de bord : néant
1814: ================================================================================
1815: */
1816:
1817: void
1818: instruction_variable(struct_processus *s_etat_processus)
1819: {
1820: struct_liste_chainee *l_element_courant;
1821:
1822: struct_objet *s_objet;
1823:
1824: (*s_etat_processus).erreur_execution = d_ex;
1825:
1826: if ((*s_etat_processus).affichage_arguments == 'Y')
1827: {
1828: printf("\n VARIABLE ");
1829:
1830: if ((*s_etat_processus).langue == 'F')
1831: {
1832: printf("(déverrouille une variable globale)\n\n");
1833: }
1834: else
1835: {
1836: printf("(unlock a global variable)\n\n");
1837: }
1838:
1839: printf(" 1: %s, %s\n", d_NOM, d_LST);
1840:
1841: return;
1842: }
1843: else if ((*s_etat_processus).test_instruction == 'Y')
1844: {
1845: (*s_etat_processus).nombre_arguments = -1;
1846: return;
1847: }
1848:
1849: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1850: {
1851: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1852: {
1853: return;
1854: }
1855: }
1856:
1857: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1858: &s_objet) == d_erreur)
1859: {
1860: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1861: return;
1862: }
1863:
1864: if ((*s_objet).type == NOM)
1865: {
1866: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1867: (*s_objet).objet)).nom)) == d_faux)
1868: {
1869: liberation(s_etat_processus, s_objet);
1870:
1871: (*s_etat_processus).erreur_systeme = d_es;
1872: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1873: return;
1874: }
1875:
1876: (*(*s_etat_processus).pointeur_variable_courante)
1877: .variable_verrouillee = d_faux;
1878: }
1879: else if ((*s_objet).type == LST)
1880: {
1881: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1882:
1883: while(l_element_courant != NULL)
1884: {
1885: if ((*(*l_element_courant).donnee).type != NOM)
1886: {
1887: liberation(s_etat_processus, s_objet);
1888:
1889: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1890: return;
1891: }
1892:
1893: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1894: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1895: {
1896: liberation(s_etat_processus, s_objet);
1897:
1898: (*s_etat_processus).erreur_systeme = d_es;
1899: (*s_etat_processus).erreur_execution =
1900: d_ex_variable_non_definie;
1901: return;
1902: }
1903:
1904: (*(*s_etat_processus).pointeur_variable_courante)
1905: .variable_verrouillee = d_faux;
1906:
1907: l_element_courant = (*l_element_courant).suivant;
1908: }
1909: }
1910: else
1911: {
1912: liberation(s_etat_processus, s_objet);
1913:
1914: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1915: return;
1916: }
1917:
1918: liberation(s_etat_processus, s_objet);
1919:
1920: return;
1921: }
1922:
1923: // 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