![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optimisation.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to optimisation.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.16 ! bertrand 3: RPL/2 (R) version 4.0.20
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:
1.13 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
1.3 bertrand 28: Boucle principale optimisé de l'interprète RPL/2
1.1 bertrand 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: logical1
39: sequenceur_optimise(struct_processus *s_etat_processus)
40: {
41: logical1 erreur;
42:
43: long i;
44: long point_entree;
45:
46: unsigned char *message;
47:
48: unsigned long adresse_point_entree;
49:
50: if ((*s_etat_processus).debug == d_vrai)
51: if (((*s_etat_processus).type_debug &
52: d_debug_analyse) != 0)
53: {
54: if ((*s_etat_processus).langue == 'F')
55: {
56: printf("[%d] Optimisation\n", (int) getpid());
57: }
58: else
59: {
60: printf("+++Optimization [%d]\n", (int) getpid());
61: }
62:
63: printf("\n");
64: fflush(stdout);
65: }
66:
67: point_entree = -1;
68: adresse_point_entree = 0;
69:
70: empilement_pile_systeme(s_etat_processus);
71: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
72: (*s_etat_processus).autorisation_empilement_programme = 'Y';
73: (*s_etat_processus).mode_execution_programme = 'N';
74:
75: for(i = 0; i < (long) (*s_etat_processus).nombre_variables; i++)
76: {
77: if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
78: {
79: // Variables qui contiennent les points d'entrée des définitions.
80:
81: (*s_etat_processus).position_courante = (*((unsigned long *)
82: (*((*s_etat_processus).s_liste_variables[i].objet)).objet));
83:
84: if (point_entree == -1)
85: {
86: adresse_point_entree = (*s_etat_processus).position_courante;
87: point_entree = i;
88: }
89: else
90: {
91: if ((*s_etat_processus).position_courante <
92: adresse_point_entree)
93: {
94: adresse_point_entree = (*s_etat_processus)
95: .position_courante;
96: point_entree = i;
97: }
98: }
99:
100: if ((erreur = recherche_instruction_suivante(s_etat_processus))
101: == d_erreur)
102: {
103: if ((*s_etat_processus).langue == 'F')
104: {
105: printf("+++Fatal : Optimisation impossible\n");
106: }
107: else
108: {
109: printf("+++Fatal : Optimization failed\n");
110: }
111:
112: return(d_erreur);
113: }
114:
115: recherche_type(s_etat_processus);
116:
117: if (((*s_etat_processus).erreur_execution != d_ex) ||
118: ((*s_etat_processus).erreur_systeme != d_es))
119: {
120: if ((*s_etat_processus).langue == 'F')
121: {
122: printf("+++Fatal : Optimisation impossible\n");
123: }
124: else
125: {
126: printf("+++Fatal : Optimization failed\n");
127: }
128:
129: return(d_erreur);
130: }
131:
132: liberation(s_etat_processus,
133: (*s_etat_processus).s_liste_variables[i].objet);
134:
135: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
136: &((*s_etat_processus).s_liste_variables[i].objet))
137: == d_erreur)
138: {
139: if ((*s_etat_processus).langue == 'F')
140: {
141: printf("+++Fatal : Optimisation impossible\n");
142: }
143: else
144: {
145: printf("+++Fatal : Optimization failed\n");
146: }
147:
148: return(d_erreur);
149: }
150:
151: (*s_etat_processus).s_liste_variables[i].origine = 'E';
152: free((*s_etat_processus).instruction_courante);
153: }
154: }
155:
156: if (point_entree == -1)
157: {
158: if ((*s_etat_processus).langue == 'F')
159: {
160: printf("+++Fatal : Optimisation impossible\n");
161: }
162: else
163: {
164: printf("+++Fatal : Optimization failed\n");
165: }
166:
167: return(d_erreur);
168: }
169:
170: if ((*s_etat_processus).debug == d_vrai)
171: {
172: if (((*s_etat_processus).type_debug &
173: d_debug_analyse) != 0)
174: {
175: printf("\n");
176:
177: if ((*s_etat_processus).langue == 'F')
178: {
179: printf("[%d] Optimisation achevée\n", (int) getpid());
180: }
181: else
182: {
183: printf("[%d] Optimization done\n", (int) getpid());
184: }
185:
186: printf("\n");
187: fflush(stdout);
188: }
189: }
190:
191: (*s_etat_processus).retour_routine_evaluation = 'Y';
192:
193: free((*s_etat_processus).definitions_chainees);
194:
195: if (((*s_etat_processus).definitions_chainees =
196: malloc(sizeof(unsigned char))) == NULL)
197: {
198: if ((*s_etat_processus).langue == 'F')
199: {
200: printf("+++Fatal : Optimisation impossible\n");
201: }
202: else
203: {
204: printf("+++Fatal : Optimization failed\n");
205: }
206:
207: return(d_erreur);
208: }
209:
210: (*s_etat_processus).definitions_chainees[0] = d_code_fin_chaine;
211: (*s_etat_processus).longueur_definitions_chainees = 0;
212: (*s_etat_processus).evaluation_expression_compilee = 'Y';
213:
214: if ((*s_etat_processus).profilage == d_vrai)
215: {
216: profilage(s_etat_processus, (*s_etat_processus).s_liste_variables
217: [point_entree].nom);
218: }
219:
220: if ((*s_etat_processus).erreur_systeme != d_es)
221: {
222: if ((*s_etat_processus).langue == 'F')
223: {
224: printf("+++Système : Mémoire insuffisante\n");
225: }
226: else
227: {
228: printf("+++System : Not enough memory\n");
229: }
230:
231: return(d_erreur);
232: }
233:
234: erreur = evaluation(s_etat_processus, (*s_etat_processus).s_liste_variables
235: [point_entree].objet, 'E');
236:
237: if ((*s_etat_processus).profilage == d_vrai)
238: {
239: profilage(s_etat_processus, NULL);
240: }
241:
242: (*s_etat_processus).mode_execution_programme = 'N';
243:
244: if (((*s_etat_processus).erreur_execution != d_ex) ||
245: ((*s_etat_processus).exception != d_ep) ||
246: ((*s_etat_processus).erreur_systeme != d_es))
247: {
248: printf("%s [%d]\n", message = messages(s_etat_processus),
249: (int) getpid());
250:
251: if (test_cfsf(s_etat_processus, 51) == d_faux)
252: {
253: printf("%s", ds_beep);
254: }
255:
256: free(message);
257: }
258:
259: return(erreur);
260: }
261:
262: // vim: ts=4