1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.0.prerelease.0
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'var'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_var(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_statistique;
42: struct_objet *s_objet_resultat;
43: struct_objet *s_objet_temporaire;
44:
45: unsigned long nombre_colonnes;
46:
47: (*s_etat_processus).erreur_execution = d_ex;
48:
49: if ((*s_etat_processus).affichage_arguments == 'Y')
50: {
51: printf("\n VAR ");
52:
53: if ((*s_etat_processus).langue == 'F')
54: {
55: printf("(variance)\n\n");
56: }
57: else
58: {
59: printf("(variance)\n\n");
60: }
61:
62: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: /*
81: * Recherche d'une variable globale référencée par SIGMA
82: */
83:
84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
85: {
86: /*
87: * Aucune variable SIGMA
88: */
89:
90: (*s_etat_processus).erreur_systeme = d_es;
91:
92: if ((*s_etat_processus).erreur_execution == d_ex)
93: {
94: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
95: }
96:
97: return;
98: }
99: else
100: {
101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
102: .type != MIN) && ((*(*(*s_etat_processus)
103: .pointeur_variable_courante).objet).type != MRL))
104: {
105: (*s_etat_processus).erreur_execution =
106: d_ex_matrice_statistique_invalide;
107: return;
108: }
109:
110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
111: .pointeur_variable_courante).objet).objet))
112: .nombre_colonnes;
113: }
114:
115: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
116: .objet;
117:
118: if (((*s_objet_statistique).type == MIN) ||
119: ((*s_objet_statistique).type == MRL))
120: {
121: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
122: <= 1)
123: {
124: (*s_etat_processus).erreur_execution =
125: d_ex_statistiques_echantillon;
126: return;
127: }
128:
129: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
130: {
131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
132: return;
133: }
134:
135: if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *)
136: (*s_objet_statistique).objet, 'E')) == NULL)
137: {
138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
139: return;
140: }
141:
142: if (nombre_colonnes == 1)
143: {
144: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
145: {
146: (*s_objet_resultat).type = VIN;
147: s_objet_temporaire = s_objet_resultat;
148:
149: if ((s_objet_resultat = allocation(s_etat_processus, INT))
150: == NULL)
151: {
152: (*s_etat_processus).erreur_systeme =
153: d_es_allocation_memoire;
154: return;
155: }
156:
157: (*((integer8 *) (*s_objet_resultat).objet)) =
158: ((integer8 *) (*((struct_vecteur *)
159: (*s_objet_temporaire).objet)).tableau)[0];
160:
161: liberation(s_etat_processus, s_objet_temporaire);
162: }
163: else
164: {
165: (*s_objet_resultat).type = VRL;
166: s_objet_temporaire = s_objet_resultat;
167:
168: if ((s_objet_resultat = allocation(s_etat_processus, REL))
169: == NULL)
170: {
171: (*s_etat_processus).erreur_systeme =
172: d_es_allocation_memoire;
173: return;
174: }
175:
176: (*((real8 *) (*s_objet_resultat).objet)) =
177: ((real8 *) (*((struct_vecteur *)
178: (*s_objet_temporaire).objet)).tableau)[0];
179:
180: liberation(s_etat_processus, s_objet_temporaire);
181: }
182: }
183: else
184: {
185: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
186: {
187: (*s_objet_resultat).type = VIN;
188: }
189: else
190: {
191: (*s_objet_resultat).type = VRL;
192: }
193: }
194:
195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
196: s_objet_resultat) == d_erreur)
197: {
198: return;
199: }
200: }
201: else
202: {
203: (*s_etat_processus).erreur_execution =
204: d_ex_matrice_statistique_invalide;
205: return;
206: }
207:
208: return;
209: }
210:
211:
212: /*
213: ================================================================================
214: Fonction 'version'
215: ================================================================================
216: Entrées :
217: --------------------------------------------------------------------------------
218: Sorties :
219: --------------------------------------------------------------------------------
220: Effets de bord : néant
221: ================================================================================
222: */
223:
224: void
225: instruction_version(struct_processus *s_etat_processus)
226: {
227: int nombre_champs;
228:
229: integer8 i1;
230: integer8 i2;
231: integer8 i3;
232: integer8 i4;
233:
234: struct_liste_chainee *l_element_courant;
235: struct_liste_chainee *l_element_interne_courant;
236:
237: struct_objet *s_objet_resultat;
238:
239: unsigned char texte[] = "RPL/2 version ";
240:
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: {
923: logical1 variable_partagee;
924:
925: struct_liste_chainee *l_element_courant;
926: struct_liste_chainee *l_element_precedent;
927:
928: struct_objet *s_objet_resultat;
929:
930: unsigned long i;
931:
932: (*s_etat_processus).erreur_execution = d_ex;
933:
934: if ((*s_etat_processus).affichage_arguments == 'Y')
935: {
936: printf("\n VARS ");
937:
938: if ((*s_etat_processus).langue == 'F')
939: {
940: printf("(liste des variables)\n\n");
941: }
942: else
943: {
944: printf("(list of variables)\n\n");
945: }
946:
947: printf("-> 1: %s\n", d_LST);
948:
949: return;
950: }
951: else if ((*s_etat_processus).test_instruction == 'Y')
952: {
953: (*s_etat_processus).nombre_arguments = -1;
954: return;
955: }
956:
957: if (test_cfsf(s_etat_processus, 31) == d_vrai)
958: {
959: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
960: {
961: return;
962: }
963: }
964:
965: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
966: {
967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
968: return;
969: }
970:
971: (*s_objet_resultat).objet = NULL;
972: l_element_precedent = NULL;
973:
974: #if 0
975: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
976: {
977: if (l_element_precedent == NULL)
978: {
979: if (((*s_objet_resultat).objet =
980: allocation_maillon(s_etat_processus)) == NULL)
981: {
982: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
983: return;
984: }
985:
986: l_element_courant = (struct_liste_chainee *)
987: (*s_objet_resultat).objet;
988: (*l_element_courant).suivant = NULL;
989: }
990: else
991: {
992: if (((*l_element_precedent).suivant =
993: allocation_maillon(s_etat_processus)) == NULL)
994: {
995: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
996: return;
997: }
998:
999: l_element_courant = (*l_element_precedent).suivant;
1000: (*l_element_courant).suivant = NULL;
1001: }
1002:
1003: /*
1004: * Allocation de la liste incluse
1005: */
1006:
1007: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
1008: == NULL)
1009: {
1010: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1011: return;
1012: }
1013:
1014: if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
1015: allocation_maillon(s_etat_processus)) == NULL)
1016: {
1017: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1018: return;
1019: }
1020:
1021: /*
1022: * Mise en place d'un verrou si la variable est partagée.
1023: */
1024:
1025: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1026: {
1027: if (pthread_mutex_lock(&((*(*s_etat_processus)
1028: .s_liste_variables_partagees).mutex)) != 0)
1029: {
1030: (*s_etat_processus).erreur_systeme = d_es_processus;
1031: return;
1032: }
1033:
1034: if (recherche_variable_partagee(s_etat_processus,
1035: ((*s_etat_processus).s_liste_variables[i]).nom,
1036: ((*s_etat_processus).s_liste_variables[i])
1037: .variable_partagee, ((*s_etat_processus)
1038: .s_liste_variables[i]).origine) == d_faux)
1039: {
1040: // La variable partagée n'existe plus.
1041:
1042: if (pthread_mutex_unlock(&((*(*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: continue;
1050: }
1051:
1052: variable_partagee = d_vrai;
1053: }
1054: else
1055: {
1056: variable_partagee = d_faux;
1057: }
1058:
1059: /*
1060: * Mise en place du nom de la variable
1061: */
1062:
1063: if (((*((struct_liste_chainee *) (*((struct_objet *)
1064: (*l_element_courant).donnee)).objet)).donnee =
1065: allocation(s_etat_processus, NOM)) == NULL)
1066: {
1067: if (variable_partagee == d_vrai)
1068: {
1069: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1070: .s_liste_variables_partagees).mutex)) != 0)
1071: {
1072: (*s_etat_processus).erreur_systeme = d_es_processus;
1073: return;
1074: }
1075: }
1076:
1077: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1078: return;
1079: }
1080:
1081: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1082: (*l_element_courant).donnee)).objet)).donnee).objet))
1083: .symbole = d_vrai;
1084:
1085: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
1086: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
1087: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
1088: + 1) * sizeof(unsigned char))) == NULL)
1089: {
1090: if (variable_partagee == d_vrai)
1091: {
1092: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1093: .s_liste_variables_partagees).mutex)) != 0)
1094: {
1095: (*s_etat_processus).erreur_systeme = d_es_processus;
1096: return;
1097: }
1098: }
1099:
1100: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1101: return;
1102: }
1103:
1104: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
1105: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1106: .donnee).objet)).nom, (*s_etat_processus)
1107: .s_liste_variables[i].nom);
1108:
1109: /*
1110: * Préparation du niveau
1111: */
1112:
1113: if (((*((struct_liste_chainee *) (*((struct_objet *)
1114: (*l_element_courant).donnee)).objet)).suivant =
1115: allocation_maillon(s_etat_processus)) == NULL)
1116: {
1117: if (variable_partagee == d_vrai)
1118: {
1119: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1120: .s_liste_variables_partagees).mutex)) != 0)
1121: {
1122: (*s_etat_processus).erreur_systeme = d_es_processus;
1123: return;
1124: }
1125: }
1126:
1127: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1128: return;
1129: }
1130:
1131: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1132: (*l_element_courant).donnee)).objet)).suivant).donnee =
1133: allocation(s_etat_processus, INT)) == NULL)
1134: {
1135: if (variable_partagee == d_vrai)
1136: {
1137: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1138: .s_liste_variables_partagees).mutex)) != 0)
1139: {
1140: (*s_etat_processus).erreur_systeme = d_es_processus;
1141: return;
1142: }
1143: }
1144:
1145: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1146: return;
1147: }
1148:
1149: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
1150: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
1151: (integer8) (*s_etat_processus).s_liste_variables[i].niveau;
1152:
1153: /*
1154: * Préparation du contenu de la variable
1155: */
1156:
1157: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
1158: (*l_element_courant).donnee)).objet)).suivant).suivant =
1159: allocation_maillon(s_etat_processus)) == NULL)
1160: {
1161: if (variable_partagee == d_vrai)
1162: {
1163: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1164: .s_liste_variables_partagees).mutex)) != 0)
1165: {
1166: (*s_etat_processus).erreur_systeme = d_es_processus;
1167: return;
1168: }
1169: }
1170:
1171: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1172: return;
1173: }
1174:
1175: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
1176: {
1177: // Variable partagée
1178:
1179: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1180: (*l_element_courant).donnee)).objet)).suivant).suivant)
1181: .donnee = copie_objet(s_etat_processus,
1182: (*(*s_etat_processus)
1183: .s_liste_variables_partagees).table[(*(*s_etat_processus)
1184: .s_liste_variables_partagees).position_variable].objet,
1185: 'P')) == NULL)
1186: {
1187: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1188: .s_liste_variables_partagees).mutex)) != 0)
1189: {
1190: (*s_etat_processus).erreur_systeme = d_es_processus;
1191: return;
1192: }
1193:
1194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1195: return;
1196: }
1197:
1198: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1199: .s_liste_variables_partagees).mutex)) != 0)
1200: {
1201: (*s_etat_processus).erreur_systeme = d_es_processus;
1202: return;
1203: }
1204: }
1205: else
1206: {
1207: // Variable privée
1208:
1209: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1210: (*l_element_courant).donnee)).objet)).suivant).suivant)
1211: .donnee = copie_objet(s_etat_processus, (*s_etat_processus)
1212: .s_liste_variables[i].objet, 'P')) == NULL)
1213: {
1214: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1215: return;
1216: }
1217: }
1218:
1219: /*
1220: * Préparation du drapeau STATIC/VOLATILE
1221: */
1222:
1223: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
1224: (*l_element_courant).donnee)).objet)).suivant).suivant)
1225: .suivant = allocation_maillon(s_etat_processus)) == NULL)
1226: {
1227: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1228: return;
1229: }
1230:
1231: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1232: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1233: .donnee = allocation(s_etat_processus, CHN)) == NULL)
1234: {
1235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1236: return;
1237: }
1238:
1239: if (((*s_etat_processus).s_liste_variables[i].origine == 'P')
1240: ? ((*s_etat_processus).s_liste_variables[i]
1241: .variable_statique.adresse != 0)
1242: : ((*s_etat_processus).s_liste_variables[i]
1243: .variable_statique.pointeur != NULL))
1244: {
1245: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1246: (*l_element_courant).donnee)).objet)).suivant).suivant)
1247: .suivant).donnee).objet = malloc(7 *
1248: sizeof(unsigned char))) == NULL)
1249: {
1250: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1251: return;
1252: }
1253:
1254: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1255: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1256: .suivant).suivant) .suivant).donnee).objet, "STATIC");
1257: }
1258: else
1259: {
1260: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1261: (*l_element_courant).donnee)).objet)).suivant).suivant)
1262: .suivant).donnee).objet = malloc(9 *
1263: sizeof(unsigned char))) == NULL)
1264: {
1265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1266: return;
1267: }
1268:
1269: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
1270: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1271: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
1272: }
1273:
1274: /*
1275: * Préparation du drapeau LOCKED/UNLOCKED
1276: */
1277:
1278: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1279: (*l_element_courant).donnee)).objet)).suivant).suivant)
1280: .suivant).suivant = allocation_maillon(s_etat_processus))
1281: == NULL)
1282: {
1283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1284: return;
1285: }
1286:
1287: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1288: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1289: .suivant).donnee = allocation(s_etat_processus, CHN))
1290: == NULL)
1291: {
1292: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1293: return;
1294: }
1295:
1296: if ((*s_etat_processus).s_liste_variables[i].variable_verrouillee
1297: == d_vrai)
1298: {
1299: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1300: (*l_element_courant).donnee)).objet)).suivant).suivant)
1301: .suivant).suivant).donnee).objet = malloc(7 *
1302: sizeof(unsigned char))) == NULL)
1303: {
1304: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1305: return;
1306: }
1307:
1308: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1309: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1310: .suivant).suivant).suivant).suivant).donnee).objet,
1311: "LOCKED");
1312: }
1313: else
1314: {
1315: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1316: (*l_element_courant).donnee)).objet)).suivant).suivant)
1317: .suivant).suivant).donnee).objet = malloc(9 *
1318: sizeof(unsigned char))) == NULL)
1319: {
1320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1321: return;
1322: }
1323:
1324: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
1325: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1326: .suivant).suivant).suivant).suivant).donnee).objet,
1327: "UNLOCKED");
1328: }
1329:
1330: /*
1331: * Préparation du drapeau PRIVATE/SHARED
1332: */
1333:
1334: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1335: (*l_element_courant).donnee)).objet)).suivant).suivant)
1336: .suivant).suivant).suivant =
1337: allocation_maillon(s_etat_processus)) == NULL)
1338: {
1339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1340: return;
1341: }
1342:
1343: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1344: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
1345: .suivant).suivant).donnee = allocation(s_etat_processus,
1346: CHN)) == NULL)
1347: {
1348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1349: return;
1350: }
1351:
1352: if (variable_partagee == d_vrai)
1353: {
1354: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1355: (*l_element_courant).donnee)).objet)).suivant).suivant)
1356: .suivant).suivant).suivant).donnee).objet = malloc(7 *
1357: sizeof(unsigned char))) == NULL)
1358: {
1359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1360: return;
1361: }
1362:
1363: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1364: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1365: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1366: "SHARED");
1367: }
1368: else
1369: {
1370: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1371: (*l_element_courant).donnee)).objet)).suivant).suivant)
1372: .suivant).suivant).suivant).donnee).objet = malloc(8 *
1373: sizeof(unsigned char))) == NULL)
1374: {
1375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1376: return;
1377: }
1378:
1379: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
1380: (*((struct_objet *) (*l_element_courant).donnee)).objet))
1381: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
1382: "PRIVATE");
1383: }
1384:
1385: /*
1386: * Fermeture de la liste incluse
1387: */
1388:
1389: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1390: (*l_element_courant).donnee)).objet)).suivant).suivant)
1391: .suivant).suivant).suivant).suivant = NULL;
1392:
1393: l_element_precedent = l_element_courant;
1394: }
1395: #endif
1396:
1397: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1398: s_objet_resultat) == d_erreur)
1399: {
1400: return;
1401: }
1402:
1403: return;
1404: }
1405:
1406:
1407: /*
1408: ================================================================================
1409: Fonction 'visit'
1410: ================================================================================
1411: Entrées :
1412: --------------------------------------------------------------------------------
1413: Sorties :
1414: --------------------------------------------------------------------------------
1415: Effets de bord : néant
1416: ================================================================================
1417: */
1418:
1419: void
1420: instruction_visit(struct_processus *s_etat_processus)
1421: {
1422: struct_liste_chainee *registre_pile_last;
1423:
1424: struct_objet *s_objet;
1425:
1426: unsigned long profondeur_initiale;
1427:
1428: (*s_etat_processus).erreur_execution = d_ex;
1429:
1430: if ((*s_etat_processus).affichage_arguments == 'Y')
1431: {
1432: printf("\n VISIT ");
1433:
1434: if ((*s_etat_processus).langue == 'F')
1435: {
1436: printf("(édition d'une variable)\n\n");
1437: }
1438: else
1439: {
1440: printf("(edit variable)\n\n");
1441: }
1442:
1443: printf(" 1: %s\n", d_NOM);
1444:
1445: return;
1446: }
1447: else if ((*s_etat_processus).test_instruction == 'Y')
1448: {
1449: (*s_etat_processus).nombre_arguments = -1;
1450: return;
1451: }
1452:
1453: registre_pile_last = NULL;
1454:
1455: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1456: {
1457: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1458: {
1459: return;
1460: }
1461:
1462: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1463: (*s_etat_processus).l_base_pile_last = NULL;
1464: }
1465:
1466: if ((*s_etat_processus).l_base_pile == NULL)
1467: {
1468: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1469: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1470: return;
1471: }
1472:
1473: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1474: {
1475: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1476: &s_objet) == d_erreur)
1477: {
1478: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1479: return;
1480: }
1481:
1482: liberation(s_etat_processus, s_objet);
1483:
1484: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1485: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1486: return;
1487: }
1488:
1489: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1490: instruction_dup(s_etat_processus);
1491:
1492: if (((*s_etat_processus).erreur_systeme != d_es) ||
1493: ((*s_etat_processus).erreur_execution != d_ex) ||
1494: ((*s_etat_processus).exception != d_ep))
1495: {
1496: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1497: {
1498: return;
1499: }
1500:
1501: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1502:
1503: return;
1504: }
1505:
1506: instruction_rcl(s_etat_processus);
1507:
1508: if (((*s_etat_processus).erreur_systeme != d_es) ||
1509: ((*s_etat_processus).erreur_execution != d_ex) ||
1510: ((*s_etat_processus).exception != d_ep))
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: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1522: {
1523: return;
1524: }
1525:
1526: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1527:
1528: return;
1529: }
1530:
1531: instruction_edit(s_etat_processus);
1532:
1533: if (((*s_etat_processus).erreur_systeme != d_es) ||
1534: ((*s_etat_processus).erreur_execution != d_ex) ||
1535: ((*s_etat_processus).exception != d_ep))
1536: {
1537: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1538: {
1539: return;
1540: }
1541:
1542: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1543:
1544: return;
1545: }
1546:
1547: while(profondeur_initiale != ((*s_etat_processus)
1548: .hauteur_pile_operationnelle - 1))
1549: {
1550: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1551: &s_objet) == d_erreur)
1552: {
1553: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1554: return;
1555: }
1556:
1557: liberation(s_etat_processus, s_objet);
1558: }
1559:
1560: instruction_swap(s_etat_processus);
1561:
1562: if (((*s_etat_processus).erreur_systeme != d_es) ||
1563: ((*s_etat_processus).erreur_execution != d_ex) ||
1564: ((*s_etat_processus).exception != d_ep))
1565: {
1566: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1567: {
1568: return;
1569: }
1570:
1571: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1572:
1573: return;
1574: }
1575:
1576: instruction_sto(s_etat_processus);
1577:
1578: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1579: {
1580: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1581: {
1582: return;
1583: }
1584:
1585: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1586: }
1587:
1588: return;
1589: }
1590:
1591:
1592: /*
1593: ================================================================================
1594: Fonction 'variable'
1595: ================================================================================
1596: Entrées :
1597: --------------------------------------------------------------------------------
1598: Sorties :
1599: --------------------------------------------------------------------------------
1600: Effets de bord : néant
1601: ================================================================================
1602: */
1603:
1604: void
1605: instruction_variable(struct_processus *s_etat_processus)
1606: {
1607: struct_liste_chainee *l_element_courant;
1608:
1609: struct_objet *s_objet;
1610:
1611: (*s_etat_processus).erreur_execution = d_ex;
1612:
1613: if ((*s_etat_processus).affichage_arguments == 'Y')
1614: {
1615: printf("\n VARIABLE ");
1616:
1617: if ((*s_etat_processus).langue == 'F')
1618: {
1619: printf("(déverrouille une variable globale)\n\n");
1620: }
1621: else
1622: {
1623: printf("(unlock a global variable)\n\n");
1624: }
1625:
1626: printf(" 1: %s, %s\n", d_NOM, d_LST);
1627:
1628: return;
1629: }
1630: else if ((*s_etat_processus).test_instruction == 'Y')
1631: {
1632: (*s_etat_processus).nombre_arguments = -1;
1633: return;
1634: }
1635:
1636: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1637: {
1638: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1639: {
1640: return;
1641: }
1642: }
1643:
1644: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1645: &s_objet) == d_erreur)
1646: {
1647: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1648: return;
1649: }
1650:
1651: if ((*s_objet).type == NOM)
1652: {
1653: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1654: (*s_objet).objet)).nom)) == d_faux)
1655: {
1656: liberation(s_etat_processus, s_objet);
1657:
1658: (*s_etat_processus).erreur_systeme = d_es;
1659: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1660: return;
1661: }
1662:
1663: (*(*s_etat_processus).pointeur_variable_courante)
1664: .variable_verrouillee = d_faux;
1665: }
1666: else if ((*s_objet).type == LST)
1667: {
1668: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1669:
1670: while(l_element_courant != NULL)
1671: {
1672: if ((*(*l_element_courant).donnee).type != NOM)
1673: {
1674: liberation(s_etat_processus, s_objet);
1675:
1676: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1677: return;
1678: }
1679:
1680: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1681: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1682: {
1683: liberation(s_etat_processus, s_objet);
1684:
1685: (*s_etat_processus).erreur_systeme = d_es;
1686: (*s_etat_processus).erreur_execution =
1687: d_ex_variable_non_definie;
1688: return;
1689: }
1690:
1691: (*(*s_etat_processus).pointeur_variable_courante)
1692: .variable_verrouillee = d_faux;
1693:
1694: l_element_courant = (*l_element_courant).suivant;
1695: }
1696: }
1697: else
1698: {
1699: liberation(s_etat_processus, s_objet);
1700:
1701: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1702: return;
1703: }
1704:
1705: liberation(s_etat_processus, s_objet);
1706:
1707: return;
1708: }
1709:
1710: // 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