![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interface_tex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to interface_tex.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.59 ! bertrand 3: RPL/2 (R) version 4.1.22
1.55 bertrand 4: Copyright (C) 1989-2015 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.15 bertrand 23: #include "rpl-conv.h"
24: #include "tex-conv.h"
1.1 bertrand 25:
26:
27: /*
28: ================================================================================
29: Fonction créant un fichier d'impression au format TeX
30: ================================================================================
31: Entrées :
32: --------------------------------------------------------------------------------
33: Sorties :
34: --------------------------------------------------------------------------------
35: Effets de bord : néant
36: ================================================================================
37: */
38:
39: file *
40: creation_fichier_tex(struct_processus *s_etat_processus)
41: {
42: file *fichier_impression;
43:
44: unsigned char *nom_fichier_temporaire;
45:
46: if ((nom_fichier_temporaire = creation_nom_fichier(s_etat_processus,
47: (*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
48: {
49: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
50: return(NULL);
51: }
52:
53: if ((nom_fichier_temporaire = realloc(nom_fichier_temporaire,
54: (strlen(nom_fichier_temporaire) + 5) *
55: sizeof(unsigned char))) == NULL)
56: {
57: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
58: return(NULL);
59: }
60:
61: strcat(nom_fichier_temporaire, ".tex");
62: (*s_etat_processus).nom_fichier_impression = nom_fichier_temporaire;
63:
64: if ((fichier_impression = fopen(nom_fichier_temporaire, "w+")) == NULL)
65: {
66: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
67: return(NULL);
68: }
69:
1.5 bertrand 70: if (tex_fprintf(s_etat_processus, fichier_impression,
71: "\\documentclass[%s,%s]{%s}\n\n",
1.1 bertrand 72: (*s_etat_processus).format_papier, ds_tex_taille_corps,
73: ds_tex_classe_document) < 0)
74: {
75: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
76: return(NULL);
77: }
78:
79:
1.5 bertrand 80: if (tex_fprintf(s_etat_processus, fichier_impression,
81: "\\usepackage[%s]{fontenc}\n", ds_tex_encodage_1) < 0)
1.1 bertrand 82: {
83: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
84: return(NULL);
85: }
86:
1.5 bertrand 87: if (tex_fprintf(s_etat_processus, fichier_impression,
88: "\\usepackage[%s]{inputenc}\n", ds_tex_encodage_2) < 0)
1.1 bertrand 89: {
90: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
91: return(NULL);
92: }
93:
1.5 bertrand 94: if (tex_fprintf(s_etat_processus, fichier_impression,
95: "\\usepackage[%s]{babel}\n\n", ds_tex_langue) < 0)
1.1 bertrand 96: {
97: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
98: return(NULL);
99: }
100:
1.5 bertrand 101: if (tex_fprintf(s_etat_processus, fichier_impression,
102: "\\usepackage{latexsym}\n") < 0)
1.1 bertrand 103: {
104: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
105: return(NULL);
106: }
107:
1.5 bertrand 108: if (tex_fprintf(s_etat_processus, fichier_impression,
109: "\\usepackage[dvips]{color}\n\n") < 0)
1.1 bertrand 110: {
111: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
112: return(NULL);
113: }
114:
1.5 bertrand 115: if (tex_fprintf(s_etat_processus, fichier_impression,
116: "\\usepackage{amsmath}\n") < 0)
1.1 bertrand 117: {
118: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
119: return(NULL);
120: }
121:
1.5 bertrand 122: if (tex_fprintf(s_etat_processus, fichier_impression,
123: "\\usepackage{amsfonts}\n") < 0)
1.1 bertrand 124: {
125: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
126: return(NULL);
127: }
128:
1.5 bertrand 129: if (tex_fprintf(s_etat_processus, fichier_impression,
130: "\\usepackage{amssymb}\n\n") < 0)
1.1 bertrand 131: {
132: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
133: return(NULL);
134: }
135:
1.5 bertrand 136: if (tex_fprintf(s_etat_processus, fichier_impression,
137: "\\title{Fichier d'impression}\n") < 0)
1.1 bertrand 138: {
139: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
140: return(NULL);
141: }
142:
1.5 bertrand 143: if (tex_fprintf(s_etat_processus, fichier_impression,
144: "\\author{RPL/2 Version %s}\n", d_version_rpl) < 0)
1.1 bertrand 145: {
146: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
147: return(NULL);
148: }
149:
1.5 bertrand 150: if (tex_fprintf(s_etat_processus, fichier_impression, "\\date{}\n\n") < 0)
1.1 bertrand 151: {
152: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
153: return(NULL);
154: }
155:
1.5 bertrand 156: if (tex_fprintf(s_etat_processus, fichier_impression,
157: "\\begin{document}\n\n") < 0)
1.1 bertrand 158: {
159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
160: return(NULL);
161: }
162:
1.5 bertrand 163: if (tex_fprintf(s_etat_processus, fichier_impression,
164: "\\thispagestyle{%s}\n", ds_tex_style) < 0)
1.1 bertrand 165: {
166: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
167: return(NULL);
168: }
169:
1.5 bertrand 170: if (tex_fprintf(s_etat_processus, fichier_impression,
171: "\\pagestyle{%s}\n\n", ds_tex_style) < 0)
1.1 bertrand 172: {
173: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
174: return(NULL);
175: }
176:
177: return(fichier_impression);
178: }
179:
180:
181: /*
182: ================================================================================
183: Fonction 'formateur_tex'
184: ================================================================================
185: Entrées : environnement 'V' verbatim, 'N' normal
186: --------------------------------------------------------------------------------
187: Sorties :
188: --------------------------------------------------------------------------------
189: Effets de bord : néant
190: ================================================================================
191: */
192:
193: void
194: formateur_tex(struct_processus *s_etat_processus, struct_objet *s_objet,
195: unsigned char environnement)
196: {
197: file *fichier_impression;
198:
199: /*
200: * Création, le cas échéant, du fichier d'impression
201: */
202:
203: if ((*s_etat_processus).nom_fichier_impression == NULL)
204: {
205: if ((fichier_impression = creation_fichier_tex(s_etat_processus))
206: == NULL)
207: {
208: return;
209: }
210: }
211: else
212: {
213: if ((fichier_impression = fopen((*s_etat_processus)
214: .nom_fichier_impression, "a")) == NULL)
215: {
216: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
217: return;
218: }
219: }
220:
221: /*
222: * Impression d'un entier binaire
223: */
224:
225: if ((*s_objet).type == BIN)
226: {
1.5 bertrand 227: if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
1.1 bertrand 228: {
229: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
230: return;
231: }
232:
233: formateur_elementaire_tex(s_etat_processus, fichier_impression,
234: s_objet, environnement);
235:
1.5 bertrand 236: if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
1.1 bertrand 237: {
238: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
239: return;
240: }
241: }
242:
243: /*
244: * Impression des chaînes de caractères
245: */
246:
247: else if ((*s_objet).type == CHN)
248: {
249: formateur_elementaire_tex(s_etat_processus, fichier_impression,
250: s_objet, environnement);
251:
1.5 bertrand 252: if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
1.1 bertrand 253: {
254: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
255: return;
256: }
257: }
258:
259: /*
260: * Impression d'un nombre
261: */
262:
263: else if (((*s_objet).type == CPL) ||
264: ((*s_objet).type == INT) ||
265: ((*s_objet).type == REL))
266: {
1.5 bertrand 267: if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
1.1 bertrand 268: {
269: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
270: return;
271: }
272:
273: formateur_elementaire_tex(s_etat_processus, fichier_impression,
274: s_objet, environnement);
275:
1.5 bertrand 276: if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
1.1 bertrand 277: {
278: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
279: return;
280: }
281: }
282:
283: /*
284: * Impression d'un nom
285: */
286:
287: else if ((*s_objet).type == NOM)
288: {
1.5 bertrand 289: if (tex_fprintf(s_etat_processus, fichier_impression,
290: "\\begin{center}\n") < 0)
1.1 bertrand 291: {
292: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
293: return;
294: }
295:
296: formateur_elementaire_tex(s_etat_processus, fichier_impression,
297: s_objet, environnement);
298:
1.5 bertrand 299: if (tex_fprintf(s_etat_processus, fichier_impression,
300: "\\end{center}\n") < 0)
1.1 bertrand 301: {
302: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
303: return;
304: }
305: }
306:
307: /*
308: * Impression d'un vecteur
309: */
310:
311: else if (((*s_objet).type == VCX) ||
312: ((*s_objet).type == VIN) ||
313: ((*s_objet).type == VRL))
314: {
1.5 bertrand 315: if (tex_fprintf(s_etat_processus, fichier_impression,
316: "\\begin{equation}\n") < 0)
1.1 bertrand 317: {
318: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
319: return;
320: }
321:
322: formateur_elementaire_tex(s_etat_processus, fichier_impression,
323: s_objet, environnement);
324:
1.5 bertrand 325: if (tex_fprintf(s_etat_processus, fichier_impression,
326: "\\nonumber\n") < 0)
1.1 bertrand 327: {
328: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
329: return;
330: }
331:
1.5 bertrand 332: if (tex_fprintf(s_etat_processus, fichier_impression,
333: "\\end{equation}\n") < 0)
1.1 bertrand 334: {
335: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
336: return;
337: }
338: }
339:
340: /*
341: * Impression d'une matrice d'entiers
342: */
343:
344: else if (((*s_objet).type == MIN) ||
345: ((*s_objet).type == MRL) ||
346: ((*s_objet).type == MCX))
347: {
1.5 bertrand 348: if (tex_fprintf(s_etat_processus, fichier_impression,
349: "\\begin{equation}\n") < 0)
1.1 bertrand 350: {
351: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
352: return;
353: }
354:
355: formateur_elementaire_tex(s_etat_processus, fichier_impression,
356: s_objet, environnement);
357:
1.5 bertrand 358: if (tex_fprintf(s_etat_processus, fichier_impression,
359: "\\nonumber\n") < 0)
1.1 bertrand 360: {
361: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
362: return;
363: }
364:
1.5 bertrand 365: if (tex_fprintf(s_etat_processus, fichier_impression,
366: "\\end{equation}\n") < 0)
1.1 bertrand 367: {
368: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
369: return;
370: }
371: }
372:
373: /*
374: * Impression d'une expression RPN ou d'une liste
375: */
376:
377: else if (((*s_objet).type == RPN) ||
378: ((*s_objet).type == LST))
379: {
1.5 bertrand 380: if (tex_fprintf(s_etat_processus, fichier_impression,
381: "\\begin{center}\n") < 0)
1.1 bertrand 382: {
383: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
384: return;
385: }
386:
387: formateur_elementaire_tex(s_etat_processus, fichier_impression,
388: s_objet, environnement);
389:
1.5 bertrand 390: if (tex_fprintf(s_etat_processus, fichier_impression,
391: "\\end{center}\n") < 0)
1.1 bertrand 392: {
393: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
394: return;
395: }
396: }
397:
398: /*
399: * Impression d'une expression algébrique
400: */
401:
402: else if ((*s_objet).type == ALG)
403: {
1.5 bertrand 404: if (tex_fprintf(s_etat_processus, fichier_impression,
405: "\\begin{equation}\n") < 0)
1.1 bertrand 406: {
407: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
408: return;
409: }
410:
411: formateur_elementaire_tex(s_etat_processus, fichier_impression,
412: s_objet, environnement);
413:
1.5 bertrand 414: if (tex_fprintf(s_etat_processus, fichier_impression,
415: "\\nonumber\n") < 0)
1.1 bertrand 416: {
417: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
418: return;
419: }
420:
1.5 bertrand 421: if (tex_fprintf(s_etat_processus, fichier_impression,
422: "\\end{equation}\n") < 0)
1.1 bertrand 423: {
424: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
425: return;
426: }
427: }
428:
429: /*
430: * Objet invalide
431: */
432:
433: else
434: {
435: if (fclose(fichier_impression) != 0)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
438: return;
439: }
440:
441: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
442: return;
443: }
444:
445: if (fclose(fichier_impression) != 0)
446: {
447: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
448: return;
449: }
450:
451: return;
452: }
453:
454:
455: /*
456: ================================================================================
457: Formatage des fichiers TeX au niveau des types d'objets élémentaires
458: ================================================================================
459: Entrées :
460: --------------------------------------------------------------------------------
461: Sorties :
462: --------------------------------------------------------------------------------
463: Effets de bord : néant
464: ================================================================================
465: */
466:
467: void
468: formateur_elementaire_tex(struct_processus *s_etat_processus,
469: file *fichier_impression, struct_objet *s_objet,
470: unsigned char environnement)
471: {
472: logical1 fraction;
473: logical1 multiplication;
474: logical1 puissance;
475:
476: struct_liste_chainee *l_element_courant;
477: struct_liste_chainee *l_liste1;
478: struct_liste_chainee *l_liste2;
479:
480: struct_objet *s_copie_objet;
481: struct_objet s_objet_elementaire;
482: struct_objet *s_sous_objet;
483: struct_objet *s_sous_objet_1;
484: struct_objet *s_sous_objet_2;
485:
486: unsigned char base;
487: unsigned char *chaine;
488: unsigned char *chaine_majuscule;
489: unsigned char *chaine_parametre;
490: unsigned char *chaine_sauvegarde;
491: unsigned char *instruction_courante;
492: unsigned char *instruction_majuscule;
493: unsigned char instruction_valide;
494: unsigned char *ligne;
495: unsigned char *ptre;
496: unsigned char *ptrl;
497: unsigned char test_instruction;
498: unsigned char *tampon;
499:
1.47 bertrand 500: integer8 i;
501: integer8 j;
502: integer8 niveau;
503: integer8 nombre_arguments;
1.1 bertrand 504:
505: /*
506: * Entier binaire
507: */
508:
509: if ((*s_objet).type == BIN)
510: {
511: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
512: {
513: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
514: return;
515: }
516:
517: base = ligne[strlen(ligne) - 1];
518: ligne[strlen(ligne) - 1] = d_code_fin_chaine;
519:
1.5 bertrand 520: if (tex_fprintf(s_etat_processus, fichier_impression,
521: "\\#\\,%s\\text{%c}", &(ligne[1]), base) < 0)
1.1 bertrand 522: {
523: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
524: return;
525: }
526:
527: free(ligne);
528: }
529:
530: /*
531: * Chaîne de caractères
532: */
533:
534: else if ((*s_objet).type == CHN)
535: {
536: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
537: {
538: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
539: return;
540: }
541:
542: if (environnement == 'N')
543: {
544: correction_formateur_tex(s_etat_processus, &ligne);
545: }
546:
1.5 bertrand 547: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
1.1 bertrand 548: {
549: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
550: return;
551: }
552:
553: free(ligne);
554: }
555:
556: /*
557: * Nom
558: */
559:
560: else if ((*s_objet).type == NOM)
561: {
562: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
563: {
564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
565: return;
566: }
567:
568: if (environnement == 'N')
569: {
570: correction_formateur_tex(s_etat_processus, &ligne);
571: }
572:
573: test_instruction = (*s_etat_processus).test_instruction;
574: instruction_valide = (*s_etat_processus).instruction_valide;
575: instruction_courante = (*s_etat_processus).instruction_courante;
576:
577: (*s_etat_processus).test_instruction = 'Y';
578: (*s_etat_processus).instruction_courante =
579: (*((struct_nom *) (*s_objet).objet)).nom;
580:
581: analyse(s_etat_processus, NULL);
582:
583: if ((*s_etat_processus).instruction_valide == 'Y')
584: {
1.57 bertrand 585: if ((instruction_majuscule = conversion_majuscule(s_etat_processus,
1.1 bertrand 586: (*s_etat_processus).instruction_courante)) == NULL)
587: {
588: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
589: return;
590: }
591:
592: if (strcmp(instruction_majuscule, "PI") == 0)
593: {
1.5 bertrand 594: if (tex_fprintf(s_etat_processus, fichier_impression,
595: "$\\pi$") < 0)
1.1 bertrand 596: {
597: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
598: return;
599: }
600: }
601: else
602: {
1.5 bertrand 603: if (tex_fprintf(s_etat_processus, fichier_impression,
604: "\\textrm{%s}", ligne) < 0)
1.1 bertrand 605: {
606: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
607: return;
608: }
609: }
610:
611: free(instruction_majuscule);
612: }
613: else
614: {
1.5 bertrand 615: if (tex_fprintf(s_etat_processus, fichier_impression,
616: "\\textit{%s}", ligne) < 0)
1.1 bertrand 617: {
618: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
619: return;
620: }
621: }
622:
623: (*s_etat_processus).instruction_courante = instruction_courante;
624: (*s_etat_processus).test_instruction = test_instruction;
625: (*s_etat_processus).instruction_valide = instruction_valide;
626:
627: free(ligne);
628: }
629:
630: /*
631: * Nombre complexe
632: */
633:
634: else if ((*s_objet).type == CPL)
635: {
636: s_objet_elementaire.type = REL;
637:
638: if ((s_objet_elementaire.objet = malloc(sizeof(real8))) == NULL)
639: {
640: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
641: return;
642: }
643:
1.5 bertrand 644: if (tex_fprintf(s_etat_processus, fichier_impression, "\\left(") < 0)
1.1 bertrand 645: {
646: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
647: return;
648: }
649:
650: (*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *)
651: (*s_objet).objet)).partie_reelle;
652:
653: formateur_elementaire_tex(s_etat_processus, fichier_impression,
654: &s_objet_elementaire, environnement);
655:
656: (*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *)
657: (*s_objet).objet)).partie_imaginaire;
658:
659: if (test_cfsf(s_etat_processus, 48) == d_vrai)
660: {
1.5 bertrand 661: if (tex_fprintf(s_etat_processus, fichier_impression, ".\\,") < 0)
1.1 bertrand 662: {
663: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
664: return;
665: }
666: }
667: else
668: {
1.5 bertrand 669: if (tex_fprintf(s_etat_processus, fichier_impression, ",") < 0)
1.1 bertrand 670: {
671: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
672: return;
673: }
674: }
675:
676: formateur_elementaire_tex(s_etat_processus, fichier_impression,
677: &s_objet_elementaire, environnement);
678:
1.5 bertrand 679: if (tex_fprintf(s_etat_processus, fichier_impression, "\\right)") < 0)
1.1 bertrand 680: {
681: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
682: return;
683: }
684:
685: free(s_objet_elementaire.objet);
686: }
687:
688: /*
689: * Entier
690: */
691:
692: else if ((*s_objet).type == INT)
693: {
694: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
695: {
696: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
697: return;
698: }
699:
1.5 bertrand 700: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
1.1 bertrand 701: {
702: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
703: return;
704: }
705:
706: free(ligne);
707: }
708:
709: /*
710: * Matrice de complexes
711: */
712:
713: else if ((*s_objet).type == MCX)
714: {
1.5 bertrand 715: if (tex_fprintf(s_etat_processus, fichier_impression,
716: "\\left(\\begin{array}{") < 0)
1.1 bertrand 717: {
718: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
719: return;
720: }
721:
722: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
723: .nombre_colonnes; i++)
724: {
1.5 bertrand 725: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
1.1 bertrand 726: {
727: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
728: return;
729: }
730: }
731:
1.5 bertrand 732: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
1.1 bertrand 733: {
734: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
735: return;
736: }
737:
738: if ((s_objet_elementaire.objet = (complex16 *) malloc(
739: sizeof(complex16))) == NULL)
740: {
741: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
742: return;
743: }
744:
745: s_objet_elementaire.type = CPL;
746:
747: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
748: i++)
749: {
750: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
751: .nombre_colonnes; j++)
752: {
753: (*((complex16 *) (s_objet_elementaire.objet))).partie_reelle =
754: ((complex16 **) (*((struct_matrice *)
755: (*s_objet).objet)).tableau)[i][j].partie_reelle;
756: (*((complex16 *) (s_objet_elementaire.objet)))
757: .partie_imaginaire = ((complex16 **)
758: (*((struct_matrice *) (*s_objet).objet)).tableau)[i][j]
759: .partie_imaginaire;
760:
761: formateur_elementaire_tex(s_etat_processus, fichier_impression,
762: &s_objet_elementaire, environnement);
763:
764: if (j == ((*((struct_matrice *) (*s_objet).objet))
765: .nombre_colonnes - 1))
766: {
1.5 bertrand 767: if (tex_fprintf(s_etat_processus, fichier_impression,
768: " \\\\\n") < 0)
1.1 bertrand 769: {
770: (*s_etat_processus).erreur_systeme =
771: d_es_erreur_fichier;
772: return;
773: }
774: }
775: else
776: {
1.5 bertrand 777: if (tex_fprintf(s_etat_processus, fichier_impression,
778: " & ") < 0)
1.1 bertrand 779: {
780: (*s_etat_processus).erreur_systeme =
781: d_es_erreur_fichier;
782: return;
783: }
784: }
785: }
786: }
787:
788: free(s_objet_elementaire.objet);
789:
1.5 bertrand 790: if (tex_fprintf(s_etat_processus, fichier_impression,
791: "\\end{array}\\right)\n") < 0)
1.1 bertrand 792: {
793: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
794: return;
795: }
796: }
797:
798: /*
799: * Matrice d'entiers
800: */
801:
802: else if ((*s_objet).type == MIN)
803: {
1.5 bertrand 804: if (tex_fprintf(s_etat_processus, fichier_impression,
805: "\\left(\\begin{array}{") < 0)
1.1 bertrand 806: {
807: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
808: return;
809: }
810:
811: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
812: .nombre_colonnes; i++)
813: {
1.5 bertrand 814: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
1.1 bertrand 815: {
816: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
817: return;
818: }
819: }
820:
1.5 bertrand 821: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
1.1 bertrand 822: {
823: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
824: return;
825: }
826:
827: if ((s_objet_elementaire.objet = (integer8 *) malloc(sizeof(integer8)))
828: == NULL)
829: {
830: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
831: return;
832: }
833:
834: s_objet_elementaire.type = INT;
835:
836: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
837: i++)
838: {
839: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
840: .nombre_colonnes; j++)
841: {
842: (*((integer8 *) (s_objet_elementaire.objet))) =
843: ((integer8 **) (*((struct_matrice *)
844: (*s_objet).objet)).tableau)[i][j];
845:
846: formateur_elementaire_tex(s_etat_processus, fichier_impression,
847: &s_objet_elementaire, environnement);
848:
849: if (j == ((*((struct_matrice *) (*s_objet).objet))
850: .nombre_colonnes - 1))
851: {
1.5 bertrand 852: if (tex_fprintf(s_etat_processus, fichier_impression,
853: " \\\\\n") < 0)
1.1 bertrand 854: {
855: (*s_etat_processus).erreur_systeme =
856: d_es_erreur_fichier;
857: return;
858: }
859: }
860: else
861: {
1.5 bertrand 862: if (tex_fprintf(s_etat_processus, fichier_impression,
863: " & ") < 0)
1.1 bertrand 864: {
865: (*s_etat_processus).erreur_systeme =
866: d_es_erreur_fichier;
867: return;
868: }
869: }
870: }
871: }
872:
873: free(s_objet_elementaire.objet);
874:
1.5 bertrand 875: if (tex_fprintf(s_etat_processus, fichier_impression,
876: "\\end{array}\\right)\n") < 0)
1.1 bertrand 877: {
878: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
879: return;
880: }
881: }
882:
883: /*
884: * Matrice de réels
885: */
886:
887: else if ((*s_objet).type == MRL)
888: {
1.5 bertrand 889: if (tex_fprintf(s_etat_processus, fichier_impression,
890: "\\left(\\begin{array}{") < 0)
1.1 bertrand 891: {
892: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
893: return;
894: }
895:
896: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
897: .nombre_colonnes; i++)
898: {
1.5 bertrand 899: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
1.1 bertrand 900: {
901: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
902: return;
903: }
904: }
905:
1.5 bertrand 906: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
1.1 bertrand 907: {
908: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
909: return;
910: }
911:
912: if ((s_objet_elementaire.objet = (real8 *) malloc(sizeof(real8)))
913: == NULL)
914: {
915: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
916: return;
917: }
918:
919: s_objet_elementaire.type = REL;
920:
921: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
922: i++)
923: {
924: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
925: .nombre_colonnes; j++)
926: {
927: (*((real8 *) (s_objet_elementaire.objet))) =
928: ((real8 **) (*((struct_matrice *)
929: (*s_objet).objet)).tableau)[i][j];
930:
931: formateur_elementaire_tex(s_etat_processus, fichier_impression,
932: &s_objet_elementaire, environnement);
933:
934: if (j == ((*((struct_matrice *) (*s_objet).objet))
935: .nombre_colonnes - 1))
936: {
1.5 bertrand 937: if (tex_fprintf(s_etat_processus, fichier_impression,
938: " \\\\\n") < 0)
1.1 bertrand 939: {
940: (*s_etat_processus).erreur_systeme =
941: d_es_erreur_fichier;
942: return;
943: }
944: }
945: else
946: {
1.5 bertrand 947: if (tex_fprintf(s_etat_processus, fichier_impression,
948: " & ") < 0)
1.1 bertrand 949: {
950: (*s_etat_processus).erreur_systeme =
951: d_es_erreur_fichier;
952: return;
953: }
954: }
955: }
956: }
957:
958: free(s_objet_elementaire.objet);
959:
1.5 bertrand 960: if (tex_fprintf(s_etat_processus, fichier_impression,
961: "\\end{array}\\right)\n") < 0)
1.1 bertrand 962: {
963: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
964: return;
965: }
966: }
967:
968: /*
969: * Réel
970: */
971:
972: else if ((*s_objet).type == REL)
973: {
974: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
975: {
976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
977: return;
978: }
979:
1.47 bertrand 980: for(i = 0; i < (integer8) strlen(ligne); i++)
1.1 bertrand 981: {
982: switch(ligne[i])
983: {
984: case 'e' :
985: case 'E' :
986: {
987: if ((tampon = (unsigned char *) malloc((strlen(ligne)
988: + 12) * sizeof(unsigned char))) == NULL)
989: {
990: (*s_etat_processus).erreur_systeme =
991: d_es_allocation_memoire;
992: return;
993: }
994:
1.47 bertrand 995: strncpy(tampon, ligne, (size_t) i);
1.1 bertrand 996: strcpy(&(tampon[i]), "\\times 10^{");
997: strcat(tampon, &(ligne[++i]));
998: strcat(tampon, "}");
999: i += 10;
1000:
1001: free(ligne);
1002: ligne = tampon;
1003:
1004: break;
1005: }
1006:
1007: case ',' :
1008: {
1009: if ((tampon = (unsigned char *) malloc((strlen(ligne)
1010: + 3) * sizeof(unsigned char))) == NULL)
1011: {
1012: (*s_etat_processus).erreur_systeme =
1013: d_es_allocation_memoire;
1014: return;
1015: }
1016:
1.47 bertrand 1017: strncpy(tampon, ligne, (size_t) ++i);
1.1 bertrand 1018: strcpy(&(tampon[i]), "\\!");
1019: strcat(tampon, &(ligne[i]));
1020: i += 2;
1021:
1022: free(ligne);
1023: ligne = tampon;
1024:
1025: break;
1026: }
1027: }
1028: }
1029:
1.5 bertrand 1030: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
1.1 bertrand 1031: {
1032: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1033: return;
1034: }
1035:
1036: free(ligne);
1037: }
1038:
1039: /*
1040: * Vecteur de complexes
1041: */
1042:
1043: else if ((*s_objet).type == VCX)
1044: {
1.5 bertrand 1045: if (tex_fprintf(s_etat_processus, fichier_impression,
1046: "\\left(\\begin{array}{c}\n") < 0)
1.1 bertrand 1047: {
1048: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1049: return;
1050: }
1051:
1052: if ((s_objet_elementaire.objet = (complex16 *) malloc(
1053: sizeof(complex16))) == NULL)
1054: {
1055: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1056: return;
1057: }
1058:
1059: s_objet_elementaire.type = CPL;
1060:
1061: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1062: {
1063: (*((complex16 *) (s_objet_elementaire.objet))).partie_reelle =
1064: ((complex16 *) (*((struct_vecteur *)
1065: (*s_objet).objet)).tableau)[i].partie_reelle;
1066: (*((complex16 *) (s_objet_elementaire.objet))).partie_imaginaire =
1067: ((complex16 *) (*((struct_vecteur *)
1068: (*s_objet).objet)).tableau)[i].partie_imaginaire;
1069:
1070: formateur_elementaire_tex(s_etat_processus, fichier_impression,
1071: &s_objet_elementaire, environnement);
1072:
1.5 bertrand 1073: if (tex_fprintf(s_etat_processus, fichier_impression,
1074: " \\\\\n") < 0)
1.1 bertrand 1075: {
1076: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1077: return;
1078: }
1079: }
1080:
1081: free(s_objet_elementaire.objet);
1082:
1.5 bertrand 1083: if (tex_fprintf(s_etat_processus, fichier_impression,
1084: "\\end{array}\\right)\n") < 0)
1.1 bertrand 1085: {
1086: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1087: return;
1088: }
1089: }
1090:
1091: /*
1092: * Vecteur d'entiers
1093: */
1094:
1095: else if ((*s_objet).type == VIN)
1096: {
1.5 bertrand 1097: if (tex_fprintf(s_etat_processus, fichier_impression,
1098: "\\left(\\begin{array}{c}\n") < 0)
1.1 bertrand 1099: {
1100: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1101: return;
1102: }
1103:
1104: if ((s_objet_elementaire.objet = (integer8 *) malloc(sizeof(integer8)))
1105: == NULL)
1106: {
1107: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1108: return;
1109: }
1110:
1111: s_objet_elementaire.type = INT;
1112:
1113: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1114: {
1115: (*((integer8 *) (s_objet_elementaire.objet))) =
1116: ((integer8 *) (*((struct_vecteur *)
1117: (*s_objet).objet)).tableau)[i];
1118:
1119: formateur_elementaire_tex(s_etat_processus, fichier_impression,
1120: &s_objet_elementaire, environnement);
1121:
1.5 bertrand 1122: if (tex_fprintf(s_etat_processus, fichier_impression,
1123: " \\\\\n") < 0)
1.1 bertrand 1124: {
1125: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1126: return;
1127: }
1128: }
1129:
1130: free(s_objet_elementaire.objet);
1131:
1.5 bertrand 1132: if (tex_fprintf(s_etat_processus, fichier_impression,
1133: "\\end{array}\\right)\n") < 0)
1.1 bertrand 1134: {
1135: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1136: return;
1137: }
1138: }
1139:
1140: /*
1141: * Vecteur de réels
1142: */
1143:
1144: else if ((*s_objet).type == VRL)
1145: {
1.5 bertrand 1146: if (tex_fprintf(s_etat_processus, fichier_impression,
1147: "\\left(\\begin{array}{c}\n") < 0)
1.1 bertrand 1148: {
1149: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1150: return;
1151: }
1152:
1153: if ((s_objet_elementaire.objet = (real8 *) malloc(sizeof(real8)))
1154: == NULL)
1155: {
1156: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1157: return;
1158: }
1159:
1160: s_objet_elementaire.type = REL;
1161:
1162: for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
1163: {
1164: (*((real8 *) (s_objet_elementaire.objet))) =
1165: ((real8 *) (*((struct_vecteur *)
1166: (*s_objet).objet)).tableau)[i];
1167:
1168: formateur_elementaire_tex(s_etat_processus, fichier_impression,
1169: &s_objet_elementaire, environnement);
1170:
1.5 bertrand 1171: if (tex_fprintf(s_etat_processus, fichier_impression,
1172: " \\\\\n") < 0)
1.1 bertrand 1173: {
1174: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1175: return;
1176: }
1177: }
1178:
1179: free(s_objet_elementaire.objet);
1180:
1.5 bertrand 1181: if (tex_fprintf(s_etat_processus, fichier_impression,
1182: "\\end{array}\\right)\n") < 0)
1.1 bertrand 1183: {
1184: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1185: return;
1186: }
1187: }
1188:
1189: /*
1190: * Fonction
1191: */
1192:
1193: else if ((*s_objet).type == FCT)
1194: {
1195: if ((strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
1196: "+") == 0) || (strcmp((*((struct_fonction *) (*s_objet).objet))
1197: .nom_fonction, "-") == 0) || (strcmp((*((struct_fonction *)
1198: (*s_objet).objet)).nom_fonction, "/") == 0))
1199: {
1.5 bertrand 1200: if (tex_fprintf(s_etat_processus, fichier_impression, "$%s$",
1201: (*((struct_fonction *) (*s_objet).objet)).nom_fonction) < 0)
1.1 bertrand 1202: {
1203: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1204: return;
1205: }
1206: }
1207: else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
1208: "*") == 0)
1209: {
1.5 bertrand 1210: if (tex_fprintf(s_etat_processus, fichier_impression,
1211: "$\\times$") < 0)
1.1 bertrand 1212: {
1213: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1214: return;
1215: }
1216: }
1217: else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
1218: "^") == 0)
1219: {
1.5 bertrand 1220: if (tex_fprintf(s_etat_processus, fichier_impression,
1221: "$\\,\\hat{}\\,$") < 0)
1.1 bertrand 1222: {
1223: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1224: return;
1225: }
1226: }
1227: else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
1228: "->") == 0)
1229: {
1.5 bertrand 1230: if (tex_fprintf(s_etat_processus, fichier_impression,
1231: "$\\rightarrow$") < 0)
1.1 bertrand 1232: {
1233: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1234: return;
1235: }
1236: }
1237: else
1238: {
1239: if ((ligne = (unsigned char *) malloc((strlen((*((struct_fonction *)
1240: (*s_objet).objet)).nom_fonction) + 1) *
1241: sizeof(unsigned char))) == NULL)
1242: {
1243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1244: return;
1245: }
1246:
1247: strcpy(ligne, (*((struct_fonction *) (*s_objet).objet))
1248: .nom_fonction);
1249:
1250: correction_formateur_tex(s_etat_processus, &ligne);
1251:
1.5 bertrand 1252: if (tex_fprintf(s_etat_processus, fichier_impression, ligne) < 0)
1.1 bertrand 1253: {
1254: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1255: return;
1256: }
1257:
1258: free(ligne);
1259: }
1260: }
1261:
1262: /*
1263: * Expression RPN ou liste
1264: */
1265:
1266: else if (((*s_objet).type == RPN) ||
1267: ((*s_objet).type == LST))
1268: {
1269: if ((*s_objet).type == LST)
1270: {
1.5 bertrand 1271: if (tex_fprintf(s_etat_processus, fichier_impression,
1272: "\\begin{equation}\n") < 0)
1.1 bertrand 1273: {
1274: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1275: return;
1276: }
1277:
1.5 bertrand 1278: if (tex_fprintf(s_etat_processus, fichier_impression,
1279: "\\left\\{\\text{%%\n") < 0)
1.1 bertrand 1280: {
1281: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1282: return;
1283: }
1284: }
1285:
1286: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
1287:
1288: while(l_element_courant != NULL)
1289: {
1290: if (((*(*l_element_courant).donnee).type == INT) ||
1291: ((*(*l_element_courant).donnee).type == REL) ||
1292: ((*(*l_element_courant).donnee).type == CPL) ||
1293: ((*(*l_element_courant).donnee).type == VIN) ||
1294: ((*(*l_element_courant).donnee).type == VRL) ||
1295: ((*(*l_element_courant).donnee).type == MIN) ||
1296: ((*(*l_element_courant).donnee).type == MRL) ||
1297: ((*(*l_element_courant).donnee).type == MCX) ||
1298: ((*(*l_element_courant).donnee).type == BIN))
1299: {
1.5 bertrand 1300: if (tex_fprintf(s_etat_processus, fichier_impression, "$") < 0)
1.1 bertrand 1301: {
1302: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1303: return;
1304: }
1305:
1306: formateur_elementaire_tex(s_etat_processus, fichier_impression,
1307: (*l_element_courant).donnee, environnement);
1308:
1.5 bertrand 1309: if (tex_fprintf(s_etat_processus, fichier_impression,
1310: "$%%") < 0)
1.1 bertrand 1311: {
1312: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1313: return;
1314: }
1315: }
1316: else
1317: {
1318: formateur_elementaire_tex(s_etat_processus, fichier_impression,
1319: (*l_element_courant).donnee, environnement);
1320: }
1321:
1.5 bertrand 1322: if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
1.1 bertrand 1323: {
1324: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1325: return;
1326: }
1327:
1328: l_element_courant = (*l_element_courant).suivant;
1329: }
1330:
1331: if ((*s_objet).type == LST)
1332: {
1.5 bertrand 1333: if (tex_fprintf(s_etat_processus, fichier_impression,
1334: "}\\right\\}\\nonumber\n") < 0)
1.1 bertrand 1335: {
1336: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1337: return;
1338: }
1339:
1.5 bertrand 1340: if (tex_fprintf(s_etat_processus, fichier_impression,
1341: "\\end{equation}\n") < 0)
1.1 bertrand 1342: {
1343: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1344: return;
1345: }
1346: }
1347: }
1348:
1349: /*
1350: * Expression algébrique
1351: */
1352:
1353: else if ((*s_objet).type == ALG)
1354: {
1355: if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'N'))
1356: == NULL)
1357: {
1358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1359: return;
1360: }
1361:
1362: l_element_courant = (struct_liste_chainee *) (*s_copie_objet).objet;
1363:
1364: while(l_element_courant != NULL)
1365: {
1366: if ((*(*l_element_courant).donnee).type == FCT)
1367: {
1368: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
1369: .donnee).objet)).nom_fonction, "<<") != 0) &&
1370: (strcmp((*((struct_fonction *) (*(*l_element_courant)
1371: .donnee).objet)).nom_fonction, ">>") != 0))
1372: {
1373: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
1374: .donnee).objet)).nom_fonction, "+") == 0) ||
1375: (strcmp((*((struct_fonction *)
1376: (*(*l_element_courant).donnee).objet))
1377: .nom_fonction, "-") == 0) || (strcmp(
1378: (*((struct_fonction *) (*(*l_element_courant)
1379: .donnee).objet)).nom_fonction, "*") == 0) ||
1380: (strcmp((*((struct_fonction *)
1381: (*(*l_element_courant).donnee).objet)).nom_fonction,
1382: "/") == 0) || (strcmp((*((struct_fonction *)
1383: (*(*l_element_courant).donnee).objet)).nom_fonction,
1384: "^") == 0) || (strcmp((*((struct_fonction *)
1385: (*(*l_element_courant).donnee).objet)).nom_fonction,
1386: "<") == 0) || (strcmp((*((struct_fonction *)
1387: (*(*l_element_courant).donnee).objet)).nom_fonction,
1388: "=") == 0) || (strcmp((*((struct_fonction *)
1389: (*(*l_element_courant).donnee).objet)).nom_fonction,
1390: ">") == 0) || (strcmp((*((struct_fonction *)
1391: (*(*l_element_courant).donnee).objet)).nom_fonction,
1392: "==") == 0) || (strcmp((*((struct_fonction *)
1393: (*(*l_element_courant).donnee).objet)).nom_fonction,
1394: "<>") == 0) || (strcmp((*((struct_fonction *)
1395: (*(*l_element_courant).donnee).objet)).nom_fonction,
1396: "<=") == 0) || (strcmp((*((struct_fonction *)
1397: (*(*l_element_courant).donnee).objet)).nom_fonction,
1398: "=<") == 0) || (strcmp((*((struct_fonction *)
1399: (*(*l_element_courant).donnee).objet)).nom_fonction,
1400: ">=") == 0) || (strcmp((*((struct_fonction *)
1401: (*(*l_element_courant).donnee).objet)).nom_fonction,
1402: "=>") == 0))
1403: {
1404: chaine_sauvegarde = (*((struct_fonction *)
1405: (*(*l_element_courant).donnee).objet))
1406: .nom_fonction;
1407:
1408: fraction = d_faux;
1409: multiplication = d_faux;
1410: puissance = d_faux;
1411:
1412: if ((strcmp(chaine_sauvegarde, "+") == 0) ||
1413: (strcmp(chaine_sauvegarde, "-") == 0) ||
1414: (strcmp(chaine_sauvegarde, "=") == 0) ||
1415: (strcmp(chaine_sauvegarde, "==") == 0))
1416: {
1417: /*
1418: * Il n'y a rien à faire
1419: */
1420: }
1421: else if (strcmp(chaine_sauvegarde, "*") == 0)
1422: {
1423: if (((*((struct_fonction *) (*(*l_element_courant)
1424: .donnee).objet)).nom_fonction = malloc(
1425: 8 * sizeof(unsigned char))) == NULL)
1426: {
1427: (*s_etat_processus).erreur_systeme =
1428: d_es_allocation_memoire;
1429: return;
1430: }
1431:
1432: strcpy((*((struct_fonction *) (*(*l_element_courant)
1433: .donnee).objet)).nom_fonction,
1434: "\\times ");
1435: free(chaine_sauvegarde);
1436:
1437: multiplication = d_vrai;
1438: }
1439: else if (strcmp(chaine_sauvegarde, "/") == 0)
1440: {
1441: fraction = d_vrai;
1442: }
1443: else if (strcmp(chaine_sauvegarde, "^") == 0)
1444: {
1445: puissance = d_vrai;
1446: }
1447: else if ((strcmp(chaine_sauvegarde, "<=") == 0) ||
1448: (strcmp(chaine_sauvegarde, "=<") == 0))
1449: {
1450: if (((*((struct_fonction *) (*(*l_element_courant)
1451: .donnee).objet)).nom_fonction = malloc(
1452: 11 * sizeof(unsigned char))) == NULL)
1453: {
1454: (*s_etat_processus).erreur_systeme =
1455: d_es_allocation_memoire;
1456: return;
1457: }
1458:
1459: strcpy((*((struct_fonction *) (*(*l_element_courant)
1460: .donnee).objet)).nom_fonction,
1461: "\\leqslant ");
1462: free(chaine_sauvegarde);
1463: }
1464: else if ((strcmp(chaine_sauvegarde, ">=") == 0) ||
1465: (strcmp(chaine_sauvegarde, "=>") == 0))
1466: {
1467: if (((*((struct_fonction *) (*(*l_element_courant)
1468: .donnee).objet)).nom_fonction = malloc(
1469: 11 * sizeof(unsigned char))) == NULL)
1470: {
1471: (*s_etat_processus).erreur_systeme =
1472: d_es_allocation_memoire;
1473: return;
1474: }
1475:
1476: strcpy((*((struct_fonction *) (*(*l_element_courant)
1477: .donnee).objet)).nom_fonction,
1478: "\\geqslant ");
1479: free(chaine_sauvegarde);
1480: }
1481: else if (strcmp(chaine_sauvegarde, "<>") == 0)
1482: {
1483: if (((*((struct_fonction *) (*(*l_element_courant)
1484: .donnee).objet)).nom_fonction = malloc(
1485: 6 * sizeof(unsigned char))) == NULL)
1486: {
1487: (*s_etat_processus).erreur_systeme =
1488: d_es_allocation_memoire;
1489: return;
1490: }
1491:
1492: strcpy((*((struct_fonction *) (*(*l_element_courant)
1493: .donnee).objet)).nom_fonction,
1494: "\\neq ");
1495: free(chaine_sauvegarde);
1496: }
1497:
1498: if (depilement(s_etat_processus, &((*s_etat_processus)
1499: .l_base_pile), &s_sous_objet_2) == d_erreur)
1500: {
1501: return;
1502: }
1503:
1504: if (depilement(s_etat_processus, &((*s_etat_processus)
1505: .l_base_pile), &s_sous_objet_1) == d_erreur)
1506: {
1507: return;
1508: }
1509:
1510: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1511: == NULL)
1512: {
1513: return;
1514: }
1515:
1516: if (fraction == d_vrai)
1517: {
1518: if (((*s_sous_objet).objet = (void *)
1519: malloc((strlen(
1520: (unsigned char *) (*s_sous_objet_1).objet) +
1521: strlen((unsigned char *)
1522: (*s_sous_objet_2).objet) + 12) *
1523: sizeof(unsigned char))) == NULL)
1524: {
1525: return;
1526: }
1527:
1528: sprintf((unsigned char *) (*s_sous_objet).objet,
1529: "{\\frac{%s}{%s}}", (unsigned char *)
1530: (*s_sous_objet_1).objet, (unsigned char *)
1531: (*s_sous_objet_2).objet);
1532: }
1533: else if (puissance == d_vrai)
1534: {
1535: if (((unsigned char *)
1536: strstr((unsigned char *) (*s_sous_objet_1)
1537: .objet, "{\\frac{")) == ((unsigned char *)
1538: (*s_sous_objet_1).objet))
1539: {
1540: niveau = 0;
1541:
1.47 bertrand 1542: for(i = 1; i < (integer8)
1543: (strlen((unsigned char *)
1.1 bertrand 1544: (*s_sous_objet_1).objet) - 1); i++)
1545: {
1546: if (((unsigned char *) (*s_sous_objet_1)
1547: .objet)[i] == '{')
1548: {
1549: niveau++;
1550: }
1551: else if (((unsigned char *)
1552: (*s_sous_objet_1).objet)[i] == '}')
1553: {
1554: niveau--;
1555:
1556: if (niveau == 0)
1557: {
1558: break;
1559: }
1560: }
1561: }
1562:
1563: if (niveau == 0)
1564: {
1565: sprintf((unsigned char *) (*s_sous_objet_1)
1566: .objet, "%s", &(((unsigned char *)
1567: (*s_sous_objet_1).objet)[1]));
1568: ((unsigned char *) (*s_sous_objet_1).objet)
1569: [strlen((unsigned char *)
1570: (*s_sous_objet_1).objet) - 1] =
1571: d_code_fin_chaine;
1572: }
1573: }
1574:
1575: chaine_parametre = (unsigned char *)
1576: (*s_sous_objet_1).objet;
1.57 bertrand 1577: conversion_element_tex(s_etat_processus,
1578: &chaine_parametre, "^");
1.1 bertrand 1579:
1580: if ((*s_sous_objet_1).objet == NULL)
1581: {
1582: (*s_etat_processus).erreur_systeme =
1583: d_es_allocation_memoire;
1584: return;
1585: }
1586:
1587: if (((*s_sous_objet).objet = (void *)
1588: malloc((strlen(
1589: (unsigned char *) (*s_sous_objet_1).objet) +
1590: strlen((unsigned char *)
1591: (*s_sous_objet_2).objet) + 8) *
1592: sizeof(unsigned char))) == NULL)
1593: {
1594: return;
1595: }
1596:
1597: sprintf((unsigned char *) (*s_sous_objet).objet,
1598: "{{%s}^{%s}}",
1599: (unsigned char *) (*s_sous_objet_1).objet,
1600: (unsigned char *) (*s_sous_objet_2).objet);
1601: }
1602: else if (multiplication == d_vrai)
1603: {
1604: chaine_parametre = (unsigned char *)
1605: (*s_sous_objet_1).objet;
1.57 bertrand 1606: conversion_element_tex(s_etat_processus,
1607: &chaine_parametre, (*((struct_fonction *)
1.1 bertrand 1608: (*(*l_element_courant).donnee).objet))
1609: .nom_fonction);
1610:
1611: if ((*s_sous_objet_1).objet == NULL)
1612: {
1613: (*s_etat_processus).erreur_systeme =
1614: d_es_allocation_memoire;
1615: return;
1616: }
1617:
1618: chaine_parametre = (unsigned char *)
1619: (*s_sous_objet_2).objet;
1.57 bertrand 1620: conversion_element_tex(s_etat_processus,
1621: &chaine_parametre, (*((struct_fonction *)
1.1 bertrand 1622: (*(*l_element_courant).donnee).objet))
1623: .nom_fonction);
1624:
1625: if ((*s_sous_objet_2).objet == NULL)
1626: {
1627: (*s_etat_processus).erreur_systeme =
1628: d_es_allocation_memoire;
1629: return;
1630: }
1631:
1632: if ((((unsigned char *) (*s_sous_objet_2)
1633: .objet)[0] == '+') || (((unsigned char *)
1634: (*s_sous_objet_2).objet)[0] == '-'))
1635: {
1636: if (((*s_sous_objet).objet = (void *)
1637: malloc((strlen((unsigned char *)
1638: (*s_sous_objet_1).objet) +
1639: strlen((*((struct_fonction *)
1640: (*(*l_element_courant).donnee).objet))
1641: .nom_fonction) +
1642: strlen((unsigned char *)
1643: (*s_sous_objet_2).objet) + 14) *
1644: sizeof(unsigned char))) == NULL)
1645: {
1646: return;
1647: }
1648:
1649: sprintf((unsigned char *) (*s_sous_objet).objet,
1650: "%s%s\\left(%s\\right)",
1651: (unsigned char *) (*s_sous_objet_1)
1652: .objet, (*((struct_fonction *)
1653: (*(*l_element_courant).donnee).objet))
1654: .nom_fonction, (unsigned char *)
1655: (*s_sous_objet_2).objet);
1656: }
1657: else
1658: {
1659: if (((*s_sous_objet).objet = (void *)
1660: malloc((strlen((unsigned char *)
1661: (*s_sous_objet_1).objet) +
1662: strlen((*((struct_fonction *)
1663: (*(*l_element_courant).donnee).objet))
1664: .nom_fonction) +
1665: strlen((unsigned char *)
1666: (*s_sous_objet_2).objet) + 1) *
1667: sizeof(unsigned char))) == NULL)
1668: {
1669: return;
1670: }
1671:
1672: sprintf((unsigned char *) (*s_sous_objet).objet,
1673: "%s%s%s", (unsigned char *)
1674: (*s_sous_objet_1)
1675: .objet, (*((struct_fonction *)
1676: (*(*l_element_courant).donnee).objet))
1677: .nom_fonction, (unsigned char *)
1678: (*s_sous_objet_2).objet);
1679: }
1680: }
1681: else
1682: {
1683: if ((strcmp((*((struct_fonction *)
1684: (*(*l_element_courant).donnee).objet))
1685: .nom_fonction, "<") != 0) &&
1686: (strcmp((*((struct_fonction *)
1687: (*(*l_element_courant).donnee).objet))
1688: .nom_fonction, ">") != 0) &&
1689: (strcmp((*((struct_fonction *)
1690: (*(*l_element_courant).donnee).objet))
1691: .nom_fonction, "=") != 0) &&
1692: (strcmp((*((struct_fonction *)
1693: (*(*l_element_courant).donnee).objet))
1694: .nom_fonction, "==") != 0) &&
1695: (strcmp((*((struct_fonction *)
1696: (*(*l_element_courant).donnee).objet))
1697: .nom_fonction, "\\geqslant ") != 0) &&
1698: (strcmp((*((struct_fonction *)
1699: (*(*l_element_courant).donnee).objet))
1700: .nom_fonction, "\\leqslant ") != 0))
1701: {
1702: chaine_parametre = (unsigned char *)
1703: (*s_sous_objet_1).objet;
1.57 bertrand 1704: conversion_element_tex(s_etat_processus,
1705: &chaine_parametre,
1.1 bertrand 1706: (*((struct_fonction *)
1707: (*(*l_element_courant).donnee).objet))
1708: .nom_fonction);
1709:
1710: if ((*s_sous_objet_1).objet == NULL)
1711: {
1712: (*s_etat_processus).erreur_systeme =
1713: d_es_allocation_memoire;
1714: return;
1715: }
1716:
1717: chaine_parametre = (unsigned char *)
1718: (*s_sous_objet_2).objet;
1.57 bertrand 1719: conversion_element_tex(s_etat_processus,
1720: &chaine_parametre,
1.1 bertrand 1721: (*((struct_fonction *)
1722: (*(*l_element_courant).donnee).objet))
1723: .nom_fonction);
1724:
1725: if ((*s_sous_objet_2).objet == NULL)
1726: {
1727: (*s_etat_processus).erreur_systeme =
1728: d_es_allocation_memoire;
1729: return;
1730: }
1731: }
1732:
1733: if ((((unsigned char *) (*s_sous_objet_2)
1734: .objet)[0] == '+') || (((unsigned char *)
1735: (*s_sous_objet_2).objet)[0] == '-'))
1736: {
1737: if (((*s_sous_objet).objet = (void *)
1738: malloc((strlen((unsigned char *)
1739: (*s_sous_objet_1).objet) +
1740: strlen((*((struct_fonction *)
1741: (*(*l_element_courant).donnee).objet))
1742: .nom_fonction) +
1743: strlen((unsigned char *)
1744: (*s_sous_objet_2).objet) + 18) *
1745: sizeof(unsigned char))) == NULL)
1746: {
1747: return;
1748: }
1749:
1750: sprintf((unsigned char *) (*s_sous_objet).objet,
1751: "{%s}%s{\\left(%s\\right)}",
1752: (unsigned char *) (*s_sous_objet_1)
1753: .objet, (*((struct_fonction *)
1754: (*(*l_element_courant).donnee).objet))
1755: .nom_fonction, (unsigned char *)
1756: (*s_sous_objet_2).objet);
1757: }
1758: else
1759: {
1760: if (((*s_sous_objet).objet = (void *)
1761: malloc((strlen((unsigned char *)
1762: (*s_sous_objet_1).objet) +
1763: strlen((*((struct_fonction *)
1764: (*(*l_element_courant).donnee).objet))
1765: .nom_fonction) +
1766: strlen((unsigned char *)
1767: (*s_sous_objet_2).objet) + 5) *
1768: sizeof(unsigned char))) == NULL)
1769: {
1770: return;
1771: }
1772:
1773: sprintf((unsigned char *) (*s_sous_objet).objet,
1774: "{%s}%s{%s}", (unsigned char *)
1775: (*s_sous_objet_1)
1776: .objet, (*((struct_fonction *)
1777: (*(*l_element_courant).donnee).objet))
1778: .nom_fonction, (unsigned char *)
1779: (*s_sous_objet_2).objet);
1780: }
1781: }
1782:
1783: liberation(s_etat_processus, s_sous_objet_1);
1784: liberation(s_etat_processus, s_sous_objet_2);
1785:
1786: if (empilement(s_etat_processus, &((*s_etat_processus)
1787: .l_base_pile), s_sous_objet) == d_erreur)
1788: {
1789: return;
1790: }
1791: }
1792: else if (strcmp((*((struct_fonction *)
1793: (*(*l_element_courant).donnee).objet)).nom_fonction,
1794: "NOT") == 0)
1795: {
1796: if (depilement(s_etat_processus, &((*s_etat_processus)
1797: .l_base_pile), &s_sous_objet_1) == d_erreur)
1798: {
1799: return;
1800: }
1801:
1802: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1803: == NULL)
1804: {
1805: return;
1806: }
1807:
1808: if (((*s_sous_objet).objet = (unsigned char *) malloc(
1809: (strlen((unsigned char *) (*s_sous_objet_1)
1810: .objet) + 25) * sizeof(unsigned char))) ==
1811: NULL)
1812: {
1813: return;
1814: }
1815:
1816: sprintf((unsigned char *) (*s_sous_objet).objet,
1817: "\\text{%s}\\left(%s\\right)",
1818: (*((struct_fonction *)
1819: (*(*l_element_courant).donnee).objet))
1820: .nom_fonction, (unsigned char *)
1821: (*s_sous_objet_1).objet);
1822:
1823: liberation(s_etat_processus, s_sous_objet_1);
1824:
1825: if (empilement(s_etat_processus, &((*s_etat_processus)
1826: .l_base_pile), s_sous_objet) == d_erreur)
1827: {
1828: return;
1829: }
1830: }
1831: else if ((strcmp((*((struct_fonction *)
1832: (*(*l_element_courant).donnee).objet)).nom_fonction,
1833: "OR") == 0) || (strcmp((*((struct_fonction *)
1834: (*(*l_element_courant).donnee).objet)).nom_fonction,
1835: "XOR") == 0) || (strcmp((*((struct_fonction *)
1836: (*(*l_element_courant).donnee).objet)).nom_fonction,
1837: "AND") == 0))
1838: {
1839: if (depilement(s_etat_processus, &((*s_etat_processus)
1840: .l_base_pile), &s_sous_objet_2) == d_erreur)
1841: {
1842: return;
1843: }
1844:
1845: if (depilement(s_etat_processus, &((*s_etat_processus)
1846: .l_base_pile), &s_sous_objet_1) == d_erreur)
1847: {
1848: return;
1849: }
1850:
1851: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1852: == NULL)
1853: {
1854: return;
1855: }
1856:
1857: if (((*s_sous_objet).objet = (void *) malloc((strlen(
1858: (unsigned char *) (*s_sous_objet_1).objet) +
1859: strlen((*((struct_fonction *)
1860: (*(*l_element_courant).donnee).objet))
1861: .nom_fonction) + strlen((unsigned char *)
1862: (*s_sous_objet_2).objet) + 10) *
1863: sizeof(unsigned char))) == NULL)
1864: {
1865: return;
1866: }
1867:
1868: sprintf((unsigned char *) (*s_sous_objet).objet,
1869: "%s \\text{%s} %s", (unsigned char *)
1870: (*s_sous_objet_1)
1871: .objet, (*((struct_fonction *)
1872: (*(*l_element_courant).donnee).objet))
1873: .nom_fonction, (unsigned char *)
1874: (*s_sous_objet_2).objet);
1875:
1876: liberation(s_etat_processus, s_sous_objet_1);
1877: liberation(s_etat_processus, s_sous_objet_2);
1878:
1879: if (empilement(s_etat_processus, &((*s_etat_processus)
1880: .l_base_pile), s_sous_objet) == d_erreur)
1881: {
1882: return;
1883: }
1884: }
1885: else
1886: {
1887: nombre_arguments = (*((struct_fonction *)
1888: (*(*l_element_courant).donnee).objet))
1889: .nombre_arguments;
1890:
1891: if ((chaine = (unsigned char *)
1892: malloc(sizeof(unsigned char))) == NULL)
1893: {
1894: return;
1895: }
1896:
1897: chaine[0] = d_code_fin_chaine;
1898:
1899: for(i = 0; i < nombre_arguments; i++)
1900: {
1901: if ((nombre_arguments - i) > 1)
1902: {
1903: l_liste1 = (*s_etat_processus).l_base_pile;
1904:
1905: for(j = 2; j < (nombre_arguments - i); j++)
1906: {
1907: l_liste1 = (*l_liste1).suivant;
1908: }
1909:
1910: l_liste2 = (*l_liste1).suivant;
1911: (*l_liste1).suivant = (*l_liste2).suivant;
1912: (*l_liste2).suivant = (*s_etat_processus)
1913: .l_base_pile;
1914: (*s_etat_processus).l_base_pile = l_liste2;
1915: }
1916:
1917: if (depilement(s_etat_processus,
1918: &((*s_etat_processus).l_base_pile),
1919: &s_sous_objet) == d_erreur)
1920: {
1921: return;
1922: }
1923:
1924: chaine_sauvegarde = chaine;
1925:
1926: if (strlen(chaine_sauvegarde) == 0)
1927: {
1928: if ((chaine = (unsigned char *) malloc((strlen(
1929: (unsigned char *) (*s_sous_objet).objet)
1930: + 1) * sizeof(unsigned char))) == NULL)
1931: {
1932: return;
1933: }
1934:
1935: sprintf(chaine, "%s", (unsigned char *)
1936: (*s_sous_objet).objet);
1937: }
1938: else
1939: {
1940: if ((chaine = (unsigned char *) malloc((strlen(
1941: chaine_sauvegarde) + 1 + strlen(
1942: (unsigned char *) (*s_sous_objet).objet)
1943: + 1) * sizeof(unsigned char))) == NULL)
1944: {
1945: return;
1946: }
1947:
1948: sprintf(chaine, "%s,%s", chaine_sauvegarde,
1949: (unsigned char *) (*s_sous_objet)
1950: .objet);
1951: }
1952:
1953: free(chaine_sauvegarde);
1954: liberation(s_etat_processus, s_sous_objet);
1955: }
1956:
1957: chaine_sauvegarde = chaine;
1958:
1959: if ((chaine = (unsigned char *) malloc((strlen(
1960: (*((struct_fonction *) (*(*l_element_courant)
1961: .donnee).objet)).nom_fonction) + 20 +
1962: strlen(chaine_sauvegarde) + 1) *
1963: sizeof(unsigned char))) == NULL)
1964: {
1965: return;
1966: }
1967:
1968: sprintf(chaine, "\\text{%s}\\left(%s\\right)",
1969: (*((struct_fonction *)
1970: (*(*l_element_courant).donnee).objet))
1971: .nom_fonction, chaine_sauvegarde);
1972: free(chaine_sauvegarde);
1973:
1974: instruction_courante = (*s_etat_processus)
1975: .instruction_courante;
1976: test_instruction = (*s_etat_processus).test_instruction;
1977: instruction_valide = (*s_etat_processus)
1978: .instruction_valide;
1979:
1980: (*s_etat_processus).test_instruction = 'Y';
1981: (*s_etat_processus).instruction_courante =
1982: (*((struct_fonction *) (*(*l_element_courant)
1983: .donnee).objet)).nom_fonction;
1984:
1985: analyse(s_etat_processus, NULL);
1986:
1987: if ((*s_etat_processus).instruction_valide == 'Y')
1988: {
1.47 bertrand 1989: for(i = 0; i < (integer8) strlen(chaine); i++)
1.1 bertrand 1990: {
1991: if ((chaine[i] >= 'A') && (chaine[i] <= 'Z'))
1992: {
1.47 bertrand 1993: chaine[i] = (unsigned char)
1994: (chaine[i] + ('a' - 'A'));
1.1 bertrand 1995: }
1996: }
1997: }
1998:
1999: (*s_etat_processus).instruction_courante =
2000: instruction_courante;
2001: (*s_etat_processus).test_instruction =
2002: instruction_valide;
2003: (*s_etat_processus).instruction_valide =
2004: instruction_valide;
2005:
2006: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2007: == NULL)
2008: {
2009: return;
2010: }
2011:
2012: (*s_sous_objet).objet = (void *) chaine;
2013:
2014: if (empilement(s_etat_processus, &((*s_etat_processus)
2015: .l_base_pile), s_sous_objet) == d_erreur)
2016: {
2017: return;
2018: }
2019: }
2020: }
2021: }
2022: else
2023: {
2024: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2025: == NULL)
2026: {
2027: return;
2028: }
2029:
2030: if (((*s_sous_objet).objet = (void *) formateur(
2031: s_etat_processus, 0,
2032: (*l_element_courant).donnee)) == NULL)
2033: {
2034: return;
2035: }
2036:
2037: if ((*(*l_element_courant).donnee).type == NOM)
2038: {
2039: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;
2040:
2041: if (((*s_sous_objet).objet = malloc((strlen(
2042: chaine_sauvegarde) - 1) *
2043: sizeof(unsigned char))) == NULL)
2044: {
2045: return;
2046: }
2047:
2048: ptrl = chaine_sauvegarde;
2049: ptre = (unsigned char *) (*s_sous_objet).objet;
2050:
1.47 bertrand 2051: for(ptrl++, i = (integer8) (strlen(chaine_sauvegarde) - 2);
2052: i > 0; i--, *ptre++ = *ptrl++);
1.1 bertrand 2053:
2054: (*ptre) = d_code_fin_chaine;
2055:
2056: free(chaine_sauvegarde);
2057:
1.57 bertrand 2058: chaine_majuscule = conversion_majuscule(s_etat_processus,
2059: (*((struct_nom *) (*(*l_element_courant).donnee)
2060: .objet)).nom);
1.1 bertrand 2061:
2062: if (strcmp(chaine_majuscule, "PI") == 0)
2063: {
2064: free((unsigned char *) (*s_sous_objet).objet);
2065:
2066: if (((*s_sous_objet).objet =
2067: malloc(5 * sizeof(unsigned char))) == NULL)
2068: {
2069: (*s_etat_processus).erreur_systeme =
2070: d_es_allocation_memoire;
2071: return;
2072: }
2073:
2074: strcpy((unsigned char *) (*s_sous_objet).objet,
2075: "\\pi ");
2076: }
2077: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2078: .donnee).objet)).nom, "i") == 0)
2079: {
2080: free((unsigned char *) (*s_sous_objet).objet);
2081:
2082: if (((*s_sous_objet).objet =
2083: malloc(9 * sizeof(unsigned char))) == NULL)
2084: {
2085: (*s_etat_processus).erreur_systeme =
2086: d_es_allocation_memoire;
2087: return;
2088: }
2089:
2090: strcpy((unsigned char *) (*s_sous_objet).objet,
2091: "\\text{i}");
2092: }
2093: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2094: .donnee).objet)).nom, "e") == 0)
2095: {
2096: free((unsigned char *) (*s_sous_objet).objet);
2097:
2098: if (((*s_sous_objet).objet =
2099: malloc(9 * sizeof(unsigned char))) == NULL)
2100: {
2101: (*s_etat_processus).erreur_systeme =
2102: d_es_allocation_memoire;
2103: return;
2104: }
2105:
2106: strcpy((unsigned char *) (*s_sous_objet).objet,
2107: "\\text{e}");
2108: }
2109:
2110: free(chaine_majuscule);
2111: }
2112:
2113: if (empilement(s_etat_processus, &((*s_etat_processus)
2114: .l_base_pile), s_sous_objet) == d_erreur)
2115: {
2116: return;
2117: }
2118: }
2119:
2120: l_element_courant = (*l_element_courant).suivant;
2121: }
2122:
2123: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2124: &s_sous_objet) == d_erreur)
2125: {
2126: return;
2127: }
2128:
1.5 bertrand 2129: if (tex_fprintf(s_etat_processus, fichier_impression, "%s",
1.1 bertrand 2130: (unsigned char *) (*s_sous_objet).objet) < 0)
2131: {
2132: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2133: return;
2134: }
2135:
2136: liberation(s_etat_processus, s_sous_objet);
2137: liberation(s_etat_processus, s_copie_objet);
2138: }
2139:
2140: return;
2141: }
2142:
2143:
2144: /*
2145: ================================================================================
2146: Echappement des caractères spéciaux de TeX
2147: ================================================================================
2148: Entrées : ligne d'instructions TeX
2149: --------------------------------------------------------------------------------
2150: Sorties : ligne corrigée
2151: --------------------------------------------------------------------------------
2152: Effets de bord : néant
2153: ================================================================================
2154: */
2155:
2156: void
2157: correction_formateur_tex(struct_processus *s_etat_processus,
2158: unsigned char **ligne)
2159: {
2160: logical1 mode_mathematique;
2161:
2162: unsigned char *tampon;
1.47 bertrand 2163:
2164: integer8 i;
1.1 bertrand 2165:
2166: mode_mathematique = d_faux;
2167:
1.47 bertrand 2168: for(i = 0; i < (integer8) strlen((*ligne)); i++)
1.1 bertrand 2169: {
2170: switch((*ligne)[i])
2171: {
2172: /*
2173: * Le caractère '_' est autorisé tel quel dans une expression
2174: * mathématique. Il est protégé en mode normal.
2175: */
2176:
2177: case '$' :
2178: {
2179: mode_mathematique = (mode_mathematique == d_faux)
2180: ? d_vrai : d_faux;
2181:
2182: if ((*ligne)[i + 1] == '$')
2183: {
2184: i++;
2185: }
2186:
2187: break;
2188: }
2189:
2190: /*
2191: * Les '$', '{' et '}' ne sont pas convertis pour pouvoir écrire
2192: * du TeX dans le texte.
2193: */
2194:
2195: case '#' :
2196: case '_' :
2197: {
2198: if (mode_mathematique == d_vrai)
2199: {
2200: break;
2201: }
2202: }
2203:
2204: case '%' :
2205: case '&' :
2206: {
2207: if ((tampon = (unsigned char *) malloc((strlen((*ligne)) + 2) *
2208: sizeof(unsigned char))) == NULL)
2209: {
2210: (*s_etat_processus).erreur_systeme =
2211: d_es_allocation_memoire;
2212: return;
2213: }
2214:
1.47 bertrand 2215: strncpy(tampon, (*ligne), (size_t) i);
1.1 bertrand 2216: strcpy(&(tampon[i]), "\\");
2217: strcat(tampon, &((*ligne)[i++]));
2218:
2219: free((*ligne));
2220: (*ligne) = tampon;
2221:
2222: break;
2223: }
2224:
2225: default :
2226: {
2227: break;
2228: }
2229: }
2230: }
2231:
2232: return;
2233: }
2234:
2235:
2236: /*
2237: ================================================================================
2238: Fonction 'impression_tex'
2239: ================================================================================
2240: Entrées :
2241: --------------------------------------------------------------------------------
2242: Sorties :
2243: --------------------------------------------------------------------------------
2244: Effets de bord : néant
2245: ================================================================================
2246: */
2247:
2248: void
2249: impression_tex(struct_processus *s_etat_processus)
2250: {
2251: file *fichier_impression;
2252:
2253: unsigned char *commande;
1.8 bertrand 2254: unsigned char *executable_candidat;
1.1 bertrand 2255: unsigned char *nom_fichier_aux;
2256: unsigned char *nom_fichier_dvi;
2257: unsigned char *nom_fichier_log;
2258: unsigned char *nom_fichier_tex;
2259: unsigned char *nom_fichier_ps;
2260:
1.47 bertrand 2261: size_t longueur_nom_base;
1.1 bertrand 2262:
2263: longueur_nom_base = strlen((*s_etat_processus).nom_fichier_impression);
2264:
2265: if ((nom_fichier_tex = malloc((longueur_nom_base + 6) *
2266: sizeof(unsigned char))) == NULL)
2267: {
2268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2269: return;
2270: }
2271:
2272: if ((nom_fichier_log = malloc((longueur_nom_base + 6) *
2273: sizeof(unsigned char))) == NULL)
2274: {
2275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2276: return;
2277: }
2278:
2279: if ((nom_fichier_aux = malloc((longueur_nom_base + 6) *
2280: sizeof(unsigned char))) == NULL)
2281: {
2282: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2283: return;
2284: }
2285:
2286: if ((nom_fichier_dvi = malloc((longueur_nom_base + 6) *
2287: sizeof(unsigned char))) == NULL)
2288: {
2289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2290: return;
2291: }
2292:
2293: if ((nom_fichier_ps = malloc((longueur_nom_base + 5) *
2294: sizeof(unsigned char))) == NULL)
2295: {
2296: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2297: return;
2298: }
2299:
2300: strcpy(nom_fichier_tex, (*s_etat_processus).nom_fichier_impression)
2301: [longueur_nom_base - 4] = d_code_fin_chaine;
2302: strcat(nom_fichier_tex, ".conv.tex");
2303:
2304: strcpy(nom_fichier_aux, (*s_etat_processus).nom_fichier_impression)
2305: [longueur_nom_base - 4] = d_code_fin_chaine;
2306: strcat(nom_fichier_aux, ".conv.aux");
2307:
2308: strcpy(nom_fichier_log, (*s_etat_processus).nom_fichier_impression)
2309: [longueur_nom_base - 4] = d_code_fin_chaine;
2310: strcat(nom_fichier_log, ".conv.log");
2311:
2312: strcpy(nom_fichier_dvi, (*s_etat_processus).nom_fichier_impression)
2313: [longueur_nom_base - 4] = d_code_fin_chaine;
2314: strcat(nom_fichier_dvi, ".conv.dvi");
2315:
2316: strcpy(nom_fichier_ps, (*s_etat_processus).nom_fichier_impression)
2317: [longueur_nom_base - 4] = d_code_fin_chaine;
2318: strcat(nom_fichier_ps, ".conv.ps");
2319:
2320: if ((fichier_impression = fopen((*s_etat_processus).nom_fichier_impression,
2321: "a")) == NULL)
2322: {
2323: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2324: return;
2325: }
2326:
1.5 bertrand 2327: if (tex_fprintf(s_etat_processus, fichier_impression,
2328: "\\end{document}\n") < 0)
1.1 bertrand 2329: {
2330: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2331: return;
2332: }
2333:
2334: if (fclose(fichier_impression) != 0)
2335: {
2336: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2337: return;
2338: }
2339:
1.7 bertrand 2340: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 2341: {
1.57 bertrand 2342: if (alsprintf(s_etat_processus, &commande, ds_tex_commande,
1.7 bertrand 2343: d_exec_path, d_exec_path, d_exec_path,
2344: (*s_etat_processus).nom_fichier_impression,
1.18 bertrand 2345: d_exec_path, d_exec_path,
1.7 bertrand 2346: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2347: (*s_etat_processus).chemin_fichiers_temporaires,
2348: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2349: {
2350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2351: return;
2352: }
1.8 bertrand 2353:
1.57 bertrand 2354: if (alsprintf(s_etat_processus, &executable_candidat, "%s/bin/rpliconv",
1.8 bertrand 2355: d_exec_path) < 0)
2356: {
2357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2358: return;
2359: }
2360:
1.35 bertrand 2361: if (controle_integrite(s_etat_processus, executable_candidat,
2362: "rpliconv") != d_vrai)
1.8 bertrand 2363: {
2364: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2365: return;
2366: }
2367:
2368: free(executable_candidat);
2369:
1.57 bertrand 2370: if (alsprintf(s_etat_processus, &executable_candidat, "%s/bin/rplfile",
1.8 bertrand 2371: d_exec_path) < 0)
2372: {
2373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2374: return;
2375: }
2376:
1.35 bertrand 2377: if (controle_integrite(s_etat_processus, executable_candidat,
2378: "rplfile") != d_vrai)
1.8 bertrand 2379: {
2380: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2381: return;
2382: }
2383:
2384: free(executable_candidat);
1.7 bertrand 2385: }
2386: else
2387: {
1.57 bertrand 2388: if (alsprintf(s_etat_processus, &commande, ds_tex_commande,
1.7 bertrand 2389: (*s_etat_processus).rpl_home,
2390: (*s_etat_processus).rpl_home,
2391: (*s_etat_processus).rpl_home,
2392: (*s_etat_processus).nom_fichier_impression,
1.18 bertrand 2393: (*s_etat_processus).rpl_home,
2394: (*s_etat_processus).rpl_home,
1.7 bertrand 2395: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2396: (*s_etat_processus).chemin_fichiers_temporaires,
2397: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2398: {
2399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2400: return;
2401: }
1.8 bertrand 2402:
1.57 bertrand 2403: if (alsprintf(s_etat_processus, &executable_candidat, "%s/bin/rpliconv",
1.8 bertrand 2404: (*s_etat_processus).rpl_home) < 0)
2405: {
2406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2407: return;
2408: }
2409:
1.35 bertrand 2410: if (controle_integrite(s_etat_processus, executable_candidat,
2411: "rpliconv") != d_vrai)
1.8 bertrand 2412: {
2413: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2414: return;
2415: }
2416:
2417: free(executable_candidat);
2418:
1.57 bertrand 2419: if (alsprintf(s_etat_processus, &executable_candidat, "%s/bin/rplfile",
1.8 bertrand 2420: (*s_etat_processus).rpl_home) < 0)
2421: {
2422: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2423: return;
2424: }
2425:
1.35 bertrand 2426: if (controle_integrite(s_etat_processus, executable_candidat,
2427: "rplfile") != d_vrai)
1.8 bertrand 2428: {
2429: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2430: return;
2431: }
2432:
2433: free(executable_candidat);
1.1 bertrand 2434: }
2435:
2436: if (system(commande) != 0)
2437: {
2438: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2439: free(commande);
2440: }
2441: else
2442: {
2443: free(commande);
2444:
1.57 bertrand 2445: if (alsprintf(s_etat_processus, &commande, ds_tex_postscript,
2446: nom_fichier_ps) < 0)
1.1 bertrand 2447: {
2448: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2449: return;
2450: }
2451:
2452: if (system(commande) != 0)
2453: {
2454: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2455: }
2456:
2457: free(commande);
2458:
2459: if (destruction_fichier(nom_fichier_ps) == d_erreur)
2460: {
2461: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2462: return;
2463: }
2464: }
2465:
2466: if (destruction_fichier((*s_etat_processus).nom_fichier_impression)
2467: == d_erreur)
2468: {
2469: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2470: return;
2471: }
2472:
2473: free((*s_etat_processus).nom_fichier_impression);
2474: (*s_etat_processus).nom_fichier_impression = NULL;
2475:
2476: if (destruction_fichier(nom_fichier_tex) == d_erreur)
2477: {
1.3 bertrand 2478: free(nom_fichier_aux);
2479: free(nom_fichier_log);
2480: free(nom_fichier_dvi);
2481: free(nom_fichier_tex);
2482: free(nom_fichier_ps);
2483:
1.1 bertrand 2484: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2485: return;
2486: }
2487:
2488: if (destruction_fichier(nom_fichier_aux) == d_erreur)
2489: {
1.3 bertrand 2490: free(nom_fichier_aux);
2491: free(nom_fichier_log);
2492: free(nom_fichier_dvi);
2493: free(nom_fichier_tex);
2494: free(nom_fichier_ps);
2495:
1.1 bertrand 2496: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2497: return;
2498: }
2499:
2500: if (destruction_fichier(nom_fichier_dvi) == d_erreur)
2501: {
1.3 bertrand 2502: free(nom_fichier_aux);
2503: free(nom_fichier_log);
2504: free(nom_fichier_dvi);
2505: free(nom_fichier_tex);
2506: free(nom_fichier_ps);
2507:
1.1 bertrand 2508: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2509: return;
2510: }
2511:
2512: if (destruction_fichier(nom_fichier_log) == d_erreur)
2513: {
1.3 bertrand 2514: free(nom_fichier_aux);
2515: free(nom_fichier_log);
2516: free(nom_fichier_dvi);
2517: free(nom_fichier_tex);
2518: free(nom_fichier_ps);
2519:
1.1 bertrand 2520: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2521: return;
2522: }
2523:
2524: free(nom_fichier_aux);
2525: free(nom_fichier_log);
2526: free(nom_fichier_dvi);
2527: free(nom_fichier_tex);
2528: free(nom_fichier_ps);
2529:
2530: return;
2531: }
2532:
2533:
2534: /*
2535: ================================================================================
2536: Conversion des éléments TeX par ajout si nécessaire de parenthèses
2537: ================================================================================
2538: Entrées :
2539: --------------------------------------------------------------------------------
2540: Sorties :
2541: --------------------------------------------------------------------------------
2542: Effets de bord : néant
2543: ================================================================================
2544: */
2545:
2546: void
1.57 bertrand 2547: conversion_element_tex(struct_processus *s_etat_processus,
2548: unsigned char **element, unsigned char *fonction)
1.1 bertrand 2549: {
2550: unsigned char *chaine;
2551: unsigned char *element_courant;
2552: unsigned char *extrait;
2553:
1.47 bertrand 2554: integer8 debut_fonction;
2555: integer8 i;
2556: integer8 niveau;
2557: integer8 nombre_passages_par_zero;
1.1 bertrand 2558:
2559: element_courant = (*element);
2560: niveau = 0;
2561: nombre_passages_par_zero = 0;
2562: i = 1;
2563: debut_fonction = 1;
2564:
2565: while((*element_courant) != d_code_fin_chaine)
2566: {
2567: if ((*element_courant) == '{')
2568: {
2569: if (niveau == 0)
2570: {
1.57 bertrand 2571: extrait = extraction_chaine(s_etat_processus,
2572: (*element), debut_fonction, i - 1);
1.1 bertrand 2573:
2574: if (strcmp(extrait, fonction) != 0)
2575: {
2576: nombre_passages_par_zero++;
2577: }
2578:
2579: free(extrait);
2580: }
2581:
2582: niveau++;
2583: }
2584: else if ((*element_courant) == '}')
2585: {
2586: debut_fonction = i + 1;
2587: niveau--;
2588: }
2589:
2590: element_courant++;
2591: i++;
2592: }
2593:
2594: if (nombre_passages_par_zero > 1)
2595: {
2596: chaine = (*element);
2597:
2598: if (((*element) = (unsigned char *) malloc((strlen(chaine) + 14) *
2599: sizeof(unsigned char))) == NULL)
2600: {
2601: return;
2602: }
2603:
2604: sprintf((*element), "\\left(%s\\right)", chaine);
2605: free(chaine);
2606: }
2607:
2608: return;
2609: }
2610:
2611: // vim: ts=4