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