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