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