1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.10
4: Copyright (C) 1989-2012 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;
62: unsigned char registre_langue;
63:
64: (*s_etat_processus).core = d_faux;
65:
66: sf(s_etat_processus, 37);
67: sf(s_etat_processus, 38);
68: sf(s_etat_processus, 39);
69: sf(s_etat_processus, 40);
70: sf(s_etat_processus, 41);
71: sf(s_etat_processus, 42);
72:
73: cf(s_etat_processus, 43);
74: cf(s_etat_processus, 44);
75:
76: sf(s_etat_processus, 45);
77:
78: cf(s_etat_processus, 48);
79:
80: cf(s_etat_processus, 49);
81: cf(s_etat_processus, 50);
82:
83: cf(s_etat_processus, 53);
84: cf(s_etat_processus, 54);
85: cf(s_etat_processus, 55);
86: cf(s_etat_processus, 56);
87:
88: sf(s_etat_processus, 60);
89:
90: registre_langue = (*s_etat_processus).langue;
91: (*s_etat_processus).langue = 'E';
92:
93: message_erreur = messages(s_etat_processus);
94:
95: (*s_etat_processus).langue = registre_langue;
96:
97: if ((nom = malloc((strlen(ds_rplcore) + 64 + 1) * sizeof(unsigned char)))
98: == NULL)
99: {
100: free(message_erreur);
101: return;
102: }
103:
104: snprintf(nom, strlen(ds_rplcore) + 64 + 1,
105: "%s-%lu-%lu", ds_rplcore, (unsigned long) getpid(),
106: (unsigned long) pthread_self());
107:
108: if ((fichier = fopen(nom, "w+")) == NULL)
109: {
110: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
111: free(message_erreur);
112: free(nom);
113:
114: return;
115: }
116:
117: free(nom);
118:
119: if (fprintf(fichier, "// RPL/2 version %s process image\n",
120: d_version_rpl) < 0)
121: {
122: free(message_erreur);
123:
124: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
125: return;
126: }
127:
128: if (fprintf(fichier, "// Process %d\n", (int) getpid()) < 0)
129: {
130: free(message_erreur);
131:
132: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
133: return;
134: }
135:
136: if (fprintf(fichier, "// Source file : %s\n\n",
137: (*s_etat_processus).nom_fichier_source) < 0)
138: {
139: free(message_erreur);
140:
141: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
142: return;
143: }
144:
145: if ((*s_etat_processus).instruction_derniere_erreur != NULL)
146: {
147: if (fprintf(fichier, "// Error :\n%s [level %lu]\n\n",
148: message_erreur, (*s_etat_processus).niveau_derniere_erreur) < 0)
149: {
150: free(message_erreur);
151:
152: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
153: return;
154: }
155: }
156: else if ((*s_etat_processus).instruction_derniere_erreur[0] ==
157: d_code_fin_chaine)
158: {
159: if (fprintf(fichier, "// Error :\n%s [level %lu]\n\n",
160: message_erreur, (*s_etat_processus).niveau_derniere_erreur) < 0)
161: {
162: free(message_erreur);
163:
164: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
165: return;
166: }
167: }
168: else if (fprintf(fichier, "// Error :\n%s [%s at level %lu]\n\n",
169: message_erreur, (*s_etat_processus).instruction_derniere_erreur,
170: (*s_etat_processus).niveau_derniere_erreur) < 0)
171: {
172: free(message_erreur);
173:
174: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
175: return;
176: }
177:
178: free(message_erreur);
179:
180: if (fprintf(fichier, "// System stack\n\n") < 0)
181: {
182: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
183: return;
184: }
185:
186: trace(s_etat_processus, fichier);
187:
188: if (fprintf(fichier, "// Process stack\n\n") < 0)
189: {
190: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
191: return;
192: }
193:
194: l_element_courant = (struct_liste_chainee *)
195: (*s_etat_processus).l_base_pile_processus;
196: i = 0;
197:
198: if (pthread_mutex_trylock(&((*s_etat_processus).mutex)) == 0)
199: {
200: while(l_element_courant != NULL)
201: {
202: if ((*(*((struct_processus_fils *)
203: (*(*l_element_courant).donnee).objet)).thread)
204: .processus_detache == d_vrai)
205: {
206: if (fprintf(fichier, "%ld: Process [%d]\n",
207: i++, (int) (*(*((struct_processus_fils *)
208: (*(*l_element_courant).donnee).objet)).thread).pid) < 0)
209: {
210: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
211: return;
212: }
213: }
214: else
215: {
216: if (fprintf(fichier, "%ld: Thread [%llu] from [%llu]\n",
217: i++, (unsigned long long) (*(*((struct_processus_fils *)
218: (*(*l_element_courant).donnee).objet)).thread)
219: .tid, (unsigned long long)
220: (*(*((struct_processus_fils *) (*(*l_element_courant)
221: .donnee).objet)).thread).pid) < 0)
222: {
223: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
224: return;
225: }
226: }
227:
228: l_element_courant = (*l_element_courant).suivant;
229: }
230:
231: if (fprintf(fichier, "%ld: Process [%d]\n\n", i,
232: (int) getpid()) < 0)
233: {
234: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
235: return;
236: }
237:
238: pthread_mutex_unlock(&((*s_etat_processus).mutex));
239: }
240:
241: if (test_cfsf(s_etat_processus, 31) == d_vrai)
242: {
243: // LAST valide
244:
245: if (fprintf(fichier, "// Arguments\n\n") < 0)
246: {
247: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
248: return;
249: }
250:
251: l_base_pile = NULL;
252:
253: while((*s_etat_processus).l_base_pile_last != NULL)
254: {
255: if (depilement(s_etat_processus, &((*s_etat_processus)
256: .l_base_pile_last), &s_objet_last) == d_erreur)
257: {
258: return;
259: }
260:
261: if (empilement(s_etat_processus, &l_base_pile, s_objet_last)
262: == d_erreur)
263: {
264: return;
265: }
266: }
267:
268: if ((*s_etat_processus).l_base_pile != NULL)
269: {
270: registre = (*s_etat_processus).autorisation_conversion_chaine;
271: (*s_etat_processus).autorisation_conversion_chaine = 'N';
272:
273: ecriture_pile(s_etat_processus, fichier, l_base_pile, 1);
274:
275: (*s_etat_processus).autorisation_conversion_chaine = registre;
276: }
277: else
278: {
279: if (fprintf(fichier, " No argument\n") < 0)
280: {
281: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
282: return;
283: }
284: }
285:
286: while(l_base_pile != NULL)
287: {
288: if (depilement(s_etat_processus, &l_base_pile,
289: &s_objet_last) == d_erreur)
290: {
291: return;
292: }
293:
294: if (empilement(s_etat_processus, &((*s_etat_processus)
295: .l_base_pile_last), s_objet_last) == d_erreur)
296: {
297: return;
298: }
299: }
300: }
301: else
302: {
303: // LAST invalide
304:
305: if (fprintf(fichier, "// Current stack (LAST disabled)\n") < 0)
306: {
307: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
308: return;
309: }
310: }
311:
312: if (fprintf(fichier, "\n// Stack\n\n") < 0)
313: {
314: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
315: return;
316: }
317:
318: if ((*s_etat_processus).l_base_pile != NULL)
319: {
320: registre = (*s_etat_processus).autorisation_conversion_chaine;
321: (*s_etat_processus).autorisation_conversion_chaine = 'N';
322:
323: ecriture_pile(s_etat_processus, fichier,
324: (*s_etat_processus).l_base_pile, 1);
325:
326: (*s_etat_processus).autorisation_conversion_chaine = registre;
327: }
328: else
329: {
330: if (fprintf(fichier, " Empty stack\n") < 0)
331: {
332: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
333: return;
334: }
335: }
336:
337: if ((*s_etat_processus).s_objet_errone != NULL)
338: {
339: if (fprintf(fichier, "\n// Current evaluation\n") < 0)
340: {
341: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
342: return;
343: }
344:
345: // L'objet ne peut être qu'une expression algébrique ou RPN
346:
347: if (((*(*s_etat_processus).s_objet_errone).type == RPN) ||
348: ((*(*s_etat_processus).s_objet_errone).type == ALG))
349: {
350: l_element_courant = (*(*s_etat_processus).s_objet_errone).objet;
351:
352: if (fprintf(fichier, "\n") < 0)
353: {
354: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
355: return;
356: }
357:
358: while(l_element_courant != NULL)
359: {
360: if ((*l_element_courant).donnee ==
361: (*s_etat_processus).s_objet_erreur)
362: {
363: if ((expression = formateur(s_etat_processus, 4,
364: (*l_element_courant).donnee)) == NULL)
365: {
366: return;
367: }
368:
369: if ((*(*l_element_courant).donnee).type == CHN)
370: {
371: if (fprintf(fichier, " -> \"%s\"\n", expression) < 0)
372: {
373: (*s_etat_processus).erreur_systeme =
374: d_es_erreur_fichier;
375: return;
376: }
377: }
378: else
379: {
380: if (fprintf(fichier, " -> %s\n", expression) < 0)
381: {
382: (*s_etat_processus).erreur_systeme =
383: d_es_erreur_fichier;
384: return;
385: }
386: }
387: }
388: else
389: {
390: if ((expression = formateur(s_etat_processus, 4,
391: (*l_element_courant).donnee)) == NULL)
392: {
393: return;
394: }
395:
396: if ((*(*l_element_courant).donnee).type == CHN)
397: {
398: if (fprintf(fichier, " \"%s\"\n", expression) < 0)
399: {
400: (*s_etat_processus).erreur_systeme =
401: d_es_erreur_fichier;
402: return;
403: }
404: }
405: else
406: {
407: if (fprintf(fichier, " %s\n", expression) < 0)
408: {
409: (*s_etat_processus).erreur_systeme =
410: d_es_erreur_fichier;
411: return;
412: }
413: }
414: }
415:
416: free(expression);
417: l_element_courant = (*l_element_courant).suivant;
418: }
419: }
420: else
421: {
422: if ((expression = formateur(s_etat_processus, 4,
423: (*s_etat_processus).s_objet_errone)) == NULL)
424: {
425: return;
426: }
427:
428: if (fprintf(fichier, "\n%s\n", expression) < 0)
429: {
430: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
431: return;
432: }
433:
434: free(expression);
435: }
436: }
437:
438: if ((*s_etat_processus).longueur_definitions_chainees != 0)
439: {
440: if (fprintf(fichier, "\n// Definitions\n") < 0)
441: {
442: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
443: return;
444: }
445:
446: ptr = (*s_etat_processus).definitions_chainees;
447: i = 0;
448: erreur = d_faux;
449:
450: while(((*ptr) != d_code_fin_chaine) || (erreur == d_vrai))
451: {
452: if ((i % longueur_lignes) == 0)
453: {
454: if (fprintf(fichier, "\n") < 0)
455: {
456: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
457: return;
458: }
459:
460: if (erreur == d_vrai)
461: {
462: if (fprintf(fichier, "PC :") < 0)
463: {
464: (*s_etat_processus).erreur_systeme =
465: d_es_erreur_fichier;
466: return;
467: }
468:
469: if ((j = i - longueur_lignes) < 0)
470: {
471: j = 0;
472: ptr_bis = (*s_etat_processus).definitions_chainees;
473: }
474: else
475: {
476: ptr_bis = ptr - longueur_lignes;
477: }
478:
479: fin_boucle = d_faux;
480:
481: while(((*ptr_bis) != d_code_fin_chaine) &&
482: (fin_boucle == d_faux))
483: {
484: if (j == (long) (*s_etat_processus).position_courante)
485: {
486: if (fprintf(fichier, ">|<") < 0)
487: {
488: (*s_etat_processus).erreur_systeme =
489: d_es_erreur_fichier;
490: return;
491: }
492:
493: fin_boucle = d_vrai;
494: }
495: else
496: {
497: if (fprintf(fichier, " ") < 0)
498: {
499: (*s_etat_processus).erreur_systeme =
500: d_es_erreur_fichier;
501: return;
502: }
503: }
504:
505: j++;
506: ptr_bis++;
507: }
508:
509: if (fprintf(fichier, "\n") < 0)
510: {
511: (*s_etat_processus).erreur_systeme =
512: d_es_erreur_fichier;
513: return;
514: }
515: }
516:
517: if ((*ptr) != d_code_fin_chaine)
518: {
519: if (erreur == d_vrai)
520: {
521: if (fprintf(fichier, "\n") < 0)
522: {
523: (*s_etat_processus).erreur_systeme =
524: d_es_erreur_fichier;
525: return;
526: }
527: }
528:
529: if ((i <= (long) (*s_etat_processus).position_courante) &&
530: ((i + longueur_lignes) > (long) (*s_etat_processus)
531: .position_courante))
532: {
533: if (fprintf(fichier, "\nError : ") < 0)
534: {
535: (*s_etat_processus).erreur_systeme =
536: d_es_erreur_fichier;
537: return;
538: }
539:
540: erreur = d_vrai;
541: }
542: else
543: {
544: if (fprintf(fichier, " ") < 0)
545: {
546: (*s_etat_processus).erreur_systeme =
547: d_es_erreur_fichier;
548: return;
549: }
550:
551: erreur = d_faux;
552: }
553: }
554: else
555: {
556: erreur = d_faux;
557: }
558: }
559:
560: if ((*ptr) != d_code_fin_chaine)
561: {
562: if (ufprintf(fichier, "%c", *ptr) < 0)
563: {
564: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
565: return;
566: }
567:
568: ptr++;
569: }
570:
571: i++;
572: }
573:
574: if (fprintf(fichier, "\n// End of definitions\n") < 0)
575: {
576: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
577: return;
578: }
579: }
580:
581: if (fprintf(fichier, "\n// Externals\n\n") < 0)
582: {
583: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
584: return;
585: }
586:
587: instruction_externals(s_etat_processus);
588:
589: if (fprintf(fichier, "%s\n", pile =
590: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
591: .donnee)) < 0)
592: {
593: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
594: return;
595: }
596:
597: free(pile);
598:
599: if (fprintf(fichier, "\n// Variables\n\n") < 0)
600: {
601: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
602: return;
603: }
604:
605: instruction_vars(s_etat_processus);
606:
607: if (fprintf(fichier, "%s\n", pile =
608: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
609: .donnee)) < 0)
610: {
611: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
612: return;
613: }
614:
615: free(pile);
616:
617: instruction_drop2(s_etat_processus);
618:
619: if (fclose(fichier) != 0)
620: {
621: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
622: return;
623: }
624:
625: free((*s_etat_processus).instruction_derniere_erreur);
626: (*s_etat_processus).instruction_derniere_erreur = NULL;
627:
628: return;
629: }
630:
631: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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