1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.9
4: Copyright (C) 1989-2012 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: unsigned long 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: int i;
973: int 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: (*s_etat_processus).s_arbre_variables);
1028:
1029: if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
1030: == NULL)
1031: {
1032: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1033: return;
1034: }
1035:
1036: liste_variables(s_etat_processus, tableau, 0,
1037: (*s_etat_processus).s_arbre_variables);
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 (pthread_mutex_lock(&((*(*s_etat_processus)
1092: .s_liste_variables_partagees).mutex)) != 0)
1093: {
1094: (*s_etat_processus).erreur_systeme = d_es_processus;
1095: return;
1096: }
1097:
1098: if (recherche_variable_partagee(s_etat_processus,
1099: tableau[i].nom, tableau[i].variable_partagee,
1100: tableau[i].origine) == d_faux)
1101: {
1102: // La variable partagée n'existe plus.
1103:
1104: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1105: .s_liste_variables_partagees).mutex)) != 0)
1106: {
1107: (*s_etat_processus).erreur_systeme = d_es_processus;
1108: return;
1109: }
1110:
1111: continue;
1112: }
1113:
1114: variable_partagee = d_vrai;
1115: }
1116: else
1117: {
1118: variable_partagee = d_faux;
1119: }
1120:
1121: /*
1122: * Mise en place du nom de la variable
1123: */
1124:
1125: if (((*((struct_liste_chainee *) (*((struct_objet *)
1126: (*l_element_courant).donnee)).objet)).donnee =
1127: allocation(s_etat_processus, NOM)) == NULL)
1128: {
1129: if (variable_partagee == d_vrai)
1130: {
1131: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1132: .s_liste_variables_partagees).mutex)) != 0)
1133: {
1134: (*s_etat_processus).erreur_systeme = d_es_processus;
1135: return;
1136: }
1137: }
1138:
1139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1140: return;
1141: }
1142:
1143: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1144: (*l_element_courant).donnee)).objet)).donnee).objet))
1145: .symbole = d_vrai;
1146:
1147: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1148: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
1149: malloc((strlen(tableau[i].nom)
1150: + 1) * sizeof(unsigned char))) == NULL)
1151: {
1152: if (variable_partagee == d_vrai)
1153: {
1154: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1155: .s_liste_variables_partagees).mutex)) != 0)
1156: {
1157: (*s_etat_processus).erreur_systeme = d_es_processus;
1158: return;
1159: }
1160: }
1161:
1162: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1163: return;
1164: }
1165:
1166: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
1167: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1168: .donnee).objet)).nom, tableau[i].nom);
1169:
1170: /*
1171: * Préparation du niveau
1172: */
1173:
1174: if (((*((struct_liste_chainee *) (*((struct_objet *)
1175: (*l_element_courant).donnee)).objet)).suivant =
1176: allocation_maillon(s_etat_processus)) == NULL)
1177: {
1178: if (variable_partagee == d_vrai)
1179: {
1180: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1181: .s_liste_variables_partagees).mutex)) != 0)
1182: {
1183: (*s_etat_processus).erreur_systeme = d_es_processus;
1184: return;
1185: }
1186: }
1187:
1188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1189: return;
1190: }
1191:
1192: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1193: (*l_element_courant).donnee)).objet)).suivant).donnee =
1194: allocation(s_etat_processus, INT)) == NULL)
1195: {
1196: if (variable_partagee == d_vrai)
1197: {
1198: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1199: .s_liste_variables_partagees).mutex)) != 0)
1200: {
1201: (*s_etat_processus).erreur_systeme = d_es_processus;
1202: return;
1203: }
1204: }
1205:
1206: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1207: return;
1208: }
1209:
1210: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
1211: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
1212: (integer8) tableau[i].niveau;
1213:
1214: /*
1215: * Préparation du contenu de la variable
1216: */
1217:
1218: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1219: (*l_element_courant).donnee)).objet)).suivant).suivant =
1220: allocation_maillon(s_etat_processus)) == NULL)
1221: {
1222: if (variable_partagee == d_vrai)
1223: {
1224: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1225: .s_liste_variables_partagees).mutex)) != 0)
1226: {
1227: (*s_etat_processus).erreur_systeme = d_es_processus;
1228: return;
1229: }
1230: }
1231:
1232: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1233: return;
1234: }
1235:
1236: if (tableau[i].objet == NULL)
1237: {
1238: // Variable partagée
1239:
1240: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1241: (*l_element_courant).donnee)).objet)).suivant).suivant)
1242: .donnee = copie_objet(s_etat_processus,
1243: (*(*s_etat_processus)
1244: .s_liste_variables_partagees).table[(*(*s_etat_processus)
1245: .s_liste_variables_partagees).position_variable].objet,
1246: 'P')) == NULL)
1247: {
1248: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1249: .s_liste_variables_partagees).mutex)) != 0)
1250: {
1251: (*s_etat_processus).erreur_systeme = d_es_processus;
1252: return;
1253: }
1254:
1255: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1256: return;
1257: }
1258:
1259: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1260: .s_liste_variables_partagees).mutex)) != 0)
1261: {
1262: (*s_etat_processus).erreur_systeme = d_es_processus;
1263: return;
1264: }
1265: }
1266: else
1267: {
1268: // Variable privée
1269:
1270: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1271: (*l_element_courant).donnee)).objet)).suivant).suivant)
1272: .donnee = copie_objet(s_etat_processus, tableau[i].objet,
1273: 'P')) == NULL)
1274: {
1275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1276: return;
1277: }
1278: }
1279:
1280: /*
1281: * Préparation du drapeau STATIC/VOLATILE
1282: */
1283:
1284: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1285: (*l_element_courant).donnee)).objet)).suivant).suivant)
1286: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1287: {
1288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1289: return;
1290: }
1291:
1292: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1293: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1294: .donnee = allocation(s_etat_processus, CHN)) == NULL)
1295: {
1296: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1297: return;
1298: }
1299:
1300: if ((tableau[i].origine == 'P')
1301: ? (tableau[i].variable_statique.adresse != 0)
1302: : (tableau[i].variable_statique.pointeur != NULL))
1303: {
1304: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1305: (*l_element_courant).donnee)).objet)).suivant).suivant)
1306: .suivant).donnee).objet = malloc(7 *
1307: sizeof(unsigned char))) == NULL)
1308: {
1309: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1310: return;
1311: }
1312:
1313: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1314: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1315: .suivant).suivant) .suivant).donnee).objet, "STATIC");
1316: }
1317: else
1318: {
1319: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1320: (*l_element_courant).donnee)).objet)).suivant).suivant)
1321: .suivant).donnee).objet = malloc(9 *
1322: sizeof(unsigned char))) == NULL)
1323: {
1324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1325: return;
1326: }
1327:
1328: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1329: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1330: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
1331: }
1332:
1333: /*
1334: * Préparation du drapeau LOCKED/UNLOCKED
1335: */
1336:
1337: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1338: (*l_element_courant).donnee)).objet)).suivant).suivant)
1339: .suivant).suivant = allocation_maillon(s_etat_processus))
1340: == NULL)
1341: {
1342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1343: return;
1344: }
1345:
1346: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1347: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1348: .suivant).donnee = allocation(s_etat_processus, CHN))
1349: == NULL)
1350: {
1351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1352: return;
1353: }
1354:
1355: if (tableau[i].variable_verrouillee == d_vrai)
1356: {
1357: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1358: (*l_element_courant).donnee)).objet)).suivant).suivant)
1359: .suivant).suivant).donnee).objet = malloc(7 *
1360: sizeof(unsigned char))) == NULL)
1361: {
1362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1363: return;
1364: }
1365:
1366: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1367: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1368: .suivant).suivant).suivant).suivant).donnee).objet,
1369: "LOCKED");
1370: }
1371: else
1372: {
1373: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1374: (*l_element_courant).donnee)).objet)).suivant).suivant)
1375: .suivant).suivant).donnee).objet = malloc(9 *
1376: sizeof(unsigned char))) == NULL)
1377: {
1378: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1379: return;
1380: }
1381:
1382: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1383: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1384: .suivant).suivant).suivant).suivant).donnee).objet,
1385: "UNLOCKED");
1386: }
1387:
1388: /*
1389: * Préparation du drapeau PRIVATE/SHARED
1390: */
1391:
1392: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1393: (*l_element_courant).donnee)).objet)).suivant).suivant)
1394: .suivant).suivant).suivant =
1395: allocation_maillon(s_etat_processus)) == NULL)
1396: {
1397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1398: return;
1399: }
1400:
1401: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1402: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1403: .suivant).suivant).donnee = allocation(s_etat_processus,
1404: CHN)) == NULL)
1405: {
1406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1407: return;
1408: }
1409:
1410: if (variable_partagee == d_vrai)
1411: {
1412: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1413: (*l_element_courant).donnee)).objet)).suivant).suivant)
1414: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1415: sizeof(unsigned char))) == NULL)
1416: {
1417: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1418: return;
1419: }
1420:
1421: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1422: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1423: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1424: "SHARED");
1425: }
1426: else
1427: {
1428: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1429: (*l_element_courant).donnee)).objet)).suivant).suivant)
1430: .suivant).suivant).suivant).donnee).objet = malloc(8 *
1431: sizeof(unsigned char))) == NULL)
1432: {
1433: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1434: return;
1435: }
1436:
1437: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1438: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1439: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1440: "PRIVATE");
1441: }
1442:
1443: /*
1444: * Fermeture de la liste incluse
1445: */
1446:
1447: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1448: (*l_element_courant).donnee)).objet)).suivant).suivant)
1449: .suivant).suivant).suivant).suivant = NULL;
1450:
1451: l_element_precedent = l_element_courant;
1452: }
1453:
1454: free(tableau);
1455:
1456: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1457: s_objet_resultat) == d_erreur)
1458: {
1459: return;
1460: }
1461:
1462: return;
1463: }
1464:
1465:
1466: /*
1467: ================================================================================
1468: Fonction 'visit'
1469: ================================================================================
1470: Entrées :
1471: --------------------------------------------------------------------------------
1472: Sorties :
1473: --------------------------------------------------------------------------------
1474: Effets de bord : néant
1475: ================================================================================
1476: */
1477:
1478: void
1479: instruction_visit(struct_processus *s_etat_processus)
1480: {
1481: struct_liste_chainee *registre_pile_last;
1482:
1483: struct_objet *s_objet;
1484:
1485: unsigned long profondeur_initiale;
1486:
1487: (*s_etat_processus).erreur_execution = d_ex;
1488:
1489: if ((*s_etat_processus).affichage_arguments == 'Y')
1490: {
1491: printf("\n VISIT ");
1492:
1493: if ((*s_etat_processus).langue == 'F')
1494: {
1495: printf("(édition d'une variable)\n\n");
1496: }
1497: else
1498: {
1499: printf("(edit variable)\n\n");
1500: }
1501:
1502: printf(" 1: %s\n", d_NOM);
1503:
1504: return;
1505: }
1506: else if ((*s_etat_processus).test_instruction == 'Y')
1507: {
1508: (*s_etat_processus).nombre_arguments = -1;
1509: return;
1510: }
1511:
1512: registre_pile_last = NULL;
1513:
1514: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1515: {
1516: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1517: {
1518: return;
1519: }
1520:
1521: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1522: (*s_etat_processus).l_base_pile_last = NULL;
1523: }
1524:
1525: if ((*s_etat_processus).l_base_pile == NULL)
1526: {
1527: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1528: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1529: return;
1530: }
1531:
1532: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1533: {
1534: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1535: &s_objet) == d_erreur)
1536: {
1537: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1538: return;
1539: }
1540:
1541: liberation(s_etat_processus, s_objet);
1542:
1543: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1544: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1545: return;
1546: }
1547:
1548: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1549: instruction_dup(s_etat_processus);
1550:
1551: if (((*s_etat_processus).erreur_systeme != d_es) ||
1552: ((*s_etat_processus).erreur_execution != d_ex) ||
1553: ((*s_etat_processus).exception != d_ep))
1554: {
1555: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1556: {
1557: return;
1558: }
1559:
1560: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1561:
1562: return;
1563: }
1564:
1565: instruction_rcl(s_etat_processus);
1566:
1567: if (((*s_etat_processus).erreur_systeme != d_es) ||
1568: ((*s_etat_processus).erreur_execution != d_ex) ||
1569: ((*s_etat_processus).exception != d_ep))
1570: {
1571: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1572: &s_objet) == d_erreur)
1573: {
1574: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1575: return;
1576: }
1577:
1578: liberation(s_etat_processus, s_objet);
1579:
1580: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1581: {
1582: return;
1583: }
1584:
1585: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1586:
1587: return;
1588: }
1589:
1590: instruction_edit(s_etat_processus);
1591:
1592: if (((*s_etat_processus).erreur_systeme != d_es) ||
1593: ((*s_etat_processus).erreur_execution != d_ex) ||
1594: ((*s_etat_processus).exception != d_ep))
1595: {
1596: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1597: {
1598: return;
1599: }
1600:
1601: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1602:
1603: return;
1604: }
1605:
1606: while(profondeur_initiale != ((*s_etat_processus)
1607: .hauteur_pile_operationnelle - 1))
1608: {
1609: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1610: &s_objet) == d_erreur)
1611: {
1612: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1613: return;
1614: }
1615:
1616: liberation(s_etat_processus, s_objet);
1617: }
1618:
1619: instruction_swap(s_etat_processus);
1620:
1621: if (((*s_etat_processus).erreur_systeme != d_es) ||
1622: ((*s_etat_processus).erreur_execution != d_ex) ||
1623: ((*s_etat_processus).exception != d_ep))
1624: {
1625: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1626: {
1627: return;
1628: }
1629:
1630: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1631:
1632: return;
1633: }
1634:
1635: instruction_sto(s_etat_processus);
1636:
1637: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1638: {
1639: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1640: {
1641: return;
1642: }
1643:
1644: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1645: }
1646:
1647: return;
1648: }
1649:
1650:
1651: /*
1652: ================================================================================
1653: Fonction 'variable'
1654: ================================================================================
1655: Entrées :
1656: --------------------------------------------------------------------------------
1657: Sorties :
1658: --------------------------------------------------------------------------------
1659: Effets de bord : néant
1660: ================================================================================
1661: */
1662:
1663: void
1664: instruction_variable(struct_processus *s_etat_processus)
1665: {
1666: struct_liste_chainee *l_element_courant;
1667:
1668: struct_objet *s_objet;
1669:
1670: (*s_etat_processus).erreur_execution = d_ex;
1671:
1672: if ((*s_etat_processus).affichage_arguments == 'Y')
1673: {
1674: printf("\n VARIABLE ");
1675:
1676: if ((*s_etat_processus).langue == 'F')
1677: {
1678: printf("(déverrouille une variable globale)\n\n");
1679: }
1680: else
1681: {
1682: printf("(unlock a global variable)\n\n");
1683: }
1684:
1685: printf(" 1: %s, %s\n", d_NOM, d_LST);
1686:
1687: return;
1688: }
1689: else if ((*s_etat_processus).test_instruction == 'Y')
1690: {
1691: (*s_etat_processus).nombre_arguments = -1;
1692: return;
1693: }
1694:
1695: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1696: {
1697: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1698: {
1699: return;
1700: }
1701: }
1702:
1703: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1704: &s_objet) == d_erreur)
1705: {
1706: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1707: return;
1708: }
1709:
1710: if ((*s_objet).type == NOM)
1711: {
1712: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1713: (*s_objet).objet)).nom)) == d_faux)
1714: {
1715: liberation(s_etat_processus, s_objet);
1716:
1717: (*s_etat_processus).erreur_systeme = d_es;
1718: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1719: return;
1720: }
1721:
1722: (*(*s_etat_processus).pointeur_variable_courante)
1723: .variable_verrouillee = d_faux;
1724: }
1725: else if ((*s_objet).type == LST)
1726: {
1727: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1728:
1729: while(l_element_courant != NULL)
1730: {
1731: if ((*(*l_element_courant).donnee).type != NOM)
1732: {
1733: liberation(s_etat_processus, s_objet);
1734:
1735: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1736: return;
1737: }
1738:
1739: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1740: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1741: {
1742: liberation(s_etat_processus, s_objet);
1743:
1744: (*s_etat_processus).erreur_systeme = d_es;
1745: (*s_etat_processus).erreur_execution =
1746: d_ex_variable_non_definie;
1747: return;
1748: }
1749:
1750: (*(*s_etat_processus).pointeur_variable_courante)
1751: .variable_verrouillee = d_faux;
1752:
1753: l_element_courant = (*l_element_courant).suivant;
1754: }
1755: }
1756: else
1757: {
1758: liberation(s_etat_processus, s_objet);
1759:
1760: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1761: return;
1762: }
1763:
1764: liberation(s_etat_processus, s_objet);
1765:
1766: return;
1767: }
1768:
1769: // 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