![[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.50 bertrand 3: RPL/2 (R) version 4.1.20
1.49 bertrand 4: Copyright (C) 1989-2015 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: {
1.51 ! bertrand 346: if ((chaine_majuscule = conversion_majuscule(
! 347: s_etat_processus, (unsigned char *)
1.1 bertrand 348: (*(*l_element_courant).donnee).objet)) == NULL)
349: {
350: (*s_etat_processus).erreur_systeme =
351: d_es_allocation_memoire;
352: return;
353: }
354:
355: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
356:
357: while(l_element_caracteristiques != NULL)
358: {
359: if ((*(*l_element_caracteristiques).donnee).type == CHN)
360: {
361: if (strcmp((unsigned char *)
362: (*(*l_element_caracteristiques).donnee).objet,
363: chaine_majuscule) == 0)
364: {
365: break;
366: }
367: }
368:
369: l_element_caracteristiques = (*l_element_caracteristiques)
370: .suivant;
371: }
372:
373: free(chaine_majuscule);
374:
375: if (l_element_caracteristiques == NULL)
376: { // La chaîne n'a pas été trouvée...
377: drapeau = d_faux;
378: break;
379: }
380: }
381: else if ((*(*l_element_courant).donnee).type == LST)
382: {
383: drapeau_final = d_vrai;
384: drapeau_prerelease = d_faux;
385: drapeau_final_courant = d_vrai;
386: drapeau_prerelease_courant = d_faux;
387: i1 = 0;
388: i2 = 0;
389: i3 = 0;
390: i4 = 0;
391: j1 = 0;
392: j2 = 0;
393: j3 = 0;
394: j4 = 0;
395:
396: l_element_version = (*(*l_element_courant).donnee).objet;
397: position = 1;
398:
399: while(l_element_version != NULL)
400: {
401: switch(position)
402: {
403: case 1 :
404: {
405: if ((*(*l_element_version).donnee).type == INT)
406: {
407: i1 = (*((integer8 *) (*(*l_element_version)
408: .donnee).objet));
409: }
410: else
411: {
412: liberation(s_etat_processus, s_objet_argument);
413: liberation(s_etat_processus,
414: s_objet_caracteristiques);
415:
416: (*s_etat_processus).erreur_execution =
417: d_ex_erreur_type_argument;
418: return;
419: }
420:
421: break;
422: }
423:
424: case 2 :
425: {
426: if ((*(*l_element_version).donnee).type == INT)
427: {
428: i2 = (*((integer8 *) (*(*l_element_version)
429: .donnee).objet));
430: }
431: else
432: {
433: liberation(s_etat_processus, s_objet_argument);
434: liberation(s_etat_processus,
435: s_objet_caracteristiques);
436:
437: (*s_etat_processus).erreur_execution =
438: d_ex_erreur_type_argument;
439: return;
440: }
441:
442: break;
443: }
444:
445: case 3 :
446: {
447: if ((*(*l_element_version).donnee).type == INT)
448: {
449: i3 = (*((integer8 *) (*(*l_element_version)
450: .donnee).objet));
451: }
452: else
453: {
454: liberation(s_etat_processus, s_objet_argument);
455: liberation(s_etat_processus,
456: s_objet_caracteristiques);
457:
458: (*s_etat_processus).erreur_execution =
459: d_ex_erreur_type_argument;
460: return;
461: }
462:
463: break;
464: }
465:
466: case 4 :
467: {
468: if ((*(*l_element_version).donnee).type == CHN)
469: {
470: if ((chaine_majuscule = conversion_majuscule(
1.51 ! bertrand 471: s_etat_processus,
1.1 bertrand 472: (unsigned char *) (*(*l_element_version)
473: .donnee).objet)) == NULL)
474: {
475: (*s_etat_processus).erreur_systeme =
476: d_es_allocation_memoire;
477: return;
478: }
479:
480: if (strcmp(chaine_majuscule, "RELEASE") == 0)
481: {
482: drapeau_final = d_vrai;
483: }
484: else if (strcmp(chaine_majuscule, "PRERELEASE")
485: == 0)
486: {
487: drapeau_final = d_faux;
488: }
489: else
490: {
491: liberation(s_etat_processus,
492: s_objet_argument);
493: liberation(s_etat_processus,
494: s_objet_caracteristiques);
495:
496: (*s_etat_processus).erreur_execution =
497: d_ex_argument_invalide;
498: return;
499: }
500:
501: free(chaine_majuscule);
502: }
503: else
504: {
505: liberation(s_etat_processus, s_objet_argument);
506: liberation(s_etat_processus,
507: s_objet_caracteristiques);
508:
509: (*s_etat_processus).erreur_execution =
510: d_ex_erreur_type_argument;
511: return;
512: }
513:
514: break;
515: }
516:
517: case 5 :
518: {
519: if ((*(*l_element_version).donnee).type == INT)
520: {
521: i4 = (*((integer8 *) (*(*l_element_version)
522: .donnee).objet));
523: }
524: else
525: {
526: liberation(s_etat_processus, s_objet_argument);
527: liberation(s_etat_processus,
528: s_objet_caracteristiques);
529:
530: (*s_etat_processus).erreur_execution =
531: d_ex_erreur_type_argument;
532: return;
533: }
534:
535: drapeau_prerelease = d_vrai;
536: break;
537: }
538:
539: default :
540: {
541: liberation(s_etat_processus, s_objet_argument);
542: liberation(s_etat_processus,
543: s_objet_caracteristiques);
544:
545: (*s_etat_processus).erreur_execution =
546: d_ex_erreur_type_argument;
547: return;
548: break;
549: }
550: }
551:
552: position++;
553: l_element_version = (*l_element_version).suivant;
554: }
555:
556: if (drapeau_prerelease == drapeau_final)
557: {
558: liberation(s_etat_processus, s_objet_argument);
559: liberation(s_etat_processus, s_objet_caracteristiques);
560:
561: (*s_etat_processus).erreur_execution =
562: d_ex_argument_invalide;
563: return;
564: }
565:
566: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
567:
568: while(l_element_caracteristiques != NULL)
569: {
570: if ((*(*l_element_caracteristiques).donnee).type == LST)
571: {
572: l_element_version = (*(*l_element_caracteristiques)
573: .donnee).objet;
574:
575: position = 1;
576:
577: while(l_element_version != NULL)
578: {
579: switch(position)
580: {
581: case 1 :
582: {
583: j1 = (*((integer8 *) (*(*l_element_version)
584: .donnee).objet));
585: break;
586: }
587:
588: case 2 :
589: {
590: j2 = (*((integer8 *) (*(*l_element_version)
591: .donnee).objet));
592: break;
593: }
594:
595: case 3 :
596: {
597: j3 = (*((integer8 *) (*(*l_element_version)
598: .donnee).objet));
599: break;
600: }
601:
602: case 4 :
603: {
604: drapeau_final_courant =
605: (strcmp((unsigned char *)
606: (*(*l_element_version).donnee)
607: .objet, "RELEASE") == 0)
608: ? d_vrai : d_faux;
609: break;
610: }
611:
612: case 5 :
613: {
614: j4 = (*((integer8 *) (*(*l_element_version)
615: .donnee).objet));
616: drapeau_prerelease_courant = d_vrai;
617: break;
618: }
619: }
620:
621: position++;
622: l_element_version = (*l_element_version).suivant;
623: }
624:
625: break;
626: }
627:
628: l_element_caracteristiques = (*l_element_caracteristiques)
629: .suivant;
630: }
631:
632: if (drapeau_prerelease_courant == drapeau_final_courant)
633: {
634: liberation(s_etat_processus, s_objet_argument);
635: liberation(s_etat_processus, s_objet_caracteristiques);
636:
637: (*s_etat_processus).erreur_execution =
638: d_ex_argument_invalide;
639: return;
640: }
641:
642: if (i1 > j1)
643: { // Version demandée supérieure à la version courante
644: drapeau = d_faux;
645: }
646: else if (i1 == j1)
647: {
648: if (i2 > j2)
649: { // Versions idendiques et sous-version demandée
650: // supérieure à la sous-version courante
651: drapeau = d_faux;
652: }
653: else if (i2 == j2)
654: { // Versions et sous-versions identiques
655: if (i3 > j3)
656: { // Niveau de patches demandé supérieur au niveau
657: // de patch courant
658: drapeau = d_faux;
659: }
660: else if (i3 == j3)
661: { // Niveaux de patches indentiques
662: if ((drapeau_final == d_vrai) &&
663: (drapeau_final_courant == d_faux))
664: { // Finale requise et prerelease obtenue
665: drapeau = d_faux;
666: }
667: else if ((drapeau_final == d_faux) &&
668: (drapeau_final_courant == d_vrai))
669: { // Prerelease requise et finale obtenue
670: }
671: else if ((drapeau_final == d_vrai) &&
672: (drapeau_final_courant == d_vrai))
673: { // Finales de part et d'autre
674: }
675: else
676: { // Prerelease de part et d'autre
677: if (i4 > j4)
678: { // Prerelease demandée supérieur à la
679: // version courante
680: drapeau = d_faux;
681: }
682: }
683: }
684: else
685: { // Niveaux de patches inférieur au niveau courant
686: }
687: }
688: else
689: { // Versions indentiques et sous-version inférieure à
690: // la sous-version courante
691: }
692: }
693: else
694: { // Version demandée inférieure à la version courante
695: }
696: }
697: else
698: {
699: liberation(s_etat_processus, s_objet_argument);
700: liberation(s_etat_processus, s_objet_caracteristiques);
701:
702: (*s_etat_processus).erreur_execution =
703: d_ex_erreur_type_argument;
704: return;
705: }
706:
707: l_element_courant = (*l_element_courant).suivant;
708: }
709:
710: liberation(s_etat_processus, s_objet_caracteristiques);
711:
712: /*
713: * Création du drapeau renvoyé
714: */
715:
716: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
717: {
718: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
719: return;
720: }
721:
722: (*((integer8 *) (*s_objet_resultat).objet)) = (drapeau == d_vrai)
723: ? -1 : 0;
724:
725: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
726: s_objet_resultat) == d_erreur)
727: {
728: return;
729: }
730: }
731: else
732: {
733: liberation(s_etat_processus, s_objet_argument);
734:
735: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
736: return;
737: }
738:
739: liberation(s_etat_processus, s_objet_argument);
740:
741: return;
742: }
743:
744: // vim: ts=4