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