Annotation of rpl/src/instructions_f1.c, revision 1.8
1.1 bertrand 1: /*
2: ================================================================================
1.7 bertrand 3: RPL/2 (R) version 4.0.14
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: Fonction '->'
29: ================================================================================
30: Entrées : structure processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_fleche(struct_processus *s_etat_processus)
40: {
41: struct_liste_chainee *l_element_courant;
42: struct_liste_chainee *l_emplacement_valeurs;
43:
44: struct_objet *s_objet;
45: struct_objet *s_objet_elementaire;
46: struct_objet *s_expression_algebrique;
47:
48: struct_variable s_variable;
49:
50: struct_variable_partagee s_variable_partagee;
51: struct_variable_statique s_variable_statique;
52:
53: logical1 fin_scrutation;
54: logical1 presence_expression_algebrique;
55:
56: union_position_variable position_variable;
57:
58: unsigned char instruction_valide;
59: unsigned char *tampon;
60: unsigned char test_instruction;
61:
62: unsigned long i;
63: unsigned long nombre_variables;
64:
65: void (*fonction)();
66:
67: (*s_etat_processus).erreur_execution = d_ex;
68:
69: if ((*s_etat_processus).affichage_arguments == 'Y')
70: {
71: printf("\n -> ");
72:
73: if ((*s_etat_processus).langue == 'F')
74: {
75: printf("(création de variables locales)\n\n");
76: }
77: else
78: {
79: printf("(create local variables)\n\n");
80: }
81:
82: printf(" n: %s, %s, %s, %s, %s, %s,\n"
83: " %s, %s, %s, %s, %s,\n"
84: " %s, %s, %s, %s, %s,\n"
85: " %s, %s, %s, %s,\n"
86: " %s, %s\n",
87: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
88: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
89: d_SQL, d_SLB, d_PRC, d_MTX);
90: printf(" ...\n");
91: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
92: " %s, %s, %s, %s, %s,\n"
93: " %s, %s, %s, %s, %s,\n"
94: " %s, %s, %s, %s,\n"
95: " %s, %s\n",
96: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
97: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
98: d_SQL, d_SLB, d_PRC, d_MTX);
99:
100: if ((*s_etat_processus).langue == 'F')
101: {
102: printf(" Utilisation :\n\n");
103: }
104: else
105: {
106: printf(" Usage:\n\n");
107: }
108:
109: printf(" -> (variables) %s\n\n", d_RPN);
110:
111: printf(" -> (variables) %s\n", d_ALG);
112:
113: return;
114: }
115: else if ((*s_etat_processus).test_instruction == 'Y')
116: {
117: (*s_etat_processus).nombre_arguments = -1;
118: return;
119: }
120:
121: if (test_cfsf(s_etat_processus, 31) == d_vrai)
122: {
123: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
124: {
125: return;
126: }
127: }
128:
129: (*s_etat_processus).autorisation_empilement_programme = 'N';
130:
131: /*
132: --------------------------------------------------------------------------------
133: Boucler jusqu'au prochain '<<' ou jusqu'à la prochaine expression algébrique
134: --------------------------------------------------------------------------------
135: */
136:
137: test_instruction = (*s_etat_processus).test_instruction;
138: instruction_valide = (*s_etat_processus).instruction_valide;
139: presence_expression_algebrique = d_faux;
140:
141: if ((*s_etat_processus).debug == d_vrai)
142: if (((*s_etat_processus).type_debug &
143: d_debug_variables) != 0)
144: {
145: if ((*s_etat_processus).langue == 'F')
146: {
147: printf("[%d] Recherche des variables locales\n", (int) getpid());
148: }
149: else
150: {
151: printf("[%d] Searching for local variables\n", (int) getpid());
152: }
153:
154: fflush(stdout);
155: }
156:
157: nombre_variables = 0;
158:
159: if ((*s_etat_processus).mode_execution_programme == 'Y')
160: {
161: /*
162: * Le programme est exécuté normalement.
163: */
164:
165: tampon = (*s_etat_processus).instruction_courante;
166:
167: do
168: {
169: if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
170: {
171: (*s_etat_processus).instruction_courante = tampon;
172: return;
173: }
174:
175: if (strcmp((*s_etat_processus).instruction_courante, "<<") == 0)
176: {
177: fin_scrutation = d_vrai;
178: (*s_etat_processus).test_instruction = 'N';
179: }
180: else
181: {
182: fin_scrutation = d_faux;
183: (*s_etat_processus).test_instruction = 'Y';
184: }
185:
186: analyse(s_etat_processus, NULL);
187:
188: if ((*s_etat_processus).instruction_valide == 'N')
189: {
190: recherche_type(s_etat_processus);
191:
192: if ((*s_etat_processus).erreur_execution != d_ex)
193: {
194: (*s_etat_processus).instruction_courante = tampon;
195: return;
196: }
197:
198: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == ALG)
199: {
200: (*s_etat_processus).niveau_courant++;
201: fin_scrutation = d_vrai;
202: presence_expression_algebrique = d_vrai;
203:
204: if (depilement(s_etat_processus, &((*s_etat_processus)
205: .l_base_pile), &s_expression_algebrique)
206: == d_erreur)
207: {
208: (*s_etat_processus).erreur_execution =
209: d_ex_manque_argument;
210: (*s_etat_processus).instruction_courante = tampon;
211: return;
212: }
213: }
214: else if ((*(*(*s_etat_processus).l_base_pile).donnee)
215: .type != NOM)
216: {
217: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
218: (*s_etat_processus).instruction_courante = tampon;
219: return;
220: }
221: else if ((*((struct_nom *) (*(*(*s_etat_processus).l_base_pile)
222: .donnee).objet)).symbole == d_vrai)
223: {
224: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
225: (*s_etat_processus).instruction_courante = tampon;
226: return;
227: }
228: else
229: {
230: nombre_variables = nombre_variables + 1;
231: }
232: }
233: else
234: {
235: if (fin_scrutation == d_faux)
236: {
237: (*s_etat_processus).erreur_execution = d_ex_nom_reserve;
238: (*s_etat_processus).instruction_courante = tampon;
239: return;
240: }
241: }
242:
243: free((*s_etat_processus).instruction_courante);
244: } while(fin_scrutation == d_faux);
245:
246: (*s_etat_processus).instruction_courante = tampon;
247: }
248: else
249: {
250: /*
251: * Une expression est en cours d'évaluation.
252: */
253:
254: l_element_courant = (*(*s_etat_processus).expression_courante).suivant;
255: tampon = (*s_etat_processus).instruction_courante;
256:
257: do
258: {
259: if ((*(*l_element_courant).donnee).type == FCT)
260: {
261: fonction = (*((struct_fonction *) (*(*l_element_courant)
262: .donnee).objet)).fonction;
263:
264: if (fonction == instruction_vers_niveau_superieur)
265: {
266: fin_scrutation = d_vrai;
267: (*s_etat_processus).test_instruction = 'N';
268:
269: analyse(s_etat_processus,
270: instruction_vers_niveau_superieur);
271: }
272: else
273: {
274: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
275: return;
276: }
277: }
278: else if ((*(*l_element_courant).donnee).type == ALG)
279: {
280: (*s_etat_processus).niveau_courant++;
281: fin_scrutation = d_vrai;
282: presence_expression_algebrique = d_vrai;
283:
284: s_expression_algebrique = (*l_element_courant).donnee;
285: }
286: else if ((*(*l_element_courant).donnee).type != NOM)
287: {
288: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
289: return;
290: }
291: else
292: {
293: if ((s_objet_elementaire = copie_objet(s_etat_processus,
294: (*l_element_courant).donnee, 'P')) == NULL)
295: {
296: (*s_etat_processus).erreur_systeme =
297: d_es_allocation_memoire;
298: return;
299: }
300:
301: if (empilement(s_etat_processus, &((*s_etat_processus)
302: .l_base_pile), s_objet_elementaire) == d_erreur)
303: {
304: return;
305: }
306:
307: nombre_variables = nombre_variables + 1;
308: fin_scrutation = d_faux;
309: }
310:
311: (*s_etat_processus).expression_courante = l_element_courant;
312: l_element_courant = (*l_element_courant).suivant;
313: } while((fin_scrutation == d_faux) && (l_element_courant != NULL));
314:
315: (*s_etat_processus).instruction_courante = tampon;
316:
317: if (fin_scrutation == d_faux)
318: {
319: (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
320: return;
321: }
322: }
323:
324: if (nombre_variables < 1)
325: {
326: (*s_etat_processus).erreur_execution = d_ex_absence_variable;
327: return;
328: }
329:
330: if ((*s_etat_processus).debug == d_vrai)
331: if (((*s_etat_processus).type_debug &
332: d_debug_variables) != 0)
333: {
334: if ((*s_etat_processus).langue == 'F')
335: {
336: printf("[%d] Nombre de variables de niveau %lu : %lu\n",
337: (int) getpid(),
338: (*s_etat_processus).niveau_courant, nombre_variables);
339: }
340: else
341: {
342: printf("[%d] Number of level %lu variables : %lu\n",
343: (int) getpid(),
344: (*s_etat_processus).niveau_courant, nombre_variables);
345: }
346:
347: fflush(stdout);
348: }
349:
350: l_emplacement_valeurs = (*s_etat_processus).l_base_pile;
351:
352: for(i = 0; i < nombre_variables; i++)
353: {
354: l_emplacement_valeurs = (*l_emplacement_valeurs).suivant;
355: }
356:
357: l_element_courant = l_emplacement_valeurs;
358:
359: for(i = 0; i < nombre_variables; i++)
360: {
361: if (l_element_courant == NULL)
362: {
363: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
364: return;
365: }
366:
367: l_element_courant = (*l_element_courant).suivant;
368: }
369:
370: for(i = 0; i < nombre_variables; i++)
371: {
372: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
373: &s_objet) == d_erreur)
374: {
375: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
376: return;
377: }
378:
379: if ((s_variable.nom = malloc((strlen(
380: (*((struct_nom *) (*s_objet).objet)).nom) + 1) *
381: sizeof(unsigned char))) == NULL)
382: {
383: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
384: return;
385: }
386:
387: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet).objet)).nom);
388:
389: if ((*s_etat_processus).debug == d_vrai)
390: if (((*s_etat_processus).type_debug &
391: d_debug_variables) != 0)
392: {
393: printf("[%d] Variable %s\n", (int) getpid(), s_variable.nom);
394: fflush(stdout);
395: }
396:
397: s_variable.niveau = (*s_etat_processus).niveau_courant;
398:
399: // Si le drapeau creation_variables_statiques est positionné,
400: // on recherche une entrée dans la table des variables statiques.
401: // Si cette entrée existe, on affecte à la variable créée l'objet
402: // contenu dans la table des variables statiques. Dans le cas contraire,
403: // on crée une entrée dans la table des variables statiques avec
404: // ce qui se trouve dans la pile.
405:
406: if ((*s_etat_processus).l_base_pile_systeme == NULL)
407: {
408: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
409: return;
410: }
411:
412: /*
413: * Vérification de l'unicité de la variable pour un niveau donné
414: */
415:
416: if (recherche_variable(s_etat_processus, s_variable.nom) == d_vrai)
417: {
418: if ((*s_etat_processus).niveau_courant ==
419: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
420: .position_variable_courante].niveau)
421: {
422: liberation(s_etat_processus, s_objet);
423: free(s_variable.nom);
424:
425: (*s_etat_processus).erreur_execution = d_ex_creation_variable;
426: return;
427: }
428: }
429:
430: (*s_etat_processus).erreur_systeme = d_es;
431:
432: if ((*(*s_etat_processus).l_base_pile_systeme)
433: .creation_variables_statiques == d_vrai)
434: {
435: if ((*s_etat_processus).mode_execution_programme == 'Y')
436: {
437: position_variable.adresse =
438: (*s_etat_processus).position_courante;
439: }
440: else
441: {
442: position_variable.pointeur =
443: (*s_etat_processus).objet_courant;
444: }
445:
446: if (recherche_variable_statique(s_etat_processus, s_variable.nom,
447: position_variable,
448: ((*s_etat_processus).mode_execution_programme == 'Y')
449: ? 'P' : 'E') == d_vrai)
450: {
451: // Variable statique à utiliser
452:
453: if ((*s_etat_processus).mode_execution_programme == 'Y')
454: {
455: s_variable.origine = 'P';
456: }
457: else
458: {
459: s_variable.origine = 'E';
460: }
461:
462: s_variable.objet = (*s_etat_processus)
463: .s_liste_variables_statiques[(*s_etat_processus)
464: .position_variable_statique_courante].objet;
465: (*s_etat_processus).s_liste_variables_statiques
466: [(*s_etat_processus)
467: .position_variable_statique_courante].objet = NULL;
468: }
469: else
470: {
471: // Variable statique à créer
472:
473: s_variable_statique.objet = NULL;
474: (*s_etat_processus).erreur_systeme = d_es;
475:
476: if ((s_variable_statique.nom = malloc((strlen(s_variable.nom)
477: + 1) * sizeof(unsigned char))) == NULL)
478: {
479: (*s_etat_processus).erreur_systeme =
480: d_es_allocation_memoire;
481: return;
482: }
483:
484: strcpy(s_variable_statique.nom, s_variable.nom);
485:
486: if ((*s_etat_processus).mode_execution_programme == 'Y')
487: {
488: s_variable_statique.origine = 'P';
489: s_variable_statique.niveau = 0;
490: s_variable_statique.variable_statique.adresse =
491: (*s_etat_processus).position_courante;
492: }
493: else
494: {
495: s_variable_statique.origine = 'E';
496:
497: /*
498: * Si la variable est appelée depuis une expression
499: * compilée (variable de niveau 0), la variable statique
500: * est persistante (niveau 0). Dans le cas contraire, elle
501: * est persistante à l'expression (niveau courant).
502: */
503:
504: if ((*s_etat_processus).evaluation_expression_compilee
505: == 'Y')
506: {
507: s_variable_statique.niveau = 0;
508: }
509: else
510: {
511: s_variable_statique.niveau =
512: (*s_etat_processus).niveau_courant;
513: }
514:
515: s_variable_statique.variable_statique.pointeur =
516: (*s_etat_processus).objet_courant;
517: }
518:
519: if (creation_variable_statique(s_etat_processus,
520: &s_variable_statique) == d_erreur)
521: {
522: return;
523: }
524:
525: s_variable.objet = (*l_emplacement_valeurs).donnee;
526: (*l_emplacement_valeurs).donnee = NULL;
527: }
528: }
529: else if ((*(*s_etat_processus).l_base_pile_systeme)
530: .creation_variables_partagees == d_vrai)
531: {
532: if ((*s_etat_processus).mode_execution_programme == 'Y')
533: {
534: position_variable.adresse =
535: (*s_etat_processus).position_courante;
536: }
537: else
538: {
539: position_variable.pointeur =
540: (*s_etat_processus).objet_courant;
541: }
542:
543: if (pthread_mutex_lock(&((*(*s_etat_processus)
544: .s_liste_variables_partagees).mutex)) != 0)
545: {
546: (*s_etat_processus).erreur_systeme = d_es_processus;
547: return;
548: }
549:
550: if (recherche_variable_partagee(s_etat_processus, s_variable.nom,
551: position_variable,
552: ((*s_etat_processus).mode_execution_programme == 'Y')
553: ? 'P' : 'E') == d_vrai)
554: {
555: // Variable partagée à utiliser
556:
557: if (pthread_mutex_unlock(&((*(*s_etat_processus)
558: .s_liste_variables_partagees).mutex)) != 0)
559: {
560: (*s_etat_processus).erreur_systeme = d_es_processus;
561: return;
562: }
563:
564: // Les champs niveau, variable_statique, variable_partagee
565: // et variable_verrouillee sont renseignés lors de l'appel
566: // à la fonction creation_variable().
567:
568: if ((*s_etat_processus).mode_execution_programme == 'Y')
569: {
570: s_variable.origine = 'P';
571: }
572: else
573: {
574: s_variable.origine = 'E';
575: }
576:
577: s_variable.objet = NULL;
578: }
579: else
580: {
1.6 bertrand 581: // Variable partagée à utiliser
1.1 bertrand 582: // Variable partagee à créer
583:
584: (*s_etat_processus).erreur_systeme = d_es;
585:
586: if ((s_variable_partagee.nom = malloc((strlen(s_variable.nom)
587: + 1) * sizeof(unsigned char))) == NULL)
588: {
1.8 ! bertrand 589: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 590: .s_liste_variables_partagees).mutex)) != 0)
! 591: {
! 592: (*s_etat_processus).erreur_systeme = d_es_processus;
! 593: return;
! 594: }
! 595:
1.1 bertrand 596: (*s_etat_processus).erreur_systeme =
597: d_es_allocation_memoire;
598: return;
599: }
600:
601: strcpy(s_variable_partagee.nom, s_variable.nom);
602:
603: if ((*s_etat_processus).mode_execution_programme == 'Y')
604: {
605: s_variable_partagee.origine = 'P';
606: s_variable_partagee.niveau = 0;
607: s_variable_partagee.variable_partagee.adresse =
608: (*s_etat_processus).position_courante;
609: }
610: else
611: {
612: s_variable_partagee.origine = 'E';
613:
614: /*
615: * Si la variable est appelée depuis une expression
616: * compilée (variable de niveau 0), la variable statique
617: * est persistante (niveau 0). Dans le cas contraire, elle
618: * est persistante à l'expression (niveau courant).
619: */
620:
621: if ((*s_etat_processus).evaluation_expression_compilee
622: == 'Y')
623: {
624: s_variable_partagee.niveau = 0;
625: }
626: else
627: {
628: s_variable_partagee.niveau =
629: (*s_etat_processus).niveau_courant;
630: }
631:
632: s_variable_partagee.variable_partagee.pointeur =
633: (*s_etat_processus).objet_courant;
634: }
635:
636: s_variable_partagee.objet = (*l_emplacement_valeurs).donnee;
637: (*l_emplacement_valeurs).donnee = NULL;
638:
639: if (creation_variable_partagee(s_etat_processus,
640: &s_variable_partagee) == d_erreur)
641: {
1.8 ! bertrand 642: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 643: .s_liste_variables_partagees).mutex)) != 0)
! 644: {
! 645: (*s_etat_processus).erreur_systeme = d_es_processus;
! 646: return;
! 647: }
! 648:
1.1 bertrand 649: return;
650: }
651:
652: if (pthread_mutex_unlock(&((*(*s_etat_processus)
653: .s_liste_variables_partagees).mutex)) != 0)
654: {
655: (*s_etat_processus).erreur_systeme = d_es_processus;
656: return;
657: }
658:
659: s_variable.objet = NULL;
660: }
661: }
662: else
663: {
664: s_variable.objet = (*l_emplacement_valeurs).donnee;
665: (*l_emplacement_valeurs).donnee = NULL;
666: }
667:
668: l_emplacement_valeurs = (*l_emplacement_valeurs).suivant;
669:
670: if (creation_variable(s_etat_processus, &s_variable,
671: ((*(*s_etat_processus).l_base_pile_systeme)
672: .creation_variables_statiques == d_vrai) ? 'S' : 'V',
673: ((*(*s_etat_processus).l_base_pile_systeme)
674: .creation_variables_partagees == d_vrai) ? 'S' : 'P')
675: == d_erreur)
676: {
677: return;
678: }
679:
680: liberation(s_etat_processus, s_objet);
681: }
682:
683: // Les prochaines variables créées seront forcément du type volatile et
684: // seront obligatoirement privées.
685:
686: if ((*s_etat_processus).l_base_pile_systeme == NULL)
687: {
688: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
689: return;
690: }
691:
692: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_statiques
693: = d_faux;
694: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_partagees
695: = d_faux;
696:
697: for(i = 0; i < nombre_variables; i++)
698: {
699: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
700: &s_objet) == d_erreur)
701: {
702: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
703: return;
704: }
705:
706: liberation(s_etat_processus, s_objet);
707: }
708:
709: (*s_etat_processus).test_instruction = test_instruction;
710: (*s_etat_processus).instruction_valide = instruction_valide;
711:
712: /*
713: * Traitement le cas échéant de l'expression algébrique
714: */
715:
716: if (presence_expression_algebrique == d_vrai)
717: {
718: evaluation(s_etat_processus, s_expression_algebrique, 'N');
719:
720: if ((*s_etat_processus).mode_execution_programme == 'Y')
721: {
722: liberation(s_etat_processus, s_expression_algebrique);
723: }
724:
725: (*s_etat_processus).niveau_courant--;
726:
727: if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
728: {
729: return;
730: }
731:
732: (*s_etat_processus).autorisation_empilement_programme = 'Y';
733: }
734:
735: return;
736: }
737:
738:
739: /*
740: ================================================================================
741: Fonction '->list'
742: ================================================================================
743: Entrées : structure processus
744: --------------------------------------------------------------------------------
745: Sorties :
746: --------------------------------------------------------------------------------
747: Effets de bord : néant
748: ================================================================================
749: */
750:
751: void
752: instruction_fleche_list(struct_processus *s_etat_processus)
753: {
754: struct_liste_chainee *l_element_courant;
755:
756: struct_objet *s_objet;
757:
758: signed long i;
759: signed long nombre_elements;
760:
761: (*s_etat_processus).erreur_execution = d_ex;
762:
763: if ((*s_etat_processus).affichage_arguments == 'Y')
764: {
765: printf("\n ->LIST ");
766:
767: if ((*s_etat_processus).langue == 'F')
768: {
769: printf("(création d'une liste)\n\n");
770: }
771: else
772: {
773: printf("(create list)\n\n");
774: }
775:
776: printf(" n: %s, %s, %s, %s, %s, %s,\n"
777: " %s, %s, %s, %s, %s,\n"
778: " %s, %s, %s, %s, %s,\n"
779: " %s, %s\n",
780: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
781: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
782: printf(" ...\n");
783: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
784: " %s, %s, %s, %s, %s,\n"
785: " %s, %s, %s, %s, %s,\n"
786: " %s, %s\n",
787: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
788: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
789: printf(" 1: %s\n", d_INT);
790: printf("-> 1: %s\n", d_LST);
791:
792: return;
793: }
794: else if ((*s_etat_processus).test_instruction == 'Y')
795: {
796: (*s_etat_processus).nombre_arguments = -1;
797: return;
798: }
799:
800: if (test_cfsf(s_etat_processus, 31) == d_vrai)
801: {
802: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
803: {
804: return;
805: }
806: }
807:
808: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
809: {
810: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
811: return;
812: }
813:
814: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != INT)
815: {
816: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
817: return;
818: }
819:
820: nombre_elements = (*((integer8 *) (*(*(*s_etat_processus).l_base_pile)
821: .donnee).objet));
822:
823: if (nombre_elements < 0)
824: {
825:
826: /*
827: -- Opération absurde autorisée sur le calculateur HP-28S -----------------------
828: */
829:
830: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
831: return;
832: }
833:
834: if ((unsigned long) nombre_elements >=
835: (*s_etat_processus).hauteur_pile_operationnelle)
836: {
837: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
838: return;
839: }
840:
841: if (test_cfsf(s_etat_processus, 31) == d_vrai)
842: {
843: if (empilement_pile_last(s_etat_processus, nombre_elements + 1)
844: == d_erreur)
845: {
846: return;
847: }
848: }
849:
850: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
851: &s_objet) == d_erreur)
852: {
853: return;
854: }
855:
856: liberation(s_etat_processus, s_objet);
857: l_element_courant = NULL;
858:
859: for(i = 0; i < nombre_elements; i++)
860: {
861: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
862: &s_objet) == d_erreur)
863: {
864: return;
865: }
866:
867: if (empilement(s_etat_processus, &l_element_courant, s_objet)
868: == d_erreur)
869: {
870: return;
871: }
872: }
873:
874: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
875: {
876: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
877: return;
878: }
879:
880: (*s_objet).objet = (void *) l_element_courant;
881:
882: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
883: s_objet) == d_erreur)
884: {
885: return;
886: }
887:
888: return;
889: }
890:
891:
892: /*
893: ================================================================================
894: Fonction 'for'
895: ================================================================================
896: Entrées : structure processus
897: --------------------------------------------------------------------------------
898: Sorties :
899: --------------------------------------------------------------------------------
900: Effets de bord : néant
901: ================================================================================
902: */
903:
904: void
905: instruction_for(struct_processus *s_etat_processus)
906: {
907: struct_objet *s_objet_1;
908: struct_objet *s_objet_2;
909: struct_objet *s_objet_3;
910:
911: struct_variable s_variable;
912:
913: unsigned char instruction_valide;
914: unsigned char *tampon;
915: unsigned char test_instruction;
916:
917: (*s_etat_processus).erreur_execution = d_ex;
918:
919: if ((*s_etat_processus).affichage_arguments == 'Y')
920: {
921: printf("\n FOR ");
922:
923: if ((*s_etat_processus).langue == 'F')
924: {
925: printf("(boucle définie avec compteur)\n\n");
926: }
927: else
928: {
929: printf("(define a counter-based loop)\n\n");
930: }
931:
932: if ((*s_etat_processus).langue == 'F')
933: {
934: printf(" Utilisation :\n\n");
935: }
936: else
937: {
938: printf(" Usage:\n\n");
939: }
940:
941: printf(" %s/%s %s/%s FOR (variable)\n", d_INT, d_REL,
942: d_INT, d_REL);
943: printf(" (expression)\n");
944: printf(" [EXIT]/[CYCLE]\n");
945: printf(" ...\n");
946: printf(" NEXT\n\n");
947:
948: printf(" %s/%s %s/%s FOR (variable)\n", d_INT, d_REL,
949: d_INT, d_REL);
950: printf(" (expression)\n");
951: printf(" [EXIT]/[CYCLE]\n");
952: printf(" ...\n");
953: printf(" %s/%s STEP\n", d_INT, d_REL);
954:
955: return;
956: }
957: else if ((*s_etat_processus).test_instruction == 'Y')
958: {
959: (*s_etat_processus).nombre_arguments = -1;
960: return;
961: }
962:
963: if ((*s_etat_processus).erreur_systeme != d_es)
964: {
965: return;
966: }
967:
968: if (test_cfsf(s_etat_processus, 31) == d_vrai)
969: {
970: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
971: {
972: return;
973: }
974: }
975:
976: empilement_pile_systeme(s_etat_processus);
977:
978: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
979: &s_objet_1) == d_erreur)
980: {
981: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
982: return;
983: }
984:
985: if (((*s_objet_1).type != INT) &&
986: ((*s_objet_1).type != REL))
987: {
988: liberation(s_etat_processus, s_objet_1);
989:
990: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
991: return;
992: }
993:
994: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
995: &s_objet_2) == d_erreur)
996: {
997: liberation(s_etat_processus, s_objet_1);
998:
999: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1000: return;
1001: }
1002:
1003: if (((*s_objet_2).type != INT) &&
1004: ((*s_objet_2).type != REL))
1005: {
1006: liberation(s_etat_processus, s_objet_1);
1007: liberation(s_etat_processus, s_objet_2);
1008:
1009: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
1010: return;
1011: }
1012:
1013: tampon = (*s_etat_processus).instruction_courante;
1014: test_instruction = (*s_etat_processus).test_instruction;
1015: instruction_valide = (*s_etat_processus).instruction_valide;
1016: (*s_etat_processus).test_instruction = 'Y';
1017:
1018: if ((*s_etat_processus).mode_execution_programme == 'Y')
1019: {
1020: if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
1021: {
1022: return;
1023: }
1024:
1025: analyse(s_etat_processus, NULL);
1026:
1027: if ((*s_etat_processus).instruction_valide == 'Y')
1028: {
1029: liberation(s_etat_processus, s_objet_1);
1030: liberation(s_etat_processus, s_objet_2);
1031:
1032: free((*s_etat_processus).instruction_courante);
1033: (*s_etat_processus).instruction_courante = tampon;
1034:
1035: (*s_etat_processus).erreur_execution = d_ex_nom_reserve;
1036: return;
1037: }
1038:
1039: recherche_type(s_etat_processus);
1040:
1041: free((*s_etat_processus).instruction_courante);
1042: (*s_etat_processus).instruction_courante = tampon;
1043:
1044: if ((*s_etat_processus).erreur_execution != d_ex)
1045: {
1046: liberation(s_etat_processus, s_objet_1);
1047: liberation(s_etat_processus, s_objet_2);
1048:
1049: return;
1050: }
1051:
1052: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1053: &s_objet_3) == d_erreur)
1054: {
1055: liberation(s_etat_processus, s_objet_1);
1056: liberation(s_etat_processus, s_objet_2);
1057:
1058: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1059: return;
1060: }
1061:
1062: (*(*s_etat_processus).l_base_pile_systeme)
1063: .origine_routine_evaluation = 'N';
1064: }
1065: else
1066: {
1067: if ((*s_etat_processus).expression_courante == NULL)
1068: {
1069: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1070: return;
1071: }
1072:
1073: (*s_etat_processus).expression_courante = (*(*s_etat_processus)
1074: .expression_courante).suivant;
1075:
1076: if ((s_objet_3 = copie_objet(s_etat_processus,
1077: (*(*s_etat_processus).expression_courante)
1078: .donnee, 'P')) == NULL)
1079: {
1080: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1081: return;
1082: }
1083:
1084: (*(*s_etat_processus).l_base_pile_systeme)
1085: .origine_routine_evaluation = 'Y';
1086: }
1087:
1088: if ((*s_objet_3).type != NOM)
1089: {
1090: liberation(s_etat_processus, s_objet_1);
1091: liberation(s_etat_processus, s_objet_2);
1092:
1093: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
1094: return;
1095: }
1096: else if ((*((struct_nom *) (*s_objet_3).objet)).symbole == d_vrai)
1097: {
1098: liberation(s_etat_processus, s_objet_1);
1099: liberation(s_etat_processus, s_objet_2);
1100:
1101: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
1102: return;
1103: }
1104:
1105: (*s_etat_processus).niveau_courant++;
1106:
1107: if ((s_variable.nom = malloc((strlen(
1108: (*((struct_nom *) (*s_objet_3).objet)).nom) + 1) *
1109: sizeof(unsigned char))) == NULL)
1110: {
1111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1112: return;
1113: }
1114:
1115: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_3).objet)).nom);
1116: s_variable.niveau = (*s_etat_processus).niveau_courant;
1117: s_variable.objet = s_objet_2;
1118:
1119: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') == d_erreur)
1120: {
1121: return;
1122: }
1123:
1124: liberation(s_etat_processus, s_objet_3);
1125:
1126: (*s_etat_processus).test_instruction = test_instruction;
1127: (*s_etat_processus).instruction_valide = instruction_valide;
1128:
1129: (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;
1130:
1131: if ((*s_etat_processus).mode_execution_programme == 'Y')
1132: {
1133: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
1134: (*s_etat_processus).position_courante;
1135: }
1136: else
1137: {
1138: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
1139: (*s_etat_processus).expression_courante;
1140: }
1141:
1142: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'F';
1143:
1144: if (((*(*s_etat_processus).l_base_pile_systeme).nom_variable =
1145: malloc((strlen(s_variable.nom) + 1) *
1146: sizeof(unsigned char))) == NULL)
1147: {
1148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1149: return;
1150: }
1151:
1152: strcpy((*(*s_etat_processus).l_base_pile_systeme).nom_variable,
1153: s_variable.nom);
1154:
1155: return;
1156: }
1157:
1158:
1159: /*
1160: ================================================================================
1161: Fonction 'fc?'
1162: ================================================================================
1163: Entrées : structure processus
1164: --------------------------------------------------------------------------------
1165: Sorties :
1166: --------------------------------------------------------------------------------
1167: Effets de bord : néant
1168: ================================================================================
1169: */
1170:
1171: void
1172: instruction_fc_test(struct_processus *s_etat_processus)
1173: {
1174: struct_objet *s_objet_argument;
1175: struct_objet *s_objet_resultat;
1176:
1177: (*s_etat_processus).erreur_execution = d_ex;
1178:
1179: if ((*s_etat_processus).affichage_arguments == 'Y')
1180: {
1181: printf("\n FC? ");
1182:
1183: if ((*s_etat_processus).langue == 'F')
1184: {
1185: printf("(teste si un drapeau est désarmé)\n\n");
1186: }
1187: else
1188: {
1189: printf("(test if flag is clear)\n\n");
1190: }
1191:
1192: printf(" 1: %s\n", d_INT);
1193: printf("-> 1: %s\n", d_INT);
1194:
1195: return;
1196: }
1197: else if ((*s_etat_processus).test_instruction == 'Y')
1198: {
1199: (*s_etat_processus).nombre_arguments = -1;
1200: return;
1201: }
1202:
1203: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1204: {
1205: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1206: {
1207: return;
1208: }
1209: }
1210:
1211: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1212: &s_objet_argument) == d_erreur)
1213: {
1214: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1215: return;
1216: }
1217:
1218: if ((*s_objet_argument).type == INT)
1219: {
1220: if (((*((integer8 *) (*s_objet_argument).objet)) < 1) ||
1221: ((*((integer8 *) (*s_objet_argument).objet)) > 64))
1222: {
1223: liberation(s_etat_processus, s_objet_argument);
1224:
1225: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
1226: return;
1227: }
1228:
1229: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1230: == NULL)
1231: {
1232: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1233: return;
1234: }
1235:
1236: if (test_cfsf(s_etat_processus, (unsigned char) (*((integer8 *)
1237: (*s_objet_argument).objet))) == d_vrai)
1238: {
1239: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
1240: }
1241: else
1242: {
1243: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
1244: }
1245: }
1246: else
1247: {
1248: liberation(s_etat_processus, s_objet_argument);
1249:
1250: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1251: return;
1252: }
1253:
1254: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1255: s_objet_resultat) == d_erreur)
1256: {
1257: return;
1258: }
1259:
1260: liberation(s_etat_processus, s_objet_argument);
1261:
1262: return;
1263: }
1264:
1265:
1266: /*
1267: ================================================================================
1268: Fonction 'fs?'
1269: ================================================================================
1270: Entrées : structure processus
1271: --------------------------------------------------------------------------------
1272: Sorties :
1273: --------------------------------------------------------------------------------
1274: Effets de bord : néant
1275: ================================================================================
1276: */
1277:
1278: void
1279: instruction_fs_test(struct_processus *s_etat_processus)
1280: {
1281: struct_objet *s_objet_argument;
1282: struct_objet *s_objet_resultat;
1283:
1284: (*s_etat_processus).erreur_execution = d_ex;
1285:
1286: if ((*s_etat_processus).affichage_arguments == 'Y')
1287: {
1288: printf("\n FS? ");
1289:
1290: if ((*s_etat_processus).langue == 'F')
1291: {
1292: printf("(teste si un drapeau est armé)\n\n");
1293: }
1294: else
1295: {
1296: printf("(test if flag is set)\n\n");
1297: }
1298:
1299: printf(" 1: %s\n", d_INT);
1300: printf("-> 1: %s\n", d_INT);
1301:
1302: return;
1303: }
1304: else if ((*s_etat_processus).test_instruction == 'Y')
1305: {
1306: (*s_etat_processus).nombre_arguments = -1;
1307: return;
1308: }
1309:
1310: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1311: {
1312: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1313: {
1314: return;
1315: }
1316: }
1317:
1318: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1319: &s_objet_argument) == d_erreur)
1320: {
1321: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1322: return;
1323: }
1324:
1325: if ((*s_objet_argument).type == INT)
1326: {
1327: if (((*((integer8 *) (*s_objet_argument).objet)) < 1) ||
1328: ((*((integer8 *) (*s_objet_argument).objet)) > 64))
1329: {
1330: liberation(s_etat_processus, s_objet_argument);
1331:
1332: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
1333: return;
1334: }
1335:
1336: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1337: == NULL)
1338: {
1339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1340: return;
1341: }
1342:
1343: if (test_cfsf(s_etat_processus, (unsigned char) (*((integer8 *)
1344: (*s_objet_argument).objet))) == d_vrai)
1345: {
1346: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
1347: }
1348: else
1349: {
1350: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
1351: }
1352: }
1353: else
1354: {
1355: liberation(s_etat_processus, s_objet_argument);
1356:
1357: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1358: return;
1359: }
1360:
1361: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1362: s_objet_resultat) == d_erreur)
1363: {
1364: return;
1365: }
1366:
1367: liberation(s_etat_processus, s_objet_argument);
1368:
1369: return;
1370: }
1371:
1372:
1373: /*
1374: ================================================================================
1375: Fonction 'fs?s'
1376: ================================================================================
1377: Entrées : structure processus
1378: --------------------------------------------------------------------------------
1379: Sorties :
1380: --------------------------------------------------------------------------------
1381: Effets de bord : néant
1382: ================================================================================
1383: */
1384:
1385: void
1386: instruction_fs_test_s(struct_processus *s_etat_processus)
1387: {
1388: (*s_etat_processus).erreur_execution = d_ex;
1389:
1390: if ((*s_etat_processus).affichage_arguments == 'Y')
1391: {
1392: printf("\n FS?S ");
1393:
1394: if ((*s_etat_processus).langue == 'F')
1395: {
1396: printf("(teste si un drapeau est armé et arme le drapeau)\n\n");
1397: }
1398: else
1399: {
1400: printf("(test if flag is set and set flag)\n\n");
1401: }
1402:
1403: printf(" 1: %s\n", d_INT);
1404: printf("-> 1: %s\n", d_INT);
1405:
1406: return;
1407: }
1408: else if ((*s_etat_processus).test_instruction == 'Y')
1409: {
1410: (*s_etat_processus).nombre_arguments = -1;
1411: return;
1412: }
1413:
1414: instruction_dup(s_etat_processus);
1415:
1416: if (((*s_etat_processus).erreur_systeme != d_es) ||
1417: ((*s_etat_processus).erreur_execution != d_ex))
1418: {
1419: return;
1420: }
1421:
1422: instruction_fs_test(s_etat_processus);
1423:
1424: if (((*s_etat_processus).erreur_systeme != d_es) ||
1425: ((*s_etat_processus).erreur_execution != d_ex))
1426: {
1427: return;
1428: }
1429:
1430: if (((*s_etat_processus).erreur_systeme != d_es) ||
1431: ((*s_etat_processus).erreur_execution != d_ex))
1432: {
1433: return;
1434: }
1435:
1436: instruction_swap(s_etat_processus);
1437:
1438: if (((*s_etat_processus).erreur_systeme != d_es) ||
1439: ((*s_etat_processus).erreur_execution != d_ex))
1440: {
1441: return;
1442: }
1443:
1444: instruction_sf(s_etat_processus);
1445:
1446: return;
1447: }
1448:
1449:
1450: /*
1451: ================================================================================
1452: Fonction 'fs?c'
1453: ================================================================================
1454: Entrées : structure processus
1455: --------------------------------------------------------------------------------
1456: Sorties :
1457: --------------------------------------------------------------------------------
1458: Effets de bord : néant
1459: ================================================================================
1460: */
1461:
1462: void
1463: instruction_fs_test_c(struct_processus *s_etat_processus)
1464: {
1465: (*s_etat_processus).erreur_execution = d_ex;
1466:
1467: if ((*s_etat_processus).affichage_arguments == 'Y')
1468: {
1469: printf("\n FS?C ");
1470:
1471: if ((*s_etat_processus).langue == 'F')
1472: {
1473: printf("(teste si un drapeau est armé et désarme le drapeau)\n\n");
1474: }
1475: else
1476: {
1477: printf("(test if flag is set and clear flag)\n\n");
1478: }
1479:
1480: printf(" 1: %s\n", d_INT);
1481: printf("-> 1: %s\n", d_INT);
1482:
1483: return;
1484: }
1485: else if ((*s_etat_processus).test_instruction == 'Y')
1486: {
1487: (*s_etat_processus).nombre_arguments = -1;
1488: return;
1489: }
1490:
1491: instruction_dup(s_etat_processus);
1492:
1493: if (((*s_etat_processus).erreur_systeme != d_es) ||
1494: ((*s_etat_processus).erreur_execution != d_ex))
1495: {
1496: return;
1497: }
1498:
1499: instruction_fs_test(s_etat_processus);
1500:
1501: if (((*s_etat_processus).erreur_systeme != d_es) ||
1502: ((*s_etat_processus).erreur_execution != d_ex))
1503: {
1504: return;
1505: }
1506:
1507: if (((*s_etat_processus).erreur_systeme != d_es) ||
1508: ((*s_etat_processus).erreur_execution != d_ex))
1509: {
1510: return;
1511: }
1512:
1513: instruction_swap(s_etat_processus);
1514:
1515: if (((*s_etat_processus).erreur_systeme != d_es) ||
1516: ((*s_etat_processus).erreur_execution != d_ex))
1517: {
1518: return;
1519: }
1520:
1521: instruction_cf(s_etat_processus);
1522:
1523: return;
1524: }
1525:
1526:
1527: /*
1528: ================================================================================
1529: Fonction 'fc?s'
1530: ================================================================================
1531: Entrées : structure processus
1532: --------------------------------------------------------------------------------
1533: Sorties :
1534: --------------------------------------------------------------------------------
1535: Effets de bord : néant
1536: ================================================================================
1537: */
1538:
1539: void
1540: instruction_fc_test_s(struct_processus *s_etat_processus)
1541: {
1542: (*s_etat_processus).erreur_execution = d_ex;
1543:
1544: if ((*s_etat_processus).affichage_arguments == 'Y')
1545: {
1546: printf("\n FC?S ");
1547:
1548: if ((*s_etat_processus).langue == 'F')
1549: {
1550: printf("(teste si un drapeau est désarmé et arme le drapeau)\n\n");
1551: }
1552: else
1553: {
1554: printf("(test if flag is clear and set flag)\n\n");
1555: }
1556:
1557: printf(" 1: %s\n", d_INT);
1558: printf("-> 1: %s\n", d_INT);
1559:
1560: return;
1561: }
1562: else if ((*s_etat_processus).test_instruction == 'Y')
1563: {
1564: (*s_etat_processus).nombre_arguments = -1;
1565: return;
1566: }
1567:
1568: instruction_dup(s_etat_processus);
1569:
1570: if (((*s_etat_processus).erreur_systeme != d_es) ||
1571: ((*s_etat_processus).erreur_execution != d_ex))
1572: {
1573: return;
1574: }
1575:
1576: instruction_fc_test(s_etat_processus);
1577:
1578: if (((*s_etat_processus).erreur_systeme != d_es) ||
1579: ((*s_etat_processus).erreur_execution != d_ex))
1580: {
1581: return;
1582: }
1583:
1584: if (((*s_etat_processus).erreur_systeme != d_es) ||
1585: ((*s_etat_processus).erreur_execution != d_ex))
1586: {
1587: return;
1588: }
1589:
1590: instruction_swap(s_etat_processus);
1591:
1592: if (((*s_etat_processus).erreur_systeme != d_es) ||
1593: ((*s_etat_processus).erreur_execution != d_ex))
1594: {
1595: return;
1596: }
1597:
1598: instruction_sf(s_etat_processus);
1599:
1600: return;
1601: }
1602:
1603:
1604: /*
1605: ================================================================================
1606: Fonction 'fc?c'
1607: ================================================================================
1608: Entrées : structure processus
1609: --------------------------------------------------------------------------------
1610: Sorties :
1611: --------------------------------------------------------------------------------
1612: Effets de bord : néant
1613: ================================================================================
1614: */
1615:
1616: void
1617: instruction_fc_test_c(struct_processus *s_etat_processus)
1618: {
1619: (*s_etat_processus).erreur_execution = d_ex;
1620:
1621: if ((*s_etat_processus).affichage_arguments == 'Y')
1622: {
1623: printf("\n FC?C ");
1624:
1625: if ((*s_etat_processus).langue == 'F')
1626: {
1627: printf("(teste si un drapeau est désarmé et désarme le drapeau)"
1628: "\n\n");
1629: }
1630: else
1631: {
1632: printf("(test if flag is clear and clear flag)\n\n");
1633: }
1634:
1635: printf(" 1: %s\n", d_INT);
1636: printf("-> 1: %s\n", d_INT);
1637:
1638: return;
1639: }
1640: else if ((*s_etat_processus).test_instruction == 'Y')
1641: {
1642: (*s_etat_processus).nombre_arguments = -1;
1643: return;
1644: }
1645:
1646: instruction_dup(s_etat_processus);
1647:
1648: if (((*s_etat_processus).erreur_systeme != d_es) ||
1649: ((*s_etat_processus).erreur_execution != d_ex))
1650: {
1651: return;
1652: }
1653:
1654: instruction_fc_test(s_etat_processus);
1655:
1656: if (((*s_etat_processus).erreur_systeme != d_es) ||
1657: ((*s_etat_processus).erreur_execution != d_ex))
1658: {
1659: return;
1660: }
1661:
1662: if (((*s_etat_processus).erreur_systeme != d_es) ||
1663: ((*s_etat_processus).erreur_execution != d_ex))
1664: {
1665: return;
1666: }
1667:
1668: instruction_swap(s_etat_processus);
1669:
1670: if (((*s_etat_processus).erreur_systeme != d_es) ||
1671: ((*s_etat_processus).erreur_execution != d_ex))
1672: {
1673: return;
1674: }
1675:
1676: instruction_cf(s_etat_processus);
1677:
1678: return;
1679: }
1680:
1681:
1682: /*
1683: ================================================================================
1684: Fonction 'fact'
1685: ================================================================================
1686: Entrées :
1687: --------------------------------------------------------------------------------
1688: Sorties :
1689: --------------------------------------------------------------------------------
1690: Effets de bord : néant
1691: ================================================================================
1692: */
1693:
1694: void
1695: instruction_fact(struct_processus *s_etat_processus)
1696: {
1697: logical1 depassement;
1698:
1699: real8 produit;
1700:
1701: integer8 i;
1702: integer8 ifact;
1703: integer8 tampon;
1704:
1705: struct_liste_chainee *l_element_courant;
1706: struct_liste_chainee *l_element_precedent;
1707:
1708: struct_objet *s_copie_argument;
1709: struct_objet *s_objet_argument;
1710: struct_objet *s_objet_resultat;
1711:
1712: (*s_etat_processus).erreur_execution = d_ex;
1713:
1714: if ((*s_etat_processus).affichage_arguments == 'Y')
1715: {
1716: printf("\n FACT ");
1717:
1718: if ((*s_etat_processus).langue == 'F')
1719: {
1720: printf("(factorielle)\n\n");
1721: }
1722: else
1723: {
1724: printf("(factorial)\n\n");
1725: }
1726:
1727: printf(" 1: %s\n", d_INT);
1728: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
1729:
1730: printf(" 1: %s, %s\n", d_NOM, d_ALG);
1731: printf("-> 1: %s\n\n", d_ALG);
1732:
1733: printf(" 1: %s\n", d_RPN);
1734: printf("-> 1: %s\n", d_RPN);
1735:
1736: return;
1737: }
1738: else if ((*s_etat_processus).test_instruction == 'Y')
1739: {
1740: (*s_etat_processus).nombre_arguments = 1;
1741: return;
1742: }
1743:
1744: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1745: {
1746: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1747: {
1748: return;
1749: }
1750: }
1751:
1752: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1753: &s_objet_argument) == d_erreur)
1754: {
1755: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1756: return;
1757: }
1758:
1759: /*
1760: --------------------------------------------------------------------------------
1761: Calcul de la factorielle d'un entier (résultat réel)
1762: --------------------------------------------------------------------------------
1763: */
1764:
1765: if ((*s_objet_argument).type == INT)
1766: {
1767: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
1768: {
1769: if (test_cfsf(s_etat_processus, 59) == d_vrai)
1770: {
1771: liberation(s_etat_processus, s_objet_argument);
1772:
1773: (*s_etat_processus).exception = d_ep_overflow;
1774: return;
1775: }
1776: else
1777: {
1778: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1779: == NULL)
1780: {
1781: (*s_etat_processus).erreur_systeme =
1782: d_es_allocation_memoire;
1783: return;
1784: }
1785:
1786: (*((real8 *) (*s_objet_resultat).objet)) =
1787: ((double) 1) / ((double) 0);
1788: }
1789: }
1790: else
1791: {
1792: ifact = 1;
1793: depassement = d_faux;
1794:
1795: for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet)); i++)
1796: {
1797: if (depassement_multiplication(&ifact, &i, &tampon) == d_erreur)
1798: {
1799: depassement = d_vrai;
1800: break;
1801: }
1802:
1803: ifact = tampon;
1804: }
1805:
1806: if (depassement == d_faux)
1807: {
1808: if ((s_objet_resultat = allocation(s_etat_processus, INT))
1809: == NULL)
1810: {
1811: (*s_etat_processus).erreur_systeme =
1812: d_es_allocation_memoire;
1813: return;
1814: }
1815:
1816: (*((integer8 *) (*s_objet_resultat).objet)) = ifact;
1817: }
1818: else
1819: {
1820: produit = 1;
1821:
1822: for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet));
1823: i++)
1824: {
1825: produit *= i;
1826: }
1827:
1828: if ((s_objet_resultat = allocation(s_etat_processus, REL))
1829: == NULL)
1830: {
1831: (*s_etat_processus).erreur_systeme =
1832: d_es_allocation_memoire;
1833: return;
1834: }
1835:
1836: (*((real8 *) (*s_objet_resultat).objet)) = produit;
1837: }
1838: }
1839: }
1840:
1841: /*
1842: --------------------------------------------------------------------------------
1843: Factorielle d'un nom
1844: --------------------------------------------------------------------------------
1845: */
1846:
1847: else if ((*s_objet_argument).type == NOM)
1848: {
1849: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
1850: == NULL)
1851: {
1852: (*s_etat_processus).erreur_systeme =
1853: d_es_allocation_memoire;
1854: return;
1855: }
1856:
1857: if (((*s_objet_resultat).objet =
1858: allocation_maillon(s_etat_processus)) == NULL)
1859: {
1860: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1861: return;
1862: }
1863:
1864: l_element_courant = (*s_objet_resultat).objet;
1865:
1866: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1867: == NULL)
1868: {
1869: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1870: return;
1871: }
1872:
1873: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1874: .nombre_arguments = 0;
1875: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1876: .fonction = instruction_vers_niveau_superieur;
1877:
1878: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1879: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1880: {
1881: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1882: return;
1883: }
1884:
1885: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1886: .nom_fonction, "<<");
1887:
1888: if (((*l_element_courant).suivant =
1889: allocation_maillon(s_etat_processus)) == NULL)
1890: {
1891: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1892: return;
1893: }
1894:
1895: l_element_courant = (*l_element_courant).suivant;
1896: (*l_element_courant).donnee = s_objet_argument;
1897:
1898: if (((*l_element_courant).suivant =
1899: allocation_maillon(s_etat_processus)) == NULL)
1900: {
1901: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1902: return;
1903: }
1904:
1905: l_element_courant = (*l_element_courant).suivant;
1906:
1907: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1908: == NULL)
1909: {
1910: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1911: return;
1912: }
1913:
1914: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1915: .nombre_arguments = 1;
1916: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1917: .fonction = instruction_fact;
1918:
1919: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1920: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
1921: {
1922: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1923: return;
1924: }
1925:
1926: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1927: .nom_fonction, "FACT");
1928:
1929: if (((*l_element_courant).suivant =
1930: allocation_maillon(s_etat_processus)) == NULL)
1931: {
1932: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1933: return;
1934: }
1935:
1936: l_element_courant = (*l_element_courant).suivant;
1937:
1938: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
1939: == NULL)
1940: {
1941: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1942: return;
1943: }
1944:
1945: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1946: .nombre_arguments = 0;
1947: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1948: .fonction = instruction_vers_niveau_inferieur;
1949:
1950: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1951: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
1952: {
1953: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1954: return;
1955: }
1956:
1957: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
1958: .nom_fonction, ">>");
1959:
1960: (*l_element_courant).suivant = NULL;
1961: s_objet_argument = NULL;
1962: }
1963:
1964: /*
1965: --------------------------------------------------------------------------------
1966: Factorielle d'une expression
1967: --------------------------------------------------------------------------------
1968: */
1969:
1970: else if (((*s_objet_argument).type == ALG) ||
1971: ((*s_objet_argument).type == RPN))
1972: {
1973: if ((s_copie_argument = copie_objet(s_etat_processus,
1974: s_objet_argument, 'N')) == NULL)
1975: {
1976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1977: return;
1978: }
1979:
1980: l_element_courant = (struct_liste_chainee *)
1981: (*s_copie_argument).objet;
1982: l_element_precedent = l_element_courant;
1983:
1984: while((*l_element_courant).suivant != NULL)
1985: {
1986: l_element_precedent = l_element_courant;
1987: l_element_courant = (*l_element_courant).suivant;
1988: }
1989:
1990: if (((*l_element_precedent).suivant =
1991: allocation_maillon(s_etat_processus)) == NULL)
1992: {
1993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1994: return;
1995: }
1996:
1997: if (((*(*l_element_precedent).suivant).donnee =
1998: allocation(s_etat_processus, FCT)) == NULL)
1999: {
2000: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2001: return;
2002: }
2003:
2004: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2005: .donnee).objet)).nombre_arguments = 1;
2006: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2007: .donnee).objet)).fonction = instruction_fact;
2008:
2009: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2010: .suivant).donnee).objet)).nom_fonction =
2011: malloc(5 * sizeof(unsigned char))) == NULL)
2012: {
2013: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2014: return;
2015: }
2016:
2017: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2018: .suivant).donnee).objet)).nom_fonction, "FACT");
2019:
2020: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2021:
2022: s_objet_resultat = s_copie_argument;
2023: }
2024:
2025: /*
2026: --------------------------------------------------------------------------------
2027: Factorielle impossible à réaliser
2028: --------------------------------------------------------------------------------
2029: */
2030:
2031: else
2032: {
2033: liberation(s_etat_processus, s_objet_argument);
2034:
2035: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2036: return;
2037: }
2038:
2039: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2040: s_objet_resultat) == d_erreur)
2041: {
2042: return;
2043: }
2044:
2045: liberation(s_etat_processus, s_objet_argument);
2046:
2047: return;
2048: }
2049:
2050:
2051: /*
2052: ================================================================================
2053: Fonction 'floor'
2054: ================================================================================
2055: Entrées :
2056: --------------------------------------------------------------------------------
2057: Sorties :
2058: --------------------------------------------------------------------------------
2059: Effets de bord : néant
2060: ================================================================================
2061: */
2062:
2063: void
2064: instruction_floor(struct_processus *s_etat_processus)
2065: {
2066: struct_liste_chainee *l_element_courant;
2067: struct_liste_chainee *l_element_precedent;
2068:
2069: struct_objet *s_copie_argument;
2070: struct_objet *s_objet_argument;
2071: struct_objet *s_objet_resultat;
2072:
2073: (*s_etat_processus).erreur_execution = d_ex;
2074:
2075: if ((*s_etat_processus).affichage_arguments == 'Y')
2076: {
2077: printf("\n FLOOR ");
2078:
2079: if ((*s_etat_processus).langue == 'F')
2080: {
2081: printf("(valeur plancher)\n\n");
2082: }
2083: else
2084: {
2085: printf("(floor value)\n\n");
2086: }
2087:
2088: printf(" 1: %s\n", d_INT);
2089: printf("-> 1: %s\n\n", d_INT);
2090:
2091: printf(" 1: %s\n", d_REL);
2092: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
2093:
2094: printf(" 1: %s, %s\n", d_NOM, d_ALG);
2095: printf("-> 1: %s\n\n", d_ALG);
2096:
2097: printf(" 1: %s\n", d_RPN);
2098: printf("-> 1: %s\n", d_RPN);
2099:
2100: return;
2101: }
2102: else if ((*s_etat_processus).test_instruction == 'Y')
2103: {
2104: (*s_etat_processus).nombre_arguments = 1;
2105: return;
2106: }
2107:
2108: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2109: {
2110: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2111: {
2112: return;
2113: }
2114: }
2115:
2116: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2117: &s_objet_argument) == d_erreur)
2118: {
2119: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2120: return;
2121: }
2122:
2123: /*
2124: --------------------------------------------------------------------------------
2125: Plancher d'un entier
2126: --------------------------------------------------------------------------------
2127: */
2128:
2129: if ((*s_objet_argument).type == INT)
2130: {
2131: s_objet_resultat = s_objet_argument;
2132: s_objet_argument = NULL;
2133: }
2134:
2135: /*
2136: --------------------------------------------------------------------------------
2137: Plancher d'un réel
2138: --------------------------------------------------------------------------------
2139: */
2140:
2141: else if ((*s_objet_argument).type == REL)
2142: {
2143: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
2144: {
2145: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2146: return;
2147: }
2148:
2149: (*((integer8 *) (*s_objet_resultat).objet)) =
2150: floor((*((real8 *) (*s_objet_argument).objet)));
2151:
2152: if (!((((*((integer8 *) (*s_objet_resultat).objet)) <
2153: (*((real8 *) (*s_objet_argument).objet))) && (((*((integer8 *)
2154: (*s_objet_resultat).objet)) + 1) > (*((real8 *)
2155: (*s_objet_argument).objet))))))
2156: {
2157: free((*s_objet_resultat).objet);
2158:
2159: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
2160: {
2161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2162: return;
2163: }
2164:
2165: (*s_objet_resultat).type = REL;
2166: (*((real8 *) (*s_objet_resultat).objet)) =
2167: ceil((*((real8 *) (*s_objet_argument).objet)));
2168: }
2169: }
2170:
2171: /*
2172: --------------------------------------------------------------------------------
2173: Plancher d'un nom
2174: --------------------------------------------------------------------------------
2175: */
2176:
2177: else if ((*s_objet_argument).type == NOM)
2178: {
2179: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
2180: {
2181: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2182: return;
2183: }
2184:
2185: if (((*s_objet_resultat).objet =
2186: allocation_maillon(s_etat_processus)) == NULL)
2187: {
2188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2189: return;
2190: }
2191:
2192: l_element_courant = (*s_objet_resultat).objet;
2193:
2194: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2195: == NULL)
2196: {
2197: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2198: return;
2199: }
2200:
2201: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2202: .nombre_arguments = 0;
2203: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2204: .fonction = instruction_vers_niveau_superieur;
2205:
2206: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2207: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2208: {
2209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2210: return;
2211: }
2212:
2213: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2214: .nom_fonction, "<<");
2215:
2216: if (((*l_element_courant).suivant =
2217: allocation_maillon(s_etat_processus)) == NULL)
2218: {
2219: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2220: return;
2221: }
2222:
2223: l_element_courant = (*l_element_courant).suivant;
2224: (*l_element_courant).donnee = s_objet_argument;
2225:
2226: if (((*l_element_courant).suivant =
2227: allocation_maillon(s_etat_processus)) == NULL)
2228: {
2229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2230: return;
2231: }
2232:
2233: l_element_courant = (*l_element_courant).suivant;
2234:
2235: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2236: == NULL)
2237: {
2238: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2239: return;
2240: }
2241:
2242: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2243: .nombre_arguments = 1;
2244: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2245: .fonction = instruction_floor;
2246:
2247: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2248: .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
2249: {
2250: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2251: return;
2252: }
2253:
2254: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2255: .nom_fonction, "FLOOR");
2256:
2257: if (((*l_element_courant).suivant =
2258: allocation_maillon(s_etat_processus)) == NULL)
2259: {
2260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2261: return;
2262: }
2263:
2264: l_element_courant = (*l_element_courant).suivant;
2265:
2266: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2267: == NULL)
2268: {
2269: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2270: return;
2271: }
2272:
2273: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2274: .nombre_arguments = 0;
2275: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2276: .fonction = instruction_vers_niveau_inferieur;
2277:
2278: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2279: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2280: {
2281: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2282: return;
2283: }
2284:
2285: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2286: .nom_fonction, ">>");
2287:
2288: (*l_element_courant).suivant = NULL;
2289: s_objet_argument = NULL;
2290: }
2291:
2292: /*
2293: --------------------------------------------------------------------------------
2294: Plancher d'une expression
2295: --------------------------------------------------------------------------------
2296: */
2297:
2298: else if (((*s_objet_argument).type == ALG) ||
2299: ((*s_objet_argument).type == RPN))
2300: {
2301: if ((s_copie_argument = copie_objet(s_etat_processus,
2302: s_objet_argument, 'N')) == NULL)
2303: {
2304: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2305: return;
2306: }
2307:
2308: l_element_courant = (struct_liste_chainee *)
2309: (*s_copie_argument).objet;
2310: l_element_precedent = l_element_courant;
2311:
2312: while((*l_element_courant).suivant != NULL)
2313: {
2314: l_element_precedent = l_element_courant;
2315: l_element_courant = (*l_element_courant).suivant;
2316: }
2317:
2318: if (((*l_element_precedent).suivant =
2319: allocation_maillon(s_etat_processus)) == NULL)
2320: {
2321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2322: return;
2323: }
2324:
2325: if (((*(*l_element_precedent).suivant).donnee =
2326: allocation(s_etat_processus, FCT)) == NULL)
2327: {
2328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2329: return;
2330: }
2331:
2332: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2333: .donnee).objet)).nombre_arguments = 1;
2334: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2335: .donnee).objet)).fonction = instruction_floor;
2336:
2337: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2338: .suivant).donnee).objet)).nom_fonction =
2339: malloc(6 * sizeof(unsigned char))) == NULL)
2340: {
2341: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2342: return;
2343: }
2344:
2345: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2346: .suivant).donnee).objet)).nom_fonction, "FLOOR");
2347:
2348: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2349:
2350: s_objet_resultat = s_copie_argument;
2351: }
2352:
2353: /*
2354: --------------------------------------------------------------------------------
2355: Fonction floor impossible à réaliser
2356: --------------------------------------------------------------------------------
2357: */
2358:
2359: else
2360: {
2361: liberation(s_etat_processus, s_objet_argument);
2362:
2363: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2364: return;
2365: }
2366:
2367: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2368: s_objet_resultat) == d_erreur)
2369: {
2370: return;
2371: }
2372:
2373: liberation(s_etat_processus, s_objet_argument);
2374:
2375: return;
2376: }
2377:
2378:
2379: /*
2380: ================================================================================
2381: Fonction 'fp'
2382: ================================================================================
2383: Entrées :
2384: --------------------------------------------------------------------------------
2385: Sorties :
2386: --------------------------------------------------------------------------------
2387: Effets de bord : néant
2388: ================================================================================
2389: */
2390:
2391: void
2392: instruction_fp(struct_processus *s_etat_processus)
2393: {
2394: struct_liste_chainee *l_element_courant;
2395: struct_liste_chainee *l_element_precedent;
2396:
2397: struct_objet *s_copie_argument;
2398: struct_objet *s_objet_argument;
2399: struct_objet *s_objet_resultat;
2400:
2401: (*s_etat_processus).erreur_execution = d_ex;
2402:
2403: if ((*s_etat_processus).affichage_arguments == 'Y')
2404: {
2405: printf("\n FP ");
2406:
2407: if ((*s_etat_processus).langue == 'F')
2408: {
2409: printf("(part fractionnaire)\n\n");
2410: }
2411: else
2412: {
2413: printf("(fractional part)\n\n");
2414: }
2415:
2416: printf(" 1: %s, %s\n", d_INT, d_REL);
2417: printf("-> 1: %s\n\n", d_REL);
2418:
2419: printf(" 1: %s, %s\n", d_NOM, d_ALG);
2420: printf("-> 1: %s\n\n", d_ALG);
2421:
2422: printf(" 1: %s\n", d_RPN);
2423: printf("-> 1: %s\n", d_RPN);
2424:
2425: return;
2426: }
2427: else if ((*s_etat_processus).test_instruction == 'Y')
2428: {
2429: (*s_etat_processus).nombre_arguments = 1;
2430: return;
2431: }
2432:
2433: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2434: {
2435: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2436: {
2437: return;
2438: }
2439: }
2440:
2441: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2442: &s_objet_argument) == d_erreur)
2443: {
2444: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2445: return;
2446: }
2447:
2448: /*
2449: --------------------------------------------------------------------------------
2450: fp d'un entier
2451: --------------------------------------------------------------------------------
2452: */
2453:
2454: if ((*s_objet_argument).type == INT)
2455: {
2456: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2457: == NULL)
2458: {
2459: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2460: return;
2461: }
2462:
2463: (*((real8 *) (*s_objet_resultat).objet)) = 0;
2464: }
2465:
2466: /*
2467: --------------------------------------------------------------------------------
2468: fp d'un réel
2469: --------------------------------------------------------------------------------
2470: */
2471:
2472: else if ((*s_objet_argument).type == REL)
2473: {
2474: if ((s_objet_resultat = allocation(s_etat_processus, REL))
2475: == NULL)
2476: {
2477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2478: return;
2479: }
2480:
2481: if ((*((real8 *) (*s_objet_argument).objet)) > 0)
2482: {
2483: (*((real8 *) (*s_objet_resultat).objet)) =
2484: (*((real8 *) (*s_objet_argument).objet)) -
2485: floor((*((real8 *) (*s_objet_argument).objet)));
2486: }
2487: else
2488: {
2489: (*((real8 *) (*s_objet_resultat).objet)) =
2490: (*((real8 *) (*s_objet_argument).objet)) -
2491: ceil((*((real8 *) (*s_objet_argument).objet)));
2492: }
2493: }
2494:
2495: /*
2496: --------------------------------------------------------------------------------
2497: fp d'un nom
2498: --------------------------------------------------------------------------------
2499: */
2500:
2501: else if ((*s_objet_argument).type == NOM)
2502: {
2503: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
2504: == NULL)
2505: {
2506: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2507: return;
2508: }
2509:
2510: if (((*s_objet_resultat).objet =
2511: allocation_maillon(s_etat_processus)) == NULL)
2512: {
2513: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2514: return;
2515: }
2516:
2517: l_element_courant = (*s_objet_resultat).objet;
2518:
2519: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2520: == NULL)
2521: {
2522: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2523: return;
2524: }
2525:
2526: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2527: .nombre_arguments = 0;
2528: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2529: .fonction = instruction_vers_niveau_superieur;
2530:
2531: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2532: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2533: {
2534: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2535: return;
2536: }
2537:
2538: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2539: .nom_fonction, "<<");
2540:
2541: if (((*l_element_courant).suivant =
2542: allocation_maillon(s_etat_processus)) == NULL)
2543: {
2544: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2545: return;
2546: }
2547:
2548: l_element_courant = (*l_element_courant).suivant;
2549: (*l_element_courant).donnee = s_objet_argument;
2550:
2551: if (((*l_element_courant).suivant =
2552: allocation_maillon(s_etat_processus)) == NULL)
2553: {
2554: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2555: return;
2556: }
2557:
2558: l_element_courant = (*l_element_courant).suivant;
2559:
2560: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2561: == NULL)
2562: {
2563: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2564: return;
2565: }
2566:
2567: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2568: .nombre_arguments = 1;
2569: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2570: .fonction = instruction_fp;
2571:
2572: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2573: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2574: {
2575: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2576: return;
2577: }
2578:
2579: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2580: .nom_fonction, "FP");
2581:
2582: if (((*l_element_courant).suivant =
2583: allocation_maillon(s_etat_processus)) == NULL)
2584: {
2585: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2586: return;
2587: }
2588:
2589: l_element_courant = (*l_element_courant).suivant;
2590:
2591: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
2592: == NULL)
2593: {
2594: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2595: return;
2596: }
2597:
2598: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2599: .nombre_arguments = 0;
2600: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2601: .fonction = instruction_vers_niveau_inferieur;
2602:
2603: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2604: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
2605: {
2606: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2607: return;
2608: }
2609:
2610: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
2611: .nom_fonction, ">>");
2612:
2613: (*l_element_courant).suivant = NULL;
2614: s_objet_argument = NULL;
2615: }
2616:
2617: /*
2618: --------------------------------------------------------------------------------
2619: fp d'une expression
2620: --------------------------------------------------------------------------------
2621: */
2622:
2623: else if (((*s_objet_argument).type == ALG) ||
2624: ((*s_objet_argument).type == RPN))
2625: {
2626: if ((s_copie_argument = copie_objet(s_etat_processus,
2627: s_objet_argument, 'N')) == NULL)
2628: {
2629: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2630: return;
2631: }
2632:
2633: l_element_courant = (struct_liste_chainee *)
2634: (*s_copie_argument).objet;
2635: l_element_precedent = l_element_courant;
2636:
2637: while((*l_element_courant).suivant != NULL)
2638: {
2639: l_element_precedent = l_element_courant;
2640: l_element_courant = (*l_element_courant).suivant;
2641: }
2642:
2643: if (((*l_element_precedent).suivant =
2644: allocation_maillon(s_etat_processus)) == NULL)
2645: {
2646: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2647: return;
2648: }
2649:
2650: if (((*(*l_element_precedent).suivant).donnee =
2651: allocation(s_etat_processus, FCT)) == NULL)
2652: {
2653: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2654: return;
2655: }
2656:
2657: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2658: .donnee).objet)).nombre_arguments = 1;
2659: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
2660: .donnee).objet)).fonction = instruction_fp;
2661:
2662: if (((*((struct_fonction *) (*(*(*l_element_precedent)
2663: .suivant).donnee).objet)).nom_fonction =
2664: malloc(3 * sizeof(unsigned char))) == NULL)
2665: {
2666: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2667: return;
2668: }
2669:
2670: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
2671: .suivant).donnee).objet)).nom_fonction, "FP");
2672:
2673: (*(*l_element_precedent).suivant).suivant = l_element_courant;
2674:
2675: s_objet_resultat = s_copie_argument;
2676: }
2677:
2678: /*
2679: --------------------------------------------------------------------------------
2680: Fonction fp impossible à réaliser
2681: --------------------------------------------------------------------------------
2682: */
2683:
2684: else
2685: {
2686: liberation(s_etat_processus, s_objet_argument);
2687:
2688: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2689: return;
2690: }
2691:
2692: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2693: s_objet_resultat) == d_erreur)
2694: {
2695: return;
2696: }
2697:
2698: liberation(s_etat_processus, s_objet_argument);
2699:
2700: return;
2701: }
2702:
2703:
2704: /*
2705: ================================================================================
2706: Fonction 'fix'
2707: ================================================================================
2708: Entrées : pointeur sur une struct_processus
2709: --------------------------------------------------------------------------------
2710: Sorties :
2711: --------------------------------------------------------------------------------
2712: Effets de bord : néant
2713: ================================================================================
2714: */
2715:
2716: void
2717: instruction_fix(struct_processus *s_etat_processus)
2718: {
2719: struct_objet *s_objet_argument;
2720: struct_objet *s_objet;
2721:
2722: logical1 i43;
2723: logical1 i44;
2724:
2725: unsigned char *valeur_binaire;
2726:
2727: unsigned long i;
2728: unsigned long j;
2729:
2730: (*s_etat_processus).erreur_execution = d_ex;
2731:
2732: if ((*s_etat_processus).affichage_arguments == 'Y')
2733: {
2734: printf("\n FIX ");
2735:
2736: if ((*s_etat_processus).langue == 'F')
2737: {
2738: printf("(format virgule fixe)\n\n");
2739: }
2740: else
2741: {
2742: printf("(fixed point format)\n\n");
2743: }
2744:
2745: printf(" 1: %s\n", d_INT);
2746:
2747: return;
2748: }
2749: else if ((*s_etat_processus).test_instruction == 'Y')
2750: {
2751: (*s_etat_processus).nombre_arguments = -1;
2752: return;
2753: }
2754:
2755: if (test_cfsf(s_etat_processus, 31) == d_vrai)
2756: {
2757: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
2758: {
2759: return;
2760: }
2761: }
2762:
2763: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2764: &s_objet_argument) == d_erreur)
2765: {
2766: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
2767: return;
2768: }
2769:
2770: if ((*s_objet_argument).type == INT)
2771: {
2772: if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) &&
2773: ((*((integer8 *) (*s_objet_argument).objet)) <= 15))
2774: {
2775: if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
2776: {
2777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2778: return;
2779: }
2780:
2781: (*((logical8 *) (*s_objet).objet)) =
2782: (*((integer8 *) (*s_objet_argument).objet));
2783:
2784: i43 = test_cfsf(s_etat_processus, 43);
2785: i44 = test_cfsf(s_etat_processus, 44);
2786:
2787: sf(s_etat_processus, 44);
2788: cf(s_etat_processus, 43);
2789:
2790: if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet))
2791: == NULL)
2792: {
2793: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2794: return;
2795: }
2796:
2797: if (i43 == d_vrai)
2798: {
2799: sf(s_etat_processus, 43);
2800: }
2801: else
2802: {
2803: cf(s_etat_processus, 43);
2804: }
2805:
2806: if (i44 == d_vrai)
2807: {
2808: sf(s_etat_processus, 44);
2809: }
2810: else
2811: {
2812: cf(s_etat_processus, 44);
2813: }
2814:
2815: for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--)
2816: {
2817: if (valeur_binaire[i] == '0')
2818: {
2819: cf(s_etat_processus, j++);
2820: }
2821: else
2822: {
2823: sf(s_etat_processus, j++);
2824: }
2825: }
2826:
2827: for(; j <= 56; cf(s_etat_processus, j++));
2828:
2829: sf(s_etat_processus, 49);
2830: cf(s_etat_processus, 50);
2831:
2832: free(valeur_binaire);
2833: liberation(s_etat_processus, s_objet);
2834: }
2835: else
2836: {
2837: liberation(s_etat_processus, s_objet_argument);
2838:
2839: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
2840: return;
2841: }
2842: }
2843: else
2844: {
2845: liberation(s_etat_processus, s_objet_argument);
2846:
2847: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2848: return;
2849: }
2850:
2851: liberation(s_etat_processus, s_objet_argument);
2852:
2853: return;
2854: }
2855:
2856: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_f1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src