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