Annotation of rpl/src/instructions_c1.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 'clear'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_clear(struct_processus *s_etat_processus)
! 40: {
! 41: struct_liste_chainee *l_element_courant;
! 42: struct_liste_chainee *l_element_suivant;
! 43:
! 44: (*s_etat_processus).erreur_execution = d_ex;
! 45:
! 46: if ((*s_etat_processus).affichage_arguments == 'Y')
! 47: {
! 48: printf("\n CLEAR ");
! 49:
! 50: if ((*s_etat_processus).langue == 'F')
! 51: {
! 52: printf("(efface la pile)\n\n");
! 53: printf(" Aucun argument\n");
! 54: }
! 55: else
! 56: {
! 57: printf("(clear stack)\n\n");
! 58: printf(" No argument\n");
! 59: }
! 60:
! 61: return;
! 62: }
! 63: else if ((*s_etat_processus).test_instruction == 'Y')
! 64: {
! 65: (*s_etat_processus).nombre_arguments = -1;
! 66: return;
! 67: }
! 68:
! 69: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 70: {
! 71: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 72: {
! 73: return;
! 74: }
! 75: }
! 76:
! 77: l_element_courant = (*s_etat_processus).l_base_pile;
! 78: while(l_element_courant != NULL)
! 79: {
! 80: liberation(s_etat_processus, (*l_element_courant).donnee);
! 81: l_element_suivant = (*l_element_courant).suivant;
! 82:
! 83: // On ne libère le maillon de la chaîne. On le sauvegarde
! 84: // arbitrairement dans le tampon.
! 85:
! 86: (*l_element_courant).donnee = NULL;
! 87: (*l_element_courant).suivant = (*s_etat_processus).pile_tampon;
! 88: (*s_etat_processus).pile_tampon = l_element_courant;
! 89: (*s_etat_processus).taille_pile_tampon++;
! 90:
! 91: l_element_courant = l_element_suivant;
! 92: }
! 93:
! 94: (*s_etat_processus).l_base_pile = NULL;
! 95: (*s_etat_processus).hauteur_pile_operationnelle = 0;
! 96:
! 97: return;
! 98: }
! 99:
! 100:
! 101: /*
! 102: ================================================================================
! 103: Fonction 'cllcd' (efface la sortie graphique)
! 104: ================================================================================
! 105: Entrées : structure processus
! 106: --------------------------------------------------------------------------------
! 107: Sorties :
! 108: --------------------------------------------------------------------------------
! 109: Effets de bord : néant
! 110: ================================================================================
! 111: */
! 112:
! 113: void
! 114: instruction_cllcd(struct_processus *s_etat_processus)
! 115: {
! 116: struct_fichier_graphique *l_element_precedent;
! 117:
! 118: struct_marque *marque;
! 119: struct_marque *prochaine_marque;
! 120:
! 121: (*s_etat_processus).erreur_execution = d_ex;
! 122:
! 123: if ((*s_etat_processus).affichage_arguments == 'Y')
! 124: {
! 125: printf("\n CLLCD ");
! 126:
! 127: if ((*s_etat_processus).langue == 'F')
! 128: {
! 129: printf("(efface la file graphique)\n\n");
! 130: printf(" Aucun argument\n");
! 131: }
! 132: else
! 133: {
! 134: printf("(erase the graphical queue)\n\n");
! 135: printf(" No argument\n");
! 136: }
! 137:
! 138: return;
! 139: }
! 140: else if ((*s_etat_processus).test_instruction == 'Y')
! 141: {
! 142: (*s_etat_processus).nombre_arguments = -1;
! 143: return;
! 144: }
! 145:
! 146: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 147: {
! 148: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 149: {
! 150: return;
! 151: }
! 152: }
! 153:
! 154: while((*s_etat_processus).fichiers_graphiques != NULL)
! 155: {
! 156: if (destruction_fichier((*(*s_etat_processus).fichiers_graphiques).nom)
! 157: == d_erreur)
! 158: {
! 159: (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
! 160: return;
! 161: }
! 162:
! 163: free((*(*s_etat_processus).fichiers_graphiques).nom);
! 164:
! 165: if ((*(*s_etat_processus).fichiers_graphiques).legende != NULL)
! 166: {
! 167: free((*(*s_etat_processus).fichiers_graphiques).legende);
! 168: }
! 169:
! 170: l_element_precedent = (*s_etat_processus).fichiers_graphiques;
! 171: (*s_etat_processus).fichiers_graphiques =
! 172: (*(*s_etat_processus).fichiers_graphiques).suivant;
! 173:
! 174: free(l_element_precedent);
! 175: }
! 176:
! 177: if ((*s_etat_processus).entree_standard != NULL)
! 178: {
! 179: if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
! 180: {
! 181: (*s_etat_processus).erreur_systeme = d_es_processus;
! 182: return;
! 183: }
! 184:
! 185: if (fflush((*s_etat_processus).entree_standard) != 0)
! 186: {
! 187: (*s_etat_processus).erreur_systeme = d_es_processus;
! 188: return;
! 189: }
! 190:
! 191: if (pclose((*s_etat_processus).entree_standard) == -1)
! 192: {
! 193: (*s_etat_processus).erreur_systeme = d_es_processus;
! 194: return;
! 195: }
! 196:
! 197: (*s_etat_processus).entree_standard = NULL;
! 198: }
! 199:
! 200: free((*s_etat_processus).titre);
! 201: free((*s_etat_processus).legende);
! 202: free((*s_etat_processus).label_x);
! 203: free((*s_etat_processus).label_y);
! 204: free((*s_etat_processus).label_z);
! 205:
! 206: (*s_etat_processus).titre = malloc(sizeof(unsigned char));
! 207: (*s_etat_processus).label_x = malloc(sizeof(unsigned char));
! 208: (*s_etat_processus).label_y = malloc(sizeof(unsigned char));
! 209: (*s_etat_processus).label_z = malloc(sizeof(unsigned char));
! 210: (*s_etat_processus).legende = malloc(sizeof(unsigned char));
! 211:
! 212: if (((*s_etat_processus).titre == NULL) ||
! 213: ((*s_etat_processus).legende == NULL) ||
! 214: ((*s_etat_processus).label_x == NULL) ||
! 215: ((*s_etat_processus).label_y == NULL) ||
! 216: ((*s_etat_processus).label_z == NULL))
! 217: {
! 218: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 219: return;
! 220: }
! 221:
! 222: (*s_etat_processus).titre[0] = d_code_fin_chaine;
! 223: (*s_etat_processus).label_x[0] = d_code_fin_chaine;
! 224: (*s_etat_processus).label_y[0] = d_code_fin_chaine;
! 225: (*s_etat_processus).label_z[0] = d_code_fin_chaine;
! 226: (*s_etat_processus).legende[0] = d_code_fin_chaine;
! 227:
! 228: marque = (*s_etat_processus).s_marques;
! 229:
! 230: while(marque != NULL)
! 231: {
! 232: free((*marque).position);
! 233: free((*marque).label);
! 234: prochaine_marque = (*marque).suivant;
! 235: free(marque);
! 236: marque = prochaine_marque;
! 237: }
! 238:
! 239: (*s_etat_processus).s_marques = NULL;
! 240:
! 241: return;
! 242: }
! 243:
! 244:
! 245: /*
! 246: ================================================================================
! 247: Fonction 'cf'
! 248: ================================================================================
! 249: Entrées : structure processus
! 250: --------------------------------------------------------------------------------
! 251: Sorties :
! 252: --------------------------------------------------------------------------------
! 253: Effets de bord : néant
! 254: ================================================================================
! 255: */
! 256:
! 257: void
! 258: instruction_cf(struct_processus *s_etat_processus)
! 259: {
! 260: struct_objet *s_objet;
! 261:
! 262: (*s_etat_processus).erreur_execution = d_ex;
! 263:
! 264: if ((*s_etat_processus).affichage_arguments == 'Y')
! 265: {
! 266: printf("\n CF ");
! 267:
! 268: if ((*s_etat_processus).langue == 'F')
! 269: {
! 270: printf("(efface un indicateur binaire)\n\n");
! 271: }
! 272: else
! 273: {
! 274: printf("(clear flag)\n\n");
! 275: }
! 276:
! 277: printf(" 1: 1 <= %s <= 64\n", d_INT);
! 278:
! 279: return;
! 280: }
! 281: else if ((*s_etat_processus).test_instruction == 'Y')
! 282: {
! 283: (*s_etat_processus).nombre_arguments = -1;
! 284: return;
! 285: }
! 286:
! 287: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 288: {
! 289: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 290: {
! 291: return;
! 292: }
! 293: }
! 294:
! 295: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 296: &s_objet) == d_erreur)
! 297: {
! 298: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 299: return;
! 300: }
! 301:
! 302: if ((*s_objet).type == INT)
! 303: {
! 304: if (((*((integer8 *) (*s_objet).objet)) < 1) || ((*((integer8 *)
! 305: (*s_objet).objet)) > 64))
! 306: {
! 307: liberation(s_etat_processus, s_objet);
! 308:
! 309: (*s_etat_processus).erreur_execution = d_ex_drapeau_inexistant;
! 310: return;
! 311: }
! 312:
! 313: cf(s_etat_processus, (unsigned char) (*((integer8 *)
! 314: (*s_objet).objet)));
! 315: }
! 316: else
! 317: {
! 318: liberation(s_etat_processus, s_objet);
! 319:
! 320: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 321: return;
! 322: }
! 323:
! 324: liberation(s_etat_processus, s_objet);
! 325:
! 326: return;
! 327: }
! 328:
! 329:
! 330: /*
! 331: ================================================================================
! 332: Fonction 'ceil'
! 333: ================================================================================
! 334: Entrées :
! 335: --------------------------------------------------------------------------------
! 336: Sorties :
! 337: --------------------------------------------------------------------------------
! 338: Effets de bord : néant
! 339: ================================================================================
! 340: */
! 341:
! 342: void
! 343: instruction_ceil(struct_processus *s_etat_processus)
! 344: {
! 345: struct_liste_chainee *l_element_courant;
! 346: struct_liste_chainee *l_element_precedent;
! 347:
! 348: struct_objet *s_copie_argument;
! 349: struct_objet *s_objet_argument;
! 350: struct_objet *s_objet_resultat;
! 351:
! 352: (*s_etat_processus).erreur_execution = d_ex;
! 353:
! 354: if ((*s_etat_processus).affichage_arguments == 'Y')
! 355: {
! 356: printf("\n CEIL ");
! 357:
! 358: if ((*s_etat_processus).langue == 'F')
! 359: {
! 360: printf("(entier supérieur)\n\n");
! 361: }
! 362: else
! 363: {
! 364: printf("(ceil)\n\n");
! 365: }
! 366:
! 367: printf(" 1: %s\n", d_INT);
! 368: printf("-> 1: %s\n\n", d_INT);
! 369:
! 370: printf(" 1: %s\n", d_REL);
! 371: printf("-> 1: %s\n\n", d_REL);
! 372:
! 373: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 374: printf("-> 1: %s\n\n", d_ALG);
! 375:
! 376: printf(" 1: %s\n", d_RPN);
! 377: printf("-> 1: %s\n", d_RPN);
! 378:
! 379: return;
! 380: }
! 381: else if ((*s_etat_processus).test_instruction == 'Y')
! 382: {
! 383: (*s_etat_processus).nombre_arguments = 1;
! 384: return;
! 385: }
! 386:
! 387: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 388: {
! 389: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 390: {
! 391: return;
! 392: }
! 393: }
! 394:
! 395: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 396: &s_objet_argument) == d_erreur)
! 397: {
! 398: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 399: return;
! 400: }
! 401:
! 402: /*
! 403: --------------------------------------------------------------------------------
! 404: Plafond d'un entier
! 405: --------------------------------------------------------------------------------
! 406: */
! 407:
! 408: if ((*s_objet_argument).type == INT)
! 409: {
! 410: s_objet_resultat = s_objet_argument;
! 411: s_objet_argument = NULL;
! 412: }
! 413:
! 414: /*
! 415: --------------------------------------------------------------------------------
! 416: Plafond d'un réel
! 417: --------------------------------------------------------------------------------
! 418: */
! 419:
! 420: else if ((*s_objet_argument).type == REL)
! 421: {
! 422: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 423: {
! 424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 425: return;
! 426: }
! 427:
! 428: (*((integer8 *) (*s_objet_resultat).objet)) =
! 429: ceil((*((real8 *) (*s_objet_argument).objet)));
! 430:
! 431: if (!(((((*((integer8 *) (*s_objet_resultat).objet)) - 1) <
! 432: (*((real8 *) (*s_objet_argument).objet))) && ((*((integer8 *)
! 433: (*s_objet_resultat).objet)) > (*((real8 *) (*s_objet_argument)
! 434: .objet))))))
! 435: {
! 436: free((*s_objet_resultat).objet);
! 437:
! 438: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL)
! 439: {
! 440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 441: return;
! 442: }
! 443:
! 444: (*s_objet_resultat).type = REL;
! 445: (*((real8 *) (*s_objet_resultat).objet)) =
! 446: ceil((*((real8 *) (*s_objet_argument).objet)));
! 447: }
! 448: }
! 449:
! 450: /*
! 451: --------------------------------------------------------------------------------
! 452: Plafond d'un nom
! 453: --------------------------------------------------------------------------------
! 454: */
! 455:
! 456: else if ((*s_objet_argument).type == NOM)
! 457: {
! 458: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL)
! 459: {
! 460: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 461: return;
! 462: }
! 463:
! 464: if (((*s_objet_resultat).objet =
! 465: allocation_maillon(s_etat_processus)) == NULL)
! 466: {
! 467: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 468: return;
! 469: }
! 470:
! 471: l_element_courant = (*s_objet_resultat).objet;
! 472:
! 473: if (((*l_element_courant).donnee =
! 474: allocation(s_etat_processus, FCT)) == NULL)
! 475: {
! 476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 477: return;
! 478: }
! 479:
! 480: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 481: .nombre_arguments = 0;
! 482: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 483: .fonction = instruction_vers_niveau_superieur;
! 484:
! 485: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 486: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 487: {
! 488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 489: return;
! 490: }
! 491:
! 492: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 493: .nom_fonction, "<<");
! 494:
! 495: if (((*l_element_courant).suivant =
! 496: allocation_maillon(s_etat_processus)) == NULL)
! 497: {
! 498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 499: return;
! 500: }
! 501:
! 502: l_element_courant = (*l_element_courant).suivant;
! 503: (*l_element_courant).donnee = s_objet_argument;
! 504:
! 505: if (((*l_element_courant).suivant =
! 506: allocation_maillon(s_etat_processus)) == NULL)
! 507: {
! 508: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 509: return;
! 510: }
! 511:
! 512: l_element_courant = (*l_element_courant).suivant;
! 513:
! 514: if (((*l_element_courant).donnee =
! 515: allocation(s_etat_processus, FCT)) == NULL)
! 516: {
! 517: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 518: return;
! 519: }
! 520:
! 521: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 522: .nombre_arguments = 1;
! 523: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 524: .fonction = instruction_ceil;
! 525:
! 526: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 527: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
! 528: {
! 529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 530: return;
! 531: }
! 532:
! 533: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 534: .nom_fonction, "CEIL");
! 535:
! 536: if (((*l_element_courant).suivant =
! 537: allocation_maillon(s_etat_processus)) == NULL)
! 538: {
! 539: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 540: return;
! 541: }
! 542:
! 543: l_element_courant = (*l_element_courant).suivant;
! 544:
! 545: if (((*l_element_courant).donnee =
! 546: allocation(s_etat_processus, FCT)) == NULL)
! 547: {
! 548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 549: return;
! 550: }
! 551:
! 552: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 553: .nombre_arguments = 0;
! 554: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 555: .fonction = instruction_vers_niveau_inferieur;
! 556:
! 557: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 558: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 559: {
! 560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 561: return;
! 562: }
! 563:
! 564: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 565: .nom_fonction, ">>");
! 566:
! 567: (*l_element_courant).suivant = NULL;
! 568: s_objet_argument = NULL;
! 569: }
! 570:
! 571: /*
! 572: --------------------------------------------------------------------------------
! 573: Plafond d'une expression
! 574: --------------------------------------------------------------------------------
! 575: */
! 576:
! 577: else if (((*s_objet_argument).type == ALG) ||
! 578: ((*s_objet_argument).type == RPN))
! 579: {
! 580: if ((s_copie_argument = copie_objet(s_etat_processus,
! 581: s_objet_argument, 'N')) == NULL)
! 582: {
! 583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 584: return;
! 585: }
! 586:
! 587: l_element_courant = (struct_liste_chainee *)
! 588: (*s_copie_argument).objet;
! 589: l_element_precedent = l_element_courant;
! 590:
! 591: while((*l_element_courant).suivant != NULL)
! 592: {
! 593: l_element_precedent = l_element_courant;
! 594: l_element_courant = (*l_element_courant).suivant;
! 595: }
! 596:
! 597: if (((*l_element_precedent).suivant =
! 598: allocation_maillon(s_etat_processus)) == NULL)
! 599: {
! 600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 601: return;
! 602: }
! 603:
! 604: if (((*(*l_element_precedent).suivant).donnee =
! 605: allocation(s_etat_processus, FCT)) == NULL)
! 606: {
! 607: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 608: return;
! 609: }
! 610:
! 611: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 612: .donnee).objet)).nombre_arguments = 1;
! 613: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 614: .donnee).objet)).fonction = instruction_ceil;
! 615:
! 616: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 617: .suivant).donnee).objet)).nom_fonction =
! 618: malloc(5 * sizeof(unsigned char))) == NULL)
! 619: {
! 620: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 621: return;
! 622: }
! 623:
! 624: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 625: .suivant).donnee).objet)).nom_fonction, "CEIL");
! 626:
! 627: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 628:
! 629: s_objet_resultat = s_copie_argument;
! 630: }
! 631:
! 632: /*
! 633: --------------------------------------------------------------------------------
! 634: Fonction ceil impossible à réaliser
! 635: --------------------------------------------------------------------------------
! 636: */
! 637:
! 638: else
! 639: {
! 640: liberation(s_etat_processus, s_objet_argument);
! 641:
! 642: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 643: return;
! 644: }
! 645:
! 646: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 647: s_objet_resultat) == d_erreur)
! 648: {
! 649: return;
! 650: }
! 651:
! 652: liberation(s_etat_processus, s_objet_argument);
! 653:
! 654: return;
! 655: }
! 656:
! 657:
! 658: /*
! 659: ================================================================================
! 660: Fonction 'case'
! 661: ================================================================================
! 662: Entrées :
! 663: --------------------------------------------------------------------------------
! 664: Sorties :
! 665: --------------------------------------------------------------------------------
! 666: Effets de bord : néant
! 667: ================================================================================
! 668: */
! 669:
! 670: void
! 671: instruction_case(struct_processus *s_etat_processus)
! 672: {
! 673: struct_objet *s_objet;
! 674:
! 675: (*s_etat_processus).erreur_execution = d_ex;
! 676:
! 677: if ((*s_etat_processus).affichage_arguments == 'Y')
! 678: {
! 679: printf("\n CASE ");
! 680:
! 681: if ((*s_etat_processus).langue == 'F')
! 682: {
! 683: printf("(structure de contrôle)\n\n");
! 684: printf(" Utilisation :\n\n");
! 685: }
! 686: else
! 687: {
! 688: printf("(control statement)\n\n");
! 689: printf(" Usage:\n\n");
! 690: }
! 691:
! 692: printf(" SELECT (expression test)\n");
! 693: printf(" CASE (clause 1) THEN (expression 1) END\n");
! 694: printf(" CASE (clause 2) THEN (expression 2) END\n");
! 695: printf(" ...\n");
! 696: printf(" CASE (clause n) THEN (expression n) END\n");
! 697: printf(" DEFAULT\n");
! 698: printf(" (expression)\n");
! 699: printf(" END\n\n");
! 700:
! 701: printf(" SELECT (expression test)\n");
! 702: printf(" CASE (clause 1) THEN (expression 1) END\n");
! 703: printf(" (expression)\n");
! 704: printf(" CASE (clause 2) THEN (expression 2) END\n");
! 705: printf(" END\n");
! 706:
! 707: return;
! 708: }
! 709: else if ((*s_etat_processus).test_instruction == 'Y')
! 710: {
! 711: (*s_etat_processus).nombre_arguments = -1;
! 712: return;
! 713: }
! 714:
! 715: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'S')
! 716: {
! 717:
! 718: /*
! 719: * Première apparition de l'instruction CASE dans la structure de test.
! 720: */
! 721:
! 722: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 723: &s_objet) == d_erreur)
! 724: {
! 725: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 726: return;
! 727: }
! 728:
! 729: (*(*s_etat_processus).l_base_pile_systeme).objet_de_test = s_objet;
! 730: (*(*s_etat_processus).l_base_pile_systeme).clause = 'K';
! 731: }
! 732:
! 733: if ((s_objet = copie_objet(s_etat_processus,
! 734: (*(*s_etat_processus).l_base_pile_systeme)
! 735: .objet_de_test, 'P')) == NULL)
! 736: {
! 737: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 738: return;
! 739: }
! 740:
! 741: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 742: s_objet) == d_erreur)
! 743: {
! 744: return;
! 745: }
! 746:
! 747: return;
! 748: }
! 749:
! 750:
! 751: /*
! 752: ================================================================================
! 753: Fonction 'c->r'
! 754: ================================================================================
! 755: Entrées : structure processus
! 756: --------------------------------------------------------------------------------
! 757: Sorties :
! 758: --------------------------------------------------------------------------------
! 759: Effets de bord : néant
! 760: ================================================================================
! 761: */
! 762:
! 763: void
! 764: instruction_c_vers_r(struct_processus *s_etat_processus)
! 765: {
! 766: struct_objet *s_objet_argument;
! 767: struct_objet *s_objet_resultat_1;
! 768: struct_objet *s_objet_resultat_2;
! 769:
! 770: unsigned long i;
! 771: unsigned long j;
! 772:
! 773: (*s_etat_processus).erreur_execution = d_ex;
! 774:
! 775: if ((*s_etat_processus).affichage_arguments == 'Y')
! 776: {
! 777: printf("\n C->R ");
! 778:
! 779: if ((*s_etat_processus).langue == 'F')
! 780: {
! 781: printf("(complexe vers réel)\n\n");
! 782: }
! 783: else
! 784: {
! 785: printf("(complex to real)\n\n");
! 786: }
! 787:
! 788: printf(" 1: %s\n", d_CPL);
! 789: printf("-> 2: %s\n", d_REL);
! 790: printf(" 1: %s\n\n", d_REL);
! 791:
! 792: printf(" 1: %s\n", d_VCX);
! 793: printf("-> 2: %s\n", d_VRL);
! 794: printf(" 1: %s\n\n", d_VRL);
! 795:
! 796: printf(" 1: %s\n", d_MCX);
! 797: printf("-> 2: %s\n", d_MRL);
! 798: printf(" 1: %s\n", d_MRL);
! 799:
! 800: return;
! 801: }
! 802: else if ((*s_etat_processus).test_instruction == 'Y')
! 803: {
! 804: (*s_etat_processus).nombre_arguments = -1;
! 805: return;
! 806: }
! 807:
! 808: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 809: {
! 810: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 811: {
! 812: return;
! 813: }
! 814: }
! 815:
! 816: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 817: &s_objet_argument) == d_erreur)
! 818: {
! 819: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 820: return;
! 821: }
! 822:
! 823: /*
! 824: --------------------------------------------------------------------------------
! 825: Eclatement d'un complexe
! 826: --------------------------------------------------------------------------------
! 827: */
! 828:
! 829: if ((*s_objet_argument).type == CPL)
! 830: {
! 831: if ((s_objet_resultat_1 = allocation(s_etat_processus, REL))
! 832: == NULL)
! 833: {
! 834: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 835: return;
! 836: }
! 837:
! 838: if ((s_objet_resultat_2 = allocation(s_etat_processus, REL))
! 839: == NULL)
! 840: {
! 841: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 842: return;
! 843: }
! 844:
! 845: (*((real8 *) (*s_objet_resultat_1).objet)) =
! 846: (*((struct_complexe16 *) (*s_objet_argument).objet))
! 847: .partie_imaginaire;
! 848:
! 849: (*((real8 *) (*s_objet_resultat_2).objet)) =
! 850: (*((struct_complexe16 *) (*s_objet_argument).objet))
! 851: .partie_reelle;
! 852: }
! 853:
! 854: /*
! 855: --------------------------------------------------------------------------------
! 856: Eclatement d'un vecteur
! 857: --------------------------------------------------------------------------------
! 858: */
! 859:
! 860: else if ((*s_objet_argument).type == VCX)
! 861: {
! 862: if ((s_objet_resultat_1 = allocation(s_etat_processus, VRL))
! 863: == NULL)
! 864: {
! 865: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 866: return;
! 867: }
! 868:
! 869: if ((s_objet_resultat_2 = allocation(s_etat_processus, VRL))
! 870: == NULL)
! 871: {
! 872: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 873: return;
! 874: }
! 875:
! 876: if (((*((struct_vecteur *) (*s_objet_resultat_1).objet)).tableau =
! 877: malloc((*(((struct_vecteur *) (*s_objet_argument)
! 878: .objet))).taille * sizeof(real8))) == NULL)
! 879: {
! 880: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 881: return;
! 882: }
! 883:
! 884: if (((*((struct_vecteur *) (*s_objet_resultat_2).objet)).tableau =
! 885: malloc((*(((struct_vecteur *) (*s_objet_argument)
! 886: .objet))).taille * sizeof(real8))) == NULL)
! 887: {
! 888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 889: return;
! 890: }
! 891:
! 892: (*((struct_vecteur *) (*s_objet_resultat_1).objet)).taille =
! 893: (*(((struct_vecteur *) (*s_objet_argument).objet))).taille;
! 894: (*((struct_vecteur *) (*s_objet_resultat_2).objet)).taille =
! 895: (*(((struct_vecteur *) (*s_objet_argument).objet))).taille;
! 896:
! 897: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
! 898: .taille; i++)
! 899: {
! 900: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat_1).objet))
! 901: .tableau)[i] = ((struct_complexe16 *) (*((struct_vecteur *)
! 902: (*s_objet_argument).objet)).tableau)[i].partie_imaginaire;
! 903:
! 904: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat_2).objet))
! 905: .tableau)[i] = ((struct_complexe16 *) (*((struct_vecteur *)
! 906: (*s_objet_argument).objet)).tableau)[i].partie_reelle;
! 907: }
! 908: }
! 909:
! 910: /*
! 911: --------------------------------------------------------------------------------
! 912: Eclatement d'une matrice
! 913: --------------------------------------------------------------------------------
! 914: */
! 915:
! 916: else if ((*s_objet_argument).type == MCX)
! 917: {
! 918: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL))
! 919: == NULL)
! 920: {
! 921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 922: return;
! 923: }
! 924:
! 925: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL))
! 926: == NULL)
! 927: {
! 928: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 929: return;
! 930: }
! 931:
! 932: if (((*((struct_matrice *) (*s_objet_resultat_1).objet)).tableau =
! 933: malloc((*(((struct_matrice *) (*s_objet_argument)
! 934: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 935: {
! 936: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 937: return;
! 938: }
! 939:
! 940: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
! 941: malloc((*(((struct_matrice *) (*s_objet_argument)
! 942: .objet))).nombre_lignes * sizeof(real8 *))) == NULL)
! 943: {
! 944: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 945: return;
! 946: }
! 947:
! 948: (*((struct_matrice *) (*s_objet_resultat_1).objet)).nombre_lignes =
! 949: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
! 950: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
! 951: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
! 952: (*((struct_matrice *) (*s_objet_resultat_1).objet)).nombre_colonnes =
! 953: (*((struct_matrice *) (*s_objet_argument).objet))
! 954: .nombre_colonnes;
! 955: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
! 956: (*((struct_matrice *) (*s_objet_argument).objet))
! 957: .nombre_colonnes;
! 958:
! 959: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
! 960: .nombre_lignes; i++)
! 961: {
! 962: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_1)
! 963: .objet)).tableau)[i] = malloc(
! 964: (*(((struct_matrice *) (*s_objet_argument).objet)))
! 965: .nombre_colonnes * sizeof(real8))) == NULL)
! 966: {
! 967: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 968: return;
! 969: }
! 970:
! 971: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
! 972: .objet)).tableau)[i] = malloc(
! 973: (*(((struct_matrice *) (*s_objet_argument).objet)))
! 974: .nombre_colonnes * sizeof(real8))) == NULL)
! 975: {
! 976: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 977: return;
! 978: }
! 979:
! 980: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
! 981: .nombre_colonnes; j++)
! 982: {
! 983: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_1).objet))
! 984: .tableau)[i][j] = ((struct_complexe16 **)
! 985: (*((struct_matrice *) (*s_objet_argument).objet))
! 986: .tableau)[i][j].partie_imaginaire;
! 987:
! 988: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
! 989: .tableau)[i][j] = ((struct_complexe16 **)
! 990: (*((struct_matrice *) (*s_objet_argument).objet))
! 991: .tableau)[i][j].partie_reelle;
! 992: }
! 993: }
! 994: }
! 995:
! 996: /*
! 997: --------------------------------------------------------------------------------
! 998: Eclatement impossible
! 999: --------------------------------------------------------------------------------
! 1000: */
! 1001:
! 1002: else
! 1003: {
! 1004: liberation(s_etat_processus, s_objet_argument);
! 1005:
! 1006: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1007: return;
! 1008: }
! 1009:
! 1010: liberation(s_etat_processus, s_objet_argument);
! 1011:
! 1012: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1013: s_objet_resultat_2) == d_erreur)
! 1014: {
! 1015: return;
! 1016: }
! 1017:
! 1018: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1019: s_objet_resultat_1) == d_erreur)
! 1020: {
! 1021: return;
! 1022: }
! 1023:
! 1024: return;
! 1025: }
! 1026:
! 1027:
! 1028: /*
! 1029: ================================================================================
! 1030: Fonction 'conj'
! 1031: ================================================================================
! 1032: Entrées :
! 1033: --------------------------------------------------------------------------------
! 1034: Sorties :
! 1035: --------------------------------------------------------------------------------
! 1036: Effets de bord : néant
! 1037: ================================================================================
! 1038: */
! 1039:
! 1040: void
! 1041: instruction_conj(struct_processus *s_etat_processus)
! 1042: {
! 1043: struct_liste_chainee *l_element_courant;
! 1044: struct_liste_chainee *l_element_precedent;
! 1045:
! 1046: struct_objet *s_copie_argument;
! 1047: struct_objet *s_objet_argument;
! 1048: struct_objet *s_objet_resultat;
! 1049:
! 1050: unsigned long i;
! 1051: unsigned long j;
! 1052:
! 1053: (*s_etat_processus).erreur_execution = d_ex;
! 1054:
! 1055: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1056: {
! 1057: printf("\n CONJ ");
! 1058:
! 1059: if ((*s_etat_processus).langue == 'F')
! 1060: {
! 1061: printf("(conjugaison)\n\n");
! 1062: }
! 1063: else
! 1064: {
! 1065: printf("(conjugated)\n\n");
! 1066: }
! 1067:
! 1068: printf(" 1: %s\n", d_INT);
! 1069: printf("-> 1: %s\n\n", d_INT);
! 1070:
! 1071: printf(" 1: %s\n", d_REL);
! 1072: printf("-> 1: %s\n\n", d_REL);
! 1073:
! 1074: printf(" 1: %s\n", d_CPL);
! 1075: printf("-> 1: %s\n\n", d_CPL);
! 1076:
! 1077: printf(" 1: %s\n", d_VIN);
! 1078: printf("-> 1: %s\n\n", d_VIN);
! 1079:
! 1080: printf(" 1: %s\n", d_VRL);
! 1081: printf("-> 1: %s\n\n", d_VRL);
! 1082:
! 1083: printf(" 1: %s\n", d_VCX);
! 1084: printf("-> 1: %s\n\n", d_VCX);
! 1085:
! 1086: printf(" 1: %s\n", d_MIN);
! 1087: printf("-> 1: %s\n\n", d_MIN);
! 1088:
! 1089: printf(" 1: %s\n", d_MRL);
! 1090: printf("-> 1: %s\n\n", d_MRL);
! 1091:
! 1092: printf(" 1: %s\n", d_MCX);
! 1093: printf("-> 1: %s\n\n", d_MCX);
! 1094:
! 1095: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 1096: printf("-> 1: %s\n\n", d_ALG);
! 1097:
! 1098: printf(" 1: %s\n", d_RPN);
! 1099: printf("-> 1: %s\n", d_RPN);
! 1100:
! 1101: return;
! 1102: }
! 1103: else if ((*s_etat_processus).test_instruction == 'Y')
! 1104: {
! 1105: (*s_etat_processus).nombre_arguments = 1;
! 1106: return;
! 1107: }
! 1108:
! 1109: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1110: {
! 1111: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1112: {
! 1113: return;
! 1114: }
! 1115: }
! 1116:
! 1117: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1118: &s_objet_argument) == d_erreur)
! 1119: {
! 1120: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1121: return;
! 1122: }
! 1123:
! 1124: /*
! 1125: --------------------------------------------------------------------------------
! 1126: Conjugué d'un entier ou d'un réel
! 1127: --------------------------------------------------------------------------------
! 1128: */
! 1129:
! 1130: if (((*s_objet_argument).type == INT) ||
! 1131: ((*s_objet_argument).type == REL))
! 1132: {
! 1133: s_objet_resultat = s_objet_argument;
! 1134: s_objet_argument = NULL;
! 1135: }
! 1136:
! 1137: /*
! 1138: --------------------------------------------------------------------------------
! 1139: Conjugué d'un complexe
! 1140: --------------------------------------------------------------------------------
! 1141: */
! 1142:
! 1143: else if ((*s_objet_argument).type == CPL)
! 1144: {
! 1145: (*((struct_complexe16 *) (*s_objet_argument).objet)).partie_reelle =
! 1146: (*((struct_complexe16 *) (*s_objet_argument).objet))
! 1147: .partie_reelle;
! 1148: (*((struct_complexe16 *) (*s_objet_argument).objet)).partie_imaginaire =
! 1149: -(*((struct_complexe16 *) (*s_objet_argument).objet))
! 1150: .partie_imaginaire;
! 1151:
! 1152: s_objet_resultat = s_objet_argument;
! 1153: s_objet_argument = NULL;
! 1154: }
! 1155:
! 1156: /*
! 1157: --------------------------------------------------------------------------------
! 1158: Conjugué d'un vecteur d'entiers ou de réels
! 1159: --------------------------------------------------------------------------------
! 1160: */
! 1161:
! 1162: else if (((*s_objet_argument).type == VIN) ||
! 1163: ((*s_objet_argument).type == VRL))
! 1164: {
! 1165: s_objet_resultat = s_objet_argument;
! 1166: s_objet_argument = NULL;
! 1167: }
! 1168:
! 1169: /*
! 1170: --------------------------------------------------------------------------------
! 1171: Conjugué d'un vecteur de complexes
! 1172: --------------------------------------------------------------------------------
! 1173: */
! 1174:
! 1175: else if ((*s_objet_argument).type == VCX)
! 1176: {
! 1177: for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
! 1178: .taille; i++)
! 1179: {
! 1180: ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument)
! 1181: .objet))).tableau)[i].partie_reelle =
! 1182: ((struct_complexe16 *) (*(((struct_vecteur *)
! 1183: (*s_objet_argument).objet))).tableau)[i].partie_reelle;
! 1184: ((struct_complexe16 *) (*(((struct_vecteur *) (*s_objet_argument)
! 1185: .objet))).tableau)[i].partie_imaginaire =
! 1186: -((struct_complexe16 *) (*(((struct_vecteur *)
! 1187: (*s_objet_argument).objet))).tableau)[i].partie_imaginaire;
! 1188: }
! 1189:
! 1190: s_objet_resultat = s_objet_argument;
! 1191: s_objet_argument = NULL;
! 1192: }
! 1193:
! 1194: /*
! 1195: --------------------------------------------------------------------------------
! 1196: Conjuguée d'une matrice d'entiers ou de réels
! 1197: --------------------------------------------------------------------------------
! 1198: */
! 1199:
! 1200: else if (((*s_objet_argument).type == MIN) ||
! 1201: ((*s_objet_argument).type == MRL))
! 1202: {
! 1203: s_objet_resultat = s_objet_argument;
! 1204: s_objet_argument = NULL;
! 1205: }
! 1206:
! 1207: /*
! 1208: --------------------------------------------------------------------------------
! 1209: Conjuguée d'une matrice de complexes
! 1210: --------------------------------------------------------------------------------
! 1211: */
! 1212:
! 1213: else if ((*s_objet_argument).type == MCX)
! 1214: {
! 1215: for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
! 1216: .nombre_lignes; i++)
! 1217: {
! 1218: for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
! 1219: .nombre_colonnes; j++)
! 1220: {
! 1221: ((struct_complexe16 **) (*(((struct_matrice *)
! 1222: (*s_objet_argument).objet))).tableau)[i][j]
! 1223: .partie_reelle = ((struct_complexe16 **)
! 1224: (*(((struct_matrice *) (*s_objet_argument).objet)))
! 1225: .tableau)[i][j].partie_reelle;
! 1226: ((struct_complexe16 **) (*(((struct_matrice *)
! 1227: (*s_objet_argument).objet))).tableau)[i][j]
! 1228: .partie_imaginaire = -((struct_complexe16 **)
! 1229: (*(((struct_matrice *) (*s_objet_argument).objet)))
! 1230: .tableau)[i][j].partie_imaginaire;
! 1231: }
! 1232: }
! 1233:
! 1234: s_objet_resultat = s_objet_argument;
! 1235: s_objet_argument = NULL;
! 1236: }
! 1237:
! 1238: /*
! 1239: --------------------------------------------------------------------------------
! 1240: Conjugué d'un nom
! 1241: --------------------------------------------------------------------------------
! 1242: */
! 1243:
! 1244: else if ((*s_objet_argument).type == NOM)
! 1245: {
! 1246: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 1247: == NULL)
! 1248: {
! 1249: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1250: return;
! 1251: }
! 1252:
! 1253: if (((*s_objet_resultat).objet =
! 1254: allocation_maillon(s_etat_processus)) == NULL)
! 1255: {
! 1256: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1257: return;
! 1258: }
! 1259:
! 1260: l_element_courant = (*s_objet_resultat).objet;
! 1261:
! 1262: if (((*l_element_courant).donnee =
! 1263: allocation(s_etat_processus, FCT)) == NULL)
! 1264: {
! 1265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1266: return;
! 1267: }
! 1268:
! 1269: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1270: .nombre_arguments = 0;
! 1271: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1272: .fonction = instruction_vers_niveau_superieur;
! 1273:
! 1274: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1275: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1276: {
! 1277: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1278: return;
! 1279: }
! 1280:
! 1281: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1282: .nom_fonction, "<<");
! 1283:
! 1284: if (((*l_element_courant).suivant =
! 1285: allocation_maillon(s_etat_processus)) == NULL)
! 1286: {
! 1287: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1288: return;
! 1289: }
! 1290:
! 1291: l_element_courant = (*l_element_courant).suivant;
! 1292: (*l_element_courant).donnee = s_objet_argument;
! 1293:
! 1294: if (((*l_element_courant).suivant =
! 1295: allocation_maillon(s_etat_processus)) == NULL)
! 1296: {
! 1297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1298: return;
! 1299: }
! 1300:
! 1301: l_element_courant = (*l_element_courant).suivant;
! 1302:
! 1303: if (((*l_element_courant).donnee =
! 1304: allocation(s_etat_processus, FCT)) == NULL)
! 1305: {
! 1306: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1307: return;
! 1308: }
! 1309:
! 1310: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1311: .nombre_arguments = 1;
! 1312: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1313: .fonction = instruction_conj;
! 1314:
! 1315: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1316: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
! 1317: {
! 1318: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1319: return;
! 1320: }
! 1321:
! 1322: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1323: .nom_fonction, "CONJ");
! 1324:
! 1325: if (((*l_element_courant).suivant =
! 1326: allocation_maillon(s_etat_processus)) == NULL)
! 1327: {
! 1328: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1329: return;
! 1330: }
! 1331:
! 1332: l_element_courant = (*l_element_courant).suivant;
! 1333:
! 1334: if (((*l_element_courant).donnee =
! 1335: allocation(s_etat_processus, FCT)) == NULL)
! 1336: {
! 1337: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1338: return;
! 1339: }
! 1340:
! 1341: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1342: .nombre_arguments = 0;
! 1343: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1344: .fonction = instruction_vers_niveau_inferieur;
! 1345:
! 1346: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1347: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1348: {
! 1349: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1350: return;
! 1351: }
! 1352:
! 1353: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1354: .nom_fonction, ">>");
! 1355:
! 1356: (*l_element_courant).suivant = NULL;
! 1357: s_objet_argument = NULL;
! 1358: }
! 1359:
! 1360: /*
! 1361: --------------------------------------------------------------------------------
! 1362: Conjuguée d'une expression
! 1363: --------------------------------------------------------------------------------
! 1364: */
! 1365:
! 1366: else if (((*s_objet_argument).type == ALG) ||
! 1367: ((*s_objet_argument).type == RPN))
! 1368: {
! 1369: if ((s_copie_argument = copie_objet(s_etat_processus,
! 1370: s_objet_argument, 'N')) == NULL)
! 1371: {
! 1372: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1373: return;
! 1374: }
! 1375:
! 1376: l_element_courant = (struct_liste_chainee *)
! 1377: (*s_copie_argument).objet;
! 1378: l_element_precedent = l_element_courant;
! 1379:
! 1380: while((*l_element_courant).suivant != NULL)
! 1381: {
! 1382: l_element_precedent = l_element_courant;
! 1383: l_element_courant = (*l_element_courant).suivant;
! 1384: }
! 1385:
! 1386: if (((*l_element_precedent).suivant =
! 1387: allocation_maillon(s_etat_processus)) == NULL)
! 1388: {
! 1389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1390: return;
! 1391: }
! 1392:
! 1393: if (((*(*l_element_precedent).suivant).donnee =
! 1394: allocation(s_etat_processus, FCT)) == NULL)
! 1395: {
! 1396: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1397: return;
! 1398: }
! 1399:
! 1400: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1401: .donnee).objet)).nombre_arguments = 1;
! 1402: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1403: .donnee).objet)).fonction = instruction_conj;
! 1404:
! 1405: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1406: .suivant).donnee).objet)).nom_fonction =
! 1407: malloc(5 * sizeof(unsigned char))) == NULL)
! 1408: {
! 1409: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1410: return;
! 1411: }
! 1412:
! 1413: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 1414: .suivant).donnee).objet)).nom_fonction, "CONJ");
! 1415:
! 1416: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1417:
! 1418: s_objet_resultat = s_copie_argument;
! 1419: }
! 1420:
! 1421: /*
! 1422: --------------------------------------------------------------------------------
! 1423: Conjugaison impossible
! 1424: --------------------------------------------------------------------------------
! 1425: */
! 1426:
! 1427: else
! 1428: {
! 1429: liberation(s_etat_processus, s_objet_argument);
! 1430:
! 1431: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1432: return;
! 1433: }
! 1434:
! 1435: liberation(s_etat_processus, s_objet_argument);
! 1436:
! 1437: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1438: s_objet_resultat) == d_erreur)
! 1439: {
! 1440: return;
! 1441: }
! 1442:
! 1443: return;
! 1444: }
! 1445:
! 1446:
! 1447: /*
! 1448: ================================================================================
! 1449: Fonction 'cos'
! 1450: ================================================================================
! 1451: Entrées : pointeur sur une structure struct_processus
! 1452: --------------------------------------------------------------------------------
! 1453: Sorties :
! 1454: --------------------------------------------------------------------------------
! 1455: Effets de bord : néant
! 1456: ================================================================================
! 1457: */
! 1458:
! 1459: void
! 1460: instruction_cos(struct_processus *s_etat_processus)
! 1461: {
! 1462: real8 angle;
! 1463:
! 1464: struct_liste_chainee *l_element_courant;
! 1465: struct_liste_chainee *l_element_precedent;
! 1466:
! 1467: struct_objet *s_copie_argument;
! 1468: struct_objet *s_objet_argument;
! 1469: struct_objet *s_objet_resultat;
! 1470:
! 1471: (*s_etat_processus).erreur_execution = d_ex;
! 1472:
! 1473: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1474: {
! 1475: printf("\n COS ");
! 1476:
! 1477: if ((*s_etat_processus).langue == 'F')
! 1478: {
! 1479: printf("(cosinus)\n\n");
! 1480: }
! 1481: else
! 1482: {
! 1483: printf("(cosine)\n\n");
! 1484: }
! 1485:
! 1486: printf(" 1: %s, %s\n", d_INT, d_REL);
! 1487: printf("-> 1: %s\n\n", d_REL);
! 1488:
! 1489: printf(" 1: %s\n", d_CPL);
! 1490: printf("-> 1: %s\n\n", d_CPL);
! 1491:
! 1492: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 1493: printf("-> 1: %s\n\n", d_ALG);
! 1494:
! 1495: printf(" 1: %s\n", d_RPN);
! 1496: printf("-> 1: %s\n", d_RPN);
! 1497:
! 1498: return;
! 1499: }
! 1500: else if ((*s_etat_processus).test_instruction == 'Y')
! 1501: {
! 1502: (*s_etat_processus).nombre_arguments = 1;
! 1503: return;
! 1504: }
! 1505:
! 1506: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1507: {
! 1508: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1509: {
! 1510: return;
! 1511: }
! 1512: }
! 1513:
! 1514: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1515: &s_objet_argument) == d_erreur)
! 1516: {
! 1517: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1518: return;
! 1519: }
! 1520:
! 1521: /*
! 1522: --------------------------------------------------------------------------------
! 1523: Cosinus d'un entier ou d'un réel
! 1524: --------------------------------------------------------------------------------
! 1525: */
! 1526:
! 1527: if (((*s_objet_argument).type == INT) ||
! 1528: ((*s_objet_argument).type == REL))
! 1529: {
! 1530: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 1531: == NULL)
! 1532: {
! 1533: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1534: return;
! 1535: }
! 1536:
! 1537: if ((*s_objet_argument).type == INT)
! 1538: {
! 1539: angle = (real8) (*((integer8 *) (*s_objet_argument).objet));
! 1540: }
! 1541: else
! 1542: {
! 1543: angle = (*((real8 *) (*s_objet_argument).objet));
! 1544: }
! 1545:
! 1546: if (test_cfsf(s_etat_processus, 60) == d_faux)
! 1547: {
! 1548: conversion_degres_vers_radians(&angle);
! 1549: }
! 1550:
! 1551: (*((real8 *) (*s_objet_resultat).objet)) = cos(angle);
! 1552: }
! 1553:
! 1554: /*
! 1555: --------------------------------------------------------------------------------
! 1556: Cosinus d'un complexe
! 1557: --------------------------------------------------------------------------------
! 1558: */
! 1559:
! 1560: else if ((*s_objet_argument).type == CPL)
! 1561: {
! 1562: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 1563: == NULL)
! 1564: {
! 1565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1566: return;
! 1567: }
! 1568:
! 1569: f77cos_((struct_complexe16 *) (*s_objet_argument).objet,
! 1570: (struct_complexe16 *) (*s_objet_resultat).objet);
! 1571: }
! 1572:
! 1573: /*
! 1574: --------------------------------------------------------------------------------
! 1575: Cosinus d'un nom
! 1576: --------------------------------------------------------------------------------
! 1577: */
! 1578:
! 1579: else if ((*s_objet_argument).type == NOM)
! 1580: {
! 1581: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 1582: == NULL)
! 1583: {
! 1584: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1585: return;
! 1586: }
! 1587:
! 1588: if (((*s_objet_resultat).objet =
! 1589: allocation_maillon(s_etat_processus)) == NULL)
! 1590: {
! 1591: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1592: return;
! 1593: }
! 1594:
! 1595: l_element_courant = (*s_objet_resultat).objet;
! 1596:
! 1597: if (((*l_element_courant).donnee =
! 1598: allocation(s_etat_processus, FCT)) == NULL)
! 1599: {
! 1600: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1601: return;
! 1602: }
! 1603:
! 1604: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1605: .nombre_arguments = 0;
! 1606: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1607: .fonction = instruction_vers_niveau_superieur;
! 1608:
! 1609: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1610: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1611: {
! 1612: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1613: return;
! 1614: }
! 1615:
! 1616: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1617: .nom_fonction, "<<");
! 1618:
! 1619: if (((*l_element_courant).suivant =
! 1620: allocation_maillon(s_etat_processus)) == NULL)
! 1621: {
! 1622: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1623: return;
! 1624: }
! 1625:
! 1626: l_element_courant = (*l_element_courant).suivant;
! 1627: (*l_element_courant).donnee = s_objet_argument;
! 1628:
! 1629: if (((*l_element_courant).suivant =
! 1630: allocation_maillon(s_etat_processus)) == NULL)
! 1631: {
! 1632: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1633: return;
! 1634: }
! 1635:
! 1636: l_element_courant = (*l_element_courant).suivant;
! 1637:
! 1638: if (((*l_element_courant).donnee =
! 1639: allocation(s_etat_processus, FCT)) == NULL)
! 1640: {
! 1641: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1642: return;
! 1643: }
! 1644:
! 1645: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1646: .nombre_arguments = 1;
! 1647: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1648: .fonction = instruction_cos;
! 1649:
! 1650: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1651: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
! 1652: {
! 1653: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1654: return;
! 1655: }
! 1656:
! 1657: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1658: .nom_fonction, "COS");
! 1659:
! 1660: if (((*l_element_courant).suivant =
! 1661: allocation_maillon(s_etat_processus)) == NULL)
! 1662: {
! 1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1664: return;
! 1665: }
! 1666:
! 1667: l_element_courant = (*l_element_courant).suivant;
! 1668:
! 1669: if (((*l_element_courant).donnee =
! 1670: allocation(s_etat_processus, FCT)) == NULL)
! 1671: {
! 1672: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1673: return;
! 1674: }
! 1675:
! 1676: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1677: .nombre_arguments = 0;
! 1678: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1679: .fonction = instruction_vers_niveau_inferieur;
! 1680:
! 1681: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1682: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1683: {
! 1684: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1685: return;
! 1686: }
! 1687:
! 1688: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1689: .nom_fonction, ">>");
! 1690:
! 1691: (*l_element_courant).suivant = NULL;
! 1692: s_objet_argument = NULL;
! 1693: }
! 1694:
! 1695: /*
! 1696: --------------------------------------------------------------------------------
! 1697: Cosinus d'une expression
! 1698: --------------------------------------------------------------------------------
! 1699: */
! 1700:
! 1701: else if (((*s_objet_argument).type == ALG) ||
! 1702: ((*s_objet_argument).type == RPN))
! 1703: {
! 1704: if ((s_copie_argument = copie_objet(s_etat_processus,
! 1705: s_objet_argument, 'N')) == NULL)
! 1706: {
! 1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1708: return;
! 1709: }
! 1710:
! 1711: l_element_courant = (struct_liste_chainee *)
! 1712: (*s_copie_argument).objet;
! 1713: l_element_precedent = l_element_courant;
! 1714:
! 1715: while((*l_element_courant).suivant != NULL)
! 1716: {
! 1717: l_element_precedent = l_element_courant;
! 1718: l_element_courant = (*l_element_courant).suivant;
! 1719: }
! 1720:
! 1721: if (((*l_element_precedent).suivant =
! 1722: allocation_maillon(s_etat_processus)) == NULL)
! 1723: {
! 1724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1725: return;
! 1726: }
! 1727:
! 1728: if (((*(*l_element_precedent).suivant).donnee =
! 1729: allocation(s_etat_processus, FCT)) == NULL)
! 1730: {
! 1731: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1732: return;
! 1733: }
! 1734:
! 1735: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1736: .donnee).objet)).nombre_arguments = 1;
! 1737: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 1738: .donnee).objet)).fonction = instruction_cos;
! 1739:
! 1740: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 1741: .suivant).donnee).objet)).nom_fonction =
! 1742: malloc(4 * sizeof(unsigned char))) == NULL)
! 1743: {
! 1744: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1745: return;
! 1746: }
! 1747:
! 1748: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 1749: .suivant).donnee).objet)).nom_fonction, "COS");
! 1750:
! 1751: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 1752:
! 1753: s_objet_resultat = s_copie_argument;
! 1754: }
! 1755:
! 1756: /*
! 1757: --------------------------------------------------------------------------------
! 1758: Réalisation impossible de la fonction cosinus
! 1759: --------------------------------------------------------------------------------
! 1760: */
! 1761:
! 1762: else
! 1763: {
! 1764: liberation(s_etat_processus, s_objet_argument);
! 1765:
! 1766: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1767: return;
! 1768: }
! 1769:
! 1770: liberation(s_etat_processus, s_objet_argument);
! 1771:
! 1772: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1773: s_objet_resultat) == d_erreur)
! 1774: {
! 1775: return;
! 1776: }
! 1777:
! 1778: return;
! 1779: }
! 1780:
! 1781:
! 1782: /*
! 1783: ================================================================================
! 1784: Fonction 'cosh'
! 1785: ================================================================================
! 1786: Entrées : pointeur sur une structure struct_processus
! 1787: --------------------------------------------------------------------------------
! 1788: Sorties :
! 1789: --------------------------------------------------------------------------------
! 1790: Effets de bord : néant
! 1791: ================================================================================
! 1792: */
! 1793:
! 1794: void
! 1795: instruction_cosh(struct_processus *s_etat_processus)
! 1796: {
! 1797: real8 argument;
! 1798:
! 1799: struct_liste_chainee *l_element_courant;
! 1800: struct_liste_chainee *l_element_precedent;
! 1801:
! 1802: struct_objet *s_copie_argument;
! 1803: struct_objet *s_objet_argument;
! 1804: struct_objet *s_objet_resultat;
! 1805:
! 1806: (*s_etat_processus).erreur_execution = d_ex;
! 1807:
! 1808: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1809: {
! 1810: printf("\n COSH ");
! 1811:
! 1812: if ((*s_etat_processus).langue == 'F')
! 1813: {
! 1814: printf("(cosinus hyperbolique)\n\n");
! 1815: }
! 1816: else
! 1817: {
! 1818: printf("(hyperbolic cosine)\n\n");
! 1819: }
! 1820:
! 1821: printf(" 1: %s, %s\n", d_INT, d_REL);
! 1822: printf("-> 1: %s\n\n", d_INT);
! 1823:
! 1824: printf(" 1: %s\n", d_CPL);
! 1825: printf("-> 1: %s\n\n", d_CPL);
! 1826:
! 1827: printf(" 1: %s, %s\n", d_NOM, d_ALG);
! 1828: printf("-> 1: %s\n\n", d_ALG);
! 1829:
! 1830: printf(" 1: %s\n", d_RPN);
! 1831: printf("-> 1: %s\n", d_RPN);
! 1832:
! 1833: return;
! 1834: }
! 1835: else if ((*s_etat_processus).test_instruction == 'Y')
! 1836: {
! 1837: (*s_etat_processus).nombre_arguments = 1;
! 1838: return;
! 1839: }
! 1840:
! 1841: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1842: {
! 1843: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1844: {
! 1845: return;
! 1846: }
! 1847: }
! 1848:
! 1849: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1850: &s_objet_argument) == d_erreur)
! 1851: {
! 1852: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1853: return;
! 1854: }
! 1855:
! 1856: /*
! 1857: --------------------------------------------------------------------------------
! 1858: Cosinus hyperbolique d'un entier ou d'un réel
! 1859: --------------------------------------------------------------------------------
! 1860: */
! 1861:
! 1862: if (((*s_objet_argument).type == INT) ||
! 1863: ((*s_objet_argument).type == REL))
! 1864: {
! 1865: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 1866: == NULL)
! 1867: {
! 1868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1869: return;
! 1870: }
! 1871:
! 1872: if ((*s_objet_argument).type == INT)
! 1873: {
! 1874: argument = (real8) (*((integer8 *) (*s_objet_argument).objet));
! 1875: }
! 1876: else
! 1877: {
! 1878: argument = (*((real8 *) (*s_objet_argument).objet));
! 1879: }
! 1880:
! 1881: (*((real8 *) (*s_objet_resultat).objet)) = cosh(argument);
! 1882: }
! 1883:
! 1884: /*
! 1885: --------------------------------------------------------------------------------
! 1886: Cosinus hyperbolique d'un complexe
! 1887: --------------------------------------------------------------------------------
! 1888: */
! 1889:
! 1890: else if ((*s_objet_argument).type == CPL)
! 1891: {
! 1892: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 1893: == NULL)
! 1894: {
! 1895: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1896: return;
! 1897: }
! 1898:
! 1899: f77cosh_((struct_complexe16 *) (*s_objet_argument).objet,
! 1900: (struct_complexe16 *) (*s_objet_resultat).objet);
! 1901: }
! 1902:
! 1903: /*
! 1904: --------------------------------------------------------------------------------
! 1905: Cosinus hyperbolique d'un nom
! 1906: --------------------------------------------------------------------------------
! 1907: */
! 1908:
! 1909: else if ((*s_objet_argument).type == NOM)
! 1910: {
! 1911: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 1912: == NULL)
! 1913: {
! 1914: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1915: return;
! 1916: }
! 1917:
! 1918: if (((*s_objet_resultat).objet =
! 1919: allocation_maillon(s_etat_processus)) == NULL)
! 1920: {
! 1921: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1922: return;
! 1923: }
! 1924:
! 1925: l_element_courant = (*s_objet_resultat).objet;
! 1926:
! 1927: if (((*l_element_courant).donnee =
! 1928: allocation(s_etat_processus, FCT)) == NULL)
! 1929: {
! 1930: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1931: return;
! 1932: }
! 1933:
! 1934: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1935: .nombre_arguments = 0;
! 1936: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1937: .fonction = instruction_vers_niveau_superieur;
! 1938:
! 1939: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1940: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 1941: {
! 1942: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1943: return;
! 1944: }
! 1945:
! 1946: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1947: .nom_fonction, "<<");
! 1948:
! 1949: if (((*l_element_courant).suivant =
! 1950: allocation_maillon(s_etat_processus)) == NULL)
! 1951: {
! 1952: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1953: return;
! 1954: }
! 1955:
! 1956: l_element_courant = (*l_element_courant).suivant;
! 1957: (*l_element_courant).donnee = s_objet_argument;
! 1958:
! 1959: if (((*l_element_courant).suivant =
! 1960: allocation_maillon(s_etat_processus)) == NULL)
! 1961: {
! 1962: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1963: return;
! 1964: }
! 1965:
! 1966: l_element_courant = (*l_element_courant).suivant;
! 1967:
! 1968: if (((*l_element_courant).donnee =
! 1969: allocation(s_etat_processus, FCT)) == NULL)
! 1970: {
! 1971: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1972: return;
! 1973: }
! 1974:
! 1975: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1976: .nombre_arguments = 1;
! 1977: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1978: .fonction = instruction_cosh;
! 1979:
! 1980: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1981: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
! 1982: {
! 1983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1984: return;
! 1985: }
! 1986:
! 1987: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 1988: .nom_fonction, "COSH");
! 1989:
! 1990: if (((*l_element_courant).suivant =
! 1991: allocation_maillon(s_etat_processus)) == NULL)
! 1992: {
! 1993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1994: return;
! 1995: }
! 1996:
! 1997: l_element_courant = (*l_element_courant).suivant;
! 1998:
! 1999: if (((*l_element_courant).donnee =
! 2000: allocation(s_etat_processus, FCT)) == NULL)
! 2001: {
! 2002: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2003: return;
! 2004: }
! 2005:
! 2006: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2007: .nombre_arguments = 0;
! 2008: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2009: .fonction = instruction_vers_niveau_inferieur;
! 2010:
! 2011: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2012: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 2013: {
! 2014: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2015: return;
! 2016: }
! 2017:
! 2018: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 2019: .nom_fonction, ">>");
! 2020:
! 2021: (*l_element_courant).suivant = NULL;
! 2022: s_objet_argument = NULL;
! 2023: }
! 2024:
! 2025: /*
! 2026: --------------------------------------------------------------------------------
! 2027: Cosinus hyperbolique d'une expression
! 2028: --------------------------------------------------------------------------------
! 2029: */
! 2030:
! 2031: else if (((*s_objet_argument).type == ALG) ||
! 2032: ((*s_objet_argument).type == RPN))
! 2033: {
! 2034: if ((s_copie_argument = copie_objet(s_etat_processus,
! 2035: s_objet_argument, 'N')) == NULL)
! 2036: {
! 2037: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2038: return;
! 2039: }
! 2040:
! 2041: l_element_courant = (struct_liste_chainee *)
! 2042: (*s_copie_argument).objet;
! 2043: l_element_precedent = l_element_courant;
! 2044:
! 2045: while((*l_element_courant).suivant != NULL)
! 2046: {
! 2047: l_element_precedent = l_element_courant;
! 2048: l_element_courant = (*l_element_courant).suivant;
! 2049: }
! 2050:
! 2051: if (((*l_element_precedent).suivant =
! 2052: allocation_maillon(s_etat_processus)) == NULL)
! 2053: {
! 2054: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2055: return;
! 2056: }
! 2057:
! 2058: if (((*(*l_element_precedent).suivant).donnee =
! 2059: allocation(s_etat_processus, FCT)) == NULL)
! 2060: {
! 2061: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2062: return;
! 2063: }
! 2064:
! 2065: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2066: .donnee).objet)).nombre_arguments = 1;
! 2067: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 2068: .donnee).objet)).fonction = instruction_cosh;
! 2069:
! 2070: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 2071: .suivant).donnee).objet)).nom_fonction =
! 2072: malloc(5 * sizeof(unsigned char))) == NULL)
! 2073: {
! 2074: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 2075: return;
! 2076: }
! 2077:
! 2078: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 2079: .suivant).donnee).objet)).nom_fonction, "COSH");
! 2080:
! 2081: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 2082:
! 2083: s_objet_resultat = s_copie_argument;
! 2084: }
! 2085:
! 2086: /*
! 2087: --------------------------------------------------------------------------------
! 2088: Réalisation impossible de la fonction cosinus hyperbolique
! 2089: --------------------------------------------------------------------------------
! 2090: */
! 2091:
! 2092: else
! 2093: {
! 2094: liberation(s_etat_processus, s_objet_argument);
! 2095:
! 2096: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 2097: return;
! 2098: }
! 2099:
! 2100: liberation(s_etat_processus, s_objet_argument);
! 2101:
! 2102: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 2103: s_objet_resultat) == d_erreur)
! 2104: {
! 2105: return;
! 2106: }
! 2107:
! 2108: return;
! 2109: }
! 2110:
! 2111: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src