![]() ![]() | ![]() |
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 'volatile' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_volatile(struct_processus *s_etat_processus) 40: { 41: struct_liste_chainee *l_element_courant; 42: 43: struct_objet *s_objet; 44: 45: (*s_etat_processus).erreur_execution = d_ex; 46: 47: if ((*s_etat_processus).affichage_arguments == 'Y') 48: { 49: printf("\n VOLATILE "); 50: 51: if ((*s_etat_processus).langue == 'F') 52: { 53: printf("(rend volatile une variable statique)\n\n"); 54: } 55: else 56: { 57: printf("(make volatile a static variable)\n\n"); 58: } 59: 60: printf(" 1: %s, %s\n", d_NOM, d_LST); 61: 62: return; 63: } 64: else if ((*s_etat_processus).test_instruction == 'Y') 65: { 66: (*s_etat_processus).nombre_arguments = -1; 67: return; 68: } 69: 70: if (test_cfsf(s_etat_processus, 31) == d_vrai) 71: { 72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 73: { 74: return; 75: } 76: } 77: 78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 79: &s_objet) == d_erreur) 80: { 81: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 82: return; 83: } 84: 85: if ((*s_objet).type == NOM) 86: { 87: if (recherche_variable(s_etat_processus, ((*((struct_nom *) 88: (*s_objet).objet)).nom)) == d_faux) 89: { 90: liberation(s_etat_processus, s_objet); 91: 92: (*s_etat_processus).erreur_systeme = d_es; 93: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 94: return; 95: } 96: 97: if (((*(*s_etat_processus).pointeur_variable_courante).origine == 'P') 98: ? ((*(*s_etat_processus).pointeur_variable_courante) 99: .variable_statique.adresse == 0) 100: : ((*(*s_etat_processus).pointeur_variable_courante) 101: .variable_statique.pointeur == NULL)) 102: { 103: liberation(s_etat_processus, s_objet); 104: 105: (*s_etat_processus).erreur_execution = d_ex_variable_volatile; 106: return; 107: } 108: else 109: { 110: if (retrait_variable_statique(s_etat_processus, 111: (*((struct_nom *) (*s_objet).objet)).nom, 112: (*(*s_etat_processus).pointeur_variable_courante) 113: .variable_statique) == d_erreur) 114: { 115: liberation(s_etat_processus, s_objet); 116: return; 117: } 118: 119: if ((*(*s_etat_processus).pointeur_variable_courante).origine 120: == 'P') 121: { 122: (*(*s_etat_processus).pointeur_variable_courante) 123: .variable_statique.adresse = 0; 124: } 125: else 126: { 127: (*(*s_etat_processus).pointeur_variable_courante) 128: .variable_statique.pointeur = NULL; 129: } 130: } 131: } 132: else if ((*s_objet).type == LST) 133: { 134: l_element_courant = (struct_liste_chainee *) (*s_objet).objet; 135: 136: while(l_element_courant != NULL) 137: { 138: if ((*(*l_element_courant).donnee).type != NOM) 139: { 140: liberation(s_etat_processus, s_objet); 141: 142: (*s_etat_processus).erreur_execution = d_ex_nom_invalide; 143: return; 144: } 145: 146: if (recherche_variable(s_etat_processus, (*((struct_nom *) 147: (*(*l_element_courant).donnee).objet)).nom) == d_faux) 148: { 149: liberation(s_etat_processus, s_objet); 150: 151: (*s_etat_processus).erreur_systeme = d_es; 152: (*s_etat_processus).erreur_execution = 153: d_ex_variable_non_definie; 154: return; 155: } 156: 157: if (((*(*s_etat_processus).pointeur_variable_courante) 158: .origine == 'P') ? ((*(*s_etat_processus) 159: .pointeur_variable_courante).variable_statique.adresse == 0) 160: : ((*(*s_etat_processus).pointeur_variable_courante) 161: .variable_statique.pointeur == NULL)) 162: { 163: liberation(s_etat_processus, s_objet); 164: 165: (*s_etat_processus).erreur_execution = d_ex_variable_volatile; 166: return; 167: } 168: else 169: { 170: if (retrait_variable_statique(s_etat_processus, 171: (*((struct_nom *) (*s_objet).objet)).nom, 172: (*(*s_etat_processus).pointeur_variable_courante) 173: .variable_statique) == d_erreur) 174: { 175: liberation(s_etat_processus, s_objet); 176: return; 177: } 178: 179: if ((*(*s_etat_processus).pointeur_variable_courante) 180: .origine == 'P') 181: { 182: (*(*s_etat_processus).pointeur_variable_courante) 183: .variable_statique.adresse = 0; 184: } 185: else 186: { 187: (*(*s_etat_processus).pointeur_variable_courante) 188: .variable_statique.pointeur = NULL; 189: } 190: } 191: 192: l_element_courant = (*l_element_courant).suivant; 193: } 194: } 195: else 196: { 197: liberation(s_etat_processus, s_objet); 198: 199: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 200: return; 201: } 202: 203: liberation(s_etat_processus, s_objet); 204: 205: return; 206: } 207: 208: 209: /* 210: ================================================================================ 211: Fonction 'verify' 212: ================================================================================ 213: Entrées : 214: -------------------------------------------------------------------------------- 215: Sorties : 216: -------------------------------------------------------------------------------- 217: Effets de bord : néant 218: ================================================================================ 219: */ 220: 221: void 222: instruction_verify(struct_processus *s_etat_processus) 223: { 224: int position; 225: 226: integer8 i1; 227: integer8 i2; 228: integer8 i3; 229: integer8 i4; 230: integer8 j1; 231: integer8 j2; 232: integer8 j3; 233: integer8 j4; 234: 235: logical1 drapeau; 236: logical1 drapeau_final; 237: logical1 drapeau_final_courant; 238: logical1 drapeau_prerelease; 239: logical1 drapeau_prerelease_courant; 240: logical1 last_valide; 241: 242: struct_liste_chainee *l_element_caracteristiques; 243: struct_liste_chainee *l_element_courant; 244: struct_liste_chainee *l_element_version; 245: 246: struct_objet *s_objet_argument; 247: struct_objet *s_objet_caracteristiques; 248: struct_objet *s_objet_resultat; 249: 250: unsigned char *chaine_majuscule; 251: 252: (*s_etat_processus).erreur_execution = d_ex; 253: 254: if ((*s_etat_processus).affichage_arguments == 'Y') 255: { 256: printf("\n VERIFY "); 257: 258: if ((*s_etat_processus).langue == 'F') 259: { 260: printf("(vérification des caractéristiques du langage)\n\n"); 261: } 262: else 263: { 264: printf("(checks of the language characteristics)\n\n"); 265: } 266: 267: printf(" 1: %s\n", d_LST); 268: printf("-> 1: %s (0 or -1)\n\n", d_INT); 269: 270: if ((*s_etat_processus).langue == 'F') 271: { 272: printf(" Utilisation :\n\n"); 273: } 274: else 275: { 276: printf(" Usage:\n\n"); 277: } 278: 279: printf(" { { 4 0 0 \"PRERELEASE\" 4 } \"POSTGRESQL\" } VERIFY\n"); 280: printf(" { { 4 0 0 } } VERIFY\n"); 281: 282: return; 283: } 284: else if ((*s_etat_processus).test_instruction == 'Y') 285: { 286: (*s_etat_processus).nombre_arguments = -1; 287: return; 288: } 289: 290: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai) 291: { 292: if (empilement_pile_last(s_etat_processus, 3) == d_erreur) 293: { 294: return; 295: } 296: } 297: 298: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 299: &s_objet_argument) == d_erreur) 300: { 301: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 302: return; 303: } 304: 305: if ((*s_objet_argument).type == LST) 306: { 307: if (last_valide == d_vrai) 308: { 309: cf(s_etat_processus, 31); 310: } 311: 312: instruction_version(s_etat_processus); 313: 314: if (last_valide == d_vrai) 315: { 316: sf(s_etat_processus, 31); 317: } 318: 319: if ((*s_etat_processus).erreur_systeme != d_es) 320: { 321: return; 322: } 323: 324: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 325: &s_objet_caracteristiques) == d_erreur) 326: { 327: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 328: return; 329: } 330: 331: /* 332: * L'objet renvoyé est obligatoirement une liste. 333: */ 334: 335: BUG((*s_objet_caracteristiques).type != LST, 336: printf("(*s_objet_caracteristiques).type='%d'\n", 337: (*s_objet_caracteristiques).type)); 338: 339: drapeau = d_vrai; 340: l_element_courant = (*s_objet_argument).objet; 341: 342: while((l_element_courant != NULL) && (drapeau == d_vrai)) 343: { 344: if ((*(*l_element_courant).donnee).type == CHN) 345: { 346: if ((chaine_majuscule = conversion_majuscule((unsigned char *) 347: (*(*l_element_courant).donnee).objet)) == NULL) 348: { 349: (*s_etat_processus).erreur_systeme = 350: d_es_allocation_memoire; 351: return; 352: } 353: 354: l_element_caracteristiques = (*s_objet_caracteristiques).objet; 355: 356: while(l_element_caracteristiques != NULL) 357: { 358: if ((*(*l_element_caracteristiques).donnee).type == CHN) 359: { 360: if (strcmp((unsigned char *) 361: (*(*l_element_caracteristiques).donnee).objet, 362: chaine_majuscule) == 0) 363: { 364: break; 365: } 366: } 367: 368: l_element_caracteristiques = (*l_element_caracteristiques) 369: .suivant; 370: } 371: 372: free(chaine_majuscule); 373: 374: if (l_element_caracteristiques == NULL) 375: { // La chaîne n'a pas été trouvée... 376: drapeau = d_faux; 377: break; 378: } 379: } 380: else if ((*(*l_element_courant).donnee).type == LST) 381: { 382: drapeau_final = d_vrai; 383: drapeau_prerelease = d_faux; 384: drapeau_final_courant = d_vrai; 385: drapeau_prerelease_courant = d_faux; 386: i1 = 0; 387: i2 = 0; 388: i3 = 0; 389: i4 = 0; 390: j1 = 0; 391: j2 = 0; 392: j3 = 0; 393: j4 = 0; 394: 395: l_element_version = (*(*l_element_courant).donnee).objet; 396: position = 1; 397: 398: while(l_element_version != NULL) 399: { 400: switch(position) 401: { 402: case 1 : 403: { 404: if ((*(*l_element_version).donnee).type == INT) 405: { 406: i1 = (*((integer8 *) (*(*l_element_version) 407: .donnee).objet)); 408: } 409: else 410: { 411: liberation(s_etat_processus, s_objet_argument); 412: liberation(s_etat_processus, 413: s_objet_caracteristiques); 414: 415: (*s_etat_processus).erreur_execution = 416: d_ex_erreur_type_argument; 417: return; 418: } 419: 420: break; 421: } 422: 423: case 2 : 424: { 425: if ((*(*l_element_version).donnee).type == INT) 426: { 427: i2 = (*((integer8 *) (*(*l_element_version) 428: .donnee).objet)); 429: } 430: else 431: { 432: liberation(s_etat_processus, s_objet_argument); 433: liberation(s_etat_processus, 434: s_objet_caracteristiques); 435: 436: (*s_etat_processus).erreur_execution = 437: d_ex_erreur_type_argument; 438: return; 439: } 440: 441: break; 442: } 443: 444: case 3 : 445: { 446: if ((*(*l_element_version).donnee).type == INT) 447: { 448: i3 = (*((integer8 *) (*(*l_element_version) 449: .donnee).objet)); 450: } 451: else 452: { 453: liberation(s_etat_processus, s_objet_argument); 454: liberation(s_etat_processus, 455: s_objet_caracteristiques); 456: 457: (*s_etat_processus).erreur_execution = 458: d_ex_erreur_type_argument; 459: return; 460: } 461: 462: break; 463: } 464: 465: case 4 : 466: { 467: if ((*(*l_element_version).donnee).type == CHN) 468: { 469: if ((chaine_majuscule = conversion_majuscule( 470: (unsigned char *) (*(*l_element_version) 471: .donnee).objet)) == NULL) 472: { 473: (*s_etat_processus).erreur_systeme = 474: d_es_allocation_memoire; 475: return; 476: } 477: 478: if (strcmp(chaine_majuscule, "RELEASE") == 0) 479: { 480: drapeau_final = d_vrai; 481: } 482: else if (strcmp(chaine_majuscule, "PRERELEASE") 483: == 0) 484: { 485: drapeau_final = d_faux; 486: } 487: else 488: { 489: liberation(s_etat_processus, 490: s_objet_argument); 491: liberation(s_etat_processus, 492: s_objet_caracteristiques); 493: 494: (*s_etat_processus).erreur_execution = 495: d_ex_argument_invalide; 496: return; 497: } 498: 499: free(chaine_majuscule); 500: } 501: else 502: { 503: liberation(s_etat_processus, s_objet_argument); 504: liberation(s_etat_processus, 505: s_objet_caracteristiques); 506: 507: (*s_etat_processus).erreur_execution = 508: d_ex_erreur_type_argument; 509: return; 510: } 511: 512: break; 513: } 514: 515: case 5 : 516: { 517: if ((*(*l_element_version).donnee).type == INT) 518: { 519: i4 = (*((integer8 *) (*(*l_element_version) 520: .donnee).objet)); 521: } 522: else 523: { 524: liberation(s_etat_processus, s_objet_argument); 525: liberation(s_etat_processus, 526: s_objet_caracteristiques); 527: 528: (*s_etat_processus).erreur_execution = 529: d_ex_erreur_type_argument; 530: return; 531: } 532: 533: drapeau_prerelease = d_vrai; 534: break; 535: } 536: 537: default : 538: { 539: liberation(s_etat_processus, s_objet_argument); 540: liberation(s_etat_processus, 541: s_objet_caracteristiques); 542: 543: (*s_etat_processus).erreur_execution = 544: d_ex_erreur_type_argument; 545: return; 546: break; 547: } 548: } 549: 550: position++; 551: l_element_version = (*l_element_version).suivant; 552: } 553: 554: if (drapeau_prerelease == drapeau_final) 555: { 556: liberation(s_etat_processus, s_objet_argument); 557: liberation(s_etat_processus, s_objet_caracteristiques); 558: 559: (*s_etat_processus).erreur_execution = 560: d_ex_argument_invalide; 561: return; 562: } 563: 564: l_element_caracteristiques = (*s_objet_caracteristiques).objet; 565: 566: while(l_element_caracteristiques != NULL) 567: { 568: if ((*(*l_element_caracteristiques).donnee).type == LST) 569: { 570: l_element_version = (*(*l_element_caracteristiques) 571: .donnee).objet; 572: 573: position = 1; 574: 575: while(l_element_version != NULL) 576: { 577: switch(position) 578: { 579: case 1 : 580: { 581: j1 = (*((integer8 *) (*(*l_element_version) 582: .donnee).objet)); 583: break; 584: } 585: 586: case 2 : 587: { 588: j2 = (*((integer8 *) (*(*l_element_version) 589: .donnee).objet)); 590: break; 591: } 592: 593: case 3 : 594: { 595: j3 = (*((integer8 *) (*(*l_element_version) 596: .donnee).objet)); 597: break; 598: } 599: 600: case 4 : 601: { 602: drapeau_final_courant = 603: (strcmp((unsigned char *) 604: (*(*l_element_version).donnee) 605: .objet, "RELEASE") == 0) 606: ? d_vrai : d_faux; 607: break; 608: } 609: 610: case 5 : 611: { 612: j4 = (*((integer8 *) (*(*l_element_version) 613: .donnee).objet)); 614: drapeau_prerelease_courant = d_vrai; 615: break; 616: } 617: } 618: 619: position++; 620: l_element_version = (*l_element_version).suivant; 621: } 622: 623: break; 624: } 625: 626: l_element_caracteristiques = (*l_element_caracteristiques) 627: .suivant; 628: } 629: 630: if (drapeau_prerelease_courant == drapeau_final_courant) 631: { 632: liberation(s_etat_processus, s_objet_argument); 633: liberation(s_etat_processus, s_objet_caracteristiques); 634: 635: (*s_etat_processus).erreur_execution = 636: d_ex_argument_invalide; 637: return; 638: } 639: 640: if (i1 > j1) 641: { // Version demandée supérieure à la version courante 642: drapeau = d_faux; 643: } 644: else if (i1 == j1) 645: { 646: if (i2 > j2) 647: { // Versions idendiques et sous-version demandée 648: // supérieure à la sous-version courante 649: drapeau = d_faux; 650: } 651: else if (i2 == j2) 652: { // Versions et sous-versions identiques 653: if (i3 > j3) 654: { // Niveau de patches demandé supérieur au niveau 655: // de patch courant 656: drapeau = d_faux; 657: } 658: else if (i3 == j3) 659: { // Niveaux de patches indentiques 660: if ((drapeau_final == d_vrai) && 661: (drapeau_final_courant == d_faux)) 662: { // Finale requise et prerelease obtenue 663: drapeau = d_faux; 664: } 665: else if ((drapeau_final == d_faux) && 666: (drapeau_final_courant == d_vrai)) 667: { // Prerelease requise et finale obtenue 668: } 669: else if ((drapeau_final == d_vrai) && 670: (drapeau_final_courant == d_vrai)) 671: { // Finales de part et d'autre 672: } 673: else 674: { // Prerelease de part et d'autre 675: if (i4 > j4) 676: { // Prerelease demandée supérieur à la 677: // version courante 678: drapeau = d_faux; 679: } 680: } 681: } 682: else 683: { // Niveaux de patches inférieur au niveau courant 684: } 685: } 686: else 687: { // Versions indentiques et sous-version inférieure à 688: // la sous-version courante 689: } 690: } 691: else 692: { // Version demandée inférieure à la version courante 693: } 694: } 695: else 696: { 697: liberation(s_etat_processus, s_objet_argument); 698: liberation(s_etat_processus, s_objet_caracteristiques); 699: 700: (*s_etat_processus).erreur_execution = 701: d_ex_erreur_type_argument; 702: return; 703: } 704: 705: l_element_courant = (*l_element_courant).suivant; 706: } 707: 708: liberation(s_etat_processus, s_objet_caracteristiques); 709: 710: /* 711: * Création du drapeau renvoyé 712: */ 713: 714: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 715: { 716: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 717: return; 718: } 719: 720: (*((integer8 *) (*s_objet_resultat).objet)) = (drapeau == d_vrai) 721: ? -1 : 0; 722: 723: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 724: s_objet_resultat) == d_erreur) 725: { 726: return; 727: } 728: } 729: else 730: { 731: liberation(s_etat_processus, s_objet_argument); 732: 733: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 734: return; 735: } 736: 737: liberation(s_etat_processus, s_objet_argument); 738: 739: return; 740: } 741: 742: // vim: ts=4