Annotation of rpl/src/types.c, revision 1.5
1.1 bertrand 1: /*
2: ================================================================================
1.2 bertrand 3: RPL/2 (R) version 4.0.10
1.1 bertrand 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 -------------
1.3 bertrand 1076: -- Analyse récursive en appelant l'interprète sur le vecteur moins -------------
1.1 bertrand 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: *ptr_ecriture++ = *ptr_lecture++;
2815: }
2816:
2817: (*(--ptr_ecriture)) = d_code_fin_chaine;
2818:
2819: break;
2820: }
2821:
2822: /*
2823: --------------------------------------------------------------------------------
2824: Définition ou tableau
2825: --------------------------------------------------------------------------------
2826: */
2827:
2828: case '<' :
2829: {
2830: if ((*s_etat_processus).instruction_courante[1] == '[')
2831: {
2832: // Tableau
2833:
2834: sauvegarde_longueur_definitions_chainees =
2835: (*s_etat_processus).longueur_definitions_chainees;
2836:
2837: tampon = (unsigned char *) malloc(
2838: (((*s_etat_processus).longueur_definitions_chainees
2839: = strlen((*s_etat_processus).instruction_courante)
2840: + 2) + 1) * sizeof(unsigned char));
2841:
2842: if (tampon == NULL)
2843: {
2844: (*s_etat_processus).erreur_systeme =
2845: d_es_allocation_memoire;
2846: (*s_etat_processus).traitement_interruptible =
2847: registre_interruption;
2848: return;
2849: }
2850:
2851: strcpy(tampon, "<< ");
2852: ptr_ecriture = tampon + 3;
2853: ptr_lecture = (*s_etat_processus).instruction_courante + 2;
2854:
2855: while((*ptr_lecture) != d_code_fin_chaine)
2856: {
2857: *ptr_ecriture++ = *ptr_lecture++;
2858: }
2859:
2860: ptr_ecriture -= 2;
2861: (*ptr_ecriture) = d_code_fin_chaine;
2862: strcat(ptr_ecriture, " >>");
2863:
2864: position_courante = (*s_etat_processus).position_courante;
2865: (*s_etat_processus).position_courante = 0;
2866:
2867: profondeur_initiale = (*s_etat_processus)
2868: .hauteur_pile_operationnelle;
2869:
2870: /*
2871: -- On met les éléments du tableau dans la pile opérationnelle ------------------
2872: */
2873:
2874: (*s_etat_processus).niveau_recursivite++;
2875: definitions_chainees_precedentes = (*s_etat_processus)
2876: .definitions_chainees;
2877: (*s_etat_processus).definitions_chainees = tampon;
2878:
2879: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
2880: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;
2881:
2882: (*s_etat_processus).l_base_pile_systeme = NULL;
2883: empilement_pile_systeme(s_etat_processus);
2884:
2885: if ((*s_etat_processus).erreur_systeme != d_es)
2886: {
2887: (*s_etat_processus).traitement_interruptible =
2888: registre_interruption;
2889: return;
2890: }
2891:
2892: (*(*s_etat_processus).l_base_pile_systeme)
2893: .retour_definition = 'Y';
2894: (*s_etat_processus).niveau_courant = 0;
2895: (*s_etat_processus).autorisation_empilement_programme = 'N';
2896: registre_mode_execution_programme =
2897: (*s_etat_processus).mode_execution_programme;
2898: (*s_etat_processus).mode_execution_programme = 'Y';
2899: (*s_etat_processus).erreur_scrutation = d_faux;
2900:
2901: tampon = (*s_etat_processus).instruction_courante;
2902: nombre_lignes_a_supprimer =
2903: (*s_etat_processus).hauteur_pile_operationnelle;
2904:
2905: if ((*s_etat_processus).profilage == d_vrai)
2906: {
2907: profilage(s_etat_processus, "RPL/2 internals");
2908:
2909: if ((*s_etat_processus).erreur_systeme != d_es)
2910: {
2911: return;
2912: }
2913: }
2914:
2915: if (sequenceur(s_etat_processus) == d_erreur)
2916: {
2917: (*s_etat_processus).mode_execution_programme =
2918: registre_mode_execution_programme;
2919: nombre_lignes_a_supprimer =
2920: (*s_etat_processus).hauteur_pile_operationnelle
2921: - nombre_lignes_a_supprimer;
2922:
2923: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2924: {
2925: if (depilement(s_etat_processus,
2926: &((*s_etat_processus).l_base_pile),
2927: &s_sous_objet) == d_erreur)
2928: {
2929: (*s_etat_processus).traitement_interruptible =
2930: registre_interruption;
2931: return;
2932: }
2933:
2934: liberation(s_etat_processus, s_sous_objet);
2935: }
2936:
2937: (*s_etat_processus).instruction_courante = tampon;
2938:
2939: (*s_etat_processus).l_base_pile_systeme =
2940: s_sauvegarde_pile;
2941: (*s_etat_processus).niveau_courant =
2942: sauvegarde_niveau_courant;
2943:
2944: free((*s_etat_processus).definitions_chainees);
2945: (*s_etat_processus).niveau_recursivite--;
2946:
2947: (*s_etat_processus).definitions_chainees =
2948: definitions_chainees_precedentes;
2949: (*s_etat_processus).longueur_definitions_chainees =
2950: sauvegarde_longueur_definitions_chainees;
2951:
2952: (*s_etat_processus).position_courante =
2953: position_courante;
2954:
2955: free(s_objet);
2956:
2957: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
2958: (*s_etat_processus).traitement_interruptible =
2959: registre_interruption;
2960: return;
2961: }
2962:
2963: (*s_etat_processus).mode_execution_programme =
2964: registre_mode_execution_programme;
2965:
2966: if ((*s_etat_processus).erreur_scrutation == d_vrai)
2967: {
2968: nombre_lignes_a_supprimer =
2969: (*s_etat_processus).hauteur_pile_operationnelle
2970: - nombre_lignes_a_supprimer;
2971:
2972: for(i = 0; i < nombre_lignes_a_supprimer; i++)
2973: {
2974: if (depilement(s_etat_processus,
2975: &((*s_etat_processus).l_base_pile),
2976: &s_sous_objet) == d_erreur)
2977: {
2978: (*s_etat_processus).traitement_interruptible =
2979: registre_interruption;
2980: return;
2981: }
2982:
2983: liberation(s_etat_processus, s_sous_objet);
2984: }
2985:
2986: (*s_etat_processus).instruction_courante = tampon;
2987:
2988: (*s_etat_processus).l_base_pile_systeme =
2989: s_sauvegarde_pile;
2990: (*s_etat_processus).niveau_courant =
2991: sauvegarde_niveau_courant;
2992:
2993: free((*s_etat_processus).definitions_chainees);
2994: (*s_etat_processus).niveau_recursivite--;
2995:
2996: (*s_etat_processus).definitions_chainees =
2997: definitions_chainees_precedentes;
2998: (*s_etat_processus).longueur_definitions_chainees =
2999: sauvegarde_longueur_definitions_chainees;
3000:
3001: (*s_etat_processus).position_courante =
3002: position_courante;
3003:
3004: free(s_objet);
3005:
3006: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3007: (*s_etat_processus).traitement_interruptible =
3008: registre_interruption;
3009: return;
3010: }
3011:
3012: (*s_etat_processus).instruction_courante = tampon;
3013:
3014: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
3015: (*s_etat_processus).niveau_courant =
3016: sauvegarde_niveau_courant;
3017:
3018: free((*s_etat_processus).definitions_chainees);
3019: (*s_etat_processus).definitions_chainees =
3020: definitions_chainees_precedentes;
3021: (*s_etat_processus).longueur_definitions_chainees =
3022: sauvegarde_longueur_definitions_chainees;
3023:
3024: (*s_etat_processus).niveau_recursivite--;
3025:
3026: (*s_etat_processus).position_courante = position_courante;
3027:
3028: /*
3029: -- On relit la pile qui contient des sous-objets contenant les -----------------
3030: -- éléments du tableau ---------------------------------------------------------
3031: */
3032:
3033: profondeur_finale = (*s_etat_processus)
3034: .hauteur_pile_operationnelle;
3035:
3036: nombre_lignes = profondeur_finale - profondeur_initiale;
3037:
3038: element = (void *) ((struct_tableau *) malloc(
3039: sizeof(struct_tableau)));
3040:
3041: if (element == NULL)
3042: {
3043: (*s_etat_processus).erreur_systeme =
3044: d_es_allocation_memoire;
3045: (*s_etat_processus).traitement_interruptible =
3046: registre_interruption;
3047: return;
3048: }
3049:
3050: (*((struct_tableau *) element)).nombre_elements = nombre_lignes;
3051:
3052: if (((*((struct_tableau *) element)).elements =
3053: malloc(nombre_lignes * sizeof(struct_objet *))) == NULL)
3054: {
3055: (*s_etat_processus).erreur_systeme =
3056: d_es_allocation_memoire;
3057: (*s_etat_processus).traitement_interruptible =
3058: registre_interruption;
3059: return;
3060: }
3061:
3062: for(i = 1; i <= nombre_lignes; i++)
3063: {
3064: if (depilement(s_etat_processus,
3065: &((*s_etat_processus).l_base_pile),
3066: &s_sous_objet) == d_erreur)
3067: {
3068: (*s_etat_processus).traitement_interruptible =
3069: registre_interruption;
3070: return;
3071: }
3072:
3073: (*((struct_tableau *) element)).elements[nombre_lignes - i]
3074: = s_sous_objet;
3075: }
3076:
3077: (*s_objet).type = TBL;
3078:
3079: (*s_etat_processus).traitement_interruptible =
3080: registre_interruption;
3081: }
3082: else
3083: {
3084: // Définition
3085:
3086: if (strlen((*s_etat_processus).instruction_courante) < 5)
3087: {
3088: free(s_objet);
3089:
3090: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3091: (*s_etat_processus).traitement_interruptible =
3092: registre_interruption;
3093: return;
3094: }
3095:
3096: if ((strncmp((*s_etat_processus).instruction_courante, "<< ", 3)
3097: != 0) && (strcmp((*s_etat_processus)
3098: .instruction_courante, "<<") != 0))
3099: {
3100: free(s_objet);
3101:
3102: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3103: (*s_etat_processus).traitement_interruptible =
3104: registre_interruption;
3105: return;
3106: }
3107:
3108: (*s_objet).type = RPN;
3109:
3110: element = (void *) analyse_rpn(s_etat_processus,
3111: (*s_etat_processus).instruction_courante);
3112:
3113: if (element == NULL)
3114: {
3115: if ((*s_etat_processus).erreur_systeme != d_es)
3116: {
3117: (*s_etat_processus).erreur_systeme =
3118: d_es_allocation_memoire;
3119: }
3120:
3121: (*s_etat_processus).traitement_interruptible =
3122: registre_interruption;
3123: return;
3124: }
3125:
3126: l_element_courant = (struct_liste_chainee *) element;
3127:
3128: while(l_element_courant != NULL)
3129: {
3130: if ((*(*l_element_courant).donnee).type == FCT)
3131: {
3132: if (strcmp((*((struct_fonction *) (*(*l_element_courant)
3133: .donnee).objet)).nom_fonction, "=") == 0)
3134: {
3135: nombre_egalites++;
3136: }
3137: }
3138:
3139: l_element_courant = (*l_element_courant).suivant;
3140: }
3141: }
3142:
3143: break;
3144: }
3145:
3146: /*
3147: --------------------------------------------------------------------------------
3148: Entier ou réel
3149: --------------------------------------------------------------------------------
3150: */
3151:
3152: default :
3153: {
3154: if (((*((*s_etat_processus).instruction_courante)) == '-') ||
3155: ((*((*s_etat_processus).instruction_courante)) == '+') ||
3156: (((*((*s_etat_processus).instruction_courante)) >= '0') &&
3157: ((*((*s_etat_processus).instruction_courante))
3158: <= '9')) || ((*((*s_etat_processus).instruction_courante))
3159: == '.'))
3160: {
3161: drapeau_valeur_entiere = ((*((*s_etat_processus)
3162: .instruction_courante)) != '.') ? d_vrai : d_faux;
3163: drapeau_valeur_reelle = d_vrai;
3164:
3165: nombre_points = 0;
3166: nombre_exposants = 0;
3167:
3168: conversion_format(s_etat_processus,
3169: (*s_etat_processus).instruction_courante);
3170:
3171: ptr = (*s_etat_processus).instruction_courante;
3172:
3173: while((*ptr) != d_code_fin_chaine)
3174: {
3175: switch(*ptr)
3176: {
3177: case '0' :
3178: case '1' :
3179: case '2' :
3180: case '3' :
3181: case '4' :
3182: case '5' :
3183: case '6' :
3184: case '7' :
3185: case '8' :
3186: case '9' :
3187: {
3188: break;
3189: }
3190:
3191: // Ne peut survenir qu'après un 'E', un 'e' ou au
3192: // début de la chaîne.
3193: case '+' :
3194: case '-' :
3195: {
3196: if (ptr > (*s_etat_processus).instruction_courante)
3197: {
3198: if (((*(ptr - 1)) != 'e') &&
3199: ((*(ptr - 1)) != 'E'))
3200: {
3201: drapeau_valeur_entiere = d_faux;
3202: drapeau_valeur_reelle = d_faux;
3203: }
3204: }
3205:
3206: break;
3207: }
3208:
3209: // Ne peut que commencer une chaîne, suivre un
3210: // chiffre ou un signe. Ne peut constituer un
3211: // nombre seul.
3212: case '.' :
3213: {
3214: nombre_points++;
3215:
3216: if (ptr > (*s_etat_processus).instruction_courante)
3217: {
3218: switch(*(ptr - 1))
3219: {
3220: case '+' :
3221: case '-' :
3222: case '0' :
3223: case '1' :
3224: case '2' :
3225: case '3' :
3226: case '4' :
3227: case '5' :
3228: case '6' :
3229: case '7' :
3230: case '8' :
3231: case '9' :
3232: {
3233: drapeau_valeur_entiere = d_faux;
3234: break;
3235: }
3236:
3237: default :
3238: {
3239: drapeau_valeur_entiere = d_faux;
3240: drapeau_valeur_reelle = d_faux;
3241: break;
3242: }
3243: }
3244: }
3245: else
3246: {
3247: if ((*(ptr + 1)) == d_code_fin_chaine)
3248: {
3249: drapeau_valeur_entiere = d_faux;
3250: drapeau_valeur_reelle = d_faux;
3251: }
3252: }
3253:
3254: break;
3255: }
3256:
3257: // Ne peut suivre qu'un chiffre ou un point
3258: case 'e' :
3259: case 'E' :
3260: {
3261: nombre_exposants++;
3262:
3263: if (ptr > (*s_etat_processus).instruction_courante)
3264: {
3265: switch(*(ptr - 1))
3266: {
3267: case '0' :
3268: case '1' :
3269: case '2' :
3270: case '3' :
3271: case '4' :
3272: case '5' :
3273: case '6' :
3274: case '7' :
3275: case '8' :
3276: case '9' :
3277: {
3278: drapeau_valeur_entiere = d_faux;
3279: break;
3280: }
3281:
3282: // Le point doit suivre un chiffre
3283: case '.' :
3284: {
3285: if ((ptr - 1) > (*s_etat_processus)
3286: .instruction_courante)
3287: {
3288: switch(*(ptr - 2))
3289: {
3290: case '0' :
3291: case '1' :
3292: case '2' :
3293: case '3' :
3294: case '4' :
3295: case '5' :
3296: case '6' :
3297: case '7' :
3298: case '8' :
3299: case '9' :
3300: {
3301: drapeau_valeur_entiere =
3302: d_faux;
3303: break;
3304: }
3305:
3306: default :
3307: {
3308: drapeau_valeur_entiere =
3309: d_faux;
3310: drapeau_valeur_reelle =
3311: d_faux;
3312: break;
3313: }
3314: }
3315: }
3316: else
3317: {
3318: drapeau_valeur_entiere = d_faux;
3319: drapeau_valeur_reelle = d_faux;
3320: }
3321:
3322: break;
3323: }
3324:
3325: default :
3326: {
3327: drapeau_valeur_entiere = d_faux;
3328: drapeau_valeur_reelle = d_faux;
3329: break;
3330: }
3331: }
3332: }
3333: else
3334: {
3335: drapeau_valeur_entiere = d_faux;
3336: drapeau_valeur_reelle = d_faux;
3337: }
3338:
3339: break;
3340: }
3341:
3342: default :
3343: {
3344: drapeau_valeur_entiere = d_faux;
3345: drapeau_valeur_reelle = d_faux;
3346: break;
3347: }
3348: }
3349:
3350: ptr++;
3351: }
3352:
3353: if ((nombre_points > 1) || (nombre_exposants > 1))
3354: {
3355: drapeau_valeur_reelle = d_faux;
3356: drapeau_valeur_entiere = d_faux;
3357: }
3358: }
3359: else
3360: {
3361: drapeau_valeur_entiere = d_faux;
3362: drapeau_valeur_reelle = d_faux;
3363: }
3364:
3365: if ((drapeau_valeur_reelle == d_faux) &&
3366: (drapeau_valeur_entiere == d_faux))
3367: {
3368: (*s_objet).type = NOM;
3369:
3370: element = malloc(sizeof(struct_nom));
3371:
3372: if (element == NULL)
3373: {
3374: (*s_etat_processus).erreur_systeme =
3375: d_es_allocation_memoire;
3376: (*s_etat_processus).traitement_interruptible =
3377: registre_interruption;
3378: return;
3379: }
3380:
3381: (*((struct_nom *) element)).symbole = d_faux;
3382: (*((struct_nom *) element)).nom = ((unsigned char *) malloc(
3383: (strlen((*s_etat_processus)
3384: .instruction_courante) + 1) * sizeof(unsigned char)));
3385:
3386: if ((*((struct_nom *) element)).nom == NULL)
3387: {
3388: (*s_etat_processus).erreur_systeme =
3389: d_es_allocation_memoire;
3390: (*s_etat_processus).traitement_interruptible =
3391: registre_interruption;
3392: return;
3393: }
3394:
3395: strcpy((*((struct_nom *) element)).nom, (*s_etat_processus)
3396: .instruction_courante);
3397: }
3398: else
3399: {
3400: if (drapeau_valeur_entiere == d_faux)
3401: {
3402: (*s_objet).type = REL;
3403:
3404: element = (void *) ((real8 *) malloc(
3405: sizeof(real8)));
3406:
3407: if (element == NULL)
3408: {
3409: (*s_etat_processus).erreur_systeme =
3410: d_es_allocation_memoire;
3411: (*s_etat_processus).traitement_interruptible =
3412: registre_interruption;
3413: return;
3414: }
3415:
3416: nombre_elements_convertis = sscanf(
3417: (*s_etat_processus).instruction_courante, "%lg",
3418: (real8 *) element);
3419:
3420: if (nombre_elements_convertis != 1)
3421: {
3422: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3423: }
3424: }
3425: else
3426: {
3427: (*s_objet).type = INT;
3428:
3429: element = (void *) ((integer8 *) malloc(
3430: sizeof(integer8)));
3431:
3432: if (element == NULL)
3433: {
3434: (*s_etat_processus).erreur_systeme =
3435: d_es_allocation_memoire;
3436: (*s_etat_processus).traitement_interruptible =
3437: registre_interruption;
3438: return;
3439: }
3440:
3441: nombre_elements_convertis = sscanf(
3442: (*s_etat_processus).instruction_courante, "%lld",
3443: (integer8 *) element);
3444:
3445: if (nombre_elements_convertis != 1)
3446: {
3447: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3448: }
3449: }
3450: }
3451:
3452: break;
3453: }
3454: }
3455:
3456: (*s_objet).objet = element;
3457:
3458: if (nombre_egalites > 1)
3459: {
3460: liberation(s_etat_processus, s_objet);
3461:
3462: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
3463: (*s_etat_processus).traitement_interruptible = registre_interruption;
3464: return;
3465: }
3466:
3467: if (empilement(s_etat_processus,
3468: &((*s_etat_processus).l_base_pile), s_objet) == d_erreur)
3469: {
3470: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
3471: (*s_etat_processus).traitement_interruptible = registre_interruption;
3472: return;
3473: }
3474:
3475: (*s_etat_processus).traitement_interruptible = registre_interruption;
3476: return;
3477: }
3478:
3479:
3480: /*
3481: ================================================================================
3482: Conversion de la virgule
3483: ================================================================================
3484: Entrées : structure sur l'état du processus
3485: --------------------------------------------------------------------------------
3486: Sorties : néant
3487: --------------------------------------------------------------------------------
3488: Effets de bord : néant
3489: ================================================================================
3490: */
3491:
3492: void
3493: conversion_format(struct_processus *s_etat_processus, unsigned char *chaine)
3494: {
3495: unsigned char *ptr;
3496:
3497: /*
3498: --------------------------------------------------------------------------------
3499: Transcription du point en virgule et réciproquement selon l'indicateur 48
3500: --------------------------------------------------------------------------------
3501: */
3502:
3503: if (test_cfsf(s_etat_processus, 48) == d_vrai)
3504: {
3505: ptr = chaine;
3506:
3507: while((*ptr) != d_code_fin_chaine)
3508: {
3509: if ((*ptr) == '.')
3510: {
3511: (*ptr) = ',';
3512: }
3513: else if ((*ptr) == ',')
3514: {
3515: (*ptr) = '.';
3516: }
3517:
3518: ptr++;
3519: }
3520: }
3521:
3522: return;
3523: }
3524:
3525: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>