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