Annotation of rpl/src/interface_tex.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interface_tex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src