![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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: unsigned long i; 501: unsigned long j; 502: unsigned long niveau; 503: unsigned long nombre_arguments; 504: 505: /* 506: * Entier binaire 507: */ 508: 509: if ((*s_objet).type == BIN) 510: { 511: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL) 512: { 513: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 514: return; 515: } 516: 517: base = ligne[strlen(ligne) - 1]; 518: ligne[strlen(ligne) - 1] = d_code_fin_chaine; 519: 520: if (tex_fprintf(s_etat_processus, fichier_impression, 521: "\\#\\,%s\\text{%c}", &(ligne[1]), base) < 0) 522: { 523: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 524: return; 525: } 526: 527: free(ligne); 528: } 529: 530: /* 531: * Chaîne de caractères 532: */ 533: 534: else if ((*s_objet).type == CHN) 535: { 536: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL) 537: { 538: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 539: return; 540: } 541: 542: if (environnement == 'N') 543: { 544: correction_formateur_tex(s_etat_processus, &ligne); 545: } 546: 547: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0) 548: { 549: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 550: return; 551: } 552: 553: free(ligne); 554: } 555: 556: /* 557: * Nom 558: */ 559: 560: else if ((*s_objet).type == NOM) 561: { 562: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL) 563: { 564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 565: return; 566: } 567: 568: if (environnement == 'N') 569: { 570: correction_formateur_tex(s_etat_processus, &ligne); 571: } 572: 573: test_instruction = (*s_etat_processus).test_instruction; 574: instruction_valide = (*s_etat_processus).instruction_valide; 575: instruction_courante = (*s_etat_processus).instruction_courante; 576: 577: (*s_etat_processus).test_instruction = 'Y'; 578: (*s_etat_processus).instruction_courante = 579: (*((struct_nom *) (*s_objet).objet)).nom; 580: 581: analyse(s_etat_processus, NULL); 582: 583: if ((*s_etat_processus).instruction_valide == 'Y') 584: { 585: if ((instruction_majuscule = conversion_majuscule( 586: (*s_etat_processus).instruction_courante)) == NULL) 587: { 588: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 589: return; 590: } 591: 592: if (strcmp(instruction_majuscule, "PI") == 0) 593: { 594: if (tex_fprintf(s_etat_processus, fichier_impression, 595: "$\\pi$") < 0) 596: { 597: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 598: return; 599: } 600: } 601: else 602: { 603: if (tex_fprintf(s_etat_processus, fichier_impression, 604: "\\textrm{%s}", ligne) < 0) 605: { 606: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 607: return; 608: } 609: } 610: 611: free(instruction_majuscule); 612: } 613: else 614: { 615: if (tex_fprintf(s_etat_processus, fichier_impression, 616: "\\textit{%s}", ligne) < 0) 617: { 618: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 619: return; 620: } 621: } 622: 623: (*s_etat_processus).instruction_courante = instruction_courante; 624: (*s_etat_processus).test_instruction = test_instruction; 625: (*s_etat_processus).instruction_valide = instruction_valide; 626: 627: free(ligne); 628: } 629: 630: /* 631: * Nombre complexe 632: */ 633: 634: else if ((*s_objet).type == CPL) 635: { 636: s_objet_elementaire.type = REL; 637: 638: if ((s_objet_elementaire.objet = malloc(sizeof(real8))) == NULL) 639: { 640: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 641: return; 642: } 643: 644: if (tex_fprintf(s_etat_processus, fichier_impression, "\\left(") < 0) 645: { 646: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 647: return; 648: } 649: 650: (*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *) 651: (*s_objet).objet)).partie_reelle; 652: 653: formateur_elementaire_tex(s_etat_processus, fichier_impression, 654: &s_objet_elementaire, environnement); 655: 656: (*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *) 657: (*s_objet).objet)).partie_imaginaire; 658: 659: if (test_cfsf(s_etat_processus, 48) == d_vrai) 660: { 661: if (tex_fprintf(s_etat_processus, fichier_impression, ".\\,") < 0) 662: { 663: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 664: return; 665: } 666: } 667: else 668: { 669: if (tex_fprintf(s_etat_processus, fichier_impression, ",") < 0) 670: { 671: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 672: return; 673: } 674: } 675: 676: formateur_elementaire_tex(s_etat_processus, fichier_impression, 677: &s_objet_elementaire, environnement); 678: 679: if (tex_fprintf(s_etat_processus, fichier_impression, "\\right)") < 0) 680: { 681: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 682: return; 683: } 684: 685: free(s_objet_elementaire.objet); 686: } 687: 688: /* 689: * Entier 690: */ 691: 692: else if ((*s_objet).type == INT) 693: { 694: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL) 695: { 696: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 697: return; 698: } 699: 700: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0) 701: { 702: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 703: return; 704: } 705: 706: free(ligne); 707: } 708: 709: /* 710: * Matrice de complexes 711: */ 712: 713: else if ((*s_objet).type == MCX) 714: { 715: if (tex_fprintf(s_etat_processus, fichier_impression, 716: "\\left(\\begin{array}{") < 0) 717: { 718: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 719: return; 720: } 721: 722: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)) 723: .nombre_colonnes; i++) 724: { 725: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0) 726: { 727: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 728: return; 729: } 730: } 731: 732: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0) 733: { 734: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 735: return; 736: } 737: 738: if ((s_objet_elementaire.objet = (complex16 *) malloc( 739: sizeof(complex16))) == NULL) 740: { 741: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 742: return; 743: } 744: 745: s_objet_elementaire.type = CPL; 746: 747: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes; 748: i++) 749: { 750: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet)) 751: .nombre_colonnes; j++) 752: { 753: (*((complex16 *) (s_objet_elementaire.objet))).partie_reelle = 754: ((complex16 **) (*((struct_matrice *) 755: (*s_objet).objet)).tableau)[i][j].partie_reelle; 756: (*((complex16 *) (s_objet_elementaire.objet))) 757: .partie_imaginaire = ((complex16 **) 758: (*((struct_matrice *) (*s_objet).objet)).tableau)[i][j] 759: .partie_imaginaire; 760: 761: formateur_elementaire_tex(s_etat_processus, fichier_impression, 762: &s_objet_elementaire, environnement); 763: 764: if (j == ((*((struct_matrice *) (*s_objet).objet)) 765: .nombre_colonnes - 1)) 766: { 767: if (tex_fprintf(s_etat_processus, fichier_impression, 768: " \\\\\n") < 0) 769: { 770: (*s_etat_processus).erreur_systeme = 771: d_es_erreur_fichier; 772: return; 773: } 774: } 775: else 776: { 777: if (tex_fprintf(s_etat_processus, fichier_impression, 778: " & ") < 0) 779: { 780: (*s_etat_processus).erreur_systeme = 781: d_es_erreur_fichier; 782: return; 783: } 784: } 785: } 786: } 787: 788: free(s_objet_elementaire.objet); 789: 790: if (tex_fprintf(s_etat_processus, fichier_impression, 791: "\\end{array}\\right)\n") < 0) 792: { 793: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 794: return; 795: } 796: } 797: 798: /* 799: * Matrice d'entiers 800: */ 801: 802: else if ((*s_objet).type == MIN) 803: { 804: if (tex_fprintf(s_etat_processus, fichier_impression, 805: "\\left(\\begin{array}{") < 0) 806: { 807: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 808: return; 809: } 810: 811: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)) 812: .nombre_colonnes; i++) 813: { 814: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0) 815: { 816: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 817: return; 818: } 819: } 820: 821: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0) 822: { 823: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 824: return; 825: } 826: 827: if ((s_objet_elementaire.objet = (integer8 *) malloc(sizeof(integer8))) 828: == NULL) 829: { 830: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 831: return; 832: } 833: 834: s_objet_elementaire.type = INT; 835: 836: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes; 837: i++) 838: { 839: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet)) 840: .nombre_colonnes; j++) 841: { 842: (*((integer8 *) (s_objet_elementaire.objet))) = 843: ((integer8 **) (*((struct_matrice *) 844: (*s_objet).objet)).tableau)[i][j]; 845: 846: formateur_elementaire_tex(s_etat_processus, fichier_impression, 847: &s_objet_elementaire, environnement); 848: 849: if (j == ((*((struct_matrice *) (*s_objet).objet)) 850: .nombre_colonnes - 1)) 851: { 852: if (tex_fprintf(s_etat_processus, fichier_impression, 853: " \\\\\n") < 0) 854: { 855: (*s_etat_processus).erreur_systeme = 856: d_es_erreur_fichier; 857: return; 858: } 859: } 860: else 861: { 862: if (tex_fprintf(s_etat_processus, fichier_impression, 863: " & ") < 0) 864: { 865: (*s_etat_processus).erreur_systeme = 866: d_es_erreur_fichier; 867: return; 868: } 869: } 870: } 871: } 872: 873: free(s_objet_elementaire.objet); 874: 875: if (tex_fprintf(s_etat_processus, fichier_impression, 876: "\\end{array}\\right)\n") < 0) 877: { 878: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 879: return; 880: } 881: } 882: 883: /* 884: * Matrice de réels 885: */ 886: 887: else if ((*s_objet).type == MRL) 888: { 889: if (tex_fprintf(s_etat_processus, fichier_impression, 890: "\\left(\\begin{array}{") < 0) 891: { 892: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 893: return; 894: } 895: 896: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)) 897: .nombre_colonnes; i++) 898: { 899: if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0) 900: { 901: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 902: return; 903: } 904: } 905: 906: if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0) 907: { 908: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 909: return; 910: } 911: 912: if ((s_objet_elementaire.objet = (real8 *) malloc(sizeof(real8))) 913: == NULL) 914: { 915: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 916: return; 917: } 918: 919: s_objet_elementaire.type = REL; 920: 921: for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes; 922: i++) 923: { 924: for(j = 0; j < (*((struct_matrice *) (*s_objet).objet)) 925: .nombre_colonnes; j++) 926: { 927: (*((real8 *) (s_objet_elementaire.objet))) = 928: ((real8 **) (*((struct_matrice *) 929: (*s_objet).objet)).tableau)[i][j]; 930: 931: formateur_elementaire_tex(s_etat_processus, fichier_impression, 932: &s_objet_elementaire, environnement); 933: 934: if (j == ((*((struct_matrice *) (*s_objet).objet)) 935: .nombre_colonnes - 1)) 936: { 937: if (tex_fprintf(s_etat_processus, fichier_impression, 938: " \\\\\n") < 0) 939: { 940: (*s_etat_processus).erreur_systeme = 941: d_es_erreur_fichier; 942: return; 943: } 944: } 945: else 946: { 947: if (tex_fprintf(s_etat_processus, fichier_impression, 948: " & ") < 0) 949: { 950: (*s_etat_processus).erreur_systeme = 951: d_es_erreur_fichier; 952: return; 953: } 954: } 955: } 956: } 957: 958: free(s_objet_elementaire.objet); 959: 960: if (tex_fprintf(s_etat_processus, fichier_impression, 961: "\\end{array}\\right)\n") < 0) 962: { 963: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 964: return; 965: } 966: } 967: 968: /* 969: * Réel 970: */ 971: 972: else if ((*s_objet).type == REL) 973: { 974: if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL) 975: { 976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 977: return; 978: } 979: 980: for(i = 0; i < strlen(ligne); i++) 981: { 982: switch(ligne[i]) 983: { 984: case 'e' : 985: case 'E' : 986: { 987: if ((tampon = (unsigned char *) malloc((strlen(ligne) 988: + 12) * sizeof(unsigned char))) == NULL) 989: { 990: (*s_etat_processus).erreur_systeme = 991: d_es_allocation_memoire; 992: return; 993: } 994: 995: strncpy(tampon, ligne, i); 996: strcpy(&(tampon[i]), "\\times 10^{"); 997: strcat(tampon, &(ligne[++i])); 998: strcat(tampon, "}"); 999: i += 10; 1000: 1001: free(ligne); 1002: ligne = tampon; 1003: 1004: break; 1005: } 1006: 1007: case ',' : 1008: { 1009: if ((tampon = (unsigned char *) malloc((strlen(ligne) 1010: + 3) * sizeof(unsigned char))) == NULL) 1011: { 1012: (*s_etat_processus).erreur_systeme = 1013: d_es_allocation_memoire; 1014: return; 1015: } 1016: 1017: strncpy(tampon, ligne, ++i); 1018: strcpy(&(tampon[i]), "\\!"); 1019: strcat(tampon, &(ligne[i])); 1020: i += 2; 1021: 1022: free(ligne); 1023: ligne = tampon; 1024: 1025: break; 1026: } 1027: } 1028: } 1029: 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 < (strlen((unsigned char *) 1543: (*s_sous_objet_1).objet) - 1); i++) 1544: { 1545: if (((unsigned char *) (*s_sous_objet_1) 1546: .objet)[i] == '{') 1547: { 1548: niveau++; 1549: } 1550: else if (((unsigned char *) 1551: (*s_sous_objet_1).objet)[i] == '}') 1552: { 1553: niveau--; 1554: 1555: if (niveau == 0) 1556: { 1557: break; 1558: } 1559: } 1560: } 1561: 1562: if (niveau == 0) 1563: { 1564: sprintf((unsigned char *) (*s_sous_objet_1) 1565: .objet, "%s", &(((unsigned char *) 1566: (*s_sous_objet_1).objet)[1])); 1567: ((unsigned char *) (*s_sous_objet_1).objet) 1568: [strlen((unsigned char *) 1569: (*s_sous_objet_1).objet) - 1] = 1570: d_code_fin_chaine; 1571: } 1572: } 1573: 1574: chaine_parametre = (unsigned char *) 1575: (*s_sous_objet_1).objet; 1576: conversion_element_tex(&chaine_parametre, "^"); 1577: 1578: if ((*s_sous_objet_1).objet == NULL) 1579: { 1580: (*s_etat_processus).erreur_systeme = 1581: d_es_allocation_memoire; 1582: return; 1583: } 1584: 1585: if (((*s_sous_objet).objet = (void *) 1586: malloc((strlen( 1587: (unsigned char *) (*s_sous_objet_1).objet) + 1588: strlen((unsigned char *) 1589: (*s_sous_objet_2).objet) + 8) * 1590: sizeof(unsigned char))) == NULL) 1591: { 1592: return; 1593: } 1594: 1595: sprintf((unsigned char *) (*s_sous_objet).objet, 1596: "{{%s}^{%s}}", 1597: (unsigned char *) (*s_sous_objet_1).objet, 1598: (unsigned char *) (*s_sous_objet_2).objet); 1599: } 1600: else if (multiplication == d_vrai) 1601: { 1602: chaine_parametre = (unsigned char *) 1603: (*s_sous_objet_1).objet; 1604: conversion_element_tex(&chaine_parametre, 1605: (*((struct_fonction *) 1606: (*(*l_element_courant).donnee).objet)) 1607: .nom_fonction); 1608: 1609: if ((*s_sous_objet_1).objet == NULL) 1610: { 1611: (*s_etat_processus).erreur_systeme = 1612: d_es_allocation_memoire; 1613: return; 1614: } 1615: 1616: chaine_parametre = (unsigned char *) 1617: (*s_sous_objet_2).objet; 1618: conversion_element_tex(&chaine_parametre, 1619: (*((struct_fonction *) 1620: (*(*l_element_courant).donnee).objet)) 1621: .nom_fonction); 1622: 1623: if ((*s_sous_objet_2).objet == NULL) 1624: { 1625: (*s_etat_processus).erreur_systeme = 1626: d_es_allocation_memoire; 1627: return; 1628: } 1629: 1630: if ((((unsigned char *) (*s_sous_objet_2) 1631: .objet)[0] == '+') || (((unsigned char *) 1632: (*s_sous_objet_2).objet)[0] == '-')) 1633: { 1634: if (((*s_sous_objet).objet = (void *) 1635: malloc((strlen((unsigned char *) 1636: (*s_sous_objet_1).objet) + 1637: strlen((*((struct_fonction *) 1638: (*(*l_element_courant).donnee).objet)) 1639: .nom_fonction) + 1640: strlen((unsigned char *) 1641: (*s_sous_objet_2).objet) + 14) * 1642: sizeof(unsigned char))) == NULL) 1643: { 1644: return; 1645: } 1646: 1647: sprintf((unsigned char *) (*s_sous_objet).objet, 1648: "%s%s\\left(%s\\right)", 1649: (unsigned char *) (*s_sous_objet_1) 1650: .objet, (*((struct_fonction *) 1651: (*(*l_element_courant).donnee).objet)) 1652: .nom_fonction, (unsigned char *) 1653: (*s_sous_objet_2).objet); 1654: } 1655: else 1656: { 1657: if (((*s_sous_objet).objet = (void *) 1658: malloc((strlen((unsigned char *) 1659: (*s_sous_objet_1).objet) + 1660: strlen((*((struct_fonction *) 1661: (*(*l_element_courant).donnee).objet)) 1662: .nom_fonction) + 1663: strlen((unsigned char *) 1664: (*s_sous_objet_2).objet) + 1) * 1665: sizeof(unsigned char))) == NULL) 1666: { 1667: return; 1668: } 1669: 1670: sprintf((unsigned char *) (*s_sous_objet).objet, 1671: "%s%s%s", (unsigned char *) 1672: (*s_sous_objet_1) 1673: .objet, (*((struct_fonction *) 1674: (*(*l_element_courant).donnee).objet)) 1675: .nom_fonction, (unsigned char *) 1676: (*s_sous_objet_2).objet); 1677: } 1678: } 1679: else 1680: { 1681: if ((strcmp((*((struct_fonction *) 1682: (*(*l_element_courant).donnee).objet)) 1683: .nom_fonction, "<") != 0) && 1684: (strcmp((*((struct_fonction *) 1685: (*(*l_element_courant).donnee).objet)) 1686: .nom_fonction, ">") != 0) && 1687: (strcmp((*((struct_fonction *) 1688: (*(*l_element_courant).donnee).objet)) 1689: .nom_fonction, "=") != 0) && 1690: (strcmp((*((struct_fonction *) 1691: (*(*l_element_courant).donnee).objet)) 1692: .nom_fonction, "==") != 0) && 1693: (strcmp((*((struct_fonction *) 1694: (*(*l_element_courant).donnee).objet)) 1695: .nom_fonction, "\\geqslant ") != 0) && 1696: (strcmp((*((struct_fonction *) 1697: (*(*l_element_courant).donnee).objet)) 1698: .nom_fonction, "\\leqslant ") != 0)) 1699: { 1700: chaine_parametre = (unsigned char *) 1701: (*s_sous_objet_1).objet; 1702: conversion_element_tex(&chaine_parametre, 1703: (*((struct_fonction *) 1704: (*(*l_element_courant).donnee).objet)) 1705: .nom_fonction); 1706: 1707: if ((*s_sous_objet_1).objet == NULL) 1708: { 1709: (*s_etat_processus).erreur_systeme = 1710: d_es_allocation_memoire; 1711: return; 1712: } 1713: 1714: chaine_parametre = (unsigned char *) 1715: (*s_sous_objet_2).objet; 1716: conversion_element_tex(&chaine_parametre, 1717: (*((struct_fonction *) 1718: (*(*l_element_courant).donnee).objet)) 1719: .nom_fonction); 1720: 1721: if ((*s_sous_objet_2).objet == NULL) 1722: { 1723: (*s_etat_processus).erreur_systeme = 1724: d_es_allocation_memoire; 1725: return; 1726: } 1727: } 1728: 1729: if ((((unsigned char *) (*s_sous_objet_2) 1730: .objet)[0] == '+') || (((unsigned char *) 1731: (*s_sous_objet_2).objet)[0] == '-')) 1732: { 1733: if (((*s_sous_objet).objet = (void *) 1734: malloc((strlen((unsigned char *) 1735: (*s_sous_objet_1).objet) + 1736: strlen((*((struct_fonction *) 1737: (*(*l_element_courant).donnee).objet)) 1738: .nom_fonction) + 1739: strlen((unsigned char *) 1740: (*s_sous_objet_2).objet) + 18) * 1741: sizeof(unsigned char))) == NULL) 1742: { 1743: return; 1744: } 1745: 1746: sprintf((unsigned char *) (*s_sous_objet).objet, 1747: "{%s}%s{\\left(%s\\right)}", 1748: (unsigned char *) (*s_sous_objet_1) 1749: .objet, (*((struct_fonction *) 1750: (*(*l_element_courant).donnee).objet)) 1751: .nom_fonction, (unsigned char *) 1752: (*s_sous_objet_2).objet); 1753: } 1754: else 1755: { 1756: if (((*s_sous_objet).objet = (void *) 1757: malloc((strlen((unsigned char *) 1758: (*s_sous_objet_1).objet) + 1759: strlen((*((struct_fonction *) 1760: (*(*l_element_courant).donnee).objet)) 1761: .nom_fonction) + 1762: strlen((unsigned char *) 1763: (*s_sous_objet_2).objet) + 5) * 1764: sizeof(unsigned char))) == NULL) 1765: { 1766: return; 1767: } 1768: 1769: sprintf((unsigned char *) (*s_sous_objet).objet, 1770: "{%s}%s{%s}", (unsigned char *) 1771: (*s_sous_objet_1) 1772: .objet, (*((struct_fonction *) 1773: (*(*l_element_courant).donnee).objet)) 1774: .nom_fonction, (unsigned char *) 1775: (*s_sous_objet_2).objet); 1776: } 1777: } 1778: 1779: liberation(s_etat_processus, s_sous_objet_1); 1780: liberation(s_etat_processus, s_sous_objet_2); 1781: 1782: if (empilement(s_etat_processus, &((*s_etat_processus) 1783: .l_base_pile), s_sous_objet) == d_erreur) 1784: { 1785: return; 1786: } 1787: } 1788: else if (strcmp((*((struct_fonction *) 1789: (*(*l_element_courant).donnee).objet)).nom_fonction, 1790: "NOT") == 0) 1791: { 1792: if (depilement(s_etat_processus, &((*s_etat_processus) 1793: .l_base_pile), &s_sous_objet_1) == d_erreur) 1794: { 1795: return; 1796: } 1797: 1798: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1799: == NULL) 1800: { 1801: return; 1802: } 1803: 1804: if (((*s_sous_objet).objet = (unsigned char *) malloc( 1805: (strlen((unsigned char *) (*s_sous_objet_1) 1806: .objet) + 25) * sizeof(unsigned char))) == 1807: NULL) 1808: { 1809: return; 1810: } 1811: 1812: sprintf((unsigned char *) (*s_sous_objet).objet, 1813: "\\text{%s}\\left(%s\\right)", 1814: (*((struct_fonction *) 1815: (*(*l_element_courant).donnee).objet)) 1816: .nom_fonction, (unsigned char *) 1817: (*s_sous_objet_1).objet); 1818: 1819: liberation(s_etat_processus, s_sous_objet_1); 1820: 1821: if (empilement(s_etat_processus, &((*s_etat_processus) 1822: .l_base_pile), s_sous_objet) == d_erreur) 1823: { 1824: return; 1825: } 1826: } 1827: else if ((strcmp((*((struct_fonction *) 1828: (*(*l_element_courant).donnee).objet)).nom_fonction, 1829: "OR") == 0) || (strcmp((*((struct_fonction *) 1830: (*(*l_element_courant).donnee).objet)).nom_fonction, 1831: "XOR") == 0) || (strcmp((*((struct_fonction *) 1832: (*(*l_element_courant).donnee).objet)).nom_fonction, 1833: "AND") == 0)) 1834: { 1835: if (depilement(s_etat_processus, &((*s_etat_processus) 1836: .l_base_pile), &s_sous_objet_2) == d_erreur) 1837: { 1838: return; 1839: } 1840: 1841: if (depilement(s_etat_processus, &((*s_etat_processus) 1842: .l_base_pile), &s_sous_objet_1) == d_erreur) 1843: { 1844: return; 1845: } 1846: 1847: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1848: == NULL) 1849: { 1850: return; 1851: } 1852: 1853: if (((*s_sous_objet).objet = (void *) malloc((strlen( 1854: (unsigned char *) (*s_sous_objet_1).objet) + 1855: strlen((*((struct_fonction *) 1856: (*(*l_element_courant).donnee).objet)) 1857: .nom_fonction) + strlen((unsigned char *) 1858: (*s_sous_objet_2).objet) + 10) * 1859: sizeof(unsigned char))) == NULL) 1860: { 1861: return; 1862: } 1863: 1864: sprintf((unsigned char *) (*s_sous_objet).objet, 1865: "%s \\text{%s} %s", (unsigned char *) 1866: (*s_sous_objet_1) 1867: .objet, (*((struct_fonction *) 1868: (*(*l_element_courant).donnee).objet)) 1869: .nom_fonction, (unsigned char *) 1870: (*s_sous_objet_2).objet); 1871: 1872: liberation(s_etat_processus, s_sous_objet_1); 1873: liberation(s_etat_processus, s_sous_objet_2); 1874: 1875: if (empilement(s_etat_processus, &((*s_etat_processus) 1876: .l_base_pile), s_sous_objet) == d_erreur) 1877: { 1878: return; 1879: } 1880: } 1881: else 1882: { 1883: nombre_arguments = (*((struct_fonction *) 1884: (*(*l_element_courant).donnee).objet)) 1885: .nombre_arguments; 1886: 1887: if ((chaine = (unsigned char *) 1888: malloc(sizeof(unsigned char))) == NULL) 1889: { 1890: return; 1891: } 1892: 1893: chaine[0] = d_code_fin_chaine; 1894: 1895: for(i = 0; i < nombre_arguments; i++) 1896: { 1897: if ((nombre_arguments - i) > 1) 1898: { 1899: l_liste1 = (*s_etat_processus).l_base_pile; 1900: 1901: for(j = 2; j < (nombre_arguments - i); j++) 1902: { 1903: l_liste1 = (*l_liste1).suivant; 1904: } 1905: 1906: l_liste2 = (*l_liste1).suivant; 1907: (*l_liste1).suivant = (*l_liste2).suivant; 1908: (*l_liste2).suivant = (*s_etat_processus) 1909: .l_base_pile; 1910: (*s_etat_processus).l_base_pile = l_liste2; 1911: } 1912: 1913: if (depilement(s_etat_processus, 1914: &((*s_etat_processus).l_base_pile), 1915: &s_sous_objet) == d_erreur) 1916: { 1917: return; 1918: } 1919: 1920: chaine_sauvegarde = chaine; 1921: 1922: if (strlen(chaine_sauvegarde) == 0) 1923: { 1924: if ((chaine = (unsigned char *) malloc((strlen( 1925: (unsigned char *) (*s_sous_objet).objet) 1926: + 1) * sizeof(unsigned char))) == NULL) 1927: { 1928: return; 1929: } 1930: 1931: sprintf(chaine, "%s", (unsigned char *) 1932: (*s_sous_objet).objet); 1933: } 1934: else 1935: { 1936: if ((chaine = (unsigned char *) malloc((strlen( 1937: chaine_sauvegarde) + 1 + strlen( 1938: (unsigned char *) (*s_sous_objet).objet) 1939: + 1) * sizeof(unsigned char))) == NULL) 1940: { 1941: return; 1942: } 1943: 1944: sprintf(chaine, "%s,%s", chaine_sauvegarde, 1945: (unsigned char *) (*s_sous_objet) 1946: .objet); 1947: } 1948: 1949: free(chaine_sauvegarde); 1950: liberation(s_etat_processus, s_sous_objet); 1951: } 1952: 1953: chaine_sauvegarde = chaine; 1954: 1955: if ((chaine = (unsigned char *) malloc((strlen( 1956: (*((struct_fonction *) (*(*l_element_courant) 1957: .donnee).objet)).nom_fonction) + 20 + 1958: strlen(chaine_sauvegarde) + 1) * 1959: sizeof(unsigned char))) == NULL) 1960: { 1961: return; 1962: } 1963: 1964: sprintf(chaine, "\\text{%s}\\left(%s\\right)", 1965: (*((struct_fonction *) 1966: (*(*l_element_courant).donnee).objet)) 1967: .nom_fonction, chaine_sauvegarde); 1968: free(chaine_sauvegarde); 1969: 1970: instruction_courante = (*s_etat_processus) 1971: .instruction_courante; 1972: test_instruction = (*s_etat_processus).test_instruction; 1973: instruction_valide = (*s_etat_processus) 1974: .instruction_valide; 1975: 1976: (*s_etat_processus).test_instruction = 'Y'; 1977: (*s_etat_processus).instruction_courante = 1978: (*((struct_fonction *) (*(*l_element_courant) 1979: .donnee).objet)).nom_fonction; 1980: 1981: analyse(s_etat_processus, NULL); 1982: 1983: if ((*s_etat_processus).instruction_valide == 'Y') 1984: { 1985: for(i = 0; i < strlen(chaine); i++) 1986: { 1987: if ((chaine[i] >= 'A') && (chaine[i] <= 'Z')) 1988: { 1989: chaine[i] += ('a' - 'A'); 1990: } 1991: } 1992: } 1993: 1994: (*s_etat_processus).instruction_courante = 1995: instruction_courante; 1996: (*s_etat_processus).test_instruction = 1997: instruction_valide; 1998: (*s_etat_processus).instruction_valide = 1999: instruction_valide; 2000: 2001: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 2002: == NULL) 2003: { 2004: return; 2005: } 2006: 2007: (*s_sous_objet).objet = (void *) chaine; 2008: 2009: if (empilement(s_etat_processus, &((*s_etat_processus) 2010: .l_base_pile), s_sous_objet) == d_erreur) 2011: { 2012: return; 2013: } 2014: } 2015: } 2016: } 2017: else 2018: { 2019: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 2020: == NULL) 2021: { 2022: return; 2023: } 2024: 2025: if (((*s_sous_objet).objet = (void *) formateur( 2026: s_etat_processus, 0, 2027: (*l_element_courant).donnee)) == NULL) 2028: { 2029: return; 2030: } 2031: 2032: if ((*(*l_element_courant).donnee).type == NOM) 2033: { 2034: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet; 2035: 2036: if (((*s_sous_objet).objet = malloc((strlen( 2037: chaine_sauvegarde) - 1) * 2038: sizeof(unsigned char))) == NULL) 2039: { 2040: return; 2041: } 2042: 2043: ptrl = chaine_sauvegarde; 2044: ptre = (unsigned char *) (*s_sous_objet).objet; 2045: 2046: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0; 2047: i--, *ptre++ = *ptrl++); 2048: 2049: (*ptre) = d_code_fin_chaine; 2050: 2051: free(chaine_sauvegarde); 2052: 2053: chaine_majuscule = conversion_majuscule((*((struct_nom *) 2054: (*(*l_element_courant).donnee).objet)).nom); 2055: 2056: if (strcmp(chaine_majuscule, "PI") == 0) 2057: { 2058: free((unsigned char *) (*s_sous_objet).objet); 2059: 2060: if (((*s_sous_objet).objet = 2061: malloc(5 * sizeof(unsigned char))) == NULL) 2062: { 2063: (*s_etat_processus).erreur_systeme = 2064: d_es_allocation_memoire; 2065: return; 2066: } 2067: 2068: strcpy((unsigned char *) (*s_sous_objet).objet, 2069: "\\pi "); 2070: } 2071: else if (strcmp((*((struct_nom *) (*(*l_element_courant) 2072: .donnee).objet)).nom, "i") == 0) 2073: { 2074: free((unsigned char *) (*s_sous_objet).objet); 2075: 2076: if (((*s_sous_objet).objet = 2077: malloc(9 * sizeof(unsigned char))) == NULL) 2078: { 2079: (*s_etat_processus).erreur_systeme = 2080: d_es_allocation_memoire; 2081: return; 2082: } 2083: 2084: strcpy((unsigned char *) (*s_sous_objet).objet, 2085: "\\text{i}"); 2086: } 2087: else if (strcmp((*((struct_nom *) (*(*l_element_courant) 2088: .donnee).objet)).nom, "e") == 0) 2089: { 2090: free((unsigned char *) (*s_sous_objet).objet); 2091: 2092: if (((*s_sous_objet).objet = 2093: malloc(9 * sizeof(unsigned char))) == NULL) 2094: { 2095: (*s_etat_processus).erreur_systeme = 2096: d_es_allocation_memoire; 2097: return; 2098: } 2099: 2100: strcpy((unsigned char *) (*s_sous_objet).objet, 2101: "\\text{e}"); 2102: } 2103: 2104: free(chaine_majuscule); 2105: } 2106: 2107: if (empilement(s_etat_processus, &((*s_etat_processus) 2108: .l_base_pile), s_sous_objet) == d_erreur) 2109: { 2110: return; 2111: } 2112: } 2113: 2114: l_element_courant = (*l_element_courant).suivant; 2115: } 2116: 2117: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2118: &s_sous_objet) == d_erreur) 2119: { 2120: return; 2121: } 2122: 2123: if (tex_fprintf(s_etat_processus, fichier_impression, "%s", 2124: (unsigned char *) (*s_sous_objet).objet) < 0) 2125: { 2126: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2127: return; 2128: } 2129: 2130: liberation(s_etat_processus, s_sous_objet); 2131: liberation(s_etat_processus, s_copie_objet); 2132: } 2133: 2134: return; 2135: } 2136: 2137: 2138: /* 2139: ================================================================================ 2140: Echappement des caractères spéciaux de TeX 2141: ================================================================================ 2142: Entrées : ligne d'instructions TeX 2143: -------------------------------------------------------------------------------- 2144: Sorties : ligne corrigée 2145: -------------------------------------------------------------------------------- 2146: Effets de bord : néant 2147: ================================================================================ 2148: */ 2149: 2150: void 2151: correction_formateur_tex(struct_processus *s_etat_processus, 2152: unsigned char **ligne) 2153: { 2154: logical1 mode_mathematique; 2155: 2156: unsigned char *tampon; 2157: unsigned long i; 2158: 2159: mode_mathematique = d_faux; 2160: 2161: for(i = 0; i < strlen((*ligne)); i++) 2162: { 2163: switch((*ligne)[i]) 2164: { 2165: /* 2166: * Le caractère '_' est autorisé tel quel dans une expression 2167: * mathématique. Il est protégé en mode normal. 2168: */ 2169: 2170: case '$' : 2171: { 2172: mode_mathematique = (mode_mathematique == d_faux) 2173: ? d_vrai : d_faux; 2174: 2175: if ((*ligne)[i + 1] == '$') 2176: { 2177: i++; 2178: } 2179: 2180: break; 2181: } 2182: 2183: /* 2184: * Les '$', '{' et '}' ne sont pas convertis pour pouvoir écrire 2185: * du TeX dans le texte. 2186: */ 2187: 2188: case '#' : 2189: case '_' : 2190: { 2191: if (mode_mathematique == d_vrai) 2192: { 2193: break; 2194: } 2195: } 2196: 2197: case '%' : 2198: case '&' : 2199: { 2200: if ((tampon = (unsigned char *) malloc((strlen((*ligne)) + 2) * 2201: sizeof(unsigned char))) == NULL) 2202: { 2203: (*s_etat_processus).erreur_systeme = 2204: d_es_allocation_memoire; 2205: return; 2206: } 2207: 2208: strncpy(tampon, (*ligne), i); 2209: strcpy(&(tampon[i]), "\\"); 2210: strcat(tampon, &((*ligne)[i++])); 2211: 2212: free((*ligne)); 2213: (*ligne) = tampon; 2214: 2215: break; 2216: } 2217: 2218: default : 2219: { 2220: break; 2221: } 2222: } 2223: } 2224: 2225: return; 2226: } 2227: 2228: 2229: /* 2230: ================================================================================ 2231: Fonction 'impression_tex' 2232: ================================================================================ 2233: Entrées : 2234: -------------------------------------------------------------------------------- 2235: Sorties : 2236: -------------------------------------------------------------------------------- 2237: Effets de bord : néant 2238: ================================================================================ 2239: */ 2240: 2241: void 2242: impression_tex(struct_processus *s_etat_processus) 2243: { 2244: file *fichier_impression; 2245: 2246: unsigned char *commande; 2247: unsigned char *executable_candidat; 2248: unsigned char *nom_fichier_aux; 2249: unsigned char *nom_fichier_dvi; 2250: unsigned char *nom_fichier_log; 2251: unsigned char *nom_fichier_tex; 2252: unsigned char *nom_fichier_ps; 2253: 2254: unsigned long longueur_nom_base; 2255: 2256: longueur_nom_base = strlen((*s_etat_processus).nom_fichier_impression); 2257: 2258: if ((nom_fichier_tex = malloc((longueur_nom_base + 6) * 2259: sizeof(unsigned char))) == NULL) 2260: { 2261: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2262: return; 2263: } 2264: 2265: if ((nom_fichier_log = malloc((longueur_nom_base + 6) * 2266: sizeof(unsigned char))) == NULL) 2267: { 2268: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2269: return; 2270: } 2271: 2272: if ((nom_fichier_aux = malloc((longueur_nom_base + 6) * 2273: sizeof(unsigned char))) == NULL) 2274: { 2275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2276: return; 2277: } 2278: 2279: if ((nom_fichier_dvi = malloc((longueur_nom_base + 6) * 2280: sizeof(unsigned char))) == NULL) 2281: { 2282: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2283: return; 2284: } 2285: 2286: if ((nom_fichier_ps = malloc((longueur_nom_base + 5) * 2287: sizeof(unsigned char))) == NULL) 2288: { 2289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2290: return; 2291: } 2292: 2293: strcpy(nom_fichier_tex, (*s_etat_processus).nom_fichier_impression) 2294: [longueur_nom_base - 4] = d_code_fin_chaine; 2295: strcat(nom_fichier_tex, ".conv.tex"); 2296: 2297: strcpy(nom_fichier_aux, (*s_etat_processus).nom_fichier_impression) 2298: [longueur_nom_base - 4] = d_code_fin_chaine; 2299: strcat(nom_fichier_aux, ".conv.aux"); 2300: 2301: strcpy(nom_fichier_log, (*s_etat_processus).nom_fichier_impression) 2302: [longueur_nom_base - 4] = d_code_fin_chaine; 2303: strcat(nom_fichier_log, ".conv.log"); 2304: 2305: strcpy(nom_fichier_dvi, (*s_etat_processus).nom_fichier_impression) 2306: [longueur_nom_base - 4] = d_code_fin_chaine; 2307: strcat(nom_fichier_dvi, ".conv.dvi"); 2308: 2309: strcpy(nom_fichier_ps, (*s_etat_processus).nom_fichier_impression) 2310: [longueur_nom_base - 4] = d_code_fin_chaine; 2311: strcat(nom_fichier_ps, ".conv.ps"); 2312: 2313: if ((fichier_impression = fopen((*s_etat_processus).nom_fichier_impression, 2314: "a")) == NULL) 2315: { 2316: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2317: return; 2318: } 2319: 2320: if (tex_fprintf(s_etat_processus, fichier_impression, 2321: "\\end{document}\n") < 0) 2322: { 2323: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2324: return; 2325: } 2326: 2327: if (fclose(fichier_impression) != 0) 2328: { 2329: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2330: return; 2331: } 2332: 2333: if ((*s_etat_processus).rpl_home == NULL) 2334: { 2335: if (alsprintf(&commande, ds_tex_commande, 2336: d_exec_path, d_exec_path, d_exec_path, 2337: (*s_etat_processus).nom_fichier_impression, 2338: d_exec_path, d_exec_path, 2339: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex, 2340: (*s_etat_processus).chemin_fichiers_temporaires, 2341: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0) 2342: { 2343: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2344: return; 2345: } 2346: 2347: if (alsprintf(&executable_candidat, "%s/bin/rpliconv", 2348: d_exec_path) < 0) 2349: { 2350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2351: return; 2352: } 2353: 2354: if (controle(s_etat_processus, executable_candidat, "md5", 2355: rpliconv_md5) != d_vrai) 2356: { 2357: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2358: return; 2359: } 2360: 2361: if (controle(s_etat_processus, executable_candidat, "sha1", 2362: rpliconv_sha1) != d_vrai) 2363: { 2364: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2365: return; 2366: } 2367: 2368: free(executable_candidat); 2369: 2370: if (alsprintf(&executable_candidat, "%s/bin/rplfile", 2371: d_exec_path) < 0) 2372: { 2373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2374: return; 2375: } 2376: 2377: if (controle(s_etat_processus, executable_candidat, "md5", 2378: rplfile_md5) != d_vrai) 2379: { 2380: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2381: return; 2382: } 2383: 2384: if (controle(s_etat_processus, executable_candidat, "sha1", 2385: rplfile_sha1) != d_vrai) 2386: { 2387: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2388: return; 2389: } 2390: 2391: free(executable_candidat); 2392: } 2393: else 2394: { 2395: if (alsprintf(&commande, ds_tex_commande, 2396: (*s_etat_processus).rpl_home, 2397: (*s_etat_processus).rpl_home, 2398: (*s_etat_processus).rpl_home, 2399: (*s_etat_processus).nom_fichier_impression, 2400: (*s_etat_processus).rpl_home, 2401: (*s_etat_processus).rpl_home, 2402: (*s_etat_processus).nom_fichier_impression, nom_fichier_tex, 2403: (*s_etat_processus).chemin_fichiers_temporaires, 2404: nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0) 2405: { 2406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2407: return; 2408: } 2409: 2410: if (alsprintf(&executable_candidat, "%s/bin/rpliconv", 2411: (*s_etat_processus).rpl_home) < 0) 2412: { 2413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2414: return; 2415: } 2416: 2417: if (controle(s_etat_processus, executable_candidat, "md5", 2418: rpliconv_md5) != d_vrai) 2419: { 2420: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2421: return; 2422: } 2423: 2424: if (controle(s_etat_processus, executable_candidat, "sha1", 2425: rpliconv_sha1) != d_vrai) 2426: { 2427: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2428: return; 2429: } 2430: 2431: free(executable_candidat); 2432: 2433: if (alsprintf(&executable_candidat, "%s/bin/rplfile", 2434: (*s_etat_processus).rpl_home) < 0) 2435: { 2436: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2437: return; 2438: } 2439: 2440: if (controle(s_etat_processus, executable_candidat, "md5", 2441: rplfile_md5) != d_vrai) 2442: { 2443: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2444: return; 2445: } 2446: 2447: if (controle(s_etat_processus, executable_candidat, "sha1", 2448: rplfile_sha1) != d_vrai) 2449: { 2450: (*s_etat_processus).erreur_systeme = d_es_somme_controle; 2451: return; 2452: } 2453: 2454: free(executable_candidat); 2455: } 2456: 2457: if (system(commande) != 0) 2458: { 2459: (*s_etat_processus).erreur_execution = d_ex_erreur_impression; 2460: free(commande); 2461: } 2462: else 2463: { 2464: free(commande); 2465: 2466: if (alsprintf(&commande, ds_tex_postscript, nom_fichier_ps) < 0) 2467: { 2468: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2469: return; 2470: } 2471: 2472: if (system(commande) != 0) 2473: { 2474: (*s_etat_processus).erreur_execution = d_ex_erreur_impression; 2475: } 2476: 2477: free(commande); 2478: 2479: if (destruction_fichier(nom_fichier_ps) == d_erreur) 2480: { 2481: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2482: return; 2483: } 2484: } 2485: 2486: if (destruction_fichier((*s_etat_processus).nom_fichier_impression) 2487: == d_erreur) 2488: { 2489: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2490: return; 2491: } 2492: 2493: free((*s_etat_processus).nom_fichier_impression); 2494: (*s_etat_processus).nom_fichier_impression = NULL; 2495: 2496: if (destruction_fichier(nom_fichier_tex) == 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_aux) == 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_dvi) == 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: if (destruction_fichier(nom_fichier_log) == d_erreur) 2533: { 2534: free(nom_fichier_aux); 2535: free(nom_fichier_log); 2536: free(nom_fichier_dvi); 2537: free(nom_fichier_tex); 2538: free(nom_fichier_ps); 2539: 2540: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 2541: return; 2542: } 2543: 2544: free(nom_fichier_aux); 2545: free(nom_fichier_log); 2546: free(nom_fichier_dvi); 2547: free(nom_fichier_tex); 2548: free(nom_fichier_ps); 2549: 2550: return; 2551: } 2552: 2553: 2554: /* 2555: ================================================================================ 2556: Conversion des éléments TeX par ajout si nécessaire de parenthèses 2557: ================================================================================ 2558: Entrées : 2559: -------------------------------------------------------------------------------- 2560: Sorties : 2561: -------------------------------------------------------------------------------- 2562: Effets de bord : néant 2563: ================================================================================ 2564: */ 2565: 2566: void 2567: conversion_element_tex(unsigned char **element, unsigned char *fonction) 2568: { 2569: unsigned char *chaine; 2570: unsigned char *element_courant; 2571: unsigned char *extrait; 2572: 2573: unsigned long debut_fonction; 2574: unsigned long i; 2575: unsigned long niveau; 2576: unsigned long nombre_passages_par_zero; 2577: 2578: element_courant = (*element); 2579: niveau = 0; 2580: nombre_passages_par_zero = 0; 2581: i = 1; 2582: debut_fonction = 1; 2583: 2584: while((*element_courant) != d_code_fin_chaine) 2585: { 2586: if ((*element_courant) == '{') 2587: { 2588: if (niveau == 0) 2589: { 2590: extrait = extraction_chaine((*element), debut_fonction, i - 1); 2591: 2592: if (strcmp(extrait, fonction) != 0) 2593: { 2594: nombre_passages_par_zero++; 2595: } 2596: 2597: free(extrait); 2598: } 2599: 2600: niveau++; 2601: } 2602: else if ((*element_courant) == '}') 2603: { 2604: debut_fonction = i + 1; 2605: niveau--; 2606: } 2607: 2608: element_courant++; 2609: i++; 2610: } 2611: 2612: if (nombre_passages_par_zero > 1) 2613: { 2614: chaine = (*element); 2615: 2616: if (((*element) = (unsigned char *) malloc((strlen(chaine) + 14) * 2617: sizeof(unsigned char))) == NULL) 2618: { 2619: return; 2620: } 2621: 2622: sprintf((*element), "\\left(%s\\right)", chaine); 2623: free(chaine); 2624: } 2625: 2626: return; 2627: } 2628: 2629: // vim: ts=4