1: /*
2: ================================================================================
3: RPL/2 (R) version 4.0.17
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: Procédure d'estimation de la longueur du tampon
29: ================================================================================
30: Entrée :
31: --------------------------------------------------------------------------------
32: Sortie :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: static inline void
39: estimation_taille_pile_systeme(struct_processus *s_etat_processus)
40: {
41: (*s_etat_processus).estimation_taille_pile_systeme_tampon =
42: ((*s_etat_processus).estimation_taille_pile_systeme_tampon *
43: ((double) 0.9)) + ((*s_etat_processus)
44: .hauteur_pile_systeme * ((double) 0.1));
45: return;
46: }
47:
48:
49: /*
50: ================================================================================
51: Procédure d'empilement d'un nouvel élément
52: ================================================================================
53: Entrée :
54: --------------------------------------------------------------------------------
55: Sortie :
56: --------------------------------------------------------------------------------
57: Effets de bord : néant
58: ================================================================================
59: */
60:
61: void
62: empilement_pile_systeme(struct_processus *s_etat_processus)
63: {
64: struct_liste_pile_systeme *l_ancienne_base_liste;
65: struct_liste_pile_systeme *l_nouvelle_base_liste;
66:
67: l_ancienne_base_liste = (*s_etat_processus).l_base_pile_systeme;
68:
69: if ((*s_etat_processus).debug == d_vrai)
70: if (((*s_etat_processus).type_debug &
71: d_debug_pile_systeme) != 0)
72: {
73: if (strlen((*s_etat_processus).instruction_courante) != 0)
74: {
75: if ((*s_etat_processus).langue == 'F')
76: {
77: printf("[%d] Empilement sur la pile système à la suite de "
78: "l'instruction %s\n", (int) getpid(),
79: (*s_etat_processus).instruction_courante);
80: }
81: else
82: {
83: printf("[%d] Pushing on system stack (instruction %s)\n",
84: (int) getpid(),
85: (*s_etat_processus).instruction_courante);
86: }
87: }
88: else
89: {
90: if ((*s_etat_processus).langue == 'F')
91: {
92: printf("[%d] Empilement sur la pile système\n",
93: (int) getpid());
94: }
95: else
96: {
97: printf("[%d] Pushing on system stack\n", (int) getpid());
98: }
99: }
100:
101: fflush(stdout);
102: }
103:
104: if ((*s_etat_processus).pile_systeme_tampon == NULL)
105: {
106: // Tampon vide, on alloue un élément.
107:
108: if ((l_nouvelle_base_liste = malloc(sizeof(struct_liste_pile_systeme)))
109: == NULL)
110: {
111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
112: return;
113: }
114: }
115: else
116: {
117: // Tampon utilisable, on retire un élément du tampon.
118:
119: l_nouvelle_base_liste = (*s_etat_processus).pile_systeme_tampon;
120: (*s_etat_processus).pile_systeme_tampon =
121: (*l_nouvelle_base_liste).suivant;
122: (*s_etat_processus).taille_pile_systeme_tampon--;
123: }
124:
125: (*s_etat_processus).hauteur_pile_systeme++;
126: (*s_etat_processus).l_base_pile_systeme = l_nouvelle_base_liste;
127: (*(*s_etat_processus).l_base_pile_systeme).suivant =
128: l_ancienne_base_liste;
129:
130: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = ' ';
131: (*(*s_etat_processus).l_base_pile_systeme).clause = ' ';
132: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour = 0;
133: (*(*s_etat_processus).l_base_pile_systeme).niveau_courant = 0;
134: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'N';
135: (*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
136: (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = NULL;
137: (*(*s_etat_processus).l_base_pile_systeme).objet_de_test = NULL;
138: (*(*s_etat_processus).l_base_pile_systeme).nom_variable = NULL;
139: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour = NULL;
140: (*(*s_etat_processus).l_base_pile_systeme)
141: .origine_routine_evaluation = 'N';
142: (*(*s_etat_processus).l_base_pile_systeme).arret_si_exception =
143: (*s_etat_processus).arret_si_exception;
144: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_statiques
145: = (*s_etat_processus).creation_variables_statiques;
146: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_partagees
147: = (*s_etat_processus).creation_variables_partagees;
148: (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression =
149: d_faux;
150:
151: (*s_etat_processus).erreur_systeme = d_es;
152: (*s_etat_processus).creation_variables_statiques = d_faux;
153: (*s_etat_processus).creation_variables_partagees = d_faux;
154:
155: return;
156: }
157:
158:
159: /*
160: ================================================================================
161: Procédure de dépilement d'un élément
162: ================================================================================
163: Entrée :
164: --------------------------------------------------------------------------------
165: Sortie :
166: --------------------------------------------------------------------------------
167: Effets de bord : néant
168: ================================================================================
169: */
170:
171: void
172: depilement_pile_systeme(struct_processus *s_etat_processus)
173: {
174: struct_liste_pile_systeme *l_ancienne_base_liste;
175: struct_liste_pile_systeme *l_nouvelle_base_liste;
176:
177: if ((*s_etat_processus).debug == d_vrai)
178: if (((*s_etat_processus).type_debug &
179: d_debug_pile_systeme) != 0)
180: {
181: if (strlen((*s_etat_processus).instruction_courante) != 0)
182: {
183: if ((*s_etat_processus).langue == 'F')
184: {
185: printf("[%d] Dépilement de la pile système à la suite "
186: "de l'instruction %s\n", (int) getpid(),
187: (*s_etat_processus).instruction_courante);
188: }
189: else
190: {
191: printf("[%d] Pulling from system stack (instruction %s)\n",
192: (int) getpid(),
193: (*s_etat_processus).instruction_courante);
194: }
195: }
196: else
197: {
198: if ((*s_etat_processus).langue == 'F')
199: {
200: printf("[%d] Dépilement de la pile système\n",
201: (int) getpid());
202: }
203: else
204: {
205: printf("[%d] Pulling from system stack\n", (int) getpid());
206: }
207: }
208:
209: fflush(stdout);
210: }
211:
212: if ((*s_etat_processus).l_base_pile_systeme == NULL)
213: {
214: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
215: }
216: else
217: {
218: (*s_etat_processus).hauteur_pile_systeme--;
219: l_ancienne_base_liste = (*s_etat_processus).l_base_pile_systeme;
220: l_nouvelle_base_liste = (*l_ancienne_base_liste).suivant;
221:
222: (*s_etat_processus).l_base_pile_systeme = l_nouvelle_base_liste;
223: (*s_etat_processus).erreur_systeme = d_es;
224:
225: // On positionne le drapeau de création des variables statiques.
226:
227: (*s_etat_processus).creation_variables_statiques =
228: (*l_ancienne_base_liste).creation_variables_statiques;
229: (*s_etat_processus).creation_variables_partagees =
230: (*l_ancienne_base_liste).creation_variables_partagees;
231:
232: if ((*l_ancienne_base_liste).nom_variable != NULL)
233: {
234: free((*l_ancienne_base_liste).nom_variable);
235: }
236:
237: liberation(s_etat_processus, (*l_ancienne_base_liste).indice_boucle);
238: liberation(s_etat_processus,
239: (*l_ancienne_base_liste).limite_indice_boucle);
240: liberation(s_etat_processus, (*l_ancienne_base_liste).objet_de_test);
241:
242: if ((*s_etat_processus).taille_pile_systeme_tampon <= (10 *
243: ((*s_etat_processus).estimation_taille_pile_systeme_tampon
244: + 1)))
245: {
246: // Enregistrement de la structure pour un usage ultérieur.
247:
248: (*l_ancienne_base_liste).suivant =
249: (*s_etat_processus).pile_systeme_tampon;
250: (*s_etat_processus).pile_systeme_tampon = l_ancienne_base_liste;
251: (*s_etat_processus).taille_pile_systeme_tampon++;
252: }
253: else
254: {
255: // Libération car le tampon est plein.
256:
257: free(l_ancienne_base_liste);
258: }
259: }
260:
261: return;
262: }
263:
264:
265: /*
266: ================================================================================
267: Procédure d'effacement de la pile système
268: ================================================================================
269: Entrée :
270: --------------------------------------------------------------------------------
271: Sortie :
272: --------------------------------------------------------------------------------
273: Effets de bord : néant
274: ================================================================================
275: */
276:
277: void
278: effacement_pile_systeme(struct_processus *s_etat_processus)
279: {
280: while((*s_etat_processus).l_base_pile_systeme != NULL)
281: {
282: depilement_pile_systeme(s_etat_processus);
283: }
284:
285: return;
286: }
287:
288:
289: /*
290: ================================================================================
291: Procédure d'affichage de la pile système
292: ================================================================================
293: Entrée :
294: --------------------------------------------------------------------------------
295: Sortie :
296: --------------------------------------------------------------------------------
297: Effets de bord : néant
298: ================================================================================
299: */
300:
301: void
302: trace(struct_processus *s_etat_processus, FILE *flux)
303: {
304: integer8 i;
305:
306: struct_liste_pile_systeme *l_element_courant;
307:
308: unsigned char *tampon;
309:
310: l_element_courant = (*s_etat_processus).l_base_pile_systeme;
311: i = 0;
312:
313: while(l_element_courant != NULL)
314: {
315: i++;
316: l_element_courant = (*l_element_courant).suivant;
317: }
318:
319: l_element_courant = (*s_etat_processus).l_base_pile_systeme;
320: flockfile(flux);
321:
322: if ((flux == stderr) || (flux == stdout))
323: {
324: fprintf(flux, "+++Backtrace\n");
325: }
326:
327: while(l_element_courant != NULL)
328: {
329: fprintf(flux, "%d : (%p) D=", i--, l_element_courant);
330:
331: fprintf(flux, ((*l_element_courant).creation_variables_statiques
332: == d_vrai) ? "1" : "0");
333: fprintf(flux, ((*l_element_courant).creation_variables_partagees
334: == d_vrai) ? "1" : "0");
335: fprintf(flux, ((*l_element_courant).arret_si_exception == d_vrai)
336: ? "1" : "0");
337: fprintf(flux, ((*l_element_courant).evaluation_expression == d_vrai)
338: ? "1" : "0");
339:
340: fprintf(flux, " F=%c%c L=%lu ",
341: ((*l_element_courant).clause == ' ') ? '-' :
342: (*l_element_courant).clause,
343: ((*l_element_courant).type_cloture == ' ') ? '-' :
344: (*l_element_courant).type_cloture,
345: (*l_element_courant).niveau_courant);
346:
347: if ((*l_element_courant).retour_definition == 'Y')
348: {
349: fprintf(flux, "RTRN ");
350:
351: if ((*l_element_courant).origine_routine_evaluation == 'Y')
352: {
353: fprintf(flux, "EVL ");
354:
355: if ((*l_element_courant).adresse_retour != 0)
356: {
357: fprintf(flux, "P=%lu", (*l_element_courant)
358: .adresse_retour);
359: }
360: }
361: else
362: {
363: fprintf(flux, "SEQ ");
364:
365: if ((*l_element_courant).pointeur_objet_retour != NULL)
366: {
367: fprintf(flux, "A=%X", (*l_element_courant)
368: .pointeur_objet_retour);
369: }
370: }
371: }
372: else
373: {
374: fprintf(flux, "NONE ");
375:
376: if ((*l_element_courant).origine_routine_evaluation == 'Y')
377: {
378: fprintf(flux, "EVL ");
379:
380: if ((*l_element_courant).adresse_retour != 0)
381: {
382: fprintf(flux, "P=%lu", (*l_element_courant)
383: .adresse_retour);
384: }
385: }
386: else
387: {
388: fprintf(flux, "SEQ ");
389:
390: if ((*l_element_courant).pointeur_objet_retour != NULL)
391: {
392: fprintf(flux, "A=%X", (*l_element_courant)
393: .pointeur_objet_retour);
394: }
395: }
396: }
397:
398: fprintf(flux, "\n");
399:
400: if ((*l_element_courant).indice_boucle != NULL)
401: {
402: tampon = formateur(s_etat_processus, 0,
403: (*l_element_courant).indice_boucle);
404: fprintf(flux, " Index = %s\n", tampon);
405: free(tampon);
406: }
407:
408: if ((*l_element_courant).limite_indice_boucle != NULL)
409: {
410: tampon = formateur(s_etat_processus, 0,
411: (*l_element_courant).limite_indice_boucle);
412: fprintf(flux, " Limit = %s\n", tampon);
413: free(tampon);
414: }
415:
416: if ((*l_element_courant).objet_de_test != NULL)
417: {
418: tampon = formateur(s_etat_processus, 0,
419: (*l_element_courant).objet_de_test);
420: fprintf(flux, " Test object = %s\n", tampon);
421: free(tampon);
422: }
423:
424: if ((*l_element_courant).nom_variable != NULL)
425: {
426: fprintf(flux, " Variable name = %s\n",
427: (*l_element_courant).nom_variable);
428: }
429:
430: l_element_courant = (*l_element_courant).suivant;
431: }
432:
433: fprintf(flux, "\n");
434: funlockfile(flux);
435:
436: return;
437: }
438:
439: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gestion_pile_systeme.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src