Annotation of rpl/src/instructions_v1.c, revision 1.51
1.1 bertrand 1: /*
2: ================================================================================
1.49 bertrand 3: RPL/2 (R) version 4.1.13
1.48 bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'var'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_var(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_statistique;
42: struct_objet *s_objet_resultat;
43: struct_objet *s_objet_temporaire;
44:
1.50 bertrand 45: integer8 nombre_colonnes;
1.1 bertrand 46:
47: (*s_etat_processus).erreur_execution = d_ex;
48:
49: if ((*s_etat_processus).affichage_arguments == 'Y')
50: {
51: printf("\n VAR ");
52:
53: if ((*s_etat_processus).langue == 'F')
54: {
55: printf("(variance)\n\n");
56: }
57: else
58: {
59: printf("(variance)\n\n");
60: }
61:
62: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: /*
81: * Recherche d'une variable globale référencée par SIGMA
82: */
83:
1.19 bertrand 84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
1.1 bertrand 85: {
86: /*
87: * Aucune variable SIGMA
88: */
89:
90: (*s_etat_processus).erreur_systeme = d_es;
1.19 bertrand 91:
92: if ((*s_etat_processus).erreur_execution == d_ex)
93: {
94: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
95: }
96:
1.1 bertrand 97: return;
98: }
99: else
100: {
1.19 bertrand 101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
102: .type != MIN) && ((*(*(*s_etat_processus)
103: .pointeur_variable_courante).objet).type != MRL))
1.1 bertrand 104: {
1.19 bertrand 105: (*s_etat_processus).erreur_execution =
106: d_ex_matrice_statistique_invalide;
1.1 bertrand 107: return;
108: }
109:
1.19 bertrand 110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus)
111: .pointeur_variable_courante).objet).objet))
112: .nombre_colonnes;
1.1 bertrand 113: }
114:
1.19 bertrand 115: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante)
116: .objet;
1.1 bertrand 117:
118: if (((*s_objet_statistique).type == MIN) ||
119: ((*s_objet_statistique).type == MRL))
120: {
121: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
122: <= 1)
123: {
124: (*s_etat_processus).erreur_execution =
125: d_ex_statistiques_echantillon;
126: return;
127: }
128:
129: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
130: {
131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
132: return;
133: }
134:
135: if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *)
136: (*s_objet_statistique).objet, 'E')) == NULL)
137: {
138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
139: return;
140: }
141:
142: if (nombre_colonnes == 1)
143: {
144: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
145: {
146: (*s_objet_resultat).type = VIN;
147: s_objet_temporaire = s_objet_resultat;
148:
149: if ((s_objet_resultat = allocation(s_etat_processus, INT))
150: == NULL)
151: {
152: (*s_etat_processus).erreur_systeme =
153: d_es_allocation_memoire;
154: return;
155: }
156:
157: (*((integer8 *) (*s_objet_resultat).objet)) =
158: ((integer8 *) (*((struct_vecteur *)
159: (*s_objet_temporaire).objet)).tableau)[0];
160:
161: liberation(s_etat_processus, s_objet_temporaire);
162: }
163: else
164: {
165: (*s_objet_resultat).type = VRL;
166: s_objet_temporaire = s_objet_resultat;
167:
168: if ((s_objet_resultat = allocation(s_etat_processus, REL))
169: == NULL)
170: {
171: (*s_etat_processus).erreur_systeme =
172: d_es_allocation_memoire;
173: return;
174: }
175:
176: (*((real8 *) (*s_objet_resultat).objet)) =
177: ((real8 *) (*((struct_vecteur *)
178: (*s_objet_temporaire).objet)).tableau)[0];
179:
180: liberation(s_etat_processus, s_objet_temporaire);
181: }
182: }
183: else
184: {
185: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
186: {
187: (*s_objet_resultat).type = VIN;
188: }
189: else
190: {
191: (*s_objet_resultat).type = VRL;
192: }
193: }
194:
195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
196: s_objet_resultat) == d_erreur)
197: {
198: return;
199: }
200: }
201: else
202: {
203: (*s_etat_processus).erreur_execution =
204: d_ex_matrice_statistique_invalide;
205: return;
206: }
207:
208: return;
209: }
210:
211:
212: /*
213: ================================================================================
214: Fonction 'version'
215: ================================================================================
216: Entrées :
217: --------------------------------------------------------------------------------
218: Sorties :
219: --------------------------------------------------------------------------------
220: Effets de bord : néant
221: ================================================================================
222: */
223:
224: void
225: instruction_version(struct_processus *s_etat_processus)
226: {
227: int nombre_champs;
228:
229: integer8 i1;
230: integer8 i2;
231: integer8 i3;
232: integer8 i4;
233:
234: struct_liste_chainee *l_element_courant;
235: struct_liste_chainee *l_element_interne_courant;
236:
237: struct_objet *s_objet_resultat;
238:
239: unsigned char texte[] = "RPL/2 version ";
1.28 bertrand 240: unsigned char tampon[256 + 1];
241:
1.1 bertrand 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:
1.34 bertrand 503: if (((*(*l_element_courant).donnee).objet = date_compilation()) == NULL)
1.1 bertrand 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:
1.28 bertrand 830: #ifdef RPLCAS
831: if (((*(*l_element_courant).donnee).objet = malloc(8 *
1.1 bertrand 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,
1.28 bertrand 839: "RPL/CAS");
1.1 bertrand 840: #else
1.28 bertrand 841: if (((*(*l_element_courant).donnee).objet = malloc(17 *
1.1 bertrand 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,
1.28 bertrand 849: "RPL/CAS DISABLED");
1.1 bertrand 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:
1.28 bertrand 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:
1.32 bertrand 908: sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);
1.28 bertrand 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:
1.1 bertrand 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: {
1.50 bertrand 972: integer8 i;
973: integer8 nb_variables;
1.20 bertrand 974:
1.1 bertrand 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:
1.20 bertrand 982: struct_tableau_variables *tableau;
1.1 bertrand 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:
1.51 ! bertrand 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:
1.45 bertrand 1032: nb_variables = nombre_variables(s_etat_processus);
1.20 bertrand 1033:
1.50 bertrand 1034: if ((tableau = malloc(((size_t) nb_variables) *
1035: sizeof(struct_tableau_variables))) == NULL)
1.20 bertrand 1036: {
1.45 bertrand 1037: liberation_mutexes_arbre_variables_partagees(s_etat_processus,
1038: (*(*s_etat_processus).s_arbre_variables_partagees));
1.51 ! bertrand 1039: pthread_mutex_unlock(&mutex_liste_variables_partagees);
1.20 bertrand 1040: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1041: return;
1042: }
1043:
1.51 ! bertrand 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: }
1.20 bertrand 1051:
1052: for(i = 0; i < nb_variables; i++)
1.1 bertrand 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:
1.20 bertrand 1102: if (tableau[i].objet == NULL)
1.1 bertrand 1103: {
1104: if (recherche_variable_partagee(s_etat_processus,
1.20 bertrand 1105: tableau[i].nom, tableau[i].variable_partagee,
1.45 bertrand 1106: tableau[i].origine) == NULL)
1.1 bertrand 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)
1.44 bertrand 1130: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1131: {
1132: (*s_etat_processus).erreur_systeme = d_es_processus;
1133: return;
1134: }
1135: }
1136:
1.51 ! bertrand 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:
1.1 bertrand 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 =
1.20 bertrand 1153: malloc((strlen(tableau[i].nom)
1.1 bertrand 1154: + 1) * sizeof(unsigned char))) == NULL)
1155: {
1156: if (variable_partagee == d_vrai)
1157: {
1158: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.44 bertrand 1159: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1160: {
1161: (*s_etat_processus).erreur_systeme = d_es_processus;
1162: return;
1163: }
1164: }
1165:
1.51 ! bertrand 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:
1.1 bertrand 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))
1.20 bertrand 1178: .donnee).objet)).nom, tableau[i].nom);
1.1 bertrand 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)
1.44 bertrand 1191: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1192: {
1193: (*s_etat_processus).erreur_systeme = d_es_processus;
1194: return;
1195: }
1196: }
1197:
1.51 ! bertrand 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:
1.1 bertrand 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)
1.44 bertrand 1215: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1216: {
1217: (*s_etat_processus).erreur_systeme = d_es_processus;
1218: return;
1219: }
1220: }
1221:
1.51 ! bertrand 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:
1.1 bertrand 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)) =
1.20 bertrand 1234: (integer8) tableau[i].niveau;
1.1 bertrand 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)
1.44 bertrand 1247: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1248: {
1249: (*s_etat_processus).erreur_systeme = d_es_processus;
1250: return;
1251: }
1252: }
1253:
1.51 ! bertrand 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:
1.1 bertrand 1260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1261: return;
1262: }
1263:
1.20 bertrand 1264: if (tableau[i].objet == NULL)
1.1 bertrand 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,
1.44 bertrand 1271: (*(*s_etat_processus).pointeur_variable_partagee_courante)
1272: .objet, 'P')) == NULL)
1.1 bertrand 1273: {
1274: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.44 bertrand 1275: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1276: {
1277: (*s_etat_processus).erreur_systeme = d_es_processus;
1278: return;
1279: }
1280:
1.51 ! bertrand 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:
1.1 bertrand 1288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1289: return;
1290: }
1291:
1292: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.44 bertrand 1293: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 1294: {
1.51 ! bertrand 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:
1.1 bertrand 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)
1.20 bertrand 1312: .donnee = copie_objet(s_etat_processus, tableau[i].objet,
1313: 'P')) == NULL)
1.1 bertrand 1314: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 1355: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1356: return;
1357: }
1358:
1.20 bertrand 1359: if ((tableau[i].origine == 'P')
1360: ? (tableau[i].variable_statique.adresse != 0)
1361: : (tableau[i].variable_statique.pointeur != NULL))
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 1375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1376: return;
1377: }
1378:
1.43 bertrand 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: }
1.1 bertrand 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)
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 1447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1448: return;
1449: }
1450:
1.20 bertrand 1451: if (tableau[i].variable_verrouillee == d_vrai)
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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
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: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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: {
1.51 ! bertrand 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:
1.1 bertrand 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: "SHARED");
1554: }
1555: else
1556: {
1557: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1558: (*l_element_courant).donnee)).objet)).suivant).suivant)
1559: .suivant).suivant).suivant).donnee).objet = malloc(8 *
1560: sizeof(unsigned char))) == NULL)
1561: {
1.51 ! bertrand 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:
1.1 bertrand 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: "PRIVATE");
1577: }
1578:
1579: /*
1580: * Fermeture de la liste incluse
1581: */
1582:
1583: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
1584: (*l_element_courant).donnee)).objet)).suivant).suivant)
1585: .suivant).suivant).suivant).suivant = NULL;
1586:
1587: l_element_precedent = l_element_courant;
1.51 ! bertrand 1588:
! 1589: if (tableau[i].mutex != NULL)
! 1590: {
! 1591: // La variable est une variable partagée. On libère
! 1592: // le mutex.
! 1593: pthread_mutex_unlock(tableau[i].mutex);
! 1594: }
1.1 bertrand 1595: }
1.20 bertrand 1596:
1597: free(tableau);
1.1 bertrand 1598:
1599: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1600: s_objet_resultat) == d_erreur)
1601: {
1602: return;
1603: }
1604:
1605: return;
1606: }
1607:
1608:
1609: /*
1610: ================================================================================
1611: Fonction 'visit'
1612: ================================================================================
1613: Entrées :
1614: --------------------------------------------------------------------------------
1615: Sorties :
1616: --------------------------------------------------------------------------------
1617: Effets de bord : néant
1618: ================================================================================
1619: */
1620:
1621: void
1622: instruction_visit(struct_processus *s_etat_processus)
1623: {
1624: struct_liste_chainee *registre_pile_last;
1625:
1626: struct_objet *s_objet;
1627:
1.50 bertrand 1628: integer8 profondeur_initiale;
1.1 bertrand 1629:
1630: (*s_etat_processus).erreur_execution = d_ex;
1631:
1632: if ((*s_etat_processus).affichage_arguments == 'Y')
1633: {
1634: printf("\n VISIT ");
1635:
1636: if ((*s_etat_processus).langue == 'F')
1637: {
1638: printf("(édition d'une variable)\n\n");
1639: }
1640: else
1641: {
1642: printf("(edit variable)\n\n");
1643: }
1644:
1645: printf(" 1: %s\n", d_NOM);
1646:
1647: return;
1648: }
1649: else if ((*s_etat_processus).test_instruction == 'Y')
1650: {
1651: (*s_etat_processus).nombre_arguments = -1;
1652: return;
1653: }
1654:
1655: registre_pile_last = NULL;
1656:
1657: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1658: {
1659: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1660: {
1661: return;
1662: }
1663:
1664: registre_pile_last = (*s_etat_processus).l_base_pile_last;
1665: (*s_etat_processus).l_base_pile_last = NULL;
1666: }
1667:
1668: if ((*s_etat_processus).l_base_pile == NULL)
1669: {
1670: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1671: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1672: return;
1673: }
1674:
1675: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
1676: {
1677: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1678: &s_objet) == d_erreur)
1679: {
1680: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1681: return;
1682: }
1683:
1684: liberation(s_etat_processus, s_objet);
1685:
1686: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1687: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1688: return;
1689: }
1690:
1691: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
1692: instruction_dup(s_etat_processus);
1693:
1694: if (((*s_etat_processus).erreur_systeme != d_es) ||
1695: ((*s_etat_processus).erreur_execution != d_ex) ||
1696: ((*s_etat_processus).exception != d_ep))
1697: {
1698: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1699: {
1700: return;
1701: }
1702:
1703: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1704:
1705: return;
1706: }
1707:
1708: instruction_rcl(s_etat_processus);
1709:
1710: if (((*s_etat_processus).erreur_systeme != d_es) ||
1711: ((*s_etat_processus).erreur_execution != d_ex) ||
1712: ((*s_etat_processus).exception != d_ep))
1713: {
1714: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1715: &s_objet) == d_erreur)
1716: {
1717: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1718: return;
1719: }
1720:
1721: liberation(s_etat_processus, s_objet);
1722:
1723: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1724: {
1725: return;
1726: }
1727:
1728: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1729:
1730: return;
1731: }
1732:
1733: instruction_edit(s_etat_processus);
1734:
1735: if (((*s_etat_processus).erreur_systeme != d_es) ||
1736: ((*s_etat_processus).erreur_execution != d_ex) ||
1737: ((*s_etat_processus).exception != d_ep))
1738: {
1739: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1740: {
1741: return;
1742: }
1743:
1744: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1745:
1746: return;
1747: }
1748:
1749: while(profondeur_initiale != ((*s_etat_processus)
1750: .hauteur_pile_operationnelle - 1))
1751: {
1752: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1753: &s_objet) == d_erreur)
1754: {
1755: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1756: return;
1757: }
1758:
1759: liberation(s_etat_processus, s_objet);
1760: }
1761:
1762: instruction_swap(s_etat_processus);
1763:
1764: if (((*s_etat_processus).erreur_systeme != d_es) ||
1765: ((*s_etat_processus).erreur_execution != d_ex) ||
1766: ((*s_etat_processus).exception != d_ep))
1767: {
1768: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1769: {
1770: return;
1771: }
1772:
1773: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1774:
1775: return;
1776: }
1777:
1778: instruction_sto(s_etat_processus);
1779:
1780: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1781: {
1782: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
1783: {
1784: return;
1785: }
1786:
1787: (*s_etat_processus).l_base_pile_last = registre_pile_last;
1788: }
1789:
1790: return;
1791: }
1792:
1793:
1794: /*
1795: ================================================================================
1796: Fonction 'variable'
1797: ================================================================================
1798: Entrées :
1799: --------------------------------------------------------------------------------
1800: Sorties :
1801: --------------------------------------------------------------------------------
1802: Effets de bord : néant
1803: ================================================================================
1804: */
1805:
1806: void
1807: instruction_variable(struct_processus *s_etat_processus)
1808: {
1809: struct_liste_chainee *l_element_courant;
1810:
1811: struct_objet *s_objet;
1812:
1813: (*s_etat_processus).erreur_execution = d_ex;
1814:
1815: if ((*s_etat_processus).affichage_arguments == 'Y')
1816: {
1817: printf("\n VARIABLE ");
1818:
1819: if ((*s_etat_processus).langue == 'F')
1820: {
1821: printf("(déverrouille une variable globale)\n\n");
1822: }
1823: else
1824: {
1825: printf("(unlock a global variable)\n\n");
1826: }
1827:
1828: printf(" 1: %s, %s\n", d_NOM, d_LST);
1829:
1830: return;
1831: }
1832: else if ((*s_etat_processus).test_instruction == 'Y')
1833: {
1834: (*s_etat_processus).nombre_arguments = -1;
1835: return;
1836: }
1837:
1838: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1839: {
1840: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1841: {
1842: return;
1843: }
1844: }
1845:
1846: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1847: &s_objet) == d_erreur)
1848: {
1849: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1850: return;
1851: }
1852:
1853: if ((*s_objet).type == NOM)
1854: {
1.19 bertrand 1855: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *)
1.1 bertrand 1856: (*s_objet).objet)).nom)) == d_faux)
1857: {
1858: liberation(s_etat_processus, s_objet);
1859:
1860: (*s_etat_processus).erreur_systeme = d_es;
1861: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
1862: return;
1863: }
1864:
1.19 bertrand 1865: (*(*s_etat_processus).pointeur_variable_courante)
1866: .variable_verrouillee = d_faux;
1.1 bertrand 1867: }
1868: else if ((*s_objet).type == LST)
1869: {
1870: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1871:
1872: while(l_element_courant != NULL)
1873: {
1874: if ((*(*l_element_courant).donnee).type != NOM)
1875: {
1876: liberation(s_etat_processus, s_objet);
1877:
1878: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
1879: return;
1880: }
1881:
1.19 bertrand 1882: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
1.1 bertrand 1883: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
1884: {
1885: liberation(s_etat_processus, s_objet);
1886:
1887: (*s_etat_processus).erreur_systeme = d_es;
1888: (*s_etat_processus).erreur_execution =
1889: d_ex_variable_non_definie;
1890: return;
1891: }
1892:
1.19 bertrand 1893: (*(*s_etat_processus).pointeur_variable_courante)
1894: .variable_verrouillee = d_faux;
1.1 bertrand 1895:
1896: l_element_courant = (*l_element_courant).suivant;
1897: }
1898: }
1899: else
1900: {
1901: liberation(s_etat_processus, s_objet);
1902:
1903: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1904: return;
1905: }
1906:
1907: liberation(s_etat_processus, s_objet);
1908:
1909: return;
1910: }
1911:
1912: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>