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