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