![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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