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