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