Annotation of rpl/src/instructions_v1.c, revision 1.23
1.1 bertrand 1: /*
2: ================================================================================
1.23 ! bertrand 3: RPL/2 (R) version 4.1.0.prerelease.2
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: 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:
1.19 bertrand 84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 85: {
86: /*
87: * Aucune variable SIGMA
88: */
89:
90: (*s_etat_processus).erreur_systeme = d_es;
1.19 bertrand 91:
92: if ((*s_etat_processus).erreur_execution == d_ex)
93: {
94: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
95: }
96:
1.1 bertrand 97: return;
98: }
99: else
100: {
1.19 bertrand 101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
102: .type != MIN) && ((*(*(*s_etat_processus)
103: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 104: {
1.19 bertrand 105: (*s_etat_processus).erreur_execution =
106: d_ex_matrice_statistique_invalide;
1.1 bertrand 107: return;
108: }
109:
1.19 bertrand 110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
111: .pointeur_variable_courante).objet).objet))
112: .nombre_colonnes;
1.1 bertrand 113: }
114:
1.19 bertrand 115: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
116: .objet;
1.1 bertrand 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:
241: (*s_etat_processus).erreur_execution = d_ex;
242:
243: if ((*s_etat_processus).affichage_arguments == 'Y')
244: {
245: printf("\n VERSION ");
246:
247: if ((*s_etat_processus).langue == 'F')
248: {
249: printf("(version du séquenceur)\n\n");
250: }
251: else
252: {
253: printf("(sequencer version)\n\n");
254: }
255:
256: printf("-> 1: %s\n", d_LST);
257:
258: return;
259: }
260: else if ((*s_etat_processus).test_instruction == 'Y')
261: {
262: (*s_etat_processus).nombre_arguments = -1;
263: return;
264: }
265:
266: if (test_cfsf(s_etat_processus, 31) == d_vrai)
267: {
268: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
269: {
270: return;
271: }
272: }
273:
274: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
275: {
276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
277: return;
278: }
279:
280: if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus))
281: == NULL)
282: {
283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
284: return;
285: }
286:
287: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
288: (*l_element_courant).suivant = NULL;
289:
290: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
291: == NULL)
292: {
293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
294: return;
295: }
296:
297: if (((*(*l_element_courant).donnee).objet = malloc((strlen(texte)
298: + strlen(d_version_rpl) + 1) * sizeof(unsigned char))) == NULL)
299: {
300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
301: return;
302: }
303:
304: sprintf((unsigned char *) (*(*l_element_courant).donnee).objet, "%s%s",
305: texte, d_version_rpl);
306:
307: /*
308: * Ajout des versions X.Y.Z sous forme d'entiers
309: */
310:
311: i1 = 0;
312: i2 = 0;
313: i3 = 0;
314: i4 = 0;
315:
316: nombre_champs = sscanf(d_version_rpl, "%lld.%lld.%lld.prerelease.%lld",
317: &i1, &i2, &i3, &i4);
318:
319: if (((*l_element_courant).suivant =
320: allocation_maillon(s_etat_processus)) == NULL)
321: {
322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
323: return;
324: }
325:
326: l_element_courant = (*l_element_courant).suivant;
327: (*l_element_courant).suivant = NULL;
328:
329: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
330: == NULL)
331: {
332: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
333: return;
334: }
335:
336: if (((*(*l_element_courant).donnee).objet =
337: allocation_maillon(s_etat_processus)) == NULL)
338: {
339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
340: return;
341: }
342:
343: l_element_interne_courant = (struct_liste_chainee *)
344: (*(*l_element_courant).donnee).objet;
345:
346: (*l_element_interne_courant).suivant = NULL;
347:
348: if (((*l_element_interne_courant).donnee =
349: allocation(s_etat_processus, INT)) == NULL)
350: {
351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
352: return;
353: }
354:
355: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i1;
356:
357: if (((*l_element_interne_courant).suivant =
358: allocation_maillon(s_etat_processus)) == NULL)
359: {
360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
361: return;
362: }
363:
364: l_element_interne_courant = (*l_element_interne_courant).suivant;
365: (*l_element_interne_courant).suivant = NULL;
366:
367: if (((*l_element_interne_courant).donnee =
368: allocation(s_etat_processus, INT)) == NULL)
369: {
370: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
371: return;
372: }
373:
374: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i2;
375:
376: if (((*l_element_interne_courant).suivant =
377: allocation_maillon(s_etat_processus)) == NULL)
378: {
379: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
380: return;
381: }
382:
383: l_element_interne_courant = (*l_element_interne_courant).suivant;
384: (*l_element_interne_courant).suivant = NULL;
385:
386: if (((*l_element_interne_courant).donnee =
387: allocation(s_etat_processus, INT)) == NULL)
388: {
389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
390: return;
391: }
392:
393: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i3;
394:
395: /*
396: * Ajout de "PRERELEASE" suivi d'un entier ou de "RELEASE"
397: */
398:
399: if (nombre_champs == 3)
400: {
401: // Version "RELEASE"
402:
403: if (((*l_element_interne_courant).suivant =
404: allocation_maillon(s_etat_processus)) == NULL)
405: {
406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
407: return;
408: }
409:
410: l_element_interne_courant = (*l_element_interne_courant).suivant;
411: (*l_element_interne_courant).suivant = NULL;
412:
413: if (((*l_element_interne_courant).donnee =
414: allocation(s_etat_processus, CHN)) == NULL)
415: {
416: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
417: return;
418: }
419:
420: if (((*(*l_element_interne_courant).donnee).objet = malloc(8 *
421: sizeof(unsigned char))) == NULL)
422: {
423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
424: return;
425: }
426:
427: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
428: "RELEASE");
429: }
430: else
431: {
432: // Version "PRERELEASE"
433:
434: if (((*l_element_interne_courant).suivant =
435: allocation_maillon(s_etat_processus)) == NULL)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
438: return;
439: }
440:
441: l_element_interne_courant = (*l_element_interne_courant).suivant;
442: (*l_element_interne_courant).suivant = NULL;
443:
444: if (((*l_element_interne_courant).donnee =
445: allocation(s_etat_processus, CHN)) == NULL)
446: {
447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
448: return;
449: }
450:
451: if (((*(*l_element_interne_courant).donnee).objet = malloc(11 *
452: sizeof(unsigned char))) == NULL)
453: {
454: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
455: return;
456: }
457:
458: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
459: "PRERELEASE");
460:
461: if (((*l_element_interne_courant).suivant =
462: allocation_maillon(s_etat_processus)) == NULL)
463: {
464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
465: return;
466: }
467:
468: l_element_interne_courant = (*l_element_interne_courant).suivant;
469: (*l_element_interne_courant).suivant = NULL;
470:
471: if (((*l_element_interne_courant).donnee =
472: allocation(s_etat_processus, INT)) == NULL)
473: {
474: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
475: return;
476: }
477:
478: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i4;
479: }
480:
481: /*
482: * Ajout de la date de compilation
483: */
484:
485: if (((*l_element_courant).suivant =
486: allocation_maillon(s_etat_processus)) == NULL)
487: {
488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
489: return;
490: }
491:
492: l_element_courant = (*l_element_courant).suivant;
493: (*l_element_courant).suivant = NULL;
494:
495: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
496: == NULL)
497: {
498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
499: return;
500: }
501:
502: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)
503: + 1) * sizeof(unsigned char))) == NULL)
504: {
505: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
506: return;
507: }
508:
509: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
510: d_date_en_rpl);
511:
512: /*
513: * Ajout des options de compilation
514: */
515:
516: if (((*l_element_courant).suivant =
517: allocation_maillon(s_etat_processus)) == NULL)
518: {
519: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
520: return;
521: }
522:
523: l_element_courant = (*l_element_courant).suivant;
524: (*l_element_courant).suivant = NULL;
525:
526: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
527: == NULL)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
530: return;
531: }
532:
533: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path)
534: + 1) * sizeof(unsigned char))) == NULL)
535: {
536: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
537: return;
538: }
539:
540: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
541: d_exec_path);
542:
543: if (((*l_element_courant).suivant =
544: allocation_maillon(s_etat_processus)) == NULL)
545: {
546: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
547: return;
548: }
549:
550: l_element_courant = (*l_element_courant).suivant;
551: (*l_element_courant).suivant = NULL;
552:
553: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
554: == NULL)
555: {
556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
557: return;
558: }
559:
560: #ifdef GNUPLOT_SUPPORT
561: if (((*(*l_element_courant).donnee).objet = malloc(8 *
562: sizeof(unsigned char))) == NULL)
563: {
564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
565: return;
566: }
567:
568: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
569: "GNUPLOT");
570: #else
571: if (((*(*l_element_courant).donnee).objet = malloc(17 *
572: sizeof(unsigned char))) == NULL)
573: {
574: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
575: return;
576: }
577:
578: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
579: "GNUPLOT DISABLED");
580: #endif
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 FORCE_GNUPLOT_PATH
600: if (((*(*l_element_courant).donnee).objet = malloc(19 *
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: "FORCE GNUPLOT PATH");
609: #else
610: if (((*(*l_element_courant).donnee).objet = malloc(21 *
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: "DEFAULT GNUPLOT PATH");
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 POSTSCRIPT_SUPPORT
639: if (((*(*l_element_courant).donnee).objet = malloc(11 *
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: "POSTSCRIPT");
648: #else
649: if (((*(*l_element_courant).donnee).objet = malloc(20 *
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: "POSTSCRIPT DISABLED");
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 VIM_SUPPORT
678: if (((*(*l_element_courant).donnee).objet = malloc(4 *
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: "VIM");
687: #else
688: if (((*(*l_element_courant).donnee).objet = malloc(13 *
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: "VIM 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 MYSQL_SUPPORT
717: if (((*(*l_element_courant).donnee).objet = malloc(6 *
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: "MYSQL");
726: #else
727: if (((*(*l_element_courant).donnee).objet = malloc(15 *
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: "MYSQL 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 POSTGRESQL_SUPPORT
756: if (((*(*l_element_courant).donnee).objet = malloc(11 *
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: "POSTGRESQL");
765: #else
766: if (((*(*l_element_courant).donnee).objet = malloc(20 *
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: "POSTGRESQL 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 MOTIF_SUPPORT
795: if (((*(*l_element_courant).donnee).objet = malloc(6 *
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: "MOTIF");
804: #else
805: if (((*(*l_element_courant).donnee).objet = malloc(15 *
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: "MOTIF 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 DEBUG
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: "DEBUG");
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: "DEBUG 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 EXPERIMENTAL_CODE
873: if (((*(*l_element_courant).donnee).objet = malloc(18 *
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: "EXPERIMENTAL CODE");
882: #else
883: if (((*(*l_element_courant).donnee).objet = malloc(27 *
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: "EXPERIMENTAL CODE DISABLED");
892: #endif
893:
894: /*
895: * Empilement du résultat
896: */
897:
898: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
899: s_objet_resultat) == d_erreur)
900: {
901: return;
902: }
903:
904: return;
905: }
906:
907:
908: /*
909: ================================================================================
910: Fonction 'vars'
911: ================================================================================
912: Entrées :
913: --------------------------------------------------------------------------------
914: Sorties :
915: --------------------------------------------------------------------------------
916: Effets de bord : néant
917: ================================================================================
918: */
919:
920: void
921: instruction_vars(struct_processus *s_etat_processus)
922: {
1.20 bertrand 923: int i;
924: int nb_variables;
925:
1.1 bertrand 926: logical1 variable_partagee;
927:
928: struct_liste_chainee *l_element_courant;
929: struct_liste_chainee *l_element_precedent;
930:
931: struct_objet *s_objet_resultat;
932:
1.20 bertrand 933: struct_tableau_variables *tableau;
1.1 bertrand 934:
935: (*s_etat_processus).erreur_execution = d_ex;
936:
937: if ((*s_etat_processus).affichage_arguments == 'Y')
938: {
939: printf("\n VARS ");
940:
941: if ((*s_etat_processus).langue == 'F')
942: {
943: printf("(liste des variables)\n\n");
944: }
945: else
946: {
947: printf("(list of variables)\n\n");
948: }
949:
950: printf("-> 1: %s\n", d_LST);
951:
952: return;
953: }
954: else if ((*s_etat_processus).test_instruction == 'Y')
955: {
956: (*s_etat_processus).nombre_arguments = -1;
957: return;
958: }
959:
960: if (test_cfsf(s_etat_processus, 31) == d_vrai)
961: {
962: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
963: {
964: return;
965: }
966: }
967:
968: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
969: {
970: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
971: return;
972: }
973:
974: (*s_objet_resultat).objet = NULL;
975: l_element_precedent = NULL;
976:
1.20 bertrand 977: nb_variables = nombre_variables(s_etat_processus,
978: (*s_etat_processus).s_arbre_variables);
979:
980: if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
981: == NULL)
982: {
983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
984: return;
985: }
986:
987: liste_variables(s_etat_processus, tableau, 0,
988: (*s_etat_processus).s_arbre_variables);
989:
990: for(i = 0; i < nb_variables; i++)
1.1 bertrand 991: {
992: if (l_element_precedent == NULL)
993: {
994: if (((*s_objet_resultat).objet =
995: allocation_maillon(s_etat_processus)) == NULL)
996: {
997: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
998: return;
999: }
1000:
1001: l_element_courant = (struct_liste_chainee *)
1002: (*s_objet_resultat).objet;
1003: (*l_element_courant).suivant = NULL;
1004: }
1005: else
1006: {
1007: if (((*l_element_precedent).suivant =
1008: allocation_maillon(s_etat_processus)) == NULL)
1009: {
1010: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1011: return;
1012: }
1013:
1014: l_element_courant = (*l_element_precedent).suivant;
1015: (*l_element_courant).suivant = NULL;
1016: }
1017:
1018: /*
1019: * Allocation de la liste incluse
1020: */
1021:
1022: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
1023: == NULL)
1024: {
1025: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1026: return;
1027: }
1028:
1029: if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
1030: allocation_maillon(s_etat_processus)) == NULL)
1031: {
1032: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1033: return;
1034: }
1035:
1036: /*
1037: * Mise en place d'un verrou si la variable est partagée.
1038: */
1039:
1.20 bertrand 1040: if (tableau[i].objet == NULL)
1.1 bertrand 1041: {
1042: if (pthread_mutex_lock(&((*(*s_etat_processus)
1043: .s_liste_variables_partagees).mutex)) != 0)
1044: {
1045: (*s_etat_processus).erreur_systeme = d_es_processus;
1046: return;
1047: }
1048:
1049: if (recherche_variable_partagee(s_etat_processus,
1.20 bertrand 1050: tableau[i].nom, tableau[i].variable_partagee,
1051: tableau[i].origine) == d_faux)
1.1 bertrand 1052: {
1053: // La variable partagée n'existe plus.
1054:
1055: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1056: .s_liste_variables_partagees).mutex)) != 0)
1057: {
1058: (*s_etat_processus).erreur_systeme = d_es_processus;
1059: return;
1060: }
1061:
1062: continue;
1063: }
1064:
1065: variable_partagee = d_vrai;
1066: }
1067: else
1068: {
1069: variable_partagee = d_faux;
1070: }
1071:
1072: /*
1073: * Mise en place du nom de la variable
1074: */
1075:
1076: if (((*((struct_liste_chainee *) (*((struct_objet *)
1077: (*l_element_courant).donnee)).objet)).donnee =
1078: allocation(s_etat_processus, NOM)) == NULL)
1079: {
1080: if (variable_partagee == d_vrai)
1081: {
1082: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1083: .s_liste_variables_partagees).mutex)) != 0)
1084: {
1085: (*s_etat_processus).erreur_systeme = d_es_processus;
1086: return;
1087: }
1088: }
1089:
1090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1091: return;
1092: }
1093:
1094: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1095: (*l_element_courant).donnee)).objet)).donnee).objet))
1096: .symbole = d_vrai;
1097:
1098: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1099: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
1.20 bertrand 1100: malloc((strlen(tableau[i].nom)
1.1 bertrand 1101: + 1) * sizeof(unsigned char))) == NULL)
1102: {
1103: if (variable_partagee == d_vrai)
1104: {
1105: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1106: .s_liste_variables_partagees).mutex)) != 0)
1107: {
1108: (*s_etat_processus).erreur_systeme = d_es_processus;
1109: return;
1110: }
1111: }
1112:
1113: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1114: return;
1115: }
1116:
1117: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
1118: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1.20 bertrand 1119: .donnee).objet)).nom, tableau[i].nom);
1.1 bertrand 1120:
1121: /*
1122: * Préparation du niveau
1123: */
1124:
1125: if (((*((struct_liste_chainee *) (*((struct_objet *)
1126: (*l_element_courant).donnee)).objet)).suivant =
1127: allocation_maillon(s_etat_processus)) == NULL)
1128: {
1129: if (variable_partagee == d_vrai)
1130: {
1131: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1132: .s_liste_variables_partagees).mutex)) != 0)
1133: {
1134: (*s_etat_processus).erreur_systeme = d_es_processus;
1135: return;
1136: }
1137: }
1138:
1139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1140: return;
1141: }
1142:
1143: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1144: (*l_element_courant).donnee)).objet)).suivant).donnee =
1145: allocation(s_etat_processus, INT)) == NULL)
1146: {
1147: if (variable_partagee == d_vrai)
1148: {
1149: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1150: .s_liste_variables_partagees).mutex)) != 0)
1151: {
1152: (*s_etat_processus).erreur_systeme = d_es_processus;
1153: return;
1154: }
1155: }
1156:
1157: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1158: return;
1159: }
1160:
1161: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
1162: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
1.20 bertrand 1163: (integer8) tableau[i].niveau;
1.1 bertrand 1164:
1165: /*
1166: * Préparation du contenu de la variable
1167: */
1168:
1169: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1170: (*l_element_courant).donnee)).objet)).suivant).suivant =
1171: allocation_maillon(s_etat_processus)) == 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:
1.20 bertrand 1187: if (tableau[i].objet == NULL)
1.1 bertrand 1188: {
1189: // Variable partagée
1190:
1191: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1192: (*l_element_courant).donnee)).objet)).suivant).suivant)
1193: .donnee = copie_objet(s_etat_processus,
1194: (*(*s_etat_processus)
1195: .s_liste_variables_partagees).table[(*(*s_etat_processus)
1196: .s_liste_variables_partagees).position_variable].objet,
1197: 'P')) == NULL)
1198: {
1199: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1200: .s_liste_variables_partagees).mutex)) != 0)
1201: {
1202: (*s_etat_processus).erreur_systeme = d_es_processus;
1203: return;
1204: }
1205:
1206: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1207: return;
1208: }
1209:
1210: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1211: .s_liste_variables_partagees).mutex)) != 0)
1212: {
1213: (*s_etat_processus).erreur_systeme = d_es_processus;
1214: return;
1215: }
1216: }
1217: else
1218: {
1219: // Variable privée
1220:
1221: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1222: (*l_element_courant).donnee)).objet)).suivant).suivant)
1.20 bertrand 1223: .donnee = copie_objet(s_etat_processus, tableau[i].objet,
1224: 'P')) == NULL)
1.1 bertrand 1225: {
1226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1227: return;
1228: }
1229: }
1230:
1231: /*
1232: * Préparation du drapeau STATIC/VOLATILE
1233: */
1234:
1235: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1236: (*l_element_courant).donnee)).objet)).suivant).suivant)
1237: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1238: {
1239: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1240: return;
1241: }
1242:
1243: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1244: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1245: .donnee = allocation(s_etat_processus, CHN)) == NULL)
1246: {
1247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1248: return;
1249: }
1250:
1.20 bertrand 1251: if ((tableau[i].origine == 'P')
1252: ? (tableau[i].variable_statique.adresse != 0)
1253: : (tableau[i].variable_statique.pointeur != NULL))
1.1 bertrand 1254: {
1255: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1256: (*l_element_courant).donnee)).objet)).suivant).suivant)
1257: .suivant).donnee).objet = malloc(7 *
1258: sizeof(unsigned char))) == NULL)
1259: {
1260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1261: return;
1262: }
1263:
1264: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1265: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1266: .suivant).suivant) .suivant).donnee).objet, "STATIC");
1267: }
1268: else
1269: {
1270: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1271: (*l_element_courant).donnee)).objet)).suivant).suivant)
1272: .suivant).donnee).objet = malloc(9 *
1273: sizeof(unsigned char))) == NULL)
1274: {
1275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1276: return;
1277: }
1278:
1279: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1280: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1281: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
1282: }
1283:
1284: /*
1285: * Préparation du drapeau LOCKED/UNLOCKED
1286: */
1287:
1288: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1289: (*l_element_courant).donnee)).objet)).suivant).suivant)
1290: .suivant).suivant = allocation_maillon(s_etat_processus))
1291: == NULL)
1292: {
1293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1294: return;
1295: }
1296:
1297: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1298: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1299: .suivant).donnee = allocation(s_etat_processus, CHN))
1300: == NULL)
1301: {
1302: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1303: return;
1304: }
1305:
1.20 bertrand 1306: if (tableau[i].variable_verrouillee == d_vrai)
1.1 bertrand 1307: {
1308: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1309: (*l_element_courant).donnee)).objet)).suivant).suivant)
1310: .suivant).suivant).donnee).objet = malloc(7 *
1311: sizeof(unsigned char))) == NULL)
1312: {
1313: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1314: return;
1315: }
1316:
1317: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1318: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1319: .suivant).suivant).suivant).suivant).donnee).objet,
1320: "LOCKED");
1321: }
1322: else
1323: {
1324: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1325: (*l_element_courant).donnee)).objet)).suivant).suivant)
1326: .suivant).suivant).donnee).objet = malloc(9 *
1327: sizeof(unsigned char))) == NULL)
1328: {
1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1330: return;
1331: }
1332:
1333: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1334: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1335: .suivant).suivant).suivant).suivant).donnee).objet,
1336: "UNLOCKED");
1337: }
1338:
1339: /*
1340: * Préparation du drapeau PRIVATE/SHARED
1341: */
1342:
1343: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1344: (*l_element_courant).donnee)).objet)).suivant).suivant)
1345: .suivant).suivant).suivant =
1346: allocation_maillon(s_etat_processus)) == 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).suivant).donnee = allocation(s_etat_processus,
1355: CHN)) == NULL)
1356: {
1357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1358: return;
1359: }
1360:
1361: if (variable_partagee == d_vrai)
1362: {
1363: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1364: (*l_element_courant).donnee)).objet)).suivant).suivant)
1365: .suivant).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).suivant).donnee).objet,
1375: "SHARED");
1376: }
1377: else
1378: {
1379: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1380: (*l_element_courant).donnee)).objet)).suivant).suivant)
1381: .suivant).suivant).suivant).donnee).objet = malloc(8 *
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).suivant).donnee).objet,
1391: "PRIVATE");
1392: }
1393:
1394: /*
1395: * Fermeture de la liste incluse
1396: */
1397:
1398: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1399: (*l_element_courant).donnee)).objet)).suivant).suivant)
1400: .suivant).suivant).suivant).suivant = NULL;
1401:
1402: l_element_precedent = l_element_courant;
1403: }
1.20 bertrand 1404:
1405: free(tableau);
1.1 bertrand 1406:
1407: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1408: s_objet_resultat) == d_erreur)
1409: {
1410: return;
1411: }
1412:
1413: return;
1414: }
1415:
1416:
1417: /*
1418: ================================================================================
1419: Fonction 'visit'
1420: ================================================================================
1421: Entrées :
1422: --------------------------------------------------------------------------------
1423: Sorties :
1424: --------------------------------------------------------------------------------
1425: Effets de bord : néant
1426: ================================================================================
1427: */
1428:
1429: void
1430: instruction_visit(struct_processus *s_etat_processus)
1431: {
1432: struct_liste_chainee *registre_pile_last;
1433:
1434: struct_objet *s_objet;
1435:
1436: unsigned long profondeur_initiale;
1437:
1438: (*s_etat_processus).erreur_execution = d_ex;
1439:
1440: if ((*s_etat_processus).affichage_arguments == 'Y')
1441: {
1442: printf("\n VISIT ");
1443:
1444: if ((*s_etat_processus).langue == 'F')
1445: {
1446: printf("(édition d'une variable)\n\n");
1447: }
1448: else
1449: {
1450: printf("(edit variable)\n\n");
1451: }
1452:
1453: printf(" 1: %s\n", d_NOM);
1454:
1455: return;
1456: }
1457: else if ((*s_etat_processus).test_instruction == 'Y')
1458: {
1459: (*s_etat_processus).nombre_arguments = -1;
1460: return;
1461: }
1462:
1463: registre_pile_last = NULL;
1464:
1465: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1466: {
1467: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1468: {
1469: return;
1470: }
1471:
1472: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1473: (*s_etat_processus).l_base_pile_last = NULL;
1474: }
1475:
1476: if ((*s_etat_processus).l_base_pile == NULL)
1477: {
1478: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1479: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1480: return;
1481: }
1482:
1483: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1484: {
1485: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1486: &s_objet) == d_erreur)
1487: {
1488: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1489: return;
1490: }
1491:
1492: liberation(s_etat_processus, s_objet);
1493:
1494: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1495: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1496: return;
1497: }
1498:
1499: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1500: instruction_dup(s_etat_processus);
1501:
1502: if (((*s_etat_processus).erreur_systeme != d_es) ||
1503: ((*s_etat_processus).erreur_execution != d_ex) ||
1504: ((*s_etat_processus).exception != d_ep))
1505: {
1506: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1507: {
1508: return;
1509: }
1510:
1511: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1512:
1513: return;
1514: }
1515:
1516: instruction_rcl(s_etat_processus);
1517:
1518: if (((*s_etat_processus).erreur_systeme != d_es) ||
1519: ((*s_etat_processus).erreur_execution != d_ex) ||
1520: ((*s_etat_processus).exception != d_ep))
1521: {
1522: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1523: &s_objet) == d_erreur)
1524: {
1525: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1526: return;
1527: }
1528:
1529: liberation(s_etat_processus, s_objet);
1530:
1531: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1532: {
1533: return;
1534: }
1535:
1536: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1537:
1538: return;
1539: }
1540:
1541: instruction_edit(s_etat_processus);
1542:
1543: if (((*s_etat_processus).erreur_systeme != d_es) ||
1544: ((*s_etat_processus).erreur_execution != d_ex) ||
1545: ((*s_etat_processus).exception != d_ep))
1546: {
1547: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1548: {
1549: return;
1550: }
1551:
1552: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1553:
1554: return;
1555: }
1556:
1557: while(profondeur_initiale != ((*s_etat_processus)
1558: .hauteur_pile_operationnelle - 1))
1559: {
1560: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1561: &s_objet) == d_erreur)
1562: {
1563: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1564: return;
1565: }
1566:
1567: liberation(s_etat_processus, s_objet);
1568: }
1569:
1570: instruction_swap(s_etat_processus);
1571:
1572: if (((*s_etat_processus).erreur_systeme != d_es) ||
1573: ((*s_etat_processus).erreur_execution != d_ex) ||
1574: ((*s_etat_processus).exception != d_ep))
1575: {
1576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1577: {
1578: return;
1579: }
1580:
1581: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1582:
1583: return;
1584: }
1585:
1586: instruction_sto(s_etat_processus);
1587:
1588: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1589: {
1590: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1591: {
1592: return;
1593: }
1594:
1595: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1596: }
1597:
1598: return;
1599: }
1600:
1601:
1602: /*
1603: ================================================================================
1604: Fonction 'variable'
1605: ================================================================================
1606: Entrées :
1607: --------------------------------------------------------------------------------
1608: Sorties :
1609: --------------------------------------------------------------------------------
1610: Effets de bord : néant
1611: ================================================================================
1612: */
1613:
1614: void
1615: instruction_variable(struct_processus *s_etat_processus)
1616: {
1617: struct_liste_chainee *l_element_courant;
1618:
1619: struct_objet *s_objet;
1620:
1621: (*s_etat_processus).erreur_execution = d_ex;
1622:
1623: if ((*s_etat_processus).affichage_arguments == 'Y')
1624: {
1625: printf("\n VARIABLE ");
1626:
1627: if ((*s_etat_processus).langue == 'F')
1628: {
1629: printf("(déverrouille une variable globale)\n\n");
1630: }
1631: else
1632: {
1633: printf("(unlock a global variable)\n\n");
1634: }
1635:
1636: printf(" 1: %s, %s\n", d_NOM, d_LST);
1637:
1638: return;
1639: }
1640: else if ((*s_etat_processus).test_instruction == 'Y')
1641: {
1642: (*s_etat_processus).nombre_arguments = -1;
1643: return;
1644: }
1645:
1646: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1647: {
1648: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1649: {
1650: return;
1651: }
1652: }
1653:
1654: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1655: &s_objet) == d_erreur)
1656: {
1657: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1658: return;
1659: }
1660:
1661: if ((*s_objet).type == NOM)
1662: {
1.19 bertrand 1663: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1.1 bertrand 1664: (*s_objet).objet)).nom)) == d_faux)
1665: {
1666: liberation(s_etat_processus, s_objet);
1667:
1668: (*s_etat_processus).erreur_systeme = d_es;
1669: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1670: return;
1671: }
1672:
1.19 bertrand 1673: (*(*s_etat_processus).pointeur_variable_courante)
1674: .variable_verrouillee = d_faux;
1.1 bertrand 1675: }
1676: else if ((*s_objet).type == LST)
1677: {
1678: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1679:
1680: while(l_element_courant != NULL)
1681: {
1682: if ((*(*l_element_courant).donnee).type != NOM)
1683: {
1684: liberation(s_etat_processus, s_objet);
1685:
1686: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1687: return;
1688: }
1689:
1.19 bertrand 1690: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1.1 bertrand 1691: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1692: {
1693: liberation(s_etat_processus, s_objet);
1694:
1695: (*s_etat_processus).erreur_systeme = d_es;
1696: (*s_etat_processus).erreur_execution =
1697: d_ex_variable_non_definie;
1698: return;
1699: }
1700:
1.19 bertrand 1701: (*(*s_etat_processus).pointeur_variable_courante)
1702: .variable_verrouillee = d_faux;
1.1 bertrand 1703:
1704: l_element_courant = (*l_element_courant).suivant;
1705: }
1706: }
1707: else
1708: {
1709: liberation(s_etat_processus, s_objet);
1710:
1711: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1712: return;
1713: }
1714:
1715: liberation(s_etat_processus, s_objet);
1716:
1717: return;
1718: }
1719:
1720: // 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