![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_v2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_v2.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.34 ! bertrand 3: RPL/2 (R) version 4.1.8
1.31 bertrand 4: Copyright (C) 1989-2012 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 '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:
1.19 bertrand 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))
1.1 bertrand 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,
1.19 bertrand 112: (*(*s_etat_processus).pointeur_variable_courante)
113: .variable_statique) == d_erreur)
1.1 bertrand 114: {
115: liberation(s_etat_processus, s_objet);
116: return;
117: }
118:
1.19 bertrand 119: if ((*(*s_etat_processus).pointeur_variable_courante).origine
120: == 'P')
1.1 bertrand 121: {
1.19 bertrand 122: (*(*s_etat_processus).pointeur_variable_courante)
123: .variable_statique.adresse = 0;
1.1 bertrand 124: }
125: else
126: {
1.19 bertrand 127: (*(*s_etat_processus).pointeur_variable_courante)
128: .variable_statique.pointeur = NULL;
1.1 bertrand 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:
1.19 bertrand 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))
1.1 bertrand 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,
1.19 bertrand 172: (*(*s_etat_processus).pointeur_variable_courante)
1.1 bertrand 173: .variable_statique) == d_erreur)
174: {
175: liberation(s_etat_processus, s_objet);
176: return;
177: }
178:
1.19 bertrand 179: if ((*(*s_etat_processus).pointeur_variable_courante)
180: .origine == 'P')
1.1 bertrand 181: {
1.19 bertrand 182: (*(*s_etat_processus).pointeur_variable_courante)
183: .variable_statique.adresse = 0;
1.1 bertrand 184: }
185: else
186: {
1.19 bertrand 187: (*(*s_etat_processus).pointeur_variable_courante)
188: .variable_statique.pointeur = NULL;
1.1 bertrand 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