Annotation of rpl/src/instructions_e3.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 '='
! 29: ================================================================================
! 30: Entrées : pointeur sur une structure struct_processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_egalite(struct_processus *s_etat_processus)
! 40: {
! 41: struct_liste_chainee *l_element_courant;
! 42: struct_liste_chainee *l_element_precedent;
! 43:
! 44: struct_objet *s_copie_argument_1;
! 45: struct_objet *s_copie_argument_2;
! 46: struct_objet *s_objet_argument_1;
! 47: struct_objet *s_objet_argument_2;
! 48: struct_objet *s_objet_resultat;
! 49:
! 50: unsigned long nombre_egalites;
! 51: unsigned long nombre_elements;
! 52:
! 53: (*s_etat_processus).erreur_execution = d_ex;
! 54:
! 55: if ((*s_etat_processus).affichage_arguments == 'Y')
! 56: {
! 57: printf("\n = ");
! 58:
! 59: if ((*s_etat_processus).langue == 'F')
! 60: {
! 61: printf("(égalité algébrique)\n\n");
! 62: }
! 63: else
! 64: {
! 65: printf("(algebraic equality)\n\n");
! 66: }
! 67:
! 68: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
! 69: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
! 70: printf("-> 1: %s\n\n", d_ALG);
! 71:
! 72: printf(" 2: %s\n", d_ALG);
! 73: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
! 74: printf("-> 1: %s\n\n", d_ALG);
! 75:
! 76: printf(" 2: %s\n", d_RPN);
! 77: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_INT, d_REL, d_CPL);
! 78: printf("-> 1: %s\n\n", d_RPN);
! 79:
! 80: printf(" 2: %s, %s, %s, %s, %s\n", d_ALG, d_NOM, d_INT,
! 81: d_REL, d_CPL);
! 82: printf(" 1: %s\n", d_ALG);
! 83: printf("-> 1: %s\n\n", d_ALG);
! 84:
! 85: printf(" 2: %s, %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT,
! 86: d_REL, d_CPL);
! 87: printf(" 1: %s\n", d_RPN);
! 88: printf("-> 1: %s\n", d_RPN);
! 89:
! 90: return;
! 91: }
! 92: else if ((*s_etat_processus).test_instruction == 'Y')
! 93: {
! 94: (*s_etat_processus).nombre_arguments = 0;
! 95: return;
! 96: }
! 97:
! 98: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 99: {
! 100: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 101: {
! 102: return;
! 103: }
! 104: }
! 105:
! 106: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 107: &s_objet_argument_1) == d_erreur)
! 108: {
! 109: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 110: return;
! 111: }
! 112:
! 113: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 114: &s_objet_argument_2) == d_erreur)
! 115: {
! 116: liberation(s_etat_processus, s_objet_argument_1);
! 117:
! 118: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 119: return;
! 120: }
! 121:
! 122: /*
! 123: * Nom ou valeur numérique / Nom ou valeur numérique
! 124: */
! 125:
! 126: if ((((*s_objet_argument_1).type == NOM) ||
! 127: ((*s_objet_argument_1).type == INT) ||
! 128: ((*s_objet_argument_1).type == REL) ||
! 129: ((*s_objet_argument_1).type == CPL)) &&
! 130: (((*s_objet_argument_2).type == NOM) ||
! 131: ((*s_objet_argument_2).type == INT) ||
! 132: ((*s_objet_argument_2).type == REL) ||
! 133: ((*s_objet_argument_2).type == CPL)))
! 134: {
! 135: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 136: {
! 137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 138: return;
! 139: }
! 140:
! 141: if (((*s_objet_resultat).objet =
! 142: allocation_maillon(s_etat_processus)) == NULL)
! 143: {
! 144: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 145: return;
! 146: }
! 147:
! 148: l_element_courant = (*s_objet_resultat).objet;
! 149:
! 150: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 151: == NULL)
! 152: {
! 153: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 154: return;
! 155: }
! 156:
! 157: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 158: .nombre_arguments = 0;
! 159: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 160: .fonction = instruction_vers_niveau_superieur;
! 161:
! 162: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 163: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 164: {
! 165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 166: return;
! 167: }
! 168:
! 169: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 170: .nom_fonction, "<<");
! 171:
! 172: if (((*l_element_courant).suivant =
! 173: allocation_maillon(s_etat_processus)) == NULL)
! 174: {
! 175: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 176: return;
! 177: }
! 178:
! 179: l_element_courant = (*l_element_courant).suivant;
! 180: (*l_element_courant).donnee = s_objet_argument_2;
! 181:
! 182: if (((*l_element_courant).suivant =
! 183: allocation_maillon(s_etat_processus)) == NULL)
! 184: {
! 185: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 186: return;
! 187: }
! 188:
! 189: l_element_courant = (*l_element_courant).suivant;
! 190: (*l_element_courant).donnee = s_objet_argument_1;
! 191:
! 192: if (((*l_element_courant).suivant =
! 193: allocation_maillon(s_etat_processus)) == NULL)
! 194: {
! 195: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 196: return;
! 197: }
! 198:
! 199: l_element_courant = (*l_element_courant).suivant;
! 200:
! 201: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 202: == NULL)
! 203: {
! 204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 205: return;
! 206: }
! 207:
! 208: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 209: .nombre_arguments = 0;
! 210: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 211: .fonction = instruction_egalite;
! 212:
! 213: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 214: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
! 215: {
! 216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 217: return;
! 218: }
! 219:
! 220: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 221: .nom_fonction, "=");
! 222:
! 223: if (((*l_element_courant).suivant =
! 224: allocation_maillon(s_etat_processus)) == NULL)
! 225: {
! 226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 227: return;
! 228: }
! 229:
! 230: l_element_courant = (*l_element_courant).suivant;
! 231:
! 232: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 233: == NULL)
! 234: {
! 235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 236: return;
! 237: }
! 238:
! 239: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 240: .nombre_arguments = 0;
! 241: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 242: .fonction = instruction_vers_niveau_inferieur;
! 243:
! 244: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 245: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 246: {
! 247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 248: return;
! 249: }
! 250:
! 251: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 252: .nom_fonction, ">>");
! 253:
! 254: (*l_element_courant).suivant = NULL;
! 255:
! 256: s_objet_argument_1 = NULL;
! 257: s_objet_argument_2 = NULL;
! 258: }
! 259:
! 260: /*
! 261: * Nom ou valeur numérique / Expression
! 262: */
! 263:
! 264: else if ((((*s_objet_argument_1).type == ALG) ||
! 265: ((*s_objet_argument_1).type == RPN)) &&
! 266: (((*s_objet_argument_2).type == NOM) ||
! 267: ((*s_objet_argument_2).type == INT) ||
! 268: ((*s_objet_argument_2).type == REL) ||
! 269: ((*s_objet_argument_2).type == CPL)))
! 270: {
! 271: nombre_elements = 0;
! 272: l_element_courant = (struct_liste_chainee *)
! 273: (*s_objet_argument_1).objet;
! 274:
! 275: while(l_element_courant != NULL)
! 276: {
! 277: nombre_elements++;
! 278: l_element_courant = (*l_element_courant).suivant;
! 279: }
! 280:
! 281: if (nombre_elements == 2)
! 282: {
! 283: liberation(s_etat_processus, s_objet_argument_1);
! 284: liberation(s_etat_processus, s_objet_argument_2);
! 285:
! 286: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 287: return;
! 288: }
! 289:
! 290: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 291: s_objet_argument_1, 'N')) == NULL)
! 292: {
! 293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 294: return;
! 295: }
! 296:
! 297: l_element_courant = (struct_liste_chainee *)
! 298: (*s_objet_resultat).objet;
! 299: l_element_precedent = l_element_courant;
! 300: l_element_courant = (*l_element_courant).suivant;
! 301:
! 302: if (((*l_element_precedent).suivant =
! 303: allocation_maillon(s_etat_processus)) == NULL)
! 304: {
! 305: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 306: return;
! 307: }
! 308:
! 309: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
! 310: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 311:
! 312: while((*l_element_courant).suivant != NULL)
! 313: {
! 314: l_element_precedent = l_element_courant;
! 315: l_element_courant = (*l_element_courant).suivant;
! 316: }
! 317:
! 318: if (((*l_element_precedent).suivant =
! 319: allocation_maillon(s_etat_processus)) == NULL)
! 320: {
! 321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 322: return;
! 323: }
! 324:
! 325: if (((*(*l_element_precedent).suivant).donnee =
! 326: allocation(s_etat_processus, FCT)) == NULL)
! 327: {
! 328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 329: return;
! 330: }
! 331:
! 332: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 333: .donnee).objet)).nombre_arguments = 0;
! 334: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 335: .donnee).objet)).fonction = instruction_egalite;
! 336:
! 337: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 338: .suivant).donnee).objet)).nom_fonction =
! 339: malloc(2 * sizeof(unsigned char))) == NULL)
! 340: {
! 341: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 342: return;
! 343: }
! 344:
! 345: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 346: .suivant).donnee).objet)).nom_fonction, "=");
! 347:
! 348: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 349:
! 350: s_objet_argument_2 = NULL;
! 351: }
! 352:
! 353: /*
! 354: * Expression / Nom ou valeur numérique
! 355: */
! 356:
! 357: else if ((((*s_objet_argument_1).type == NOM) ||
! 358: ((*s_objet_argument_1).type == INT) ||
! 359: ((*s_objet_argument_1).type == REL) ||
! 360: ((*s_objet_argument_1).type == CPL)) &&
! 361: (((*s_objet_argument_2).type == ALG) ||
! 362: ((*s_objet_argument_2).type == RPN)))
! 363: {
! 364: nombre_elements = 0;
! 365: l_element_courant = (struct_liste_chainee *)
! 366: (*s_objet_argument_2).objet;
! 367:
! 368: while(l_element_courant != NULL)
! 369: {
! 370: nombre_elements++;
! 371: l_element_courant = (*l_element_courant).suivant;
! 372: }
! 373:
! 374: if (nombre_elements == 2)
! 375: {
! 376: liberation(s_etat_processus, s_objet_argument_1);
! 377: liberation(s_etat_processus, s_objet_argument_2);
! 378:
! 379: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 380: return;
! 381: }
! 382:
! 383: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 384: s_objet_argument_2, 'N')) == NULL)
! 385: {
! 386: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 387: return;
! 388: }
! 389:
! 390: l_element_courant = (struct_liste_chainee *)
! 391: (*s_objet_resultat).objet;
! 392: l_element_precedent = l_element_courant;
! 393:
! 394: while((*l_element_courant).suivant != NULL)
! 395: {
! 396: l_element_precedent = l_element_courant;
! 397: l_element_courant = (*l_element_courant).suivant;
! 398: }
! 399:
! 400: if (((*l_element_precedent).suivant =
! 401: allocation_maillon(s_etat_processus)) == NULL)
! 402: {
! 403: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 404: return;
! 405: }
! 406:
! 407: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 408: l_element_precedent = (*l_element_precedent).suivant;
! 409:
! 410: if (((*l_element_precedent).suivant =
! 411: allocation_maillon(s_etat_processus)) == NULL)
! 412: {
! 413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 414: return;
! 415: }
! 416:
! 417: if (((*(*l_element_precedent).suivant).donnee =
! 418: allocation(s_etat_processus, FCT)) == NULL)
! 419: {
! 420: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 421: return;
! 422: }
! 423:
! 424: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 425: .donnee).objet)).nombre_arguments = 0;
! 426: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 427: .donnee).objet)).fonction = instruction_egalite;
! 428:
! 429: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 430: .suivant).donnee).objet)).nom_fonction =
! 431: malloc(2 * sizeof(unsigned char))) == NULL)
! 432: {
! 433: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 434: return;
! 435: }
! 436:
! 437: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 438: .suivant).donnee).objet)).nom_fonction, "=");
! 439:
! 440: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 441:
! 442: s_objet_argument_1 = NULL;
! 443: }
! 444:
! 445: /*
! 446: * Expression / Expression
! 447: */
! 448:
! 449: else if ((((*s_objet_argument_1).type == ALG) &&
! 450: ((*s_objet_argument_2).type == ALG)) ||
! 451: (((*s_objet_argument_1).type == RPN) &&
! 452: ((*s_objet_argument_2).type == RPN)))
! 453: {
! 454: nombre_elements = 0;
! 455: l_element_courant = (struct_liste_chainee *)
! 456: (*s_objet_argument_1).objet;
! 457:
! 458: while(l_element_courant != NULL)
! 459: {
! 460: nombre_elements++;
! 461: l_element_courant = (*l_element_courant).suivant;
! 462: }
! 463:
! 464: if (nombre_elements == 2)
! 465: {
! 466: liberation(s_etat_processus, s_objet_argument_1);
! 467: liberation(s_etat_processus, s_objet_argument_2);
! 468:
! 469: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 470: return;
! 471: }
! 472:
! 473: nombre_elements = 0;
! 474: l_element_courant = (struct_liste_chainee *)
! 475: (*s_objet_argument_2).objet;
! 476:
! 477: while(l_element_courant != NULL)
! 478: {
! 479: nombre_elements++;
! 480: l_element_courant = (*l_element_courant).suivant;
! 481: }
! 482:
! 483: if (nombre_elements == 2)
! 484: {
! 485: liberation(s_etat_processus, s_objet_argument_1);
! 486: liberation(s_etat_processus, s_objet_argument_2);
! 487:
! 488: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 489: return;
! 490: }
! 491:
! 492: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
! 493: s_objet_argument_1, 'N')) == NULL)
! 494: {
! 495: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 496: return;
! 497: }
! 498:
! 499: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 500: s_objet_argument_2, 'N')) == NULL)
! 501: {
! 502: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 503: return;
! 504: }
! 505:
! 506: l_element_courant = (struct_liste_chainee *)
! 507: (*s_copie_argument_1).objet;
! 508: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
! 509: (*s_copie_argument_1).objet)).suivant;
! 510:
! 511: liberation(s_etat_processus, (*l_element_courant).donnee);
! 512: free(l_element_courant);
! 513:
! 514: l_element_courant = (struct_liste_chainee *)
! 515: (*s_copie_argument_2).objet;
! 516: l_element_precedent = l_element_courant;
! 517: s_objet_resultat = s_copie_argument_2;
! 518:
! 519: while((*l_element_courant).suivant != NULL)
! 520: {
! 521: l_element_precedent = l_element_courant;
! 522: l_element_courant = (*l_element_courant).suivant;
! 523: }
! 524:
! 525: liberation(s_etat_processus, (*l_element_courant).donnee);
! 526: free(l_element_courant);
! 527:
! 528: (*l_element_precedent).suivant = (struct_liste_chainee *)
! 529: (*s_copie_argument_1).objet;
! 530: free(s_copie_argument_1);
! 531:
! 532: l_element_courant = (*l_element_precedent).suivant;
! 533: while((*l_element_courant).suivant != NULL)
! 534: {
! 535: l_element_precedent = l_element_courant;
! 536: l_element_courant = (*l_element_courant).suivant;
! 537: }
! 538:
! 539: if (((*l_element_precedent).suivant =
! 540: allocation_maillon(s_etat_processus)) == NULL)
! 541: {
! 542: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 543: return;
! 544: }
! 545:
! 546: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 547: l_element_courant = (*l_element_precedent).suivant;
! 548:
! 549: if (((*l_element_courant).donnee =
! 550: allocation(s_etat_processus, FCT)) == NULL)
! 551: {
! 552: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 553: return;
! 554: }
! 555:
! 556: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 557: .nombre_arguments = 0;
! 558: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 559: .fonction = instruction_egalite;
! 560:
! 561: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 562: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
! 563: {
! 564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 565: return;
! 566: }
! 567:
! 568: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 569: .nom_fonction, "=");
! 570: }
! 571: else
! 572: {
! 573: liberation(s_etat_processus, s_objet_argument_1);
! 574: liberation(s_etat_processus, s_objet_argument_2);
! 575:
! 576: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 577: return;
! 578: }
! 579:
! 580: liberation(s_etat_processus, s_objet_argument_1);
! 581: liberation(s_etat_processus, s_objet_argument_2);
! 582:
! 583: /*
! 584: * Vérification du nombre d'égalités dans l'expression
! 585: */
! 586:
! 587: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
! 588: nombre_egalites = 0;
! 589:
! 590: while(l_element_courant != NULL)
! 591: {
! 592: if ((*(*l_element_courant).donnee).type == FCT)
! 593: {
! 594: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee)
! 595: .objet)).nom_fonction, "=") == 0)
! 596: {
! 597: nombre_egalites++;
! 598: }
! 599: }
! 600:
! 601: l_element_courant = (*l_element_courant).suivant;
! 602: }
! 603:
! 604: if (nombre_egalites != 1)
! 605: {
! 606: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 607:
! 608: liberation(s_etat_processus, s_objet_resultat);
! 609: return;
! 610: }
! 611:
! 612: /*
! 613: * Empilement du résultat
! 614: */
! 615:
! 616: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 617: s_objet_resultat) == d_erreur)
! 618: {
! 619: return;
! 620: }
! 621:
! 622: return;
! 623: }
! 624:
! 625:
! 626: /*
! 627: ================================================================================
! 628: Fonction 'eyept'
! 629: ================================================================================
! 630: Entrées : pointeur sur une structure struct_processus
! 631: --------------------------------------------------------------------------------
! 632: Sorties :
! 633: --------------------------------------------------------------------------------
! 634: Effets de bord : néant
! 635: ================================================================================
! 636: */
! 637:
! 638: void
! 639: instruction_eyept(struct_processus *s_etat_processus)
! 640: {
! 641: double deux_pi;
! 642:
! 643: long nombre_arguments;
! 644:
! 645: struct_liste_chainee *l_element_courant;
! 646:
! 647: struct_objet *s_objet_argument;
! 648: struct_objet *s_objet_auxiliaire;
! 649:
! 650: (*s_etat_processus).erreur_execution = d_ex;
! 651:
! 652: if ((*s_etat_processus).affichage_arguments == 'Y')
! 653: {
! 654: printf("\n EYEPT ");
! 655:
! 656: if ((*s_etat_processus).langue == 'F')
! 657: {
! 658: printf("(point de vue)\n\n");
! 659: }
! 660: else
! 661: {
! 662: printf("(eye point)\n\n");
! 663: }
! 664:
! 665: printf(" 1: %s\n\n", d_LST);
! 666:
! 667: if ((*s_etat_processus).langue == 'F')
! 668: {
! 669: printf(" Utilisation :\n\n");
! 670: }
! 671: else
! 672: {
! 673: printf(" Usage:\n\n");
! 674: }
! 675:
! 676: printf(" { theta phi scale } EYEPT\n");
! 677:
! 678: return;
! 679: }
! 680: else if ((*s_etat_processus).test_instruction == 'Y')
! 681: {
! 682: (*s_etat_processus).nombre_arguments = -1;
! 683: return;
! 684: }
! 685:
! 686: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 687: {
! 688: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 689: {
! 690: return;
! 691: }
! 692: }
! 693:
! 694: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 695: &s_objet_argument) == d_erreur)
! 696: {
! 697: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 698: return;
! 699: }
! 700:
! 701: if ((*s_objet_argument).type == LST)
! 702: {
! 703: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
! 704: nombre_arguments = 0;
! 705:
! 706: while(l_element_courant != NULL)
! 707: {
! 708: nombre_arguments++;
! 709: l_element_courant = (*l_element_courant).suivant;
! 710: }
! 711:
! 712: if ((nombre_arguments != 2) && (nombre_arguments != 3))
! 713: {
! 714: liberation(s_etat_processus, s_objet_argument);
! 715:
! 716: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 717: return;
! 718: }
! 719:
! 720: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
! 721: nombre_arguments = 0;
! 722:
! 723: while(l_element_courant != NULL)
! 724: {
! 725: nombre_arguments++;
! 726:
! 727: if (((*(*l_element_courant).donnee).type == RPN) ||
! 728: ((*(*l_element_courant).donnee).type == ALG) ||
! 729: ((*(*l_element_courant).donnee).type == NOM))
! 730: {
! 731: if (evaluation(s_etat_processus,
! 732: (*l_element_courant).donnee, 'N') == d_erreur)
! 733: {
! 734: liberation(s_etat_processus, s_objet_argument);
! 735:
! 736: return;
! 737: }
! 738:
! 739: if (depilement(s_etat_processus,
! 740: &((*s_etat_processus).l_base_pile),
! 741: &s_objet_auxiliaire) == d_erreur)
! 742: {
! 743: liberation(s_etat_processus, s_objet_argument);
! 744:
! 745: (*s_etat_processus).erreur_execution =
! 746: d_ex_manque_argument;
! 747:
! 748: return;
! 749: }
! 750:
! 751: liberation(s_etat_processus, (*l_element_courant).donnee);
! 752: (*l_element_courant).donnee = s_objet_auxiliaire;
! 753: }
! 754:
! 755: if ((*(*l_element_courant).donnee).type == INT)
! 756: {
! 757: switch(nombre_arguments)
! 758: {
! 759: case 1 :
! 760: {
! 761: (*s_etat_processus).point_de_vue_theta = (real8)
! 762: (*((integer8 *) (*(*l_element_courant).donnee)
! 763: .objet));
! 764: break;
! 765: }
! 766:
! 767: case 2 :
! 768: {
! 769: (*s_etat_processus).point_de_vue_phi = (real8)
! 770: (*((integer8 *) (*(*l_element_courant).donnee)
! 771: .objet));
! 772: break;
! 773: }
! 774:
! 775: case 3 :
! 776: {
! 777: if ((*((integer8 *) (*(*l_element_courant).donnee)
! 778: .objet)) <= 0)
! 779: {
! 780: liberation(s_etat_processus, s_objet_argument);
! 781:
! 782: (*s_etat_processus).erreur_execution =
! 783: d_ex_argument_invalide;
! 784: return;
! 785: }
! 786:
! 787: (*s_etat_processus).echelle_3D = (real8) (*((integer8 *)
! 788: (*(*l_element_courant).donnee).objet));
! 789: break;
! 790: }
! 791: }
! 792: }
! 793: else if ((*(*l_element_courant).donnee).type == REL)
! 794: {
! 795: switch(nombre_arguments)
! 796: {
! 797: case 1 :
! 798: {
! 799: (*s_etat_processus).point_de_vue_theta =
! 800: (*((real8 *) (*(*l_element_courant).donnee)
! 801: .objet));
! 802: break;
! 803: }
! 804:
! 805: case 2 :
! 806: {
! 807: (*s_etat_processus).point_de_vue_phi =
! 808: (*((real8 *) (*(*l_element_courant).donnee)
! 809: .objet));
! 810: break;
! 811: }
! 812:
! 813: case 3 :
! 814: {
! 815: if ((*((real8 *) (*(*l_element_courant).donnee)
! 816: .objet)) <= 0)
! 817: {
! 818: liberation(s_etat_processus, s_objet_argument);
! 819:
! 820: (*s_etat_processus).erreur_execution =
! 821: d_ex_argument_invalide;
! 822: return;
! 823: }
! 824:
! 825: (*s_etat_processus).echelle_3D = (*((real8 *)
! 826: (*(*l_element_courant).donnee).objet));
! 827: break;
! 828: }
! 829: }
! 830: }
! 831: else
! 832: {
! 833: liberation(s_etat_processus, s_objet_argument);
! 834:
! 835: (*s_etat_processus).erreur_execution =
! 836: d_ex_erreur_type_argument;
! 837: return;
! 838: }
! 839:
! 840: l_element_courant = (*l_element_courant).suivant;
! 841: }
! 842:
! 843: if (test_cfsf(s_etat_processus, 60) == d_faux)
! 844: {
! 845: conversion_degres_vers_radians(&((*s_etat_processus)
! 846: .point_de_vue_theta));
! 847: conversion_degres_vers_radians(&((*s_etat_processus)
! 848: .point_de_vue_phi));
! 849: }
! 850:
! 851: deux_pi = 8 * atan((real8) 1);
! 852:
! 853: (*s_etat_processus).point_de_vue_theta =
! 854: (*s_etat_processus).point_de_vue_theta - (deux_pi *
! 855: floor((*s_etat_processus).point_de_vue_theta / deux_pi));
! 856: (*s_etat_processus).point_de_vue_phi =
! 857: (*s_etat_processus).point_de_vue_phi - (deux_pi *
! 858: floor((*s_etat_processus).point_de_vue_phi / deux_pi));
! 859:
! 860: if ((*s_etat_processus).point_de_vue_phi > deux_pi)
! 861: {
! 862: (*s_etat_processus).point_de_vue_phi = deux_pi -
! 863: (*s_etat_processus).point_de_vue_phi;
! 864: (*s_etat_processus).point_de_vue_theta += (deux_pi / 2);
! 865: (*s_etat_processus).point_de_vue_theta =
! 866: (*s_etat_processus).point_de_vue_theta - (deux_pi *
! 867: floor((*s_etat_processus).point_de_vue_theta / deux_pi));
! 868: }
! 869: }
! 870: else
! 871: {
! 872: liberation(s_etat_processus, s_objet_argument);
! 873:
! 874: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 875: return;
! 876: }
! 877:
! 878: liberation(s_etat_processus, s_objet_argument);
! 879:
! 880: if (test_cfsf(s_etat_processus, 52) == d_faux)
! 881: {
! 882: if ((*s_etat_processus).fichiers_graphiques != NULL)
! 883: {
! 884: appel_gnuplot(s_etat_processus, 'N');
! 885: }
! 886: }
! 887:
! 888: return;
! 889: }
! 890:
! 891: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_e3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src