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