![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rplcore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to rplcore.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.2 ! bertrand 3: RPL/2 (R) version 4.0.10
1.1 bertrand 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl.conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'rplcore' générant un fichier de débogage
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: rplcore(struct_processus *s_etat_processus)
40: {
41: file *fichier;
42:
43: logical1 erreur;
44: logical1 fin_boucle;
45:
46: long i;
47: long j;
48: long longueur_lignes = 65;
49:
50: struct_liste_chainee *l_base_pile;
51: struct_liste_chainee *l_element_courant;
52:
53: struct_objet *s_objet_last;
54:
55: unsigned char *expression;
56: unsigned char *nom;
57: unsigned char *message_erreur;
58: unsigned char *pile;
59: unsigned char *ptr;
60: unsigned char *ptr_bis;
61: unsigned char registre_langue;
62:
63: (*s_etat_processus).core = d_faux;
64:
65: sf(s_etat_processus, 37);
66: sf(s_etat_processus, 38);
67: sf(s_etat_processus, 39);
68: sf(s_etat_processus, 40);
69: sf(s_etat_processus, 41);
70: sf(s_etat_processus, 42);
71:
72: cf(s_etat_processus, 43);
73: cf(s_etat_processus, 44);
74:
75: sf(s_etat_processus, 45);
76:
77: cf(s_etat_processus, 48);
78:
79: cf(s_etat_processus, 49);
80: cf(s_etat_processus, 50);
81:
82: cf(s_etat_processus, 53);
83: cf(s_etat_processus, 54);
84: cf(s_etat_processus, 55);
85: cf(s_etat_processus, 56);
86:
87: sf(s_etat_processus, 60);
88:
89: registre_langue = (*s_etat_processus).langue;
90: (*s_etat_processus).langue = 'E';
91:
92: message_erreur = messages(s_etat_processus);
93:
94: (*s_etat_processus).langue = registre_langue;
95:
96: if ((nom = malloc((strlen(ds_rplcore) + 64 + 1) * sizeof(unsigned char)))
97: == NULL)
98: {
99: free(message_erreur);
100: return;
101: }
102:
103: snprintf(nom, strlen(ds_rplcore) + 64 + 1,
104: "%s-%lu-%lu", ds_rplcore, (unsigned long) getpid(),
105: (unsigned long) pthread_self());
106:
107: if ((fichier = fopen(nom, "w+")) == NULL)
108: {
109: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
110: free(message_erreur);
111: free(nom);
112:
113: return;
114: }
115:
116: free(nom);
117:
118: if (fprintf(fichier, "// RPL/2 version %s process image\n",
119: d_version_rpl) < 0)
120: {
121: free(message_erreur);
122:
123: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
124: return;
125: }
126:
127: if (fprintf(fichier, "// Process %d\n", (int) getpid()) < 0)
128: {
129: free(message_erreur);
130:
131: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
132: return;
133: }
134:
135: if (fprintf(fichier, "// Source file : %s\n\n",
136: (*s_etat_processus).nom_fichier_source) < 0)
137: {
138: free(message_erreur);
139:
140: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
141: return;
142: }
143:
144: if (fprintf(fichier, "// Error :\n%s [%s at level %lu]\n\n",
145: message_erreur, (*s_etat_processus).instruction_derniere_erreur,
146: (*s_etat_processus).niveau_derniere_erreur) < 0)
147: {
148: free(message_erreur);
149:
150: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
151: return;
152: }
153:
154: free(message_erreur);
155:
156: if (fprintf(fichier, "// Process stack\n\n") < 0)
157: {
158: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
159: return;
160: }
161:
162: l_element_courant = (struct_liste_chainee *)
163: (*s_etat_processus).l_base_pile_processus;
164: i = 0;
165:
166: if (pthread_mutex_trylock(&((*s_etat_processus).mutex)) == 0)
167: {
168: while(l_element_courant != NULL)
169: {
170: if ((*(*((struct_processus_fils *)
171: (*(*l_element_courant).donnee).objet)).thread)
172: .processus_detache == d_vrai)
173: {
174: if (fprintf(fichier, "%ld: Process [%d]\n",
175: i++, (int) (*(*((struct_processus_fils *)
176: (*(*l_element_courant).donnee).objet)).thread).pid) < 0)
177: {
178: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
179: return;
180: }
181: }
182: else
183: {
184: if (fprintf(fichier, "%ld: Thread [%llu] from [%llu]\n",
185: i++, (unsigned long long) (*(*((struct_processus_fils *)
186: (*(*l_element_courant).donnee).objet)).thread)
187: .tid, (unsigned long long)
188: (*(*((struct_processus_fils *) (*(*l_element_courant)
189: .donnee).objet)).thread).pid) < 0)
190: {
191: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
192: return;
193: }
194: }
195:
196: l_element_courant = (*l_element_courant).suivant;
197: }
198:
199: if (fprintf(fichier, "%ld: Process [%d]\n\n", i,
200: (int) getpid()) < 0)
201: {
202: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
203: return;
204: }
205:
206: pthread_mutex_unlock(&((*s_etat_processus).mutex));
207: }
208:
209: if (test_cfsf(s_etat_processus, 31) == d_vrai)
210: {
211: // LAST valide
212:
213: if (fprintf(fichier, "// Arguments\n\n") < 0)
214: {
215: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
216: return;
217: }
218:
219: l_base_pile = NULL;
220:
221: while((*s_etat_processus).l_base_pile_last != NULL)
222: {
223: if (depilement(s_etat_processus, &((*s_etat_processus)
224: .l_base_pile_last), &s_objet_last) == d_erreur)
225: {
226: return;
227: }
228:
229: if (empilement(s_etat_processus, &l_base_pile, s_objet_last)
230: == d_erreur)
231: {
232: return;
233: }
234: }
235:
236: if ((*s_etat_processus).l_base_pile != NULL)
237: {
238: ecriture_pile(s_etat_processus, fichier, l_base_pile, 1);
239: }
240: else
241: {
242: if (fprintf(fichier, " No argument\n") < 0)
243: {
244: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
245: return;
246: }
247: }
248:
249: while(l_base_pile != NULL)
250: {
251: if (depilement(s_etat_processus, &l_base_pile,
252: &s_objet_last) == d_erreur)
253: {
254: return;
255: }
256:
257: if (empilement(s_etat_processus, &((*s_etat_processus)
258: .l_base_pile_last), s_objet_last) == d_erreur)
259: {
260: return;
261: }
262: }
263: }
264: else
265: {
266: // LAST invalide
267:
268: if (fprintf(fichier, "// Current stack (LAST disabled)\n") < 0)
269: {
270: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
271: return;
272: }
273: }
274:
275: if (fprintf(fichier, "\n// Stack\n\n") < 0)
276: {
277: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
278: return;
279: }
280:
281: if ((*s_etat_processus).l_base_pile != NULL)
282: {
283: ecriture_pile(s_etat_processus, fichier,
284: (*s_etat_processus).l_base_pile, 1);
285: }
286: else
287: {
288: if (fprintf(fichier, " Empty stack\n") < 0)
289: {
290: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
291: return;
292: }
293: }
294:
295: if ((*s_etat_processus).s_objet_errone != NULL)
296: {
297: if (fprintf(fichier, "\n// Current evaluation\n") < 0)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
300: return;
301: }
302:
303: // L'objet ne peut être qu'une expression algébrique ou RPN
304:
305: if (((*(*s_etat_processus).s_objet_errone).type == RPN) ||
306: ((*(*s_etat_processus).s_objet_errone).type == ALG))
307: {
308: l_element_courant = (*(*s_etat_processus).s_objet_errone).objet;
309:
310: if (fprintf(fichier, "\n") < 0)
311: {
312: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
313: return;
314: }
315:
316: while(l_element_courant != NULL)
317: {
318: if ((*l_element_courant).donnee ==
319: (*s_etat_processus).s_objet_erreur)
320: {
321: if ((expression = formateur(s_etat_processus, 4,
322: (*l_element_courant).donnee)) == NULL)
323: {
324: return;
325: }
326:
327: if ((*(*l_element_courant).donnee).type == CHN)
328: {
329: if (fprintf(fichier, " -> \"%s\"\n", expression) < 0)
330: {
331: (*s_etat_processus).erreur_systeme =
332: d_es_erreur_fichier;
333: return;
334: }
335: }
336: else
337: {
338: if (fprintf(fichier, " -> %s\n", expression) < 0)
339: {
340: (*s_etat_processus).erreur_systeme =
341: d_es_erreur_fichier;
342: return;
343: }
344: }
345: }
346: else
347: {
348: if ((expression = formateur(s_etat_processus, 4,
349: (*l_element_courant).donnee)) == NULL)
350: {
351: return;
352: }
353:
354: if ((*(*l_element_courant).donnee).type == CHN)
355: {
356: if (fprintf(fichier, " \"%s\"\n", expression) < 0)
357: {
358: (*s_etat_processus).erreur_systeme =
359: d_es_erreur_fichier;
360: return;
361: }
362: }
363: else
364: {
365: if (fprintf(fichier, " %s\n", expression) < 0)
366: {
367: (*s_etat_processus).erreur_systeme =
368: d_es_erreur_fichier;
369: return;
370: }
371: }
372: }
373:
374: free(expression);
375: l_element_courant = (*l_element_courant).suivant;
376: }
377: }
378: else
379: {
380: if ((expression = formateur(s_etat_processus, 4,
381: (*s_etat_processus).s_objet_errone)) == NULL)
382: {
383: return;
384: }
385:
386: if (fprintf(fichier, "\n%s\n", expression) < 0)
387: {
388: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
389: return;
390: }
391:
392: free(expression);
393: }
394: }
395:
396: if ((*s_etat_processus).longueur_definitions_chainees != 0)
397: {
398: if (fprintf(fichier, "\n// Definitions\n") < 0)
399: {
400: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
401: return;
402: }
403:
404: ptr = (*s_etat_processus).definitions_chainees;
405: i = 0;
406: erreur = d_faux;
407:
408: while(((*ptr) != d_code_fin_chaine) || (erreur == d_vrai))
409: {
410: if ((i % longueur_lignes) == 0)
411: {
412: if (fprintf(fichier, "\n") < 0)
413: {
414: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
415: return;
416: }
417:
418: if (erreur == d_vrai)
419: {
420: if (fprintf(fichier, "PC :") < 0)
421: {
422: (*s_etat_processus).erreur_systeme =
423: d_es_erreur_fichier;
424: return;
425: }
426:
427: if ((j = i - longueur_lignes) < 0)
428: {
429: j = 0;
430: ptr_bis = (*s_etat_processus).definitions_chainees;
431: }
432: else
433: {
434: ptr_bis = ptr - longueur_lignes;
435: }
436:
437: fin_boucle = d_faux;
438:
439: while(((*ptr_bis) != d_code_fin_chaine) &&
440: (fin_boucle == d_faux))
441: {
442: if (j == (long) (*s_etat_processus).position_courante)
443: {
444: if (fprintf(fichier, ">|<") < 0)
445: {
446: (*s_etat_processus).erreur_systeme =
447: d_es_erreur_fichier;
448: return;
449: }
450:
451: fin_boucle = d_vrai;
452: }
453: else
454: {
455: if (fprintf(fichier, " ") < 0)
456: {
457: (*s_etat_processus).erreur_systeme =
458: d_es_erreur_fichier;
459: return;
460: }
461: }
462:
463: j++;
464: ptr_bis++;
465: }
466:
467: if (fprintf(fichier, "\n") < 0)
468: {
469: (*s_etat_processus).erreur_systeme =
470: d_es_erreur_fichier;
471: return;
472: }
473: }
474:
475: if ((*ptr) != d_code_fin_chaine)
476: {
477: if (erreur == d_vrai)
478: {
479: if (fprintf(fichier, "\n") < 0)
480: {
481: (*s_etat_processus).erreur_systeme =
482: d_es_erreur_fichier;
483: return;
484: }
485: }
486:
487: if ((i <= (long) (*s_etat_processus).position_courante) &&
488: ((i + longueur_lignes) > (long) (*s_etat_processus)
489: .position_courante))
490: {
491: if (fprintf(fichier, "\nError : ") < 0)
492: {
493: (*s_etat_processus).erreur_systeme =
494: d_es_erreur_fichier;
495: return;
496: }
497:
498: erreur = d_vrai;
499: }
500: else
501: {
502: if (fprintf(fichier, " ") < 0)
503: {
504: (*s_etat_processus).erreur_systeme =
505: d_es_erreur_fichier;
506: return;
507: }
508:
509: erreur = d_faux;
510: }
511: }
512: else
513: {
514: erreur = d_faux;
515: }
516: }
517:
518: if ((*ptr) != d_code_fin_chaine)
519: {
520: if (ufprintf(fichier, "%c", *ptr) < 0)
521: {
522: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
523: return;
524: }
525:
526: ptr++;
527: }
528:
529: i++;
530: }
531:
532: if (fprintf(fichier, "\n// End of definitions\n") < 0)
533: {
534: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
535: return;
536: }
537: }
538:
539: if (fprintf(fichier, "\n// Externals\n\n") < 0)
540: {
541: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
542: return;
543: }
544:
545: instruction_externals(s_etat_processus);
546:
547: if (fprintf(fichier, "%s\n", pile =
548: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
549: .donnee)) < 0)
550: {
551: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
552: return;
553: }
554:
555: free(pile);
556:
557: if (fprintf(fichier, "\n// Variables\n\n") < 0)
558: {
559: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
560: return;
561: }
562:
563: instruction_vars(s_etat_processus);
564:
565: if (fprintf(fichier, "%s\n", pile =
566: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
567: .donnee)) < 0)
568: {
569: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
570: return;
571: }
572:
573: free(pile);
574:
575: instruction_drop2(s_etat_processus);
576:
577: if (fclose(fichier) != 0)
578: {
579: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
580: return;
581: }
582:
583: free((*s_etat_processus).instruction_derniere_erreur);
584: (*s_etat_processus).instruction_derniere_erreur = NULL;
585:
586: return;
587: }
588:
589: // vim: ts=4