![[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.38 ! bertrand 3: RPL/2 (R) version 4.1.7
1.36 bertrand 4: Copyright (C) 1989-2012 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:
500: unsigned long i;
501: unsigned long j;
502: unsigned long niveau;
503: unsigned long nombre_arguments;
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: {
585: if ((instruction_majuscule = conversion_majuscule(
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:
980: for(i = 0; i < strlen(ligne); i++)
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:
995: strncpy(tampon, ligne, i);
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:
1017: strncpy(tampon, ligne, ++i);
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:
1542: for(i = 1; i < (strlen((unsigned char *)
1543: (*s_sous_objet_1).objet) - 1); i++)
1544: {
1545: if (((unsigned char *) (*s_sous_objet_1)
1546: .objet)[i] == '{')
1547: {
1548: niveau++;
1549: }
1550: else if (((unsigned char *)
1551: (*s_sous_objet_1).objet)[i] == '}')
1552: {
1553: niveau--;
1554:
1555: if (niveau == 0)
1556: {
1557: break;
1558: }
1559: }
1560: }
1561:
1562: if (niveau == 0)
1563: {
1564: sprintf((unsigned char *) (*s_sous_objet_1)
1565: .objet, "%s", &(((unsigned char *)
1566: (*s_sous_objet_1).objet)[1]));
1567: ((unsigned char *) (*s_sous_objet_1).objet)
1568: [strlen((unsigned char *)
1569: (*s_sous_objet_1).objet) - 1] =
1570: d_code_fin_chaine;
1571: }
1572: }
1573:
1574: chaine_parametre = (unsigned char *)
1575: (*s_sous_objet_1).objet;
1576: conversion_element_tex(&chaine_parametre, "^");
1577:
1578: if ((*s_sous_objet_1).objet == NULL)
1579: {
1580: (*s_etat_processus).erreur_systeme =
1581: d_es_allocation_memoire;
1582: return;
1583: }
1584:
1585: if (((*s_sous_objet).objet = (void *)
1586: malloc((strlen(
1587: (unsigned char *) (*s_sous_objet_1).objet) +
1588: strlen((unsigned char *)
1589: (*s_sous_objet_2).objet) + 8) *
1590: sizeof(unsigned char))) == NULL)
1591: {
1592: return;
1593: }
1594:
1595: sprintf((unsigned char *) (*s_sous_objet).objet,
1596: "{{%s}^{%s}}",
1597: (unsigned char *) (*s_sous_objet_1).objet,
1598: (unsigned char *) (*s_sous_objet_2).objet);
1599: }
1600: else if (multiplication == d_vrai)
1601: {
1602: chaine_parametre = (unsigned char *)
1603: (*s_sous_objet_1).objet;
1604: conversion_element_tex(&chaine_parametre,
1605: (*((struct_fonction *)
1606: (*(*l_element_courant).donnee).objet))
1607: .nom_fonction);
1608:
1609: if ((*s_sous_objet_1).objet == NULL)
1610: {
1611: (*s_etat_processus).erreur_systeme =
1612: d_es_allocation_memoire;
1613: return;
1614: }
1615:
1616: chaine_parametre = (unsigned char *)
1617: (*s_sous_objet_2).objet;
1618: conversion_element_tex(&chaine_parametre,
1619: (*((struct_fonction *)
1620: (*(*l_element_courant).donnee).objet))
1621: .nom_fonction);
1622:
1623: if ((*s_sous_objet_2).objet == NULL)
1624: {
1625: (*s_etat_processus).erreur_systeme =
1626: d_es_allocation_memoire;
1627: return;
1628: }
1629:
1630: if ((((unsigned char *) (*s_sous_objet_2)
1631: .objet)[0] == '+') || (((unsigned char *)
1632: (*s_sous_objet_2).objet)[0] == '-'))
1633: {
1634: if (((*s_sous_objet).objet = (void *)
1635: malloc((strlen((unsigned char *)
1636: (*s_sous_objet_1).objet) +
1637: strlen((*((struct_fonction *)
1638: (*(*l_element_courant).donnee).objet))
1639: .nom_fonction) +
1640: strlen((unsigned char *)
1641: (*s_sous_objet_2).objet) + 14) *
1642: sizeof(unsigned char))) == NULL)
1643: {
1644: return;
1645: }
1646:
1647: sprintf((unsigned char *) (*s_sous_objet).objet,
1648: "%s%s\\left(%s\\right)",
1649: (unsigned char *) (*s_sous_objet_1)
1650: .objet, (*((struct_fonction *)
1651: (*(*l_element_courant).donnee).objet))
1652: .nom_fonction, (unsigned char *)
1653: (*s_sous_objet_2).objet);
1654: }
1655: else
1656: {
1657: if (((*s_sous_objet).objet = (void *)
1658: malloc((strlen((unsigned char *)
1659: (*s_sous_objet_1).objet) +
1660: strlen((*((struct_fonction *)
1661: (*(*l_element_courant).donnee).objet))
1662: .nom_fonction) +
1663: strlen((unsigned char *)
1664: (*s_sous_objet_2).objet) + 1) *
1665: sizeof(unsigned char))) == NULL)
1666: {
1667: return;
1668: }
1669:
1670: sprintf((unsigned char *) (*s_sous_objet).objet,
1671: "%s%s%s", (unsigned char *)
1672: (*s_sous_objet_1)
1673: .objet, (*((struct_fonction *)
1674: (*(*l_element_courant).donnee).objet))
1675: .nom_fonction, (unsigned char *)
1676: (*s_sous_objet_2).objet);
1677: }
1678: }
1679: else
1680: {
1681: if ((strcmp((*((struct_fonction *)
1682: (*(*l_element_courant).donnee).objet))
1683: .nom_fonction, "<") != 0) &&
1684: (strcmp((*((struct_fonction *)
1685: (*(*l_element_courant).donnee).objet))
1686: .nom_fonction, ">") != 0) &&
1687: (strcmp((*((struct_fonction *)
1688: (*(*l_element_courant).donnee).objet))
1689: .nom_fonction, "=") != 0) &&
1690: (strcmp((*((struct_fonction *)
1691: (*(*l_element_courant).donnee).objet))
1692: .nom_fonction, "==") != 0) &&
1693: (strcmp((*((struct_fonction *)
1694: (*(*l_element_courant).donnee).objet))
1695: .nom_fonction, "\\geqslant ") != 0) &&
1696: (strcmp((*((struct_fonction *)
1697: (*(*l_element_courant).donnee).objet))
1698: .nom_fonction, "\\leqslant ") != 0))
1699: {
1700: chaine_parametre = (unsigned char *)
1701: (*s_sous_objet_1).objet;
1702: conversion_element_tex(&chaine_parametre,
1703: (*((struct_fonction *)
1704: (*(*l_element_courant).donnee).objet))
1705: .nom_fonction);
1706:
1707: if ((*s_sous_objet_1).objet == NULL)
1708: {
1709: (*s_etat_processus).erreur_systeme =
1710: d_es_allocation_memoire;
1711: return;
1712: }
1713:
1714: chaine_parametre = (unsigned char *)
1715: (*s_sous_objet_2).objet;
1716: conversion_element_tex(&chaine_parametre,
1717: (*((struct_fonction *)
1718: (*(*l_element_courant).donnee).objet))
1719: .nom_fonction);
1720:
1721: if ((*s_sous_objet_2).objet == NULL)
1722: {
1723: (*s_etat_processus).erreur_systeme =
1724: d_es_allocation_memoire;
1725: return;
1726: }
1727: }
1728:
1729: if ((((unsigned char *) (*s_sous_objet_2)
1730: .objet)[0] == '+') || (((unsigned char *)
1731: (*s_sous_objet_2).objet)[0] == '-'))
1732: {
1733: if (((*s_sous_objet).objet = (void *)
1734: malloc((strlen((unsigned char *)
1735: (*s_sous_objet_1).objet) +
1736: strlen((*((struct_fonction *)
1737: (*(*l_element_courant).donnee).objet))
1738: .nom_fonction) +
1739: strlen((unsigned char *)
1740: (*s_sous_objet_2).objet) + 18) *
1741: sizeof(unsigned char))) == NULL)
1742: {
1743: return;
1744: }
1745:
1746: sprintf((unsigned char *) (*s_sous_objet).objet,
1747: "{%s}%s{\\left(%s\\right)}",
1748: (unsigned char *) (*s_sous_objet_1)
1749: .objet, (*((struct_fonction *)
1750: (*(*l_element_courant).donnee).objet))
1751: .nom_fonction, (unsigned char *)
1752: (*s_sous_objet_2).objet);
1753: }
1754: else
1755: {
1756: if (((*s_sous_objet).objet = (void *)
1757: malloc((strlen((unsigned char *)
1758: (*s_sous_objet_1).objet) +
1759: strlen((*((struct_fonction *)
1760: (*(*l_element_courant).donnee).objet))
1761: .nom_fonction) +
1762: strlen((unsigned char *)
1763: (*s_sous_objet_2).objet) + 5) *
1764: sizeof(unsigned char))) == NULL)
1765: {
1766: return;
1767: }
1768:
1769: sprintf((unsigned char *) (*s_sous_objet).objet,
1770: "{%s}%s{%s}", (unsigned char *)
1771: (*s_sous_objet_1)
1772: .objet, (*((struct_fonction *)
1773: (*(*l_element_courant).donnee).objet))
1774: .nom_fonction, (unsigned char *)
1775: (*s_sous_objet_2).objet);
1776: }
1777: }
1778:
1779: liberation(s_etat_processus, s_sous_objet_1);
1780: liberation(s_etat_processus, s_sous_objet_2);
1781:
1782: if (empilement(s_etat_processus, &((*s_etat_processus)
1783: .l_base_pile), s_sous_objet) == d_erreur)
1784: {
1785: return;
1786: }
1787: }
1788: else if (strcmp((*((struct_fonction *)
1789: (*(*l_element_courant).donnee).objet)).nom_fonction,
1790: "NOT") == 0)
1791: {
1792: if (depilement(s_etat_processus, &((*s_etat_processus)
1793: .l_base_pile), &s_sous_objet_1) == d_erreur)
1794: {
1795: return;
1796: }
1797:
1798: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1799: == NULL)
1800: {
1801: return;
1802: }
1803:
1804: if (((*s_sous_objet).objet = (unsigned char *) malloc(
1805: (strlen((unsigned char *) (*s_sous_objet_1)
1806: .objet) + 25) * sizeof(unsigned char))) ==
1807: NULL)
1808: {
1809: return;
1810: }
1811:
1812: sprintf((unsigned char *) (*s_sous_objet).objet,
1813: "\\text{%s}\\left(%s\\right)",
1814: (*((struct_fonction *)
1815: (*(*l_element_courant).donnee).objet))
1816: .nom_fonction, (unsigned char *)
1817: (*s_sous_objet_1).objet);
1818:
1819: liberation(s_etat_processus, s_sous_objet_1);
1820:
1821: if (empilement(s_etat_processus, &((*s_etat_processus)
1822: .l_base_pile), s_sous_objet) == d_erreur)
1823: {
1824: return;
1825: }
1826: }
1827: else if ((strcmp((*((struct_fonction *)
1828: (*(*l_element_courant).donnee).objet)).nom_fonction,
1829: "OR") == 0) || (strcmp((*((struct_fonction *)
1830: (*(*l_element_courant).donnee).objet)).nom_fonction,
1831: "XOR") == 0) || (strcmp((*((struct_fonction *)
1832: (*(*l_element_courant).donnee).objet)).nom_fonction,
1833: "AND") == 0))
1834: {
1835: if (depilement(s_etat_processus, &((*s_etat_processus)
1836: .l_base_pile), &s_sous_objet_2) == d_erreur)
1837: {
1838: return;
1839: }
1840:
1841: if (depilement(s_etat_processus, &((*s_etat_processus)
1842: .l_base_pile), &s_sous_objet_1) == d_erreur)
1843: {
1844: return;
1845: }
1846:
1847: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1848: == NULL)
1849: {
1850: return;
1851: }
1852:
1853: if (((*s_sous_objet).objet = (void *) malloc((strlen(
1854: (unsigned char *) (*s_sous_objet_1).objet) +
1855: strlen((*((struct_fonction *)
1856: (*(*l_element_courant).donnee).objet))
1857: .nom_fonction) + strlen((unsigned char *)
1858: (*s_sous_objet_2).objet) + 10) *
1859: sizeof(unsigned char))) == NULL)
1860: {
1861: return;
1862: }
1863:
1864: sprintf((unsigned char *) (*s_sous_objet).objet,
1865: "%s \\text{%s} %s", (unsigned char *)
1866: (*s_sous_objet_1)
1867: .objet, (*((struct_fonction *)
1868: (*(*l_element_courant).donnee).objet))
1869: .nom_fonction, (unsigned char *)
1870: (*s_sous_objet_2).objet);
1871:
1872: liberation(s_etat_processus, s_sous_objet_1);
1873: liberation(s_etat_processus, s_sous_objet_2);
1874:
1875: if (empilement(s_etat_processus, &((*s_etat_processus)
1876: .l_base_pile), s_sous_objet) == d_erreur)
1877: {
1878: return;
1879: }
1880: }
1881: else
1882: {
1883: nombre_arguments = (*((struct_fonction *)
1884: (*(*l_element_courant).donnee).objet))
1885: .nombre_arguments;
1886:
1887: if ((chaine = (unsigned char *)
1888: malloc(sizeof(unsigned char))) == NULL)
1889: {
1890: return;
1891: }
1892:
1893: chaine[0] = d_code_fin_chaine;
1894:
1895: for(i = 0; i < nombre_arguments; i++)
1896: {
1897: if ((nombre_arguments - i) > 1)
1898: {
1899: l_liste1 = (*s_etat_processus).l_base_pile;
1900:
1901: for(j = 2; j < (nombre_arguments - i); j++)
1902: {
1903: l_liste1 = (*l_liste1).suivant;
1904: }
1905:
1906: l_liste2 = (*l_liste1).suivant;
1907: (*l_liste1).suivant = (*l_liste2).suivant;
1908: (*l_liste2).suivant = (*s_etat_processus)
1909: .l_base_pile;
1910: (*s_etat_processus).l_base_pile = l_liste2;
1911: }
1912:
1913: if (depilement(s_etat_processus,
1914: &((*s_etat_processus).l_base_pile),
1915: &s_sous_objet) == d_erreur)
1916: {
1917: return;
1918: }
1919:
1920: chaine_sauvegarde = chaine;
1921:
1922: if (strlen(chaine_sauvegarde) == 0)
1923: {
1924: if ((chaine = (unsigned char *) malloc((strlen(
1925: (unsigned char *) (*s_sous_objet).objet)
1926: + 1) * sizeof(unsigned char))) == NULL)
1927: {
1928: return;
1929: }
1930:
1931: sprintf(chaine, "%s", (unsigned char *)
1932: (*s_sous_objet).objet);
1933: }
1934: else
1935: {
1936: if ((chaine = (unsigned char *) malloc((strlen(
1937: chaine_sauvegarde) + 1 + strlen(
1938: (unsigned char *) (*s_sous_objet).objet)
1939: + 1) * sizeof(unsigned char))) == NULL)
1940: {
1941: return;
1942: }
1943:
1944: sprintf(chaine, "%s,%s", chaine_sauvegarde,
1945: (unsigned char *) (*s_sous_objet)
1946: .objet);
1947: }
1948:
1949: free(chaine_sauvegarde);
1950: liberation(s_etat_processus, s_sous_objet);
1951: }
1952:
1953: chaine_sauvegarde = chaine;
1954:
1955: if ((chaine = (unsigned char *) malloc((strlen(
1956: (*((struct_fonction *) (*(*l_element_courant)
1957: .donnee).objet)).nom_fonction) + 20 +
1958: strlen(chaine_sauvegarde) + 1) *
1959: sizeof(unsigned char))) == NULL)
1960: {
1961: return;
1962: }
1963:
1964: sprintf(chaine, "\\text{%s}\\left(%s\\right)",
1965: (*((struct_fonction *)
1966: (*(*l_element_courant).donnee).objet))
1967: .nom_fonction, chaine_sauvegarde);
1968: free(chaine_sauvegarde);
1969:
1970: instruction_courante = (*s_etat_processus)
1971: .instruction_courante;
1972: test_instruction = (*s_etat_processus).test_instruction;
1973: instruction_valide = (*s_etat_processus)
1974: .instruction_valide;
1975:
1976: (*s_etat_processus).test_instruction = 'Y';
1977: (*s_etat_processus).instruction_courante =
1978: (*((struct_fonction *) (*(*l_element_courant)
1979: .donnee).objet)).nom_fonction;
1980:
1981: analyse(s_etat_processus, NULL);
1982:
1983: if ((*s_etat_processus).instruction_valide == 'Y')
1984: {
1985: for(i = 0; i < strlen(chaine); i++)
1986: {
1987: if ((chaine[i] >= 'A') && (chaine[i] <= 'Z'))
1988: {
1989: chaine[i] += ('a' - 'A');
1990: }
1991: }
1992: }
1993:
1994: (*s_etat_processus).instruction_courante =
1995: instruction_courante;
1996: (*s_etat_processus).test_instruction =
1997: instruction_valide;
1998: (*s_etat_processus).instruction_valide =
1999: instruction_valide;
2000:
2001: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2002: == NULL)
2003: {
2004: return;
2005: }
2006:
2007: (*s_sous_objet).objet = (void *) chaine;
2008:
2009: if (empilement(s_etat_processus, &((*s_etat_processus)
2010: .l_base_pile), s_sous_objet) == d_erreur)
2011: {
2012: return;
2013: }
2014: }
2015: }
2016: }
2017: else
2018: {
2019: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2020: == NULL)
2021: {
2022: return;
2023: }
2024:
2025: if (((*s_sous_objet).objet = (void *) formateur(
2026: s_etat_processus, 0,
2027: (*l_element_courant).donnee)) == NULL)
2028: {
2029: return;
2030: }
2031:
2032: if ((*(*l_element_courant).donnee).type == NOM)
2033: {
2034: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;
2035:
2036: if (((*s_sous_objet).objet = malloc((strlen(
2037: chaine_sauvegarde) - 1) *
2038: sizeof(unsigned char))) == NULL)
2039: {
2040: return;
2041: }
2042:
2043: ptrl = chaine_sauvegarde;
2044: ptre = (unsigned char *) (*s_sous_objet).objet;
2045:
2046: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
2047: i--, *ptre++ = *ptrl++);
2048:
2049: (*ptre) = d_code_fin_chaine;
2050:
2051: free(chaine_sauvegarde);
2052:
2053: chaine_majuscule = conversion_majuscule((*((struct_nom *)
2054: (*(*l_element_courant).donnee).objet)).nom);
2055:
2056: if (strcmp(chaine_majuscule, "PI") == 0)
2057: {
2058: free((unsigned char *) (*s_sous_objet).objet);
2059:
2060: if (((*s_sous_objet).objet =
2061: malloc(5 * sizeof(unsigned char))) == NULL)
2062: {
2063: (*s_etat_processus).erreur_systeme =
2064: d_es_allocation_memoire;
2065: return;
2066: }
2067:
2068: strcpy((unsigned char *) (*s_sous_objet).objet,
2069: "\\pi ");
2070: }
2071: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2072: .donnee).objet)).nom, "i") == 0)
2073: {
2074: free((unsigned char *) (*s_sous_objet).objet);
2075:
2076: if (((*s_sous_objet).objet =
2077: malloc(9 * sizeof(unsigned char))) == NULL)
2078: {
2079: (*s_etat_processus).erreur_systeme =
2080: d_es_allocation_memoire;
2081: return;
2082: }
2083:
2084: strcpy((unsigned char *) (*s_sous_objet).objet,
2085: "\\text{i}");
2086: }
2087: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2088: .donnee).objet)).nom, "e") == 0)
2089: {
2090: free((unsigned char *) (*s_sous_objet).objet);
2091:
2092: if (((*s_sous_objet).objet =
2093: malloc(9 * sizeof(unsigned char))) == NULL)
2094: {
2095: (*s_etat_processus).erreur_systeme =
2096: d_es_allocation_memoire;
2097: return;
2098: }
2099:
2100: strcpy((unsigned char *) (*s_sous_objet).objet,
2101: "\\text{e}");
2102: }
2103:
2104: free(chaine_majuscule);
2105: }
2106:
2107: if (empilement(s_etat_processus, &((*s_etat_processus)
2108: .l_base_pile), s_sous_objet) == d_erreur)
2109: {
2110: return;
2111: }
2112: }
2113:
2114: l_element_courant = (*l_element_courant).suivant;
2115: }
2116:
2117: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2118: &s_sous_objet) == d_erreur)
2119: {
2120: return;
2121: }
2122:
1.5 bertrand 2123: if (tex_fprintf(s_etat_processus, fichier_impression, "%s",
1.1 bertrand 2124: (unsigned char *) (*s_sous_objet).objet) < 0)
2125: {
2126: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2127: return;
2128: }
2129:
2130: liberation(s_etat_processus, s_sous_objet);
2131: liberation(s_etat_processus, s_copie_objet);
2132: }
2133:
2134: return;
2135: }
2136:
2137:
2138: /*
2139: ================================================================================
2140: Echappement des caractères spéciaux de TeX
2141: ================================================================================
2142: Entrées : ligne d'instructions TeX
2143: --------------------------------------------------------------------------------
2144: Sorties : ligne corrigée
2145: --------------------------------------------------------------------------------
2146: Effets de bord : néant
2147: ================================================================================
2148: */
2149:
2150: void
2151: correction_formateur_tex(struct_processus *s_etat_processus,
2152: unsigned char **ligne)
2153: {
2154: logical1 mode_mathematique;
2155:
2156: unsigned char *tampon;
2157: unsigned long i;
2158:
2159: mode_mathematique = d_faux;
2160:
2161: for(i = 0; i < strlen((*ligne)); i++)
2162: {
2163: switch((*ligne)[i])
2164: {
2165: /*
2166: * Le caractère '_' est autorisé tel quel dans une expression
2167: * mathématique. Il est protégé en mode normal.
2168: */
2169:
2170: case '$' :
2171: {
2172: mode_mathematique = (mode_mathematique == d_faux)
2173: ? d_vrai : d_faux;
2174:
2175: if ((*ligne)[i + 1] == '$')
2176: {
2177: i++;
2178: }
2179:
2180: break;
2181: }
2182:
2183: /*
2184: * Les '$', '{' et '}' ne sont pas convertis pour pouvoir écrire
2185: * du TeX dans le texte.
2186: */
2187:
2188: case '#' :
2189: case '_' :
2190: {
2191: if (mode_mathematique == d_vrai)
2192: {
2193: break;
2194: }
2195: }
2196:
2197: case '%' :
2198: case '&' :
2199: {
2200: if ((tampon = (unsigned char *) malloc((strlen((*ligne)) + 2) *
2201: sizeof(unsigned char))) == NULL)
2202: {
2203: (*s_etat_processus).erreur_systeme =
2204: d_es_allocation_memoire;
2205: return;
2206: }
2207:
2208: strncpy(tampon, (*ligne), i);
2209: strcpy(&(tampon[i]), "\\");
2210: strcat(tampon, &((*ligne)[i++]));
2211:
2212: free((*ligne));
2213: (*ligne) = tampon;
2214:
2215: break;
2216: }
2217:
2218: default :
2219: {
2220: break;
2221: }
2222: }
2223: }
2224:
2225: return;
2226: }
2227:
2228:
2229: /*
2230: ================================================================================
2231: Fonction 'impression_tex'
2232: ================================================================================
2233: Entrées :
2234: --------------------------------------------------------------------------------
2235: Sorties :
2236: --------------------------------------------------------------------------------
2237: Effets de bord : néant
2238: ================================================================================
2239: */
2240:
2241: void
2242: impression_tex(struct_processus *s_etat_processus)
2243: {
2244: file *fichier_impression;
2245:
2246: unsigned char *commande;
1.8 bertrand 2247: unsigned char *executable_candidat;
1.1 bertrand 2248: unsigned char *nom_fichier_aux;
2249: unsigned char *nom_fichier_dvi;
2250: unsigned char *nom_fichier_log;
2251: unsigned char *nom_fichier_tex;
2252: unsigned char *nom_fichier_ps;
2253:
2254: unsigned long longueur_nom_base;
2255:
2256: longueur_nom_base = strlen((*s_etat_processus).nom_fichier_impression);
2257:
2258: if ((nom_fichier_tex = malloc((longueur_nom_base + 6) *
2259: sizeof(unsigned char))) == NULL)
2260: {
2261: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2262: return;
2263: }
2264:
2265: if ((nom_fichier_log = 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_aux = 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_dvi = 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_ps = malloc((longueur_nom_base + 5) *
2287: sizeof(unsigned char))) == NULL)
2288: {
2289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2290: return;
2291: }
2292:
2293: strcpy(nom_fichier_tex, (*s_etat_processus).nom_fichier_impression)
2294: [longueur_nom_base - 4] = d_code_fin_chaine;
2295: strcat(nom_fichier_tex, ".conv.tex");
2296:
2297: strcpy(nom_fichier_aux, (*s_etat_processus).nom_fichier_impression)
2298: [longueur_nom_base - 4] = d_code_fin_chaine;
2299: strcat(nom_fichier_aux, ".conv.aux");
2300:
2301: strcpy(nom_fichier_log, (*s_etat_processus).nom_fichier_impression)
2302: [longueur_nom_base - 4] = d_code_fin_chaine;
2303: strcat(nom_fichier_log, ".conv.log");
2304:
2305: strcpy(nom_fichier_dvi, (*s_etat_processus).nom_fichier_impression)
2306: [longueur_nom_base - 4] = d_code_fin_chaine;
2307: strcat(nom_fichier_dvi, ".conv.dvi");
2308:
2309: strcpy(nom_fichier_ps, (*s_etat_processus).nom_fichier_impression)
2310: [longueur_nom_base - 4] = d_code_fin_chaine;
2311: strcat(nom_fichier_ps, ".conv.ps");
2312:
2313: if ((fichier_impression = fopen((*s_etat_processus).nom_fichier_impression,
2314: "a")) == NULL)
2315: {
2316: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2317: return;
2318: }
2319:
1.5 bertrand 2320: if (tex_fprintf(s_etat_processus, fichier_impression,
2321: "\\end{document}\n") < 0)
1.1 bertrand 2322: {
2323: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2324: return;
2325: }
2326:
2327: if (fclose(fichier_impression) != 0)
2328: {
2329: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2330: return;
2331: }
2332:
1.7 bertrand 2333: if ((*s_etat_processus).rpl_home == NULL)
1.1 bertrand 2334: {
1.7 bertrand 2335: if (alsprintf(&commande, ds_tex_commande,
2336: d_exec_path, d_exec_path, d_exec_path,
2337: (*s_etat_processus).nom_fichier_impression,
1.18 bertrand 2338: d_exec_path, d_exec_path,
1.7 bertrand 2339: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2340: (*s_etat_processus).chemin_fichiers_temporaires,
2341: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2342: {
2343: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2344: return;
2345: }
1.8 bertrand 2346:
2347: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
2348: d_exec_path) < 0)
2349: {
2350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2351: return;
2352: }
2353:
1.35 bertrand 2354: if (controle_integrite(s_etat_processus, executable_candidat,
2355: "rpliconv") != d_vrai)
1.8 bertrand 2356: {
2357: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2358: return;
2359: }
2360:
2361: free(executable_candidat);
2362:
2363: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
2364: d_exec_path) < 0)
2365: {
2366: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2367: return;
2368: }
2369:
1.35 bertrand 2370: if (controle_integrite(s_etat_processus, executable_candidat,
2371: "rplfile") != d_vrai)
1.8 bertrand 2372: {
2373: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2374: return;
2375: }
2376:
2377: free(executable_candidat);
1.7 bertrand 2378: }
2379: else
2380: {
2381: if (alsprintf(&commande, ds_tex_commande,
2382: (*s_etat_processus).rpl_home,
2383: (*s_etat_processus).rpl_home,
2384: (*s_etat_processus).rpl_home,
2385: (*s_etat_processus).nom_fichier_impression,
1.18 bertrand 2386: (*s_etat_processus).rpl_home,
2387: (*s_etat_processus).rpl_home,
1.7 bertrand 2388: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2389: (*s_etat_processus).chemin_fichiers_temporaires,
2390: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2391: {
2392: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2393: return;
2394: }
1.8 bertrand 2395:
2396: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
2397: (*s_etat_processus).rpl_home) < 0)
2398: {
2399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2400: return;
2401: }
2402:
1.35 bertrand 2403: if (controle_integrite(s_etat_processus, executable_candidat,
2404: "rpliconv") != d_vrai)
1.8 bertrand 2405: {
2406: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2407: return;
2408: }
2409:
2410: free(executable_candidat);
2411:
2412: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
2413: (*s_etat_processus).rpl_home) < 0)
2414: {
2415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2416: return;
2417: }
2418:
1.35 bertrand 2419: if (controle_integrite(s_etat_processus, executable_candidat,
2420: "rplfile") != d_vrai)
1.8 bertrand 2421: {
2422: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2423: return;
2424: }
2425:
2426: free(executable_candidat);
1.1 bertrand 2427: }
2428:
2429: if (system(commande) != 0)
2430: {
2431: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2432: free(commande);
2433: }
2434: else
2435: {
2436: free(commande);
2437:
1.3 bertrand 2438: if (alsprintf(&commande, ds_tex_postscript, nom_fichier_ps) < 0)
1.1 bertrand 2439: {
2440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2441: return;
2442: }
2443:
2444: if (system(commande) != 0)
2445: {
2446: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2447: }
2448:
2449: free(commande);
2450:
2451: if (destruction_fichier(nom_fichier_ps) == d_erreur)
2452: {
2453: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2454: return;
2455: }
2456: }
2457:
2458: if (destruction_fichier((*s_etat_processus).nom_fichier_impression)
2459: == d_erreur)
2460: {
2461: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2462: return;
2463: }
2464:
2465: free((*s_etat_processus).nom_fichier_impression);
2466: (*s_etat_processus).nom_fichier_impression = NULL;
2467:
2468: if (destruction_fichier(nom_fichier_tex) == d_erreur)
2469: {
1.3 bertrand 2470: free(nom_fichier_aux);
2471: free(nom_fichier_log);
2472: free(nom_fichier_dvi);
2473: free(nom_fichier_tex);
2474: free(nom_fichier_ps);
2475:
1.1 bertrand 2476: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2477: return;
2478: }
2479:
2480: if (destruction_fichier(nom_fichier_aux) == d_erreur)
2481: {
1.3 bertrand 2482: free(nom_fichier_aux);
2483: free(nom_fichier_log);
2484: free(nom_fichier_dvi);
2485: free(nom_fichier_tex);
2486: free(nom_fichier_ps);
2487:
1.1 bertrand 2488: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2489: return;
2490: }
2491:
2492: if (destruction_fichier(nom_fichier_dvi) == d_erreur)
2493: {
1.3 bertrand 2494: free(nom_fichier_aux);
2495: free(nom_fichier_log);
2496: free(nom_fichier_dvi);
2497: free(nom_fichier_tex);
2498: free(nom_fichier_ps);
2499:
1.1 bertrand 2500: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2501: return;
2502: }
2503:
2504: if (destruction_fichier(nom_fichier_log) == d_erreur)
2505: {
1.3 bertrand 2506: free(nom_fichier_aux);
2507: free(nom_fichier_log);
2508: free(nom_fichier_dvi);
2509: free(nom_fichier_tex);
2510: free(nom_fichier_ps);
2511:
1.1 bertrand 2512: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2513: return;
2514: }
2515:
2516: free(nom_fichier_aux);
2517: free(nom_fichier_log);
2518: free(nom_fichier_dvi);
2519: free(nom_fichier_tex);
2520: free(nom_fichier_ps);
2521:
2522: return;
2523: }
2524:
2525:
2526: /*
2527: ================================================================================
2528: Conversion des éléments TeX par ajout si nécessaire de parenthèses
2529: ================================================================================
2530: Entrées :
2531: --------------------------------------------------------------------------------
2532: Sorties :
2533: --------------------------------------------------------------------------------
2534: Effets de bord : néant
2535: ================================================================================
2536: */
2537:
2538: void
2539: conversion_element_tex(unsigned char **element, unsigned char *fonction)
2540: {
2541: unsigned char *chaine;
2542: unsigned char *element_courant;
2543: unsigned char *extrait;
2544:
2545: unsigned long debut_fonction;
2546: unsigned long i;
2547: unsigned long niveau;
2548: unsigned long nombre_passages_par_zero;
2549:
2550: element_courant = (*element);
2551: niveau = 0;
2552: nombre_passages_par_zero = 0;
2553: i = 1;
2554: debut_fonction = 1;
2555:
2556: while((*element_courant) != d_code_fin_chaine)
2557: {
2558: if ((*element_courant) == '{')
2559: {
2560: if (niveau == 0)
2561: {
2562: extrait = extraction_chaine((*element), debut_fonction, i - 1);
2563:
2564: if (strcmp(extrait, fonction) != 0)
2565: {
2566: nombre_passages_par_zero++;
2567: }
2568:
2569: free(extrait);
2570: }
2571:
2572: niveau++;
2573: }
2574: else if ((*element_courant) == '}')
2575: {
2576: debut_fonction = i + 1;
2577: niveau--;
2578: }
2579:
2580: element_courant++;
2581: i++;
2582: }
2583:
2584: if (nombre_passages_par_zero > 1)
2585: {
2586: chaine = (*element);
2587:
2588: if (((*element) = (unsigned char *) malloc((strlen(chaine) + 14) *
2589: sizeof(unsigned char))) == NULL)
2590: {
2591: return;
2592: }
2593:
2594: sprintf((*element), "\\left(%s\\right)", chaine);
2595: free(chaine);
2596: }
2597:
2598: return;
2599: }
2600:
2601: // vim: ts=4