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