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