![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 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' (formaté, non formaté) 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: if ((longueur_champ == -1) || (strlen((unsigned char *) 1180: (*s_objet).objet) < longueur_champ)) 1181: { 1182: chaine = (unsigned char *) malloc((strlen((unsigned char *) 1183: ((*s_objet).objet)) + 1) * sizeof(unsigned char)); 1184: 1185: if (chaine == NULL) 1186: { 1187: (*s_etat_processus).erreur_systeme = 1188: d_es_allocation_memoire; 1189: return(NULL); 1190: } 1191: 1192: strcpy(chaine, (unsigned char *) ((*s_objet).objet)); 1193: } 1194: else 1195: { 1196: chaine = (unsigned char *) malloc((longueur_champ + 1) 1197: * sizeof(unsigned char)); 1198: 1199: if (chaine == NULL) 1200: { 1201: (*s_etat_processus).erreur_systeme = 1202: d_es_allocation_memoire; 1203: return(NULL); 1204: } 1205: 1206: strncpy(chaine, (unsigned char *) ((*s_objet).objet), 1207: longueur_champ); 1208: chaine[longueur_champ] = d_code_fin_chaine; 1209: } 1210: } 1211: else if ((*s_objet).type == CPL) 1212: { 1213: 1214: /* 1215: -------------------------------------------------------------------------------- 1216: Complexe 1217: -------------------------------------------------------------------------------- 1218: */ 1219: 1220: if ((format_sortie != 'S') && (format_sortie != 'F') && 1221: (format_sortie != 'I') && (format_sortie != 'E')) 1222: { 1223: (*s_etat_processus).erreur_execution = 1224: d_ex_erreur_format_fichier; 1225: return(NULL); 1226: } 1227: 1228: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, 1229: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C', 1230: longueur, longueur_champ, format_sortie)) == NULL) 1231: { 1232: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1233: return(NULL); 1234: } 1235: 1236: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 1237: + 1) * sizeof(unsigned char)); 1238: 1239: if (chaine == NULL) 1240: { 1241: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1242: return(NULL); 1243: } 1244: 1245: strcpy(chaine, chaine_formatee); 1246: free(chaine_formatee); 1247: } 1248: else if ((*s_objet).type == RPN) 1249: { 1250: 1251: /* 1252: -------------------------------------------------------------------------------- 1253: Définition 1254: -------------------------------------------------------------------------------- 1255: */ 1256: 1257: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 1258: chaine_sauvegarde = chaine; 1259: 1260: while(l_element_courant != NULL) 1261: { 1262: if ((chaine_formatee = formateur_fichier(s_etat_processus, 1263: (*l_element_courant).donnee, s_format, 1264: longueur, longueur_champ, format_sortie, type, 1265: longueur_effective, recursivite)) == NULL) 1266: { 1267: return(NULL); 1268: } 1269: 1270: if ((*(*l_element_courant).donnee).type == CHN) 1271: { 1272: chaine_tampon = chaine_formatee; 1273: 1274: if ((chaine_formatee = (unsigned char *) malloc((strlen( 1275: chaine_tampon) + 3) * sizeof(unsigned char))) 1276: == NULL) 1277: { 1278: (*s_etat_processus).erreur_systeme = 1279: d_es_allocation_memoire; 1280: return(NULL); 1281: } 1282: 1283: sprintf(chaine_formatee, "\"%s\"", chaine_tampon); 1284: free(chaine_tampon); 1285: } 1286: 1287: l_element_courant = (*l_element_courant).suivant; 1288: 1289: if (chaine != NULL) 1290: { 1291: chaine_sauvegarde = chaine; 1292: 1293: if ((chaine = (unsigned char *) malloc((strlen( 1294: chaine_sauvegarde) + strlen(chaine_formatee) + 2) * 1295: sizeof(unsigned char))) == NULL) 1296: { 1297: (*s_etat_processus).erreur_systeme = 1298: d_es_allocation_memoire; 1299: return(NULL); 1300: } 1301: 1302: strcpy(chaine, chaine_sauvegarde); 1303: free(chaine_sauvegarde); 1304: strcat(chaine, " "); 1305: strcat(chaine, chaine_formatee); 1306: free(chaine_formatee); 1307: } 1308: else 1309: { 1310: chaine = chaine_formatee; 1311: } 1312: } 1313: 1314: chaine_sauvegarde = chaine; 1315: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) * 1316: sizeof(unsigned char)); 1317: 1318: if (chaine == NULL) 1319: { 1320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1321: free(chaine_sauvegarde); 1322: return(NULL); 1323: } 1324: 1325: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine; 1326: strcpy(chaine, chaine_sauvegarde); 1327: free(chaine_sauvegarde); 1328: } 1329: else if ((*s_objet).type == INT) 1330: { 1331: 1332: /* 1333: -------------------------------------------------------------------------------- 1334: Entier 1335: -------------------------------------------------------------------------------- 1336: */ 1337: 1338: if ((format_sortie != 'S') && (format_sortie != 'F') && 1339: (format_sortie != 'I') && (format_sortie != 'E')) 1340: { 1341: (*s_etat_processus).erreur_execution = 1342: d_ex_erreur_format_fichier; 1343: return(NULL); 1344: } 1345: 1346: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, 1347: (void *) ((integer8 *) ((*s_objet).objet)), 'I', 1348: longueur, longueur_champ, format_sortie)) == NULL) 1349: { 1350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1351: return(NULL); 1352: } 1353: 1354: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) 1355: * sizeof(unsigned char)); 1356: 1357: if (chaine == NULL) 1358: { 1359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1360: return(NULL); 1361: } 1362: 1363: strcpy(chaine, chaine_formatee); 1364: free(chaine_formatee); 1365: } 1366: else if ((*s_objet).type == FCT) 1367: { 1368: 1369: /* 1370: -------------------------------------------------------------------------------- 1371: Fonction 1372: -------------------------------------------------------------------------------- 1373: */ 1374: 1375: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *) 1376: ((*s_objet).objet))).nom_fonction) + 1) * 1377: sizeof(unsigned char)); 1378: 1379: if (chaine == NULL) 1380: { 1381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1382: return(NULL); 1383: } 1384: 1385: strcpy(chaine, (unsigned char *) (*((struct_fonction *) 1386: ((*s_objet).objet))).nom_fonction); 1387: } 1388: else if ((*s_objet).type == LST) 1389: { 1390: 1391: /* 1392: -------------------------------------------------------------------------------- 1393: Liste 1394: -------------------------------------------------------------------------------- 1395: */ 1396: 1397: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 1398: 1399: if (chaine == NULL) 1400: { 1401: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1402: return(NULL); 1403: } 1404: 1405: strcpy(chaine, "{"); 1406: 1407: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 1408: l_element_courant_format = (struct_liste_chainee *) 1409: (*s_format).objet; 1410: nombre_elements = 0; 1411: 1412: while((l_element_courant != NULL) && 1413: (l_element_courant_format != NULL)) 1414: { 1415: if ((((*(*l_element_courant_format).donnee).type == LST) 1416: && ((*(*l_element_courant).donnee).type == LST)) || 1417: (((*(*l_element_courant_format).donnee).type == TBL) 1418: && ((*(*l_element_courant).donnee).type == TBL))) 1419: { 1420: chaine_sauvegarde = chaine; 1421: 1422: if ((chaine_formatee = formateur_fichier(s_etat_processus, 1423: (*l_element_courant).donnee, 1424: (*l_element_courant_format).donnee, 1425: 0, 0, ' ', 'F', longueur_effective, recursivite)) 1426: == NULL) 1427: { 1428: return(NULL); 1429: } 1430: 1431: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 1432: + strlen(chaine_sauvegarde) + 2) 1433: * sizeof(unsigned char)); 1434: 1435: if (chaine == NULL) 1436: { 1437: (*s_etat_processus).erreur_systeme = 1438: d_es_allocation_memoire; 1439: return(NULL); 1440: } 1441: 1442: strcpy(chaine, chaine_sauvegarde); 1443: free(chaine_sauvegarde); 1444: strcat(chaine, " "); 1445: strcat(chaine, chaine_formatee); 1446: free(chaine_formatee); 1447: } 1448: else if ((*(*l_element_courant_format).donnee).type != CHN) 1449: { 1450: free(chaine); 1451: 1452: (*s_etat_processus).erreur_execution = 1453: d_ex_erreur_format_fichier; 1454: return(NULL); 1455: } 1456: else 1457: { 1458: if ((format_chaine = conversion_majuscule((unsigned char *) 1459: (*(*l_element_courant_format).donnee).objet)) 1460: == NULL) 1461: { 1462: (*s_etat_processus).erreur_systeme = 1463: d_es_allocation_memoire; 1464: return(NULL); 1465: } 1466: 1467: format_degenere = d_faux; 1468: 1469: if (strncmp("STANDARD*", format_chaine, 9) == 0) 1470: { 1471: format_sortie = 'S'; 1472: position_1 = 9; 1473: format_degenere = d_vrai; 1474: } 1475: else if (strncmp("BINARY*", format_chaine, 7) == 0) 1476: { 1477: format_sortie = 'B'; 1478: position_1 = 7; 1479: } 1480: else if (strncmp("FIXED*", format_chaine, 6) == 0) 1481: { 1482: format_sortie = 'F'; 1483: position_1 = 6; 1484: } 1485: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0) 1486: { 1487: format_sortie = 'I'; 1488: position_1 = 11; 1489: } 1490: else if (strncmp("ENGINEER*", format_chaine, 9) == 0) 1491: { 1492: format_sortie = 'E'; 1493: position_1 = 9; 1494: } 1495: else if (strncmp("CHARACTER*", format_chaine, 10) == 0) 1496: { 1497: format_sortie = 'C'; 1498: position_1 = 10; 1499: format_degenere = d_vrai; 1500: } 1501: else 1502: { 1503: free(chaine); 1504: free(format_chaine); 1505: 1506: (*s_etat_processus).erreur_execution = 1507: d_ex_erreur_format_fichier; 1508: return(NULL); 1509: } 1510: 1511: position_3 = strlen(format_chaine); 1512: format_chaine[--position_3] = d_code_fin_chaine; 1513: 1514: position_2 = position_1; 1515: 1516: while(format_chaine[position_2] != '(') 1517: { 1518: if (format_chaine[position_2] == d_code_fin_chaine) 1519: { 1520: free(chaine); 1521: free(format_chaine); 1522: 1523: (*s_etat_processus).erreur_execution = 1524: d_ex_erreur_format_fichier; 1525: return(NULL); 1526: } 1527: 1528: position_2++; 1529: } 1530: 1531: format_chaine[position_2++] = d_code_fin_chaine; 1532: 1533: if (format_degenere == d_faux) 1534: { 1535: if (sscanf(&(format_chaine[position_1]), "%ld", 1536: &longueur) != 1) 1537: { 1538: free(chaine); 1539: free(format_chaine); 1540: 1541: (*s_etat_processus).erreur_execution = 1542: d_ex_erreur_format_fichier; 1543: return(NULL); 1544: } 1545: } 1546: else 1547: { 1548: longueur = -1; 1549: } 1550: 1551: if (strcmp(&(format_chaine[position_2]), "*") != 0) 1552: { 1553: if (sscanf(&(format_chaine[position_2]), "%ld", 1554: &longueur_champ) != 1) 1555: { 1556: free(chaine); 1557: free(format_chaine); 1558: 1559: (*s_etat_processus).erreur_execution = 1560: d_ex_erreur_format_fichier; 1561: return(NULL); 1562: } 1563: } 1564: else 1565: { 1566: longueur_champ = -1; 1567: } 1568: 1569: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > 1570: longueur_champ)) 1571: { 1572: free(chaine); 1573: free(format_chaine); 1574: 1575: (*s_etat_processus).erreur_execution = 1576: d_ex_erreur_format_fichier; 1577: return(NULL); 1578: } 1579: 1580: free(format_chaine); 1581: 1582: chaine_sauvegarde = chaine; 1583: 1584: if ((chaine_formatee = formateur_fichier(s_etat_processus, 1585: (*l_element_courant).donnee, s_format, 1586: longueur, longueur_champ, format_sortie, type, 1587: longueur_effective, recursivite)) == NULL) 1588: { 1589: free(chaine); 1590: return(NULL); 1591: } 1592: 1593: if ((*(*l_element_courant).donnee).type == CHN) 1594: { 1595: chaine = (unsigned char *) 1596: malloc((strlen(chaine_formatee) 1597: + strlen(chaine_sauvegarde) + 4) 1598: * sizeof(unsigned char)); 1599: 1600: if (chaine == NULL) 1601: { 1602: (*s_etat_processus).erreur_systeme = 1603: d_es_allocation_memoire; 1604: return(NULL); 1605: } 1606: 1607: strcpy(chaine, chaine_sauvegarde); 1608: free(chaine_sauvegarde); 1609: strcat(chaine, " \""); 1610: strcat(chaine, chaine_formatee); 1611: free(chaine_formatee); 1612: strcat(chaine, "\""); 1613: } 1614: else if ((*(*l_element_courant).donnee).type == NOM) 1615: { 1616: chaine = (unsigned char *) 1617: malloc((strlen(chaine_formatee) 1618: + strlen(chaine_sauvegarde) + 2) 1619: * sizeof(unsigned char)); 1620: 1621: if (chaine == NULL) 1622: { 1623: (*s_etat_processus).erreur_systeme = 1624: d_es_allocation_memoire; 1625: return(NULL); 1626: } 1627: 1628: sprintf(chaine, "%s %s", chaine_sauvegarde, 1629: chaine_formatee); 1630: free(chaine_formatee); 1631: } 1632: else 1633: { 1634: chaine = (unsigned char *) 1635: malloc((strlen(chaine_formatee) 1636: + strlen(chaine_sauvegarde) + 2) 1637: * sizeof(unsigned char)); 1638: 1639: if (chaine == NULL) 1640: { 1641: (*s_etat_processus).erreur_systeme = 1642: d_es_allocation_memoire; 1643: return(NULL); 1644: } 1645: 1646: strcpy(chaine, chaine_sauvegarde); 1647: free(chaine_sauvegarde); 1648: strcat(chaine, " "); 1649: strcat(chaine, chaine_formatee); 1650: free(chaine_formatee); 1651: } 1652: } 1653: 1654: nombre_elements++; 1655: l_element_courant = (*l_element_courant).suivant; 1656: l_element_courant_format = (*l_element_courant_format).suivant; 1657: } 1658: 1659: if ((l_element_courant != NULL) || 1660: (l_element_courant_format != NULL)) 1661: { 1662: free(chaine); 1663: 1664: (*s_etat_processus).erreur_execution = 1665: d_ex_erreur_format_fichier; 1666: return(NULL); 1667: } 1668: 1669: chaine_sauvegarde = chaine; 1670: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3) 1671: * sizeof(unsigned char)); 1672: 1673: if (chaine == NULL) 1674: { 1675: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1676: return(NULL); 1677: } 1678: 1679: strcpy(chaine, chaine_sauvegarde); 1680: free(chaine_sauvegarde); 1681: strcat(chaine, " }"); 1682: } 1683: else if ((*s_objet).type == TBL) 1684: { 1685: 1686: /* 1687: -------------------------------------------------------------------------------- 1688: Table 1689: -------------------------------------------------------------------------------- 1690: */ 1691: 1692: if ((*s_format).type != TBL) 1693: { 1694: (*s_etat_processus).erreur_execution = 1695: d_ex_erreur_format_fichier; 1696: return(NULL); 1697: } 1698: 1699: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 1700: l_element_courant_format = (struct_liste_chainee *) 1701: (*s_format).objet; 1702: 1703: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 1704: (*((struct_tableau *) (*s_format).objet)).nombre_elements) 1705: { 1706: (*s_etat_processus).erreur_execution = 1707: d_ex_erreur_format_fichier; 1708: return(NULL); 1709: } 1710: 1711: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 1712: 1713: if (chaine == NULL) 1714: { 1715: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1716: return(NULL); 1717: } 1718: 1719: strcpy(chaine, "<["); 1720: 1721: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 1722: .nombre_elements; i++) 1723: { 1724: if ((((*(*((struct_tableau *) (*s_format).objet)) 1725: .elements[i]).type == LST) && 1726: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) 1727: .type == LST)) || 1728: (((*(*((struct_tableau *) (*s_format).objet)) 1729: .elements[i]).type == TBL) && 1730: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) 1731: .type == TBL))) 1732: { 1733: chaine_sauvegarde = chaine; 1734: 1735: if ((chaine_formatee = formateur_fichier(s_etat_processus, 1736: (*l_element_courant).donnee, 1737: (*l_element_courant_format).donnee, 1738: 0, 0, ' ', 'F', longueur_effective, recursivite)) 1739: == NULL) 1740: { 1741: return(NULL); 1742: } 1743: 1744: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 1745: + strlen(chaine_sauvegarde) + 2) 1746: * sizeof(unsigned char)); 1747: 1748: if (chaine == NULL) 1749: { 1750: (*s_etat_processus).erreur_systeme = 1751: d_es_allocation_memoire; 1752: return(NULL); 1753: } 1754: 1755: strcpy(chaine, chaine_sauvegarde); 1756: free(chaine_sauvegarde); 1757: strcat(chaine, " "); 1758: strcat(chaine, chaine_formatee); 1759: free(chaine_formatee); 1760: } 1761: else if ((*(*((struct_tableau *) (*s_format).objet)) 1762: .elements[i]).type != CHN) 1763: { 1764: free(chaine); 1765: 1766: (*s_etat_processus).erreur_execution = 1767: d_ex_erreur_format_fichier; 1768: return(NULL); 1769: } 1770: else 1771: { 1772: if ((format_chaine = conversion_majuscule((unsigned char *) 1773: (*(*((struct_tableau *) (*s_format).objet)) 1774: .elements[i]).objet)) == NULL) 1775: { 1776: (*s_etat_processus).erreur_systeme = 1777: d_es_allocation_memoire; 1778: return(NULL); 1779: } 1780: 1781: format_degenere = d_faux; 1782: 1783: if (strncmp("STANDARD*", format_chaine, 9) == 0) 1784: { 1785: format_sortie = 'S'; 1786: position_1 = 9; 1787: format_degenere = d_vrai; 1788: } 1789: else if (strncmp("BINARY*", format_chaine, 7) == 0) 1790: { 1791: format_sortie = 'B'; 1792: position_1 = 7; 1793: } 1794: else if (strncmp("FIXED*", format_chaine, 6) == 0) 1795: { 1796: format_sortie = 'F'; 1797: position_1 = 6; 1798: } 1799: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0) 1800: { 1801: format_sortie = 'I'; 1802: position_1 = 11; 1803: } 1804: else if (strncmp("ENGINEER*", format_chaine, 9) == 0) 1805: { 1806: format_sortie = 'E'; 1807: position_1 = 9; 1808: } 1809: else if (strncmp("CHARACTER*", format_chaine, 10) == 0) 1810: { 1811: format_sortie = 'C'; 1812: position_1 = 10; 1813: format_degenere = d_vrai; 1814: } 1815: else 1816: { 1817: free(chaine); 1818: free(format_chaine); 1819: 1820: (*s_etat_processus).erreur_execution = 1821: d_ex_erreur_format_fichier; 1822: return(NULL); 1823: } 1824: 1825: position_3 = strlen(format_chaine); 1826: format_chaine[--position_3] = d_code_fin_chaine; 1827: 1828: position_2 = position_1; 1829: 1830: while(format_chaine[position_2] != '(') 1831: { 1832: if (format_chaine[position_2] == d_code_fin_chaine) 1833: { 1834: free(chaine); 1835: free(format_chaine); 1836: 1837: (*s_etat_processus).erreur_execution = 1838: d_ex_erreur_format_fichier; 1839: return(NULL); 1840: } 1841: 1842: position_2++; 1843: } 1844: 1845: format_chaine[position_2++] = d_code_fin_chaine; 1846: 1847: if (format_degenere == d_faux) 1848: { 1849: if (sscanf(&(format_chaine[position_1]), "%ld", 1850: &longueur) != 1) 1851: { 1852: free(chaine); 1853: free(format_chaine); 1854: 1855: (*s_etat_processus).erreur_execution = 1856: d_ex_erreur_format_fichier; 1857: return(NULL); 1858: } 1859: } 1860: else 1861: { 1862: longueur = -1; 1863: } 1864: 1865: if (strcmp(&(format_chaine[position_2]), "*") != 0) 1866: { 1867: if (sscanf(&(format_chaine[position_2]), "%ld", 1868: &longueur_champ) != 1) 1869: { 1870: free(chaine); 1871: free(format_chaine); 1872: 1873: (*s_etat_processus).erreur_execution = 1874: d_ex_erreur_format_fichier; 1875: return(NULL); 1876: } 1877: } 1878: else 1879: { 1880: longueur_champ = -1; 1881: } 1882: 1883: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > 1884: longueur_champ)) 1885: { 1886: free(chaine); 1887: free(format_chaine); 1888: 1889: (*s_etat_processus).erreur_execution = 1890: d_ex_erreur_format_fichier; 1891: return(NULL); 1892: } 1893: 1894: free(format_chaine); 1895: 1896: chaine_sauvegarde = chaine; 1897: 1898: if ((chaine_formatee = formateur_fichier(s_etat_processus, 1899: (*((struct_tableau *) (*s_objet).objet)) 1900: .elements[i], s_format, 1901: longueur, longueur_champ, format_sortie, type, 1902: longueur_effective, recursivite)) == NULL) 1903: { 1904: return(NULL); 1905: } 1906: 1907: if ((*(*((struct_tableau *) (*s_objet).objet)) 1908: .elements[i]).type == CHN) 1909: { 1910: chaine = (unsigned char *) 1911: malloc((strlen(chaine_formatee) 1912: + strlen(chaine_sauvegarde) + 4) 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: strcpy(chaine, chaine_sauvegarde); 1923: free(chaine_sauvegarde); 1924: strcat(chaine, " \""); 1925: strcat(chaine, chaine_formatee); 1926: free(chaine_formatee); 1927: strcat(chaine, "\""); 1928: } 1929: else if ((*(*((struct_tableau *) (*s_objet).objet)) 1930: .elements[i]).type == NOM) 1931: { 1932: chaine = (unsigned char *) 1933: malloc((strlen(chaine_formatee) 1934: + strlen(chaine_sauvegarde) + 2) 1935: * sizeof(unsigned char)); 1936: 1937: if (chaine == NULL) 1938: { 1939: (*s_etat_processus).erreur_systeme = 1940: d_es_allocation_memoire; 1941: return(NULL); 1942: } 1943: 1944: sprintf(chaine, "%s %s", chaine_sauvegarde, 1945: chaine_formatee); 1946: free(chaine_formatee); 1947: } 1948: else 1949: { 1950: chaine = (unsigned char *) 1951: malloc((strlen(chaine_formatee) 1952: + strlen(chaine_sauvegarde) + 2) 1953: * sizeof(unsigned char)); 1954: 1955: if (chaine == NULL) 1956: { 1957: (*s_etat_processus).erreur_systeme = 1958: d_es_allocation_memoire; 1959: return(NULL); 1960: } 1961: 1962: strcpy(chaine, chaine_sauvegarde); 1963: free(chaine_sauvegarde); 1964: strcat(chaine, " "); 1965: strcat(chaine, chaine_formatee); 1966: free(chaine_formatee); 1967: } 1968: } 1969: } 1970: 1971: chaine_sauvegarde = chaine; 1972: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) 1973: * sizeof(unsigned char)); 1974: 1975: if (chaine == NULL) 1976: { 1977: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1978: return(NULL); 1979: } 1980: 1981: strcpy(chaine, chaine_sauvegarde); 1982: free(chaine_sauvegarde); 1983: strcat(chaine, " ]>"); 1984: } 1985: else if ((*s_objet).type == MCX) 1986: { 1987: 1988: /* 1989: -------------------------------------------------------------------------------- 1990: Matrice complexe 1991: -------------------------------------------------------------------------------- 1992: */ 1993: 1994: if ((format_sortie != 'S') && (format_sortie != 'F') && 1995: (format_sortie != 'I') && (format_sortie != 'E')) 1996: { 1997: (*s_etat_processus).erreur_execution = 1998: d_ex_erreur_format_fichier; 1999: return(NULL); 2000: } 2001: 2002: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2003: .nombre_lignes; 2004: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2005: .nombre_colonnes; 2006: 2007: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2008: 2009: if (chaine != NULL) 2010: { 2011: strcpy(chaine, "[["); 2012: 2013: for(i = 0; i < nombre_lignes; i++) 2014: { 2015: for(j = 0; j < nombre_colonnes; j++) 2016: { 2017: if ((chaine_formatee = 2018: formateur_fichier_nombre(s_etat_processus, 2019: (void *) &(((struct_complexe16 **) 2020: ((*((struct_matrice *) 2021: ((*s_objet).objet))).tableau))[i][j]), 'C', 2022: longueur, longueur_champ, format_sortie)) 2023: == NULL) 2024: { 2025: (*s_etat_processus).erreur_systeme = 2026: d_es_allocation_memoire; 2027: return(NULL); 2028: } 2029: 2030: chaine_sauvegarde = chaine; 2031: chaine = (unsigned char *) malloc( 2032: (strlen(chaine_sauvegarde) + 2033: strlen(chaine_formatee) + 2) 2034: * sizeof(unsigned char)); 2035: 2036: if (chaine == NULL) 2037: { 2038: (*s_etat_processus).erreur_systeme = 2039: d_es_allocation_memoire; 2040: return(NULL); 2041: } 2042: 2043: strcpy(chaine, chaine_sauvegarde); 2044: free(chaine_sauvegarde); 2045: strcat(chaine, " "); 2046: strcat(chaine, chaine_formatee); 2047: free(chaine_formatee); 2048: } 2049: 2050: chaine_sauvegarde = chaine; 2051: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2052: { 2053: chaine = (unsigned char *) malloc( 2054: (strlen(chaine_sauvegarde) + 6) 2055: * sizeof(unsigned char)); 2056: 2057: if (chaine == NULL) 2058: { 2059: (*s_etat_processus).erreur_systeme = 2060: d_es_allocation_memoire; 2061: return(NULL); 2062: } 2063: 2064: strcpy(chaine, chaine_sauvegarde); 2065: free(chaine_sauvegarde); 2066: strcat(chaine, " ]\n ["); 2067: } 2068: else 2069: { 2070: chaine = (unsigned char *) malloc( 2071: (strlen(chaine_sauvegarde) + 4) 2072: * 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: strcat(chaine, " ]["); 2084: } 2085: } 2086: 2087: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2088: { 2089: chaine[strlen(chaine) - 3] = ']'; 2090: chaine[strlen(chaine) - 2] = 0; 2091: 2092: chaine_sauvegarde = chaine; 2093: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2094: + 1) * sizeof(unsigned char)); 2095: 2096: if (chaine == NULL) 2097: { 2098: (*s_etat_processus).erreur_systeme = 2099: d_es_allocation_memoire; 2100: return(NULL); 2101: } 2102: 2103: strcpy(chaine, chaine_sauvegarde); 2104: free(chaine_sauvegarde); 2105: } 2106: else 2107: { 2108: chaine[strlen(chaine) - 2] = ']'; 2109: chaine[strlen(chaine) - 1] = 0; 2110: 2111: chaine_sauvegarde = chaine; 2112: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2113: + 2) * sizeof(unsigned char)); 2114: 2115: if (chaine == NULL) 2116: { 2117: (*s_etat_processus).erreur_systeme = 2118: d_es_allocation_memoire; 2119: return(NULL); 2120: } 2121: 2122: strcpy(chaine, chaine_sauvegarde); 2123: free(chaine_sauvegarde); 2124: strcat(chaine, "]"); 2125: } 2126: } 2127: } 2128: else if ((*s_objet).type == MIN) 2129: { 2130: 2131: /* 2132: -------------------------------------------------------------------------------- 2133: Matrice entière 2134: -------------------------------------------------------------------------------- 2135: */ 2136: 2137: if ((format_sortie != 'S') && (format_sortie != 'F') && 2138: (format_sortie != 'I') && (format_sortie != 'E')) 2139: { 2140: (*s_etat_processus).erreur_execution = 2141: d_ex_erreur_format_fichier; 2142: return(NULL); 2143: } 2144: 2145: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2146: .nombre_lignes; 2147: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2148: .nombre_colonnes; 2149: 2150: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2151: 2152: if (chaine != NULL) 2153: { 2154: strcpy(chaine, "[["); 2155: 2156: for(i = 0; i < nombre_lignes; i++) 2157: { 2158: for(j = 0; j < nombre_colonnes; j++) 2159: { 2160: if ((chaine_formatee = 2161: formateur_fichier_nombre(s_etat_processus, 2162: (void *) &(((integer8 **) ((*((struct_matrice *) 2163: ((*s_objet).objet))).tableau))[i][j]), 'I', 2164: longueur, longueur_champ, format_sortie)) 2165: == NULL) 2166: { 2167: (*s_etat_processus).erreur_systeme = 2168: d_es_allocation_memoire; 2169: return(NULL); 2170: } 2171: 2172: chaine_sauvegarde = chaine; 2173: chaine = (unsigned char *) malloc( 2174: (strlen(chaine_sauvegarde) + 2175: strlen(chaine_formatee) + 2) 2176: * sizeof(unsigned char)); 2177: 2178: if (chaine == NULL) 2179: { 2180: (*s_etat_processus).erreur_systeme = 2181: d_es_allocation_memoire; 2182: return(NULL); 2183: } 2184: 2185: strcpy(chaine, chaine_sauvegarde); 2186: free(chaine_sauvegarde); 2187: strcat(chaine, " "); 2188: strcat(chaine, chaine_formatee); 2189: free(chaine_formatee); 2190: } 2191: 2192: chaine_sauvegarde = chaine; 2193: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2194: { 2195: chaine = (unsigned char *) malloc( 2196: (strlen(chaine_sauvegarde) + 6) 2197: * sizeof(unsigned char)); 2198: 2199: if (chaine == NULL) 2200: { 2201: (*s_etat_processus).erreur_systeme = 2202: d_es_allocation_memoire; 2203: return(NULL); 2204: } 2205: 2206: strcpy(chaine, chaine_sauvegarde); 2207: free(chaine_sauvegarde); 2208: strcat(chaine, " ]\n ["); 2209: } 2210: else 2211: { 2212: chaine = (unsigned char *) malloc( 2213: (strlen(chaine_sauvegarde) + 4) 2214: * 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: strcat(chaine, " ]["); 2226: } 2227: } 2228: 2229: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2230: { 2231: chaine[strlen(chaine) - 3] = ']'; 2232: chaine[strlen(chaine) - 2] = 0; 2233: 2234: chaine_sauvegarde = chaine; 2235: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2236: + 1) * sizeof(unsigned char)); 2237: 2238: if (chaine == NULL) 2239: { 2240: (*s_etat_processus).erreur_systeme = 2241: d_es_allocation_memoire; 2242: return(NULL); 2243: } 2244: 2245: strcpy(chaine, chaine_sauvegarde); 2246: free(chaine_sauvegarde); 2247: } 2248: else 2249: { 2250: chaine[strlen(chaine) - 2] = ']'; 2251: chaine[strlen(chaine) - 1] = 0; 2252: 2253: chaine_sauvegarde = chaine; 2254: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2255: + 2) * sizeof(unsigned char)); 2256: 2257: if (chaine == NULL) 2258: { 2259: (*s_etat_processus).erreur_systeme = 2260: d_es_allocation_memoire; 2261: return(NULL); 2262: } 2263: 2264: strcpy(chaine, chaine_sauvegarde); 2265: free(chaine_sauvegarde); 2266: strcat(chaine, "]"); 2267: } 2268: } 2269: } 2270: else if ((*s_objet).type == MRL) 2271: { 2272: 2273: /* 2274: -------------------------------------------------------------------------------- 2275: Matrice réelle 2276: -------------------------------------------------------------------------------- 2277: */ 2278: 2279: if ((format_sortie != 'S') && (format_sortie != 'F') && 2280: (format_sortie != 'I') && (format_sortie != 'E')) 2281: { 2282: (*s_etat_processus).erreur_execution = 2283: d_ex_erreur_format_fichier; 2284: return(NULL); 2285: } 2286: 2287: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2288: .nombre_lignes; 2289: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2290: .nombre_colonnes; 2291: 2292: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2293: 2294: if (chaine != NULL) 2295: { 2296: strcpy(chaine, "[["); 2297: 2298: for(i = 0; i < nombre_lignes; i++) 2299: { 2300: for(j = 0; j < nombre_colonnes; j++) 2301: { 2302: if ((chaine_formatee = 2303: formateur_fichier_nombre(s_etat_processus, 2304: (void *) &(((real8 **) ((*((struct_matrice *) 2305: ((*s_objet).objet))).tableau))[i][j]), 'R', 2306: longueur, longueur_champ, format_sortie)) 2307: == NULL) 2308: { 2309: (*s_etat_processus).erreur_systeme = 2310: d_es_allocation_memoire; 2311: return(NULL); 2312: } 2313: 2314: chaine_sauvegarde = chaine; 2315: chaine = (unsigned char *) malloc( 2316: (strlen(chaine_sauvegarde) + 2317: strlen(chaine_formatee) + 2) 2318: * sizeof(unsigned char)); 2319: 2320: if (chaine == NULL) 2321: { 2322: (*s_etat_processus).erreur_systeme = 2323: d_es_allocation_memoire; 2324: return(NULL); 2325: } 2326: 2327: strcpy(chaine, chaine_sauvegarde); 2328: free(chaine_sauvegarde); 2329: strcat(chaine, " "); 2330: strcat(chaine, chaine_formatee); 2331: free(chaine_formatee); 2332: } 2333: 2334: chaine_sauvegarde = chaine; 2335: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2336: { 2337: chaine = (unsigned char *) malloc( 2338: (strlen(chaine_sauvegarde) + 6) 2339: * sizeof(unsigned char)); 2340: 2341: if (chaine == NULL) 2342: { 2343: (*s_etat_processus).erreur_systeme = 2344: d_es_allocation_memoire; 2345: return(NULL); 2346: } 2347: 2348: strcpy(chaine, chaine_sauvegarde); 2349: free(chaine_sauvegarde); 2350: strcat(chaine, " ]\n ["); 2351: } 2352: else 2353: { 2354: chaine = (unsigned char *) malloc( 2355: (strlen(chaine_sauvegarde) + 4) 2356: * 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: strcat(chaine, " ]["); 2368: } 2369: } 2370: 2371: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2372: { 2373: chaine[strlen(chaine) - 3] = ']'; 2374: chaine[strlen(chaine) - 2] = 0; 2375: 2376: chaine_sauvegarde = chaine; 2377: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2378: + 1) * sizeof(unsigned char)); 2379: 2380: if (chaine == NULL) 2381: { 2382: (*s_etat_processus).erreur_systeme = 2383: d_es_allocation_memoire; 2384: return(NULL); 2385: } 2386: 2387: strcpy(chaine, chaine_sauvegarde); 2388: free(chaine_sauvegarde); 2389: } 2390: else 2391: { 2392: chaine[strlen(chaine) - 2] = ']'; 2393: chaine[strlen(chaine) - 1] = 0; 2394: 2395: chaine_sauvegarde = chaine; 2396: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2397: + 2) * sizeof(unsigned char)); 2398: 2399: if (chaine == NULL) 2400: { 2401: (*s_etat_processus).erreur_systeme = 2402: d_es_allocation_memoire; 2403: return(NULL); 2404: } 2405: 2406: strcpy(chaine, chaine_sauvegarde); 2407: free(chaine_sauvegarde); 2408: strcat(chaine, "]"); 2409: } 2410: } 2411: } 2412: else if ((*s_objet).type == NOM) 2413: { 2414: 2415: /* 2416: -------------------------------------------------------------------------------- 2417: Nom 2418: -------------------------------------------------------------------------------- 2419: */ 2420: 2421: chaine = (unsigned char *) malloc((strlen((*((struct_nom *) 2422: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); 2423: 2424: if (chaine == NULL) 2425: { 2426: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2427: return(NULL); 2428: } 2429: 2430: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom); 2431: } 2432: else if ((*s_objet).type == REL) 2433: { 2434: 2435: /* 2436: -------------------------------------------------------------------------------- 2437: Réel 2438: -------------------------------------------------------------------------------- 2439: */ 2440: 2441: if ((format_sortie != 'S') && (format_sortie != 'F') && 2442: (format_sortie != 'I') && (format_sortie != 'E')) 2443: { 2444: (*s_etat_processus).erreur_execution = 2445: d_ex_erreur_format_fichier; 2446: return(NULL); 2447: } 2448: 2449: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, 2450: (void *) ((real8 *) ((*s_objet).objet)), 'R', 2451: longueur, longueur_champ, format_sortie)) == NULL) 2452: { 2453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2454: return(NULL); 2455: } 2456: 2457: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) 2458: * sizeof(unsigned char)); 2459: 2460: if (chaine == NULL) 2461: { 2462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2463: return(NULL); 2464: } 2465: 2466: strcpy(chaine, chaine_formatee); 2467: free(chaine_formatee); 2468: } 2469: else if ((*s_objet).type == VCX) 2470: { 2471: 2472: /* 2473: -------------------------------------------------------------------------------- 2474: Vecteur complexe 2475: -------------------------------------------------------------------------------- 2476: */ 2477: 2478: if ((format_sortie != 'S') && (format_sortie != 'F') && 2479: (format_sortie != 'I') && (format_sortie != 'E')) 2480: { 2481: (*s_etat_processus).erreur_execution = 2482: d_ex_erreur_format_fichier; 2483: return(NULL); 2484: } 2485: 2486: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 2487: .taille; 2488: 2489: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 2490: 2491: if (chaine != NULL) 2492: { 2493: strcpy(chaine, "["); 2494: 2495: for(i = 0; i < nombre_colonnes; i++) 2496: { 2497: if ((chaine_formatee = 2498: formateur_fichier_nombre(s_etat_processus, 2499: (void *) &(((struct_complexe16 *) 2500: ((*((struct_vecteur *) 2501: ((*s_objet).objet))).tableau))[i]), 'C', 2502: longueur, longueur_champ, format_sortie)) == NULL) 2503: { 2504: (*s_etat_processus).erreur_systeme = 2505: d_es_allocation_memoire; 2506: return(NULL); 2507: } 2508: 2509: chaine_sauvegarde = chaine; 2510: chaine = (unsigned char *) malloc( 2511: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 2512: + 2) * sizeof(unsigned char)); 2513: 2514: if (chaine == NULL) 2515: { 2516: (*s_etat_processus).erreur_systeme = 2517: d_es_allocation_memoire; 2518: return(NULL); 2519: } 2520: 2521: strcpy(chaine, chaine_sauvegarde); 2522: free(chaine_sauvegarde); 2523: strcat(chaine, " "); 2524: strcat(chaine, chaine_formatee); 2525: free(chaine_formatee); 2526: } 2527: 2528: chaine_sauvegarde = chaine; 2529: chaine = (unsigned char *) malloc( 2530: (strlen(chaine_sauvegarde) + 3) 2531: * sizeof(unsigned char)); 2532: 2533: if (chaine == NULL) 2534: { 2535: (*s_etat_processus).erreur_systeme = 2536: d_es_allocation_memoire; 2537: return(NULL); 2538: } 2539: 2540: strcpy(chaine, chaine_sauvegarde); 2541: free(chaine_sauvegarde); 2542: strcat(chaine, " ]"); 2543: } 2544: } 2545: else if ((*s_objet).type == VIN) 2546: { 2547: 2548: /* 2549: -------------------------------------------------------------------------------- 2550: Vecteur entier 2551: -------------------------------------------------------------------------------- 2552: */ 2553: 2554: if ((format_sortie != 'S') && (format_sortie != 'F') && 2555: (format_sortie != 'I') && (format_sortie != 'E')) 2556: { 2557: (*s_etat_processus).erreur_execution = 2558: d_ex_erreur_format_fichier; 2559: return(NULL); 2560: } 2561: 2562: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 2563: .taille; 2564: 2565: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 2566: 2567: if (chaine != NULL) 2568: { 2569: strcpy(chaine, "["); 2570: 2571: for(i = 0; i < nombre_colonnes; i++) 2572: { 2573: if ((chaine_formatee = 2574: formateur_fichier_nombre(s_etat_processus, 2575: (void *) &(((integer8 *) ((*((struct_vecteur *) 2576: ((*s_objet).objet))).tableau))[i]), 'I', 2577: longueur, longueur_champ, format_sortie)) == NULL) 2578: { 2579: (*s_etat_processus).erreur_systeme = 2580: d_es_allocation_memoire; 2581: return(NULL); 2582: } 2583: 2584: chaine_sauvegarde = chaine; 2585: chaine = (unsigned char *) malloc( 2586: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 2587: + 2) * sizeof(unsigned char)); 2588: 2589: if (chaine == NULL) 2590: { 2591: (*s_etat_processus).erreur_systeme = 2592: d_es_allocation_memoire; 2593: return(NULL); 2594: } 2595: 2596: strcpy(chaine, chaine_sauvegarde); 2597: free(chaine_sauvegarde); 2598: strcat(chaine, " "); 2599: strcat(chaine, chaine_formatee); 2600: free(chaine_formatee); 2601: } 2602: 2603: chaine_sauvegarde = chaine; 2604: chaine = (unsigned char *) malloc( 2605: (strlen(chaine_sauvegarde) + 3) 2606: * sizeof(unsigned char)); 2607: 2608: if (chaine == NULL) 2609: { 2610: (*s_etat_processus).erreur_systeme = 2611: d_es_allocation_memoire; 2612: return(NULL); 2613: } 2614: 2615: strcpy(chaine, chaine_sauvegarde); 2616: free(chaine_sauvegarde); 2617: strcat(chaine, " ]"); 2618: } 2619: } 2620: else if ((*s_objet).type == VRL) 2621: { 2622: 2623: /* 2624: -------------------------------------------------------------------------------- 2625: Vecteur réel 2626: -------------------------------------------------------------------------------- 2627: */ 2628: 2629: if ((format_sortie != 'S') && (format_sortie != 'F') && 2630: (format_sortie != 'I') && (format_sortie != 'E')) 2631: { 2632: (*s_etat_processus).erreur_execution = 2633: d_ex_erreur_format_fichier; 2634: return(NULL); 2635: } 2636: 2637: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 2638: .taille; 2639: 2640: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 2641: 2642: if (chaine != NULL) 2643: { 2644: strcpy(chaine, "["); 2645: 2646: for(i = 0; i < nombre_colonnes; i++) 2647: { 2648: if ((chaine_formatee = 2649: formateur_fichier_nombre(s_etat_processus, 2650: (void *) &(((real8 *) ((*((struct_vecteur *) 2651: ((*s_objet).objet))).tableau))[i]), 'R', 2652: longueur, longueur_champ, format_sortie)) == NULL) 2653: { 2654: (*s_etat_processus).erreur_systeme = 2655: d_es_allocation_memoire; 2656: return(NULL); 2657: } 2658: 2659: chaine_sauvegarde = chaine; 2660: chaine = (unsigned char *) malloc( 2661: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 2662: + 2) * sizeof(unsigned char)); 2663: 2664: if (chaine == NULL) 2665: { 2666: (*s_etat_processus).erreur_systeme = 2667: d_es_allocation_memoire; 2668: return(NULL); 2669: } 2670: 2671: strcpy(chaine, chaine_sauvegarde); 2672: free(chaine_sauvegarde); 2673: strcat(chaine, " "); 2674: strcat(chaine, chaine_formatee); 2675: free(chaine_formatee); 2676: } 2677: 2678: chaine_sauvegarde = chaine; 2679: chaine = (unsigned char *) malloc( 2680: (strlen(chaine_sauvegarde) + 3) 2681: * sizeof(unsigned char)); 2682: 2683: if (chaine == NULL) 2684: { 2685: (*s_etat_processus).erreur_systeme = 2686: d_es_allocation_memoire; 2687: return(NULL); 2688: } 2689: 2690: strcpy(chaine, chaine_sauvegarde); 2691: free(chaine_sauvegarde); 2692: strcat(chaine, " ]"); 2693: } 2694: } 2695: else 2696: { 2697: // Type non exportable 2698: 2699: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; 2700: free(chaine); 2701: 2702: return(NULL); 2703: } 2704: 2705: (*longueur_effective) = strlen(chaine) + 1; 2706: } 2707: else 2708: { 2709: /* 2710: * Fichiers non formatés 2711: */ 2712: 2713: #define __zone() \ 2714: do { int _i; for(_i = 0; _i < longueur_totale; _i++) \ 2715: printf("%02X ", chaine[_i]); printf("\b\n"); } while(0) 2716: 2717: /* 2718: * Chaque enregistrement est composé d'une donnée (une liste) 2719: * suivie de sa longueur en octets et d'un champ binaire indiquant 2720: * le format (integer*1,2,4 ou 8) d'écriture de cette longueur. 2721: * Les données contenues dans ces fichiers sont associées à un 2722: * descripteur de type. 2723: * 2724: * Attention : les fichiers non formatés ne sont pas portables 2725: * d'une architecture à l'autre. 2726: * 2727: * Structure d'un enregistrement : 2728: * [en-tête][.........données..........][longueur + type de longueur] 2729: * 2730: * Longueur : (pour l'instruction backspace) 2731: * 2732: * 00 XXXXXX longueur sur 6 bits 2733: * 01 ------ longueur sur 16 bits 2734: * 10 ------ longueur sur 32 bits 2735: * 11 ------ longueur sur 64 bits 2736: * 2737: * Structures des enregistrements : 2738: * chaque type de donnée est associé à une en-tête binaire comprenant 2739: * le type de données ainsi que toutes autres informations utiles. 2740: * 2741: * Représentation binaire : 2742: * 2743: * 1/ scalaires 2744: * 0000 XXXX Binaire sur XXXX octets 2745: * 2746: * TYPE 2747: * 0001 00 00 integer*1 2748: * 0001 00 01 integer*2 2749: * 0001 00 10 integer*4 2750: * 0001 00 11 integer*8 2751: * 2752: * 0001 01 00 real*4 2753: * 0001 01 01 real*8 2754: * 2755: * 0001 10 00 complex*8 2756: * 0001 10 01 complex*16 2757: * 2758: * 0010 00 00 vecteur integer*1 (dimensions integer*1) 2759: * 0010 01 00 vecteur integer*1 (dimensions integer*2) 2760: * 0010 10 00 vecteur integer*1 (dimensions integer*4) 2761: * 0010 11 00 vecteur integer*1 (dimensions integer*8) 2762: * 0010 00 01 vecteur integer*2 (dimensions integer*1) 2763: * 0010 01 01 vecteur integer*2 (dimensions integer*2) 2764: * 0010 10 01 vecteur integer*2 (dimensions integer*4) 2765: * 0010 11 01 vecteur integer*2 (dimensions integer*8) 2766: * 0010 00 10 vecteur integer*4 (dimensions integer*1) 2767: * 0010 01 10 vecteur integer*4 (dimensions integer*2) 2768: * 0010 10 10 vecteur integer*4 (dimensions integer*4) 2769: * 0010 11 10 vecteur integer*4 (dimensions integer*8) 2770: * 0010 00 11 vecteur integer*8 (dimensions integer*1) 2771: * 0010 01 11 vecteur integer*8 (dimensions integer*2) 2772: * 0010 10 11 vecteur integer*8 (dimensions integer*4) 2773: * 0010 11 11 vecteur integer*8 (dimensions integer*8) 2774: * 2775: * 0011 00 00 matrice integer*1 (dimensions integer*1) 2776: * 0011 01 00 matrice integer*1 (dimensions integer*2) 2777: * 0011 10 00 matrice integer*1 (dimensions integer*4) 2778: * 0011 11 00 matrice integer*1 (dimensions integer*8) 2779: * 0011 00 01 matrice integer*2 (dimensions integer*1) 2780: * 0011 01 01 matrice integer*2 (dimensions integer*2) 2781: * 0011 10 01 matrice integer*2 (dimensions integer*4) 2782: * 0011 11 01 matrice integer*2 (dimensions integer*8) 2783: * 0011 00 10 matrice integer*4 (dimensions integer*1) 2784: * 0011 01 10 matrice integer*4 (dimensions integer*2) 2785: * 0011 10 10 matrice integer*4 (dimensions integer*4) 2786: * 0011 11 10 matrice integer*4 (dimensions integer*8) 2787: * 0011 00 11 matrice integer*8 (dimensions integer*1) 2788: * 0011 01 11 matrice integer*8 (dimensions integer*2) 2789: * 0011 10 11 matrice integer*8 (dimensions integer*4) 2790: * 0011 11 11 matrice integer*8 (dimensions integer*8) 2791: * 2792: * 0100 0 XXX liste de longueur XXX 2793: * 0100 10 00 liste de longueur integer*1 2794: * 0100 10 01 liste de longueur integer*2 2795: * 0100 10 10 liste de longueur integer*4 2796: * 0100 10 11 liste de longueur integer*8 2797: * 2798: * 0101 0 XXX nom de longueur XXX 2799: * 0101 10 LL nom de longueur integer*LL 2800: * 2801: * 0110 0 XXX expression RPN 2802: * 0110 10 LL 2803: * 2804: * 0111 0 XXX expression algébrique 2805: * 0111 10 LL 2806: * 2807: * 1000 0 XXX chaîne de caractères 2808: * 1000 10 LL 2809: * 2810: * 1001 0 XXX table de longueur XXX 2811: * 1001 10 00 table de longueur integer*1 2812: * 1001 10 01 table de longueur integer*2 2813: * 1001 10 10 table de longueur integer*4 2814: * 1001 10 11 table de longueur integer*8 2815: * 2816: * Les longueurs indiquées par le champ LL suivent l'en-tête : 2817: * [En-tête][longueur_1][longueur_2][données] 2818: * le nombre de champs longueur dépendant des types d'enregistrement. 2819: * 2820: * Toutes les autres combinaisons sont invalides. 2821: */ 2822: 2823: chaine = NULL; 2824: chaine_formatee = NULL; 2825: chaine_sauvegarde = NULL; 2826: 2827: strcpy(base, " "); 2828: 2829: longueur_binaire = 0; 2830: masque_binaire = 0; 2831: 2832: if ((*s_objet).type == ALG) 2833: { 2834: 2835: /* 2836: -------------------------------------------------------------------------------- 2837: Expression algébrique 2838: -------------------------------------------------------------------------------- 2839: */ 2840: 2841: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 2842: 2843: while(l_element_courant != NULL) 2844: { 2845: if ((*(*l_element_courant).donnee).type == FCT) 2846: { 2847: if ((strcmp((*((struct_fonction *) (*(*l_element_courant) 2848: .donnee).objet)).nom_fonction, "<<") != 0) && 2849: (strcmp((*((struct_fonction *) 2850: (*(*l_element_courant) 2851: .donnee).objet)).nom_fonction, ">>") != 0)) 2852: { 2853: if ((strcmp((*((struct_fonction *) 2854: (*(*l_element_courant) 2855: .donnee).objet)).nom_fonction, "+") == 0) || 2856: (strcmp((*((struct_fonction *) 2857: (*(*l_element_courant).donnee).objet)) 2858: .nom_fonction, "-") == 0) || (strcmp( 2859: (*((struct_fonction *) (*(*l_element_courant) 2860: .donnee).objet)).nom_fonction, "*") == 0) || 2861: (strcmp((*((struct_fonction *) 2862: (*(*l_element_courant).donnee).objet)) 2863: .nom_fonction, 2864: "/") == 0) || (strcmp((*((struct_fonction *) 2865: (*(*l_element_courant).donnee).objet)) 2866: .nom_fonction, 2867: "^") == 0) || (strcmp((*((struct_fonction *) 2868: (*(*l_element_courant).donnee).objet)) 2869: .nom_fonction, 2870: "<") == 0) || (strcmp((*((struct_fonction *) 2871: (*(*l_element_courant).donnee).objet)) 2872: .nom_fonction, 2873: ">") == 0) || (strcmp((*((struct_fonction *) 2874: (*(*l_element_courant).donnee).objet)) 2875: .nom_fonction, 2876: "==") == 0) || (strcmp((*((struct_fonction *) 2877: (*(*l_element_courant).donnee).objet)) 2878: .nom_fonction, 2879: "<>") == 0) || (strcmp((*((struct_fonction *) 2880: (*(*l_element_courant).donnee).objet)) 2881: .nom_fonction, 2882: "<=") == 0) || (strcmp((*((struct_fonction *) 2883: (*(*l_element_courant).donnee).objet)) 2884: .nom_fonction, 2885: "=<") == 0) || (strcmp((*((struct_fonction *) 2886: (*(*l_element_courant).donnee).objet)) 2887: .nom_fonction, 2888: ">=") == 0) || (strcmp((*((struct_fonction *) 2889: (*(*l_element_courant).donnee).objet)) 2890: .nom_fonction, 2891: "=>") == 0)) 2892: { 2893: if (depilement(s_etat_processus, 2894: &((*s_etat_processus) 2895: .l_base_pile), &s_sous_objet_2) == d_erreur) 2896: { 2897: return(NULL); 2898: } 2899: 2900: chaine_sauvegarde = (*s_etat_processus) 2901: .instruction_courante; 2902: 2903: if (((*s_etat_processus).instruction_courante = 2904: (unsigned char *) malloc((strlen( 2905: (unsigned char *) (*s_sous_objet_2).objet) 2906: + 2 + 1) * sizeof(unsigned char))) == NULL) 2907: { 2908: (*s_etat_processus).instruction_courante = 2909: chaine_sauvegarde; 2910: (*s_etat_processus).erreur_systeme = 2911: d_es_allocation_memoire; 2912: return(NULL); 2913: } 2914: 2915: sprintf((*s_etat_processus).instruction_courante, 2916: "'%s'", (unsigned char *) 2917: (*s_sous_objet_2).objet); 2918: 2919: presence_signe = (((*s_etat_processus) 2920: .instruction_courante[1] == '+') 2921: || ((*s_etat_processus) 2922: .instruction_courante[1] 2923: == '-')) ? d_vrai : d_faux; 2924: 2925: recherche_type(s_etat_processus); 2926: 2927: if ((*s_etat_processus).erreur_execution != d_ex) 2928: { 2929: // Aucune erreur ne peut être renvoyée. 2930: 2931: return(NULL); 2932: } 2933: 2934: if (depilement(s_etat_processus, 2935: &((*s_etat_processus) 2936: .l_base_pile), &s_sous_objet_3) == d_erreur) 2937: { 2938: return(NULL); 2939: } 2940: 2941: free((*s_etat_processus).instruction_courante); 2942: 2943: (*s_etat_processus).instruction_courante = 2944: chaine_sauvegarde; 2945: 2946: autorisation_parenthese = d_faux; 2947: 2948: if ((*s_sous_objet_3).type == ALG) 2949: { 2950: l_atome = (struct_liste_chainee *) 2951: (*s_sous_objet_3).objet; 2952: chaine_fonction = ""; 2953: nombre_arguments_fonction = 0; 2954: 2955: while(l_atome != NULL) 2956: { 2957: if ((*(*l_atome).donnee).type == FCT) 2958: { 2959: if (strcmp((*((struct_fonction *) 2960: (*(*l_atome).donnee).objet)) 2961: .nom_fonction, ">>") != 0) 2962: { 2963: chaine_fonction = 2964: (*((struct_fonction *) 2965: (*(*l_atome).donnee).objet)) 2966: .nom_fonction; 2967: nombre_arguments_fonction = 2968: (*((struct_fonction *) 2969: (*(*l_atome).donnee).objet)) 2970: .nombre_arguments; 2971: } 2972: } 2973: 2974: l_atome = (*l_atome).suivant; 2975: } 2976: 2977: if (strcmp((*((struct_fonction *) 2978: (*(*l_element_courant).donnee).objet)) 2979: .nom_fonction, "+") == 0) 2980: { 2981: if ((strcmp(chaine_fonction, "AND") == 0) || 2982: (strcmp(chaine_fonction, "XOR") == 2983: 0) || (strcmp(chaine_fonction, "OR") 2984: == 0)) 2985: { 2986: autorisation_parenthese = d_vrai; 2987: } 2988: } 2989: else if (strcmp((*((struct_fonction *) 2990: (*(*l_element_courant).donnee).objet)) 2991: .nom_fonction, "-") == 0) 2992: { 2993: if (nombre_arguments_fonction != 0) 2994: { 2995: autorisation_parenthese = d_faux; 2996: } 2997: else 2998: { 2999: autorisation_parenthese = d_vrai; 3000: } 3001: } 3002: else if (strcmp((*((struct_fonction *) 3003: (*(*l_element_courant).donnee).objet)) 3004: .nom_fonction, "*") == 0) 3005: { 3006: if ((strcmp(chaine_fonction, "+") == 0) || 3007: (strcmp(chaine_fonction, "-") == 0) 3008: || (strcmp(chaine_fonction, "AND") 3009: == 0) || (strcmp(chaine_fonction, 3010: "XOR") == 0) || (strcmp( 3011: chaine_fonction, "OR") == 0)) 3012: { 3013: autorisation_parenthese = d_vrai; 3014: } 3015: } 3016: else if (strcmp((*((struct_fonction *) 3017: (*(*l_element_courant).donnee).objet)) 3018: .nom_fonction, "/") == 0) 3019: { 3020: if (nombre_arguments_fonction != 0) 3021: { 3022: autorisation_parenthese = d_faux; 3023: } 3024: else 3025: { 3026: autorisation_parenthese = d_vrai; 3027: } 3028: } 3029: else if ((strcmp((*((struct_fonction *) 3030: (*(*l_element_courant).donnee).objet)) 3031: .nom_fonction, "^") == 0)) 3032: { 3033: if (nombre_arguments_fonction != 0) 3034: { 3035: autorisation_parenthese = d_faux; 3036: } 3037: else 3038: { 3039: autorisation_parenthese = d_vrai; 3040: } 3041: } 3042: } 3043: 3044: if ((autorisation_parenthese == d_vrai) || 3045: (presence_signe == d_vrai)) 3046: { 3047: chaine_sauvegarde = (unsigned char *) 3048: (*s_sous_objet_2).objet; 3049: 3050: if (((*s_sous_objet_2).objet = (void *) 3051: malloc((strlen(chaine_sauvegarde) + 2 3052: + 1) * sizeof(unsigned char))) == NULL) 3053: { 3054: (*s_etat_processus).erreur_systeme = 3055: d_es_allocation_memoire; 3056: return(NULL); 3057: } 3058: 3059: sprintf((unsigned char *) (*s_sous_objet_2) 3060: .objet, "(%s)", chaine_sauvegarde); 3061: free(chaine_sauvegarde); 3062: } 3063: 3064: liberation(s_etat_processus, s_sous_objet_3); 3065: 3066: if (depilement(s_etat_processus, 3067: &((*s_etat_processus) 3068: .l_base_pile), &s_sous_objet_1) == d_erreur) 3069: { 3070: return(NULL); 3071: } 3072: 3073: chaine_sauvegarde = (*s_etat_processus) 3074: .instruction_courante; 3075: 3076: if (((*s_etat_processus).instruction_courante = 3077: (unsigned char *) malloc((strlen( 3078: (unsigned char *) (*s_sous_objet_1).objet) 3079: + 2 + 1) * sizeof(unsigned char))) == NULL) 3080: { 3081: (*s_etat_processus).instruction_courante = 3082: chaine_sauvegarde; 3083: (*s_etat_processus).erreur_systeme = 3084: d_es_allocation_memoire; 3085: return(NULL); 3086: } 3087: 3088: sprintf((*s_etat_processus).instruction_courante, 3089: "'%s'", (unsigned char *) 3090: (*s_sous_objet_1).objet); 3091: 3092: recherche_type(s_etat_processus); 3093: 3094: if ((*s_etat_processus).erreur_execution != d_ex) 3095: { 3096: // Aucune erreur ne peut être renvoyée. 3097: 3098: return(NULL); 3099: } 3100: 3101: if (depilement(s_etat_processus, 3102: &((*s_etat_processus) 3103: .l_base_pile), &s_sous_objet_3) == d_erreur) 3104: { 3105: return(NULL); 3106: } 3107: 3108: free((*s_etat_processus).instruction_courante); 3109: 3110: (*s_etat_processus).instruction_courante = 3111: chaine_sauvegarde; 3112: 3113: autorisation_parenthese = d_faux; 3114: 3115: if ((*s_sous_objet_3).type == ALG) 3116: { 3117: l_atome = (struct_liste_chainee *) 3118: (*s_sous_objet_3).objet; 3119: chaine_fonction = ""; 3120: 3121: while(l_atome != NULL) 3122: { 3123: if ((*(*l_atome).donnee).type == FCT) 3124: { 3125: if (strcmp((*((struct_fonction *) 3126: (*(*l_atome).donnee).objet)) 3127: .nom_fonction, ">>") != 0) 3128: { 3129: chaine_fonction = 3130: (*((struct_fonction *) 3131: (*(*l_atome).donnee).objet)) 3132: .nom_fonction; 3133: } 3134: } 3135: 3136: l_atome = (*l_atome).suivant; 3137: } 3138: 3139: if ((strcmp((*((struct_fonction *) 3140: (*(*l_element_courant).donnee).objet)) 3141: .nom_fonction, "+") == 0) || 3142: (strcmp((*((struct_fonction *) 3143: (*(*l_element_courant).donnee).objet)) 3144: .nom_fonction, "-") == 0)) 3145: { 3146: if ((strcmp(chaine_fonction, "AND") == 0) || 3147: (strcmp(chaine_fonction, "XOR") == 3148: 0) || (strcmp(chaine_fonction, "OR") 3149: == 0)) 3150: { 3151: autorisation_parenthese = d_vrai; 3152: } 3153: } 3154: else if ((strcmp((*((struct_fonction *) 3155: (*(*l_element_courant).donnee).objet)) 3156: .nom_fonction, "*") == 0) || 3157: (strcmp((*((struct_fonction *) 3158: (*(*l_element_courant).donnee).objet)) 3159: .nom_fonction, "/") == 0)) 3160: { 3161: if ((strcmp(chaine_fonction, "+") == 0) || 3162: (strcmp(chaine_fonction, "-") == 0) 3163: || (strcmp(chaine_fonction, "AND") 3164: == 0) || (strcmp(chaine_fonction, 3165: "XOR") == 0) || (strcmp( 3166: chaine_fonction, "OR") == 0)) 3167: { 3168: autorisation_parenthese = d_vrai; 3169: } 3170: } 3171: else if ((strcmp((*((struct_fonction *) 3172: (*(*l_element_courant).donnee).objet)) 3173: .nom_fonction, "^") == 0)) 3174: { 3175: autorisation_parenthese = d_vrai; 3176: } 3177: } 3178: 3179: if (autorisation_parenthese == d_vrai) 3180: { 3181: chaine_sauvegarde = (unsigned char *) 3182: (*s_sous_objet_1).objet; 3183: 3184: if (((*s_sous_objet_1).objet = (void *) 3185: malloc((strlen(chaine_sauvegarde) + 2 3186: + 1) * sizeof(unsigned char))) == NULL) 3187: { 3188: (*s_etat_processus).erreur_systeme = 3189: d_es_allocation_memoire; 3190: return(NULL); 3191: } 3192: 3193: sprintf((unsigned char *) (*s_sous_objet_1) 3194: .objet, "(%s)", chaine_sauvegarde); 3195: free(chaine_sauvegarde); 3196: } 3197: 3198: liberation(s_etat_processus, s_sous_objet_3); 3199: 3200: if ((s_sous_objet = allocation(s_etat_processus, 3201: CHN)) == NULL) 3202: { 3203: (*s_etat_processus).erreur_systeme = 3204: d_es_allocation_memoire; 3205: return(NULL); 3206: } 3207: 3208: if (((*s_sous_objet).objet = (void *) 3209: malloc((strlen( 3210: (unsigned char *) (*s_sous_objet_1).objet) + 3211: strlen((*((struct_fonction *) 3212: (*(*l_element_courant).donnee).objet)) 3213: .nom_fonction) + strlen((unsigned char *) 3214: (*s_sous_objet_2).objet) + 1) * 3215: sizeof(unsigned char))) == NULL) 3216: { 3217: (*s_etat_processus).erreur_systeme = 3218: d_es_allocation_memoire; 3219: return(NULL); 3220: } 3221: 3222: sprintf((unsigned char *) (*s_sous_objet).objet, 3223: "%s%s%s", (unsigned char *) 3224: (*s_sous_objet_1) 3225: .objet, (*((struct_fonction *) 3226: (*(*l_element_courant).donnee).objet)) 3227: .nom_fonction, (unsigned char *) 3228: (*s_sous_objet_2).objet); 3229: 3230: liberation(s_etat_processus, s_sous_objet_1); 3231: liberation(s_etat_processus, s_sous_objet_2); 3232: 3233: if (empilement(s_etat_processus, 3234: &((*s_etat_processus) 3235: .l_base_pile), s_sous_objet) == d_erreur) 3236: { 3237: return(NULL); 3238: } 3239: } 3240: else if (strcmp((*((struct_fonction *) 3241: (*(*l_element_courant).donnee).objet)) 3242: .nom_fonction, "=") == 0) 3243: { 3244: if (depilement(s_etat_processus, 3245: &((*s_etat_processus).l_base_pile), 3246: &s_sous_objet_2) == d_erreur) 3247: { 3248: return(NULL); 3249: } 3250: 3251: if (depilement(s_etat_processus, 3252: &((*s_etat_processus).l_base_pile), 3253: &s_sous_objet_1) == d_erreur) 3254: { 3255: return(NULL); 3256: } 3257: 3258: if ((s_sous_objet = allocation(s_etat_processus, 3259: CHN)) == NULL) 3260: { 3261: (*s_etat_processus).erreur_systeme = 3262: d_es_allocation_memoire; 3263: return(NULL); 3264: } 3265: 3266: autorisation_parenthese = d_vrai; 3267: l_atome = l_element_courant; 3268: 3269: if (l_atome != NULL) 3270: { 3271: if ((*l_atome).suivant != NULL) 3272: { 3273: l_atome = (*l_atome).suivant; 3274: 3275: if ((*(*l_atome).donnee).type == FCT) 3276: { 3277: if (strcmp((*((struct_fonction *) 3278: (*(*l_atome).donnee).objet)) 3279: .nom_fonction, ">>") == 0) 3280: { 3281: if ((*l_atome).suivant == NULL) 3282: { 3283: autorisation_parenthese = 3284: d_faux; 3285: } 3286: } 3287: } 3288: } 3289: } 3290: 3291: if (autorisation_parenthese == d_vrai) 3292: { 3293: if (((*s_sous_objet).objet = 3294: (void *) malloc((strlen( 3295: (unsigned char *) (*s_sous_objet_1) 3296: .objet) + strlen((*((struct_fonction *) 3297: (*(*l_element_courant).donnee).objet)) 3298: .nom_fonction) + 3299: strlen((unsigned char *) 3300: (*s_sous_objet_2).objet) + 2 + 1) * 3301: sizeof(unsigned char))) == NULL) 3302: { 3303: (*s_etat_processus).erreur_systeme = 3304: d_es_allocation_memoire; 3305: return(NULL); 3306: } 3307: 3308: sprintf((unsigned char *) (*s_sous_objet).objet, 3309: "(%s%s%s)", (unsigned char *) 3310: (*s_sous_objet_1) 3311: .objet, (*((struct_fonction *) 3312: (*(*l_element_courant).donnee).objet)) 3313: .nom_fonction, (unsigned char *) 3314: (*s_sous_objet_2).objet); 3315: } 3316: else 3317: { 3318: if (((*s_sous_objet).objet = 3319: (void *) malloc((strlen( 3320: (unsigned char *) (*s_sous_objet_1) 3321: .objet) + strlen((*((struct_fonction *) 3322: (*(*l_element_courant).donnee).objet)) 3323: .nom_fonction) + strlen( 3324: (unsigned char *) (*s_sous_objet_2) 3325: .objet) + 1) * sizeof(unsigned char))) 3326: == NULL) 3327: { 3328: (*s_etat_processus).erreur_systeme = 3329: d_es_allocation_memoire; 3330: return(NULL); 3331: } 3332: 3333: sprintf((unsigned char *) (*s_sous_objet).objet, 3334: "%s%s%s", (unsigned char *) 3335: (*s_sous_objet_1) 3336: .objet, (*((struct_fonction *) 3337: (*(*l_element_courant).donnee).objet)) 3338: .nom_fonction, (unsigned char *) 3339: (*s_sous_objet_2).objet); 3340: } 3341: 3342: liberation(s_etat_processus, s_sous_objet_1); 3343: liberation(s_etat_processus, s_sous_objet_2); 3344: 3345: if (empilement(s_etat_processus, 3346: &((*s_etat_processus).l_base_pile), 3347: s_sous_objet) == d_erreur) 3348: { 3349: return(NULL); 3350: } 3351: } 3352: else if (strcmp((*((struct_fonction *) 3353: (*(*l_element_courant).donnee).objet)) 3354: .nom_fonction, 3355: "NOT") == 0) 3356: { 3357: if (depilement(s_etat_processus, 3358: &((*s_etat_processus) 3359: .l_base_pile), &s_sous_objet_1) == d_erreur) 3360: { 3361: return(NULL); 3362: } 3363: 3364: if ((s_sous_objet = allocation(s_etat_processus, 3365: CHN)) == NULL) 3366: { 3367: (*s_etat_processus).erreur_systeme = 3368: d_es_allocation_memoire; 3369: return(NULL); 3370: } 3371: 3372: if (((*s_sous_objet).objet = (unsigned char *) 3373: malloc( 3374: (strlen((unsigned char *) (*s_sous_objet_1) 3375: .objet) + 4 + 1) * sizeof(unsigned char))) 3376: == NULL) 3377: { 3378: (*s_etat_processus).erreur_systeme = 3379: d_es_allocation_memoire; 3380: return(NULL); 3381: } 3382: 3383: sprintf((unsigned char *) (*s_sous_objet).objet, 3384: "%s %s", (*((struct_fonction *) 3385: (*(*l_element_courant).donnee).objet)) 3386: .nom_fonction, (unsigned char *) 3387: (*s_sous_objet_1).objet ); 3388: 3389: liberation(s_etat_processus, s_sous_objet_1); 3390: 3391: if (empilement(s_etat_processus, 3392: &((*s_etat_processus) 3393: .l_base_pile), s_sous_objet) == d_erreur) 3394: { 3395: return(NULL); 3396: } 3397: } 3398: else if ((strcmp((*((struct_fonction *) 3399: (*(*l_element_courant).donnee).objet)) 3400: .nom_fonction, 3401: "OR") == 0) || (strcmp((*((struct_fonction *) 3402: (*(*l_element_courant).donnee).objet)) 3403: .nom_fonction, 3404: "XOR") == 0) || (strcmp((*((struct_fonction *) 3405: (*(*l_element_courant).donnee).objet)) 3406: .nom_fonction, 3407: "AND") == 0)) 3408: { 3409: if (depilement(s_etat_processus, 3410: &((*s_etat_processus) 3411: .l_base_pile), &s_sous_objet_2) == d_erreur) 3412: { 3413: return(NULL); 3414: } 3415: 3416: if (depilement(s_etat_processus, 3417: &((*s_etat_processus) 3418: .l_base_pile), &s_sous_objet_1) == d_erreur) 3419: { 3420: return(NULL); 3421: } 3422: 3423: if ((s_sous_objet = allocation(s_etat_processus, 3424: CHN)) == NULL) 3425: { 3426: (*s_etat_processus).erreur_systeme = 3427: d_es_allocation_memoire; 3428: return(NULL); 3429: } 3430: 3431: if (((*s_sous_objet).objet = (void *) 3432: malloc((strlen( 3433: (unsigned char *) (*s_sous_objet_1).objet) + 3434: strlen((*((struct_fonction *) 3435: (*(*l_element_courant).donnee).objet)) 3436: .nom_fonction) + strlen((unsigned char *) 3437: (*s_sous_objet_2).objet) + 2 + 1) * 3438: sizeof(unsigned char))) == NULL) 3439: { 3440: (*s_etat_processus).erreur_systeme = 3441: d_es_allocation_memoire; 3442: return(NULL); 3443: } 3444: 3445: sprintf((unsigned char *) (*s_sous_objet).objet, 3446: "%s %s %s", (unsigned char *) 3447: (*s_sous_objet_1) 3448: .objet, (*((struct_fonction *) 3449: (*(*l_element_courant).donnee).objet)) 3450: .nom_fonction, (unsigned char *) 3451: (*s_sous_objet_2).objet); 3452: 3453: liberation(s_etat_processus, s_sous_objet_1); 3454: liberation(s_etat_processus, s_sous_objet_2); 3455: 3456: if (empilement(s_etat_processus, 3457: &((*s_etat_processus) 3458: .l_base_pile), s_sous_objet) == d_erreur) 3459: { 3460: return(NULL); 3461: } 3462: } 3463: else 3464: { 3465: nombre_arguments = (*((struct_fonction *) 3466: (*(*l_element_courant).donnee).objet)) 3467: .nombre_arguments; 3468: 3469: if ((chaine = (unsigned char *) 3470: malloc(sizeof(unsigned char))) == NULL) 3471: { 3472: (*s_etat_processus).erreur_systeme = 3473: d_es_allocation_memoire; 3474: return(NULL); 3475: } 3476: 3477: chaine[0] = d_code_fin_chaine; 3478: 3479: for(i = 0; i < nombre_arguments; i++) 3480: { 3481: if ((nombre_arguments - i) > 1) 3482: { 3483: l_liste1 = (*s_etat_processus).l_base_pile; 3484: 3485: for(j = 2; j < (nombre_arguments - i); j++) 3486: { 3487: l_liste1 = (*l_liste1).suivant; 3488: } 3489: 3490: l_liste2 = (*l_liste1).suivant; 3491: (*l_liste1).suivant = (*l_liste2).suivant; 3492: (*l_liste2).suivant = (*s_etat_processus) 3493: .l_base_pile; 3494: (*s_etat_processus).l_base_pile = l_liste2; 3495: } 3496: 3497: if (depilement(s_etat_processus, 3498: &((*s_etat_processus).l_base_pile), 3499: &s_sous_objet) == d_erreur) 3500: { 3501: return(NULL); 3502: } 3503: 3504: chaine_sauvegarde = chaine; 3505: 3506: if (strlen(chaine_sauvegarde) == 0) 3507: { 3508: if ((chaine = (unsigned char *) 3509: malloc((strlen((unsigned char *) 3510: (*s_sous_objet).objet) + 1) * 3511: sizeof(unsigned char))) == NULL) 3512: { 3513: (*s_etat_processus).erreur_systeme = 3514: d_es_allocation_memoire; 3515: return(NULL); 3516: } 3517: 3518: sprintf(chaine, "%s", (unsigned char *) 3519: (*s_sous_objet).objet); 3520: } 3521: else 3522: { 3523: if ((chaine = (unsigned char *) 3524: malloc((strlen(chaine_sauvegarde) 3525: + 1 + strlen((unsigned char *) 3526: (*s_sous_objet).objet) + 1) * 3527: sizeof(unsigned char))) == NULL) 3528: { 3529: (*s_etat_processus).erreur_systeme = 3530: d_es_allocation_memoire; 3531: return(NULL); 3532: } 3533: 3534: sprintf(chaine, "%s,%s", chaine_sauvegarde, 3535: (unsigned char *) (*s_sous_objet) 3536: .objet); 3537: } 3538: 3539: free(chaine_sauvegarde); 3540: liberation(s_etat_processus, s_sous_objet); 3541: } 3542: 3543: chaine_sauvegarde = chaine; 3544: 3545: if ((chaine = (unsigned char *) malloc((strlen( 3546: (*((struct_fonction *) 3547: (*(*l_element_courant) 3548: .donnee).objet)).nom_fonction) + 2 + 3549: strlen(chaine_sauvegarde) + 1) * 3550: sizeof(unsigned char))) == NULL) 3551: { 3552: (*s_etat_processus).erreur_systeme = 3553: d_es_allocation_memoire; 3554: return(NULL); 3555: } 3556: 3557: sprintf(chaine, "%s(%s)", (*((struct_fonction *) 3558: (*(*l_element_courant).donnee).objet)) 3559: .nom_fonction, chaine_sauvegarde); 3560: free(chaine_sauvegarde); 3561: 3562: if ((s_sous_objet = allocation(s_etat_processus, 3563: CHN)) == NULL) 3564: { 3565: (*s_etat_processus).erreur_systeme = 3566: d_es_allocation_memoire; 3567: return(NULL); 3568: } 3569: 3570: (*s_sous_objet).objet = (void *) chaine; 3571: 3572: if (empilement(s_etat_processus, 3573: &((*s_etat_processus) 3574: .l_base_pile), s_sous_objet) == d_erreur) 3575: { 3576: return(NULL); 3577: } 3578: } 3579: } 3580: } 3581: else 3582: { 3583: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 3584: == NULL) 3585: { 3586: (*s_etat_processus).erreur_systeme = 3587: d_es_allocation_memoire; 3588: return(NULL); 3589: } 3590: 3591: if (((*s_sous_objet).objet = (void *) formateur_fichier( 3592: s_etat_processus, (*l_element_courant).donnee, 3593: s_format, longueur, longueur_champ, format_sortie, 3594: type, longueur_effective, recursivite)) == NULL) 3595: { 3596: (*s_etat_processus).erreur_systeme = 3597: d_es_allocation_memoire; 3598: return(NULL); 3599: } 3600: 3601: if (((*(*l_element_courant).donnee).type == ALG) 3602: || ((*(*l_element_courant).donnee).type == NOM)) 3603: { 3604: chaine_sauvegarde = (unsigned char *) 3605: (*s_sous_objet).objet; 3606: 3607: if (((*s_sous_objet).objet = malloc((strlen( 3608: chaine_sauvegarde) - 1) * 3609: sizeof(unsigned char))) == NULL) 3610: { 3611: (*s_etat_processus).erreur_systeme = 3612: d_es_allocation_memoire; 3613: return(NULL); 3614: } 3615: 3616: ptrl = chaine_sauvegarde; 3617: ptre = (unsigned char *) (*s_sous_objet).objet; 3618: 3619: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0; 3620: i--, *ptre++ = *ptrl++); 3621: 3622: (*ptre) = d_code_fin_chaine; 3623: 3624: free(chaine_sauvegarde); 3625: } 3626: else if ((*(*l_element_courant).donnee).type == CHN) 3627: { 3628: chaine_sauvegarde = (unsigned char *) 3629: (*s_sous_objet).objet; 3630: 3631: if (((*s_sous_objet).objet = malloc((strlen( 3632: chaine_sauvegarde) + 3) * 3633: sizeof(unsigned char))) == NULL) 3634: { 3635: (*s_etat_processus).erreur_systeme = 3636: d_es_allocation_memoire; 3637: return(NULL); 3638: } 3639: 3640: sprintf((unsigned char *) (*s_sous_objet).objet, 3641: "\"%s\"", chaine_sauvegarde); 3642: 3643: free(chaine_sauvegarde); 3644: } 3645: 3646: if (empilement(s_etat_processus, &((*s_etat_processus) 3647: .l_base_pile), s_sous_objet) == d_erreur) 3648: { 3649: return(NULL); 3650: } 3651: } 3652: 3653: l_element_courant = (*l_element_courant).suivant; 3654: } 3655: 3656: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 3657: &s_sous_objet) == d_erreur) 3658: { 3659: return(NULL); 3660: } 3661: 3662: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *) 3663: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char))) 3664: == NULL) 3665: { 3666: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3667: return(NULL); 3668: } 3669: 3670: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet); 3671: liberation(s_etat_processus, s_sous_objet); 3672: } 3673: else if ((*s_objet).type == BIN) 3674: { 3675: 3676: /* 3677: -------------------------------------------------------------------------------- 3678: Entier binaire en base 2, 8, 10 ou 16 3679: -------------------------------------------------------------------------------- 3680: */ 3681: 3682: if (format_sortie != 'B') 3683: { 3684: (*s_etat_processus).erreur_execution = 3685: d_ex_erreur_format_fichier; 3686: return(NULL); 3687: } 3688: 3689: longueur_binaire = longueur_entiers_binaires(s_etat_processus); 3690: masque_binaire = masque_entiers_binaires(s_etat_processus); 3691: 3692: if ((test_cfsf(s_etat_processus, 43) == d_faux) && 3693: (test_cfsf(s_etat_processus, 44) == d_faux)) 3694: { 3695: 3696: /* 3697: -- Base décimale --------------------------------------------------------------- 3698: */ 3699: 3700: sprintf(tampon, "%llu", (*((logical8 *) 3701: ((*s_objet).objet))) & masque_binaire); 3702: strcpy(base, "d"); 3703: } 3704: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && 3705: (test_cfsf(s_etat_processus, 44) == d_faux)) 3706: { 3707: 3708: /* 3709: -- Base octale ----------------------------------------------------------------- 3710: */ 3711: 3712: sprintf(tampon, "%llo", (*((logical8 *) 3713: ((*s_objet).objet))) & masque_binaire); 3714: strcpy(base, "o"); 3715: } 3716: else if (test_cfsf(s_etat_processus, 44) == d_vrai) 3717: { 3718: 3719: /* 3720: -- Bases hexadécimale et binaire ----------------------------------------------- 3721: */ 3722: 3723: sprintf(tampon, "%llX", (*((logical8 *) 3724: ((*s_objet).objet))) & masque_binaire); 3725: 3726: if (test_cfsf(s_etat_processus, 43) == d_vrai) 3727: { 3728: strcpy(base, "h"); 3729: } 3730: else 3731: { 3732: chaine = (unsigned char *) malloc((strlen(tampon) + 1) 3733: * sizeof(unsigned char)); 3734: 3735: if (chaine == NULL) 3736: { 3737: (*s_etat_processus).erreur_systeme = 3738: d_es_allocation_memoire; 3739: return(NULL); 3740: } 3741: 3742: strcpy(chaine, tampon); 3743: tampon[0] = 0; 3744: 3745: for(i = 0; i < strlen(chaine); i++) 3746: { 3747: switch(chaine[i]) 3748: { 3749: case '0' : 3750: { 3751: strcat(tampon, (i != 0) ? "0000" : "0"); 3752: break; 3753: } 3754: case '1' : 3755: { 3756: strcat(tampon, (i != 0) ? "0001" : "1"); 3757: break; 3758: } 3759: case '2' : 3760: { 3761: strcat(tampon, (i != 0) ? "0010" : "10"); 3762: break; 3763: } 3764: case '3' : 3765: { 3766: strcat(tampon, (i != 0) ? "0011" : "11"); 3767: break; 3768: } 3769: case '4' : 3770: { 3771: strcat(tampon, (i != 0) ? "0100" : "100"); 3772: break; 3773: } 3774: case '5' : 3775: { 3776: strcat(tampon, (i != 0) ? "0101" : "101"); 3777: break; 3778: } 3779: case '6' : 3780: { 3781: strcat(tampon, (i != 0) ? "0110" : "110"); 3782: break; 3783: } 3784: case '7' : 3785: { 3786: strcat(tampon, (i != 0) ? "0111" : "111"); 3787: break; 3788: } 3789: case '8' : 3790: { 3791: strcat(tampon, "1000"); 3792: break; 3793: } 3794: case '9' : 3795: { 3796: strcat(tampon, "1001"); 3797: break; 3798: } 3799: case 'A' : 3800: { 3801: strcat(tampon, "1010"); 3802: break; 3803: } 3804: case 'B' : 3805: { 3806: strcat(tampon, "1011"); 3807: break; 3808: } 3809: case 'C' : 3810: { 3811: strcat(tampon, "1100"); 3812: break; 3813: } 3814: case 'D' : 3815: { 3816: strcat(tampon, "1101"); 3817: break; 3818: } 3819: case 'E' : 3820: { 3821: strcat(tampon, "1110"); 3822: break; 3823: } 3824: case 'F' : 3825: { 3826: strcat(tampon, "1111"); 3827: break; 3828: } 3829: } 3830: } 3831: 3832: free(chaine); 3833: strcpy(base, "b"); 3834: } 3835: } 3836: 3837: chaine = (unsigned char *) malloc((strlen(tampon) + 4) 3838: * sizeof(unsigned char)); 3839: 3840: if (chaine == NULL) 3841: { 3842: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3843: return(NULL); 3844: } 3845: 3846: strcpy(chaine, "# "); 3847: 3848: strcat(chaine, tampon); 3849: strcat(chaine, base); 3850: } 3851: else if ((*s_objet).type == CHN) 3852: { 3853: 3854: /* 3855: -------------------------------------------------------------------------------- 3856: Chaîne de caractères 3857: -------------------------------------------------------------------------------- 3858: */ 3859: 3860: if (format_sortie != 'C') 3861: { 3862: (*s_etat_processus).erreur_execution = 3863: d_ex_erreur_format_fichier; 3864: return(NULL); 3865: } 3866: 3867: chaine = (unsigned char *) malloc((strlen((unsigned char *) 3868: ((*s_objet).objet)) + 1) * sizeof(unsigned char)); 3869: 3870: if (chaine == NULL) 3871: { 3872: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3873: return(NULL); 3874: } 3875: 3876: strcpy(chaine, (unsigned char *) ((*s_objet).objet)); 3877: } 3878: else if ((*s_objet).type == CPL) 3879: { 3880: 3881: /* 3882: -------------------------------------------------------------------------------- 3883: Complexe 3884: -------------------------------------------------------------------------------- 3885: */ 3886: 3887: if ((format_sortie != 'S') && (format_sortie != 'F') && 3888: (format_sortie != 'I') && (format_sortie != 'E')) 3889: { 3890: (*s_etat_processus).erreur_execution = 3891: d_ex_erreur_format_fichier; 3892: return(NULL); 3893: } 3894: 3895: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, 3896: (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C', 3897: longueur, longueur_champ, format_sortie)) == NULL) 3898: { 3899: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3900: return(NULL); 3901: } 3902: 3903: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 3904: + 1) * sizeof(unsigned char)); 3905: 3906: if (chaine == NULL) 3907: { 3908: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3909: return(NULL); 3910: } 3911: 3912: strcpy(chaine, chaine_formatee); 3913: free(chaine_formatee); 3914: } 3915: else if ((*s_objet).type == RPN) 3916: { 3917: 3918: /* 3919: -------------------------------------------------------------------------------- 3920: Définition 3921: -------------------------------------------------------------------------------- 3922: */ 3923: 3924: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 3925: chaine_sauvegarde = chaine; 3926: 3927: while(l_element_courant != NULL) 3928: { 3929: if ((chaine_formatee = formateur_fichier(s_etat_processus, 3930: (*l_element_courant).donnee, s_format, 3931: longueur, longueur_champ, format_sortie, type, 3932: longueur_effective, recursivite)) == NULL) 3933: { 3934: return(NULL); 3935: } 3936: 3937: if ((*(*l_element_courant).donnee).type == CHN) 3938: { 3939: chaine_tampon = chaine_formatee; 3940: 3941: if ((chaine_formatee = (unsigned char *) malloc((strlen( 3942: chaine_tampon) + 3) * sizeof(unsigned char))) 3943: == NULL) 3944: { 3945: (*s_etat_processus).erreur_systeme = 3946: d_es_allocation_memoire; 3947: return(NULL); 3948: } 3949: 3950: sprintf(chaine_formatee, "\"%s\"", chaine_tampon); 3951: free(chaine_tampon); 3952: } 3953: 3954: l_element_courant = (*l_element_courant).suivant; 3955: 3956: if (chaine != NULL) 3957: { 3958: chaine_sauvegarde = chaine; 3959: 3960: if ((chaine = (unsigned char *) malloc((strlen( 3961: chaine_sauvegarde) + strlen(chaine_formatee) + 2) * 3962: sizeof(unsigned char))) == NULL) 3963: { 3964: (*s_etat_processus).erreur_systeme = 3965: d_es_allocation_memoire; 3966: return(NULL); 3967: } 3968: 3969: strcpy(chaine, chaine_sauvegarde); 3970: free(chaine_sauvegarde); 3971: strcat(chaine, " "); 3972: strcat(chaine, chaine_formatee); 3973: free(chaine_formatee); 3974: } 3975: else 3976: { 3977: chaine = chaine_formatee; 3978: } 3979: } 3980: 3981: chaine_sauvegarde = chaine; 3982: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) * 3983: sizeof(unsigned char)); 3984: 3985: if (chaine == NULL) 3986: { 3987: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3988: free(chaine_sauvegarde); 3989: return(NULL); 3990: } 3991: 3992: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine; 3993: strcpy(chaine, chaine_sauvegarde); 3994: free(chaine_sauvegarde); 3995: } 3996: else if ((*s_objet).type == INT) 3997: { 3998: 3999: /* 4000: -------------------------------------------------------------------------------- 4001: Entier 4002: -------------------------------------------------------------------------------- 4003: */ 4004: 4005: if (format_sortie != 'I') 4006: { 4007: (*s_etat_processus).erreur_execution = 4008: d_ex_erreur_format_fichier; 4009: return(NULL); 4010: } 4011: 4012: switch(longueur) 4013: { 4014: case 1: 4015: { 4016: if ((*((integer8 *) (*s_objet).objet)) != 4017: ((integer1) (*((integer8 *) (*s_objet).objet)))) 4018: { 4019: (*s_etat_processus).erreur_execution = 4020: d_ex_representation; 4021: return(NULL); 4022: } 4023: 4024: if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL) 4025: { 4026: (*s_etat_processus).erreur_systeme = 4027: d_es_allocation_memoire; 4028: return(NULL); 4029: } 4030: 4031: longueur_totale = 2; 4032: chaine[0] = 0x10; 4033: chaine[1] = (*((integer8 *) (*s_objet).objet)) & 0xFF; 4034: break; 4035: } 4036: 4037: case 2: 4038: { 4039: if ((*((integer8 *) (*s_objet).objet)) != 4040: ((integer2) (*((integer8 *) (*s_objet).objet)))) 4041: { 4042: (*s_etat_processus).erreur_execution = 4043: d_ex_representation; 4044: return(NULL); 4045: } 4046: 4047: if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL) 4048: { 4049: (*s_etat_processus).erreur_systeme = 4050: d_es_allocation_memoire; 4051: return(NULL); 4052: } 4053: 4054: longueur_totale = 3; 4055: chaine[0] = 0x11; 4056: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 8) 4057: & 0xFF; 4058: chaine[2] = (*((integer8 *) (*s_objet).objet)) & 0xFF; 4059: break; 4060: } 4061: 4062: case 4: 4063: { 4064: if ((*((integer4 *) (*s_objet).objet)) != 4065: ((integer2) (*((integer8 *) (*s_objet).objet)))) 4066: { 4067: (*s_etat_processus).erreur_execution = 4068: d_ex_representation; 4069: return(NULL); 4070: } 4071: 4072: if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL) 4073: { 4074: (*s_etat_processus).erreur_systeme = 4075: d_es_allocation_memoire; 4076: return(NULL); 4077: } 4078: 4079: longueur_totale = 5; 4080: chaine[0] = 0x12; 4081: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 24) 4082: & 0xFF; 4083: chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 16) 4084: & 0xFF; 4085: chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 8) 4086: & 0xFF; 4087: chaine[4] = (*((integer8 *) (*s_objet).objet)) & 0xFF; 4088: break; 4089: } 4090: 4091: case 8: 4092: { 4093: if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) 4094: { 4095: (*s_etat_processus).erreur_systeme = 4096: d_es_allocation_memoire; 4097: return(NULL); 4098: } 4099: 4100: longueur_totale = 9; 4101: chaine[0] = 0x13; 4102: chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 56) 4103: & 0xFF; 4104: chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 48) 4105: & 0xFF; 4106: chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 40) 4107: & 0xFF; 4108: chaine[4] = ((*((integer8 *) (*s_objet).objet)) >> 32) 4109: & 0xFF; 4110: chaine[5] = ((*((integer8 *) (*s_objet).objet)) >> 24) 4111: & 0xFF; 4112: chaine[6] = ((*((integer8 *) (*s_objet).objet)) >> 16) 4113: & 0xFF; 4114: chaine[7] = ((*((integer8 *) (*s_objet).objet)) >> 8) 4115: & 0xFF; 4116: chaine[8] = (*((integer8 *) (*s_objet).objet)) & 0xFF; 4117: break; 4118: } 4119: 4120: default : 4121: { 4122: (*s_etat_processus).erreur_execution = 4123: d_ex_erreur_format_fichier; 4124: return(NULL); 4125: } 4126: } 4127: 4128: (*longueur_effective) = longueur_totale; 4129: } 4130: else if ((*s_objet).type == FCT) 4131: { 4132: 4133: /* 4134: -------------------------------------------------------------------------------- 4135: Fonction 4136: -------------------------------------------------------------------------------- 4137: */ 4138: 4139: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *) 4140: ((*s_objet).objet))).nom_fonction) + 1) * 4141: sizeof(unsigned char)); 4142: 4143: if (chaine == NULL) 4144: { 4145: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4146: return(NULL); 4147: } 4148: 4149: strcpy(chaine, (unsigned char *) (*((struct_fonction *) 4150: ((*s_objet).objet))).nom_fonction); 4151: } 4152: else if ((*s_objet).type == LST) 4153: { 4154: 4155: /* 4156: -------------------------------------------------------------------------------- 4157: Liste 4158: Poids fort 0100 4159: -------------------------------------------------------------------------------- 4160: */ 4161: 4162: chaine = malloc(sizeof(unsigned char)); 4163: 4164: if (chaine == NULL) 4165: { 4166: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4167: return(NULL); 4168: } 4169: 4170: // Calcul de la longueur de la liste. 4171: 4172: longueur_liste = 0; 4173: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 4174: 4175: while(l_element_courant != NULL) 4176: { 4177: l_element_courant = (*l_element_courant).suivant; 4178: longueur_liste++; 4179: } 4180: 4181: if (longueur_liste < (1LL << 3)) 4182: { 4183: chaine[0] = 0x40 | (longueur_liste & 0x7); 4184: } 4185: else if (longueur_liste < (1LL << 8)) 4186: { 4187: chaine[0] = 0x48; 4188: } 4189: else if (longueur_liste < (1LL << 16)) 4190: { 4191: chaine[0] = 0x49; 4192: } 4193: else if (longueur_liste < (1LL << 32)) 4194: { 4195: chaine[0] = 0x4A; 4196: } 4197: else 4198: { 4199: chaine[0] = 0x4B; 4200: } 4201: 4202: longueur_totale = 1; 4203: 4204: if ((chaine[0] & 0x8) != 0) 4205: { 4206: switch(chaine[0] & 0x03) 4207: { 4208: case 0x00 : 4209: { 4210: longueur_totale += 1; 4211: 4212: if ((chaine = realloc(chaine, longueur_totale * 4213: sizeof(unsigned char))) == NULL) 4214: { 4215: (*s_etat_processus).erreur_systeme = 4216: d_es_allocation_memoire; 4217: return(NULL); 4218: } 4219: 4220: chaine[longueur_totale - 1] = 4221: (unsigned char) (longueur_liste & 0xFF); 4222: break; 4223: } 4224: 4225: case 0x01 : 4226: { 4227: longueur_totale += 2; 4228: 4229: if ((chaine = realloc(chaine, longueur_totale * 4230: sizeof(unsigned char))) == NULL) 4231: { 4232: (*s_etat_processus).erreur_systeme = 4233: d_es_allocation_memoire; 4234: return(NULL); 4235: } 4236: 4237: chaine[longueur_totale - 2] = 4238: (unsigned char) ((longueur_liste >> 8) & 0xFF); 4239: chaine[longueur_totale - 1] = 4240: (unsigned char) (longueur_liste & 0xFF); 4241: break; 4242: } 4243: 4244: case 0x02 : 4245: { 4246: longueur_totale += 4; 4247: 4248: if ((chaine = realloc(chaine, longueur_totale * 4249: sizeof(unsigned char))) == NULL) 4250: { 4251: (*s_etat_processus).erreur_systeme = 4252: d_es_allocation_memoire; 4253: return(NULL); 4254: } 4255: 4256: chaine[longueur_totale - 4] = 4257: (unsigned char) ((longueur_liste >> 24) & 0xFF); 4258: chaine[longueur_totale - 3] = 4259: (unsigned char) ((longueur_liste >> 16) & 0xFF); 4260: chaine[longueur_totale - 2] = 4261: (unsigned char) ((longueur_liste >> 8) & 0xFF); 4262: chaine[longueur_totale - 1] = 4263: (unsigned char) (longueur_liste & 0xFF); 4264: break; 4265: } 4266: 4267: case 0x03 : 4268: { 4269: longueur_totale += 8; 4270: 4271: if ((chaine = realloc(chaine, longueur_totale * 4272: sizeof(unsigned char))) == NULL) 4273: { 4274: (*s_etat_processus).erreur_systeme = 4275: d_es_allocation_memoire; 4276: return(NULL); 4277: } 4278: 4279: chaine[longueur_totale - 8] = 4280: (unsigned char) ((longueur_liste >> 56) & 0xFF); 4281: chaine[longueur_totale - 7] = 4282: (unsigned char) ((longueur_liste >> 48) & 0xFF); 4283: chaine[longueur_totale - 6] = 4284: (unsigned char) ((longueur_liste >> 40) & 0xFF); 4285: chaine[longueur_totale - 5] = 4286: (unsigned char) ((longueur_liste >> 32) & 0xFF); 4287: chaine[longueur_totale - 4] = 4288: (unsigned char) ((longueur_liste >> 24) & 0xFF); 4289: chaine[longueur_totale - 3] = 4290: (unsigned char) ((longueur_liste >> 16) & 0xFF); 4291: chaine[longueur_totale - 2] = 4292: (unsigned char) ((longueur_liste >> 8) & 0xFF); 4293: chaine[longueur_totale - 1] = 4294: (unsigned char) (longueur_liste & 0xFF); 4295: break; 4296: } 4297: 4298: default : 4299: { 4300: BUG(1, printf("Internal format error\n")); 4301: } 4302: } 4303: } 4304: 4305: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 4306: l_element_courant_format = (struct_liste_chainee *) 4307: (*s_format).objet; 4308: nombre_elements = 0; 4309: 4310: while((l_element_courant != NULL) && 4311: (l_element_courant_format != NULL)) 4312: { 4313: if ((((*(*l_element_courant_format).donnee).type == LST) 4314: && ((*(*l_element_courant).donnee).type == LST)) || 4315: (((*(*l_element_courant_format).donnee).type == TBL) 4316: && ((*(*l_element_courant).donnee).type == TBL))) 4317: { 4318: if ((chaine_formatee = formateur_fichier(s_etat_processus, 4319: (*l_element_courant).donnee, 4320: (*l_element_courant_format).donnee, 4321: 0, 0, ' ', 'U', longueur_effective, recursivite)) 4322: == NULL) 4323: { 4324: return(NULL); 4325: } 4326: 4327: if ((chaine = realloc(chaine, (longueur_totale + 4328: (*longueur_effective)) * sizeof(unsigned char))) 4329: == NULL) 4330: { 4331: (*s_etat_processus).erreur_systeme = 4332: d_es_allocation_memoire; 4333: return(NULL); 4334: } 4335: 4336: memcpy(&(chaine[longueur_totale]), chaine_formatee, 4337: (*longueur_effective)); 4338: longueur_totale += (*longueur_effective); 4339: free(chaine_formatee); 4340: } 4341: else if ((*(*l_element_courant_format).donnee).type != CHN) 4342: { 4343: free(chaine); 4344: 4345: (*s_etat_processus).erreur_execution = 4346: d_ex_erreur_format_fichier; 4347: return(NULL); 4348: } 4349: else 4350: { 4351: if ((format_chaine = conversion_majuscule((unsigned char *) 4352: (*(*l_element_courant_format).donnee).objet)) 4353: == NULL) 4354: { 4355: (*s_etat_processus).erreur_systeme = 4356: d_es_allocation_memoire; 4357: return(NULL); 4358: } 4359: 4360: format_degenere = d_faux; 4361: 4362: if (strncmp("INTEGER*", format_chaine, 8) == 0) 4363: { 4364: format_sortie = 'I'; 4365: position_1 = 8; 4366: } 4367: else if (strncmp("LOGICAL*", format_chaine, 8) == 0) 4368: { 4369: format_sortie = 'L'; 4370: position_1 = 8; 4371: } 4372: else if (strncmp("REAL*", format_chaine, 5) == 0) 4373: { 4374: format_sortie = 'R'; 4375: position_1 = 5; 4376: } 4377: else if (strncmp("COMPLEX*", format_chaine, 8) == 0) 4378: { 4379: format_sortie = 'C'; 4380: position_1 = 8; 4381: } 4382: else if (strcmp("CHARACTER", format_chaine) == 0) 4383: { 4384: format_sortie = 'S'; 4385: position_1 = 10; 4386: format_degenere = d_vrai; 4387: } 4388: else 4389: { 4390: free(chaine); 4391: free(format_chaine); 4392: 4393: (*s_etat_processus).erreur_execution = 4394: d_ex_erreur_format_fichier; 4395: return(NULL); 4396: } 4397: 4398: if (format_degenere == d_faux) 4399: { 4400: if (format_chaine[position_1] == d_code_fin_chaine) 4401: { 4402: free(chaine); 4403: free(format_chaine); 4404: 4405: (*s_etat_processus).erreur_execution = 4406: d_ex_erreur_format_fichier; 4407: return(NULL); 4408: } 4409: 4410: if (sscanf(&(format_chaine[position_1]), "%ld", 4411: &longueur) != 1) 4412: { 4413: free(chaine); 4414: free(format_chaine); 4415: 4416: (*s_etat_processus).erreur_execution = 4417: d_ex_erreur_format_fichier; 4418: return(NULL); 4419: } 4420: } 4421: else 4422: { 4423: longueur = -1; 4424: } 4425: 4426: free(format_chaine); 4427: 4428: if ((chaine_formatee = formateur_fichier(s_etat_processus, 4429: (*l_element_courant).donnee, s_format, 4430: longueur, longueur_champ, format_sortie, type, 4431: longueur_effective, recursivite)) == NULL) 4432: { 4433: free(chaine); 4434: return(NULL); 4435: } 4436: 4437: if ((chaine = realloc(chaine, 4438: (longueur_totale + (*longueur_effective)) 4439: * sizeof(unsigned char))) == NULL) 4440: { 4441: (*s_etat_processus).erreur_systeme = 4442: d_es_allocation_memoire; 4443: return(NULL); 4444: } 4445: 4446: memcpy(&(chaine[longueur_totale]), chaine_formatee, 4447: (*longueur_effective)); 4448: longueur_totale += (*longueur_effective); 4449: free(chaine_formatee); 4450: } 4451: 4452: nombre_elements++; 4453: l_element_courant = (*l_element_courant).suivant; 4454: l_element_courant_format = (*l_element_courant_format).suivant; 4455: } 4456: 4457: if ((l_element_courant != NULL) || 4458: (l_element_courant_format != NULL)) 4459: { 4460: free(chaine); 4461: 4462: (*s_etat_processus).erreur_execution = 4463: d_ex_erreur_format_fichier; 4464: return(NULL); 4465: } 4466: 4467: if ((*recursivite) == 1) 4468: { 4469: // Ajout de la longueur totale en fin d'enregistrement. 4470: 4471: if (longueur_totale < (((integer8) 1) << 6)) 4472: { 4473: tampon[0] = longueur_totale + 1; 4474: 4475: if ((chaine = realloc(chaine, (longueur_totale + 1) 4476: * sizeof(unsigned char))) == NULL) 4477: { 4478: (*s_etat_processus).erreur_systeme = 4479: d_es_allocation_memoire; 4480: return(NULL); 4481: } 4482: 4483: memcpy(&(chaine[longueur_totale]), tampon, 1); 4484: longueur_totale += 1; 4485: } 4486: else if (longueur_totale < (((integer8) 1) << 16)) 4487: { 4488: tampon[2] = 0x40; 4489: tampon[1] = (longueur_totale + 1) & 0xFF; 4490: tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF; 4491: 4492: if ((chaine = realloc(chaine, (longueur_totale + 3) 4493: * sizeof(unsigned char))) == NULL) 4494: { 4495: (*s_etat_processus).erreur_systeme = 4496: d_es_allocation_memoire; 4497: return(NULL); 4498: } 4499: 4500: memcpy(&(chaine[longueur_totale]), tampon, 3); 4501: longueur_totale += 3; 4502: } 4503: else if (longueur_totale < (((integer8) 1) << 32)) 4504: { 4505: tampon[4] = 0x80; 4506: tampon[3] = (longueur_totale + 1) & 0xFF; 4507: tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF; 4508: tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF; 4509: tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF; 4510: 4511: if ((chaine = realloc(chaine, (longueur_totale + 5) 4512: * sizeof(unsigned char))) == NULL) 4513: { 4514: (*s_etat_processus).erreur_systeme = 4515: d_es_allocation_memoire; 4516: return(NULL); 4517: } 4518: 4519: memcpy(&(chaine[longueur_totale]), tampon, 5); 4520: longueur_totale += 5; 4521: } 4522: else 4523: { 4524: tampon[8] = 0xC0; 4525: tampon[7] = (longueur_totale + 1) & 0xFF; 4526: tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF; 4527: tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF; 4528: tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF; 4529: tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF; 4530: tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF; 4531: tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF; 4532: tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF; 4533: 4534: if ((chaine = realloc(chaine, (longueur_totale + 9) 4535: * sizeof(unsigned char))) == NULL) 4536: { 4537: (*s_etat_processus).erreur_systeme = 4538: d_es_allocation_memoire; 4539: return(NULL); 4540: } 4541: 4542: memcpy(&(chaine[longueur_totale]), tampon, 9); 4543: longueur_totale += 9; 4544: } 4545: 4546: __zone(); 4547: } 4548: 4549: (*longueur_effective) = longueur_totale; 4550: } 4551: else if ((*s_objet).type == TBL) 4552: { 4553: 4554: /* 4555: -------------------------------------------------------------------------------- 4556: Table 4557: -------------------------------------------------------------------------------- 4558: */ 4559: 4560: if ((*s_format).type != TBL) 4561: { 4562: (*s_etat_processus).erreur_execution = 4563: d_ex_erreur_format_fichier; 4564: return(NULL); 4565: } 4566: 4567: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 4568: l_element_courant_format = (struct_liste_chainee *) 4569: (*s_format).objet; 4570: 4571: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 4572: (*((struct_tableau *) (*s_format).objet)).nombre_elements) 4573: { 4574: (*s_etat_processus).erreur_execution = 4575: d_ex_erreur_format_fichier; 4576: return(NULL); 4577: } 4578: 4579: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 4580: 4581: if (chaine == NULL) 4582: { 4583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4584: return(NULL); 4585: } 4586: 4587: strcpy(chaine, "<["); 4588: 4589: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 4590: .nombre_elements; i++) 4591: { 4592: if ((((*(*((struct_tableau *) (*s_format).objet)) 4593: .elements[i]).type == LST) && 4594: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) 4595: .type == LST)) || 4596: (((*(*((struct_tableau *) (*s_format).objet)) 4597: .elements[i]).type == TBL) && 4598: ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) 4599: .type == TBL))) 4600: { 4601: chaine_sauvegarde = chaine; 4602: 4603: if ((chaine_formatee = formateur_fichier(s_etat_processus, 4604: (*l_element_courant).donnee, 4605: (*l_element_courant_format).donnee, 4606: 0, 0, ' ', 'F', longueur_effective, recursivite)) 4607: == NULL) 4608: { 4609: return(NULL); 4610: } 4611: 4612: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 4613: + strlen(chaine_sauvegarde) + 2) 4614: * sizeof(unsigned char)); 4615: 4616: if (chaine == NULL) 4617: { 4618: (*s_etat_processus).erreur_systeme = 4619: d_es_allocation_memoire; 4620: return(NULL); 4621: } 4622: 4623: strcpy(chaine, chaine_sauvegarde); 4624: free(chaine_sauvegarde); 4625: strcat(chaine, " "); 4626: strcat(chaine, chaine_formatee); 4627: free(chaine_formatee); 4628: } 4629: else if ((*(*((struct_tableau *) (*s_format).objet)) 4630: .elements[i]).type != CHN) 4631: { 4632: free(chaine); 4633: 4634: (*s_etat_processus).erreur_execution = 4635: d_ex_erreur_format_fichier; 4636: return(NULL); 4637: } 4638: else 4639: { 4640: if ((format_chaine = conversion_majuscule((unsigned char *) 4641: (*(*((struct_tableau *) (*s_format).objet)) 4642: .elements[i]).objet)) == NULL) 4643: { 4644: (*s_etat_processus).erreur_systeme = 4645: d_es_allocation_memoire; 4646: return(NULL); 4647: } 4648: 4649: format_degenere = d_faux; 4650: 4651: if (strncmp("STANDARD*", format_chaine, 9) == 0) 4652: { 4653: format_sortie = 'S'; 4654: position_1 = 9; 4655: format_degenere = d_vrai; 4656: } 4657: else if (strncmp("BINARY*", format_chaine, 7) == 0) 4658: { 4659: format_sortie = 'B'; 4660: position_1 = 7; 4661: } 4662: else if (strncmp("FIXED*", format_chaine, 6) == 0) 4663: { 4664: format_sortie = 'F'; 4665: position_1 = 6; 4666: } 4667: else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0) 4668: { 4669: format_sortie = 'I'; 4670: position_1 = 11; 4671: } 4672: else if (strncmp("ENGINEER*", format_chaine, 9) == 0) 4673: { 4674: format_sortie = 'E'; 4675: position_1 = 9; 4676: } 4677: else if (strncmp("CHARACTER*", format_chaine, 10) == 0) 4678: { 4679: format_sortie = 'C'; 4680: position_1 = 10; 4681: format_degenere = d_vrai; 4682: } 4683: else 4684: { 4685: free(chaine); 4686: free(format_chaine); 4687: 4688: (*s_etat_processus).erreur_execution = 4689: d_ex_erreur_format_fichier; 4690: return(NULL); 4691: } 4692: 4693: position_3 = strlen(format_chaine); 4694: format_chaine[--position_3] = d_code_fin_chaine; 4695: 4696: position_2 = position_1; 4697: 4698: while(format_chaine[position_2] != '(') 4699: { 4700: if (format_chaine[position_2] == d_code_fin_chaine) 4701: { 4702: free(chaine); 4703: free(format_chaine); 4704: 4705: (*s_etat_processus).erreur_execution = 4706: d_ex_erreur_format_fichier; 4707: return(NULL); 4708: } 4709: 4710: position_2++; 4711: } 4712: 4713: format_chaine[position_2++] = d_code_fin_chaine; 4714: 4715: if (format_degenere == d_faux) 4716: { 4717: if (sscanf(&(format_chaine[position_1]), "%ld", 4718: &longueur) != 1) 4719: { 4720: free(chaine); 4721: free(format_chaine); 4722: 4723: (*s_etat_processus).erreur_execution = 4724: d_ex_erreur_format_fichier; 4725: return(NULL); 4726: } 4727: } 4728: else 4729: { 4730: longueur = -1; 4731: } 4732: 4733: if (strcmp(&(format_chaine[position_2]), "*") != 0) 4734: { 4735: if (sscanf(&(format_chaine[position_2]), "%ld", 4736: &longueur_champ) != 1) 4737: { 4738: free(chaine); 4739: free(format_chaine); 4740: 4741: (*s_etat_processus).erreur_execution = 4742: d_ex_erreur_format_fichier; 4743: return(NULL); 4744: } 4745: } 4746: else 4747: { 4748: longueur_champ = -1; 4749: } 4750: 4751: if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > 4752: longueur_champ)) 4753: { 4754: free(chaine); 4755: free(format_chaine); 4756: 4757: (*s_etat_processus).erreur_execution = 4758: d_ex_erreur_format_fichier; 4759: return(NULL); 4760: } 4761: 4762: free(format_chaine); 4763: 4764: chaine_sauvegarde = chaine; 4765: 4766: if ((chaine_formatee = formateur_fichier(s_etat_processus, 4767: (*((struct_tableau *) (*s_objet).objet)) 4768: .elements[i], s_format, 4769: longueur, longueur_champ, format_sortie, type, 4770: longueur_effective, recursivite)) == NULL) 4771: { 4772: return(NULL); 4773: } 4774: 4775: if ((*(*((struct_tableau *) (*s_objet).objet)) 4776: .elements[i]).type == CHN) 4777: { 4778: chaine = (unsigned char *) 4779: malloc((strlen(chaine_formatee) 4780: + strlen(chaine_sauvegarde) + 4) 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: strcpy(chaine, chaine_sauvegarde); 4791: free(chaine_sauvegarde); 4792: strcat(chaine, " \""); 4793: strcat(chaine, chaine_formatee); 4794: free(chaine_formatee); 4795: strcat(chaine, "\""); 4796: } 4797: else if ((*(*((struct_tableau *) (*s_objet).objet)) 4798: .elements[i]).type == NOM) 4799: { 4800: chaine = (unsigned char *) 4801: malloc((strlen(chaine_formatee) 4802: + strlen(chaine_sauvegarde) + 2) 4803: * sizeof(unsigned char)); 4804: 4805: if (chaine == NULL) 4806: { 4807: (*s_etat_processus).erreur_systeme = 4808: d_es_allocation_memoire; 4809: return(NULL); 4810: } 4811: 4812: sprintf(chaine, "%s %s", chaine_sauvegarde, 4813: chaine_formatee); 4814: free(chaine_formatee); 4815: } 4816: else 4817: { 4818: chaine = (unsigned char *) 4819: malloc((strlen(chaine_formatee) 4820: + strlen(chaine_sauvegarde) + 2) 4821: * sizeof(unsigned char)); 4822: 4823: if (chaine == NULL) 4824: { 4825: (*s_etat_processus).erreur_systeme = 4826: d_es_allocation_memoire; 4827: return(NULL); 4828: } 4829: 4830: strcpy(chaine, chaine_sauvegarde); 4831: free(chaine_sauvegarde); 4832: strcat(chaine, " "); 4833: strcat(chaine, chaine_formatee); 4834: free(chaine_formatee); 4835: } 4836: } 4837: } 4838: 4839: chaine_sauvegarde = chaine; 4840: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) 4841: * sizeof(unsigned char)); 4842: 4843: if (chaine == NULL) 4844: { 4845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 4846: return(NULL); 4847: } 4848: 4849: strcpy(chaine, chaine_sauvegarde); 4850: free(chaine_sauvegarde); 4851: strcat(chaine, " ]>"); 4852: } 4853: else if ((*s_objet).type == MCX) 4854: { 4855: 4856: /* 4857: -------------------------------------------------------------------------------- 4858: Matrice complexe 4859: -------------------------------------------------------------------------------- 4860: */ 4861: 4862: if ((format_sortie != 'S') && (format_sortie != 'F') && 4863: (format_sortie != 'I') && (format_sortie != 'E')) 4864: { 4865: (*s_etat_processus).erreur_execution = 4866: d_ex_erreur_format_fichier; 4867: return(NULL); 4868: } 4869: 4870: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 4871: .nombre_lignes; 4872: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 4873: .nombre_colonnes; 4874: 4875: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 4876: 4877: if (chaine != NULL) 4878: { 4879: strcpy(chaine, "[["); 4880: 4881: for(i = 0; i < nombre_lignes; i++) 4882: { 4883: for(j = 0; j < nombre_colonnes; j++) 4884: { 4885: if ((chaine_formatee = 4886: formateur_fichier_nombre(s_etat_processus, 4887: (void *) &(((struct_complexe16 **) 4888: ((*((struct_matrice *) 4889: ((*s_objet).objet))).tableau))[i][j]), 'C', 4890: longueur, longueur_champ, format_sortie)) 4891: == NULL) 4892: { 4893: (*s_etat_processus).erreur_systeme = 4894: d_es_allocation_memoire; 4895: return(NULL); 4896: } 4897: 4898: chaine_sauvegarde = chaine; 4899: chaine = (unsigned char *) malloc( 4900: (strlen(chaine_sauvegarde) + 4901: strlen(chaine_formatee) + 2) 4902: * sizeof(unsigned char)); 4903: 4904: if (chaine == NULL) 4905: { 4906: (*s_etat_processus).erreur_systeme = 4907: d_es_allocation_memoire; 4908: return(NULL); 4909: } 4910: 4911: strcpy(chaine, chaine_sauvegarde); 4912: free(chaine_sauvegarde); 4913: strcat(chaine, " "); 4914: strcat(chaine, chaine_formatee); 4915: free(chaine_formatee); 4916: } 4917: 4918: chaine_sauvegarde = chaine; 4919: if (test_cfsf(s_etat_processus, 45) == d_vrai) 4920: { 4921: chaine = (unsigned char *) malloc( 4922: (strlen(chaine_sauvegarde) + 6) 4923: * sizeof(unsigned char)); 4924: 4925: if (chaine == NULL) 4926: { 4927: (*s_etat_processus).erreur_systeme = 4928: d_es_allocation_memoire; 4929: return(NULL); 4930: } 4931: 4932: strcpy(chaine, chaine_sauvegarde); 4933: free(chaine_sauvegarde); 4934: strcat(chaine, " ]\n ["); 4935: } 4936: else 4937: { 4938: chaine = (unsigned char *) malloc( 4939: (strlen(chaine_sauvegarde) + 4) 4940: * 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: strcat(chaine, " ]["); 4952: } 4953: } 4954: 4955: if (test_cfsf(s_etat_processus, 45) == d_vrai) 4956: { 4957: chaine[strlen(chaine) - 3] = ']'; 4958: chaine[strlen(chaine) - 2] = 0; 4959: 4960: chaine_sauvegarde = chaine; 4961: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 4962: + 1) * sizeof(unsigned char)); 4963: 4964: if (chaine == NULL) 4965: { 4966: (*s_etat_processus).erreur_systeme = 4967: d_es_allocation_memoire; 4968: return(NULL); 4969: } 4970: 4971: strcpy(chaine, chaine_sauvegarde); 4972: free(chaine_sauvegarde); 4973: } 4974: else 4975: { 4976: chaine[strlen(chaine) - 2] = ']'; 4977: chaine[strlen(chaine) - 1] = 0; 4978: 4979: chaine_sauvegarde = chaine; 4980: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 4981: + 2) * sizeof(unsigned char)); 4982: 4983: if (chaine == NULL) 4984: { 4985: (*s_etat_processus).erreur_systeme = 4986: d_es_allocation_memoire; 4987: return(NULL); 4988: } 4989: 4990: strcpy(chaine, chaine_sauvegarde); 4991: free(chaine_sauvegarde); 4992: strcat(chaine, "]"); 4993: } 4994: } 4995: } 4996: else if ((*s_objet).type == MIN) 4997: { 4998: 4999: /* 5000: -------------------------------------------------------------------------------- 5001: Matrice entière 5002: -------------------------------------------------------------------------------- 5003: */ 5004: 5005: if ((format_sortie != 'S') && (format_sortie != 'F') && 5006: (format_sortie != 'I') && (format_sortie != 'E')) 5007: { 5008: (*s_etat_processus).erreur_execution = 5009: d_ex_erreur_format_fichier; 5010: return(NULL); 5011: } 5012: 5013: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 5014: .nombre_lignes; 5015: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 5016: .nombre_colonnes; 5017: 5018: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 5019: 5020: if (chaine != NULL) 5021: { 5022: strcpy(chaine, "[["); 5023: 5024: for(i = 0; i < nombre_lignes; i++) 5025: { 5026: for(j = 0; j < nombre_colonnes; j++) 5027: { 5028: if ((chaine_formatee = 5029: formateur_fichier_nombre(s_etat_processus, 5030: (void *) &(((integer8 **) ((*((struct_matrice *) 5031: ((*s_objet).objet))).tableau))[i][j]), 'I', 5032: longueur, longueur_champ, format_sortie)) 5033: == NULL) 5034: { 5035: (*s_etat_processus).erreur_systeme = 5036: d_es_allocation_memoire; 5037: return(NULL); 5038: } 5039: 5040: chaine_sauvegarde = chaine; 5041: chaine = (unsigned char *) malloc( 5042: (strlen(chaine_sauvegarde) + 5043: strlen(chaine_formatee) + 2) 5044: * sizeof(unsigned char)); 5045: 5046: if (chaine == NULL) 5047: { 5048: (*s_etat_processus).erreur_systeme = 5049: d_es_allocation_memoire; 5050: return(NULL); 5051: } 5052: 5053: strcpy(chaine, chaine_sauvegarde); 5054: free(chaine_sauvegarde); 5055: strcat(chaine, " "); 5056: strcat(chaine, chaine_formatee); 5057: free(chaine_formatee); 5058: } 5059: 5060: chaine_sauvegarde = chaine; 5061: if (test_cfsf(s_etat_processus, 45) == d_vrai) 5062: { 5063: chaine = (unsigned char *) malloc( 5064: (strlen(chaine_sauvegarde) + 6) 5065: * sizeof(unsigned char)); 5066: 5067: if (chaine == NULL) 5068: { 5069: (*s_etat_processus).erreur_systeme = 5070: d_es_allocation_memoire; 5071: return(NULL); 5072: } 5073: 5074: strcpy(chaine, chaine_sauvegarde); 5075: free(chaine_sauvegarde); 5076: strcat(chaine, " ]\n ["); 5077: } 5078: else 5079: { 5080: chaine = (unsigned char *) malloc( 5081: (strlen(chaine_sauvegarde) + 4) 5082: * 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: strcat(chaine, " ]["); 5094: } 5095: } 5096: 5097: if (test_cfsf(s_etat_processus, 45) == d_vrai) 5098: { 5099: chaine[strlen(chaine) - 3] = ']'; 5100: chaine[strlen(chaine) - 2] = 0; 5101: 5102: chaine_sauvegarde = chaine; 5103: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 5104: + 1) * sizeof(unsigned char)); 5105: 5106: if (chaine == NULL) 5107: { 5108: (*s_etat_processus).erreur_systeme = 5109: d_es_allocation_memoire; 5110: return(NULL); 5111: } 5112: 5113: strcpy(chaine, chaine_sauvegarde); 5114: free(chaine_sauvegarde); 5115: } 5116: else 5117: { 5118: chaine[strlen(chaine) - 2] = ']'; 5119: chaine[strlen(chaine) - 1] = 0; 5120: 5121: chaine_sauvegarde = chaine; 5122: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 5123: + 2) * sizeof(unsigned char)); 5124: 5125: if (chaine == NULL) 5126: { 5127: (*s_etat_processus).erreur_systeme = 5128: d_es_allocation_memoire; 5129: return(NULL); 5130: } 5131: 5132: strcpy(chaine, chaine_sauvegarde); 5133: free(chaine_sauvegarde); 5134: strcat(chaine, "]"); 5135: } 5136: } 5137: } 5138: else if ((*s_objet).type == MRL) 5139: { 5140: 5141: /* 5142: -------------------------------------------------------------------------------- 5143: Matrice réelle 5144: -------------------------------------------------------------------------------- 5145: */ 5146: 5147: if ((format_sortie != 'S') && (format_sortie != 'F') && 5148: (format_sortie != 'I') && (format_sortie != 'E')) 5149: { 5150: (*s_etat_processus).erreur_execution = 5151: d_ex_erreur_format_fichier; 5152: return(NULL); 5153: } 5154: 5155: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 5156: .nombre_lignes; 5157: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 5158: .nombre_colonnes; 5159: 5160: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 5161: 5162: if (chaine != NULL) 5163: { 5164: strcpy(chaine, "[["); 5165: 5166: for(i = 0; i < nombre_lignes; i++) 5167: { 5168: for(j = 0; j < nombre_colonnes; j++) 5169: { 5170: if ((chaine_formatee = 5171: formateur_fichier_nombre(s_etat_processus, 5172: (void *) &(((real8 **) ((*((struct_matrice *) 5173: ((*s_objet).objet))).tableau))[i][j]), 'R', 5174: longueur, longueur_champ, format_sortie)) 5175: == NULL) 5176: { 5177: (*s_etat_processus).erreur_systeme = 5178: d_es_allocation_memoire; 5179: return(NULL); 5180: } 5181: 5182: chaine_sauvegarde = chaine; 5183: chaine = (unsigned char *) malloc( 5184: (strlen(chaine_sauvegarde) + 5185: strlen(chaine_formatee) + 2) 5186: * sizeof(unsigned char)); 5187: 5188: if (chaine == NULL) 5189: { 5190: (*s_etat_processus).erreur_systeme = 5191: d_es_allocation_memoire; 5192: return(NULL); 5193: } 5194: 5195: strcpy(chaine, chaine_sauvegarde); 5196: free(chaine_sauvegarde); 5197: strcat(chaine, " "); 5198: strcat(chaine, chaine_formatee); 5199: free(chaine_formatee); 5200: } 5201: 5202: chaine_sauvegarde = chaine; 5203: if (test_cfsf(s_etat_processus, 45) == d_vrai) 5204: { 5205: chaine = (unsigned char *) malloc( 5206: (strlen(chaine_sauvegarde) + 6) 5207: * sizeof(unsigned char)); 5208: 5209: if (chaine == NULL) 5210: { 5211: (*s_etat_processus).erreur_systeme = 5212: d_es_allocation_memoire; 5213: return(NULL); 5214: } 5215: 5216: strcpy(chaine, chaine_sauvegarde); 5217: free(chaine_sauvegarde); 5218: strcat(chaine, " ]\n ["); 5219: } 5220: else 5221: { 5222: chaine = (unsigned char *) malloc( 5223: (strlen(chaine_sauvegarde) + 4) 5224: * 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: strcat(chaine, " ]["); 5236: } 5237: } 5238: 5239: if (test_cfsf(s_etat_processus, 45) == d_vrai) 5240: { 5241: chaine[strlen(chaine) - 3] = ']'; 5242: chaine[strlen(chaine) - 2] = 0; 5243: 5244: chaine_sauvegarde = chaine; 5245: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 5246: + 1) * sizeof(unsigned char)); 5247: 5248: if (chaine == NULL) 5249: { 5250: (*s_etat_processus).erreur_systeme = 5251: d_es_allocation_memoire; 5252: return(NULL); 5253: } 5254: 5255: strcpy(chaine, chaine_sauvegarde); 5256: free(chaine_sauvegarde); 5257: } 5258: else 5259: { 5260: chaine[strlen(chaine) - 2] = ']'; 5261: chaine[strlen(chaine) - 1] = 0; 5262: 5263: chaine_sauvegarde = chaine; 5264: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 5265: + 2) * sizeof(unsigned char)); 5266: 5267: if (chaine == NULL) 5268: { 5269: (*s_etat_processus).erreur_systeme = 5270: d_es_allocation_memoire; 5271: return(NULL); 5272: } 5273: 5274: strcpy(chaine, chaine_sauvegarde); 5275: free(chaine_sauvegarde); 5276: strcat(chaine, "]"); 5277: } 5278: } 5279: } 5280: else if ((*s_objet).type == NOM) 5281: { 5282: 5283: /* 5284: -------------------------------------------------------------------------------- 5285: Nom 5286: -------------------------------------------------------------------------------- 5287: */ 5288: 5289: chaine = (unsigned char *) malloc((strlen((*((struct_nom *) 5290: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); 5291: 5292: if (chaine == NULL) 5293: { 5294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 5295: return(NULL); 5296: } 5297: 5298: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom); 5299: } 5300: else if ((*s_objet).type == REL) 5301: { 5302: 5303: /* 5304: -------------------------------------------------------------------------------- 5305: Réel 5306: -------------------------------------------------------------------------------- 5307: */ 5308: 5309: if ((format_sortie != 'S') && (format_sortie != 'F') && 5310: (format_sortie != 'I') && (format_sortie != 'E')) 5311: { 5312: (*s_etat_processus).erreur_execution = 5313: d_ex_erreur_format_fichier; 5314: return(NULL); 5315: } 5316: 5317: if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, 5318: (void *) ((real8 *) ((*s_objet).objet)), 'R', 5319: longueur, longueur_champ, format_sortie)) == NULL) 5320: { 5321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 5322: return(NULL); 5323: } 5324: 5325: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) 5326: * sizeof(unsigned char)); 5327: 5328: if (chaine == NULL) 5329: { 5330: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 5331: return(NULL); 5332: } 5333: 5334: strcpy(chaine, chaine_formatee); 5335: free(chaine_formatee); 5336: } 5337: else if ((*s_objet).type == VCX) 5338: { 5339: 5340: /* 5341: -------------------------------------------------------------------------------- 5342: Vecteur complexe 5343: -------------------------------------------------------------------------------- 5344: */ 5345: 5346: if ((format_sortie != 'S') && (format_sortie != 'F') && 5347: (format_sortie != 'I') && (format_sortie != 'E')) 5348: { 5349: (*s_etat_processus).erreur_execution = 5350: d_ex_erreur_format_fichier; 5351: return(NULL); 5352: } 5353: 5354: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 5355: .taille; 5356: 5357: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 5358: 5359: if (chaine != NULL) 5360: { 5361: strcpy(chaine, "["); 5362: 5363: for(i = 0; i < nombre_colonnes; i++) 5364: { 5365: if ((chaine_formatee = 5366: formateur_fichier_nombre(s_etat_processus, 5367: (void *) &(((struct_complexe16 *) 5368: ((*((struct_vecteur *) 5369: ((*s_objet).objet))).tableau))[i]), 'C', 5370: longueur, longueur_champ, format_sortie)) == NULL) 5371: { 5372: (*s_etat_processus).erreur_systeme = 5373: d_es_allocation_memoire; 5374: return(NULL); 5375: } 5376: 5377: chaine_sauvegarde = chaine; 5378: chaine = (unsigned char *) malloc( 5379: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 5380: + 2) * sizeof(unsigned char)); 5381: 5382: if (chaine == NULL) 5383: { 5384: (*s_etat_processus).erreur_systeme = 5385: d_es_allocation_memoire; 5386: return(NULL); 5387: } 5388: 5389: strcpy(chaine, chaine_sauvegarde); 5390: free(chaine_sauvegarde); 5391: strcat(chaine, " "); 5392: strcat(chaine, chaine_formatee); 5393: free(chaine_formatee); 5394: } 5395: 5396: chaine_sauvegarde = chaine; 5397: chaine = (unsigned char *) malloc( 5398: (strlen(chaine_sauvegarde) + 3) 5399: * sizeof(unsigned char)); 5400: 5401: if (chaine == NULL) 5402: { 5403: (*s_etat_processus).erreur_systeme = 5404: d_es_allocation_memoire; 5405: return(NULL); 5406: } 5407: 5408: strcpy(chaine, chaine_sauvegarde); 5409: free(chaine_sauvegarde); 5410: strcat(chaine, " ]"); 5411: } 5412: } 5413: else if ((*s_objet).type == VIN) 5414: { 5415: 5416: /* 5417: -------------------------------------------------------------------------------- 5418: Vecteur entier 5419: -------------------------------------------------------------------------------- 5420: */ 5421: 5422: if ((format_sortie != 'S') && (format_sortie != 'F') && 5423: (format_sortie != 'I') && (format_sortie != 'E')) 5424: { 5425: (*s_etat_processus).erreur_execution = 5426: d_ex_erreur_format_fichier; 5427: return(NULL); 5428: } 5429: 5430: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 5431: .taille; 5432: 5433: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 5434: 5435: if (chaine != NULL) 5436: { 5437: strcpy(chaine, "["); 5438: 5439: for(i = 0; i < nombre_colonnes; i++) 5440: { 5441: if ((chaine_formatee = 5442: formateur_fichier_nombre(s_etat_processus, 5443: (void *) &(((integer8 *) ((*((struct_vecteur *) 5444: ((*s_objet).objet))).tableau))[i]), 'I', 5445: longueur, longueur_champ, format_sortie)) == NULL) 5446: { 5447: (*s_etat_processus).erreur_systeme = 5448: d_es_allocation_memoire; 5449: return(NULL); 5450: } 5451: 5452: chaine_sauvegarde = chaine; 5453: chaine = (unsigned char *) malloc( 5454: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 5455: + 2) * sizeof(unsigned char)); 5456: 5457: if (chaine == NULL) 5458: { 5459: (*s_etat_processus).erreur_systeme = 5460: d_es_allocation_memoire; 5461: return(NULL); 5462: } 5463: 5464: strcpy(chaine, chaine_sauvegarde); 5465: free(chaine_sauvegarde); 5466: strcat(chaine, " "); 5467: strcat(chaine, chaine_formatee); 5468: free(chaine_formatee); 5469: } 5470: 5471: chaine_sauvegarde = chaine; 5472: chaine = (unsigned char *) malloc( 5473: (strlen(chaine_sauvegarde) + 3) 5474: * sizeof(unsigned char)); 5475: 5476: if (chaine == NULL) 5477: { 5478: (*s_etat_processus).erreur_systeme = 5479: d_es_allocation_memoire; 5480: return(NULL); 5481: } 5482: 5483: strcpy(chaine, chaine_sauvegarde); 5484: free(chaine_sauvegarde); 5485: strcat(chaine, " ]"); 5486: } 5487: } 5488: else if ((*s_objet).type == VRL) 5489: { 5490: 5491: /* 5492: -------------------------------------------------------------------------------- 5493: Vecteur réel 5494: -------------------------------------------------------------------------------- 5495: */ 5496: 5497: if ((format_sortie != 'S') && (format_sortie != 'F') && 5498: (format_sortie != 'I') && (format_sortie != 'E')) 5499: { 5500: (*s_etat_processus).erreur_execution = 5501: d_ex_erreur_format_fichier; 5502: return(NULL); 5503: } 5504: 5505: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 5506: .taille; 5507: 5508: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 5509: 5510: if (chaine != NULL) 5511: { 5512: strcpy(chaine, "["); 5513: 5514: for(i = 0; i < nombre_colonnes; i++) 5515: { 5516: if ((chaine_formatee = 5517: formateur_fichier_nombre(s_etat_processus, 5518: (void *) &(((real8 *) ((*((struct_vecteur *) 5519: ((*s_objet).objet))).tableau))[i]), 'R', 5520: longueur, longueur_champ, format_sortie)) == NULL) 5521: { 5522: (*s_etat_processus).erreur_systeme = 5523: d_es_allocation_memoire; 5524: return(NULL); 5525: } 5526: 5527: chaine_sauvegarde = chaine; 5528: chaine = (unsigned char *) malloc( 5529: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 5530: + 2) * sizeof(unsigned char)); 5531: 5532: if (chaine == NULL) 5533: { 5534: (*s_etat_processus).erreur_systeme = 5535: d_es_allocation_memoire; 5536: return(NULL); 5537: } 5538: 5539: strcpy(chaine, chaine_sauvegarde); 5540: free(chaine_sauvegarde); 5541: strcat(chaine, " "); 5542: strcat(chaine, chaine_formatee); 5543: free(chaine_formatee); 5544: } 5545: 5546: chaine_sauvegarde = chaine; 5547: chaine = (unsigned char *) malloc( 5548: (strlen(chaine_sauvegarde) + 3) 5549: * sizeof(unsigned char)); 5550: 5551: if (chaine == NULL) 5552: { 5553: (*s_etat_processus).erreur_systeme = 5554: d_es_allocation_memoire; 5555: return(NULL); 5556: } 5557: 5558: strcpy(chaine, chaine_sauvegarde); 5559: free(chaine_sauvegarde); 5560: strcat(chaine, " ]"); 5561: } 5562: } 5563: else 5564: { 5565: // Type non exportable 5566: 5567: (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; 5568: free(chaine); 5569: 5570: return(NULL); 5571: } 5572: } 5573: 5574: (*recursivite)--; 5575: 5576: return(chaine); 5577: } 5578: 5579: 5580: /* 5581: ================================================================================ 5582: Routines qui transforment un nombre entier, réel ou complexe en chaîne de 5583: caractères suivant le format courant 5584: ================================================================================ 5585: Entrées : pointeur générique sur la donnée numérique à convertir, 5586: type de l'entité (I, R ou C). 5587: -------------------------------------------------------------------------------- 5588: Sorties : chaîne de caractères allouée dans la routine 5589: -------------------------------------------------------------------------------- 5590: Effets de bord : néant 5591: ================================================================================ 5592: */ 5593: 5594: /* 5595: -------------------------------------------------------------------------------- 5596: Formatage des complexes, réels et entiers 5597: -------------------------------------------------------------------------------- 5598: */ 5599: 5600: unsigned char * 5601: formateur_fichier_nombre(struct_processus *s_etat_processus, 5602: void *valeur_numerique, unsigned char type, 5603: long longueur, long longueur_champ, unsigned char format) 5604: { 5605: unsigned char *chaine; 5606: unsigned char *construction_chaine; 5607: unsigned char *sauvegarde; 5608: unsigned char *tampon; 5609: 5610: chaine = NULL; 5611: 5612: switch(type) 5613: { 5614: case 'C' : 5615: { 5616: construction_chaine = (unsigned char *) malloc( 5617: 2 * sizeof(unsigned char)); 5618: 5619: if (construction_chaine == NULL) 5620: { 5621: (*s_etat_processus).erreur_systeme = 5622: d_es_allocation_memoire; 5623: return(NULL); 5624: } 5625: 5626: strcpy(construction_chaine, "("); 5627: 5628: tampon = formateur_fichier_reel(s_etat_processus, 5629: (void *) &((*((struct_complexe16 *) 5630: valeur_numerique)).partie_reelle), 'R', 5631: longueur, longueur_champ, format); 5632: 5633: if (tampon == NULL) 5634: { 5635: (*s_etat_processus).erreur_systeme = 5636: d_es_allocation_memoire; 5637: return(NULL); 5638: } 5639: 5640: sauvegarde = construction_chaine; 5641: 5642: construction_chaine = (unsigned char *) malloc( 5643: (strlen(sauvegarde) + strlen(tampon) + 2) 5644: * sizeof(unsigned char)); 5645: 5646: if (construction_chaine == NULL) 5647: { 5648: (*s_etat_processus).erreur_systeme = 5649: d_es_allocation_memoire; 5650: return(NULL); 5651: } 5652: 5653: strcpy(construction_chaine, sauvegarde); 5654: free(sauvegarde); 5655: strcat(construction_chaine, tampon); 5656: free(tampon); 5657: 5658: strcat(construction_chaine, ","); 5659: 5660: tampon = formateur_fichier_reel(s_etat_processus, 5661: (void *) &((*((struct_complexe16 *) 5662: valeur_numerique)).partie_imaginaire), 'R', 5663: longueur, longueur_champ, format); 5664: 5665: if (tampon == NULL) 5666: { 5667: (*s_etat_processus).erreur_systeme = 5668: d_es_allocation_memoire; 5669: return(NULL); 5670: } 5671: 5672: sauvegarde = construction_chaine; 5673: 5674: construction_chaine = (unsigned char *) malloc( 5675: (strlen(sauvegarde) + strlen(tampon) + 2) 5676: * sizeof(unsigned char)); 5677: 5678: if (construction_chaine == NULL) 5679: { 5680: (*s_etat_processus).erreur_systeme = 5681: d_es_allocation_memoire; 5682: return(NULL); 5683: } 5684: 5685: strcpy(construction_chaine, sauvegarde); 5686: free(sauvegarde); 5687: strcat(construction_chaine, tampon); 5688: free(tampon); 5689: strcat(construction_chaine, ")"); 5690: 5691: chaine = construction_chaine; 5692: 5693: break; 5694: } 5695: 5696: case 'R' : 5697: { 5698: chaine = formateur_fichier_reel(s_etat_processus, 5699: valeur_numerique, 'R', longueur, longueur_champ, 5700: format); 5701: 5702: if (chaine == NULL) 5703: { 5704: (*s_etat_processus).erreur_systeme = 5705: d_es_allocation_memoire; 5706: return(NULL); 5707: } 5708: 5709: break; 5710: } 5711: 5712: default : 5713: case 'I' : 5714: { 5715: chaine = formateur_fichier_reel(s_etat_processus, 5716: valeur_numerique, 'I', longueur, longueur_champ, 5717: format); 5718: 5719: if (chaine == NULL) 5720: { 5721: (*s_etat_processus).erreur_systeme = 5722: d_es_allocation_memoire; 5723: return(NULL); 5724: } 5725: 5726: break; 5727: } 5728: } 5729: 5730: return(chaine); 5731: } 5732: 5733: 5734: /* 5735: -------------------------------------------------------------------------------- 5736: Recherche de la longueur de l'entier minimale pour représenter la donnée 5737: -------------------------------------------------------------------------------- 5738: */ 5739: 5740: unsigned char 5741: recherche_longueur_optimale(integer8 parametre) 5742: { 5743: if (parametre == (integer8) ((integer1) parametre)) 5744: { 5745: return(0x0); 5746: } 5747: else if (parametre == (integer8) ((integer2) parametre)) 5748: { 5749: return(0x1); 5750: } 5751: else if (parametre == (integer8) ((integer4) parametre)) 5752: { 5753: return(0x2); 5754: } 5755: else 5756: { 5757: return(0x3); 5758: } 5759: } 5760: 5761: 5762: /* 5763: -------------------------------------------------------------------------------- 5764: Formateur des réels et entiers 5765: -------------------------------------------------------------------------------- 5766: */ 5767: 5768: unsigned char * 5769: formateur_fichier_reel(struct_processus *s_etat_processus, 5770: void *valeur_numerique, unsigned char type, 5771: long longueur, long longueur_champ, 5772: unsigned char format_sortie) 5773: { 5774: real8 mantisse; 5775: real8 tampon_reel; 5776: 5777: integer8 tampon_entier; 5778: 5779: long correction; 5780: long exposant; 5781: long longueur_utile; 5782: long longueur_utile_limite; 5783: 5784: unsigned char *chaine; 5785: unsigned char format[16 + 1]; 5786: unsigned char mode[3 + 1]; 5787: unsigned char tampon[16 + 1]; 5788: 5789: unsigned long i; 5790: 5791: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char)); 5792: 5793: if (chaine == NULL) 5794: { 5795: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 5796: return(NULL); 5797: } 5798: 5799: if (type == 'R') 5800: { 5801: tampon_reel = *((real8 *) valeur_numerique); 5802: 5803: if (tampon_reel > ((real8) 0)) 5804: { 5805: exposant = (long) floor(log10(tampon_reel)); 5806: } 5807: else if (tampon_reel < ((real8) 0)) 5808: { 5809: exposant = (long) floor(log10(-tampon_reel)); 5810: } 5811: else 5812: { 5813: exposant = 0; 5814: } 5815: 5816: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant); 5817: } 5818: else 5819: { 5820: tampon_entier = *((integer8 *) valeur_numerique); 5821: 5822: if (tampon_entier > ((integer8) 0)) 5823: { 5824: exposant = (long) floor(log10(tampon_entier)); 5825: } 5826: else if (tampon_entier < ((integer8) 0)) 5827: { 5828: exposant = (long) floor(log10(-tampon_entier)); 5829: } 5830: else 5831: { 5832: exposant = 0; 5833: } 5834: 5835: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant); 5836: } 5837: 5838: longueur_utile = longueur; 5839: longueur_utile_limite = 15; 5840: 5841: if (longueur_utile > longueur_utile_limite) 5842: { 5843: longueur_utile = longueur_utile_limite; 5844: } 5845: 5846: if (format_sortie == 'S') 5847: { 5848: strcpy(mode, "STD"); 5849: } 5850: else if (format_sortie == 'C') 5851: { 5852: strcpy(mode, "SCI"); 5853: } 5854: else if (format_sortie == 'F') 5855: { 5856: strcpy(mode, "FIX"); 5857: } 5858: else 5859: { 5860: strcpy(mode, "ENG"); 5861: } 5862: 5863: if ((strcmp(mode, "SCI") == 0) || 5864: ((strcmp(mode, "STD") == 0) && ((exposant > 5865: longueur_utile_limite) || 5866: (exposant < -longueur_utile_limite))) || 5867: ((strcmp(mode, "FIX") == 0) && 5868: ((exposant >= longueur_utile_limite) || 5869: (exposant < -longueur_utile)))) 5870: { 5871: chaine[0] = 0; 5872: format[0] = 0; 5873: 5874: if (strcmp(mode, "STD") == 0) 5875: { 5876: longueur_utile = longueur_utile_limite - 1; 5877: } 5878: 5879: sprintf(format, "%%.%luf", longueur_utile); 5880: 5881: sprintf(tampon, format, mantisse); 5882: strcpy(chaine, tampon); 5883: strcat(chaine, "E"); 5884: sprintf(tampon, "%ld", exposant); 5885: strcat(chaine, tampon); 5886: } 5887: else if (strcmp(mode, "FIX") == 0) 5888: { 5889: chaine[0] = 0; 5890: format[0] = 0; 5891: 5892: if (longueur_utile + exposant >= longueur_utile_limite) 5893: { 5894: longueur_utile = longueur_utile_limite - (exposant + 1); 5895: } 5896: 5897: sprintf(format, "%%.%luf", longueur_utile); 5898: 5899: sprintf(tampon, format, (mantisse * pow(10, exposant))); 5900: strcpy(chaine, tampon); 5901: } 5902: else if (strcmp(mode, "ENG") == 0) 5903: { 5904: chaine[0] = 0; 5905: format[0] = 0; 5906: 5907: correction = labs(exposant) % 3; 5908: 5909: if (exposant < 0) 5910: { 5911: if (correction == 0) 5912: { 5913: correction = 3; 5914: } 5915: 5916: correction = 3 - correction; 5917: } 5918: 5919: longueur_utile -= correction; 5920: sprintf(format, "%%.%luf", longueur_utile); 5921: 5922: sprintf(tampon, format, (mantisse * pow(10, correction))); 5923: strcpy(chaine, tampon); 5924: strcat(chaine, "E"); 5925: sprintf(tampon, "%ld", (exposant - correction)); 5926: strcat(chaine, tampon); 5927: } 5928: else 5929: { 5930: if (type == 'I') 5931: { 5932: chaine[0] = 0; 5933: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique)); 5934: } 5935: else 5936: { 5937: chaine[0] = 0; 5938: format[0] = 0; 5939: 5940: if (exposant >= 0) 5941: { 5942: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant 5943: - 1)); 5944: } 5945: else 5946: { 5947: sprintf(format, "%%.%luf", longueur_utile_limite); 5948: } 5949: 5950: sprintf(tampon, format, *((real8 *) valeur_numerique)); 5951: 5952: i = strlen(tampon) - 1; 5953: while(tampon[i] == '0') 5954: { 5955: tampon[i] = 0; 5956: i--; 5957: } 5958: 5959: if (ds_imposition_separateur_decimal == d_faux) 5960: { 5961: i = strlen(tampon) - 1; 5962: if (tampon[i] == '.') 5963: { 5964: tampon[i] = 0; 5965: } 5966: } 5967: } 5968: strcpy(chaine, tampon); 5969: } 5970: 5971: if (longueur_champ >= 0) 5972: { 5973: if (strlen(chaine) > (size_t) longueur_champ) 5974: { 5975: for(i = 0; i < (unsigned long) longueur_champ; i++) 5976: { 5977: chaine[i] = '*'; 5978: } 5979: 5980: chaine[i] = d_code_fin_chaine; 5981: } 5982: } 5983: 5984: return(chaine); 5985: }