![]() ![]() | ![]() |
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 'var' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_var(struct_processus *s_etat_processus) 40: { 41: struct_objet *s_objet_statistique; 42: struct_objet *s_objet_resultat; 43: struct_objet *s_objet_temporaire; 44: 45: unsigned long nombre_colonnes; 46: 47: (*s_etat_processus).erreur_execution = d_ex; 48: 49: if ((*s_etat_processus).affichage_arguments == 'Y') 50: { 51: printf("\n VAR "); 52: 53: if ((*s_etat_processus).langue == 'F') 54: { 55: printf("(variance)\n\n"); 56: } 57: else 58: { 59: printf("(variance)\n\n"); 60: } 61: 62: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL); 63: 64: return; 65: } 66: else if ((*s_etat_processus).test_instruction == 'Y') 67: { 68: (*s_etat_processus).nombre_arguments = -1; 69: return; 70: } 71: 72: if (test_cfsf(s_etat_processus, 31) == d_vrai) 73: { 74: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 75: { 76: return; 77: } 78: } 79: 80: /* 81: * Recherche d'une variable globale référencée par SIGMA 82: */ 83: 84: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 85: { 86: /* 87: * Aucune variable SIGMA 88: */ 89: 90: (*s_etat_processus).erreur_systeme = d_es; 91: 92: if ((*s_etat_processus).erreur_execution == d_ex) 93: { 94: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 95: } 96: 97: return; 98: } 99: else 100: { 101: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 102: .type != MIN) && ((*(*(*s_etat_processus) 103: .pointeur_variable_courante).objet).type != MRL)) 104: { 105: (*s_etat_processus).erreur_execution = 106: d_ex_matrice_statistique_invalide; 107: return; 108: } 109: 110: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 111: .pointeur_variable_courante).objet).objet)) 112: .nombre_colonnes; 113: } 114: 115: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 116: .objet; 117: 118: if (((*s_objet_statistique).type == MIN) || 119: ((*s_objet_statistique).type == MRL)) 120: { 121: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes 122: <= 1) 123: { 124: (*s_etat_processus).erreur_execution = 125: d_ex_statistiques_echantillon; 126: return; 127: } 128: 129: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 130: { 131: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 132: return; 133: } 134: 135: if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *) 136: (*s_objet_statistique).objet, 'E')) == NULL) 137: { 138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 139: return; 140: } 141: 142: if (nombre_colonnes == 1) 143: { 144: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I') 145: { 146: (*s_objet_resultat).type = VIN; 147: s_objet_temporaire = s_objet_resultat; 148: 149: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 150: == NULL) 151: { 152: (*s_etat_processus).erreur_systeme = 153: d_es_allocation_memoire; 154: return; 155: } 156: 157: (*((integer8 *) (*s_objet_resultat).objet)) = 158: ((integer8 *) (*((struct_vecteur *) 159: (*s_objet_temporaire).objet)).tableau)[0]; 160: 161: liberation(s_etat_processus, s_objet_temporaire); 162: } 163: else 164: { 165: (*s_objet_resultat).type = VRL; 166: s_objet_temporaire = s_objet_resultat; 167: 168: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 169: == NULL) 170: { 171: (*s_etat_processus).erreur_systeme = 172: d_es_allocation_memoire; 173: return; 174: } 175: 176: (*((real8 *) (*s_objet_resultat).objet)) = 177: ((real8 *) (*((struct_vecteur *) 178: (*s_objet_temporaire).objet)).tableau)[0]; 179: 180: liberation(s_etat_processus, s_objet_temporaire); 181: } 182: } 183: else 184: { 185: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I') 186: { 187: (*s_objet_resultat).type = VIN; 188: } 189: else 190: { 191: (*s_objet_resultat).type = VRL; 192: } 193: } 194: 195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 196: s_objet_resultat) == d_erreur) 197: { 198: return; 199: } 200: } 201: else 202: { 203: (*s_etat_processus).erreur_execution = 204: d_ex_matrice_statistique_invalide; 205: return; 206: } 207: 208: return; 209: } 210: 211: 212: /* 213: ================================================================================ 214: Fonction 'version' 215: ================================================================================ 216: Entrées : 217: -------------------------------------------------------------------------------- 218: Sorties : 219: -------------------------------------------------------------------------------- 220: Effets de bord : néant 221: ================================================================================ 222: */ 223: 224: void 225: instruction_version(struct_processus *s_etat_processus) 226: { 227: int nombre_champs; 228: 229: integer8 i1; 230: integer8 i2; 231: integer8 i3; 232: integer8 i4; 233: 234: struct_liste_chainee *l_element_courant; 235: struct_liste_chainee *l_element_interne_courant; 236: 237: struct_objet *s_objet_resultat; 238: 239: unsigned char texte[] = "RPL/2 version "; 240: 241: (*s_etat_processus).erreur_execution = d_ex; 242: 243: if ((*s_etat_processus).affichage_arguments == 'Y') 244: { 245: printf("\n VERSION "); 246: 247: if ((*s_etat_processus).langue == 'F') 248: { 249: printf("(version du séquenceur)\n\n"); 250: } 251: else 252: { 253: printf("(sequencer version)\n\n"); 254: } 255: 256: printf("-> 1: %s\n", d_LST); 257: 258: return; 259: } 260: else if ((*s_etat_processus).test_instruction == 'Y') 261: { 262: (*s_etat_processus).nombre_arguments = -1; 263: return; 264: } 265: 266: if (test_cfsf(s_etat_processus, 31) == d_vrai) 267: { 268: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 269: { 270: return; 271: } 272: } 273: 274: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) 275: { 276: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 277: return; 278: } 279: 280: if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus)) 281: == NULL) 282: { 283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 284: return; 285: } 286: 287: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet; 288: (*l_element_courant).suivant = NULL; 289: 290: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 291: == NULL) 292: { 293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 294: return; 295: } 296: 297: if (((*(*l_element_courant).donnee).objet = malloc((strlen(texte) 298: + strlen(d_version_rpl) + 1) * sizeof(unsigned char))) == NULL) 299: { 300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 301: return; 302: } 303: 304: sprintf((unsigned char *) (*(*l_element_courant).donnee).objet, "%s%s", 305: texte, d_version_rpl); 306: 307: /* 308: * Ajout des versions X.Y.Z sous forme d'entiers 309: */ 310: 311: i1 = 0; 312: i2 = 0; 313: i3 = 0; 314: i4 = 0; 315: 316: nombre_champs = sscanf(d_version_rpl, "%lld.%lld.%lld.prerelease.%lld", 317: &i1, &i2, &i3, &i4); 318: 319: if (((*l_element_courant).suivant = 320: allocation_maillon(s_etat_processus)) == NULL) 321: { 322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 323: return; 324: } 325: 326: l_element_courant = (*l_element_courant).suivant; 327: (*l_element_courant).suivant = NULL; 328: 329: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST)) 330: == NULL) 331: { 332: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 333: return; 334: } 335: 336: if (((*(*l_element_courant).donnee).objet = 337: allocation_maillon(s_etat_processus)) == NULL) 338: { 339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 340: return; 341: } 342: 343: l_element_interne_courant = (struct_liste_chainee *) 344: (*(*l_element_courant).donnee).objet; 345: 346: (*l_element_interne_courant).suivant = NULL; 347: 348: if (((*l_element_interne_courant).donnee = 349: allocation(s_etat_processus, INT)) == NULL) 350: { 351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 352: return; 353: } 354: 355: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i1; 356: 357: if (((*l_element_interne_courant).suivant = 358: allocation_maillon(s_etat_processus)) == NULL) 359: { 360: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 361: return; 362: } 363: 364: l_element_interne_courant = (*l_element_interne_courant).suivant; 365: (*l_element_interne_courant).suivant = NULL; 366: 367: if (((*l_element_interne_courant).donnee = 368: allocation(s_etat_processus, INT)) == NULL) 369: { 370: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 371: return; 372: } 373: 374: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i2; 375: 376: if (((*l_element_interne_courant).suivant = 377: allocation_maillon(s_etat_processus)) == NULL) 378: { 379: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 380: return; 381: } 382: 383: l_element_interne_courant = (*l_element_interne_courant).suivant; 384: (*l_element_interne_courant).suivant = NULL; 385: 386: if (((*l_element_interne_courant).donnee = 387: allocation(s_etat_processus, INT)) == NULL) 388: { 389: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 390: return; 391: } 392: 393: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i3; 394: 395: /* 396: * Ajout de "PRERELEASE" suivi d'un entier ou de "RELEASE" 397: */ 398: 399: if (nombre_champs == 3) 400: { 401: // Version "RELEASE" 402: 403: if (((*l_element_interne_courant).suivant = 404: allocation_maillon(s_etat_processus)) == NULL) 405: { 406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 407: return; 408: } 409: 410: l_element_interne_courant = (*l_element_interne_courant).suivant; 411: (*l_element_interne_courant).suivant = NULL; 412: 413: if (((*l_element_interne_courant).donnee = 414: allocation(s_etat_processus, CHN)) == NULL) 415: { 416: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 417: return; 418: } 419: 420: if (((*(*l_element_interne_courant).donnee).objet = malloc(8 * 421: sizeof(unsigned char))) == NULL) 422: { 423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 424: return; 425: } 426: 427: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet, 428: "RELEASE"); 429: } 430: else 431: { 432: // Version "PRERELEASE" 433: 434: if (((*l_element_interne_courant).suivant = 435: allocation_maillon(s_etat_processus)) == NULL) 436: { 437: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 438: return; 439: } 440: 441: l_element_interne_courant = (*l_element_interne_courant).suivant; 442: (*l_element_interne_courant).suivant = NULL; 443: 444: if (((*l_element_interne_courant).donnee = 445: allocation(s_etat_processus, CHN)) == NULL) 446: { 447: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 448: return; 449: } 450: 451: if (((*(*l_element_interne_courant).donnee).objet = malloc(11 * 452: sizeof(unsigned char))) == NULL) 453: { 454: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 455: return; 456: } 457: 458: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet, 459: "PRERELEASE"); 460: 461: if (((*l_element_interne_courant).suivant = 462: allocation_maillon(s_etat_processus)) == NULL) 463: { 464: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 465: return; 466: } 467: 468: l_element_interne_courant = (*l_element_interne_courant).suivant; 469: (*l_element_interne_courant).suivant = NULL; 470: 471: if (((*l_element_interne_courant).donnee = 472: allocation(s_etat_processus, INT)) == NULL) 473: { 474: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 475: return; 476: } 477: 478: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i4; 479: } 480: 481: /* 482: * Ajout de la date de compilation 483: */ 484: 485: if (((*l_element_courant).suivant = 486: allocation_maillon(s_etat_processus)) == NULL) 487: { 488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 489: return; 490: } 491: 492: l_element_courant = (*l_element_courant).suivant; 493: (*l_element_courant).suivant = NULL; 494: 495: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 496: == NULL) 497: { 498: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 499: return; 500: } 501: 502: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl) 503: + 1) * sizeof(unsigned char))) == NULL) 504: { 505: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 506: return; 507: } 508: 509: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 510: d_date_en_rpl); 511: 512: /* 513: * Ajout des options de compilation 514: */ 515: 516: if (((*l_element_courant).suivant = 517: allocation_maillon(s_etat_processus)) == NULL) 518: { 519: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 520: return; 521: } 522: 523: l_element_courant = (*l_element_courant).suivant; 524: (*l_element_courant).suivant = NULL; 525: 526: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 527: == NULL) 528: { 529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 530: return; 531: } 532: 533: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path) 534: + 1) * sizeof(unsigned char))) == NULL) 535: { 536: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 537: return; 538: } 539: 540: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 541: d_exec_path); 542: 543: if (((*l_element_courant).suivant = 544: allocation_maillon(s_etat_processus)) == NULL) 545: { 546: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 547: return; 548: } 549: 550: l_element_courant = (*l_element_courant).suivant; 551: (*l_element_courant).suivant = NULL; 552: 553: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 554: == NULL) 555: { 556: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 557: return; 558: } 559: 560: #ifdef GNUPLOT_SUPPORT 561: if (((*(*l_element_courant).donnee).objet = malloc(8 * 562: sizeof(unsigned char))) == NULL) 563: { 564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 565: return; 566: } 567: 568: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 569: "GNUPLOT"); 570: #else 571: if (((*(*l_element_courant).donnee).objet = malloc(17 * 572: sizeof(unsigned char))) == NULL) 573: { 574: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 575: return; 576: } 577: 578: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 579: "GNUPLOT DISABLED"); 580: #endif 581: 582: if (((*l_element_courant).suivant = 583: allocation_maillon(s_etat_processus)) == NULL) 584: { 585: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 586: return; 587: } 588: 589: l_element_courant = (*l_element_courant).suivant; 590: (*l_element_courant).suivant = NULL; 591: 592: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 593: == NULL) 594: { 595: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 596: return; 597: } 598: 599: #ifdef FORCE_GNUPLOT_PATH 600: if (((*(*l_element_courant).donnee).objet = malloc(19 * 601: sizeof(unsigned char))) == NULL) 602: { 603: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 604: return; 605: } 606: 607: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 608: "FORCE GNUPLOT PATH"); 609: #else 610: if (((*(*l_element_courant).donnee).objet = malloc(21 * 611: sizeof(unsigned char))) == NULL) 612: { 613: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 614: return; 615: } 616: 617: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 618: "DEFAULT GNUPLOT PATH"); 619: #endif 620: 621: if (((*l_element_courant).suivant = 622: allocation_maillon(s_etat_processus)) == NULL) 623: { 624: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 625: return; 626: } 627: 628: l_element_courant = (*l_element_courant).suivant; 629: (*l_element_courant).suivant = NULL; 630: 631: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 632: == NULL) 633: { 634: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 635: return; 636: } 637: 638: #ifdef POSTSCRIPT_SUPPORT 639: if (((*(*l_element_courant).donnee).objet = malloc(11 * 640: sizeof(unsigned char))) == NULL) 641: { 642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 643: return; 644: } 645: 646: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 647: "POSTSCRIPT"); 648: #else 649: if (((*(*l_element_courant).donnee).objet = malloc(20 * 650: sizeof(unsigned char))) == NULL) 651: { 652: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 653: return; 654: } 655: 656: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 657: "POSTSCRIPT DISABLED"); 658: #endif 659: 660: if (((*l_element_courant).suivant = 661: allocation_maillon(s_etat_processus)) == NULL) 662: { 663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 664: return; 665: } 666: 667: l_element_courant = (*l_element_courant).suivant; 668: (*l_element_courant).suivant = NULL; 669: 670: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 671: == NULL) 672: { 673: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 674: return; 675: } 676: 677: #ifdef VIM_SUPPORT 678: if (((*(*l_element_courant).donnee).objet = malloc(4 * 679: sizeof(unsigned char))) == NULL) 680: { 681: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 682: return; 683: } 684: 685: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 686: "VIM"); 687: #else 688: if (((*(*l_element_courant).donnee).objet = malloc(13 * 689: sizeof(unsigned char))) == NULL) 690: { 691: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 692: return; 693: } 694: 695: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 696: "VIM DISABLED"); 697: #endif 698: 699: if (((*l_element_courant).suivant = 700: allocation_maillon(s_etat_processus)) == NULL) 701: { 702: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 703: return; 704: } 705: 706: l_element_courant = (*l_element_courant).suivant; 707: (*l_element_courant).suivant = NULL; 708: 709: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 710: == NULL) 711: { 712: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 713: return; 714: } 715: 716: #ifdef MYSQL_SUPPORT 717: if (((*(*l_element_courant).donnee).objet = malloc(6 * 718: sizeof(unsigned char))) == NULL) 719: { 720: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 721: return; 722: } 723: 724: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 725: "MYSQL"); 726: #else 727: if (((*(*l_element_courant).donnee).objet = malloc(15 * 728: sizeof(unsigned char))) == NULL) 729: { 730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 731: return; 732: } 733: 734: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 735: "MYSQL DISABLED"); 736: #endif 737: 738: if (((*l_element_courant).suivant = 739: allocation_maillon(s_etat_processus)) == NULL) 740: { 741: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 742: return; 743: } 744: 745: l_element_courant = (*l_element_courant).suivant; 746: (*l_element_courant).suivant = NULL; 747: 748: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 749: == NULL) 750: { 751: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 752: return; 753: } 754: 755: #ifdef POSTGRESQL_SUPPORT 756: if (((*(*l_element_courant).donnee).objet = malloc(11 * 757: sizeof(unsigned char))) == NULL) 758: { 759: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 760: return; 761: } 762: 763: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 764: "POSTGRESQL"); 765: #else 766: if (((*(*l_element_courant).donnee).objet = malloc(20 * 767: sizeof(unsigned char))) == NULL) 768: { 769: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 770: return; 771: } 772: 773: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 774: "POSTGRESQL DISABLED"); 775: #endif 776: 777: if (((*l_element_courant).suivant = 778: allocation_maillon(s_etat_processus)) == NULL) 779: { 780: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 781: return; 782: } 783: 784: l_element_courant = (*l_element_courant).suivant; 785: (*l_element_courant).suivant = NULL; 786: 787: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 788: == NULL) 789: { 790: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 791: return; 792: } 793: 794: #ifdef MOTIF_SUPPORT 795: if (((*(*l_element_courant).donnee).objet = malloc(6 * 796: sizeof(unsigned char))) == NULL) 797: { 798: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 799: return; 800: } 801: 802: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 803: "MOTIF"); 804: #else 805: if (((*(*l_element_courant).donnee).objet = malloc(15 * 806: sizeof(unsigned char))) == NULL) 807: { 808: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 809: return; 810: } 811: 812: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 813: "MOTIF DISABLED"); 814: #endif 815: 816: if (((*l_element_courant).suivant = 817: allocation_maillon(s_etat_processus)) == NULL) 818: { 819: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 820: return; 821: } 822: 823: l_element_courant = (*l_element_courant).suivant; 824: (*l_element_courant).suivant = NULL; 825: 826: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 827: == NULL) 828: { 829: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 830: return; 831: } 832: 833: #ifdef DEBUG 834: if (((*(*l_element_courant).donnee).objet = malloc(6 * 835: sizeof(unsigned char))) == NULL) 836: { 837: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 838: return; 839: } 840: 841: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 842: "DEBUG"); 843: #else 844: if (((*(*l_element_courant).donnee).objet = malloc(15 * 845: sizeof(unsigned char))) == NULL) 846: { 847: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 848: return; 849: } 850: 851: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 852: "DEBUG DISABLED"); 853: #endif 854: 855: if (((*l_element_courant).suivant = 856: allocation_maillon(s_etat_processus)) == NULL) 857: { 858: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 859: return; 860: } 861: 862: l_element_courant = (*l_element_courant).suivant; 863: (*l_element_courant).suivant = NULL; 864: 865: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN)) 866: == NULL) 867: { 868: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 869: return; 870: } 871: 872: #ifdef EXPERIMENTAL_CODE 873: if (((*(*l_element_courant).donnee).objet = malloc(18 * 874: sizeof(unsigned char))) == NULL) 875: { 876: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 877: return; 878: } 879: 880: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 881: "EXPERIMENTAL CODE"); 882: #else 883: if (((*(*l_element_courant).donnee).objet = malloc(27 * 884: sizeof(unsigned char))) == NULL) 885: { 886: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 887: return; 888: } 889: 890: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, 891: "EXPERIMENTAL CODE DISABLED"); 892: #endif 893: 894: /* 895: * Empilement du résultat 896: */ 897: 898: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 899: s_objet_resultat) == d_erreur) 900: { 901: return; 902: } 903: 904: return; 905: } 906: 907: 908: /* 909: ================================================================================ 910: Fonction 'vars' 911: ================================================================================ 912: Entrées : 913: -------------------------------------------------------------------------------- 914: Sorties : 915: -------------------------------------------------------------------------------- 916: Effets de bord : néant 917: ================================================================================ 918: */ 919: 920: void 921: instruction_vars(struct_processus *s_etat_processus) 922: { 923: int i; 924: int nb_variables; 925: 926: logical1 variable_partagee; 927: 928: struct_liste_chainee *l_element_courant; 929: struct_liste_chainee *l_element_precedent; 930: 931: struct_objet *s_objet_resultat; 932: 933: struct_tableau_variables *tableau; 934: 935: (*s_etat_processus).erreur_execution = d_ex; 936: 937: if ((*s_etat_processus).affichage_arguments == 'Y') 938: { 939: printf("\n VARS "); 940: 941: if ((*s_etat_processus).langue == 'F') 942: { 943: printf("(liste des variables)\n\n"); 944: } 945: else 946: { 947: printf("(list of variables)\n\n"); 948: } 949: 950: printf("-> 1: %s\n", d_LST); 951: 952: return; 953: } 954: else if ((*s_etat_processus).test_instruction == 'Y') 955: { 956: (*s_etat_processus).nombre_arguments = -1; 957: return; 958: } 959: 960: if (test_cfsf(s_etat_processus, 31) == d_vrai) 961: { 962: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 963: { 964: return; 965: } 966: } 967: 968: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL) 969: { 970: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 971: return; 972: } 973: 974: (*s_objet_resultat).objet = NULL; 975: l_element_precedent = NULL; 976: 977: nb_variables = nombre_variables(s_etat_processus, 978: (*s_etat_processus).s_arbre_variables); 979: 980: if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables))) 981: == NULL) 982: { 983: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 984: return; 985: } 986: 987: liste_variables(s_etat_processus, tableau, 0, 988: (*s_etat_processus).s_arbre_variables); 989: 990: for(i = 0; i < nb_variables; i++) 991: { 992: if (l_element_precedent == NULL) 993: { 994: if (((*s_objet_resultat).objet = 995: allocation_maillon(s_etat_processus)) == NULL) 996: { 997: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 998: return; 999: } 1000: 1001: l_element_courant = (struct_liste_chainee *) 1002: (*s_objet_resultat).objet; 1003: (*l_element_courant).suivant = NULL; 1004: } 1005: else 1006: { 1007: if (((*l_element_precedent).suivant = 1008: allocation_maillon(s_etat_processus)) == NULL) 1009: { 1010: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1011: return; 1012: } 1013: 1014: l_element_courant = (*l_element_precedent).suivant; 1015: (*l_element_courant).suivant = NULL; 1016: } 1017: 1018: /* 1019: * Allocation de la liste incluse 1020: */ 1021: 1022: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST)) 1023: == NULL) 1024: { 1025: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1026: return; 1027: } 1028: 1029: if (((*((struct_objet *) (*l_element_courant).donnee)).objet = 1030: allocation_maillon(s_etat_processus)) == NULL) 1031: { 1032: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1033: return; 1034: } 1035: 1036: /* 1037: * Mise en place d'un verrou si la variable est partagée. 1038: */ 1039: 1040: if (tableau[i].objet == NULL) 1041: { 1042: if (pthread_mutex_lock(&((*(*s_etat_processus) 1043: .s_liste_variables_partagees).mutex)) != 0) 1044: { 1045: (*s_etat_processus).erreur_systeme = d_es_processus; 1046: return; 1047: } 1048: 1049: if (recherche_variable_partagee(s_etat_processus, 1050: tableau[i].nom, tableau[i].variable_partagee, 1051: tableau[i].origine) == d_faux) 1052: { 1053: // La variable partagée n'existe plus. 1054: 1055: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1056: .s_liste_variables_partagees).mutex)) != 0) 1057: { 1058: (*s_etat_processus).erreur_systeme = d_es_processus; 1059: return; 1060: } 1061: 1062: continue; 1063: } 1064: 1065: variable_partagee = d_vrai; 1066: } 1067: else 1068: { 1069: variable_partagee = d_faux; 1070: } 1071: 1072: /* 1073: * Mise en place du nom de la variable 1074: */ 1075: 1076: if (((*((struct_liste_chainee *) (*((struct_objet *) 1077: (*l_element_courant).donnee)).objet)).donnee = 1078: allocation(s_etat_processus, NOM)) == NULL) 1079: { 1080: if (variable_partagee == d_vrai) 1081: { 1082: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1083: .s_liste_variables_partagees).mutex)) != 0) 1084: { 1085: (*s_etat_processus).erreur_systeme = d_es_processus; 1086: return; 1087: } 1088: } 1089: 1090: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1091: return; 1092: } 1093: 1094: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *) 1095: (*l_element_courant).donnee)).objet)).donnee).objet)) 1096: .symbole = d_vrai; 1097: 1098: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *) 1099: (*l_element_courant).donnee)).objet)).donnee).objet)).nom = 1100: malloc((strlen(tableau[i].nom) 1101: + 1) * sizeof(unsigned char))) == NULL) 1102: { 1103: if (variable_partagee == d_vrai) 1104: { 1105: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1106: .s_liste_variables_partagees).mutex)) != 0) 1107: { 1108: (*s_etat_processus).erreur_systeme = d_es_processus; 1109: return; 1110: } 1111: } 1112: 1113: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1114: return; 1115: } 1116: 1117: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *) 1118: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1119: .donnee).objet)).nom, tableau[i].nom); 1120: 1121: /* 1122: * Préparation du niveau 1123: */ 1124: 1125: if (((*((struct_liste_chainee *) (*((struct_objet *) 1126: (*l_element_courant).donnee)).objet)).suivant = 1127: allocation_maillon(s_etat_processus)) == NULL) 1128: { 1129: if (variable_partagee == d_vrai) 1130: { 1131: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1132: .s_liste_variables_partagees).mutex)) != 0) 1133: { 1134: (*s_etat_processus).erreur_systeme = d_es_processus; 1135: return; 1136: } 1137: } 1138: 1139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1140: return; 1141: } 1142: 1143: if (((*(*((struct_liste_chainee *) (*((struct_objet *) 1144: (*l_element_courant).donnee)).objet)).suivant).donnee = 1145: allocation(s_etat_processus, INT)) == NULL) 1146: { 1147: if (variable_partagee == d_vrai) 1148: { 1149: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1150: .s_liste_variables_partagees).mutex)) != 0) 1151: { 1152: (*s_etat_processus).erreur_systeme = d_es_processus; 1153: return; 1154: } 1155: } 1156: 1157: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1158: return; 1159: } 1160: 1161: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *) 1162: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) = 1163: (integer8) tableau[i].niveau; 1164: 1165: /* 1166: * Préparation du contenu de la variable 1167: */ 1168: 1169: if (((*(*((struct_liste_chainee *) (*((struct_objet *) 1170: (*l_element_courant).donnee)).objet)).suivant).suivant = 1171: allocation_maillon(s_etat_processus)) == NULL) 1172: { 1173: if (variable_partagee == d_vrai) 1174: { 1175: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1176: .s_liste_variables_partagees).mutex)) != 0) 1177: { 1178: (*s_etat_processus).erreur_systeme = d_es_processus; 1179: return; 1180: } 1181: } 1182: 1183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1184: return; 1185: } 1186: 1187: if (tableau[i].objet == NULL) 1188: { 1189: // Variable partagée 1190: 1191: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) 1192: (*l_element_courant).donnee)).objet)).suivant).suivant) 1193: .donnee = copie_objet(s_etat_processus, 1194: (*(*s_etat_processus) 1195: .s_liste_variables_partagees).table[(*(*s_etat_processus) 1196: .s_liste_variables_partagees).position_variable].objet, 1197: 'P')) == NULL) 1198: { 1199: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1200: .s_liste_variables_partagees).mutex)) != 0) 1201: { 1202: (*s_etat_processus).erreur_systeme = d_es_processus; 1203: return; 1204: } 1205: 1206: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1207: return; 1208: } 1209: 1210: if (pthread_mutex_unlock(&((*(*s_etat_processus) 1211: .s_liste_variables_partagees).mutex)) != 0) 1212: { 1213: (*s_etat_processus).erreur_systeme = d_es_processus; 1214: return; 1215: } 1216: } 1217: else 1218: { 1219: // Variable privée 1220: 1221: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) 1222: (*l_element_courant).donnee)).objet)).suivant).suivant) 1223: .donnee = copie_objet(s_etat_processus, tableau[i].objet, 1224: 'P')) == NULL) 1225: { 1226: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1227: return; 1228: } 1229: } 1230: 1231: /* 1232: * Préparation du drapeau STATIC/VOLATILE 1233: */ 1234: 1235: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *) 1236: (*l_element_courant).donnee)).objet)).suivant).suivant) 1237: .suivant = allocation_maillon(s_etat_processus)) == NULL) 1238: { 1239: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1240: return; 1241: } 1242: 1243: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1244: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant) 1245: .donnee = allocation(s_etat_processus, CHN)) == NULL) 1246: { 1247: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1248: return; 1249: } 1250: 1251: if ((tableau[i].origine == 'P') 1252: ? (tableau[i].variable_statique.adresse != 0) 1253: : (tableau[i].variable_statique.pointeur != NULL)) 1254: { 1255: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1256: (*l_element_courant).donnee)).objet)).suivant).suivant) 1257: .suivant).donnee).objet = malloc(7 * 1258: sizeof(unsigned char))) == NULL) 1259: { 1260: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1261: return; 1262: } 1263: 1264: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *) 1265: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1266: .suivant).suivant) .suivant).donnee).objet, "STATIC"); 1267: } 1268: else 1269: { 1270: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1271: (*l_element_courant).donnee)).objet)).suivant).suivant) 1272: .suivant).donnee).objet = malloc(9 * 1273: sizeof(unsigned char))) == NULL) 1274: { 1275: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1276: return; 1277: } 1278: 1279: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *) 1280: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1281: .suivant).suivant) .suivant).donnee).objet, "VOLATILE"); 1282: } 1283: 1284: /* 1285: * Préparation du drapeau LOCKED/UNLOCKED 1286: */ 1287: 1288: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1289: (*l_element_courant).donnee)).objet)).suivant).suivant) 1290: .suivant).suivant = allocation_maillon(s_etat_processus)) 1291: == NULL) 1292: { 1293: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1294: return; 1295: } 1296: 1297: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1298: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant) 1299: .suivant).donnee = allocation(s_etat_processus, CHN)) 1300: == NULL) 1301: { 1302: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1303: return; 1304: } 1305: 1306: if (tableau[i].variable_verrouillee == d_vrai) 1307: { 1308: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1309: (*l_element_courant).donnee)).objet)).suivant).suivant) 1310: .suivant).suivant).donnee).objet = malloc(7 * 1311: sizeof(unsigned char))) == NULL) 1312: { 1313: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1314: return; 1315: } 1316: 1317: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *) 1318: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1319: .suivant).suivant).suivant).suivant).donnee).objet, 1320: "LOCKED"); 1321: } 1322: else 1323: { 1324: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1325: (*l_element_courant).donnee)).objet)).suivant).suivant) 1326: .suivant).suivant).donnee).objet = malloc(9 * 1327: sizeof(unsigned char))) == NULL) 1328: { 1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1330: return; 1331: } 1332: 1333: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *) 1334: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1335: .suivant).suivant).suivant).suivant).donnee).objet, 1336: "UNLOCKED"); 1337: } 1338: 1339: /* 1340: * Préparation du drapeau PRIVATE/SHARED 1341: */ 1342: 1343: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1344: (*l_element_courant).donnee)).objet)).suivant).suivant) 1345: .suivant).suivant).suivant = 1346: allocation_maillon(s_etat_processus)) == NULL) 1347: { 1348: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1349: return; 1350: } 1351: 1352: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1353: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant) 1354: .suivant).suivant).donnee = allocation(s_etat_processus, 1355: CHN)) == NULL) 1356: { 1357: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1358: return; 1359: } 1360: 1361: if (variable_partagee == d_vrai) 1362: { 1363: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1364: (*l_element_courant).donnee)).objet)).suivant).suivant) 1365: .suivant).suivant).suivant).donnee).objet = malloc(7 * 1366: sizeof(unsigned char))) == NULL) 1367: { 1368: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1369: return; 1370: } 1371: 1372: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *) 1373: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1374: .suivant).suivant).suivant).suivant).suivant).donnee).objet, 1375: "SHARED"); 1376: } 1377: else 1378: { 1379: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1380: (*l_element_courant).donnee)).objet)).suivant).suivant) 1381: .suivant).suivant).suivant).donnee).objet = malloc(8 * 1382: sizeof(unsigned char))) == NULL) 1383: { 1384: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1385: return; 1386: } 1387: 1388: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *) 1389: (*((struct_objet *) (*l_element_courant).donnee)).objet)) 1390: .suivant).suivant).suivant).suivant).suivant).donnee).objet, 1391: "PRIVATE"); 1392: } 1393: 1394: /* 1395: * Fermeture de la liste incluse 1396: */ 1397: 1398: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *) 1399: (*l_element_courant).donnee)).objet)).suivant).suivant) 1400: .suivant).suivant).suivant).suivant = NULL; 1401: 1402: l_element_precedent = l_element_courant; 1403: } 1404: 1405: free(tableau); 1406: 1407: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1408: s_objet_resultat) == d_erreur) 1409: { 1410: return; 1411: } 1412: 1413: return; 1414: } 1415: 1416: 1417: /* 1418: ================================================================================ 1419: Fonction 'visit' 1420: ================================================================================ 1421: Entrées : 1422: -------------------------------------------------------------------------------- 1423: Sorties : 1424: -------------------------------------------------------------------------------- 1425: Effets de bord : néant 1426: ================================================================================ 1427: */ 1428: 1429: void 1430: instruction_visit(struct_processus *s_etat_processus) 1431: { 1432: struct_liste_chainee *registre_pile_last; 1433: 1434: struct_objet *s_objet; 1435: 1436: unsigned long profondeur_initiale; 1437: 1438: (*s_etat_processus).erreur_execution = d_ex; 1439: 1440: if ((*s_etat_processus).affichage_arguments == 'Y') 1441: { 1442: printf("\n VISIT "); 1443: 1444: if ((*s_etat_processus).langue == 'F') 1445: { 1446: printf("(édition d'une variable)\n\n"); 1447: } 1448: else 1449: { 1450: printf("(edit variable)\n\n"); 1451: } 1452: 1453: printf(" 1: %s\n", d_NOM); 1454: 1455: return; 1456: } 1457: else if ((*s_etat_processus).test_instruction == 'Y') 1458: { 1459: (*s_etat_processus).nombre_arguments = -1; 1460: return; 1461: } 1462: 1463: registre_pile_last = NULL; 1464: 1465: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1466: { 1467: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1468: { 1469: return; 1470: } 1471: 1472: registre_pile_last = (*s_etat_processus).l_base_pile_last; 1473: (*s_etat_processus).l_base_pile_last = NULL; 1474: } 1475: 1476: if ((*s_etat_processus).l_base_pile == NULL) 1477: { 1478: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1479: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1480: return; 1481: } 1482: 1483: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM) 1484: { 1485: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1486: &s_objet) == d_erreur) 1487: { 1488: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1489: return; 1490: } 1491: 1492: liberation(s_etat_processus, s_objet); 1493: 1494: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1495: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1496: return; 1497: } 1498: 1499: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle; 1500: instruction_dup(s_etat_processus); 1501: 1502: if (((*s_etat_processus).erreur_systeme != d_es) || 1503: ((*s_etat_processus).erreur_execution != d_ex) || 1504: ((*s_etat_processus).exception != d_ep)) 1505: { 1506: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1507: { 1508: return; 1509: } 1510: 1511: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1512: 1513: return; 1514: } 1515: 1516: instruction_rcl(s_etat_processus); 1517: 1518: if (((*s_etat_processus).erreur_systeme != d_es) || 1519: ((*s_etat_processus).erreur_execution != d_ex) || 1520: ((*s_etat_processus).exception != d_ep)) 1521: { 1522: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1523: &s_objet) == d_erreur) 1524: { 1525: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1526: return; 1527: } 1528: 1529: liberation(s_etat_processus, s_objet); 1530: 1531: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1532: { 1533: return; 1534: } 1535: 1536: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1537: 1538: return; 1539: } 1540: 1541: instruction_edit(s_etat_processus); 1542: 1543: if (((*s_etat_processus).erreur_systeme != d_es) || 1544: ((*s_etat_processus).erreur_execution != d_ex) || 1545: ((*s_etat_processus).exception != d_ep)) 1546: { 1547: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1548: { 1549: return; 1550: } 1551: 1552: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1553: 1554: return; 1555: } 1556: 1557: while(profondeur_initiale != ((*s_etat_processus) 1558: .hauteur_pile_operationnelle - 1)) 1559: { 1560: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1561: &s_objet) == d_erreur) 1562: { 1563: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1564: return; 1565: } 1566: 1567: liberation(s_etat_processus, s_objet); 1568: } 1569: 1570: instruction_swap(s_etat_processus); 1571: 1572: if (((*s_etat_processus).erreur_systeme != d_es) || 1573: ((*s_etat_processus).erreur_execution != d_ex) || 1574: ((*s_etat_processus).exception != d_ep)) 1575: { 1576: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1577: { 1578: return; 1579: } 1580: 1581: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1582: 1583: return; 1584: } 1585: 1586: instruction_sto(s_etat_processus); 1587: 1588: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1589: { 1590: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1591: { 1592: return; 1593: } 1594: 1595: (*s_etat_processus).l_base_pile_last = registre_pile_last; 1596: } 1597: 1598: return; 1599: } 1600: 1601: 1602: /* 1603: ================================================================================ 1604: Fonction 'variable' 1605: ================================================================================ 1606: Entrées : 1607: -------------------------------------------------------------------------------- 1608: Sorties : 1609: -------------------------------------------------------------------------------- 1610: Effets de bord : néant 1611: ================================================================================ 1612: */ 1613: 1614: void 1615: instruction_variable(struct_processus *s_etat_processus) 1616: { 1617: struct_liste_chainee *l_element_courant; 1618: 1619: struct_objet *s_objet; 1620: 1621: (*s_etat_processus).erreur_execution = d_ex; 1622: 1623: if ((*s_etat_processus).affichage_arguments == 'Y') 1624: { 1625: printf("\n VARIABLE "); 1626: 1627: if ((*s_etat_processus).langue == 'F') 1628: { 1629: printf("(déverrouille une variable globale)\n\n"); 1630: } 1631: else 1632: { 1633: printf("(unlock a global variable)\n\n"); 1634: } 1635: 1636: printf(" 1: %s, %s\n", d_NOM, d_LST); 1637: 1638: return; 1639: } 1640: else if ((*s_etat_processus).test_instruction == 'Y') 1641: { 1642: (*s_etat_processus).nombre_arguments = -1; 1643: return; 1644: } 1645: 1646: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1647: { 1648: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1649: { 1650: return; 1651: } 1652: } 1653: 1654: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1655: &s_objet) == d_erreur) 1656: { 1657: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1658: return; 1659: } 1660: 1661: if ((*s_objet).type == NOM) 1662: { 1663: if (recherche_variable_globale(s_etat_processus, ((*((struct_nom *) 1664: (*s_objet).objet)).nom)) == d_faux) 1665: { 1666: liberation(s_etat_processus, s_objet); 1667: 1668: (*s_etat_processus).erreur_systeme = d_es; 1669: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 1670: return; 1671: } 1672: 1673: (*(*s_etat_processus).pointeur_variable_courante) 1674: .variable_verrouillee = d_faux; 1675: } 1676: else if ((*s_objet).type == LST) 1677: { 1678: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 1679: 1680: while(l_element_courant != NULL) 1681: { 1682: if ((*(*l_element_courant).donnee).type != NOM) 1683: { 1684: liberation(s_etat_processus, s_objet); 1685: 1686: (*s_etat_processus).erreur_execution = d_ex_nom_invalide; 1687: return; 1688: } 1689: 1690: if (recherche_variable_globale(s_etat_processus, (*((struct_nom *) 1691: (*(*l_element_courant).donnee).objet)).nom) == d_faux) 1692: { 1693: liberation(s_etat_processus, s_objet); 1694: 1695: (*s_etat_processus).erreur_systeme = d_es; 1696: (*s_etat_processus).erreur_execution = 1697: d_ex_variable_non_definie; 1698: return; 1699: } 1700: 1701: (*(*s_etat_processus).pointeur_variable_courante) 1702: .variable_verrouillee = d_faux; 1703: 1704: l_element_courant = (*l_element_courant).suivant; 1705: } 1706: } 1707: else 1708: { 1709: liberation(s_etat_processus, s_objet); 1710: 1711: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1712: return; 1713: } 1714: 1715: liberation(s_etat_processus, s_objet); 1716: 1717: return; 1718: } 1719: 1720: // vim: ts=4