Annotation of rpl/src/instructions_f1.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Fonction '->'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_fleche(struct_processus *s_etat_processus)
! 40: {
! 41: struct_liste_chainee *l_element_courant;
! 42: struct_liste_chainee *l_emplacement_valeurs;
! 43:
! 44: struct_objet *s_objet;
! 45: struct_objet *s_objet_elementaire;
! 46: struct_objet *s_expression_algebrique;
! 47:
! 48: struct_variable s_variable;
! 49:
! 50: struct_variable_partagee s_variable_partagee;
! 51: struct_variable_statique s_variable_statique;
! 52:
! 53: logical1 fin_scrutation;
! 54: logical1 presence_expression_algebrique;
! 55:
! 56: union_position_variable position_variable;
! 57:
! 58: unsigned char instruction_valide;
! 59: unsigned char *tampon;
! 60: unsigned char test_instruction;
! 61:
! 62: unsigned long i;
! 63: unsigned long nombre_variables;
! 64:
! 65: void (*fonction)();
! 66:
! 67: (*s_etat_processus).erreur_execution = d_ex;
! 68:
! 69: if ((*s_etat_processus).affichage_arguments == 'Y')
! 70: {
! 71: printf("\n -> ");
! 72:
! 73: if ((*s_etat_processus).langue == 'F')
! 74: {
! 75: printf("(création de variables locales)\n\n");
! 76: }
! 77: else
! 78: {
! 79: printf("(create local variables)\n\n");
! 80: }
! 81:
! 82: printf(" n: %s, %s, %s, %s, %s, %s,\n"
! 83: " %s, %s, %s, %s, %s,\n"
! 84: " %s, %s, %s, %s, %s,\n"
! 85: " %s, %s, %s, %s,\n"
! 86: " %s, %s\n",
! 87: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 88: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
! 89: d_SQL, d_SLB, d_PRC, d_MTX);
! 90: printf(" ...\n");
! 91: printf(" 1: %s, %s, %s, %s, %s, %s,\n"
! 92: " %s, %s, %s, %s, %s,\n"
! 93: " %s, %s, %s, %s, %s,\n"
! 94: " %s, %s, %s, %s,\n"
! 95: " %s, %s\n",
! 96: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 97: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
! 98: d_SQL, d_SLB, d_PRC, d_MTX);
! 99:
! 100: if ((*s_etat_processus).langue == 'F')
! 101: {
! 102: printf(" Utilisation :\n\n");
! 103: }
! 104: else
! 105: {
! 106: printf(" Usage:\n\n");
! 107: }
! 108:
! 109: printf(" -> (variables) %s\n\n", d_RPN);
! 110:
! 111: printf(" -> (variables) %s\n", d_ALG);
! 112:
! 113: return;
! 114: }
! 115: else if ((*s_etat_processus).test_instruction == 'Y')
! 116: {
! 117: (*s_etat_processus).nombre_arguments = -1;
! 118: return;
! 119: }
! 120:
! 121: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 122: {
! 123: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 124: {
! 125: return;
! 126: }
! 127: }
! 128:
! 129: (*s_etat_processus).autorisation_empilement_programme = 'N';
! 130:
! 131: /*
! 132: --------------------------------------------------------------------------------
! 133: Boucler jusqu'au prochain '<<' ou jusqu'à la prochaine expression algébrique
! 134: --------------------------------------------------------------------------------
! 135: */
! 136:
! 137: test_instruction = (*s_etat_processus).test_instruction;
! 138: instruction_valide = (*s_etat_processus).instruction_valide;
! 139: presence_expression_algebrique = d_faux;
! 140:
! 141: if ((*s_etat_processus).debug == d_vrai)
! 142: if (((*s_etat_processus).type_debug &
! 143: d_debug_variables) != 0)
! 144: {
! 145: if ((*s_etat_processus).langue == 'F')
! 146: {
! 147: printf("[%d] Recherche des variables locales\n", (int) getpid());
! 148: }
! 149: else
! 150: {
! 151: printf("[%d] Searching for local variables\n", (int) getpid());
! 152: }
! 153:
! 154: fflush(stdout);
! 155: }
! 156:
! 157: nombre_variables = 0;
! 158:
! 159: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 160: {
! 161: /*
! 162: * Le programme est exécuté normalement.
! 163: */
! 164:
! 165: tampon = (*s_etat_processus).instruction_courante;
! 166:
! 167: do
! 168: {
! 169: if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
! 170: {
! 171: (*s_etat_processus).instruction_courante = tampon;
! 172: return;
! 173: }
! 174:
! 175: if (strcmp((*s_etat_processus).instruction_courante, "<<") == 0)
! 176: {
! 177: fin_scrutation = d_vrai;
! 178: (*s_etat_processus).test_instruction = 'N';
! 179: }
! 180: else
! 181: {
! 182: fin_scrutation = d_faux;
! 183: (*s_etat_processus).test_instruction = 'Y';
! 184: }
! 185:
! 186: analyse(s_etat_processus, NULL);
! 187:
! 188: if ((*s_etat_processus).instruction_valide == 'N')
! 189: {
! 190: recherche_type(s_etat_processus);
! 191:
! 192: if ((*s_etat_processus).erreur_execution != d_ex)
! 193: {
! 194: (*s_etat_processus).instruction_courante = tampon;
! 195: return;
! 196: }
! 197:
! 198: if ((*(*(*s_etat_processus).l_base_pile).donnee).type == ALG)
! 199: {
! 200: (*s_etat_processus).niveau_courant++;
! 201: fin_scrutation = d_vrai;
! 202: presence_expression_algebrique = d_vrai;
! 203:
! 204: if (depilement(s_etat_processus, &((*s_etat_processus)
! 205: .l_base_pile), &s_expression_algebrique)
! 206: == d_erreur)
! 207: {
! 208: (*s_etat_processus).erreur_execution =
! 209: d_ex_manque_argument;
! 210: (*s_etat_processus).instruction_courante = tampon;
! 211: return;
! 212: }
! 213: }
! 214: else if ((*(*(*s_etat_processus).l_base_pile).donnee)
! 215: .type != NOM)
! 216: {
! 217: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 218: (*s_etat_processus).instruction_courante = tampon;
! 219: return;
! 220: }
! 221: else if ((*((struct_nom *) (*(*(*s_etat_processus).l_base_pile)
! 222: .donnee).objet)).symbole == d_vrai)
! 223: {
! 224: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 225: (*s_etat_processus).instruction_courante = tampon;
! 226: return;
! 227: }
! 228: else
! 229: {
! 230: nombre_variables = nombre_variables + 1;
! 231: }
! 232: }
! 233: else
! 234: {
! 235: if (fin_scrutation == d_faux)
! 236: {
! 237: (*s_etat_processus).erreur_execution = d_ex_nom_reserve;
! 238: (*s_etat_processus).instruction_courante = tampon;
! 239: return;
! 240: }
! 241: }
! 242:
! 243: free((*s_etat_processus).instruction_courante);
! 244: } while(fin_scrutation == d_faux);
! 245:
! 246: (*s_etat_processus).instruction_courante = tampon;
! 247: }
! 248: else
! 249: {
! 250: /*
! 251: * Une expression est en cours d'évaluation.
! 252: */
! 253:
! 254: l_element_courant = (*(*s_etat_processus).expression_courante).suivant;
! 255: tampon = (*s_etat_processus).instruction_courante;
! 256:
! 257: do
! 258: {
! 259: if ((*(*l_element_courant).donnee).type == FCT)
! 260: {
! 261: fonction = (*((struct_fonction *) (*(*l_element_courant)
! 262: .donnee).objet)).fonction;
! 263:
! 264: if (fonction == instruction_vers_niveau_superieur)
! 265: {
! 266: fin_scrutation = d_vrai;
! 267: (*s_etat_processus).test_instruction = 'N';
! 268:
! 269: analyse(s_etat_processus,
! 270: instruction_vers_niveau_superieur);
! 271: }
! 272: else
! 273: {
! 274: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 275: return;
! 276: }
! 277: }
! 278: else if ((*(*l_element_courant).donnee).type == ALG)
! 279: {
! 280: (*s_etat_processus).niveau_courant++;
! 281: fin_scrutation = d_vrai;
! 282: presence_expression_algebrique = d_vrai;
! 283:
! 284: s_expression_algebrique = (*l_element_courant).donnee;
! 285: }
! 286: else if ((*(*l_element_courant).donnee).type != NOM)
! 287: {
! 288: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 289: return;
! 290: }
! 291: else
! 292: {
! 293: if ((s_objet_elementaire = copie_objet(s_etat_processus,
! 294: (*l_element_courant).donnee, 'P')) == NULL)
! 295: {
! 296: (*s_etat_processus).erreur_systeme =
! 297: d_es_allocation_memoire;
! 298: return;
! 299: }
! 300:
! 301: if (empilement(s_etat_processus, &((*s_etat_processus)
! 302: .l_base_pile), s_objet_elementaire) == d_erreur)
! 303: {
! 304: return;
! 305: }
! 306:
! 307: nombre_variables = nombre_variables + 1;
! 308: fin_scrutation = d_faux;
! 309: }
! 310:
! 311: (*s_etat_processus).expression_courante = l_element_courant;
! 312: l_element_courant = (*l_element_courant).suivant;
! 313: } while((fin_scrutation == d_faux) && (l_element_courant != NULL));
! 314:
! 315: (*s_etat_processus).instruction_courante = tampon;
! 316:
! 317: if (fin_scrutation == d_faux)
! 318: {
! 319: (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
! 320: return;
! 321: }
! 322: }
! 323:
! 324: if (nombre_variables < 1)
! 325: {
! 326: (*s_etat_processus).erreur_execution = d_ex_absence_variable;
! 327: return;
! 328: }
! 329:
! 330: if ((*s_etat_processus).debug == d_vrai)
! 331: if (((*s_etat_processus).type_debug &
! 332: d_debug_variables) != 0)
! 333: {
! 334: if ((*s_etat_processus).langue == 'F')
! 335: {
! 336: printf("[%d] Nombre de variables de niveau %lu : %lu\n",
! 337: (int) getpid(),
! 338: (*s_etat_processus).niveau_courant, nombre_variables);
! 339: }
! 340: else
! 341: {
! 342: printf("[%d] Number of level %lu variables : %lu\n",
! 343: (int) getpid(),
! 344: (*s_etat_processus).niveau_courant, nombre_variables);
! 345: }
! 346:
! 347: fflush(stdout);
! 348: }
! 349:
! 350: l_emplacement_valeurs = (*s_etat_processus).l_base_pile;
! 351:
! 352: for(i = 0; i < nombre_variables; i++)
! 353: {
! 354: l_emplacement_valeurs = (*l_emplacement_valeurs).suivant;
! 355: }
! 356:
! 357: l_element_courant = l_emplacement_valeurs;
! 358:
! 359: for(i = 0; i < nombre_variables; i++)
! 360: {
! 361: if (l_element_courant == NULL)
! 362: {
! 363: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 364: return;
! 365: }
! 366:
! 367: l_element_courant = (*l_element_courant).suivant;
! 368: }
! 369:
! 370: for(i = 0; i < nombre_variables; i++)
! 371: {
! 372: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 373: &s_objet) == d_erreur)
! 374: {
! 375: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 376: return;
! 377: }
! 378:
! 379: if ((s_variable.nom = malloc((strlen(
! 380: (*((struct_nom *) (*s_objet).objet)).nom) + 1) *
! 381: sizeof(unsigned char))) == NULL)
! 382: {
! 383: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 384: return;
! 385: }
! 386:
! 387: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet).objet)).nom);
! 388:
! 389: if ((*s_etat_processus).debug == d_vrai)
! 390: if (((*s_etat_processus).type_debug &
! 391: d_debug_variables) != 0)
! 392: {
! 393: printf("[%d] Variable %s\n", (int) getpid(), s_variable.nom);
! 394: fflush(stdout);
! 395: }
! 396:
! 397: s_variable.niveau = (*s_etat_processus).niveau_courant;
! 398:
! 399: // Si le drapeau creation_variables_statiques est positionné,
! 400: // on recherche une entrée dans la table des variables statiques.
! 401: // Si cette entrée existe, on affecte à la variable créée l'objet
! 402: // contenu dans la table des variables statiques. Dans le cas contraire,
! 403: // on crée une entrée dans la table des variables statiques avec
! 404: // ce qui se trouve dans la pile.
! 405:
! 406: if ((*s_etat_processus).l_base_pile_systeme == NULL)
! 407: {
! 408: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
! 409: return;
! 410: }
! 411:
! 412: /*
! 413: * Vérification de l'unicité de la variable pour un niveau donné
! 414: */
! 415:
! 416: if (recherche_variable(s_etat_processus, s_variable.nom) == d_vrai)
! 417: {
! 418: if ((*s_etat_processus).niveau_courant ==
! 419: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 420: .position_variable_courante].niveau)
! 421: {
! 422: liberation(s_etat_processus, s_objet);
! 423: free(s_variable.nom);
! 424:
! 425: (*s_etat_processus).erreur_execution = d_ex_creation_variable;
! 426: return;
! 427: }
! 428: }
! 429:
! 430: (*s_etat_processus).erreur_systeme = d_es;
! 431:
! 432: if ((*(*s_etat_processus).l_base_pile_systeme)
! 433: .creation_variables_statiques == d_vrai)
! 434: {
! 435: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 436: {
! 437: position_variable.adresse =
! 438: (*s_etat_processus).position_courante;
! 439: }
! 440: else
! 441: {
! 442: position_variable.pointeur =
! 443: (*s_etat_processus).objet_courant;
! 444: }
! 445:
! 446: if (recherche_variable_statique(s_etat_processus, s_variable.nom,
! 447: position_variable,
! 448: ((*s_etat_processus).mode_execution_programme == 'Y')
! 449: ? 'P' : 'E') == d_vrai)
! 450: {
! 451: // Variable statique à utiliser
! 452:
! 453: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 454: {
! 455: s_variable.origine = 'P';
! 456: }
! 457: else
! 458: {
! 459: s_variable.origine = 'E';
! 460: }
! 461:
! 462: s_variable.objet = (*s_etat_processus)
! 463: .s_liste_variables_statiques[(*s_etat_processus)
! 464: .position_variable_statique_courante].objet;
! 465: (*s_etat_processus).s_liste_variables_statiques
! 466: [(*s_etat_processus)
! 467: .position_variable_statique_courante].objet = NULL;
! 468: }
! 469: else
! 470: {
! 471: // Variable statique à créer
! 472:
! 473: s_variable_statique.objet = NULL;
! 474: (*s_etat_processus).erreur_systeme = d_es;
! 475:
! 476: if ((s_variable_statique.nom = malloc((strlen(s_variable.nom)
! 477: + 1) * sizeof(unsigned char))) == NULL)
! 478: {
! 479: (*s_etat_processus).erreur_systeme =
! 480: d_es_allocation_memoire;
! 481: return;
! 482: }
! 483:
! 484: strcpy(s_variable_statique.nom, s_variable.nom);
! 485:
! 486: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 487: {
! 488: s_variable_statique.origine = 'P';
! 489: s_variable_statique.niveau = 0;
! 490: s_variable_statique.variable_statique.adresse =
! 491: (*s_etat_processus).position_courante;
! 492: }
! 493: else
! 494: {
! 495: s_variable_statique.origine = 'E';
! 496:
! 497: /*
! 498: * Si la variable est appelée depuis une expression
! 499: * compilée (variable de niveau 0), la variable statique
! 500: * est persistante (niveau 0). Dans le cas contraire, elle
! 501: * est persistante à l'expression (niveau courant).
! 502: */
! 503:
! 504: if ((*s_etat_processus).evaluation_expression_compilee
! 505: == 'Y')
! 506: {
! 507: s_variable_statique.niveau = 0;
! 508: }
! 509: else
! 510: {
! 511: s_variable_statique.niveau =
! 512: (*s_etat_processus).niveau_courant;
! 513: }
! 514:
! 515: s_variable_statique.variable_statique.pointeur =
! 516: (*s_etat_processus).objet_courant;
! 517: }
! 518:
! 519: if (creation_variable_statique(s_etat_processus,
! 520: &s_variable_statique) == d_erreur)
! 521: {
! 522: return;
! 523: }
! 524:
! 525: s_variable.objet = (*l_emplacement_valeurs).donnee;
! 526: (*l_emplacement_valeurs).donnee = NULL;
! 527: }
! 528: }
! 529: else if ((*(*s_etat_processus).l_base_pile_systeme)
! 530: .creation_variables_partagees == d_vrai)
! 531: {
! 532: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 533: {
! 534: position_variable.adresse =
! 535: (*s_etat_processus).position_courante;
! 536: }
! 537: else
! 538: {
! 539: position_variable.pointeur =
! 540: (*s_etat_processus).objet_courant;
! 541: }
! 542:
! 543: if (pthread_mutex_lock(&((*(*s_etat_processus)
! 544: .s_liste_variables_partagees).mutex)) != 0)
! 545: {
! 546: (*s_etat_processus).erreur_systeme = d_es_processus;
! 547: return;
! 548: }
! 549:
! 550: if (recherche_variable_partagee(s_etat_processus, s_variable.nom,
! 551: position_variable,
! 552: ((*s_etat_processus).mode_execution_programme == 'Y')
! 553: ? 'P' : 'E') == d_vrai)
! 554: {
! 555: // Variable partagée à utiliser
! 556:
! 557: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 558: .s_liste_variables_partagees).mutex)) != 0)
! 559: {
! 560: (*s_etat_processus).erreur_systeme = d_es_processus;
! 561: return;
! 562: }
! 563:
! 564: // Les champs niveau, variable_statique, variable_partagee
! 565: // et variable_verrouillee sont renseignés lors de l'appel
! 566: // à la fonction creation_variable().
! 567:
! 568: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 569: {
! 570: s_variable.origine = 'P';
! 571: }
! 572: else
! 573: {
! 574: s_variable.origine = 'E';
! 575: }
! 576:
! 577: s_variable.objet = NULL;
! 578: }
! 579: else
! 580: {
! 581: // Variable partagee à créer
! 582:
! 583: (*s_etat_processus).erreur_systeme = d_es;
! 584:
! 585: if ((s_variable_partagee.nom = malloc((strlen(s_variable.nom)
! 586: + 1) * sizeof(unsigned char))) == NULL)
! 587: {
! 588: (*s_etat_processus).erreur_systeme =
! 589: d_es_allocation_memoire;
! 590: return;
! 591: }
! 592:
! 593: strcpy(s_variable_partagee.nom, s_variable.nom);
! 594:
! 595: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 596: {
! 597: s_variable_partagee.origine = 'P';
! 598: s_variable_partagee.niveau = 0;
! 599: s_variable_partagee.variable_partagee.adresse =
! 600: (*s_etat_processus).position_courante;
! 601: }
! 602: else
! 603: {
! 604: s_variable_partagee.origine = 'E';
! 605:
! 606: /*
! 607: * Si la variable est appelée depuis une expression
! 608: * compilée (variable de niveau 0), la variable statique
! 609: * est persistante (niveau 0). Dans le cas contraire, elle
! 610: * est persistante à l'expression (niveau courant).
! 611: */
! 612:
! 613: if ((*s_etat_processus).evaluation_expression_compilee
! 614: == 'Y')
! 615: {
! 616: s_variable_partagee.niveau = 0;
! 617: }
! 618: else
! 619: {
! 620: s_variable_partagee.niveau =
! 621: (*s_etat_processus).niveau_courant;
! 622: }
! 623:
! 624: s_variable_partagee.variable_partagee.pointeur =
! 625: (*s_etat_processus).objet_courant;
! 626: }
! 627:
! 628: s_variable_partagee.objet = (*l_emplacement_valeurs).donnee;
! 629: (*l_emplacement_valeurs).donnee = NULL;
! 630:
! 631: if (creation_variable_partagee(s_etat_processus,
! 632: &s_variable_partagee) == d_erreur)
! 633: {
! 634: return;
! 635: }
! 636:
! 637: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 638: .s_liste_variables_partagees).mutex)) != 0)
! 639: {
! 640: (*s_etat_processus).erreur_systeme = d_es_processus;
! 641: return;
! 642: }
! 643:
! 644: s_variable.objet = NULL;
! 645: }
! 646: }
! 647: else
! 648: {
! 649: s_variable.objet = (*l_emplacement_valeurs).donnee;
! 650: (*l_emplacement_valeurs).donnee = NULL;
! 651: }
! 652:
! 653: l_emplacement_valeurs = (*l_emplacement_valeurs).suivant;
! 654:
! 655: if (creation_variable(s_etat_processus, &s_variable,
! 656: ((*(*s_etat_processus).l_base_pile_systeme)
! 657: .creation_variables_statiques == d_vrai) ? 'S' : 'V',
! 658: ((*(*s_etat_processus).l_base_pile_systeme)
! 659: .creation_variables_partagees == d_vrai) ? 'S' : 'P')
! 660: == d_erreur)
! 661: {
! 662: return;
! 663: }
! 664:
! 665: liberation(s_etat_processus, s_objet);
! 666: }
! 667:
! 668: // Les prochaines variables créées seront forcément du type volatile et
! 669: // seront obligatoirement privées.
! 670:
! 671: if ((*s_etat_processus).l_base_pile_systeme == NULL)
! 672: {
! 673: (*s_etat_processus).erreur_systeme = d_es_pile_vide;
! 674: return;
! 675: }
! 676:
! 677: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_statiques
! 678: = d_faux;
! 679: (*(*s_etat_processus).l_base_pile_systeme).creation_variables_partagees
! 680: = d_faux;
! 681:
! 682: for(i = 0; i < nombre_variables; i++)
! 683: {
! 684: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 685: &s_objet) == d_erreur)
! 686: {
! 687: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 688: return;
! 689: }
! 690:
! 691: liberation(s_etat_processus, s_objet);
! 692: }
! 693:
! 694: (*s_etat_processus).test_instruction = test_instruction;
! 695: (*s_etat_processus).instruction_valide = instruction_valide;
! 696:
! 697: /*
! 698: * Traitement le cas échéant de l'expression algébrique
! 699: */
! 700:
! 701: if (presence_expression_algebrique == d_vrai)
! 702: {
! 703: evaluation(s_etat_processus, s_expression_algebrique, 'N');
! 704:
! 705: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 706: {
! 707: liberation(s_etat_processus, s_expression_algebrique);
! 708: }
! 709:
! 710: (*s_etat_processus).niveau_courant--;
! 711:
! 712: if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
! 713: {
! 714: return;
! 715: }
! 716:
! 717: (*s_etat_processus).autorisation_empilement_programme = 'Y';
! 718: }
! 719:
! 720: return;
! 721: }
! 722:
! 723:
! 724: /*
! 725: ================================================================================
! 726: Fonction '->list'
! 727: ================================================================================
! 728: Entrées : structure processus
! 729: --------------------------------------------------------------------------------
! 730: Sorties :
! 731: --------------------------------------------------------------------------------
! 732: Effets de bord : néant
! 733: ================================================================================
! 734: */
! 735:
! 736: void
! 737: instruction_fleche_list(struct_processus *s_etat_processus)
! 738: {
! 739: struct_liste_chainee *l_element_courant;
! 740:
! 741: struct_objet *s_objet;
! 742:
! 743: signed long i;
! 744: signed long nombre_elements;
! 745:
! 746: (*s_etat_processus).erreur_execution = d_ex;
! 747:
! 748: if ((*s_etat_processus).affichage_arguments == 'Y')
! 749: {
! 750: printf("\n ->LIST ");
! 751:
! 752: if ((*s_etat_processus).langue == 'F')
! 753: {
! 754: printf("(création d'une liste)\n\n");
! 755: }
! 756: else
! 757: {
! 758: printf("(create list)\n\n");
! 759: }
! 760:
! 761: printf(" n: %s, %s, %s, %s, %s, %s,\n"
! 762: " %s, %s, %s, %s, %s,\n"
! 763: " %s, %s, %s, %s, %s,\n"
! 764: " %s, %s\n",
! 765: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 766: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
! 767: printf(" ...\n");
! 768: printf(" 2: %s, %s, %s, %s, %s, %s,\n"
! 769: " %s, %s, %s, %s, %s,\n"
! 770: " %s, %s, %s, %s, %s,\n"
! 771: " %s, %s\n",
! 772: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
! 773: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
! 774: printf(" 1: %s\n", d_INT);
! 775: printf("-> 1: %s\n", d_LST);
! 776:
! 777: return;
! 778: }
! 779: else if ((*s_etat_processus).test_instruction == 'Y')
! 780: {
! 781: (*s_etat_processus).nombre_arguments = -1;
! 782: return;
! 783: }
! 784:
! 785: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 786: {
! 787: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 788: {
! 789: return;
! 790: }
! 791: }
! 792:
! 793: if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
! 794: {
! 795: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 796: return;
! 797: }
! 798:
! 799: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != INT)
! 800: {
! 801: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 802: return;
! 803: }
! 804:
! 805: nombre_elements = (*((integer8 *) (*(*(*s_etat_processus).l_base_pile)
! 806: .donnee).objet));
! 807:
! 808: if (nombre_elements < 0)
! 809: {
! 810:
! 811: /*
! 812: -- Opération absurde autorisée sur le calculateur HP-28S -----------------------
! 813: */
! 814:
! 815: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 816: return;
! 817: }
! 818:
! 819: if ((unsigned long) nombre_elements >=
! 820: (*s_etat_processus).hauteur_pile_operationnelle)
! 821: {
! 822: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 823: return;
! 824: }
! 825:
! 826: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 827: {
! 828: if (empilement_pile_last(s_etat_processus, nombre_elements + 1)
! 829: == d_erreur)
! 830: {
! 831: return;
! 832: }
! 833: }
! 834:
! 835: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 836: &s_objet) == d_erreur)
! 837: {
! 838: return;
! 839: }
! 840:
! 841: liberation(s_etat_processus, s_objet);
! 842: l_element_courant = NULL;
! 843:
! 844: for(i = 0; i < nombre_elements; i++)
! 845: {
! 846: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 847: &s_objet) == d_erreur)
! 848: {
! 849: return;
! 850: }
! 851:
! 852: if (empilement(s_etat_processus, &l_element_courant, s_objet)
! 853: == d_erreur)
! 854: {
! 855: return;
! 856: }
! 857: }
! 858:
! 859: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
! 860: {
! 861: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 862: return;
! 863: }
! 864:
! 865: (*s_objet).objet = (void *) l_element_courant;
! 866:
! 867: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 868: s_objet) == d_erreur)
! 869: {
! 870: return;
! 871: }
! 872:
! 873: return;
! 874: }
! 875:
! 876:
! 877: /*
! 878: ================================================================================
! 879: Fonction 'for'
! 880: ================================================================================
! 881: Entrées : structure processus
! 882: --------------------------------------------------------------------------------
! 883: Sorties :
! 884: --------------------------------------------------------------------------------
! 885: Effets de bord : néant
! 886: ================================================================================
! 887: */
! 888:
! 889: void
! 890: instruction_for(struct_processus *s_etat_processus)
! 891: {
! 892: struct_objet *s_objet_1;
! 893: struct_objet *s_objet_2;
! 894: struct_objet *s_objet_3;
! 895:
! 896: struct_variable s_variable;
! 897:
! 898: unsigned char instruction_valide;
! 899: unsigned char *tampon;
! 900: unsigned char test_instruction;
! 901:
! 902: (*s_etat_processus).erreur_execution = d_ex;
! 903:
! 904: if ((*s_etat_processus).affichage_arguments == 'Y')
! 905: {
! 906: printf("\n FOR ");
! 907:
! 908: if ((*s_etat_processus).langue == 'F')
! 909: {
! 910: printf("(boucle définie avec compteur)\n\n");
! 911: }
! 912: else
! 913: {
! 914: printf("(define a counter-based loop)\n\n");
! 915: }
! 916:
! 917: if ((*s_etat_processus).langue == 'F')
! 918: {
! 919: printf(" Utilisation :\n\n");
! 920: }
! 921: else
! 922: {
! 923: printf(" Usage:\n\n");
! 924: }
! 925:
! 926: printf(" %s/%s %s/%s FOR (variable)\n", d_INT, d_REL,
! 927: d_INT, d_REL);
! 928: printf(" (expression)\n");
! 929: printf(" [EXIT]/[CYCLE]\n");
! 930: printf(" ...\n");
! 931: printf(" NEXT\n\n");
! 932:
! 933: printf(" %s/%s %s/%s FOR (variable)\n", d_INT, d_REL,
! 934: d_INT, d_REL);
! 935: printf(" (expression)\n");
! 936: printf(" [EXIT]/[CYCLE]\n");
! 937: printf(" ...\n");
! 938: printf(" %s/%s STEP\n", d_INT, d_REL);
! 939:
! 940: return;
! 941: }
! 942: else if ((*s_etat_processus).test_instruction == 'Y')
! 943: {
! 944: (*s_etat_processus).nombre_arguments = -1;
! 945: return;
! 946: }
! 947:
! 948: if ((*s_etat_processus).erreur_systeme != d_es)
! 949: {
! 950: return;
! 951: }
! 952:
! 953: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 954: {
! 955: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 956: {
! 957: return;
! 958: }
! 959: }
! 960:
! 961: empilement_pile_systeme(s_etat_processus);
! 962:
! 963: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 964: &s_objet_1) == d_erreur)
! 965: {
! 966: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 967: return;
! 968: }
! 969:
! 970: if (((*s_objet_1).type != INT) &&
! 971: ((*s_objet_1).type != REL))
! 972: {
! 973: liberation(s_etat_processus, s_objet_1);
! 974:
! 975: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
! 976: return;
! 977: }
! 978:
! 979: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 980: &s_objet_2) == d_erreur)
! 981: {
! 982: liberation(s_etat_processus, s_objet_1);
! 983:
! 984: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 985: return;
! 986: }
! 987:
! 988: if (((*s_objet_2).type != INT) &&
! 989: ((*s_objet_2).type != REL))
! 990: {
! 991: liberation(s_etat_processus, s_objet_1);
! 992: liberation(s_etat_processus, s_objet_2);
! 993:
! 994: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
! 995: return;
! 996: }
! 997:
! 998: tampon = (*s_etat_processus).instruction_courante;
! 999: test_instruction = (*s_etat_processus).test_instruction;
! 1000: instruction_valide = (*s_etat_processus).instruction_valide;
! 1001: (*s_etat_processus).test_instruction = 'Y';
! 1002:
! 1003: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 1004: {
! 1005: if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
! 1006: {
! 1007: return;
! 1008: }
! 1009:
! 1010: analyse(s_etat_processus, NULL);
! 1011:
! 1012: if ((*s_etat_processus).instruction_valide == 'Y')
! 1013: {
! 1014: liberation(s_etat_processus, s_objet_1);
! 1015: liberation(s_etat_processus, s_objet_2);
! 1016:
! 1017: free((*s_etat_processus).instruction_courante);
! 1018: (*s_etat_processus).instruction_courante = tampon;
! 1019:
! 1020: (*s_etat_processus).erreur_execution = d_ex_nom_reserve;
! 1021: return;
! 1022: }
! 1023:
! 1024: recherche_type(s_etat_processus);
! 1025:
! 1026: free((*s_etat_processus).instruction_courante);
! 1027: (*s_etat_processus).instruction_courante = tampon;
! 1028:
! 1029: if ((*s_etat_processus).erreur_execution != d_ex)
! 1030: {
! 1031: liberation(s_etat_processus, s_objet_1);
! 1032: liberation(s_etat_processus, s_objet_2);
! 1033:
! 1034: return;
! 1035: }
! 1036:
! 1037: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1038: &s_objet_3) == d_erreur)
! 1039: {
! 1040: liberation(s_etat_processus, s_objet_1);
! 1041: liberation(s_etat_processus, s_objet_2);
! 1042:
! 1043: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1044: return;
! 1045: }
! 1046:
! 1047: (*(*s_etat_processus).l_base_pile_systeme)
! 1048: .origine_routine_evaluation = 'N';
! 1049: }
! 1050: else
! 1051: {
! 1052: if ((*s_etat_processus).expression_courante == NULL)
! 1053: {
! 1054: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1055: return;
! 1056: }
! 1057:
! 1058: (*s_etat_processus).expression_courante = (*(*s_etat_processus)
! 1059: .expression_courante).suivant;
! 1060:
! 1061: if ((s_objet_3 = copie_objet(s_etat_processus,
! 1062: (*(*s_etat_processus).expression_courante)
! 1063: .donnee, 'P')) == NULL)
! 1064: {
! 1065: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1066: return;
! 1067: }
! 1068:
! 1069: (*(*s_etat_processus).l_base_pile_systeme)
! 1070: .origine_routine_evaluation = 'Y';
! 1071: }
! 1072:
! 1073: if ((*s_objet_3).type != NOM)
! 1074: {
! 1075: liberation(s_etat_processus, s_objet_1);
! 1076: liberation(s_etat_processus, s_objet_2);
! 1077:
! 1078: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
! 1079: return;
! 1080: }
! 1081: else if ((*((struct_nom *) (*s_objet_3).objet)).symbole == d_vrai)
! 1082: {
! 1083: liberation(s_etat_processus, s_objet_1);
! 1084: liberation(s_etat_processus, s_objet_2);
! 1085:
! 1086: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
! 1087: return;
! 1088: }
! 1089:
! 1090: (*s_etat_processus).niveau_courant++;
! 1091:
! 1092: if ((s_variable.nom = malloc((strlen(
! 1093: (*((struct_nom *) (*s_objet_3).objet)).nom) + 1) *
! 1094: sizeof(unsigned char))) == NULL)
! 1095: {
! 1096: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1097: return;
! 1098: }
! 1099:
! 1100: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_3).objet)).nom);
! 1101: s_variable.niveau = (*s_etat_processus).niveau_courant;
! 1102: s_variable.objet = s_objet_2;
! 1103:
! 1104: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') == d_erreur)
! 1105: {
! 1106: return;
! 1107: }
! 1108:
! 1109: liberation(s_etat_processus, s_objet_3);
! 1110:
! 1111: (*s_etat_processus).test_instruction = test_instruction;
! 1112: (*s_etat_processus).instruction_valide = instruction_valide;
! 1113:
! 1114: (*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;
! 1115:
! 1116: if ((*s_etat_processus).mode_execution_programme == 'Y')
! 1117: {
! 1118: (*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
! 1119: (*s_etat_processus).position_courante;
! 1120: }
! 1121: else
! 1122: {
! 1123: (*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
! 1124: (*s_etat_processus).expression_courante;
! 1125: }
! 1126:
! 1127: (*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'F';
! 1128:
! 1129: if (((*(*s_etat_processus).l_base_pile_systeme).nom_variable =
! 1130: malloc((strlen(s_variable.nom) + 1) *
! 1131: sizeof(unsigned char))) == NULL)
! 1132: {
! 1133: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1134: return;
! 1135: }
! 1136:
! 1137: strcpy((*(*s_etat_processus).l_base_pile_systeme).nom_variable,
! 1138: s_variable.nom);
! 1139:
! 1140: return;
! 1141: }
! 1142:
! 1143:
! 1144: /*
! 1145: ================================================================================
! 1146: Fonction 'fc?'
! 1147: ================================================================================
! 1148: Entrées : structure processus
! 1149: --------------------------------------------------------------------------------
! 1150: Sorties :
! 1151: --------------------------------------------------------------------------------
! 1152: Effets de bord : néant
! 1153: ================================================================================
! 1154: */
! 1155:
! 1156: void
! 1157: instruction_fc_test(struct_processus *s_etat_processus)
! 1158: {
! 1159: struct_objet *s_objet_argument;
! 1160: struct_objet *s_objet_resultat;
! 1161:
! 1162: (*s_etat_processus).erreur_execution = d_ex;
! 1163:
! 1164: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1165: {
! 1166: printf("\n FC? ");
! 1167:
! 1168: if ((*s_etat_processus).langue == 'F')
! 1169: {
! 1170: printf("(teste si un drapeau est désarmé)\n\n");
! 1171: }
! 1172: else
! 1173: {
! 1174: printf("(test if flag is clear)\n\n");
! 1175: }
! 1176:
! 1177: printf(" 1: %s\n", d_INT);
! 1178: printf("-> 1: %s\n", d_INT);
! 1179:
! 1180: return;
! 1181: }
! 1182: else if ((*s_etat_processus).test_instruction == 'Y')
! 1183: {
! 1184: (*s_etat_processus).nombre_arguments = -1;
! 1185: return;
! 1186: }
! 1187:
! 1188: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1189: {
! 1190: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1191: {
! 1192: return;
! 1193: }
! 1194: }
! 1195:
! 1196: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1197: &s_objet_argument) == d_erreur)
! 1198: {
! 1199: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1200: return;
! 1201: }
! 1202:
! 1203: if ((*s_objet_argument).type == INT)
! 1204: {
! 1205: if (((*((integer8 *) (*s_objet_argument).objet)) < 1) ||
! 1206: ((*((integer8 *) (*s_objet_argument).objet)) > 64))
! 1207: {
! 1208: liberation(s_etat_processus, s_objet_argument);
! 1209:
! 1210: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
! 1211: return;
! 1212: }
! 1213:
! 1214: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 1215: == NULL)
! 1216: {
! 1217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1218: return;
! 1219: }
! 1220:
! 1221: if (test_cfsf(s_etat_processus, (unsigned char) (*((integer8 *)
! 1222: (*s_objet_argument).objet))) == d_vrai)
! 1223: {
! 1224: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 1225: }
! 1226: else
! 1227: {
! 1228: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
! 1229: }
! 1230: }
! 1231: else
! 1232: {
! 1233: liberation(s_etat_processus, s_objet_argument);
! 1234:
! 1235: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1236: return;
! 1237: }
! 1238:
! 1239: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1240: s_objet_resultat) == d_erreur)
! 1241: {
! 1242: return;
! 1243: }
! 1244:
! 1245: liberation(s_etat_processus, s_objet_argument);
! 1246:
! 1247: return;
! 1248: }
! 1249:
! 1250:
! 1251: /*
! 1252: ================================================================================
! 1253: Fonction 'fs?'
! 1254: ================================================================================
! 1255: Entrées : structure processus
! 1256: --------------------------------------------------------------------------------
! 1257: Sorties :
! 1258: --------------------------------------------------------------------------------
! 1259: Effets de bord : néant
! 1260: ================================================================================
! 1261: */
! 1262:
! 1263: void
! 1264: instruction_fs_test(struct_processus *s_etat_processus)
! 1265: {
! 1266: struct_objet *s_objet_argument;
! 1267: struct_objet *s_objet_resultat;
! 1268:
! 1269: (*s_etat_processus).erreur_execution = d_ex;
! 1270:
! 1271: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1272: {
! 1273: printf("\n FS? ");
! 1274:
! 1275: if ((*s_etat_processus).langue == 'F')
! 1276: {
! 1277: printf("(teste si un drapeau est armé)\n\n");
! 1278: }
! 1279: else
! 1280: {
! 1281: printf("(test if flag is set)\n\n");
! 1282: }
! 1283:
! 1284: printf(" 1: %s\n", d_INT);
! 1285: printf("-> 1: %s\n", d_INT);
! 1286:
! 1287: return;
! 1288: }
! 1289: else if ((*s_etat_processus).test_instruction == 'Y')
! 1290: {
! 1291: (*s_etat_processus).nombre_arguments = -1;
! 1292: return;
! 1293: }
! 1294:
! 1295: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1296: {
! 1297: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1298: {
! 1299: return;
! 1300: }
! 1301: }
! 1302:
! 1303: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1304: &s_objet_argument) == d_erreur)
! 1305: {
! 1306: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1307: return;
! 1308: }
! 1309:
! 1310: if ((*s_objet_argument).type == INT)
! 1311: {
! 1312: if (((*((integer8 *) (*s_objet_argument).objet)) < 1) ||
! 1313: ((*((integer8 *) (*s_objet_argument).objet)) > 64))
! 1314: {
! 1315: liberation(s_etat_processus, s_objet_argument);
! 1316:
! 1317: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
! 1318: return;
! 1319: }
! 1320:
! 1321: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 1322: == NULL)
! 1323: {
! 1324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1325: return;
! 1326: }
! 1327:
! 1328: if (test_cfsf(s_etat_processus, (unsigned char) (*((integer8 *)
! 1329: (*s_objet_argument).objet))) == d_vrai)
! 1330: {
! 1331: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
! 1332: }
! 1333: else
! 1334: {
! 1335: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 1336: }
! 1337: }
! 1338: else
! 1339: {
! 1340: liberation(s_etat_processus, s_objet_argument);
! 1341:
! 1342: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1343: return;
! 1344: }
! 1345:
! 1346: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1347: s_objet_resultat) == d_erreur)
! 1348: {
! 1349: return;
! 1350: }
! 1351:
! 1352: liberation(s_etat_processus, s_objet_argument);
! 1353:
! 1354: return;
! 1355: }
! 1356:
! 1357:
! 1358: /*
! 1359: ================================================================================
! 1360: Fonction 'fs?s'
! 1361: ================================================================================
! 1362: Entrées : structure processus
! 1363: --------------------------------------------------------------------------------
! 1364: Sorties :
! 1365: --------------------------------------------------------------------------------
! 1366: Effets de bord : néant
! 1367: ================================================================================
! 1368: */
! 1369:
! 1370: void
! 1371: instruction_fs_test_s(struct_processus *s_etat_processus)
! 1372: {
! 1373: (*s_etat_processus).erreur_execution = d_ex;
! 1374:
! 1375: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1376: {
! 1377: printf("\n FS?S ");
! 1378:
! 1379: if ((*s_etat_processus).langue == 'F')
! 1380: {
! 1381: printf("(teste si un drapeau est armé et arme le drapeau)\n\n");
! 1382: }
! 1383: else
! 1384: {
! 1385: printf("(test if flag is set and set flag)\n\n");
! 1386: }
! 1387:
! 1388: printf(" 1: %s\n", d_INT);
! 1389: printf("-> 1: %s\n", d_INT);
! 1390:
! 1391: return;
! 1392: }
! 1393: else if ((*s_etat_processus).test_instruction == 'Y')
! 1394: {
! 1395: (*s_etat_processus).nombre_arguments = -1;
! 1396: return;
! 1397: }
! 1398:
! 1399: instruction_dup(s_etat_processus);
! 1400:
! 1401: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1402: ((*s_etat_processus).erreur_execution != d_ex))
! 1403: {
! 1404: return;
! 1405: }
! 1406:
! 1407: instruction_fs_test(s_etat_processus);
! 1408:
! 1409: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1410: ((*s_etat_processus).erreur_execution != d_ex))
! 1411: {
! 1412: return;
! 1413: }
! 1414:
! 1415: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1416: ((*s_etat_processus).erreur_execution != d_ex))
! 1417: {
! 1418: return;
! 1419: }
! 1420:
! 1421: instruction_swap(s_etat_processus);
! 1422:
! 1423: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1424: ((*s_etat_processus).erreur_execution != d_ex))
! 1425: {
! 1426: return;
! 1427: }
! 1428:
! 1429: instruction_sf(s_etat_processus);
! 1430:
! 1431: return;
! 1432: }
! 1433:
! 1434:
! 1435: /*
! 1436: ================================================================================
! 1437: Fonction 'fs?c'
! 1438: ================================================================================
! 1439: Entrées : structure processus
! 1440: --------------------------------------------------------------------------------
! 1441: Sorties :
! 1442: --------------------------------------------------------------------------------
! 1443: Effets de bord : néant
! 1444: ================================================================================
! 1445: */
! 1446:
! 1447: void
! 1448: instruction_fs_test_c(struct_processus *s_etat_processus)
! 1449: {
! 1450: (*s_etat_processus).erreur_execution = d_ex;
! 1451:
! 1452: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1453: {
! 1454: printf("\n FS?C ");
! 1455:
! 1456: if ((*s_etat_processus).langue == 'F')
! 1457: {
! 1458: printf("(teste si un drapeau est armé et désarme le drapeau)\n\n");
! 1459: }
! 1460: else
! 1461: {
! 1462: printf("(test if flag is set and clear flag)\n\n");
! 1463: }
! 1464:
! 1465: printf(" 1: %s\n", d_INT);
! 1466: printf("-> 1: %s\n", d_INT);
! 1467:
! 1468: return;
! 1469: }
! 1470: else if ((*s_etat_processus).test_instruction == 'Y')
! 1471: {
! 1472: (*s_etat_processus).nombre_arguments = -1;
! 1473: return;
! 1474: }
! 1475:
! 1476: instruction_dup(s_etat_processus);
! 1477:
! 1478: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1479: ((*s_etat_processus).erreur_execution != d_ex))
! 1480: {
! 1481: return;
! 1482: }
! 1483:
! 1484: instruction_fs_test(s_etat_processus);
! 1485:
! 1486: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1487: ((*s_etat_processus).erreur_execution != d_ex))
! 1488: {
! 1489: return;
! 1490: }
! 1491:
! 1492: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1493: ((*s_etat_processus).erreur_execution != d_ex))
! 1494: {
! 1495: return;
! 1496: }
! 1497:
! 1498: instruction_swap(s_etat_processus);
! 1499:
! 1500: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1501: ((*s_etat_processus).erreur_execution != d_ex))
! 1502: {
! 1503: return;
! 1504: }
! 1505:
! 1506: instruction_cf(s_etat_processus);
! 1507:
! 1508: return;
! 1509: }
! 1510:
! 1511:
! 1512: /*
! 1513: ================================================================================
! 1514: Fonction 'fc?s'
! 1515: ================================================================================
! 1516: Entrées : structure processus
! 1517: --------------------------------------------------------------------------------
! 1518: Sorties :
! 1519: --------------------------------------------------------------------------------
! 1520: Effets de bord : néant
! 1521: ================================================================================
! 1522: */
! 1523:
! 1524: void
! 1525: instruction_fc_test_s(struct_processus *s_etat_processus)
! 1526: {
! 1527: (*s_etat_processus).erreur_execution = d_ex;
! 1528:
! 1529: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1530: {
! 1531: printf("\n FC?S ");
! 1532:
! 1533: if ((*s_etat_processus).langue == 'F')
! 1534: {
! 1535: printf("(teste si un drapeau est désarmé et arme le drapeau)\n\n");
! 1536: }
! 1537: else
! 1538: {
! 1539: printf("(test if flag is clear and set flag)\n\n");
! 1540: }
! 1541:
! 1542: printf(" 1: %s\n", d_INT);
! 1543: printf("-> 1: %s\n", d_INT);
! 1544:
! 1545: return;
! 1546: }
! 1547: else if ((*s_etat_processus).test_instruction == 'Y')
! 1548: {
! 1549: (*s_etat_processus).nombre_arguments = -1;
! 1550: return;
! 1551: }
! 1552:
! 1553: instruction_dup(s_etat_processus);
! 1554:
! 1555: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1556: ((*s_etat_processus).erreur_execution != d_ex))
! 1557: {
! 1558: return;
! 1559: }
! 1560:
! 1561: instruction_fc_test(s_etat_processus);
! 1562:
! 1563: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1564: ((*s_etat_processus).erreur_execution != d_ex))
! 1565: {
! 1566: return;
! 1567: }
! 1568:
! 1569: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1570: ((*s_etat_processus).erreur_execution != d_ex))
! 1571: {
! 1572: return;
! 1573: }
! 1574:
! 1575: instruction_swap(s_etat_processus);
! 1576:
! 1577: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1578: ((*s_etat_processus).erreur_execution != d_ex))
! 1579: {
! 1580: return;
! 1581: }
! 1582:
! 1583: instruction_sf(s_etat_processus);
! 1584:
! 1585: return;
! 1586: }
! 1587:
! 1588:
! 1589: /*
! 1590: ================================================================================
! 1591: Fonction 'fc?c'
! 1592: ================================================================================
! 1593: Entrées : structure processus
! 1594: --------------------------------------------------------------------------------
! 1595: Sorties :
! 1596: --------------------------------------------------------------------------------
! 1597: Effets de bord : néant
! 1598: ================================================================================
! 1599: */
! 1600:
! 1601: void
! 1602: instruction_fc_test_c(struct_processus *s_etat_processus)
! 1603: {
! 1604: (*s_etat_processus).erreur_execution = d_ex;
! 1605:
! 1606: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1607: {
! 1608: printf("\n FC?C ");
! 1609:
! 1610: if ((*s_etat_processus).langue == 'F')
! 1611: {
! 1612: printf("(teste si un drapeau est désarmé et désarme le drapeau)"
! 1613: "\n\n");
! 1614: }
! 1615: else
! 1616: {
! 1617: printf("(test if flag is clear and clear flag)\n\n");
! 1618: }
! 1619:
! 1620: printf(" 1: %s\n", d_INT);
! 1621: printf("-> 1: %s\n", d_INT);
! 1622:
! 1623: return;
! 1624: }
! 1625: else if ((*s_etat_processus).test_instruction == 'Y')
! 1626: {
! 1627: (*s_etat_processus).nombre_arguments = -1;
! 1628: return;
! 1629: }
! 1630:
! 1631: instruction_dup(s_etat_processus);
! 1632:
! 1633: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1634: ((*s_etat_processus).erreur_execution != d_ex))
! 1635: {
! 1636: return;
! 1637: }
! 1638:
! 1639: instruction_fc_test(s_etat_processus);
! 1640:
! 1641: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1642: ((*s_etat_processus).erreur_execution != d_ex))
! 1643: {
! 1644: return;
! 1645: }
! 1646:
! 1647: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1648: ((*s_etat_processus).erreur_execution != d_ex))
! 1649: {
! 1650: return;
! 1651: }
! 1652:
! 1653: instruction_swap(s_etat_processus);
! 1654:
! 1655: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1656: ((*s_etat_processus).erreur_execution != d_ex))
! 1657: {
! 1658: return;
! 1659: }
! 1660:
! 1661: instruction_cf(s_etat_processus);
! 1662:
! 1663: return;
! 1664: }
! 1665:
! 1666:
! 1667: /*
! 1668: ================================================================================
! 1669: Fonction 'fact'
! 1670: ================================================================================
! 1671: Entrées :
! 1672: --------------------------------------------------------------------------------
! 1673: Sorties :
! 1674: --------------------------------------------------------------------------------
! 1675: Effets de bord : néant
! 1676: ================================================================================
! 1677: */
! 1678:
! 1679: void
! 1680: instruction_fact(struct_processus *s_etat_processus)
! 1681: {
! 1682: logical1 depassement;
! 1683:
! 1684: real8 produit;
! 1685:
! 1686: integer8 i;
! 1687: integer8 ifact;
! 1688: integer8 tampon;
! 1689:
! 1690: struct_liste_chainee *l_element_courant;
! 1691: struct_liste_chainee *l_element_precedent;
! 1692:
! 1693: struct_objet *s_copie_argument;
! 1694: struct_objet *s_objet_argument;
! 1695: struct_objet *s_objet_resultat;
! 1696:
! 1697: (*s_etat_processus).erreur_execution = d_ex;
! 1698:
! 1699: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1700: {
! 1701: printf("\n FACT ");
! 1702:
! 1703: if ((*s_etat_processus).langue == 'F')
! 1704: {
! 1705: printf("(factorielle)\n\n");
! 1706: }
! 1707: else
! 1708: {
! 1709: printf("(factorial)\n\n");
! 1710: }
! 1711:
! 1712: printf(" 1: %s\n", d_INT);
! 1713: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
! 1714:
! 1715: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 1716: printf("-> 1: %s\n\n", d_ALG);
! 1717:
! 1718: printf(" 1: %s\n", d_RPN);
! 1719: printf("-> 1: %s\n", d_RPN);
! 1720:
! 1721: return;
! 1722: }
! 1723: else if ((*s_etat_processus).test_instruction == 'Y')
! 1724: {
! 1725: (*s_etat_processus).nombre_arguments = 1;
! 1726: return;
! 1727: }
! 1728:
! 1729: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1730: {
! 1731: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1732: {
! 1733: return;
! 1734: }
! 1735: }
! 1736:
! 1737: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1738: &s_objet_argument) == d_erreur)
! 1739: {
! 1740: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1741: return;
! 1742: }
! 1743:
! 1744: /*
! 1745: --------------------------------------------------------------------------------
! 1746: Calcul de la factorielle d'un entier (résultat réel)
! 1747: --------------------------------------------------------------------------------
! 1748: */
! 1749:
! 1750: if ((*s_objet_argument).type == INT)
! 1751: {
! 1752: if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
! 1753: {
! 1754: if (test_cfsf(s_etat_processus, 59) == d_vrai)
! 1755: {
! 1756: liberation(s_etat_processus, s_objet_argument);
! 1757:
! 1758: (*s_etat_processus).exception = d_ep_overflow;
! 1759: return;
! 1760: }
! 1761: else
! 1762: {
! 1763: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 1764: == NULL)
! 1765: {
! 1766: (*s_etat_processus).erreur_systeme =
! 1767: d_es_allocation_memoire;
! 1768: return;
! 1769: }
! 1770:
! 1771: (*((real8 *) (*s_objet_resultat).objet)) =
! 1772: ((double) 1) / ((double) 0);
! 1773: }
! 1774: }
! 1775: else
! 1776: {
! 1777: ifact = 1;
! 1778: depassement = d_faux;
! 1779:
! 1780: for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet)); i++)
! 1781: {
! 1782: if (depassement_multiplication(&ifact, &i, &tampon) == d_erreur)
! 1783: {
! 1784: depassement = d_vrai;
! 1785: break;
! 1786: }
! 1787:
! 1788: ifact = tampon;
! 1789: }
! 1790:
! 1791: if (depassement == d_faux)
! 1792: {
! 1793: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 1794: == NULL)
! 1795: {
! 1796: (*s_etat_processus).erreur_systeme =
! 1797: d_es_allocation_memoire;
! 1798: return;
! 1799: }
! 1800:
! 1801: (*((integer8 *) (*s_objet_resultat).objet)) = ifact;
! 1802: }
! 1803: else
! 1804: {
! 1805: produit = 1;
! 1806:
! 1807: for (i = 1; i <= (*((integer8 *) (*s_objet_argument).objet));
! 1808: i++)
! 1809: {
! 1810: produit *= i;
! 1811: }
! 1812:
! 1813: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 1814: == NULL)
! 1815: {
! 1816: (*s_etat_processus).erreur_systeme =
! 1817: d_es_allocation_memoire;
! 1818: return;
! 1819: }
! 1820:
! 1821: (*((real8 *) (*s_objet_resultat).objet)) = produit;
! 1822: }
! 1823: }
! 1824: }
! 1825:
! 1826: /*
! 1827: --------------------------------------------------------------------------------
! 1828: Factorielle d'un nom
! 1829: --------------------------------------------------------------------------------
! 1830: */
! 1831:
! 1832: else if ((*s_objet_argument).type == NOM)
! 1833: {
! 1834: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 1835: == NULL)
! 1836: {
! 1837: (*s_etat_processus).erreur_systeme =
! 1838: d_es_allocation_memoire;
! 1839: return;
! 1840: }
! 1841:
! 1842: if (((*s_objet_resultat).objet =
! 1843: allocation_maillon(s_etat_processus)) == NULL)
! 1844: {
! 1845: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1846: return;
! 1847: }
! 1848:
! 1849: l_element_courant = (*s_objet_resultat).objet;
! 1850:
! 1851: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1852: == NULL)
! 1853: {
! 1854: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1855: return;
! 1856: }
! 1857:
! 1858: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1859: .nombre_arguments = 0;
! 1860: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1861: .fonction = instruction_vers_niveau_superieur;
! 1862:
! 1863: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1864: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1865: {
! 1866: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1867: return;
! 1868: }
! 1869:
! 1870: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1871: .nom_fonction, "<<");
! 1872:
! 1873: if (((*l_element_courant).suivant =
! 1874: allocation_maillon(s_etat_processus)) == NULL)
! 1875: {
! 1876: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1877: return;
! 1878: }
! 1879:
! 1880: l_element_courant = (*l_element_courant).suivant;
! 1881: (*l_element_courant).donnee = s_objet_argument;
! 1882:
! 1883: if (((*l_element_courant).suivant =
! 1884: allocation_maillon(s_etat_processus)) == NULL)
! 1885: {
! 1886: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1887: return;
! 1888: }
! 1889:
! 1890: l_element_courant = (*l_element_courant).suivant;
! 1891:
! 1892: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1893: == NULL)
! 1894: {
! 1895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1896: return;
! 1897: }
! 1898:
! 1899: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1900: .nombre_arguments = 1;
! 1901: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1902: .fonction = instruction_fact;
! 1903:
! 1904: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1905: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
! 1906: {
! 1907: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1908: return;
! 1909: }
! 1910:
! 1911: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1912: .nom_fonction, "FACT");
! 1913:
! 1914: if (((*l_element_courant).suivant =
! 1915: allocation_maillon(s_etat_processus)) == NULL)
! 1916: {
! 1917: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1918: return;
! 1919: }
! 1920:
! 1921: l_element_courant = (*l_element_courant).suivant;
! 1922:
! 1923: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 1924: == NULL)
! 1925: {
! 1926: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1927: return;
! 1928: }
! 1929:
! 1930: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1931: .nombre_arguments = 0;
! 1932: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1933: .fonction = instruction_vers_niveau_inferieur;
! 1934:
! 1935: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1936: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1937: {
! 1938: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1939: return;
! 1940: }
! 1941:
! 1942: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1943: .nom_fonction, ">>");
! 1944:
! 1945: (*l_element_courant).suivant = NULL;
! 1946: s_objet_argument = NULL;
! 1947: }
! 1948:
! 1949: /*
! 1950: --------------------------------------------------------------------------------
! 1951: Factorielle d'une expression
! 1952: --------------------------------------------------------------------------------
! 1953: */
! 1954:
! 1955: else if (((*s_objet_argument).type == ALG) ||
! 1956: ((*s_objet_argument).type == RPN))
! 1957: {
! 1958: if ((s_copie_argument = copie_objet(s_etat_processus,
! 1959: s_objet_argument, 'N')) == NULL)
! 1960: {
! 1961: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1962: return;
! 1963: }
! 1964:
! 1965: l_element_courant = (struct_liste_chainee *)
! 1966: (*s_copie_argument).objet;
! 1967: l_element_precedent = l_element_courant;
! 1968:
! 1969: while((*l_element_courant).suivant != NULL)
! 1970: {
! 1971: l_element_precedent = l_element_courant;
! 1972: l_element_courant = (*l_element_courant).suivant;
! 1973: }
! 1974:
! 1975: if (((*l_element_precedent).suivant =
! 1976: allocation_maillon(s_etat_processus)) == NULL)
! 1977: {
! 1978: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1979: return;
! 1980: }
! 1981:
! 1982: if (((*(*l_element_precedent).suivant).donnee =
! 1983: allocation(s_etat_processus, FCT)) == NULL)
! 1984: {
! 1985: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1986: return;
! 1987: }
! 1988:
! 1989: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1990: .donnee).objet)).nombre_arguments = 1;
! 1991: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1992: .donnee).objet)).fonction = instruction_fact;
! 1993:
! 1994: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1995: .suivant).donnee).objet)).nom_fonction =
! 1996: malloc(5 * sizeof(unsigned char))) == NULL)
! 1997: {
! 1998: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1999: return;
! 2000: }
! 2001:
! 2002: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 2003: .suivant).donnee).objet)).nom_fonction, "FACT");
! 2004:
! 2005: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 2006:
! 2007: s_objet_resultat = s_copie_argument;
! 2008: }
! 2009:
! 2010: /*
! 2011: --------------------------------------------------------------------------------
! 2012: Factorielle impossible à réaliser
! 2013: --------------------------------------------------------------------------------
! 2014: */
! 2015:
! 2016: else
! 2017: {
! 2018: liberation(s_etat_processus, s_objet_argument);
! 2019:
! 2020: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2021: return;
! 2022: }
! 2023:
! 2024: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2025: s_objet_resultat) == d_erreur)
! 2026: {
! 2027: return;
! 2028: }
! 2029:
! 2030: liberation(s_etat_processus, s_objet_argument);
! 2031:
! 2032: return;
! 2033: }
! 2034:
! 2035:
! 2036: /*
! 2037: ================================================================================
! 2038: Fonction 'floor'
! 2039: ================================================================================
! 2040: Entrées :
! 2041: --------------------------------------------------------------------------------
! 2042: Sorties :
! 2043: --------------------------------------------------------------------------------
! 2044: Effets de bord : néant
! 2045: ================================================================================
! 2046: */
! 2047:
! 2048: void
! 2049: instruction_floor(struct_processus *s_etat_processus)
! 2050: {
! 2051: struct_liste_chainee *l_element_courant;
! 2052: struct_liste_chainee *l_element_precedent;
! 2053:
! 2054: struct_objet *s_copie_argument;
! 2055: struct_objet *s_objet_argument;
! 2056: struct_objet *s_objet_resultat;
! 2057:
! 2058: (*s_etat_processus).erreur_execution = d_ex;
! 2059:
! 2060: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2061: {
! 2062: printf("\n FLOOR ");
! 2063:
! 2064: if ((*s_etat_processus).langue == 'F')
! 2065: {
! 2066: printf("(valeur plancher)\n\n");
! 2067: }
! 2068: else
! 2069: {
! 2070: printf("(floor value)\n\n");
! 2071: }
! 2072:
! 2073: printf(" 1: %s\n", d_INT);
! 2074: printf("-> 1: %s\n\n", d_INT);
! 2075:
! 2076: printf(" 1: %s\n", d_REL);
! 2077: printf("-> 1: %s, %s\n\n", d_INT, d_REL);
! 2078:
! 2079: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 2080: printf("-> 1: %s\n\n", d_ALG);
! 2081:
! 2082: printf(" 1: %s\n", d_RPN);
! 2083: printf("-> 1: %s\n", d_RPN);
! 2084:
! 2085: return;
! 2086: }
! 2087: else if ((*s_etat_processus).test_instruction == 'Y')
! 2088: {
! 2089: (*s_etat_processus).nombre_arguments = 1;
! 2090: return;
! 2091: }
! 2092:
! 2093: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2094: {
! 2095: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2096: {
! 2097: return;
! 2098: }
! 2099: }
! 2100:
! 2101: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2102: &s_objet_argument) == d_erreur)
! 2103: {
! 2104: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2105: return;
! 2106: }
! 2107:
! 2108: /*
! 2109: --------------------------------------------------------------------------------
! 2110: Plancher d'un entier
! 2111: --------------------------------------------------------------------------------
! 2112: */
! 2113:
! 2114: if ((*s_objet_argument).type == INT)
! 2115: {
! 2116: s_objet_resultat = s_objet_argument;
! 2117: s_objet_argument = NULL;
! 2118: }
! 2119:
! 2120: /*
! 2121: --------------------------------------------------------------------------------
! 2122: Plancher d'un réel
! 2123: --------------------------------------------------------------------------------
! 2124: */
! 2125:
! 2126: else if ((*s_objet_argument).type == REL)
! 2127: {
! 2128: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 2129: {
! 2130: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2131: return;
! 2132: }
! 2133:
! 2134: (*((integer8 *) (*s_objet_resultat).objet)) =
! 2135: floor((*((real8 *) (*s_objet_argument).objet)));
! 2136:
! 2137: if (!((((*((integer8 *) (*s_objet_resultat).objet)) <
! 2138: (*((real8 *) (*s_objet_argument).objet))) && (((*((integer8 *)
! 2139: (*s_objet_resultat).objet)) + 1) > (*((real8 *)
! 2140: (*s_objet_argument).objet))))))
! 2141: {
! 2142: free((*s_objet_resultat).objet);
! 2143:
! 2144: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
! 2145: {
! 2146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2147: return;
! 2148: }
! 2149:
! 2150: (*s_objet_resultat).type = REL;
! 2151: (*((real8 *) (*s_objet_resultat).objet)) =
! 2152: ceil((*((real8 *) (*s_objet_argument).objet)));
! 2153: }
! 2154: }
! 2155:
! 2156: /*
! 2157: --------------------------------------------------------------------------------
! 2158: Plancher d'un nom
! 2159: --------------------------------------------------------------------------------
! 2160: */
! 2161:
! 2162: else if ((*s_objet_argument).type == NOM)
! 2163: {
! 2164: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 2165: {
! 2166: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2167: return;
! 2168: }
! 2169:
! 2170: if (((*s_objet_resultat).objet =
! 2171: allocation_maillon(s_etat_processus)) == NULL)
! 2172: {
! 2173: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2174: return;
! 2175: }
! 2176:
! 2177: l_element_courant = (*s_objet_resultat).objet;
! 2178:
! 2179: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2180: == NULL)
! 2181: {
! 2182: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2183: return;
! 2184: }
! 2185:
! 2186: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2187: .nombre_arguments = 0;
! 2188: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2189: .fonction = instruction_vers_niveau_superieur;
! 2190:
! 2191: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2192: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2193: {
! 2194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2195: return;
! 2196: }
! 2197:
! 2198: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2199: .nom_fonction, "<<");
! 2200:
! 2201: if (((*l_element_courant).suivant =
! 2202: allocation_maillon(s_etat_processus)) == NULL)
! 2203: {
! 2204: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2205: return;
! 2206: }
! 2207:
! 2208: l_element_courant = (*l_element_courant).suivant;
! 2209: (*l_element_courant).donnee = s_objet_argument;
! 2210:
! 2211: if (((*l_element_courant).suivant =
! 2212: allocation_maillon(s_etat_processus)) == NULL)
! 2213: {
! 2214: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2215: return;
! 2216: }
! 2217:
! 2218: l_element_courant = (*l_element_courant).suivant;
! 2219:
! 2220: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2221: == NULL)
! 2222: {
! 2223: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2224: return;
! 2225: }
! 2226:
! 2227: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2228: .nombre_arguments = 1;
! 2229: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2230: .fonction = instruction_floor;
! 2231:
! 2232: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2233: .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
! 2234: {
! 2235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2236: return;
! 2237: }
! 2238:
! 2239: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2240: .nom_fonction, "FLOOR");
! 2241:
! 2242: if (((*l_element_courant).suivant =
! 2243: allocation_maillon(s_etat_processus)) == NULL)
! 2244: {
! 2245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2246: return;
! 2247: }
! 2248:
! 2249: l_element_courant = (*l_element_courant).suivant;
! 2250:
! 2251: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2252: == NULL)
! 2253: {
! 2254: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2255: return;
! 2256: }
! 2257:
! 2258: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2259: .nombre_arguments = 0;
! 2260: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2261: .fonction = instruction_vers_niveau_inferieur;
! 2262:
! 2263: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2264: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2265: {
! 2266: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2267: return;
! 2268: }
! 2269:
! 2270: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2271: .nom_fonction, ">>");
! 2272:
! 2273: (*l_element_courant).suivant = NULL;
! 2274: s_objet_argument = NULL;
! 2275: }
! 2276:
! 2277: /*
! 2278: --------------------------------------------------------------------------------
! 2279: Plancher d'une expression
! 2280: --------------------------------------------------------------------------------
! 2281: */
! 2282:
! 2283: else if (((*s_objet_argument).type == ALG) ||
! 2284: ((*s_objet_argument).type == RPN))
! 2285: {
! 2286: if ((s_copie_argument = copie_objet(s_etat_processus,
! 2287: s_objet_argument, 'N')) == NULL)
! 2288: {
! 2289: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2290: return;
! 2291: }
! 2292:
! 2293: l_element_courant = (struct_liste_chainee *)
! 2294: (*s_copie_argument).objet;
! 2295: l_element_precedent = l_element_courant;
! 2296:
! 2297: while((*l_element_courant).suivant != NULL)
! 2298: {
! 2299: l_element_precedent = l_element_courant;
! 2300: l_element_courant = (*l_element_courant).suivant;
! 2301: }
! 2302:
! 2303: if (((*l_element_precedent).suivant =
! 2304: allocation_maillon(s_etat_processus)) == NULL)
! 2305: {
! 2306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2307: return;
! 2308: }
! 2309:
! 2310: if (((*(*l_element_precedent).suivant).donnee =
! 2311: allocation(s_etat_processus, FCT)) == NULL)
! 2312: {
! 2313: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2314: return;
! 2315: }
! 2316:
! 2317: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2318: .donnee).objet)).nombre_arguments = 1;
! 2319: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2320: .donnee).objet)).fonction = instruction_floor;
! 2321:
! 2322: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 2323: .suivant).donnee).objet)).nom_fonction =
! 2324: malloc(6 * sizeof(unsigned char))) == NULL)
! 2325: {
! 2326: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2327: return;
! 2328: }
! 2329:
! 2330: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 2331: .suivant).donnee).objet)).nom_fonction, "FLOOR");
! 2332:
! 2333: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 2334:
! 2335: s_objet_resultat = s_copie_argument;
! 2336: }
! 2337:
! 2338: /*
! 2339: --------------------------------------------------------------------------------
! 2340: Fonction floor impossible à réaliser
! 2341: --------------------------------------------------------------------------------
! 2342: */
! 2343:
! 2344: else
! 2345: {
! 2346: liberation(s_etat_processus, s_objet_argument);
! 2347:
! 2348: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2349: return;
! 2350: }
! 2351:
! 2352: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2353: s_objet_resultat) == d_erreur)
! 2354: {
! 2355: return;
! 2356: }
! 2357:
! 2358: liberation(s_etat_processus, s_objet_argument);
! 2359:
! 2360: return;
! 2361: }
! 2362:
! 2363:
! 2364: /*
! 2365: ================================================================================
! 2366: Fonction 'fp'
! 2367: ================================================================================
! 2368: Entrées :
! 2369: --------------------------------------------------------------------------------
! 2370: Sorties :
! 2371: --------------------------------------------------------------------------------
! 2372: Effets de bord : néant
! 2373: ================================================================================
! 2374: */
! 2375:
! 2376: void
! 2377: instruction_fp(struct_processus *s_etat_processus)
! 2378: {
! 2379: struct_liste_chainee *l_element_courant;
! 2380: struct_liste_chainee *l_element_precedent;
! 2381:
! 2382: struct_objet *s_copie_argument;
! 2383: struct_objet *s_objet_argument;
! 2384: struct_objet *s_objet_resultat;
! 2385:
! 2386: (*s_etat_processus).erreur_execution = d_ex;
! 2387:
! 2388: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2389: {
! 2390: printf("\n FP ");
! 2391:
! 2392: if ((*s_etat_processus).langue == 'F')
! 2393: {
! 2394: printf("(part fractionnaire)\n\n");
! 2395: }
! 2396: else
! 2397: {
! 2398: printf("(fractional part)\n\n");
! 2399: }
! 2400:
! 2401: printf(" 1: %s, %s\n", d_INT, d_REL);
! 2402: printf("-> 1: %s\n\n", d_REL);
! 2403:
! 2404: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 2405: printf("-> 1: %s\n\n", d_ALG);
! 2406:
! 2407: printf(" 1: %s\n", d_RPN);
! 2408: printf("-> 1: %s\n", d_RPN);
! 2409:
! 2410: return;
! 2411: }
! 2412: else if ((*s_etat_processus).test_instruction == 'Y')
! 2413: {
! 2414: (*s_etat_processus).nombre_arguments = 1;
! 2415: return;
! 2416: }
! 2417:
! 2418: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2419: {
! 2420: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2421: {
! 2422: return;
! 2423: }
! 2424: }
! 2425:
! 2426: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2427: &s_objet_argument) == d_erreur)
! 2428: {
! 2429: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2430: return;
! 2431: }
! 2432:
! 2433: /*
! 2434: --------------------------------------------------------------------------------
! 2435: fp d'un entier
! 2436: --------------------------------------------------------------------------------
! 2437: */
! 2438:
! 2439: if ((*s_objet_argument).type == INT)
! 2440: {
! 2441: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 2442: == NULL)
! 2443: {
! 2444: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2445: return;
! 2446: }
! 2447:
! 2448: (*((real8 *) (*s_objet_resultat).objet)) = 0;
! 2449: }
! 2450:
! 2451: /*
! 2452: --------------------------------------------------------------------------------
! 2453: fp d'un réel
! 2454: --------------------------------------------------------------------------------
! 2455: */
! 2456:
! 2457: else if ((*s_objet_argument).type == REL)
! 2458: {
! 2459: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 2460: == NULL)
! 2461: {
! 2462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2463: return;
! 2464: }
! 2465:
! 2466: if ((*((real8 *) (*s_objet_argument).objet)) > 0)
! 2467: {
! 2468: (*((real8 *) (*s_objet_resultat).objet)) =
! 2469: (*((real8 *) (*s_objet_argument).objet)) -
! 2470: floor((*((real8 *) (*s_objet_argument).objet)));
! 2471: }
! 2472: else
! 2473: {
! 2474: (*((real8 *) (*s_objet_resultat).objet)) =
! 2475: (*((real8 *) (*s_objet_argument).objet)) -
! 2476: ceil((*((real8 *) (*s_objet_argument).objet)));
! 2477: }
! 2478: }
! 2479:
! 2480: /*
! 2481: --------------------------------------------------------------------------------
! 2482: fp d'un nom
! 2483: --------------------------------------------------------------------------------
! 2484: */
! 2485:
! 2486: else if ((*s_objet_argument).type == NOM)
! 2487: {
! 2488: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 2489: == NULL)
! 2490: {
! 2491: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2492: return;
! 2493: }
! 2494:
! 2495: if (((*s_objet_resultat).objet =
! 2496: allocation_maillon(s_etat_processus)) == NULL)
! 2497: {
! 2498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2499: return;
! 2500: }
! 2501:
! 2502: l_element_courant = (*s_objet_resultat).objet;
! 2503:
! 2504: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2505: == NULL)
! 2506: {
! 2507: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2508: return;
! 2509: }
! 2510:
! 2511: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2512: .nombre_arguments = 0;
! 2513: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2514: .fonction = instruction_vers_niveau_superieur;
! 2515:
! 2516: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2517: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2518: {
! 2519: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2520: return;
! 2521: }
! 2522:
! 2523: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2524: .nom_fonction, "<<");
! 2525:
! 2526: if (((*l_element_courant).suivant =
! 2527: allocation_maillon(s_etat_processus)) == NULL)
! 2528: {
! 2529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2530: return;
! 2531: }
! 2532:
! 2533: l_element_courant = (*l_element_courant).suivant;
! 2534: (*l_element_courant).donnee = s_objet_argument;
! 2535:
! 2536: if (((*l_element_courant).suivant =
! 2537: allocation_maillon(s_etat_processus)) == NULL)
! 2538: {
! 2539: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2540: return;
! 2541: }
! 2542:
! 2543: l_element_courant = (*l_element_courant).suivant;
! 2544:
! 2545: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2546: == NULL)
! 2547: {
! 2548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2549: return;
! 2550: }
! 2551:
! 2552: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2553: .nombre_arguments = 1;
! 2554: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2555: .fonction = instruction_fp;
! 2556:
! 2557: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2558: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2559: {
! 2560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2561: return;
! 2562: }
! 2563:
! 2564: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2565: .nom_fonction, "FP");
! 2566:
! 2567: if (((*l_element_courant).suivant =
! 2568: allocation_maillon(s_etat_processus)) == NULL)
! 2569: {
! 2570: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2571: return;
! 2572: }
! 2573:
! 2574: l_element_courant = (*l_element_courant).suivant;
! 2575:
! 2576: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 2577: == NULL)
! 2578: {
! 2579: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2580: return;
! 2581: }
! 2582:
! 2583: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2584: .nombre_arguments = 0;
! 2585: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2586: .fonction = instruction_vers_niveau_inferieur;
! 2587:
! 2588: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2589: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2590: {
! 2591: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2592: return;
! 2593: }
! 2594:
! 2595: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2596: .nom_fonction, ">>");
! 2597:
! 2598: (*l_element_courant).suivant = NULL;
! 2599: s_objet_argument = NULL;
! 2600: }
! 2601:
! 2602: /*
! 2603: --------------------------------------------------------------------------------
! 2604: fp d'une expression
! 2605: --------------------------------------------------------------------------------
! 2606: */
! 2607:
! 2608: else if (((*s_objet_argument).type == ALG) ||
! 2609: ((*s_objet_argument).type == RPN))
! 2610: {
! 2611: if ((s_copie_argument = copie_objet(s_etat_processus,
! 2612: s_objet_argument, 'N')) == NULL)
! 2613: {
! 2614: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2615: return;
! 2616: }
! 2617:
! 2618: l_element_courant = (struct_liste_chainee *)
! 2619: (*s_copie_argument).objet;
! 2620: l_element_precedent = l_element_courant;
! 2621:
! 2622: while((*l_element_courant).suivant != NULL)
! 2623: {
! 2624: l_element_precedent = l_element_courant;
! 2625: l_element_courant = (*l_element_courant).suivant;
! 2626: }
! 2627:
! 2628: if (((*l_element_precedent).suivant =
! 2629: allocation_maillon(s_etat_processus)) == NULL)
! 2630: {
! 2631: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2632: return;
! 2633: }
! 2634:
! 2635: if (((*(*l_element_precedent).suivant).donnee =
! 2636: allocation(s_etat_processus, FCT)) == NULL)
! 2637: {
! 2638: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2639: return;
! 2640: }
! 2641:
! 2642: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2643: .donnee).objet)).nombre_arguments = 1;
! 2644: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2645: .donnee).objet)).fonction = instruction_fp;
! 2646:
! 2647: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 2648: .suivant).donnee).objet)).nom_fonction =
! 2649: malloc(3 * sizeof(unsigned char))) == NULL)
! 2650: {
! 2651: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2652: return;
! 2653: }
! 2654:
! 2655: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 2656: .suivant).donnee).objet)).nom_fonction, "FP");
! 2657:
! 2658: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 2659:
! 2660: s_objet_resultat = s_copie_argument;
! 2661: }
! 2662:
! 2663: /*
! 2664: --------------------------------------------------------------------------------
! 2665: Fonction fp impossible à réaliser
! 2666: --------------------------------------------------------------------------------
! 2667: */
! 2668:
! 2669: else
! 2670: {
! 2671: liberation(s_etat_processus, s_objet_argument);
! 2672:
! 2673: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2674: return;
! 2675: }
! 2676:
! 2677: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2678: s_objet_resultat) == d_erreur)
! 2679: {
! 2680: return;
! 2681: }
! 2682:
! 2683: liberation(s_etat_processus, s_objet_argument);
! 2684:
! 2685: return;
! 2686: }
! 2687:
! 2688:
! 2689: /*
! 2690: ================================================================================
! 2691: Fonction 'fix'
! 2692: ================================================================================
! 2693: Entrées : pointeur sur une struct_processus
! 2694: --------------------------------------------------------------------------------
! 2695: Sorties :
! 2696: --------------------------------------------------------------------------------
! 2697: Effets de bord : néant
! 2698: ================================================================================
! 2699: */
! 2700:
! 2701: void
! 2702: instruction_fix(struct_processus *s_etat_processus)
! 2703: {
! 2704: struct_objet *s_objet_argument;
! 2705: struct_objet *s_objet;
! 2706:
! 2707: logical1 i43;
! 2708: logical1 i44;
! 2709:
! 2710: unsigned char *valeur_binaire;
! 2711:
! 2712: unsigned long i;
! 2713: unsigned long j;
! 2714:
! 2715: (*s_etat_processus).erreur_execution = d_ex;
! 2716:
! 2717: if ((*s_etat_processus).affichage_arguments == 'Y')
! 2718: {
! 2719: printf("\n FIX ");
! 2720:
! 2721: if ((*s_etat_processus).langue == 'F')
! 2722: {
! 2723: printf("(format virgule fixe)\n\n");
! 2724: }
! 2725: else
! 2726: {
! 2727: printf("(fixed point format)\n\n");
! 2728: }
! 2729:
! 2730: printf(" 1: %s\n", d_INT);
! 2731:
! 2732: return;
! 2733: }
! 2734: else if ((*s_etat_processus).test_instruction == 'Y')
! 2735: {
! 2736: (*s_etat_processus).nombre_arguments = -1;
! 2737: return;
! 2738: }
! 2739:
! 2740: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 2741: {
! 2742: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 2743: {
! 2744: return;
! 2745: }
! 2746: }
! 2747:
! 2748: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2749: &s_objet_argument) == d_erreur)
! 2750: {
! 2751: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 2752: return;
! 2753: }
! 2754:
! 2755: if ((*s_objet_argument).type == INT)
! 2756: {
! 2757: if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) &&
! 2758: ((*((integer8 *) (*s_objet_argument).objet)) <= 15))
! 2759: {
! 2760: if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
! 2761: {
! 2762: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2763: return;
! 2764: }
! 2765:
! 2766: (*((logical8 *) (*s_objet).objet)) =
! 2767: (*((integer8 *) (*s_objet_argument).objet));
! 2768:
! 2769: i43 = test_cfsf(s_etat_processus, 43);
! 2770: i44 = test_cfsf(s_etat_processus, 44);
! 2771:
! 2772: sf(s_etat_processus, 44);
! 2773: cf(s_etat_processus, 43);
! 2774:
! 2775: if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet))
! 2776: == NULL)
! 2777: {
! 2778: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2779: return;
! 2780: }
! 2781:
! 2782: if (i43 == d_vrai)
! 2783: {
! 2784: sf(s_etat_processus, 43);
! 2785: }
! 2786: else
! 2787: {
! 2788: cf(s_etat_processus, 43);
! 2789: }
! 2790:
! 2791: if (i44 == d_vrai)
! 2792: {
! 2793: sf(s_etat_processus, 44);
! 2794: }
! 2795: else
! 2796: {
! 2797: cf(s_etat_processus, 44);
! 2798: }
! 2799:
! 2800: for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--)
! 2801: {
! 2802: if (valeur_binaire[i] == '0')
! 2803: {
! 2804: cf(s_etat_processus, j++);
! 2805: }
! 2806: else
! 2807: {
! 2808: sf(s_etat_processus, j++);
! 2809: }
! 2810: }
! 2811:
! 2812: for(; j <= 56; cf(s_etat_processus, j++));
! 2813:
! 2814: sf(s_etat_processus, 49);
! 2815: cf(s_etat_processus, 50);
! 2816:
! 2817: free(valeur_binaire);
! 2818: liberation(s_etat_processus, s_objet);
! 2819: }
! 2820: else
! 2821: {
! 2822: liberation(s_etat_processus, s_objet_argument);
! 2823:
! 2824: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 2825: return;
! 2826: }
! 2827: }
! 2828: else
! 2829: {
! 2830: liberation(s_etat_processus, s_objet_argument);
! 2831:
! 2832: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2833: return;
! 2834: }
! 2835:
! 2836: liberation(s_etat_processus, s_objet_argument);
! 2837:
! 2838: return;
! 2839: }
! 2840:
! 2841: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_f1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src