1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.19
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: Affectation automatique d'un type à des données
29: ================================================================================
30: Entrées : structure sur l'état du processus
31: --------------------------------------------------------------------------------
32: Sorties : Néant
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: recherche_type(struct_processus *s_etat_processus)
40: {
41: int nombre_elements_convertis;
42:
43: struct_liste_chainee *l_base_liste_fonctions;
44: struct_liste_chainee *l_base_liste_decomposition;
45: struct_liste_chainee *l_element_courant;
46: struct_liste_chainee *l_element_courant_fonctions;
47: struct_liste_chainee *l_element_precedent;
48:
49: struct_liste_pile_systeme *s_sauvegarde_pile;
50:
51: struct_objet *s_objet;
52: struct_objet *s_sous_objet;
53:
54: logical1 drapeau_chaine;
55: logical1 drapeau_complexe;
56: logical1 drapeau_matrice;
57: logical1 drapeau_reel;
58: logical1 drapeau_valeur_entiere;
59: logical1 drapeau_valeur_reelle;
60: logical1 erreur;
61: logical1 erreur_lecture_binaire;
62:
63: logical8 ancienne_valeur_base;
64: logical8 valeur_base;
65:
66: long coherence_liste;
67:
68: unsigned char autorisation_evaluation_nom;
69: unsigned char *definitions_chainees_precedentes;
70: unsigned char *fonction_majuscule;
71: unsigned char *instruction_majuscule;
72: unsigned char *ptr;
73: unsigned char *ptr_ecriture;
74: unsigned char *ptr_lecture;
75: unsigned char registre_instruction_valide;
76: unsigned char registre_interruption;
77: unsigned char registre_mode_execution_programme;
78: unsigned char registre_test;
79: unsigned char registre_test_bis;
80: unsigned char *tampon;
81:
82: unsigned long i;
83: unsigned long j;
84: unsigned long niveau;
85: unsigned long niveau_maximal;
86: unsigned long nombre_colonnes;
87: unsigned long nombre_egalites;
88: unsigned long nombre_elements;
89: unsigned long nombre_exposants;
90: unsigned long nombre_lignes;
91: unsigned long nombre_lignes_a_supprimer;
92: unsigned long nombre_points;
93: unsigned long nombre_virgules;
94: unsigned long position_courante;
95: unsigned long profondeur_finale;
96: unsigned long profondeur_initiale;
97: unsigned long sauvegarde_niveau_courant;
98: unsigned long sauvegarde_longueur_definitions_chainees;
99:
100: void *element;
101:
102: s_objet = (struct_objet *) malloc(sizeof(struct_objet));
103: element = NULL;
104: nombre_egalites = 0;
105: i = 0;
106:
107: if (s_objet == NULL)
108: {
109: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
110: return;
111: }
112:
113: initialisation_objet(s_objet);
114: registre_test = (*s_etat_processus).test_instruction;
115: registre_instruction_valide = (*s_etat_processus).instruction_valide;
116: registre_interruption = (*s_etat_processus).traitement_interruptible;
117: (*s_etat_processus).test_instruction = 'Y';
118: (*s_etat_processus).traitement_interruptible = 'N';
119:
120: analyse(s_etat_processus, NULL);
121:
122: (*s_etat_processus).test_instruction = registre_test;
123:
124: if ((*s_etat_processus).instruction_valide == 'Y')
125: {
126: if ((*s_etat_processus).constante_symbolique == 'N')
127: {
128: if ((element = malloc(sizeof(struct_fonction))) == NULL)
129: {
130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
131: (*s_etat_processus).traitement_interruptible =
132: registre_interruption;
133: return;
134: }
135:
136: (*((struct_fonction *) element)).nombre_arguments = 0;
137: (*((struct_fonction *) element)).prediction_saut = NULL;
138:
139: if ((*s_etat_processus).instruction_intrinseque == 'Y')
140: {
141: /*
142: * Les fonctions intrinsèques ne sont pas sensibles à la casse.
143: */
144:
145: if (((*((struct_fonction *) element)).nom_fonction =
146: conversion_majuscule((*s_etat_processus)
147: .instruction_courante)) == NULL)
148: {
149: (*s_etat_processus).erreur_systeme =
150: d_es_allocation_memoire;
151: (*s_etat_processus).traitement_interruptible =
152: registre_interruption;
153: return;
154: }
155: }
156: else
157: {
158: if (((*((struct_fonction *) element)).nom_fonction =
159: malloc((strlen((*s_etat_processus).instruction_courante)
160: + 1) * sizeof(unsigned char))) == NULL)
161: {
162: (*s_etat_processus).erreur_systeme =
163: d_es_allocation_memoire;
164: (*s_etat_processus).traitement_interruptible =
165: registre_interruption;
166: return;
167: }
168:
169: strcpy((*((struct_fonction *) element)).nom_fonction,
170: (*s_etat_processus).instruction_courante);
171: }
172:
173: (*((struct_fonction *) element)).fonction =
174: analyse_instruction(s_etat_processus,
175: (*((struct_fonction *) element)).nom_fonction);
176:
177: (*s_objet).type = FCT;
178: (*s_objet).objet = element;
179: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
180: (*((struct_fonction *) (*s_objet).objet)).prediction_execution
181: = d_faux;
182:
183: if (empilement(s_etat_processus,
184: &((*s_etat_processus).l_base_pile), s_objet) == d_erreur)
185: {
186: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
187: (*s_etat_processus).traitement_interruptible =
188: registre_interruption;
189: return;
190: }
191: }
192: else
193: {
194: if ((instruction_majuscule = conversion_majuscule(
195: (*s_etat_processus).instruction_courante)) == NULL)
196: {
197: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
198: (*s_etat_processus).traitement_interruptible =
199: registre_interruption;
200: return;
201: }
202:
203: if ((*s_etat_processus).constante_symbolique == 'Y')
204: {
205: registre_test_bis = (*s_etat_processus).test_instruction;
206: (*s_etat_processus).test_instruction = 'N';
207: analyse(s_etat_processus, NULL);
208: (*s_etat_processus).test_instruction = registre_test_bis;
209: free(s_objet);
210: }
211: else
212: {
213: (*s_objet).type = NOM;
214:
215: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
216: {
217: (*s_etat_processus).erreur_systeme =
218: d_es_allocation_memoire;
219: (*s_etat_processus).traitement_interruptible =
220: registre_interruption;
221: return;
222: }
223:
224: (*((struct_nom *) (*s_objet).objet)).symbole = d_faux;
225:
226: if (((*((struct_nom *) (*s_objet).objet)).nom =
227: (unsigned char *) malloc((strlen((*s_etat_processus)
228: .instruction_courante) + 1) * sizeof(unsigned char)))
229: == NULL)
230: {
231: (*s_etat_processus).erreur_systeme =
232: d_es_allocation_memoire;
233: (*s_etat_processus).traitement_interruptible =
234: registre_interruption;
235: return;
236: }
237:
238: strcpy((*((struct_nom *) (*s_objet).objet)).nom,
239: (*s_etat_processus).instruction_courante);
240:
241: if (empilement(s_etat_processus,
242: &((*s_etat_processus).l_base_pile), s_objet) ==
243: d_erreur)
244: {
245: (*s_etat_processus).erreur_systeme =
246: d_es_allocation_memoire;
247: (*s_etat_processus).traitement_interruptible =
248: registre_interruption;
249: return;
250: }
251: }
252:
253: free(instruction_majuscule);
254: }
255:
256: (*s_etat_processus).instruction_valide = registre_instruction_valide;
257: (*s_etat_processus).traitement_interruptible = registre_interruption;
258: return;
259: }
260:
261: (*s_etat_processus).instruction_valide = registre_instruction_valide;
262:
263: switch(*((*s_etat_processus).instruction_courante))
264: {
265:
266: /*
267: --------------------------------------------------------------------------------
268: Complexe
269: --------------------------------------------------------------------------------
270: */
271:
272: case '(' :
273: {
274: (*s_objet).type = CPL;
275:
276: element = (void *) ((struct_complexe16 *) malloc(
277: sizeof(struct_complexe16)));
278:
279: if (element == NULL)
280: {
281: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
282: (*s_etat_processus).traitement_interruptible =
283: registre_interruption;
284: return;
285: }
286:
287: conversion_format(s_etat_processus,
288: (*s_etat_processus).instruction_courante);
289:
290: sauvegarde_longueur_definitions_chainees =
291: (*s_etat_processus).longueur_definitions_chainees;
292:
293: tampon = (unsigned char *) malloc(
294: (((*s_etat_processus).longueur_definitions_chainees
295: = strlen((*s_etat_processus).instruction_courante)
296: + 4) + 1) * sizeof(unsigned char));
297:
298: if (tampon == NULL)
299: {
300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
301: (*s_etat_processus).traitement_interruptible =
302: registre_interruption;
303: return;
304: }
305:
306: strcpy(tampon, "<< ");
307: ptr_ecriture = tampon + 3;
308: ptr_lecture = (*s_etat_processus).instruction_courante + 1;
309:
310: nombre_virgules = 0;
311:
312: while((*ptr_lecture) != d_code_fin_chaine)
313: {
314: if ((*ptr_lecture) == ',')
315: {
316: (*ptr_lecture) = ' ';
317: nombre_virgules++;
318: }
319:
320: *ptr_ecriture++ = *ptr_lecture++;
321: }
322:
323: (*(--ptr_ecriture)) = d_code_fin_chaine;
324: strcat(ptr_ecriture, " >>");
325:
326: position_courante = (*s_etat_processus).position_courante;
327: (*s_etat_processus).position_courante = 0;
328:
329: profondeur_initiale = (*s_etat_processus)
330: .hauteur_pile_operationnelle;
331:
332: /*
333: -- On met le tout dans la pile opérationnelle ----------------------------------
334: */
335:
336: (*s_etat_processus).niveau_recursivite++;
337: definitions_chainees_precedentes = (*s_etat_processus)
338: .definitions_chainees;
339: (*s_etat_processus).definitions_chainees = tampon;
340:
341: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
342: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;
343:
344: (*s_etat_processus).l_base_pile_systeme = NULL;
345: empilement_pile_systeme(s_etat_processus);
346:
347: if ((*s_etat_processus).erreur_systeme != d_es)
348: {
349: (*s_etat_processus).traitement_interruptible =
350: registre_interruption;
351: return;
352: }
353:
354: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
355: (*s_etat_processus).niveau_courant = 0;
356: (*s_etat_processus).autorisation_empilement_programme = 'N';
357: registre_mode_execution_programme =
358: (*s_etat_processus).mode_execution_programme;
359: (*s_etat_processus).mode_execution_programme = 'Y';
360:
361: tampon = (*s_etat_processus).instruction_courante;
362:
363: if ((*s_etat_processus).profilage == d_vrai)
364: {
365: profilage(s_etat_processus, "RPL/2 internals");
366:
367: if ((*s_etat_processus).erreur_systeme != d_es)
368: {
369: return;
370: }
371: }
372:
373: if (sequenceur(s_etat_processus) == d_erreur)
374: {
375: (*s_etat_processus).instruction_courante = tampon;
376: (*s_etat_processus).mode_execution_programme =
377: registre_mode_execution_programme;
378:
379: effacement_pile_systeme(s_etat_processus);
380: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
381: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
382:
383: (*s_etat_processus).niveau_recursivite--;
384:
385: (*s_etat_processus).position_courante = position_courante;
386: free((*s_etat_processus).definitions_chainees);
387: (*s_etat_processus).definitions_chainees =
388: definitions_chainees_precedentes;
389: (*s_etat_processus).longueur_definitions_chainees =
390: sauvegarde_longueur_definitions_chainees;
391:
392: free(element);
393: free(s_objet);
394:
395: (*s_etat_processus).traitement_interruptible =
396: registre_interruption;
397: return;
398: }
399:
400: (*s_etat_processus).instruction_courante = tampon;
401: (*s_etat_processus).mode_execution_programme =
402: registre_mode_execution_programme;
403:
404: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
405: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
406:
407: (*s_etat_processus).niveau_recursivite--;
408:
409: (*s_etat_processus).position_courante = position_courante;
410: free((*s_etat_processus).definitions_chainees);
411: (*s_etat_processus).definitions_chainees =
412: definitions_chainees_precedentes;
413: (*s_etat_processus).longueur_definitions_chainees =
414: sauvegarde_longueur_definitions_chainees;
415:
416: /*
417: -- On relit la pile pour remplir le complexe -----------------------------------
418: */
419:
420: profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle;
421: nombre_elements_convertis = profondeur_finale - profondeur_initiale;
422:
423: if ((nombre_elements_convertis != 2) || (nombre_virgules != 1))
424: {
425: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
426:
427: free(s_objet);
428: free(element);
429:
430: for(i = 0; i < (unsigned long) nombre_elements_convertis; i++)
431: {
432: if (depilement(s_etat_processus, &((*s_etat_processus)
433: .l_base_pile), &s_sous_objet) == d_erreur)
434: {
435: (*s_etat_processus).traitement_interruptible =
436: registre_interruption;
437: return;
438: }
439:
440: liberation(s_etat_processus, s_sous_objet);
441: }
442:
443: (*s_etat_processus).traitement_interruptible =
444: registre_interruption;
445: return;
446: }
447: else
448: {
449: if (depilement(s_etat_processus,
450: &((*s_etat_processus).l_base_pile), &s_sous_objet) ==
451: d_absence_erreur)
452: {
453: if ((*s_sous_objet).type == INT)
454: {
455: (*((struct_complexe16 *) element)).partie_imaginaire =
456: (*((integer8 *) (*s_sous_objet).objet));
457: }
458: else if ((*s_sous_objet).type == REL)
459: {
460: (*((struct_complexe16 *) element)).partie_imaginaire =
461: (*((real8 *) (*s_sous_objet).objet));
462: }
463: else
464: {
465: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
466:
467: free(element);
468: free(s_objet);
469:
470: liberation(s_etat_processus, s_sous_objet);
471:
472: (*s_etat_processus).traitement_interruptible =
473: registre_interruption;
474: return;
475: }
476:
477: liberation(s_etat_processus, s_sous_objet);
478:
479: if (depilement(s_etat_processus,
480: &((*s_etat_processus).l_base_pile), &s_sous_objet)
481: == d_absence_erreur)
482: {
483: if ((*s_sous_objet).type == INT)
484: {
485: (*((struct_complexe16 *) element)).partie_reelle =
486: (*((integer8 *) (*s_sous_objet).objet));
487: }
488: else if ((*s_sous_objet).type == REL)
489: {
490: (*((struct_complexe16 *) element)).partie_reelle =
491: (*((real8 *) (*s_sous_objet).objet));
492: }
493: else
494: {
495: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
496:
497: free(element);
498: free(s_objet);
499:
500: liberation(s_etat_processus, s_sous_objet);
501:
502: (*s_etat_processus).traitement_interruptible =
503: registre_interruption;
504: return;
505: }
506:
507: liberation(s_etat_processus, s_sous_objet);
508: }
509: }
510: }
511:
512: break;
513: }
514:
515: /*
516: --------------------------------------------------------------------------------
517: Binaire
518: --------------------------------------------------------------------------------
519: */
520:
521: case '#' :
522: {
523: (*s_objet).type = BIN;
524:
525: element = (void *) ((logical8 *) malloc(
526: sizeof(logical8)));
527:
528: if (element == NULL)
529: {
530: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
531: (*s_etat_processus).traitement_interruptible =
532: registre_interruption;
533: return;
534: }
535:
536: erreur_lecture_binaire = d_faux;
537:
538: switch((*s_etat_processus).instruction_courante
539: [strlen((*s_etat_processus).instruction_courante) - 1])
540: {
541: case 'b' :
542: {
543: i = strlen((*s_etat_processus).instruction_courante) - 2;
544: valeur_base = 1;
545:
546: (*((logical8 *) element)) = 0;
547:
548: while(i > 0)
549: {
550: if ((*s_etat_processus).instruction_courante[i] == '1')
551: {
552: (*((logical8 *) element)) += valeur_base;
553: }
554: else if ((*s_etat_processus).instruction_courante[i]
555: != '0')
556: {
557: if ((*s_etat_processus).instruction_courante[i]
558: == ' ')
559: {
560: while(i > 0)
561: {
562: if ((*s_etat_processus)
563: .instruction_courante[i] != ' ')
564: {
565: break;
566: }
567:
568: i--;
569: }
570: }
571:
572: if (i != 0)
573: {
574: free(element);
575: free(s_objet);
576:
577: (*s_etat_processus).erreur_execution =
578: d_ex_syntaxe;
579: (*s_etat_processus).traitement_interruptible =
580: registre_interruption;
581: return;
582: }
583:
584: break;
585: }
586:
587: ancienne_valeur_base = valeur_base;
588: valeur_base *= 2;
589:
590: if (ancienne_valeur_base > valeur_base)
591: {
592: i--;
593:
594: while(i > 0)
595: {
596: if ((*s_etat_processus).instruction_courante[i]
597: != ' ')
598: {
599: erreur_lecture_binaire = d_vrai;
600: }
601:
602: i--;
603: }
604:
605: break;
606: }
607:
608: i--;
609: }
610:
611: nombre_elements_convertis = 1;
612: break;
613: }
614:
615: case 'o' :
616: {
617: i = strlen((*s_etat_processus).instruction_courante) - 2;
618: valeur_base = 1;
619:
620: (*((logical8 *) element)) = 0;
621:
622: while(i > 0)
623: {
624: if ((*s_etat_processus).instruction_courante[i] == '1')
625: {
626: (*((logical8 *) element)) += valeur_base;
627: }
628: else if ((*s_etat_processus).instruction_courante[i]
629: == '2')
630: {
631: (*((logical8 *) element)) += 2 * valeur_base;
632: }
633: else if ((*s_etat_processus).instruction_courante[i]
634: == '3')
635: {
636: (*((logical8 *) element)) += 3 * valeur_base;
637: }
638: else if ((*s_etat_processus).instruction_courante[i]
639: == '4')
640: {
641: (*((logical8 *) element)) += 4 * valeur_base;
642: }
643: else if ((*s_etat_processus).instruction_courante[i]
644: == '5')
645: {
646: (*((logical8 *) element)) += 5 * valeur_base;
647: }
648: else if ((*s_etat_processus).instruction_courante[i]
649: == '6')
650: {
651: (*((logical8 *) element)) += 6 * valeur_base;
652: }
653: else if ((*s_etat_processus).instruction_courante[i]
654: == '7')
655: {
656: (*((logical8 *) element)) += 7 * valeur_base;
657: }
658: else if ((*s_etat_processus).instruction_courante[i]
659: != '0')
660: {
661: if ((*s_etat_processus).instruction_courante[i]
662: == ' ')
663: {
664: while(i > 0)
665: {
666: if ((*s_etat_processus)
667: .instruction_courante[i] != ' ')
668: {
669: break;
670: }
671:
672: i--;
673: }
674: }
675:
676: if (i != 0)
677: {
678: free(element);
679: free(s_objet);
680:
681: (*s_etat_processus).erreur_execution =
682: d_ex_syntaxe;
683: (*s_etat_processus).traitement_interruptible =
684: registre_interruption;
685: return;
686: }
687:
688: break;
689: }
690:
691: ancienne_valeur_base = valeur_base;
692: valeur_base *= 8;
693:
694: if (ancienne_valeur_base > valeur_base)
695: {
696: i--;
697:
698: while(i > 0)
699: {
700: if ((*s_etat_processus).instruction_courante[i]
701: != ' ')
702: {
703: erreur_lecture_binaire = d_vrai;
704: }
705:
706: i--;
707: }
708:
709: break;
710: }
711:
712: i--;
713: }
714:
715: nombre_elements_convertis = 1;
716: break;
717: }
718:
719: case 'd' :
720: {
721: i = strlen((*s_etat_processus).instruction_courante) - 2;
722: valeur_base = 1;
723:
724: (*((logical8 *) element)) = 0;
725:
726: while(i > 0)
727: {
728: if ((*s_etat_processus).instruction_courante[i] == '1')
729: {
730: (*((logical8 *) element)) += valeur_base;
731: }
732: else if ((*s_etat_processus).instruction_courante[i]
733: == '2')
734: {
735: (*((logical8 *) element)) += 2 * valeur_base;
736: }
737: else if ((*s_etat_processus).instruction_courante[i]
738: == '3')
739: {
740: (*((logical8 *) element)) += 3 * valeur_base;
741: }
742: else if ((*s_etat_processus).instruction_courante[i]
743: == '4')
744: {
745: (*((logical8 *) element)) += 4 * valeur_base;
746: }
747: else if ((*s_etat_processus).instruction_courante[i]
748: == '5')
749: {
750: (*((logical8 *) element)) += 5 * valeur_base;
751: }
752: else if ((*s_etat_processus).instruction_courante[i]
753: == '6')
754: {
755: (*((logical8 *) element)) += 6 * valeur_base;
756: }
757: else if ((*s_etat_processus).instruction_courante[i]
758: == '7')
759: {
760: (*((logical8 *) element)) += 7 * valeur_base;
761: }
762: else if ((*s_etat_processus).instruction_courante[i]
763: == '8')
764: {
765: (*((logical8 *) element)) += 8 * valeur_base;
766: }
767: else if ((*s_etat_processus).instruction_courante[i]
768: == '9')
769: {
770: (*((logical8 *) element)) += 9 * valeur_base;
771: }
772: else if ((*s_etat_processus).instruction_courante[i]
773: != '0')
774: {
775: if ((*s_etat_processus).instruction_courante[i]
776: == ' ')
777: {
778: while(i > 0)
779: {
780: if ((*s_etat_processus)
781: .instruction_courante[i] != ' ')
782: {
783: break;
784: }
785:
786: i--;
787: }
788: }
789:
790: if (i != 0)
791: {
792: free(element);
793: free(s_objet);
794:
795: (*s_etat_processus).erreur_execution =
796: d_ex_syntaxe;
797: (*s_etat_processus).traitement_interruptible =
798: registre_interruption;
799: return;
800: }
801:
802: break;
803: }
804:
805: ancienne_valeur_base = valeur_base;
806: valeur_base *= 10;
807:
808: if (ancienne_valeur_base > valeur_base)
809: {
810: i--;
811:
812: while(i > 0)
813: {
814: if ((*s_etat_processus).instruction_courante[i]
815: != ' ')
816: {
817: erreur_lecture_binaire = d_vrai;
818: }
819:
820: i--;
821: }
822:
823: break;
824: }
825:
826: i--;
827: }
828:
829: nombre_elements_convertis = 1;
830: break;
831: }
832:
833: case 'h' :
834: {
835: i = strlen((*s_etat_processus).instruction_courante) - 2;
836: valeur_base = 1;
837:
838: (*((logical8 *) element)) = 0;
839:
840: while(i > 0)
841: {
842: if ((*s_etat_processus).instruction_courante[i] == '1')
843: {
844: (*((logical8 *) element)) += valeur_base;
845: }
846: else if ((*s_etat_processus).instruction_courante[i]
847: == '2')
848: {
849: (*((logical8 *) element)) += 2 * valeur_base;
850: }
851: else if ((*s_etat_processus).instruction_courante[i]
852: == '3')
853: {
854: (*((logical8 *) element)) += 3 * valeur_base;
855: }
856: else if ((*s_etat_processus).instruction_courante[i]
857: == '4')
858: {
859: (*((logical8 *) element)) += 4 * valeur_base;
860: }
861: else if ((*s_etat_processus).instruction_courante[i]
862: == '5')
863: {
864: (*((logical8 *) element)) += 5 * valeur_base;
865: }
866: else if ((*s_etat_processus).instruction_courante[i]
867: == '6')
868: {
869: (*((logical8 *) element)) += 6 * valeur_base;
870: }
871: else if ((*s_etat_processus).instruction_courante[i]
872: == '7')
873: {
874: (*((logical8 *) element)) += 7 * valeur_base;
875: }
876: else if ((*s_etat_processus).instruction_courante[i]
877: == '8')
878: {
879: (*((logical8 *) element)) += 8 * valeur_base;
880: }
881: else if ((*s_etat_processus).instruction_courante[i]
882: == '9')
883: {
884: (*((logical8 *) element)) += 9 * valeur_base;
885: }
886: else if ((*s_etat_processus).instruction_courante[i]
887: == 'A')
888: {
889: (*((logical8 *) element)) += 10 * valeur_base;
890: }
891: else if ((*s_etat_processus).instruction_courante[i]
892: == 'B')
893: {
894: (*((logical8 *) element)) += 11 * valeur_base;
895: }
896: else if ((*s_etat_processus).instruction_courante[i]
897: == 'C')
898: {
899: (*((logical8 *) element)) += 12 * valeur_base;
900: }
901: else if ((*s_etat_processus).instruction_courante[i]
902: == 'D')
903: {
904: (*((logical8 *) element)) += 13 * valeur_base;
905: }
906: else if ((*s_etat_processus).instruction_courante[i]
907: == 'E')
908: {
909: (*((logical8 *) element)) += 14 * valeur_base;
910: }
911: else if ((*s_etat_processus).instruction_courante[i]
912: == 'F')
913: {
914: (*((logical8 *) element)) += 15 * valeur_base;
915: }
916: else if ((*s_etat_processus).instruction_courante[i]
917: != '0')
918: {
919: if ((*s_etat_processus).instruction_courante[i]
920: == ' ')
921: {
922: while(i > 0)
923: {
924: if ((*s_etat_processus)
925: .instruction_courante[i] != ' ')
926: {
927: break;
928: }
929:
930: i--;
931: }
932: }
933:
934: if (i != 0)
935: {
936: free(element);
937: free(s_objet);
938:
939: (*s_etat_processus).erreur_execution =
940: d_ex_syntaxe;
941: (*s_etat_processus).traitement_interruptible =
942: registre_interruption;
943: return;
944: }
945:
946: break;
947: }
948:
949: ancienne_valeur_base = valeur_base;
950: valeur_base *= 16;
951:
952: if (ancienne_valeur_base > valeur_base)
953: {
954: i--;
955:
956: while(i > 0)
957: {
958: if ((*s_etat_processus).instruction_courante[i]
959: != ' ')
960: {
961: erreur_lecture_binaire = d_vrai;
962: }
963:
964: i--;
965: }
966:
967: break;
968: }
969:
970: i--;
971: }
972:
973: nombre_elements_convertis = 1;
974: break;
975: }
976:
977: default :
978: {
979: nombre_elements_convertis = 0;
980: break;
981: }
982: }
983:
984: if ((nombre_elements_convertis != 1) ||
985: (erreur_lecture_binaire == d_vrai))
986: {
987: free(element);
988: free(s_objet);
989:
990: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
991: (*s_etat_processus).traitement_interruptible =
992: registre_interruption;
993: return;
994: }
995:
996: break;
997: }
998:
999: /*
1000: --------------------------------------------------------------------------------
1001: Matrices ou vecteurs entiers, réels ou complexes
1002: --------------------------------------------------------------------------------
1003: */
1004:
1005: case '[' :
1006: {
1007: niveau = 0;
1008: niveau_maximal = 0;
1009:
1010: nombre_colonnes = 0;
1011: nombre_lignes = 0;
1012:
1013: drapeau_complexe = d_faux;
1014: drapeau_reel = d_faux;
1015:
1016: ptr = (*s_etat_processus).instruction_courante;
1017:
1018: while((*ptr) != d_code_fin_chaine)
1019: {
1020: switch(*ptr)
1021: {
1022: case '(' :
1023: case ')' :
1024: {
1025: drapeau_complexe = d_vrai;
1026: drapeau_reel = d_vrai;
1027: break;
1028: }
1029:
1030: case '.' :
1031: case 'E' :
1032: case 'e' :
1033: {
1034: drapeau_reel = d_vrai;
1035: break;
1036: }
1037:
1038: case '[' :
1039: {
1040: niveau_maximal = (++niveau);
1041: break;
1042: }
1043:
1044: case ']' :
1045: {
1046: niveau--;
1047: break;
1048: }
1049: }
1050:
1051: ptr++;
1052: }
1053:
1054: if (niveau != 0)
1055: {
1056: free(s_objet);
1057:
1058: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1059: (*s_etat_processus).traitement_interruptible =
1060: registre_interruption;
1061: return;
1062: }
1063:
1064: drapeau_matrice = (niveau_maximal == 2) ? d_vrai : d_faux;
1065:
1066: switch (drapeau_matrice)
1067: {
1068:
1069: /*
1070: --------------------------------------------------------------------------------
1071: Vecteur
1072: --------------------------------------------------------------------------------
1073: */
1074:
1075: case d_faux :
1076: {
1077:
1078: /*
1079: -- Sauvegarde des paramètres du processus pour analyser le vecteur -------------
1080: -- Analyse récursive en appelant l'interprète sur le vecteur moins -------------
1081: -- ses délimiteurs -------------------------------------------------------------
1082: */
1083:
1084: sauvegarde_longueur_definitions_chainees =
1085: (*s_etat_processus).longueur_definitions_chainees;
1086:
1087: tampon = (unsigned char *) malloc(
1088: (((*s_etat_processus).longueur_definitions_chainees
1089: = strlen((*s_etat_processus).instruction_courante)
1090: + 4) + 1) * sizeof(unsigned char));
1091:
1092: if (tampon == NULL)
1093: {
1094: (*s_etat_processus).erreur_systeme =
1095: d_es_allocation_memoire;
1096: (*s_etat_processus).traitement_interruptible =
1097: registre_interruption;
1098: return;
1099: }
1100:
1101: strcpy(tampon, "<< ");
1102: ptr_ecriture = tampon + 3;
1103: ptr_lecture = (*s_etat_processus).instruction_courante + 1;
1104:
1105: while((*ptr_lecture) != d_code_fin_chaine)
1106: {
1107: *ptr_ecriture++ = *ptr_lecture++;
1108: }
1109:
1110: (*(--ptr_ecriture)) = d_code_fin_chaine;
1111: strcat(ptr_ecriture, " >>");
1112:
1113: position_courante = (*s_etat_processus).position_courante;
1114: (*s_etat_processus).position_courante = 0;
1115:
1116: profondeur_initiale = (*s_etat_processus)
1117: .hauteur_pile_operationnelle;
1118:
1119: /*
1120: -- On met le tout dans la pile opérationnelle ----------------------------------
1121: */
1122:
1123: (*s_etat_processus).niveau_recursivite++;
1124: definitions_chainees_precedentes = (*s_etat_processus)
1125: .definitions_chainees;
1126: (*s_etat_processus).definitions_chainees = tampon;
1127:
1128: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
1129: sauvegarde_niveau_courant = (*s_etat_processus)
1130: .niveau_courant;
1131:
1132: (*s_etat_processus).l_base_pile_systeme = NULL;
1133: empilement_pile_systeme(s_etat_processus);
1134:
1135: if ((*s_etat_processus).erreur_systeme != d_es)
1136: {
1137: (*s_etat_processus).traitement_interruptible =
1138: registre_interruption;
1139: return;
1140: }
1141:
1142: (*(*s_etat_processus).l_base_pile_systeme)
1143: .retour_definition = 'Y';
1144: (*s_etat_processus).niveau_courant = 0;
1145: (*s_etat_processus).autorisation_empilement_programme = 'N';
1146: registre_mode_execution_programme =
1147: (*s_etat_processus).mode_execution_programme;
1148: (*s_etat_processus).mode_execution_programme = 'Y';
1149: (*s_etat_processus).erreur_scrutation = d_faux;
1150:
1151: tampon = (*s_etat_processus).instruction_courante;
1152: nombre_lignes_a_supprimer =
1153: (*s_etat_processus).hauteur_pile_operationnelle;
1154:
1155: if ((*s_etat_processus).profilage == d_vrai)
1156: {
1157: profilage(s_etat_processus, "RPL/2 internals");
1158:
1159: if ((*s_etat_processus).erreur_systeme != d_es)
1160: {
1161: return;
1162: }
1163: }
1164:
1165: if (sequenceur(s_etat_processus) == d_erreur)
1166: {
1167: (*s_etat_processus).mode_execution_programme =
1168: registre_mode_execution_programme;
1169: nombre_lignes_a_supprimer =
1170: (*s_etat_processus).hauteur_pile_operationnelle
1171: - nombre_lignes_a_supprimer;
1172:
1173: for(i = 0; i < nombre_lignes_a_supprimer; i++)
1174: {
1175: if (depilement(s_etat_processus,
1176: &((*s_etat_processus).l_base_pile),
1177: &s_sous_objet) == d_erreur)
1178: {
1179: (*s_etat_processus).traitement_interruptible =
1180: registre_interruption;
1181: return;
1182: }
1183:
1184: liberation(s_etat_processus, s_sous_objet);
1185: }
1186:
1187: (*s_etat_processus).instruction_courante = tampon;
1188:
1189: effacement_pile_systeme(s_etat_processus);
1190: (*s_etat_processus).l_base_pile_systeme =
1191: s_sauvegarde_pile;
1192: (*s_etat_processus).niveau_courant =
1193: sauvegarde_niveau_courant;
1194:
1195: (*s_etat_processus).niveau_recursivite--;
1196: free((*s_etat_processus).definitions_chainees);
1197:
1198: (*s_etat_processus).position_courante =
1199: position_courante;
1200: (*s_etat_processus).definitions_chainees =
1201: definitions_chainees_precedentes;
1202: (*s_etat_processus).longueur_definitions_chainees =
1203: sauvegarde_longueur_definitions_chainees;
1204:
1205: free(s_objet);
1206:
1207: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1208: (*s_etat_processus).traitement_interruptible =
1209: registre_interruption;
1210: return;
1211: }
1212:
1213: (*s_etat_processus).mode_execution_programme =
1214: registre_mode_execution_programme;
1215:
1216: if ((*s_etat_processus).erreur_scrutation == d_vrai)
1217: {
1218: nombre_lignes_a_supprimer =
1219: (*s_etat_processus).hauteur_pile_operationnelle
1220: - nombre_lignes_a_supprimer;
1221:
1222: for(i = 0; i < nombre_lignes_a_supprimer; i++)
1223: {
1224: if (depilement(s_etat_processus,
1225: &((*s_etat_processus).l_base_pile),
1226: &s_sous_objet) == d_erreur)
1227: {
1228: (*s_etat_processus).traitement_interruptible =
1229: registre_interruption;
1230: return;
1231: }
1232:
1233: liberation(s_etat_processus, s_sous_objet);
1234: }
1235:
1236: (*s_etat_processus).instruction_courante = tampon;
1237:
1238: effacement_pile_systeme(s_etat_processus);
1239: (*s_etat_processus).l_base_pile_systeme =
1240: s_sauvegarde_pile;
1241: (*s_etat_processus).niveau_courant =
1242: sauvegarde_niveau_courant;
1243:
1244: (*s_etat_processus).niveau_recursivite--;
1245: free((*s_etat_processus).definitions_chainees);
1246:
1247: (*s_etat_processus).position_courante =
1248: position_courante;
1249: (*s_etat_processus).definitions_chainees =
1250: definitions_chainees_precedentes;
1251: (*s_etat_processus).longueur_definitions_chainees =
1252: sauvegarde_longueur_definitions_chainees;
1253:
1254: free(s_objet);
1255:
1256: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1257: (*s_etat_processus).traitement_interruptible =
1258: registre_interruption;
1259: return;
1260: }
1261:
1262: (*s_etat_processus).instruction_courante = tampon;
1263:
1264: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
1265: (*s_etat_processus).niveau_courant =
1266: sauvegarde_niveau_courant;
1267:
1268: (*s_etat_processus).niveau_recursivite--;
1269:
1270: (*s_etat_processus).position_courante = position_courante;
1271: free((*s_etat_processus).definitions_chainees);
1272: (*s_etat_processus).definitions_chainees =
1273: definitions_chainees_precedentes;
1274: (*s_etat_processus).longueur_definitions_chainees =
1275: sauvegarde_longueur_definitions_chainees;
1276:
1277: /*
1278: -- On relit la pile pour remplir le vecteur ------------------------------------
1279: */
1280:
1281: profondeur_finale = (*s_etat_processus)
1282: .hauteur_pile_operationnelle;
1283: nombre_colonnes = profondeur_finale - profondeur_initiale;
1284:
1285: element = (void *) ((struct_vecteur *)
1286: malloc(sizeof(struct_vecteur)));
1287:
1288: if (element == NULL)
1289: {
1290: (*s_etat_processus).erreur_systeme =
1291: d_es_allocation_memoire;
1292: (*s_etat_processus).traitement_interruptible =
1293: registre_interruption;
1294: return;
1295: }
1296:
1297: (*((struct_vecteur *) element)).taille = nombre_colonnes;
1298:
1299: if (drapeau_complexe == d_vrai)
1300: {
1301: (*((struct_vecteur *) element)).tableau = (void *)
1302: ((struct_complexe16 *) malloc(nombre_colonnes *
1303: sizeof(struct_complexe16)));
1304: (*((struct_vecteur *) element)).type = 'C';
1305: }
1306: else if (drapeau_reel == d_vrai)
1307: {
1308: (*((struct_vecteur *) element)).tableau = (void *)
1309: ((real8 *) malloc(nombre_colonnes *
1310: sizeof(real8)));
1311: (*((struct_vecteur *) element)).type = 'R';
1312: }
1313: else
1314: {
1315: (*((struct_vecteur *) element)).tableau = (void *)
1316: ((integer8 *) malloc(nombre_colonnes *
1317: sizeof(integer8)));
1318: (*((struct_vecteur *) element)).type = 'I';
1319: }
1320:
1321: if ((*((struct_vecteur *) element)).tableau == NULL)
1322: {
1323: (*s_etat_processus).erreur_systeme =
1324: d_es_allocation_memoire;
1325: (*s_etat_processus).traitement_interruptible =
1326: registre_interruption;
1327: return;
1328: }
1329:
1330: erreur = d_absence_erreur;
1331: free(s_objet);
1332:
1333: for(i = 0; (i < nombre_colonnes) &&
1334: (erreur == d_absence_erreur); i++)
1335: {
1336: erreur = depilement(s_etat_processus,
1337: &((*s_etat_processus).l_base_pile), &s_objet);
1338:
1339: if (erreur == d_absence_erreur)
1340: {
1341: if (drapeau_complexe == d_vrai)
1342: {
1343: if ((*s_objet).type == CPL)
1344: {
1345: ((struct_complexe16 *) (*((struct_vecteur *)
1346: element)).tableau)[nombre_colonnes
1347: - i - 1] = *((struct_complexe16 *)
1348: ((*s_objet).objet));
1349: }
1350: else if ((*s_objet).type == REL)
1351: {
1352: ((struct_complexe16 *) (*((struct_vecteur *)
1353: element)).tableau)[nombre_colonnes
1354: - i - 1].partie_reelle =
1355: *((real8 *) ((*s_objet).objet));
1356: ((struct_complexe16 *) (*((struct_vecteur *)
1357: element)).tableau)[nombre_colonnes
1358: - i - 1].partie_imaginaire =
1359: (real8) 0;
1360: }
1361: else if ((*s_objet).type == INT)
1362: {
1363: ((struct_complexe16 *) (*((struct_vecteur *)
1364: element)).tableau)[nombre_colonnes
1365: - i - 1].partie_reelle = (real8)
1366: (*((integer8 *) ((*s_objet)
1367: .objet)));
1368: ((struct_complexe16 *) (*((struct_vecteur *)
1369: element)).tableau) [nombre_colonnes
1370: - i - 1].partie_imaginaire =
1371: (real8) 0;
1372: }
1373: else
1374: {
1375: erreur = d_erreur;
1376: }
1377: }
1378: else if (drapeau_reel == d_vrai)
1379: {
1380: if ((*s_objet).type == REL)
1381: {
1382: ((real8 *) (*((struct_vecteur *)
1383: element)).tableau)
1384: [nombre_colonnes - i - 1] =
1385: *((real8 *) ((*s_objet).objet));
1386: }
1387: else if ((*s_objet).type == INT)
1388: {
1389: ((real8 *) (*((struct_vecteur *)
1390: element)).tableau)
1391: [nombre_colonnes - i - 1] =
1392: (real8) (*((integer8 *)
1393: ((*s_objet).objet)));
1394: }
1395: else
1396: {
1397: erreur = d_erreur;
1398: }
1399: }
1400: else
1401: {
1402: if ((*s_objet).type == INT)
1403: {
1404: ((integer8 *) (*((struct_vecteur *)
1405: element)).tableau)
1406: [nombre_colonnes - i - 1] =
1407: *((integer8 *) ((*s_objet).objet));
1408: }
1409: else
1410: {
1411: erreur = d_erreur;
1412: }
1413: }
1414:
1415: liberation(s_etat_processus, s_objet);
1416:
1417: if (erreur == d_erreur)
1418: {
1419: for(i++; i < nombre_colonnes; i++)
1420: {
1421: if (depilement(s_etat_processus,
1422: &((*s_etat_processus).l_base_pile),
1423: &s_objet) == d_erreur)
1424: {
1425: (*s_etat_processus)
1426: .traitement_interruptible =
1427: registre_interruption;
1428: return;
1429: }
1430:
1431: liberation(s_etat_processus, s_objet);
1432: }
1433:
1434: (*s_etat_processus).erreur_execution =
1435: d_ex_syntaxe;
1436:
1437: free((*((struct_vecteur *) element)).tableau);
1438: free(element);
1439:
1440: (*s_etat_processus).traitement_interruptible =
1441: registre_interruption;
1442: return;
1443: }
1444: }
1445: else
1446: {
1447: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
1448: (*s_etat_processus).traitement_interruptible =
1449: registre_interruption;
1450: return;
1451: }
1452: }
1453:
1454: s_objet = (struct_objet *) malloc(sizeof(struct_objet));
1455:
1456: if (s_objet == NULL)
1457: {
1458: (*s_etat_processus).erreur_systeme =
1459: d_es_allocation_memoire;
1460: (*s_etat_processus).traitement_interruptible =
1461: registre_interruption;
1462: return;
1463: }
1464:
1465: initialisation_objet(s_objet);
1466:
1467: if (drapeau_complexe == d_vrai)
1468: {
1469: (*s_objet).type = VCX;
1470: }
1471: else if (drapeau_reel == d_vrai)
1472: {
1473: (*s_objet).type = VRL;
1474: }
1475: else
1476: {
1477: (*s_objet).type = VIN;
1478: }
1479:
1480: break;
1481: }
1482:
1483: /*
1484: --------------------------------------------------------------------------------
1485: Matrice
1486: --------------------------------------------------------------------------------
1487: */
1488:
1489: case d_vrai :
1490: {
1491: nombre_lignes--;
1492:
1493: sauvegarde_longueur_definitions_chainees =
1494: (*s_etat_processus).longueur_definitions_chainees;
1495:
1496: tampon = (unsigned char *) malloc(
1497: (((*s_etat_processus).longueur_definitions_chainees
1498: = strlen((*s_etat_processus).instruction_courante)
1499: + 4) + 1) * sizeof(unsigned char));
1500:
1501: if (tampon == NULL)
1502: {
1503: (*s_etat_processus).erreur_systeme =
1504: d_es_allocation_memoire;
1505: (*s_etat_processus).traitement_interruptible =
1506: registre_interruption;
1507: return;
1508: }
1509:
1510: strcpy(tampon, "<< ");
1511: ptr_ecriture = tampon + 3;
1512: ptr_lecture = (*s_etat_processus).instruction_courante + 1;
1513:
1514: while((*ptr_lecture) != d_code_fin_chaine)
1515: {
1516: *ptr_ecriture++ = *ptr_lecture++;
1517: }
1518:
1519: (*(--ptr_ecriture)) = d_code_fin_chaine;
1520: strcat(ptr_ecriture, " >>");
1521:
1522: position_courante = (*s_etat_processus).position_courante;
1523: (*s_etat_processus).position_courante = 0;
1524:
1525: profondeur_initiale = (*s_etat_processus)
1526: .hauteur_pile_operationnelle;
1527:
1528: /*
1529: -- On met les lignes de la matrice dans la pile opérationnelle -----------------
1530: */
1531:
1532: (*s_etat_processus).niveau_recursivite++;
1533: definitions_chainees_precedentes = (*s_etat_processus)
1534: .definitions_chainees;
1535: (*s_etat_processus).definitions_chainees = tampon;
1536:
1537: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
1538: sauvegarde_niveau_courant = (*s_etat_processus)
1539: .niveau_courant;
1540:
1541: (*s_etat_processus).l_base_pile_systeme = NULL;
1542: empilement_pile_systeme(s_etat_processus);
1543:
1544: if ((*s_etat_processus).erreur_systeme != d_es)
1545: {
1546: (*s_etat_processus).traitement_interruptible =
1547: registre_interruption;
1548: return;
1549: }
1550:
1551: (*(*s_etat_processus).l_base_pile_systeme)
1552: .retour_definition = 'Y';
1553: (*s_etat_processus).niveau_courant = 0;
1554: (*s_etat_processus).autorisation_empilement_programme = 'N';
1555: registre_mode_execution_programme =
1556: (*s_etat_processus).mode_execution_programme;
1557: (*s_etat_processus).mode_execution_programme = 'Y';
1558: (*s_etat_processus).erreur_scrutation = d_faux;
1559:
1560: tampon = (*s_etat_processus).instruction_courante;
1561: nombre_lignes_a_supprimer =
1562: (*s_etat_processus).hauteur_pile_operationnelle;
1563:
1564: if ((*s_etat_processus).profilage == d_vrai)
1565: {
1566: profilage(s_etat_processus, "RPL/2 internals");
1567:
1568: if ((*s_etat_processus).erreur_systeme != d_es)
1569: {
1570: return;
1571: }
1572: }
1573:
1574: if (sequenceur(s_etat_processus) == d_erreur)
1575: {
1576: (*s_etat_processus).mode_execution_programme =
1577: registre_mode_execution_programme;
1578: nombre_lignes_a_supprimer =
1579: (*s_etat_processus).hauteur_pile_operationnelle
1580: - nombre_lignes_a_supprimer;
1581:
1582: for(i = 0; i < nombre_lignes_a_supprimer; i++)
1583: {
1584: if (depilement(s_etat_processus,
1585: &((*s_etat_processus).l_base_pile),
1586: &s_sous_objet) == d_erreur)
1587: {
1588: (*s_etat_processus).traitement_interruptible =
1589: registre_interruption;
1590: return;
1591: }
1592:
1593: liberation(s_etat_processus, s_sous_objet);
1594: }
1595:
1596: (*s_etat_processus).instruction_courante = tampon;
1597:
1598: effacement_pile_systeme(s_etat_processus);
1599: (*s_etat_processus).l_base_pile_systeme =
1600: s_sauvegarde_pile;
1601: (*s_etat_processus).niveau_courant =
1602: sauvegarde_niveau_courant;
1603:
1604: free((*s_etat_processus).definitions_chainees);
1605: (*s_etat_processus).niveau_recursivite--;
1606:
1607: (*s_etat_processus).definitions_chainees =
1608: definitions_chainees_precedentes;
1609: (*s_etat_processus).longueur_definitions_chainees =
1610: sauvegarde_longueur_definitions_chainees;
1611:
1612: (*s_etat_processus).position_courante =
1613: position_courante;
1614:
1615: free(s_objet);
1616:
1617: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1618: (*s_etat_processus).traitement_interruptible =
1619: registre_interruption;
1620: return;
1621: }
1622:
1623: (*s_etat_processus).mode_execution_programme =
1624: registre_mode_execution_programme;
1625:
1626: if ((*s_etat_processus).erreur_scrutation == d_vrai)
1627: {
1628: nombre_lignes_a_supprimer =
1629: (*s_etat_processus).hauteur_pile_operationnelle
1630: - nombre_lignes_a_supprimer;
1631:
1632: for(i = 0; i < nombre_lignes_a_supprimer; i++)
1633: {
1634: if (depilement(s_etat_processus,
1635: &((*s_etat_processus).l_base_pile),
1636: &s_sous_objet) == d_erreur)
1637: {
1638: (*s_etat_processus).traitement_interruptible =
1639: registre_interruption;
1640: return;
1641: }
1642:
1643: liberation(s_etat_processus, s_sous_objet);
1644: }
1645:
1646: (*s_etat_processus).instruction_courante = tampon;
1647:
1648: effacement_pile_systeme(s_etat_processus);
1649: (*s_etat_processus).l_base_pile_systeme =
1650: s_sauvegarde_pile;
1651: (*s_etat_processus).niveau_courant =
1652: sauvegarde_niveau_courant;
1653:
1654: free((*s_etat_processus).definitions_chainees);
1655: (*s_etat_processus).niveau_recursivite--;
1656:
1657: (*s_etat_processus).definitions_chainees =
1658: definitions_chainees_precedentes;
1659: (*s_etat_processus).longueur_definitions_chainees =
1660: sauvegarde_longueur_definitions_chainees;
1661:
1662: (*s_etat_processus).position_courante =
1663: position_courante;
1664:
1665: free(s_objet);
1666:
1667: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1668: (*s_etat_processus).traitement_interruptible =
1669: registre_interruption;
1670: return;
1671: }
1672:
1673: (*s_etat_processus).instruction_courante = tampon;
1674:
1675: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
1676: (*s_etat_processus).niveau_courant =
1677: sauvegarde_niveau_courant;
1678:
1679: free((*s_etat_processus).definitions_chainees);
1680: (*s_etat_processus).definitions_chainees =
1681: definitions_chainees_precedentes;
1682: (*s_etat_processus).longueur_definitions_chainees =
1683: sauvegarde_longueur_definitions_chainees;
1684:
1685: (*s_etat_processus).niveau_recursivite--;
1686:
1687: (*s_etat_processus).position_courante = position_courante;
1688:
1689: /*
1690: -- On relit la pile qui contient des objets "vecteurs" contenant les -----------
1691: -- lignes de la matrice --------------------------------------------------------
1692: */
1693:
1694: profondeur_finale = (*s_etat_processus)
1695: .hauteur_pile_operationnelle;
1696:
1697: nombre_lignes = profondeur_finale - profondeur_initiale;
1698:
1699: element = (void *) ((struct_matrice *) malloc(
1700: sizeof(struct_matrice)));
1701:
1702: if (element == NULL)
1703: {
1704: (*s_etat_processus).erreur_systeme =
1705: d_es_allocation_memoire;
1706: (*s_etat_processus).traitement_interruptible =
1707: registre_interruption;
1708: return;
1709: }
1710:
1711: (*((struct_matrice *) element))
1712: .nombre_lignes = nombre_lignes;
1713: (*((struct_matrice *) element)).nombre_colonnes =
1714: (*((struct_vecteur *) ((*(*(*s_etat_processus)
1715: .l_base_pile).donnee).objet))).taille;
1716: nombre_colonnes = (*((struct_matrice *)
1717: element)).nombre_colonnes;
1718:
1719: l_element_courant = (*s_etat_processus).l_base_pile;
1720:
1721: drapeau_complexe = d_faux;
1722: drapeau_reel = d_faux;
1723: erreur = d_absence_erreur;
1724:
1725: for(i = 0; i < nombre_lignes; i++)
1726: {
1727: if (nombre_colonnes != (*((struct_vecteur *)
1728: (*(*l_element_courant).donnee).objet)).taille)
1729: {
1730: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
1731:
1732: for(j = 0; j < nombre_lignes; j++)
1733: {
1734: if (depilement(s_etat_processus,
1735: &((*s_etat_processus).l_base_pile),
1736: &s_sous_objet) == d_erreur)
1737: {
1738: (*s_etat_processus)
1739: .traitement_interruptible =
1740: registre_interruption;
1741: return;
1742: }
1743:
1744: liberation(s_etat_processus, s_sous_objet);
1745: }
1746:
1747: free(element);
1748: free(s_objet);
1749:
1750: (*s_etat_processus).traitement_interruptible =
1751: registre_interruption;
1752: return;
1753: }
1754:
1755: if ((*(*l_element_courant)
1756: .donnee).type == VRL)
1757: {
1758: drapeau_reel = d_vrai;
1759: }
1760: else if ((*(*l_element_courant)
1761: .donnee).type == VCX)
1762: {
1763: drapeau_complexe = d_vrai;
1764: }
1765:
1766: l_element_courant = (*l_element_courant).suivant;
1767: }
1768:
1769: free(s_objet);
1770:
1771: if ((*s_etat_processus).erreur_execution == d_ex)
1772: {
1773: if (drapeau_complexe == d_vrai)
1774: {
1775: if (((*((struct_matrice *) element)).tableau =
1776: (void **) ((struct_complexe16 **)
1777: malloc(nombre_lignes * sizeof(
1778: struct_complexe16 *)))) == NULL)
1779: {
1780: (*s_etat_processus).erreur_systeme =
1781: d_es_allocation_memoire;
1782: (*s_etat_processus).traitement_interruptible =
1783: registre_interruption;
1784: return;
1785: }
1786:
1787: (*((struct_matrice *) element)).type = 'C';
1788:
1789: for(i = 0; i < nombre_lignes; i++)
1790: {
1791: if ((((*((struct_matrice *)
1792: element)).tableau)[i] = (void *)
1793: ((struct_complexe16 *)
1794: malloc(nombre_colonnes * sizeof(
1795: struct_complexe16)))) == NULL)
1796: {
1797: (*s_etat_processus).erreur_systeme =
1798: d_es_allocation_memoire;
1799: (*s_etat_processus)
1800: .traitement_interruptible =
1801: registre_interruption;
1802: return;
1803: }
1804: }
1805: }
1806: else if (drapeau_reel == d_vrai)
1807: {
1808: if (((*((struct_matrice *) element)).tableau =
1809: (void **) ((real8 **)
1810: malloc(nombre_lignes * sizeof(real8 *))))
1811: == NULL)
1812: {
1813: (*s_etat_processus).erreur_systeme =
1814: d_es_allocation_memoire;
1815: (*s_etat_processus).traitement_interruptible =
1816: registre_interruption;
1817: return;
1818: }
1819:
1820: (*((struct_matrice *) element)).type = 'R';
1821:
1822: for(i = 0; i < nombre_lignes; i++)
1823: {
1824: if ((((*((struct_matrice *)element)).tableau)[i]
1825: = (void *) ((real8 *)
1826: malloc(nombre_colonnes *
1827: sizeof(real8)))) == NULL)
1828: {
1829: (*s_etat_processus).erreur_systeme =
1830: d_es_allocation_memoire;
1831: (*s_etat_processus)
1832: .traitement_interruptible =
1833: registre_interruption;
1834: return;
1835: }
1836: }
1837: }
1838: else
1839: {
1840: if (((*((struct_matrice *) element)).tableau =
1841: (void **) ((integer8 **)
1842: malloc(nombre_lignes *
1843: sizeof(integer8 *)))) == NULL)
1844: {
1845: (*s_etat_processus).erreur_systeme =
1846: d_es_allocation_memoire;
1847: (*s_etat_processus).traitement_interruptible =
1848: registre_interruption;
1849: return;
1850: }
1851:
1852: (*((struct_matrice *) element)).type = 'I';
1853:
1854: for(i = 0; i < nombre_lignes; i++)
1855: {
1856: if ((((*((struct_matrice *)
1857: element)).tableau)[i] = (void *)
1858: ((integer8 *)
1859: malloc(nombre_colonnes *
1860: sizeof(integer8)))) == NULL)
1861: {
1862: (*s_etat_processus).erreur_systeme =
1863: d_es_allocation_memoire;
1864: (*s_etat_processus)
1865: .traitement_interruptible =
1866: registre_interruption;
1867: return;
1868: }
1869: }
1870: }
1871:
1872: for(i = 0; i < nombre_lignes; i++)
1873: {
1874: if (depilement(s_etat_processus,
1875: &((*s_etat_processus)
1876: .l_base_pile), &s_objet) ==
1877: d_absence_erreur)
1878: {
1879: if (drapeau_complexe == d_vrai)
1880: {
1881: if ((*s_objet).type == VCX)
1882: {
1883: for(j = 0; j < nombre_colonnes; j++)
1884: {
1885: ((struct_complexe16 **) ((*(
1886: (struct_matrice *) element))
1887: .tableau))[nombre_lignes - i
1888: - 1][j] =
1889: ((struct_complexe16 *)
1890: (*((struct_vecteur *)
1891: (*s_objet).objet))
1892: .tableau)[j];
1893: }
1894: }
1895: else if ((*s_objet).type == VRL)
1896: {
1897: for(j = 0; j < nombre_colonnes; j++)
1898: {
1899: (((struct_complexe16 **) ((*(
1900: (struct_matrice *) element))
1901: .tableau))[nombre_lignes - i
1902: - 1][j]).partie_reelle =
1903: ((real8 *) (*(
1904: (struct_vecteur *)
1905: (*s_objet).objet))
1906: .tableau)[j];
1907: (((struct_complexe16 **) ((*(
1908: (struct_matrice *) element))
1909: .tableau))[nombre_lignes - i
1910: - 1][j]).partie_imaginaire =
1911: (real8) 0;
1912: }
1913: }
1914: else if ((*s_objet).type == VIN)
1915: {
1916: for(j = 0; j < nombre_colonnes; j++)
1917: {
1918: (((struct_complexe16 **) ((*(
1919: (struct_matrice *) element))
1920: .tableau))[nombre_lignes - i
1921: - 1][j]).partie_reelle =
1922: (real8) ((integer8 *)
1923: (*((struct_vecteur *)
1924: (*s_objet).objet)).tableau)
1925: [j];
1926: (((struct_complexe16 **) ((*(
1927: (struct_matrice *) element))
1928: .tableau))[nombre_lignes - i
1929: - 1][j]).partie_imaginaire =
1930: (real8) 0;
1931: }
1932: }
1933: else
1934: {
1935: erreur = d_erreur;
1936: }
1937: }
1938: else if (drapeau_reel == d_vrai)
1939: {
1940: if ((*s_objet).type == VRL)
1941: {
1942: for(j = 0; j < nombre_colonnes; j++)
1943: {
1944: ((real8 **) ((*((struct_matrice *)
1945: element)).tableau))
1946: [nombre_lignes - i - 1][j] =
1947: ((real8 *) (*(
1948: (struct_vecteur *)
1949: (*s_objet).objet)).tableau)
1950: [j];
1951: }
1952: }
1953: else if ((*s_objet).type == VIN)
1954: {
1955: for(j = 0; j < nombre_colonnes; j++)
1956: {
1957: ((real8 **) ((*((struct_matrice *)
1958: element)).tableau))
1959: [nombre_lignes - i - 1][j] =
1960: (real8) ((integer8 *)
1961: (*((struct_vecteur *)
1962: (*s_objet).objet)).tableau)
1963: [j];
1964: }
1965: }
1966: else
1967: {
1968: erreur = d_erreur;
1969: }
1970: }
1971: else
1972: {
1973: if ((*s_objet).type == VIN)
1974: {
1975: for(j = 0; j < nombre_colonnes; j++)
1976: {
1977: ((integer8 **)
1978: ((*((struct_matrice *)
1979: element)).tableau))
1980: [nombre_lignes - i - 1][j] =
1981: ((integer8 *)
1982: (*((struct_vecteur *)
1983: (*s_objet)
1984: .objet)).tableau)[j];
1985: }
1986: }
1987: else
1988: {
1989: erreur = d_erreur;
1990: }
1991: }
1992:
1993: liberation(s_etat_processus, s_objet);
1994:
1995: if (erreur == d_erreur)
1996: {
1997: for(i++; i < nombre_lignes; i++)
1998: {
1999: if (depilement(s_etat_processus,
2000: &((*s_etat_processus)
2001: .l_base_pile), &s_objet)
2002: == d_erreur)
2003: {
2004: (*s_etat_processus)
2005: .traitement_interruptible =
2006: registre_interruption;
2007: return;
2008: }
2009:
2010: liberation(s_etat_processus, s_objet);
2011: }
2012:
2013: (*s_etat_processus).erreur_execution =
2014: d_ex_syntaxe;
2015:
2016: for(j = 0; j < (*((struct_matrice *)
2017: element)).nombre_lignes; j++)
2018: {
2019: free((*((struct_matrice *) element))
2020: .tableau[j]);
2021: }
2022:
2023: free((*((struct_matrice *) element))
2024: .tableau);
2025: free(element);
2026:
2027: (*s_etat_processus)
2028: .traitement_interruptible =
2029: registre_interruption;
2030: return;
2031: }
2032: }
2033: else
2034: {
2035: (*s_etat_processus).erreur_systeme =
2036: d_es_pile_vide;
2037: (*s_etat_processus).traitement_interruptible =
2038: registre_interruption;
2039: return;
2040: }
2041: }
2042:
2043: s_objet = (struct_objet *) malloc(sizeof(struct_objet));
2044:
2045: if (s_objet == NULL)
2046: {
2047: (*s_etat_processus).erreur_systeme =
2048: d_es_allocation_memoire;
2049: (*s_etat_processus).traitement_interruptible =
2050: registre_interruption;
2051: return;
2052: }
2053:
2054: initialisation_objet(s_objet);
2055:
2056: if (drapeau_complexe == d_vrai)
2057: {
2058: (*s_objet).type = MCX;
2059: }
2060: else if (drapeau_reel == d_vrai)
2061: {
2062: (*s_objet).type = MRL;
2063: }
2064: else
2065: {
2066: (*s_objet).type = MIN;
2067: }
2068: }
2069: else
2070: {
2071: if ((*s_etat_processus).langue == 'F')
2072: {
2073: printf("+++Erreur : Matrice %s invalide [%d]\n",
2074: (*s_etat_processus).instruction_courante,
2075: (int) getpid());
2076: }
2077: else
2078: {
2079: printf("+++Error : Invalid %s matrix [%d]\n",
2080: (*s_etat_processus).instruction_courante,
2081: (int) getpid());
2082: }
2083:
2084: fflush(stdout);
2085: }
2086:
2087: break;
2088: }
2089: }
2090:
2091: break;
2092: }
2093:
2094: /*
2095: --------------------------------------------------------------------------------
2096: Liste
2097: --------------------------------------------------------------------------------
2098: */
2099:
2100: case '{' :
2101: {
2102: sauvegarde_longueur_definitions_chainees =
2103: (*s_etat_processus).longueur_definitions_chainees;
2104:
2105: tampon = (unsigned char *) malloc(
2106: (((*s_etat_processus).longueur_definitions_chainees =
2107: strlen((*s_etat_processus).instruction_courante) + 4) + 1)
2108: * sizeof(unsigned char));
2109:
2110: if (tampon == NULL)
2111: {
2112: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2113: (*s_etat_processus).traitement_interruptible =
2114: registre_interruption;
2115: return;
2116: }
2117:
2118: strcpy(tampon, "<< ");
2119: ptr_ecriture = tampon + 3;
2120: ptr_lecture = (*s_etat_processus).instruction_courante + 1;
2121:
2122: while((*ptr_lecture) != d_code_fin_chaine)
2123: {
2124: *ptr_ecriture++ = *ptr_lecture++;
2125: }
2126:
2127: (*(--ptr_ecriture)) = d_code_fin_chaine;
2128: strcat(ptr_ecriture, " >>");
2129:
2130: position_courante = (*s_etat_processus).position_courante;
2131: (*s_etat_processus).position_courante = 0;
2132:
2133: profondeur_initiale = (*s_etat_processus)
2134: .hauteur_pile_operationnelle;
2135:
2136: /*
2137: -- On met le tout dans la pile opérationnelle. ---------------------------------
2138: */
2139:
2140: (*s_etat_processus).niveau_recursivite++;
2141: definitions_chainees_precedentes = (*s_etat_processus)
2142: .definitions_chainees;
2143: (*s_etat_processus).definitions_chainees = tampon;
2144:
2145: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
2146: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;
2147:
2148: (*s_etat_processus).l_base_pile_systeme = NULL;
2149: empilement_pile_systeme(s_etat_processus);
2150:
2151: if ((*s_etat_processus).erreur_systeme != d_es)
2152: {
2153: (*s_etat_processus).traitement_interruptible =
2154: registre_interruption;
2155: return;
2156: }
2157:
2158: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
2159: (*(*s_etat_processus).l_base_pile_systeme)
2160: .origine_routine_evaluation = 'N';
2161: (*s_etat_processus).niveau_courant = 0;
2162: (*s_etat_processus).autorisation_empilement_programme = 'N';
2163:
2164: tampon = (*s_etat_processus).instruction_courante;
2165: autorisation_evaluation_nom = (*s_etat_processus)
2166: .autorisation_evaluation_nom;
2167: (*s_etat_processus).autorisation_evaluation_nom = 'N';
2168:
2169: registre_test = (*s_etat_processus).test_instruction;
2170: (*s_etat_processus).test_instruction = 'Y';
2171: registre_mode_execution_programme =
2172: (*s_etat_processus).mode_execution_programme;
2173: (*s_etat_processus).mode_execution_programme = 'Y';
2174: (*s_etat_processus).erreur_scrutation = d_faux;
2175:
2176: nombre_lignes_a_supprimer =
2177: (*s_etat_processus).hauteur_pile_operationnelle;
2178:
2179: /*
2180: * Vérification de la cohérence des arguments.
2181: * Il doit y avoir autant de '<<' que de '>>' dans
2182: * l'expression candidate.
2183: */
2184:
2185: coherence_liste = 0;
2186: drapeau_chaine = d_faux;
2187:
2188: while((*s_etat_processus).definitions_chainees
2189: [(*s_etat_processus).position_courante] !=
2190: d_code_fin_chaine)
2191: {
2192: if ((*s_etat_processus).definitions_chainees
2193: [(*s_etat_processus).position_courante] == '"')
2194: {
2195: if (drapeau_chaine == d_faux)
2196: {
2197: drapeau_chaine = d_vrai;
2198: }
2199: else
2200: {
2201: drapeau_chaine = d_faux;
2202: }
2203: }
2204: else if (drapeau_chaine == d_faux)
2205: {
2206: if (((*s_etat_processus).definitions_chainees
2207: [(*s_etat_processus).position_courante] == '<') &&
2208: ((*s_etat_processus).definitions_chainees
2209: [(*s_etat_processus).position_courante + 1] == '<'))
2210: {
2211: coherence_liste++;
2212: }
2213: else if (((*s_etat_processus).definitions_chainees
2214: [(*s_etat_processus).position_courante] == '>') &&
2215: ((*s_etat_processus).definitions_chainees
2216: [(*s_etat_processus).position_courante + 1] == '>'))
2217: {
2218: coherence_liste--;
2219: }
2220:
2221: }
2222:
2223: (*s_etat_processus).position_courante++;
2224: }
2225:
2226: (*s_etat_processus).position_courante = 0;
2227:
2228: if ((coherence_liste != 0) || (drapeau_chaine == d_vrai))
2229: {
2230: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2231:
2232: nombre_lignes_a_supprimer =
2233: (*s_etat_processus).hauteur_pile_operationnelle
2234: - nombre_lignes_a_supprimer;
2235:
2236: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2237: {
2238: if (depilement(s_etat_processus, &((*s_etat_processus)
2239: .l_base_pile), &s_sous_objet) == d_erreur)
2240: {
2241: (*s_etat_processus).traitement_interruptible =
2242: registre_interruption;
2243: (*s_etat_processus).mode_execution_programme =
2244: registre_mode_execution_programme;
2245: return;
2246: }
2247:
2248: liberation(s_etat_processus, s_sous_objet);
2249: }
2250:
2251: (*s_etat_processus).test_instruction = registre_test;
2252: (*s_etat_processus).longueur_definitions_chainees =
2253: sauvegarde_longueur_definitions_chainees;
2254:
2255: (*s_etat_processus).instruction_courante = tampon;
2256: (*s_etat_processus).autorisation_evaluation_nom =
2257: autorisation_evaluation_nom;
2258:
2259: effacement_pile_systeme(s_etat_processus);
2260: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
2261: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
2262:
2263: free((*s_etat_processus).definitions_chainees);
2264: free(s_objet);
2265:
2266: (*s_etat_processus).definitions_chainees =
2267: definitions_chainees_precedentes;
2268:
2269: (*s_etat_processus).niveau_recursivite--;
2270:
2271: (*s_etat_processus).position_courante = position_courante;
2272:
2273: (*s_etat_processus).traitement_interruptible =
2274: registre_interruption;
2275: (*s_etat_processus).mode_execution_programme =
2276: registre_mode_execution_programme;
2277: return;
2278: }
2279:
2280: /*
2281: * Scrutation de la séquence.
2282: */
2283:
2284: (*s_etat_processus).position_courante = 0;
2285:
2286: if ((*s_etat_processus).profilage == d_vrai)
2287: {
2288: profilage(s_etat_processus, "RPL/2 internals");
2289:
2290: if ((*s_etat_processus).erreur_systeme != d_es)
2291: {
2292: return;
2293: }
2294: }
2295:
2296: if (sequenceur(s_etat_processus) == d_erreur)
2297: {
2298: (*s_etat_processus).mode_execution_programme =
2299: registre_mode_execution_programme;
2300: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2301:
2302: nombre_lignes_a_supprimer =
2303: (*s_etat_processus).hauteur_pile_operationnelle
2304: - nombre_lignes_a_supprimer;
2305:
2306: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2307: {
2308: if (depilement(s_etat_processus, &((*s_etat_processus)
2309: .l_base_pile), &s_sous_objet) == d_erreur)
2310: {
2311: (*s_etat_processus).traitement_interruptible =
2312: registre_interruption;
2313: return;
2314: }
2315:
2316: liberation(s_etat_processus, s_sous_objet);
2317: }
2318:
2319: (*s_etat_processus).test_instruction = registre_test;
2320: (*s_etat_processus).longueur_definitions_chainees =
2321: sauvegarde_longueur_definitions_chainees;
2322:
2323: (*s_etat_processus).instruction_courante = tampon;
2324: (*s_etat_processus).autorisation_evaluation_nom =
2325: autorisation_evaluation_nom;
2326:
2327: effacement_pile_systeme(s_etat_processus);
2328: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
2329: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
2330:
2331: free((*s_etat_processus).definitions_chainees);
2332: free(s_objet);
2333:
2334: (*s_etat_processus).definitions_chainees =
2335: definitions_chainees_precedentes;
2336:
2337: (*s_etat_processus).niveau_recursivite--;
2338:
2339: (*s_etat_processus).position_courante = position_courante;
2340:
2341: (*s_etat_processus).traitement_interruptible =
2342: registre_interruption;
2343: return;
2344: }
2345:
2346: (*s_etat_processus).mode_execution_programme =
2347: registre_mode_execution_programme;
2348:
2349: if ((*s_etat_processus).erreur_scrutation == d_vrai)
2350: {
2351: nombre_lignes_a_supprimer =
2352: (*s_etat_processus).hauteur_pile_operationnelle
2353: - nombre_lignes_a_supprimer;
2354:
2355: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2356: {
2357: if (depilement(s_etat_processus, &((*s_etat_processus)
2358: .l_base_pile), &s_sous_objet) == d_erreur)
2359: {
2360: (*s_etat_processus).traitement_interruptible =
2361: registre_interruption;
2362: return;
2363: }
2364:
2365: liberation(s_etat_processus, s_sous_objet);
2366: }
2367:
2368: (*s_etat_processus).test_instruction = registre_test;
2369: (*s_etat_processus).longueur_definitions_chainees =
2370: sauvegarde_longueur_definitions_chainees;
2371:
2372: (*s_etat_processus).instruction_courante = tampon;
2373: (*s_etat_processus).autorisation_evaluation_nom =
2374: autorisation_evaluation_nom;
2375:
2376: effacement_pile_systeme(s_etat_processus);
2377: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
2378: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
2379:
2380: free((*s_etat_processus).definitions_chainees);
2381: free(s_objet);
2382:
2383: (*s_etat_processus).definitions_chainees =
2384: definitions_chainees_precedentes;
2385:
2386: (*s_etat_processus).niveau_recursivite--;
2387: (*s_etat_processus).position_courante = position_courante;
2388:
2389: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2390: (*s_etat_processus).traitement_interruptible =
2391: registre_interruption;
2392: return;
2393: }
2394:
2395: (*s_etat_processus).test_instruction = registre_test;
2396: (*s_etat_processus).longueur_definitions_chainees =
2397: sauvegarde_longueur_definitions_chainees;
2398:
2399: (*s_etat_processus).instruction_courante = tampon;
2400: (*s_etat_processus).autorisation_evaluation_nom =
2401: autorisation_evaluation_nom;
2402:
2403: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
2404: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
2405:
2406: free((*s_etat_processus).definitions_chainees);
2407: (*s_etat_processus).definitions_chainees =
2408: definitions_chainees_precedentes;
2409:
2410: (*s_etat_processus).niveau_recursivite--;
2411:
2412: (*s_etat_processus).position_courante = position_courante;
2413:
2414: /*
2415: -- Relecture de la pile opérationnelle -----------------------------------------
2416: */
2417:
2418: profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle;
2419:
2420: l_element_courant = NULL;
2421:
2422: free(s_objet);
2423:
2424: for(i = 0; i < (profondeur_finale - profondeur_initiale); i++)
2425: {
2426: if (depilement(s_etat_processus,
2427: &((*s_etat_processus).l_base_pile),
2428: &s_objet) == d_erreur)
2429: {
2430: (*s_etat_processus).traitement_interruptible =
2431: registre_interruption;
2432: return;
2433: }
2434:
2435: if (empilement(s_etat_processus, &l_element_courant,
2436: s_objet) == d_erreur)
2437: {
2438: (*s_etat_processus).traitement_interruptible =
2439: registre_interruption;
2440: return;
2441: }
2442: }
2443:
2444: s_objet = (struct_objet *) malloc(sizeof(struct_objet));
2445:
2446: if (s_objet == NULL)
2447: {
2448: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2449: (*s_etat_processus).traitement_interruptible =
2450: registre_interruption;
2451: return;
2452: }
2453:
2454: initialisation_objet(s_objet);
2455: (*s_objet).type = LST;
2456: element = (void *) l_element_courant;
2457:
2458: break;
2459: }
2460:
2461: /*
2462: --------------------------------------------------------------------------------
2463: Nom ou expression algébrique
2464: --------------------------------------------------------------------------------
2465: */
2466:
2467: case '\'' :
2468: {
2469: if ((tampon = analyse_algebrique(s_etat_processus,
2470: (*s_etat_processus).instruction_courante,
2471: &l_base_liste_fonctions)) == NULL)
2472: {
2473: /*
2474: * L'erreur est de type exécution ou système.
2475: * Dans le doute, on libère *s_objet.
2476: */
2477:
2478: while(l_base_liste_fonctions != NULL)
2479: {
2480: l_element_courant_fonctions = l_base_liste_fonctions;
2481: l_base_liste_fonctions = (*l_base_liste_fonctions).suivant;
2482:
2483: free((*((struct_fonction *) (*l_element_courant_fonctions)
2484: .donnee)).nom_fonction);
2485: free((struct_fonction *) (*l_element_courant_fonctions)
2486: .donnee);
2487: free(l_element_courant_fonctions);
2488: }
2489:
2490: free(s_objet);
2491:
2492: (*s_etat_processus).traitement_interruptible =
2493: registre_interruption;
2494: return;
2495: }
2496:
2497: l_base_liste_decomposition = analyse_rpn(s_etat_processus, tampon);
2498: l_element_courant = l_base_liste_decomposition;
2499: nombre_elements = 0;
2500:
2501: while(l_element_courant != NULL)
2502: {
2503: nombre_elements++;
2504: l_element_courant = (*l_element_courant).suivant;
2505: }
2506:
2507: if (nombre_elements == 3)
2508: {
2509: free(tampon);
2510:
2511: (*s_objet).type = (*(*(*l_base_liste_decomposition)
2512: .suivant).donnee).type;
2513: element = (void *) (*(*(*l_base_liste_decomposition)
2514: .suivant).donnee).objet;
2515:
2516: if ((*s_objet).type == NOM)
2517: {
2518: (*((struct_nom *) (*(*(*l_base_liste_decomposition)
2519: .suivant).donnee).objet)).symbole = d_vrai;
2520: }
2521: else if ((*s_objet).type == FCT)
2522: {
2523: /*
2524: * On essaye de mettre d'utiliser une fonction
2525: * comme un nom... On convertit la fonction en nom
2526: * puis on renvoie une erreur.
2527: */
2528:
2529: free(s_objet);
2530:
2531: l_element_courant = l_base_liste_decomposition;
2532:
2533: while(l_element_courant != NULL)
2534: {
2535: liberation(s_etat_processus,
2536: (*l_element_courant).donnee);
2537: l_element_precedent = l_element_courant;
2538: l_element_courant = (*l_element_courant).suivant;
2539: free(l_element_precedent);
2540: }
2541:
2542: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2543: (*s_etat_processus).traitement_interruptible =
2544: registre_interruption;
2545: return;
2546: }
2547:
2548: l_element_precedent = l_base_liste_decomposition;
2549: l_element_courant = (*l_element_precedent).suivant;
2550: liberation(s_etat_processus, (*l_element_precedent).donnee);
2551: free(l_element_precedent);
2552: l_element_precedent = l_element_courant;
2553: l_element_courant = (*l_element_courant).suivant;
2554: free((*l_element_precedent).donnee);
2555: free(l_element_precedent);
2556: liberation(s_etat_processus, (*l_element_courant).donnee);
2557: free(l_element_courant);
2558: }
2559: else
2560: {
2561: (*s_objet).type = ALG;
2562:
2563: if ((*s_etat_processus).debug == d_vrai)
2564: if (((*s_etat_processus).type_debug &
2565: d_debug_variables) != 0)
2566: {
2567: if ((*s_etat_processus).langue == 'F')
2568: {
2569: printf("[%d] Conversion de l'expression en "
2570: "notation polonaise inversée\n%s\n",
2571: (int) getpid(), tampon);
2572: }
2573: else
2574: {
2575: printf("[%d] Translation of expression "
2576: "into reverse polish notation\n%s",
2577: (int) getpid(), tampon);
2578: }
2579:
2580: fflush(stdout);
2581: }
2582:
2583: element = (void *) l_base_liste_decomposition;
2584: free(tampon);
2585:
2586: if (element == NULL)
2587: {
2588: (*s_etat_processus).erreur_execution =
2589: d_ex_expression_invalide;
2590: (*s_etat_processus).traitement_interruptible =
2591: registre_interruption;
2592: return;
2593: }
2594:
2595: l_element_courant = (struct_liste_chainee *) element;
2596:
2597: while(l_element_courant != NULL)
2598: {
2599: if ((*(*l_element_courant).donnee).type == FCT)
2600: {
2601: /*
2602: * Si la fonction est intrinsèque au langage,
2603: * elle est convertie en majuscules.
2604: */
2605:
2606: tampon = conversion_majuscule((*((struct_fonction *)
2607: (*(*l_element_courant).donnee).objet))
2608: .nom_fonction);
2609:
2610: free((*((struct_fonction *)
2611: (*(*l_element_courant).donnee).objet))
2612: .nom_fonction);
2613:
2614: (*((struct_fonction *) (*(*l_element_courant).donnee)
2615: .objet)).nom_fonction = tampon;
2616:
2617: if (strcmp(tampon, "=") == 0)
2618: {
2619: nombre_egalites++;
2620: }
2621: }
2622:
2623: l_element_courant = (*l_element_courant).suivant;
2624: }
2625:
2626: l_element_courant = (struct_liste_chainee *) element;
2627:
2628: while(l_element_courant != NULL)
2629: {
2630: if (((*(*l_element_courant).donnee).type == FCT)
2631: || ((*(*l_element_courant).donnee).type == NOM))
2632: {
2633: if ((*(*l_element_courant).donnee).type == FCT)
2634: {
2635: if (l_base_liste_fonctions != NULL)
2636: {
2637: l_element_courant_fonctions =
2638: l_base_liste_fonctions;
2639:
2640: while(l_element_courant_fonctions != NULL)
2641: {
2642: if ((fonction_majuscule =
2643: conversion_majuscule(
2644: (*((struct_fonction *)
2645: ((*l_element_courant_fonctions)
2646: .donnee))).nom_fonction)) == NULL)
2647: {
2648: (*s_etat_processus).erreur_systeme =
2649: d_es_allocation_memoire;
2650: (*s_etat_processus)
2651: .traitement_interruptible =
2652: registre_interruption;
2653: return;
2654: }
2655:
2656: if (strcmp(fonction_majuscule,
2657: (*((struct_fonction *)
2658: (*(*l_element_courant).donnee)
2659: .objet)).nom_fonction) == 0)
2660: {
2661: free(fonction_majuscule);
2662: break;
2663: }
2664:
2665: free(fonction_majuscule);
2666: l_element_courant_fonctions =
2667: (*l_element_courant_fonctions)
2668: .suivant;
2669: }
2670:
2671: if (l_element_courant_fonctions != NULL)
2672: {
2673: (*((struct_fonction *)
2674: (*(*l_element_courant)
2675: .donnee).objet)).nombre_arguments =
2676: (*((struct_fonction *)
2677: ((*l_element_courant_fonctions)
2678: .donnee))).nombre_arguments;
2679: }
2680: else
2681: {
2682: (*((struct_fonction *)
2683: (*(*l_element_courant).donnee)
2684: .objet)).nombre_arguments = 0;
2685: }
2686: }
2687: else
2688: {
2689: (*((struct_fonction *)
2690: (*(*l_element_courant).donnee)
2691: .objet)).nombre_arguments = 0;
2692: }
2693: }
2694: else
2695: {
2696: (*((struct_nom *) (*(*l_element_courant).donnee)
2697: .objet)).symbole = d_faux;
2698:
2699: if (l_base_liste_fonctions != NULL)
2700: {
2701: l_element_courant_fonctions =
2702: l_base_liste_fonctions;
2703:
2704: while((strcmp((*((struct_fonction *)
2705: ((*l_element_courant_fonctions)
2706: .donnee))).nom_fonction,
2707: (*((struct_nom *)
2708: (*(*l_element_courant).donnee).objet))
2709: .nom) != 0) &&
2710: ((*l_element_courant_fonctions)
2711: .suivant != NULL))
2712: {
2713: l_element_courant_fonctions =
2714: (*l_element_courant_fonctions)
2715: .suivant;
2716: }
2717:
2718: if (((*l_element_courant_fonctions).suivant !=
2719: NULL) || (strcmp((*((struct_nom *)
2720: (*(*l_element_courant).donnee).objet))
2721: .nom, (*((struct_fonction *)
2722: ((*l_element_courant_fonctions)
2723: .donnee))).nom_fonction) == 0))
2724: {
2725: tampon = (*((struct_nom *)
2726: (*(*l_element_courant)
2727: .donnee).objet)).nom;
2728:
2729: if ((s_sous_objet = (struct_objet *)
2730: malloc(sizeof(
2731: struct_objet))) == NULL)
2732: {
2733: (*s_etat_processus).erreur_systeme =
2734: d_es_allocation_memoire;
2735: (*s_etat_processus)
2736: .traitement_interruptible =
2737: registre_interruption;
2738: return;
2739: }
2740:
2741: initialisation_objet(s_sous_objet);
2742: (*s_sous_objet).type = FCT;
2743:
2744: if (((*s_sous_objet).objet = (void *)
2745: malloc(sizeof(struct_fonction)))
2746: == NULL)
2747: {
2748: (*s_etat_processus).erreur_systeme =
2749: d_es_allocation_memoire;
2750: (*s_etat_processus)
2751: .traitement_interruptible =
2752: registre_interruption;
2753: return;
2754: }
2755:
2756: (*((struct_fonction *) ((*s_sous_objet)
2757: .objet))).nom_fonction = tampon;
2758:
2759: (*((struct_fonction *) ((*s_sous_objet)
2760: .objet))).fonction =
2761: analyse_instruction(
2762: s_etat_processus, tampon);
2763:
2764: (*((struct_fonction *) ((*s_sous_objet)
2765: .objet))).nombre_arguments =
2766: (*((struct_fonction *)
2767: ((*l_element_courant_fonctions)
2768: .donnee))).nombre_arguments;
2769:
2770: free((struct_nom *) (*(*l_element_courant)
2771: .donnee).objet);
2772: free((*l_element_courant).donnee);
2773:
2774: (*l_element_courant).donnee = s_sous_objet;
2775: }
2776: }
2777: }
2778: }
2779:
2780: l_element_courant = (*l_element_courant).suivant;
2781: }
2782: }
2783:
2784: while(l_base_liste_fonctions != NULL)
2785: {
2786: l_element_courant_fonctions = l_base_liste_fonctions;
2787: l_base_liste_fonctions = (*l_base_liste_fonctions).suivant;
2788:
2789: free((*((struct_fonction *) (*l_element_courant_fonctions)
2790: .donnee)).nom_fonction);
2791: free((struct_fonction *) (*l_element_courant_fonctions).donnee);
2792: free(l_element_courant_fonctions);
2793: }
2794:
2795: break;
2796: }
2797:
2798: /*
2799: --------------------------------------------------------------------------------
2800: Chaîne de caractères
2801: --------------------------------------------------------------------------------
2802: */
2803:
2804: case '"' :
2805: {
2806: (*s_objet).type = CHN;
2807:
2808: element = (void *) ((unsigned char *) malloc(
2809: (strlen((*s_etat_processus).instruction_courante) - 1)
2810: * sizeof(unsigned char)));
2811:
2812: if (element == NULL)
2813: {
2814: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2815: (*s_etat_processus).traitement_interruptible =
2816: registre_interruption;
2817: return;
2818: }
2819:
2820: ptr_lecture = (*s_etat_processus).instruction_courante + 1;
2821: ptr_ecriture = (unsigned char *) element;
2822:
2823: while((*ptr_lecture) != d_code_fin_chaine)
2824: {
2825: *ptr_ecriture++ = *ptr_lecture++;
2826: }
2827:
2828: (*(--ptr_ecriture)) = d_code_fin_chaine;
2829:
2830: break;
2831: }
2832:
2833: /*
2834: --------------------------------------------------------------------------------
2835: Définition ou tableau
2836: --------------------------------------------------------------------------------
2837: */
2838:
2839: case '<' :
2840: {
2841: if ((*s_etat_processus).instruction_courante[1] == '[')
2842: {
2843: // Tableau
2844:
2845: sauvegarde_longueur_definitions_chainees =
2846: (*s_etat_processus).longueur_definitions_chainees;
2847:
2848: tampon = (unsigned char *) malloc(
2849: (((*s_etat_processus).longueur_definitions_chainees
2850: = strlen((*s_etat_processus).instruction_courante)
2851: + 2) + 1) * sizeof(unsigned char));
2852:
2853: if (tampon == NULL)
2854: {
2855: (*s_etat_processus).erreur_systeme =
2856: d_es_allocation_memoire;
2857: (*s_etat_processus).traitement_interruptible =
2858: registre_interruption;
2859: return;
2860: }
2861:
2862: strcpy(tampon, "<< ");
2863: ptr_ecriture = tampon + 3;
2864: ptr_lecture = (*s_etat_processus).instruction_courante + 2;
2865:
2866: while((*ptr_lecture) != d_code_fin_chaine)
2867: {
2868: *ptr_ecriture++ = *ptr_lecture++;
2869: }
2870:
2871: ptr_ecriture -= 2;
2872: (*ptr_ecriture) = d_code_fin_chaine;
2873: strcat(ptr_ecriture, " >>");
2874:
2875: position_courante = (*s_etat_processus).position_courante;
2876: (*s_etat_processus).position_courante = 0;
2877:
2878: profondeur_initiale = (*s_etat_processus)
2879: .hauteur_pile_operationnelle;
2880:
2881: /*
2882: -- On met les éléments du tableau dans la pile opérationnelle ------------------
2883: */
2884:
2885: (*s_etat_processus).niveau_recursivite++;
2886: definitions_chainees_precedentes = (*s_etat_processus)
2887: .definitions_chainees;
2888: (*s_etat_processus).definitions_chainees = tampon;
2889:
2890: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
2891: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;
2892:
2893: (*s_etat_processus).l_base_pile_systeme = NULL;
2894: empilement_pile_systeme(s_etat_processus);
2895:
2896: if ((*s_etat_processus).erreur_systeme != d_es)
2897: {
2898: (*s_etat_processus).traitement_interruptible =
2899: registre_interruption;
2900: return;
2901: }
2902:
2903: (*(*s_etat_processus).l_base_pile_systeme)
2904: .retour_definition = 'Y';
2905: (*s_etat_processus).niveau_courant = 0;
2906: (*s_etat_processus).autorisation_empilement_programme = 'N';
2907: registre_mode_execution_programme =
2908: (*s_etat_processus).mode_execution_programme;
2909: (*s_etat_processus).mode_execution_programme = 'Y';
2910: (*s_etat_processus).erreur_scrutation = d_faux;
2911:
2912: tampon = (*s_etat_processus).instruction_courante;
2913: nombre_lignes_a_supprimer =
2914: (*s_etat_processus).hauteur_pile_operationnelle;
2915:
2916: if ((*s_etat_processus).profilage == d_vrai)
2917: {
2918: profilage(s_etat_processus, "RPL/2 internals");
2919:
2920: if ((*s_etat_processus).erreur_systeme != d_es)
2921: {
2922: return;
2923: }
2924: }
2925:
2926: if (sequenceur(s_etat_processus) == d_erreur)
2927: {
2928: (*s_etat_processus).mode_execution_programme =
2929: registre_mode_execution_programme;
2930: nombre_lignes_a_supprimer =
2931: (*s_etat_processus).hauteur_pile_operationnelle
2932: - nombre_lignes_a_supprimer;
2933:
2934: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2935: {
2936: if (depilement(s_etat_processus,
2937: &((*s_etat_processus).l_base_pile),
2938: &s_sous_objet) == d_erreur)
2939: {
2940: (*s_etat_processus).traitement_interruptible =
2941: registre_interruption;
2942: return;
2943: }
2944:
2945: liberation(s_etat_processus, s_sous_objet);
2946: }
2947:
2948: (*s_etat_processus).instruction_courante = tampon;
2949:
2950: effacement_pile_systeme(s_etat_processus);
2951: (*s_etat_processus).l_base_pile_systeme =
2952: s_sauvegarde_pile;
2953: (*s_etat_processus).niveau_courant =
2954: sauvegarde_niveau_courant;
2955:
2956: free((*s_etat_processus).definitions_chainees);
2957: (*s_etat_processus).niveau_recursivite--;
2958:
2959: (*s_etat_processus).definitions_chainees =
2960: definitions_chainees_precedentes;
2961: (*s_etat_processus).longueur_definitions_chainees =
2962: sauvegarde_longueur_definitions_chainees;
2963:
2964: (*s_etat_processus).position_courante =
2965: position_courante;
2966:
2967: free(s_objet);
2968:
2969: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2970: (*s_etat_processus).traitement_interruptible =
2971: registre_interruption;
2972: return;
2973: }
2974:
2975: (*s_etat_processus).mode_execution_programme =
2976: registre_mode_execution_programme;
2977:
2978: if ((*s_etat_processus).erreur_scrutation == d_vrai)
2979: {
2980: nombre_lignes_a_supprimer =
2981: (*s_etat_processus).hauteur_pile_operationnelle
2982: - nombre_lignes_a_supprimer;
2983:
2984: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2985: {
2986: if (depilement(s_etat_processus,
2987: &((*s_etat_processus).l_base_pile),
2988: &s_sous_objet) == d_erreur)
2989: {
2990: (*s_etat_processus).traitement_interruptible =
2991: registre_interruption;
2992: return;
2993: }
2994:
2995: liberation(s_etat_processus, s_sous_objet);
2996: }
2997:
2998: (*s_etat_processus).instruction_courante = tampon;
2999:
3000: effacement_pile_systeme(s_etat_processus);
3001: (*s_etat_processus).l_base_pile_systeme =
3002: s_sauvegarde_pile;
3003: (*s_etat_processus).niveau_courant =
3004: sauvegarde_niveau_courant;
3005:
3006: free((*s_etat_processus).definitions_chainees);
3007: (*s_etat_processus).niveau_recursivite--;
3008:
3009: (*s_etat_processus).definitions_chainees =
3010: definitions_chainees_precedentes;
3011: (*s_etat_processus).longueur_definitions_chainees =
3012: sauvegarde_longueur_definitions_chainees;
3013:
3014: (*s_etat_processus).position_courante =
3015: position_courante;
3016:
3017: free(s_objet);
3018:
3019: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3020: (*s_etat_processus).traitement_interruptible =
3021: registre_interruption;
3022: return;
3023: }
3024:
3025: (*s_etat_processus).instruction_courante = tampon;
3026:
3027: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
3028: (*s_etat_processus).niveau_courant =
3029: sauvegarde_niveau_courant;
3030:
3031: free((*s_etat_processus).definitions_chainees);
3032: (*s_etat_processus).definitions_chainees =
3033: definitions_chainees_precedentes;
3034: (*s_etat_processus).longueur_definitions_chainees =
3035: sauvegarde_longueur_definitions_chainees;
3036:
3037: (*s_etat_processus).niveau_recursivite--;
3038:
3039: (*s_etat_processus).position_courante = position_courante;
3040:
3041: /*
3042: -- On relit la pile qui contient des sous-objets contenant les -----------------
3043: -- éléments du tableau ---------------------------------------------------------
3044: */
3045:
3046: profondeur_finale = (*s_etat_processus)
3047: .hauteur_pile_operationnelle;
3048:
3049: nombre_lignes = profondeur_finale - profondeur_initiale;
3050:
3051: if ((element = malloc(sizeof(struct_tableau))) == NULL)
3052: {
3053: (*s_etat_processus).erreur_systeme =
3054: d_es_allocation_memoire;
3055: (*s_etat_processus).traitement_interruptible =
3056: registre_interruption;
3057: return;
3058: }
3059:
3060: (*((struct_tableau *) element)).nombre_elements = nombre_lignes;
3061:
3062: if (((*((struct_tableau *) element)).elements =
3063: malloc(nombre_lignes * sizeof(struct_objet *))) == NULL)
3064: {
3065: (*s_etat_processus).erreur_systeme =
3066: d_es_allocation_memoire;
3067: (*s_etat_processus).traitement_interruptible =
3068: registre_interruption;
3069: return;
3070: }
3071:
3072: for(i = 1; i <= nombre_lignes; i++)
3073: {
3074: if (depilement(s_etat_processus,
3075: &((*s_etat_processus).l_base_pile),
3076: &s_sous_objet) == d_erreur)
3077: {
3078: (*s_etat_processus).traitement_interruptible =
3079: registre_interruption;
3080: return;
3081: }
3082:
3083: (*((struct_tableau *) element)).elements[nombre_lignes - i]
3084: = s_sous_objet;
3085: }
3086:
3087: (*s_objet).type = TBL;
3088:
3089: (*s_etat_processus).traitement_interruptible =
3090: registre_interruption;
3091: }
3092: else
3093: {
3094: // Définition
3095:
3096: if (strlen((*s_etat_processus).instruction_courante) < 5)
3097: {
3098: free(s_objet);
3099:
3100: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3101: (*s_etat_processus).traitement_interruptible =
3102: registre_interruption;
3103: return;
3104: }
3105:
3106: if ((strncmp((*s_etat_processus).instruction_courante, "<< ", 3)
3107: != 0) && (strcmp((*s_etat_processus)
3108: .instruction_courante, "<<") != 0))
3109: {
3110: free(s_objet);
3111:
3112: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3113: (*s_etat_processus).traitement_interruptible =
3114: registre_interruption;
3115: return;
3116: }
3117:
3118: (*s_objet).type = RPN;
3119:
3120: element = (void *) analyse_rpn(s_etat_processus,
3121: (*s_etat_processus).instruction_courante);
3122:
3123: if (element == NULL)
3124: {
3125: if ((*s_etat_processus).erreur_systeme != d_es)
3126: {
3127: (*s_etat_processus).erreur_systeme =
3128: d_es_allocation_memoire;
3129: }
3130:
3131: free(s_objet);
3132:
3133: (*s_etat_processus).traitement_interruptible =
3134: registre_interruption;
3135: return;
3136: }
3137:
3138: l_element_courant = (struct_liste_chainee *) element;
3139:
3140: while(l_element_courant != NULL)
3141: {
3142: if ((*(*l_element_courant).donnee).type == FCT)
3143: {
3144: if (strcmp((*((struct_fonction *) (*(*l_element_courant)
3145: .donnee).objet)).nom_fonction, "=") == 0)
3146: {
3147: nombre_egalites++;
3148: }
3149: }
3150:
3151: l_element_courant = (*l_element_courant).suivant;
3152: }
3153: }
3154:
3155: break;
3156: }
3157:
3158: /*
3159: --------------------------------------------------------------------------------
3160: Entier ou réel
3161: --------------------------------------------------------------------------------
3162: */
3163:
3164: default :
3165: {
3166: if (((*((*s_etat_processus).instruction_courante)) == '-') ||
3167: ((*((*s_etat_processus).instruction_courante)) == '+') ||
3168: (((*((*s_etat_processus).instruction_courante)) >= '0') &&
3169: ((*((*s_etat_processus).instruction_courante))
3170: <= '9')) || ((*((*s_etat_processus).instruction_courante))
3171: == '.'))
3172: {
3173: drapeau_valeur_entiere = ((*((*s_etat_processus)
3174: .instruction_courante)) != '.') ? d_vrai : d_faux;
3175: drapeau_valeur_reelle = d_vrai;
3176:
3177: nombre_points = 0;
3178: nombre_exposants = 0;
3179:
3180: conversion_format(s_etat_processus,
3181: (*s_etat_processus).instruction_courante);
3182:
3183: ptr = (*s_etat_processus).instruction_courante;
3184:
3185: while((*ptr) != d_code_fin_chaine)
3186: {
3187: switch(*ptr)
3188: {
3189: case '0' :
3190: case '1' :
3191: case '2' :
3192: case '3' :
3193: case '4' :
3194: case '5' :
3195: case '6' :
3196: case '7' :
3197: case '8' :
3198: case '9' :
3199: {
3200: break;
3201: }
3202:
3203: // Ne peut survenir qu'après un 'E', un 'e' ou au
3204: // début de la chaîne.
3205: case '+' :
3206: case '-' :
3207: {
3208: if (ptr > (*s_etat_processus).instruction_courante)
3209: {
3210: if (((*(ptr - 1)) != 'e') &&
3211: ((*(ptr - 1)) != 'E'))
3212: {
3213: drapeau_valeur_entiere = d_faux;
3214: drapeau_valeur_reelle = d_faux;
3215: }
3216: }
3217:
3218: break;
3219: }
3220:
3221: // Ne peut que commencer une chaîne, suivre un
3222: // chiffre ou un signe. Ne peut constituer un
3223: // nombre seul.
3224: case '.' :
3225: {
3226: nombre_points++;
3227:
3228: if (ptr > (*s_etat_processus).instruction_courante)
3229: {
3230: switch(*(ptr - 1))
3231: {
3232: case '+' :
3233: case '-' :
3234: case '0' :
3235: case '1' :
3236: case '2' :
3237: case '3' :
3238: case '4' :
3239: case '5' :
3240: case '6' :
3241: case '7' :
3242: case '8' :
3243: case '9' :
3244: {
3245: drapeau_valeur_entiere = d_faux;
3246: break;
3247: }
3248:
3249: default :
3250: {
3251: drapeau_valeur_entiere = d_faux;
3252: drapeau_valeur_reelle = d_faux;
3253: break;
3254: }
3255: }
3256: }
3257: else
3258: {
3259: if ((*(ptr + 1)) == d_code_fin_chaine)
3260: {
3261: drapeau_valeur_entiere = d_faux;
3262: drapeau_valeur_reelle = d_faux;
3263: }
3264: }
3265:
3266: break;
3267: }
3268:
3269: // Ne peut suivre qu'un chiffre ou un point
3270: case 'e' :
3271: case 'E' :
3272: {
3273: nombre_exposants++;
3274:
3275: if (ptr > (*s_etat_processus).instruction_courante)
3276: {
3277: switch(*(ptr - 1))
3278: {
3279: case '0' :
3280: case '1' :
3281: case '2' :
3282: case '3' :
3283: case '4' :
3284: case '5' :
3285: case '6' :
3286: case '7' :
3287: case '8' :
3288: case '9' :
3289: {
3290: drapeau_valeur_entiere = d_faux;
3291: break;
3292: }
3293:
3294: // Le point doit suivre un chiffre
3295: case '.' :
3296: {
3297: if ((ptr - 1) > (*s_etat_processus)
3298: .instruction_courante)
3299: {
3300: switch(*(ptr - 2))
3301: {
3302: case '0' :
3303: case '1' :
3304: case '2' :
3305: case '3' :
3306: case '4' :
3307: case '5' :
3308: case '6' :
3309: case '7' :
3310: case '8' :
3311: case '9' :
3312: {
3313: drapeau_valeur_entiere =
3314: d_faux;
3315: break;
3316: }
3317:
3318: default :
3319: {
3320: drapeau_valeur_entiere =
3321: d_faux;
3322: drapeau_valeur_reelle =
3323: d_faux;
3324: break;
3325: }
3326: }
3327: }
3328: else
3329: {
3330: drapeau_valeur_entiere = d_faux;
3331: drapeau_valeur_reelle = d_faux;
3332: }
3333:
3334: break;
3335: }
3336:
3337: default :
3338: {
3339: drapeau_valeur_entiere = d_faux;
3340: drapeau_valeur_reelle = d_faux;
3341: break;
3342: }
3343: }
3344: }
3345: else
3346: {
3347: drapeau_valeur_entiere = d_faux;
3348: drapeau_valeur_reelle = d_faux;
3349: }
3350:
3351: break;
3352: }
3353:
3354: default :
3355: {
3356: drapeau_valeur_entiere = d_faux;
3357: drapeau_valeur_reelle = d_faux;
3358: break;
3359: }
3360: }
3361:
3362: ptr++;
3363: }
3364:
3365: if ((nombre_points > 1) || (nombre_exposants > 1))
3366: {
3367: drapeau_valeur_reelle = d_faux;
3368: drapeau_valeur_entiere = d_faux;
3369: }
3370: }
3371: else
3372: {
3373: drapeau_valeur_entiere = d_faux;
3374: drapeau_valeur_reelle = d_faux;
3375: }
3376:
3377: if ((drapeau_valeur_reelle == d_faux) &&
3378: (drapeau_valeur_entiere == d_faux))
3379: {
3380: (*s_objet).type = NOM;
3381:
3382: element = malloc(sizeof(struct_nom));
3383:
3384: if (element == NULL)
3385: {
3386: (*s_etat_processus).erreur_systeme =
3387: d_es_allocation_memoire;
3388: (*s_etat_processus).traitement_interruptible =
3389: registre_interruption;
3390: return;
3391: }
3392:
3393: (*((struct_nom *) element)).symbole = d_faux;
3394: (*((struct_nom *) element)).nom = ((unsigned char *) malloc(
3395: (strlen((*s_etat_processus)
3396: .instruction_courante) + 1) * sizeof(unsigned char)));
3397:
3398: if ((*((struct_nom *) element)).nom == NULL)
3399: {
3400: (*s_etat_processus).erreur_systeme =
3401: d_es_allocation_memoire;
3402: (*s_etat_processus).traitement_interruptible =
3403: registre_interruption;
3404: return;
3405: }
3406:
3407: strcpy((*((struct_nom *) element)).nom, (*s_etat_processus)
3408: .instruction_courante);
3409: }
3410: else
3411: {
3412: if (drapeau_valeur_entiere == d_faux)
3413: {
3414: (*s_objet).type = REL;
3415:
3416: element = (void *) ((real8 *) malloc(
3417: sizeof(real8)));
3418:
3419: if (element == NULL)
3420: {
3421: (*s_etat_processus).erreur_systeme =
3422: d_es_allocation_memoire;
3423: (*s_etat_processus).traitement_interruptible =
3424: registre_interruption;
3425: return;
3426: }
3427:
3428: nombre_elements_convertis = sscanf(
3429: (*s_etat_processus).instruction_courante, "%lg",
3430: (real8 *) element);
3431:
3432: if (nombre_elements_convertis != 1)
3433: {
3434: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3435: }
3436: }
3437: else
3438: {
3439: (*s_objet).type = INT;
3440:
3441: element = (void *) ((integer8 *) malloc(
3442: sizeof(integer8)));
3443:
3444: if (element == NULL)
3445: {
3446: (*s_etat_processus).erreur_systeme =
3447: d_es_allocation_memoire;
3448: (*s_etat_processus).traitement_interruptible =
3449: registre_interruption;
3450: return;
3451: }
3452:
3453: nombre_elements_convertis = sscanf(
3454: (*s_etat_processus).instruction_courante, "%lld",
3455: (integer8 *) element);
3456:
3457: if (nombre_elements_convertis != 1)
3458: {
3459: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3460: }
3461: }
3462: }
3463:
3464: break;
3465: }
3466: }
3467:
3468: (*s_objet).objet = element;
3469:
3470: if (nombre_egalites > 1)
3471: {
3472: liberation(s_etat_processus, s_objet);
3473:
3474: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3475: (*s_etat_processus).traitement_interruptible = registre_interruption;
3476: return;
3477: }
3478:
3479: if (empilement(s_etat_processus,
3480: &((*s_etat_processus).l_base_pile), s_objet) == d_erreur)
3481: {
3482: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3483: (*s_etat_processus).traitement_interruptible =
3484: registre_interruption;
3485: return;
3486: }
3487:
3488: (*s_etat_processus).traitement_interruptible = registre_interruption;
3489: return;
3490: }
3491:
3492:
3493: /*
3494: ================================================================================
3495: Conversion de la virgule
3496: ================================================================================
3497: Entrées : structure sur l'état du processus
3498: --------------------------------------------------------------------------------
3499: Sorties : néant
3500: --------------------------------------------------------------------------------
3501: Effets de bord : néant
3502: ================================================================================
3503: */
3504:
3505: void
3506: conversion_format(struct_processus *s_etat_processus, unsigned char *chaine)
3507: {
3508: unsigned char *ptr;
3509:
3510: /*
3511: --------------------------------------------------------------------------------
3512: Transcription du point en virgule et réciproquement selon l'indicateur 48
3513: --------------------------------------------------------------------------------
3514: */
3515:
3516: if (test_cfsf(s_etat_processus, 48) == d_vrai)
3517: {
3518: ptr = chaine;
3519:
3520: while((*ptr) != d_code_fin_chaine)
3521: {
3522: if ((*ptr) == '.')
3523: {
3524: (*ptr) = ',';
3525: }
3526: else if ((*ptr) == ',')
3527: {
3528: (*ptr) = '.';
3529: }
3530:
3531: ptr++;
3532: }
3533: }
3534:
3535: return;
3536: }
3537:
3538: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to types.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src