![]() ![]() | ![]() |
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 '=' 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