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