Annotation of rpl/src/instructions_x2.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 'xroot'
! 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_xroot(struct_processus *s_etat_processus)
! 40: {
! 41: real8 argument;
! 42: real8 module;
! 43:
! 44: struct_liste_chainee *l_element_courant;
! 45: struct_liste_chainee *l_element_precedent;
! 46:
! 47: struct_objet *s_copie_argument_1;
! 48: struct_objet *s_copie_argument_2;
! 49: struct_objet *s_objet_argument_1;
! 50: struct_objet *s_objet_argument_2;
! 51: struct_objet *s_objet_resultat;
! 52:
! 53: unsigned long nombre_elements;
! 54:
! 55: (*s_etat_processus).erreur_execution = d_ex;
! 56:
! 57: if ((*s_etat_processus).affichage_arguments == 'Y')
! 58: {
! 59: printf("\n XROOT ");
! 60:
! 61: if ((*s_etat_processus).langue == 'F')
! 62: {
! 63: printf("(racine n-ième)\n\n");
! 64: }
! 65: else
! 66: {
! 67: printf("(Nth root)\n\n");
! 68: }
! 69:
! 70: printf(" 2: %s, %s, %s\n", d_INT, d_REL, d_CPL);
! 71: printf(" 1: %s\n", d_INT);
! 72: printf("-> 1: %s, %s\n\n", d_REL, d_CPL);
! 73:
! 74: printf(" 2: %s, %s, %s, %s, %s, %s\n",
! 75: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 76: printf(" 1: %s, %s, %s, %s, %s, %s\n",
! 77: d_INT, d_REL, d_CPL, d_NOM, d_ALG, d_RPN);
! 78: printf("-> 1: %s, %s\n", d_ALG, d_RPN);
! 79:
! 80: return;
! 81: }
! 82: else if ((*s_etat_processus).test_instruction == 'Y')
! 83: {
! 84: (*s_etat_processus).nombre_arguments = 2;
! 85: return;
! 86: }
! 87:
! 88: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 89: {
! 90: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 91: {
! 92: return;
! 93: }
! 94: }
! 95:
! 96: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 97: &s_objet_argument_1) == d_erreur)
! 98: {
! 99: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 100: return;
! 101: }
! 102:
! 103: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 104: &s_objet_argument_2) == d_erreur)
! 105: {
! 106: liberation(s_etat_processus, s_objet_argument_1);
! 107:
! 108: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 109: return;
! 110: }
! 111:
! 112: /*
! 113: --------------------------------------------------------------------------------
! 114: Racines n-ièmes de scalaires
! 115: --------------------------------------------------------------------------------
! 116: */
! 117:
! 118: if (((*s_objet_argument_1).type == INT) &&
! 119: ((*s_objet_argument_2).type == INT))
! 120: {
! 121: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
! 122: {
! 123: liberation(s_etat_processus, s_objet_argument_1);
! 124: liberation(s_etat_processus, s_objet_argument_2);
! 125:
! 126: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 127: return;
! 128: }
! 129:
! 130: if (((*((integer8 *) (*s_objet_argument_2).objet)) < 0) &&
! 131: (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
! 132: {
! 133: /*
! 134: * Résultat Y^(1/X) complexe si X impair et Y négatif
! 135: */
! 136:
! 137: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 138: == NULL)
! 139: {
! 140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 141: return;
! 142: }
! 143:
! 144: module = abs((*((integer8 *) (*s_objet_argument_2).objet)));
! 145: argument = ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
! 146: ? 0 : (4 * atan((double) 1));
! 147:
! 148: argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
! 149: .objet)));
! 150: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
! 151: (*s_objet_argument_1).objet))));
! 152:
! 153: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
! 154: module * cos(argument);
! 155: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
! 156: module * sin(argument);
! 157: }
! 158: else
! 159: {
! 160: /*
! 161: * Résultat réel
! 162: */
! 163:
! 164: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 165: == NULL)
! 166: {
! 167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 168: return;
! 169: }
! 170:
! 171: if ((*((integer8 *) (*s_objet_argument_2).objet)) >= 0)
! 172: {
! 173: (*((real8 *) (*s_objet_resultat).objet)) = pow(((double)
! 174: (*((integer8 *) (*s_objet_argument_2).objet))),
! 175: ((double) 1) / ((double) (*((integer8 *)
! 176: (*s_objet_argument_1).objet))));
! 177: }
! 178: else
! 179: {
! 180: (*((real8 *) (*s_objet_resultat).objet)) = -pow(((double)
! 181: -(*((integer8 *) (*s_objet_argument_2).objet))),
! 182: ((double) 1) / ((double) (*((integer8 *)
! 183: (*s_objet_argument_1).objet))));
! 184: }
! 185: }
! 186: }
! 187: else if (((*s_objet_argument_1).type == INT) &&
! 188: ((*s_objet_argument_2).type == REL))
! 189: {
! 190: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
! 191: {
! 192: liberation(s_etat_processus, s_objet_argument_1);
! 193: liberation(s_etat_processus, s_objet_argument_2);
! 194:
! 195: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 196: return;
! 197: }
! 198:
! 199: if (((*((real8 *) (*s_objet_argument_2).objet)) < 0) &&
! 200: (((*((integer8 *) (*s_objet_argument_1).objet)) % 2) == 0))
! 201: {
! 202: /*
! 203: * Résultat Y^(1/X) complexe si X impair et Y négatif
! 204: */
! 205:
! 206: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 207: == NULL)
! 208: {
! 209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 210: return;
! 211: }
! 212:
! 213: module = abs((*((real8 *) (*s_objet_argument_2).objet)));
! 214: argument = ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
! 215: ? 0 : (4 * atan((double) 1));
! 216:
! 217: argument /= ((double) (*((integer8 *) (*s_objet_argument_1)
! 218: .objet)));
! 219: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
! 220: (*s_objet_argument_1).objet))));
! 221:
! 222: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
! 223: module * cos(argument);
! 224: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
! 225: module * sin(argument);
! 226: }
! 227: else
! 228: {
! 229: /*
! 230: * Résultat réel
! 231: */
! 232:
! 233: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 234: == NULL)
! 235: {
! 236: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 237: return;
! 238: }
! 239:
! 240: if ((*((real8 *) (*s_objet_argument_2).objet)) >= 0)
! 241: {
! 242: (*((real8 *) (*s_objet_resultat).objet)) = pow(
! 243: (*((real8 *) (*s_objet_argument_2).objet)),
! 244: ((double) 1) / ((double) (*((integer8 *)
! 245: (*s_objet_argument_1).objet))));
! 246: }
! 247: else
! 248: {
! 249: (*((real8 *) (*s_objet_resultat).objet)) = -pow(
! 250: -(*((real8 *) (*s_objet_argument_2).objet)),
! 251: ((double) 1) / ((double) (*((integer8 *)
! 252: (*s_objet_argument_1).objet))));
! 253: }
! 254: }
! 255: }
! 256: else if (((*s_objet_argument_1).type == INT) &&
! 257: ((*s_objet_argument_2).type == CPL))
! 258: {
! 259: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0)
! 260: {
! 261: liberation(s_etat_processus, s_objet_argument_1);
! 262: liberation(s_etat_processus, s_objet_argument_2);
! 263:
! 264: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 265: return;
! 266: }
! 267:
! 268: if ((s_objet_resultat = allocation(s_etat_processus, CPL))
! 269: == NULL)
! 270: {
! 271: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 272: return;
! 273: }
! 274:
! 275: f77absc_(((struct_complexe16 *) (*s_objet_argument_2).objet), &module);
! 276:
! 277: argument = atan2((*((struct_complexe16 *) (*s_objet_argument_2).objet))
! 278: .partie_imaginaire, (*((struct_complexe16 *)
! 279: (*s_objet_argument_2).objet)).partie_reelle);
! 280:
! 281: argument /= ((double) (*((integer8 *) (*s_objet_argument_1).objet)));
! 282: module = pow(module, ((double) 1) / ((double) (*((integer8 *)
! 283: (*s_objet_argument_1).objet))));
! 284:
! 285: (*((complex16 *) (*s_objet_resultat).objet)).partie_reelle =
! 286: module * cos(argument);
! 287: (*((complex16 *) (*s_objet_resultat).objet)).partie_imaginaire =
! 288: module * sin(argument);
! 289: }
! 290:
! 291: /*
! 292: --------------------------------------------------------------------------------
! 293: Résultat sous forme d'expression algébrique
! 294: --------------------------------------------------------------------------------
! 295: */
! 296:
! 297: else if ((((*s_objet_argument_2).type == NOM) &&
! 298: (((*s_objet_argument_1).type == NOM) ||
! 299: ((*s_objet_argument_1).type == INT))) ||
! 300: ((((*s_objet_argument_2).type == INT) ||
! 301: ((*s_objet_argument_2).type == REL) ||
! 302: ((*s_objet_argument_2).type == CPL)) &&
! 303: ((*s_objet_argument_1).type == NOM)))
! 304: {
! 305: if ((s_objet_resultat = allocation(s_etat_processus, ALG))
! 306: == NULL)
! 307: {
! 308: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 309: return;
! 310: }
! 311:
! 312: if (((*s_objet_resultat).objet =
! 313: allocation_maillon(s_etat_processus)) == NULL)
! 314: {
! 315: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 316: return;
! 317: }
! 318:
! 319: l_element_courant = (*s_objet_resultat).objet;
! 320:
! 321: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 322: == NULL)
! 323: {
! 324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 325: return;
! 326: }
! 327:
! 328: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 329: .nombre_arguments = 2;
! 330: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 331: .fonction = instruction_vers_niveau_superieur;
! 332:
! 333: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 334: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 335: {
! 336: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 337: return;
! 338: }
! 339:
! 340: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 341: .nom_fonction, "<<");
! 342:
! 343: if (((*l_element_courant).suivant =
! 344: allocation_maillon(s_etat_processus)) == NULL)
! 345: {
! 346: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 347: return;
! 348: }
! 349:
! 350: l_element_courant = (*l_element_courant).suivant;
! 351: (*l_element_courant).donnee = s_objet_argument_2;
! 352:
! 353: if (((*l_element_courant).suivant =
! 354: allocation_maillon(s_etat_processus)) == NULL)
! 355: {
! 356: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 357: return;
! 358: }
! 359:
! 360: l_element_courant = (*l_element_courant).suivant;
! 361: (*l_element_courant).donnee = s_objet_argument_1;
! 362:
! 363: if (((*l_element_courant).suivant =
! 364: allocation_maillon(s_etat_processus)) == NULL)
! 365: {
! 366: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 367: return;
! 368: }
! 369:
! 370: l_element_courant = (*l_element_courant).suivant;
! 371:
! 372: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 373: == NULL)
! 374: {
! 375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 376: return;
! 377: }
! 378:
! 379: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 380: .nombre_arguments = 2;
! 381: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 382: .fonction = instruction_xroot;
! 383:
! 384: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 385: .nom_fonction = malloc(6 * sizeof(unsigned char))) == NULL)
! 386: {
! 387: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 388: return;
! 389: }
! 390:
! 391: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 392: .nom_fonction, "XROOT");
! 393:
! 394: if (((*l_element_courant).suivant =
! 395: allocation_maillon(s_etat_processus)) == NULL)
! 396: {
! 397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 398: return;
! 399: }
! 400:
! 401: l_element_courant = (*l_element_courant).suivant;
! 402:
! 403: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT))
! 404: == NULL)
! 405: {
! 406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 407: return;
! 408: }
! 409:
! 410: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 411: .nombre_arguments = 2;
! 412: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 413: .fonction = instruction_vers_niveau_inferieur;
! 414:
! 415: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 416: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
! 417: {
! 418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 419: return;
! 420: }
! 421:
! 422: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 423: .nom_fonction, ">>");
! 424:
! 425: (*l_element_courant).suivant = NULL;
! 426:
! 427: s_objet_argument_1 = NULL;
! 428: s_objet_argument_2 = NULL;
! 429: }
! 430:
! 431: /*
! 432: * Expression / Nom ou valeur numérique
! 433: */
! 434:
! 435: else if ((((*s_objet_argument_1).type == ALG) ||
! 436: ((*s_objet_argument_1).type == RPN)) &&
! 437: (((*s_objet_argument_2).type == NOM) ||
! 438: ((*s_objet_argument_2).type == INT) ||
! 439: ((*s_objet_argument_2).type == REL) ||
! 440: ((*s_objet_argument_2).type == CPL)))
! 441: {
! 442: nombre_elements = 0;
! 443: l_element_courant = (struct_liste_chainee *)
! 444: (*s_objet_argument_1).objet;
! 445:
! 446: while(l_element_courant != NULL)
! 447: {
! 448: nombre_elements++;
! 449: l_element_courant = (*l_element_courant).suivant;
! 450: }
! 451:
! 452: if (nombre_elements == 2)
! 453: {
! 454: liberation(s_etat_processus, s_objet_argument_1);
! 455: liberation(s_etat_processus, s_objet_argument_2);
! 456:
! 457: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 458: return;
! 459: }
! 460:
! 461: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 462: s_objet_argument_1, 'N')) == NULL)
! 463: {
! 464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 465: return;
! 466: }
! 467:
! 468: l_element_courant = (struct_liste_chainee *)
! 469: (*s_objet_resultat).objet;
! 470: l_element_precedent = l_element_courant;
! 471: l_element_courant = (*l_element_courant).suivant;
! 472:
! 473: if (((*l_element_precedent).suivant =
! 474: allocation_maillon(s_etat_processus)) == NULL)
! 475: {
! 476: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 477: return;
! 478: }
! 479:
! 480: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
! 481: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 482:
! 483: while((*l_element_courant).suivant != NULL)
! 484: {
! 485: l_element_precedent = l_element_courant;
! 486: l_element_courant = (*l_element_courant).suivant;
! 487: }
! 488:
! 489: if (((*l_element_precedent).suivant =
! 490: allocation_maillon(s_etat_processus)) == NULL)
! 491: {
! 492: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 493: return;
! 494: }
! 495:
! 496: if (((*(*l_element_precedent).suivant).donnee =
! 497: allocation(s_etat_processus, FCT)) == NULL)
! 498: {
! 499: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 500: return;
! 501: }
! 502:
! 503: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 504: .donnee).objet)).nombre_arguments = 2;
! 505: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 506: .donnee).objet)).fonction = instruction_xroot;
! 507:
! 508: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 509: .suivant).donnee).objet)).nom_fonction =
! 510: malloc(6 * sizeof(unsigned char))) == NULL)
! 511: {
! 512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 513: return;
! 514: }
! 515:
! 516: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 517: .suivant).donnee).objet)).nom_fonction, "XROOT");
! 518:
! 519: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 520:
! 521: s_objet_argument_2 = NULL;
! 522: }
! 523:
! 524: /*
! 525: * Expression / Nom ou valeur numérique
! 526: */
! 527:
! 528: else if ((((*s_objet_argument_1).type == NOM) ||
! 529: ((*s_objet_argument_1).type == INT)) &&
! 530: (((*s_objet_argument_2).type == ALG) ||
! 531: ((*s_objet_argument_2).type == RPN)))
! 532: {
! 533: nombre_elements = 0;
! 534: l_element_courant = (struct_liste_chainee *)
! 535: (*s_objet_argument_2).objet;
! 536:
! 537: while(l_element_courant != NULL)
! 538: {
! 539: nombre_elements++;
! 540: l_element_courant = (*l_element_courant).suivant;
! 541: }
! 542:
! 543: if (nombre_elements == 2)
! 544: {
! 545: liberation(s_etat_processus, s_objet_argument_1);
! 546: liberation(s_etat_processus, s_objet_argument_2);
! 547:
! 548: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 549: return;
! 550: }
! 551:
! 552: if ((s_objet_resultat = copie_objet(s_etat_processus,
! 553: s_objet_argument_2, 'N')) == NULL)
! 554: {
! 555: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 556: return;
! 557: }
! 558:
! 559: l_element_courant = (struct_liste_chainee *)
! 560: (*s_objet_resultat).objet;
! 561: l_element_precedent = l_element_courant;
! 562:
! 563: while((*l_element_courant).suivant != NULL)
! 564: {
! 565: l_element_precedent = l_element_courant;
! 566: l_element_courant = (*l_element_courant).suivant;
! 567: }
! 568:
! 569: if (((*l_element_precedent).suivant =
! 570: allocation_maillon(s_etat_processus)) == NULL)
! 571: {
! 572: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 573: return;
! 574: }
! 575:
! 576: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
! 577: l_element_precedent = (*l_element_precedent).suivant;
! 578:
! 579: if (((*l_element_precedent).suivant =
! 580: allocation_maillon(s_etat_processus)) == NULL)
! 581: {
! 582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 583: return;
! 584: }
! 585:
! 586: if (((*(*l_element_precedent).suivant).donnee =
! 587: allocation(s_etat_processus, FCT)) == NULL)
! 588: {
! 589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 590: return;
! 591: }
! 592:
! 593: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 594: .donnee).objet)).nombre_arguments = 2;
! 595: (*((struct_fonction *) (*(*(*l_element_precedent).suivant)
! 596: .donnee).objet)).fonction = instruction_xroot;
! 597:
! 598: if (((*((struct_fonction *) (*(*(*l_element_precedent)
! 599: .suivant).donnee).objet)).nom_fonction =
! 600: malloc(6 * sizeof(unsigned char))) == NULL)
! 601: {
! 602: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 603: return;
! 604: }
! 605:
! 606: strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
! 607: .suivant).donnee).objet)).nom_fonction, "XROOT");
! 608:
! 609: (*(*l_element_precedent).suivant).suivant = l_element_courant;
! 610:
! 611: s_objet_argument_1 = NULL;
! 612: }
! 613:
! 614: /*
! 615: * Expression / Expression
! 616: */
! 617:
! 618: else if ((((*s_objet_argument_1).type == ALG) &&
! 619: ((*s_objet_argument_2).type == ALG)) ||
! 620: (((*s_objet_argument_1).type == RPN) &&
! 621: ((*s_objet_argument_2).type == RPN)))
! 622: {
! 623: nombre_elements = 0;
! 624: l_element_courant = (struct_liste_chainee *)
! 625: (*s_objet_argument_1).objet;
! 626:
! 627: while(l_element_courant != NULL)
! 628: {
! 629: nombre_elements++;
! 630: l_element_courant = (*l_element_courant).suivant;
! 631: }
! 632:
! 633: if (nombre_elements == 2)
! 634: {
! 635: liberation(s_etat_processus, s_objet_argument_1);
! 636: liberation(s_etat_processus, s_objet_argument_2);
! 637:
! 638: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 639: return;
! 640: }
! 641:
! 642: nombre_elements = 0;
! 643: l_element_courant = (struct_liste_chainee *)
! 644: (*s_objet_argument_2).objet;
! 645:
! 646: while(l_element_courant != NULL)
! 647: {
! 648: nombre_elements++;
! 649: l_element_courant = (*l_element_courant).suivant;
! 650: }
! 651:
! 652: if (nombre_elements == 2)
! 653: {
! 654: liberation(s_etat_processus, s_objet_argument_1);
! 655: liberation(s_etat_processus, s_objet_argument_2);
! 656:
! 657: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 658: return;
! 659: }
! 660:
! 661: if ((s_copie_argument_1 = copie_objet(s_etat_processus,
! 662: s_objet_argument_1, 'N')) == NULL)
! 663: {
! 664: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 665: return;
! 666: }
! 667:
! 668: if ((s_copie_argument_2 = copie_objet(s_etat_processus,
! 669: s_objet_argument_2, 'N')) == NULL)
! 670: {
! 671: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 672: return;
! 673: }
! 674:
! 675: l_element_courant = (struct_liste_chainee *)
! 676: (*s_copie_argument_1).objet;
! 677: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *)
! 678: (*s_copie_argument_1).objet)).suivant;
! 679:
! 680: liberation(s_etat_processus, (*l_element_courant).donnee);
! 681: free(l_element_courant);
! 682:
! 683: l_element_courant = (struct_liste_chainee *)
! 684: (*s_copie_argument_2).objet;
! 685: l_element_precedent = l_element_courant;
! 686: s_objet_resultat = s_copie_argument_2;
! 687:
! 688: while((*l_element_courant).suivant != NULL)
! 689: {
! 690: l_element_precedent = l_element_courant;
! 691: l_element_courant = (*l_element_courant).suivant;
! 692: }
! 693:
! 694: liberation(s_etat_processus, (*l_element_courant).donnee);
! 695: free(l_element_courant);
! 696:
! 697: (*l_element_precedent).suivant = (struct_liste_chainee *)
! 698: (*s_copie_argument_1).objet;
! 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 = allocation(s_etat_processus, FCT))
! 719: == 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 = 2;
! 727: (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 728: .fonction = instruction_xroot;
! 729:
! 730: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
! 731: .nom_fonction = malloc(6 * 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, "XROOT");
! 739: }
! 740: else
! 741: {
! 742: liberation(s_etat_processus, s_objet_argument_1);
! 743: liberation(s_etat_processus, s_objet_argument_2);
! 744:
! 745: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 746: return;
! 747: }
! 748:
! 749: liberation(s_etat_processus, s_objet_argument_1);
! 750: liberation(s_etat_processus, s_objet_argument_2);
! 751:
! 752: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 753: s_objet_resultat) == d_erreur)
! 754: {
! 755: return;
! 756: }
! 757:
! 758: return;
! 759: }
! 760:
! 761:
! 762: /*
! 763: ================================================================================
! 764: Fonction 'xcol'
! 765: ================================================================================
! 766: Entrées : pointeur sur une structure struct_processus
! 767: --------------------------------------------------------------------------------
! 768: Sorties :
! 769: --------------------------------------------------------------------------------
! 770: Effets de bord : néant
! 771: ================================================================================
! 772: */
! 773:
! 774: void
! 775: instruction_xcol(struct_processus *s_etat_processus)
! 776: {
! 777: struct_objet *s_objet_argument;
! 778:
! 779: (*s_etat_processus).erreur_execution = d_ex;
! 780:
! 781: if ((*s_etat_processus).affichage_arguments == 'Y')
! 782: {
! 783: printf("\n XCOL ");
! 784:
! 785: if ((*s_etat_processus).langue == 'F')
! 786: {
! 787: printf("(définition de la colonne statistique X)\n\n");
! 788: }
! 789: else
! 790: {
! 791: printf("(definition of statistical X column)\n\n");
! 792: }
! 793:
! 794: printf(" 1: %s\n", d_INT);
! 795:
! 796: return;
! 797: }
! 798: else if ((*s_etat_processus).test_instruction == 'Y')
! 799: {
! 800: (*s_etat_processus).nombre_arguments = -1;
! 801: return;
! 802: }
! 803:
! 804: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 805: {
! 806: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 807: {
! 808: return;
! 809: }
! 810: }
! 811:
! 812: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 813: &s_objet_argument) == d_erreur)
! 814: {
! 815: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 816: return;
! 817: }
! 818:
! 819: if ((*s_objet_argument).type == INT)
! 820: {
! 821: if ((*((integer8 *) (*s_objet_argument).objet)) <= 0)
! 822: {
! 823: liberation(s_etat_processus, s_objet_argument);
! 824:
! 825: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 826: return;
! 827: }
! 828:
! 829: (*s_etat_processus).colonne_statistique_1 =
! 830: (*((integer8 *) (*s_objet_argument).objet));
! 831: }
! 832: else
! 833: {
! 834: liberation(s_etat_processus, s_objet_argument);
! 835:
! 836: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 837: return;
! 838: }
! 839:
! 840: liberation(s_etat_processus, s_objet_argument);
! 841:
! 842: return;
! 843: }
! 844:
! 845: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_x2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src