![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to compilation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to compilation.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.9
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:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Procédure de vérification syntaxique du source et de précompilation
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: - renvoi : erreur
34: --------------------------------------------------------------------------------
35: Effets de bord :
36: ================================================================================
37: */
38:
39: logical1
40: compilation(struct_processus *s_etat_processus)
41: {
42: struct_objet *s_objet;
43:
44: struct_variable *s_variable;
45:
46: unsigned char apostrophe_ouverte;
47: unsigned char apostrophe_ouverte_registre;
48: unsigned char caractere_courant;
49: unsigned char caractere_precedent;
50: unsigned char caractere_suivant;
51: unsigned char *definition;
52: unsigned char fermeture_definition;
53: unsigned char guillemet_ouvert;
54: unsigned char ouverture_definition;
55: unsigned char position_debut_nom_definition_valide;
56:
57: unsigned long *adresse;
58: unsigned long i;
59: unsigned long niveau_definition;
60: unsigned long niveau_definition_registre;
61: unsigned long position_courante;
62: unsigned long position_debut_nom_definition;
63: unsigned long position_fin_nom_definition;
64: unsigned long validation;
65: unsigned long validation_registre;
66:
67: (*s_etat_processus).erreur_compilation = d_ec;
68: (*s_etat_processus).erreur_systeme = d_es;
69: (*s_etat_processus).erreur_execution = d_ex;
70: (*s_etat_processus).exception = d_ep;
71: (*s_etat_processus).arret_si_exception = d_vrai;
72:
73: (*s_etat_processus).position_courante = 0;
74:
75:
76: /*
77: --------------------------------------------------------------------------------
78: Recheche des définitions
79: --------------------------------------------------------------------------------
80: */
81:
82: niveau_definition = 0;
83: niveau_definition_registre = 0;
84: position_courante = 0;
85: position_debut_nom_definition = 0;
86: validation = 0;
87:
88: apostrophe_ouverte = d_faux;
89: apostrophe_ouverte_registre = d_faux;
90: guillemet_ouvert = d_faux;
91: position_debut_nom_definition_valide = d_faux;
92:
93: if ((*s_etat_processus).debug == d_vrai)
94: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
95: {
96: printf("\n");
97: printf("[%d] Compilation\n", (int) getpid());
98: fflush(stdout);
99: }
100:
101: while((*s_etat_processus).definitions_chainees[position_courante] !=
102: d_code_fin_chaine)
103: {
104: caractere_courant = (*s_etat_processus)
105: .definitions_chainees[position_courante];
106:
107: fermeture_definition = d_faux;
108: ouverture_definition = d_faux;
109:
110: if (position_courante >= 1)
111: {
112: if (position_courante >= 2)
113: {
114: if (((*s_etat_processus).definitions_chainees
115: [position_courante - 2] == '\\') &&
116: ((*s_etat_processus).definitions_chainees
117: [position_courante - 1] == '\\'))
118: {
119: caractere_precedent = '*';
120: }
121: else
122: {
123: caractere_precedent = (*s_etat_processus)
124: .definitions_chainees[position_courante - 1];
125: }
126: }
127: else
128: {
129: caractere_precedent = (*s_etat_processus)
130: .definitions_chainees[position_courante - 1];
131: }
132: }
133: else
134: {
135: caractere_precedent = ' ';
136: }
137:
138: caractere_suivant = (*s_etat_processus)
139: .definitions_chainees[position_courante + 1];
140:
141: if (caractere_suivant == d_code_fin_chaine)
142: {
143: caractere_suivant = ' ';
144: }
145:
146: if ((caractere_courant == '[') || (caractere_courant == '{'))
147: {
148: validation++;
149: }
150: else if ((caractere_courant == ']') || (caractere_courant == '}'))
151: {
152: validation--;
153: }
154: else if (caractere_courant == '\'')
155: {
156: if (apostrophe_ouverte == d_faux)
157: {
158: validation++;
159: apostrophe_ouverte = d_vrai;
160: }
161: else
162: {
163: validation--;
164: apostrophe_ouverte = d_faux;
165: }
166: }
167: else if (caractere_courant == '"')
168: {
169: if (caractere_precedent != '\\')
170: {
171: swap((void *) &validation, (void *) &validation_registre,
172: sizeof(validation));
173: swap((void *) &apostrophe_ouverte,
174: (void *) &apostrophe_ouverte_registre,
175: sizeof(apostrophe_ouverte));
176: swap((void *) &niveau_definition,
177: (void *) &niveau_definition_registre,
178: sizeof(niveau_definition));
179:
180: guillemet_ouvert = (guillemet_ouvert == d_faux)
181: ? d_vrai : d_faux;
182: }
183: }
184: else if ((caractere_courant == '<') &&
185: (caractere_precedent == ' ') &&
186: (caractere_suivant == '<'))
187: {
188: if ((*s_etat_processus)
189: .definitions_chainees[position_courante + 2] == ' ')
190: {
191: niveau_definition++;
192: ouverture_definition = d_vrai;
193: }
194: }
195: else if ((caractere_courant == '>') &&
196: (caractere_precedent == ' ') &&
197: (caractere_suivant == '>'))
198: {
199: if (((*s_etat_processus)
200: .definitions_chainees[position_courante + 2] == ' ') ||
201: ((*s_etat_processus).definitions_chainees
202: [position_courante + 2] == d_code_fin_chaine))
203: {
204: if (niveau_definition == 0)
205: {
206: (*s_etat_processus).erreur_compilation =
207: d_ec_niveau_definition_negatif;
208: return(d_erreur);
209: }
210: else
211: {
212: niveau_definition--;
213: fermeture_definition = d_vrai;
214: position_courante++;
215: }
216: }
217: }
218:
219: if ((niveau_definition == 0) && (guillemet_ouvert == d_faux) &&
220: (caractere_courant != ' ') && (fermeture_definition == d_faux))
221: {
222: if (position_debut_nom_definition_valide == d_faux)
223: {
224: position_debut_nom_definition_valide = d_vrai;
225: position_debut_nom_definition = position_courante;
226: }
227: }
228:
229: if (((niveau_definition == 1) && (ouverture_definition == d_vrai)) &&
230: (position_debut_nom_definition_valide == d_vrai))
231: {
232: position_fin_nom_definition = position_courante - 1;
233: position_debut_nom_definition_valide = d_faux;
234:
235: while((*s_etat_processus).definitions_chainees
236: [position_fin_nom_definition] == ' ')
237: {
238: position_fin_nom_definition--;
239: }
240:
241: i = position_debut_nom_definition;
242:
243: while(i <= position_fin_nom_definition)
244: {
245: if ((*s_etat_processus).definitions_chainees[i] == ' ')
246: {
247: (*s_etat_processus).erreur_compilation =
248: d_ec_nom_definition_invalide;
249: return(d_erreur);
250: }
251: else
252: {
253: i++;
254: }
255: }
256:
257: s_objet = allocation(s_etat_processus, ADR);
258: s_variable = (struct_variable *)
259: malloc(sizeof(struct_variable));
260: adresse = (*s_objet).objet;
261: definition = (unsigned char *) malloc(
262: (position_fin_nom_definition -
263: position_debut_nom_definition + 2) *
264: sizeof(unsigned char));
265:
266: if ((s_objet == NULL) || (s_variable == NULL) ||
267: (adresse == NULL) || definition == NULL)
268: {
269: (*s_etat_processus).erreur_systeme =
270: d_es_allocation_memoire;
271: return(d_erreur);
272: }
273: else
274: {
275: (*adresse) = position_fin_nom_definition + 1;
276:
277: (*s_variable).nom = definition;
278: (*s_variable).niveau = (*s_etat_processus).niveau_courant;
279: (*s_variable).objet = s_objet;
280:
281: i = position_debut_nom_definition;
282:
283: while(i <= position_fin_nom_definition)
284: {
285: *(definition++) = (*s_etat_processus)
286: .definitions_chainees[i++];
287: }
288:
289: *definition = d_code_fin_chaine;
290:
291: if (recherche_variable(s_etat_processus, (*s_variable).nom)
292: == d_vrai)
293: {
294: if ((*s_etat_processus).langue == 'F')
295: {
296: printf("+++Attention : Plusieurs définitions de"
297: " même nom\n");
298: }
299: else
300: {
301: printf("+++Warning : Same name for several"
302: " definitions\n");
303: }
304:
305: fflush(stdout);
306: return(d_erreur);
307: }
308:
309: (*s_etat_processus).erreur_systeme = d_es;
310: creation_variable(s_etat_processus, s_variable, 'V', 'P');
311:
312: if ((*s_etat_processus).erreur_systeme != d_es)
313: {
314: free(s_variable);
315:
316: return(d_erreur);
317: }
318:
319: if ((*s_etat_processus).debug == d_vrai)
320: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
321: {
322: if ((*s_etat_processus).langue == 'F')
323: {
324: printf("[%d] Compilation : Définition %s ($ %016lX) "
325: "\n", (int) getpid(), (*s_variable).nom,
326: (*adresse));
327: }
328: else
329: {
330: printf("[%d] Compilation : %s definition ($ %016lX) "
331: "\n", (int) getpid(), (*s_variable).nom,
332: (*adresse));
333: }
334:
335: fflush(stdout);
336: }
337: }
338:
339: free(s_variable);
340: }
341:
342: position_courante++;
343: }
344:
345: return(analyse_syntaxique(s_etat_processus));
346: }
347:
348:
349: /*
350: ================================================================================
351: Procédure de d'analyse syntaxique du source
352: ================================================================================
353: Entrées :
354: --------------------------------------------------------------------------------
355: Sorties :
356: - renvoi : erreur
357: --------------------------------------------------------------------------------
358: Effets de bord :
359: ================================================================================
360: */
361:
362: logical1
363: analyse_syntaxique(struct_processus *s_etat_processus)
364: {
365: enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF,
366: AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT,
367: AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START,
368: AN_NEXT, AN_STEP };
369:
370: unsigned char *instruction;
371: unsigned char registre;
372:
373: typedef struct pile
374: {
375: enum t_condition condition;
376: struct pile *suivant;
377: } struct_pile_analyse;
378:
379: struct_pile_analyse *l_base_pile;
380: struct_pile_analyse *l_nouvelle_base_pile;
381:
382: inline struct_pile_analyse *
383: empilement_analyse(struct_pile_analyse *ancienne_base,
384: enum t_condition condition)
385: {
386: struct_pile_analyse *nouvelle_base;
387:
388: if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)
389: {
390: return(NULL);
391: }
392:
393: (*nouvelle_base).suivant = ancienne_base;
394: (*nouvelle_base).condition = condition;
395:
396: return(nouvelle_base);
397: }
398:
399: inline struct_pile_analyse *
400: depilement_analyse(struct_pile_analyse *ancienne_base)
401: {
402: struct_pile_analyse *nouvelle_base;
403:
404: if (ancienne_base == NULL)
405: {
406: return(NULL);
407: }
408:
409: nouvelle_base = (*ancienne_base).suivant;
410: free(ancienne_base);
411:
412: return(nouvelle_base);
413: }
414:
415: inline logical1
416: test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition)
417: {
418: if (l_base_pile == NULL)
419: {
420: return(d_faux);
421: }
422:
423: return(((*l_base_pile).condition == condition) ? d_vrai : d_faux);
424: }
425:
426: inline void
427: liberation_analyse(struct_pile_analyse *l_base_pile)
428: {
429: struct_pile_analyse *l_nouvelle_base_pile;
430:
431: while(l_base_pile != NULL)
432: {
433: l_nouvelle_base_pile = (*l_base_pile).suivant;
434: free(l_base_pile);
435: l_base_pile = l_nouvelle_base_pile;
436: }
437:
438: return;
439: }
440:
441: l_base_pile = NULL;
442: l_nouvelle_base_pile = NULL;
443:
444: if ((*s_etat_processus).debug == d_vrai)
445: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
446: {
447: if ((*s_etat_processus).langue == 'F')
448: {
449: printf("[%d] Analyse\n", (int) getpid());
450: }
451: else
452: {
453: printf("[%d] Analysis\n", (int) getpid());
454: }
455:
456: fflush(stdout);
457: }
458:
459: (*s_etat_processus).position_courante = 0;
460: registre = (*s_etat_processus).autorisation_empilement_programme;
461: (*s_etat_processus).autorisation_empilement_programme = 'N';
462:
463: /*
464: --------------------------------------------------------------------------------
465: Analyse structurelle
466: --------------------------------------------------------------------------------
467: */
468:
469: while((*s_etat_processus).definitions_chainees
470: [(*s_etat_processus).position_courante] != d_code_fin_chaine)
471: {
472: if (recherche_instruction_suivante(s_etat_processus) !=
473: d_absence_erreur)
474: {
475: liberation_analyse(l_base_pile);
476:
477: (*s_etat_processus).autorisation_empilement_programme = registre;
478: return(d_erreur);
479: }
480:
481: if ((instruction = conversion_majuscule(
482: (*s_etat_processus).instruction_courante)) == NULL)
483: {
484: liberation_analyse(l_base_pile);
485:
486: (*s_etat_processus).autorisation_empilement_programme = registre;
487: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
488: return(d_erreur);
489: }
490:
491: if (strcmp(instruction, "IF") == 0)
492: {
493: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF))
494: == NULL)
495: {
496: liberation_analyse(l_base_pile);
497:
498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
499: return(d_erreur);
500: }
501:
502: l_base_pile = l_nouvelle_base_pile;
503: (*l_base_pile).condition = AN_IF;
504: }
505: else if (strcmp(instruction, "IFERR") == 0)
506: {
507: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
508: AN_IFERR)) == NULL)
509: {
510: liberation_analyse(l_base_pile);
511:
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return(d_erreur);
514: }
515:
516: l_base_pile = l_nouvelle_base_pile;
517: }
518: else if (strcmp(instruction, "THEN") == 0)
519: {
520: if ((test_analyse(l_base_pile, AN_IF) == d_faux) &&
521: (test_analyse(l_base_pile, AN_ELSEIF) == d_faux) &&
522: (test_analyse(l_base_pile, AN_CASE) == d_faux) &&
523: (test_analyse(l_base_pile, AN_IFERR) == d_faux))
524: {
525: liberation_analyse(l_base_pile);
526:
527: (*s_etat_processus).autorisation_empilement_programme =
528: registre;
529:
530: (*s_etat_processus).erreur_compilation =
531: d_ec_erreur_instruction_then;
532: return(d_erreur);
533: }
534:
535: (*l_base_pile).condition = AN_THEN;
536: }
537: else if (strcmp(instruction, "ELSE") == 0)
538: {
539: if (test_analyse(l_base_pile, AN_THEN) == d_faux)
540: {
541: liberation_analyse(l_base_pile);
542:
543: (*s_etat_processus).autorisation_empilement_programme =
544: registre;
545:
546: (*s_etat_processus).erreur_compilation =
547: d_ec_erreur_instruction_else;
548: return(d_erreur);
549: }
550:
551: (*l_base_pile).condition = AN_ELSE;
552: }
553: else if (strcmp(instruction, "ELSEIF") == 0)
554: {
555: if (test_analyse(l_base_pile, AN_THEN) == d_faux)
556: {
557: liberation_analyse(l_base_pile);
558:
559: (*s_etat_processus).autorisation_empilement_programme =
560: registre;
561:
562: (*s_etat_processus).erreur_compilation =
563: d_ec_erreur_instruction_elseif;
564: return(d_erreur);
565: }
566:
567: (*l_base_pile).condition = AN_ELSEIF;
568: }
569: else if (strcmp(instruction, "END") == 0)
570: {
571: if ((test_analyse(l_base_pile, AN_UNTIL) == d_faux) &&
572: (test_analyse(l_base_pile, AN_REPEAT) == d_faux) &&
573: (test_analyse(l_base_pile, AN_DEFAULT) == d_faux) &&
574: (test_analyse(l_base_pile, AN_SELECT) == d_faux) &&
575: (test_analyse(l_base_pile, AN_THEN) == d_faux) &&
576: (test_analyse(l_base_pile, AN_ELSE) == d_faux))
577: {
578: liberation_analyse(l_base_pile);
579:
580: (*s_etat_processus).autorisation_empilement_programme =
581: registre;
582:
583: (*s_etat_processus).erreur_compilation =
584: d_ec_erreur_instruction_end;
585: return(d_erreur);
586: }
587:
588: l_base_pile = depilement_analyse(l_base_pile);
589: }
590: else if (strcmp(instruction, "DO") == 0)
591: {
592: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO))
593: == NULL)
594: {
595: liberation_analyse(l_base_pile);
596:
597: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
598: return(d_erreur);
599: }
600:
601: l_base_pile = l_nouvelle_base_pile;
602: }
603: else if (strcmp(instruction, "UNTIL") == 0)
604: {
605: if (test_analyse(l_base_pile, AN_DO) == d_faux)
606: {
607: liberation_analyse(l_base_pile);
608:
609: (*s_etat_processus).autorisation_empilement_programme =
610: registre;
611:
612: (*s_etat_processus).erreur_compilation =
613: d_ec_erreur_instruction_until;
614: return(d_erreur);
615: }
616:
617: (*l_base_pile).condition = AN_UNTIL;
618: }
619: else if (strcmp(instruction, "WHILE") == 0)
620: {
621: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
622: AN_WHILE)) == NULL)
623: {
624: liberation_analyse(l_base_pile);
625:
626: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
627: return(d_erreur);
628: }
629:
630: l_base_pile = l_nouvelle_base_pile;
631: }
632: else if (strcmp(instruction, "REPEAT") == 0)
633: {
634: if (test_analyse(l_base_pile, AN_WHILE) == d_faux)
635: {
636: liberation_analyse(l_base_pile);
637:
638: (*s_etat_processus).autorisation_empilement_programme =
639: registre;
640:
641: (*s_etat_processus).erreur_compilation =
642: d_ec_erreur_instruction_while;
643: return(d_erreur);
644: }
645:
646: (*l_base_pile).condition = AN_REPEAT;
647: }
648: else if (strcmp(instruction, "SELECT") == 0)
649: {
650: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
651: AN_SELECT)) == NULL)
652: {
653: liberation_analyse(l_base_pile);
654:
655: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
656: return(d_erreur);
657: }
658:
659: l_base_pile = l_nouvelle_base_pile;
660: }
661: else if (strcmp(instruction, "CASE") == 0)
662: {
663: if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
664: {
665: liberation_analyse(l_base_pile);
666:
667: (*s_etat_processus).autorisation_empilement_programme =
668: registre;
669:
670: (*s_etat_processus).erreur_compilation =
671: d_ec_erreur_instruction_case;
672: return(d_erreur);
673: }
674:
675: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
676: AN_CASE)) == NULL)
677: {
678: liberation_analyse(l_base_pile);
679:
680: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
681: return(d_erreur);
682: }
683:
684: l_base_pile = l_nouvelle_base_pile;
685: }
686: else if (strcmp(instruction, "DEFAULT") == 0)
687: {
688: if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
689: {
690: liberation_analyse(l_base_pile);
691:
692: (*s_etat_processus).autorisation_empilement_programme =
693: registre;
694:
695: (*s_etat_processus).erreur_compilation =
696: d_ec_erreur_instruction_select;
697: return(d_erreur);
698: }
699:
700: (*l_base_pile).condition = AN_DEFAULT;
701: }
702: else if (strcmp(instruction, "<<") == 0)
703: {
704: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP))
705: == NULL)
706: {
707: liberation_analyse(l_base_pile);
708:
709: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
710: return(d_erreur);
711: }
712:
713: l_base_pile = l_nouvelle_base_pile;
714: }
715: else if (strcmp(instruction, ">>") == 0)
716: {
717: if (test_analyse(l_base_pile, AN_UP) == d_faux)
718: {
719: liberation_analyse(l_base_pile);
720:
721: (*s_etat_processus).autorisation_empilement_programme =
722: registre;
723:
724: (*s_etat_processus).erreur_compilation =
725: d_ec_source_incoherent;
726: return(d_erreur);
727: }
728:
729: l_base_pile = depilement_analyse(l_base_pile);
730: }
731: else if (strcmp(instruction, "FOR") == 0)
732: {
733: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR))
734: == NULL)
735: {
736: liberation_analyse(l_base_pile);
737:
738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
739: return(d_erreur);
740: }
741:
742: l_base_pile = l_nouvelle_base_pile;
743: }
744: else if (strcmp(instruction, "START") == 0)
745: {
746: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,
747: AN_START)) == NULL)
748: {
749: liberation_analyse(l_base_pile);
750:
751: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
752: return(d_erreur);
753: }
754:
755: l_base_pile = l_nouvelle_base_pile;
756: }
757: else if (strcmp(instruction, "NEXT") == 0)
758: {
759: if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&
760: (test_analyse(l_base_pile, AN_START) == d_faux))
761: {
762: liberation_analyse(l_base_pile);
763:
764: (*s_etat_processus).autorisation_empilement_programme =
765: registre;
766:
767: (*s_etat_processus).erreur_compilation =
768: d_ec_erreur_boucle_definie;
769: return(d_erreur);
770: }
771:
772: l_base_pile = depilement_analyse(l_base_pile);
773: }
774: else if (strcmp(instruction, "STEP") == 0)
775: {
776: if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&
777: (test_analyse(l_base_pile, AN_START) == d_faux))
778: {
779: liberation_analyse(l_base_pile);
780:
781: (*s_etat_processus).autorisation_empilement_programme =
782: registre;
783:
784: (*s_etat_processus).erreur_compilation =
785: d_ec_erreur_boucle_definie;
786: return(d_erreur);
787: }
788:
789: l_base_pile = depilement_analyse(l_base_pile);
790: }
791:
792: // Invalidation de l'instruction courante dans le fichier rpl-core
793: free((*s_etat_processus).instruction_courante);
794: (*s_etat_processus).instruction_courante = NULL;
795: free(instruction);
796: }
797:
798: (*s_etat_processus).autorisation_empilement_programme = registre;
799:
800: if (l_base_pile != NULL)
801: {
802: liberation_analyse(l_base_pile);
803:
804: (*s_etat_processus).autorisation_empilement_programme = registre;
805: (*s_etat_processus).erreur_compilation = d_ec_source_incoherent;
806: return(d_erreur);
807: }
808:
809: return(d_absence_erreur);
810: }
811:
812:
813: /*
814: ================================================================================
815: Routine d'échange de deux variables
816: ================================================================================
817: Entrées :
818: - pointeurs génériques sur les deux variables,
819: - longueur en octet des objets à permuter.
820: --------------------------------------------------------------------------------
821: Sorties : idem.
822: --------------------------------------------------------------------------------
823: Effets de bord : néant.
824: ================================================================================
825: */
826:
827: void
828: swap(void *variable_1, void *variable_2, unsigned long taille)
829: {
830: register unsigned char *t_var_1;
831: register unsigned char *t_var_2;
832: register unsigned char variable_temporaire;
833:
834: register signed long i;
835:
836: t_var_1 = (unsigned char *) variable_1;
837: t_var_2 = (unsigned char *) variable_2;
838:
839: i = taille;
840:
841: for(i--; i >= 0; i--)
842: {
843: variable_temporaire = t_var_1[i];
844: t_var_1[i] = t_var_2[i];
845: t_var_2[i] = variable_temporaire;
846: }
847: }
848:
849:
850: /*
851: ================================================================================
852: Routine recherchant l'instruction suivante dans le programme compilé
853: ================================================================================
854: Entrée :
855: --------------------------------------------------------------------------------
856: Sortie :
857: --------------------------------------------------------------------------------
858: Effets de bord : néant.
859: ================================================================================
860: */
861:
862: logical1
863: recherche_instruction_suivante(struct_processus *s_etat_processus)
864: {
865: logical1 drapeau_fin_objet;
866: logical1 erreur;
867: logical1 erreur_analyse;
868: logical1 erreur_format;
869:
870: unsigned char base_binaire;
871: unsigned char *pointeur_caractere_courant;
872: unsigned char *pointeur_caractere_destination;
873: unsigned char *pointeur_debut_instruction;
874: unsigned char *pointeur_fin_instruction;
875:
876: signed long niveau;
877: signed long niveau_annexe;
878:
879: erreur_analyse = d_ex;
880: erreur_format = d_ex;
881: erreur = d_absence_erreur;
882:
883: drapeau_fin_objet = d_faux;
884: niveau = 0;
885:
886: pointeur_caractere_courant = (*s_etat_processus).definitions_chainees +
887: (*s_etat_processus).position_courante;
888:
889: while(((*pointeur_caractere_courant) == d_code_espace) &&
890: ((*pointeur_caractere_courant) != d_code_fin_chaine))
891: {
892: pointeur_caractere_courant++;
893: }
894:
895: if ((*pointeur_caractere_courant) == d_code_fin_chaine)
896: {
897: (*s_etat_processus).instruction_courante = (unsigned char *)
898: malloc(sizeof(unsigned char));
899:
900: if ((*s_etat_processus).instruction_courante == NULL)
901: {
902: erreur = d_erreur;
903: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
904: }
905: else
906: {
907: erreur = d_absence_erreur;
908: (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine;
909: (*s_etat_processus).position_courante = pointeur_caractere_courant
910: - (*s_etat_processus).definitions_chainees;
911: }
912:
913: return(erreur);
914: }
915:
916: pointeur_debut_instruction = pointeur_caractere_courant;
917:
918: while(((*pointeur_caractere_courant) != d_code_espace) &&
919: ((*pointeur_caractere_courant) != d_code_fin_chaine) &&
920: (drapeau_fin_objet == d_faux) &&
921: (erreur_analyse == d_ex) &&
922: (erreur_format == d_ex))
923: {
924: switch(*pointeur_caractere_courant++)
925: {
926: case ']' :
927: case '}' :
928: case ')' :
929: {
930: erreur_format = d_ex_syntaxe;
931: break;
932: }
933:
934: case '"' :
935: {
936: if (pointeur_debut_instruction !=
937: (pointeur_caractere_courant - 1))
938: {
939: erreur_format = d_ex_syntaxe;
940: }
941:
942: while((*pointeur_caractere_courant != '"') &&
943: ((*pointeur_caractere_courant) != d_code_fin_chaine))
944: {
945: if (*pointeur_caractere_courant == '\\')
946: {
947: pointeur_caractere_courant++;
948:
949: switch(*pointeur_caractere_courant)
950: {
951: case '\\' :
952: case '"' :
953: {
954: pointeur_caractere_courant++;
955: break;
956: }
957: }
958: }
959: else
960: {
961: pointeur_caractere_courant++;
962: }
963: }
964:
965: if ((*pointeur_caractere_courant) != '"')
966: {
967: erreur_analyse = d_ex_syntaxe;
968: }
969:
970: if (erreur_analyse == d_ex)
971: {
972: pointeur_caractere_courant++;
973: }
974:
975: drapeau_fin_objet = d_vrai;
976: break;
977: }
978:
979: case '\'' :
980: {
981: if (pointeur_debut_instruction !=
982: (pointeur_caractere_courant - 1))
983: {
984: erreur_format = d_ex_syntaxe;
985: }
986:
987: while(((*pointeur_caractere_courant) != '\'') &&
988: ((*pointeur_caractere_courant) != d_code_fin_chaine))
989: {
990: if ((*pointeur_caractere_courant) == '(')
991: {
992: niveau++;
993: }
994: else if ((*pointeur_caractere_courant) == ')')
995: {
996: niveau--;
997: }
998:
999: pointeur_caractere_courant++;
1000: }
1001:
1002: if ((*pointeur_caractere_courant) != '\'')
1003: {
1004: erreur_analyse = d_ex_syntaxe;
1005: }
1006: else if (niveau != 0)
1007: {
1008: erreur_analyse = d_ex_syntaxe;
1009: }
1010:
1011: if (erreur_analyse == d_ex)
1012: {
1013: pointeur_caractere_courant++;
1014: }
1015:
1016: drapeau_fin_objet = d_vrai;
1017: break;
1018: }
1019:
1020: case '(' :
1021: {
1022: if (pointeur_debut_instruction !=
1023: (pointeur_caractere_courant - 1))
1024: {
1025: erreur_format = d_ex_syntaxe;
1026: }
1027:
1028: while(((*pointeur_caractere_courant) != ')') &&
1029: ((*pointeur_caractere_courant) != d_code_fin_chaine)
1030: && (erreur_analyse == d_ex))
1031: {
1032: switch(*pointeur_caractere_courant)
1033: {
1034: case '0' :
1035: case '1' :
1036: case '2' :
1037: case '3' :
1038: case '4' :
1039: case '5' :
1040: case '6' :
1041: case '7' :
1042: case '8' :
1043: case '9' :
1044: case 'e' :
1045: case 'E' :
1046: case ',' :
1047: case '.' :
1048: case ' ' :
1049: case '-' :
1050: case '+' :
1051: case ')' :
1052: {
1053: break;
1054: }
1055:
1056: default :
1057: {
1058: erreur_analyse = d_ex_syntaxe;
1059: break;
1060: }
1061: }
1062:
1063: pointeur_caractere_courant++;
1064: }
1065:
1066: if ((*pointeur_caractere_courant) != ')')
1067: {
1068: erreur_analyse = d_ex_syntaxe;
1069: }
1070:
1071: if (erreur_analyse == d_ex)
1072: {
1073: pointeur_caractere_courant++;
1074: }
1075:
1076: drapeau_fin_objet = d_vrai;
1077: break;
1078: }
1079:
1080: case '#' :
1081: {
1082: if (pointeur_debut_instruction !=
1083: (pointeur_caractere_courant - 1))
1084: {
1085: erreur_format = d_ex_syntaxe;
1086: }
1087:
1088: while(((*pointeur_caractere_courant) != 'b') &&
1089: ((*pointeur_caractere_courant) != 'o') &&
1090: ((*pointeur_caractere_courant) != 'd') &&
1091: ((*pointeur_caractere_courant) != 'h') &&
1092: ((*pointeur_caractere_courant) !=
1093: d_code_fin_chaine) &&
1094: (erreur_analyse == d_ex))
1095: {
1096: switch(*pointeur_caractere_courant)
1097: {
1098: case ' ' :
1099: case '0' :
1100: case '1' :
1101: case '2' :
1102: case '3' :
1103: case '4' :
1104: case '5' :
1105: case '6' :
1106: case '7' :
1107: case '8' :
1108: case '9' :
1109: case 'A' :
1110: case 'B' :
1111: case 'C' :
1112: case 'D' :
1113: case 'E' :
1114: case 'F' :
1115: case 'b' :
1116: case 'o' :
1117: case 'd' :
1118: case 'h' :
1119: {
1120: break;
1121: }
1122:
1123: default :
1124: {
1125: erreur_analyse = d_ex_syntaxe;
1126: break;
1127: }
1128: }
1129:
1130: pointeur_caractere_courant++;
1131: }
1132:
1133: base_binaire = (*pointeur_caractere_courant);
1134: pointeur_caractere_courant++;
1135:
1136: if (((*pointeur_caractere_courant) != d_code_fin_chaine) &&
1137: ((*pointeur_caractere_courant) != ' '))
1138: {
1139: erreur_analyse = d_ex_syntaxe;
1140: }
1141: else
1142: {
1143: pointeur_caractere_courant = pointeur_debut_instruction + 1;
1144:
1145: switch(base_binaire)
1146: {
1147: case 'b' :
1148: case 'o' :
1149: case 'd' :
1150: case 'h' :
1151: {
1152: break;
1153: }
1154:
1155: default :
1156: {
1157: erreur_analyse = d_ex_syntaxe;
1158: break;
1159: }
1160: }
1161: }
1162:
1163: while(((*pointeur_caractere_courant) != base_binaire) &&
1164: ((*pointeur_caractere_courant) != d_code_fin_chaine) &&
1165: (erreur_analyse == d_ex))
1166: {
1167: if (base_binaire == 'b')
1168: {
1169: switch(*pointeur_caractere_courant)
1170: {
1171: case ' ' :
1172: case '0' :
1173: case '1' :
1174: {
1175: break;
1176: }
1177:
1178: default :
1179: {
1180: erreur_analyse = d_ex_syntaxe;
1181: break;
1182: }
1183: }
1184: }
1185: else if (base_binaire == 'o')
1186: {
1187: switch(*pointeur_caractere_courant)
1188: {
1189: case ' ' :
1190: case '0' :
1191: case '1' :
1192: case '2' :
1193: case '3' :
1194: case '4' :
1195: case '5' :
1196: case '6' :
1197: case '7' :
1198: {
1199: break;
1200: }
1201:
1202: default :
1203: {
1204: erreur_analyse = d_ex_syntaxe;
1205: break;
1206: }
1207: }
1208: }
1209: else if (base_binaire == 'd')
1210: {
1211: switch(*pointeur_caractere_courant)
1212: {
1213: case ' ' :
1214: case '0' :
1215: case '1' :
1216: case '2' :
1217: case '3' :
1218: case '4' :
1219: case '5' :
1220: case '6' :
1221: case '7' :
1222: case '8' :
1223: case '9' :
1224: {
1225: break;
1226: }
1227:
1228: default :
1229: {
1230: erreur_analyse = d_ex_syntaxe;
1231: break;
1232: }
1233: }
1234: }
1235: else if (base_binaire != 'h')
1236: {
1237: erreur_analyse = d_ex_syntaxe;
1238: }
1239:
1240: pointeur_caractere_courant++;
1241: }
1242:
1243: if (erreur_analyse == d_ex)
1244: {
1245: pointeur_caractere_courant++;
1246: }
1247:
1248: drapeau_fin_objet = d_vrai;
1249: break;
1250: }
1251:
1252: case '{' :
1253: {
1254: if (pointeur_debut_instruction !=
1255: (pointeur_caractere_courant - 1))
1256: {
1257: erreur_format = d_ex_syntaxe;
1258: }
1259:
1260: niveau = 1;
1261: niveau_annexe = 0;
1262:
1263: while((niveau != 0) && ((*pointeur_caractere_courant) !=
1264: d_code_fin_chaine))
1265: {
1266: switch(*pointeur_caractere_courant)
1267: {
1268: case '{' :
1269: {
1270: if (niveau_annexe == 0)
1271: {
1272: niveau++;
1273: }
1274: else
1275: {
1276: erreur_analyse = d_ex_syntaxe;
1277: }
1278:
1279: break;
1280: }
1281:
1282: case '}' :
1283: {
1284: if (niveau_annexe == 0)
1285: {
1286: niveau--;
1287: }
1288: else
1289: {
1290: erreur_analyse = d_ex_syntaxe;
1291: }
1292:
1293: break;
1294: }
1295:
1296: case '[' :
1297: {
1298: niveau_annexe++;
1299:
1300: if (niveau_annexe > 2)
1301: {
1302: erreur_analyse = d_ex_syntaxe;
1303: }
1304:
1305: break;
1306: }
1307:
1308: case ']' :
1309: {
1310: niveau_annexe--;
1311:
1312: if (niveau_annexe < 0)
1313: {
1314: erreur_analyse = d_ex_syntaxe;
1315: }
1316:
1317: break;
1318: }
1319:
1320: case '"' :
1321: {
1322: if (niveau_annexe == 0)
1323: {
1324: pointeur_caractere_courant++;
1325:
1326: while((*pointeur_caractere_courant != '"') &&
1327: ((*pointeur_caractere_courant) !=
1328: d_code_fin_chaine))
1329: {
1330: if (*pointeur_caractere_courant == '\\')
1331: {
1332: pointeur_caractere_courant++;
1333:
1334: switch(*pointeur_caractere_courant)
1335: {
1336: case '\\' :
1337: case '"' :
1338: {
1339: pointeur_caractere_courant++;
1340: break;
1341: }
1342: }
1343: }
1344: else
1345: {
1346: pointeur_caractere_courant++;
1347: }
1348: }
1349: }
1350: else
1351: {
1352: erreur_analyse = d_ex_syntaxe;
1353: }
1354:
1355: break;
1356: }
1357: }
1358:
1359: pointeur_caractere_courant++;
1360: }
1361:
1362: if ((niveau != 0) || (niveau_annexe != 0))
1363: {
1364: erreur_analyse = d_ex_syntaxe;
1365: }
1366:
1367: drapeau_fin_objet = d_vrai;
1368: break;
1369: }
1370:
1371: case '[' :
1372: {
1373: if (pointeur_debut_instruction !=
1374: (pointeur_caractere_courant - 1))
1375: {
1376: erreur_format = d_ex_syntaxe;
1377: }
1378:
1379: niveau = 1;
1380:
1381: while((niveau > 0) && ((*pointeur_caractere_courant) !=
1382: d_code_fin_chaine) && (erreur_analyse == d_ex))
1383: {
1384: switch(*pointeur_caractere_courant)
1385: {
1386: case '[' :
1387: {
1388: niveau++;
1389: break;
1390: }
1391:
1392: case ']' :
1393: {
1394: niveau--;
1395: break;
1396: }
1397:
1398: case '0' :
1399: case '1' :
1400: case '2' :
1401: case '3' :
1402: case '4' :
1403: case '5' :
1404: case '6' :
1405: case '7' :
1406: case '8' :
1407: case '9' :
1408: case '+' :
1409: case '-' :
1410: case 'e' :
1411: case 'E' :
1412: case '.' :
1413: case ',' :
1414: case '(' :
1415: case ')' :
1416: case ' ' :
1417: {
1418: break;
1419: }
1420:
1421: default :
1422: {
1423: erreur_analyse = d_ex_syntaxe;
1424: break;
1425: }
1426: }
1427:
1428: if (niveau < 0)
1429: {
1430: erreur_analyse = d_ex_syntaxe;
1431: }
1432: else if (niveau > 2)
1433: {
1434: erreur_format = d_ex_syntaxe;
1435: }
1436:
1437: pointeur_caractere_courant++;
1438: }
1439:
1440: if (niveau != 0)
1441: {
1442: erreur_analyse = d_ex_syntaxe;
1443: }
1444:
1445: drapeau_fin_objet = d_vrai;
1446: break;
1447: }
1448:
1449: case '<' :
1450: {
1451: if (((*s_etat_processus).autorisation_empilement_programme
1452: == 'Y') && ((*pointeur_caractere_courant) == '<'))
1453: {
1454: if (pointeur_debut_instruction !=
1455: (pointeur_caractere_courant - 1))
1456: {
1457: erreur_format = d_ex_syntaxe;
1458: }
1459:
1460: niveau = 1;
1461:
1462: while((niveau != 0) && ((*pointeur_caractere_courant) !=
1463: d_code_fin_chaine))
1464: {
1465: if (((*pointeur_caractere_courant) == '<') &&
1466: ((*(pointeur_caractere_courant + 1)) == '<'))
1467: {
1468: niveau++;
1469: pointeur_caractere_courant++;
1470: }
1471: else if (((*pointeur_caractere_courant) == '>') &&
1472: ((*(pointeur_caractere_courant + 1)) == '>'))
1473: {
1474: niveau--;
1475: pointeur_caractere_courant++;
1476: }
1477: else if ((*pointeur_caractere_courant) == '"')
1478: {
1479: pointeur_caractere_courant++;
1480:
1481: while((*pointeur_caractere_courant != '"') &&
1482: ((*pointeur_caractere_courant) !=
1483: d_code_fin_chaine))
1484: {
1485: if (*pointeur_caractere_courant == '\\')
1486: {
1487: pointeur_caractere_courant++;
1488:
1489: switch(*pointeur_caractere_courant)
1490: {
1491: case '\\' :
1492: case '"' :
1493: {
1494: pointeur_caractere_courant++;
1495: break;
1496: }
1497: }
1498: }
1499: else
1500: {
1501: pointeur_caractere_courant++;
1502: }
1503: }
1504: }
1505:
1506: pointeur_caractere_courant++;
1507: }
1508:
1509: if (niveau != 0)
1510: {
1511: erreur_analyse = d_ex_syntaxe;
1512: }
1513:
1514: drapeau_fin_objet = d_vrai;
1515: }
1516: else if ((*pointeur_caractere_courant) == '[')
1517: {
1518: if (pointeur_debut_instruction !=
1519: (pointeur_caractere_courant - 1))
1520: {
1521: erreur_format = d_ex_syntaxe;
1522: }
1523:
1524: pointeur_caractere_courant++;
1525: drapeau_fin_objet = d_faux;
1526:
1527: while(((*pointeur_caractere_courant) != d_code_fin_chaine)
1528: && (erreur_format == d_absence_erreur))
1529: {
1530: while((*pointeur_caractere_courant) == d_code_espace)
1531: {
1532: pointeur_caractere_courant++;
1533: }
1534:
1535: if ((*pointeur_caractere_courant) == ']')
1536: {
1537: if ((*(++pointeur_caractere_courant)) == '>')
1538: {
1539: drapeau_fin_objet = d_vrai;
1540: }
1541: else
1542: {
1543: erreur_analyse = d_ex_syntaxe;
1544: }
1545:
1546: pointeur_caractere_courant++;
1547: break;
1548: }
1549:
1550: if ((erreur_format == d_absence_erreur) &&
1551: (drapeau_fin_objet == d_faux))
1552: {
1553: (*s_etat_processus).position_courante =
1554: pointeur_caractere_courant
1555: - (*s_etat_processus).definitions_chainees;
1556:
1557: if ((erreur = recherche_instruction_suivante(
1558: s_etat_processus)) != d_absence_erreur)
1559: {
1560: if ((*s_etat_processus).instruction_courante
1561: != NULL)
1562: {
1563: free((*s_etat_processus)
1564: .instruction_courante);
1565: }
1566:
1567: return(d_erreur);
1568: }
1569:
1570: pointeur_caractere_courant = (*s_etat_processus)
1571: .definitions_chainees + (*s_etat_processus)
1572: .position_courante;
1573:
1574: free((*s_etat_processus).instruction_courante);
1575: }
1576: }
1577:
1578: if (drapeau_fin_objet == d_faux)
1579: {
1580: erreur_analyse = d_ex_syntaxe;
1581: drapeau_fin_objet = d_vrai;
1582: }
1583: }
1584:
1585: break;
1586: }
1587: }
1588: }
1589:
1590: pointeur_fin_instruction = pointeur_caractere_courant;
1591:
1592: (*s_etat_processus).instruction_courante = (unsigned char *)
1593: malloc(((pointeur_fin_instruction - pointeur_debut_instruction)
1594: + 1) * sizeof(unsigned char));
1595:
1596: if ((*s_etat_processus).instruction_courante == NULL)
1597: {
1598: erreur = d_erreur;
1599: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1600: }
1601: else if (pointeur_fin_instruction != pointeur_debut_instruction)
1602: {
1603: pointeur_caractere_courant = pointeur_debut_instruction;
1604: pointeur_caractere_destination =
1605: (*s_etat_processus).instruction_courante;
1606:
1607: do
1608: {
1609: *pointeur_caractere_destination++ = *pointeur_caractere_courant++;
1610: } while(pointeur_caractere_courant < pointeur_fin_instruction);
1611:
1612: (*pointeur_caractere_destination) = d_code_fin_chaine;
1613:
1614: erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex))
1615: ? d_absence_erreur : d_erreur;
1616: (*s_etat_processus).erreur_execution = erreur_analyse;
1617: }
1618: else
1619: {
1620: (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine;
1621: }
1622:
1623: (*s_etat_processus).position_courante = pointeur_fin_instruction
1624: - (*s_etat_processus).definitions_chainees;
1625:
1626: return(erreur);
1627: }
1628:
1629:
1630: /*
1631: ================================================================================
1632: Routine mettant la chaine d'entrée en majuscule
1633: ================================================================================
1634: Entrée : pointeur sur une chaine en minuscules.
1635: --------------------------------------------------------------------------------
1636: Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné
1637: est nul, il s'est produit une erreur. L'allocation est faite dans la
1638: routine.
1639: --------------------------------------------------------------------------------
1640: Effets de bord : néant.
1641: ================================================================================
1642: */
1643:
1644: unsigned char *
1645: conversion_majuscule(unsigned char *chaine)
1646: {
1647: register unsigned char *caractere_courant;
1648: register unsigned char *caractere_courant_converti;
1649: register unsigned char *chaine_convertie;
1650:
1651: unsigned long longueur_chaine_plus_terminaison;
1652:
1653: longueur_chaine_plus_terminaison = 0;
1654: caractere_courant = chaine;
1655:
1656: while((*caractere_courant) != d_code_fin_chaine)
1657: {
1658: caractere_courant++;
1659: longueur_chaine_plus_terminaison++;
1660: }
1661:
1662: caractere_courant = chaine;
1663: caractere_courant_converti = chaine_convertie = (unsigned char *) malloc(
1664: (longueur_chaine_plus_terminaison + 1) * sizeof(unsigned char));
1665:
1666: if (chaine_convertie != NULL)
1667: {
1668: while((*caractere_courant) != d_code_fin_chaine)
1669: {
1670: if (isalpha((*caractere_courant)))
1671: {
1672: (*caractere_courant_converti) = (unsigned char)
1673: toupper((*caractere_courant));
1674: }
1675: else
1676: {
1677: (*caractere_courant_converti) = (*caractere_courant);
1678: }
1679:
1680: caractere_courant++;
1681: caractere_courant_converti++;
1682: }
1683:
1684: (*caractere_courant_converti) = d_code_fin_chaine;
1685: }
1686:
1687: return(chaine_convertie);
1688: }
1689:
1690:
1691: /*
1692: ================================================================================
1693: Initialisation de l'état du calculateur
1694: Configuration par défaut d'un calculateur HP-28S
1695: ================================================================================
1696: Entrée : pointeur sur la structure struct_processus
1697: --------------------------------------------------------------------------------
1698: Sortie : néant
1699: --------------------------------------------------------------------------------
1700: Effets de bord : néant
1701: ================================================================================
1702: */
1703:
1704: void
1705: initialisation_drapeaux(struct_processus *s_etat_processus)
1706: {
1707: unsigned long i;
1708:
1709: for(i = 0; i < 31; cf(s_etat_processus, i++));
1710:
1711: if ((*s_etat_processus).lancement_interactif == d_vrai)
1712: {
1713: sf(s_etat_processus, 31);
1714: /* LAST autorisé */
1715: }
1716: else
1717: {
1718: cf(s_etat_processus, 31);
1719: /* LAST invalidé */
1720: }
1721:
1722: cf(s_etat_processus, 32); /* Impression automatique */
1723: cf(s_etat_processus, 33); /* CR automatique (disp) */
1724: cf(s_etat_processus, 34); /* Valeur principale (intervalle de déf.) */
1725: sf(s_etat_processus, 35); /* Evaluation symbolique des constantes */
1726: sf(s_etat_processus, 36); /* Evaluation symbolique des fonctions */
1727: sf(s_etat_processus, 37); /* Taille de mot pour les entiers binaires */
1728: sf(s_etat_processus, 38); /* Taille de mot pour les entiers binaires */
1729: sf(s_etat_processus, 39); /* Taille de mot pour les entiers binaires */
1730: sf(s_etat_processus, 40); /* Taille de mot pour les entiers binaires */
1731: sf(s_etat_processus, 41); /* Taille de mot pour les entiers binaires */
1732: sf(s_etat_processus, 42); /* Taille de mot pour les entiers binaires */
1733: /*
1734: 37 : bit de poids faible
1735: 42 : bit de poids fort
1736: Les six drapeaux peuvent être nuls. Dans ce cas, la longueur des mots
1737: binaires reste de un bit.
1738: */
1739: cf(s_etat_processus, 43); /* Base de numération binaire */
1740: cf(s_etat_processus, 44); /* Base de numération binaire */
1741: /*
1742: 43 44 = 00 => décimal
1743: 43 44 = 01 => binaire
1744: 43 44 = 10 => octal
1745: 43 44 = 11 => hexadécimal
1746: */
1747: sf(s_etat_processus, 45); /* Affichage multiligne du niveau 1 */
1748: cf(s_etat_processus, 46); /* Réservé */
1749: cf(s_etat_processus, 47); /* Réservé */
1750: /*
1751: 46 et 47 réservés sur le calculateur HP28S
1752: 46 47 = 00 => système rectangulaire
1753: 46 47 = 01 => système cylindrique
1754: 46 47 = 10 => système sphérique
1755: */
1756: cf(s_etat_processus, 48); /* Séparateur décimal */
1757: cf(s_etat_processus, 49); /* Format des nombres réels */
1758: cf(s_etat_processus, 50); /* Format des nombres réels */
1759: /*
1760: 49 50 = 00 => standard
1761: 49 50 = 01 => scientifique
1762: 49 50 = 10 => virgule fixe
1763: 49 50 = 11 => ingénieur
1764: */
1765: cf(s_etat_processus, 51); /* Tonalité */
1766: cf(s_etat_processus, 52); /* REDRAW automatique */
1767: cf(s_etat_processus, 53); /* Nombre de chiffres décimaux */
1768: cf(s_etat_processus, 54); /* Nombre de chiffres décimaux */
1769: cf(s_etat_processus, 55); /* Nombre de chiffres décimaux */
1770: cf(s_etat_processus, 56); /* Nombre de chiffres décimaux */
1771: /*
1772: 53 : bit de poids faible
1773: 56 : bit de poids fort
1774: */
1775: cf(s_etat_processus, 57); /* Underflow traité normalement */
1776: cf(s_etat_processus, 58); /* Overflow traité normalement */
1777: sf(s_etat_processus, 59); /* Infinite result traité normalement */
1778: sf(s_etat_processus, 60); /* Angles */
1779: /*
1780: 60 = 0 => degrés
1781: 60 = 1 => radians
1782: */
1783: cf(s_etat_processus, 61); /* Underflow- traité en exception */
1784: cf(s_etat_processus, 62); /* Underflow+ traité en exception */
1785: cf(s_etat_processus, 63); /* Overflow traité en exception */
1786: cf(s_etat_processus, 64); /* Infinite result traité en exception */
1787: }
1788:
1789: // vim: ts=4