Annotation of rpl/src/formateur_fichiers.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:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Routine de formation des données pour l'écriture dans les fichiers
! 29: ================================================================================
! 30: Entrées : structure sur l'état du processus et objet à afficher
! 31: Longueur est la précision requise et longueur_champ, le nombre maximal
! 32: de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)
! 33: Type = 'F/U'
! 34: --------------------------------------------------------------------------------
! 35: Sorties : chaine de caractères et longueur du tableau de caractères
! 36: --------------------------------------------------------------------------------
! 37: Effets de bord : néant
! 38: ================================================================================
! 39: */
! 40:
! 41: unsigned char *
! 42: formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
! 43: struct_objet *s_format, long longueur, long longueur_champ,
! 44: unsigned char format_sortie, unsigned char type,
! 45: long *longueur_effective, long *recursivite)
! 46: {
! 47: /*
! 48: * Traitement du format des fichiers formatés :
! 49: *
! 50: * { "standard*(*)" (format classique sans limitation)
! 51: * "standard*(Y)" (format classique limité à Y caractères)
! 52: * "fixed*X(*)" (format virgule fixe avec une partie
! 53: * fractionnaire composée de X chiffres,
! 54: * mais dont la longueur est limité par
! 55: * la précision de la représentation interne)
! 56: * "fixed*X(Y)" (idem, mais longueur totale inférieure ou égale à
! 57: * Y caractères)
! 58: * "scientific*X(*)"
! 59: * "scientific*X(Y)"
! 60: * "engineer*X(*)"
! 61: * "engineer*X(Y)"
! 62: * "binary*X(*)"
! 63: * "binary*X(Y)" (X est la base : 2, 8, 10, 16)
! 64: * "character*(*)"
! 65: * "character*(Y)" }
! 66: *
! 67: * Traitement du format des fichiers non formatés :
! 68: *
! 69: * { "integer*1", "integer*2", "integer*4", "integer*8",
! 70: * "real*4", "real*8", ["real*16",]
! 71: * "complex*8", "complex*16", ["complex*32",]
! 72: * "logical*1", "logical*2", "logical*4", logical*8",
! 73: * "character" }
! 74: */
! 75:
! 76: logical1 autorisation_parenthese;
! 77: logical1 format_degenere;
! 78: logical1 longueur_3bits;
! 79: logical1 longueur_6bits;
! 80: logical1 presence_signe;
! 81:
! 82: struct_liste_chainee *l_atome;
! 83: struct_liste_chainee *l_element_courant;
! 84: struct_liste_chainee *l_element_courant_format;
! 85: struct_liste_chainee *l_liste1;
! 86: struct_liste_chainee *l_liste2;
! 87:
! 88: struct_objet *s_sous_objet;
! 89: struct_objet *s_sous_objet_1;
! 90: struct_objet *s_sous_objet_2;
! 91: struct_objet *s_sous_objet_3;
! 92:
! 93: unsigned char base[1 + 1];
! 94: unsigned char *chaine;
! 95: unsigned char *chaine_fonction;
! 96: unsigned char *chaine_formatee;
! 97: unsigned char *chaine_tampon;
! 98: unsigned char *chaine_sauvegarde;
! 99: unsigned char *format_chaine;
! 100: unsigned char longueur_optimale;
! 101: unsigned char parametre_longueur;
! 102: unsigned char *ptre;
! 103: unsigned char *ptrl;
! 104: unsigned char tampon[64 + 1];
! 105:
! 106: unsigned long i;
! 107: unsigned long j;
! 108: unsigned long longueur_binaire;
! 109: unsigned long longueur_champ_final;
! 110: unsigned long nombre_arguments;
! 111: unsigned long nombre_arguments_fonction;
! 112: unsigned long nombre_colonnes;
! 113: unsigned long nombre_elements;
! 114: unsigned long nombre_lignes;
! 115:
! 116: integer8 longueur_liste;
! 117: integer8 longueur_entete;
! 118: integer8 longueur_objet;
! 119: integer8 longueur_totale;
! 120: integer8 masque_binaire;
! 121: integer8 position_1;
! 122: integer8 position_2;
! 123: integer8 position_3;
! 124:
! 125: long offset;
! 126:
! 127: (*recursivite)++;
! 128:
! 129: if (type == 'F')
! 130: {
! 131: /*
! 132: * Fichiers formatés
! 133: */
! 134:
! 135: chaine = NULL;
! 136: chaine_formatee = NULL;
! 137: chaine_sauvegarde = NULL;
! 138:
! 139: strcpy(base, " ");
! 140:
! 141: longueur_binaire = 0;
! 142: masque_binaire = 0;
! 143:
! 144: if ((*s_objet).type == ALG)
! 145: {
! 146:
! 147: /*
! 148: --------------------------------------------------------------------------------
! 149: Expression algébrique
! 150: --------------------------------------------------------------------------------
! 151: */
! 152:
! 153: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 154:
! 155: while(l_element_courant != NULL)
! 156: {
! 157: if ((*(*l_element_courant).donnee).type == FCT)
! 158: {
! 159: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
! 160: .donnee).objet)).nom_fonction, "<<") != 0) &&
! 161: (strcmp((*((struct_fonction *)
! 162: (*(*l_element_courant)
! 163: .donnee).objet)).nom_fonction, ">>") != 0))
! 164: {
! 165: if ((strcmp((*((struct_fonction *)
! 166: (*(*l_element_courant)
! 167: .donnee).objet)).nom_fonction, "+") == 0) ||
! 168: (strcmp((*((struct_fonction *)
! 169: (*(*l_element_courant).donnee).objet))
! 170: .nom_fonction, "-") == 0) || (strcmp(
! 171: (*((struct_fonction *) (*(*l_element_courant)
! 172: .donnee).objet)).nom_fonction, "*") == 0) ||
! 173: (strcmp((*((struct_fonction *)
! 174: (*(*l_element_courant).donnee).objet))
! 175: .nom_fonction,
! 176: "/") == 0) || (strcmp((*((struct_fonction *)
! 177: (*(*l_element_courant).donnee).objet))
! 178: .nom_fonction,
! 179: "^") == 0) || (strcmp((*((struct_fonction *)
! 180: (*(*l_element_courant).donnee).objet))
! 181: .nom_fonction,
! 182: "<") == 0) || (strcmp((*((struct_fonction *)
! 183: (*(*l_element_courant).donnee).objet))
! 184: .nom_fonction,
! 185: ">") == 0) || (strcmp((*((struct_fonction *)
! 186: (*(*l_element_courant).donnee).objet))
! 187: .nom_fonction,
! 188: "==") == 0) || (strcmp((*((struct_fonction *)
! 189: (*(*l_element_courant).donnee).objet))
! 190: .nom_fonction,
! 191: "<>") == 0) || (strcmp((*((struct_fonction *)
! 192: (*(*l_element_courant).donnee).objet))
! 193: .nom_fonction,
! 194: "<=") == 0) || (strcmp((*((struct_fonction *)
! 195: (*(*l_element_courant).donnee).objet))
! 196: .nom_fonction,
! 197: "=<") == 0) || (strcmp((*((struct_fonction *)
! 198: (*(*l_element_courant).donnee).objet))
! 199: .nom_fonction,
! 200: ">=") == 0) || (strcmp((*((struct_fonction *)
! 201: (*(*l_element_courant).donnee).objet))
! 202: .nom_fonction,
! 203: "=>") == 0))
! 204: {
! 205: if (depilement(s_etat_processus,
! 206: &((*s_etat_processus)
! 207: .l_base_pile), &s_sous_objet_2) == d_erreur)
! 208: {
! 209: return(NULL);
! 210: }
! 211:
! 212: chaine_sauvegarde = (*s_etat_processus)
! 213: .instruction_courante;
! 214:
! 215: if (((*s_etat_processus).instruction_courante =
! 216: (unsigned char *) malloc((strlen(
! 217: (unsigned char *) (*s_sous_objet_2).objet)
! 218: + 2 + 1) * sizeof(unsigned char))) == NULL)
! 219: {
! 220: (*s_etat_processus).instruction_courante =
! 221: chaine_sauvegarde;
! 222: (*s_etat_processus).erreur_systeme =
! 223: d_es_allocation_memoire;
! 224: return(NULL);
! 225: }
! 226:
! 227: sprintf((*s_etat_processus).instruction_courante,
! 228: "'%s'", (unsigned char *)
! 229: (*s_sous_objet_2).objet);
! 230:
! 231: presence_signe = (((*s_etat_processus)
! 232: .instruction_courante[1] == '+')
! 233: || ((*s_etat_processus)
! 234: .instruction_courante[1]
! 235: == '-')) ? d_vrai : d_faux;
! 236:
! 237: recherche_type(s_etat_processus);
! 238:
! 239: if ((*s_etat_processus).erreur_execution != d_ex)
! 240: {
! 241: // Aucune erreur ne peut être renvoyée.
! 242:
! 243: return(NULL);
! 244: }
! 245:
! 246: if (depilement(s_etat_processus,
! 247: &((*s_etat_processus)
! 248: .l_base_pile), &s_sous_objet_3) == d_erreur)
! 249: {
! 250: return(NULL);
! 251: }
! 252:
! 253: free((*s_etat_processus).instruction_courante);
! 254:
! 255: (*s_etat_processus).instruction_courante =
! 256: chaine_sauvegarde;
! 257:
! 258: autorisation_parenthese = d_faux;
! 259:
! 260: if ((*s_sous_objet_3).type == ALG)
! 261: {
! 262: l_atome = (struct_liste_chainee *)
! 263: (*s_sous_objet_3).objet;
! 264: chaine_fonction = "";
! 265: nombre_arguments_fonction = 0;
! 266:
! 267: while(l_atome != NULL)
! 268: {
! 269: if ((*(*l_atome).donnee).type == FCT)
! 270: {
! 271: if (strcmp((*((struct_fonction *)
! 272: (*(*l_atome).donnee).objet))
! 273: .nom_fonction, ">>") != 0)
! 274: {
! 275: chaine_fonction =
! 276: (*((struct_fonction *)
! 277: (*(*l_atome).donnee).objet))
! 278: .nom_fonction;
! 279: nombre_arguments_fonction =
! 280: (*((struct_fonction *)
! 281: (*(*l_atome).donnee).objet))
! 282: .nombre_arguments;
! 283: }
! 284: }
! 285:
! 286: l_atome = (*l_atome).suivant;
! 287: }
! 288:
! 289: if (strcmp((*((struct_fonction *)
! 290: (*(*l_element_courant).donnee).objet))
! 291: .nom_fonction, "+") == 0)
! 292: {
! 293: if ((strcmp(chaine_fonction, "AND") == 0) ||
! 294: (strcmp(chaine_fonction, "XOR") ==
! 295: 0) || (strcmp(chaine_fonction, "OR")
! 296: == 0))
! 297: {
! 298: autorisation_parenthese = d_vrai;
! 299: }
! 300: }
! 301: else if (strcmp((*((struct_fonction *)
! 302: (*(*l_element_courant).donnee).objet))
! 303: .nom_fonction, "-") == 0)
! 304: {
! 305: if (nombre_arguments_fonction != 0)
! 306: {
! 307: autorisation_parenthese = d_faux;
! 308: }
! 309: else
! 310: {
! 311: autorisation_parenthese = d_vrai;
! 312: }
! 313: }
! 314: else if (strcmp((*((struct_fonction *)
! 315: (*(*l_element_courant).donnee).objet))
! 316: .nom_fonction, "*") == 0)
! 317: {
! 318: if ((strcmp(chaine_fonction, "+") == 0) ||
! 319: (strcmp(chaine_fonction, "-") == 0)
! 320: || (strcmp(chaine_fonction, "AND")
! 321: == 0) || (strcmp(chaine_fonction,
! 322: "XOR") == 0) || (strcmp(
! 323: chaine_fonction, "OR") == 0))
! 324: {
! 325: autorisation_parenthese = d_vrai;
! 326: }
! 327: }
! 328: else if (strcmp((*((struct_fonction *)
! 329: (*(*l_element_courant).donnee).objet))
! 330: .nom_fonction, "/") == 0)
! 331: {
! 332: if (nombre_arguments_fonction != 0)
! 333: {
! 334: autorisation_parenthese = d_faux;
! 335: }
! 336: else
! 337: {
! 338: autorisation_parenthese = d_vrai;
! 339: }
! 340: }
! 341: else if ((strcmp((*((struct_fonction *)
! 342: (*(*l_element_courant).donnee).objet))
! 343: .nom_fonction, "^") == 0))
! 344: {
! 345: if (nombre_arguments_fonction != 0)
! 346: {
! 347: autorisation_parenthese = d_faux;
! 348: }
! 349: else
! 350: {
! 351: autorisation_parenthese = d_vrai;
! 352: }
! 353: }
! 354: }
! 355:
! 356: if ((autorisation_parenthese == d_vrai) ||
! 357: (presence_signe == d_vrai))
! 358: {
! 359: chaine_sauvegarde = (unsigned char *)
! 360: (*s_sous_objet_2).objet;
! 361:
! 362: if (((*s_sous_objet_2).objet = (void *)
! 363: malloc((strlen(chaine_sauvegarde) + 2
! 364: + 1) * sizeof(unsigned char))) == NULL)
! 365: {
! 366: (*s_etat_processus).erreur_systeme =
! 367: d_es_allocation_memoire;
! 368: return(NULL);
! 369: }
! 370:
! 371: sprintf((unsigned char *) (*s_sous_objet_2)
! 372: .objet, "(%s)", chaine_sauvegarde);
! 373: free(chaine_sauvegarde);
! 374: }
! 375:
! 376: liberation(s_etat_processus, s_sous_objet_3);
! 377:
! 378: if (depilement(s_etat_processus,
! 379: &((*s_etat_processus)
! 380: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 381: {
! 382: return(NULL);
! 383: }
! 384:
! 385: chaine_sauvegarde = (*s_etat_processus)
! 386: .instruction_courante;
! 387:
! 388: if (((*s_etat_processus).instruction_courante =
! 389: (unsigned char *) malloc((strlen(
! 390: (unsigned char *) (*s_sous_objet_1).objet)
! 391: + 2 + 1) * sizeof(unsigned char))) == NULL)
! 392: {
! 393: (*s_etat_processus).instruction_courante =
! 394: chaine_sauvegarde;
! 395: (*s_etat_processus).erreur_systeme =
! 396: d_es_allocation_memoire;
! 397: return(NULL);
! 398: }
! 399:
! 400: sprintf((*s_etat_processus).instruction_courante,
! 401: "'%s'", (unsigned char *)
! 402: (*s_sous_objet_1).objet);
! 403:
! 404: recherche_type(s_etat_processus);
! 405:
! 406: if ((*s_etat_processus).erreur_execution != d_ex)
! 407: {
! 408: // Aucune erreur ne peut être renvoyée.
! 409:
! 410: return(NULL);
! 411: }
! 412:
! 413: if (depilement(s_etat_processus,
! 414: &((*s_etat_processus)
! 415: .l_base_pile), &s_sous_objet_3) == d_erreur)
! 416: {
! 417: return(NULL);
! 418: }
! 419:
! 420: free((*s_etat_processus).instruction_courante);
! 421:
! 422: (*s_etat_processus).instruction_courante =
! 423: chaine_sauvegarde;
! 424:
! 425: autorisation_parenthese = d_faux;
! 426:
! 427: if ((*s_sous_objet_3).type == ALG)
! 428: {
! 429: l_atome = (struct_liste_chainee *)
! 430: (*s_sous_objet_3).objet;
! 431: chaine_fonction = "";
! 432:
! 433: while(l_atome != NULL)
! 434: {
! 435: if ((*(*l_atome).donnee).type == FCT)
! 436: {
! 437: if (strcmp((*((struct_fonction *)
! 438: (*(*l_atome).donnee).objet))
! 439: .nom_fonction, ">>") != 0)
! 440: {
! 441: chaine_fonction =
! 442: (*((struct_fonction *)
! 443: (*(*l_atome).donnee).objet))
! 444: .nom_fonction;
! 445: }
! 446: }
! 447:
! 448: l_atome = (*l_atome).suivant;
! 449: }
! 450:
! 451: if ((strcmp((*((struct_fonction *)
! 452: (*(*l_element_courant).donnee).objet))
! 453: .nom_fonction, "+") == 0) ||
! 454: (strcmp((*((struct_fonction *)
! 455: (*(*l_element_courant).donnee).objet))
! 456: .nom_fonction, "-") == 0))
! 457: {
! 458: if ((strcmp(chaine_fonction, "AND") == 0) ||
! 459: (strcmp(chaine_fonction, "XOR") ==
! 460: 0) || (strcmp(chaine_fonction, "OR")
! 461: == 0))
! 462: {
! 463: autorisation_parenthese = d_vrai;
! 464: }
! 465: }
! 466: else if ((strcmp((*((struct_fonction *)
! 467: (*(*l_element_courant).donnee).objet))
! 468: .nom_fonction, "*") == 0) ||
! 469: (strcmp((*((struct_fonction *)
! 470: (*(*l_element_courant).donnee).objet))
! 471: .nom_fonction, "/") == 0))
! 472: {
! 473: if ((strcmp(chaine_fonction, "+") == 0) ||
! 474: (strcmp(chaine_fonction, "-") == 0)
! 475: || (strcmp(chaine_fonction, "AND")
! 476: == 0) || (strcmp(chaine_fonction,
! 477: "XOR") == 0) || (strcmp(
! 478: chaine_fonction, "OR") == 0))
! 479: {
! 480: autorisation_parenthese = d_vrai;
! 481: }
! 482: }
! 483: else if ((strcmp((*((struct_fonction *)
! 484: (*(*l_element_courant).donnee).objet))
! 485: .nom_fonction, "^") == 0))
! 486: {
! 487: autorisation_parenthese = d_vrai;
! 488: }
! 489: }
! 490:
! 491: if (autorisation_parenthese == d_vrai)
! 492: {
! 493: chaine_sauvegarde = (unsigned char *)
! 494: (*s_sous_objet_1).objet;
! 495:
! 496: if (((*s_sous_objet_1).objet = (void *)
! 497: malloc((strlen(chaine_sauvegarde) + 2
! 498: + 1) * sizeof(unsigned char))) == NULL)
! 499: {
! 500: (*s_etat_processus).erreur_systeme =
! 501: d_es_allocation_memoire;
! 502: return(NULL);
! 503: }
! 504:
! 505: sprintf((unsigned char *) (*s_sous_objet_1)
! 506: .objet, "(%s)", chaine_sauvegarde);
! 507: free(chaine_sauvegarde);
! 508: }
! 509:
! 510: liberation(s_etat_processus, s_sous_objet_3);
! 511:
! 512: if ((s_sous_objet = allocation(s_etat_processus,
! 513: CHN)) == NULL)
! 514: {
! 515: (*s_etat_processus).erreur_systeme =
! 516: d_es_allocation_memoire;
! 517: return(NULL);
! 518: }
! 519:
! 520: if (((*s_sous_objet).objet = (void *)
! 521: malloc((strlen(
! 522: (unsigned char *) (*s_sous_objet_1).objet) +
! 523: strlen((*((struct_fonction *)
! 524: (*(*l_element_courant).donnee).objet))
! 525: .nom_fonction) + strlen((unsigned char *)
! 526: (*s_sous_objet_2).objet) + 1) *
! 527: sizeof(unsigned char))) == NULL)
! 528: {
! 529: (*s_etat_processus).erreur_systeme =
! 530: d_es_allocation_memoire;
! 531: return(NULL);
! 532: }
! 533:
! 534: sprintf((unsigned char *) (*s_sous_objet).objet,
! 535: "%s%s%s", (unsigned char *)
! 536: (*s_sous_objet_1)
! 537: .objet, (*((struct_fonction *)
! 538: (*(*l_element_courant).donnee).objet))
! 539: .nom_fonction, (unsigned char *)
! 540: (*s_sous_objet_2).objet);
! 541:
! 542: liberation(s_etat_processus, s_sous_objet_1);
! 543: liberation(s_etat_processus, s_sous_objet_2);
! 544:
! 545: if (empilement(s_etat_processus,
! 546: &((*s_etat_processus)
! 547: .l_base_pile), s_sous_objet) == d_erreur)
! 548: {
! 549: return(NULL);
! 550: }
! 551: }
! 552: else if (strcmp((*((struct_fonction *)
! 553: (*(*l_element_courant).donnee).objet))
! 554: .nom_fonction, "=") == 0)
! 555: {
! 556: if (depilement(s_etat_processus,
! 557: &((*s_etat_processus).l_base_pile),
! 558: &s_sous_objet_2) == d_erreur)
! 559: {
! 560: return(NULL);
! 561: }
! 562:
! 563: if (depilement(s_etat_processus,
! 564: &((*s_etat_processus).l_base_pile),
! 565: &s_sous_objet_1) == d_erreur)
! 566: {
! 567: return(NULL);
! 568: }
! 569:
! 570: if ((s_sous_objet = allocation(s_etat_processus,
! 571: CHN)) == NULL)
! 572: {
! 573: (*s_etat_processus).erreur_systeme =
! 574: d_es_allocation_memoire;
! 575: return(NULL);
! 576: }
! 577:
! 578: autorisation_parenthese = d_vrai;
! 579: l_atome = l_element_courant;
! 580:
! 581: if (l_atome != NULL)
! 582: {
! 583: if ((*l_atome).suivant != NULL)
! 584: {
! 585: l_atome = (*l_atome).suivant;
! 586:
! 587: if ((*(*l_atome).donnee).type == FCT)
! 588: {
! 589: if (strcmp((*((struct_fonction *)
! 590: (*(*l_atome).donnee).objet))
! 591: .nom_fonction, ">>") == 0)
! 592: {
! 593: if ((*l_atome).suivant == NULL)
! 594: {
! 595: autorisation_parenthese =
! 596: d_faux;
! 597: }
! 598: }
! 599: }
! 600: }
! 601: }
! 602:
! 603: if (autorisation_parenthese == d_vrai)
! 604: {
! 605: if (((*s_sous_objet).objet =
! 606: (void *) malloc((strlen(
! 607: (unsigned char *) (*s_sous_objet_1)
! 608: .objet) + strlen((*((struct_fonction *)
! 609: (*(*l_element_courant).donnee).objet))
! 610: .nom_fonction) +
! 611: strlen((unsigned char *)
! 612: (*s_sous_objet_2).objet) + 2 + 1) *
! 613: sizeof(unsigned char))) == NULL)
! 614: {
! 615: (*s_etat_processus).erreur_systeme =
! 616: d_es_allocation_memoire;
! 617: return(NULL);
! 618: }
! 619:
! 620: sprintf((unsigned char *) (*s_sous_objet).objet,
! 621: "(%s%s%s)", (unsigned char *)
! 622: (*s_sous_objet_1)
! 623: .objet, (*((struct_fonction *)
! 624: (*(*l_element_courant).donnee).objet))
! 625: .nom_fonction, (unsigned char *)
! 626: (*s_sous_objet_2).objet);
! 627: }
! 628: else
! 629: {
! 630: if (((*s_sous_objet).objet =
! 631: (void *) malloc((strlen(
! 632: (unsigned char *) (*s_sous_objet_1)
! 633: .objet) + strlen((*((struct_fonction *)
! 634: (*(*l_element_courant).donnee).objet))
! 635: .nom_fonction) + strlen(
! 636: (unsigned char *) (*s_sous_objet_2)
! 637: .objet) + 1) * sizeof(unsigned char)))
! 638: == NULL)
! 639: {
! 640: (*s_etat_processus).erreur_systeme =
! 641: d_es_allocation_memoire;
! 642: return(NULL);
! 643: }
! 644:
! 645: sprintf((unsigned char *) (*s_sous_objet).objet,
! 646: "%s%s%s", (unsigned char *)
! 647: (*s_sous_objet_1)
! 648: .objet, (*((struct_fonction *)
! 649: (*(*l_element_courant).donnee).objet))
! 650: .nom_fonction, (unsigned char *)
! 651: (*s_sous_objet_2).objet);
! 652: }
! 653:
! 654: liberation(s_etat_processus, s_sous_objet_1);
! 655: liberation(s_etat_processus, s_sous_objet_2);
! 656:
! 657: if (empilement(s_etat_processus,
! 658: &((*s_etat_processus).l_base_pile),
! 659: s_sous_objet) == d_erreur)
! 660: {
! 661: return(NULL);
! 662: }
! 663: }
! 664: else if (strcmp((*((struct_fonction *)
! 665: (*(*l_element_courant).donnee).objet))
! 666: .nom_fonction,
! 667: "NOT") == 0)
! 668: {
! 669: if (depilement(s_etat_processus,
! 670: &((*s_etat_processus)
! 671: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 672: {
! 673: return(NULL);
! 674: }
! 675:
! 676: if ((s_sous_objet = allocation(s_etat_processus,
! 677: CHN)) == NULL)
! 678: {
! 679: (*s_etat_processus).erreur_systeme =
! 680: d_es_allocation_memoire;
! 681: return(NULL);
! 682: }
! 683:
! 684: if (((*s_sous_objet).objet = (unsigned char *)
! 685: malloc(
! 686: (strlen((unsigned char *) (*s_sous_objet_1)
! 687: .objet) + 4 + 1) * sizeof(unsigned char)))
! 688: == NULL)
! 689: {
! 690: (*s_etat_processus).erreur_systeme =
! 691: d_es_allocation_memoire;
! 692: return(NULL);
! 693: }
! 694:
! 695: sprintf((unsigned char *) (*s_sous_objet).objet,
! 696: "%s %s", (*((struct_fonction *)
! 697: (*(*l_element_courant).donnee).objet))
! 698: .nom_fonction, (unsigned char *)
! 699: (*s_sous_objet_1).objet );
! 700:
! 701: liberation(s_etat_processus, s_sous_objet_1);
! 702:
! 703: if (empilement(s_etat_processus,
! 704: &((*s_etat_processus)
! 705: .l_base_pile), s_sous_objet) == d_erreur)
! 706: {
! 707: return(NULL);
! 708: }
! 709: }
! 710: else if ((strcmp((*((struct_fonction *)
! 711: (*(*l_element_courant).donnee).objet))
! 712: .nom_fonction,
! 713: "OR") == 0) || (strcmp((*((struct_fonction *)
! 714: (*(*l_element_courant).donnee).objet))
! 715: .nom_fonction,
! 716: "XOR") == 0) || (strcmp((*((struct_fonction *)
! 717: (*(*l_element_courant).donnee).objet))
! 718: .nom_fonction,
! 719: "AND") == 0))
! 720: {
! 721: if (depilement(s_etat_processus,
! 722: &((*s_etat_processus)
! 723: .l_base_pile), &s_sous_objet_2) == d_erreur)
! 724: {
! 725: return(NULL);
! 726: }
! 727:
! 728: if (depilement(s_etat_processus,
! 729: &((*s_etat_processus)
! 730: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 731: {
! 732: return(NULL);
! 733: }
! 734:
! 735: if ((s_sous_objet = allocation(s_etat_processus,
! 736: CHN)) == NULL)
! 737: {
! 738: (*s_etat_processus).erreur_systeme =
! 739: d_es_allocation_memoire;
! 740: return(NULL);
! 741: }
! 742:
! 743: if (((*s_sous_objet).objet = (void *)
! 744: malloc((strlen(
! 745: (unsigned char *) (*s_sous_objet_1).objet) +
! 746: strlen((*((struct_fonction *)
! 747: (*(*l_element_courant).donnee).objet))
! 748: .nom_fonction) + strlen((unsigned char *)
! 749: (*s_sous_objet_2).objet) + 2 + 1) *
! 750: sizeof(unsigned char))) == NULL)
! 751: {
! 752: (*s_etat_processus).erreur_systeme =
! 753: d_es_allocation_memoire;
! 754: return(NULL);
! 755: }
! 756:
! 757: sprintf((unsigned char *) (*s_sous_objet).objet,
! 758: "%s %s %s", (unsigned char *)
! 759: (*s_sous_objet_1)
! 760: .objet, (*((struct_fonction *)
! 761: (*(*l_element_courant).donnee).objet))
! 762: .nom_fonction, (unsigned char *)
! 763: (*s_sous_objet_2).objet);
! 764:
! 765: liberation(s_etat_processus, s_sous_objet_1);
! 766: liberation(s_etat_processus, s_sous_objet_2);
! 767:
! 768: if (empilement(s_etat_processus,
! 769: &((*s_etat_processus)
! 770: .l_base_pile), s_sous_objet) == d_erreur)
! 771: {
! 772: return(NULL);
! 773: }
! 774: }
! 775: else
! 776: {
! 777: nombre_arguments = (*((struct_fonction *)
! 778: (*(*l_element_courant).donnee).objet))
! 779: .nombre_arguments;
! 780:
! 781: if ((chaine = (unsigned char *)
! 782: malloc(sizeof(unsigned char))) == NULL)
! 783: {
! 784: (*s_etat_processus).erreur_systeme =
! 785: d_es_allocation_memoire;
! 786: return(NULL);
! 787: }
! 788:
! 789: chaine[0] = d_code_fin_chaine;
! 790:
! 791: for(i = 0; i < nombre_arguments; i++)
! 792: {
! 793: if ((nombre_arguments - i) > 1)
! 794: {
! 795: l_liste1 = (*s_etat_processus).l_base_pile;
! 796:
! 797: for(j = 2; j < (nombre_arguments - i); j++)
! 798: {
! 799: l_liste1 = (*l_liste1).suivant;
! 800: }
! 801:
! 802: l_liste2 = (*l_liste1).suivant;
! 803: (*l_liste1).suivant = (*l_liste2).suivant;
! 804: (*l_liste2).suivant = (*s_etat_processus)
! 805: .l_base_pile;
! 806: (*s_etat_processus).l_base_pile = l_liste2;
! 807: }
! 808:
! 809: if (depilement(s_etat_processus,
! 810: &((*s_etat_processus).l_base_pile),
! 811: &s_sous_objet) == d_erreur)
! 812: {
! 813: return(NULL);
! 814: }
! 815:
! 816: chaine_sauvegarde = chaine;
! 817:
! 818: if (strlen(chaine_sauvegarde) == 0)
! 819: {
! 820: if ((chaine = (unsigned char *)
! 821: malloc((strlen((unsigned char *)
! 822: (*s_sous_objet).objet) + 1) *
! 823: sizeof(unsigned char))) == NULL)
! 824: {
! 825: (*s_etat_processus).erreur_systeme =
! 826: d_es_allocation_memoire;
! 827: return(NULL);
! 828: }
! 829:
! 830: sprintf(chaine, "%s", (unsigned char *)
! 831: (*s_sous_objet).objet);
! 832: }
! 833: else
! 834: {
! 835: if ((chaine = (unsigned char *)
! 836: malloc((strlen(chaine_sauvegarde)
! 837: + 1 + strlen((unsigned char *)
! 838: (*s_sous_objet).objet) + 1) *
! 839: sizeof(unsigned char))) == NULL)
! 840: {
! 841: (*s_etat_processus).erreur_systeme =
! 842: d_es_allocation_memoire;
! 843: return(NULL);
! 844: }
! 845:
! 846: sprintf(chaine, "%s,%s", chaine_sauvegarde,
! 847: (unsigned char *) (*s_sous_objet)
! 848: .objet);
! 849: }
! 850:
! 851: free(chaine_sauvegarde);
! 852: liberation(s_etat_processus, s_sous_objet);
! 853: }
! 854:
! 855: chaine_sauvegarde = chaine;
! 856:
! 857: if ((chaine = (unsigned char *) malloc((strlen(
! 858: (*((struct_fonction *)
! 859: (*(*l_element_courant)
! 860: .donnee).objet)).nom_fonction) + 2 +
! 861: strlen(chaine_sauvegarde) + 1) *
! 862: sizeof(unsigned char))) == NULL)
! 863: {
! 864: (*s_etat_processus).erreur_systeme =
! 865: d_es_allocation_memoire;
! 866: return(NULL);
! 867: }
! 868:
! 869: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
! 870: (*(*l_element_courant).donnee).objet))
! 871: .nom_fonction, chaine_sauvegarde);
! 872: free(chaine_sauvegarde);
! 873:
! 874: if ((s_sous_objet = allocation(s_etat_processus,
! 875: CHN)) == NULL)
! 876: {
! 877: (*s_etat_processus).erreur_systeme =
! 878: d_es_allocation_memoire;
! 879: return(NULL);
! 880: }
! 881:
! 882: (*s_sous_objet).objet = (void *) chaine;
! 883:
! 884: if (empilement(s_etat_processus,
! 885: &((*s_etat_processus)
! 886: .l_base_pile), s_sous_objet) == d_erreur)
! 887: {
! 888: return(NULL);
! 889: }
! 890: }
! 891: }
! 892: }
! 893: else
! 894: {
! 895: if ((s_sous_objet = allocation(s_etat_processus, CHN))
! 896: == NULL)
! 897: {
! 898: (*s_etat_processus).erreur_systeme =
! 899: d_es_allocation_memoire;
! 900: return(NULL);
! 901: }
! 902:
! 903: if (((*s_sous_objet).objet = (void *) formateur_fichier(
! 904: s_etat_processus, (*l_element_courant).donnee,
! 905: s_format, longueur, longueur_champ, format_sortie,
! 906: type, longueur_effective, recursivite)) == NULL)
! 907: {
! 908: (*s_etat_processus).erreur_systeme =
! 909: d_es_allocation_memoire;
! 910: return(NULL);
! 911: }
! 912:
! 913: if (((*(*l_element_courant).donnee).type == ALG)
! 914: || ((*(*l_element_courant).donnee).type == NOM))
! 915: {
! 916: chaine_sauvegarde = (unsigned char *)
! 917: (*s_sous_objet).objet;
! 918:
! 919: if (((*s_sous_objet).objet = malloc((strlen(
! 920: chaine_sauvegarde) - 1) *
! 921: sizeof(unsigned char))) == NULL)
! 922: {
! 923: (*s_etat_processus).erreur_systeme =
! 924: d_es_allocation_memoire;
! 925: return(NULL);
! 926: }
! 927:
! 928: ptrl = chaine_sauvegarde;
! 929: ptre = (unsigned char *) (*s_sous_objet).objet;
! 930:
! 931: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
! 932: i--, *ptre++ = *ptrl++);
! 933:
! 934: (*ptre) = d_code_fin_chaine;
! 935:
! 936: free(chaine_sauvegarde);
! 937: }
! 938: else if ((*(*l_element_courant).donnee).type == CHN)
! 939: {
! 940: chaine_sauvegarde = (unsigned char *)
! 941: (*s_sous_objet).objet;
! 942:
! 943: if (((*s_sous_objet).objet = malloc((strlen(
! 944: chaine_sauvegarde) + 3) *
! 945: sizeof(unsigned char))) == NULL)
! 946: {
! 947: (*s_etat_processus).erreur_systeme =
! 948: d_es_allocation_memoire;
! 949: return(NULL);
! 950: }
! 951:
! 952: sprintf((unsigned char *) (*s_sous_objet).objet,
! 953: "\"%s\"", chaine_sauvegarde);
! 954:
! 955: free(chaine_sauvegarde);
! 956: }
! 957:
! 958: if (empilement(s_etat_processus, &((*s_etat_processus)
! 959: .l_base_pile), s_sous_objet) == d_erreur)
! 960: {
! 961: return(NULL);
! 962: }
! 963: }
! 964:
! 965: l_element_courant = (*l_element_courant).suivant;
! 966: }
! 967:
! 968: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 969: &s_sous_objet) == d_erreur)
! 970: {
! 971: return(NULL);
! 972: }
! 973:
! 974: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
! 975: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
! 976: == NULL)
! 977: {
! 978: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 979: return(NULL);
! 980: }
! 981:
! 982: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
! 983: liberation(s_etat_processus, s_sous_objet);
! 984: }
! 985: else if ((*s_objet).type == BIN)
! 986: {
! 987:
! 988: /*
! 989: --------------------------------------------------------------------------------
! 990: Entier binaire en base 2, 8, 10 ou 16
! 991: --------------------------------------------------------------------------------
! 992: */
! 993:
! 994: if (format_sortie != 'B')
! 995: {
! 996: (*s_etat_processus).erreur_execution =
! 997: d_ex_erreur_format_fichier;
! 998: return(NULL);
! 999: }
! 1000:
! 1001: longueur_binaire = longueur_entiers_binaires(s_etat_processus);
! 1002: masque_binaire = masque_entiers_binaires(s_etat_processus);
! 1003:
! 1004: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
! 1005: (test_cfsf(s_etat_processus, 44) == d_faux))
! 1006: {
! 1007:
! 1008: /*
! 1009: -- Base décimale ---------------------------------------------------------------
! 1010: */
! 1011:
! 1012: sprintf(tampon, "%llu", (*((logical8 *)
! 1013: ((*s_objet).objet))) & masque_binaire);
! 1014: strcpy(base, "d");
! 1015: }
! 1016: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
! 1017: (test_cfsf(s_etat_processus, 44) == d_faux))
! 1018: {
! 1019:
! 1020: /*
! 1021: -- Base octale -----------------------------------------------------------------
! 1022: */
! 1023:
! 1024: sprintf(tampon, "%llo", (*((logical8 *)
! 1025: ((*s_objet).objet))) & masque_binaire);
! 1026: strcpy(base, "o");
! 1027: }
! 1028: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
! 1029: {
! 1030:
! 1031: /*
! 1032: -- Bases hexadécimale et binaire -----------------------------------------------
! 1033: */
! 1034:
! 1035: sprintf(tampon, "%llX", (*((logical8 *)
! 1036: ((*s_objet).objet))) & masque_binaire);
! 1037:
! 1038: if (test_cfsf(s_etat_processus, 43) == d_vrai)
! 1039: {
! 1040: strcpy(base, "h");
! 1041: }
! 1042: else
! 1043: {
! 1044: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
! 1045: * sizeof(unsigned char));
! 1046:
! 1047: if (chaine == NULL)
! 1048: {
! 1049: (*s_etat_processus).erreur_systeme =
! 1050: d_es_allocation_memoire;
! 1051: return(NULL);
! 1052: }
! 1053:
! 1054: strcpy(chaine, tampon);
! 1055: tampon[0] = 0;
! 1056:
! 1057: for(i = 0; i < strlen(chaine); i++)
! 1058: {
! 1059: switch(chaine[i])
! 1060: {
! 1061: case '0' :
! 1062: {
! 1063: strcat(tampon, (i != 0) ? "0000" : "0");
! 1064: break;
! 1065: }
! 1066: case '1' :
! 1067: {
! 1068: strcat(tampon, (i != 0) ? "0001" : "1");
! 1069: break;
! 1070: }
! 1071: case '2' :
! 1072: {
! 1073: strcat(tampon, (i != 0) ? "0010" : "10");
! 1074: break;
! 1075: }
! 1076: case '3' :
! 1077: {
! 1078: strcat(tampon, (i != 0) ? "0011" : "11");
! 1079: break;
! 1080: }
! 1081: case '4' :
! 1082: {
! 1083: strcat(tampon, (i != 0) ? "0100" : "100");
! 1084: break;
! 1085: }
! 1086: case '5' :
! 1087: {
! 1088: strcat(tampon, (i != 0) ? "0101" : "101");
! 1089: break;
! 1090: }
! 1091: case '6' :
! 1092: {
! 1093: strcat(tampon, (i != 0) ? "0110" : "110");
! 1094: break;
! 1095: }
! 1096: case '7' :
! 1097: {
! 1098: strcat(tampon, (i != 0) ? "0111" : "111");
! 1099: break;
! 1100: }
! 1101: case '8' :
! 1102: {
! 1103: strcat(tampon, "1000");
! 1104: break;
! 1105: }
! 1106: case '9' :
! 1107: {
! 1108: strcat(tampon, "1001");
! 1109: break;
! 1110: }
! 1111: case 'A' :
! 1112: {
! 1113: strcat(tampon, "1010");
! 1114: break;
! 1115: }
! 1116: case 'B' :
! 1117: {
! 1118: strcat(tampon, "1011");
! 1119: break;
! 1120: }
! 1121: case 'C' :
! 1122: {
! 1123: strcat(tampon, "1100");
! 1124: break;
! 1125: }
! 1126: case 'D' :
! 1127: {
! 1128: strcat(tampon, "1101");
! 1129: break;
! 1130: }
! 1131: case 'E' :
! 1132: {
! 1133: strcat(tampon, "1110");
! 1134: break;
! 1135: }
! 1136: case 'F' :
! 1137: {
! 1138: strcat(tampon, "1111");
! 1139: break;
! 1140: }
! 1141: }
! 1142: }
! 1143:
! 1144: free(chaine);
! 1145: strcpy(base, "b");
! 1146: }
! 1147: }
! 1148:
! 1149: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
! 1150: * sizeof(unsigned char));
! 1151:
! 1152: if (chaine == NULL)
! 1153: {
! 1154: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1155: return(NULL);
! 1156: }
! 1157:
! 1158: strcpy(chaine, "# ");
! 1159:
! 1160: strcat(chaine, tampon);
! 1161: strcat(chaine, base);
! 1162: }
! 1163: else if ((*s_objet).type == CHN)
! 1164: {
! 1165:
! 1166: /*
! 1167: --------------------------------------------------------------------------------
! 1168: Chaîne de caractères
! 1169: --------------------------------------------------------------------------------
! 1170: */
! 1171:
! 1172: if (format_sortie != 'C')
! 1173: {
! 1174: (*s_etat_processus).erreur_execution =
! 1175: d_ex_erreur_format_fichier;
! 1176: return(NULL);
! 1177: }
! 1178:
! 1179: chaine = (unsigned char *) malloc((strlen((unsigned char *)
! 1180: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
! 1181:
! 1182: if (chaine == NULL)
! 1183: {
! 1184: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1185: return(NULL);
! 1186: }
! 1187:
! 1188: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
! 1189: }
! 1190: else if ((*s_objet).type == CPL)
! 1191: {
! 1192:
! 1193: /*
! 1194: --------------------------------------------------------------------------------
! 1195: Complexe
! 1196: --------------------------------------------------------------------------------
! 1197: */
! 1198:
! 1199: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 1200: (format_sortie != 'I') && (format_sortie != 'E'))
! 1201: {
! 1202: (*s_etat_processus).erreur_execution =
! 1203: d_ex_erreur_format_fichier;
! 1204: return(NULL);
! 1205: }
! 1206:
! 1207: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
! 1208: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',
! 1209: longueur, longueur_champ, format_sortie)) == NULL)
! 1210: {
! 1211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1212: return(NULL);
! 1213: }
! 1214:
! 1215: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
! 1216: + 1) * sizeof(unsigned char));
! 1217:
! 1218: if (chaine == NULL)
! 1219: {
! 1220: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1221: return(NULL);
! 1222: }
! 1223:
! 1224: strcpy(chaine, chaine_formatee);
! 1225: free(chaine_formatee);
! 1226: }
! 1227: else if ((*s_objet).type == RPN)
! 1228: {
! 1229:
! 1230: /*
! 1231: --------------------------------------------------------------------------------
! 1232: Définition
! 1233: --------------------------------------------------------------------------------
! 1234: */
! 1235:
! 1236: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
! 1237: chaine_sauvegarde = chaine;
! 1238:
! 1239: while(l_element_courant != NULL)
! 1240: {
! 1241: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 1242: (*l_element_courant).donnee, s_format,
! 1243: longueur, longueur_champ, format_sortie, type,
! 1244: longueur_effective, recursivite)) == NULL)
! 1245: {
! 1246: return(NULL);
! 1247: }
! 1248:
! 1249: if ((*(*l_element_courant).donnee).type == CHN)
! 1250: {
! 1251: chaine_tampon = chaine_formatee;
! 1252:
! 1253: if ((chaine_formatee = (unsigned char *) malloc((strlen(
! 1254: chaine_tampon) + 3) * sizeof(unsigned char)))
! 1255: == NULL)
! 1256: {
! 1257: (*s_etat_processus).erreur_systeme =
! 1258: d_es_allocation_memoire;
! 1259: return(NULL);
! 1260: }
! 1261:
! 1262: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
! 1263: free(chaine_tampon);
! 1264: }
! 1265:
! 1266: l_element_courant = (*l_element_courant).suivant;
! 1267:
! 1268: if (chaine != NULL)
! 1269: {
! 1270: chaine_sauvegarde = chaine;
! 1271:
! 1272: if ((chaine = (unsigned char *) malloc((strlen(
! 1273: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
! 1274: sizeof(unsigned char))) == NULL)
! 1275: {
! 1276: (*s_etat_processus).erreur_systeme =
! 1277: d_es_allocation_memoire;
! 1278: return(NULL);
! 1279: }
! 1280:
! 1281: strcpy(chaine, chaine_sauvegarde);
! 1282: free(chaine_sauvegarde);
! 1283: strcat(chaine, " ");
! 1284: strcat(chaine, chaine_formatee);
! 1285: free(chaine_formatee);
! 1286: }
! 1287: else
! 1288: {
! 1289: chaine = chaine_formatee;
! 1290: }
! 1291: }
! 1292:
! 1293: chaine_sauvegarde = chaine;
! 1294: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
! 1295: sizeof(unsigned char));
! 1296:
! 1297: if (chaine == NULL)
! 1298: {
! 1299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1300: free(chaine_sauvegarde);
! 1301: return(NULL);
! 1302: }
! 1303:
! 1304: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
! 1305: strcpy(chaine, chaine_sauvegarde);
! 1306: free(chaine_sauvegarde);
! 1307: }
! 1308: else if ((*s_objet).type == INT)
! 1309: {
! 1310:
! 1311: /*
! 1312: --------------------------------------------------------------------------------
! 1313: Entier
! 1314: --------------------------------------------------------------------------------
! 1315: */
! 1316:
! 1317: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 1318: (format_sortie != 'I') && (format_sortie != 'E'))
! 1319: {
! 1320: (*s_etat_processus).erreur_execution =
! 1321: d_ex_erreur_format_fichier;
! 1322: return(NULL);
! 1323: }
! 1324:
! 1325: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
! 1326: (void *) ((integer8 *) ((*s_objet).objet)), 'I',
! 1327: longueur, longueur_champ, format_sortie)) == NULL)
! 1328: {
! 1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1330: return(NULL);
! 1331: }
! 1332:
! 1333: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
! 1334: * sizeof(unsigned char));
! 1335:
! 1336: if (chaine == NULL)
! 1337: {
! 1338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1339: return(NULL);
! 1340: }
! 1341:
! 1342: strcpy(chaine, chaine_formatee);
! 1343: free(chaine_formatee);
! 1344: }
! 1345: else if ((*s_objet).type == FCT)
! 1346: {
! 1347:
! 1348: /*
! 1349: --------------------------------------------------------------------------------
! 1350: Fonction
! 1351: --------------------------------------------------------------------------------
! 1352: */
! 1353:
! 1354: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
! 1355: ((*s_objet).objet))).nom_fonction) + 1) *
! 1356: sizeof(unsigned char));
! 1357:
! 1358: if (chaine == NULL)
! 1359: {
! 1360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1361: return(NULL);
! 1362: }
! 1363:
! 1364: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
! 1365: ((*s_objet).objet))).nom_fonction);
! 1366: }
! 1367: else if ((*s_objet).type == LST)
! 1368: {
! 1369:
! 1370: /*
! 1371: --------------------------------------------------------------------------------
! 1372: Liste
! 1373: --------------------------------------------------------------------------------
! 1374: */
! 1375:
! 1376: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 1377:
! 1378: if (chaine == NULL)
! 1379: {
! 1380: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1381: return(NULL);
! 1382: }
! 1383:
! 1384: strcpy(chaine, "{");
! 1385:
! 1386: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 1387: l_element_courant_format = (struct_liste_chainee *)
! 1388: (*s_format).objet;
! 1389: nombre_elements = 0;
! 1390:
! 1391: while((l_element_courant != NULL) &&
! 1392: (l_element_courant_format != NULL))
! 1393: {
! 1394: if ((((*(*l_element_courant_format).donnee).type == LST)
! 1395: && ((*(*l_element_courant).donnee).type == LST)) ||
! 1396: (((*(*l_element_courant_format).donnee).type == TBL)
! 1397: && ((*(*l_element_courant).donnee).type == TBL)))
! 1398: {
! 1399: chaine_sauvegarde = chaine;
! 1400:
! 1401: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 1402: (*l_element_courant).donnee,
! 1403: (*l_element_courant_format).donnee,
! 1404: 0, 0, ' ', 'F', longueur_effective, recursivite))
! 1405: == NULL)
! 1406: {
! 1407: return(NULL);
! 1408: }
! 1409:
! 1410: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
! 1411: + strlen(chaine_sauvegarde) + 2)
! 1412: * sizeof(unsigned char));
! 1413:
! 1414: if (chaine == NULL)
! 1415: {
! 1416: (*s_etat_processus).erreur_systeme =
! 1417: d_es_allocation_memoire;
! 1418: return(NULL);
! 1419: }
! 1420:
! 1421: strcpy(chaine, chaine_sauvegarde);
! 1422: free(chaine_sauvegarde);
! 1423: strcat(chaine, " ");
! 1424: strcat(chaine, chaine_formatee);
! 1425: free(chaine_formatee);
! 1426: }
! 1427: else if ((*(*l_element_courant_format).donnee).type != CHN)
! 1428: {
! 1429: free(chaine);
! 1430:
! 1431: (*s_etat_processus).erreur_execution =
! 1432: d_ex_erreur_format_fichier;
! 1433: return(NULL);
! 1434: }
! 1435: else
! 1436: {
! 1437: if ((format_chaine = conversion_majuscule((unsigned char *)
! 1438: (*(*l_element_courant_format).donnee).objet))
! 1439: == NULL)
! 1440: {
! 1441: (*s_etat_processus).erreur_systeme =
! 1442: d_es_allocation_memoire;
! 1443: return(NULL);
! 1444: }
! 1445:
! 1446: format_degenere = d_faux;
! 1447:
! 1448: if (strncmp("STANDARD*", format_chaine, 9) == 0)
! 1449: {
! 1450: format_sortie = 'S';
! 1451: position_1 = 9;
! 1452: format_degenere = d_vrai;
! 1453: }
! 1454: else if (strncmp("BINARY*", format_chaine, 7) == 0)
! 1455: {
! 1456: format_sortie = 'B';
! 1457: position_1 = 7;
! 1458: }
! 1459: else if (strncmp("FIXED*", format_chaine, 6) == 0)
! 1460: {
! 1461: format_sortie = 'F';
! 1462: position_1 = 6;
! 1463: }
! 1464: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
! 1465: {
! 1466: format_sortie = 'I';
! 1467: position_1 = 11;
! 1468: }
! 1469: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
! 1470: {
! 1471: format_sortie = 'E';
! 1472: position_1 = 9;
! 1473: }
! 1474: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
! 1475: {
! 1476: format_sortie = 'C';
! 1477: position_1 = 10;
! 1478: format_degenere = d_vrai;
! 1479: }
! 1480: else
! 1481: {
! 1482: free(chaine);
! 1483: free(format_chaine);
! 1484:
! 1485: (*s_etat_processus).erreur_execution =
! 1486: d_ex_erreur_format_fichier;
! 1487: return(NULL);
! 1488: }
! 1489:
! 1490: position_3 = strlen(format_chaine);
! 1491: format_chaine[--position_3] = d_code_fin_chaine;
! 1492:
! 1493: position_2 = position_1;
! 1494:
! 1495: while(format_chaine[position_2] != '(')
! 1496: {
! 1497: if (format_chaine[position_2] == d_code_fin_chaine)
! 1498: {
! 1499: free(chaine);
! 1500: free(format_chaine);
! 1501:
! 1502: (*s_etat_processus).erreur_execution =
! 1503: d_ex_erreur_format_fichier;
! 1504: return(NULL);
! 1505: }
! 1506:
! 1507: position_2++;
! 1508: }
! 1509:
! 1510: format_chaine[position_2++] = d_code_fin_chaine;
! 1511:
! 1512: if (format_degenere == d_faux)
! 1513: {
! 1514: if (sscanf(&(format_chaine[position_1]), "%ld",
! 1515: &longueur) != 1)
! 1516: {
! 1517: free(chaine);
! 1518: free(format_chaine);
! 1519:
! 1520: (*s_etat_processus).erreur_execution =
! 1521: d_ex_erreur_format_fichier;
! 1522: return(NULL);
! 1523: }
! 1524: }
! 1525: else
! 1526: {
! 1527: longueur = -1;
! 1528: }
! 1529:
! 1530: if (strcmp(&(format_chaine[position_2]), "*") != 0)
! 1531: {
! 1532: if (sscanf(&(format_chaine[position_2]), "%ld",
! 1533: &longueur_champ) != 1)
! 1534: {
! 1535: free(chaine);
! 1536: free(format_chaine);
! 1537:
! 1538: (*s_etat_processus).erreur_execution =
! 1539: d_ex_erreur_format_fichier;
! 1540: return(NULL);
! 1541: }
! 1542: }
! 1543: else
! 1544: {
! 1545: longueur_champ = -1;
! 1546: }
! 1547:
! 1548: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
! 1549: longueur_champ))
! 1550: {
! 1551: free(chaine);
! 1552: free(format_chaine);
! 1553:
! 1554: (*s_etat_processus).erreur_execution =
! 1555: d_ex_erreur_format_fichier;
! 1556: return(NULL);
! 1557: }
! 1558:
! 1559: free(format_chaine);
! 1560:
! 1561: chaine_sauvegarde = chaine;
! 1562:
! 1563: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 1564: (*l_element_courant).donnee, s_format,
! 1565: longueur, longueur_champ, format_sortie, type,
! 1566: longueur_effective, recursivite)) == NULL)
! 1567: {
! 1568: return(NULL);
! 1569: }
! 1570:
! 1571: if ((*(*l_element_courant).donnee).type == CHN)
! 1572: {
! 1573: chaine = (unsigned char *)
! 1574: malloc((strlen(chaine_formatee)
! 1575: + strlen(chaine_sauvegarde) + 4)
! 1576: * sizeof(unsigned char));
! 1577:
! 1578: if (chaine == NULL)
! 1579: {
! 1580: (*s_etat_processus).erreur_systeme =
! 1581: d_es_allocation_memoire;
! 1582: return(NULL);
! 1583: }
! 1584:
! 1585: strcpy(chaine, chaine_sauvegarde);
! 1586: free(chaine_sauvegarde);
! 1587: strcat(chaine, " \"");
! 1588: strcat(chaine, chaine_formatee);
! 1589: free(chaine_formatee);
! 1590: strcat(chaine, "\"");
! 1591: }
! 1592: else if ((*(*l_element_courant).donnee).type == NOM)
! 1593: {
! 1594: chaine = (unsigned char *)
! 1595: malloc((strlen(chaine_formatee)
! 1596: + strlen(chaine_sauvegarde) + 2)
! 1597: * sizeof(unsigned char));
! 1598:
! 1599: if (chaine == NULL)
! 1600: {
! 1601: (*s_etat_processus).erreur_systeme =
! 1602: d_es_allocation_memoire;
! 1603: return(NULL);
! 1604: }
! 1605:
! 1606: sprintf(chaine, "%s %s", chaine_sauvegarde,
! 1607: chaine_formatee);
! 1608: free(chaine_formatee);
! 1609: }
! 1610: else
! 1611: {
! 1612: chaine = (unsigned char *)
! 1613: malloc((strlen(chaine_formatee)
! 1614: + strlen(chaine_sauvegarde) + 2)
! 1615: * sizeof(unsigned char));
! 1616:
! 1617: if (chaine == NULL)
! 1618: {
! 1619: (*s_etat_processus).erreur_systeme =
! 1620: d_es_allocation_memoire;
! 1621: return(NULL);
! 1622: }
! 1623:
! 1624: strcpy(chaine, chaine_sauvegarde);
! 1625: free(chaine_sauvegarde);
! 1626: strcat(chaine, " ");
! 1627: strcat(chaine, chaine_formatee);
! 1628: free(chaine_formatee);
! 1629: }
! 1630: }
! 1631:
! 1632: nombre_elements++;
! 1633: l_element_courant = (*l_element_courant).suivant;
! 1634: l_element_courant_format = (*l_element_courant_format).suivant;
! 1635: }
! 1636:
! 1637: if ((l_element_courant != NULL) ||
! 1638: (l_element_courant_format != NULL))
! 1639: {
! 1640: free(chaine);
! 1641:
! 1642: (*s_etat_processus).erreur_execution =
! 1643: d_ex_erreur_format_fichier;
! 1644: return(NULL);
! 1645: }
! 1646:
! 1647: chaine_sauvegarde = chaine;
! 1648: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
! 1649: * sizeof(unsigned char));
! 1650:
! 1651: if (chaine == NULL)
! 1652: {
! 1653: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1654: return(NULL);
! 1655: }
! 1656:
! 1657: strcpy(chaine, chaine_sauvegarde);
! 1658: free(chaine_sauvegarde);
! 1659: strcat(chaine, " }");
! 1660: }
! 1661: else if ((*s_objet).type == TBL)
! 1662: {
! 1663:
! 1664: /*
! 1665: --------------------------------------------------------------------------------
! 1666: Table
! 1667: --------------------------------------------------------------------------------
! 1668: */
! 1669:
! 1670: if ((*s_format).type != TBL)
! 1671: {
! 1672: (*s_etat_processus).erreur_execution =
! 1673: d_ex_erreur_format_fichier;
! 1674: return(NULL);
! 1675: }
! 1676:
! 1677: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 1678: l_element_courant_format = (struct_liste_chainee *)
! 1679: (*s_format).objet;
! 1680:
! 1681: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
! 1682: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
! 1683: {
! 1684: (*s_etat_processus).erreur_execution =
! 1685: d_ex_erreur_format_fichier;
! 1686: return(NULL);
! 1687: }
! 1688:
! 1689: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 1690:
! 1691: if (chaine == NULL)
! 1692: {
! 1693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1694: return(NULL);
! 1695: }
! 1696:
! 1697: strcpy(chaine, "<[");
! 1698:
! 1699: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
! 1700: .nombre_elements; i++)
! 1701: {
! 1702: if ((((*(*((struct_tableau *) (*s_format).objet))
! 1703: .elements[i]).type == LST) &&
! 1704: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
! 1705: .type == LST)) ||
! 1706: (((*(*((struct_tableau *) (*s_format).objet))
! 1707: .elements[i]).type == TBL) &&
! 1708: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
! 1709: .type == TAB)))
! 1710: {
! 1711: chaine_sauvegarde = chaine;
! 1712:
! 1713: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 1714: (*l_element_courant).donnee,
! 1715: (*l_element_courant_format).donnee,
! 1716: 0, 0, ' ', 'F', longueur_effective, recursivite))
! 1717: == NULL)
! 1718: {
! 1719: return(NULL);
! 1720: }
! 1721:
! 1722: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
! 1723: + strlen(chaine_sauvegarde) + 2)
! 1724: * sizeof(unsigned char));
! 1725:
! 1726: if (chaine == NULL)
! 1727: {
! 1728: (*s_etat_processus).erreur_systeme =
! 1729: d_es_allocation_memoire;
! 1730: return(NULL);
! 1731: }
! 1732:
! 1733: strcpy(chaine, chaine_sauvegarde);
! 1734: free(chaine_sauvegarde);
! 1735: strcat(chaine, " ");
! 1736: strcat(chaine, chaine_formatee);
! 1737: free(chaine_formatee);
! 1738: }
! 1739: else if ((*(*((struct_tableau *) (*s_format).objet))
! 1740: .elements[i]).type != CHN)
! 1741: {
! 1742: free(chaine);
! 1743:
! 1744: (*s_etat_processus).erreur_execution =
! 1745: d_ex_erreur_format_fichier;
! 1746: return(NULL);
! 1747: }
! 1748: else
! 1749: {
! 1750: if ((format_chaine = conversion_majuscule((unsigned char *)
! 1751: (*(*((struct_tableau *) (*s_format).objet))
! 1752: .elements[i]).objet)) == NULL)
! 1753: {
! 1754: (*s_etat_processus).erreur_systeme =
! 1755: d_es_allocation_memoire;
! 1756: return(NULL);
! 1757: }
! 1758:
! 1759: format_degenere = d_faux;
! 1760:
! 1761: if (strncmp("STANDARD*", format_chaine, 9) == 0)
! 1762: {
! 1763: format_sortie = 'S';
! 1764: position_1 = 9;
! 1765: format_degenere = d_vrai;
! 1766: }
! 1767: else if (strncmp("BINARY*", format_chaine, 7) == 0)
! 1768: {
! 1769: format_sortie = 'B';
! 1770: position_1 = 7;
! 1771: }
! 1772: else if (strncmp("FIXED*", format_chaine, 6) == 0)
! 1773: {
! 1774: format_sortie = 'F';
! 1775: position_1 = 6;
! 1776: }
! 1777: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
! 1778: {
! 1779: format_sortie = 'I';
! 1780: position_1 = 11;
! 1781: }
! 1782: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
! 1783: {
! 1784: format_sortie = 'E';
! 1785: position_1 = 9;
! 1786: }
! 1787: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
! 1788: {
! 1789: format_sortie = 'C';
! 1790: position_1 = 10;
! 1791: format_degenere = d_vrai;
! 1792: }
! 1793: else
! 1794: {
! 1795: free(chaine);
! 1796: free(format_chaine);
! 1797:
! 1798: (*s_etat_processus).erreur_execution =
! 1799: d_ex_erreur_format_fichier;
! 1800: return(NULL);
! 1801: }
! 1802:
! 1803: position_3 = strlen(format_chaine);
! 1804: format_chaine[--position_3] = d_code_fin_chaine;
! 1805:
! 1806: position_2 = position_1;
! 1807:
! 1808: while(format_chaine[position_2] != '(')
! 1809: {
! 1810: if (format_chaine[position_2] == d_code_fin_chaine)
! 1811: {
! 1812: free(chaine);
! 1813: free(format_chaine);
! 1814:
! 1815: (*s_etat_processus).erreur_execution =
! 1816: d_ex_erreur_format_fichier;
! 1817: return(NULL);
! 1818: }
! 1819:
! 1820: position_2++;
! 1821: }
! 1822:
! 1823: format_chaine[position_2++] = d_code_fin_chaine;
! 1824:
! 1825: if (format_degenere == d_faux)
! 1826: {
! 1827: if (sscanf(&(format_chaine[position_1]), "%ld",
! 1828: &longueur) != 1)
! 1829: {
! 1830: free(chaine);
! 1831: free(format_chaine);
! 1832:
! 1833: (*s_etat_processus).erreur_execution =
! 1834: d_ex_erreur_format_fichier;
! 1835: return(NULL);
! 1836: }
! 1837: }
! 1838: else
! 1839: {
! 1840: longueur = -1;
! 1841: }
! 1842:
! 1843: if (strcmp(&(format_chaine[position_2]), "*") != 0)
! 1844: {
! 1845: if (sscanf(&(format_chaine[position_2]), "%ld",
! 1846: &longueur_champ) != 1)
! 1847: {
! 1848: free(chaine);
! 1849: free(format_chaine);
! 1850:
! 1851: (*s_etat_processus).erreur_execution =
! 1852: d_ex_erreur_format_fichier;
! 1853: return(NULL);
! 1854: }
! 1855: }
! 1856: else
! 1857: {
! 1858: longueur_champ = -1;
! 1859: }
! 1860:
! 1861: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
! 1862: longueur_champ))
! 1863: {
! 1864: free(chaine);
! 1865: free(format_chaine);
! 1866:
! 1867: (*s_etat_processus).erreur_execution =
! 1868: d_ex_erreur_format_fichier;
! 1869: return(NULL);
! 1870: }
! 1871:
! 1872: free(format_chaine);
! 1873:
! 1874: chaine_sauvegarde = chaine;
! 1875:
! 1876: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 1877: (*((struct_tableau *) (*s_objet).objet))
! 1878: .elements[i], s_format,
! 1879: longueur, longueur_champ, format_sortie, type,
! 1880: longueur_effective, recursivite)) == NULL)
! 1881: {
! 1882: return(NULL);
! 1883: }
! 1884:
! 1885: if ((*(*((struct_tableau *) (*s_objet).objet))
! 1886: .elements[i]).type == CHN)
! 1887: {
! 1888: chaine = (unsigned char *)
! 1889: malloc((strlen(chaine_formatee)
! 1890: + strlen(chaine_sauvegarde) + 4)
! 1891: * sizeof(unsigned char));
! 1892:
! 1893: if (chaine == NULL)
! 1894: {
! 1895: (*s_etat_processus).erreur_systeme =
! 1896: d_es_allocation_memoire;
! 1897: return(NULL);
! 1898: }
! 1899:
! 1900: strcpy(chaine, chaine_sauvegarde);
! 1901: free(chaine_sauvegarde);
! 1902: strcat(chaine, " \"");
! 1903: strcat(chaine, chaine_formatee);
! 1904: free(chaine_formatee);
! 1905: strcat(chaine, "\"");
! 1906: }
! 1907: else if ((*(*((struct_tableau *) (*s_objet).objet))
! 1908: .elements[i]).type == NOM)
! 1909: {
! 1910: chaine = (unsigned char *)
! 1911: malloc((strlen(chaine_formatee)
! 1912: + strlen(chaine_sauvegarde) + 2)
! 1913: * sizeof(unsigned char));
! 1914:
! 1915: if (chaine == NULL)
! 1916: {
! 1917: (*s_etat_processus).erreur_systeme =
! 1918: d_es_allocation_memoire;
! 1919: return(NULL);
! 1920: }
! 1921:
! 1922: sprintf(chaine, "%s %s", chaine_sauvegarde,
! 1923: chaine_formatee);
! 1924: free(chaine_formatee);
! 1925: }
! 1926: else
! 1927: {
! 1928: chaine = (unsigned char *)
! 1929: malloc((strlen(chaine_formatee)
! 1930: + strlen(chaine_sauvegarde) + 2)
! 1931: * sizeof(unsigned char));
! 1932:
! 1933: if (chaine == NULL)
! 1934: {
! 1935: (*s_etat_processus).erreur_systeme =
! 1936: d_es_allocation_memoire;
! 1937: return(NULL);
! 1938: }
! 1939:
! 1940: strcpy(chaine, chaine_sauvegarde);
! 1941: free(chaine_sauvegarde);
! 1942: strcat(chaine, " ");
! 1943: strcat(chaine, chaine_formatee);
! 1944: free(chaine_formatee);
! 1945: }
! 1946: }
! 1947: }
! 1948:
! 1949: chaine_sauvegarde = chaine;
! 1950: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
! 1951: * sizeof(unsigned char));
! 1952:
! 1953: if (chaine == NULL)
! 1954: {
! 1955: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1956: return(NULL);
! 1957: }
! 1958:
! 1959: strcpy(chaine, chaine_sauvegarde);
! 1960: free(chaine_sauvegarde);
! 1961: strcat(chaine, " ]>");
! 1962: }
! 1963: else if ((*s_objet).type == MCX)
! 1964: {
! 1965:
! 1966: /*
! 1967: --------------------------------------------------------------------------------
! 1968: Matrice complexe
! 1969: --------------------------------------------------------------------------------
! 1970: */
! 1971:
! 1972: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 1973: (format_sortie != 'I') && (format_sortie != 'E'))
! 1974: {
! 1975: (*s_etat_processus).erreur_execution =
! 1976: d_ex_erreur_format_fichier;
! 1977: return(NULL);
! 1978: }
! 1979:
! 1980: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 1981: .nombre_lignes;
! 1982: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 1983: .nombre_colonnes;
! 1984:
! 1985: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 1986:
! 1987: if (chaine != NULL)
! 1988: {
! 1989: strcpy(chaine, "[[");
! 1990:
! 1991: for(i = 0; i < nombre_lignes; i++)
! 1992: {
! 1993: for(j = 0; j < nombre_colonnes; j++)
! 1994: {
! 1995: if ((chaine_formatee =
! 1996: formateur_fichier_nombre(s_etat_processus,
! 1997: (void *) &(((struct_complexe16 **)
! 1998: ((*((struct_matrice *)
! 1999: ((*s_objet).objet))).tableau))[i][j]), 'C',
! 2000: longueur, longueur_champ, format_sortie))
! 2001: == NULL)
! 2002: {
! 2003: (*s_etat_processus).erreur_systeme =
! 2004: d_es_allocation_memoire;
! 2005: return(NULL);
! 2006: }
! 2007:
! 2008: chaine_sauvegarde = chaine;
! 2009: chaine = (unsigned char *) malloc(
! 2010: (strlen(chaine_sauvegarde) +
! 2011: strlen(chaine_formatee) + 2)
! 2012: * sizeof(unsigned char));
! 2013:
! 2014: if (chaine == NULL)
! 2015: {
! 2016: (*s_etat_processus).erreur_systeme =
! 2017: d_es_allocation_memoire;
! 2018: return(NULL);
! 2019: }
! 2020:
! 2021: strcpy(chaine, chaine_sauvegarde);
! 2022: free(chaine_sauvegarde);
! 2023: strcat(chaine, " ");
! 2024: strcat(chaine, chaine_formatee);
! 2025: free(chaine_formatee);
! 2026: }
! 2027:
! 2028: chaine_sauvegarde = chaine;
! 2029: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2030: {
! 2031: chaine = (unsigned char *) malloc(
! 2032: (strlen(chaine_sauvegarde) + 6)
! 2033: * sizeof(unsigned char));
! 2034:
! 2035: if (chaine == NULL)
! 2036: {
! 2037: (*s_etat_processus).erreur_systeme =
! 2038: d_es_allocation_memoire;
! 2039: return(NULL);
! 2040: }
! 2041:
! 2042: strcpy(chaine, chaine_sauvegarde);
! 2043: free(chaine_sauvegarde);
! 2044: strcat(chaine, " ]\n [");
! 2045: }
! 2046: else
! 2047: {
! 2048: chaine = (unsigned char *) malloc(
! 2049: (strlen(chaine_sauvegarde) + 4)
! 2050: * sizeof(unsigned char));
! 2051:
! 2052: if (chaine == NULL)
! 2053: {
! 2054: (*s_etat_processus).erreur_systeme =
! 2055: d_es_allocation_memoire;
! 2056: return(NULL);
! 2057: }
! 2058:
! 2059: strcpy(chaine, chaine_sauvegarde);
! 2060: free(chaine_sauvegarde);
! 2061: strcat(chaine, " ][");
! 2062: }
! 2063: }
! 2064:
! 2065: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2066: {
! 2067: chaine[strlen(chaine) - 3] = ']';
! 2068: chaine[strlen(chaine) - 2] = 0;
! 2069:
! 2070: chaine_sauvegarde = chaine;
! 2071: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2072: + 1) * sizeof(unsigned char));
! 2073:
! 2074: if (chaine == NULL)
! 2075: {
! 2076: (*s_etat_processus).erreur_systeme =
! 2077: d_es_allocation_memoire;
! 2078: return(NULL);
! 2079: }
! 2080:
! 2081: strcpy(chaine, chaine_sauvegarde);
! 2082: free(chaine_sauvegarde);
! 2083: }
! 2084: else
! 2085: {
! 2086: chaine[strlen(chaine) - 2] = ']';
! 2087: chaine[strlen(chaine) - 1] = 0;
! 2088:
! 2089: chaine_sauvegarde = chaine;
! 2090: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2091: + 2) * sizeof(unsigned char));
! 2092:
! 2093: if (chaine == NULL)
! 2094: {
! 2095: (*s_etat_processus).erreur_systeme =
! 2096: d_es_allocation_memoire;
! 2097: return(NULL);
! 2098: }
! 2099:
! 2100: strcpy(chaine, chaine_sauvegarde);
! 2101: free(chaine_sauvegarde);
! 2102: strcat(chaine, "]");
! 2103: }
! 2104: }
! 2105: }
! 2106: else if ((*s_objet).type == MIN)
! 2107: {
! 2108:
! 2109: /*
! 2110: --------------------------------------------------------------------------------
! 2111: Matrice entière
! 2112: --------------------------------------------------------------------------------
! 2113: */
! 2114:
! 2115: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2116: (format_sortie != 'I') && (format_sortie != 'E'))
! 2117: {
! 2118: (*s_etat_processus).erreur_execution =
! 2119: d_ex_erreur_format_fichier;
! 2120: return(NULL);
! 2121: }
! 2122:
! 2123: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 2124: .nombre_lignes;
! 2125: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 2126: .nombre_colonnes;
! 2127:
! 2128: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 2129:
! 2130: if (chaine != NULL)
! 2131: {
! 2132: strcpy(chaine, "[[");
! 2133:
! 2134: for(i = 0; i < nombre_lignes; i++)
! 2135: {
! 2136: for(j = 0; j < nombre_colonnes; j++)
! 2137: {
! 2138: if ((chaine_formatee =
! 2139: formateur_fichier_nombre(s_etat_processus,
! 2140: (void *) &(((integer8 **) ((*((struct_matrice *)
! 2141: ((*s_objet).objet))).tableau))[i][j]), 'I',
! 2142: longueur, longueur_champ, format_sortie))
! 2143: == NULL)
! 2144: {
! 2145: (*s_etat_processus).erreur_systeme =
! 2146: d_es_allocation_memoire;
! 2147: return(NULL);
! 2148: }
! 2149:
! 2150: chaine_sauvegarde = chaine;
! 2151: chaine = (unsigned char *) malloc(
! 2152: (strlen(chaine_sauvegarde) +
! 2153: strlen(chaine_formatee) + 2)
! 2154: * sizeof(unsigned char));
! 2155:
! 2156: if (chaine == NULL)
! 2157: {
! 2158: (*s_etat_processus).erreur_systeme =
! 2159: d_es_allocation_memoire;
! 2160: return(NULL);
! 2161: }
! 2162:
! 2163: strcpy(chaine, chaine_sauvegarde);
! 2164: free(chaine_sauvegarde);
! 2165: strcat(chaine, " ");
! 2166: strcat(chaine, chaine_formatee);
! 2167: free(chaine_formatee);
! 2168: }
! 2169:
! 2170: chaine_sauvegarde = chaine;
! 2171: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2172: {
! 2173: chaine = (unsigned char *) malloc(
! 2174: (strlen(chaine_sauvegarde) + 6)
! 2175: * sizeof(unsigned char));
! 2176:
! 2177: if (chaine == NULL)
! 2178: {
! 2179: (*s_etat_processus).erreur_systeme =
! 2180: d_es_allocation_memoire;
! 2181: return(NULL);
! 2182: }
! 2183:
! 2184: strcpy(chaine, chaine_sauvegarde);
! 2185: free(chaine_sauvegarde);
! 2186: strcat(chaine, " ]\n [");
! 2187: }
! 2188: else
! 2189: {
! 2190: chaine = (unsigned char *) malloc(
! 2191: (strlen(chaine_sauvegarde) + 4)
! 2192: * sizeof(unsigned char));
! 2193:
! 2194: if (chaine == NULL)
! 2195: {
! 2196: (*s_etat_processus).erreur_systeme =
! 2197: d_es_allocation_memoire;
! 2198: return(NULL);
! 2199: }
! 2200:
! 2201: strcpy(chaine, chaine_sauvegarde);
! 2202: free(chaine_sauvegarde);
! 2203: strcat(chaine, " ][");
! 2204: }
! 2205: }
! 2206:
! 2207: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2208: {
! 2209: chaine[strlen(chaine) - 3] = ']';
! 2210: chaine[strlen(chaine) - 2] = 0;
! 2211:
! 2212: chaine_sauvegarde = chaine;
! 2213: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2214: + 1) * sizeof(unsigned char));
! 2215:
! 2216: if (chaine == NULL)
! 2217: {
! 2218: (*s_etat_processus).erreur_systeme =
! 2219: d_es_allocation_memoire;
! 2220: return(NULL);
! 2221: }
! 2222:
! 2223: strcpy(chaine, chaine_sauvegarde);
! 2224: free(chaine_sauvegarde);
! 2225: }
! 2226: else
! 2227: {
! 2228: chaine[strlen(chaine) - 2] = ']';
! 2229: chaine[strlen(chaine) - 1] = 0;
! 2230:
! 2231: chaine_sauvegarde = chaine;
! 2232: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2233: + 2) * sizeof(unsigned char));
! 2234:
! 2235: if (chaine == NULL)
! 2236: {
! 2237: (*s_etat_processus).erreur_systeme =
! 2238: d_es_allocation_memoire;
! 2239: return(NULL);
! 2240: }
! 2241:
! 2242: strcpy(chaine, chaine_sauvegarde);
! 2243: free(chaine_sauvegarde);
! 2244: strcat(chaine, "]");
! 2245: }
! 2246: }
! 2247: }
! 2248: else if ((*s_objet).type == MRL)
! 2249: {
! 2250:
! 2251: /*
! 2252: --------------------------------------------------------------------------------
! 2253: Matrice réelle
! 2254: --------------------------------------------------------------------------------
! 2255: */
! 2256:
! 2257: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2258: (format_sortie != 'I') && (format_sortie != 'E'))
! 2259: {
! 2260: (*s_etat_processus).erreur_execution =
! 2261: d_ex_erreur_format_fichier;
! 2262: return(NULL);
! 2263: }
! 2264:
! 2265: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 2266: .nombre_lignes;
! 2267: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 2268: .nombre_colonnes;
! 2269:
! 2270: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 2271:
! 2272: if (chaine != NULL)
! 2273: {
! 2274: strcpy(chaine, "[[");
! 2275:
! 2276: for(i = 0; i < nombre_lignes; i++)
! 2277: {
! 2278: for(j = 0; j < nombre_colonnes; j++)
! 2279: {
! 2280: if ((chaine_formatee =
! 2281: formateur_fichier_nombre(s_etat_processus,
! 2282: (void *) &(((real8 **) ((*((struct_matrice *)
! 2283: ((*s_objet).objet))).tableau))[i][j]), 'R',
! 2284: longueur, longueur_champ, format_sortie))
! 2285: == NULL)
! 2286: {
! 2287: (*s_etat_processus).erreur_systeme =
! 2288: d_es_allocation_memoire;
! 2289: return(NULL);
! 2290: }
! 2291:
! 2292: chaine_sauvegarde = chaine;
! 2293: chaine = (unsigned char *) malloc(
! 2294: (strlen(chaine_sauvegarde) +
! 2295: strlen(chaine_formatee) + 2)
! 2296: * sizeof(unsigned char));
! 2297:
! 2298: if (chaine == NULL)
! 2299: {
! 2300: (*s_etat_processus).erreur_systeme =
! 2301: d_es_allocation_memoire;
! 2302: return(NULL);
! 2303: }
! 2304:
! 2305: strcpy(chaine, chaine_sauvegarde);
! 2306: free(chaine_sauvegarde);
! 2307: strcat(chaine, " ");
! 2308: strcat(chaine, chaine_formatee);
! 2309: free(chaine_formatee);
! 2310: }
! 2311:
! 2312: chaine_sauvegarde = chaine;
! 2313: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2314: {
! 2315: chaine = (unsigned char *) malloc(
! 2316: (strlen(chaine_sauvegarde) + 6)
! 2317: * sizeof(unsigned char));
! 2318:
! 2319: if (chaine == NULL)
! 2320: {
! 2321: (*s_etat_processus).erreur_systeme =
! 2322: d_es_allocation_memoire;
! 2323: return(NULL);
! 2324: }
! 2325:
! 2326: strcpy(chaine, chaine_sauvegarde);
! 2327: free(chaine_sauvegarde);
! 2328: strcat(chaine, " ]\n [");
! 2329: }
! 2330: else
! 2331: {
! 2332: chaine = (unsigned char *) malloc(
! 2333: (strlen(chaine_sauvegarde) + 4)
! 2334: * sizeof(unsigned char));
! 2335:
! 2336: if (chaine == NULL)
! 2337: {
! 2338: (*s_etat_processus).erreur_systeme =
! 2339: d_es_allocation_memoire;
! 2340: return(NULL);
! 2341: }
! 2342:
! 2343: strcpy(chaine, chaine_sauvegarde);
! 2344: free(chaine_sauvegarde);
! 2345: strcat(chaine, " ][");
! 2346: }
! 2347: }
! 2348:
! 2349: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 2350: {
! 2351: chaine[strlen(chaine) - 3] = ']';
! 2352: chaine[strlen(chaine) - 2] = 0;
! 2353:
! 2354: chaine_sauvegarde = chaine;
! 2355: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2356: + 1) * sizeof(unsigned char));
! 2357:
! 2358: if (chaine == NULL)
! 2359: {
! 2360: (*s_etat_processus).erreur_systeme =
! 2361: d_es_allocation_memoire;
! 2362: return(NULL);
! 2363: }
! 2364:
! 2365: strcpy(chaine, chaine_sauvegarde);
! 2366: free(chaine_sauvegarde);
! 2367: }
! 2368: else
! 2369: {
! 2370: chaine[strlen(chaine) - 2] = ']';
! 2371: chaine[strlen(chaine) - 1] = 0;
! 2372:
! 2373: chaine_sauvegarde = chaine;
! 2374: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 2375: + 2) * sizeof(unsigned char));
! 2376:
! 2377: if (chaine == NULL)
! 2378: {
! 2379: (*s_etat_processus).erreur_systeme =
! 2380: d_es_allocation_memoire;
! 2381: return(NULL);
! 2382: }
! 2383:
! 2384: strcpy(chaine, chaine_sauvegarde);
! 2385: free(chaine_sauvegarde);
! 2386: strcat(chaine, "]");
! 2387: }
! 2388: }
! 2389: }
! 2390: else if ((*s_objet).type == NOM)
! 2391: {
! 2392:
! 2393: /*
! 2394: --------------------------------------------------------------------------------
! 2395: Nom
! 2396: --------------------------------------------------------------------------------
! 2397: */
! 2398:
! 2399: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
! 2400: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
! 2401:
! 2402: if (chaine == NULL)
! 2403: {
! 2404: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2405: return(NULL);
! 2406: }
! 2407:
! 2408: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
! 2409: }
! 2410: else if ((*s_objet).type == REL)
! 2411: {
! 2412:
! 2413: /*
! 2414: --------------------------------------------------------------------------------
! 2415: Réel
! 2416: --------------------------------------------------------------------------------
! 2417: */
! 2418:
! 2419: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2420: (format_sortie != 'I') && (format_sortie != 'E'))
! 2421: {
! 2422: (*s_etat_processus).erreur_execution =
! 2423: d_ex_erreur_format_fichier;
! 2424: return(NULL);
! 2425: }
! 2426:
! 2427: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
! 2428: (void *) ((real8 *) ((*s_objet).objet)), 'R',
! 2429: longueur, longueur_champ, format_sortie)) == NULL)
! 2430: {
! 2431: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2432: return(NULL);
! 2433: }
! 2434:
! 2435: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
! 2436: * sizeof(unsigned char));
! 2437:
! 2438: if (chaine == NULL)
! 2439: {
! 2440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2441: return(NULL);
! 2442: }
! 2443:
! 2444: strcpy(chaine, chaine_formatee);
! 2445: free(chaine_formatee);
! 2446: }
! 2447: else if ((*s_objet).type == VCX)
! 2448: {
! 2449:
! 2450: /*
! 2451: --------------------------------------------------------------------------------
! 2452: Vecteur complexe
! 2453: --------------------------------------------------------------------------------
! 2454: */
! 2455:
! 2456: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2457: (format_sortie != 'I') && (format_sortie != 'E'))
! 2458: {
! 2459: (*s_etat_processus).erreur_execution =
! 2460: d_ex_erreur_format_fichier;
! 2461: return(NULL);
! 2462: }
! 2463:
! 2464: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 2465: .taille;
! 2466:
! 2467: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 2468:
! 2469: if (chaine != NULL)
! 2470: {
! 2471: strcpy(chaine, "[");
! 2472:
! 2473: for(i = 0; i < nombre_colonnes; i++)
! 2474: {
! 2475: if ((chaine_formatee =
! 2476: formateur_fichier_nombre(s_etat_processus,
! 2477: (void *) &(((struct_complexe16 *)
! 2478: ((*((struct_vecteur *)
! 2479: ((*s_objet).objet))).tableau))[i]), 'C',
! 2480: longueur, longueur_champ, format_sortie)) == NULL)
! 2481: {
! 2482: (*s_etat_processus).erreur_systeme =
! 2483: d_es_allocation_memoire;
! 2484: return(NULL);
! 2485: }
! 2486:
! 2487: chaine_sauvegarde = chaine;
! 2488: chaine = (unsigned char *) malloc(
! 2489: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 2490: + 2) * sizeof(unsigned char));
! 2491:
! 2492: if (chaine == NULL)
! 2493: {
! 2494: (*s_etat_processus).erreur_systeme =
! 2495: d_es_allocation_memoire;
! 2496: return(NULL);
! 2497: }
! 2498:
! 2499: strcpy(chaine, chaine_sauvegarde);
! 2500: free(chaine_sauvegarde);
! 2501: strcat(chaine, " ");
! 2502: strcat(chaine, chaine_formatee);
! 2503: free(chaine_formatee);
! 2504: }
! 2505:
! 2506: chaine_sauvegarde = chaine;
! 2507: chaine = (unsigned char *) malloc(
! 2508: (strlen(chaine_sauvegarde) + 3)
! 2509: * sizeof(unsigned char));
! 2510:
! 2511: if (chaine == NULL)
! 2512: {
! 2513: (*s_etat_processus).erreur_systeme =
! 2514: d_es_allocation_memoire;
! 2515: return(NULL);
! 2516: }
! 2517:
! 2518: strcpy(chaine, chaine_sauvegarde);
! 2519: free(chaine_sauvegarde);
! 2520: strcat(chaine, " ]");
! 2521: }
! 2522: }
! 2523: else if ((*s_objet).type == VIN)
! 2524: {
! 2525:
! 2526: /*
! 2527: --------------------------------------------------------------------------------
! 2528: Vecteur entier
! 2529: --------------------------------------------------------------------------------
! 2530: */
! 2531:
! 2532: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2533: (format_sortie != 'I') && (format_sortie != 'E'))
! 2534: {
! 2535: (*s_etat_processus).erreur_execution =
! 2536: d_ex_erreur_format_fichier;
! 2537: return(NULL);
! 2538: }
! 2539:
! 2540: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 2541: .taille;
! 2542:
! 2543: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 2544:
! 2545: if (chaine != NULL)
! 2546: {
! 2547: strcpy(chaine, "[");
! 2548:
! 2549: for(i = 0; i < nombre_colonnes; i++)
! 2550: {
! 2551: if ((chaine_formatee =
! 2552: formateur_fichier_nombre(s_etat_processus,
! 2553: (void *) &(((integer8 *) ((*((struct_vecteur *)
! 2554: ((*s_objet).objet))).tableau))[i]), 'I',
! 2555: longueur, longueur_champ, format_sortie)) == NULL)
! 2556: {
! 2557: (*s_etat_processus).erreur_systeme =
! 2558: d_es_allocation_memoire;
! 2559: return(NULL);
! 2560: }
! 2561:
! 2562: chaine_sauvegarde = chaine;
! 2563: chaine = (unsigned char *) malloc(
! 2564: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 2565: + 2) * sizeof(unsigned char));
! 2566:
! 2567: if (chaine == NULL)
! 2568: {
! 2569: (*s_etat_processus).erreur_systeme =
! 2570: d_es_allocation_memoire;
! 2571: return(NULL);
! 2572: }
! 2573:
! 2574: strcpy(chaine, chaine_sauvegarde);
! 2575: free(chaine_sauvegarde);
! 2576: strcat(chaine, " ");
! 2577: strcat(chaine, chaine_formatee);
! 2578: free(chaine_formatee);
! 2579: }
! 2580:
! 2581: chaine_sauvegarde = chaine;
! 2582: chaine = (unsigned char *) malloc(
! 2583: (strlen(chaine_sauvegarde) + 3)
! 2584: * sizeof(unsigned char));
! 2585:
! 2586: if (chaine == NULL)
! 2587: {
! 2588: (*s_etat_processus).erreur_systeme =
! 2589: d_es_allocation_memoire;
! 2590: return(NULL);
! 2591: }
! 2592:
! 2593: strcpy(chaine, chaine_sauvegarde);
! 2594: free(chaine_sauvegarde);
! 2595: strcat(chaine, " ]");
! 2596: }
! 2597: }
! 2598: else if ((*s_objet).type == VRL)
! 2599: {
! 2600:
! 2601: /*
! 2602: --------------------------------------------------------------------------------
! 2603: Vecteur réel
! 2604: --------------------------------------------------------------------------------
! 2605: */
! 2606:
! 2607: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 2608: (format_sortie != 'I') && (format_sortie != 'E'))
! 2609: {
! 2610: (*s_etat_processus).erreur_execution =
! 2611: d_ex_erreur_format_fichier;
! 2612: return(NULL);
! 2613: }
! 2614:
! 2615: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 2616: .taille;
! 2617:
! 2618: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 2619:
! 2620: if (chaine != NULL)
! 2621: {
! 2622: strcpy(chaine, "[");
! 2623:
! 2624: for(i = 0; i < nombre_colonnes; i++)
! 2625: {
! 2626: if ((chaine_formatee =
! 2627: formateur_fichier_nombre(s_etat_processus,
! 2628: (void *) &(((real8 *) ((*((struct_vecteur *)
! 2629: ((*s_objet).objet))).tableau))[i]), 'R',
! 2630: longueur, longueur_champ, format_sortie)) == NULL)
! 2631: {
! 2632: (*s_etat_processus).erreur_systeme =
! 2633: d_es_allocation_memoire;
! 2634: return(NULL);
! 2635: }
! 2636:
! 2637: chaine_sauvegarde = chaine;
! 2638: chaine = (unsigned char *) malloc(
! 2639: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 2640: + 2) * sizeof(unsigned char));
! 2641:
! 2642: if (chaine == NULL)
! 2643: {
! 2644: (*s_etat_processus).erreur_systeme =
! 2645: d_es_allocation_memoire;
! 2646: return(NULL);
! 2647: }
! 2648:
! 2649: strcpy(chaine, chaine_sauvegarde);
! 2650: free(chaine_sauvegarde);
! 2651: strcat(chaine, " ");
! 2652: strcat(chaine, chaine_formatee);
! 2653: free(chaine_formatee);
! 2654: }
! 2655:
! 2656: chaine_sauvegarde = chaine;
! 2657: chaine = (unsigned char *) malloc(
! 2658: (strlen(chaine_sauvegarde) + 3)
! 2659: * sizeof(unsigned char));
! 2660:
! 2661: if (chaine == NULL)
! 2662: {
! 2663: (*s_etat_processus).erreur_systeme =
! 2664: d_es_allocation_memoire;
! 2665: return(NULL);
! 2666: }
! 2667:
! 2668: strcpy(chaine, chaine_sauvegarde);
! 2669: free(chaine_sauvegarde);
! 2670: strcat(chaine, " ]");
! 2671: }
! 2672: }
! 2673: else
! 2674: {
! 2675: // Type non exportable
! 2676:
! 2677: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
! 2678: free(chaine);
! 2679:
! 2680: return(NULL);
! 2681: }
! 2682:
! 2683: (*longueur_effective) = strlen(chaine) + 1;
! 2684: }
! 2685: else
! 2686: {
! 2687: /*
! 2688: * Fichiers non formatés
! 2689: */
! 2690:
! 2691: #define __zone() \
! 2692: do { int _i; for(_i = 0; _i < longueur_totale; _i++) \
! 2693: printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)
! 2694:
! 2695: /*
! 2696: * Chaque enregistrement est composé d'une donnée (une liste)
! 2697: * suivie de sa longueur en octets et d'un champ binaire indiquant
! 2698: * le format (integer*1,2,4 ou 8) d'écriture de cette longueur.
! 2699: * Les données contenues dans ces fichiers sont associées à un
! 2700: * descripteur de type.
! 2701: *
! 2702: * Attention : les fichiers non formatés ne sont pas portables
! 2703: * d'une architecture à l'autre.
! 2704: *
! 2705: * Structure d'un enregistrement :
! 2706: * [en-tête][.........données..........][longueur + type de longueur]
! 2707: *
! 2708: * Longueur : (pour l'instruction backspace)
! 2709: *
! 2710: * 00 XXXXXX longueur sur 6 bits
! 2711: * 01 ------ longueur sur 16 bits
! 2712: * 10 ------ longueur sur 32 bits
! 2713: * 11 ------ longueur sur 64 bits
! 2714: *
! 2715: * Structures des enregistrements :
! 2716: * chaque type de donnée est associé à une en-tête binaire comprenant
! 2717: * le type de données ainsi que toutes autres informations utiles.
! 2718: *
! 2719: * Représentation binaire :
! 2720: *
! 2721: * 1/ scalaires
! 2722: * 0000 XXXX Binaire sur XXXX octets
! 2723: *
! 2724: * TYPE
! 2725: * 0001 00 00 integer*1
! 2726: * 0001 00 01 integer*2
! 2727: * 0001 00 10 integer*4
! 2728: * 0001 00 11 integer*8
! 2729: *
! 2730: * 0001 01 00 real*4
! 2731: * 0001 01 01 real*8
! 2732: *
! 2733: * 0001 10 00 complex*8
! 2734: * 0001 10 01 complex*16
! 2735: *
! 2736: * 0010 00 00 vecteur integer*1 (dimensions integer*1)
! 2737: * 0010 01 00 vecteur integer*1 (dimensions integer*2)
! 2738: * 0010 10 00 vecteur integer*1 (dimensions integer*4)
! 2739: * 0010 11 00 vecteur integer*1 (dimensions integer*8)
! 2740: * 0010 00 01 vecteur integer*2 (dimensions integer*1)
! 2741: * 0010 01 01 vecteur integer*2 (dimensions integer*2)
! 2742: * 0010 10 01 vecteur integer*2 (dimensions integer*4)
! 2743: * 0010 11 01 vecteur integer*2 (dimensions integer*8)
! 2744: * 0010 00 10 vecteur integer*4 (dimensions integer*1)
! 2745: * 0010 01 10 vecteur integer*4 (dimensions integer*2)
! 2746: * 0010 10 10 vecteur integer*4 (dimensions integer*4)
! 2747: * 0010 11 10 vecteur integer*4 (dimensions integer*8)
! 2748: * 0010 00 11 vecteur integer*8 (dimensions integer*1)
! 2749: * 0010 01 11 vecteur integer*8 (dimensions integer*2)
! 2750: * 0010 10 11 vecteur integer*8 (dimensions integer*4)
! 2751: * 0010 11 11 vecteur integer*8 (dimensions integer*8)
! 2752: *
! 2753: * 0011 00 00 matrice integer*1 (dimensions integer*1)
! 2754: * 0011 01 00 matrice integer*1 (dimensions integer*2)
! 2755: * 0011 10 00 matrice integer*1 (dimensions integer*4)
! 2756: * 0011 11 00 matrice integer*1 (dimensions integer*8)
! 2757: * 0011 00 01 matrice integer*2 (dimensions integer*1)
! 2758: * 0011 01 01 matrice integer*2 (dimensions integer*2)
! 2759: * 0011 10 01 matrice integer*2 (dimensions integer*4)
! 2760: * 0011 11 01 matrice integer*2 (dimensions integer*8)
! 2761: * 0011 00 10 matrice integer*4 (dimensions integer*1)
! 2762: * 0011 01 10 matrice integer*4 (dimensions integer*2)
! 2763: * 0011 10 10 matrice integer*4 (dimensions integer*4)
! 2764: * 0011 11 10 matrice integer*4 (dimensions integer*8)
! 2765: * 0011 00 11 matrice integer*8 (dimensions integer*1)
! 2766: * 0011 01 11 matrice integer*8 (dimensions integer*2)
! 2767: * 0011 10 11 matrice integer*8 (dimensions integer*4)
! 2768: * 0011 11 11 matrice integer*8 (dimensions integer*8)
! 2769: *
! 2770: * 0100 0 XXX liste de longueur XXX
! 2771: * 0100 10 00 liste de longueur integer*1
! 2772: * 0100 10 01 liste de longueur integer*2
! 2773: * 0100 10 10 liste de longueur integer*4
! 2774: * 0100 10 11 liste de longueur integer*8
! 2775: *
! 2776: * 0101 0 XXX nom de longueur XXX
! 2777: * 0101 10 LL nom de longueur integer*LL
! 2778: *
! 2779: * 0110 0 XXX expression RPN
! 2780: * 0110 10 LL
! 2781: *
! 2782: * 0111 0 XXX expression algébrique
! 2783: * 0111 10 LL
! 2784: *
! 2785: * 1000 0 XXX chaîne de caractères
! 2786: * 1000 10 LL
! 2787: *
! 2788: * 1001 0 XXX table de longueur XXX
! 2789: * 1001 10 00 table de longueur integer*1
! 2790: * 1001 10 01 table de longueur integer*2
! 2791: * 1001 10 10 table de longueur integer*4
! 2792: * 1001 10 11 table de longueur integer*8
! 2793: *
! 2794: * Les longueurs indiquées par le champ LL suivent l'en-tête :
! 2795: * [En-tête][longueur_1][longueur_2][données]
! 2796: * le nombre de champs longueur dépendant des types d'enregistrement.
! 2797: *
! 2798: * Toutes les autres combinaisons sont invalides.
! 2799: */
! 2800:
! 2801: chaine = NULL;
! 2802: chaine_formatee = NULL;
! 2803: chaine_sauvegarde = NULL;
! 2804:
! 2805: strcpy(base, " ");
! 2806:
! 2807: longueur_binaire = 0;
! 2808: masque_binaire = 0;
! 2809:
! 2810: if ((*s_objet).type == ALG)
! 2811: {
! 2812:
! 2813: /*
! 2814: --------------------------------------------------------------------------------
! 2815: Expression algébrique
! 2816: --------------------------------------------------------------------------------
! 2817: */
! 2818:
! 2819: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 2820:
! 2821: while(l_element_courant != NULL)
! 2822: {
! 2823: if ((*(*l_element_courant).donnee).type == FCT)
! 2824: {
! 2825: if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
! 2826: .donnee).objet)).nom_fonction, "<<") != 0) &&
! 2827: (strcmp((*((struct_fonction *)
! 2828: (*(*l_element_courant)
! 2829: .donnee).objet)).nom_fonction, ">>") != 0))
! 2830: {
! 2831: if ((strcmp((*((struct_fonction *)
! 2832: (*(*l_element_courant)
! 2833: .donnee).objet)).nom_fonction, "+") == 0) ||
! 2834: (strcmp((*((struct_fonction *)
! 2835: (*(*l_element_courant).donnee).objet))
! 2836: .nom_fonction, "-") == 0) || (strcmp(
! 2837: (*((struct_fonction *) (*(*l_element_courant)
! 2838: .donnee).objet)).nom_fonction, "*") == 0) ||
! 2839: (strcmp((*((struct_fonction *)
! 2840: (*(*l_element_courant).donnee).objet))
! 2841: .nom_fonction,
! 2842: "/") == 0) || (strcmp((*((struct_fonction *)
! 2843: (*(*l_element_courant).donnee).objet))
! 2844: .nom_fonction,
! 2845: "^") == 0) || (strcmp((*((struct_fonction *)
! 2846: (*(*l_element_courant).donnee).objet))
! 2847: .nom_fonction,
! 2848: "<") == 0) || (strcmp((*((struct_fonction *)
! 2849: (*(*l_element_courant).donnee).objet))
! 2850: .nom_fonction,
! 2851: ">") == 0) || (strcmp((*((struct_fonction *)
! 2852: (*(*l_element_courant).donnee).objet))
! 2853: .nom_fonction,
! 2854: "==") == 0) || (strcmp((*((struct_fonction *)
! 2855: (*(*l_element_courant).donnee).objet))
! 2856: .nom_fonction,
! 2857: "<>") == 0) || (strcmp((*((struct_fonction *)
! 2858: (*(*l_element_courant).donnee).objet))
! 2859: .nom_fonction,
! 2860: "<=") == 0) || (strcmp((*((struct_fonction *)
! 2861: (*(*l_element_courant).donnee).objet))
! 2862: .nom_fonction,
! 2863: "=<") == 0) || (strcmp((*((struct_fonction *)
! 2864: (*(*l_element_courant).donnee).objet))
! 2865: .nom_fonction,
! 2866: ">=") == 0) || (strcmp((*((struct_fonction *)
! 2867: (*(*l_element_courant).donnee).objet))
! 2868: .nom_fonction,
! 2869: "=>") == 0))
! 2870: {
! 2871: if (depilement(s_etat_processus,
! 2872: &((*s_etat_processus)
! 2873: .l_base_pile), &s_sous_objet_2) == d_erreur)
! 2874: {
! 2875: return(NULL);
! 2876: }
! 2877:
! 2878: chaine_sauvegarde = (*s_etat_processus)
! 2879: .instruction_courante;
! 2880:
! 2881: if (((*s_etat_processus).instruction_courante =
! 2882: (unsigned char *) malloc((strlen(
! 2883: (unsigned char *) (*s_sous_objet_2).objet)
! 2884: + 2 + 1) * sizeof(unsigned char))) == NULL)
! 2885: {
! 2886: (*s_etat_processus).instruction_courante =
! 2887: chaine_sauvegarde;
! 2888: (*s_etat_processus).erreur_systeme =
! 2889: d_es_allocation_memoire;
! 2890: return(NULL);
! 2891: }
! 2892:
! 2893: sprintf((*s_etat_processus).instruction_courante,
! 2894: "'%s'", (unsigned char *)
! 2895: (*s_sous_objet_2).objet);
! 2896:
! 2897: presence_signe = (((*s_etat_processus)
! 2898: .instruction_courante[1] == '+')
! 2899: || ((*s_etat_processus)
! 2900: .instruction_courante[1]
! 2901: == '-')) ? d_vrai : d_faux;
! 2902:
! 2903: recherche_type(s_etat_processus);
! 2904:
! 2905: if ((*s_etat_processus).erreur_execution != d_ex)
! 2906: {
! 2907: // Aucune erreur ne peut être renvoyée.
! 2908:
! 2909: return(NULL);
! 2910: }
! 2911:
! 2912: if (depilement(s_etat_processus,
! 2913: &((*s_etat_processus)
! 2914: .l_base_pile), &s_sous_objet_3) == d_erreur)
! 2915: {
! 2916: return(NULL);
! 2917: }
! 2918:
! 2919: free((*s_etat_processus).instruction_courante);
! 2920:
! 2921: (*s_etat_processus).instruction_courante =
! 2922: chaine_sauvegarde;
! 2923:
! 2924: autorisation_parenthese = d_faux;
! 2925:
! 2926: if ((*s_sous_objet_3).type == ALG)
! 2927: {
! 2928: l_atome = (struct_liste_chainee *)
! 2929: (*s_sous_objet_3).objet;
! 2930: chaine_fonction = "";
! 2931: nombre_arguments_fonction = 0;
! 2932:
! 2933: while(l_atome != NULL)
! 2934: {
! 2935: if ((*(*l_atome).donnee).type == FCT)
! 2936: {
! 2937: if (strcmp((*((struct_fonction *)
! 2938: (*(*l_atome).donnee).objet))
! 2939: .nom_fonction, ">>") != 0)
! 2940: {
! 2941: chaine_fonction =
! 2942: (*((struct_fonction *)
! 2943: (*(*l_atome).donnee).objet))
! 2944: .nom_fonction;
! 2945: nombre_arguments_fonction =
! 2946: (*((struct_fonction *)
! 2947: (*(*l_atome).donnee).objet))
! 2948: .nombre_arguments;
! 2949: }
! 2950: }
! 2951:
! 2952: l_atome = (*l_atome).suivant;
! 2953: }
! 2954:
! 2955: if (strcmp((*((struct_fonction *)
! 2956: (*(*l_element_courant).donnee).objet))
! 2957: .nom_fonction, "+") == 0)
! 2958: {
! 2959: if ((strcmp(chaine_fonction, "AND") == 0) ||
! 2960: (strcmp(chaine_fonction, "XOR") ==
! 2961: 0) || (strcmp(chaine_fonction, "OR")
! 2962: == 0))
! 2963: {
! 2964: autorisation_parenthese = d_vrai;
! 2965: }
! 2966: }
! 2967: else if (strcmp((*((struct_fonction *)
! 2968: (*(*l_element_courant).donnee).objet))
! 2969: .nom_fonction, "-") == 0)
! 2970: {
! 2971: if (nombre_arguments_fonction != 0)
! 2972: {
! 2973: autorisation_parenthese = d_faux;
! 2974: }
! 2975: else
! 2976: {
! 2977: autorisation_parenthese = d_vrai;
! 2978: }
! 2979: }
! 2980: else if (strcmp((*((struct_fonction *)
! 2981: (*(*l_element_courant).donnee).objet))
! 2982: .nom_fonction, "*") == 0)
! 2983: {
! 2984: if ((strcmp(chaine_fonction, "+") == 0) ||
! 2985: (strcmp(chaine_fonction, "-") == 0)
! 2986: || (strcmp(chaine_fonction, "AND")
! 2987: == 0) || (strcmp(chaine_fonction,
! 2988: "XOR") == 0) || (strcmp(
! 2989: chaine_fonction, "OR") == 0))
! 2990: {
! 2991: autorisation_parenthese = d_vrai;
! 2992: }
! 2993: }
! 2994: else if (strcmp((*((struct_fonction *)
! 2995: (*(*l_element_courant).donnee).objet))
! 2996: .nom_fonction, "/") == 0)
! 2997: {
! 2998: if (nombre_arguments_fonction != 0)
! 2999: {
! 3000: autorisation_parenthese = d_faux;
! 3001: }
! 3002: else
! 3003: {
! 3004: autorisation_parenthese = d_vrai;
! 3005: }
! 3006: }
! 3007: else if ((strcmp((*((struct_fonction *)
! 3008: (*(*l_element_courant).donnee).objet))
! 3009: .nom_fonction, "^") == 0))
! 3010: {
! 3011: if (nombre_arguments_fonction != 0)
! 3012: {
! 3013: autorisation_parenthese = d_faux;
! 3014: }
! 3015: else
! 3016: {
! 3017: autorisation_parenthese = d_vrai;
! 3018: }
! 3019: }
! 3020: }
! 3021:
! 3022: if ((autorisation_parenthese == d_vrai) ||
! 3023: (presence_signe == d_vrai))
! 3024: {
! 3025: chaine_sauvegarde = (unsigned char *)
! 3026: (*s_sous_objet_2).objet;
! 3027:
! 3028: if (((*s_sous_objet_2).objet = (void *)
! 3029: malloc((strlen(chaine_sauvegarde) + 2
! 3030: + 1) * sizeof(unsigned char))) == NULL)
! 3031: {
! 3032: (*s_etat_processus).erreur_systeme =
! 3033: d_es_allocation_memoire;
! 3034: return(NULL);
! 3035: }
! 3036:
! 3037: sprintf((unsigned char *) (*s_sous_objet_2)
! 3038: .objet, "(%s)", chaine_sauvegarde);
! 3039: free(chaine_sauvegarde);
! 3040: }
! 3041:
! 3042: liberation(s_etat_processus, s_sous_objet_3);
! 3043:
! 3044: if (depilement(s_etat_processus,
! 3045: &((*s_etat_processus)
! 3046: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 3047: {
! 3048: return(NULL);
! 3049: }
! 3050:
! 3051: chaine_sauvegarde = (*s_etat_processus)
! 3052: .instruction_courante;
! 3053:
! 3054: if (((*s_etat_processus).instruction_courante =
! 3055: (unsigned char *) malloc((strlen(
! 3056: (unsigned char *) (*s_sous_objet_1).objet)
! 3057: + 2 + 1) * sizeof(unsigned char))) == NULL)
! 3058: {
! 3059: (*s_etat_processus).instruction_courante =
! 3060: chaine_sauvegarde;
! 3061: (*s_etat_processus).erreur_systeme =
! 3062: d_es_allocation_memoire;
! 3063: return(NULL);
! 3064: }
! 3065:
! 3066: sprintf((*s_etat_processus).instruction_courante,
! 3067: "'%s'", (unsigned char *)
! 3068: (*s_sous_objet_1).objet);
! 3069:
! 3070: recherche_type(s_etat_processus);
! 3071:
! 3072: if ((*s_etat_processus).erreur_execution != d_ex)
! 3073: {
! 3074: // Aucune erreur ne peut être renvoyée.
! 3075:
! 3076: return(NULL);
! 3077: }
! 3078:
! 3079: if (depilement(s_etat_processus,
! 3080: &((*s_etat_processus)
! 3081: .l_base_pile), &s_sous_objet_3) == d_erreur)
! 3082: {
! 3083: return(NULL);
! 3084: }
! 3085:
! 3086: free((*s_etat_processus).instruction_courante);
! 3087:
! 3088: (*s_etat_processus).instruction_courante =
! 3089: chaine_sauvegarde;
! 3090:
! 3091: autorisation_parenthese = d_faux;
! 3092:
! 3093: if ((*s_sous_objet_3).type == ALG)
! 3094: {
! 3095: l_atome = (struct_liste_chainee *)
! 3096: (*s_sous_objet_3).objet;
! 3097: chaine_fonction = "";
! 3098:
! 3099: while(l_atome != NULL)
! 3100: {
! 3101: if ((*(*l_atome).donnee).type == FCT)
! 3102: {
! 3103: if (strcmp((*((struct_fonction *)
! 3104: (*(*l_atome).donnee).objet))
! 3105: .nom_fonction, ">>") != 0)
! 3106: {
! 3107: chaine_fonction =
! 3108: (*((struct_fonction *)
! 3109: (*(*l_atome).donnee).objet))
! 3110: .nom_fonction;
! 3111: }
! 3112: }
! 3113:
! 3114: l_atome = (*l_atome).suivant;
! 3115: }
! 3116:
! 3117: if ((strcmp((*((struct_fonction *)
! 3118: (*(*l_element_courant).donnee).objet))
! 3119: .nom_fonction, "+") == 0) ||
! 3120: (strcmp((*((struct_fonction *)
! 3121: (*(*l_element_courant).donnee).objet))
! 3122: .nom_fonction, "-") == 0))
! 3123: {
! 3124: if ((strcmp(chaine_fonction, "AND") == 0) ||
! 3125: (strcmp(chaine_fonction, "XOR") ==
! 3126: 0) || (strcmp(chaine_fonction, "OR")
! 3127: == 0))
! 3128: {
! 3129: autorisation_parenthese = d_vrai;
! 3130: }
! 3131: }
! 3132: else if ((strcmp((*((struct_fonction *)
! 3133: (*(*l_element_courant).donnee).objet))
! 3134: .nom_fonction, "*") == 0) ||
! 3135: (strcmp((*((struct_fonction *)
! 3136: (*(*l_element_courant).donnee).objet))
! 3137: .nom_fonction, "/") == 0))
! 3138: {
! 3139: if ((strcmp(chaine_fonction, "+") == 0) ||
! 3140: (strcmp(chaine_fonction, "-") == 0)
! 3141: || (strcmp(chaine_fonction, "AND")
! 3142: == 0) || (strcmp(chaine_fonction,
! 3143: "XOR") == 0) || (strcmp(
! 3144: chaine_fonction, "OR") == 0))
! 3145: {
! 3146: autorisation_parenthese = d_vrai;
! 3147: }
! 3148: }
! 3149: else if ((strcmp((*((struct_fonction *)
! 3150: (*(*l_element_courant).donnee).objet))
! 3151: .nom_fonction, "^") == 0))
! 3152: {
! 3153: autorisation_parenthese = d_vrai;
! 3154: }
! 3155: }
! 3156:
! 3157: if (autorisation_parenthese == d_vrai)
! 3158: {
! 3159: chaine_sauvegarde = (unsigned char *)
! 3160: (*s_sous_objet_1).objet;
! 3161:
! 3162: if (((*s_sous_objet_1).objet = (void *)
! 3163: malloc((strlen(chaine_sauvegarde) + 2
! 3164: + 1) * sizeof(unsigned char))) == NULL)
! 3165: {
! 3166: (*s_etat_processus).erreur_systeme =
! 3167: d_es_allocation_memoire;
! 3168: return(NULL);
! 3169: }
! 3170:
! 3171: sprintf((unsigned char *) (*s_sous_objet_1)
! 3172: .objet, "(%s)", chaine_sauvegarde);
! 3173: free(chaine_sauvegarde);
! 3174: }
! 3175:
! 3176: liberation(s_etat_processus, s_sous_objet_3);
! 3177:
! 3178: if ((s_sous_objet = allocation(s_etat_processus,
! 3179: CHN)) == NULL)
! 3180: {
! 3181: (*s_etat_processus).erreur_systeme =
! 3182: d_es_allocation_memoire;
! 3183: return(NULL);
! 3184: }
! 3185:
! 3186: if (((*s_sous_objet).objet = (void *)
! 3187: malloc((strlen(
! 3188: (unsigned char *) (*s_sous_objet_1).objet) +
! 3189: strlen((*((struct_fonction *)
! 3190: (*(*l_element_courant).donnee).objet))
! 3191: .nom_fonction) + strlen((unsigned char *)
! 3192: (*s_sous_objet_2).objet) + 1) *
! 3193: sizeof(unsigned char))) == NULL)
! 3194: {
! 3195: (*s_etat_processus).erreur_systeme =
! 3196: d_es_allocation_memoire;
! 3197: return(NULL);
! 3198: }
! 3199:
! 3200: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3201: "%s%s%s", (unsigned char *)
! 3202: (*s_sous_objet_1)
! 3203: .objet, (*((struct_fonction *)
! 3204: (*(*l_element_courant).donnee).objet))
! 3205: .nom_fonction, (unsigned char *)
! 3206: (*s_sous_objet_2).objet);
! 3207:
! 3208: liberation(s_etat_processus, s_sous_objet_1);
! 3209: liberation(s_etat_processus, s_sous_objet_2);
! 3210:
! 3211: if (empilement(s_etat_processus,
! 3212: &((*s_etat_processus)
! 3213: .l_base_pile), s_sous_objet) == d_erreur)
! 3214: {
! 3215: return(NULL);
! 3216: }
! 3217: }
! 3218: else if (strcmp((*((struct_fonction *)
! 3219: (*(*l_element_courant).donnee).objet))
! 3220: .nom_fonction, "=") == 0)
! 3221: {
! 3222: if (depilement(s_etat_processus,
! 3223: &((*s_etat_processus).l_base_pile),
! 3224: &s_sous_objet_2) == d_erreur)
! 3225: {
! 3226: return(NULL);
! 3227: }
! 3228:
! 3229: if (depilement(s_etat_processus,
! 3230: &((*s_etat_processus).l_base_pile),
! 3231: &s_sous_objet_1) == d_erreur)
! 3232: {
! 3233: return(NULL);
! 3234: }
! 3235:
! 3236: if ((s_sous_objet = allocation(s_etat_processus,
! 3237: CHN)) == NULL)
! 3238: {
! 3239: (*s_etat_processus).erreur_systeme =
! 3240: d_es_allocation_memoire;
! 3241: return(NULL);
! 3242: }
! 3243:
! 3244: autorisation_parenthese = d_vrai;
! 3245: l_atome = l_element_courant;
! 3246:
! 3247: if (l_atome != NULL)
! 3248: {
! 3249: if ((*l_atome).suivant != NULL)
! 3250: {
! 3251: l_atome = (*l_atome).suivant;
! 3252:
! 3253: if ((*(*l_atome).donnee).type == FCT)
! 3254: {
! 3255: if (strcmp((*((struct_fonction *)
! 3256: (*(*l_atome).donnee).objet))
! 3257: .nom_fonction, ">>") == 0)
! 3258: {
! 3259: if ((*l_atome).suivant == NULL)
! 3260: {
! 3261: autorisation_parenthese =
! 3262: d_faux;
! 3263: }
! 3264: }
! 3265: }
! 3266: }
! 3267: }
! 3268:
! 3269: if (autorisation_parenthese == d_vrai)
! 3270: {
! 3271: if (((*s_sous_objet).objet =
! 3272: (void *) malloc((strlen(
! 3273: (unsigned char *) (*s_sous_objet_1)
! 3274: .objet) + strlen((*((struct_fonction *)
! 3275: (*(*l_element_courant).donnee).objet))
! 3276: .nom_fonction) +
! 3277: strlen((unsigned char *)
! 3278: (*s_sous_objet_2).objet) + 2 + 1) *
! 3279: sizeof(unsigned char))) == NULL)
! 3280: {
! 3281: (*s_etat_processus).erreur_systeme =
! 3282: d_es_allocation_memoire;
! 3283: return(NULL);
! 3284: }
! 3285:
! 3286: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3287: "(%s%s%s)", (unsigned char *)
! 3288: (*s_sous_objet_1)
! 3289: .objet, (*((struct_fonction *)
! 3290: (*(*l_element_courant).donnee).objet))
! 3291: .nom_fonction, (unsigned char *)
! 3292: (*s_sous_objet_2).objet);
! 3293: }
! 3294: else
! 3295: {
! 3296: if (((*s_sous_objet).objet =
! 3297: (void *) malloc((strlen(
! 3298: (unsigned char *) (*s_sous_objet_1)
! 3299: .objet) + strlen((*((struct_fonction *)
! 3300: (*(*l_element_courant).donnee).objet))
! 3301: .nom_fonction) + strlen(
! 3302: (unsigned char *) (*s_sous_objet_2)
! 3303: .objet) + 1) * sizeof(unsigned char)))
! 3304: == NULL)
! 3305: {
! 3306: (*s_etat_processus).erreur_systeme =
! 3307: d_es_allocation_memoire;
! 3308: return(NULL);
! 3309: }
! 3310:
! 3311: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3312: "%s%s%s", (unsigned char *)
! 3313: (*s_sous_objet_1)
! 3314: .objet, (*((struct_fonction *)
! 3315: (*(*l_element_courant).donnee).objet))
! 3316: .nom_fonction, (unsigned char *)
! 3317: (*s_sous_objet_2).objet);
! 3318: }
! 3319:
! 3320: liberation(s_etat_processus, s_sous_objet_1);
! 3321: liberation(s_etat_processus, s_sous_objet_2);
! 3322:
! 3323: if (empilement(s_etat_processus,
! 3324: &((*s_etat_processus).l_base_pile),
! 3325: s_sous_objet) == d_erreur)
! 3326: {
! 3327: return(NULL);
! 3328: }
! 3329: }
! 3330: else if (strcmp((*((struct_fonction *)
! 3331: (*(*l_element_courant).donnee).objet))
! 3332: .nom_fonction,
! 3333: "NOT") == 0)
! 3334: {
! 3335: if (depilement(s_etat_processus,
! 3336: &((*s_etat_processus)
! 3337: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 3338: {
! 3339: return(NULL);
! 3340: }
! 3341:
! 3342: if ((s_sous_objet = allocation(s_etat_processus,
! 3343: CHN)) == NULL)
! 3344: {
! 3345: (*s_etat_processus).erreur_systeme =
! 3346: d_es_allocation_memoire;
! 3347: return(NULL);
! 3348: }
! 3349:
! 3350: if (((*s_sous_objet).objet = (unsigned char *)
! 3351: malloc(
! 3352: (strlen((unsigned char *) (*s_sous_objet_1)
! 3353: .objet) + 4 + 1) * sizeof(unsigned char)))
! 3354: == NULL)
! 3355: {
! 3356: (*s_etat_processus).erreur_systeme =
! 3357: d_es_allocation_memoire;
! 3358: return(NULL);
! 3359: }
! 3360:
! 3361: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3362: "%s %s", (*((struct_fonction *)
! 3363: (*(*l_element_courant).donnee).objet))
! 3364: .nom_fonction, (unsigned char *)
! 3365: (*s_sous_objet_1).objet );
! 3366:
! 3367: liberation(s_etat_processus, s_sous_objet_1);
! 3368:
! 3369: if (empilement(s_etat_processus,
! 3370: &((*s_etat_processus)
! 3371: .l_base_pile), s_sous_objet) == d_erreur)
! 3372: {
! 3373: return(NULL);
! 3374: }
! 3375: }
! 3376: else if ((strcmp((*((struct_fonction *)
! 3377: (*(*l_element_courant).donnee).objet))
! 3378: .nom_fonction,
! 3379: "OR") == 0) || (strcmp((*((struct_fonction *)
! 3380: (*(*l_element_courant).donnee).objet))
! 3381: .nom_fonction,
! 3382: "XOR") == 0) || (strcmp((*((struct_fonction *)
! 3383: (*(*l_element_courant).donnee).objet))
! 3384: .nom_fonction,
! 3385: "AND") == 0))
! 3386: {
! 3387: if (depilement(s_etat_processus,
! 3388: &((*s_etat_processus)
! 3389: .l_base_pile), &s_sous_objet_2) == d_erreur)
! 3390: {
! 3391: return(NULL);
! 3392: }
! 3393:
! 3394: if (depilement(s_etat_processus,
! 3395: &((*s_etat_processus)
! 3396: .l_base_pile), &s_sous_objet_1) == d_erreur)
! 3397: {
! 3398: return(NULL);
! 3399: }
! 3400:
! 3401: if ((s_sous_objet = allocation(s_etat_processus,
! 3402: CHN)) == NULL)
! 3403: {
! 3404: (*s_etat_processus).erreur_systeme =
! 3405: d_es_allocation_memoire;
! 3406: return(NULL);
! 3407: }
! 3408:
! 3409: if (((*s_sous_objet).objet = (void *)
! 3410: malloc((strlen(
! 3411: (unsigned char *) (*s_sous_objet_1).objet) +
! 3412: strlen((*((struct_fonction *)
! 3413: (*(*l_element_courant).donnee).objet))
! 3414: .nom_fonction) + strlen((unsigned char *)
! 3415: (*s_sous_objet_2).objet) + 2 + 1) *
! 3416: sizeof(unsigned char))) == NULL)
! 3417: {
! 3418: (*s_etat_processus).erreur_systeme =
! 3419: d_es_allocation_memoire;
! 3420: return(NULL);
! 3421: }
! 3422:
! 3423: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3424: "%s %s %s", (unsigned char *)
! 3425: (*s_sous_objet_1)
! 3426: .objet, (*((struct_fonction *)
! 3427: (*(*l_element_courant).donnee).objet))
! 3428: .nom_fonction, (unsigned char *)
! 3429: (*s_sous_objet_2).objet);
! 3430:
! 3431: liberation(s_etat_processus, s_sous_objet_1);
! 3432: liberation(s_etat_processus, s_sous_objet_2);
! 3433:
! 3434: if (empilement(s_etat_processus,
! 3435: &((*s_etat_processus)
! 3436: .l_base_pile), s_sous_objet) == d_erreur)
! 3437: {
! 3438: return(NULL);
! 3439: }
! 3440: }
! 3441: else
! 3442: {
! 3443: nombre_arguments = (*((struct_fonction *)
! 3444: (*(*l_element_courant).donnee).objet))
! 3445: .nombre_arguments;
! 3446:
! 3447: if ((chaine = (unsigned char *)
! 3448: malloc(sizeof(unsigned char))) == NULL)
! 3449: {
! 3450: (*s_etat_processus).erreur_systeme =
! 3451: d_es_allocation_memoire;
! 3452: return(NULL);
! 3453: }
! 3454:
! 3455: chaine[0] = d_code_fin_chaine;
! 3456:
! 3457: for(i = 0; i < nombre_arguments; i++)
! 3458: {
! 3459: if ((nombre_arguments - i) > 1)
! 3460: {
! 3461: l_liste1 = (*s_etat_processus).l_base_pile;
! 3462:
! 3463: for(j = 2; j < (nombre_arguments - i); j++)
! 3464: {
! 3465: l_liste1 = (*l_liste1).suivant;
! 3466: }
! 3467:
! 3468: l_liste2 = (*l_liste1).suivant;
! 3469: (*l_liste1).suivant = (*l_liste2).suivant;
! 3470: (*l_liste2).suivant = (*s_etat_processus)
! 3471: .l_base_pile;
! 3472: (*s_etat_processus).l_base_pile = l_liste2;
! 3473: }
! 3474:
! 3475: if (depilement(s_etat_processus,
! 3476: &((*s_etat_processus).l_base_pile),
! 3477: &s_sous_objet) == d_erreur)
! 3478: {
! 3479: return(NULL);
! 3480: }
! 3481:
! 3482: chaine_sauvegarde = chaine;
! 3483:
! 3484: if (strlen(chaine_sauvegarde) == 0)
! 3485: {
! 3486: if ((chaine = (unsigned char *)
! 3487: malloc((strlen((unsigned char *)
! 3488: (*s_sous_objet).objet) + 1) *
! 3489: sizeof(unsigned char))) == NULL)
! 3490: {
! 3491: (*s_etat_processus).erreur_systeme =
! 3492: d_es_allocation_memoire;
! 3493: return(NULL);
! 3494: }
! 3495:
! 3496: sprintf(chaine, "%s", (unsigned char *)
! 3497: (*s_sous_objet).objet);
! 3498: }
! 3499: else
! 3500: {
! 3501: if ((chaine = (unsigned char *)
! 3502: malloc((strlen(chaine_sauvegarde)
! 3503: + 1 + strlen((unsigned char *)
! 3504: (*s_sous_objet).objet) + 1) *
! 3505: sizeof(unsigned char))) == NULL)
! 3506: {
! 3507: (*s_etat_processus).erreur_systeme =
! 3508: d_es_allocation_memoire;
! 3509: return(NULL);
! 3510: }
! 3511:
! 3512: sprintf(chaine, "%s,%s", chaine_sauvegarde,
! 3513: (unsigned char *) (*s_sous_objet)
! 3514: .objet);
! 3515: }
! 3516:
! 3517: free(chaine_sauvegarde);
! 3518: liberation(s_etat_processus, s_sous_objet);
! 3519: }
! 3520:
! 3521: chaine_sauvegarde = chaine;
! 3522:
! 3523: if ((chaine = (unsigned char *) malloc((strlen(
! 3524: (*((struct_fonction *)
! 3525: (*(*l_element_courant)
! 3526: .donnee).objet)).nom_fonction) + 2 +
! 3527: strlen(chaine_sauvegarde) + 1) *
! 3528: sizeof(unsigned char))) == NULL)
! 3529: {
! 3530: (*s_etat_processus).erreur_systeme =
! 3531: d_es_allocation_memoire;
! 3532: return(NULL);
! 3533: }
! 3534:
! 3535: sprintf(chaine, "%s(%s)", (*((struct_fonction *)
! 3536: (*(*l_element_courant).donnee).objet))
! 3537: .nom_fonction, chaine_sauvegarde);
! 3538: free(chaine_sauvegarde);
! 3539:
! 3540: if ((s_sous_objet = allocation(s_etat_processus,
! 3541: CHN)) == NULL)
! 3542: {
! 3543: (*s_etat_processus).erreur_systeme =
! 3544: d_es_allocation_memoire;
! 3545: return(NULL);
! 3546: }
! 3547:
! 3548: (*s_sous_objet).objet = (void *) chaine;
! 3549:
! 3550: if (empilement(s_etat_processus,
! 3551: &((*s_etat_processus)
! 3552: .l_base_pile), s_sous_objet) == d_erreur)
! 3553: {
! 3554: return(NULL);
! 3555: }
! 3556: }
! 3557: }
! 3558: }
! 3559: else
! 3560: {
! 3561: if ((s_sous_objet = allocation(s_etat_processus, CHN))
! 3562: == NULL)
! 3563: {
! 3564: (*s_etat_processus).erreur_systeme =
! 3565: d_es_allocation_memoire;
! 3566: return(NULL);
! 3567: }
! 3568:
! 3569: if (((*s_sous_objet).objet = (void *) formateur_fichier(
! 3570: s_etat_processus, (*l_element_courant).donnee,
! 3571: s_format, longueur, longueur_champ, format_sortie,
! 3572: type, longueur_effective, recursivite)) == NULL)
! 3573: {
! 3574: (*s_etat_processus).erreur_systeme =
! 3575: d_es_allocation_memoire;
! 3576: return(NULL);
! 3577: }
! 3578:
! 3579: if (((*(*l_element_courant).donnee).type == ALG)
! 3580: || ((*(*l_element_courant).donnee).type == NOM))
! 3581: {
! 3582: chaine_sauvegarde = (unsigned char *)
! 3583: (*s_sous_objet).objet;
! 3584:
! 3585: if (((*s_sous_objet).objet = malloc((strlen(
! 3586: chaine_sauvegarde) - 1) *
! 3587: sizeof(unsigned char))) == NULL)
! 3588: {
! 3589: (*s_etat_processus).erreur_systeme =
! 3590: d_es_allocation_memoire;
! 3591: return(NULL);
! 3592: }
! 3593:
! 3594: ptrl = chaine_sauvegarde;
! 3595: ptre = (unsigned char *) (*s_sous_objet).objet;
! 3596:
! 3597: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
! 3598: i--, *ptre++ = *ptrl++);
! 3599:
! 3600: (*ptre) = d_code_fin_chaine;
! 3601:
! 3602: free(chaine_sauvegarde);
! 3603: }
! 3604: else if ((*(*l_element_courant).donnee).type == CHN)
! 3605: {
! 3606: chaine_sauvegarde = (unsigned char *)
! 3607: (*s_sous_objet).objet;
! 3608:
! 3609: if (((*s_sous_objet).objet = malloc((strlen(
! 3610: chaine_sauvegarde) + 3) *
! 3611: sizeof(unsigned char))) == NULL)
! 3612: {
! 3613: (*s_etat_processus).erreur_systeme =
! 3614: d_es_allocation_memoire;
! 3615: return(NULL);
! 3616: }
! 3617:
! 3618: sprintf((unsigned char *) (*s_sous_objet).objet,
! 3619: "\"%s\"", chaine_sauvegarde);
! 3620:
! 3621: free(chaine_sauvegarde);
! 3622: }
! 3623:
! 3624: if (empilement(s_etat_processus, &((*s_etat_processus)
! 3625: .l_base_pile), s_sous_objet) == d_erreur)
! 3626: {
! 3627: return(NULL);
! 3628: }
! 3629: }
! 3630:
! 3631: l_element_courant = (*l_element_courant).suivant;
! 3632: }
! 3633:
! 3634: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 3635: &s_sous_objet) == d_erreur)
! 3636: {
! 3637: return(NULL);
! 3638: }
! 3639:
! 3640: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *)
! 3641: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char)))
! 3642: == NULL)
! 3643: {
! 3644: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3645: return(NULL);
! 3646: }
! 3647:
! 3648: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
! 3649: liberation(s_etat_processus, s_sous_objet);
! 3650: }
! 3651: else if ((*s_objet).type == BIN)
! 3652: {
! 3653:
! 3654: /*
! 3655: --------------------------------------------------------------------------------
! 3656: Entier binaire en base 2, 8, 10 ou 16
! 3657: --------------------------------------------------------------------------------
! 3658: */
! 3659:
! 3660: if (format_sortie != 'B')
! 3661: {
! 3662: (*s_etat_processus).erreur_execution =
! 3663: d_ex_erreur_format_fichier;
! 3664: return(NULL);
! 3665: }
! 3666:
! 3667: longueur_binaire = longueur_entiers_binaires(s_etat_processus);
! 3668: masque_binaire = masque_entiers_binaires(s_etat_processus);
! 3669:
! 3670: if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
! 3671: (test_cfsf(s_etat_processus, 44) == d_faux))
! 3672: {
! 3673:
! 3674: /*
! 3675: -- Base décimale ---------------------------------------------------------------
! 3676: */
! 3677:
! 3678: sprintf(tampon, "%llu", (*((logical8 *)
! 3679: ((*s_objet).objet))) & masque_binaire);
! 3680: strcpy(base, "d");
! 3681: }
! 3682: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
! 3683: (test_cfsf(s_etat_processus, 44) == d_faux))
! 3684: {
! 3685:
! 3686: /*
! 3687: -- Base octale -----------------------------------------------------------------
! 3688: */
! 3689:
! 3690: sprintf(tampon, "%llo", (*((logical8 *)
! 3691: ((*s_objet).objet))) & masque_binaire);
! 3692: strcpy(base, "o");
! 3693: }
! 3694: else if (test_cfsf(s_etat_processus, 44) == d_vrai)
! 3695: {
! 3696:
! 3697: /*
! 3698: -- Bases hexadécimale et binaire -----------------------------------------------
! 3699: */
! 3700:
! 3701: sprintf(tampon, "%llX", (*((logical8 *)
! 3702: ((*s_objet).objet))) & masque_binaire);
! 3703:
! 3704: if (test_cfsf(s_etat_processus, 43) == d_vrai)
! 3705: {
! 3706: strcpy(base, "h");
! 3707: }
! 3708: else
! 3709: {
! 3710: chaine = (unsigned char *) malloc((strlen(tampon) + 1)
! 3711: * sizeof(unsigned char));
! 3712:
! 3713: if (chaine == NULL)
! 3714: {
! 3715: (*s_etat_processus).erreur_systeme =
! 3716: d_es_allocation_memoire;
! 3717: return(NULL);
! 3718: }
! 3719:
! 3720: strcpy(chaine, tampon);
! 3721: tampon[0] = 0;
! 3722:
! 3723: for(i = 0; i < strlen(chaine); i++)
! 3724: {
! 3725: switch(chaine[i])
! 3726: {
! 3727: case '0' :
! 3728: {
! 3729: strcat(tampon, (i != 0) ? "0000" : "0");
! 3730: break;
! 3731: }
! 3732: case '1' :
! 3733: {
! 3734: strcat(tampon, (i != 0) ? "0001" : "1");
! 3735: break;
! 3736: }
! 3737: case '2' :
! 3738: {
! 3739: strcat(tampon, (i != 0) ? "0010" : "10");
! 3740: break;
! 3741: }
! 3742: case '3' :
! 3743: {
! 3744: strcat(tampon, (i != 0) ? "0011" : "11");
! 3745: break;
! 3746: }
! 3747: case '4' :
! 3748: {
! 3749: strcat(tampon, (i != 0) ? "0100" : "100");
! 3750: break;
! 3751: }
! 3752: case '5' :
! 3753: {
! 3754: strcat(tampon, (i != 0) ? "0101" : "101");
! 3755: break;
! 3756: }
! 3757: case '6' :
! 3758: {
! 3759: strcat(tampon, (i != 0) ? "0110" : "110");
! 3760: break;
! 3761: }
! 3762: case '7' :
! 3763: {
! 3764: strcat(tampon, (i != 0) ? "0111" : "111");
! 3765: break;
! 3766: }
! 3767: case '8' :
! 3768: {
! 3769: strcat(tampon, "1000");
! 3770: break;
! 3771: }
! 3772: case '9' :
! 3773: {
! 3774: strcat(tampon, "1001");
! 3775: break;
! 3776: }
! 3777: case 'A' :
! 3778: {
! 3779: strcat(tampon, "1010");
! 3780: break;
! 3781: }
! 3782: case 'B' :
! 3783: {
! 3784: strcat(tampon, "1011");
! 3785: break;
! 3786: }
! 3787: case 'C' :
! 3788: {
! 3789: strcat(tampon, "1100");
! 3790: break;
! 3791: }
! 3792: case 'D' :
! 3793: {
! 3794: strcat(tampon, "1101");
! 3795: break;
! 3796: }
! 3797: case 'E' :
! 3798: {
! 3799: strcat(tampon, "1110");
! 3800: break;
! 3801: }
! 3802: case 'F' :
! 3803: {
! 3804: strcat(tampon, "1111");
! 3805: break;
! 3806: }
! 3807: }
! 3808: }
! 3809:
! 3810: free(chaine);
! 3811: strcpy(base, "b");
! 3812: }
! 3813: }
! 3814:
! 3815: chaine = (unsigned char *) malloc((strlen(tampon) + 4)
! 3816: * sizeof(unsigned char));
! 3817:
! 3818: if (chaine == NULL)
! 3819: {
! 3820: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3821: return(NULL);
! 3822: }
! 3823:
! 3824: strcpy(chaine, "# ");
! 3825:
! 3826: strcat(chaine, tampon);
! 3827: strcat(chaine, base);
! 3828: }
! 3829: else if ((*s_objet).type == CHN)
! 3830: {
! 3831:
! 3832: /*
! 3833: --------------------------------------------------------------------------------
! 3834: Chaîne de caractères
! 3835: --------------------------------------------------------------------------------
! 3836: */
! 3837:
! 3838: if (format_sortie != 'C')
! 3839: {
! 3840: (*s_etat_processus).erreur_execution =
! 3841: d_ex_erreur_format_fichier;
! 3842: return(NULL);
! 3843: }
! 3844:
! 3845: chaine = (unsigned char *) malloc((strlen((unsigned char *)
! 3846: ((*s_objet).objet)) + 1) * sizeof(unsigned char));
! 3847:
! 3848: if (chaine == NULL)
! 3849: {
! 3850: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3851: return(NULL);
! 3852: }
! 3853:
! 3854: strcpy(chaine, (unsigned char *) ((*s_objet).objet));
! 3855: }
! 3856: else if ((*s_objet).type == CPL)
! 3857: {
! 3858:
! 3859: /*
! 3860: --------------------------------------------------------------------------------
! 3861: Complexe
! 3862: --------------------------------------------------------------------------------
! 3863: */
! 3864:
! 3865: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 3866: (format_sortie != 'I') && (format_sortie != 'E'))
! 3867: {
! 3868: (*s_etat_processus).erreur_execution =
! 3869: d_ex_erreur_format_fichier;
! 3870: return(NULL);
! 3871: }
! 3872:
! 3873: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
! 3874: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',
! 3875: longueur, longueur_champ, format_sortie)) == NULL)
! 3876: {
! 3877: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3878: return(NULL);
! 3879: }
! 3880:
! 3881: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
! 3882: + 1) * sizeof(unsigned char));
! 3883:
! 3884: if (chaine == NULL)
! 3885: {
! 3886: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3887: return(NULL);
! 3888: }
! 3889:
! 3890: strcpy(chaine, chaine_formatee);
! 3891: free(chaine_formatee);
! 3892: }
! 3893: else if ((*s_objet).type == RPN)
! 3894: {
! 3895:
! 3896: /*
! 3897: --------------------------------------------------------------------------------
! 3898: Définition
! 3899: --------------------------------------------------------------------------------
! 3900: */
! 3901:
! 3902: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
! 3903: chaine_sauvegarde = chaine;
! 3904:
! 3905: while(l_element_courant != NULL)
! 3906: {
! 3907: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 3908: (*l_element_courant).donnee, s_format,
! 3909: longueur, longueur_champ, format_sortie, type,
! 3910: longueur_effective, recursivite)) == NULL)
! 3911: {
! 3912: return(NULL);
! 3913: }
! 3914:
! 3915: if ((*(*l_element_courant).donnee).type == CHN)
! 3916: {
! 3917: chaine_tampon = chaine_formatee;
! 3918:
! 3919: if ((chaine_formatee = (unsigned char *) malloc((strlen(
! 3920: chaine_tampon) + 3) * sizeof(unsigned char)))
! 3921: == NULL)
! 3922: {
! 3923: (*s_etat_processus).erreur_systeme =
! 3924: d_es_allocation_memoire;
! 3925: return(NULL);
! 3926: }
! 3927:
! 3928: sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
! 3929: free(chaine_tampon);
! 3930: }
! 3931:
! 3932: l_element_courant = (*l_element_courant).suivant;
! 3933:
! 3934: if (chaine != NULL)
! 3935: {
! 3936: chaine_sauvegarde = chaine;
! 3937:
! 3938: if ((chaine = (unsigned char *) malloc((strlen(
! 3939: chaine_sauvegarde) + strlen(chaine_formatee) + 2) *
! 3940: sizeof(unsigned char))) == NULL)
! 3941: {
! 3942: (*s_etat_processus).erreur_systeme =
! 3943: d_es_allocation_memoire;
! 3944: return(NULL);
! 3945: }
! 3946:
! 3947: strcpy(chaine, chaine_sauvegarde);
! 3948: free(chaine_sauvegarde);
! 3949: strcat(chaine, " ");
! 3950: strcat(chaine, chaine_formatee);
! 3951: free(chaine_formatee);
! 3952: }
! 3953: else
! 3954: {
! 3955: chaine = chaine_formatee;
! 3956: }
! 3957: }
! 3958:
! 3959: chaine_sauvegarde = chaine;
! 3960: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) *
! 3961: sizeof(unsigned char));
! 3962:
! 3963: if (chaine == NULL)
! 3964: {
! 3965: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 3966: free(chaine_sauvegarde);
! 3967: return(NULL);
! 3968: }
! 3969:
! 3970: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
! 3971: strcpy(chaine, chaine_sauvegarde);
! 3972: free(chaine_sauvegarde);
! 3973: }
! 3974: else if ((*s_objet).type == INT)
! 3975: {
! 3976:
! 3977: /*
! 3978: --------------------------------------------------------------------------------
! 3979: Entier
! 3980: --------------------------------------------------------------------------------
! 3981: */
! 3982:
! 3983: if (format_sortie != 'I')
! 3984: {
! 3985: (*s_etat_processus).erreur_execution =
! 3986: d_ex_erreur_format_fichier;
! 3987: return(NULL);
! 3988: }
! 3989:
! 3990: switch(longueur)
! 3991: {
! 3992: case 1:
! 3993: {
! 3994: if ((*((integer8 *) (*s_objet).objet)) !=
! 3995: ((integer1) (*((integer8 *) (*s_objet).objet))))
! 3996: {
! 3997: (*s_etat_processus).erreur_execution =
! 3998: d_ex_representation;
! 3999: return(NULL);
! 4000: }
! 4001:
! 4002: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
! 4003: {
! 4004: (*s_etat_processus).erreur_systeme =
! 4005: d_es_allocation_memoire;
! 4006: return(NULL);
! 4007: }
! 4008:
! 4009: longueur_totale = 2;
! 4010: chaine[0] = 0x10;
! 4011: chaine[1] = (*((integer8 *) (*s_objet).objet)) & 0xFF;
! 4012: break;
! 4013: }
! 4014:
! 4015: case 2:
! 4016: {
! 4017: if ((*((integer8 *) (*s_objet).objet)) !=
! 4018: ((integer2) (*((integer8 *) (*s_objet).objet))))
! 4019: {
! 4020: (*s_etat_processus).erreur_execution =
! 4021: d_ex_representation;
! 4022: return(NULL);
! 4023: }
! 4024:
! 4025: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
! 4026: {
! 4027: (*s_etat_processus).erreur_systeme =
! 4028: d_es_allocation_memoire;
! 4029: return(NULL);
! 4030: }
! 4031:
! 4032: longueur_totale = 3;
! 4033: chaine[0] = 0x11;
! 4034: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 8)
! 4035: & 0xFF;
! 4036: chaine[2] = (*((integer8 *) (*s_objet).objet)) & 0xFF;
! 4037: break;
! 4038: }
! 4039:
! 4040: case 4:
! 4041: {
! 4042: if ((*((integer4 *) (*s_objet).objet)) !=
! 4043: ((integer2) (*((integer8 *) (*s_objet).objet))))
! 4044: {
! 4045: (*s_etat_processus).erreur_execution =
! 4046: d_ex_representation;
! 4047: return(NULL);
! 4048: }
! 4049:
! 4050: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
! 4051: {
! 4052: (*s_etat_processus).erreur_systeme =
! 4053: d_es_allocation_memoire;
! 4054: return(NULL);
! 4055: }
! 4056:
! 4057: longueur_totale = 5;
! 4058: chaine[0] = 0x12;
! 4059: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 24)
! 4060: & 0xFF;
! 4061: chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 16)
! 4062: & 0xFF;
! 4063: chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 8)
! 4064: & 0xFF;
! 4065: chaine[4] = (*((integer8 *) (*s_objet).objet)) & 0xFF;
! 4066: break;
! 4067: }
! 4068:
! 4069: case 8:
! 4070: {
! 4071: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
! 4072: {
! 4073: (*s_etat_processus).erreur_systeme =
! 4074: d_es_allocation_memoire;
! 4075: return(NULL);
! 4076: }
! 4077:
! 4078: longueur_totale = 9;
! 4079: chaine[0] = 0x13;
! 4080: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 56)
! 4081: & 0xFF;
! 4082: chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 48)
! 4083: & 0xFF;
! 4084: chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 40)
! 4085: & 0xFF;
! 4086: chaine[4] = ((*((integer8 *) (*s_objet).objet)) >> 32)
! 4087: & 0xFF;
! 4088: chaine[5] = ((*((integer8 *) (*s_objet).objet)) >> 24)
! 4089: & 0xFF;
! 4090: chaine[6] = ((*((integer8 *) (*s_objet).objet)) >> 16)
! 4091: & 0xFF;
! 4092: chaine[7] = ((*((integer8 *) (*s_objet).objet)) >> 8)
! 4093: & 0xFF;
! 4094: chaine[8] = (*((integer8 *) (*s_objet).objet)) & 0xFF;
! 4095: break;
! 4096: }
! 4097:
! 4098: default :
! 4099: {
! 4100: (*s_etat_processus).erreur_execution =
! 4101: d_ex_erreur_format_fichier;
! 4102: return(NULL);
! 4103: }
! 4104: }
! 4105:
! 4106: (*longueur_effective) = longueur_totale;
! 4107: }
! 4108: else if ((*s_objet).type == FCT)
! 4109: {
! 4110:
! 4111: /*
! 4112: --------------------------------------------------------------------------------
! 4113: Fonction
! 4114: --------------------------------------------------------------------------------
! 4115: */
! 4116:
! 4117: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
! 4118: ((*s_objet).objet))).nom_fonction) + 1) *
! 4119: sizeof(unsigned char));
! 4120:
! 4121: if (chaine == NULL)
! 4122: {
! 4123: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4124: return(NULL);
! 4125: }
! 4126:
! 4127: strcpy(chaine, (unsigned char *) (*((struct_fonction *)
! 4128: ((*s_objet).objet))).nom_fonction);
! 4129: }
! 4130: else if ((*s_objet).type == LST)
! 4131: {
! 4132:
! 4133: /*
! 4134: --------------------------------------------------------------------------------
! 4135: Liste
! 4136: Poids fort 0100
! 4137: --------------------------------------------------------------------------------
! 4138: */
! 4139:
! 4140: chaine = malloc(sizeof(unsigned char));
! 4141:
! 4142: if (chaine == NULL)
! 4143: {
! 4144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4145: return(NULL);
! 4146: }
! 4147:
! 4148: // Calcul de la longueur de la liste.
! 4149:
! 4150: longueur_liste = 0;
! 4151: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 4152:
! 4153: while(l_element_courant != NULL)
! 4154: {
! 4155: l_element_courant = (*l_element_courant).suivant;
! 4156: longueur_liste++;
! 4157: }
! 4158:
! 4159: if (longueur_liste < (1LL << 3))
! 4160: {
! 4161: chaine[0] = 0x40 | (longueur_liste & 0x7);
! 4162: }
! 4163: else if (longueur_liste < (1LL << 8))
! 4164: {
! 4165: chaine[0] = 0x48;
! 4166: }
! 4167: else if (longueur_liste < (1LL << 16))
! 4168: {
! 4169: chaine[0] = 0x49;
! 4170: }
! 4171: else if (longueur_liste < (1LL << 32))
! 4172: {
! 4173: chaine[0] = 0x4A;
! 4174: }
! 4175: else
! 4176: {
! 4177: chaine[0] = 0x4B;
! 4178: }
! 4179:
! 4180: longueur_totale = 1;
! 4181:
! 4182: if ((chaine[0] & 0x8) != 0)
! 4183: {
! 4184: switch(chaine[0] & 0x03)
! 4185: {
! 4186: case 0x00 :
! 4187: {
! 4188: longueur_totale += 1;
! 4189:
! 4190: if ((chaine = realloc(chaine, longueur_totale *
! 4191: sizeof(unsigned char))) == NULL)
! 4192: {
! 4193: (*s_etat_processus).erreur_systeme =
! 4194: d_es_allocation_memoire;
! 4195: return(NULL);
! 4196: }
! 4197:
! 4198: chaine[longueur_totale - 1] =
! 4199: (unsigned char) (longueur_liste & 0xFF);
! 4200: break;
! 4201: }
! 4202:
! 4203: case 0x01 :
! 4204: {
! 4205: longueur_totale += 2;
! 4206:
! 4207: if ((chaine = realloc(chaine, longueur_totale *
! 4208: sizeof(unsigned char))) == NULL)
! 4209: {
! 4210: (*s_etat_processus).erreur_systeme =
! 4211: d_es_allocation_memoire;
! 4212: return(NULL);
! 4213: }
! 4214:
! 4215: chaine[longueur_totale - 2] =
! 4216: (unsigned char) ((longueur_liste >> 8) & 0xFF);
! 4217: chaine[longueur_totale - 1] =
! 4218: (unsigned char) (longueur_liste & 0xFF);
! 4219: break;
! 4220: }
! 4221:
! 4222: case 0x02 :
! 4223: {
! 4224: longueur_totale += 4;
! 4225:
! 4226: if ((chaine = realloc(chaine, longueur_totale *
! 4227: sizeof(unsigned char))) == NULL)
! 4228: {
! 4229: (*s_etat_processus).erreur_systeme =
! 4230: d_es_allocation_memoire;
! 4231: return(NULL);
! 4232: }
! 4233:
! 4234: chaine[longueur_totale - 4] =
! 4235: (unsigned char) ((longueur_liste >> 24) & 0xFF);
! 4236: chaine[longueur_totale - 3] =
! 4237: (unsigned char) ((longueur_liste >> 16) & 0xFF);
! 4238: chaine[longueur_totale - 2] =
! 4239: (unsigned char) ((longueur_liste >> 8) & 0xFF);
! 4240: chaine[longueur_totale - 1] =
! 4241: (unsigned char) (longueur_liste & 0xFF);
! 4242: break;
! 4243: }
! 4244:
! 4245: case 0x03 :
! 4246: {
! 4247: longueur_totale += 8;
! 4248:
! 4249: if ((chaine = realloc(chaine, longueur_totale *
! 4250: sizeof(unsigned char))) == NULL)
! 4251: {
! 4252: (*s_etat_processus).erreur_systeme =
! 4253: d_es_allocation_memoire;
! 4254: return(NULL);
! 4255: }
! 4256:
! 4257: chaine[longueur_totale - 8] =
! 4258: (unsigned char) ((longueur_liste >> 56) & 0xFF);
! 4259: chaine[longueur_totale - 7] =
! 4260: (unsigned char) ((longueur_liste >> 48) & 0xFF);
! 4261: chaine[longueur_totale - 6] =
! 4262: (unsigned char) ((longueur_liste >> 40) & 0xFF);
! 4263: chaine[longueur_totale - 5] =
! 4264: (unsigned char) ((longueur_liste >> 32) & 0xFF);
! 4265: chaine[longueur_totale - 4] =
! 4266: (unsigned char) ((longueur_liste >> 24) & 0xFF);
! 4267: chaine[longueur_totale - 3] =
! 4268: (unsigned char) ((longueur_liste >> 16) & 0xFF);
! 4269: chaine[longueur_totale - 2] =
! 4270: (unsigned char) ((longueur_liste >> 8) & 0xFF);
! 4271: chaine[longueur_totale - 1] =
! 4272: (unsigned char) (longueur_liste & 0xFF);
! 4273: break;
! 4274: }
! 4275:
! 4276: default :
! 4277: {
! 4278: BUG(1, printf("Internal format error\n"));
! 4279: }
! 4280: }
! 4281: }
! 4282:
! 4283: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 4284: l_element_courant_format = (struct_liste_chainee *)
! 4285: (*s_format).objet;
! 4286: nombre_elements = 0;
! 4287:
! 4288: while((l_element_courant != NULL) &&
! 4289: (l_element_courant_format != NULL))
! 4290: {
! 4291: if ((((*(*l_element_courant_format).donnee).type == LST)
! 4292: && ((*(*l_element_courant).donnee).type == LST)) ||
! 4293: (((*(*l_element_courant_format).donnee).type == TBL)
! 4294: && ((*(*l_element_courant).donnee).type == TBL)))
! 4295: {
! 4296: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 4297: (*l_element_courant).donnee,
! 4298: (*l_element_courant_format).donnee,
! 4299: 0, 0, ' ', 'U', longueur_effective, recursivite))
! 4300: == NULL)
! 4301: {
! 4302: return(NULL);
! 4303: }
! 4304:
! 4305: if ((chaine = realloc(chaine, (longueur_totale +
! 4306: (*longueur_effective)) * sizeof(unsigned char)))
! 4307: == NULL)
! 4308: {
! 4309: (*s_etat_processus).erreur_systeme =
! 4310: d_es_allocation_memoire;
! 4311: return(NULL);
! 4312: }
! 4313:
! 4314: memcpy(&(chaine[longueur_totale]), chaine_formatee,
! 4315: (*longueur_effective));
! 4316: longueur_totale += (*longueur_effective);
! 4317: free(chaine_formatee);
! 4318: }
! 4319: else if ((*(*l_element_courant_format).donnee).type != CHN)
! 4320: {
! 4321: free(chaine);
! 4322:
! 4323: (*s_etat_processus).erreur_execution =
! 4324: d_ex_erreur_format_fichier;
! 4325: return(NULL);
! 4326: }
! 4327: else
! 4328: {
! 4329: if ((format_chaine = conversion_majuscule((unsigned char *)
! 4330: (*(*l_element_courant_format).donnee).objet))
! 4331: == NULL)
! 4332: {
! 4333: (*s_etat_processus).erreur_systeme =
! 4334: d_es_allocation_memoire;
! 4335: return(NULL);
! 4336: }
! 4337:
! 4338: format_degenere = d_faux;
! 4339:
! 4340: if (strncmp("INTEGER*", format_chaine, 8) == 0)
! 4341: {
! 4342: format_sortie = 'I';
! 4343: position_1 = 8;
! 4344: }
! 4345: else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
! 4346: {
! 4347: format_sortie = 'L';
! 4348: position_1 = 8;
! 4349: }
! 4350: else if (strncmp("REAL*", format_chaine, 5) == 0)
! 4351: {
! 4352: format_sortie = 'R';
! 4353: position_1 = 5;
! 4354: }
! 4355: else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
! 4356: {
! 4357: format_sortie = 'C';
! 4358: position_1 = 8;
! 4359: }
! 4360: else if (strcmp("CHARACTER", format_chaine) == 0)
! 4361: {
! 4362: format_sortie = 'S';
! 4363: position_1 = 10;
! 4364: format_degenere = d_vrai;
! 4365: }
! 4366: else
! 4367: {
! 4368: free(chaine);
! 4369: free(format_chaine);
! 4370:
! 4371: (*s_etat_processus).erreur_execution =
! 4372: d_ex_erreur_format_fichier;
! 4373: return(NULL);
! 4374: }
! 4375:
! 4376: if (format_degenere == d_faux)
! 4377: {
! 4378: if (format_chaine[position_1] == d_code_fin_chaine)
! 4379: {
! 4380: free(chaine);
! 4381: free(format_chaine);
! 4382:
! 4383: (*s_etat_processus).erreur_execution =
! 4384: d_ex_erreur_format_fichier;
! 4385: return(NULL);
! 4386: }
! 4387:
! 4388: if (sscanf(&(format_chaine[position_1]), "%ld",
! 4389: &longueur) != 1)
! 4390: {
! 4391: free(chaine);
! 4392: free(format_chaine);
! 4393:
! 4394: (*s_etat_processus).erreur_execution =
! 4395: d_ex_erreur_format_fichier;
! 4396: return(NULL);
! 4397: }
! 4398: }
! 4399: else
! 4400: {
! 4401: longueur = -1;
! 4402: }
! 4403:
! 4404: free(format_chaine);
! 4405:
! 4406: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 4407: (*l_element_courant).donnee, s_format,
! 4408: longueur, longueur_champ, format_sortie, type,
! 4409: longueur_effective, recursivite)) == NULL)
! 4410: {
! 4411: free(chaine);
! 4412: return(NULL);
! 4413: }
! 4414:
! 4415: if ((chaine = realloc(chaine,
! 4416: (longueur_totale + (*longueur_effective))
! 4417: * sizeof(unsigned char))) == NULL)
! 4418: {
! 4419: (*s_etat_processus).erreur_systeme =
! 4420: d_es_allocation_memoire;
! 4421: return(NULL);
! 4422: }
! 4423:
! 4424: memcpy(&(chaine[longueur_totale]), chaine_formatee,
! 4425: (*longueur_effective));
! 4426: longueur_totale += (*longueur_effective);
! 4427: free(chaine_formatee);
! 4428: }
! 4429:
! 4430: nombre_elements++;
! 4431: l_element_courant = (*l_element_courant).suivant;
! 4432: l_element_courant_format = (*l_element_courant_format).suivant;
! 4433: }
! 4434:
! 4435: if ((l_element_courant != NULL) ||
! 4436: (l_element_courant_format != NULL))
! 4437: {
! 4438: free(chaine);
! 4439:
! 4440: (*s_etat_processus).erreur_execution =
! 4441: d_ex_erreur_format_fichier;
! 4442: return(NULL);
! 4443: }
! 4444:
! 4445: if ((*recursivite) == 1)
! 4446: {
! 4447: // Ajout de la longueur totale en fin d'enregistrement.
! 4448:
! 4449: if (longueur_totale < (((integer8) 1) << 6))
! 4450: {
! 4451: tampon[0] = longueur_totale + 1;
! 4452:
! 4453: if ((chaine = realloc(chaine, (longueur_totale + 1)
! 4454: * sizeof(unsigned char))) == NULL)
! 4455: {
! 4456: (*s_etat_processus).erreur_systeme =
! 4457: d_es_allocation_memoire;
! 4458: return(NULL);
! 4459: }
! 4460:
! 4461: memcpy(&(chaine[longueur_totale]), tampon, 1);
! 4462: longueur_totale += 1;
! 4463: }
! 4464: else if (longueur_totale < (((integer8) 1) << 16))
! 4465: {
! 4466: tampon[2] = 0x40;
! 4467: tampon[1] = (longueur_totale + 1) & 0xFF;
! 4468: tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF;
! 4469:
! 4470: if ((chaine = realloc(chaine, (longueur_totale + 3)
! 4471: * sizeof(unsigned char))) == NULL)
! 4472: {
! 4473: (*s_etat_processus).erreur_systeme =
! 4474: d_es_allocation_memoire;
! 4475: return(NULL);
! 4476: }
! 4477:
! 4478: memcpy(&(chaine[longueur_totale]), tampon, 3);
! 4479: longueur_totale += 3;
! 4480: }
! 4481: else if (longueur_totale < (((integer8) 1) << 32))
! 4482: {
! 4483: tampon[4] = 0x80;
! 4484: tampon[3] = (longueur_totale + 1) & 0xFF;
! 4485: tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF;
! 4486: tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF;
! 4487: tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF;
! 4488:
! 4489: if ((chaine = realloc(chaine, (longueur_totale + 5)
! 4490: * sizeof(unsigned char))) == NULL)
! 4491: {
! 4492: (*s_etat_processus).erreur_systeme =
! 4493: d_es_allocation_memoire;
! 4494: return(NULL);
! 4495: }
! 4496:
! 4497: memcpy(&(chaine[longueur_totale]), tampon, 5);
! 4498: longueur_totale += 5;
! 4499: }
! 4500: else
! 4501: {
! 4502: tampon[8] = 0xC0;
! 4503: tampon[7] = (longueur_totale + 1) & 0xFF;
! 4504: tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF;
! 4505: tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF;
! 4506: tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF;
! 4507: tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF;
! 4508: tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF;
! 4509: tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF;
! 4510: tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF;
! 4511:
! 4512: if ((chaine = realloc(chaine, (longueur_totale + 9)
! 4513: * sizeof(unsigned char))) == NULL)
! 4514: {
! 4515: (*s_etat_processus).erreur_systeme =
! 4516: d_es_allocation_memoire;
! 4517: return(NULL);
! 4518: }
! 4519:
! 4520: memcpy(&(chaine[longueur_totale]), tampon, 9);
! 4521: longueur_totale += 9;
! 4522: }
! 4523:
! 4524: __zone();
! 4525: }
! 4526:
! 4527: (*longueur_effective) = longueur_totale;
! 4528: }
! 4529: else if ((*s_objet).type == TBL)
! 4530: {
! 4531:
! 4532: /*
! 4533: --------------------------------------------------------------------------------
! 4534: Table
! 4535: --------------------------------------------------------------------------------
! 4536: */
! 4537:
! 4538: if ((*s_format).type != TBL)
! 4539: {
! 4540: (*s_etat_processus).erreur_execution =
! 4541: d_ex_erreur_format_fichier;
! 4542: return(NULL);
! 4543: }
! 4544:
! 4545: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 4546: l_element_courant_format = (struct_liste_chainee *)
! 4547: (*s_format).objet;
! 4548:
! 4549: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
! 4550: (*((struct_tableau *) (*s_format).objet)).nombre_elements)
! 4551: {
! 4552: (*s_etat_processus).erreur_execution =
! 4553: d_ex_erreur_format_fichier;
! 4554: return(NULL);
! 4555: }
! 4556:
! 4557: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 4558:
! 4559: if (chaine == NULL)
! 4560: {
! 4561: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4562: return(NULL);
! 4563: }
! 4564:
! 4565: strcpy(chaine, "<[");
! 4566:
! 4567: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
! 4568: .nombre_elements; i++)
! 4569: {
! 4570: if ((((*(*((struct_tableau *) (*s_format).objet))
! 4571: .elements[i]).type == LST) &&
! 4572: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
! 4573: .type == LST)) ||
! 4574: (((*(*((struct_tableau *) (*s_format).objet))
! 4575: .elements[i]).type == TBL) &&
! 4576: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
! 4577: .type == TAB)))
! 4578: {
! 4579: chaine_sauvegarde = chaine;
! 4580:
! 4581: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 4582: (*l_element_courant).donnee,
! 4583: (*l_element_courant_format).donnee,
! 4584: 0, 0, ' ', 'F', longueur_effective, recursivite))
! 4585: == NULL)
! 4586: {
! 4587: return(NULL);
! 4588: }
! 4589:
! 4590: chaine = (unsigned char *) malloc((strlen(chaine_formatee)
! 4591: + strlen(chaine_sauvegarde) + 2)
! 4592: * sizeof(unsigned char));
! 4593:
! 4594: if (chaine == NULL)
! 4595: {
! 4596: (*s_etat_processus).erreur_systeme =
! 4597: d_es_allocation_memoire;
! 4598: return(NULL);
! 4599: }
! 4600:
! 4601: strcpy(chaine, chaine_sauvegarde);
! 4602: free(chaine_sauvegarde);
! 4603: strcat(chaine, " ");
! 4604: strcat(chaine, chaine_formatee);
! 4605: free(chaine_formatee);
! 4606: }
! 4607: else if ((*(*((struct_tableau *) (*s_format).objet))
! 4608: .elements[i]).type != CHN)
! 4609: {
! 4610: free(chaine);
! 4611:
! 4612: (*s_etat_processus).erreur_execution =
! 4613: d_ex_erreur_format_fichier;
! 4614: return(NULL);
! 4615: }
! 4616: else
! 4617: {
! 4618: if ((format_chaine = conversion_majuscule((unsigned char *)
! 4619: (*(*((struct_tableau *) (*s_format).objet))
! 4620: .elements[i]).objet)) == NULL)
! 4621: {
! 4622: (*s_etat_processus).erreur_systeme =
! 4623: d_es_allocation_memoire;
! 4624: return(NULL);
! 4625: }
! 4626:
! 4627: format_degenere = d_faux;
! 4628:
! 4629: if (strncmp("STANDARD*", format_chaine, 9) == 0)
! 4630: {
! 4631: format_sortie = 'S';
! 4632: position_1 = 9;
! 4633: format_degenere = d_vrai;
! 4634: }
! 4635: else if (strncmp("BINARY*", format_chaine, 7) == 0)
! 4636: {
! 4637: format_sortie = 'B';
! 4638: position_1 = 7;
! 4639: }
! 4640: else if (strncmp("FIXED*", format_chaine, 6) == 0)
! 4641: {
! 4642: format_sortie = 'F';
! 4643: position_1 = 6;
! 4644: }
! 4645: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
! 4646: {
! 4647: format_sortie = 'I';
! 4648: position_1 = 11;
! 4649: }
! 4650: else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
! 4651: {
! 4652: format_sortie = 'E';
! 4653: position_1 = 9;
! 4654: }
! 4655: else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
! 4656: {
! 4657: format_sortie = 'C';
! 4658: position_1 = 10;
! 4659: format_degenere = d_vrai;
! 4660: }
! 4661: else
! 4662: {
! 4663: free(chaine);
! 4664: free(format_chaine);
! 4665:
! 4666: (*s_etat_processus).erreur_execution =
! 4667: d_ex_erreur_format_fichier;
! 4668: return(NULL);
! 4669: }
! 4670:
! 4671: position_3 = strlen(format_chaine);
! 4672: format_chaine[--position_3] = d_code_fin_chaine;
! 4673:
! 4674: position_2 = position_1;
! 4675:
! 4676: while(format_chaine[position_2] != '(')
! 4677: {
! 4678: if (format_chaine[position_2] == d_code_fin_chaine)
! 4679: {
! 4680: free(chaine);
! 4681: free(format_chaine);
! 4682:
! 4683: (*s_etat_processus).erreur_execution =
! 4684: d_ex_erreur_format_fichier;
! 4685: return(NULL);
! 4686: }
! 4687:
! 4688: position_2++;
! 4689: }
! 4690:
! 4691: format_chaine[position_2++] = d_code_fin_chaine;
! 4692:
! 4693: if (format_degenere == d_faux)
! 4694: {
! 4695: if (sscanf(&(format_chaine[position_1]), "%ld",
! 4696: &longueur) != 1)
! 4697: {
! 4698: free(chaine);
! 4699: free(format_chaine);
! 4700:
! 4701: (*s_etat_processus).erreur_execution =
! 4702: d_ex_erreur_format_fichier;
! 4703: return(NULL);
! 4704: }
! 4705: }
! 4706: else
! 4707: {
! 4708: longueur = -1;
! 4709: }
! 4710:
! 4711: if (strcmp(&(format_chaine[position_2]), "*") != 0)
! 4712: {
! 4713: if (sscanf(&(format_chaine[position_2]), "%ld",
! 4714: &longueur_champ) != 1)
! 4715: {
! 4716: free(chaine);
! 4717: free(format_chaine);
! 4718:
! 4719: (*s_etat_processus).erreur_execution =
! 4720: d_ex_erreur_format_fichier;
! 4721: return(NULL);
! 4722: }
! 4723: }
! 4724: else
! 4725: {
! 4726: longueur_champ = -1;
! 4727: }
! 4728:
! 4729: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
! 4730: longueur_champ))
! 4731: {
! 4732: free(chaine);
! 4733: free(format_chaine);
! 4734:
! 4735: (*s_etat_processus).erreur_execution =
! 4736: d_ex_erreur_format_fichier;
! 4737: return(NULL);
! 4738: }
! 4739:
! 4740: free(format_chaine);
! 4741:
! 4742: chaine_sauvegarde = chaine;
! 4743:
! 4744: if ((chaine_formatee = formateur_fichier(s_etat_processus,
! 4745: (*((struct_tableau *) (*s_objet).objet))
! 4746: .elements[i], s_format,
! 4747: longueur, longueur_champ, format_sortie, type,
! 4748: longueur_effective, recursivite)) == NULL)
! 4749: {
! 4750: return(NULL);
! 4751: }
! 4752:
! 4753: if ((*(*((struct_tableau *) (*s_objet).objet))
! 4754: .elements[i]).type == CHN)
! 4755: {
! 4756: chaine = (unsigned char *)
! 4757: malloc((strlen(chaine_formatee)
! 4758: + strlen(chaine_sauvegarde) + 4)
! 4759: * sizeof(unsigned char));
! 4760:
! 4761: if (chaine == NULL)
! 4762: {
! 4763: (*s_etat_processus).erreur_systeme =
! 4764: d_es_allocation_memoire;
! 4765: return(NULL);
! 4766: }
! 4767:
! 4768: strcpy(chaine, chaine_sauvegarde);
! 4769: free(chaine_sauvegarde);
! 4770: strcat(chaine, " \"");
! 4771: strcat(chaine, chaine_formatee);
! 4772: free(chaine_formatee);
! 4773: strcat(chaine, "\"");
! 4774: }
! 4775: else if ((*(*((struct_tableau *) (*s_objet).objet))
! 4776: .elements[i]).type == NOM)
! 4777: {
! 4778: chaine = (unsigned char *)
! 4779: malloc((strlen(chaine_formatee)
! 4780: + strlen(chaine_sauvegarde) + 2)
! 4781: * sizeof(unsigned char));
! 4782:
! 4783: if (chaine == NULL)
! 4784: {
! 4785: (*s_etat_processus).erreur_systeme =
! 4786: d_es_allocation_memoire;
! 4787: return(NULL);
! 4788: }
! 4789:
! 4790: sprintf(chaine, "%s %s", chaine_sauvegarde,
! 4791: chaine_formatee);
! 4792: free(chaine_formatee);
! 4793: }
! 4794: else
! 4795: {
! 4796: chaine = (unsigned char *)
! 4797: malloc((strlen(chaine_formatee)
! 4798: + strlen(chaine_sauvegarde) + 2)
! 4799: * sizeof(unsigned char));
! 4800:
! 4801: if (chaine == NULL)
! 4802: {
! 4803: (*s_etat_processus).erreur_systeme =
! 4804: d_es_allocation_memoire;
! 4805: return(NULL);
! 4806: }
! 4807:
! 4808: strcpy(chaine, chaine_sauvegarde);
! 4809: free(chaine_sauvegarde);
! 4810: strcat(chaine, " ");
! 4811: strcat(chaine, chaine_formatee);
! 4812: free(chaine_formatee);
! 4813: }
! 4814: }
! 4815: }
! 4816:
! 4817: chaine_sauvegarde = chaine;
! 4818: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
! 4819: * sizeof(unsigned char));
! 4820:
! 4821: if (chaine == NULL)
! 4822: {
! 4823: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 4824: return(NULL);
! 4825: }
! 4826:
! 4827: strcpy(chaine, chaine_sauvegarde);
! 4828: free(chaine_sauvegarde);
! 4829: strcat(chaine, " ]>");
! 4830: }
! 4831: else if ((*s_objet).type == MCX)
! 4832: {
! 4833:
! 4834: /*
! 4835: --------------------------------------------------------------------------------
! 4836: Matrice complexe
! 4837: --------------------------------------------------------------------------------
! 4838: */
! 4839:
! 4840: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 4841: (format_sortie != 'I') && (format_sortie != 'E'))
! 4842: {
! 4843: (*s_etat_processus).erreur_execution =
! 4844: d_ex_erreur_format_fichier;
! 4845: return(NULL);
! 4846: }
! 4847:
! 4848: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 4849: .nombre_lignes;
! 4850: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 4851: .nombre_colonnes;
! 4852:
! 4853: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 4854:
! 4855: if (chaine != NULL)
! 4856: {
! 4857: strcpy(chaine, "[[");
! 4858:
! 4859: for(i = 0; i < nombre_lignes; i++)
! 4860: {
! 4861: for(j = 0; j < nombre_colonnes; j++)
! 4862: {
! 4863: if ((chaine_formatee =
! 4864: formateur_fichier_nombre(s_etat_processus,
! 4865: (void *) &(((struct_complexe16 **)
! 4866: ((*((struct_matrice *)
! 4867: ((*s_objet).objet))).tableau))[i][j]), 'C',
! 4868: longueur, longueur_champ, format_sortie))
! 4869: == NULL)
! 4870: {
! 4871: (*s_etat_processus).erreur_systeme =
! 4872: d_es_allocation_memoire;
! 4873: return(NULL);
! 4874: }
! 4875:
! 4876: chaine_sauvegarde = chaine;
! 4877: chaine = (unsigned char *) malloc(
! 4878: (strlen(chaine_sauvegarde) +
! 4879: strlen(chaine_formatee) + 2)
! 4880: * sizeof(unsigned char));
! 4881:
! 4882: if (chaine == NULL)
! 4883: {
! 4884: (*s_etat_processus).erreur_systeme =
! 4885: d_es_allocation_memoire;
! 4886: return(NULL);
! 4887: }
! 4888:
! 4889: strcpy(chaine, chaine_sauvegarde);
! 4890: free(chaine_sauvegarde);
! 4891: strcat(chaine, " ");
! 4892: strcat(chaine, chaine_formatee);
! 4893: free(chaine_formatee);
! 4894: }
! 4895:
! 4896: chaine_sauvegarde = chaine;
! 4897: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 4898: {
! 4899: chaine = (unsigned char *) malloc(
! 4900: (strlen(chaine_sauvegarde) + 6)
! 4901: * sizeof(unsigned char));
! 4902:
! 4903: if (chaine == NULL)
! 4904: {
! 4905: (*s_etat_processus).erreur_systeme =
! 4906: d_es_allocation_memoire;
! 4907: return(NULL);
! 4908: }
! 4909:
! 4910: strcpy(chaine, chaine_sauvegarde);
! 4911: free(chaine_sauvegarde);
! 4912: strcat(chaine, " ]\n [");
! 4913: }
! 4914: else
! 4915: {
! 4916: chaine = (unsigned char *) malloc(
! 4917: (strlen(chaine_sauvegarde) + 4)
! 4918: * sizeof(unsigned char));
! 4919:
! 4920: if (chaine == NULL)
! 4921: {
! 4922: (*s_etat_processus).erreur_systeme =
! 4923: d_es_allocation_memoire;
! 4924: return(NULL);
! 4925: }
! 4926:
! 4927: strcpy(chaine, chaine_sauvegarde);
! 4928: free(chaine_sauvegarde);
! 4929: strcat(chaine, " ][");
! 4930: }
! 4931: }
! 4932:
! 4933: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 4934: {
! 4935: chaine[strlen(chaine) - 3] = ']';
! 4936: chaine[strlen(chaine) - 2] = 0;
! 4937:
! 4938: chaine_sauvegarde = chaine;
! 4939: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 4940: + 1) * sizeof(unsigned char));
! 4941:
! 4942: if (chaine == NULL)
! 4943: {
! 4944: (*s_etat_processus).erreur_systeme =
! 4945: d_es_allocation_memoire;
! 4946: return(NULL);
! 4947: }
! 4948:
! 4949: strcpy(chaine, chaine_sauvegarde);
! 4950: free(chaine_sauvegarde);
! 4951: }
! 4952: else
! 4953: {
! 4954: chaine[strlen(chaine) - 2] = ']';
! 4955: chaine[strlen(chaine) - 1] = 0;
! 4956:
! 4957: chaine_sauvegarde = chaine;
! 4958: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 4959: + 2) * sizeof(unsigned char));
! 4960:
! 4961: if (chaine == NULL)
! 4962: {
! 4963: (*s_etat_processus).erreur_systeme =
! 4964: d_es_allocation_memoire;
! 4965: return(NULL);
! 4966: }
! 4967:
! 4968: strcpy(chaine, chaine_sauvegarde);
! 4969: free(chaine_sauvegarde);
! 4970: strcat(chaine, "]");
! 4971: }
! 4972: }
! 4973: }
! 4974: else if ((*s_objet).type == MIN)
! 4975: {
! 4976:
! 4977: /*
! 4978: --------------------------------------------------------------------------------
! 4979: Matrice entière
! 4980: --------------------------------------------------------------------------------
! 4981: */
! 4982:
! 4983: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 4984: (format_sortie != 'I') && (format_sortie != 'E'))
! 4985: {
! 4986: (*s_etat_processus).erreur_execution =
! 4987: d_ex_erreur_format_fichier;
! 4988: return(NULL);
! 4989: }
! 4990:
! 4991: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 4992: .nombre_lignes;
! 4993: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 4994: .nombre_colonnes;
! 4995:
! 4996: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 4997:
! 4998: if (chaine != NULL)
! 4999: {
! 5000: strcpy(chaine, "[[");
! 5001:
! 5002: for(i = 0; i < nombre_lignes; i++)
! 5003: {
! 5004: for(j = 0; j < nombre_colonnes; j++)
! 5005: {
! 5006: if ((chaine_formatee =
! 5007: formateur_fichier_nombre(s_etat_processus,
! 5008: (void *) &(((integer8 **) ((*((struct_matrice *)
! 5009: ((*s_objet).objet))).tableau))[i][j]), 'I',
! 5010: longueur, longueur_champ, format_sortie))
! 5011: == NULL)
! 5012: {
! 5013: (*s_etat_processus).erreur_systeme =
! 5014: d_es_allocation_memoire;
! 5015: return(NULL);
! 5016: }
! 5017:
! 5018: chaine_sauvegarde = chaine;
! 5019: chaine = (unsigned char *) malloc(
! 5020: (strlen(chaine_sauvegarde) +
! 5021: strlen(chaine_formatee) + 2)
! 5022: * sizeof(unsigned char));
! 5023:
! 5024: if (chaine == NULL)
! 5025: {
! 5026: (*s_etat_processus).erreur_systeme =
! 5027: d_es_allocation_memoire;
! 5028: return(NULL);
! 5029: }
! 5030:
! 5031: strcpy(chaine, chaine_sauvegarde);
! 5032: free(chaine_sauvegarde);
! 5033: strcat(chaine, " ");
! 5034: strcat(chaine, chaine_formatee);
! 5035: free(chaine_formatee);
! 5036: }
! 5037:
! 5038: chaine_sauvegarde = chaine;
! 5039: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 5040: {
! 5041: chaine = (unsigned char *) malloc(
! 5042: (strlen(chaine_sauvegarde) + 6)
! 5043: * sizeof(unsigned char));
! 5044:
! 5045: if (chaine == NULL)
! 5046: {
! 5047: (*s_etat_processus).erreur_systeme =
! 5048: d_es_allocation_memoire;
! 5049: return(NULL);
! 5050: }
! 5051:
! 5052: strcpy(chaine, chaine_sauvegarde);
! 5053: free(chaine_sauvegarde);
! 5054: strcat(chaine, " ]\n [");
! 5055: }
! 5056: else
! 5057: {
! 5058: chaine = (unsigned char *) malloc(
! 5059: (strlen(chaine_sauvegarde) + 4)
! 5060: * sizeof(unsigned char));
! 5061:
! 5062: if (chaine == NULL)
! 5063: {
! 5064: (*s_etat_processus).erreur_systeme =
! 5065: d_es_allocation_memoire;
! 5066: return(NULL);
! 5067: }
! 5068:
! 5069: strcpy(chaine, chaine_sauvegarde);
! 5070: free(chaine_sauvegarde);
! 5071: strcat(chaine, " ][");
! 5072: }
! 5073: }
! 5074:
! 5075: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 5076: {
! 5077: chaine[strlen(chaine) - 3] = ']';
! 5078: chaine[strlen(chaine) - 2] = 0;
! 5079:
! 5080: chaine_sauvegarde = chaine;
! 5081: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 5082: + 1) * sizeof(unsigned char));
! 5083:
! 5084: if (chaine == NULL)
! 5085: {
! 5086: (*s_etat_processus).erreur_systeme =
! 5087: d_es_allocation_memoire;
! 5088: return(NULL);
! 5089: }
! 5090:
! 5091: strcpy(chaine, chaine_sauvegarde);
! 5092: free(chaine_sauvegarde);
! 5093: }
! 5094: else
! 5095: {
! 5096: chaine[strlen(chaine) - 2] = ']';
! 5097: chaine[strlen(chaine) - 1] = 0;
! 5098:
! 5099: chaine_sauvegarde = chaine;
! 5100: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 5101: + 2) * sizeof(unsigned char));
! 5102:
! 5103: if (chaine == NULL)
! 5104: {
! 5105: (*s_etat_processus).erreur_systeme =
! 5106: d_es_allocation_memoire;
! 5107: return(NULL);
! 5108: }
! 5109:
! 5110: strcpy(chaine, chaine_sauvegarde);
! 5111: free(chaine_sauvegarde);
! 5112: strcat(chaine, "]");
! 5113: }
! 5114: }
! 5115: }
! 5116: else if ((*s_objet).type == MRL)
! 5117: {
! 5118:
! 5119: /*
! 5120: --------------------------------------------------------------------------------
! 5121: Matrice réelle
! 5122: --------------------------------------------------------------------------------
! 5123: */
! 5124:
! 5125: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 5126: (format_sortie != 'I') && (format_sortie != 'E'))
! 5127: {
! 5128: (*s_etat_processus).erreur_execution =
! 5129: d_ex_erreur_format_fichier;
! 5130: return(NULL);
! 5131: }
! 5132:
! 5133: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
! 5134: .nombre_lignes;
! 5135: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
! 5136: .nombre_colonnes;
! 5137:
! 5138: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
! 5139:
! 5140: if (chaine != NULL)
! 5141: {
! 5142: strcpy(chaine, "[[");
! 5143:
! 5144: for(i = 0; i < nombre_lignes; i++)
! 5145: {
! 5146: for(j = 0; j < nombre_colonnes; j++)
! 5147: {
! 5148: if ((chaine_formatee =
! 5149: formateur_fichier_nombre(s_etat_processus,
! 5150: (void *) &(((real8 **) ((*((struct_matrice *)
! 5151: ((*s_objet).objet))).tableau))[i][j]), 'R',
! 5152: longueur, longueur_champ, format_sortie))
! 5153: == NULL)
! 5154: {
! 5155: (*s_etat_processus).erreur_systeme =
! 5156: d_es_allocation_memoire;
! 5157: return(NULL);
! 5158: }
! 5159:
! 5160: chaine_sauvegarde = chaine;
! 5161: chaine = (unsigned char *) malloc(
! 5162: (strlen(chaine_sauvegarde) +
! 5163: strlen(chaine_formatee) + 2)
! 5164: * sizeof(unsigned char));
! 5165:
! 5166: if (chaine == NULL)
! 5167: {
! 5168: (*s_etat_processus).erreur_systeme =
! 5169: d_es_allocation_memoire;
! 5170: return(NULL);
! 5171: }
! 5172:
! 5173: strcpy(chaine, chaine_sauvegarde);
! 5174: free(chaine_sauvegarde);
! 5175: strcat(chaine, " ");
! 5176: strcat(chaine, chaine_formatee);
! 5177: free(chaine_formatee);
! 5178: }
! 5179:
! 5180: chaine_sauvegarde = chaine;
! 5181: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 5182: {
! 5183: chaine = (unsigned char *) malloc(
! 5184: (strlen(chaine_sauvegarde) + 6)
! 5185: * sizeof(unsigned char));
! 5186:
! 5187: if (chaine == NULL)
! 5188: {
! 5189: (*s_etat_processus).erreur_systeme =
! 5190: d_es_allocation_memoire;
! 5191: return(NULL);
! 5192: }
! 5193:
! 5194: strcpy(chaine, chaine_sauvegarde);
! 5195: free(chaine_sauvegarde);
! 5196: strcat(chaine, " ]\n [");
! 5197: }
! 5198: else
! 5199: {
! 5200: chaine = (unsigned char *) malloc(
! 5201: (strlen(chaine_sauvegarde) + 4)
! 5202: * sizeof(unsigned char));
! 5203:
! 5204: if (chaine == NULL)
! 5205: {
! 5206: (*s_etat_processus).erreur_systeme =
! 5207: d_es_allocation_memoire;
! 5208: return(NULL);
! 5209: }
! 5210:
! 5211: strcpy(chaine, chaine_sauvegarde);
! 5212: free(chaine_sauvegarde);
! 5213: strcat(chaine, " ][");
! 5214: }
! 5215: }
! 5216:
! 5217: if (test_cfsf(s_etat_processus, 45) == d_vrai)
! 5218: {
! 5219: chaine[strlen(chaine) - 3] = ']';
! 5220: chaine[strlen(chaine) - 2] = 0;
! 5221:
! 5222: chaine_sauvegarde = chaine;
! 5223: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 5224: + 1) * sizeof(unsigned char));
! 5225:
! 5226: if (chaine == NULL)
! 5227: {
! 5228: (*s_etat_processus).erreur_systeme =
! 5229: d_es_allocation_memoire;
! 5230: return(NULL);
! 5231: }
! 5232:
! 5233: strcpy(chaine, chaine_sauvegarde);
! 5234: free(chaine_sauvegarde);
! 5235: }
! 5236: else
! 5237: {
! 5238: chaine[strlen(chaine) - 2] = ']';
! 5239: chaine[strlen(chaine) - 1] = 0;
! 5240:
! 5241: chaine_sauvegarde = chaine;
! 5242: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
! 5243: + 2) * sizeof(unsigned char));
! 5244:
! 5245: if (chaine == NULL)
! 5246: {
! 5247: (*s_etat_processus).erreur_systeme =
! 5248: d_es_allocation_memoire;
! 5249: return(NULL);
! 5250: }
! 5251:
! 5252: strcpy(chaine, chaine_sauvegarde);
! 5253: free(chaine_sauvegarde);
! 5254: strcat(chaine, "]");
! 5255: }
! 5256: }
! 5257: }
! 5258: else if ((*s_objet).type == NOM)
! 5259: {
! 5260:
! 5261: /*
! 5262: --------------------------------------------------------------------------------
! 5263: Nom
! 5264: --------------------------------------------------------------------------------
! 5265: */
! 5266:
! 5267: chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
! 5268: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
! 5269:
! 5270: if (chaine == NULL)
! 5271: {
! 5272: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5273: return(NULL);
! 5274: }
! 5275:
! 5276: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
! 5277: }
! 5278: else if ((*s_objet).type == REL)
! 5279: {
! 5280:
! 5281: /*
! 5282: --------------------------------------------------------------------------------
! 5283: Réel
! 5284: --------------------------------------------------------------------------------
! 5285: */
! 5286:
! 5287: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 5288: (format_sortie != 'I') && (format_sortie != 'E'))
! 5289: {
! 5290: (*s_etat_processus).erreur_execution =
! 5291: d_ex_erreur_format_fichier;
! 5292: return(NULL);
! 5293: }
! 5294:
! 5295: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
! 5296: (void *) ((real8 *) ((*s_objet).objet)), 'R',
! 5297: longueur, longueur_champ, format_sortie)) == NULL)
! 5298: {
! 5299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5300: return(NULL);
! 5301: }
! 5302:
! 5303: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)
! 5304: * sizeof(unsigned char));
! 5305:
! 5306: if (chaine == NULL)
! 5307: {
! 5308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5309: return(NULL);
! 5310: }
! 5311:
! 5312: strcpy(chaine, chaine_formatee);
! 5313: free(chaine_formatee);
! 5314: }
! 5315: else if ((*s_objet).type == VCX)
! 5316: {
! 5317:
! 5318: /*
! 5319: --------------------------------------------------------------------------------
! 5320: Vecteur complexe
! 5321: --------------------------------------------------------------------------------
! 5322: */
! 5323:
! 5324: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 5325: (format_sortie != 'I') && (format_sortie != 'E'))
! 5326: {
! 5327: (*s_etat_processus).erreur_execution =
! 5328: d_ex_erreur_format_fichier;
! 5329: return(NULL);
! 5330: }
! 5331:
! 5332: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 5333: .taille;
! 5334:
! 5335: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 5336:
! 5337: if (chaine != NULL)
! 5338: {
! 5339: strcpy(chaine, "[");
! 5340:
! 5341: for(i = 0; i < nombre_colonnes; i++)
! 5342: {
! 5343: if ((chaine_formatee =
! 5344: formateur_fichier_nombre(s_etat_processus,
! 5345: (void *) &(((struct_complexe16 *)
! 5346: ((*((struct_vecteur *)
! 5347: ((*s_objet).objet))).tableau))[i]), 'C',
! 5348: longueur, longueur_champ, format_sortie)) == NULL)
! 5349: {
! 5350: (*s_etat_processus).erreur_systeme =
! 5351: d_es_allocation_memoire;
! 5352: return(NULL);
! 5353: }
! 5354:
! 5355: chaine_sauvegarde = chaine;
! 5356: chaine = (unsigned char *) malloc(
! 5357: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 5358: + 2) * sizeof(unsigned char));
! 5359:
! 5360: if (chaine == NULL)
! 5361: {
! 5362: (*s_etat_processus).erreur_systeme =
! 5363: d_es_allocation_memoire;
! 5364: return(NULL);
! 5365: }
! 5366:
! 5367: strcpy(chaine, chaine_sauvegarde);
! 5368: free(chaine_sauvegarde);
! 5369: strcat(chaine, " ");
! 5370: strcat(chaine, chaine_formatee);
! 5371: free(chaine_formatee);
! 5372: }
! 5373:
! 5374: chaine_sauvegarde = chaine;
! 5375: chaine = (unsigned char *) malloc(
! 5376: (strlen(chaine_sauvegarde) + 3)
! 5377: * sizeof(unsigned char));
! 5378:
! 5379: if (chaine == NULL)
! 5380: {
! 5381: (*s_etat_processus).erreur_systeme =
! 5382: d_es_allocation_memoire;
! 5383: return(NULL);
! 5384: }
! 5385:
! 5386: strcpy(chaine, chaine_sauvegarde);
! 5387: free(chaine_sauvegarde);
! 5388: strcat(chaine, " ]");
! 5389: }
! 5390: }
! 5391: else if ((*s_objet).type == VIN)
! 5392: {
! 5393:
! 5394: /*
! 5395: --------------------------------------------------------------------------------
! 5396: Vecteur entier
! 5397: --------------------------------------------------------------------------------
! 5398: */
! 5399:
! 5400: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 5401: (format_sortie != 'I') && (format_sortie != 'E'))
! 5402: {
! 5403: (*s_etat_processus).erreur_execution =
! 5404: d_ex_erreur_format_fichier;
! 5405: return(NULL);
! 5406: }
! 5407:
! 5408: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 5409: .taille;
! 5410:
! 5411: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 5412:
! 5413: if (chaine != NULL)
! 5414: {
! 5415: strcpy(chaine, "[");
! 5416:
! 5417: for(i = 0; i < nombre_colonnes; i++)
! 5418: {
! 5419: if ((chaine_formatee =
! 5420: formateur_fichier_nombre(s_etat_processus,
! 5421: (void *) &(((integer8 *) ((*((struct_vecteur *)
! 5422: ((*s_objet).objet))).tableau))[i]), 'I',
! 5423: longueur, longueur_champ, format_sortie)) == NULL)
! 5424: {
! 5425: (*s_etat_processus).erreur_systeme =
! 5426: d_es_allocation_memoire;
! 5427: return(NULL);
! 5428: }
! 5429:
! 5430: chaine_sauvegarde = chaine;
! 5431: chaine = (unsigned char *) malloc(
! 5432: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 5433: + 2) * sizeof(unsigned char));
! 5434:
! 5435: if (chaine == NULL)
! 5436: {
! 5437: (*s_etat_processus).erreur_systeme =
! 5438: d_es_allocation_memoire;
! 5439: return(NULL);
! 5440: }
! 5441:
! 5442: strcpy(chaine, chaine_sauvegarde);
! 5443: free(chaine_sauvegarde);
! 5444: strcat(chaine, " ");
! 5445: strcat(chaine, chaine_formatee);
! 5446: free(chaine_formatee);
! 5447: }
! 5448:
! 5449: chaine_sauvegarde = chaine;
! 5450: chaine = (unsigned char *) malloc(
! 5451: (strlen(chaine_sauvegarde) + 3)
! 5452: * sizeof(unsigned char));
! 5453:
! 5454: if (chaine == NULL)
! 5455: {
! 5456: (*s_etat_processus).erreur_systeme =
! 5457: d_es_allocation_memoire;
! 5458: return(NULL);
! 5459: }
! 5460:
! 5461: strcpy(chaine, chaine_sauvegarde);
! 5462: free(chaine_sauvegarde);
! 5463: strcat(chaine, " ]");
! 5464: }
! 5465: }
! 5466: else if ((*s_objet).type == VRL)
! 5467: {
! 5468:
! 5469: /*
! 5470: --------------------------------------------------------------------------------
! 5471: Vecteur réel
! 5472: --------------------------------------------------------------------------------
! 5473: */
! 5474:
! 5475: if ((format_sortie != 'S') && (format_sortie != 'F') &&
! 5476: (format_sortie != 'I') && (format_sortie != 'E'))
! 5477: {
! 5478: (*s_etat_processus).erreur_execution =
! 5479: d_ex_erreur_format_fichier;
! 5480: return(NULL);
! 5481: }
! 5482:
! 5483: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet)))
! 5484: .taille;
! 5485:
! 5486: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));
! 5487:
! 5488: if (chaine != NULL)
! 5489: {
! 5490: strcpy(chaine, "[");
! 5491:
! 5492: for(i = 0; i < nombre_colonnes; i++)
! 5493: {
! 5494: if ((chaine_formatee =
! 5495: formateur_fichier_nombre(s_etat_processus,
! 5496: (void *) &(((real8 *) ((*((struct_vecteur *)
! 5497: ((*s_objet).objet))).tableau))[i]), 'R',
! 5498: longueur, longueur_champ, format_sortie)) == NULL)
! 5499: {
! 5500: (*s_etat_processus).erreur_systeme =
! 5501: d_es_allocation_memoire;
! 5502: return(NULL);
! 5503: }
! 5504:
! 5505: chaine_sauvegarde = chaine;
! 5506: chaine = (unsigned char *) malloc(
! 5507: (strlen(chaine_sauvegarde) + strlen(chaine_formatee)
! 5508: + 2) * sizeof(unsigned char));
! 5509:
! 5510: if (chaine == NULL)
! 5511: {
! 5512: (*s_etat_processus).erreur_systeme =
! 5513: d_es_allocation_memoire;
! 5514: return(NULL);
! 5515: }
! 5516:
! 5517: strcpy(chaine, chaine_sauvegarde);
! 5518: free(chaine_sauvegarde);
! 5519: strcat(chaine, " ");
! 5520: strcat(chaine, chaine_formatee);
! 5521: free(chaine_formatee);
! 5522: }
! 5523:
! 5524: chaine_sauvegarde = chaine;
! 5525: chaine = (unsigned char *) malloc(
! 5526: (strlen(chaine_sauvegarde) + 3)
! 5527: * sizeof(unsigned char));
! 5528:
! 5529: if (chaine == NULL)
! 5530: {
! 5531: (*s_etat_processus).erreur_systeme =
! 5532: d_es_allocation_memoire;
! 5533: return(NULL);
! 5534: }
! 5535:
! 5536: strcpy(chaine, chaine_sauvegarde);
! 5537: free(chaine_sauvegarde);
! 5538: strcat(chaine, " ]");
! 5539: }
! 5540: }
! 5541: else
! 5542: {
! 5543: // Type non exportable
! 5544:
! 5545: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
! 5546: free(chaine);
! 5547:
! 5548: return(NULL);
! 5549: }
! 5550: }
! 5551:
! 5552: (*recursivite)--;
! 5553:
! 5554: return(chaine);
! 5555: }
! 5556:
! 5557:
! 5558: /*
! 5559: ================================================================================
! 5560: Routines qui transforment un nombre entier, réel ou complexe en chaîne de
! 5561: caractères suivant le format courant
! 5562: ================================================================================
! 5563: Entrées : pointeur générique sur la donnée numérique à convertir,
! 5564: type de l'entité (I, R ou C).
! 5565: --------------------------------------------------------------------------------
! 5566: Sorties : chaîne de caractères allouée dans la routine
! 5567: --------------------------------------------------------------------------------
! 5568: Effets de bord : néant
! 5569: ================================================================================
! 5570: */
! 5571:
! 5572: /*
! 5573: --------------------------------------------------------------------------------
! 5574: Formatage des complexes, réels et entiers
! 5575: --------------------------------------------------------------------------------
! 5576: */
! 5577:
! 5578: unsigned char *
! 5579: formateur_fichier_nombre(struct_processus *s_etat_processus,
! 5580: void *valeur_numerique, unsigned char type,
! 5581: long longueur, long longueur_champ, unsigned char format)
! 5582: {
! 5583: unsigned char *chaine;
! 5584: unsigned char *construction_chaine;
! 5585: unsigned char *sauvegarde;
! 5586: unsigned char *tampon;
! 5587:
! 5588: chaine = NULL;
! 5589:
! 5590: switch(type)
! 5591: {
! 5592: case 'C' :
! 5593: {
! 5594: construction_chaine = (unsigned char *) malloc(
! 5595: 2 * sizeof(unsigned char));
! 5596:
! 5597: if (construction_chaine == NULL)
! 5598: {
! 5599: (*s_etat_processus).erreur_systeme =
! 5600: d_es_allocation_memoire;
! 5601: return(NULL);
! 5602: }
! 5603:
! 5604: strcpy(construction_chaine, "(");
! 5605:
! 5606: tampon = formateur_fichier_reel(s_etat_processus,
! 5607: (void *) &((*((struct_complexe16 *)
! 5608: valeur_numerique)).partie_reelle), 'R',
! 5609: longueur, longueur_champ, format);
! 5610:
! 5611: if (tampon == NULL)
! 5612: {
! 5613: (*s_etat_processus).erreur_systeme =
! 5614: d_es_allocation_memoire;
! 5615: return(NULL);
! 5616: }
! 5617:
! 5618: sauvegarde = construction_chaine;
! 5619:
! 5620: construction_chaine = (unsigned char *) malloc(
! 5621: (strlen(sauvegarde) + strlen(tampon) + 2)
! 5622: * sizeof(unsigned char));
! 5623:
! 5624: if (construction_chaine == NULL)
! 5625: {
! 5626: (*s_etat_processus).erreur_systeme =
! 5627: d_es_allocation_memoire;
! 5628: return(NULL);
! 5629: }
! 5630:
! 5631: strcpy(construction_chaine, sauvegarde);
! 5632: free(sauvegarde);
! 5633: strcat(construction_chaine, tampon);
! 5634: free(tampon);
! 5635:
! 5636: if (test_cfsf(s_etat_processus, 48) == d_faux)
! 5637: {
! 5638: strcat(construction_chaine, ",");
! 5639: }
! 5640: else
! 5641: {
! 5642: strcat(construction_chaine, ".");
! 5643: }
! 5644:
! 5645: tampon = formateur_fichier_reel(s_etat_processus,
! 5646: (void *) &((*((struct_complexe16 *)
! 5647: valeur_numerique)).partie_imaginaire), 'R',
! 5648: longueur, longueur_champ, format);
! 5649:
! 5650: if (tampon == NULL)
! 5651: {
! 5652: (*s_etat_processus).erreur_systeme =
! 5653: d_es_allocation_memoire;
! 5654: return(NULL);
! 5655: }
! 5656:
! 5657: sauvegarde = construction_chaine;
! 5658:
! 5659: construction_chaine = (unsigned char *) malloc(
! 5660: (strlen(sauvegarde) + strlen(tampon) + 2)
! 5661: * sizeof(unsigned char));
! 5662:
! 5663: if (construction_chaine == NULL)
! 5664: {
! 5665: (*s_etat_processus).erreur_systeme =
! 5666: d_es_allocation_memoire;
! 5667: return(NULL);
! 5668: }
! 5669:
! 5670: strcpy(construction_chaine, sauvegarde);
! 5671: free(sauvegarde);
! 5672: strcat(construction_chaine, tampon);
! 5673: free(tampon);
! 5674: strcat(construction_chaine, ")");
! 5675:
! 5676: chaine = construction_chaine;
! 5677:
! 5678: break;
! 5679: }
! 5680:
! 5681: case 'R' :
! 5682: {
! 5683: chaine = formateur_fichier_reel(s_etat_processus,
! 5684: valeur_numerique, 'R', longueur, longueur_champ,
! 5685: format);
! 5686:
! 5687: if (chaine == NULL)
! 5688: {
! 5689: (*s_etat_processus).erreur_systeme =
! 5690: d_es_allocation_memoire;
! 5691: return(NULL);
! 5692: }
! 5693:
! 5694: break;
! 5695: }
! 5696:
! 5697: default :
! 5698: case 'I' :
! 5699: {
! 5700: chaine = formateur_fichier_reel(s_etat_processus,
! 5701: valeur_numerique, 'I', longueur, longueur_champ,
! 5702: format);
! 5703:
! 5704: if (chaine == NULL)
! 5705: {
! 5706: (*s_etat_processus).erreur_systeme =
! 5707: d_es_allocation_memoire;
! 5708: return(NULL);
! 5709: }
! 5710:
! 5711: break;
! 5712: }
! 5713: }
! 5714:
! 5715: return(chaine);
! 5716: }
! 5717:
! 5718:
! 5719: /*
! 5720: --------------------------------------------------------------------------------
! 5721: Recherche de la longueur de l'entier minimale pour représenter la donnée
! 5722: --------------------------------------------------------------------------------
! 5723: */
! 5724:
! 5725: unsigned char
! 5726: recherche_longueur_optimale(integer8 parametre)
! 5727: {
! 5728: if (parametre == (integer8) ((integer1) parametre))
! 5729: {
! 5730: return(0x0);
! 5731: }
! 5732: else if (parametre == (integer8) ((integer2) parametre))
! 5733: {
! 5734: return(0x1);
! 5735: }
! 5736: else if (parametre == (integer8) ((integer4) parametre))
! 5737: {
! 5738: return(0x2);
! 5739: }
! 5740: else
! 5741: {
! 5742: return(0x3);
! 5743: }
! 5744: }
! 5745:
! 5746:
! 5747: /*
! 5748: --------------------------------------------------------------------------------
! 5749: Formateur des réels et entiers
! 5750: --------------------------------------------------------------------------------
! 5751: */
! 5752:
! 5753: unsigned char *
! 5754: formateur_fichier_reel(struct_processus *s_etat_processus,
! 5755: void *valeur_numerique, unsigned char type,
! 5756: long longueur, long longueur_champ,
! 5757: unsigned char format_sortie)
! 5758: {
! 5759: real8 mantisse;
! 5760: real8 tampon_reel;
! 5761:
! 5762: integer8 tampon_entier;
! 5763:
! 5764: long correction;
! 5765: long exposant;
! 5766: long longueur_utile;
! 5767: long longueur_utile_limite;
! 5768:
! 5769: unsigned char *chaine;
! 5770: unsigned char format[16 + 1];
! 5771: unsigned char mode[3 + 1];
! 5772: unsigned char tampon[16 + 1];
! 5773:
! 5774: unsigned long i;
! 5775:
! 5776: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
! 5777:
! 5778: if (chaine == NULL)
! 5779: {
! 5780: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 5781: return(NULL);
! 5782: }
! 5783:
! 5784: if (type == 'R')
! 5785: {
! 5786: tampon_reel = *((real8 *) valeur_numerique);
! 5787:
! 5788: if (tampon_reel > ((real8) 0))
! 5789: {
! 5790: exposant = (long) floor(log10(tampon_reel));
! 5791: }
! 5792: else if (tampon_reel < ((real8) 0))
! 5793: {
! 5794: exposant = (long) floor(log10(-tampon_reel));
! 5795: }
! 5796: else
! 5797: {
! 5798: exposant = 0;
! 5799: }
! 5800:
! 5801: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
! 5802: }
! 5803: else
! 5804: {
! 5805: tampon_entier = *((integer8 *) valeur_numerique);
! 5806:
! 5807: if (tampon_entier > ((integer8) 0))
! 5808: {
! 5809: exposant = (long) floor(log10(tampon_entier));
! 5810: }
! 5811: else if (tampon_entier < ((integer8) 0))
! 5812: {
! 5813: exposant = (long) floor(log10(-tampon_entier));
! 5814: }
! 5815: else
! 5816: {
! 5817: exposant = 0;
! 5818: }
! 5819:
! 5820: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);
! 5821: }
! 5822:
! 5823: longueur_utile = longueur;
! 5824: longueur_utile_limite = 15;
! 5825:
! 5826: if (longueur_utile > longueur_utile_limite)
! 5827: {
! 5828: longueur_utile = longueur_utile_limite;
! 5829: }
! 5830:
! 5831: if (format_sortie == 'S')
! 5832: {
! 5833: strcpy(mode, "STD");
! 5834: }
! 5835: else if (format_sortie == 'C')
! 5836: {
! 5837: strcpy(mode, "SCI");
! 5838: }
! 5839: else if (format_sortie == 'F')
! 5840: {
! 5841: strcpy(mode, "FIX");
! 5842: }
! 5843: else
! 5844: {
! 5845: strcpy(mode, "ENG");
! 5846: }
! 5847:
! 5848: if ((strcmp(mode, "SCI") == 0) ||
! 5849: ((strcmp(mode, "STD") == 0) && ((exposant >
! 5850: longueur_utile_limite) ||
! 5851: (exposant < -longueur_utile_limite))) ||
! 5852: ((strcmp(mode, "FIX") == 0) &&
! 5853: ((exposant >= longueur_utile_limite) ||
! 5854: (exposant < -longueur_utile))))
! 5855: {
! 5856: chaine[0] = 0;
! 5857: format[0] = 0;
! 5858:
! 5859: if (strcmp(mode, "STD") == 0)
! 5860: {
! 5861: longueur_utile = longueur_utile_limite - 1;
! 5862: }
! 5863:
! 5864: sprintf(format, "%%.%luf", longueur_utile);
! 5865:
! 5866: sprintf(tampon, format, mantisse);
! 5867: strcpy(chaine, tampon);
! 5868: strcat(chaine, "E");
! 5869: sprintf(tampon, "%ld", exposant);
! 5870: strcat(chaine, tampon);
! 5871: }
! 5872: else if (strcmp(mode, "FIX") == 0)
! 5873: {
! 5874: chaine[0] = 0;
! 5875: format[0] = 0;
! 5876:
! 5877: if (longueur_utile + exposant >= longueur_utile_limite)
! 5878: {
! 5879: longueur_utile = longueur_utile_limite - (exposant + 1);
! 5880: }
! 5881:
! 5882: sprintf(format, "%%.%luf", longueur_utile);
! 5883:
! 5884: sprintf(tampon, format, (mantisse * pow(10, exposant)));
! 5885: strcpy(chaine, tampon);
! 5886: }
! 5887: else if (strcmp(mode, "ENG") == 0)
! 5888: {
! 5889: chaine[0] = 0;
! 5890: format[0] = 0;
! 5891:
! 5892: correction = labs(exposant) % 3;
! 5893:
! 5894: if (exposant < 0)
! 5895: {
! 5896: if (correction == 0)
! 5897: {
! 5898: correction = 3;
! 5899: }
! 5900:
! 5901: correction = 3 - correction;
! 5902: }
! 5903:
! 5904: longueur_utile -= correction;
! 5905: sprintf(format, "%%.%luf", longueur_utile);
! 5906:
! 5907: sprintf(tampon, format, (mantisse * pow(10, correction)));
! 5908: strcpy(chaine, tampon);
! 5909: strcat(chaine, "E");
! 5910: sprintf(tampon, "%ld", (exposant - correction));
! 5911: strcat(chaine, tampon);
! 5912: }
! 5913: else
! 5914: {
! 5915: if (type == 'I')
! 5916: {
! 5917: chaine[0] = 0;
! 5918: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
! 5919: }
! 5920: else
! 5921: {
! 5922: chaine[0] = 0;
! 5923: format[0] = 0;
! 5924:
! 5925: if (exposant >= 0)
! 5926: {
! 5927: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
! 5928: - 1));
! 5929: }
! 5930: else
! 5931: {
! 5932: sprintf(format, "%%.%luf", longueur_utile_limite);
! 5933: }
! 5934:
! 5935: sprintf(tampon, format, *((real8 *) valeur_numerique));
! 5936:
! 5937: i = strlen(tampon) - 1;
! 5938: while(tampon[i] == '0')
! 5939: {
! 5940: tampon[i] = 0;
! 5941: i--;
! 5942: }
! 5943:
! 5944: if (ds_imposition_separateur_decimal == d_faux)
! 5945: {
! 5946: i = strlen(tampon) - 1;
! 5947: if (tampon[i] == '.')
! 5948: {
! 5949: tampon[i] = 0;
! 5950: }
! 5951: }
! 5952: }
! 5953: strcpy(chaine, tampon);
! 5954: }
! 5955:
! 5956: if (longueur_champ >= 0)
! 5957: {
! 5958: if (strlen(chaine) > (size_t) longueur_champ)
! 5959: {
! 5960: for(i = 0; i < (unsigned long) longueur_champ; i++)
! 5961: {
! 5962: chaine[i] = '*';
! 5963: }
! 5964:
! 5965: chaine[i] = d_code_fin_chaine;
! 5966: }
! 5967: }
! 5968:
! 5969: return(chaine);
! 5970: }
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur_fichiers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src