![]() ![]() | ![]() |
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 'autoscale' 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_autoscale(struct_processus *s_etat_processus) 40: { 41: logical1 presence[3]; 42: 43: struct_liste_chainee *l_element_courant; 44: 45: struct_objet *s_objet; 46: 47: unsigned char *tampon; 48: 49: (*s_etat_processus).erreur_execution = d_ex; 50: 51: if ((*s_etat_processus).affichage_arguments == 'Y') 52: { 53: printf("\n AUTOSCALE "); 54: 55: if ((*s_etat_processus).langue == 'F') 56: { 57: printf("(échelles automatiques)\n\n"); 58: } 59: else 60: { 61: printf("(automatic scales)\n\n"); 62: } 63: 64: printf(" 1: %s\n\n", d_NOM); 65: 66: printf(" 1: %s\n\n", d_LST); 67: 68: if ((*s_etat_processus).langue == 'F') 69: { 70: printf(" Utilisation :\n\n"); 71: } 72: else 73: { 74: printf(" Usage:\n\n"); 75: } 76: 77: printf(" { X Y } AUTOSCALE\n"); 78: printf(" { } AUTOSCALE\n"); 79: printf(" 'Z' AUTOSCALE\n"); 80: 81: return; 82: } 83: else if ((*s_etat_processus).test_instruction == 'Y') 84: { 85: (*s_etat_processus).nombre_arguments = -1; 86: return; 87: } 88: 89: if (test_cfsf(s_etat_processus, 31) == d_vrai) 90: { 91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 92: { 93: return; 94: } 95: } 96: 97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 98: &s_objet) == d_erreur) 99: { 100: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 101: return; 102: } 103: 104: if ((*s_etat_processus).systeme_axes == 0) 105: { 106: (*s_etat_processus).echelle_automatique_x = d_faux; 107: (*s_etat_processus).echelle_automatique_y = d_faux; 108: (*s_etat_processus).echelle_automatique_z = d_faux; 109: } 110: else 111: { 112: (*s_etat_processus).echelle_automatique_x2 = d_faux; 113: (*s_etat_processus).echelle_automatique_y2 = d_faux; 114: (*s_etat_processus).echelle_automatique_z2 = d_faux; 115: } 116: 117: if ((*s_objet).type == NOM) 118: { 119: tampon = conversion_majuscule((*((struct_nom *) (*s_objet).objet)).nom); 120: 121: if (tampon == NULL) 122: { 123: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 124: return; 125: } 126: 127: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) && 128: (strcmp(tampon, "Z")!= 0)) 129: { 130: liberation(s_etat_processus, s_objet); 131: free(tampon); 132: 133: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 134: return; 135: } 136: 137: if (tampon[0] == 'X') 138: { 139: if ((*s_etat_processus).systeme_axes == 0) 140: { 141: (*s_etat_processus).echelle_automatique_x = d_vrai; 142: } 143: else 144: { 145: (*s_etat_processus).echelle_automatique_x2 = d_vrai; 146: } 147: } 148: else if (tampon[0] == 'Y') 149: { 150: if ((*s_etat_processus).systeme_axes == 0) 151: { 152: (*s_etat_processus).echelle_automatique_y = d_vrai; 153: } 154: else 155: { 156: (*s_etat_processus).echelle_automatique_y2 = d_vrai; 157: } 158: } 159: else 160: { 161: if ((*s_etat_processus).systeme_axes == 0) 162: { 163: (*s_etat_processus).echelle_automatique_z = d_vrai; 164: } 165: else 166: { 167: (*s_etat_processus).echelle_automatique_z2 = d_vrai; 168: } 169: } 170: 171: free(tampon); 172: } 173: else if ((*s_objet).type == LST) 174: { 175: presence[0] = d_faux; 176: presence[1] = d_faux; 177: presence[2] = d_faux; 178: 179: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 180: 181: while(l_element_courant != NULL) 182: { 183: if ((*(*l_element_courant).donnee).type != NOM) 184: { 185: liberation(s_etat_processus, s_objet); 186: 187: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 188: return; 189: } 190: 191: tampon = conversion_majuscule((*((struct_nom *) 192: (*(*l_element_courant).donnee).objet)).nom); 193: 194: if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) && 195: (strcmp(tampon, "Z")!= 0)) 196: { 197: liberation(s_etat_processus, s_objet); 198: free(tampon); 199: 200: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 201: return; 202: } 203: 204: if (tampon[0] == 'X') 205: { 206: if (presence[0] == d_vrai) 207: { 208: free(tampon); 209: liberation(s_etat_processus, s_objet); 210: 211: (*s_etat_processus).erreur_execution = 212: d_ex_argument_invalide; 213: return; 214: } 215: 216: if ((*s_etat_processus).systeme_axes == 0) 217: { 218: (*s_etat_processus).echelle_automatique_x = d_vrai; 219: } 220: else 221: { 222: (*s_etat_processus).echelle_automatique_x2 = d_vrai; 223: } 224: 225: presence[0] = d_vrai; 226: } 227: else if (tampon[0] == 'Y') 228: { 229: if (presence[1] == d_vrai) 230: { 231: free(tampon); 232: liberation(s_etat_processus, s_objet); 233: 234: (*s_etat_processus).erreur_execution = 235: d_ex_argument_invalide; 236: return; 237: } 238: 239: if ((*s_etat_processus).systeme_axes == 0) 240: { 241: (*s_etat_processus).echelle_automatique_y = d_vrai; 242: } 243: else 244: { 245: (*s_etat_processus).echelle_automatique_y2 = d_vrai; 246: } 247: 248: presence[1] = d_vrai; 249: } 250: else 251: { 252: if (presence[2] == d_vrai) 253: { 254: free(tampon); 255: liberation(s_etat_processus, s_objet); 256: 257: (*s_etat_processus).erreur_execution = 258: d_ex_argument_invalide; 259: return; 260: } 261: 262: if ((*s_etat_processus).systeme_axes == 0) 263: { 264: (*s_etat_processus).echelle_automatique_z = d_vrai; 265: } 266: else 267: { 268: (*s_etat_processus).echelle_automatique_z2 = d_vrai; 269: } 270: 271: presence[2] = d_vrai; 272: } 273: 274: l_element_courant = (*l_element_courant).suivant; 275: free(tampon); 276: } 277: } 278: else 279: { 280: liberation(s_etat_processus, s_objet); 281: 282: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 283: return; 284: } 285: 286: liberation(s_etat_processus, s_objet); 287: 288: if (test_cfsf(s_etat_processus, 52) == d_faux) 289: { 290: if ((*s_etat_processus).fichiers_graphiques != NULL) 291: { 292: appel_gnuplot(s_etat_processus, 'N'); 293: } 294: } 295: 296: return; 297: } 298: 299: 300: /* 301: ================================================================================ 302: Fonction 'asl' 303: ================================================================================ 304: Entrées : pointeur sur une structure struct_processus 305: -------------------------------------------------------------------------------- 306: Sorties : 307: -------------------------------------------------------------------------------- 308: Effets de bord : néant 309: ================================================================================ 310: */ 311: 312: void 313: instruction_asl(struct_processus *s_etat_processus) 314: { 315: logical8 masque; 316: logical8 retenue; 317: logical8 tampon; 318: 319: struct_objet *s_copie; 320: struct_objet *s_objet; 321: 322: unsigned long i; 323: unsigned long j; 324: unsigned long longueur; 325: 326: (*s_etat_processus).erreur_execution = d_ex; 327: 328: if ((*s_etat_processus).affichage_arguments == 'Y') 329: { 330: printf("\n ASL "); 331: 332: if ((*s_etat_processus).langue == 'F') 333: { 334: printf("(décalage arithmétique à gauche)\n\n"); 335: } 336: else 337: { 338: printf("arithmetic shift left)\n\n"); 339: } 340: 341: printf(" 1: %s\n", d_BIN); 342: printf("-> 1: %s\n", d_BIN); 343: 344: return; 345: } 346: else if ((*s_etat_processus).test_instruction == 'Y') 347: { 348: (*s_etat_processus).nombre_arguments = -1; 349: return; 350: } 351: 352: if (test_cfsf(s_etat_processus, 31) == d_vrai) 353: { 354: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 355: { 356: return; 357: } 358: } 359: 360: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 361: &s_objet) == d_erreur) 362: { 363: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 364: return; 365: } 366: 367: if ((*s_objet).type == BIN) 368: { 369: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) 370: { 371: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 372: return; 373: } 374: 375: longueur = 1; 376: j = 1; 377: 378: for(i = 37; i <= 42; i++) 379: { 380: longueur += (test_cfsf(s_etat_processus, (unsigned char) i) 381: == d_vrai) ? j : 0; 382: j *= 2; 383: } 384: 385: retenue = (tampon = (*((logical8 *) (*s_copie).objet))) & (logical8) 1; 386: tampon <<= 1; 387: 388: for(masque = 0, i = 1; i < longueur; i++) 389: { 390: masque <<= 1; 391: masque |= (logical8) 1; 392: } 393: 394: masque <<= 1; 395: tampon &= masque; 396: (*((logical8 *) (*s_copie).objet)) = tampon | retenue; 397: 398: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 399: s_copie) == d_erreur) 400: { 401: return; 402: } 403: } 404: else 405: { 406: liberation(s_etat_processus, s_objet); 407: 408: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 409: return; 410: } 411: 412: liberation(s_etat_processus, s_objet); 413: 414: return; 415: } 416: 417: 418: /* 419: ================================================================================ 420: Fonction 'asr' 421: ================================================================================ 422: Entrées : pointeur sur une structure struct_processus 423: -------------------------------------------------------------------------------- 424: Sorties : 425: -------------------------------------------------------------------------------- 426: Effets de bord : néant 427: ================================================================================ 428: */ 429: 430: void 431: instruction_asr(struct_processus *s_etat_processus) 432: { 433: logical8 masque; 434: logical8 tampon; 435: 436: struct_objet *s_copie; 437: struct_objet *s_objet; 438: 439: unsigned long i; 440: unsigned long j; 441: unsigned long longueur; 442: 443: (*s_etat_processus).erreur_execution = d_ex; 444: 445: if ((*s_etat_processus).affichage_arguments == 'Y') 446: { 447: printf("\n ASR "); 448: 449: if ((*s_etat_processus).langue == 'F') 450: { 451: printf("(décalage arithmétique à droite)\n\n"); 452: } 453: else 454: { 455: printf("(arithmetic shift right)\n\n"); 456: } 457: 458: printf(" 1: %s\n", d_BIN); 459: printf("-> 1: %s\n", d_BIN); 460: 461: return; 462: } 463: else if ((*s_etat_processus).test_instruction == 'Y') 464: { 465: (*s_etat_processus).nombre_arguments = -1; 466: return; 467: } 468: 469: if (test_cfsf(s_etat_processus, 31) == d_vrai) 470: { 471: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 472: { 473: return; 474: } 475: } 476: 477: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 478: &s_objet) == d_erreur) 479: { 480: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 481: return; 482: } 483: 484: if ((*s_objet).type == BIN) 485: { 486: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL) 487: { 488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 489: return; 490: } 491: 492: longueur = 1; 493: j = 1; 494: 495: for(i = 37; i <= 42; i++) 496: { 497: longueur += (test_cfsf(s_etat_processus, (unsigned char) i) 498: == d_vrai) ? j : 0; 499: j *= 2; 500: } 501: 502: tampon = (*((logical8 *) (*s_copie).objet)); 503: masque = ((logical8) 1) << (longueur - 1); 504: 505: if ((tampon & masque) == 0) 506: { 507: tampon >>= 1; 508: } 509: else 510: { 511: tampon >>= 1; 512: tampon |= masque; 513: } 514: 515: for(masque = 0, i = 0; i < longueur; i++) 516: { 517: masque <<= 1; 518: masque |= 1; 519: } 520: 521: tampon &= masque; 522: (*((logical8 *) (*s_copie).objet)) = tampon; 523: 524: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 525: s_copie) == d_erreur) 526: { 527: return; 528: } 529: } 530: else 531: { 532: liberation(s_etat_processus, s_objet); 533: 534: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 535: return; 536: } 537: 538: liberation(s_etat_processus, s_objet); 539: 540: return; 541: } 542: 543: 544: /* 545: ================================================================================ 546: Fonction 'append' 547: ================================================================================ 548: Entrées : pointeur sur une structure struct_processus 549: -------------------------------------------------------------------------------- 550: Sorties : 551: -------------------------------------------------------------------------------- 552: Effets de bord : néant 553: ================================================================================ 554: */ 555: 556: void 557: instruction_append(struct_processus *s_etat_processus) 558: { 559: struct_descripteur_fichier *descripteur; 560: 561: struct_objet *s_objet_argument; 562: 563: (*s_etat_processus).erreur_execution = d_ex; 564: 565: if ((*s_etat_processus).affichage_arguments == 'Y') 566: { 567: printf("\n APPEND "); 568: 569: if ((*s_etat_processus).langue == 'F') 570: { 571: printf("(positionnement à la fin du fichier)\n\n"); 572: } 573: else 574: { 575: printf("(to reach the end of the file)\n\n"); 576: } 577: 578: printf(" 1: %s\n", d_FCH); 579: 580: return; 581: } 582: else if ((*s_etat_processus).test_instruction == 'Y') 583: { 584: (*s_etat_processus).nombre_arguments = -1; 585: return; 586: } 587: 588: if (test_cfsf(s_etat_processus, 31) == d_vrai) 589: { 590: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 591: { 592: return; 593: } 594: } 595: 596: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 597: &s_objet_argument) == d_erreur) 598: { 599: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 600: return; 601: } 602: 603: if ((*s_objet_argument).type == FCH) 604: { 605: if ((descripteur = descripteur_fichier(s_etat_processus, 606: (struct_fichier *) (*s_objet_argument).objet)) == NULL) 607: { 608: liberation(s_etat_processus, s_objet_argument); 609: return; 610: } 611: 612: if ((*descripteur).type == 'C') 613: { 614: if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END) != 0) 615: { 616: liberation(s_etat_processus, s_objet_argument); 617: 618: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; 619: return; 620: } 621: } 622: else 623: { 624: liberation(s_etat_processus, s_objet_argument); 625: 626: (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier; 627: return; 628: } 629: } 630: else 631: { 632: liberation(s_etat_processus, s_objet_argument); 633: 634: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 635: return; 636: } 637: 638: liberation(s_etat_processus, s_objet_argument); 639: 640: return; 641: } 642: 643: 644: /* 645: ================================================================================ 646: Fonction 'axes' 647: ================================================================================ 648: Entrées : pointeur sur une structure struct_processus 649: -------------------------------------------------------------------------------- 650: Sorties : 651: -------------------------------------------------------------------------------- 652: Effets de bord : néant 653: ================================================================================ 654: */ 655: 656: void 657: instruction_axes(struct_processus *s_etat_processus) 658: { 659: /* 660: * Prend comme argument une liste 661: */ 662: 663: logical1 autorisation_trace; 664: logical1 axes_principaux; 665: logical1 presence_type; 666: 667: long nombre_arguments_principaux; 668: long nombre_arguments_auxiliaires; 669: 670: struct_liste_chainee *l_element_courant; 671: struct_liste_chainee *l_element_courant_auxiliaire; 672: 673: struct_objet *s_objet_argument; 674: struct_objet *s_objet_auxiliaire; 675: 676: unsigned char *tampon; 677: 678: (*s_etat_processus).erreur_execution = d_ex; 679: 680: if ((*s_etat_processus).affichage_arguments == 'Y') 681: { 682: printf("\n AXES "); 683: 684: if ((*s_etat_processus).langue == 'F') 685: { 686: printf("(définition des axes)\n\n"); 687: } 688: else 689: { 690: printf("(axes definition)\n\n"); 691: } 692: 693: printf(" 1: %s\n\n", d_LST); 694: 695: if ((*s_etat_processus).langue == 'F') 696: { 697: printf(" Utilisation :\n\n"); 698: } 699: else 700: { 701: printf(" Usage:\n\n"); 702: } 703: 704: printf(" { \"MAIN\" } AXES\n"); 705: printf(" { \"AUXILIARY\" } AXES\n"); 706: printf(" { \"MAIN\" { (expression 1) (expression 2) }\n"); 707: printf(" { (expression 3) TICSONLY } } AXES\n\n"); 708: printf(" { \"MAIN\" { (expression 1) \"TICSONLY\" }\n"); 709: printf(" { (expression 2) } } AXES\n\n"); 710: printf(" { \"AUXILIARY\" { \"AUTOMATIC\" }\n"); 711: printf(" { \"TICSONLY\" \"AUTOMATIC\" } } AXES\n\n"); 712: printf(" { { (expression 1) \"DEFAULT\" } { \"AUTOMATIC\" } }\n"); 713: printf(" { \"TICSONLY\" (expression 2) } } AXES\n"); 714: 715: return; 716: } 717: else if ((*s_etat_processus).test_instruction == 'Y') 718: { 719: (*s_etat_processus).nombre_arguments = -1; 720: return; 721: } 722: 723: if (test_cfsf(s_etat_processus, 31) == d_vrai) 724: { 725: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 726: { 727: return; 728: } 729: } 730: 731: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 732: &s_objet_argument) == d_erreur) 733: { 734: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 735: return; 736: } 737: 738: if ((*s_objet_argument).type == LST) 739: { 740: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet; 741: nombre_arguments_principaux = 0; 742: presence_type = d_faux; 743: tampon = NULL; 744: 745: while(l_element_courant != NULL) 746: { 747: if ((*(*l_element_courant).donnee).type == CHN) 748: { 749: if (presence_type == d_vrai) 750: { 751: free(tampon); 752: 753: liberation(s_etat_processus, s_objet_argument); 754: 755: (*s_etat_processus).erreur_execution = 756: d_ex_argument_invalide; 757: return; 758: } 759: 760: if ((tampon = conversion_majuscule((unsigned char *) 761: (*(*l_element_courant).donnee).objet)) == NULL) 762: { 763: (*s_etat_processus).erreur_systeme = 764: d_es_allocation_memoire; 765: return; 766: } 767: 768: presence_type = d_vrai; 769: } 770: else 771: { 772: nombre_arguments_principaux++; 773: } 774: 775: l_element_courant = (*l_element_courant).suivant; 776: } 777: 778: if (presence_type == d_faux) 779: { 780: if ((tampon = malloc(5 * sizeof(unsigned char))) == NULL) 781: { 782: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 783: return; 784: } 785: 786: if ((*s_etat_processus).systeme_axes == 0) 787: { 788: strcpy(tampon, "MAIN"); 789: } 790: else 791: { 792: strcpy(tampon, "AUXILIARY"); 793: } 794: } 795: 796: if (strcmp(tampon, "MAIN") == 0) 797: { 798: axes_principaux = d_vrai; 799: (*s_etat_processus).systeme_axes = 0; 800: } 801: else if (strcmp(tampon, "AUXILIARY") == 0) 802: { 803: axes_principaux = d_faux; 804: (*s_etat_processus).systeme_axes = 1; 805: } 806: else 807: { 808: free(tampon); 809: 810: liberation(s_etat_processus, s_objet_argument); 811: 812: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 813: return; 814: } 815: 816: free(tampon); 817: 818: if ((nombre_arguments_principaux != 0) && 819: (nombre_arguments_principaux != 2) && 820: (nombre_arguments_principaux != 3)) 821: { 822: liberation(s_etat_processus, s_objet_argument); 823: 824: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 825: return; 826: } 827: 828: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet; 829: nombre_arguments_principaux = 0; 830: 831: while(l_element_courant != NULL) 832: { 833: nombre_arguments_principaux++; 834: 835: if ((*(*l_element_courant).donnee).type == CHN) 836: { 837: l_element_courant = (*l_element_courant).suivant; 838: nombre_arguments_principaux--; 839: continue; 840: } 841: else if ((*(*l_element_courant).donnee).type == LST) 842: { 843: l_element_courant_auxiliaire = (struct_liste_chainee *) 844: (*(*l_element_courant).donnee).objet; 845: nombre_arguments_auxiliaires = 0; 846: autorisation_trace = d_vrai; 847: 848: while(l_element_courant_auxiliaire != NULL) 849: { 850: nombre_arguments_auxiliaires++; 851: 852: if (((*(*l_element_courant_auxiliaire).donnee).type == 853: RPN) || ((*(*l_element_courant_auxiliaire).donnee) 854: .type == ALG) || ((*(*l_element_courant_auxiliaire) 855: .donnee).type == NOM)) 856: { 857: if (evaluation(s_etat_processus, 858: (*l_element_courant_auxiliaire).donnee, 'N') 859: == d_erreur) 860: { 861: liberation(s_etat_processus, s_objet_argument); 862: 863: return; 864: } 865: 866: if (depilement(s_etat_processus, 867: &((*s_etat_processus).l_base_pile), 868: &s_objet_auxiliaire) == d_erreur) 869: { 870: liberation(s_etat_processus, s_objet_argument); 871: 872: (*s_etat_processus).erreur_execution = 873: d_ex_manque_argument; 874: return; 875: } 876: 877: liberation(s_etat_processus, 878: (*l_element_courant_auxiliaire).donnee); 879: (*l_element_courant_auxiliaire).donnee = 880: s_objet_auxiliaire; 881: } 882: 883: if ((*(*l_element_courant_auxiliaire).donnee).type == INT) 884: { 885: if ((*((integer8 *) (*(*l_element_courant_auxiliaire) 886: .donnee).objet)) <= 0) 887: { 888: liberation(s_etat_processus, s_objet_argument); 889: 890: (*s_etat_processus).erreur_execution = 891: d_ex_argument_invalide; 892: return; 893: } 894: 895: switch(nombre_arguments_principaux) 896: { 897: case 1 : 898: { 899: if (axes_principaux == d_vrai) 900: { 901: if (nombre_arguments_auxiliaires == 1) 902: { 903: (*s_etat_processus).x_tics = (real8) 904: (*((integer8 *) (* 905: (*l_element_courant_auxiliaire) 906: .donnee).objet)); 907: (*s_etat_processus).x_lines = 908: autorisation_trace; 909: } 910: else if (nombre_arguments_auxiliaires == 2) 911: { 912: (*s_etat_processus).mx_tics = (real8) 913: (*((integer8 *) (* 914: (*l_element_courant_auxiliaire) 915: .donnee).objet)); 916: (*s_etat_processus).mx_lines = 917: autorisation_trace; 918: } 919: else 920: { 921: liberation(s_etat_processus, 922: s_objet_argument); 923: 924: (*s_etat_processus).erreur_execution = 925: d_ex_argument_invalide; 926: return; 927: } 928: } 929: else 930: { 931: if (nombre_arguments_auxiliaires == 1) 932: { 933: (*s_etat_processus).x2_tics = (real8) 934: (*((integer8 *) (* 935: (*l_element_courant_auxiliaire) 936: .donnee).objet)); 937: (*s_etat_processus).x2_lines = 938: autorisation_trace; 939: } 940: else if (nombre_arguments_auxiliaires == 2) 941: { 942: (*s_etat_processus).mx2_tics = (real8) 943: (*((integer8 *) (* 944: (*l_element_courant_auxiliaire) 945: .donnee).objet)); 946: (*s_etat_processus).mx2_lines = 947: autorisation_trace; 948: } 949: else 950: { 951: liberation(s_etat_processus, 952: s_objet_argument); 953: 954: (*s_etat_processus).erreur_execution = 955: d_ex_argument_invalide; 956: return; 957: } 958: } 959: 960: break; 961: } 962: 963: case 2 : 964: { 965: if (axes_principaux == d_vrai) 966: { 967: if (nombre_arguments_auxiliaires == 1) 968: { 969: (*s_etat_processus).y_tics = (real8) 970: (*((integer8 *) (* 971: (*l_element_courant_auxiliaire) 972: .donnee).objet)); 973: (*s_etat_processus).y_lines = 974: autorisation_trace; 975: } 976: else if (nombre_arguments_auxiliaires == 2) 977: { 978: (*s_etat_processus).my_tics = (real8) 979: (*((integer8 *) (* 980: (*l_element_courant_auxiliaire) 981: .donnee).objet)); 982: (*s_etat_processus).my_lines = 983: autorisation_trace; 984: } 985: else 986: { 987: liberation(s_etat_processus, 988: s_objet_argument); 989: 990: (*s_etat_processus).erreur_execution = 991: d_ex_argument_invalide; 992: return; 993: } 994: } 995: else 996: { 997: if (nombre_arguments_auxiliaires == 1) 998: { 999: (*s_etat_processus).y2_tics = (real8) 1000: (*((integer8 *) (* 1001: (*l_element_courant_auxiliaire) 1002: .donnee).objet)); 1003: (*s_etat_processus).y2_lines = 1004: autorisation_trace; 1005: } 1006: else if (nombre_arguments_auxiliaires == 2) 1007: { 1008: (*s_etat_processus).my2_tics = (real8) 1009: (*((integer8 *) (* 1010: (*l_element_courant_auxiliaire) 1011: .donnee).objet)); 1012: (*s_etat_processus).my2_lines = 1013: autorisation_trace; 1014: } 1015: else 1016: { 1017: liberation(s_etat_processus, 1018: s_objet_argument); 1019: 1020: (*s_etat_processus).erreur_execution = 1021: d_ex_argument_invalide; 1022: return; 1023: } 1024: } 1025: 1026: break; 1027: } 1028: 1029: case 3 : 1030: { 1031: if (axes_principaux == d_vrai) 1032: { 1033: if (nombre_arguments_auxiliaires == 1) 1034: { 1035: (*s_etat_processus).z_tics = (real8) 1036: (*((integer8 *) (* 1037: (*l_element_courant_auxiliaire) 1038: .donnee).objet)); 1039: (*s_etat_processus).z_lines = 1040: autorisation_trace; 1041: } 1042: else if (nombre_arguments_auxiliaires == 2) 1043: { 1044: (*s_etat_processus).mz_tics = (real8) 1045: (*((integer8 *) (* 1046: (*l_element_courant_auxiliaire) 1047: .donnee).objet)); 1048: (*s_etat_processus).mz_lines = 1049: autorisation_trace; 1050: } 1051: else 1052: { 1053: liberation(s_etat_processus, 1054: s_objet_argument); 1055: 1056: (*s_etat_processus).erreur_execution = 1057: d_ex_argument_invalide; 1058: return; 1059: } 1060: } 1061: else 1062: { 1063: if (nombre_arguments_auxiliaires == 1) 1064: { 1065: (*s_etat_processus).z2_tics = (real8) 1066: (*((integer8 *) (* 1067: (*l_element_courant_auxiliaire) 1068: .donnee).objet)); 1069: (*s_etat_processus).z2_lines = 1070: autorisation_trace; 1071: } 1072: else if (nombre_arguments_auxiliaires == 2) 1073: { 1074: (*s_etat_processus).mz2_tics = (real8) 1075: (*((integer8 *) (* 1076: (*l_element_courant_auxiliaire) 1077: .donnee).objet)); 1078: (*s_etat_processus).mz2_lines = 1079: autorisation_trace; 1080: } 1081: else 1082: { 1083: liberation(s_etat_processus, 1084: s_objet_argument); 1085: 1086: (*s_etat_processus).erreur_execution = 1087: d_ex_argument_invalide; 1088: return; 1089: } 1090: } 1091: 1092: break; 1093: } 1094: 1095: default : 1096: { 1097: liberation(s_etat_processus, s_objet_argument); 1098: 1099: (*s_etat_processus).erreur_execution = 1100: d_ex_argument_invalide; 1101: return; 1102: } 1103: } 1104: } 1105: else if ((*(*l_element_courant_auxiliaire) 1106: .donnee).type == REL) 1107: { 1108: if ((*((real8 *) (*(*l_element_courant_auxiliaire) 1109: .donnee).objet)) <= 0) 1110: { 1111: liberation(s_etat_processus, s_objet_argument); 1112: 1113: (*s_etat_processus).erreur_execution = 1114: d_ex_argument_invalide; 1115: return; 1116: } 1117: 1118: switch(nombre_arguments_principaux) 1119: { 1120: case 1 : 1121: { 1122: if (axes_principaux == d_vrai) 1123: { 1124: if (nombre_arguments_auxiliaires == 1) 1125: { 1126: (*s_etat_processus).x_tics = 1127: (*((real8 *) (* 1128: (*l_element_courant_auxiliaire) 1129: .donnee).objet)); 1130: (*s_etat_processus).x_lines = 1131: autorisation_trace; 1132: } 1133: else if (nombre_arguments_auxiliaires == 2) 1134: { 1135: (*s_etat_processus).mx_tics = 1136: (*((real8 *) (* 1137: (*l_element_courant_auxiliaire) 1138: .donnee).objet)); 1139: (*s_etat_processus).mx_lines = 1140: autorisation_trace; 1141: } 1142: else 1143: { 1144: liberation(s_etat_processus, 1145: s_objet_argument); 1146: 1147: (*s_etat_processus).erreur_execution = 1148: d_ex_argument_invalide; 1149: return; 1150: } 1151: } 1152: else 1153: { 1154: if (nombre_arguments_auxiliaires == 1) 1155: { 1156: (*s_etat_processus).x2_tics = 1157: (*((real8 *) (* 1158: (*l_element_courant_auxiliaire) 1159: .donnee).objet)); 1160: (*s_etat_processus).x2_lines = 1161: autorisation_trace; 1162: } 1163: else if (nombre_arguments_auxiliaires == 2) 1164: { 1165: (*s_etat_processus).mx2_tics = 1166: (*((real8 *) (* 1167: (*l_element_courant_auxiliaire) 1168: .donnee).objet)); 1169: (*s_etat_processus).mx2_lines = 1170: autorisation_trace; 1171: } 1172: else 1173: { 1174: liberation(s_etat_processus, 1175: s_objet_argument); 1176: 1177: (*s_etat_processus).erreur_execution = 1178: d_ex_argument_invalide; 1179: return; 1180: } 1181: } 1182: 1183: break; 1184: } 1185: 1186: case 2 : 1187: { 1188: if (axes_principaux == d_vrai) 1189: { 1190: if (nombre_arguments_auxiliaires == 1) 1191: { 1192: (*s_etat_processus).y_tics = 1193: (*((real8 *) (* 1194: (*l_element_courant_auxiliaire) 1195: .donnee).objet)); 1196: (*s_etat_processus).y_lines = 1197: autorisation_trace; 1198: } 1199: else if (nombre_arguments_auxiliaires == 2) 1200: { 1201: (*s_etat_processus).my_tics = 1202: (*((real8 *) (* 1203: (*l_element_courant_auxiliaire) 1204: .donnee).objet)); 1205: (*s_etat_processus).my_lines = 1206: autorisation_trace; 1207: } 1208: else 1209: { 1210: liberation(s_etat_processus, 1211: s_objet_argument); 1212: 1213: (*s_etat_processus).erreur_execution = 1214: d_ex_argument_invalide; 1215: return; 1216: } 1217: } 1218: else 1219: { 1220: if (nombre_arguments_auxiliaires == 1) 1221: { 1222: (*s_etat_processus).y2_tics = 1223: (*((real8 *) (* 1224: (*l_element_courant_auxiliaire) 1225: .donnee).objet)); 1226: (*s_etat_processus).y2_lines = 1227: autorisation_trace; 1228: } 1229: else if (nombre_arguments_auxiliaires == 2) 1230: { 1231: (*s_etat_processus).my2_tics = 1232: (*((real8 *) (* 1233: (*l_element_courant_auxiliaire) 1234: .donnee).objet)); 1235: (*s_etat_processus).my2_lines = 1236: autorisation_trace; 1237: } 1238: else 1239: { 1240: liberation(s_etat_processus, 1241: s_objet_argument); 1242: 1243: (*s_etat_processus).erreur_execution = 1244: d_ex_argument_invalide; 1245: return; 1246: } 1247: } 1248: 1249: break; 1250: } 1251: 1252: case 3 : 1253: { 1254: if (axes_principaux == d_vrai) 1255: { 1256: if (nombre_arguments_auxiliaires == 1) 1257: { 1258: (*s_etat_processus).z_tics = 1259: (*((real8 *) (* 1260: (*l_element_courant_auxiliaire) 1261: .donnee).objet)); 1262: (*s_etat_processus).z_lines = 1263: autorisation_trace; 1264: } 1265: else if (nombre_arguments_auxiliaires == 2) 1266: { 1267: (*s_etat_processus).mz_tics = 1268: (*((real8 *) (* 1269: (*l_element_courant_auxiliaire) 1270: .donnee).objet)); 1271: (*s_etat_processus).mz_lines = 1272: autorisation_trace; 1273: } 1274: else 1275: { 1276: liberation(s_etat_processus, 1277: s_objet_argument); 1278: 1279: (*s_etat_processus).erreur_execution = 1280: d_ex_argument_invalide; 1281: return; 1282: } 1283: } 1284: else 1285: { 1286: if (nombre_arguments_auxiliaires == 1) 1287: { 1288: (*s_etat_processus).z2_tics = 1289: (*((real8 *) (* 1290: (*l_element_courant_auxiliaire) 1291: .donnee).objet)); 1292: (*s_etat_processus).z2_lines = 1293: autorisation_trace; 1294: } 1295: else if (nombre_arguments_auxiliaires == 2) 1296: { 1297: (*s_etat_processus).mz2_tics = 1298: (*((real8 *) (* 1299: (*l_element_courant_auxiliaire) 1300: .donnee).objet)); 1301: (*s_etat_processus).mz2_lines = 1302: autorisation_trace; 1303: } 1304: else 1305: { 1306: liberation(s_etat_processus, 1307: s_objet_argument); 1308: 1309: (*s_etat_processus).erreur_execution = 1310: d_ex_argument_invalide; 1311: return; 1312: } 1313: } 1314: 1315: break; 1316: } 1317: 1318: default : 1319: { 1320: liberation(s_etat_processus, s_objet_argument); 1321: 1322: (*s_etat_processus).erreur_execution = 1323: d_ex_argument_invalide; 1324: return; 1325: } 1326: } 1327: } 1328: else if ((*(*l_element_courant_auxiliaire).donnee) 1329: .type == CHN) 1330: { 1331: tampon = conversion_majuscule((unsigned char *) 1332: (*(*l_element_courant_auxiliaire).donnee) 1333: .objet); 1334: 1335: if (tampon == NULL) 1336: { 1337: (*s_etat_processus).erreur_systeme = 1338: d_es_allocation_memoire; 1339: return; 1340: } 1341: 1342: if (strcmp(tampon, "AUTOMATIC") == 0) 1343: { 1344: switch(nombre_arguments_principaux) 1345: { 1346: case 1 : 1347: { 1348: if (axes_principaux == d_vrai) 1349: { 1350: if (nombre_arguments_auxiliaires 1351: == 1) 1352: { 1353: (*s_etat_processus).x_tics = 0; 1354: (*s_etat_processus).x_lines = 1355: autorisation_trace; 1356: } 1357: else 1358: { 1359: liberation(s_etat_processus, 1360: s_objet_argument); 1361: 1362: (*s_etat_processus).erreur_execution 1363: = d_ex_argument_invalide; 1364: 1365: return; 1366: } 1367: } 1368: else 1369: { 1370: if (nombre_arguments_auxiliaires 1371: == 1) 1372: { 1373: (*s_etat_processus).x2_tics = 0; 1374: (*s_etat_processus).x2_lines = 1375: autorisation_trace; 1376: } 1377: else 1378: { 1379: liberation(s_etat_processus, 1380: s_objet_argument); 1381: 1382: (*s_etat_processus).erreur_execution 1383: = d_ex_argument_invalide; 1384: 1385: return; 1386: } 1387: } 1388: 1389: break; 1390: } 1391: 1392: case 2 : 1393: { 1394: if (axes_principaux == d_vrai) 1395: { 1396: if (nombre_arguments_auxiliaires 1397: == 1) 1398: { 1399: (*s_etat_processus).y_tics = 0; 1400: (*s_etat_processus).y_lines = 1401: autorisation_trace; 1402: } 1403: else 1404: { 1405: liberation(s_etat_processus, 1406: s_objet_argument); 1407: 1408: (*s_etat_processus).erreur_execution 1409: = d_ex_argument_invalide; 1410: 1411: return; 1412: } 1413: } 1414: else 1415: { 1416: if (nombre_arguments_auxiliaires 1417: == 1) 1418: { 1419: (*s_etat_processus).y2_tics = 0; 1420: (*s_etat_processus).y2_lines = 1421: autorisation_trace; 1422: } 1423: else 1424: { 1425: liberation(s_etat_processus, 1426: s_objet_argument); 1427: 1428: (*s_etat_processus).erreur_execution 1429: = d_ex_argument_invalide; 1430: 1431: return; 1432: } 1433: } 1434: 1435: break; 1436: } 1437: 1438: case 3 : 1439: { 1440: if (axes_principaux == d_vrai) 1441: { 1442: if (nombre_arguments_auxiliaires 1443: == 1) 1444: { 1445: (*s_etat_processus).z_tics = 0; 1446: (*s_etat_processus).z_lines = 1447: autorisation_trace; 1448: } 1449: else 1450: { 1451: liberation(s_etat_processus, 1452: s_objet_argument); 1453: 1454: (*s_etat_processus).erreur_execution 1455: = d_ex_argument_invalide; 1456: 1457: return; 1458: } 1459: } 1460: else 1461: { 1462: if (nombre_arguments_auxiliaires 1463: == 1) 1464: { 1465: (*s_etat_processus).z2_tics = 0; 1466: (*s_etat_processus).z2_lines = 1467: autorisation_trace; 1468: } 1469: else 1470: { 1471: liberation(s_etat_processus, 1472: s_objet_argument); 1473: 1474: (*s_etat_processus).erreur_execution 1475: = d_ex_argument_invalide; 1476: 1477: return; 1478: } 1479: } 1480: 1481: break; 1482: } 1483: 1484: default : 1485: { 1486: liberation(s_etat_processus, 1487: s_objet_argument); 1488: 1489: free(tampon); 1490: 1491: (*s_etat_processus).erreur_execution = 1492: d_ex_argument_invalide; 1493: return; 1494: } 1495: } 1496: } 1497: else if (strcmp(tampon, "DEFAULT") == 0) 1498: { 1499: switch(nombre_arguments_principaux) 1500: { 1501: case 1 : 1502: { 1503: if (axes_principaux == d_vrai) 1504: { 1505: if (nombre_arguments_auxiliaires 1506: == 2) 1507: { 1508: (*s_etat_processus).mx_tics = 0; 1509: (*s_etat_processus).mx_lines = 1510: autorisation_trace; 1511: } 1512: else 1513: { 1514: liberation(s_etat_processus, 1515: s_objet_argument); 1516: 1517: (*s_etat_processus).erreur_execution 1518: = d_ex_argument_invalide; 1519: 1520: return; 1521: } 1522: } 1523: else 1524: { 1525: if (nombre_arguments_auxiliaires 1526: == 2) 1527: { 1528: (*s_etat_processus).mx2_tics = 0; 1529: (*s_etat_processus).mx2_lines = 1530: autorisation_trace; 1531: } 1532: else 1533: { 1534: liberation(s_etat_processus, 1535: s_objet_argument); 1536: 1537: (*s_etat_processus).erreur_execution 1538: = d_ex_argument_invalide; 1539: 1540: return; 1541: } 1542: } 1543: 1544: break; 1545: } 1546: 1547: case 2 : 1548: { 1549: if (axes_principaux == d_vrai) 1550: { 1551: if (nombre_arguments_auxiliaires 1552: == 2) 1553: { 1554: (*s_etat_processus).my_tics = 0; 1555: (*s_etat_processus).my_lines = 1556: autorisation_trace; 1557: } 1558: else 1559: { 1560: liberation(s_etat_processus, 1561: s_objet_argument); 1562: 1563: (*s_etat_processus).erreur_execution 1564: = d_ex_argument_invalide; 1565: 1566: return; 1567: } 1568: } 1569: else 1570: { 1571: if (nombre_arguments_auxiliaires 1572: == 2) 1573: { 1574: (*s_etat_processus).my2_tics = 0; 1575: (*s_etat_processus).my2_lines = 1576: autorisation_trace; 1577: } 1578: else 1579: { 1580: liberation(s_etat_processus, 1581: s_objet_argument); 1582: 1583: (*s_etat_processus).erreur_execution 1584: = d_ex_argument_invalide; 1585: 1586: return; 1587: } 1588: } 1589: 1590: break; 1591: } 1592: 1593: case 3 : 1594: { 1595: if (axes_principaux == d_vrai) 1596: { 1597: if (nombre_arguments_auxiliaires 1598: == 2) 1599: { 1600: (*s_etat_processus).mz_tics = 0; 1601: (*s_etat_processus).mz_lines = 1602: autorisation_trace; 1603: } 1604: else 1605: { 1606: liberation(s_etat_processus, 1607: s_objet_argument); 1608: 1609: (*s_etat_processus).erreur_execution 1610: = d_ex_argument_invalide; 1611: 1612: return; 1613: } 1614: } 1615: else 1616: { 1617: if (nombre_arguments_auxiliaires 1618: == 2) 1619: { 1620: (*s_etat_processus).mz2_tics = 0; 1621: (*s_etat_processus).mz2_lines = 1622: autorisation_trace; 1623: } 1624: else 1625: { 1626: liberation(s_etat_processus, 1627: s_objet_argument); 1628: 1629: (*s_etat_processus).erreur_execution 1630: = d_ex_argument_invalide; 1631: 1632: return; 1633: } 1634: } 1635: 1636: break; 1637: } 1638: 1639: default : 1640: { 1641: liberation(s_etat_processus, 1642: s_objet_argument); 1643: 1644: free(tampon); 1645: 1646: (*s_etat_processus).erreur_execution = 1647: d_ex_argument_invalide; 1648: return; 1649: } 1650: } 1651: } 1652: else if (strcmp(tampon, "TICSONLY") == 0) 1653: { 1654: nombre_arguments_auxiliaires--; 1655: autorisation_trace = d_faux; 1656: } 1657: else 1658: { 1659: liberation(s_etat_processus, s_objet_argument); 1660: 1661: free(tampon); 1662: 1663: (*s_etat_processus).erreur_execution = 1664: d_ex_argument_invalide; 1665: return; 1666: } 1667: 1668: free(tampon); 1669: } 1670: else 1671: { 1672: liberation(s_etat_processus, s_objet_argument); 1673: 1674: (*s_etat_processus).erreur_execution = 1675: d_ex_erreur_type_argument; 1676: return; 1677: } 1678: 1679: l_element_courant_auxiliaire = 1680: (*l_element_courant_auxiliaire).suivant; 1681: } 1682: } 1683: else 1684: { 1685: liberation(s_etat_processus, s_objet_argument); 1686: 1687: (*s_etat_processus).erreur_execution = 1688: d_ex_erreur_type_argument; 1689: return; 1690: } 1691: 1692: l_element_courant = (*l_element_courant).suivant; 1693: } 1694: } 1695: else 1696: { 1697: liberation(s_etat_processus, s_objet_argument); 1698: 1699: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1700: return; 1701: } 1702: 1703: liberation(s_etat_processus, s_objet_argument); 1704: 1705: return; 1706: } 1707: 1708: // vim: ts=4