![]() ![]() | ![]() |
Suite des patches pour améliorer le parser.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.19 4: Copyright (C) 1989-2014 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: Procédure de vérification syntaxique du source et de précompilation 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: - renvoi : erreur 34: -------------------------------------------------------------------------------- 35: Effets de bord : 36: ================================================================================ 37: */ 38: 39: logical1 40: compilation(struct_processus *s_etat_processus) 41: { 42: struct_objet *s_objet; 43: 44: struct_variable *s_variable; 45: 46: unsigned char apostrophe_ouverte; 47: unsigned char apostrophe_ouverte_registre; 48: unsigned char caractere_courant; 49: unsigned char caractere_precedent; 50: unsigned char caractere_suivant; 51: unsigned char *definition; 52: unsigned char fermeture_definition; 53: unsigned char guillemet_ouvert; 54: unsigned char ouverture_definition; 55: unsigned char position_debut_nom_definition_valide; 56: 57: integer8 *adresse; 58: integer8 i; 59: integer8 niveau_definition; 60: integer8 niveau_definition_registre; 61: integer8 position_courante; 62: integer8 position_debut_nom_definition; 63: integer8 position_fin_nom_definition; 64: integer8 validation; 65: integer8 validation_registre; 66: 67: (*s_etat_processus).erreur_compilation = d_ec; 68: (*s_etat_processus).erreur_systeme = d_es; 69: (*s_etat_processus).erreur_execution = d_ex; 70: (*s_etat_processus).exception = d_ep; 71: (*s_etat_processus).arret_si_exception = d_vrai; 72: 73: (*s_etat_processus).position_courante = 0; 74: 75: /* 76: -------------------------------------------------------------------------------- 77: Recheche des définitions 78: -------------------------------------------------------------------------------- 79: */ 80: 81: niveau_definition = 0; 82: niveau_definition_registre = 0; 83: position_courante = 0; 84: position_debut_nom_definition = 0; 85: validation = 0; 86: 87: apostrophe_ouverte = d_faux; 88: apostrophe_ouverte_registre = d_faux; 89: guillemet_ouvert = d_faux; 90: position_debut_nom_definition_valide = d_faux; 91: 92: if ((*s_etat_processus).debug == d_vrai) 93: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0) 94: { 95: printf("\n"); 96: printf("[%d] Compilation\n", (int) getpid()); 97: fflush(stdout); 98: } 99: 100: while((*s_etat_processus).definitions_chainees[position_courante] != 101: d_code_fin_chaine) 102: { 103: caractere_courant = (*s_etat_processus) 104: .definitions_chainees[position_courante]; 105: 106: fermeture_definition = d_faux; 107: ouverture_definition = d_faux; 108: 109: if (position_courante >= 1) 110: { 111: if (position_courante >= 2) 112: { 113: if (((*s_etat_processus).definitions_chainees 114: [position_courante - 2] == '\\') && 115: ((*s_etat_processus).definitions_chainees 116: [position_courante - 1] == '\\')) 117: { 118: caractere_precedent = '*'; 119: } 120: else 121: { 122: caractere_precedent = (*s_etat_processus) 123: .definitions_chainees[position_courante - 1]; 124: } 125: } 126: else 127: { 128: caractere_precedent = (*s_etat_processus) 129: .definitions_chainees[position_courante - 1]; 130: } 131: } 132: else 133: { 134: caractere_precedent = ' '; 135: } 136: 137: caractere_suivant = (*s_etat_processus) 138: .definitions_chainees[position_courante + 1]; 139: 140: if (caractere_suivant == d_code_fin_chaine) 141: { 142: caractere_suivant = ' '; 143: } 144: 145: if ((caractere_courant == '[') || (caractere_courant == '{')) 146: { 147: validation++; 148: } 149: else if ((caractere_courant == ']') || (caractere_courant == '}')) 150: { 151: validation--; 152: } 153: else if (caractere_courant == '\'') 154: { 155: if (apostrophe_ouverte == d_faux) 156: { 157: validation++; 158: apostrophe_ouverte = d_vrai; 159: } 160: else 161: { 162: validation--; 163: apostrophe_ouverte = d_faux; 164: } 165: } 166: else if (caractere_courant == '"') 167: { 168: if (caractere_precedent != '\\') 169: { 170: swap((void *) &validation, (void *) &validation_registre, 171: sizeof(validation)); 172: swap((void *) &apostrophe_ouverte, 173: (void *) &apostrophe_ouverte_registre, 174: sizeof(apostrophe_ouverte)); 175: swap((void *) &niveau_definition, 176: (void *) &niveau_definition_registre, 177: sizeof(niveau_definition)); 178: 179: guillemet_ouvert = (guillemet_ouvert == d_faux) 180: ? d_vrai : d_faux; 181: } 182: } 183: else if ((caractere_courant == '<') && 184: (caractere_precedent == ' ') && 185: (caractere_suivant == '<')) 186: { 187: if ((*s_etat_processus) 188: .definitions_chainees[position_courante + 2] == ' ') 189: { 190: niveau_definition++; 191: ouverture_definition = d_vrai; 192: } 193: } 194: else if ((caractere_courant == '>') && 195: (caractere_precedent == ' ') && 196: (caractere_suivant == '>')) 197: { 198: if (((*s_etat_processus) 199: .definitions_chainees[position_courante + 2] == ' ') || 200: ((*s_etat_processus).definitions_chainees 201: [position_courante + 2] == d_code_fin_chaine)) 202: { 203: if (niveau_definition == 0) 204: { 205: (*s_etat_processus).erreur_compilation = 206: d_ec_niveau_definition_negatif; 207: return(d_erreur); 208: } 209: else 210: { 211: niveau_definition--; 212: fermeture_definition = d_vrai; 213: position_courante++; 214: } 215: } 216: } 217: 218: if ((niveau_definition == 0) && (guillemet_ouvert == d_faux) && 219: (caractere_courant != ' ') && (fermeture_definition == d_faux)) 220: { 221: if (position_debut_nom_definition_valide == d_faux) 222: { 223: position_debut_nom_definition_valide = d_vrai; 224: position_debut_nom_definition = position_courante; 225: } 226: } 227: 228: if (((niveau_definition == 1) && (ouverture_definition == d_vrai)) && 229: (position_debut_nom_definition_valide == d_vrai)) 230: { 231: position_fin_nom_definition = position_courante - 1; 232: position_debut_nom_definition_valide = d_faux; 233: 234: while((*s_etat_processus).definitions_chainees 235: [position_fin_nom_definition] == ' ') 236: { 237: position_fin_nom_definition--; 238: } 239: 240: i = position_debut_nom_definition; 241: 242: while(i <= position_fin_nom_definition) 243: { 244: if ((*s_etat_processus).definitions_chainees[i] == ' ') 245: { 246: (*s_etat_processus).erreur_compilation = 247: d_ec_nom_definition_invalide; 248: return(d_erreur); 249: } 250: else 251: { 252: i++; 253: } 254: } 255: 256: s_objet = allocation(s_etat_processus, ADR); 257: s_variable = (struct_variable *) 258: malloc(sizeof(struct_variable)); 259: adresse = (*s_objet).objet; 260: definition = (unsigned char *) malloc(((size_t) 261: (position_fin_nom_definition - 262: position_debut_nom_definition + 2)) * 263: sizeof(unsigned char)); 264: 265: if ((s_objet == NULL) || (s_variable == NULL) || 266: (adresse == NULL) || definition == NULL) 267: { 268: (*s_etat_processus).erreur_systeme = 269: d_es_allocation_memoire; 270: return(d_erreur); 271: } 272: else 273: { 274: (*adresse) = position_fin_nom_definition + 1; 275: 276: (*s_variable).nom = definition; 277: (*s_variable).niveau = (*s_etat_processus).niveau_courant; 278: (*s_variable).objet = s_objet; 279: 280: i = position_debut_nom_definition; 281: 282: while(i <= position_fin_nom_definition) 283: { 284: *(definition++) = (*s_etat_processus) 285: .definitions_chainees[i++]; 286: } 287: 288: *definition = d_code_fin_chaine; 289: 290: if (recherche_variable(s_etat_processus, (*s_variable).nom) 291: == d_vrai) 292: { 293: if ((*s_etat_processus).langue == 'F') 294: { 295: printf("+++Attention : Plusieurs définitions de" 296: " même nom\n"); 297: } 298: else 299: { 300: printf("+++Warning : Same name for several" 301: " definitions\n"); 302: } 303: 304: fflush(stdout); 305: return(d_erreur); 306: } 307: 308: (*s_etat_processus).erreur_systeme = d_es; 309: creation_variable(s_etat_processus, s_variable, 'V', 'P'); 310: 311: if ((*s_etat_processus).erreur_systeme != d_es) 312: { 313: free(s_variable); 314: 315: return(d_erreur); 316: } 317: 318: if ((*s_etat_processus).debug == d_vrai) 319: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0) 320: { 321: if ((*s_etat_processus).langue == 'F') 322: { 323: printf("[%d] Compilation : Définition %s ($ %016lX) " 324: "\n", (int) getpid(), (*s_variable).nom, 325: (*adresse)); 326: } 327: else 328: { 329: printf("[%d] Compilation : %s definition ($ %016lX) " 330: "\n", (int) getpid(), (*s_variable).nom, 331: (*adresse)); 332: } 333: 334: fflush(stdout); 335: } 336: } 337: 338: free(s_variable); 339: } 340: 341: position_courante++; 342: } 343: 344: return(analyse_syntaxique(s_etat_processus)); 345: } 346: 347: 348: /* 349: ================================================================================ 350: Procédure de d'analyse syntaxique du source 351: ================================================================================ 352: Entrées : 353: -------------------------------------------------------------------------------- 354: Sorties : 355: - renvoi : erreur 356: -------------------------------------------------------------------------------- 357: Effets de bord : 358: ================================================================================ 359: */ 360: 361: enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF, 362: AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT, 363: AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START, 364: AN_NEXT, AN_STEP, AN_CRITICAL, AN_FORALL }; 365: 366: typedef struct pile 367: { 368: enum t_condition condition; 369: struct pile *suivant; 370: } struct_pile_analyse; 371: 372: static inline struct_pile_analyse * 373: empilement_analyse(struct_pile_analyse *ancienne_base, 374: enum t_condition condition) 375: { 376: struct_pile_analyse *nouvelle_base; 377: 378: if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL) 379: { 380: return(NULL); 381: } 382: 383: (*nouvelle_base).suivant = ancienne_base; 384: (*nouvelle_base).condition = condition; 385: 386: return(nouvelle_base); 387: } 388: 389: static inline struct_pile_analyse * 390: depilement_analyse(struct_pile_analyse *ancienne_base) 391: { 392: struct_pile_analyse *nouvelle_base; 393: 394: if (ancienne_base == NULL) 395: { 396: return(NULL); 397: } 398: 399: nouvelle_base = (*ancienne_base).suivant; 400: free(ancienne_base); 401: 402: return(nouvelle_base); 403: } 404: 405: static inline logical1 406: test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition) 407: { 408: if (l_base_pile == NULL) 409: { 410: return(d_faux); 411: } 412: 413: return(((*l_base_pile).condition == condition) ? d_vrai : d_faux); 414: } 415: 416: static inline void 417: liberation_analyse(struct_pile_analyse *l_base_pile) 418: { 419: struct_pile_analyse *l_nouvelle_base_pile; 420: 421: while(l_base_pile != NULL) 422: { 423: l_nouvelle_base_pile = (*l_base_pile).suivant; 424: free(l_base_pile); 425: l_base_pile = l_nouvelle_base_pile; 426: } 427: 428: return; 429: } 430: 431: logical1 432: analyse_syntaxique(struct_processus *s_etat_processus) 433: { 434: unsigned char *instruction; 435: unsigned char registre; 436: 437: struct_pile_analyse *l_base_pile; 438: struct_pile_analyse *l_nouvelle_base_pile; 439: 440: l_base_pile = NULL; 441: l_nouvelle_base_pile = NULL; 442: 443: if ((*s_etat_processus).debug == d_vrai) 444: if (((*s_etat_processus).type_debug & d_debug_analyse) != 0) 445: { 446: if ((*s_etat_processus).langue == 'F') 447: { 448: printf("[%d] Analyse\n", (int) getpid()); 449: } 450: else 451: { 452: printf("[%d] Analysis\n", (int) getpid()); 453: } 454: 455: fflush(stdout); 456: } 457: 458: (*s_etat_processus).position_courante = 0; 459: registre = (*s_etat_processus).autorisation_empilement_programme; 460: (*s_etat_processus).autorisation_empilement_programme = 'N'; 461: 462: /* 463: -------------------------------------------------------------------------------- 464: Analyse structurelle 465: -------------------------------------------------------------------------------- 466: */ 467: 468: while((*s_etat_processus).definitions_chainees 469: [(*s_etat_processus).position_courante] != d_code_fin_chaine) 470: { 471: if (recherche_instruction_suivante(s_etat_processus) != 472: d_absence_erreur) 473: { 474: liberation_analyse(l_base_pile); 475: 476: (*s_etat_processus).autorisation_empilement_programme = registre; 477: return(d_erreur); 478: } 479: 480: if ((instruction = conversion_majuscule( 481: (*s_etat_processus).instruction_courante)) == NULL) 482: { 483: liberation_analyse(l_base_pile); 484: 485: (*s_etat_processus).autorisation_empilement_programme = registre; 486: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 487: return(d_erreur); 488: } 489: 490: if (strcmp(instruction, "IF") == 0) 491: { 492: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF)) 493: == NULL) 494: { 495: liberation_analyse(l_base_pile); 496: 497: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 498: return(d_erreur); 499: } 500: 501: l_base_pile = l_nouvelle_base_pile; 502: (*l_base_pile).condition = AN_IF; 503: } 504: else if (strcmp(instruction, "IFERR") == 0) 505: { 506: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 507: AN_IFERR)) == NULL) 508: { 509: liberation_analyse(l_base_pile); 510: 511: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 512: return(d_erreur); 513: } 514: 515: l_base_pile = l_nouvelle_base_pile; 516: } 517: else if (strcmp(instruction, "CRITICAL") == 0) 518: { 519: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 520: AN_CRITICAL)) == NULL) 521: { 522: liberation_analyse(l_base_pile); 523: 524: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 525: return(d_erreur); 526: } 527: 528: l_base_pile = l_nouvelle_base_pile; 529: } 530: else if (strcmp(instruction, "THEN") == 0) 531: { 532: if ((test_analyse(l_base_pile, AN_IF) == d_faux) && 533: (test_analyse(l_base_pile, AN_ELSEIF) == d_faux) && 534: (test_analyse(l_base_pile, AN_CASE) == d_faux) && 535: (test_analyse(l_base_pile, AN_IFERR) == d_faux)) 536: { 537: liberation_analyse(l_base_pile); 538: 539: (*s_etat_processus).autorisation_empilement_programme = 540: registre; 541: 542: (*s_etat_processus).erreur_compilation = 543: d_ec_erreur_instruction_then; 544: return(d_erreur); 545: } 546: 547: (*l_base_pile).condition = AN_THEN; 548: } 549: else if (strcmp(instruction, "ELSE") == 0) 550: { 551: if (test_analyse(l_base_pile, AN_THEN) == d_faux) 552: { 553: liberation_analyse(l_base_pile); 554: 555: (*s_etat_processus).autorisation_empilement_programme = 556: registre; 557: 558: (*s_etat_processus).erreur_compilation = 559: d_ec_erreur_instruction_else; 560: return(d_erreur); 561: } 562: 563: (*l_base_pile).condition = AN_ELSE; 564: } 565: else if (strcmp(instruction, "ELSEIF") == 0) 566: { 567: if (test_analyse(l_base_pile, AN_THEN) == d_faux) 568: { 569: liberation_analyse(l_base_pile); 570: 571: (*s_etat_processus).autorisation_empilement_programme = 572: registre; 573: 574: (*s_etat_processus).erreur_compilation = 575: d_ec_erreur_instruction_elseif; 576: return(d_erreur); 577: } 578: 579: (*l_base_pile).condition = AN_ELSEIF; 580: } 581: else if (strcmp(instruction, "END") == 0) 582: { 583: if ((test_analyse(l_base_pile, AN_UNTIL) == d_faux) && 584: (test_analyse(l_base_pile, AN_REPEAT) == d_faux) && 585: (test_analyse(l_base_pile, AN_DEFAULT) == d_faux) && 586: (test_analyse(l_base_pile, AN_SELECT) == d_faux) && 587: (test_analyse(l_base_pile, AN_THEN) == d_faux) && 588: (test_analyse(l_base_pile, AN_CRITICAL) == d_faux) && 589: (test_analyse(l_base_pile, AN_ELSE) == d_faux)) 590: { 591: liberation_analyse(l_base_pile); 592: 593: (*s_etat_processus).autorisation_empilement_programme = 594: registre; 595: 596: (*s_etat_processus).erreur_compilation = 597: d_ec_erreur_instruction_end; 598: return(d_erreur); 599: } 600: 601: l_base_pile = depilement_analyse(l_base_pile); 602: } 603: else if (strcmp(instruction, "DO") == 0) 604: { 605: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO)) 606: == NULL) 607: { 608: liberation_analyse(l_base_pile); 609: 610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 611: return(d_erreur); 612: } 613: 614: l_base_pile = l_nouvelle_base_pile; 615: } 616: else if (strcmp(instruction, "UNTIL") == 0) 617: { 618: if (test_analyse(l_base_pile, AN_DO) == d_faux) 619: { 620: liberation_analyse(l_base_pile); 621: 622: (*s_etat_processus).autorisation_empilement_programme = 623: registre; 624: 625: (*s_etat_processus).erreur_compilation = 626: d_ec_erreur_instruction_until; 627: return(d_erreur); 628: } 629: 630: (*l_base_pile).condition = AN_UNTIL; 631: } 632: else if (strcmp(instruction, "WHILE") == 0) 633: { 634: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 635: AN_WHILE)) == NULL) 636: { 637: liberation_analyse(l_base_pile); 638: 639: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 640: return(d_erreur); 641: } 642: 643: l_base_pile = l_nouvelle_base_pile; 644: } 645: else if (strcmp(instruction, "REPEAT") == 0) 646: { 647: if (test_analyse(l_base_pile, AN_WHILE) == d_faux) 648: { 649: liberation_analyse(l_base_pile); 650: 651: (*s_etat_processus).autorisation_empilement_programme = 652: registre; 653: 654: (*s_etat_processus).erreur_compilation = 655: d_ec_erreur_instruction_while; 656: return(d_erreur); 657: } 658: 659: (*l_base_pile).condition = AN_REPEAT; 660: } 661: else if (strcmp(instruction, "SELECT") == 0) 662: { 663: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 664: AN_SELECT)) == NULL) 665: { 666: liberation_analyse(l_base_pile); 667: 668: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 669: return(d_erreur); 670: } 671: 672: l_base_pile = l_nouvelle_base_pile; 673: } 674: else if (strcmp(instruction, "CASE") == 0) 675: { 676: if (test_analyse(l_base_pile, AN_SELECT) == d_faux) 677: { 678: liberation_analyse(l_base_pile); 679: 680: (*s_etat_processus).autorisation_empilement_programme = 681: registre; 682: 683: (*s_etat_processus).erreur_compilation = 684: d_ec_erreur_instruction_case; 685: return(d_erreur); 686: } 687: 688: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 689: AN_CASE)) == NULL) 690: { 691: liberation_analyse(l_base_pile); 692: 693: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 694: return(d_erreur); 695: } 696: 697: l_base_pile = l_nouvelle_base_pile; 698: } 699: else if (strcmp(instruction, "DEFAULT") == 0) 700: { 701: if (test_analyse(l_base_pile, AN_SELECT) == d_faux) 702: { 703: liberation_analyse(l_base_pile); 704: 705: (*s_etat_processus).autorisation_empilement_programme = 706: registre; 707: 708: (*s_etat_processus).erreur_compilation = 709: d_ec_erreur_instruction_select; 710: return(d_erreur); 711: } 712: 713: (*l_base_pile).condition = AN_DEFAULT; 714: } 715: else if (strcmp(instruction, "<<") == 0) 716: { 717: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP)) 718: == NULL) 719: { 720: liberation_analyse(l_base_pile); 721: 722: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 723: return(d_erreur); 724: } 725: 726: l_base_pile = l_nouvelle_base_pile; 727: } 728: else if (strcmp(instruction, ">>") == 0) 729: { 730: if (test_analyse(l_base_pile, AN_UP) == d_faux) 731: { 732: liberation_analyse(l_base_pile); 733: 734: (*s_etat_processus).autorisation_empilement_programme = 735: registre; 736: 737: (*s_etat_processus).erreur_compilation = 738: d_ec_source_incoherent; 739: return(d_erreur); 740: } 741: 742: l_base_pile = depilement_analyse(l_base_pile); 743: } 744: else if (strcmp(instruction, "FOR") == 0) 745: { 746: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR)) 747: == NULL) 748: { 749: liberation_analyse(l_base_pile); 750: 751: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 752: return(d_erreur); 753: } 754: 755: l_base_pile = l_nouvelle_base_pile; 756: } 757: else if (strcmp(instruction, "START") == 0) 758: { 759: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 760: AN_START)) == NULL) 761: { 762: liberation_analyse(l_base_pile); 763: 764: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 765: return(d_erreur); 766: } 767: 768: l_base_pile = l_nouvelle_base_pile; 769: } 770: else if (strcmp(instruction, "FORALL") == 0) 771: { 772: if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, 773: AN_FORALL)) == NULL) 774: { 775: liberation_analyse(l_base_pile); 776: 777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 778: return(d_erreur); 779: } 780: 781: l_base_pile = l_nouvelle_base_pile; 782: } 783: else if (strcmp(instruction, "NEXT") == 0) 784: { 785: if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && 786: (test_analyse(l_base_pile, AN_FORALL) == d_faux) && 787: (test_analyse(l_base_pile, AN_START) == d_faux)) 788: { 789: liberation_analyse(l_base_pile); 790: 791: (*s_etat_processus).autorisation_empilement_programme = 792: registre; 793: 794: (*s_etat_processus).erreur_compilation = 795: d_ec_erreur_boucle_definie; 796: return(d_erreur); 797: } 798: 799: l_base_pile = depilement_analyse(l_base_pile); 800: } 801: else if (strcmp(instruction, "STEP") == 0) 802: { 803: if ((test_analyse(l_base_pile, AN_FOR) == d_faux) && 804: (test_analyse(l_base_pile, AN_START) == d_faux)) 805: { 806: liberation_analyse(l_base_pile); 807: 808: (*s_etat_processus).autorisation_empilement_programme = 809: registre; 810: 811: (*s_etat_processus).erreur_compilation = 812: d_ec_erreur_boucle_definie; 813: return(d_erreur); 814: } 815: 816: l_base_pile = depilement_analyse(l_base_pile); 817: } 818: 819: // Invalidation de l'instruction courante dans le fichier rpl-core 820: free((*s_etat_processus).instruction_courante); 821: (*s_etat_processus).instruction_courante = NULL; 822: free(instruction); 823: } 824: 825: (*s_etat_processus).autorisation_empilement_programme = registre; 826: 827: if (l_base_pile != NULL) 828: { 829: liberation_analyse(l_base_pile); 830: 831: (*s_etat_processus).autorisation_empilement_programme = registre; 832: (*s_etat_processus).erreur_compilation = d_ec_source_incoherent; 833: return(d_erreur); 834: } 835: 836: return(d_absence_erreur); 837: } 838: 839: 840: /* 841: ================================================================================ 842: Procédure de d'analyse syntaxique du source pour readline 843: ================================================================================ 844: Entrées : 845: -------------------------------------------------------------------------------- 846: Sorties : 847: - rl_done à 0 ou à 1. 848: -------------------------------------------------------------------------------- 849: Effets de bord : 850: ================================================================================ 851: */ 852: 853: static char *ligne = NULL; 854: static unsigned int niveau = 0; 855: 856: int 857: readline_analyse_syntaxique(int count, int key) 858: { 859: char prompt[] = "+ %03d> "; 860: char prompt2[8]; 861: char *registre; 862: 863: struct_processus s_etat_processus; 864: 865: if ((*rl_line_buffer) == d_code_fin_chaine) 866: { 867: if (ligne == NULL) 868: { 869: rl_done = 1; 870: } 871: else 872: { 873: rl_done = 0; 874: } 875: } 876: else 877: { 878: if (ligne == NULL) 879: { 880: if ((ligne = malloc((strlen(rl_line_buffer) + 1) 881: * sizeof(char))) == NULL) 882: { 883: rl_done = 1; 884: return(0); 885: } 886: 887: strcpy(ligne, rl_line_buffer); 888: } 889: else 890: { 891: registre = ligne; 892: 893: if ((ligne = malloc((strlen(registre) 894: + strlen(rl_line_buffer) + 2) * sizeof(char))) == NULL) 895: { 896: rl_done = 1; 897: return(0); 898: } 899: 900: sprintf(ligne, "%s %s", registre, rl_line_buffer); 901: } 902: 903: rl_replace_line("", 1); 904: 905: s_etat_processus.definitions_chainees = ligne; 906: s_etat_processus.debug = d_faux; 907: s_etat_processus.erreur_systeme = d_es; 908: s_etat_processus.erreur_execution = d_ex; 909: 910: if (analyse_syntaxique(&s_etat_processus) == d_absence_erreur) 911: { 912: rl_done = 1; 913: } 914: else 915: { 916: if (s_etat_processus.erreur_systeme != d_es) 917: { 918: rl_done = 1; 919: } 920: else 921: { 922: rl_done = 0; 923: rl_crlf(); 924: 925: sprintf(prompt2, prompt, ++niveau); 926: 927: rl_expand_prompt(prompt2); 928: rl_on_new_line(); 929: } 930: } 931: } 932: 933: if (rl_done != 0) 934: { 935: uprintf("\n"); 936: 937: if (ligne != NULL) 938: { 939: rl_replace_line(ligne, 1); 940: 941: free(ligne); 942: ligne = NULL; 943: } 944: 945: niveau = 0; 946: } 947: 948: return(0); 949: } 950: 951: int 952: readline_effacement(int count, int key) 953: { 954: rl_done = 0; 955: rl_replace_line("", 1); 956: 957: free(ligne); 958: ligne = NULL; 959: niveau = 0; 960: 961: uprintf("^G\n"); 962: rl_expand_prompt("RPL/2> "); 963: rl_on_new_line(); 964: return(0); 965: } 966: 967: 968: /* 969: ================================================================================ 970: Routine d'échange de deux variables 971: ================================================================================ 972: Entrées : 973: - pointeurs génériques sur les deux variables, 974: - longueur en octet des objets à permuter. 975: -------------------------------------------------------------------------------- 976: Sorties : idem. 977: -------------------------------------------------------------------------------- 978: Effets de bord : néant. 979: ================================================================================ 980: */ 981: 982: void 983: swap(void *variable_1, void *variable_2, integer8 taille) 984: { 985: register unsigned char *t_var_1; 986: register unsigned char *t_var_2; 987: register unsigned char variable_temporaire; 988: 989: register integer8 i; 990: 991: t_var_1 = (unsigned char *) variable_1; 992: t_var_2 = (unsigned char *) variable_2; 993: 994: for(i = 0; i < taille; i++) 995: { 996: variable_temporaire = (*t_var_1); 997: (*(t_var_1++)) = (*t_var_2); 998: (*(t_var_2++)) = variable_temporaire; 999: } 1000: 1001: return; 1002: } 1003: 1004: 1005: /* 1006: ================================================================================ 1007: Routine recherchant l'instruction suivante dans le programme compilé 1008: ================================================================================ 1009: Entrée : 1010: -------------------------------------------------------------------------------- 1011: Sortie : 1012: -------------------------------------------------------------------------------- 1013: Effets de bord : néant. 1014: ================================================================================ 1015: */ 1016: 1017: logical1 1018: recherche_instruction_suivante(struct_processus *s_etat_processus) 1019: { 1020: enum t_type registre_type_en_cours; 1021: 1022: logical1 drapeau_fin_objet; 1023: logical1 erreur; 1024: 1025: int erreur_analyse; 1026: int erreur_format; 1027: 1028: unsigned char base_binaire; 1029: unsigned char caractere_fin; 1030: unsigned char *pointeur_caractere_courant; 1031: unsigned char *pointeur_caractere_destination; 1032: unsigned char *pointeur_debut_instruction; 1033: unsigned char *pointeur_fin_instruction; 1034: 1035: signed long niveau; 1036: 1037: erreur_analyse = d_ex; 1038: erreur_format = d_ex; 1039: erreur = d_absence_erreur; 1040: 1041: switch((*s_etat_processus).type_en_cours) 1042: { 1043: case RPN: 1044: { 1045: caractere_fin = '>'; 1046: break; 1047: } 1048: 1049: case LST: 1050: { 1051: caractere_fin = '}'; 1052: break; 1053: } 1054: 1055: case TBL: 1056: { 1057: caractere_fin = ']'; 1058: break; 1059: } 1060: 1061: default: 1062: { 1063: caractere_fin = d_code_espace; 1064: break; 1065: } 1066: } 1067: 1068: drapeau_fin_objet = d_faux; 1069: niveau = 0; 1070: 1071: pointeur_caractere_courant = (*s_etat_processus).definitions_chainees + 1072: (*s_etat_processus).position_courante; 1073: 1074: while(((*pointeur_caractere_courant) == d_code_espace) && 1075: ((*pointeur_caractere_courant) != d_code_fin_chaine)) 1076: { 1077: pointeur_caractere_courant++; 1078: } 1079: 1080: if ((*pointeur_caractere_courant) == d_code_fin_chaine) 1081: { 1082: (*s_etat_processus).instruction_courante = (unsigned char *) 1083: malloc(sizeof(unsigned char)); 1084: 1085: if ((*s_etat_processus).instruction_courante == NULL) 1086: { 1087: erreur = d_erreur; 1088: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1089: } 1090: else 1091: { 1092: erreur = d_absence_erreur; 1093: (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine; 1094: (*s_etat_processus).position_courante = pointeur_caractere_courant 1095: - (*s_etat_processus).definitions_chainees; 1096: } 1097: 1098: return(erreur); 1099: } 1100: 1101: pointeur_debut_instruction = pointeur_caractere_courant; 1102: 1103: while(((*pointeur_caractere_courant) != d_code_espace) && 1104: ((*pointeur_caractere_courant) != d_code_fin_chaine) && 1105: (drapeau_fin_objet == d_faux) && 1106: (erreur_analyse == d_ex) && (erreur_format == d_ex)) 1107: { 1108: switch(*pointeur_caractere_courant++) 1109: { 1110: case ']' : 1111: case '}' : 1112: { 1113: break; 1114: } 1115: 1116: case ')' : 1117: { 1118: erreur_format = d_ex_syntaxe; 1119: break; 1120: } 1121: 1122: case '"' : 1123: { 1124: if (pointeur_debut_instruction != 1125: (pointeur_caractere_courant - 1)) 1126: { 1127: erreur_format = d_ex_syntaxe; 1128: } 1129: 1130: while((*pointeur_caractere_courant != '"') && 1131: ((*pointeur_caractere_courant) != d_code_fin_chaine)) 1132: { 1133: if (*pointeur_caractere_courant == '\\') 1134: { 1135: pointeur_caractere_courant++; 1136: 1137: switch(*pointeur_caractere_courant) 1138: { 1139: case '\\' : 1140: case '"' : 1141: { 1142: pointeur_caractere_courant++; 1143: break; 1144: } 1145: } 1146: } 1147: else 1148: { 1149: pointeur_caractere_courant++; 1150: } 1151: } 1152: 1153: if ((*pointeur_caractere_courant) != '"') 1154: { 1155: erreur_analyse = d_ex_syntaxe; 1156: } 1157: 1158: if (erreur_analyse == d_ex) 1159: { 1160: pointeur_caractere_courant++; 1161: } 1162: 1163: drapeau_fin_objet = d_vrai; 1164: break; 1165: } 1166: 1167: case '\'' : 1168: { 1169: if (pointeur_debut_instruction != 1170: (pointeur_caractere_courant - 1)) 1171: { 1172: erreur_format = d_ex_syntaxe; 1173: } 1174: 1175: while(((*pointeur_caractere_courant) != '\'') && 1176: ((*pointeur_caractere_courant) != d_code_fin_chaine)) 1177: { 1178: if ((*pointeur_caractere_courant) == '(') 1179: { 1180: niveau++; 1181: } 1182: else if ((*pointeur_caractere_courant) == ')') 1183: { 1184: niveau--; 1185: } 1186: 1187: pointeur_caractere_courant++; 1188: } 1189: 1190: if ((*pointeur_caractere_courant) != '\'') 1191: { 1192: erreur_analyse = d_ex_syntaxe; 1193: } 1194: else if (niveau != 0) 1195: { 1196: erreur_analyse = d_ex_syntaxe; 1197: } 1198: 1199: if (erreur_analyse == d_ex) 1200: { 1201: pointeur_caractere_courant++; 1202: } 1203: 1204: drapeau_fin_objet = d_vrai; 1205: break; 1206: } 1207: 1208: case '(' : 1209: { 1210: if (pointeur_debut_instruction != 1211: (pointeur_caractere_courant - 1)) 1212: { 1213: erreur_format = d_ex_syntaxe; 1214: } 1215: 1216: while(((*pointeur_caractere_courant) != ')') && 1217: ((*pointeur_caractere_courant) != d_code_fin_chaine) 1218: && (erreur_analyse == d_ex)) 1219: { 1220: switch(*pointeur_caractere_courant) 1221: { 1222: case '0' : 1223: case '1' : 1224: case '2' : 1225: case '3' : 1226: case '4' : 1227: case '5' : 1228: case '6' : 1229: case '7' : 1230: case '8' : 1231: case '9' : 1232: case 'e' : 1233: case 'E' : 1234: case ',' : 1235: case '.' : 1236: case ' ' : 1237: case '-' : 1238: case '+' : 1239: case ')' : 1240: { 1241: break; 1242: } 1243: 1244: default : 1245: { 1246: erreur_analyse = d_ex_syntaxe; 1247: break; 1248: } 1249: } 1250: 1251: pointeur_caractere_courant++; 1252: } 1253: 1254: if ((*pointeur_caractere_courant) != ')') 1255: { 1256: erreur_analyse = d_ex_syntaxe; 1257: } 1258: 1259: if (erreur_analyse == d_ex) 1260: { 1261: pointeur_caractere_courant++; 1262: } 1263: 1264: drapeau_fin_objet = d_vrai; 1265: break; 1266: } 1267: 1268: case '#' : 1269: { 1270: if (pointeur_debut_instruction != 1271: (pointeur_caractere_courant - 1)) 1272: { 1273: erreur_format = d_ex_syntaxe; 1274: } 1275: 1276: while(((*pointeur_caractere_courant) != 'b') && 1277: ((*pointeur_caractere_courant) != 'o') && 1278: ((*pointeur_caractere_courant) != 'd') && 1279: ((*pointeur_caractere_courant) != 'h') && 1280: ((*pointeur_caractere_courant) != 1281: d_code_fin_chaine) && 1282: (erreur_analyse == d_ex)) 1283: { 1284: switch(*pointeur_caractere_courant) 1285: { 1286: case ' ' : 1287: case '0' : 1288: case '1' : 1289: case '2' : 1290: case '3' : 1291: case '4' : 1292: case '5' : 1293: case '6' : 1294: case '7' : 1295: case '8' : 1296: case '9' : 1297: case 'A' : 1298: case 'B' : 1299: case 'C' : 1300: case 'D' : 1301: case 'E' : 1302: case 'F' : 1303: case 'b' : 1304: case 'o' : 1305: case 'd' : 1306: case 'h' : 1307: { 1308: break; 1309: } 1310: 1311: default : 1312: { 1313: erreur_analyse = d_ex_syntaxe; 1314: break; 1315: } 1316: } 1317: 1318: pointeur_caractere_courant++; 1319: } 1320: 1321: base_binaire = (*pointeur_caractere_courant); 1322: pointeur_caractere_courant++; 1323: 1324: if (((*pointeur_caractere_courant) != d_code_fin_chaine) && 1325: ((*pointeur_caractere_courant) != d_code_espace) && 1326: ((*pointeur_caractere_courant) != caractere_fin)) 1327: { 1328: erreur_analyse = d_ex_syntaxe; 1329: } 1330: else 1331: { 1332: pointeur_caractere_courant = pointeur_debut_instruction + 1; 1333: 1334: switch(base_binaire) 1335: { 1336: case 'b' : 1337: case 'o' : 1338: case 'd' : 1339: case 'h' : 1340: { 1341: break; 1342: } 1343: 1344: default : 1345: { 1346: erreur_analyse = d_ex_syntaxe; 1347: break; 1348: } 1349: } 1350: } 1351: 1352: while(((*pointeur_caractere_courant) != base_binaire) && 1353: ((*pointeur_caractere_courant) != d_code_fin_chaine) && 1354: (erreur_analyse == d_ex)) 1355: { 1356: if (base_binaire == 'b') 1357: { 1358: switch(*pointeur_caractere_courant) 1359: { 1360: case ' ' : 1361: case '0' : 1362: case '1' : 1363: { 1364: break; 1365: } 1366: 1367: default : 1368: { 1369: erreur_analyse = d_ex_syntaxe; 1370: break; 1371: } 1372: } 1373: } 1374: else if (base_binaire == 'o') 1375: { 1376: switch(*pointeur_caractere_courant) 1377: { 1378: case ' ' : 1379: case '0' : 1380: case '1' : 1381: case '2' : 1382: case '3' : 1383: case '4' : 1384: case '5' : 1385: case '6' : 1386: case '7' : 1387: { 1388: break; 1389: } 1390: 1391: default : 1392: { 1393: erreur_analyse = d_ex_syntaxe; 1394: break; 1395: } 1396: } 1397: } 1398: else if (base_binaire == 'd') 1399: { 1400: switch(*pointeur_caractere_courant) 1401: { 1402: case ' ' : 1403: case '0' : 1404: case '1' : 1405: case '2' : 1406: case '3' : 1407: case '4' : 1408: case '5' : 1409: case '6' : 1410: case '7' : 1411: case '8' : 1412: case '9' : 1413: { 1414: break; 1415: } 1416: 1417: default : 1418: { 1419: erreur_analyse = d_ex_syntaxe; 1420: break; 1421: } 1422: } 1423: } 1424: else if (base_binaire != 'h') 1425: { 1426: erreur_analyse = d_ex_syntaxe; 1427: } 1428: 1429: pointeur_caractere_courant++; 1430: } 1431: 1432: if (erreur_analyse == d_ex) 1433: { 1434: pointeur_caractere_courant++; 1435: } 1436: 1437: drapeau_fin_objet = d_vrai; 1438: break; 1439: } 1440: 1441: case '{' : 1442: { 1443: if (pointeur_debut_instruction != 1444: (pointeur_caractere_courant - 1)) 1445: { 1446: erreur_format = d_ex_syntaxe; 1447: } 1448: 1449: niveau = 1; 1450: 1451: while((niveau != 0) && ((*pointeur_caractere_courant) != 1452: d_code_fin_chaine)) 1453: { 1454: (*s_etat_processus).position_courante = 1455: pointeur_caractere_courant 1456: - (*s_etat_processus).definitions_chainees; 1457: 1458: registre_type_en_cours = (*s_etat_processus).type_en_cours; 1459: (*s_etat_processus).type_en_cours = LST; 1460: 1461: if (recherche_instruction_suivante(s_etat_processus) 1462: == d_erreur) 1463: { 1464: (*s_etat_processus).type_en_cours = 1465: registre_type_en_cours; 1466: 1467: if ((*s_etat_processus).instruction_courante 1468: != NULL) 1469: { 1470: free((*s_etat_processus).instruction_courante); 1471: (*s_etat_processus).instruction_courante = NULL; 1472: } 1473: 1474: return(d_erreur); 1475: } 1476: 1477: pointeur_caractere_courant = 1478: (*s_etat_processus).definitions_chainees + 1479: (*s_etat_processus).position_courante; 1480: 1481: if (strcmp((*s_etat_processus).instruction_courante, "}") 1482: == 0) 1483: { 1484: niveau--; 1485: } 1486: 1487: free((*s_etat_processus).instruction_courante); 1488: } 1489: 1490: if (niveau != 0) 1491: { 1492: erreur_analyse = d_ex_syntaxe; 1493: } 1494: 1495: drapeau_fin_objet = d_vrai; 1496: break; 1497: } 1498: 1499: case '[' : 1500: { 1501: if (pointeur_debut_instruction != 1502: (pointeur_caractere_courant - 1)) 1503: { 1504: erreur_format = d_ex_syntaxe; 1505: } 1506: 1507: niveau = 1; 1508: 1509: while((niveau > 0) && ((*pointeur_caractere_courant) != 1510: d_code_fin_chaine) && (erreur_analyse == d_ex)) 1511: { 1512: switch(*pointeur_caractere_courant) 1513: { 1514: case '[' : 1515: { 1516: niveau++; 1517: break; 1518: } 1519: 1520: case ']' : 1521: { 1522: niveau--; 1523: break; 1524: } 1525: 1526: case '0' : 1527: case '1' : 1528: case '2' : 1529: case '3' : 1530: case '4' : 1531: case '5' : 1532: case '6' : 1533: case '7' : 1534: case '8' : 1535: case '9' : 1536: case '+' : 1537: case '-' : 1538: case 'e' : 1539: case 'E' : 1540: case '.' : 1541: case ',' : 1542: case '(' : 1543: case ')' : 1544: case ' ' : 1545: { 1546: break; 1547: } 1548: 1549: default : 1550: { 1551: erreur_analyse = d_ex_syntaxe; 1552: break; 1553: } 1554: } 1555: 1556: if (niveau < 0) 1557: { 1558: erreur_analyse = d_ex_syntaxe; 1559: } 1560: else if (niveau > 2) 1561: { 1562: erreur_format = d_ex_syntaxe; 1563: } 1564: 1565: pointeur_caractere_courant++; 1566: } 1567: 1568: if (niveau != 0) 1569: { 1570: erreur_analyse = d_ex_syntaxe; 1571: } 1572: 1573: drapeau_fin_objet = d_vrai; 1574: break; 1575: } 1576: 1577: case '<' : 1578: { 1579: if (((*s_etat_processus).autorisation_empilement_programme 1580: == 'Y') && ((*pointeur_caractere_courant) == '<')) 1581: { // Cas << >> 1582: if (pointeur_debut_instruction != 1583: (pointeur_caractere_courant - 1)) 1584: { 1585: erreur_format = d_ex_syntaxe; 1586: } 1587: 1588: niveau = 1; 1589: 1590: while((niveau != 0) && ((*pointeur_caractere_courant) != 1591: d_code_fin_chaine)) 1592: { 1593: (*s_etat_processus).position_courante = 1594: pointeur_caractere_courant 1595: - (*s_etat_processus).definitions_chainees; 1596: 1597: registre_type_en_cours = (*s_etat_processus) 1598: .type_en_cours; 1599: (*s_etat_processus).type_en_cours = RPN; 1600: 1601: if (recherche_instruction_suivante(s_etat_processus) 1602: == d_erreur) 1603: { 1604: (*s_etat_processus).type_en_cours = 1605: registre_type_en_cours; 1606: 1607: if ((*s_etat_processus).instruction_courante 1608: != NULL) 1609: { 1610: free((*s_etat_processus).instruction_courante); 1611: (*s_etat_processus).instruction_courante = NULL; 1612: } 1613: 1614: return(d_erreur); 1615: } 1616: 1617: (*s_etat_processus).type_en_cours = 1618: registre_type_en_cours; 1619: pointeur_caractere_courant = 1620: (*s_etat_processus).definitions_chainees + 1621: (*s_etat_processus).position_courante; 1622: 1623: if (strcmp((*s_etat_processus).instruction_courante, 1624: "<<") == 0) 1625: { 1626: niveau++; 1627: } 1628: else if (strcmp((*s_etat_processus) 1629: .instruction_courante, ">>") == 0) 1630: { 1631: niveau--; 1632: } 1633: 1634: free((*s_etat_processus).instruction_courante); 1635: } 1636: 1637: if (niveau != 0) 1638: { 1639: erreur_analyse = d_ex_syntaxe; 1640: } 1641: 1642: drapeau_fin_objet = d_vrai; 1643: } 1644: else if ((*pointeur_caractere_courant) == '[') 1645: { // Cas <[ ]> 1646: if (pointeur_debut_instruction != 1647: (pointeur_caractere_courant - 1)) 1648: { 1649: erreur_format = d_ex_syntaxe; 1650: } 1651: 1652: pointeur_caractere_courant++; 1653: drapeau_fin_objet = d_faux; 1654: 1655: while(((*pointeur_caractere_courant) != d_code_fin_chaine) 1656: && (erreur_format == d_absence_erreur)) 1657: { 1658: while((*pointeur_caractere_courant) == d_code_espace) 1659: { 1660: pointeur_caractere_courant++; 1661: } 1662: 1663: if ((*pointeur_caractere_courant) == ']') 1664: { 1665: if ((*(++pointeur_caractere_courant)) == '>') 1666: { 1667: drapeau_fin_objet = d_vrai; 1668: } 1669: else 1670: { 1671: erreur_analyse = d_ex_syntaxe; 1672: } 1673: 1674: pointeur_caractere_courant++; 1675: break; 1676: } 1677: 1678: if ((erreur_format == d_absence_erreur) && 1679: (drapeau_fin_objet == d_faux)) 1680: { 1681: (*s_etat_processus).position_courante = 1682: pointeur_caractere_courant 1683: - (*s_etat_processus).definitions_chainees; 1684: 1685: registre_type_en_cours = (*s_etat_processus) 1686: .type_en_cours; 1687: (*s_etat_processus).type_en_cours = TBL; 1688: 1689: if ((erreur = recherche_instruction_suivante( 1690: s_etat_processus)) != d_absence_erreur) 1691: { 1692: (*s_etat_processus).type_en_cours = 1693: registre_type_en_cours; 1694: 1695: if ((*s_etat_processus).instruction_courante 1696: != NULL) 1697: { 1698: free((*s_etat_processus) 1699: .instruction_courante); 1700: (*s_etat_processus).instruction_courante 1701: = NULL; 1702: } 1703: 1704: return(d_erreur); 1705: } 1706: 1707: (*s_etat_processus).type_en_cours = 1708: registre_type_en_cours; 1709: pointeur_caractere_courant = (*s_etat_processus) 1710: .definitions_chainees + (*s_etat_processus) 1711: .position_courante; 1712: 1713: free((*s_etat_processus).instruction_courante); 1714: } 1715: } 1716: 1717: if (drapeau_fin_objet == d_faux) 1718: { 1719: erreur_analyse = d_ex_syntaxe; 1720: drapeau_fin_objet = d_vrai; 1721: } 1722: } 1723: 1724: break; 1725: } 1726: } 1727: 1728: if ((*pointeur_caractere_courant) == caractere_fin) 1729: { 1730: break; 1731: } 1732: } 1733: 1734: pointeur_fin_instruction = pointeur_caractere_courant; 1735: 1736: (*s_etat_processus).instruction_courante = (unsigned char *) 1737: malloc((((size_t) (pointeur_fin_instruction 1738: - pointeur_debut_instruction)) + 1) * sizeof(unsigned char)); 1739: 1740: if ((*s_etat_processus).instruction_courante == NULL) 1741: { 1742: erreur = d_erreur; 1743: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1744: } 1745: else if (pointeur_fin_instruction != pointeur_debut_instruction) 1746: { 1747: pointeur_caractere_courant = pointeur_debut_instruction; 1748: pointeur_caractere_destination = 1749: (*s_etat_processus).instruction_courante; 1750: 1751: do 1752: { 1753: *pointeur_caractere_destination++ = *pointeur_caractere_courant++; 1754: } while(pointeur_caractere_courant < pointeur_fin_instruction); 1755: 1756: (*pointeur_caractere_destination) = d_code_fin_chaine; 1757: 1758: erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex)) 1759: ? d_absence_erreur : d_erreur; 1760: (*s_etat_processus).erreur_execution = erreur_analyse; 1761: } 1762: else 1763: { 1764: (*(*s_etat_processus).instruction_courante) = d_code_fin_chaine; 1765: } 1766: 1767: uprintf("%c %s\n", caractere_fin, (*s_etat_processus).instruction_courante); 1768: (*s_etat_processus).position_courante = pointeur_fin_instruction 1769: - (*s_etat_processus).definitions_chainees; 1770: 1771: return(erreur); 1772: } 1773: 1774: 1775: /* 1776: ================================================================================ 1777: Routine mettant la chaine d'entrée en majuscule 1778: ================================================================================ 1779: Entrée : pointeur sur une chaine en minuscules. 1780: -------------------------------------------------------------------------------- 1781: Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné 1782: est nul, il s'est produit une erreur. L'allocation est faite dans la 1783: routine. 1784: -------------------------------------------------------------------------------- 1785: Effets de bord : néant. 1786: ================================================================================ 1787: */ 1788: 1789: unsigned char * 1790: conversion_majuscule(unsigned char *chaine) 1791: { 1792: register unsigned char *caractere_courant; 1793: register unsigned char *caractere_courant_converti; 1794: register unsigned char *chaine_convertie; 1795: 1796: integer8 longueur_chaine_plus_terminaison; 1797: 1798: longueur_chaine_plus_terminaison = 0; 1799: caractere_courant = chaine; 1800: 1801: while((*caractere_courant) != d_code_fin_chaine) 1802: { 1803: caractere_courant++; 1804: longueur_chaine_plus_terminaison++; 1805: } 1806: 1807: caractere_courant = chaine; 1808: caractere_courant_converti = chaine_convertie = (unsigned char *) malloc( 1809: ((size_t) (longueur_chaine_plus_terminaison + 1)) 1810: * sizeof(unsigned char)); 1811: 1812: if (chaine_convertie != NULL) 1813: { 1814: while((*caractere_courant) != d_code_fin_chaine) 1815: { 1816: if (isalpha((*caractere_courant))) 1817: { 1818: (*caractere_courant_converti) = (unsigned char) 1819: toupper((*caractere_courant)); 1820: } 1821: else 1822: { 1823: (*caractere_courant_converti) = (*caractere_courant); 1824: } 1825: 1826: caractere_courant++; 1827: caractere_courant_converti++; 1828: } 1829: 1830: (*caractere_courant_converti) = d_code_fin_chaine; 1831: } 1832: 1833: return(chaine_convertie); 1834: } 1835: 1836: void 1837: conversion_majuscule_limitee(unsigned char *chaine_entree, 1838: unsigned char *chaine_sortie, integer8 longueur) 1839: { 1840: integer8 i; 1841: 1842: for(i = 0; i < longueur; i++) 1843: { 1844: if (isalpha((*chaine_entree))) 1845: { 1846: (*chaine_sortie) = (unsigned char) toupper((*chaine_entree)); 1847: } 1848: else 1849: { 1850: (*chaine_sortie) = (*chaine_entree); 1851: } 1852: 1853: if ((*chaine_entree) == d_code_fin_chaine) 1854: { 1855: break; 1856: } 1857: 1858: chaine_entree++; 1859: chaine_sortie++; 1860: } 1861: 1862: return; 1863: } 1864: 1865: 1866: /* 1867: ================================================================================ 1868: Initialisation de l'état du calculateur 1869: Configuration par défaut d'un calculateur HP-28S 1870: ================================================================================ 1871: Entrée : pointeur sur la structure struct_processus 1872: -------------------------------------------------------------------------------- 1873: Sortie : néant 1874: -------------------------------------------------------------------------------- 1875: Effets de bord : néant 1876: ================================================================================ 1877: */ 1878: 1879: void 1880: initialisation_drapeaux(struct_processus *s_etat_processus) 1881: { 1882: unsigned long i; 1883: 1884: for(i = 0; i < 31; cf(s_etat_processus, (unsigned char) i++)); 1885: 1886: if ((*s_etat_processus).lancement_interactif == d_vrai) 1887: { 1888: sf(s_etat_processus, 31); 1889: /* LAST autorisé */ 1890: } 1891: else 1892: { 1893: cf(s_etat_processus, 31); 1894: /* LAST invalidé */ 1895: } 1896: 1897: cf(s_etat_processus, 32); /* Impression automatique */ 1898: cf(s_etat_processus, 33); /* CR automatique (disp) */ 1899: sf(s_etat_processus, 34); /* Évaluation des caractères de contrôle */ 1900: sf(s_etat_processus, 35); /* Évaluation symbolique des constantes */ 1901: sf(s_etat_processus, 36); /* Évaluation symbolique des fonctions */ 1902: sf(s_etat_processus, 37); /* Taille de mot pour les entiers binaires */ 1903: sf(s_etat_processus, 38); /* Taille de mot pour les entiers binaires */ 1904: sf(s_etat_processus, 39); /* Taille de mot pour les entiers binaires */ 1905: sf(s_etat_processus, 40); /* Taille de mot pour les entiers binaires */ 1906: sf(s_etat_processus, 41); /* Taille de mot pour les entiers binaires */ 1907: sf(s_etat_processus, 42); /* Taille de mot pour les entiers binaires */ 1908: /* 1909: 37 : bit de poids faible 1910: 42 : bit de poids fort 1911: Les six drapeaux peuvent être nuls. Dans ce cas, la longueur des mots 1912: binaires reste de un bit. 1913: */ 1914: cf(s_etat_processus, 43); /* Base de numération binaire */ 1915: cf(s_etat_processus, 44); /* Base de numération binaire */ 1916: /* 1917: 43 44 = 00 => décimal 1918: 43 44 = 01 => binaire 1919: 43 44 = 10 => octal 1920: 43 44 = 11 => hexadécimal 1921: */ 1922: sf(s_etat_processus, 45); /* Affichage multiligne du niveau 1 */ 1923: cf(s_etat_processus, 46); /* Réservé */ 1924: cf(s_etat_processus, 47); /* Réservé */ 1925: /* 1926: 46 et 47 réservés sur le calculateur HP28S 1927: 46 47 = 00 => système rectangulaire 1928: 46 47 = 01 => système cylindrique 1929: 46 47 = 10 => système sphérique 1930: */ 1931: cf(s_etat_processus, 48); /* Séparateur décimal */ 1932: cf(s_etat_processus, 49); /* Format des nombres réels */ 1933: cf(s_etat_processus, 50); /* Format des nombres réels */ 1934: /* 1935: 49 50 = 00 => standard 1936: 49 50 = 01 => scientifique 1937: 49 50 = 10 => virgule fixe 1938: 49 50 = 11 => ingénieur 1939: */ 1940: cf(s_etat_processus, 51); /* Tonalité */ 1941: cf(s_etat_processus, 52); /* REDRAW automatique */ 1942: cf(s_etat_processus, 53); /* Nombre de chiffres décimaux */ 1943: cf(s_etat_processus, 54); /* Nombre de chiffres décimaux */ 1944: cf(s_etat_processus, 55); /* Nombre de chiffres décimaux */ 1945: cf(s_etat_processus, 56); /* Nombre de chiffres décimaux */ 1946: /* 1947: 53 : bit de poids faible 1948: 56 : bit de poids fort 1949: */ 1950: cf(s_etat_processus, 57); /* Underflow traité normalement */ 1951: cf(s_etat_processus, 58); /* Overflow traité normalement */ 1952: sf(s_etat_processus, 59); /* Infinite result traité normalement */ 1953: sf(s_etat_processus, 60); /* Angles */ 1954: /* 1955: 60 = 0 => degrés 1956: 60 = 1 => radians 1957: */ 1958: cf(s_etat_processus, 61); /* Underflow- traité en exception */ 1959: cf(s_etat_processus, 62); /* Underflow+ traité en exception */ 1960: cf(s_etat_processus, 63); /* Overflow traité en exception */ 1961: cf(s_etat_processus, 64); /* Infinite result traité en exception */ 1962: } 1963: 1964: // vim: ts=4