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