![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction 'ppar' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_ppar(struct_processus *s_etat_processus) 40: { 41: struct_liste_chainee *l_ancienne_base; 42: struct_liste_chainee *l_nouvelle_base; 43: 44: struct_objet *s_objet_resultat; 45: 46: /* 47: * { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax } 48: * INDEP DEPND RES { EYEPT } } 49: * { "automatic" { Ymin Ymax } "automatic" INDEP DEPND RES { EYEPT } } 50: */ 51: 52: (*s_etat_processus).erreur_execution = d_ex; 53: 54: if ((*s_etat_processus).affichage_arguments == 'Y') 55: { 56: printf("\n PPAR "); 57: 58: if ((*s_etat_processus).langue == 'F') 59: { 60: printf("(paramètres graphiques)\n\n"); 61: } 62: else 63: { 64: printf("(graphical parameters)\n\n"); 65: } 66: 67: printf("-> 1: %s\n", d_LST); 68: 69: return; 70: } 71: else if ((*s_etat_processus).test_instruction == 'Y') 72: { 73: (*s_etat_processus).nombre_arguments = -1; 74: return; 75: } 76: 77: if (test_cfsf(s_etat_processus, 31) == d_vrai) 78: { 79: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 80: { 81: return; 82: } 83: } 84: 85: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) 86: { 87: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 88: return; 89: } 90: 91: (*s_objet_resultat).objet = NULL; 92: l_ancienne_base = (*s_objet_resultat).objet; 93: 94: // Paramètres des courbes de niveau 95: 96: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 97: { 98: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 99: return; 100: } 101: 102: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus, 103: (*s_etat_processus).parametres_courbes_de_niveau, 'O')) == NULL) 104: { 105: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 106: return; 107: } 108: 109: (*l_nouvelle_base).suivant = l_ancienne_base; 110: (*s_objet_resultat).objet = l_nouvelle_base; 111: l_ancienne_base = (*s_objet_resultat).objet; 112: 113: // Point de vue 114: 115: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 116: { 117: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 118: return; 119: } 120: 121: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, LST)) 122: == NULL) 123: { 124: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 125: return; 126: } 127: 128: (*l_nouvelle_base).suivant = l_ancienne_base; 129: 130: if (((*(*l_nouvelle_base).donnee).objet = 131: allocation_maillon(s_etat_processus)) == NULL) 132: { 133: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 134: return; 135: } 136: 137: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)).donnee 138: = allocation(s_etat_processus, REL)) == NULL) 139: { 140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 141: return; 142: } 143: 144: (*((real8 *) (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 145: .objet)).donnee).objet)) = (*s_etat_processus).point_de_vue_theta; 146: 147: if (test_cfsf(s_etat_processus, 60) == d_faux) 148: { 149: conversion_radians_vers_degres((real8 *) (*(*((struct_liste_chainee *) 150: (*(*l_nouvelle_base).donnee).objet)).donnee).objet); 151: } 152: 153: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 154: .suivant = allocation_maillon(s_etat_processus)) == NULL) 155: { 156: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 157: return; 158: } 159: 160: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 161: .suivant).donnee = allocation(s_etat_processus, REL)) == NULL) 162: { 163: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 164: return; 165: } 166: 167: (*((real8 *) (*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 168: .objet)).suivant).donnee).objet)) = 169: (*s_etat_processus).point_de_vue_phi; 170: 171: if (test_cfsf(s_etat_processus, 60) == d_faux) 172: { 173: conversion_radians_vers_degres((real8 *) (*(*(*((struct_liste_chainee *) 174: (*(*l_nouvelle_base).donnee).objet)).suivant).donnee).objet); 175: } 176: 177: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 178: .suivant).suivant = allocation_maillon(s_etat_processus)) == NULL) 179: { 180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 181: return; 182: } 183: 184: if (((*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 185: .suivant).suivant).donnee = allocation(s_etat_processus, REL)) 186: == NULL) 187: { 188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 189: return; 190: } 191: 192: (*((real8 *) (*(*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 193: .objet)).suivant).suivant).donnee).objet)) = 194: (*s_etat_processus).echelle_3D; 195: 196: (*((*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 197: .suivant)).suivant)).suivant = NULL; 198: 199: (*s_objet_resultat).objet = l_nouvelle_base; 200: l_ancienne_base = (*s_objet_resultat).objet; 201: 202: // Type en cours 203: 204: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 205: { 206: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 207: return; 208: } 209: 210: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, CHN)) 211: == NULL) 212: { 213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 214: return; 215: } 216: 217: (*l_nouvelle_base).suivant = l_ancienne_base; 218: 219: if (strcmp((*s_etat_processus).type_trace_eq, "FONCTION") == 0) 220: { 221: if (((*(*l_nouvelle_base).donnee).objet = malloc(9 * 222: sizeof(unsigned char))) == NULL) 223: { 224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 225: return; 226: } 227: 228: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 229: "FUNCTION"); 230: } 231: else if (strcmp((*s_etat_processus).type_trace_eq, "PARAMETRIQUE") == 0) 232: { 233: if (((*(*l_nouvelle_base).donnee).objet = malloc(11 * 234: sizeof(unsigned char))) == NULL) 235: { 236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 237: return; 238: } 239: 240: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 241: "PARAMETRIC"); 242: } 243: else if (strcmp((*s_etat_processus).type_trace_eq, "POLAIRE") == 0) 244: { 245: if (((*(*l_nouvelle_base).donnee).objet = malloc(6 * 246: sizeof(unsigned char))) == NULL) 247: { 248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 249: return; 250: } 251: 252: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 253: "POLAR"); 254: } 255: else if (strcmp((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU") 256: == 0) 257: { 258: if (((*(*l_nouvelle_base).donnee).objet = malloc(6 * 259: sizeof(unsigned char))) == NULL) 260: { 261: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 262: return; 263: } 264: 265: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 266: "SLICE"); 267: } 268: else if (strcmp((*s_etat_processus).type_trace_eq, "GRILLE 3D") == 0) 269: { 270: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 271: sizeof(unsigned char))) == NULL) 272: { 273: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 274: return; 275: } 276: 277: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 278: "WIREFRAME"); 279: } 280: else 281: { 282: if (((*(*l_nouvelle_base).donnee).objet = malloc( 283: sizeof(unsigned char))) == NULL) 284: { 285: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 286: return; 287: } 288: 289: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, ""); 290: } 291: 292: (*s_objet_resultat).objet = l_nouvelle_base; 293: l_ancienne_base = (*s_objet_resultat).objet; 294: 295: // Résolution 296: 297: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 298: { 299: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 300: return; 301: } 302: 303: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, REL)) 304: == NULL) 305: { 306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 307: return; 308: } 309: 310: (*l_nouvelle_base).suivant = l_ancienne_base; 311: (*((real8 *) (*(*l_nouvelle_base).donnee).objet)) = 312: (*s_etat_processus).resolution; 313: (*s_objet_resultat).objet = l_nouvelle_base; 314: l_ancienne_base = (*s_objet_resultat).objet; 315: 316: // DEPND 317: 318: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 319: { 320: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 321: return; 322: } 323: 324: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus, 325: (*s_etat_processus).depend, 'O')) == NULL) 326: { 327: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 328: return; 329: } 330: 331: (*l_nouvelle_base).suivant = l_ancienne_base; 332: (*s_objet_resultat).objet = l_nouvelle_base; 333: l_ancienne_base = (*s_objet_resultat).objet; 334: 335: // INDEP 336: 337: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 338: { 339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 340: return; 341: } 342: 343: if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus, 344: (*s_etat_processus).indep, 'O')) == NULL) 345: { 346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 347: return; 348: } 349: 350: (*l_nouvelle_base).suivant = l_ancienne_base; 351: (*s_objet_resultat).objet = l_nouvelle_base; 352: l_ancienne_base = (*s_objet_resultat).objet; 353: 354: // Coordonnées Z2 355: 356: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 357: { 358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 359: return; 360: } 361: 362: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 363: == NULL) 364: { 365: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 366: return; 367: } 368: 369: if ((*s_etat_processus).echelle_automatique_z2 == d_vrai) 370: { 371: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 372: sizeof(unsigned char))) == NULL) 373: { 374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 375: return; 376: } 377: 378: (*(*l_nouvelle_base).donnee).type = CHN; 379: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 380: "AUTOMATIC"); 381: } 382: else 383: { 384: (*(*l_nouvelle_base).donnee).type = LST; 385: 386: if (((*(*l_nouvelle_base).donnee).objet = 387: allocation_maillon(s_etat_processus)) == NULL) 388: { 389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 390: return; 391: } 392: 393: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 394: .donnee = allocation(s_etat_processus, REL)) == NULL) 395: { 396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 397: return; 398: } 399: 400: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 401: .objet)).donnee)).objet)) = (*s_etat_processus).z2_min; 402: 403: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 404: .suivant = allocation_maillon(s_etat_processus)) == NULL) 405: { 406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 407: return; 408: } 409: 410: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 411: .suivant).suivant = NULL; 412: 413: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 414: .suivant).donnee = allocation(s_etat_processus, REL)) 415: == NULL) 416: { 417: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 418: return; 419: } 420: 421: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 422: .donnee).objet)).suivant).donnee)).objet)) = 423: (*s_etat_processus).z2_max; 424: } 425: 426: (*l_nouvelle_base).suivant = l_ancienne_base; 427: (*s_objet_resultat).objet = l_nouvelle_base; 428: l_ancienne_base = (*s_objet_resultat).objet; 429: 430: // Coordonnées Y2 431: 432: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 433: { 434: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 435: return; 436: } 437: 438: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 439: == NULL) 440: { 441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 442: return; 443: } 444: 445: if ((*s_etat_processus).echelle_automatique_y2 == d_vrai) 446: { 447: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 448: sizeof(unsigned char))) == NULL) 449: { 450: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 451: return; 452: } 453: 454: (*(*l_nouvelle_base).donnee).type = CHN; 455: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 456: "AUTOMATIC"); 457: } 458: else 459: { 460: (*(*l_nouvelle_base).donnee).type = LST; 461: 462: if (((*(*l_nouvelle_base).donnee).objet = 463: allocation_maillon(s_etat_processus)) == NULL) 464: { 465: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 466: return; 467: } 468: 469: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 470: .donnee = allocation(s_etat_processus, REL)) == NULL) 471: { 472: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 473: return; 474: } 475: 476: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 477: .objet)).donnee)).objet)) = (*s_etat_processus).y2_min; 478: 479: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 480: .suivant = allocation_maillon(s_etat_processus)) == NULL) 481: { 482: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 483: return; 484: } 485: 486: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 487: .suivant).suivant = NULL; 488: 489: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 490: .suivant).donnee = allocation(s_etat_processus, REL)) 491: == NULL) 492: { 493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 494: return; 495: } 496: 497: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 498: .donnee).objet)).suivant).donnee)).objet)) = 499: (*s_etat_processus).y2_max; 500: } 501: 502: (*l_nouvelle_base).suivant = l_ancienne_base; 503: (*s_objet_resultat).objet = l_nouvelle_base; 504: l_ancienne_base = (*s_objet_resultat).objet; 505: 506: // Coordonnées X2 507: 508: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 509: { 510: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 511: return; 512: } 513: 514: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 515: == NULL) 516: { 517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 518: return; 519: } 520: 521: if ((*s_etat_processus).echelle_automatique_x2 == d_vrai) 522: { 523: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 524: sizeof(unsigned char))) == NULL) 525: { 526: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 527: return; 528: } 529: 530: (*(*l_nouvelle_base).donnee).type = CHN; 531: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 532: "AUTOMATIC"); 533: } 534: else 535: { 536: (*(*l_nouvelle_base).donnee).type = LST; 537: 538: if (((*(*l_nouvelle_base).donnee).objet = 539: allocation_maillon(s_etat_processus)) == NULL) 540: { 541: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 542: return; 543: } 544: 545: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 546: .donnee = allocation(s_etat_processus, REL)) == NULL) 547: { 548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 549: return; 550: } 551: 552: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 553: .objet)).donnee)).objet)) = (*s_etat_processus).x2_min; 554: 555: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 556: .suivant = allocation_maillon(s_etat_processus)) == NULL) 557: { 558: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 559: return; 560: } 561: 562: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 563: .suivant).suivant = NULL; 564: 565: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 566: .suivant).donnee = allocation(s_etat_processus, REL)) 567: == NULL) 568: { 569: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 570: return; 571: } 572: 573: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 574: .donnee).objet)).suivant).donnee)).objet)) = 575: (*s_etat_processus).x2_max; 576: } 577: 578: (*l_nouvelle_base).suivant = l_ancienne_base; 579: (*s_objet_resultat).objet = l_nouvelle_base; 580: l_ancienne_base = (*s_objet_resultat).objet; 581: 582: // Coordonnées Z 583: 584: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 585: { 586: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 587: return; 588: } 589: 590: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 591: == NULL) 592: { 593: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 594: return; 595: } 596: 597: if ((*s_etat_processus).echelle_automatique_z == d_vrai) 598: { 599: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 600: sizeof(unsigned char))) == NULL) 601: { 602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 603: return; 604: } 605: 606: (*(*l_nouvelle_base).donnee).type = CHN; 607: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 608: "AUTOMATIC"); 609: } 610: else 611: { 612: (*(*l_nouvelle_base).donnee).type = LST; 613: 614: if (((*(*l_nouvelle_base).donnee).objet = 615: allocation_maillon(s_etat_processus)) == NULL) 616: { 617: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 618: return; 619: } 620: 621: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 622: .donnee = allocation(s_etat_processus, REL)) == NULL) 623: { 624: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 625: return; 626: } 627: 628: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 629: .objet)).donnee)).objet)) = (*s_etat_processus).z_min; 630: 631: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 632: .suivant = allocation_maillon(s_etat_processus)) == NULL) 633: { 634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 635: return; 636: } 637: 638: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 639: .suivant).suivant = NULL; 640: 641: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 642: .suivant).donnee = allocation(s_etat_processus, REL)) 643: == NULL) 644: { 645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 646: return; 647: } 648: 649: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 650: .donnee).objet)).suivant).donnee)).objet)) = 651: (*s_etat_processus).z_max; 652: } 653: 654: (*l_nouvelle_base).suivant = l_ancienne_base; 655: (*s_objet_resultat).objet = l_nouvelle_base; 656: l_ancienne_base = (*s_objet_resultat).objet; 657: 658: // Coordonnées Y 659: 660: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 661: { 662: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 663: return; 664: } 665: 666: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 667: == NULL) 668: { 669: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 670: return; 671: } 672: 673: if ((*s_etat_processus).echelle_automatique_y == d_vrai) 674: { 675: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 676: sizeof(unsigned char))) == NULL) 677: { 678: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 679: return; 680: } 681: 682: (*(*l_nouvelle_base).donnee).type = CHN; 683: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 684: "AUTOMATIC"); 685: } 686: else 687: { 688: (*(*l_nouvelle_base).donnee).type = LST; 689: 690: if (((*(*l_nouvelle_base).donnee).objet = 691: allocation_maillon(s_etat_processus)) == NULL) 692: { 693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 694: return; 695: } 696: 697: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 698: .donnee = allocation(s_etat_processus, REL)) == NULL) 699: { 700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 701: return; 702: } 703: 704: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 705: .objet)).donnee)).objet)) = (*s_etat_processus).y_min; 706: 707: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 708: .suivant = allocation_maillon(s_etat_processus)) == NULL) 709: { 710: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 711: return; 712: } 713: 714: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 715: .suivant).suivant = NULL; 716: 717: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 718: .suivant).donnee = allocation(s_etat_processus, REL)) 719: == NULL) 720: { 721: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 722: return; 723: } 724: 725: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 726: .donnee).objet)).suivant).donnee)).objet)) = 727: (*s_etat_processus).y_max; 728: } 729: 730: (*l_nouvelle_base).suivant = l_ancienne_base; 731: (*s_objet_resultat).objet = l_nouvelle_base; 732: l_ancienne_base = (*s_objet_resultat).objet; 733: 734: // Coordonnées X 735: 736: if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL) 737: { 738: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 739: return; 740: } 741: 742: if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON)) 743: == NULL) 744: { 745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 746: return; 747: } 748: 749: if ((*s_etat_processus).echelle_automatique_x == d_vrai) 750: { 751: if (((*(*l_nouvelle_base).donnee).objet = malloc(10 * 752: sizeof(unsigned char))) == NULL) 753: { 754: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 755: return; 756: } 757: 758: (*(*l_nouvelle_base).donnee).type = CHN; 759: strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, 760: "AUTOMATIC"); 761: } 762: else 763: { 764: (*(*l_nouvelle_base).donnee).type = LST; 765: 766: if (((*(*l_nouvelle_base).donnee).objet = 767: allocation_maillon(s_etat_processus)) == NULL) 768: { 769: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 770: return; 771: } 772: 773: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 774: .donnee = allocation(s_etat_processus, REL)) == NULL) 775: { 776: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 777: return; 778: } 779: 780: (*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee) 781: .objet)).donnee)).objet)) = (*s_etat_processus).x_min; 782: 783: if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 784: .suivant = allocation_maillon(s_etat_processus)) == NULL) 785: { 786: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 787: return; 788: } 789: 790: (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 791: .suivant).suivant = NULL; 792: 793: if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)) 794: .suivant).donnee = allocation(s_etat_processus, REL)) 795: == NULL) 796: { 797: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 798: return; 799: } 800: 801: (*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base) 802: .donnee).objet)).suivant).donnee)).objet)) = 803: (*s_etat_processus).x_max; 804: } 805: 806: (*l_nouvelle_base).suivant = l_ancienne_base; 807: (*s_objet_resultat).objet = l_nouvelle_base; 808: 809: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 810: s_objet_resultat) == d_erreur) 811: { 812: return; 813: } 814: 815: return; 816: } 817: 818: 819: /* 820: ================================================================================ 821: Fonction 'plotter' (passe en mode d'affichage relié) 822: ================================================================================ 823: Entrées : structure processus 824: -------------------------------------------------------------------------------- 825: Sorties : 826: -------------------------------------------------------------------------------- 827: Effets de bord : néant 828: ================================================================================ 829: */ 830: 831: void 832: instruction_plotter(struct_processus *s_etat_processus) 833: { 834: (*s_etat_processus).erreur_execution = d_ex; 835: 836: if ((*s_etat_processus).affichage_arguments == 'Y') 837: { 838: printf("\n PLOTTER "); 839: 840: if ((*s_etat_processus).langue == 'F') 841: { 842: printf("(nuage de points reliés entre eux)\n\n"); 843: printf(" Aucun argument\n"); 844: } 845: else 846: { 847: printf("(plotter mode)\n\n"); 848: printf(" No argument\n"); 849: } 850: 851: return; 852: } 853: else if ((*s_etat_processus).test_instruction == 'Y') 854: { 855: (*s_etat_processus).nombre_arguments = -1; 856: return; 857: } 858: 859: strcpy((*s_etat_processus).type_trace_sigma, "TABLE TRACANTE"); 860: 861: return; 862: } 863: 864: 865: /* 866: ================================================================================ 867: Fonction 'paper' 868: ================================================================================ 869: Entrées : 870: -------------------------------------------------------------------------------- 871: Sorties : 872: -------------------------------------------------------------------------------- 873: Effets de bord : néant 874: ================================================================================ 875: */ 876: 877: void 878: instruction_paper(struct_processus *s_etat_processus) 879: { 880: struct_objet *s_objet_argument; 881: 882: unsigned char *tampon; 883: 884: (*s_etat_processus).erreur_execution = d_ex; 885: 886: if ((*s_etat_processus).affichage_arguments == 'Y') 887: { 888: printf("\n PAPER "); 889: 890: if ((*s_etat_processus).langue == 'F') 891: { 892: printf("(format de papier)\n\n"); 893: } 894: else 895: { 896: printf("(paper format)\n\n"); 897: } 898: 899: printf(" 1: %s\n\n", d_CHN); 900: 901: if ((*s_etat_processus).langue == 'F') 902: { 903: printf(" Formats :\n\n"); 904: } 905: else 906: { 907: printf(" Format:\n\n"); 908: } 909: 910: printf(" A4, A5, B5, EXECUTIVE, LETTER, LEGAL\n"); 911: 912: return; 913: } 914: else if ((*s_etat_processus).test_instruction == 'Y') 915: { 916: (*s_etat_processus).nombre_arguments = -1; 917: return; 918: } 919: 920: if (test_cfsf(s_etat_processus, 31) == d_vrai) 921: { 922: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 923: { 924: return; 925: } 926: } 927: 928: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 929: &s_objet_argument) == d_erreur) 930: { 931: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 932: return; 933: } 934: 935: if ((*s_objet_argument).type == CHN) 936: { 937: if ((tampon = conversion_majuscule((unsigned char *) 938: (*s_objet_argument).objet)) == NULL) 939: 940: { 941: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 942: return; 943: } 944: 945: if (strcmp(tampon, "A4") == 0) 946: { 947: strcpy((*s_etat_processus).format_papier, "a4paper"); 948: } 949: else if (strcmp(tampon, "A5") == 0) 950: { 951: strcpy((*s_etat_processus).format_papier, "a5paper"); 952: } 953: else if (strcmp(tampon, "B5") == 0) 954: { 955: strcpy((*s_etat_processus).format_papier, "b5paper"); 956: } 957: else if (strcmp(tampon, "LETTER") == 0) 958: { 959: strcpy((*s_etat_processus).format_papier, "letterpaper"); 960: } 961: else if (strcmp(tampon, "LEGAL") == 0) 962: { 963: strcpy((*s_etat_processus).format_papier, "legalpaper"); 964: } 965: else if (strcmp(tampon, "EXECUTIVE") == 0) 966: { 967: strcpy((*s_etat_processus).format_papier, "executivepaper"); 968: } 969: else 970: { 971: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 972: } 973: 974: free(tampon); 975: } 976: else 977: { 978: liberation(s_etat_processus, s_objet_argument); 979: 980: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 981: return; 982: } 983: 984: liberation(s_etat_processus, s_objet_argument); 985: 986: return; 987: } 988: 989: // vim: ts=4