![[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.14 ! bertrand 3: RPL/2 (R) version 4.0.20
1.1 bertrand 4: Copyright (C) 1989-2010 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:
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:
97: if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)
98: .position_variable_courante].origine == 'P')
99: ? ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
100: .position_variable_courante].variable_statique.adresse == 0)
101: : ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
102: .position_variable_courante].variable_statique.pointeur
103: == NULL))
104: {
105: liberation(s_etat_processus, s_objet);
106:
107: (*s_etat_processus).erreur_execution = d_ex_variable_volatile;
108: return;
109: }
110: else
111: {
112: if (retrait_variable_statique(s_etat_processus,
113: (*((struct_nom *) (*s_objet).objet)).nom,
114: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
115: .position_variable_courante].variable_statique)
116: == d_erreur)
117: {
118: liberation(s_etat_processus, s_objet);
119: return;
120: }
121:
122: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
123: .position_variable_courante].origine == 'P')
124: {
125: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
126: .position_variable_courante].variable_statique.adresse
127: = 0;
128: }
129: else
130: {
131: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
132: .position_variable_courante].variable_statique.pointeur
133: = NULL;
134: }
135: }
136: }
137: else if ((*s_objet).type == LST)
138: {
139: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
140:
141: while(l_element_courant != NULL)
142: {
143: if ((*(*l_element_courant).donnee).type != NOM)
144: {
145: liberation(s_etat_processus, s_objet);
146:
147: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
148: return;
149: }
150:
151: if (recherche_variable(s_etat_processus, (*((struct_nom *)
152: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
153: {
154: liberation(s_etat_processus, s_objet);
155:
156: (*s_etat_processus).erreur_systeme = d_es;
157: (*s_etat_processus).erreur_execution =
158: d_ex_variable_non_definie;
159: return;
160: }
161:
162: if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)
163: .position_variable_courante].origine == 'P')
164: ? ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
165: .position_variable_courante].variable_statique.adresse == 0)
166: : ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
167: .position_variable_courante].variable_statique.pointeur
168: == NULL))
169: {
170: liberation(s_etat_processus, s_objet);
171:
172: (*s_etat_processus).erreur_execution = d_ex_variable_volatile;
173: return;
174: }
175: else
176: {
177: if (retrait_variable_statique(s_etat_processus,
178: (*((struct_nom *) (*s_objet).objet)).nom,
179: (*s_etat_processus).s_liste_variables
180: [(*s_etat_processus).position_variable_courante]
181: .variable_statique) == d_erreur)
182: {
183: liberation(s_etat_processus, s_objet);
184: return;
185: }
186:
187: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
188: .position_variable_courante].origine == 'P')
189: {
190: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
191: .position_variable_courante].variable_statique
192: .adresse = 0;
193: }
194: else
195: {
196: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
197: .position_variable_courante].variable_statique
198: .pointeur = NULL;
199: }
200: }
201:
202: l_element_courant = (*l_element_courant).suivant;
203: }
204: }
205: else
206: {
207: liberation(s_etat_processus, s_objet);
208:
209: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
210: return;
211: }
212:
213: liberation(s_etat_processus, s_objet);
214:
215: return;
216: }
217:
218:
219: /*
220: ================================================================================
221: Fonction 'verify'
222: ================================================================================
223: Entrées :
224: --------------------------------------------------------------------------------
225: Sorties :
226: --------------------------------------------------------------------------------
227: Effets de bord : néant
228: ================================================================================
229: */
230:
231: void
232: instruction_verify(struct_processus *s_etat_processus)
233: {
234: int position;
235:
236: integer8 i1;
237: integer8 i2;
238: integer8 i3;
239: integer8 i4;
240: integer8 j1;
241: integer8 j2;
242: integer8 j3;
243: integer8 j4;
244:
245: logical1 drapeau;
246: logical1 drapeau_final;
247: logical1 drapeau_final_courant;
248: logical1 drapeau_prerelease;
249: logical1 drapeau_prerelease_courant;
250: logical1 last_valide;
251:
252: struct_liste_chainee *l_element_caracteristiques;
253: struct_liste_chainee *l_element_courant;
254: struct_liste_chainee *l_element_version;
255:
256: struct_objet *s_objet_argument;
257: struct_objet *s_objet_caracteristiques;
258: struct_objet *s_objet_resultat;
259:
260: unsigned char *chaine_majuscule;
261:
262: (*s_etat_processus).erreur_execution = d_ex;
263:
264: if ((*s_etat_processus).affichage_arguments == 'Y')
265: {
266: printf("\n VERIFY ");
267:
268: if ((*s_etat_processus).langue == 'F')
269: {
270: printf("(vérification des caractéristiques du langage)\n\n");
271: }
272: else
273: {
274: printf("(checks of the language characteristics)\n\n");
275: }
276:
277: printf(" 1: %s\n", d_LST);
278: printf("-> 1: %s (0 or -1)\n\n", d_INT);
279:
280: if ((*s_etat_processus).langue == 'F')
281: {
282: printf(" Utilisation :\n\n");
283: }
284: else
285: {
286: printf(" Usage:\n\n");
287: }
288:
289: printf(" { { 4 0 0 \"PRERELEASE\" 4 } \"POSTGRESQL\" } VERIFY\n");
290: printf(" { { 4 0 0 } } VERIFY\n");
291:
292: return;
293: }
294: else if ((*s_etat_processus).test_instruction == 'Y')
295: {
296: (*s_etat_processus).nombre_arguments = -1;
297: return;
298: }
299:
300: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
301: {
302: if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
303: {
304: return;
305: }
306: }
307:
308: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
309: &s_objet_argument) == d_erreur)
310: {
311: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
312: return;
313: }
314:
315: if ((*s_objet_argument).type == LST)
316: {
317: if (last_valide == d_vrai)
318: {
319: cf(s_etat_processus, 31);
320: }
321:
322: instruction_version(s_etat_processus);
323:
324: if (last_valide == d_vrai)
325: {
326: sf(s_etat_processus, 31);
327: }
328:
329: if ((*s_etat_processus).erreur_systeme != d_es)
330: {
331: return;
332: }
333:
334: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
335: &s_objet_caracteristiques) == d_erreur)
336: {
337: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
338: return;
339: }
340:
341: /*
342: * L'objet renvoyé est obligatoirement une liste.
343: */
344:
345: BUG((*s_objet_caracteristiques).type != LST,
346: printf("(*s_objet_caracteristiques).type='%d'\n",
347: (*s_objet_caracteristiques).type));
348:
349: drapeau = d_vrai;
350: l_element_courant = (*s_objet_argument).objet;
351:
352: while((l_element_courant != NULL) && (drapeau == d_vrai))
353: {
354: if ((*(*l_element_courant).donnee).type == CHN)
355: {
356: if ((chaine_majuscule = conversion_majuscule((unsigned char *)
357: (*(*l_element_courant).donnee).objet)) == NULL)
358: {
359: (*s_etat_processus).erreur_systeme =
360: d_es_allocation_memoire;
361: return;
362: }
363:
364: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
365:
366: while(l_element_caracteristiques != NULL)
367: {
368: if ((*(*l_element_caracteristiques).donnee).type == CHN)
369: {
370: if (strcmp((unsigned char *)
371: (*(*l_element_caracteristiques).donnee).objet,
372: chaine_majuscule) == 0)
373: {
374: break;
375: }
376: }
377:
378: l_element_caracteristiques = (*l_element_caracteristiques)
379: .suivant;
380: }
381:
382: free(chaine_majuscule);
383:
384: if (l_element_caracteristiques == NULL)
385: { // La chaîne n'a pas été trouvée...
386: drapeau = d_faux;
387: break;
388: }
389: }
390: else if ((*(*l_element_courant).donnee).type == LST)
391: {
392: drapeau_final = d_vrai;
393: drapeau_prerelease = d_faux;
394: drapeau_final_courant = d_vrai;
395: drapeau_prerelease_courant = d_faux;
396: i1 = 0;
397: i2 = 0;
398: i3 = 0;
399: i4 = 0;
400: j1 = 0;
401: j2 = 0;
402: j3 = 0;
403: j4 = 0;
404:
405: l_element_version = (*(*l_element_courant).donnee).objet;
406: position = 1;
407:
408: while(l_element_version != NULL)
409: {
410: switch(position)
411: {
412: case 1 :
413: {
414: if ((*(*l_element_version).donnee).type == INT)
415: {
416: i1 = (*((integer8 *) (*(*l_element_version)
417: .donnee).objet));
418: }
419: else
420: {
421: liberation(s_etat_processus, s_objet_argument);
422: liberation(s_etat_processus,
423: s_objet_caracteristiques);
424:
425: (*s_etat_processus).erreur_execution =
426: d_ex_erreur_type_argument;
427: return;
428: }
429:
430: break;
431: }
432:
433: case 2 :
434: {
435: if ((*(*l_element_version).donnee).type == INT)
436: {
437: i2 = (*((integer8 *) (*(*l_element_version)
438: .donnee).objet));
439: }
440: else
441: {
442: liberation(s_etat_processus, s_objet_argument);
443: liberation(s_etat_processus,
444: s_objet_caracteristiques);
445:
446: (*s_etat_processus).erreur_execution =
447: d_ex_erreur_type_argument;
448: return;
449: }
450:
451: break;
452: }
453:
454: case 3 :
455: {
456: if ((*(*l_element_version).donnee).type == INT)
457: {
458: i3 = (*((integer8 *) (*(*l_element_version)
459: .donnee).objet));
460: }
461: else
462: {
463: liberation(s_etat_processus, s_objet_argument);
464: liberation(s_etat_processus,
465: s_objet_caracteristiques);
466:
467: (*s_etat_processus).erreur_execution =
468: d_ex_erreur_type_argument;
469: return;
470: }
471:
472: break;
473: }
474:
475: case 4 :
476: {
477: if ((*(*l_element_version).donnee).type == CHN)
478: {
479: if ((chaine_majuscule = conversion_majuscule(
480: (unsigned char *) (*(*l_element_version)
481: .donnee).objet)) == NULL)
482: {
483: (*s_etat_processus).erreur_systeme =
484: d_es_allocation_memoire;
485: return;
486: }
487:
488: if (strcmp(chaine_majuscule, "RELEASE") == 0)
489: {
490: drapeau_final = d_vrai;
491: }
492: else if (strcmp(chaine_majuscule, "PRERELEASE")
493: == 0)
494: {
495: drapeau_final = d_faux;
496: }
497: else
498: {
499: liberation(s_etat_processus,
500: s_objet_argument);
501: liberation(s_etat_processus,
502: s_objet_caracteristiques);
503:
504: (*s_etat_processus).erreur_execution =
505: d_ex_argument_invalide;
506: return;
507: }
508:
509: free(chaine_majuscule);
510: }
511: else
512: {
513: liberation(s_etat_processus, s_objet_argument);
514: liberation(s_etat_processus,
515: s_objet_caracteristiques);
516:
517: (*s_etat_processus).erreur_execution =
518: d_ex_erreur_type_argument;
519: return;
520: }
521:
522: break;
523: }
524:
525: case 5 :
526: {
527: if ((*(*l_element_version).donnee).type == INT)
528: {
529: i4 = (*((integer8 *) (*(*l_element_version)
530: .donnee).objet));
531: }
532: else
533: {
534: liberation(s_etat_processus, s_objet_argument);
535: liberation(s_etat_processus,
536: s_objet_caracteristiques);
537:
538: (*s_etat_processus).erreur_execution =
539: d_ex_erreur_type_argument;
540: return;
541: }
542:
543: drapeau_prerelease = d_vrai;
544: break;
545: }
546:
547: default :
548: {
549: liberation(s_etat_processus, s_objet_argument);
550: liberation(s_etat_processus,
551: s_objet_caracteristiques);
552:
553: (*s_etat_processus).erreur_execution =
554: d_ex_erreur_type_argument;
555: return;
556: break;
557: }
558: }
559:
560: position++;
561: l_element_version = (*l_element_version).suivant;
562: }
563:
564: if (drapeau_prerelease == drapeau_final)
565: {
566: liberation(s_etat_processus, s_objet_argument);
567: liberation(s_etat_processus, s_objet_caracteristiques);
568:
569: (*s_etat_processus).erreur_execution =
570: d_ex_argument_invalide;
571: return;
572: }
573:
574: l_element_caracteristiques = (*s_objet_caracteristiques).objet;
575:
576: while(l_element_caracteristiques != NULL)
577: {
578: if ((*(*l_element_caracteristiques).donnee).type == LST)
579: {
580: l_element_version = (*(*l_element_caracteristiques)
581: .donnee).objet;
582:
583: position = 1;
584:
585: while(l_element_version != NULL)
586: {
587: switch(position)
588: {
589: case 1 :
590: {
591: j1 = (*((integer8 *) (*(*l_element_version)
592: .donnee).objet));
593: break;
594: }
595:
596: case 2 :
597: {
598: j2 = (*((integer8 *) (*(*l_element_version)
599: .donnee).objet));
600: break;
601: }
602:
603: case 3 :
604: {
605: j3 = (*((integer8 *) (*(*l_element_version)
606: .donnee).objet));
607: break;
608: }
609:
610: case 4 :
611: {
612: drapeau_final_courant =
613: (strcmp((unsigned char *)
614: (*(*l_element_version).donnee)
615: .objet, "RELEASE") == 0)
616: ? d_vrai : d_faux;
617: break;
618: }
619:
620: case 5 :
621: {
622: j4 = (*((integer8 *) (*(*l_element_version)
623: .donnee).objet));
624: drapeau_prerelease_courant = d_vrai;
625: break;
626: }
627: }
628:
629: position++;
630: l_element_version = (*l_element_version).suivant;
631: }
632:
633: break;
634: }
635:
636: l_element_caracteristiques = (*l_element_caracteristiques)
637: .suivant;
638: }
639:
640: if (drapeau_prerelease_courant == drapeau_final_courant)
641: {
642: liberation(s_etat_processus, s_objet_argument);
643: liberation(s_etat_processus, s_objet_caracteristiques);
644:
645: (*s_etat_processus).erreur_execution =
646: d_ex_argument_invalide;
647: return;
648: }
649:
650: if (i1 > j1)
651: { // Version demandée supérieure à la version courante
652: drapeau = d_faux;
653: }
654: else if (i1 == j1)
655: {
656: if (i2 > j2)
657: { // Versions idendiques et sous-version demandée
658: // supérieure à la sous-version courante
659: drapeau = d_faux;
660: }
661: else if (i2 == j2)
662: { // Versions et sous-versions identiques
663: if (i3 > j3)
664: { // Niveau de patches demandé supérieur au niveau
665: // de patch courant
666: drapeau = d_faux;
667: }
668: else if (i3 == j3)
669: { // Niveaux de patches indentiques
670: if ((drapeau_final == d_vrai) &&
671: (drapeau_final_courant == d_faux))
672: { // Finale requise et prerelease obtenue
673: drapeau = d_faux;
674: }
675: else if ((drapeau_final == d_faux) &&
676: (drapeau_final_courant == d_vrai))
677: { // Prerelease requise et finale obtenue
678: }
679: else if ((drapeau_final == d_vrai) &&
680: (drapeau_final_courant == d_vrai))
681: { // Finales de part et d'autre
682: }
683: else
684: { // Prerelease de part et d'autre
685: if (i4 > j4)
686: { // Prerelease demandée supérieur à la
687: // version courante
688: drapeau = d_faux;
689: }
690: }
691: }
692: else
693: { // Niveaux de patches inférieur au niveau courant
694: }
695: }
696: else
697: { // Versions indentiques et sous-version inférieure à
698: // la sous-version courante
699: }
700: }
701: else
702: { // Version demandée inférieure à la version courante
703: }
704: }
705: else
706: {
707: liberation(s_etat_processus, s_objet_argument);
708: liberation(s_etat_processus, s_objet_caracteristiques);
709:
710: (*s_etat_processus).erreur_execution =
711: d_ex_erreur_type_argument;
712: return;
713: }
714:
715: l_element_courant = (*l_element_courant).suivant;
716: }
717:
718: liberation(s_etat_processus, s_objet_caracteristiques);
719:
720: /*
721: * Création du drapeau renvoyé
722: */
723:
724: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
725: {
726: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
727: return;
728: }
729:
730: (*((integer8 *) (*s_objet_resultat).objet)) = (drapeau == d_vrai)
731: ? -1 : 0;
732:
733: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
734: s_objet_resultat) == d_erreur)
735: {
736: return;
737: }
738: }
739: else
740: {
741: liberation(s_etat_processus, s_objet_argument);
742:
743: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
744: return;
745: }
746:
747: liberation(s_etat_processus, s_objet_argument);
748:
749: return;
750: }
751:
752: // vim: ts=4