File:
[local] /
rpl /
src /
instructions_v2.c
Revision
1.22:
download - view:
text,
annotated -
select for diffs -
revision graph
Tue Jun 21 15:26:34 2011 UTC (13 years ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.0.prerelease.2
4: Copyright (C) 1989-2011 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'volatile'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_volatile(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42:
43: struct_objet *s_objet;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n VOLATILE ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(rend volatile une variable statique)\n\n");
54: }
55: else
56: {
57: printf("(make volatile a static variable)\n\n");
58: }
59:
60: printf(" 1: %s, %s\n", d_NOM, d_LST);
61:
62: return;
63: }
64: else if ((*s_etat_processus).test_instruction == 'Y')
65: {
66: (*s_etat_processus).nombre_arguments = -1;
67: return;
68: }
69:
70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
71: {
72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
73: {
74: return;
75: }
76: }
77:
78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
79: &s_objet) == d_erreur)
80: {
81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
82: return;
83: }
84:
85: if ((*s_objet).type == NOM)
86: {
87: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
88: (*s_objet).objet)).nom)) == d_faux)
89: {
90: liberation(s_etat_processus, s_objet);
91:
92: (*s_etat_processus).erreur_systeme = d_es;
93: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
94: return;
95: }
96:
97: if (((*(*s_etat_processus).pointeur_variable_courante).origine == 'P')
98: ? ((*(*s_etat_processus).pointeur_variable_courante)
99: .variable_statique.adresse == 0)
100: : ((*(*s_etat_processus).pointeur_variable_courante)
101: .variable_statique.pointeur == NULL))
102: {
103: liberation(s_etat_processus, s_objet);
104:
105: (*s_etat_processus).erreur_execution = d_ex_variable_volatile;
106: return;
107: }
108: else
109: {
110: if (retrait_variable_statique(s_etat_processus,
111: (*((struct_nom *) (*s_objet).objet)).nom,
112: (*(*s_etat_processus).pointeur_variable_courante)
113: .variable_statique) == d_erreur)
114: {
115: liberation(s_etat_processus, s_objet);
116: return;
117: }
118:
119: if ((*(*s_etat_processus).pointeur_variable_courante).origine
120: == 'P')
121: {
122: (*(*s_etat_processus).pointeur_variable_courante)
123: .variable_statique.adresse = 0;
124: }
125: else
126: {
127: (*(*s_etat_processus).pointeur_variable_courante)
128: .variable_statique.pointeur = NULL;
129: }
130: }
131: }
132: else if ((*s_objet).type == LST)
133: {
134: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
135:
136: while(l_element_courant != NULL)
137: {
138: if ((*(*l_element_courant).donnee).type != NOM)
139: {
140: liberation(s_etat_processus, s_objet);
141:
142: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
143: return;
144: }
145:
146: if (recherche_variable(s_etat_processus, (*((struct_nom *)
147: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
148: {
149: liberation(s_etat_processus, s_objet);
150:
151: (*s_etat_processus).erreur_systeme = d_es;
152: (*s_etat_processus).erreur_execution =
153: d_ex_variable_non_definie;
154: return;
155: }
156:
157: if (((*(*s_etat_processus).pointeur_variable_courante)
158: .origine == 'P') ? ((*(*s_etat_processus)
159: .pointeur_variable_courante).variable_statique.adresse == 0)
160: : ((*(*s_etat_processus).pointeur_variable_courante)
161: .variable_statique.pointeur == NULL))
162: {
163: liberation(s_etat_processus, s_objet);
164:
165: (*s_etat_processus).erreur_execution = d_ex_variable_volatile;
166: return;
167: }
168: else
169: {
170: if (retrait_variable_statique(s_etat_processus,
171: (*((struct_nom *) (*s_objet).objet)).nom,
172: (*(*s_etat_processus).pointeur_variable_courante)
173: .variable_statique) == d_erreur)
174: {
175: liberation(s_etat_processus, s_objet);
176: return;
177: }
178:
179: if ((*(*s_etat_processus).pointeur_variable_courante)
180: .origine == 'P')
181: {
182: (*(*s_etat_processus).pointeur_variable_courante)
183: .variable_statique.adresse = 0;
184: }
185: else
186: {
187: (*(*s_etat_processus).pointeur_variable_courante)
188: .variable_statique.pointeur = NULL;
189: }
190: }
191:
192: l_element_courant = (*l_element_courant).suivant;
193: }
194: }
195: else
196: {
197: liberation(s_etat_processus, s_objet);
198:
199: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
200: return;
201: }
202:
203: liberation(s_etat_processus, s_objet);
204:
205: return;
206: }
207:
208:
209: /*
210: ================================================================================
211: Fonction 'verify'
212: ================================================================================
213: Entrées :
214: --------------------------------------------------------------------------------
215: Sorties :
216: --------------------------------------------------------------------------------
217: Effets de bord : néant
218: ================================================================================
219: */
220:
221: void
222: instruction_verify(struct_processus *s_etat_processus)
223: {
224: int position;
225:
226: integer8 i1;
227: integer8 i2;
228: integer8 i3;
229: integer8 i4;
230: integer8 j1;
231: integer8 j2;
232: integer8 j3;
233: integer8 j4;
234:
235: logical1 drapeau;
236: logical1 drapeau_final;
237: logical1 drapeau_final_courant;
238: logical1 drapeau_prerelease;
239: logical1 drapeau_prerelease_courant;
240: logical1 last_valide;
241:
242: struct_liste_chainee *l_element_caracteristiques;
243: struct_liste_chainee *l_element_courant;
244: struct_liste_chainee *l_element_version;
245:
246: struct_objet *s_objet_argument;
247: struct_objet *s_objet_caracteristiques;
248: struct_objet *s_objet_resultat;
249:
250: unsigned char *chaine_majuscule;
251:
252: (*s_etat_processus).erreur_execution = d_ex;
253:
254: if ((*s_etat_processus).affichage_arguments == 'Y')
255: {
256: printf("\n VERIFY ");
257:
258: if ((*s_etat_processus).langue == 'F')
259: {
260: printf("(vérification des caractéristiques du langage)\n\n");
261: }
262: else
263: {
264: printf("(checks of the language characteristics)\n\n");
265: }
266:
267: printf(" 1: %s\n", d_LST);
268: printf("-> 1: %s (0 or -1)\n\n", d_INT);
269:
270: if ((*s_etat_processus).langue == 'F')
271: {
272: printf(" Utilisation :\n\n");
273: }
274: else
275: {
276: printf(" Usage:\n\n");
277: }
278:
279: printf(" { { 4 0 0 \"PRERELEASE\" 4 } \"POSTGRESQL\" } VERIFY\n");
280: printf(" { { 4 0 0 } } VERIFY\n");
281:
282: return;
283: }
284: else if ((*s_etat_processus).test_instruction == 'Y')
285: {
286: (*s_etat_processus).nombre_arguments = -1;
287: return;
288: }
289:
290: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
291: {
292: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
293: {
294: return;
295: }
296: }
297:
298: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
299: &s_objet_argument) == d_erreur)
300: {
301: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
302: return;
303: }
304:
305: if ((*s_objet_argument).type == LST)
306: {
307: if (last_valide == d_vrai)
308: {
309: cf(s_etat_processus, 31);
310: }
311:
312: instruction_version(s_etat_processus);
313:
314: if (last_valide == d_vrai)
315: {
316: sf(s_etat_processus, 31);
317: }
318:
319: if ((*s_etat_processus).erreur_systeme != d_es)
320: {
321: return;
322: }
323:
324: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
325: &s_objet_caracteristiques) == d_erreur)
326: {
327: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
328: return;
329: }
330:
331: /*
332: * L'objet renvoyé est obligatoirement une liste.
333: */
334:
335: BUG((*s_objet_caracteristiques).type != LST,
336: printf("(*s_objet_caracteristiques).type='%d'\n",
337: (*s_objet_caracteristiques).type));
338:
339: drapeau = d_vrai;
340: l_element_courant = (*s_objet_argument).objet;
341:
342: while((l_element_courant != NULL) && (drapeau == d_vrai))
343: {
344: if ((*(*l_element_courant).donnee).type == CHN)
345: {
346: if ((chaine_majuscule = conversion_majuscule((unsigned char *)
347: (*(*l_element_courant).donnee).objet)) == NULL)
348: {
349: (*s_etat_processus).erreur_systeme =
350: d_es_allocation_memoire;
351: return;
352: }
353:
354: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
355:
356: while(l_element_caracteristiques != NULL)
357: {
358: if ((*(*l_element_caracteristiques).donnee).type == CHN)
359: {
360: if (strcmp((unsigned char *)
361: (*(*l_element_caracteristiques).donnee).objet,
362: chaine_majuscule) == 0)
363: {
364: break;
365: }
366: }
367:
368: l_element_caracteristiques = (*l_element_caracteristiques)
369: .suivant;
370: }
371:
372: free(chaine_majuscule);
373:
374: if (l_element_caracteristiques == NULL)
375: { // La chaîne n'a pas été trouvée...
376: drapeau = d_faux;
377: break;
378: }
379: }
380: else if ((*(*l_element_courant).donnee).type == LST)
381: {
382: drapeau_final = d_vrai;
383: drapeau_prerelease = d_faux;
384: drapeau_final_courant = d_vrai;
385: drapeau_prerelease_courant = d_faux;
386: i1 = 0;
387: i2 = 0;
388: i3 = 0;
389: i4 = 0;
390: j1 = 0;
391: j2 = 0;
392: j3 = 0;
393: j4 = 0;
394:
395: l_element_version = (*(*l_element_courant).donnee).objet;
396: position = 1;
397:
398: while(l_element_version != NULL)
399: {
400: switch(position)
401: {
402: case 1 :
403: {
404: if ((*(*l_element_version).donnee).type == INT)
405: {
406: i1 = (*((integer8 *) (*(*l_element_version)
407: .donnee).objet));
408: }
409: else
410: {
411: liberation(s_etat_processus, s_objet_argument);
412: liberation(s_etat_processus,
413: s_objet_caracteristiques);
414:
415: (*s_etat_processus).erreur_execution =
416: d_ex_erreur_type_argument;
417: return;
418: }
419:
420: break;
421: }
422:
423: case 2 :
424: {
425: if ((*(*l_element_version).donnee).type == INT)
426: {
427: i2 = (*((integer8 *) (*(*l_element_version)
428: .donnee).objet));
429: }
430: else
431: {
432: liberation(s_etat_processus, s_objet_argument);
433: liberation(s_etat_processus,
434: s_objet_caracteristiques);
435:
436: (*s_etat_processus).erreur_execution =
437: d_ex_erreur_type_argument;
438: return;
439: }
440:
441: break;
442: }
443:
444: case 3 :
445: {
446: if ((*(*l_element_version).donnee).type == INT)
447: {
448: i3 = (*((integer8 *) (*(*l_element_version)
449: .donnee).objet));
450: }
451: else
452: {
453: liberation(s_etat_processus, s_objet_argument);
454: liberation(s_etat_processus,
455: s_objet_caracteristiques);
456:
457: (*s_etat_processus).erreur_execution =
458: d_ex_erreur_type_argument;
459: return;
460: }
461:
462: break;
463: }
464:
465: case 4 :
466: {
467: if ((*(*l_element_version).donnee).type == CHN)
468: {
469: if ((chaine_majuscule = conversion_majuscule(
470: (unsigned char *) (*(*l_element_version)
471: .donnee).objet)) == NULL)
472: {
473: (*s_etat_processus).erreur_systeme =
474: d_es_allocation_memoire;
475: return;
476: }
477:
478: if (strcmp(chaine_majuscule, "RELEASE") == 0)
479: {
480: drapeau_final = d_vrai;
481: }
482: else if (strcmp(chaine_majuscule, "PRERELEASE")
483: == 0)
484: {
485: drapeau_final = d_faux;
486: }
487: else
488: {
489: liberation(s_etat_processus,
490: s_objet_argument);
491: liberation(s_etat_processus,
492: s_objet_caracteristiques);
493:
494: (*s_etat_processus).erreur_execution =
495: d_ex_argument_invalide;
496: return;
497: }
498:
499: free(chaine_majuscule);
500: }
501: else
502: {
503: liberation(s_etat_processus, s_objet_argument);
504: liberation(s_etat_processus,
505: s_objet_caracteristiques);
506:
507: (*s_etat_processus).erreur_execution =
508: d_ex_erreur_type_argument;
509: return;
510: }
511:
512: break;
513: }
514:
515: case 5 :
516: {
517: if ((*(*l_element_version).donnee).type == INT)
518: {
519: i4 = (*((integer8 *) (*(*l_element_version)
520: .donnee).objet));
521: }
522: else
523: {
524: liberation(s_etat_processus, s_objet_argument);
525: liberation(s_etat_processus,
526: s_objet_caracteristiques);
527:
528: (*s_etat_processus).erreur_execution =
529: d_ex_erreur_type_argument;
530: return;
531: }
532:
533: drapeau_prerelease = d_vrai;
534: break;
535: }
536:
537: default :
538: {
539: liberation(s_etat_processus, s_objet_argument);
540: liberation(s_etat_processus,
541: s_objet_caracteristiques);
542:
543: (*s_etat_processus).erreur_execution =
544: d_ex_erreur_type_argument;
545: return;
546: break;
547: }
548: }
549:
550: position++;
551: l_element_version = (*l_element_version).suivant;
552: }
553:
554: if (drapeau_prerelease == drapeau_final)
555: {
556: liberation(s_etat_processus, s_objet_argument);
557: liberation(s_etat_processus, s_objet_caracteristiques);
558:
559: (*s_etat_processus).erreur_execution =
560: d_ex_argument_invalide;
561: return;
562: }
563:
564: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
565:
566: while(l_element_caracteristiques != NULL)
567: {
568: if ((*(*l_element_caracteristiques).donnee).type == LST)
569: {
570: l_element_version = (*(*l_element_caracteristiques)
571: .donnee).objet;
572:
573: position = 1;
574:
575: while(l_element_version != NULL)
576: {
577: switch(position)
578: {
579: case 1 :
580: {
581: j1 = (*((integer8 *) (*(*l_element_version)
582: .donnee).objet));
583: break;
584: }
585:
586: case 2 :
587: {
588: j2 = (*((integer8 *) (*(*l_element_version)
589: .donnee).objet));
590: break;
591: }
592:
593: case 3 :
594: {
595: j3 = (*((integer8 *) (*(*l_element_version)
596: .donnee).objet));
597: break;
598: }
599:
600: case 4 :
601: {
602: drapeau_final_courant =
603: (strcmp((unsigned char *)
604: (*(*l_element_version).donnee)
605: .objet, "RELEASE") == 0)
606: ? d_vrai : d_faux;
607: break;
608: }
609:
610: case 5 :
611: {
612: j4 = (*((integer8 *) (*(*l_element_version)
613: .donnee).objet));
614: drapeau_prerelease_courant = d_vrai;
615: break;
616: }
617: }
618:
619: position++;
620: l_element_version = (*l_element_version).suivant;
621: }
622:
623: break;
624: }
625:
626: l_element_caracteristiques = (*l_element_caracteristiques)
627: .suivant;
628: }
629:
630: if (drapeau_prerelease_courant == drapeau_final_courant)
631: {
632: liberation(s_etat_processus, s_objet_argument);
633: liberation(s_etat_processus, s_objet_caracteristiques);
634:
635: (*s_etat_processus).erreur_execution =
636: d_ex_argument_invalide;
637: return;
638: }
639:
640: if (i1 > j1)
641: { // Version demandée supérieure à la version courante
642: drapeau = d_faux;
643: }
644: else if (i1 == j1)
645: {
646: if (i2 > j2)
647: { // Versions idendiques et sous-version demandée
648: // supérieure à la sous-version courante
649: drapeau = d_faux;
650: }
651: else if (i2 == j2)
652: { // Versions et sous-versions identiques
653: if (i3 > j3)
654: { // Niveau de patches demandé supérieur au niveau
655: // de patch courant
656: drapeau = d_faux;
657: }
658: else if (i3 == j3)
659: { // Niveaux de patches indentiques
660: if ((drapeau_final == d_vrai) &&
661: (drapeau_final_courant == d_faux))
662: { // Finale requise et prerelease obtenue
663: drapeau = d_faux;
664: }
665: else if ((drapeau_final == d_faux) &&
666: (drapeau_final_courant == d_vrai))
667: { // Prerelease requise et finale obtenue
668: }
669: else if ((drapeau_final == d_vrai) &&
670: (drapeau_final_courant == d_vrai))
671: { // Finales de part et d'autre
672: }
673: else
674: { // Prerelease de part et d'autre
675: if (i4 > j4)
676: { // Prerelease demandée supérieur à la
677: // version courante
678: drapeau = d_faux;
679: }
680: }
681: }
682: else
683: { // Niveaux de patches inférieur au niveau courant
684: }
685: }
686: else
687: { // Versions indentiques et sous-version inférieure à
688: // la sous-version courante
689: }
690: }
691: else
692: { // Version demandée inférieure à la version courante
693: }
694: }
695: else
696: {
697: liberation(s_etat_processus, s_objet_argument);
698: liberation(s_etat_processus, s_objet_caracteristiques);
699:
700: (*s_etat_processus).erreur_execution =
701: d_ex_erreur_type_argument;
702: return;
703: }
704:
705: l_element_courant = (*l_element_courant).suivant;
706: }
707:
708: liberation(s_etat_processus, s_objet_caracteristiques);
709:
710: /*
711: * Création du drapeau renvoyé
712: */
713:
714: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
715: {
716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
717: return;
718: }
719:
720: (*((integer8 *) (*s_objet_resultat).objet)) = (drapeau == d_vrai)
721: ? -1 : 0;
722:
723: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
724: s_objet_resultat) == d_erreur)
725: {
726: return;
727: }
728: }
729: else
730: {
731: liberation(s_etat_processus, s_objet_argument);
732:
733: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
734: return;
735: }
736:
737: liberation(s_etat_processus, s_objet_argument);
738:
739: return;
740: }
741:
742: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>