![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Routine de formation des données pour l'affichage 29: ================================================================================ 30: Entrées : structure sur l'état du processus et objet à afficher 31: -------------------------------------------------------------------------------- 32: Sorties : chaine de caractères 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: unsigned char * 39: formateur(struct_processus *s_etat_processus, long offset_initial, 40: struct_objet *s_objet) 41: { 42: int parentheses_groupe_gauche; 43: int parentheses_groupe_droit; 44: 45: logical1 registre45; 46: 47: logical4 autorisation_parenthese; 48: logical4 presence_signe; 49: 50: struct_liste_chainee *l_atome; 51: struct_liste_chainee *l_element_courant; 52: struct_liste_chainee *l_liste1; 53: struct_liste_chainee *l_liste2; 54: 55: struct_objet *s_sous_objet; 56: struct_objet *s_sous_objet_1; 57: struct_objet *s_sous_objet_2; 58: struct_objet *s_sous_objet_3; 59: 60: unsigned char base[1 + 1]; 61: unsigned char *chaine; 62: unsigned char *chaine_fonction; 63: unsigned char *chaine_formatee; 64: unsigned char *chaine_tampon; 65: unsigned char *chaine_sauvegarde; 66: unsigned char *format; 67: unsigned char *format_majuscule; 68: unsigned char *ptre; 69: unsigned char *ptrl; 70: unsigned char *ptr_ecriture; 71: unsigned char *ptr_lecture; 72: unsigned char *registre; 73: unsigned char tampon[1024 + 1]; 74: 75: unsigned long i; 76: unsigned long j; 77: unsigned long k; 78: unsigned long longueur_binaire; 79: unsigned long longueur_courante; 80: unsigned long longueur_decimale_courante; 81: unsigned long *longueurs_maximales; 82: unsigned long nombre_arguments; 83: unsigned long nombre_arguments_fonction; 84: unsigned long nombre_colonnes; 85: unsigned long nombre_elements; 86: unsigned long nombre_lignes; 87: unsigned long offset; 88: 89: integer8 masque_binaire; 90: 91: chaine = NULL; 92: chaine_formatee = NULL; 93: chaine_sauvegarde = NULL; 94: 95: strcpy(base, " "); 96: 97: longueur_binaire = 0; 98: masque_binaire = 0; 99: 100: if ((*s_objet).type == ADR) 101: { 102: 103: /* 104: -------------------------------------------------------------------------------- 105: Adresse 106: -------------------------------------------------------------------------------- 107: */ 108: 109: if (alsprintf(&chaine, "@ %016lX", (*((unsigned long *) 110: ((*s_objet).objet)))) < 0) 111: { 112: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 113: return(NULL); 114: } 115: } 116: else if ((*s_objet).type == SLB) 117: { 118: 119: /* 120: -------------------------------------------------------------------------------- 121: Bibliothèque partagée 122: -------------------------------------------------------------------------------- 123: */ 124: 125: if (alsprintf(&chaine, "Library $ %016lX [%s]", 126: (unsigned long) (*((struct_bibliotheque *) 127: (*s_objet).objet)).descripteur, (*((struct_bibliotheque *) 128: (*s_objet).objet)).nom) < 0) 129: { 130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 131: return(NULL); 132: } 133: } 134: else if ((*s_objet).type == SPH) 135: { 136: 137: /* 138: -------------------------------------------------------------------------------- 139: Sémaphore 140: -------------------------------------------------------------------------------- 141: */ 142: 143: if (alsprintf(&chaine, "Semaphore $ %016lX '%s'", 144: &((*((struct_semaphore *) (*s_objet).objet)).semaphore), 145: (*((struct_semaphore *) (*s_objet).objet)).nom) < 0) 146: { 147: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 148: return(NULL); 149: } 150: } 151: else if ((*s_objet).type == SQL) 152: { 153: 154: /* 155: -------------------------------------------------------------------------------- 156: Connecteur SQL 157: -------------------------------------------------------------------------------- 158: */ 159: 160: if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, 161: "MYSQL") == 0) 162: { 163: # ifdef MYSQL_SUPPORT 164: if (alsprintf(&chaine, "Sql $ %016lX (%s)", 165: (long unsigned int) (*((struct_connecteur_sql *) 166: (*s_objet).objet)).descripteur.mysql, 167: (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0) 168: { 169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 170: return(NULL); 171: } 172: # else 173: if ((*s_etat_processus).langue == 'F') 174: { 175: printf("+++Attention : Support de MySQL " 176: "non compilé !\n"); 177: } 178: else 179: { 180: printf("+++Warning : MySQL support " 181: "not available !\n"); 182: } 183: 184: fflush(stdout); 185: # endif 186: } 187: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, 188: "POSTGRESQL") == 0) 189: { 190: # ifdef POSTGRESQL_SUPPORT 191: if (alsprintf(&chaine, "Sql $ %016lX (%s)", 192: (long unsigned int) (*((struct_connecteur_sql *) 193: (*s_objet).objet)).descripteur.postgresql, 194: (*((struct_connecteur_sql *) (*s_objet).objet)).type) < 0) 195: { 196: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 197: return(NULL); 198: } 199: # else 200: if ((*s_etat_processus).langue == 'F') 201: { 202: printf("+++Attention : Support de PostgreSQL " 203: "non compilé !\n"); 204: } 205: else 206: { 207: printf("+++Warning : PostgreSQL support " 208: "not available !\n"); 209: } 210: 211: fflush(stdout); 212: # endif 213: } 214: else 215: { 216: BUG(1, printf("SQL type '%s' not allowed!", 217: (*((struct_connecteur_sql *) (*s_objet).objet)) 218: .type)); 219: } 220: } 221: else if ((*s_objet).type == PRC) 222: { 223: 224: /* 225: -------------------------------------------------------------------------------- 226: Processus 227: -------------------------------------------------------------------------------- 228: */ 229: 230: if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread) 231: .processus_detache == d_vrai) 232: { 233: if (alsprintf(&chaine, "Process $ %016lX", (unsigned long) 234: (*(*((struct_processus_fils *) (*s_objet).objet)).thread) 235: .pid) < 0) 236: { 237: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 238: return(NULL); 239: } 240: } 241: else 242: { 243: if (alsprintf(&chaine, "Light weight process $ %016lX/%016lX", 244: (unsigned long) (*(*((struct_processus_fils *) 245: (*s_objet).objet)).thread).pid, 246: (unsigned long) (*(*((struct_processus_fils *) 247: (*s_objet).objet)).thread).tid) < 0) 248: { 249: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 250: return(NULL); 251: } 252: } 253: } 254: else if ((*s_objet).type == FCH) 255: { 256: 257: /* 258: -------------------------------------------------------------------------------- 259: Fichier 260: -------------------------------------------------------------------------------- 261: */ 262: 263: if (alsprintf(&chaine, "File $ %016lX", (unsigned long) 264: (*((struct_fichier *) ((*s_objet).objet))).descripteur) < 0) 265: { 266: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 267: return(NULL); 268: } 269: 270: registre45 = test_cfsf(s_etat_processus, 45); 271: cf(s_etat_processus, 45); 272: 273: if ((format = formateur(s_etat_processus, 0, (*((struct_fichier *) 274: ((*s_objet).objet))).format)) == NULL) 275: { 276: return(NULL); 277: } 278: 279: if (registre45 == d_vrai) 280: { 281: sf(s_etat_processus, 45); 282: } 283: else 284: { 285: cf(s_etat_processus, 45); 286: } 287: 288: if ((format_majuscule = conversion_majuscule(format)) == NULL) 289: { 290: return(NULL); 291: } 292: 293: free(format); 294: 295: registre = chaine; 296: 297: if ((chaine = malloc((strlen(registre) + 1 + 298: strlen(format_majuscule) + 1) * sizeof(unsigned char))) 299: == NULL) 300: { 301: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 302: return(NULL); 303: } 304: 305: sprintf(chaine, "%s %s", registre, format_majuscule); 306: free(registre); 307: 308: tampon[0] = d_code_fin_chaine; 309: 310: if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'S') 311: { 312: strcat(tampon, "SEQUENTIAL, "); 313: } 314: else if ((*((struct_fichier *) ((*s_objet).objet))).acces == 'D') 315: { 316: strcat(tampon, "DIRECT, "); 317: } 318: else 319: { 320: strcat(tampon, "KEYED, "); 321: } 322: 323: if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'N') 324: { 325: strcat(tampon, "FORMATTED, "); 326: } 327: else if ((*((struct_fichier *) ((*s_objet).objet))).binaire == 'Y') 328: { 329: strcat(tampon, "UNFORMATTED, "); 330: } 331: else 332: { 333: strcat(tampon, "FLOW, "); 334: } 335: 336: if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'N') 337: { 338: strcat(tampon, "NEW, "); 339: } 340: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'O') 341: { 342: strcat(tampon, "OLD, "); 343: } 344: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'R') 345: { 346: strcat(tampon, "REPLACE, "); 347: } 348: else if ((*((struct_fichier *) ((*s_objet).objet))).ouverture == 'U') 349: { 350: strcat(tampon, "UNKNOWN, "); 351: } 352: else 353: { 354: strcat(tampon, "SCRATCH, "); 355: } 356: 357: if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'R') 358: { 359: strcat(tampon, "READONLY"); 360: } 361: else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W') 362: { 363: strcat(tampon, "WRITEONLY"); 364: } 365: else 366: { 367: strcat(tampon, "READWRITE"); 368: } 369: 370: registre = chaine; 371: 372: if ((chaine = malloc((strlen(chaine) + 6 + strlen(tampon) + 373: strlen((*((struct_fichier *) ((*s_objet).objet))).nom) + 1) * 374: sizeof(unsigned char))) == NULL) 375: { 376: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 377: return(NULL); 378: } 379: 380: sprintf(chaine, "%s [%s <%s>]", registre, (*((struct_fichier *) 381: ((*s_objet).objet))).nom, tampon); 382: free(registre); 383: 384: free(format_majuscule); 385: } 386: else if ((*s_objet).type == SCK) 387: { 388: 389: /* 390: -------------------------------------------------------------------------------- 391: Socket 392: -------------------------------------------------------------------------------- 393: */ 394: 395: if (alsprintf(&chaine, "Socket $ %016lX", 396: (unsigned long) (*((struct_socket *) 397: ((*s_objet).objet))).socket) < 0) 398: { 399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 400: return(NULL); 401: } 402: 403: registre45 = test_cfsf(s_etat_processus, 45); 404: cf(s_etat_processus, 45); 405: 406: if ((format = formateur(s_etat_processus, 0, (*((struct_socket *) 407: ((*s_objet).objet))).format)) == NULL) 408: { 409: return(NULL); 410: } 411: 412: if (registre45 == d_vrai) 413: { 414: sf(s_etat_processus, 45); 415: } 416: else 417: { 418: cf(s_etat_processus, 45); 419: } 420: 421: if ((format_majuscule = conversion_majuscule(format)) == NULL) 422: { 423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 424: return(NULL); 425: } 426: 427: free(format); 428: 429: registre = chaine; 430: 431: if ((chaine = malloc((strlen(registre) + 1 + 432: strlen(format_majuscule) + 1) * sizeof(unsigned char))) 433: == NULL) 434: { 435: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 436: return(NULL); 437: } 438: 439: sprintf(chaine, "%s %s", registre, format_majuscule); 440: free(registre); 441: 442: tampon[0] = d_code_fin_chaine; 443: 444: strcat(tampon, (*((struct_socket *) ((*s_objet).objet))).type); 445: strcat(tampon, ", "); 446: 447: if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_UNIX) 448: { 449: strcat(tampon, "UNIX, "); 450: } 451: else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET) 452: { 453: strcat(tampon, "IPV4, "); 454: } 455: else if ((*((struct_socket *) ((*s_objet).objet))).domaine == PF_INET6) 456: { 457: strcat(tampon, "IPV6, "); 458: } 459: 460: if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L') 461: { 462: strcat(tampon, "LOCAL, "); 463: } 464: else 465: { 466: strcat(tampon, "FOREIGN, "); 467: } 468: 469: if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'N') 470: { 471: strcat(tampon, "FORMATTED, "); 472: } 473: else if ((*((struct_socket *) ((*s_objet).objet))).binaire == 'Y') 474: { 475: strcat(tampon, "UNFORMATTED, "); 476: } 477: else 478: { 479: strcat(tampon, "FLOW, "); 480: } 481: 482: if ((*((struct_socket *) ((*s_objet).objet))).protection == 'R') 483: { 484: strcat(tampon, "READONLY"); 485: } 486: else if ((*((struct_fichier *) ((*s_objet).objet))).protection == 'W') 487: { 488: strcat(tampon, "WRITEONLY"); 489: } 490: else 491: { 492: strcat(tampon, "READWRITE"); 493: } 494: 495: registre = chaine; 496: 497: if ((*((struct_socket *) ((*s_objet).objet))).localisation == 'L') 498: { // Socket locale 499: if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type, 500: "STREAM") == 0) || (strcmp((*((struct_socket *) 501: ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0)) 502: { 503: if (strcmp((*((struct_socket *) ((*s_objet).objet))) 504: .adresse_distante, "") == 0) 505: { // Socket connectée en écoute 506: if ((chaine = malloc((strlen(registre) + 16 + 507: strlen(tampon) + strlen((*((struct_socket *) 508: ((*s_objet).objet))).adresse) + 509: + 1) * sizeof(unsigned char))) == NULL) 510: { 511: (*s_etat_processus).erreur_systeme = 512: d_es_allocation_memoire; 513: return(NULL); 514: } 515: 516: sprintf(chaine, "%s [%s LISTENING <%s>]", registre, 517: (*((struct_socket *) ((*s_objet).objet))).adresse, 518: tampon); 519: } 520: else 521: { // Socket connecté 522: if ((chaine = malloc((strlen(registre) + 12 + 523: strlen(tampon) + strlen((*((struct_socket *) 524: ((*s_objet).objet))).adresse) + 525: strlen((*((struct_socket *) ((*s_objet).objet))) 526: .adresse_distante) 527: + 1) * sizeof(unsigned char))) == NULL) 528: { 529: (*s_etat_processus).erreur_systeme = 530: d_es_allocation_memoire; 531: return(NULL); 532: } 533: 534: sprintf(chaine, "%s [%s FROM %s <%s>]", registre, 535: (*((struct_socket *) ((*s_objet).objet))).adresse, 536: (*((struct_socket *) ((*s_objet).objet))) 537: .adresse_distante, tampon); 538: } 539: } 540: else // Socket non connectée 541: { 542: if ((chaine = malloc((strlen(registre) + 6 + 543: strlen(tampon) + strlen((*((struct_socket *) 544: ((*s_objet).objet))).adresse) + 545: + 1) * sizeof(unsigned char))) == NULL) 546: { 547: (*s_etat_processus).erreur_systeme = 548: d_es_allocation_memoire; 549: return(NULL); 550: } 551: 552: sprintf(chaine, "%s [%s <%s>]", registre, 553: (*((struct_socket *) ((*s_objet).objet))).adresse, 554: tampon); 555: } 556: } 557: else 558: { // Socket distante 559: if ((strcmp((*((struct_socket *) ((*s_objet).objet))).type, 560: "STREAM") == 0) || (strcmp((*((struct_socket *) 561: ((*s_objet).objet))).type, "SEQUENTIAL DATAGRAM") == 0)) 562: { 563: if ((chaine = malloc((strlen(registre) + 9 + 564: strlen((*((struct_socket *) ((*s_objet).objet))) 565: .adresse) + strlen(tampon) 566: + 1) * sizeof(unsigned char))) == NULL) 567: { 568: (*s_etat_processus).erreur_systeme = 569: d_es_allocation_memoire; 570: return(NULL); 571: } 572: 573: sprintf(chaine, "%s [TO %s <%s>]", registre, 574: (*((struct_socket *) ((*s_objet).objet))) 575: .adresse, tampon); 576: } 577: else 578: { 579: if (strcmp((*((struct_socket *) ((*s_objet).objet))) 580: .adresse_distante, "") == 0) 581: { 582: if ((chaine = malloc((strlen(registre) + 5 + 583: strlen(tampon) + 1) * sizeof(unsigned char))) 584: == NULL) 585: { 586: (*s_etat_processus).erreur_systeme = 587: d_es_allocation_memoire; 588: return(NULL); 589: } 590: 591: sprintf(chaine, "%s [<%s>]", registre, tampon); 592: } 593: else 594: { 595: if ((chaine = malloc((strlen(registre) + 9 + 596: strlen((*((struct_socket *) ((*s_objet).objet))) 597: .adresse_distante) + strlen(tampon) 598: + 1) * sizeof(unsigned char))) == NULL) 599: { 600: (*s_etat_processus).erreur_systeme = 601: d_es_allocation_memoire; 602: return(NULL); 603: } 604: 605: sprintf(chaine, "%s [TO %s <%s>]", registre, 606: (*((struct_socket *) ((*s_objet).objet))) 607: .adresse_distante, tampon); 608: } 609: } 610: } 611: 612: free(registre); 613: free(format_majuscule); 614: } 615: else if ((*s_objet).type == ALG) 616: { 617: 618: /* 619: -------------------------------------------------------------------------------- 620: Expression algébrique 621: -------------------------------------------------------------------------------- 622: */ 623: 624: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 625: 626: while(l_element_courant != NULL) 627: { 628: if ((*(*l_element_courant).donnee).type == FCT) 629: { 630: if ((strcmp((*((struct_fonction *) (*(*l_element_courant) 631: .donnee).objet)).nom_fonction, "<<") != 0) && 632: (strcmp((*((struct_fonction *) (*(*l_element_courant) 633: .donnee).objet)).nom_fonction, ">>") != 0)) 634: { 635: if ((strcmp((*((struct_fonction *) (*(*l_element_courant) 636: .donnee).objet)).nom_fonction, "+") == 0) || 637: (strcmp((*((struct_fonction *) 638: (*(*l_element_courant).donnee).objet)) 639: .nom_fonction, "-") == 0) || (strcmp( 640: (*((struct_fonction *) (*(*l_element_courant) 641: .donnee).objet)).nom_fonction, "*") == 0) || 642: (strcmp((*((struct_fonction *) 643: (*(*l_element_courant).donnee).objet)).nom_fonction, 644: "/") == 0) || (strcmp((*((struct_fonction *) 645: (*(*l_element_courant).donnee).objet)).nom_fonction, 646: "^") == 0) || (strcmp((*((struct_fonction *) 647: (*(*l_element_courant).donnee).objet)).nom_fonction, 648: "<") == 0) || (strcmp((*((struct_fonction *) 649: (*(*l_element_courant).donnee).objet)).nom_fonction, 650: ">") == 0) || (strcmp((*((struct_fonction *) 651: (*(*l_element_courant).donnee).objet)).nom_fonction, 652: "==") == 0) || (strcmp((*((struct_fonction *) 653: (*(*l_element_courant).donnee).objet)).nom_fonction, 654: "<>") == 0) || (strcmp((*((struct_fonction *) 655: (*(*l_element_courant).donnee).objet)).nom_fonction, 656: "<=") == 0) || (strcmp((*((struct_fonction *) 657: (*(*l_element_courant).donnee).objet)).nom_fonction, 658: "=<") == 0) || (strcmp((*((struct_fonction *) 659: (*(*l_element_courant).donnee).objet)).nom_fonction, 660: ">=") == 0) || (strcmp((*((struct_fonction *) 661: (*(*l_element_courant).donnee).objet)).nom_fonction, 662: "=>") == 0)) 663: { 664: if (depilement(s_etat_processus, &((*s_etat_processus) 665: .l_base_pile), &s_sous_objet_2) == d_erreur) 666: { 667: return(NULL); 668: } 669: 670: chaine_sauvegarde = (*s_etat_processus) 671: .instruction_courante; 672: 673: if (((*s_etat_processus).instruction_courante = 674: (unsigned char *) malloc((strlen( 675: (unsigned char *) (*s_sous_objet_2).objet) + 2 676: + 1) * sizeof(unsigned char))) == NULL) 677: { 678: (*s_etat_processus).instruction_courante = 679: chaine_sauvegarde; 680: (*s_etat_processus).erreur_systeme = 681: d_es_allocation_memoire; 682: return(NULL); 683: } 684: 685: sprintf((*s_etat_processus).instruction_courante, 686: "'%s'", (unsigned char *) 687: (*s_sous_objet_2).objet); 688: 689: presence_signe = (((*s_etat_processus) 690: .instruction_courante[1] == '+') 691: || ((*s_etat_processus).instruction_courante[1] 692: == '-')) ? d_vrai : d_faux; 693: 694: recherche_type(s_etat_processus); 695: 696: if ((*s_etat_processus).erreur_execution != d_ex) 697: { 698: // Aucune erreur d'exécution ne peut être 699: // retournée, car l'argument est cohérent. 700: 701: return(NULL); 702: } 703: 704: if (depilement(s_etat_processus, &((*s_etat_processus) 705: .l_base_pile), &s_sous_objet_3) == d_erreur) 706: { 707: return(NULL); 708: } 709: 710: free((*s_etat_processus).instruction_courante); 711: 712: (*s_etat_processus).instruction_courante = 713: chaine_sauvegarde; 714: 715: autorisation_parenthese = d_faux; 716: 717: if ((*s_sous_objet_3).type == ALG) 718: { 719: l_atome = (struct_liste_chainee *) 720: (*s_sous_objet_3).objet; 721: chaine_fonction = ""; 722: nombre_arguments_fonction = 0; 723: 724: while(l_atome != NULL) 725: { 726: if ((*(*l_atome).donnee).type == FCT) 727: { 728: if (strcmp((*((struct_fonction *) 729: (*(*l_atome).donnee).objet)) 730: .nom_fonction, ">>") != 0) 731: { 732: chaine_fonction = (*((struct_fonction *) 733: (*(*l_atome).donnee).objet)) 734: .nom_fonction; 735: nombre_arguments_fonction = 736: (*((struct_fonction *) 737: (*(*l_atome).donnee).objet)) 738: .nombre_arguments; 739: } 740: } 741: 742: l_atome = (*l_atome).suivant; 743: } 744: 745: if (strcmp((*((struct_fonction *) 746: (*(*l_element_courant).donnee).objet)) 747: .nom_fonction, "+") == 0) 748: { 749: if ((strcmp(chaine_fonction, "AND") == 0) || 750: (strcmp(chaine_fonction, "XOR") == 0) || 751: (strcmp(chaine_fonction, "OR") == 0)) 752: { 753: autorisation_parenthese = d_vrai; 754: } 755: } 756: else if (strcmp((*((struct_fonction *) 757: (*(*l_element_courant).donnee).objet)) 758: .nom_fonction, "-") == 0) 759: { 760: if (nombre_arguments_fonction != 0) 761: { 762: autorisation_parenthese = d_faux; 763: } 764: else 765: { 766: autorisation_parenthese = d_vrai; 767: } 768: } 769: else if (strcmp((*((struct_fonction *) 770: (*(*l_element_courant).donnee).objet)) 771: .nom_fonction, "*") == 0) 772: { 773: if ((strcmp(chaine_fonction, "+") == 0) || 774: (strcmp(chaine_fonction, "-") == 0) || 775: (strcmp(chaine_fonction, "AND") == 0) || 776: (strcmp(chaine_fonction, "XOR") == 0) || 777: (strcmp(chaine_fonction, "OR") == 0)) 778: { 779: autorisation_parenthese = d_vrai; 780: } 781: } 782: else if (strcmp((*((struct_fonction *) 783: (*(*l_element_courant).donnee).objet)) 784: .nom_fonction, "/") == 0) 785: { 786: if (nombre_arguments_fonction != 0) 787: { 788: autorisation_parenthese = d_faux; 789: } 790: else 791: { 792: autorisation_parenthese = d_vrai; 793: } 794: } 795: else if ((strcmp((*((struct_fonction *) 796: (*(*l_element_courant).donnee).objet)) 797: .nom_fonction, "^") == 0)) 798: { 799: if (nombre_arguments_fonction != 0) 800: { 801: autorisation_parenthese = d_faux; 802: } 803: else 804: { 805: autorisation_parenthese = d_vrai; 806: } 807: } 808: } 809: 810: if ((autorisation_parenthese == d_vrai) || 811: (presence_signe == d_vrai)) 812: { 813: chaine_sauvegarde = (unsigned char *) 814: (*s_sous_objet_2).objet; 815: 816: if (((*s_sous_objet_2).objet = (void *) 817: malloc((strlen(chaine_sauvegarde) + 2 + 1) 818: * sizeof(unsigned char))) == NULL) 819: { 820: (*s_etat_processus).erreur_systeme = 821: d_es_allocation_memoire; 822: return(NULL); 823: } 824: 825: sprintf((unsigned char *) (*s_sous_objet_2).objet, 826: "(%s)", chaine_sauvegarde); 827: free(chaine_sauvegarde); 828: } 829: 830: liberation(s_etat_processus, s_sous_objet_3); 831: 832: if (depilement(s_etat_processus, &((*s_etat_processus) 833: .l_base_pile), &s_sous_objet_1) == d_erreur) 834: { 835: return(NULL); 836: } 837: 838: chaine_sauvegarde = (*s_etat_processus) 839: .instruction_courante; 840: 841: if (((*s_etat_processus).instruction_courante = 842: (unsigned char *) malloc((strlen( 843: (unsigned char *) (*s_sous_objet_1).objet) + 2 844: + 1) * sizeof(unsigned char))) == NULL) 845: { 846: (*s_etat_processus).instruction_courante = 847: chaine_sauvegarde; 848: (*s_etat_processus).erreur_systeme = 849: d_es_allocation_memoire; 850: return(NULL); 851: } 852: 853: sprintf((*s_etat_processus).instruction_courante, 854: "'%s'", (unsigned char *) 855: (*s_sous_objet_1).objet); 856: 857: recherche_type(s_etat_processus); 858: 859: if ((*s_etat_processus).erreur_execution != d_ex) 860: { 861: // Aucune erreur d'exécution ne peut être 862: // retournée, car l'argument est cohérent. 863: 864: return(NULL); 865: } 866: 867: if (depilement(s_etat_processus, &((*s_etat_processus) 868: .l_base_pile), &s_sous_objet_3) == d_erreur) 869: { 870: return(NULL); 871: } 872: 873: free((*s_etat_processus).instruction_courante); 874: 875: (*s_etat_processus).instruction_courante = 876: chaine_sauvegarde; 877: 878: autorisation_parenthese = d_faux; 879: 880: if ((*s_sous_objet_3).type == ALG) 881: { 882: l_atome = (struct_liste_chainee *) 883: (*s_sous_objet_3).objet; 884: chaine_fonction = ""; 885: 886: while(l_atome != NULL) 887: { 888: if ((*(*l_atome).donnee).type == FCT) 889: { 890: if (strcmp((*((struct_fonction *) 891: (*(*l_atome).donnee).objet)) 892: .nom_fonction, ">>") != 0) 893: { 894: chaine_fonction = (*((struct_fonction *) 895: (*(*l_atome).donnee).objet)) 896: .nom_fonction; 897: } 898: } 899: 900: l_atome = (*l_atome).suivant; 901: } 902: 903: if ((strcmp((*((struct_fonction *) 904: (*(*l_element_courant).donnee).objet)) 905: .nom_fonction, "+") == 0) || 906: (strcmp((*((struct_fonction *) 907: (*(*l_element_courant).donnee).objet)) 908: .nom_fonction, "-") == 0)) 909: { 910: if ((strcmp(chaine_fonction, "AND") == 0) || 911: (strcmp(chaine_fonction, "XOR") == 0) || 912: (strcmp(chaine_fonction, "OR") == 0)) 913: { 914: autorisation_parenthese = d_vrai; 915: } 916: } 917: else if ((strcmp((*((struct_fonction *) 918: (*(*l_element_courant).donnee).objet)) 919: .nom_fonction, "*") == 0) || 920: (strcmp((*((struct_fonction *) 921: (*(*l_element_courant).donnee).objet)) 922: .nom_fonction, "/") == 0)) 923: { 924: if ((strcmp(chaine_fonction, "+") == 0) || 925: (strcmp(chaine_fonction, "-") == 0) || 926: (strcmp(chaine_fonction, "AND") == 0) || 927: (strcmp(chaine_fonction, "XOR") == 0) || 928: (strcmp(chaine_fonction, "OR") == 0)) 929: { 930: autorisation_parenthese = d_vrai; 931: } 932: } 933: else if ((strcmp((*((struct_fonction *) 934: (*(*l_element_courant).donnee).objet)) 935: .nom_fonction, "^") == 0)) 936: { 937: autorisation_parenthese = d_vrai; 938: } 939: } 940: 941: if (autorisation_parenthese == d_vrai) 942: { 943: chaine_sauvegarde = (unsigned char *) 944: (*s_sous_objet_1).objet; 945: 946: if (((*s_sous_objet_1).objet = (void *) 947: malloc((strlen(chaine_sauvegarde) + 2 + 1) 948: * sizeof(unsigned char))) == NULL) 949: { 950: (*s_etat_processus).erreur_systeme = 951: d_es_allocation_memoire; 952: return(NULL); 953: } 954: 955: sprintf((unsigned char *) (*s_sous_objet_1).objet, 956: "(%s)", chaine_sauvegarde); 957: free(chaine_sauvegarde); 958: } 959: 960: liberation(s_etat_processus, s_sous_objet_3); 961: 962: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 963: == NULL) 964: { 965: (*s_etat_processus).erreur_systeme = 966: d_es_allocation_memoire; 967: return(NULL); 968: } 969: 970: if (((*s_sous_objet).objet = (void *) malloc((strlen( 971: (unsigned char *) (*s_sous_objet_1).objet) + 972: strlen((*((struct_fonction *) 973: (*(*l_element_courant).donnee).objet)) 974: .nom_fonction) + strlen((unsigned char *) 975: (*s_sous_objet_2).objet) + 1) * 976: sizeof(unsigned char))) == NULL) 977: { 978: (*s_etat_processus).erreur_systeme = 979: d_es_allocation_memoire; 980: return(NULL); 981: } 982: 983: sprintf((unsigned char *) (*s_sous_objet).objet, 984: "%s%s%s", (unsigned char *) 985: (*s_sous_objet_1) 986: .objet, (*((struct_fonction *) 987: (*(*l_element_courant).donnee).objet)) 988: .nom_fonction, (unsigned char *) 989: (*s_sous_objet_2).objet); 990: 991: liberation(s_etat_processus, s_sous_objet_1); 992: liberation(s_etat_processus, s_sous_objet_2); 993: 994: if (empilement(s_etat_processus, &((*s_etat_processus) 995: .l_base_pile), s_sous_objet) == d_erreur) 996: { 997: return(NULL); 998: } 999: } 1000: else if (strcmp((*((struct_fonction *) 1001: (*(*l_element_courant).donnee).objet)).nom_fonction, 1002: "=") == 0) 1003: { 1004: if (depilement(s_etat_processus, &((*s_etat_processus) 1005: .l_base_pile), &s_sous_objet_2) == d_erreur) 1006: { 1007: return(NULL); 1008: } 1009: 1010: if (depilement(s_etat_processus, &((*s_etat_processus) 1011: .l_base_pile), &s_sous_objet_1) == d_erreur) 1012: { 1013: return(NULL); 1014: } 1015: 1016: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1017: == NULL) 1018: { 1019: (*s_etat_processus).erreur_systeme = 1020: d_es_allocation_memoire; 1021: return(NULL); 1022: } 1023: 1024: autorisation_parenthese = d_vrai; 1025: l_atome = l_element_courant; 1026: 1027: if (l_atome != NULL) 1028: { 1029: if ((*l_atome).suivant != NULL) 1030: { 1031: l_atome = (*l_atome).suivant; 1032: 1033: if ((*(*l_atome).donnee).type == FCT) 1034: { 1035: if (strcmp((*((struct_fonction *) 1036: (*(*l_atome).donnee).objet)) 1037: .nom_fonction, ">>") == 0) 1038: { 1039: if ((*l_atome).suivant == NULL) 1040: { 1041: autorisation_parenthese = d_faux; 1042: } 1043: } 1044: } 1045: } 1046: } 1047: 1048: if (autorisation_parenthese == d_vrai) 1049: { 1050: if (((*s_sous_objet).objet = 1051: (void *) malloc((strlen( 1052: (unsigned char *) (*s_sous_objet_1).objet) + 1053: strlen((*((struct_fonction *) 1054: (*(*l_element_courant).donnee).objet)) 1055: .nom_fonction) + strlen((unsigned char *) 1056: (*s_sous_objet_2).objet) + 2 + 1) * 1057: sizeof(unsigned char))) == NULL) 1058: { 1059: (*s_etat_processus).erreur_systeme = 1060: d_es_allocation_memoire; 1061: return(NULL); 1062: } 1063: 1064: sprintf((unsigned char *) (*s_sous_objet).objet, 1065: "(%s%s%s)", (unsigned char *) 1066: (*s_sous_objet_1) 1067: .objet, (*((struct_fonction *) 1068: (*(*l_element_courant).donnee).objet)) 1069: .nom_fonction, (unsigned char *) 1070: (*s_sous_objet_2).objet); 1071: } 1072: else 1073: { 1074: if (((*s_sous_objet).objet = 1075: (void *) malloc((strlen( 1076: (unsigned char *) (*s_sous_objet_1).objet) + 1077: strlen((*((struct_fonction *) 1078: (*(*l_element_courant).donnee).objet)) 1079: .nom_fonction) + strlen((unsigned char *) 1080: (*s_sous_objet_2).objet) + 1) * 1081: sizeof(unsigned char))) == NULL) 1082: { 1083: (*s_etat_processus).erreur_systeme = 1084: d_es_allocation_memoire; 1085: return(NULL); 1086: } 1087: 1088: sprintf((unsigned char *) (*s_sous_objet).objet, 1089: "%s%s%s", (unsigned char *) 1090: (*s_sous_objet_1) 1091: .objet, (*((struct_fonction *) 1092: (*(*l_element_courant).donnee).objet)) 1093: .nom_fonction, (unsigned char *) 1094: (*s_sous_objet_2).objet); 1095: } 1096: 1097: liberation(s_etat_processus, s_sous_objet_1); 1098: liberation(s_etat_processus, s_sous_objet_2); 1099: 1100: if (empilement(s_etat_processus, &((*s_etat_processus) 1101: .l_base_pile), s_sous_objet) == d_erreur) 1102: { 1103: return(NULL); 1104: } 1105: } 1106: else if (strcmp((*((struct_fonction *) 1107: (*(*l_element_courant).donnee).objet)).nom_fonction, 1108: "NOT") == 0) 1109: { 1110: if (depilement(s_etat_processus, &((*s_etat_processus) 1111: .l_base_pile), &s_sous_objet_1) == d_erreur) 1112: { 1113: return(NULL); 1114: } 1115: 1116: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1117: == NULL) 1118: { 1119: (*s_etat_processus).erreur_systeme = 1120: d_es_allocation_memoire; 1121: return(NULL); 1122: } 1123: 1124: if (((*s_sous_objet).objet = (unsigned char *) malloc( 1125: (strlen((unsigned char *) (*s_sous_objet_1) 1126: .objet) + 5 + 1) * sizeof(unsigned char))) == 1127: NULL) 1128: { 1129: (*s_etat_processus).erreur_systeme = 1130: d_es_allocation_memoire; 1131: return(NULL); 1132: } 1133: 1134: sprintf((unsigned char *) (*s_sous_objet).objet, 1135: "%s(%s)", (*((struct_fonction *) 1136: (*(*l_element_courant).donnee).objet)) 1137: .nom_fonction, (unsigned char *) 1138: (*s_sous_objet_1).objet ); 1139: 1140: liberation(s_etat_processus, s_sous_objet_1); 1141: 1142: if (empilement(s_etat_processus, &((*s_etat_processus) 1143: .l_base_pile), s_sous_objet) == d_erreur) 1144: { 1145: return(NULL); 1146: } 1147: } 1148: else if ((strcmp((*((struct_fonction *) 1149: (*(*l_element_courant).donnee).objet)).nom_fonction, 1150: "OR") == 0) || (strcmp((*((struct_fonction *) 1151: (*(*l_element_courant).donnee).objet)).nom_fonction, 1152: "XOR") == 0) || (strcmp((*((struct_fonction *) 1153: (*(*l_element_courant).donnee).objet)).nom_fonction, 1154: "AND") == 0)) 1155: { 1156: if (depilement(s_etat_processus, &((*s_etat_processus) 1157: .l_base_pile), &s_sous_objet_2) == d_erreur) 1158: { 1159: return(NULL); 1160: } 1161: 1162: if (depilement(s_etat_processus, &((*s_etat_processus) 1163: .l_base_pile), &s_sous_objet_1) == d_erreur) 1164: { 1165: return(NULL); 1166: } 1167: 1168: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1169: == NULL) 1170: { 1171: (*s_etat_processus).erreur_systeme = 1172: d_es_allocation_memoire; 1173: return(NULL); 1174: } 1175: 1176: parentheses_groupe_gauche = 0; 1177: parentheses_groupe_droit = 0; 1178: 1179: chaine_sauvegarde = (*s_etat_processus) 1180: .instruction_courante; 1181: 1182: if (((*s_etat_processus).instruction_courante = 1183: (unsigned char *) malloc((strlen( 1184: (unsigned char *) (*s_sous_objet_1).objet) + 2 1185: + 1) * sizeof(unsigned char))) == NULL) 1186: { 1187: (*s_etat_processus).instruction_courante = 1188: chaine_sauvegarde; 1189: (*s_etat_processus).erreur_systeme = 1190: d_es_allocation_memoire; 1191: return(NULL); 1192: } 1193: 1194: sprintf((*s_etat_processus).instruction_courante, 1195: "'%s'", (unsigned char *) 1196: (*s_sous_objet_1).objet); 1197: 1198: recherche_type(s_etat_processus); 1199: 1200: if ((*s_etat_processus).erreur_execution != d_ex) 1201: { 1202: // Aucune erreur d'exécution ne peut être 1203: // retournée, car l'argument est cohérent. 1204: 1205: return(NULL); 1206: } 1207: 1208: if (depilement(s_etat_processus, &((*s_etat_processus) 1209: .l_base_pile), &s_sous_objet_3) == d_erreur) 1210: { 1211: return(NULL); 1212: } 1213: 1214: free((*s_etat_processus).instruction_courante); 1215: 1216: (*s_etat_processus).instruction_courante = 1217: chaine_sauvegarde; 1218: 1219: if ((*s_sous_objet_3).type == ALG) 1220: { 1221: l_atome = (struct_liste_chainee *) 1222: (*s_sous_objet_3).objet; 1223: chaine_fonction = ""; 1224: 1225: while(l_atome != NULL) 1226: { 1227: if ((*(*l_atome).donnee).type == FCT) 1228: { 1229: if (strcmp((*((struct_fonction *) 1230: (*(*l_atome).donnee).objet)) 1231: .nom_fonction, ">>") != 0) 1232: { 1233: chaine_fonction = (*((struct_fonction *) 1234: (*(*l_atome).donnee).objet)) 1235: .nom_fonction; 1236: } 1237: } 1238: 1239: l_atome = (*l_atome).suivant; 1240: } 1241: 1242: if (((strcmp(chaine_fonction, "OR") == 0) || 1243: (strcmp(chaine_fonction, "XOR") == 0)) && 1244: (strcmp((*((struct_fonction *) 1245: (*(*l_element_courant).donnee).objet)) 1246: .nom_fonction, "AND") == 0)) 1247: { 1248: parentheses_groupe_gauche = 2; 1249: } 1250: } 1251: 1252: liberation(s_etat_processus, s_sous_objet_3); 1253: 1254: chaine_sauvegarde = (*s_etat_processus) 1255: .instruction_courante; 1256: 1257: if (((*s_etat_processus).instruction_courante = 1258: (unsigned char *) malloc((strlen( 1259: (unsigned char *) (*s_sous_objet_2).objet) + 2 1260: + 1) * sizeof(unsigned char))) == NULL) 1261: { 1262: (*s_etat_processus).instruction_courante = 1263: chaine_sauvegarde; 1264: (*s_etat_processus).erreur_systeme = 1265: d_es_allocation_memoire; 1266: return(NULL); 1267: } 1268: 1269: sprintf((*s_etat_processus).instruction_courante, 1270: "'%s'", (unsigned char *) 1271: (*s_sous_objet_2).objet); 1272: 1273: recherche_type(s_etat_processus); 1274: 1275: if ((*s_etat_processus).erreur_execution != d_ex) 1276: { 1277: // Aucune erreur d'exécution ne peut être 1278: // retournée, car l'argument est cohérent. 1279: 1280: return(NULL); 1281: } 1282: 1283: if (depilement(s_etat_processus, &((*s_etat_processus) 1284: .l_base_pile), &s_sous_objet_3) == d_erreur) 1285: { 1286: return(NULL); 1287: } 1288: 1289: free((*s_etat_processus).instruction_courante); 1290: 1291: (*s_etat_processus).instruction_courante = 1292: chaine_sauvegarde; 1293: 1294: if ((*s_sous_objet_3).type == ALG) 1295: { 1296: l_atome = (struct_liste_chainee *) 1297: (*s_sous_objet_3).objet; 1298: chaine_fonction = ""; 1299: 1300: while(l_atome != NULL) 1301: { 1302: if ((*(*l_atome).donnee).type == FCT) 1303: { 1304: if (strcmp((*((struct_fonction *) 1305: (*(*l_atome).donnee).objet)) 1306: .nom_fonction, ">>") != 0) 1307: { 1308: chaine_fonction = (*((struct_fonction *) 1309: (*(*l_atome).donnee).objet)) 1310: .nom_fonction; 1311: } 1312: } 1313: 1314: l_atome = (*l_atome).suivant; 1315: } 1316: 1317: if (((strcmp(chaine_fonction, "OR") == 0) || 1318: (strcmp(chaine_fonction, "XOR") == 0)) && 1319: (strcmp((*((struct_fonction *) 1320: (*(*l_element_courant).donnee).objet)) 1321: .nom_fonction, "AND") == 0)) 1322: { 1323: parentheses_groupe_droit = 2; 1324: } 1325: } 1326: 1327: liberation(s_etat_processus, s_sous_objet_3); 1328: 1329: if (((*s_sous_objet).objet = (void *) malloc((strlen( 1330: (unsigned char *) (*s_sous_objet_1).objet) + 1331: strlen((*((struct_fonction *) 1332: (*(*l_element_courant).donnee).objet)) 1333: .nom_fonction) + strlen((unsigned char *) 1334: (*s_sous_objet_2).objet) + 2 + 1 + 1335: parentheses_groupe_gauche + 1336: parentheses_groupe_droit) * 1337: sizeof(unsigned char))) == NULL) 1338: { 1339: (*s_etat_processus).erreur_systeme = 1340: d_es_allocation_memoire; 1341: return(NULL); 1342: } 1343: 1344: sprintf((unsigned char *) (*s_sous_objet).objet, 1345: (parentheses_groupe_gauche == 0) 1346: ? ((parentheses_groupe_droit == 0) 1347: ? "%s %s %s" 1348: : "%s %s (%s)") 1349: : ((parentheses_groupe_droit == 0) 1350: ? "(%s) %s %s" 1351: : "(%s) %s (%s)"), 1352: (unsigned char *) (*s_sous_objet_1) 1353: .objet, (*((struct_fonction *) 1354: (*(*l_element_courant).donnee).objet)) 1355: .nom_fonction, (unsigned char *) 1356: (*s_sous_objet_2).objet); 1357: 1358: liberation(s_etat_processus, s_sous_objet_1); 1359: liberation(s_etat_processus, s_sous_objet_2); 1360: 1361: if (empilement(s_etat_processus, &((*s_etat_processus) 1362: .l_base_pile), s_sous_objet) == d_erreur) 1363: { 1364: (*s_etat_processus).erreur_systeme = 1365: d_es_allocation_memoire; 1366: return(NULL); 1367: } 1368: } 1369: else 1370: { 1371: nombre_arguments = (*((struct_fonction *) 1372: (*(*l_element_courant).donnee).objet)) 1373: .nombre_arguments; 1374: 1375: if ((chaine = (unsigned char *) 1376: malloc(sizeof(unsigned char))) == NULL) 1377: { 1378: (*s_etat_processus).erreur_systeme = 1379: d_es_allocation_memoire; 1380: return(NULL); 1381: } 1382: 1383: chaine[0] = d_code_fin_chaine; 1384: 1385: for(i = 0; i < nombre_arguments; i++) 1386: { 1387: if ((nombre_arguments - i) > 1) 1388: { 1389: l_liste1 = (*s_etat_processus).l_base_pile; 1390: 1391: for(j = 2; j < (nombre_arguments - i); j++) 1392: { 1393: l_liste1 = (*l_liste1).suivant; 1394: } 1395: 1396: l_liste2 = (*l_liste1).suivant; 1397: (*l_liste1).suivant = (*l_liste2).suivant; 1398: (*l_liste2).suivant = (*s_etat_processus) 1399: .l_base_pile; 1400: (*s_etat_processus).l_base_pile = l_liste2; 1401: } 1402: 1403: if (depilement(s_etat_processus, 1404: &((*s_etat_processus).l_base_pile), 1405: &s_sous_objet) == d_erreur) 1406: { 1407: return(NULL); 1408: } 1409: 1410: chaine_sauvegarde = chaine; 1411: 1412: if (strlen(chaine_sauvegarde) == 0) 1413: { 1414: if ((chaine = (unsigned char *) malloc((strlen( 1415: (unsigned char *) (*s_sous_objet).objet) 1416: + 1) * sizeof(unsigned char))) == NULL) 1417: { 1418: (*s_etat_processus).erreur_systeme = 1419: d_es_allocation_memoire; 1420: return(NULL); 1421: } 1422: 1423: sprintf(chaine, "%s", (unsigned char *) 1424: (*s_sous_objet).objet); 1425: } 1426: else 1427: { 1428: if ((chaine = (unsigned char *) malloc((strlen( 1429: chaine_sauvegarde) + 1 + strlen( 1430: (unsigned char *) (*s_sous_objet).objet) 1431: + 1) * sizeof(unsigned char))) == NULL) 1432: { 1433: (*s_etat_processus).erreur_systeme = 1434: d_es_allocation_memoire; 1435: return(NULL); 1436: } 1437: 1438: sprintf(chaine, "%s,%s", chaine_sauvegarde, 1439: (unsigned char *) (*s_sous_objet) 1440: .objet); 1441: } 1442: 1443: free(chaine_sauvegarde); 1444: liberation(s_etat_processus, s_sous_objet); 1445: } 1446: 1447: chaine_sauvegarde = chaine; 1448: 1449: if ((chaine = (unsigned char *) malloc((strlen( 1450: (*((struct_fonction *) (*(*l_element_courant) 1451: .donnee).objet)).nom_fonction) + 2 + 1452: strlen(chaine_sauvegarde) + 1) * 1453: sizeof(unsigned char))) == NULL) 1454: { 1455: (*s_etat_processus).erreur_systeme = 1456: d_es_allocation_memoire; 1457: return(NULL); 1458: } 1459: 1460: sprintf(chaine, "%s(%s)", (*((struct_fonction *) 1461: (*(*l_element_courant).donnee).objet)) 1462: .nom_fonction, chaine_sauvegarde); 1463: free(chaine_sauvegarde); 1464: 1465: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1466: == NULL) 1467: { 1468: (*s_etat_processus).erreur_systeme = 1469: d_es_allocation_memoire; 1470: return(NULL); 1471: } 1472: 1473: (*s_sous_objet).objet = (void *) chaine; 1474: 1475: if (empilement(s_etat_processus, &((*s_etat_processus) 1476: .l_base_pile), s_sous_objet) == d_erreur) 1477: { 1478: return(NULL); 1479: } 1480: } 1481: } 1482: } 1483: else 1484: { 1485: if ((s_sous_objet = allocation(s_etat_processus, CHN)) 1486: == NULL) 1487: { 1488: (*s_etat_processus).erreur_systeme = 1489: d_es_allocation_memoire; 1490: return(NULL); 1491: } 1492: 1493: if (((*s_sous_objet).objet = (void *) formateur( 1494: s_etat_processus, 0, (*l_element_courant).donnee)) 1495: == NULL) 1496: { 1497: (*s_etat_processus).erreur_systeme = 1498: d_es_allocation_memoire; 1499: return(NULL); 1500: } 1501: 1502: if (((*(*l_element_courant).donnee).type == ALG) 1503: || (((*(*l_element_courant).donnee).type == NOM) 1504: && ((*((struct_nom *) (*(*l_element_courant) 1505: .donnee).objet)).symbole == d_vrai))) 1506: { 1507: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet; 1508: 1509: if (((*s_sous_objet).objet = malloc((strlen( 1510: chaine_sauvegarde) - 1) * 1511: sizeof(unsigned char))) == NULL) 1512: { 1513: (*s_etat_processus).erreur_systeme = 1514: d_es_allocation_memoire; 1515: return(NULL); 1516: } 1517: 1518: ptrl = chaine_sauvegarde; 1519: ptre = (unsigned char *) (*s_sous_objet).objet; 1520: 1521: for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0; 1522: i--, *ptre++ = *ptrl++); 1523: 1524: (*ptre) = d_code_fin_chaine; 1525: 1526: free(chaine_sauvegarde); 1527: } 1528: else if ((*(*l_element_courant).donnee).type == CHN) 1529: { 1530: chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet; 1531: 1532: if (((*s_sous_objet).objet = malloc((strlen( 1533: chaine_sauvegarde) + 3) * 1534: sizeof(unsigned char))) == NULL) 1535: { 1536: (*s_etat_processus).erreur_systeme = 1537: d_es_allocation_memoire; 1538: return(NULL); 1539: } 1540: 1541: sprintf((unsigned char *) (*s_sous_objet).objet, 1542: "\"%s\"", chaine_sauvegarde); 1543: 1544: free(chaine_sauvegarde); 1545: } 1546: 1547: if (empilement(s_etat_processus, &((*s_etat_processus) 1548: .l_base_pile), s_sous_objet) == d_erreur) 1549: { 1550: return(NULL); 1551: } 1552: } 1553: 1554: l_element_courant = (*l_element_courant).suivant; 1555: } 1556: 1557: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1558: &s_sous_objet) == d_erreur) 1559: { 1560: return(NULL); 1561: } 1562: 1563: if ((chaine = (unsigned char *) malloc((strlen((unsigned char *) 1564: (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char))) 1565: == NULL) 1566: { 1567: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1568: return(NULL); 1569: } 1570: 1571: sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet); 1572: liberation(s_etat_processus, s_sous_objet); 1573: } 1574: else if ((*s_objet).type == BIN) 1575: { 1576: 1577: /* 1578: -------------------------------------------------------------------------------- 1579: Entier binaire en base 2, 8, 10 ou 16 1580: -------------------------------------------------------------------------------- 1581: */ 1582: 1583: longueur_binaire = longueur_entiers_binaires(s_etat_processus); 1584: masque_binaire = masque_entiers_binaires(s_etat_processus); 1585: 1586: if ((test_cfsf(s_etat_processus, 43) == d_faux) && 1587: (test_cfsf(s_etat_processus, 44) == d_faux)) 1588: { 1589: 1590: /* 1591: -- Base décimale --------------------------------------------------------------- 1592: */ 1593: 1594: sprintf(tampon, "%llu", (*((logical8 *) 1595: ((*s_objet).objet))) & masque_binaire); 1596: strcpy(base, "d"); 1597: } 1598: else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && 1599: (test_cfsf(s_etat_processus, 44) == d_faux)) 1600: { 1601: 1602: /* 1603: -- Base octale ----------------------------------------------------------------- 1604: */ 1605: 1606: sprintf(tampon, "%llo", (*((logical8 *) 1607: ((*s_objet).objet))) & masque_binaire); 1608: strcpy(base, "o"); 1609: } 1610: else if (test_cfsf(s_etat_processus, 44) == d_vrai) 1611: { 1612: 1613: /* 1614: -- Bases hexadécimale et binaire ----------------------------------------------- 1615: */ 1616: 1617: sprintf(tampon, "%llX", (*((logical8 *) 1618: ((*s_objet).objet))) & masque_binaire); 1619: 1620: if (test_cfsf(s_etat_processus, 43) == d_vrai) 1621: { 1622: strcpy(base, "h"); 1623: } 1624: else 1625: { 1626: chaine = (unsigned char *) malloc((strlen(tampon) + 1) 1627: * sizeof(unsigned char)); 1628: 1629: if (chaine == NULL) 1630: { 1631: (*s_etat_processus).erreur_systeme = 1632: d_es_allocation_memoire; 1633: return(NULL); 1634: } 1635: 1636: strcpy(chaine, tampon); 1637: tampon[0] = 0; 1638: 1639: for(i = 0; i < strlen(chaine); i++) 1640: { 1641: switch(chaine[i]) 1642: { 1643: case '0' : 1644: { 1645: strcat(tampon, (i != 0) ? "0000" : "0"); 1646: break; 1647: } 1648: case '1' : 1649: { 1650: strcat(tampon, (i != 0) ? "0001" : "1"); 1651: break; 1652: } 1653: case '2' : 1654: { 1655: strcat(tampon, (i != 0) ? "0010" : "10"); 1656: break; 1657: } 1658: case '3' : 1659: { 1660: strcat(tampon, (i != 0) ? "0011" : "11"); 1661: break; 1662: } 1663: case '4' : 1664: { 1665: strcat(tampon, (i != 0) ? "0100" : "100"); 1666: break; 1667: } 1668: case '5' : 1669: { 1670: strcat(tampon, (i != 0) ? "0101" : "101"); 1671: break; 1672: } 1673: case '6' : 1674: { 1675: strcat(tampon, (i != 0) ? "0110" : "110"); 1676: break; 1677: } 1678: case '7' : 1679: { 1680: strcat(tampon, (i != 0) ? "0111" : "111"); 1681: break; 1682: } 1683: case '8' : 1684: { 1685: strcat(tampon, "1000"); 1686: break; 1687: } 1688: case '9' : 1689: { 1690: strcat(tampon, "1001"); 1691: break; 1692: } 1693: case 'A' : 1694: { 1695: strcat(tampon, "1010"); 1696: break; 1697: } 1698: case 'B' : 1699: { 1700: strcat(tampon, "1011"); 1701: break; 1702: } 1703: case 'C' : 1704: { 1705: strcat(tampon, "1100"); 1706: break; 1707: } 1708: case 'D' : 1709: { 1710: strcat(tampon, "1101"); 1711: break; 1712: } 1713: case 'E' : 1714: { 1715: strcat(tampon, "1110"); 1716: break; 1717: } 1718: case 'F' : 1719: { 1720: strcat(tampon, "1111"); 1721: break; 1722: } 1723: } 1724: } 1725: 1726: free(chaine); 1727: strcpy(base, "b"); 1728: } 1729: } 1730: 1731: chaine = (unsigned char *) malloc((strlen(tampon) + 4) 1732: * sizeof(unsigned char)); 1733: 1734: if (chaine == NULL) 1735: { 1736: (*s_etat_processus).erreur_systeme = 1737: d_es_allocation_memoire; 1738: return(NULL); 1739: } 1740: 1741: strcpy(chaine, "# "); 1742: 1743: strcat(chaine, tampon); 1744: strcat(chaine, base); 1745: } 1746: else if ((*s_objet).type == CHN) 1747: { 1748: 1749: /* 1750: -------------------------------------------------------------------------------- 1751: Chaîne de caractères 1752: -------------------------------------------------------------------------------- 1753: */ 1754: 1755: if ((chaine = malloc((strlen((unsigned char *) 1756: ((*s_objet).objet)) + 1) * sizeof(unsigned char))) == NULL) 1757: { 1758: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1759: return(NULL); 1760: } 1761: 1762: if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') && 1763: (test_cfsf(s_etat_processus, 34) == d_vrai)) 1764: { 1765: ptr_lecture = (unsigned char *) (*s_objet).objet; 1766: ptr_ecriture = chaine; 1767: 1768: while((*ptr_lecture) != d_code_fin_chaine) 1769: { 1770: (*ptr_ecriture) = (*ptr_lecture); 1771: 1772: // Début de la séquence d'échappement 1773: 1774: if ((*ptr_lecture) == '\\') 1775: { 1776: if ((*(ptr_lecture + 1)) == '"') 1777: { 1778: ptr_lecture++; 1779: (*ptr_ecriture) = '\"'; 1780: } 1781: else if ((*(ptr_lecture + 1)) == 'b') 1782: { 1783: ptr_lecture++; 1784: (*ptr_ecriture) = '\b'; 1785: } 1786: else if ((*(ptr_lecture + 1)) == 'n') 1787: { 1788: ptr_lecture++; 1789: (*ptr_ecriture) = '\n'; 1790: } 1791: else if ((*(ptr_lecture + 1)) == 't') 1792: { 1793: ptr_lecture++; 1794: (*ptr_ecriture) = '\t'; 1795: } 1796: else if ((*(ptr_lecture + 1)) == 'x') 1797: { 1798: ptr_lecture += 2; 1799: 1800: if ((*ptr_lecture) != d_code_fin_chaine) 1801: { 1802: if ((*(ptr_lecture + 1)) != d_code_fin_chaine) 1803: { 1804: logical1 erreur; 1805: unsigned char ec; 1806: 1807: erreur = d_faux; 1808: 1809: switch(*ptr_lecture) 1810: { 1811: case '0': 1812: case '1': 1813: case '2': 1814: case '3': 1815: case '4': 1816: case '5': 1817: case '6': 1818: case '7': 1819: case '8': 1820: case '9': 1821: ec = (*ptr_lecture) - '0'; 1822: break; 1823: 1824: case 'A': 1825: case 'B': 1826: case 'C': 1827: case 'D': 1828: case 'E': 1829: case 'F': 1830: ec = ((*ptr_lecture) - 'A') + 10; 1831: break; 1832: 1833: default: 1834: ec = 0; 1835: erreur = d_vrai; 1836: break; 1837: } 1838: 1839: ec *= 0x10; 1840: ptr_lecture++; 1841: 1842: switch(*ptr_lecture) 1843: { 1844: case '0': 1845: case '1': 1846: case '2': 1847: case '3': 1848: case '4': 1849: case '5': 1850: case '6': 1851: case '7': 1852: case '8': 1853: case '9': 1854: ec += (*ptr_lecture) - '0'; 1855: break; 1856: 1857: case 'A': 1858: case 'B': 1859: case 'C': 1860: case 'D': 1861: case 'E': 1862: case 'F': 1863: ec += ((*ptr_lecture) - 'A') + 10; 1864: break; 1865: 1866: default: 1867: erreur = d_vrai; 1868: break; 1869: } 1870: 1871: (*ptr_ecriture) = ec; 1872: 1873: if (erreur == d_vrai) 1874: { 1875: if ((*s_etat_processus).langue == 'F') 1876: { 1877: printf("+++Information : " 1878: "Séquence d'échappement " 1879: "inconnue [%d]\n", 1880: (int) getpid()); 1881: } 1882: else 1883: { 1884: printf("+++Warning : Unknown " 1885: "escape code " 1886: "[%d]\n", (int) getpid()); 1887: } 1888: } 1889: } 1890: else 1891: { 1892: if ((*s_etat_processus).langue == 'F') 1893: { 1894: printf("+++Information : " 1895: "Séquence d'échappement " 1896: "inconnue [%d]\n", (int) getpid()); 1897: } 1898: else 1899: { 1900: printf("+++Warning : Unknown escape code " 1901: "[%d]\n", (int) getpid()); 1902: } 1903: } 1904: } 1905: else 1906: { 1907: if ((*s_etat_processus).langue == 'F') 1908: { 1909: printf("+++Information : " 1910: "Séquence d'échappement " 1911: "inconnue [%d]\n", (int) getpid()); 1912: } 1913: else 1914: { 1915: printf("+++Warning : Unknown escape code " 1916: "[%d]\n", (int) getpid()); 1917: } 1918: } 1919: } 1920: else if ((*(ptr_lecture + 1)) == '\\') 1921: { 1922: ptr_lecture++; 1923: } 1924: else 1925: { 1926: if ((*s_etat_processus).langue == 'F') 1927: { 1928: printf("+++Information : Séquence d'échappement " 1929: "inconnue [%d]\n", (int) getpid()); 1930: } 1931: else 1932: { 1933: printf("+++Warning : Unknown escape code " 1934: "[%d]\n", (int) getpid()); 1935: } 1936: } 1937: } 1938: 1939: ptr_ecriture++; 1940: ptr_lecture++; 1941: } 1942: 1943: (*ptr_ecriture) = d_code_fin_chaine; 1944: 1945: if ((chaine = realloc(chaine, ((ptr_ecriture - chaine) + 1) * 1946: sizeof(unsigned char))) == NULL) 1947: { 1948: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1949: return(NULL); 1950: } 1951: } 1952: else 1953: { 1954: strcpy(chaine, (unsigned char *) ((*s_objet).objet)); 1955: } 1956: } 1957: else if ((*s_objet).type == CPL) 1958: { 1959: 1960: /* 1961: -------------------------------------------------------------------------------- 1962: Complexe 1963: -------------------------------------------------------------------------------- 1964: */ 1965: 1966: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 1967: ((struct_complexe16 *) ((*s_objet).objet)), 'C'); 1968: 1969: if (chaine_formatee == NULL) 1970: { 1971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1972: return(NULL); 1973: } 1974: 1975: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 1976: + 1) * sizeof(unsigned char)); 1977: 1978: if (chaine == NULL) 1979: { 1980: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1981: return(NULL); 1982: } 1983: 1984: strcpy(chaine, chaine_formatee); 1985: free(chaine_formatee); 1986: } 1987: else if ((*s_objet).type == RPN) 1988: { 1989: 1990: /* 1991: -------------------------------------------------------------------------------- 1992: Définition 1993: -------------------------------------------------------------------------------- 1994: */ 1995: 1996: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 1997: chaine_sauvegarde = chaine; 1998: 1999: while(l_element_courant != NULL) 2000: { 2001: if ((chaine_formatee = formateur(s_etat_processus, 0, 2002: (*l_element_courant).donnee)) == NULL) 2003: { 2004: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2005: return(NULL); 2006: } 2007: 2008: if ((*(*l_element_courant).donnee).type == CHN) 2009: { 2010: chaine_tampon = chaine_formatee; 2011: 2012: if ((chaine_formatee = (unsigned char *) malloc((strlen( 2013: chaine_tampon) + 3) * sizeof(unsigned char))) == NULL) 2014: { 2015: (*s_etat_processus).erreur_systeme = 2016: d_es_allocation_memoire; 2017: return(NULL); 2018: } 2019: 2020: sprintf(chaine_formatee, "\"%s\"", chaine_tampon); 2021: free(chaine_tampon); 2022: } 2023: 2024: l_element_courant = (*l_element_courant).suivant; 2025: 2026: if (chaine != NULL) 2027: { 2028: chaine_sauvegarde = chaine; 2029: 2030: if ((chaine = (unsigned char *) malloc((strlen( 2031: chaine_sauvegarde) + strlen(chaine_formatee) + 2) * 2032: sizeof(unsigned char))) == NULL) 2033: { 2034: (*s_etat_processus).erreur_systeme = 2035: d_es_allocation_memoire; 2036: return(NULL); 2037: } 2038: 2039: strcpy(chaine, chaine_sauvegarde); 2040: free(chaine_sauvegarde); 2041: strcat(chaine, " "); 2042: strcat(chaine, chaine_formatee); 2043: free(chaine_formatee); 2044: } 2045: else 2046: { 2047: chaine = chaine_formatee; 2048: } 2049: } 2050: 2051: chaine_sauvegarde = chaine; 2052: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) * 2053: sizeof(unsigned char)); 2054: 2055: if (chaine == NULL) 2056: { 2057: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2058: return(NULL); 2059: } 2060: 2061: chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine; 2062: strcpy(chaine, chaine_sauvegarde); 2063: free(chaine_sauvegarde); 2064: } 2065: else if ((*s_objet).type == INT) 2066: { 2067: 2068: /* 2069: -------------------------------------------------------------------------------- 2070: Entier 2071: -------------------------------------------------------------------------------- 2072: */ 2073: 2074: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 2075: ((integer8 *) ((*s_objet).objet)), 'I'); 2076: 2077: if (chaine_formatee == NULL) 2078: { 2079: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2080: return(NULL); 2081: } 2082: 2083: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) 2084: * sizeof(unsigned char)); 2085: 2086: if (chaine == NULL) 2087: { 2088: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2089: return(NULL); 2090: } 2091: 2092: strcpy(chaine, chaine_formatee); 2093: free(chaine_formatee); 2094: } 2095: else if ((*s_objet).type == FCT) 2096: { 2097: 2098: /* 2099: -------------------------------------------------------------------------------- 2100: Fonction 2101: -------------------------------------------------------------------------------- 2102: */ 2103: 2104: chaine = (unsigned char *) malloc((strlen((*((struct_fonction *) 2105: ((*s_objet).objet))).nom_fonction) + 1) * 2106: sizeof(unsigned char)); 2107: 2108: if (chaine == NULL) 2109: { 2110: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2111: return(NULL); 2112: } 2113: 2114: strcpy(chaine, (unsigned char *) (*((struct_fonction *) 2115: ((*s_objet).objet))).nom_fonction); 2116: } 2117: else if ((*s_objet).type == TBL) 2118: { 2119: 2120: /* 2121: -------------------------------------------------------------------------------- 2122: Tableau 2123: -------------------------------------------------------------------------------- 2124: */ 2125: 2126: chaine = (unsigned char *) malloc(4 * sizeof(unsigned char)); 2127: 2128: if (chaine == NULL) 2129: { 2130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2131: return(NULL); 2132: } 2133: 2134: strcpy(chaine, "<[ "); 2135: offset = strlen(chaine) + offset_initial; 2136: 2137: for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) 2138: .nombre_elements; i++) 2139: { 2140: chaine_sauvegarde = chaine; 2141: chaine_formatee = formateur(s_etat_processus, offset, 2142: (*((struct_tableau *) (*s_objet).objet)).elements[i]); 2143: 2144: if (chaine_formatee == NULL) 2145: { 2146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2147: return(NULL); 2148: } 2149: 2150: if ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) 2151: .type == CHN) 2152: { 2153: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2154: + strlen(chaine_sauvegarde) + 3) 2155: * sizeof(unsigned char)); 2156: 2157: if (chaine == NULL) 2158: { 2159: (*s_etat_processus).erreur_systeme = 2160: d_es_allocation_memoire; 2161: return(NULL); 2162: } 2163: 2164: strcpy(chaine, chaine_sauvegarde); 2165: free(chaine_sauvegarde); 2166: strcat(chaine, "\""); 2167: strcat(chaine, chaine_formatee); 2168: free(chaine_formatee); 2169: strcat(chaine, "\""); 2170: } 2171: else if ((*(*((struct_tableau *) (*s_objet).objet)) 2172: .elements[i]).type == CHN) 2173: { 2174: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2175: + strlen(chaine_sauvegarde) + 1) 2176: * sizeof(unsigned char)); 2177: 2178: if (chaine == NULL) 2179: { 2180: (*s_etat_processus).erreur_systeme = 2181: d_es_allocation_memoire; 2182: return(NULL); 2183: } 2184: 2185: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); 2186: free(chaine_sauvegarde); 2187: free(chaine_formatee); 2188: } 2189: else 2190: { 2191: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2192: + strlen(chaine_sauvegarde) + 1) 2193: * sizeof(unsigned char)); 2194: 2195: if (chaine == NULL) 2196: { 2197: (*s_etat_processus).erreur_systeme = 2198: d_es_allocation_memoire; 2199: return(NULL); 2200: } 2201: 2202: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); 2203: free(chaine_sauvegarde); 2204: free(chaine_formatee); 2205: } 2206: 2207: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2208: { 2209: chaine_sauvegarde = chaine; 2210: 2211: chaine = (unsigned char *) malloc( 2212: (strlen(chaine_sauvegarde) + 2) 2213: * sizeof(unsigned char)); 2214: 2215: if (chaine == NULL) 2216: { 2217: (*s_etat_processus).erreur_systeme = 2218: d_es_allocation_memoire; 2219: return(NULL); 2220: } 2221: 2222: strcpy(chaine, chaine_sauvegarde); 2223: free(chaine_sauvegarde); 2224: strcat(chaine, "\n"); 2225: 2226: if ((*((struct_tableau *) (*s_objet).objet)) 2227: .nombre_elements != (i + 1)) 2228: { 2229: chaine_sauvegarde = chaine; 2230: 2231: chaine = (unsigned char *) malloc( 2232: (strlen(chaine_sauvegarde) + 1 + offset) 2233: * sizeof(unsigned char)); 2234: 2235: if (chaine == NULL) 2236: { 2237: (*s_etat_processus).erreur_systeme = 2238: d_es_allocation_memoire; 2239: return(NULL); 2240: } 2241: 2242: strcpy(chaine, chaine_sauvegarde); 2243: free(chaine_sauvegarde); 2244: ptre = &(chaine[strlen(chaine)]); 2245: 2246: for(k = 0; k < offset; k++, *(ptre++) = ' '); 2247: 2248: (*ptre) = d_code_fin_chaine; 2249: } 2250: } 2251: else 2252: { 2253: if ((*((struct_tableau *) (*s_objet).objet)) 2254: .nombre_elements != (i + 1)) 2255: { 2256: chaine_sauvegarde = chaine; 2257: 2258: chaine = (unsigned char *) malloc( 2259: (strlen(chaine_sauvegarde) + 2) 2260: * sizeof(unsigned char)); 2261: 2262: if (chaine == NULL) 2263: { 2264: (*s_etat_processus).erreur_systeme = 2265: d_es_allocation_memoire; 2266: return(NULL); 2267: } 2268: 2269: strcpy(chaine, chaine_sauvegarde); 2270: free(chaine_sauvegarde); 2271: strcat(chaine, " "); 2272: } 2273: } 2274: } 2275: 2276: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2277: { 2278: if (chaine[strlen(chaine) - 1] == '\n') 2279: { 2280: chaine[strlen(chaine) - 1] = d_code_fin_chaine; 2281: } 2282: } 2283: 2284: if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != 0) 2285: { 2286: chaine_sauvegarde = chaine; 2287: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) 2288: * sizeof(unsigned char)); 2289: 2290: if (chaine == NULL) 2291: { 2292: (*s_etat_processus).erreur_systeme = 2293: d_es_allocation_memoire; 2294: return(NULL); 2295: } 2296: 2297: strcpy(chaine, chaine_sauvegarde); 2298: free(chaine_sauvegarde); 2299: strcat(chaine, " ]>"); 2300: } 2301: else 2302: { 2303: chaine_sauvegarde = chaine; 2304: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3) 2305: * sizeof(unsigned char)); 2306: 2307: if (chaine == NULL) 2308: { 2309: (*s_etat_processus).erreur_systeme = 2310: d_es_allocation_memoire; 2311: return(NULL); 2312: } 2313: 2314: strcpy(chaine, chaine_sauvegarde); 2315: free(chaine_sauvegarde); 2316: strcat(chaine, "]>"); 2317: } 2318: } 2319: else if ((*s_objet).type == LST) 2320: { 2321: 2322: /* 2323: -------------------------------------------------------------------------------- 2324: Liste 2325: -------------------------------------------------------------------------------- 2326: */ 2327: 2328: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2329: 2330: if (chaine == NULL) 2331: { 2332: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2333: return(NULL); 2334: } 2335: 2336: strcpy(chaine, "{ "); 2337: 2338: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 2339: nombre_elements = 0; 2340: offset = strlen(chaine) + offset_initial; 2341: 2342: while(l_element_courant != NULL) 2343: { 2344: chaine_sauvegarde = chaine; 2345: chaine_formatee = formateur(s_etat_processus, offset, 2346: (*l_element_courant).donnee); 2347: 2348: if (chaine_formatee == NULL) 2349: { 2350: (*s_etat_processus).erreur_systeme = 2351: d_es_allocation_memoire; 2352: return(NULL); 2353: } 2354: 2355: if ((*(*l_element_courant).donnee).type == CHN) 2356: { 2357: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2358: + strlen(chaine_sauvegarde) + 3) 2359: * sizeof(unsigned char)); 2360: 2361: if (chaine == NULL) 2362: { 2363: (*s_etat_processus).erreur_systeme = 2364: d_es_allocation_memoire; 2365: return(NULL); 2366: } 2367: 2368: strcpy(chaine, chaine_sauvegarde); 2369: free(chaine_sauvegarde); 2370: strcat(chaine, "\""); 2371: strcat(chaine, chaine_formatee); 2372: free(chaine_formatee); 2373: strcat(chaine, "\""); 2374: } 2375: else if ((*(*l_element_courant).donnee).type == NOM) 2376: { 2377: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2378: + strlen(chaine_sauvegarde) + 1) 2379: * sizeof(unsigned char)); 2380: 2381: if (chaine == NULL) 2382: { 2383: (*s_etat_processus).erreur_systeme = 2384: d_es_allocation_memoire; 2385: return(NULL); 2386: } 2387: 2388: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); 2389: free(chaine_sauvegarde); 2390: free(chaine_formatee); 2391: } 2392: else 2393: { 2394: chaine = (unsigned char *) malloc((strlen(chaine_formatee) 2395: + strlen(chaine_sauvegarde) + 1) 2396: * sizeof(unsigned char)); 2397: 2398: if (chaine == NULL) 2399: { 2400: (*s_etat_processus).erreur_systeme = 2401: d_es_allocation_memoire; 2402: return(NULL); 2403: } 2404: 2405: sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee); 2406: free(chaine_sauvegarde); 2407: free(chaine_formatee); 2408: } 2409: 2410: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2411: { 2412: chaine_sauvegarde = chaine; 2413: 2414: chaine = (unsigned char *) malloc( 2415: (strlen(chaine_sauvegarde) + 2) 2416: * sizeof(unsigned char)); 2417: 2418: if (chaine == NULL) 2419: { 2420: (*s_etat_processus).erreur_systeme = 2421: d_es_allocation_memoire; 2422: return(NULL); 2423: } 2424: 2425: strcpy(chaine, chaine_sauvegarde); 2426: free(chaine_sauvegarde); 2427: strcat(chaine, "\n"); 2428: 2429: if ((*l_element_courant).suivant != NULL) 2430: { 2431: chaine_sauvegarde = chaine; 2432: 2433: chaine = (unsigned char *) malloc( 2434: (strlen(chaine_sauvegarde) + 1 + offset) 2435: * sizeof(unsigned char)); 2436: 2437: if (chaine == NULL) 2438: { 2439: (*s_etat_processus).erreur_systeme = 2440: d_es_allocation_memoire; 2441: return(NULL); 2442: } 2443: 2444: strcpy(chaine, chaine_sauvegarde); 2445: free(chaine_sauvegarde); 2446: ptre = &(chaine[strlen(chaine)]); 2447: 2448: for(k = 0; k < offset; k++, *(ptre++) = ' '); 2449: 2450: (*ptre) = d_code_fin_chaine; 2451: } 2452: } 2453: else 2454: { 2455: if ((*l_element_courant).suivant != NULL) 2456: { 2457: chaine_sauvegarde = chaine; 2458: 2459: chaine = (unsigned char *) malloc( 2460: (strlen(chaine_sauvegarde) + 2) 2461: * sizeof(unsigned char)); 2462: 2463: if (chaine == NULL) 2464: { 2465: (*s_etat_processus).erreur_systeme = 2466: d_es_allocation_memoire; 2467: return(NULL); 2468: } 2469: 2470: strcpy(chaine, chaine_sauvegarde); 2471: free(chaine_sauvegarde); 2472: strcat(chaine, " "); 2473: } 2474: } 2475: 2476: nombre_elements++; 2477: l_element_courant = (*l_element_courant).suivant; 2478: } 2479: 2480: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2481: { 2482: if (chaine[strlen(chaine) - 1] == '\n') 2483: { 2484: chaine[strlen(chaine) - 1] = d_code_fin_chaine; 2485: } 2486: } 2487: 2488: if (nombre_elements != 0) 2489: { 2490: chaine_sauvegarde = chaine; 2491: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3) 2492: * sizeof(unsigned char)); 2493: 2494: if (chaine == NULL) 2495: { 2496: (*s_etat_processus).erreur_systeme = 2497: d_es_allocation_memoire; 2498: return(NULL); 2499: } 2500: 2501: strcpy(chaine, chaine_sauvegarde); 2502: free(chaine_sauvegarde); 2503: strcat(chaine, " }"); 2504: } 2505: else 2506: { 2507: chaine_sauvegarde = chaine; 2508: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 2) 2509: * sizeof(unsigned char)); 2510: 2511: if (chaine == NULL) 2512: { 2513: (*s_etat_processus).erreur_systeme = 2514: d_es_allocation_memoire; 2515: return(NULL); 2516: } 2517: 2518: strcpy(chaine, chaine_sauvegarde); 2519: free(chaine_sauvegarde); 2520: strcat(chaine, "}"); 2521: } 2522: } 2523: else if ((*s_objet).type == MCX) 2524: { 2525: 2526: /* 2527: -------------------------------------------------------------------------------- 2528: Matrice complexe 2529: -------------------------------------------------------------------------------- 2530: */ 2531: 2532: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2533: .nombre_lignes; 2534: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2535: .nombre_colonnes; 2536: 2537: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2538: 2539: if (chaine != NULL) 2540: { 2541: strcpy(chaine, "[["); 2542: offset = strlen(chaine) + offset_initial - 1; 2543: 2544: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 * 2545: nombre_colonnes)) == NULL) 2546: { 2547: (*s_etat_processus).erreur_systeme = 2548: d_es_allocation_memoire; 2549: return(NULL); 2550: } 2551: 2552: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2553: { 2554: for(j = 0; j < (2 * nombre_colonnes); j++) 2555: { 2556: longueurs_maximales[j] = 0; 2557: } 2558: 2559: for(i = 0; i < nombre_lignes; i++) 2560: { 2561: for(j = 0; j < nombre_colonnes; j++) 2562: { 2563: chaine_formatee = formateur_nombre(s_etat_processus, 2564: (void *) &(((struct_complexe16 **) 2565: ((*((struct_matrice *) 2566: ((*s_objet).objet))).tableau))[i][j]), 'C'); 2567: 2568: if (chaine_formatee == NULL) 2569: { 2570: (*s_etat_processus).erreur_systeme = 2571: d_es_allocation_memoire; 2572: return(NULL); 2573: } 2574: 2575: longueur_courante = strlen(chaine_formatee); 2576: longueur_decimale_courante = 0; 2577: 2578: if ((ptrl = index(chaine_formatee, 2579: (test_cfsf(s_etat_processus, 48) == d_vrai) 2580: ? '.' : ',')) != NULL) 2581: { 2582: longueur_decimale_courante = longueur_courante 2583: - (ptrl - chaine_formatee); 2584: longueur_courante = ptrl - chaine_formatee; 2585: } 2586: 2587: free(chaine_formatee); 2588: 2589: if (longueurs_maximales[2 * j] < longueur_courante) 2590: { 2591: longueurs_maximales[2 * j] = longueur_courante; 2592: } 2593: 2594: if (longueurs_maximales[(2 * j) + 1] < 2595: longueur_decimale_courante) 2596: { 2597: longueurs_maximales[(2 * j) + 1] = 2598: longueur_decimale_courante; 2599: } 2600: } 2601: } 2602: } 2603: 2604: for(i = 0; i < nombre_lignes; i++) 2605: { 2606: for(j = 0; j < nombre_colonnes; j++) 2607: { 2608: chaine_formatee = formateur_nombre(s_etat_processus, 2609: (void *) &(((struct_complexe16 **) 2610: ((*((struct_matrice *) 2611: ((*s_objet).objet))).tableau))[i][j]), 'C'); 2612: 2613: if (chaine_formatee == NULL) 2614: { 2615: (*s_etat_processus).erreur_systeme = 2616: d_es_allocation_memoire; 2617: return(NULL); 2618: } 2619: 2620: longueur_courante = strlen(chaine_formatee); 2621: longueur_decimale_courante = 0; 2622: 2623: if ((ptrl = index(chaine_formatee, 2624: (test_cfsf(s_etat_processus, 48) == d_vrai) 2625: ? '.' : ',')) != NULL) 2626: { 2627: longueur_decimale_courante = longueur_courante 2628: - (ptrl - chaine_formatee); 2629: longueur_courante = ptrl - chaine_formatee; 2630: } 2631: 2632: chaine_sauvegarde = chaine; 2633: 2634: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2635: { 2636: 2637: chaine = (unsigned char *) malloc( 2638: (strlen(chaine_sauvegarde) + 2639: longueur_courante + longueur_decimale_courante + 2640: longueurs_maximales[2 * j] + 2641: longueurs_maximales[(2 * j) + 1] + 2) 2642: * sizeof(unsigned char)); 2643: 2644: if (chaine == NULL) 2645: { 2646: (*s_etat_processus).erreur_systeme = 2647: d_es_allocation_memoire; 2648: return(NULL); 2649: } 2650: 2651: strcpy(chaine, chaine_sauvegarde); 2652: free(chaine_sauvegarde); 2653: strcat(chaine, " "); 2654: 2655: ptre = &(chaine[strlen(chaine)]); 2656: 2657: for (k = 0; k < (longueurs_maximales[2 * j] 2658: - longueur_courante); k++, *(ptre++) = ' '); 2659: 2660: (*ptre) = d_code_fin_chaine; 2661: strcat(chaine, chaine_formatee); 2662: ptre = &(chaine[strlen(chaine)]); 2663: 2664: for(k = 0; k < (longueurs_maximales[(2 * j) + 1] 2665: - longueur_decimale_courante); 2666: k++, *(ptre++) = ' '); 2667: 2668: (*ptre) = d_code_fin_chaine; 2669: } 2670: else 2671: { 2672: chaine = (unsigned char *) malloc( 2673: (strlen(chaine_sauvegarde) + 2674: longueur_courante + longueur_decimale_courante 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: } 2689: 2690: free(chaine_formatee); 2691: } 2692: 2693: chaine_sauvegarde = chaine; 2694: 2695: if (i != (nombre_lignes - 1)) 2696: { 2697: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2698: { 2699: chaine = (unsigned char *) malloc( 2700: (strlen(chaine_sauvegarde) + 5 + offset) 2701: * sizeof(unsigned char)); 2702: 2703: if (chaine == NULL) 2704: { 2705: (*s_etat_processus).erreur_systeme = 2706: d_es_allocation_memoire; 2707: return(NULL); 2708: } 2709: 2710: strcpy(chaine, chaine_sauvegarde); 2711: free(chaine_sauvegarde); 2712: strcat(chaine, " ]\n"); 2713: ptre = &(chaine[strlen(chaine)]); 2714: 2715: for(k = 0; k < offset; k++, *(ptre++) = ' '); 2716: 2717: (*ptre) = d_code_fin_chaine; 2718: strcat(chaine, "["); 2719: } 2720: else 2721: { 2722: chaine = (unsigned char *) malloc( 2723: (strlen(chaine_sauvegarde) + 4) 2724: * sizeof(unsigned char)); 2725: 2726: if (chaine == NULL) 2727: { 2728: (*s_etat_processus).erreur_systeme = 2729: d_es_allocation_memoire; 2730: return(NULL); 2731: } 2732: 2733: strcpy(chaine, chaine_sauvegarde); 2734: free(chaine_sauvegarde); 2735: strcat(chaine, " ]["); 2736: } 2737: } 2738: } 2739: 2740: free(longueurs_maximales); 2741: 2742: chaine_sauvegarde = chaine; 2743: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2744: + 4) * sizeof(unsigned char)); 2745: 2746: if (chaine == NULL) 2747: { 2748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2749: return(NULL); 2750: } 2751: 2752: strcpy(chaine, chaine_sauvegarde); 2753: free(chaine_sauvegarde); 2754: strcat(chaine, " ]]"); 2755: } 2756: } 2757: else if ((*s_objet).type == MIN) 2758: { 2759: 2760: /* 2761: -------------------------------------------------------------------------------- 2762: Matrice entière 2763: -------------------------------------------------------------------------------- 2764: */ 2765: 2766: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2767: .nombre_lignes; 2768: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2769: .nombre_colonnes; 2770: 2771: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2772: 2773: if (chaine != NULL) 2774: { 2775: strcpy(chaine, "[["); 2776: offset = strlen(chaine) + offset_initial - 1; 2777: 2778: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2779: nombre_colonnes)) == NULL) 2780: { 2781: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2782: return(NULL); 2783: } 2784: 2785: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2786: { 2787: for(j = 0; j < nombre_colonnes; j++) 2788: { 2789: longueurs_maximales[j] = 0; 2790: } 2791: 2792: for(i = 0; i < nombre_lignes; i++) 2793: { 2794: for(j = 0; j < nombre_colonnes; j++) 2795: { 2796: chaine_formatee = formateur_nombre(s_etat_processus, 2797: (void *) &(((integer8 **) ((*((struct_matrice *) 2798: ((*s_objet).objet))).tableau))[i][j]), 'I'); 2799: 2800: if (chaine_formatee == NULL) 2801: { 2802: (*s_etat_processus).erreur_systeme = 2803: d_es_allocation_memoire; 2804: return(NULL); 2805: } 2806: 2807: longueur_courante = strlen(chaine_formatee); 2808: free(chaine_formatee); 2809: 2810: if (longueurs_maximales[j] < longueur_courante) 2811: { 2812: longueurs_maximales[j] = longueur_courante; 2813: } 2814: } 2815: } 2816: } 2817: 2818: for(i = 0; i < nombre_lignes; i++) 2819: { 2820: for(j = 0; j < nombre_colonnes; j++) 2821: { 2822: chaine_formatee = formateur_nombre(s_etat_processus, 2823: (void *) &(((integer8 **) ((*((struct_matrice *) 2824: ((*s_objet).objet))).tableau))[i][j]), 'I'); 2825: 2826: if (chaine_formatee == NULL) 2827: { 2828: (*s_etat_processus).erreur_systeme = 2829: d_es_allocation_memoire; 2830: return(NULL); 2831: } 2832: 2833: longueur_courante = strlen(chaine_formatee); 2834: chaine_sauvegarde = chaine; 2835: 2836: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2837: { 2838: chaine = (unsigned char *) malloc( 2839: (strlen(chaine_sauvegarde) + longueur_courante 2840: + longueurs_maximales[j] + 2) 2841: * sizeof(unsigned char)); 2842: 2843: if (chaine == NULL) 2844: { 2845: (*s_etat_processus).erreur_systeme = 2846: d_es_allocation_memoire; 2847: return(NULL); 2848: } 2849: 2850: strcpy(chaine, chaine_sauvegarde); 2851: free(chaine_sauvegarde); 2852: strcat(chaine, " "); 2853: 2854: ptre = &(chaine[strlen(chaine)]); 2855: 2856: for(k = 0; k < (longueurs_maximales[j] 2857: - longueur_courante); k++, *(ptre++) = ' '); 2858: 2859: (*ptre) = d_code_fin_chaine; 2860: } 2861: else 2862: { 2863: chaine = (unsigned char *) malloc( 2864: (strlen(chaine_sauvegarde) + longueur_courante 2865: + 2) * sizeof(unsigned char)); 2866: 2867: if (chaine == NULL) 2868: { 2869: (*s_etat_processus).erreur_systeme = 2870: d_es_allocation_memoire; 2871: return(NULL); 2872: } 2873: 2874: strcpy(chaine, chaine_sauvegarde); 2875: free(chaine_sauvegarde); 2876: strcat(chaine, " "); 2877: } 2878: 2879: strcat(chaine, chaine_formatee); 2880: free(chaine_formatee); 2881: } 2882: 2883: chaine_sauvegarde = chaine; 2884: 2885: if (i != (nombre_lignes - 1)) 2886: { 2887: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2888: { 2889: chaine = (unsigned char *) malloc( 2890: (strlen(chaine_sauvegarde) + 5 + offset) 2891: * sizeof(unsigned char)); 2892: 2893: if (chaine == NULL) 2894: { 2895: (*s_etat_processus).erreur_systeme = 2896: d_es_allocation_memoire; 2897: return(NULL); 2898: } 2899: 2900: strcpy(chaine, chaine_sauvegarde); 2901: free(chaine_sauvegarde); 2902: strcat(chaine, " ]\n"); 2903: ptre = &(chaine[strlen(chaine)]); 2904: 2905: for(k = 0; k < offset; k++, *(ptre++) = ' '); 2906: 2907: (*ptre) = d_code_fin_chaine; 2908: strcat(chaine, "["); 2909: } 2910: else 2911: { 2912: chaine = (unsigned char *) malloc( 2913: (strlen(chaine_sauvegarde) + 4) 2914: * sizeof(unsigned char)); 2915: 2916: if (chaine == NULL) 2917: { 2918: (*s_etat_processus).erreur_systeme = 2919: d_es_allocation_memoire; 2920: return(NULL); 2921: } 2922: 2923: strcpy(chaine, chaine_sauvegarde); 2924: free(chaine_sauvegarde); 2925: strcat(chaine, " ]["); 2926: } 2927: } 2928: } 2929: 2930: free(longueurs_maximales); 2931: 2932: chaine_sauvegarde = chaine; 2933: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 2934: + 4) * sizeof(unsigned char)); 2935: 2936: if (chaine == NULL) 2937: { 2938: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2939: return(NULL); 2940: } 2941: 2942: strcpy(chaine, chaine_sauvegarde); 2943: free(chaine_sauvegarde); 2944: strcat(chaine, " ]]"); 2945: } 2946: } 2947: else if ((*s_objet).type == MRL) 2948: { 2949: 2950: /* 2951: -------------------------------------------------------------------------------- 2952: Matrice réelle 2953: -------------------------------------------------------------------------------- 2954: */ 2955: 2956: nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) 2957: .nombre_lignes; 2958: nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) 2959: .nombre_colonnes; 2960: 2961: chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); 2962: 2963: if (chaine != NULL) 2964: { 2965: strcpy(chaine, "[["); 2966: offset = strlen(chaine) + offset_initial - 1; 2967: 2968: if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 * 2969: nombre_colonnes)) == NULL) 2970: { 2971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2972: return(NULL); 2973: } 2974: 2975: if (test_cfsf(s_etat_processus, 45) == d_vrai) 2976: { 2977: for(j = 0; j < (2 * nombre_colonnes); j++) 2978: { 2979: longueurs_maximales[j] = 0; 2980: } 2981: 2982: for(i = 0; i < nombre_lignes; i++) 2983: { 2984: for(j = 0; j < nombre_colonnes; j++) 2985: { 2986: chaine_formatee = formateur_nombre(s_etat_processus, 2987: (void *) &(((real8 **) ((*((struct_matrice *) 2988: ((*s_objet).objet))).tableau))[i][j]), 'R'); 2989: 2990: if (chaine_formatee == NULL) 2991: { 2992: (*s_etat_processus).erreur_systeme = 2993: d_es_allocation_memoire; 2994: return(NULL); 2995: } 2996: 2997: longueur_courante = strlen(chaine_formatee); 2998: longueur_decimale_courante = 0; 2999: 3000: if ((ptrl = index(chaine_formatee, 3001: (test_cfsf(s_etat_processus, 48) == d_vrai) 3002: ? ',' : '.')) != NULL) 3003: { 3004: longueur_decimale_courante = longueur_courante 3005: - (ptrl - chaine_formatee); 3006: longueur_courante = ptrl - chaine_formatee; 3007: } 3008: 3009: free(chaine_formatee); 3010: 3011: if (longueurs_maximales[2 * j] < longueur_courante) 3012: { 3013: longueurs_maximales[2 * j] = longueur_courante; 3014: } 3015: 3016: if (longueurs_maximales[(2 * j) + 1] < 3017: longueur_decimale_courante) 3018: { 3019: longueurs_maximales[(2 * j) + 1] = 3020: longueur_decimale_courante; 3021: } 3022: } 3023: } 3024: } 3025: 3026: for(i = 0; i < nombre_lignes; i++) 3027: { 3028: for(j = 0; j < nombre_colonnes; j++) 3029: { 3030: chaine_formatee = formateur_nombre(s_etat_processus, 3031: (void *) &(((real8 **) ((*((struct_matrice *) 3032: ((*s_objet).objet))).tableau))[i][j]), 'R'); 3033: 3034: if (chaine_formatee == NULL) 3035: { 3036: (*s_etat_processus).erreur_systeme = 3037: d_es_allocation_memoire; 3038: return(NULL); 3039: } 3040: 3041: longueur_courante = strlen(chaine_formatee); 3042: longueur_decimale_courante = 0; 3043: 3044: if ((ptrl = index(chaine_formatee, 3045: (test_cfsf(s_etat_processus, 48) == d_vrai) 3046: ? ',' : '.')) != NULL) 3047: { 3048: longueur_decimale_courante = longueur_courante 3049: - (ptrl - chaine_formatee); 3050: longueur_courante = ptrl - chaine_formatee; 3051: } 3052: 3053: chaine_sauvegarde = chaine; 3054: 3055: if (test_cfsf(s_etat_processus, 45) == d_vrai) 3056: { 3057: chaine = (unsigned char *) malloc( 3058: (strlen(chaine_sauvegarde) + 3059: longueur_courante + longueur_decimale_courante + 3060: longueurs_maximales[2 * j] + 3061: longueurs_maximales[(2 * j) + 1] + 2) 3062: * sizeof(unsigned char)); 3063: 3064: if (chaine == NULL) 3065: { 3066: (*s_etat_processus).erreur_systeme = 3067: d_es_allocation_memoire; 3068: return(NULL); 3069: } 3070: 3071: strcpy(chaine, chaine_sauvegarde); 3072: free(chaine_sauvegarde); 3073: strcat(chaine, " "); 3074: 3075: ptre = &(chaine[strlen(chaine)]); 3076: 3077: for(k = 0; k < (longueurs_maximales[2 * j] 3078: - longueur_courante); k++, *(ptre++) = ' '); 3079: 3080: (*ptre) = d_code_fin_chaine; 3081: strcat(chaine, chaine_formatee); 3082: ptre = &(chaine[strlen(chaine)]); 3083: 3084: for(k = 0; k < (longueurs_maximales[(2 * j) + 1] 3085: - longueur_decimale_courante); 3086: k++, *(ptre++) = ' '); 3087: 3088: (*ptre) = d_code_fin_chaine; 3089: } 3090: else 3091: { 3092: chaine = (unsigned char *) malloc( 3093: (strlen(chaine_sauvegarde) + 3094: longueur_courante + longueur_decimale_courante 3095: + 2) * sizeof(unsigned char)); 3096: 3097: if (chaine == NULL) 3098: { 3099: (*s_etat_processus).erreur_systeme = 3100: d_es_allocation_memoire; 3101: return(NULL); 3102: } 3103: 3104: strcpy(chaine, chaine_sauvegarde); 3105: free(chaine_sauvegarde); 3106: strcat(chaine, " "); 3107: strcat(chaine, chaine_formatee); 3108: } 3109: 3110: free(chaine_formatee); 3111: } 3112: 3113: chaine_sauvegarde = chaine; 3114: 3115: if (i != (nombre_lignes - 1)) 3116: { 3117: if (test_cfsf(s_etat_processus, 45) == d_vrai) 3118: { 3119: chaine = (unsigned char *) malloc( 3120: (strlen(chaine_sauvegarde) + 5 + offset) 3121: * sizeof(unsigned char)); 3122: 3123: if (chaine == NULL) 3124: { 3125: (*s_etat_processus).erreur_systeme = 3126: d_es_allocation_memoire; 3127: return(NULL); 3128: } 3129: 3130: strcpy(chaine, chaine_sauvegarde); 3131: free(chaine_sauvegarde); 3132: strcat(chaine, " ]\n"); 3133: ptre = &(chaine[strlen(chaine)]); 3134: 3135: for(k = 0; k < offset; k++, *(ptre++) = ' '); 3136: 3137: (*ptre) = d_code_fin_chaine; 3138: strcat(chaine, "["); 3139: } 3140: else 3141: { 3142: chaine = (unsigned char *) malloc( 3143: (strlen(chaine_sauvegarde) + 4) 3144: * sizeof(unsigned char)); 3145: 3146: if (chaine == NULL) 3147: { 3148: (*s_etat_processus).erreur_systeme = 3149: d_es_allocation_memoire; 3150: return(NULL); 3151: } 3152: 3153: strcpy(chaine, chaine_sauvegarde); 3154: free(chaine_sauvegarde); 3155: strcat(chaine, " ]["); 3156: } 3157: } 3158: } 3159: 3160: free(longueurs_maximales); 3161: 3162: chaine_sauvegarde = chaine; 3163: chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) 3164: + 4) * sizeof(unsigned char)); 3165: 3166: if (chaine == NULL) 3167: { 3168: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3169: return(NULL); 3170: } 3171: 3172: strcpy(chaine, chaine_sauvegarde); 3173: free(chaine_sauvegarde); 3174: strcat(chaine, " ]]"); 3175: } 3176: } 3177: else if ((*s_objet).type == MTX) 3178: { 3179: if (alsprintf(&chaine, "Mutex $ %016lX", (unsigned long) 3180: &((*((struct_mutex *) (*s_objet).objet)).mutex)) < 0) 3181: { 3182: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3183: return(NULL); 3184: } 3185: } 3186: else if ((*s_objet).type == NOM) 3187: { 3188: 3189: /* 3190: -------------------------------------------------------------------------------- 3191: Nom 3192: -------------------------------------------------------------------------------- 3193: */ 3194: 3195: if ((*((struct_nom *) (*s_objet).objet)).symbole == d_vrai) 3196: { 3197: chaine = (unsigned char *) malloc((strlen((*((struct_nom *) 3198: (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); 3199: 3200: if (chaine == NULL) 3201: { 3202: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3203: return(NULL); 3204: } 3205: 3206: sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom); 3207: } 3208: else 3209: { 3210: chaine = (unsigned char *) malloc((strlen((*((struct_nom *) 3211: (*s_objet).objet)).nom) + 1) * sizeof(unsigned char)); 3212: 3213: if (chaine == NULL) 3214: { 3215: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3216: return(NULL); 3217: } 3218: 3219: sprintf(chaine, "%s", (*((struct_nom *) (*s_objet).objet)).nom); 3220: } 3221: } 3222: else if ((*s_objet).type == REL) 3223: { 3224: 3225: /* 3226: -------------------------------------------------------------------------------- 3227: Réel 3228: -------------------------------------------------------------------------------- 3229: */ 3230: 3231: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 3232: ((real8 *) ((*s_objet).objet)), 'R'); 3233: 3234: if (chaine_formatee == NULL) 3235: { 3236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3237: return(NULL); 3238: } 3239: 3240: chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) 3241: * sizeof(unsigned char)); 3242: 3243: if (chaine == NULL) 3244: { 3245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3246: return(NULL); 3247: } 3248: 3249: strcpy(chaine, chaine_formatee); 3250: free(chaine_formatee); 3251: } 3252: else if ((*s_objet).type == VCX) 3253: { 3254: 3255: /* 3256: -------------------------------------------------------------------------------- 3257: Vecteur complexe 3258: -------------------------------------------------------------------------------- 3259: */ 3260: 3261: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 3262: .taille; 3263: 3264: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 3265: 3266: if (chaine != NULL) 3267: { 3268: strcpy(chaine, "["); 3269: 3270: for(i = 0; i < nombre_colonnes; i++) 3271: { 3272: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 3273: &(((struct_complexe16 *) ((*((struct_vecteur *) 3274: ((*s_objet).objet))).tableau))[i]), 'C'); 3275: 3276: if (chaine_formatee == NULL) 3277: { 3278: (*s_etat_processus).erreur_systeme = 3279: d_es_allocation_memoire; 3280: return(NULL); 3281: } 3282: 3283: chaine_sauvegarde = chaine; 3284: chaine = (unsigned char *) malloc( 3285: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 3286: + 2) * sizeof(unsigned char)); 3287: 3288: if (chaine == NULL) 3289: { 3290: (*s_etat_processus).erreur_systeme = 3291: d_es_allocation_memoire; 3292: return(NULL); 3293: } 3294: 3295: strcpy(chaine, chaine_sauvegarde); 3296: free(chaine_sauvegarde); 3297: strcat(chaine, " "); 3298: strcat(chaine, chaine_formatee); 3299: free(chaine_formatee); 3300: } 3301: 3302: chaine_sauvegarde = chaine; 3303: chaine = (unsigned char *) malloc( 3304: (strlen(chaine_sauvegarde) + 3) 3305: * sizeof(unsigned char)); 3306: 3307: if (chaine == NULL) 3308: { 3309: (*s_etat_processus).erreur_systeme = 3310: d_es_allocation_memoire; 3311: return(NULL); 3312: } 3313: 3314: strcpy(chaine, chaine_sauvegarde); 3315: free(chaine_sauvegarde); 3316: strcat(chaine, " ]"); 3317: } 3318: } 3319: else if ((*s_objet).type == VIN) 3320: { 3321: 3322: /* 3323: -------------------------------------------------------------------------------- 3324: Vecteur entier 3325: -------------------------------------------------------------------------------- 3326: */ 3327: 3328: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 3329: .taille; 3330: 3331: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 3332: 3333: if (chaine != NULL) 3334: { 3335: strcpy(chaine, "["); 3336: 3337: for(i = 0; i < nombre_colonnes; i++) 3338: { 3339: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 3340: &(((integer8 *) ((*((struct_vecteur *) 3341: ((*s_objet).objet))).tableau))[i]), 'I'); 3342: 3343: if (chaine_formatee == NULL) 3344: { 3345: (*s_etat_processus).erreur_systeme = 3346: d_es_allocation_memoire; 3347: return(NULL); 3348: } 3349: 3350: chaine_sauvegarde = chaine; 3351: chaine = (unsigned char *) malloc( 3352: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 3353: + 2) * sizeof(unsigned char)); 3354: 3355: if (chaine == NULL) 3356: { 3357: (*s_etat_processus).erreur_systeme = 3358: d_es_allocation_memoire; 3359: return(NULL); 3360: } 3361: 3362: strcpy(chaine, chaine_sauvegarde); 3363: free(chaine_sauvegarde); 3364: strcat(chaine, " "); 3365: strcat(chaine, chaine_formatee); 3366: free(chaine_formatee); 3367: } 3368: 3369: chaine_sauvegarde = chaine; 3370: chaine = (unsigned char *) malloc( 3371: (strlen(chaine_sauvegarde) + 3) 3372: * sizeof(unsigned char)); 3373: 3374: if (chaine == NULL) 3375: { 3376: (*s_etat_processus).erreur_systeme = 3377: d_es_allocation_memoire; 3378: return(NULL); 3379: } 3380: 3381: strcpy(chaine, chaine_sauvegarde); 3382: free(chaine_sauvegarde); 3383: strcat(chaine, " ]"); 3384: } 3385: } 3386: else if ((*s_objet).type == VRL) 3387: { 3388: 3389: /* 3390: -------------------------------------------------------------------------------- 3391: Vecteur réel 3392: -------------------------------------------------------------------------------- 3393: */ 3394: 3395: nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) 3396: .taille; 3397: 3398: chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); 3399: 3400: if (chaine != NULL) 3401: { 3402: strcpy(chaine, "["); 3403: 3404: for(i = 0; i < nombre_colonnes; i++) 3405: { 3406: chaine_formatee = formateur_nombre(s_etat_processus, (void *) 3407: &(((real8 *) ((*((struct_vecteur *) 3408: ((*s_objet).objet))).tableau))[i]), 'R'); 3409: 3410: if (chaine_formatee == NULL) 3411: { 3412: (*s_etat_processus).erreur_systeme = 3413: d_es_allocation_memoire; 3414: return(NULL); 3415: } 3416: 3417: chaine_sauvegarde = chaine; 3418: chaine = (unsigned char *) malloc( 3419: (strlen(chaine_sauvegarde) + strlen(chaine_formatee) 3420: + 2) * sizeof(unsigned char)); 3421: 3422: if (chaine == NULL) 3423: { 3424: (*s_etat_processus).erreur_systeme = 3425: d_es_allocation_memoire; 3426: return(NULL); 3427: } 3428: 3429: strcpy(chaine, chaine_sauvegarde); 3430: free(chaine_sauvegarde); 3431: strcat(chaine, " "); 3432: strcat(chaine, chaine_formatee); 3433: free(chaine_formatee); 3434: } 3435: 3436: chaine_sauvegarde = chaine; 3437: chaine = (unsigned char *) malloc( 3438: (strlen(chaine_sauvegarde) + 3) 3439: * sizeof(unsigned char)); 3440: 3441: if (chaine == NULL) 3442: { 3443: (*s_etat_processus).erreur_systeme = 3444: d_es_allocation_memoire; 3445: return(NULL); 3446: } 3447: 3448: strcpy(chaine, chaine_sauvegarde); 3449: free(chaine_sauvegarde); 3450: strcat(chaine, " ]"); 3451: } 3452: } 3453: 3454: return(chaine); 3455: } 3456: 3457: 3458: /* 3459: ================================================================================ 3460: Routines qui transforment un nombre entier, réel ou complexe en chaîne de 3461: caractères suivant le format courant 3462: ================================================================================ 3463: Entrées : pointeur générique sur la donnée numérique à convertir, 3464: type de l'entité (I, R ou C). 3465: -------------------------------------------------------------------------------- 3466: Sorties : chaîne de caractères allouée dans la routine 3467: -------------------------------------------------------------------------------- 3468: Effets de bord : néant 3469: ================================================================================ 3470: */ 3471: 3472: /* 3473: -------------------------------------------------------------------------------- 3474: Formatage des complexes, réels et entiers 3475: -------------------------------------------------------------------------------- 3476: */ 3477: 3478: unsigned char * 3479: formateur_nombre(struct_processus *s_etat_processus, 3480: void *valeur_numerique, unsigned char type) 3481: { 3482: unsigned char *chaine; 3483: unsigned char *construction_chaine; 3484: unsigned char *sauvegarde; 3485: unsigned char *tampon; 3486: 3487: chaine = NULL; 3488: 3489: switch(type) 3490: { 3491: case 'C' : 3492: { 3493: construction_chaine = (unsigned char *) malloc( 3494: 2 * sizeof(unsigned char)); 3495: 3496: if (construction_chaine == NULL) 3497: { 3498: (*s_etat_processus).erreur_systeme = 3499: d_es_allocation_memoire; 3500: return(NULL); 3501: } 3502: 3503: strcpy(construction_chaine, "("); 3504: 3505: tampon = formateur_reel(s_etat_processus, 3506: (void *) &((*((struct_complexe16 *) 3507: valeur_numerique)).partie_reelle), 'R'); 3508: 3509: if (tampon == NULL) 3510: { 3511: (*s_etat_processus).erreur_systeme = 3512: d_es_allocation_memoire; 3513: return(NULL); 3514: } 3515: 3516: sauvegarde = construction_chaine; 3517: 3518: construction_chaine = (unsigned char *) malloc( 3519: (strlen(sauvegarde) + strlen(tampon) + 2) 3520: * sizeof(unsigned char)); 3521: 3522: if (construction_chaine == NULL) 3523: { 3524: (*s_etat_processus).erreur_systeme = 3525: d_es_allocation_memoire; 3526: return(NULL); 3527: } 3528: 3529: strcpy(construction_chaine, sauvegarde); 3530: free(sauvegarde); 3531: strcat(construction_chaine, tampon); 3532: free(tampon); 3533: 3534: if (test_cfsf(s_etat_processus, 48) == d_faux) 3535: { 3536: strcat(construction_chaine, ","); 3537: } 3538: else 3539: { 3540: strcat(construction_chaine, "."); 3541: } 3542: 3543: tampon = formateur_reel(s_etat_processus, 3544: (void *) &((*((struct_complexe16 *) 3545: valeur_numerique)).partie_imaginaire), 'R'); 3546: 3547: if (tampon == NULL) 3548: { 3549: (*s_etat_processus).erreur_systeme = 3550: d_es_allocation_memoire; 3551: return(NULL); 3552: } 3553: 3554: sauvegarde = construction_chaine; 3555: 3556: construction_chaine = (unsigned char *) malloc( 3557: (strlen(sauvegarde) + strlen(tampon) + 2) 3558: * sizeof(unsigned char)); 3559: 3560: if (construction_chaine == NULL) 3561: { 3562: (*s_etat_processus).erreur_systeme = 3563: d_es_allocation_memoire; 3564: return(NULL); 3565: } 3566: 3567: strcpy(construction_chaine, sauvegarde); 3568: free(sauvegarde); 3569: strcat(construction_chaine, tampon); 3570: free(tampon); 3571: strcat(construction_chaine, ")"); 3572: 3573: chaine = construction_chaine; 3574: 3575: break; 3576: } 3577: 3578: case 'R' : 3579: { 3580: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'R'); 3581: 3582: if (chaine == NULL) 3583: { 3584: (*s_etat_processus).erreur_systeme = 3585: d_es_allocation_memoire; 3586: return(NULL); 3587: } 3588: 3589: break; 3590: } 3591: 3592: default : 3593: case 'I' : 3594: { 3595: chaine = formateur_reel(s_etat_processus, valeur_numerique, 'I'); 3596: 3597: if (chaine == NULL) 3598: { 3599: (*s_etat_processus).erreur_systeme = 3600: d_es_allocation_memoire; 3601: return(NULL); 3602: } 3603: 3604: break; 3605: } 3606: } 3607: 3608: return(chaine); 3609: } 3610: 3611: 3612: /* 3613: -------------------------------------------------------------------------------- 3614: Formateur des réels et entiers 3615: -------------------------------------------------------------------------------- 3616: */ 3617: 3618: unsigned char * 3619: formateur_reel(struct_processus *s_etat_processus, 3620: void *valeur_numerique, unsigned char type) 3621: { 3622: real8 mantisse; 3623: real8 tampon_reel; 3624: 3625: integer8 tampon_entier; 3626: 3627: logical1 i49; 3628: logical1 i50; 3629: 3630: long correction; 3631: long dernier_chiffre_significatif; 3632: long exposant; 3633: long longueur_utile; 3634: long longueur_utile_limite; 3635: 3636: unsigned char *chaine; 3637: unsigned char format[32 + 1]; 3638: unsigned char mode[3 + 1]; 3639: unsigned char *ptr; 3640: unsigned char tampon[32 + 1]; 3641: 3642: unsigned long i; 3643: unsigned long j; 3644: 3645: chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char)); 3646: 3647: if (chaine == NULL) 3648: { 3649: (*s_etat_processus).erreur_systeme = 3650: d_es_allocation_memoire; 3651: return(NULL); 3652: } 3653: 3654: if (type == 'R') 3655: { 3656: tampon_reel = *((real8 *) valeur_numerique); 3657: 3658: if (tampon_reel > ((real8) 0)) 3659: { 3660: exposant = (long) floor(log10(tampon_reel)); 3661: } 3662: else if (tampon_reel < ((real8) 0)) 3663: { 3664: exposant = (long) floor(log10(-tampon_reel)); 3665: } 3666: else 3667: { 3668: exposant = 0; 3669: } 3670: 3671: mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant); 3672: } 3673: else 3674: { 3675: tampon_entier = *((integer8 *) valeur_numerique); 3676: 3677: if (tampon_entier > ((integer8) 0)) 3678: { 3679: exposant = (long) floor(log10(tampon_entier)); 3680: } 3681: else if (tampon_entier < ((integer8) 0)) 3682: { 3683: exposant = (long) floor(log10(-tampon_entier)); 3684: } 3685: else 3686: { 3687: exposant = 0; 3688: } 3689: 3690: mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant); 3691: } 3692: 3693: longueur_utile = 0; 3694: j = 1; 3695: 3696: for(i = 53; i <= 56; i++) 3697: { 3698: longueur_utile += (test_cfsf(s_etat_processus, (unsigned char) i) 3699: == d_vrai) ? j : 0; 3700: j *= 2; 3701: } 3702: 3703: longueur_utile_limite = 15; 3704: 3705: if (longueur_utile > longueur_utile_limite) 3706: { 3707: longueur_utile = longueur_utile_limite; 3708: } 3709: 3710: i49 = test_cfsf(s_etat_processus, 49); 3711: i50 = test_cfsf(s_etat_processus, 50); 3712: 3713: if (i49 == d_faux) 3714: { 3715: if (i50 == d_faux) 3716: { 3717: 3718: /* 3719: -------------------------------------------------------------------------------- 3720: Mode standard 3721: -------------------------------------------------------------------------------- 3722: */ 3723: 3724: strcpy(mode, "STD"); 3725: } 3726: else 3727: { 3728: 3729: /* 3730: -------------------------------------------------------------------------------- 3731: Mode scientifique 3732: -------------------------------------------------------------------------------- 3733: */ 3734: 3735: strcpy(mode, "SCI"); 3736: } 3737: } 3738: else 3739: { 3740: if (i50 == d_faux) 3741: { 3742: 3743: /* 3744: -------------------------------------------------------------------------------- 3745: Mode fixe 3746: -------------------------------------------------------------------------------- 3747: */ 3748: 3749: strcpy(mode, "FIX"); 3750: } 3751: else 3752: { 3753: 3754: /* 3755: -------------------------------------------------------------------------------- 3756: Mode ingénieur 3757: -------------------------------------------------------------------------------- 3758: */ 3759: 3760: strcpy(mode, "ENG"); 3761: } 3762: } 3763: 3764: // Test portant sur le nombre de chiffres significatifs dans 3765: // le cas du format STD pour que 1.2E-15 apparaisse en notation 3766: // SCI car il y a une perte de précision dans l'affichage. 3767: 3768: if ((strcmp(mode, "STD") == 0) && (type == 'R')) 3769: { 3770: if (abs(*((real8 *) valeur_numerique)) < 1) 3771: { 3772: dernier_chiffre_significatif = -exposant; 3773: sprintf(tampon, ".%f", mantisse); 3774: 3775: ptr = &(tampon[strlen(tampon) - 1]); 3776: 3777: while((*ptr) != '.') 3778: { 3779: if ((*ptr) != '0') 3780: { 3781: dernier_chiffre_significatif++; 3782: } 3783: 3784: ptr--; 3785: } 3786: } 3787: else 3788: { 3789: dernier_chiffre_significatif = 0; 3790: } 3791: } 3792: else 3793: { 3794: dernier_chiffre_significatif = 0; 3795: } 3796: 3797: if ((strcmp(mode, "SCI") == 0) || 3798: ((strcmp(mode, "STD") == 0) && ((exposant > 3799: longueur_utile_limite) || (dernier_chiffre_significatif > 15) || 3800: (exposant < -longueur_utile_limite))) || 3801: ((strcmp(mode, "FIX") == 0) && 3802: ((exposant >= longueur_utile_limite) || 3803: (exposant < -longueur_utile)))) 3804: { 3805: chaine[0] = d_code_fin_chaine; 3806: format[0] = d_code_fin_chaine; 3807: 3808: if (strcmp(mode, "STD") == 0) 3809: { 3810: longueur_utile = longueur_utile_limite - 1; 3811: } 3812: 3813: sprintf(format, "%%.%luf", longueur_utile); 3814: sprintf(tampon, format, mantisse); 3815: strcpy(chaine, tampon); 3816: 3817: if (strcmp(mode, "STD") == 0) 3818: { 3819: ptr = &(chaine[strlen(chaine) - 1]); 3820: while(((*ptr) == '0') || ((*ptr) == '.')) 3821: { 3822: (*ptr) = d_code_fin_chaine; 3823: ptr--; 3824: } 3825: } 3826: 3827: strcat(chaine, "E"); 3828: sprintf(tampon, "%ld", exposant); 3829: strcat(chaine, tampon); 3830: } 3831: else if (strcmp(mode, "FIX") == 0) 3832: { 3833: chaine[0] = d_code_fin_chaine; 3834: format[0] = d_code_fin_chaine; 3835: 3836: if (longueur_utile + exposant >= longueur_utile_limite) 3837: { 3838: longueur_utile = longueur_utile_limite - (exposant + 1); 3839: } 3840: 3841: sprintf(format, "%%.%luf", longueur_utile); 3842: 3843: sprintf(tampon, format, (mantisse * pow(10, exposant))); 3844: strcpy(chaine, tampon); 3845: } 3846: else if (strcmp(mode, "ENG") == 0) 3847: { 3848: chaine[0] = d_code_fin_chaine; 3849: format[0] = d_code_fin_chaine; 3850: 3851: correction = labs(exposant) % 3; 3852: 3853: if (exposant < 0) 3854: { 3855: if (correction == 0) 3856: { 3857: correction = 3; 3858: } 3859: 3860: correction = 3 - correction; 3861: } 3862: 3863: longueur_utile -= correction; 3864: sprintf(format, "%%.%luf", longueur_utile); 3865: 3866: sprintf(tampon, format, (mantisse * pow(10, correction))); 3867: strcpy(chaine, tampon); 3868: strcat(chaine, "E"); 3869: sprintf(tampon, "%ld", (exposant - correction)); 3870: strcat(chaine, tampon); 3871: } 3872: else 3873: { 3874: if (type == 'I') 3875: { 3876: chaine[0] = d_code_fin_chaine; 3877: sprintf(tampon, "%lld", *((integer8 *) valeur_numerique)); 3878: } 3879: else 3880: { 3881: chaine[0] = d_code_fin_chaine; 3882: format[0] = d_code_fin_chaine; 3883: 3884: if (exposant >= 0) 3885: { 3886: if ((exposant + 1) < longueur_utile_limite) 3887: { 3888: sprintf(format, "%%.%luf", (longueur_utile_limite - exposant 3889: - 1)); 3890: } 3891: else 3892: { 3893: strcpy(format, "%.0f."); 3894: } 3895: } 3896: else 3897: { 3898: sprintf(format, "%%.%luf", longueur_utile_limite); 3899: } 3900: 3901: sprintf(tampon, format, *((real8 *) valeur_numerique)); 3902: 3903: i = strlen(tampon) - 1; 3904: while(tampon[i] == '0') 3905: { 3906: tampon[i] = d_code_fin_chaine; 3907: i--; 3908: } 3909: 3910: if (ds_imposition_separateur_decimal == d_faux) 3911: { 3912: i = strlen(tampon) - 1; 3913: if (tampon[i] == '.') 3914: { 3915: tampon[i] = d_code_fin_chaine; 3916: } 3917: } 3918: } 3919: 3920: strcpy(chaine, tampon); 3921: } 3922: 3923: if (test_cfsf(s_etat_processus, 48) == d_vrai) 3924: { 3925: for(i = 0; i < strlen(chaine); i++) 3926: { 3927: if (chaine[i] == '.') 3928: { 3929: chaine[i] = ','; 3930: } 3931: } 3932: } 3933: 3934: return(chaine); 3935: } 3936: 3937: // vim: ts=4