Annotation of rpl/src/instructions_a4.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 '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: file *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 (fseek(descripteur, (long) 0, SEEK_END) != 0)
! 613: {
! 614: liberation(s_etat_processus, s_objet_argument);
! 615:
! 616: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 617: return;
! 618: }
! 619: }
! 620: else
! 621: {
! 622: liberation(s_etat_processus, s_objet_argument);
! 623:
! 624: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 625: return;
! 626: }
! 627:
! 628: liberation(s_etat_processus, s_objet_argument);
! 629:
! 630: return;
! 631: }
! 632:
! 633:
! 634: /*
! 635: ================================================================================
! 636: Fonction 'axes'
! 637: ================================================================================
! 638: Entrées : pointeur sur une structure struct_processus
! 639: --------------------------------------------------------------------------------
! 640: Sorties :
! 641: --------------------------------------------------------------------------------
! 642: Effets de bord : néant
! 643: ================================================================================
! 644: */
! 645:
! 646: void
! 647: instruction_axes(struct_processus *s_etat_processus)
! 648: {
! 649: /*
! 650: * Prend comme argument une liste
! 651: */
! 652:
! 653: logical1 autorisation_trace;
! 654: logical1 axes_principaux;
! 655: logical1 presence_type;
! 656:
! 657: long nombre_arguments_principaux;
! 658: long nombre_arguments_auxiliaires;
! 659:
! 660: struct_liste_chainee *l_element_courant;
! 661: struct_liste_chainee *l_element_courant_auxiliaire;
! 662:
! 663: struct_objet *s_objet_argument;
! 664: struct_objet *s_objet_auxiliaire;
! 665:
! 666: unsigned char *tampon;
! 667:
! 668: (*s_etat_processus).erreur_execution = d_ex;
! 669:
! 670: if ((*s_etat_processus).affichage_arguments == 'Y')
! 671: {
! 672: printf("\n AXES ");
! 673:
! 674: if ((*s_etat_processus).langue == 'F')
! 675: {
! 676: printf("(définition des axes)\n\n");
! 677: }
! 678: else
! 679: {
! 680: printf("(axes definition)\n\n");
! 681: }
! 682:
! 683: printf(" 1: %s\n\n", d_LST);
! 684:
! 685: if ((*s_etat_processus).langue == 'F')
! 686: {
! 687: printf(" Utilisation :\n\n");
! 688: }
! 689: else
! 690: {
! 691: printf(" Usage:\n\n");
! 692: }
! 693:
! 694: printf(" { \"MAIN\" } AXES\n");
! 695: printf(" { \"AUXILIARY\" } AXES\n");
! 696: printf(" { \"MAIN\" { (expression 1) (expression 2) }\n");
! 697: printf(" { (expression 3) TICSONLY } } AXES\n\n");
! 698: printf(" { \"MAIN\" { (expression 1) \"TICSONLY\" }\n");
! 699: printf(" { (expression 2) } } AXES\n\n");
! 700: printf(" { \"AUXILIARY\" { \"AUTOMATIC\" }\n");
! 701: printf(" { \"TICSONLY\" \"AUTOMATIC\" } } AXES\n\n");
! 702: printf(" { { (expression 1) \"DEFAULT\" } { \"AUTOMATIC\" } }\n");
! 703: printf(" { \"TICSONLY\" (expression 2) } } AXES\n");
! 704:
! 705: return;
! 706: }
! 707: else if ((*s_etat_processus).test_instruction == 'Y')
! 708: {
! 709: (*s_etat_processus).nombre_arguments = -1;
! 710: return;
! 711: }
! 712:
! 713: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 714: {
! 715: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 716: {
! 717: return;
! 718: }
! 719: }
! 720:
! 721: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 722: &s_objet_argument) == d_erreur)
! 723: {
! 724: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 725: return;
! 726: }
! 727:
! 728: if ((*s_objet_argument).type == LST)
! 729: {
! 730: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
! 731: nombre_arguments_principaux = 0;
! 732: presence_type = d_faux;
! 733: tampon = NULL;
! 734:
! 735: while(l_element_courant != NULL)
! 736: {
! 737: if ((*(*l_element_courant).donnee).type == CHN)
! 738: {
! 739: if (presence_type == d_vrai)
! 740: {
! 741: free(tampon);
! 742:
! 743: liberation(s_etat_processus, s_objet_argument);
! 744:
! 745: (*s_etat_processus).erreur_execution =
! 746: d_ex_argument_invalide;
! 747: return;
! 748: }
! 749:
! 750: if ((tampon = conversion_majuscule((unsigned char *)
! 751: (*(*l_element_courant).donnee).objet)) == NULL)
! 752: {
! 753: (*s_etat_processus).erreur_systeme =
! 754: d_es_allocation_memoire;
! 755: return;
! 756: }
! 757:
! 758: presence_type = d_vrai;
! 759: }
! 760: else
! 761: {
! 762: nombre_arguments_principaux++;
! 763: }
! 764:
! 765: l_element_courant = (*l_element_courant).suivant;
! 766: }
! 767:
! 768: if (presence_type == d_faux)
! 769: {
! 770: if ((tampon = malloc(5 * sizeof(unsigned char))) == NULL)
! 771: {
! 772: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 773: return;
! 774: }
! 775:
! 776: if ((*s_etat_processus).systeme_axes == 0)
! 777: {
! 778: strcpy(tampon, "MAIN");
! 779: }
! 780: else
! 781: {
! 782: strcpy(tampon, "AUXILIARY");
! 783: }
! 784: }
! 785:
! 786: if (strcmp(tampon, "MAIN") == 0)
! 787: {
! 788: axes_principaux = d_vrai;
! 789: (*s_etat_processus).systeme_axes = 0;
! 790: }
! 791: else if (strcmp(tampon, "AUXILIARY") == 0)
! 792: {
! 793: axes_principaux = d_faux;
! 794: (*s_etat_processus).systeme_axes = 1;
! 795: }
! 796: else
! 797: {
! 798: free(tampon);
! 799:
! 800: liberation(s_etat_processus, s_objet_argument);
! 801:
! 802: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 803: return;
! 804: }
! 805:
! 806: free(tampon);
! 807:
! 808: if ((nombre_arguments_principaux != 0) &&
! 809: (nombre_arguments_principaux != 2) &&
! 810: (nombre_arguments_principaux != 3))
! 811: {
! 812: liberation(s_etat_processus, s_objet_argument);
! 813:
! 814: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 815: return;
! 816: }
! 817:
! 818: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
! 819: nombre_arguments_principaux = 0;
! 820:
! 821: while(l_element_courant != NULL)
! 822: {
! 823: nombre_arguments_principaux++;
! 824:
! 825: if ((*(*l_element_courant).donnee).type == CHN)
! 826: {
! 827: l_element_courant = (*l_element_courant).suivant;
! 828: nombre_arguments_principaux--;
! 829: continue;
! 830: }
! 831: else if ((*(*l_element_courant).donnee).type == LST)
! 832: {
! 833: l_element_courant_auxiliaire = (struct_liste_chainee *)
! 834: (*(*l_element_courant).donnee).objet;
! 835: nombre_arguments_auxiliaires = 0;
! 836: autorisation_trace = d_vrai;
! 837:
! 838: while(l_element_courant_auxiliaire != NULL)
! 839: {
! 840: nombre_arguments_auxiliaires++;
! 841:
! 842: if (((*(*l_element_courant_auxiliaire).donnee).type ==
! 843: RPN) || ((*(*l_element_courant_auxiliaire).donnee)
! 844: .type == ALG) || ((*(*l_element_courant_auxiliaire)
! 845: .donnee).type == NOM))
! 846: {
! 847: if (evaluation(s_etat_processus,
! 848: (*l_element_courant_auxiliaire).donnee, 'N')
! 849: == d_erreur)
! 850: {
! 851: liberation(s_etat_processus, s_objet_argument);
! 852:
! 853: return;
! 854: }
! 855:
! 856: if (depilement(s_etat_processus,
! 857: &((*s_etat_processus).l_base_pile),
! 858: &s_objet_auxiliaire) == d_erreur)
! 859: {
! 860: liberation(s_etat_processus, s_objet_argument);
! 861:
! 862: (*s_etat_processus).erreur_execution =
! 863: d_ex_manque_argument;
! 864: return;
! 865: }
! 866:
! 867: liberation(s_etat_processus,
! 868: (*l_element_courant_auxiliaire).donnee);
! 869: (*l_element_courant_auxiliaire).donnee =
! 870: s_objet_auxiliaire;
! 871: }
! 872:
! 873: if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
! 874: {
! 875: if ((*((integer8 *) (*(*l_element_courant_auxiliaire)
! 876: .donnee).objet)) <= 0)
! 877: {
! 878: liberation(s_etat_processus, s_objet_argument);
! 879:
! 880: (*s_etat_processus).erreur_execution =
! 881: d_ex_argument_invalide;
! 882: return;
! 883: }
! 884:
! 885: switch(nombre_arguments_principaux)
! 886: {
! 887: case 1 :
! 888: {
! 889: if (axes_principaux == d_vrai)
! 890: {
! 891: if (nombre_arguments_auxiliaires == 1)
! 892: {
! 893: (*s_etat_processus).x_tics = (real8)
! 894: (*((integer8 *) (*
! 895: (*l_element_courant_auxiliaire)
! 896: .donnee).objet));
! 897: (*s_etat_processus).x_lines =
! 898: autorisation_trace;
! 899: }
! 900: else if (nombre_arguments_auxiliaires == 2)
! 901: {
! 902: (*s_etat_processus).mx_tics = (real8)
! 903: (*((integer8 *) (*
! 904: (*l_element_courant_auxiliaire)
! 905: .donnee).objet));
! 906: (*s_etat_processus).mx_lines =
! 907: autorisation_trace;
! 908: }
! 909: else
! 910: {
! 911: liberation(s_etat_processus,
! 912: s_objet_argument);
! 913:
! 914: (*s_etat_processus).erreur_execution =
! 915: d_ex_argument_invalide;
! 916: return;
! 917: }
! 918: }
! 919: else
! 920: {
! 921: if (nombre_arguments_auxiliaires == 1)
! 922: {
! 923: (*s_etat_processus).x2_tics = (real8)
! 924: (*((integer8 *) (*
! 925: (*l_element_courant_auxiliaire)
! 926: .donnee).objet));
! 927: (*s_etat_processus).x2_lines =
! 928: autorisation_trace;
! 929: }
! 930: else if (nombre_arguments_auxiliaires == 2)
! 931: {
! 932: (*s_etat_processus).mx2_tics = (real8)
! 933: (*((integer8 *) (*
! 934: (*l_element_courant_auxiliaire)
! 935: .donnee).objet));
! 936: (*s_etat_processus).mx2_lines =
! 937: autorisation_trace;
! 938: }
! 939: else
! 940: {
! 941: liberation(s_etat_processus,
! 942: s_objet_argument);
! 943:
! 944: (*s_etat_processus).erreur_execution =
! 945: d_ex_argument_invalide;
! 946: return;
! 947: }
! 948: }
! 949:
! 950: break;
! 951: }
! 952:
! 953: case 2 :
! 954: {
! 955: if (axes_principaux == d_vrai)
! 956: {
! 957: if (nombre_arguments_auxiliaires == 1)
! 958: {
! 959: (*s_etat_processus).y_tics = (real8)
! 960: (*((integer8 *) (*
! 961: (*l_element_courant_auxiliaire)
! 962: .donnee).objet));
! 963: (*s_etat_processus).y_lines =
! 964: autorisation_trace;
! 965: }
! 966: else if (nombre_arguments_auxiliaires == 2)
! 967: {
! 968: (*s_etat_processus).my_tics = (real8)
! 969: (*((integer8 *) (*
! 970: (*l_element_courant_auxiliaire)
! 971: .donnee).objet));
! 972: (*s_etat_processus).my_lines =
! 973: autorisation_trace;
! 974: }
! 975: else
! 976: {
! 977: liberation(s_etat_processus,
! 978: s_objet_argument);
! 979:
! 980: (*s_etat_processus).erreur_execution =
! 981: d_ex_argument_invalide;
! 982: return;
! 983: }
! 984: }
! 985: else
! 986: {
! 987: if (nombre_arguments_auxiliaires == 1)
! 988: {
! 989: (*s_etat_processus).y2_tics = (real8)
! 990: (*((integer8 *) (*
! 991: (*l_element_courant_auxiliaire)
! 992: .donnee).objet));
! 993: (*s_etat_processus).y2_lines =
! 994: autorisation_trace;
! 995: }
! 996: else if (nombre_arguments_auxiliaires == 2)
! 997: {
! 998: (*s_etat_processus).my2_tics = (real8)
! 999: (*((integer8 *) (*
! 1000: (*l_element_courant_auxiliaire)
! 1001: .donnee).objet));
! 1002: (*s_etat_processus).my2_lines =
! 1003: autorisation_trace;
! 1004: }
! 1005: else
! 1006: {
! 1007: liberation(s_etat_processus,
! 1008: s_objet_argument);
! 1009:
! 1010: (*s_etat_processus).erreur_execution =
! 1011: d_ex_argument_invalide;
! 1012: return;
! 1013: }
! 1014: }
! 1015:
! 1016: break;
! 1017: }
! 1018:
! 1019: case 3 :
! 1020: {
! 1021: if (axes_principaux == d_vrai)
! 1022: {
! 1023: if (nombre_arguments_auxiliaires == 1)
! 1024: {
! 1025: (*s_etat_processus).z_tics = (real8)
! 1026: (*((integer8 *) (*
! 1027: (*l_element_courant_auxiliaire)
! 1028: .donnee).objet));
! 1029: (*s_etat_processus).z_lines =
! 1030: autorisation_trace;
! 1031: }
! 1032: else if (nombre_arguments_auxiliaires == 2)
! 1033: {
! 1034: (*s_etat_processus).mz_tics = (real8)
! 1035: (*((integer8 *) (*
! 1036: (*l_element_courant_auxiliaire)
! 1037: .donnee).objet));
! 1038: (*s_etat_processus).mz_lines =
! 1039: autorisation_trace;
! 1040: }
! 1041: else
! 1042: {
! 1043: liberation(s_etat_processus,
! 1044: s_objet_argument);
! 1045:
! 1046: (*s_etat_processus).erreur_execution =
! 1047: d_ex_argument_invalide;
! 1048: return;
! 1049: }
! 1050: }
! 1051: else
! 1052: {
! 1053: if (nombre_arguments_auxiliaires == 1)
! 1054: {
! 1055: (*s_etat_processus).z2_tics = (real8)
! 1056: (*((integer8 *) (*
! 1057: (*l_element_courant_auxiliaire)
! 1058: .donnee).objet));
! 1059: (*s_etat_processus).z2_lines =
! 1060: autorisation_trace;
! 1061: }
! 1062: else if (nombre_arguments_auxiliaires == 2)
! 1063: {
! 1064: (*s_etat_processus).mz2_tics = (real8)
! 1065: (*((integer8 *) (*
! 1066: (*l_element_courant_auxiliaire)
! 1067: .donnee).objet));
! 1068: (*s_etat_processus).mz2_lines =
! 1069: autorisation_trace;
! 1070: }
! 1071: else
! 1072: {
! 1073: liberation(s_etat_processus,
! 1074: s_objet_argument);
! 1075:
! 1076: (*s_etat_processus).erreur_execution =
! 1077: d_ex_argument_invalide;
! 1078: return;
! 1079: }
! 1080: }
! 1081:
! 1082: break;
! 1083: }
! 1084:
! 1085: default :
! 1086: {
! 1087: liberation(s_etat_processus, s_objet_argument);
! 1088:
! 1089: (*s_etat_processus).erreur_execution =
! 1090: d_ex_argument_invalide;
! 1091: return;
! 1092: }
! 1093: }
! 1094: }
! 1095: else if ((*(*l_element_courant_auxiliaire)
! 1096: .donnee).type == REL)
! 1097: {
! 1098: if ((*((real8 *) (*(*l_element_courant_auxiliaire)
! 1099: .donnee).objet)) <= 0)
! 1100: {
! 1101: liberation(s_etat_processus, s_objet_argument);
! 1102:
! 1103: (*s_etat_processus).erreur_execution =
! 1104: d_ex_argument_invalide;
! 1105: return;
! 1106: }
! 1107:
! 1108: switch(nombre_arguments_principaux)
! 1109: {
! 1110: case 1 :
! 1111: {
! 1112: if (axes_principaux == d_vrai)
! 1113: {
! 1114: if (nombre_arguments_auxiliaires == 1)
! 1115: {
! 1116: (*s_etat_processus).x_tics =
! 1117: (*((real8 *) (*
! 1118: (*l_element_courant_auxiliaire)
! 1119: .donnee).objet));
! 1120: (*s_etat_processus).x_lines =
! 1121: autorisation_trace;
! 1122: }
! 1123: else if (nombre_arguments_auxiliaires == 2)
! 1124: {
! 1125: (*s_etat_processus).mx_tics =
! 1126: (*((real8 *) (*
! 1127: (*l_element_courant_auxiliaire)
! 1128: .donnee).objet));
! 1129: (*s_etat_processus).mx_lines =
! 1130: autorisation_trace;
! 1131: }
! 1132: else
! 1133: {
! 1134: liberation(s_etat_processus,
! 1135: s_objet_argument);
! 1136:
! 1137: (*s_etat_processus).erreur_execution =
! 1138: d_ex_argument_invalide;
! 1139: return;
! 1140: }
! 1141: }
! 1142: else
! 1143: {
! 1144: if (nombre_arguments_auxiliaires == 1)
! 1145: {
! 1146: (*s_etat_processus).x2_tics =
! 1147: (*((real8 *) (*
! 1148: (*l_element_courant_auxiliaire)
! 1149: .donnee).objet));
! 1150: (*s_etat_processus).x2_lines =
! 1151: autorisation_trace;
! 1152: }
! 1153: else if (nombre_arguments_auxiliaires == 2)
! 1154: {
! 1155: (*s_etat_processus).mx2_tics =
! 1156: (*((real8 *) (*
! 1157: (*l_element_courant_auxiliaire)
! 1158: .donnee).objet));
! 1159: (*s_etat_processus).mx2_lines =
! 1160: autorisation_trace;
! 1161: }
! 1162: else
! 1163: {
! 1164: liberation(s_etat_processus,
! 1165: s_objet_argument);
! 1166:
! 1167: (*s_etat_processus).erreur_execution =
! 1168: d_ex_argument_invalide;
! 1169: return;
! 1170: }
! 1171: }
! 1172:
! 1173: break;
! 1174: }
! 1175:
! 1176: case 2 :
! 1177: {
! 1178: if (axes_principaux == d_vrai)
! 1179: {
! 1180: if (nombre_arguments_auxiliaires == 1)
! 1181: {
! 1182: (*s_etat_processus).y_tics =
! 1183: (*((real8 *) (*
! 1184: (*l_element_courant_auxiliaire)
! 1185: .donnee).objet));
! 1186: (*s_etat_processus).y_lines =
! 1187: autorisation_trace;
! 1188: }
! 1189: else if (nombre_arguments_auxiliaires == 2)
! 1190: {
! 1191: (*s_etat_processus).my_tics =
! 1192: (*((real8 *) (*
! 1193: (*l_element_courant_auxiliaire)
! 1194: .donnee).objet));
! 1195: (*s_etat_processus).my_lines =
! 1196: autorisation_trace;
! 1197: }
! 1198: else
! 1199: {
! 1200: liberation(s_etat_processus,
! 1201: s_objet_argument);
! 1202:
! 1203: (*s_etat_processus).erreur_execution =
! 1204: d_ex_argument_invalide;
! 1205: return;
! 1206: }
! 1207: }
! 1208: else
! 1209: {
! 1210: if (nombre_arguments_auxiliaires == 1)
! 1211: {
! 1212: (*s_etat_processus).y2_tics =
! 1213: (*((real8 *) (*
! 1214: (*l_element_courant_auxiliaire)
! 1215: .donnee).objet));
! 1216: (*s_etat_processus).y2_lines =
! 1217: autorisation_trace;
! 1218: }
! 1219: else if (nombre_arguments_auxiliaires == 2)
! 1220: {
! 1221: (*s_etat_processus).my2_tics =
! 1222: (*((real8 *) (*
! 1223: (*l_element_courant_auxiliaire)
! 1224: .donnee).objet));
! 1225: (*s_etat_processus).my2_lines =
! 1226: autorisation_trace;
! 1227: }
! 1228: else
! 1229: {
! 1230: liberation(s_etat_processus,
! 1231: s_objet_argument);
! 1232:
! 1233: (*s_etat_processus).erreur_execution =
! 1234: d_ex_argument_invalide;
! 1235: return;
! 1236: }
! 1237: }
! 1238:
! 1239: break;
! 1240: }
! 1241:
! 1242: case 3 :
! 1243: {
! 1244: if (axes_principaux == d_vrai)
! 1245: {
! 1246: if (nombre_arguments_auxiliaires == 1)
! 1247: {
! 1248: (*s_etat_processus).z_tics =
! 1249: (*((real8 *) (*
! 1250: (*l_element_courant_auxiliaire)
! 1251: .donnee).objet));
! 1252: (*s_etat_processus).z_lines =
! 1253: autorisation_trace;
! 1254: }
! 1255: else if (nombre_arguments_auxiliaires == 2)
! 1256: {
! 1257: (*s_etat_processus).mz_tics =
! 1258: (*((real8 *) (*
! 1259: (*l_element_courant_auxiliaire)
! 1260: .donnee).objet));
! 1261: (*s_etat_processus).mz_lines =
! 1262: autorisation_trace;
! 1263: }
! 1264: else
! 1265: {
! 1266: liberation(s_etat_processus,
! 1267: s_objet_argument);
! 1268:
! 1269: (*s_etat_processus).erreur_execution =
! 1270: d_ex_argument_invalide;
! 1271: return;
! 1272: }
! 1273: }
! 1274: else
! 1275: {
! 1276: if (nombre_arguments_auxiliaires == 1)
! 1277: {
! 1278: (*s_etat_processus).z2_tics =
! 1279: (*((real8 *) (*
! 1280: (*l_element_courant_auxiliaire)
! 1281: .donnee).objet));
! 1282: (*s_etat_processus).z2_lines =
! 1283: autorisation_trace;
! 1284: }
! 1285: else if (nombre_arguments_auxiliaires == 2)
! 1286: {
! 1287: (*s_etat_processus).mz2_tics =
! 1288: (*((real8 *) (*
! 1289: (*l_element_courant_auxiliaire)
! 1290: .donnee).objet));
! 1291: (*s_etat_processus).mz2_lines =
! 1292: autorisation_trace;
! 1293: }
! 1294: else
! 1295: {
! 1296: liberation(s_etat_processus,
! 1297: s_objet_argument);
! 1298:
! 1299: (*s_etat_processus).erreur_execution =
! 1300: d_ex_argument_invalide;
! 1301: return;
! 1302: }
! 1303: }
! 1304:
! 1305: break;
! 1306: }
! 1307:
! 1308: default :
! 1309: {
! 1310: liberation(s_etat_processus, s_objet_argument);
! 1311:
! 1312: (*s_etat_processus).erreur_execution =
! 1313: d_ex_argument_invalide;
! 1314: return;
! 1315: }
! 1316: }
! 1317: }
! 1318: else if ((*(*l_element_courant_auxiliaire).donnee)
! 1319: .type == CHN)
! 1320: {
! 1321: tampon = conversion_majuscule((unsigned char *)
! 1322: (*(*l_element_courant_auxiliaire).donnee)
! 1323: .objet);
! 1324:
! 1325: if (tampon == NULL)
! 1326: {
! 1327: (*s_etat_processus).erreur_systeme =
! 1328: d_es_allocation_memoire;
! 1329: return;
! 1330: }
! 1331:
! 1332: if (strcmp(tampon, "AUTOMATIC") == 0)
! 1333: {
! 1334: switch(nombre_arguments_principaux)
! 1335: {
! 1336: case 1 :
! 1337: {
! 1338: if (axes_principaux == d_vrai)
! 1339: {
! 1340: if (nombre_arguments_auxiliaires
! 1341: == 1)
! 1342: {
! 1343: (*s_etat_processus).x_tics = 0;
! 1344: (*s_etat_processus).x_lines =
! 1345: autorisation_trace;
! 1346: }
! 1347: else
! 1348: {
! 1349: liberation(s_etat_processus,
! 1350: s_objet_argument);
! 1351:
! 1352: (*s_etat_processus).erreur_execution
! 1353: = d_ex_argument_invalide;
! 1354:
! 1355: return;
! 1356: }
! 1357: }
! 1358: else
! 1359: {
! 1360: if (nombre_arguments_auxiliaires
! 1361: == 1)
! 1362: {
! 1363: (*s_etat_processus).x2_tics = 0;
! 1364: (*s_etat_processus).x2_lines =
! 1365: autorisation_trace;
! 1366: }
! 1367: else
! 1368: {
! 1369: liberation(s_etat_processus,
! 1370: s_objet_argument);
! 1371:
! 1372: (*s_etat_processus).erreur_execution
! 1373: = d_ex_argument_invalide;
! 1374:
! 1375: return;
! 1376: }
! 1377: }
! 1378:
! 1379: break;
! 1380: }
! 1381:
! 1382: case 2 :
! 1383: {
! 1384: if (axes_principaux == d_vrai)
! 1385: {
! 1386: if (nombre_arguments_auxiliaires
! 1387: == 1)
! 1388: {
! 1389: (*s_etat_processus).y_tics = 0;
! 1390: (*s_etat_processus).y_lines =
! 1391: autorisation_trace;
! 1392: }
! 1393: else
! 1394: {
! 1395: liberation(s_etat_processus,
! 1396: s_objet_argument);
! 1397:
! 1398: (*s_etat_processus).erreur_execution
! 1399: = d_ex_argument_invalide;
! 1400:
! 1401: return;
! 1402: }
! 1403: }
! 1404: else
! 1405: {
! 1406: if (nombre_arguments_auxiliaires
! 1407: == 1)
! 1408: {
! 1409: (*s_etat_processus).y2_tics = 0;
! 1410: (*s_etat_processus).y2_lines =
! 1411: autorisation_trace;
! 1412: }
! 1413: else
! 1414: {
! 1415: liberation(s_etat_processus,
! 1416: s_objet_argument);
! 1417:
! 1418: (*s_etat_processus).erreur_execution
! 1419: = d_ex_argument_invalide;
! 1420:
! 1421: return;
! 1422: }
! 1423: }
! 1424:
! 1425: break;
! 1426: }
! 1427:
! 1428: case 3 :
! 1429: {
! 1430: if (axes_principaux == d_vrai)
! 1431: {
! 1432: if (nombre_arguments_auxiliaires
! 1433: == 1)
! 1434: {
! 1435: (*s_etat_processus).z_tics = 0;
! 1436: (*s_etat_processus).z_lines =
! 1437: autorisation_trace;
! 1438: }
! 1439: else
! 1440: {
! 1441: liberation(s_etat_processus,
! 1442: s_objet_argument);
! 1443:
! 1444: (*s_etat_processus).erreur_execution
! 1445: = d_ex_argument_invalide;
! 1446:
! 1447: return;
! 1448: }
! 1449: }
! 1450: else
! 1451: {
! 1452: if (nombre_arguments_auxiliaires
! 1453: == 1)
! 1454: {
! 1455: (*s_etat_processus).z2_tics = 0;
! 1456: (*s_etat_processus).z2_lines =
! 1457: autorisation_trace;
! 1458: }
! 1459: else
! 1460: {
! 1461: liberation(s_etat_processus,
! 1462: s_objet_argument);
! 1463:
! 1464: (*s_etat_processus).erreur_execution
! 1465: = d_ex_argument_invalide;
! 1466:
! 1467: return;
! 1468: }
! 1469: }
! 1470:
! 1471: break;
! 1472: }
! 1473:
! 1474: default :
! 1475: {
! 1476: liberation(s_etat_processus,
! 1477: s_objet_argument);
! 1478:
! 1479: free(tampon);
! 1480:
! 1481: (*s_etat_processus).erreur_execution =
! 1482: d_ex_argument_invalide;
! 1483: return;
! 1484: }
! 1485: }
! 1486: }
! 1487: else if (strcmp(tampon, "DEFAULT") == 0)
! 1488: {
! 1489: switch(nombre_arguments_principaux)
! 1490: {
! 1491: case 1 :
! 1492: {
! 1493: if (axes_principaux == d_vrai)
! 1494: {
! 1495: if (nombre_arguments_auxiliaires
! 1496: == 2)
! 1497: {
! 1498: (*s_etat_processus).mx_tics = 0;
! 1499: (*s_etat_processus).mx_lines =
! 1500: autorisation_trace;
! 1501: }
! 1502: else
! 1503: {
! 1504: liberation(s_etat_processus,
! 1505: s_objet_argument);
! 1506:
! 1507: (*s_etat_processus).erreur_execution
! 1508: = d_ex_argument_invalide;
! 1509:
! 1510: return;
! 1511: }
! 1512: }
! 1513: else
! 1514: {
! 1515: if (nombre_arguments_auxiliaires
! 1516: == 2)
! 1517: {
! 1518: (*s_etat_processus).mx2_tics = 0;
! 1519: (*s_etat_processus).mx2_lines =
! 1520: autorisation_trace;
! 1521: }
! 1522: else
! 1523: {
! 1524: liberation(s_etat_processus,
! 1525: s_objet_argument);
! 1526:
! 1527: (*s_etat_processus).erreur_execution
! 1528: = d_ex_argument_invalide;
! 1529:
! 1530: return;
! 1531: }
! 1532: }
! 1533:
! 1534: break;
! 1535: }
! 1536:
! 1537: case 2 :
! 1538: {
! 1539: if (axes_principaux == d_vrai)
! 1540: {
! 1541: if (nombre_arguments_auxiliaires
! 1542: == 2)
! 1543: {
! 1544: (*s_etat_processus).my_tics = 0;
! 1545: (*s_etat_processus).my_lines =
! 1546: autorisation_trace;
! 1547: }
! 1548: else
! 1549: {
! 1550: liberation(s_etat_processus,
! 1551: s_objet_argument);
! 1552:
! 1553: (*s_etat_processus).erreur_execution
! 1554: = d_ex_argument_invalide;
! 1555:
! 1556: return;
! 1557: }
! 1558: }
! 1559: else
! 1560: {
! 1561: if (nombre_arguments_auxiliaires
! 1562: == 2)
! 1563: {
! 1564: (*s_etat_processus).my2_tics = 0;
! 1565: (*s_etat_processus).my2_lines =
! 1566: autorisation_trace;
! 1567: }
! 1568: else
! 1569: {
! 1570: liberation(s_etat_processus,
! 1571: s_objet_argument);
! 1572:
! 1573: (*s_etat_processus).erreur_execution
! 1574: = d_ex_argument_invalide;
! 1575:
! 1576: return;
! 1577: }
! 1578: }
! 1579:
! 1580: break;
! 1581: }
! 1582:
! 1583: case 3 :
! 1584: {
! 1585: if (axes_principaux == d_vrai)
! 1586: {
! 1587: if (nombre_arguments_auxiliaires
! 1588: == 2)
! 1589: {
! 1590: (*s_etat_processus).mz_tics = 0;
! 1591: (*s_etat_processus).mz_lines =
! 1592: autorisation_trace;
! 1593: }
! 1594: else
! 1595: {
! 1596: liberation(s_etat_processus,
! 1597: s_objet_argument);
! 1598:
! 1599: (*s_etat_processus).erreur_execution
! 1600: = d_ex_argument_invalide;
! 1601:
! 1602: return;
! 1603: }
! 1604: }
! 1605: else
! 1606: {
! 1607: if (nombre_arguments_auxiliaires
! 1608: == 2)
! 1609: {
! 1610: (*s_etat_processus).mz2_tics = 0;
! 1611: (*s_etat_processus).mz2_lines =
! 1612: autorisation_trace;
! 1613: }
! 1614: else
! 1615: {
! 1616: liberation(s_etat_processus,
! 1617: s_objet_argument);
! 1618:
! 1619: (*s_etat_processus).erreur_execution
! 1620: = d_ex_argument_invalide;
! 1621:
! 1622: return;
! 1623: }
! 1624: }
! 1625:
! 1626: break;
! 1627: }
! 1628:
! 1629: default :
! 1630: {
! 1631: liberation(s_etat_processus,
! 1632: s_objet_argument);
! 1633:
! 1634: free(tampon);
! 1635:
! 1636: (*s_etat_processus).erreur_execution =
! 1637: d_ex_argument_invalide;
! 1638: return;
! 1639: }
! 1640: }
! 1641: }
! 1642: else if (strcmp(tampon, "TICSONLY") == 0)
! 1643: {
! 1644: nombre_arguments_auxiliaires--;
! 1645: autorisation_trace = d_faux;
! 1646: }
! 1647: else
! 1648: {
! 1649: liberation(s_etat_processus, s_objet_argument);
! 1650:
! 1651: free(tampon);
! 1652:
! 1653: (*s_etat_processus).erreur_execution =
! 1654: d_ex_argument_invalide;
! 1655: return;
! 1656: }
! 1657:
! 1658: free(tampon);
! 1659: }
! 1660: else
! 1661: {
! 1662: liberation(s_etat_processus, s_objet_argument);
! 1663:
! 1664: (*s_etat_processus).erreur_execution =
! 1665: d_ex_erreur_type_argument;
! 1666: return;
! 1667: }
! 1668:
! 1669: l_element_courant_auxiliaire =
! 1670: (*l_element_courant_auxiliaire).suivant;
! 1671: }
! 1672: }
! 1673: else
! 1674: {
! 1675: liberation(s_etat_processus, s_objet_argument);
! 1676:
! 1677: (*s_etat_processus).erreur_execution =
! 1678: d_ex_erreur_type_argument;
! 1679: return;
! 1680: }
! 1681:
! 1682: l_element_courant = (*l_element_courant).suivant;
! 1683: }
! 1684: }
! 1685: else
! 1686: {
! 1687: liberation(s_etat_processus, s_objet_argument);
! 1688:
! 1689: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1690: return;
! 1691: }
! 1692:
! 1693: liberation(s_etat_processus, s_objet_argument);
! 1694:
! 1695: return;
! 1696: }
! 1697:
! 1698: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_a4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src