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