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