1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.18
4: Copyright (C) 1989-2014 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24: #include "tex-conv.h"
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:
70: if (tex_fprintf(s_etat_processus, fichier_impression,
71: "\\documentclass[%s,%s]{%s}\n\n",
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:
80: if (tex_fprintf(s_etat_processus, fichier_impression,
81: "\\usepackage[%s]{fontenc}\n", ds_tex_encodage_1) < 0)
82: {
83: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
84: return(NULL);
85: }
86:
87: if (tex_fprintf(s_etat_processus, fichier_impression,
88: "\\usepackage[%s]{inputenc}\n", ds_tex_encodage_2) < 0)
89: {
90: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
91: return(NULL);
92: }
93:
94: if (tex_fprintf(s_etat_processus, fichier_impression,
95: "\\usepackage[%s]{babel}\n\n", ds_tex_langue) < 0)
96: {
97: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
98: return(NULL);
99: }
100:
101: if (tex_fprintf(s_etat_processus, fichier_impression,
102: "\\usepackage{latexsym}\n") < 0)
103: {
104: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
105: return(NULL);
106: }
107:
108: if (tex_fprintf(s_etat_processus, fichier_impression,
109: "\\usepackage[dvips]{color}\n\n") < 0)
110: {
111: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
112: return(NULL);
113: }
114:
115: if (tex_fprintf(s_etat_processus, fichier_impression,
116: "\\usepackage{amsmath}\n") < 0)
117: {
118: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
119: return(NULL);
120: }
121:
122: if (tex_fprintf(s_etat_processus, fichier_impression,
123: "\\usepackage{amsfonts}\n") < 0)
124: {
125: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
126: return(NULL);
127: }
128:
129: if (tex_fprintf(s_etat_processus, fichier_impression,
130: "\\usepackage{amssymb}\n\n") < 0)
131: {
132: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
133: return(NULL);
134: }
135:
136: if (tex_fprintf(s_etat_processus, fichier_impression,
137: "\\title{Fichier d'impression}\n") < 0)
138: {
139: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
140: return(NULL);
141: }
142:
143: if (tex_fprintf(s_etat_processus, fichier_impression,
144: "\\author{RPL/2 Version %s}\n", d_version_rpl) < 0)
145: {
146: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
147: return(NULL);
148: }
149:
150: if (tex_fprintf(s_etat_processus, fichier_impression, "\\date{}\n\n") < 0)
151: {
152: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
153: return(NULL);
154: }
155:
156: if (tex_fprintf(s_etat_processus, fichier_impression,
157: "\\begin{document}\n\n") < 0)
158: {
159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
160: return(NULL);
161: }
162:
163: if (tex_fprintf(s_etat_processus, fichier_impression,
164: "\\thispagestyle{%s}\n", ds_tex_style) < 0)
165: {
166: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
167: return(NULL);
168: }
169:
170: if (tex_fprintf(s_etat_processus, fichier_impression,
171: "\\pagestyle{%s}\n\n", ds_tex_style) < 0)
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: {
227: if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
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:
236: if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
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:
252: if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
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: {
267: if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
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:
276: if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
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: {
289: if (tex_fprintf(s_etat_processus, fichier_impression,
290: "\\begin{center}\n") < 0)
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:
299: if (tex_fprintf(s_etat_processus, fichier_impression,
300: "\\end{center}\n") < 0)
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: {
315: if (tex_fprintf(s_etat_processus, fichier_impression,
316: "\\begin{equation}\n") < 0)
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:
325: if (tex_fprintf(s_etat_processus, fichier_impression,
326: "\\nonumber\n") < 0)
327: {
328: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
329: return;
330: }
331:
332: if (tex_fprintf(s_etat_processus, fichier_impression,
333: "\\end{equation}\n") < 0)
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: {
348: if (tex_fprintf(s_etat_processus, fichier_impression,
349: "\\begin{equation}\n") < 0)
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:
358: if (tex_fprintf(s_etat_processus, fichier_impression,
359: "\\nonumber\n") < 0)
360: {
361: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
362: return;
363: }
364:
365: if (tex_fprintf(s_etat_processus, fichier_impression,
366: "\\end{equation}\n") < 0)
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: {
380: if (tex_fprintf(s_etat_processus, fichier_impression,
381: "\\begin{center}\n") < 0)
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:
390: if (tex_fprintf(s_etat_processus, fichier_impression,
391: "\\end{center}\n") < 0)
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: {
404: if (tex_fprintf(s_etat_processus, fichier_impression,
405: "\\begin{equation}\n") < 0)
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:
414: if (tex_fprintf(s_etat_processus, fichier_impression,
415: "\\nonumber\n") < 0)
416: {
417: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
418: return;
419: }
420:
421: if (tex_fprintf(s_etat_processus, fichier_impression,
422: "\\end{equation}\n") < 0)
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: integer8 i;
501: integer8 j;
502: integer8 niveau;
503: integer8 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:
520: if (tex_fprintf(s_etat_processus, fichier_impression,
521: "\\#\\,%s\\text{%c}", &(ligne[1]), base) < 0)
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:
547: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
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: {
594: if (tex_fprintf(s_etat_processus, fichier_impression,
595: "$\\pi$") < 0)
596: {
597: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
598: return;
599: }
600: }
601: else
602: {
603: if (tex_fprintf(s_etat_processus, fichier_impression,
604: "\\textrm{%s}", ligne) < 0)
605: {
606: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
607: return;
608: }
609: }
610:
611: free(instruction_majuscule);
612: }
613: else
614: {
615: if (tex_fprintf(s_etat_processus, fichier_impression,
616: "\\textit{%s}", ligne) < 0)
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:
644: if (tex_fprintf(s_etat_processus, fichier_impression, "\\left(") < 0)
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: {
661: if (tex_fprintf(s_etat_processus, fichier_impression, ".\\,") < 0)
662: {
663: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
664: return;
665: }
666: }
667: else
668: {
669: if (tex_fprintf(s_etat_processus, fichier_impression, ",") < 0)
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:
679: if (tex_fprintf(s_etat_processus, fichier_impression, "\\right)") < 0)
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:
700: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
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: {
715: if (tex_fprintf(s_etat_processus, fichier_impression,
716: "\\left(\\begin{array}{") < 0)
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: {
725: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
726: {
727: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
728: return;
729: }
730: }
731:
732: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
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: {
767: if (tex_fprintf(s_etat_processus, fichier_impression,
768: " \\\\\n") < 0)
769: {
770: (*s_etat_processus).erreur_systeme =
771: d_es_erreur_fichier;
772: return;
773: }
774: }
775: else
776: {
777: if (tex_fprintf(s_etat_processus, fichier_impression,
778: " & ") < 0)
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:
790: if (tex_fprintf(s_etat_processus, fichier_impression,
791: "\\end{array}\\right)\n") < 0)
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: {
804: if (tex_fprintf(s_etat_processus, fichier_impression,
805: "\\left(\\begin{array}{") < 0)
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: {
814: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
815: {
816: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
817: return;
818: }
819: }
820:
821: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
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: {
852: if (tex_fprintf(s_etat_processus, fichier_impression,
853: " \\\\\n") < 0)
854: {
855: (*s_etat_processus).erreur_systeme =
856: d_es_erreur_fichier;
857: return;
858: }
859: }
860: else
861: {
862: if (tex_fprintf(s_etat_processus, fichier_impression,
863: " & ") < 0)
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:
875: if (tex_fprintf(s_etat_processus, fichier_impression,
876: "\\end{array}\\right)\n") < 0)
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: {
889: if (tex_fprintf(s_etat_processus, fichier_impression,
890: "\\left(\\begin{array}{") < 0)
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: {
899: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
900: {
901: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
902: return;
903: }
904: }
905:
906: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
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: {
937: if (tex_fprintf(s_etat_processus, fichier_impression,
938: " \\\\\n") < 0)
939: {
940: (*s_etat_processus).erreur_systeme =
941: d_es_erreur_fichier;
942: return;
943: }
944: }
945: else
946: {
947: if (tex_fprintf(s_etat_processus, fichier_impression,
948: " & ") < 0)
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:
960: if (tex_fprintf(s_etat_processus, fichier_impression,
961: "\\end{array}\\right)\n") < 0)
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 < (integer8) 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, (size_t) 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, (size_t) ++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:
1030: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
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: {
1045: if (tex_fprintf(s_etat_processus, fichier_impression,
1046: "\\left(\\begin{array}{c}\n") < 0)
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:
1073: if (tex_fprintf(s_etat_processus, fichier_impression,
1074: " \\\\\n") < 0)
1075: {
1076: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1077: return;
1078: }
1079: }
1080:
1081: free(s_objet_elementaire.objet);
1082:
1083: if (tex_fprintf(s_etat_processus, fichier_impression,
1084: "\\end{array}\\right)\n") < 0)
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: {
1097: if (tex_fprintf(s_etat_processus, fichier_impression,
1098: "\\left(\\begin{array}{c}\n") < 0)
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:
1122: if (tex_fprintf(s_etat_processus, fichier_impression,
1123: " \\\\\n") < 0)
1124: {
1125: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1126: return;
1127: }
1128: }
1129:
1130: free(s_objet_elementaire.objet);
1131:
1132: if (tex_fprintf(s_etat_processus, fichier_impression,
1133: "\\end{array}\\right)\n") < 0)
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: {
1146: if (tex_fprintf(s_etat_processus, fichier_impression,
1147: "\\left(\\begin{array}{c}\n") < 0)
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:
1171: if (tex_fprintf(s_etat_processus, fichier_impression,
1172: " \\\\\n") < 0)
1173: {
1174: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1175: return;
1176: }
1177: }
1178:
1179: free(s_objet_elementaire.objet);
1180:
1181: if (tex_fprintf(s_etat_processus, fichier_impression,
1182: "\\end{array}\\right)\n") < 0)
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: {
1200: if (tex_fprintf(s_etat_processus, fichier_impression, "$%s$",
1201: (*((struct_fonction *) (*s_objet).objet)).nom_fonction) < 0)
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: {
1210: if (tex_fprintf(s_etat_processus, fichier_impression,
1211: "$\\times$") < 0)
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: {
1220: if (tex_fprintf(s_etat_processus, fichier_impression,
1221: "$\\,\\hat{}\\,$") < 0)
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: {
1230: if (tex_fprintf(s_etat_processus, fichier_impression,
1231: "$\\rightarrow$") < 0)
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:
1252: if (tex_fprintf(s_etat_processus, fichier_impression, ligne) < 0)
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: {
1271: if (tex_fprintf(s_etat_processus, fichier_impression,
1272: "\\begin{equation}\n") < 0)
1273: {
1274: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1275: return;
1276: }
1277:
1278: if (tex_fprintf(s_etat_processus, fichier_impression,
1279: "\\left\\{\\text{%%\n") < 0)
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: {
1300: if (tex_fprintf(s_etat_processus, fichier_impression, "$") < 0)
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:
1309: if (tex_fprintf(s_etat_processus, fichier_impression,
1310: "$%%") < 0)
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:
1322: if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
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: {
1333: if (tex_fprintf(s_etat_processus, fichier_impression,
1334: "}\\right\\}\\nonumber\n") < 0)
1335: {
1336: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
1337: return;
1338: }
1339:
1340: if (tex_fprintf(s_etat_processus, fichier_impression,
1341: "\\end{equation}\n") < 0)
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 < (integer8)
1543: (strlen((unsigned char *)
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;
1577: conversion_element_tex(&chaine_parametre, "^");
1578:
1579: if ((*s_sous_objet_1).objet == NULL)
1580: {
1581: (*s_etat_processus).erreur_systeme =
1582: d_es_allocation_memoire;
1583: return;
1584: }
1585:
1586: if (((*s_sous_objet).objet = (void *)
1587: malloc((strlen(
1588: (unsigned char *) (*s_sous_objet_1).objet) +
1589: strlen((unsigned char *)
1590: (*s_sous_objet_2).objet) + 8) *
1591: sizeof(unsigned char))) == NULL)
1592: {
1593: return;
1594: }
1595:
1596: sprintf((unsigned char *) (*s_sous_objet).objet,
1597: "{{%s}^{%s}}",
1598: (unsigned char *) (*s_sous_objet_1).objet,
1599: (unsigned char *) (*s_sous_objet_2).objet);
1600: }
1601: else if (multiplication == d_vrai)
1602: {
1603: chaine_parametre = (unsigned char *)
1604: (*s_sous_objet_1).objet;
1605: conversion_element_tex(&chaine_parametre,
1606: (*((struct_fonction *)
1607: (*(*l_element_courant).donnee).objet))
1608: .nom_fonction);
1609:
1610: if ((*s_sous_objet_1).objet == NULL)
1611: {
1612: (*s_etat_processus).erreur_systeme =
1613: d_es_allocation_memoire;
1614: return;
1615: }
1616:
1617: chaine_parametre = (unsigned char *)
1618: (*s_sous_objet_2).objet;
1619: conversion_element_tex(&chaine_parametre,
1620: (*((struct_fonction *)
1621: (*(*l_element_courant).donnee).objet))
1622: .nom_fonction);
1623:
1624: if ((*s_sous_objet_2).objet == NULL)
1625: {
1626: (*s_etat_processus).erreur_systeme =
1627: d_es_allocation_memoire;
1628: return;
1629: }
1630:
1631: if ((((unsigned char *) (*s_sous_objet_2)
1632: .objet)[0] == '+') || (((unsigned char *)
1633: (*s_sous_objet_2).objet)[0] == '-'))
1634: {
1635: if (((*s_sous_objet).objet = (void *)
1636: malloc((strlen((unsigned char *)
1637: (*s_sous_objet_1).objet) +
1638: strlen((*((struct_fonction *)
1639: (*(*l_element_courant).donnee).objet))
1640: .nom_fonction) +
1641: strlen((unsigned char *)
1642: (*s_sous_objet_2).objet) + 14) *
1643: sizeof(unsigned char))) == NULL)
1644: {
1645: return;
1646: }
1647:
1648: sprintf((unsigned char *) (*s_sous_objet).objet,
1649: "%s%s\\left(%s\\right)",
1650: (unsigned char *) (*s_sous_objet_1)
1651: .objet, (*((struct_fonction *)
1652: (*(*l_element_courant).donnee).objet))
1653: .nom_fonction, (unsigned char *)
1654: (*s_sous_objet_2).objet);
1655: }
1656: else
1657: {
1658: if (((*s_sous_objet).objet = (void *)
1659: malloc((strlen((unsigned char *)
1660: (*s_sous_objet_1).objet) +
1661: strlen((*((struct_fonction *)
1662: (*(*l_element_courant).donnee).objet))
1663: .nom_fonction) +
1664: strlen((unsigned char *)
1665: (*s_sous_objet_2).objet) + 1) *
1666: sizeof(unsigned char))) == NULL)
1667: {
1668: return;
1669: }
1670:
1671: sprintf((unsigned char *) (*s_sous_objet).objet,
1672: "%s%s%s", (unsigned char *)
1673: (*s_sous_objet_1)
1674: .objet, (*((struct_fonction *)
1675: (*(*l_element_courant).donnee).objet))
1676: .nom_fonction, (unsigned char *)
1677: (*s_sous_objet_2).objet);
1678: }
1679: }
1680: else
1681: {
1682: if ((strcmp((*((struct_fonction *)
1683: (*(*l_element_courant).donnee).objet))
1684: .nom_fonction, "<") != 0) &&
1685: (strcmp((*((struct_fonction *)
1686: (*(*l_element_courant).donnee).objet))
1687: .nom_fonction, ">") != 0) &&
1688: (strcmp((*((struct_fonction *)
1689: (*(*l_element_courant).donnee).objet))
1690: .nom_fonction, "=") != 0) &&
1691: (strcmp((*((struct_fonction *)
1692: (*(*l_element_courant).donnee).objet))
1693: .nom_fonction, "==") != 0) &&
1694: (strcmp((*((struct_fonction *)
1695: (*(*l_element_courant).donnee).objet))
1696: .nom_fonction, "\\geqslant ") != 0) &&
1697: (strcmp((*((struct_fonction *)
1698: (*(*l_element_courant).donnee).objet))
1699: .nom_fonction, "\\leqslant ") != 0))
1700: {
1701: chaine_parametre = (unsigned char *)
1702: (*s_sous_objet_1).objet;
1703: conversion_element_tex(&chaine_parametre,
1704: (*((struct_fonction *)
1705: (*(*l_element_courant).donnee).objet))
1706: .nom_fonction);
1707:
1708: if ((*s_sous_objet_1).objet == NULL)
1709: {
1710: (*s_etat_processus).erreur_systeme =
1711: d_es_allocation_memoire;
1712: return;
1713: }
1714:
1715: chaine_parametre = (unsigned char *)
1716: (*s_sous_objet_2).objet;
1717: conversion_element_tex(&chaine_parametre,
1718: (*((struct_fonction *)
1719: (*(*l_element_courant).donnee).objet))
1720: .nom_fonction);
1721:
1722: if ((*s_sous_objet_2).objet == NULL)
1723: {
1724: (*s_etat_processus).erreur_systeme =
1725: d_es_allocation_memoire;
1726: return;
1727: }
1728: }
1729:
1730: if ((((unsigned char *) (*s_sous_objet_2)
1731: .objet)[0] == '+') || (((unsigned char *)
1732: (*s_sous_objet_2).objet)[0] == '-'))
1733: {
1734: if (((*s_sous_objet).objet = (void *)
1735: malloc((strlen((unsigned char *)
1736: (*s_sous_objet_1).objet) +
1737: strlen((*((struct_fonction *)
1738: (*(*l_element_courant).donnee).objet))
1739: .nom_fonction) +
1740: strlen((unsigned char *)
1741: (*s_sous_objet_2).objet) + 18) *
1742: sizeof(unsigned char))) == NULL)
1743: {
1744: return;
1745: }
1746:
1747: sprintf((unsigned char *) (*s_sous_objet).objet,
1748: "{%s}%s{\\left(%s\\right)}",
1749: (unsigned char *) (*s_sous_objet_1)
1750: .objet, (*((struct_fonction *)
1751: (*(*l_element_courant).donnee).objet))
1752: .nom_fonction, (unsigned char *)
1753: (*s_sous_objet_2).objet);
1754: }
1755: else
1756: {
1757: if (((*s_sous_objet).objet = (void *)
1758: malloc((strlen((unsigned char *)
1759: (*s_sous_objet_1).objet) +
1760: strlen((*((struct_fonction *)
1761: (*(*l_element_courant).donnee).objet))
1762: .nom_fonction) +
1763: strlen((unsigned char *)
1764: (*s_sous_objet_2).objet) + 5) *
1765: sizeof(unsigned char))) == NULL)
1766: {
1767: return;
1768: }
1769:
1770: sprintf((unsigned char *) (*s_sous_objet).objet,
1771: "{%s}%s{%s}", (unsigned char *)
1772: (*s_sous_objet_1)
1773: .objet, (*((struct_fonction *)
1774: (*(*l_element_courant).donnee).objet))
1775: .nom_fonction, (unsigned char *)
1776: (*s_sous_objet_2).objet);
1777: }
1778: }
1779:
1780: liberation(s_etat_processus, s_sous_objet_1);
1781: liberation(s_etat_processus, s_sous_objet_2);
1782:
1783: if (empilement(s_etat_processus, &((*s_etat_processus)
1784: .l_base_pile), s_sous_objet) == d_erreur)
1785: {
1786: return;
1787: }
1788: }
1789: else if (strcmp((*((struct_fonction *)
1790: (*(*l_element_courant).donnee).objet)).nom_fonction,
1791: "NOT") == 0)
1792: {
1793: if (depilement(s_etat_processus, &((*s_etat_processus)
1794: .l_base_pile), &s_sous_objet_1) == d_erreur)
1795: {
1796: return;
1797: }
1798:
1799: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1800: == NULL)
1801: {
1802: return;
1803: }
1804:
1805: if (((*s_sous_objet).objet = (unsigned char *) malloc(
1806: (strlen((unsigned char *) (*s_sous_objet_1)
1807: .objet) + 25) * sizeof(unsigned char))) ==
1808: NULL)
1809: {
1810: return;
1811: }
1812:
1813: sprintf((unsigned char *) (*s_sous_objet).objet,
1814: "\\text{%s}\\left(%s\\right)",
1815: (*((struct_fonction *)
1816: (*(*l_element_courant).donnee).objet))
1817: .nom_fonction, (unsigned char *)
1818: (*s_sous_objet_1).objet);
1819:
1820: liberation(s_etat_processus, s_sous_objet_1);
1821:
1822: if (empilement(s_etat_processus, &((*s_etat_processus)
1823: .l_base_pile), s_sous_objet) == d_erreur)
1824: {
1825: return;
1826: }
1827: }
1828: else if ((strcmp((*((struct_fonction *)
1829: (*(*l_element_courant).donnee).objet)).nom_fonction,
1830: "OR") == 0) || (strcmp((*((struct_fonction *)
1831: (*(*l_element_courant).donnee).objet)).nom_fonction,
1832: "XOR") == 0) || (strcmp((*((struct_fonction *)
1833: (*(*l_element_courant).donnee).objet)).nom_fonction,
1834: "AND") == 0))
1835: {
1836: if (depilement(s_etat_processus, &((*s_etat_processus)
1837: .l_base_pile), &s_sous_objet_2) == d_erreur)
1838: {
1839: return;
1840: }
1841:
1842: if (depilement(s_etat_processus, &((*s_etat_processus)
1843: .l_base_pile), &s_sous_objet_1) == d_erreur)
1844: {
1845: return;
1846: }
1847:
1848: if ((s_sous_objet = allocation(s_etat_processus, CHN))
1849: == NULL)
1850: {
1851: return;
1852: }
1853:
1854: if (((*s_sous_objet).objet = (void *) malloc((strlen(
1855: (unsigned char *) (*s_sous_objet_1).objet) +
1856: strlen((*((struct_fonction *)
1857: (*(*l_element_courant).donnee).objet))
1858: .nom_fonction) + strlen((unsigned char *)
1859: (*s_sous_objet_2).objet) + 10) *
1860: sizeof(unsigned char))) == NULL)
1861: {
1862: return;
1863: }
1864:
1865: sprintf((unsigned char *) (*s_sous_objet).objet,
1866: "%s \\text{%s} %s", (unsigned char *)
1867: (*s_sous_objet_1)
1868: .objet, (*((struct_fonction *)
1869: (*(*l_element_courant).donnee).objet))
1870: .nom_fonction, (unsigned char *)
1871: (*s_sous_objet_2).objet);
1872:
1873: liberation(s_etat_processus, s_sous_objet_1);
1874: liberation(s_etat_processus, s_sous_objet_2);
1875:
1876: if (empilement(s_etat_processus, &((*s_etat_processus)
1877: .l_base_pile), s_sous_objet) == d_erreur)
1878: {
1879: return;
1880: }
1881: }
1882: else
1883: {
1884: nombre_arguments = (*((struct_fonction *)
1885: (*(*l_element_courant).donnee).objet))
1886: .nombre_arguments;
1887:
1888: if ((chaine = (unsigned char *)
1889: malloc(sizeof(unsigned char))) == NULL)
1890: {
1891: return;
1892: }
1893:
1894: chaine[0] = d_code_fin_chaine;
1895:
1896: for(i = 0; i < nombre_arguments; i++)
1897: {
1898: if ((nombre_arguments - i) > 1)
1899: {
1900: l_liste1 = (*s_etat_processus).l_base_pile;
1901:
1902: for(j = 2; j < (nombre_arguments - i); j++)
1903: {
1904: l_liste1 = (*l_liste1).suivant;
1905: }
1906:
1907: l_liste2 = (*l_liste1).suivant;
1908: (*l_liste1).suivant = (*l_liste2).suivant;
1909: (*l_liste2).suivant = (*s_etat_processus)
1910: .l_base_pile;
1911: (*s_etat_processus).l_base_pile = l_liste2;
1912: }
1913:
1914: if (depilement(s_etat_processus,
1915: &((*s_etat_processus).l_base_pile),
1916: &s_sous_objet) == d_erreur)
1917: {
1918: return;
1919: }
1920:
1921: chaine_sauvegarde = chaine;
1922:
1923: if (strlen(chaine_sauvegarde) == 0)
1924: {
1925: if ((chaine = (unsigned char *) malloc((strlen(
1926: (unsigned char *) (*s_sous_objet).objet)
1927: + 1) * sizeof(unsigned char))) == NULL)
1928: {
1929: return;
1930: }
1931:
1932: sprintf(chaine, "%s", (unsigned char *)
1933: (*s_sous_objet).objet);
1934: }
1935: else
1936: {
1937: if ((chaine = (unsigned char *) malloc((strlen(
1938: chaine_sauvegarde) + 1 + strlen(
1939: (unsigned char *) (*s_sous_objet).objet)
1940: + 1) * sizeof(unsigned char))) == NULL)
1941: {
1942: return;
1943: }
1944:
1945: sprintf(chaine, "%s,%s", chaine_sauvegarde,
1946: (unsigned char *) (*s_sous_objet)
1947: .objet);
1948: }
1949:
1950: free(chaine_sauvegarde);
1951: liberation(s_etat_processus, s_sous_objet);
1952: }
1953:
1954: chaine_sauvegarde = chaine;
1955:
1956: if ((chaine = (unsigned char *) malloc((strlen(
1957: (*((struct_fonction *) (*(*l_element_courant)
1958: .donnee).objet)).nom_fonction) + 20 +
1959: strlen(chaine_sauvegarde) + 1) *
1960: sizeof(unsigned char))) == NULL)
1961: {
1962: return;
1963: }
1964:
1965: sprintf(chaine, "\\text{%s}\\left(%s\\right)",
1966: (*((struct_fonction *)
1967: (*(*l_element_courant).donnee).objet))
1968: .nom_fonction, chaine_sauvegarde);
1969: free(chaine_sauvegarde);
1970:
1971: instruction_courante = (*s_etat_processus)
1972: .instruction_courante;
1973: test_instruction = (*s_etat_processus).test_instruction;
1974: instruction_valide = (*s_etat_processus)
1975: .instruction_valide;
1976:
1977: (*s_etat_processus).test_instruction = 'Y';
1978: (*s_etat_processus).instruction_courante =
1979: (*((struct_fonction *) (*(*l_element_courant)
1980: .donnee).objet)).nom_fonction;
1981:
1982: analyse(s_etat_processus, NULL);
1983:
1984: if ((*s_etat_processus).instruction_valide == 'Y')
1985: {
1986: for(i = 0; i < (integer8) strlen(chaine); i++)
1987: {
1988: if ((chaine[i] >= 'A') && (chaine[i] <= 'Z'))
1989: {
1990: chaine[i] = (unsigned char)
1991: (chaine[i] + ('a' - 'A'));
1992: }
1993: }
1994: }
1995:
1996: (*s_etat_processus).instruction_courante =
1997: instruction_courante;
1998: (*s_etat_processus).test_instruction =
1999: instruction_valide;
2000: (*s_etat_processus).instruction_valide =
2001: instruction_valide;
2002:
2003: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2004: == NULL)
2005: {
2006: return;
2007: }
2008:
2009: (*s_sous_objet).objet = (void *) chaine;
2010:
2011: if (empilement(s_etat_processus, &((*s_etat_processus)
2012: .l_base_pile), s_sous_objet) == d_erreur)
2013: {
2014: return;
2015: }
2016: }
2017: }
2018: }
2019: else
2020: {
2021: if ((s_sous_objet = allocation(s_etat_processus, CHN))
2022: == NULL)
2023: {
2024: return;
2025: }
2026:
2027: if (((*s_sous_objet).objet = (void *) formateur(
2028: s_etat_processus, 0,
2029: (*l_element_courant).donnee)) == NULL)
2030: {
2031: return;
2032: }
2033:
2034: if ((*(*l_element_courant).donnee).type == NOM)
2035: {
2036: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;
2037:
2038: if (((*s_sous_objet).objet = malloc((strlen(
2039: chaine_sauvegarde) - 1) *
2040: sizeof(unsigned char))) == NULL)
2041: {
2042: return;
2043: }
2044:
2045: ptrl = chaine_sauvegarde;
2046: ptre = (unsigned char *) (*s_sous_objet).objet;
2047:
2048: for(ptrl++, i = (integer8) (strlen(chaine_sauvegarde) - 2);
2049: i > 0; i--, *ptre++ = *ptrl++);
2050:
2051: (*ptre) = d_code_fin_chaine;
2052:
2053: free(chaine_sauvegarde);
2054:
2055: chaine_majuscule = conversion_majuscule((*((struct_nom *)
2056: (*(*l_element_courant).donnee).objet)).nom);
2057:
2058: if (strcmp(chaine_majuscule, "PI") == 0)
2059: {
2060: free((unsigned char *) (*s_sous_objet).objet);
2061:
2062: if (((*s_sous_objet).objet =
2063: malloc(5 * sizeof(unsigned char))) == NULL)
2064: {
2065: (*s_etat_processus).erreur_systeme =
2066: d_es_allocation_memoire;
2067: return;
2068: }
2069:
2070: strcpy((unsigned char *) (*s_sous_objet).objet,
2071: "\\pi ");
2072: }
2073: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2074: .donnee).objet)).nom, "i") == 0)
2075: {
2076: free((unsigned char *) (*s_sous_objet).objet);
2077:
2078: if (((*s_sous_objet).objet =
2079: malloc(9 * sizeof(unsigned char))) == NULL)
2080: {
2081: (*s_etat_processus).erreur_systeme =
2082: d_es_allocation_memoire;
2083: return;
2084: }
2085:
2086: strcpy((unsigned char *) (*s_sous_objet).objet,
2087: "\\text{i}");
2088: }
2089: else if (strcmp((*((struct_nom *) (*(*l_element_courant)
2090: .donnee).objet)).nom, "e") == 0)
2091: {
2092: free((unsigned char *) (*s_sous_objet).objet);
2093:
2094: if (((*s_sous_objet).objet =
2095: malloc(9 * sizeof(unsigned char))) == NULL)
2096: {
2097: (*s_etat_processus).erreur_systeme =
2098: d_es_allocation_memoire;
2099: return;
2100: }
2101:
2102: strcpy((unsigned char *) (*s_sous_objet).objet,
2103: "\\text{e}");
2104: }
2105:
2106: free(chaine_majuscule);
2107: }
2108:
2109: if (empilement(s_etat_processus, &((*s_etat_processus)
2110: .l_base_pile), s_sous_objet) == d_erreur)
2111: {
2112: return;
2113: }
2114: }
2115:
2116: l_element_courant = (*l_element_courant).suivant;
2117: }
2118:
2119: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2120: &s_sous_objet) == d_erreur)
2121: {
2122: return;
2123: }
2124:
2125: if (tex_fprintf(s_etat_processus, fichier_impression, "%s",
2126: (unsigned char *) (*s_sous_objet).objet) < 0)
2127: {
2128: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2129: return;
2130: }
2131:
2132: liberation(s_etat_processus, s_sous_objet);
2133: liberation(s_etat_processus, s_copie_objet);
2134: }
2135:
2136: return;
2137: }
2138:
2139:
2140: /*
2141: ================================================================================
2142: Echappement des caractères spéciaux de TeX
2143: ================================================================================
2144: Entrées : ligne d'instructions TeX
2145: --------------------------------------------------------------------------------
2146: Sorties : ligne corrigée
2147: --------------------------------------------------------------------------------
2148: Effets de bord : néant
2149: ================================================================================
2150: */
2151:
2152: void
2153: correction_formateur_tex(struct_processus *s_etat_processus,
2154: unsigned char **ligne)
2155: {
2156: logical1 mode_mathematique;
2157:
2158: unsigned char *tampon;
2159:
2160: integer8 i;
2161:
2162: mode_mathematique = d_faux;
2163:
2164: for(i = 0; i < (integer8) strlen((*ligne)); i++)
2165: {
2166: switch((*ligne)[i])
2167: {
2168: /*
2169: * Le caractère '_' est autorisé tel quel dans une expression
2170: * mathématique. Il est protégé en mode normal.
2171: */
2172:
2173: case '$' :
2174: {
2175: mode_mathematique = (mode_mathematique == d_faux)
2176: ? d_vrai : d_faux;
2177:
2178: if ((*ligne)[i + 1] == '$')
2179: {
2180: i++;
2181: }
2182:
2183: break;
2184: }
2185:
2186: /*
2187: * Les '$', '{' et '}' ne sont pas convertis pour pouvoir écrire
2188: * du TeX dans le texte.
2189: */
2190:
2191: case '#' :
2192: case '_' :
2193: {
2194: if (mode_mathematique == d_vrai)
2195: {
2196: break;
2197: }
2198: }
2199:
2200: case '%' :
2201: case '&' :
2202: {
2203: if ((tampon = (unsigned char *) malloc((strlen((*ligne)) + 2) *
2204: sizeof(unsigned char))) == NULL)
2205: {
2206: (*s_etat_processus).erreur_systeme =
2207: d_es_allocation_memoire;
2208: return;
2209: }
2210:
2211: strncpy(tampon, (*ligne), (size_t) i);
2212: strcpy(&(tampon[i]), "\\");
2213: strcat(tampon, &((*ligne)[i++]));
2214:
2215: free((*ligne));
2216: (*ligne) = tampon;
2217:
2218: break;
2219: }
2220:
2221: default :
2222: {
2223: break;
2224: }
2225: }
2226: }
2227:
2228: return;
2229: }
2230:
2231:
2232: /*
2233: ================================================================================
2234: Fonction 'impression_tex'
2235: ================================================================================
2236: Entrées :
2237: --------------------------------------------------------------------------------
2238: Sorties :
2239: --------------------------------------------------------------------------------
2240: Effets de bord : néant
2241: ================================================================================
2242: */
2243:
2244: void
2245: impression_tex(struct_processus *s_etat_processus)
2246: {
2247: file *fichier_impression;
2248:
2249: unsigned char *commande;
2250: unsigned char *executable_candidat;
2251: unsigned char *nom_fichier_aux;
2252: unsigned char *nom_fichier_dvi;
2253: unsigned char *nom_fichier_log;
2254: unsigned char *nom_fichier_tex;
2255: unsigned char *nom_fichier_ps;
2256:
2257: size_t longueur_nom_base;
2258:
2259: longueur_nom_base = strlen((*s_etat_processus).nom_fichier_impression);
2260:
2261: if ((nom_fichier_tex = malloc((longueur_nom_base + 6) *
2262: sizeof(unsigned char))) == NULL)
2263: {
2264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2265: return;
2266: }
2267:
2268: if ((nom_fichier_log = malloc((longueur_nom_base + 6) *
2269: sizeof(unsigned char))) == NULL)
2270: {
2271: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2272: return;
2273: }
2274:
2275: if ((nom_fichier_aux = malloc((longueur_nom_base + 6) *
2276: sizeof(unsigned char))) == NULL)
2277: {
2278: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2279: return;
2280: }
2281:
2282: if ((nom_fichier_dvi = malloc((longueur_nom_base + 6) *
2283: sizeof(unsigned char))) == NULL)
2284: {
2285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2286: return;
2287: }
2288:
2289: if ((nom_fichier_ps = malloc((longueur_nom_base + 5) *
2290: sizeof(unsigned char))) == NULL)
2291: {
2292: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2293: return;
2294: }
2295:
2296: strcpy(nom_fichier_tex, (*s_etat_processus).nom_fichier_impression)
2297: [longueur_nom_base - 4] = d_code_fin_chaine;
2298: strcat(nom_fichier_tex, ".conv.tex");
2299:
2300: strcpy(nom_fichier_aux, (*s_etat_processus).nom_fichier_impression)
2301: [longueur_nom_base - 4] = d_code_fin_chaine;
2302: strcat(nom_fichier_aux, ".conv.aux");
2303:
2304: strcpy(nom_fichier_log, (*s_etat_processus).nom_fichier_impression)
2305: [longueur_nom_base - 4] = d_code_fin_chaine;
2306: strcat(nom_fichier_log, ".conv.log");
2307:
2308: strcpy(nom_fichier_dvi, (*s_etat_processus).nom_fichier_impression)
2309: [longueur_nom_base - 4] = d_code_fin_chaine;
2310: strcat(nom_fichier_dvi, ".conv.dvi");
2311:
2312: strcpy(nom_fichier_ps, (*s_etat_processus).nom_fichier_impression)
2313: [longueur_nom_base - 4] = d_code_fin_chaine;
2314: strcat(nom_fichier_ps, ".conv.ps");
2315:
2316: if ((fichier_impression = fopen((*s_etat_processus).nom_fichier_impression,
2317: "a")) == NULL)
2318: {
2319: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2320: return;
2321: }
2322:
2323: if (tex_fprintf(s_etat_processus, fichier_impression,
2324: "\\end{document}\n") < 0)
2325: {
2326: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2327: return;
2328: }
2329:
2330: if (fclose(fichier_impression) != 0)
2331: {
2332: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2333: return;
2334: }
2335:
2336: if ((*s_etat_processus).rpl_home == NULL)
2337: {
2338: if (alsprintf(&commande, ds_tex_commande,
2339: d_exec_path, d_exec_path, d_exec_path,
2340: (*s_etat_processus).nom_fichier_impression,
2341: d_exec_path, d_exec_path,
2342: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2343: (*s_etat_processus).chemin_fichiers_temporaires,
2344: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2345: {
2346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2347: return;
2348: }
2349:
2350: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
2351: d_exec_path) < 0)
2352: {
2353: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2354: return;
2355: }
2356:
2357: if (controle_integrite(s_etat_processus, executable_candidat,
2358: "rpliconv") != d_vrai)
2359: {
2360: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2361: return;
2362: }
2363:
2364: free(executable_candidat);
2365:
2366: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
2367: d_exec_path) < 0)
2368: {
2369: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2370: return;
2371: }
2372:
2373: if (controle_integrite(s_etat_processus, executable_candidat,
2374: "rplfile") != d_vrai)
2375: {
2376: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2377: return;
2378: }
2379:
2380: free(executable_candidat);
2381: }
2382: else
2383: {
2384: if (alsprintf(&commande, ds_tex_commande,
2385: (*s_etat_processus).rpl_home,
2386: (*s_etat_processus).rpl_home,
2387: (*s_etat_processus).rpl_home,
2388: (*s_etat_processus).nom_fichier_impression,
2389: (*s_etat_processus).rpl_home,
2390: (*s_etat_processus).rpl_home,
2391: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
2392: (*s_etat_processus).chemin_fichiers_temporaires,
2393: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
2394: {
2395: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2396: return;
2397: }
2398:
2399: if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
2400: (*s_etat_processus).rpl_home) < 0)
2401: {
2402: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2403: return;
2404: }
2405:
2406: if (controle_integrite(s_etat_processus, executable_candidat,
2407: "rpliconv") != d_vrai)
2408: {
2409: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2410: return;
2411: }
2412:
2413: free(executable_candidat);
2414:
2415: if (alsprintf(&executable_candidat, "%s/bin/rplfile",
2416: (*s_etat_processus).rpl_home) < 0)
2417: {
2418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2419: return;
2420: }
2421:
2422: if (controle_integrite(s_etat_processus, executable_candidat,
2423: "rplfile") != d_vrai)
2424: {
2425: (*s_etat_processus).erreur_systeme = d_es_somme_controle;
2426: return;
2427: }
2428:
2429: free(executable_candidat);
2430: }
2431:
2432: if (system(commande) != 0)
2433: {
2434: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2435: free(commande);
2436: }
2437: else
2438: {
2439: free(commande);
2440:
2441: if (alsprintf(&commande, ds_tex_postscript, nom_fichier_ps) < 0)
2442: {
2443: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2444: return;
2445: }
2446:
2447: if (system(commande) != 0)
2448: {
2449: (*s_etat_processus).erreur_execution = d_ex_erreur_impression;
2450: }
2451:
2452: free(commande);
2453:
2454: if (destruction_fichier(nom_fichier_ps) == d_erreur)
2455: {
2456: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2457: return;
2458: }
2459: }
2460:
2461: if (destruction_fichier((*s_etat_processus).nom_fichier_impression)
2462: == d_erreur)
2463: {
2464: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2465: return;
2466: }
2467:
2468: free((*s_etat_processus).nom_fichier_impression);
2469: (*s_etat_processus).nom_fichier_impression = NULL;
2470:
2471: if (destruction_fichier(nom_fichier_tex) == d_erreur)
2472: {
2473: free(nom_fichier_aux);
2474: free(nom_fichier_log);
2475: free(nom_fichier_dvi);
2476: free(nom_fichier_tex);
2477: free(nom_fichier_ps);
2478:
2479: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2480: return;
2481: }
2482:
2483: if (destruction_fichier(nom_fichier_aux) == d_erreur)
2484: {
2485: free(nom_fichier_aux);
2486: free(nom_fichier_log);
2487: free(nom_fichier_dvi);
2488: free(nom_fichier_tex);
2489: free(nom_fichier_ps);
2490:
2491: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2492: return;
2493: }
2494:
2495: if (destruction_fichier(nom_fichier_dvi) == d_erreur)
2496: {
2497: free(nom_fichier_aux);
2498: free(nom_fichier_log);
2499: free(nom_fichier_dvi);
2500: free(nom_fichier_tex);
2501: free(nom_fichier_ps);
2502:
2503: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2504: return;
2505: }
2506:
2507: if (destruction_fichier(nom_fichier_log) == d_erreur)
2508: {
2509: free(nom_fichier_aux);
2510: free(nom_fichier_log);
2511: free(nom_fichier_dvi);
2512: free(nom_fichier_tex);
2513: free(nom_fichier_ps);
2514:
2515: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
2516: return;
2517: }
2518:
2519: free(nom_fichier_aux);
2520: free(nom_fichier_log);
2521: free(nom_fichier_dvi);
2522: free(nom_fichier_tex);
2523: free(nom_fichier_ps);
2524:
2525: return;
2526: }
2527:
2528:
2529: /*
2530: ================================================================================
2531: Conversion des éléments TeX par ajout si nécessaire de parenthèses
2532: ================================================================================
2533: Entrées :
2534: --------------------------------------------------------------------------------
2535: Sorties :
2536: --------------------------------------------------------------------------------
2537: Effets de bord : néant
2538: ================================================================================
2539: */
2540:
2541: void
2542: conversion_element_tex(unsigned char **element, unsigned char *fonction)
2543: {
2544: unsigned char *chaine;
2545: unsigned char *element_courant;
2546: unsigned char *extrait;
2547:
2548: integer8 debut_fonction;
2549: integer8 i;
2550: integer8 niveau;
2551: integer8 nombre_passages_par_zero;
2552:
2553: element_courant = (*element);
2554: niveau = 0;
2555: nombre_passages_par_zero = 0;
2556: i = 1;
2557: debut_fonction = 1;
2558:
2559: while((*element_courant) != d_code_fin_chaine)
2560: {
2561: if ((*element_courant) == '{')
2562: {
2563: if (niveau == 0)
2564: {
2565: extrait = extraction_chaine((*element), debut_fonction, i - 1);
2566:
2567: if (strcmp(extrait, fonction) != 0)
2568: {
2569: nombre_passages_par_zero++;
2570: }
2571:
2572: free(extrait);
2573: }
2574:
2575: niveau++;
2576: }
2577: else if ((*element_courant) == '}')
2578: {
2579: debut_fonction = i + 1;
2580: niveau--;
2581: }
2582:
2583: element_courant++;
2584: i++;
2585: }
2586:
2587: if (nombre_passages_par_zero > 1)
2588: {
2589: chaine = (*element);
2590:
2591: if (((*element) = (unsigned char *) malloc((strlen(chaine) + 14) *
2592: sizeof(unsigned char))) == NULL)
2593: {
2594: return;
2595: }
2596:
2597: sprintf((*element), "\\left(%s\\right)", chaine);
2598: free(chaine);
2599: }
2600:
2601: return;
2602: }
2603:
2604: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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