Annotation of rpl/src/instructions_v1.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 '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: logical1 presence_variable;
! 42:
! 43: long i;
! 44:
! 45: struct_objet *s_objet_statistique;
! 46: struct_objet *s_objet_resultat;
! 47: struct_objet *s_objet_temporaire;
! 48:
! 49: unsigned long nombre_colonnes;
! 50:
! 51: (*s_etat_processus).erreur_execution = d_ex;
! 52:
! 53: if ((*s_etat_processus).affichage_arguments == 'Y')
! 54: {
! 55: printf("\n VAR ");
! 56:
! 57: if ((*s_etat_processus).langue == 'F')
! 58: {
! 59: printf("(variance)\n\n");
! 60: }
! 61: else
! 62: {
! 63: printf("(variance)\n\n");
! 64: }
! 65:
! 66: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
! 67:
! 68: return;
! 69: }
! 70: else if ((*s_etat_processus).test_instruction == 'Y')
! 71: {
! 72: (*s_etat_processus).nombre_arguments = -1;
! 73: return;
! 74: }
! 75:
! 76: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 77: {
! 78: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 79: {
! 80: return;
! 81: }
! 82: }
! 83:
! 84: /*
! 85: * Recherche d'une variable globale référencée par SIGMA
! 86: */
! 87:
! 88: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
! 89: {
! 90: /*
! 91: * Aucune variable SIGMA
! 92: */
! 93:
! 94: (*s_etat_processus).erreur_systeme = d_es;
! 95: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 96: return;
! 97: }
! 98: else
! 99: {
! 100: /*
! 101: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
! 102: * d'une variable SIGMA globale...
! 103: */
! 104:
! 105: i = (*s_etat_processus).position_variable_courante;
! 106: presence_variable = d_faux;
! 107:
! 108: while(i >= 0)
! 109: {
! 110: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 111: ds_sdat) == 0) && ((*s_etat_processus)
! 112: .s_liste_variables[i].niveau == 1))
! 113: {
! 114: presence_variable = d_vrai;
! 115: break;
! 116: }
! 117:
! 118: i--;
! 119: }
! 120:
! 121: if (presence_variable == d_faux)
! 122: {
! 123: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 124: return;
! 125: }
! 126: else
! 127: {
! 128: (*s_etat_processus).position_variable_courante = i;
! 129:
! 130: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 131: {
! 132: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 133: return;
! 134: }
! 135:
! 136: if (((*((*s_etat_processus).s_liste_variables
! 137: [(*s_etat_processus).position_variable_courante].objet))
! 138: .type != MIN) && ((*((*s_etat_processus)
! 139: .s_liste_variables[(*s_etat_processus)
! 140: .position_variable_courante].objet)).type != MRL))
! 141: {
! 142: (*s_etat_processus).erreur_execution =
! 143: d_ex_matrice_statistique_invalide;
! 144: return;
! 145: }
! 146:
! 147: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
! 148: .s_liste_variables[(*s_etat_processus)
! 149: .position_variable_courante].objet)).objet))
! 150: .nombre_colonnes;
! 151: }
! 152: }
! 153:
! 154: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 155: [(*s_etat_processus).position_variable_courante]).objet;
! 156:
! 157: if (((*s_objet_statistique).type == MIN) ||
! 158: ((*s_objet_statistique).type == MRL))
! 159: {
! 160: if ((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_lignes
! 161: <= 1)
! 162: {
! 163: (*s_etat_processus).erreur_execution =
! 164: d_ex_statistiques_echantillon;
! 165: return;
! 166: }
! 167:
! 168: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
! 169: {
! 170: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 171: return;
! 172: }
! 173:
! 174: if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *)
! 175: (*s_objet_statistique).objet, 'E')) == NULL)
! 176: {
! 177: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 178: return;
! 179: }
! 180:
! 181: if (nombre_colonnes == 1)
! 182: {
! 183: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
! 184: {
! 185: (*s_objet_resultat).type = VIN;
! 186: s_objet_temporaire = s_objet_resultat;
! 187:
! 188: if ((s_objet_resultat = allocation(s_etat_processus, INT))
! 189: == NULL)
! 190: {
! 191: (*s_etat_processus).erreur_systeme =
! 192: d_es_allocation_memoire;
! 193: return;
! 194: }
! 195:
! 196: (*((integer8 *) (*s_objet_resultat).objet)) =
! 197: ((integer8 *) (*((struct_vecteur *)
! 198: (*s_objet_temporaire).objet)).tableau)[0];
! 199:
! 200: liberation(s_etat_processus, s_objet_temporaire);
! 201: }
! 202: else
! 203: {
! 204: (*s_objet_resultat).type = VRL;
! 205: s_objet_temporaire = s_objet_resultat;
! 206:
! 207: if ((s_objet_resultat = allocation(s_etat_processus, REL))
! 208: == NULL)
! 209: {
! 210: (*s_etat_processus).erreur_systeme =
! 211: d_es_allocation_memoire;
! 212: return;
! 213: }
! 214:
! 215: (*((real8 *) (*s_objet_resultat).objet)) =
! 216: ((real8 *) (*((struct_vecteur *)
! 217: (*s_objet_temporaire).objet)).tableau)[0];
! 218:
! 219: liberation(s_etat_processus, s_objet_temporaire);
! 220: }
! 221: }
! 222: else
! 223: {
! 224: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I')
! 225: {
! 226: (*s_objet_resultat).type = VIN;
! 227: }
! 228: else
! 229: {
! 230: (*s_objet_resultat).type = VRL;
! 231: }
! 232: }
! 233:
! 234: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 235: s_objet_resultat) == d_erreur)
! 236: {
! 237: return;
! 238: }
! 239: }
! 240: else
! 241: {
! 242: (*s_etat_processus).erreur_execution =
! 243: d_ex_matrice_statistique_invalide;
! 244: return;
! 245: }
! 246:
! 247: return;
! 248: }
! 249:
! 250:
! 251: /*
! 252: ================================================================================
! 253: Fonction 'version'
! 254: ================================================================================
! 255: Entrées :
! 256: --------------------------------------------------------------------------------
! 257: Sorties :
! 258: --------------------------------------------------------------------------------
! 259: Effets de bord : néant
! 260: ================================================================================
! 261: */
! 262:
! 263: void
! 264: instruction_version(struct_processus *s_etat_processus)
! 265: {
! 266: int nombre_champs;
! 267:
! 268: integer8 i1;
! 269: integer8 i2;
! 270: integer8 i3;
! 271: integer8 i4;
! 272:
! 273: struct_liste_chainee *l_element_courant;
! 274: struct_liste_chainee *l_element_interne_courant;
! 275:
! 276: struct_objet *s_objet_resultat;
! 277:
! 278: unsigned char texte[] = "RPL/2 version ";
! 279:
! 280: (*s_etat_processus).erreur_execution = d_ex;
! 281:
! 282: if ((*s_etat_processus).affichage_arguments == 'Y')
! 283: {
! 284: printf("\n VERSION ");
! 285:
! 286: if ((*s_etat_processus).langue == 'F')
! 287: {
! 288: printf("(version du séquenceur)\n\n");
! 289: }
! 290: else
! 291: {
! 292: printf("(sequencer version)\n\n");
! 293: }
! 294:
! 295: printf("-> 1: %s\n", d_LST);
! 296:
! 297: return;
! 298: }
! 299: else if ((*s_etat_processus).test_instruction == 'Y')
! 300: {
! 301: (*s_etat_processus).nombre_arguments = -1;
! 302: return;
! 303: }
! 304:
! 305: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 306: {
! 307: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 308: {
! 309: return;
! 310: }
! 311: }
! 312:
! 313: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
! 314: {
! 315: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 316: return;
! 317: }
! 318:
! 319: if (((*s_objet_resultat).objet = allocation_maillon(s_etat_processus))
! 320: == NULL)
! 321: {
! 322: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 323: return;
! 324: }
! 325:
! 326: l_element_courant = (struct_liste_chainee *) (*s_objet_resultat).objet;
! 327: (*l_element_courant).suivant = NULL;
! 328:
! 329: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
! 330: == NULL)
! 331: {
! 332: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 333: return;
! 334: }
! 335:
! 336: if (((*(*l_element_courant).donnee).objet = malloc((strlen(texte)
! 337: + strlen(d_version_rpl) + 1) * sizeof(unsigned char))) == NULL)
! 338: {
! 339: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 340: return;
! 341: }
! 342:
! 343: sprintf((unsigned char *) (*(*l_element_courant).donnee).objet, "%s%s",
! 344: texte, d_version_rpl);
! 345:
! 346: /*
! 347: * Ajout des versions X.Y.Z sous forme d'entiers
! 348: */
! 349:
! 350: i1 = 0;
! 351: i2 = 0;
! 352: i3 = 0;
! 353: i4 = 0;
! 354:
! 355: nombre_champs = sscanf(d_version_rpl, "%lld.%lld.%lld.prerelease.%lld",
! 356: &i1, &i2, &i3, &i4);
! 357:
! 358: if (((*l_element_courant).suivant =
! 359: allocation_maillon(s_etat_processus)) == NULL)
! 360: {
! 361: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 362: return;
! 363: }
! 364:
! 365: l_element_courant = (*l_element_courant).suivant;
! 366: (*l_element_courant).suivant = NULL;
! 367:
! 368: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 369: == NULL)
! 370: {
! 371: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 372: return;
! 373: }
! 374:
! 375: if (((*(*l_element_courant).donnee).objet =
! 376: allocation_maillon(s_etat_processus)) == NULL)
! 377: {
! 378: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 379: return;
! 380: }
! 381:
! 382: l_element_interne_courant = (struct_liste_chainee *)
! 383: (*(*l_element_courant).donnee).objet;
! 384:
! 385: (*l_element_interne_courant).suivant = NULL;
! 386:
! 387: if (((*l_element_interne_courant).donnee =
! 388: allocation(s_etat_processus, INT)) == NULL)
! 389: {
! 390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 391: return;
! 392: }
! 393:
! 394: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i1;
! 395:
! 396: if (((*l_element_interne_courant).suivant =
! 397: allocation_maillon(s_etat_processus)) == NULL)
! 398: {
! 399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 400: return;
! 401: }
! 402:
! 403: l_element_interne_courant = (*l_element_interne_courant).suivant;
! 404: (*l_element_interne_courant).suivant = NULL;
! 405:
! 406: if (((*l_element_interne_courant).donnee =
! 407: allocation(s_etat_processus, INT)) == NULL)
! 408: {
! 409: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 410: return;
! 411: }
! 412:
! 413: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i2;
! 414:
! 415: if (((*l_element_interne_courant).suivant =
! 416: allocation_maillon(s_etat_processus)) == NULL)
! 417: {
! 418: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 419: return;
! 420: }
! 421:
! 422: l_element_interne_courant = (*l_element_interne_courant).suivant;
! 423: (*l_element_interne_courant).suivant = NULL;
! 424:
! 425: if (((*l_element_interne_courant).donnee =
! 426: allocation(s_etat_processus, INT)) == NULL)
! 427: {
! 428: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 429: return;
! 430: }
! 431:
! 432: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i3;
! 433:
! 434: /*
! 435: * Ajout de "PRERELEASE" suivi d'un entier ou de "RELEASE"
! 436: */
! 437:
! 438: if (nombre_champs == 3)
! 439: {
! 440: // Version "RELEASE"
! 441:
! 442: if (((*l_element_interne_courant).suivant =
! 443: allocation_maillon(s_etat_processus)) == NULL)
! 444: {
! 445: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 446: return;
! 447: }
! 448:
! 449: l_element_interne_courant = (*l_element_interne_courant).suivant;
! 450: (*l_element_interne_courant).suivant = NULL;
! 451:
! 452: if (((*l_element_interne_courant).donnee =
! 453: allocation(s_etat_processus, CHN)) == NULL)
! 454: {
! 455: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 456: return;
! 457: }
! 458:
! 459: if (((*(*l_element_interne_courant).donnee).objet = malloc(8 *
! 460: sizeof(unsigned char))) == NULL)
! 461: {
! 462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 463: return;
! 464: }
! 465:
! 466: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
! 467: "RELEASE");
! 468: }
! 469: else
! 470: {
! 471: // Version "PRERELEASE"
! 472:
! 473: if (((*l_element_interne_courant).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_interne_courant = (*l_element_interne_courant).suivant;
! 481: (*l_element_interne_courant).suivant = NULL;
! 482:
! 483: if (((*l_element_interne_courant).donnee =
! 484: allocation(s_etat_processus, CHN)) == NULL)
! 485: {
! 486: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 487: return;
! 488: }
! 489:
! 490: if (((*(*l_element_interne_courant).donnee).objet = malloc(11 *
! 491: sizeof(unsigned char))) == NULL)
! 492: {
! 493: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 494: return;
! 495: }
! 496:
! 497: strcpy((unsigned char *) (*(*l_element_interne_courant).donnee).objet,
! 498: "PRERELEASE");
! 499:
! 500: if (((*l_element_interne_courant).suivant =
! 501: allocation_maillon(s_etat_processus)) == NULL)
! 502: {
! 503: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 504: return;
! 505: }
! 506:
! 507: l_element_interne_courant = (*l_element_interne_courant).suivant;
! 508: (*l_element_interne_courant).suivant = NULL;
! 509:
! 510: if (((*l_element_interne_courant).donnee =
! 511: allocation(s_etat_processus, INT)) == NULL)
! 512: {
! 513: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 514: return;
! 515: }
! 516:
! 517: (*((integer8 *) (*(*l_element_interne_courant).donnee).objet)) = i4;
! 518: }
! 519:
! 520: /*
! 521: * Ajout de la date de compilation
! 522: */
! 523:
! 524: if (((*l_element_courant).suivant =
! 525: allocation_maillon(s_etat_processus)) == NULL)
! 526: {
! 527: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 528: return;
! 529: }
! 530:
! 531: l_element_courant = (*l_element_courant).suivant;
! 532: (*l_element_courant).suivant = NULL;
! 533:
! 534: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
! 535: == NULL)
! 536: {
! 537: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 538: return;
! 539: }
! 540:
! 541: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)
! 542: + 1) * sizeof(unsigned char))) == NULL)
! 543: {
! 544: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 545: return;
! 546: }
! 547:
! 548: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
! 549: d_date_en_rpl);
! 550:
! 551: /*
! 552: * Ajout des options de compilation
! 553: */
! 554:
! 555: if (((*l_element_courant).suivant =
! 556: allocation_maillon(s_etat_processus)) == NULL)
! 557: {
! 558: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 559: return;
! 560: }
! 561:
! 562: l_element_courant = (*l_element_courant).suivant;
! 563: (*l_element_courant).suivant = NULL;
! 564:
! 565: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
! 566: == NULL)
! 567: {
! 568: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 569: return;
! 570: }
! 571:
! 572: if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_exec_path)
! 573: + 1) * sizeof(unsigned char))) == NULL)
! 574: {
! 575: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 576: return;
! 577: }
! 578:
! 579: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
! 580: d_exec_path);
! 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 GNUPLOT_SUPPORT
! 600: if (((*(*l_element_courant).donnee).objet = malloc(8 *
! 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: "GNUPLOT");
! 609: #else
! 610: if (((*(*l_element_courant).donnee).objet = malloc(17 *
! 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: "GNUPLOT DISABLED");
! 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 FORCE_GNUPLOT_PATH
! 639: if (((*(*l_element_courant).donnee).objet = malloc(19 *
! 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: "FORCE GNUPLOT PATH");
! 648: #else
! 649: if (((*(*l_element_courant).donnee).objet = malloc(21 *
! 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: "DEFAULT GNUPLOT PATH");
! 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 POSTSCRIPT_SUPPORT
! 678: if (((*(*l_element_courant).donnee).objet = malloc(11 *
! 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: "POSTSCRIPT");
! 687: #else
! 688: if (((*(*l_element_courant).donnee).objet = malloc(20 *
! 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: "POSTSCRIPT 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 VIM_SUPPORT
! 717: if (((*(*l_element_courant).donnee).objet = malloc(4 *
! 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: "VIM");
! 726: #else
! 727: if (((*(*l_element_courant).donnee).objet = malloc(13 *
! 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: "VIM 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 MYSQL_SUPPORT
! 756: if (((*(*l_element_courant).donnee).objet = malloc(6 *
! 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: "MYSQL");
! 765: #else
! 766: if (((*(*l_element_courant).donnee).objet = malloc(15 *
! 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: "MYSQL 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 POSTGRESQL_SUPPORT
! 795: if (((*(*l_element_courant).donnee).objet = malloc(11 *
! 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: "POSTGRESQL");
! 804: #else
! 805: if (((*(*l_element_courant).donnee).objet = malloc(20 *
! 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: "POSTGRESQL 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 MOTIF_SUPPORT
! 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: "MOTIF");
! 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: "MOTIF 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 DEBUG
! 873: if (((*(*l_element_courant).donnee).objet = malloc(6 *
! 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: "DEBUG");
! 882: #else
! 883: if (((*(*l_element_courant).donnee).objet = malloc(15 *
! 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: "DEBUG DISABLED");
! 892: #endif
! 893:
! 894: if (((*l_element_courant).suivant =
! 895: allocation_maillon(s_etat_processus)) == NULL)
! 896: {
! 897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 898: return;
! 899: }
! 900:
! 901: l_element_courant = (*l_element_courant).suivant;
! 902: (*l_element_courant).suivant = NULL;
! 903:
! 904: if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
! 905: == NULL)
! 906: {
! 907: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 908: return;
! 909: }
! 910:
! 911: #ifdef EXPERIMENTAL_CODE
! 912: if (((*(*l_element_courant).donnee).objet = malloc(18 *
! 913: sizeof(unsigned char))) == NULL)
! 914: {
! 915: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 916: return;
! 917: }
! 918:
! 919: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
! 920: "EXPERIMENTAL CODE");
! 921: #else
! 922: if (((*(*l_element_courant).donnee).objet = malloc(27 *
! 923: sizeof(unsigned char))) == NULL)
! 924: {
! 925: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 926: return;
! 927: }
! 928:
! 929: strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
! 930: "EXPERIMENTAL CODE DISABLED");
! 931: #endif
! 932:
! 933: /*
! 934: * Empilement du résultat
! 935: */
! 936:
! 937: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 938: s_objet_resultat) == d_erreur)
! 939: {
! 940: return;
! 941: }
! 942:
! 943: return;
! 944: }
! 945:
! 946:
! 947: /*
! 948: ================================================================================
! 949: Fonction 'vars'
! 950: ================================================================================
! 951: Entrées :
! 952: --------------------------------------------------------------------------------
! 953: Sorties :
! 954: --------------------------------------------------------------------------------
! 955: Effets de bord : néant
! 956: ================================================================================
! 957: */
! 958:
! 959: void
! 960: instruction_vars(struct_processus *s_etat_processus)
! 961: {
! 962: logical1 variable_partagee;
! 963:
! 964: struct_liste_chainee *l_element_courant;
! 965: struct_liste_chainee *l_element_precedent;
! 966:
! 967: struct_objet *s_objet_resultat;
! 968:
! 969: unsigned long i;
! 970:
! 971: (*s_etat_processus).erreur_execution = d_ex;
! 972:
! 973: if ((*s_etat_processus).affichage_arguments == 'Y')
! 974: {
! 975: printf("\n VARS ");
! 976:
! 977: if ((*s_etat_processus).langue == 'F')
! 978: {
! 979: printf("(liste des variables)\n\n");
! 980: }
! 981: else
! 982: {
! 983: printf("(list of variables)\n\n");
! 984: }
! 985:
! 986: printf("-> 1: %s\n", d_LST);
! 987:
! 988: return;
! 989: }
! 990: else if ((*s_etat_processus).test_instruction == 'Y')
! 991: {
! 992: (*s_etat_processus).nombre_arguments = -1;
! 993: return;
! 994: }
! 995:
! 996: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 997: {
! 998: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 999: {
! 1000: return;
! 1001: }
! 1002: }
! 1003:
! 1004: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
! 1005: {
! 1006: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1007: return;
! 1008: }
! 1009:
! 1010: (*s_objet_resultat).objet = NULL;
! 1011: l_element_precedent = NULL;
! 1012:
! 1013: for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
! 1014: {
! 1015: if (l_element_precedent == NULL)
! 1016: {
! 1017: if (((*s_objet_resultat).objet =
! 1018: allocation_maillon(s_etat_processus)) == NULL)
! 1019: {
! 1020: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1021: return;
! 1022: }
! 1023:
! 1024: l_element_courant = (struct_liste_chainee *)
! 1025: (*s_objet_resultat).objet;
! 1026: (*l_element_courant).suivant = NULL;
! 1027: }
! 1028: else
! 1029: {
! 1030: if (((*l_element_precedent).suivant =
! 1031: allocation_maillon(s_etat_processus)) == NULL)
! 1032: {
! 1033: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1034: return;
! 1035: }
! 1036:
! 1037: l_element_courant = (*l_element_precedent).suivant;
! 1038: (*l_element_courant).suivant = NULL;
! 1039: }
! 1040:
! 1041: /*
! 1042: * Allocation de la liste incluse
! 1043: */
! 1044:
! 1045: if (((*l_element_courant).donnee = allocation(s_etat_processus, LST))
! 1046: == NULL)
! 1047: {
! 1048: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1049: return;
! 1050: }
! 1051:
! 1052: if (((*((struct_objet *) (*l_element_courant).donnee)).objet =
! 1053: allocation_maillon(s_etat_processus)) == NULL)
! 1054: {
! 1055: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1056: return;
! 1057: }
! 1058:
! 1059: /*
! 1060: * Mise en place d'un verrou si la variable est partagée.
! 1061: */
! 1062:
! 1063: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 1064: {
! 1065: if (pthread_mutex_lock(&((*(*s_etat_processus)
! 1066: .s_liste_variables_partagees).mutex)) != 0)
! 1067: {
! 1068: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1069: return;
! 1070: }
! 1071:
! 1072: if (recherche_variable_partagee(s_etat_processus,
! 1073: ((*s_etat_processus).s_liste_variables[i]).nom,
! 1074: ((*s_etat_processus).s_liste_variables[i])
! 1075: .variable_partagee, ((*s_etat_processus)
! 1076: .s_liste_variables[i]).origine) == d_faux)
! 1077: {
! 1078: // La variable partagée n'existe plus.
! 1079:
! 1080: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1081: .s_liste_variables_partagees).mutex)) != 0)
! 1082: {
! 1083: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1084: return;
! 1085: }
! 1086:
! 1087: continue;
! 1088: }
! 1089:
! 1090: variable_partagee = d_vrai;
! 1091: }
! 1092: else
! 1093: {
! 1094: variable_partagee = d_faux;
! 1095: }
! 1096:
! 1097: /*
! 1098: * Mise en place du nom de la variable
! 1099: */
! 1100:
! 1101: if (((*((struct_liste_chainee *) (*((struct_objet *)
! 1102: (*l_element_courant).donnee)).objet)).donnee =
! 1103: allocation(s_etat_processus, NOM)) == NULL)
! 1104: {
! 1105: if (variable_partagee == d_vrai)
! 1106: {
! 1107: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1108: .s_liste_variables_partagees).mutex)) != 0)
! 1109: {
! 1110: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1111: return;
! 1112: }
! 1113: }
! 1114:
! 1115: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1116: return;
! 1117: }
! 1118:
! 1119: (*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
! 1120: (*l_element_courant).donnee)).objet)).donnee).objet))
! 1121: .symbole = d_vrai;
! 1122:
! 1123: if (((*((struct_nom *) (*(*((struct_liste_chainee *) (*((struct_objet *)
! 1124: (*l_element_courant).donnee)).objet)).donnee).objet)).nom =
! 1125: malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
! 1126: + 1) * sizeof(unsigned char))) == NULL)
! 1127: {
! 1128: if (variable_partagee == d_vrai)
! 1129: {
! 1130: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1131: .s_liste_variables_partagees).mutex)) != 0)
! 1132: {
! 1133: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1134: return;
! 1135: }
! 1136: }
! 1137:
! 1138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1139: return;
! 1140: }
! 1141:
! 1142: strcpy((*((struct_nom *) (*(*((struct_liste_chainee *)
! 1143: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1144: .donnee).objet)).nom, (*s_etat_processus)
! 1145: .s_liste_variables[i].nom);
! 1146:
! 1147: /*
! 1148: * Préparation du niveau
! 1149: */
! 1150:
! 1151: if (((*((struct_liste_chainee *) (*((struct_objet *)
! 1152: (*l_element_courant).donnee)).objet)).suivant =
! 1153: allocation_maillon(s_etat_processus)) == NULL)
! 1154: {
! 1155: if (variable_partagee == d_vrai)
! 1156: {
! 1157: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1158: .s_liste_variables_partagees).mutex)) != 0)
! 1159: {
! 1160: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1161: return;
! 1162: }
! 1163: }
! 1164:
! 1165: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1166: return;
! 1167: }
! 1168:
! 1169: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
! 1170: (*l_element_courant).donnee)).objet)).suivant).donnee =
! 1171: allocation(s_etat_processus, INT)) == 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: (*((integer8 *) (*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1188: (*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
! 1189: (integer8) (*s_etat_processus).s_liste_variables[i].niveau;
! 1190:
! 1191: /*
! 1192: * Préparation du contenu de la variable
! 1193: */
! 1194:
! 1195: if (((*(*((struct_liste_chainee *) (*((struct_objet *)
! 1196: (*l_element_courant).donnee)).objet)).suivant).suivant =
! 1197: allocation_maillon(s_etat_processus)) == NULL)
! 1198: {
! 1199: if (variable_partagee == d_vrai)
! 1200: {
! 1201: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1202: .s_liste_variables_partagees).mutex)) != 0)
! 1203: {
! 1204: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1205: return;
! 1206: }
! 1207: }
! 1208:
! 1209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1210: return;
! 1211: }
! 1212:
! 1213: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 1214: {
! 1215: // Variable partagée
! 1216:
! 1217: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1218: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1219: .donnee = copie_objet(s_etat_processus,
! 1220: (*(*s_etat_processus)
! 1221: .s_liste_variables_partagees).table[(*(*s_etat_processus)
! 1222: .s_liste_variables_partagees).position_variable].objet,
! 1223: 'P')) == NULL)
! 1224: {
! 1225: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1226: .s_liste_variables_partagees).mutex)) != 0)
! 1227: {
! 1228: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1229: return;
! 1230: }
! 1231:
! 1232: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1233: return;
! 1234: }
! 1235:
! 1236: if (pthread_mutex_unlock(&((*(*s_etat_processus)
! 1237: .s_liste_variables_partagees).mutex)) != 0)
! 1238: {
! 1239: (*s_etat_processus).erreur_systeme = d_es_processus;
! 1240: return;
! 1241: }
! 1242: }
! 1243: else
! 1244: {
! 1245: // Variable privée
! 1246:
! 1247: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1248: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1249: .donnee = copie_objet(s_etat_processus, (*s_etat_processus)
! 1250: .s_liste_variables[i].objet, 'P')) == NULL)
! 1251: {
! 1252: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1253: return;
! 1254: }
! 1255: }
! 1256:
! 1257: /*
! 1258: * Préparation du drapeau STATIC/VOLATILE
! 1259: */
! 1260:
! 1261: if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1262: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1263: .suivant = allocation_maillon(s_etat_processus)) == NULL)
! 1264: {
! 1265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1266: return;
! 1267: }
! 1268:
! 1269: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1270: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
! 1271: .donnee = allocation(s_etat_processus, CHN)) == NULL)
! 1272: {
! 1273: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1274: return;
! 1275: }
! 1276:
! 1277: if (((*s_etat_processus).s_liste_variables[i].origine == 'P')
! 1278: ? ((*s_etat_processus).s_liste_variables[i]
! 1279: .variable_statique.adresse != 0)
! 1280: : ((*s_etat_processus).s_liste_variables[i]
! 1281: .variable_statique.pointeur != NULL))
! 1282: {
! 1283: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1284: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1285: .suivant).donnee).objet = malloc(7 *
! 1286: sizeof(unsigned char))) == NULL)
! 1287: {
! 1288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1289: return;
! 1290: }
! 1291:
! 1292: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
! 1293: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1294: .suivant).suivant) .suivant).donnee).objet, "STATIC");
! 1295: }
! 1296: else
! 1297: {
! 1298: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1299: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1300: .suivant).donnee).objet = malloc(9 *
! 1301: sizeof(unsigned char))) == NULL)
! 1302: {
! 1303: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1304: return;
! 1305: }
! 1306:
! 1307: strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
! 1308: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1309: .suivant).suivant) .suivant).donnee).objet, "VOLATILE");
! 1310: }
! 1311:
! 1312: /*
! 1313: * Préparation du drapeau LOCKED/UNLOCKED
! 1314: */
! 1315:
! 1316: if (((*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1317: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1318: .suivant).suivant = allocation_maillon(s_etat_processus))
! 1319: == NULL)
! 1320: {
! 1321: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1322: return;
! 1323: }
! 1324:
! 1325: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1326: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
! 1327: .suivant).donnee = allocation(s_etat_processus, CHN))
! 1328: == NULL)
! 1329: {
! 1330: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1331: return;
! 1332: }
! 1333:
! 1334: if ((*s_etat_processus).s_liste_variables[i].variable_verrouillee
! 1335: == d_vrai)
! 1336: {
! 1337: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1338: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1339: .suivant).suivant).donnee).objet = malloc(7 *
! 1340: sizeof(unsigned char))) == NULL)
! 1341: {
! 1342: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1343: return;
! 1344: }
! 1345:
! 1346: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
! 1347: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1348: .suivant).suivant).suivant).suivant).donnee).objet,
! 1349: "LOCKED");
! 1350: }
! 1351: else
! 1352: {
! 1353: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1354: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1355: .suivant).suivant).donnee).objet = malloc(9 *
! 1356: sizeof(unsigned char))) == NULL)
! 1357: {
! 1358: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1359: return;
! 1360: }
! 1361:
! 1362: strcpy((unsigned char *) (*(*(*(*(*(*((struct_liste_chainee *)
! 1363: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1364: .suivant).suivant).suivant).suivant).donnee).objet,
! 1365: "UNLOCKED");
! 1366: }
! 1367:
! 1368: /*
! 1369: * Préparation du drapeau PRIVATE/SHARED
! 1370: */
! 1371:
! 1372: if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1373: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1374: .suivant).suivant).suivant =
! 1375: allocation_maillon(s_etat_processus)) == NULL)
! 1376: {
! 1377: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1378: return;
! 1379: }
! 1380:
! 1381: if (((*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1382: (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
! 1383: .suivant).suivant).donnee = allocation(s_etat_processus,
! 1384: CHN)) == NULL)
! 1385: {
! 1386: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1387: return;
! 1388: }
! 1389:
! 1390: if (variable_partagee == d_vrai)
! 1391: {
! 1392: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1393: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1394: .suivant).suivant).suivant).donnee).objet = malloc(7 *
! 1395: sizeof(unsigned char))) == NULL)
! 1396: {
! 1397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1398: return;
! 1399: }
! 1400:
! 1401: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
! 1402: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1403: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
! 1404: "SHARED");
! 1405: }
! 1406: else
! 1407: {
! 1408: if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1409: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1410: .suivant).suivant).suivant).donnee).objet = malloc(8 *
! 1411: sizeof(unsigned char))) == NULL)
! 1412: {
! 1413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1414: return;
! 1415: }
! 1416:
! 1417: strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
! 1418: (*((struct_objet *) (*l_element_courant).donnee)).objet))
! 1419: .suivant).suivant).suivant).suivant).suivant).donnee).objet,
! 1420: "PRIVATE");
! 1421: }
! 1422:
! 1423: /*
! 1424: * Fermeture de la liste incluse
! 1425: */
! 1426:
! 1427: (*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
! 1428: (*l_element_courant).donnee)).objet)).suivant).suivant)
! 1429: .suivant).suivant).suivant).suivant = NULL;
! 1430:
! 1431: l_element_precedent = l_element_courant;
! 1432: }
! 1433:
! 1434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1435: s_objet_resultat) == d_erreur)
! 1436: {
! 1437: return;
! 1438: }
! 1439:
! 1440: return;
! 1441: }
! 1442:
! 1443:
! 1444: /*
! 1445: ================================================================================
! 1446: Fonction 'visit'
! 1447: ================================================================================
! 1448: Entrées :
! 1449: --------------------------------------------------------------------------------
! 1450: Sorties :
! 1451: --------------------------------------------------------------------------------
! 1452: Effets de bord : néant
! 1453: ================================================================================
! 1454: */
! 1455:
! 1456: void
! 1457: instruction_visit(struct_processus *s_etat_processus)
! 1458: {
! 1459: struct_liste_chainee *registre_pile_last;
! 1460:
! 1461: struct_objet *s_objet;
! 1462:
! 1463: unsigned long profondeur_initiale;
! 1464:
! 1465: (*s_etat_processus).erreur_execution = d_ex;
! 1466:
! 1467: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1468: {
! 1469: printf("\n VISIT ");
! 1470:
! 1471: if ((*s_etat_processus).langue == 'F')
! 1472: {
! 1473: printf("(édition d'une variable)\n\n");
! 1474: }
! 1475: else
! 1476: {
! 1477: printf("(edit variable)\n\n");
! 1478: }
! 1479:
! 1480: printf(" 1: %s\n", d_NOM);
! 1481:
! 1482: return;
! 1483: }
! 1484: else if ((*s_etat_processus).test_instruction == 'Y')
! 1485: {
! 1486: (*s_etat_processus).nombre_arguments = -1;
! 1487: return;
! 1488: }
! 1489:
! 1490: registre_pile_last = NULL;
! 1491:
! 1492: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1493: {
! 1494: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1495: {
! 1496: return;
! 1497: }
! 1498:
! 1499: registre_pile_last = (*s_etat_processus).l_base_pile_last;
! 1500: (*s_etat_processus).l_base_pile_last = NULL;
! 1501: }
! 1502:
! 1503: if ((*s_etat_processus).l_base_pile == NULL)
! 1504: {
! 1505: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1506: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1507: return;
! 1508: }
! 1509:
! 1510: if ((*(*(*s_etat_processus).l_base_pile).donnee).type != NOM)
! 1511: {
! 1512: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1513: &s_objet) == d_erreur)
! 1514: {
! 1515: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1516: return;
! 1517: }
! 1518:
! 1519: liberation(s_etat_processus, s_objet);
! 1520:
! 1521: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1522: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1523: return;
! 1524: }
! 1525:
! 1526: profondeur_initiale = (*s_etat_processus).hauteur_pile_operationnelle;
! 1527: instruction_dup(s_etat_processus);
! 1528:
! 1529: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1530: ((*s_etat_processus).erreur_execution != d_ex) ||
! 1531: ((*s_etat_processus).exception != d_ep))
! 1532: {
! 1533: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1534: {
! 1535: return;
! 1536: }
! 1537:
! 1538: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1539:
! 1540: return;
! 1541: }
! 1542:
! 1543: instruction_rcl(s_etat_processus);
! 1544:
! 1545: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1546: ((*s_etat_processus).erreur_execution != d_ex) ||
! 1547: ((*s_etat_processus).exception != d_ep))
! 1548: {
! 1549: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1550: &s_objet) == d_erreur)
! 1551: {
! 1552: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1553: return;
! 1554: }
! 1555:
! 1556: liberation(s_etat_processus, s_objet);
! 1557:
! 1558: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1559: {
! 1560: return;
! 1561: }
! 1562:
! 1563: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1564:
! 1565: return;
! 1566: }
! 1567:
! 1568: instruction_edit(s_etat_processus);
! 1569:
! 1570: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1571: ((*s_etat_processus).erreur_execution != d_ex) ||
! 1572: ((*s_etat_processus).exception != d_ep))
! 1573: {
! 1574: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1575: {
! 1576: return;
! 1577: }
! 1578:
! 1579: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1580:
! 1581: return;
! 1582: }
! 1583:
! 1584: while(profondeur_initiale != ((*s_etat_processus)
! 1585: .hauteur_pile_operationnelle - 1))
! 1586: {
! 1587: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1588: &s_objet) == d_erreur)
! 1589: {
! 1590: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1591: return;
! 1592: }
! 1593:
! 1594: liberation(s_etat_processus, s_objet);
! 1595: }
! 1596:
! 1597: instruction_swap(s_etat_processus);
! 1598:
! 1599: if (((*s_etat_processus).erreur_systeme != d_es) ||
! 1600: ((*s_etat_processus).erreur_execution != d_ex) ||
! 1601: ((*s_etat_processus).exception != d_ep))
! 1602: {
! 1603: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1604: {
! 1605: return;
! 1606: }
! 1607:
! 1608: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1609:
! 1610: return;
! 1611: }
! 1612:
! 1613: instruction_sto(s_etat_processus);
! 1614:
! 1615: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1616: {
! 1617: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1618: {
! 1619: return;
! 1620: }
! 1621:
! 1622: (*s_etat_processus).l_base_pile_last = registre_pile_last;
! 1623: }
! 1624:
! 1625: return;
! 1626: }
! 1627:
! 1628:
! 1629: /*
! 1630: ================================================================================
! 1631: Fonction 'variable'
! 1632: ================================================================================
! 1633: Entrées :
! 1634: --------------------------------------------------------------------------------
! 1635: Sorties :
! 1636: --------------------------------------------------------------------------------
! 1637: Effets de bord : néant
! 1638: ================================================================================
! 1639: */
! 1640:
! 1641: void
! 1642: instruction_variable(struct_processus *s_etat_processus)
! 1643: {
! 1644: logical1 presence_variable;
! 1645:
! 1646: long i;
! 1647:
! 1648: struct_liste_chainee *l_element_courant;
! 1649:
! 1650: struct_objet *s_objet;
! 1651:
! 1652: (*s_etat_processus).erreur_execution = d_ex;
! 1653:
! 1654: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1655: {
! 1656: printf("\n VARIABLE ");
! 1657:
! 1658: if ((*s_etat_processus).langue == 'F')
! 1659: {
! 1660: printf("(déverrouille une variable globale)\n\n");
! 1661: }
! 1662: else
! 1663: {
! 1664: printf("(unlock a global variable)\n\n");
! 1665: }
! 1666:
! 1667: printf(" 1: %s, %s\n", d_NOM, d_LST);
! 1668:
! 1669: return;
! 1670: }
! 1671: else if ((*s_etat_processus).test_instruction == 'Y')
! 1672: {
! 1673: (*s_etat_processus).nombre_arguments = -1;
! 1674: return;
! 1675: }
! 1676:
! 1677: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1678: {
! 1679: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 1680: {
! 1681: return;
! 1682: }
! 1683: }
! 1684:
! 1685: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1686: &s_objet) == d_erreur)
! 1687: {
! 1688: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 1689: return;
! 1690: }
! 1691:
! 1692: if ((*s_objet).type == NOM)
! 1693: {
! 1694: if (recherche_variable(s_etat_processus, ((*((struct_nom *)
! 1695: (*s_objet).objet)).nom)) == d_faux)
! 1696: {
! 1697: liberation(s_etat_processus, s_objet);
! 1698:
! 1699: (*s_etat_processus).erreur_systeme = d_es;
! 1700: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
! 1701: return;
! 1702: }
! 1703:
! 1704: i = (*s_etat_processus).position_variable_courante;
! 1705: presence_variable = d_faux;
! 1706:
! 1707: while(i >= 0)
! 1708: {
! 1709: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 1710: (*((struct_nom *) (*s_objet).objet)).nom) == 0)
! 1711: && ((*s_etat_processus).s_liste_variables[i].niveau == 1))
! 1712: {
! 1713: presence_variable = d_vrai;
! 1714: break;
! 1715: }
! 1716:
! 1717: i--;
! 1718: }
! 1719:
! 1720: (*s_etat_processus).position_variable_courante = i;
! 1721:
! 1722: if (presence_variable == d_faux)
! 1723: {
! 1724: liberation(s_etat_processus, s_objet);
! 1725:
! 1726: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
! 1727: return;
! 1728: }
! 1729:
! 1730: ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 1731: .position_variable_courante]).variable_verrouillee = d_faux;
! 1732: }
! 1733: else if ((*s_objet).type == LST)
! 1734: {
! 1735: l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
! 1736:
! 1737: while(l_element_courant != NULL)
! 1738: {
! 1739: if ((*(*l_element_courant).donnee).type != NOM)
! 1740: {
! 1741: liberation(s_etat_processus, s_objet);
! 1742:
! 1743: (*s_etat_processus).erreur_execution = d_ex_nom_invalide;
! 1744: return;
! 1745: }
! 1746:
! 1747: if (recherche_variable(s_etat_processus, (*((struct_nom *)
! 1748: (*(*l_element_courant).donnee).objet)).nom) == d_faux)
! 1749: {
! 1750: liberation(s_etat_processus, s_objet);
! 1751:
! 1752: (*s_etat_processus).erreur_systeme = d_es;
! 1753: (*s_etat_processus).erreur_execution =
! 1754: d_ex_variable_non_definie;
! 1755: return;
! 1756: }
! 1757:
! 1758: i = (*s_etat_processus).position_variable_courante;
! 1759: presence_variable = d_faux;
! 1760:
! 1761: while(i >= 0)
! 1762: {
! 1763: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 1764: (*((struct_nom *) (*(*l_element_courant).donnee)
! 1765: .objet)).nom) == 0) && ((*s_etat_processus)
! 1766: .s_liste_variables[i].niveau == 1))
! 1767: {
! 1768: presence_variable = d_vrai;
! 1769: break;
! 1770: }
! 1771:
! 1772: i--;
! 1773: }
! 1774:
! 1775: (*s_etat_processus).position_variable_courante = i;
! 1776:
! 1777: if (presence_variable == d_faux)
! 1778: {
! 1779: liberation(s_etat_processus, s_objet);
! 1780:
! 1781: (*s_etat_processus).erreur_execution =
! 1782: d_ex_variable_non_definie;
! 1783: return;
! 1784: }
! 1785:
! 1786: ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 1787: .position_variable_courante]).variable_verrouillee = d_faux;
! 1788:
! 1789: l_element_courant = (*l_element_courant).suivant;
! 1790: }
! 1791: }
! 1792: else
! 1793: {
! 1794: liberation(s_etat_processus, s_objet);
! 1795:
! 1796: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1797: return;
! 1798: }
! 1799:
! 1800: liberation(s_etat_processus, s_objet);
! 1801:
! 1802: return;
! 1803: }
! 1804:
! 1805: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_v1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src