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