![[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.12 ! bertrand 3: RPL/2 (R) version 4.0.18
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;
1.3 bertrand 61: unsigned char registre;
1.1 bertrand 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 (fprintf(fichier, "// Error :\n%s [%s at level %lu]\n\n",
146: message_erreur, (*s_etat_processus).instruction_derniere_erreur,
147: (*s_etat_processus).niveau_derniere_erreur) < 0)
148: {
149: free(message_erreur);
150:
151: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
152: return;
153: }
154:
155: free(message_erreur);
156:
1.10 bertrand 157: if (fprintf(fichier, "// System stack\n\n") < 0)
158: {
159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
160: return;
161: }
162:
163: trace(s_etat_processus, fichier);
164:
1.1 bertrand 165: if (fprintf(fichier, "// Process stack\n\n") < 0)
166: {
167: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
168: return;
169: }
170:
171: l_element_courant = (struct_liste_chainee *)
172: (*s_etat_processus).l_base_pile_processus;
173: i = 0;
174:
175: if (pthread_mutex_trylock(&((*s_etat_processus).mutex)) == 0)
176: {
177: while(l_element_courant != NULL)
178: {
179: if ((*(*((struct_processus_fils *)
180: (*(*l_element_courant).donnee).objet)).thread)
181: .processus_detache == d_vrai)
182: {
183: if (fprintf(fichier, "%ld: Process [%d]\n",
184: i++, (int) (*(*((struct_processus_fils *)
185: (*(*l_element_courant).donnee).objet)).thread).pid) < 0)
186: {
187: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
188: return;
189: }
190: }
191: else
192: {
193: if (fprintf(fichier, "%ld: Thread [%llu] from [%llu]\n",
194: i++, (unsigned long long) (*(*((struct_processus_fils *)
195: (*(*l_element_courant).donnee).objet)).thread)
196: .tid, (unsigned long long)
197: (*(*((struct_processus_fils *) (*(*l_element_courant)
198: .donnee).objet)).thread).pid) < 0)
199: {
200: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
201: return;
202: }
203: }
204:
205: l_element_courant = (*l_element_courant).suivant;
206: }
207:
208: if (fprintf(fichier, "%ld: Process [%d]\n\n", i,
209: (int) getpid()) < 0)
210: {
211: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
212: return;
213: }
214:
215: pthread_mutex_unlock(&((*s_etat_processus).mutex));
216: }
217:
218: if (test_cfsf(s_etat_processus, 31) == d_vrai)
219: {
220: // LAST valide
221:
222: if (fprintf(fichier, "// Arguments\n\n") < 0)
223: {
224: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
225: return;
226: }
227:
228: l_base_pile = NULL;
229:
230: while((*s_etat_processus).l_base_pile_last != NULL)
231: {
232: if (depilement(s_etat_processus, &((*s_etat_processus)
233: .l_base_pile_last), &s_objet_last) == d_erreur)
234: {
235: return;
236: }
237:
238: if (empilement(s_etat_processus, &l_base_pile, s_objet_last)
239: == d_erreur)
240: {
241: return;
242: }
243: }
244:
245: if ((*s_etat_processus).l_base_pile != NULL)
246: {
1.3 bertrand 247: registre = (*s_etat_processus).autorisation_conversion_chaine;
248: (*s_etat_processus).autorisation_conversion_chaine = 'N';
249:
1.1 bertrand 250: ecriture_pile(s_etat_processus, fichier, l_base_pile, 1);
1.3 bertrand 251:
252: (*s_etat_processus).autorisation_conversion_chaine = registre;
1.1 bertrand 253: }
254: else
255: {
256: if (fprintf(fichier, " No argument\n") < 0)
257: {
258: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
259: return;
260: }
261: }
262:
263: while(l_base_pile != NULL)
264: {
265: if (depilement(s_etat_processus, &l_base_pile,
266: &s_objet_last) == d_erreur)
267: {
268: return;
269: }
270:
271: if (empilement(s_etat_processus, &((*s_etat_processus)
272: .l_base_pile_last), s_objet_last) == d_erreur)
273: {
274: return;
275: }
276: }
277: }
278: else
279: {
280: // LAST invalide
281:
282: if (fprintf(fichier, "// Current stack (LAST disabled)\n") < 0)
283: {
284: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
285: return;
286: }
287: }
288:
289: if (fprintf(fichier, "\n// Stack\n\n") < 0)
290: {
291: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
292: return;
293: }
294:
295: if ((*s_etat_processus).l_base_pile != NULL)
296: {
1.3 bertrand 297: registre = (*s_etat_processus).autorisation_conversion_chaine;
298: (*s_etat_processus).autorisation_conversion_chaine = 'N';
299:
1.1 bertrand 300: ecriture_pile(s_etat_processus, fichier,
301: (*s_etat_processus).l_base_pile, 1);
1.3 bertrand 302:
303: (*s_etat_processus).autorisation_conversion_chaine = registre;
1.1 bertrand 304: }
305: else
306: {
307: if (fprintf(fichier, " Empty stack\n") < 0)
308: {
309: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
310: return;
311: }
312: }
313:
314: if ((*s_etat_processus).s_objet_errone != NULL)
315: {
316: if (fprintf(fichier, "\n// Current evaluation\n") < 0)
317: {
318: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
319: return;
320: }
321:
322: // L'objet ne peut être qu'une expression algébrique ou RPN
323:
324: if (((*(*s_etat_processus).s_objet_errone).type == RPN) ||
325: ((*(*s_etat_processus).s_objet_errone).type == ALG))
326: {
327: l_element_courant = (*(*s_etat_processus).s_objet_errone).objet;
328:
329: if (fprintf(fichier, "\n") < 0)
330: {
331: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
332: return;
333: }
334:
335: while(l_element_courant != NULL)
336: {
337: if ((*l_element_courant).donnee ==
338: (*s_etat_processus).s_objet_erreur)
339: {
340: if ((expression = formateur(s_etat_processus, 4,
341: (*l_element_courant).donnee)) == NULL)
342: {
343: return;
344: }
345:
346: if ((*(*l_element_courant).donnee).type == CHN)
347: {
348: if (fprintf(fichier, " -> \"%s\"\n", expression) < 0)
349: {
350: (*s_etat_processus).erreur_systeme =
351: d_es_erreur_fichier;
352: return;
353: }
354: }
355: else
356: {
357: if (fprintf(fichier, " -> %s\n", expression) < 0)
358: {
359: (*s_etat_processus).erreur_systeme =
360: d_es_erreur_fichier;
361: return;
362: }
363: }
364: }
365: else
366: {
367: if ((expression = formateur(s_etat_processus, 4,
368: (*l_element_courant).donnee)) == NULL)
369: {
370: return;
371: }
372:
373: if ((*(*l_element_courant).donnee).type == CHN)
374: {
375: if (fprintf(fichier, " \"%s\"\n", expression) < 0)
376: {
377: (*s_etat_processus).erreur_systeme =
378: d_es_erreur_fichier;
379: return;
380: }
381: }
382: else
383: {
384: if (fprintf(fichier, " %s\n", expression) < 0)
385: {
386: (*s_etat_processus).erreur_systeme =
387: d_es_erreur_fichier;
388: return;
389: }
390: }
391: }
392:
393: free(expression);
394: l_element_courant = (*l_element_courant).suivant;
395: }
396: }
397: else
398: {
399: if ((expression = formateur(s_etat_processus, 4,
400: (*s_etat_processus).s_objet_errone)) == NULL)
401: {
402: return;
403: }
404:
405: if (fprintf(fichier, "\n%s\n", expression) < 0)
406: {
407: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
408: return;
409: }
410:
411: free(expression);
412: }
413: }
414:
415: if ((*s_etat_processus).longueur_definitions_chainees != 0)
416: {
417: if (fprintf(fichier, "\n// Definitions\n") < 0)
418: {
419: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
420: return;
421: }
422:
423: ptr = (*s_etat_processus).definitions_chainees;
424: i = 0;
425: erreur = d_faux;
426:
427: while(((*ptr) != d_code_fin_chaine) || (erreur == d_vrai))
428: {
429: if ((i % longueur_lignes) == 0)
430: {
431: if (fprintf(fichier, "\n") < 0)
432: {
433: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
434: return;
435: }
436:
437: if (erreur == d_vrai)
438: {
439: if (fprintf(fichier, "PC :") < 0)
440: {
441: (*s_etat_processus).erreur_systeme =
442: d_es_erreur_fichier;
443: return;
444: }
445:
446: if ((j = i - longueur_lignes) < 0)
447: {
448: j = 0;
449: ptr_bis = (*s_etat_processus).definitions_chainees;
450: }
451: else
452: {
453: ptr_bis = ptr - longueur_lignes;
454: }
455:
456: fin_boucle = d_faux;
457:
458: while(((*ptr_bis) != d_code_fin_chaine) &&
459: (fin_boucle == d_faux))
460: {
461: if (j == (long) (*s_etat_processus).position_courante)
462: {
463: if (fprintf(fichier, ">|<") < 0)
464: {
465: (*s_etat_processus).erreur_systeme =
466: d_es_erreur_fichier;
467: return;
468: }
469:
470: fin_boucle = d_vrai;
471: }
472: else
473: {
474: if (fprintf(fichier, " ") < 0)
475: {
476: (*s_etat_processus).erreur_systeme =
477: d_es_erreur_fichier;
478: return;
479: }
480: }
481:
482: j++;
483: ptr_bis++;
484: }
485:
486: if (fprintf(fichier, "\n") < 0)
487: {
488: (*s_etat_processus).erreur_systeme =
489: d_es_erreur_fichier;
490: return;
491: }
492: }
493:
494: if ((*ptr) != d_code_fin_chaine)
495: {
496: if (erreur == d_vrai)
497: {
498: if (fprintf(fichier, "\n") < 0)
499: {
500: (*s_etat_processus).erreur_systeme =
501: d_es_erreur_fichier;
502: return;
503: }
504: }
505:
506: if ((i <= (long) (*s_etat_processus).position_courante) &&
507: ((i + longueur_lignes) > (long) (*s_etat_processus)
508: .position_courante))
509: {
510: if (fprintf(fichier, "\nError : ") < 0)
511: {
512: (*s_etat_processus).erreur_systeme =
513: d_es_erreur_fichier;
514: return;
515: }
516:
517: erreur = d_vrai;
518: }
519: else
520: {
521: if (fprintf(fichier, " ") < 0)
522: {
523: (*s_etat_processus).erreur_systeme =
524: d_es_erreur_fichier;
525: return;
526: }
527:
528: erreur = d_faux;
529: }
530: }
531: else
532: {
533: erreur = d_faux;
534: }
535: }
536:
537: if ((*ptr) != d_code_fin_chaine)
538: {
539: if (ufprintf(fichier, "%c", *ptr) < 0)
540: {
541: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
542: return;
543: }
544:
545: ptr++;
546: }
547:
548: i++;
549: }
550:
551: if (fprintf(fichier, "\n// End of definitions\n") < 0)
552: {
553: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
554: return;
555: }
556: }
557:
558: if (fprintf(fichier, "\n// Externals\n\n") < 0)
559: {
560: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
561: return;
562: }
563:
564: instruction_externals(s_etat_processus);
565:
566: if (fprintf(fichier, "%s\n", pile =
567: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
568: .donnee)) < 0)
569: {
570: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
571: return;
572: }
573:
574: free(pile);
575:
576: if (fprintf(fichier, "\n// Variables\n\n") < 0)
577: {
578: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
579: return;
580: }
581:
582: instruction_vars(s_etat_processus);
583:
584: if (fprintf(fichier, "%s\n", pile =
585: formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
586: .donnee)) < 0)
587: {
588: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
589: return;
590: }
591:
592: free(pile);
593:
594: instruction_drop2(s_etat_processus);
595:
596: if (fclose(fichier) != 0)
597: {
598: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
599: return;
600: }
601:
602: free((*s_etat_processus).instruction_derniere_erreur);
603: (*s_etat_processus).instruction_derniere_erreur = NULL;
604:
605: return;
606: }
607:
608: // vim: ts=4