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