Annotation of rpl/src/instructions_p6.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: 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_p6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src