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