![]() ![]() | ![]() |
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: Affectation automatique d'un type à des données 29: ================================================================================ 30: Entrées : structure sur l'état du processus 31: -------------------------------------------------------------------------------- 32: Sorties : Néant 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: recherche_type(struct_processus *s_etat_processus) 40: { 41: int nombre_elements_convertis; 42: 43: struct_liste_chainee *l_base_liste_fonctions; 44: struct_liste_chainee *l_base_liste_decomposition; 45: struct_liste_chainee *l_element_courant; 46: struct_liste_chainee *l_element_courant_fonctions; 47: struct_liste_chainee *l_element_precedent; 48: 49: struct_liste_pile_systeme *s_sauvegarde_pile; 50: 51: struct_objet *s_objet; 52: struct_objet *s_sous_objet; 53: 54: logical1 drapeau_chaine; 55: logical1 drapeau_complexe; 56: logical1 drapeau_matrice; 57: logical1 drapeau_reel; 58: logical1 drapeau_valeur_entiere; 59: logical1 drapeau_valeur_reelle; 60: logical1 erreur; 61: logical1 erreur_lecture_binaire; 62: 63: logical8 ancienne_valeur_base; 64: logical8 valeur_base; 65: 66: long coherence_liste; 67: 68: unsigned char autorisation_evaluation_nom; 69: unsigned char *definitions_chainees_precedentes; 70: unsigned char *fonction_majuscule; 71: unsigned char *instruction_majuscule; 72: unsigned char *ptr; 73: unsigned char *ptr_ecriture; 74: unsigned char *ptr_lecture; 75: unsigned char registre_instruction_valide; 76: unsigned char registre_interruption; 77: unsigned char registre_mode_execution_programme; 78: unsigned char registre_recherche_type; 79: unsigned char registre_test; 80: unsigned char registre_test_bis; 81: unsigned char *tampon; 82: unsigned char variable_implicite; 83: 84: unsigned long i; 85: unsigned long j; 86: unsigned long niveau; 87: unsigned long niveau_maximal; 88: unsigned long nombre_colonnes; 89: unsigned long nombre_egalites; 90: unsigned long nombre_elements; 91: unsigned long nombre_exposants; 92: unsigned long nombre_lignes; 93: unsigned long nombre_lignes_a_supprimer; 94: unsigned long nombre_points; 95: unsigned long nombre_virgules; 96: unsigned long position_courante; 97: unsigned long profondeur_finale; 98: unsigned long profondeur_initiale; 99: unsigned long sauvegarde_niveau_courant; 100: unsigned long sauvegarde_longueur_definitions_chainees; 101: 102: void *element; 103: 104: s_objet = (struct_objet *) malloc(sizeof(struct_objet)); 105: element = NULL; 106: nombre_egalites = 0; 107: i = 0; 108: 109: if (s_objet == NULL) 110: { 111: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 112: return; 113: } 114: 115: initialisation_objet(s_objet); 116: registre_test = (*s_etat_processus).test_instruction; 117: registre_instruction_valide = (*s_etat_processus).instruction_valide; 118: registre_interruption = (*s_etat_processus).traitement_interruptible; 119: (*s_etat_processus).test_instruction = 'Y'; 120: (*s_etat_processus).traitement_interruptible = 'N'; 121: 122: analyse(s_etat_processus, NULL); 123: 124: (*s_etat_processus).test_instruction = registre_test; 125: 126: if ((*s_etat_processus).instruction_valide == 'Y') 127: { 128: if ((*s_etat_processus).constante_symbolique == 'N') 129: { 130: if ((element = malloc(sizeof(struct_fonction))) == NULL) 131: { 132: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 133: (*s_etat_processus).traitement_interruptible = 134: registre_interruption; 135: return; 136: } 137: 138: (*((struct_fonction *) element)).nombre_arguments = 0; 139: (*((struct_fonction *) element)).prediction_saut = NULL; 140: 141: if ((*s_etat_processus).instruction_intrinseque == 'Y') 142: { 143: /* 144: * Les fonctions intrinsèques ne sont pas sensibles à la casse. 145: */ 146: 147: if (((*((struct_fonction *) element)).nom_fonction = 148: conversion_majuscule((*s_etat_processus) 149: .instruction_courante)) == NULL) 150: { 151: (*s_etat_processus).erreur_systeme = 152: d_es_allocation_memoire; 153: (*s_etat_processus).traitement_interruptible = 154: registre_interruption; 155: return; 156: } 157: } 158: else 159: { 160: if (((*((struct_fonction *) element)).nom_fonction = 161: malloc((strlen((*s_etat_processus).instruction_courante) 162: + 1) * sizeof(unsigned char))) == NULL) 163: { 164: (*s_etat_processus).erreur_systeme = 165: d_es_allocation_memoire; 166: (*s_etat_processus).traitement_interruptible = 167: registre_interruption; 168: return; 169: } 170: 171: strcpy((*((struct_fonction *) element)).nom_fonction, 172: (*s_etat_processus).instruction_courante); 173: } 174: 175: (*((struct_fonction *) element)).fonction = 176: analyse_instruction(s_etat_processus, 177: (*((struct_fonction *) element)).nom_fonction); 178: 179: (*s_objet).type = FCT; 180: (*s_objet).objet = element; 181: (*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL; 182: (*((struct_fonction *) (*s_objet).objet)).prediction_execution 183: = d_faux; 184: 185: if (empilement(s_etat_processus, 186: &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) 187: { 188: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 189: (*s_etat_processus).traitement_interruptible = 190: registre_interruption; 191: return; 192: } 193: } 194: else 195: { 196: if ((instruction_majuscule = conversion_majuscule( 197: (*s_etat_processus).instruction_courante)) == NULL) 198: { 199: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 200: (*s_etat_processus).traitement_interruptible = 201: registre_interruption; 202: return; 203: } 204: 205: if ((*s_etat_processus).constante_symbolique == 'Y') 206: { 207: registre_test_bis = (*s_etat_processus).test_instruction; 208: (*s_etat_processus).test_instruction = 'N'; 209: analyse(s_etat_processus, NULL); 210: (*s_etat_processus).test_instruction = registre_test_bis; 211: free(s_objet); 212: } 213: else 214: { 215: (*s_objet).type = NOM; 216: 217: if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL) 218: { 219: (*s_etat_processus).erreur_systeme = 220: d_es_allocation_memoire; 221: (*s_etat_processus).traitement_interruptible = 222: registre_interruption; 223: return; 224: } 225: 226: (*((struct_nom *) (*s_objet).objet)).symbole = d_faux; 227: 228: if (((*((struct_nom *) (*s_objet).objet)).nom = 229: (unsigned char *) malloc((strlen((*s_etat_processus) 230: .instruction_courante) + 1) * sizeof(unsigned char))) 231: == NULL) 232: { 233: (*s_etat_processus).erreur_systeme = 234: d_es_allocation_memoire; 235: (*s_etat_processus).traitement_interruptible = 236: registre_interruption; 237: return; 238: } 239: 240: strcpy((*((struct_nom *) (*s_objet).objet)).nom, 241: (*s_etat_processus).instruction_courante); 242: 243: if (empilement(s_etat_processus, 244: &((*s_etat_processus).l_base_pile), s_objet) == 245: d_erreur) 246: { 247: (*s_etat_processus).erreur_systeme = 248: d_es_allocation_memoire; 249: (*s_etat_processus).traitement_interruptible = 250: registre_interruption; 251: return; 252: } 253: } 254: 255: free(instruction_majuscule); 256: } 257: 258: (*s_etat_processus).instruction_valide = registre_instruction_valide; 259: (*s_etat_processus).traitement_interruptible = registre_interruption; 260: return; 261: } 262: 263: (*s_etat_processus).instruction_valide = registre_instruction_valide; 264: 265: switch(*((*s_etat_processus).instruction_courante)) 266: { 267: 268: /* 269: -------------------------------------------------------------------------------- 270: Complexe 271: -------------------------------------------------------------------------------- 272: */ 273: 274: case '(' : 275: { 276: (*s_objet).type = CPL; 277: 278: element = (void *) ((struct_complexe16 *) malloc( 279: sizeof(struct_complexe16))); 280: 281: if (element == NULL) 282: { 283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 284: (*s_etat_processus).traitement_interruptible = 285: registre_interruption; 286: return; 287: } 288: 289: conversion_format(s_etat_processus, 290: (*s_etat_processus).instruction_courante); 291: 292: sauvegarde_longueur_definitions_chainees = 293: (*s_etat_processus).longueur_definitions_chainees; 294: 295: tampon = (unsigned char *) malloc( 296: (((*s_etat_processus).longueur_definitions_chainees 297: = strlen((*s_etat_processus).instruction_courante) 298: + 4) + 1) * sizeof(unsigned char)); 299: 300: if (tampon == NULL) 301: { 302: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 303: (*s_etat_processus).traitement_interruptible = 304: registre_interruption; 305: return; 306: } 307: 308: strcpy(tampon, "<< "); 309: ptr_ecriture = tampon + 3; 310: ptr_lecture = (*s_etat_processus).instruction_courante + 1; 311: 312: nombre_virgules = 0; 313: 314: while((*ptr_lecture) != d_code_fin_chaine) 315: { 316: if ((*ptr_lecture) == ',') 317: { 318: (*ptr_lecture) = ' '; 319: nombre_virgules++; 320: } 321: 322: *ptr_ecriture++ = *ptr_lecture++; 323: } 324: 325: (*(--ptr_ecriture)) = d_code_fin_chaine; 326: strcat(ptr_ecriture, " >>"); 327: 328: position_courante = (*s_etat_processus).position_courante; 329: (*s_etat_processus).position_courante = 0; 330: 331: profondeur_initiale = (*s_etat_processus) 332: .hauteur_pile_operationnelle; 333: 334: /* 335: -- On met le tout dans la pile opérationnelle ---------------------------------- 336: */ 337: 338: (*s_etat_processus).niveau_recursivite++; 339: definitions_chainees_precedentes = (*s_etat_processus) 340: .definitions_chainees; 341: (*s_etat_processus).definitions_chainees = tampon; 342: 343: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; 344: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant; 345: 346: (*s_etat_processus).l_base_pile_systeme = NULL; 347: empilement_pile_systeme(s_etat_processus); 348: 349: if ((*s_etat_processus).erreur_systeme != d_es) 350: { 351: (*s_etat_processus).traitement_interruptible = 352: registre_interruption; 353: return; 354: } 355: 356: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; 357: (*s_etat_processus).niveau_courant = 0; 358: (*s_etat_processus).autorisation_empilement_programme = 'N'; 359: registre_mode_execution_programme = 360: (*s_etat_processus).mode_execution_programme; 361: (*s_etat_processus).mode_execution_programme = 'Y'; 362: 363: tampon = (*s_etat_processus).instruction_courante; 364: 365: if ((*s_etat_processus).profilage == d_vrai) 366: { 367: profilage(s_etat_processus, "RPL/2 internals"); 368: 369: if ((*s_etat_processus).erreur_systeme != d_es) 370: { 371: return; 372: } 373: } 374: 375: registre_recherche_type = (*s_etat_processus).recherche_type; 376: (*s_etat_processus).recherche_type = 'Y'; 377: 378: if (sequenceur(s_etat_processus) == d_erreur) 379: { 380: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 381: (*s_etat_processus).recherche_type = registre_recherche_type; 382: (*s_etat_processus).instruction_courante = tampon; 383: (*s_etat_processus).mode_execution_programme = 384: registre_mode_execution_programme; 385: 386: effacement_pile_systeme(s_etat_processus); 387: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 388: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 389: 390: (*s_etat_processus).niveau_recursivite--; 391: 392: (*s_etat_processus).position_courante = position_courante; 393: free((*s_etat_processus).definitions_chainees); 394: (*s_etat_processus).definitions_chainees = 395: definitions_chainees_precedentes; 396: (*s_etat_processus).longueur_definitions_chainees = 397: sauvegarde_longueur_definitions_chainees; 398: 399: free(element); 400: free(s_objet); 401: 402: (*s_etat_processus).traitement_interruptible = 403: registre_interruption; 404: return; 405: } 406: 407: (*s_etat_processus).recherche_type = registre_recherche_type; 408: (*s_etat_processus).instruction_courante = tampon; 409: (*s_etat_processus).mode_execution_programme = 410: registre_mode_execution_programme; 411: 412: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 413: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 414: 415: (*s_etat_processus).niveau_recursivite--; 416: 417: (*s_etat_processus).position_courante = position_courante; 418: free((*s_etat_processus).definitions_chainees); 419: (*s_etat_processus).definitions_chainees = 420: definitions_chainees_precedentes; 421: (*s_etat_processus).longueur_definitions_chainees = 422: sauvegarde_longueur_definitions_chainees; 423: 424: /* 425: -- On relit la pile pour remplir le complexe ----------------------------------- 426: */ 427: 428: profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle; 429: nombre_elements_convertis = profondeur_finale - profondeur_initiale; 430: 431: if ((nombre_elements_convertis != 2) || (nombre_virgules != 1)) 432: { 433: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 434: 435: free(s_objet); 436: free(element); 437: 438: for(i = 0; i < (unsigned long) nombre_elements_convertis; i++) 439: { 440: if (depilement(s_etat_processus, &((*s_etat_processus) 441: .l_base_pile), &s_sous_objet) == d_erreur) 442: { 443: (*s_etat_processus).traitement_interruptible = 444: registre_interruption; 445: return; 446: } 447: 448: liberation(s_etat_processus, s_sous_objet); 449: } 450: 451: (*s_etat_processus).traitement_interruptible = 452: registre_interruption; 453: return; 454: } 455: else 456: { 457: if (depilement(s_etat_processus, 458: &((*s_etat_processus).l_base_pile), &s_sous_objet) == 459: d_absence_erreur) 460: { 461: if ((*s_sous_objet).type == INT) 462: { 463: (*((struct_complexe16 *) element)).partie_imaginaire = 464: (*((integer8 *) (*s_sous_objet).objet)); 465: } 466: else if ((*s_sous_objet).type == REL) 467: { 468: (*((struct_complexe16 *) element)).partie_imaginaire = 469: (*((real8 *) (*s_sous_objet).objet)); 470: } 471: else 472: { 473: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 474: 475: free(element); 476: free(s_objet); 477: 478: liberation(s_etat_processus, s_sous_objet); 479: 480: (*s_etat_processus).traitement_interruptible = 481: registre_interruption; 482: return; 483: } 484: 485: liberation(s_etat_processus, s_sous_objet); 486: 487: if (depilement(s_etat_processus, 488: &((*s_etat_processus).l_base_pile), &s_sous_objet) 489: == d_absence_erreur) 490: { 491: if ((*s_sous_objet).type == INT) 492: { 493: (*((struct_complexe16 *) element)).partie_reelle = 494: (*((integer8 *) (*s_sous_objet).objet)); 495: } 496: else if ((*s_sous_objet).type == REL) 497: { 498: (*((struct_complexe16 *) element)).partie_reelle = 499: (*((real8 *) (*s_sous_objet).objet)); 500: } 501: else 502: { 503: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 504: 505: free(element); 506: free(s_objet); 507: 508: liberation(s_etat_processus, s_sous_objet); 509: 510: (*s_etat_processus).traitement_interruptible = 511: registre_interruption; 512: return; 513: } 514: 515: liberation(s_etat_processus, s_sous_objet); 516: } 517: } 518: } 519: 520: break; 521: } 522: 523: /* 524: -------------------------------------------------------------------------------- 525: Binaire 526: -------------------------------------------------------------------------------- 527: */ 528: 529: case '#' : 530: { 531: (*s_objet).type = BIN; 532: 533: element = (void *) ((logical8 *) malloc( 534: sizeof(logical8))); 535: 536: if (element == NULL) 537: { 538: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 539: (*s_etat_processus).traitement_interruptible = 540: registre_interruption; 541: return; 542: } 543: 544: erreur_lecture_binaire = d_faux; 545: 546: switch((*s_etat_processus).instruction_courante 547: [strlen((*s_etat_processus).instruction_courante) - 1]) 548: { 549: case 'b' : 550: { 551: i = strlen((*s_etat_processus).instruction_courante) - 2; 552: valeur_base = 1; 553: 554: (*((logical8 *) element)) = 0; 555: 556: while(i > 0) 557: { 558: if ((*s_etat_processus).instruction_courante[i] == '1') 559: { 560: (*((logical8 *) element)) += valeur_base; 561: } 562: else if ((*s_etat_processus).instruction_courante[i] 563: != '0') 564: { 565: if ((*s_etat_processus).instruction_courante[i] 566: == ' ') 567: { 568: while(i > 0) 569: { 570: if ((*s_etat_processus) 571: .instruction_courante[i] != ' ') 572: { 573: break; 574: } 575: 576: i--; 577: } 578: } 579: 580: if (i != 0) 581: { 582: free(element); 583: free(s_objet); 584: 585: (*s_etat_processus).erreur_execution = 586: d_ex_syntaxe; 587: (*s_etat_processus).traitement_interruptible = 588: registre_interruption; 589: return; 590: } 591: 592: break; 593: } 594: 595: ancienne_valeur_base = valeur_base; 596: valeur_base *= 2; 597: 598: if (ancienne_valeur_base > valeur_base) 599: { 600: i--; 601: 602: while(i > 0) 603: { 604: if ((*s_etat_processus).instruction_courante[i] 605: != ' ') 606: { 607: erreur_lecture_binaire = d_vrai; 608: } 609: 610: i--; 611: } 612: 613: break; 614: } 615: 616: i--; 617: } 618: 619: nombre_elements_convertis = 1; 620: break; 621: } 622: 623: case 'o' : 624: { 625: i = strlen((*s_etat_processus).instruction_courante) - 2; 626: valeur_base = 1; 627: 628: (*((logical8 *) element)) = 0; 629: 630: while(i > 0) 631: { 632: if ((*s_etat_processus).instruction_courante[i] == '1') 633: { 634: (*((logical8 *) element)) += valeur_base; 635: } 636: else if ((*s_etat_processus).instruction_courante[i] 637: == '2') 638: { 639: (*((logical8 *) element)) += 2 * valeur_base; 640: } 641: else if ((*s_etat_processus).instruction_courante[i] 642: == '3') 643: { 644: (*((logical8 *) element)) += 3 * valeur_base; 645: } 646: else if ((*s_etat_processus).instruction_courante[i] 647: == '4') 648: { 649: (*((logical8 *) element)) += 4 * valeur_base; 650: } 651: else if ((*s_etat_processus).instruction_courante[i] 652: == '5') 653: { 654: (*((logical8 *) element)) += 5 * valeur_base; 655: } 656: else if ((*s_etat_processus).instruction_courante[i] 657: == '6') 658: { 659: (*((logical8 *) element)) += 6 * valeur_base; 660: } 661: else if ((*s_etat_processus).instruction_courante[i] 662: == '7') 663: { 664: (*((logical8 *) element)) += 7 * valeur_base; 665: } 666: else if ((*s_etat_processus).instruction_courante[i] 667: != '0') 668: { 669: if ((*s_etat_processus).instruction_courante[i] 670: == ' ') 671: { 672: while(i > 0) 673: { 674: if ((*s_etat_processus) 675: .instruction_courante[i] != ' ') 676: { 677: break; 678: } 679: 680: i--; 681: } 682: } 683: 684: if (i != 0) 685: { 686: free(element); 687: free(s_objet); 688: 689: (*s_etat_processus).erreur_execution = 690: d_ex_syntaxe; 691: (*s_etat_processus).traitement_interruptible = 692: registre_interruption; 693: return; 694: } 695: 696: break; 697: } 698: 699: ancienne_valeur_base = valeur_base; 700: valeur_base *= 8; 701: 702: if (ancienne_valeur_base > valeur_base) 703: { 704: i--; 705: 706: while(i > 0) 707: { 708: if ((*s_etat_processus).instruction_courante[i] 709: != ' ') 710: { 711: erreur_lecture_binaire = d_vrai; 712: } 713: 714: i--; 715: } 716: 717: break; 718: } 719: 720: i--; 721: } 722: 723: nombre_elements_convertis = 1; 724: break; 725: } 726: 727: case 'd' : 728: { 729: i = strlen((*s_etat_processus).instruction_courante) - 2; 730: valeur_base = 1; 731: 732: (*((logical8 *) element)) = 0; 733: 734: while(i > 0) 735: { 736: if ((*s_etat_processus).instruction_courante[i] == '1') 737: { 738: (*((logical8 *) element)) += valeur_base; 739: } 740: else if ((*s_etat_processus).instruction_courante[i] 741: == '2') 742: { 743: (*((logical8 *) element)) += 2 * valeur_base; 744: } 745: else if ((*s_etat_processus).instruction_courante[i] 746: == '3') 747: { 748: (*((logical8 *) element)) += 3 * valeur_base; 749: } 750: else if ((*s_etat_processus).instruction_courante[i] 751: == '4') 752: { 753: (*((logical8 *) element)) += 4 * valeur_base; 754: } 755: else if ((*s_etat_processus).instruction_courante[i] 756: == '5') 757: { 758: (*((logical8 *) element)) += 5 * valeur_base; 759: } 760: else if ((*s_etat_processus).instruction_courante[i] 761: == '6') 762: { 763: (*((logical8 *) element)) += 6 * valeur_base; 764: } 765: else if ((*s_etat_processus).instruction_courante[i] 766: == '7') 767: { 768: (*((logical8 *) element)) += 7 * valeur_base; 769: } 770: else if ((*s_etat_processus).instruction_courante[i] 771: == '8') 772: { 773: (*((logical8 *) element)) += 8 * valeur_base; 774: } 775: else if ((*s_etat_processus).instruction_courante[i] 776: == '9') 777: { 778: (*((logical8 *) element)) += 9 * valeur_base; 779: } 780: else if ((*s_etat_processus).instruction_courante[i] 781: != '0') 782: { 783: if ((*s_etat_processus).instruction_courante[i] 784: == ' ') 785: { 786: while(i > 0) 787: { 788: if ((*s_etat_processus) 789: .instruction_courante[i] != ' ') 790: { 791: break; 792: } 793: 794: i--; 795: } 796: } 797: 798: if (i != 0) 799: { 800: free(element); 801: free(s_objet); 802: 803: (*s_etat_processus).erreur_execution = 804: d_ex_syntaxe; 805: (*s_etat_processus).traitement_interruptible = 806: registre_interruption; 807: return; 808: } 809: 810: break; 811: } 812: 813: ancienne_valeur_base = valeur_base; 814: valeur_base *= 10; 815: 816: if (ancienne_valeur_base > valeur_base) 817: { 818: i--; 819: 820: while(i > 0) 821: { 822: if ((*s_etat_processus).instruction_courante[i] 823: != ' ') 824: { 825: erreur_lecture_binaire = d_vrai; 826: } 827: 828: i--; 829: } 830: 831: break; 832: } 833: 834: i--; 835: } 836: 837: nombre_elements_convertis = 1; 838: break; 839: } 840: 841: case 'h' : 842: { 843: i = strlen((*s_etat_processus).instruction_courante) - 2; 844: valeur_base = 1; 845: 846: (*((logical8 *) element)) = 0; 847: 848: while(i > 0) 849: { 850: if ((*s_etat_processus).instruction_courante[i] == '1') 851: { 852: (*((logical8 *) element)) += valeur_base; 853: } 854: else if ((*s_etat_processus).instruction_courante[i] 855: == '2') 856: { 857: (*((logical8 *) element)) += 2 * valeur_base; 858: } 859: else if ((*s_etat_processus).instruction_courante[i] 860: == '3') 861: { 862: (*((logical8 *) element)) += 3 * valeur_base; 863: } 864: else if ((*s_etat_processus).instruction_courante[i] 865: == '4') 866: { 867: (*((logical8 *) element)) += 4 * valeur_base; 868: } 869: else if ((*s_etat_processus).instruction_courante[i] 870: == '5') 871: { 872: (*((logical8 *) element)) += 5 * valeur_base; 873: } 874: else if ((*s_etat_processus).instruction_courante[i] 875: == '6') 876: { 877: (*((logical8 *) element)) += 6 * valeur_base; 878: } 879: else if ((*s_etat_processus).instruction_courante[i] 880: == '7') 881: { 882: (*((logical8 *) element)) += 7 * valeur_base; 883: } 884: else if ((*s_etat_processus).instruction_courante[i] 885: == '8') 886: { 887: (*((logical8 *) element)) += 8 * valeur_base; 888: } 889: else if ((*s_etat_processus).instruction_courante[i] 890: == '9') 891: { 892: (*((logical8 *) element)) += 9 * valeur_base; 893: } 894: else if ((*s_etat_processus).instruction_courante[i] 895: == 'A') 896: { 897: (*((logical8 *) element)) += 10 * valeur_base; 898: } 899: else if ((*s_etat_processus).instruction_courante[i] 900: == 'B') 901: { 902: (*((logical8 *) element)) += 11 * valeur_base; 903: } 904: else if ((*s_etat_processus).instruction_courante[i] 905: == 'C') 906: { 907: (*((logical8 *) element)) += 12 * valeur_base; 908: } 909: else if ((*s_etat_processus).instruction_courante[i] 910: == 'D') 911: { 912: (*((logical8 *) element)) += 13 * valeur_base; 913: } 914: else if ((*s_etat_processus).instruction_courante[i] 915: == 'E') 916: { 917: (*((logical8 *) element)) += 14 * valeur_base; 918: } 919: else if ((*s_etat_processus).instruction_courante[i] 920: == 'F') 921: { 922: (*((logical8 *) element)) += 15 * valeur_base; 923: } 924: else if ((*s_etat_processus).instruction_courante[i] 925: != '0') 926: { 927: if ((*s_etat_processus).instruction_courante[i] 928: == ' ') 929: { 930: while(i > 0) 931: { 932: if ((*s_etat_processus) 933: .instruction_courante[i] != ' ') 934: { 935: break; 936: } 937: 938: i--; 939: } 940: } 941: 942: if (i != 0) 943: { 944: free(element); 945: free(s_objet); 946: 947: (*s_etat_processus).erreur_execution = 948: d_ex_syntaxe; 949: (*s_etat_processus).traitement_interruptible = 950: registre_interruption; 951: return; 952: } 953: 954: break; 955: } 956: 957: ancienne_valeur_base = valeur_base; 958: valeur_base *= 16; 959: 960: if (ancienne_valeur_base > valeur_base) 961: { 962: i--; 963: 964: while(i > 0) 965: { 966: if ((*s_etat_processus).instruction_courante[i] 967: != ' ') 968: { 969: erreur_lecture_binaire = d_vrai; 970: } 971: 972: i--; 973: } 974: 975: break; 976: } 977: 978: i--; 979: } 980: 981: nombre_elements_convertis = 1; 982: break; 983: } 984: 985: default : 986: { 987: nombre_elements_convertis = 0; 988: break; 989: } 990: } 991: 992: if ((nombre_elements_convertis != 1) || 993: (erreur_lecture_binaire == d_vrai)) 994: { 995: free(element); 996: free(s_objet); 997: 998: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 999: (*s_etat_processus).traitement_interruptible = 1000: registre_interruption; 1001: return; 1002: } 1003: 1004: break; 1005: } 1006: 1007: /* 1008: -------------------------------------------------------------------------------- 1009: Matrices ou vecteurs entiers, réels ou complexes 1010: -------------------------------------------------------------------------------- 1011: */ 1012: 1013: case '[' : 1014: { 1015: niveau = 0; 1016: niveau_maximal = 0; 1017: 1018: nombre_colonnes = 0; 1019: nombre_lignes = 0; 1020: 1021: drapeau_complexe = d_faux; 1022: drapeau_reel = d_faux; 1023: 1024: ptr = (*s_etat_processus).instruction_courante; 1025: 1026: while((*ptr) != d_code_fin_chaine) 1027: { 1028: switch(*ptr) 1029: { 1030: case '(' : 1031: case ')' : 1032: { 1033: drapeau_complexe = d_vrai; 1034: drapeau_reel = d_vrai; 1035: break; 1036: } 1037: 1038: case '.' : 1039: case 'E' : 1040: case 'e' : 1041: { 1042: drapeau_reel = d_vrai; 1043: break; 1044: } 1045: 1046: case '[' : 1047: { 1048: niveau_maximal = (++niveau); 1049: break; 1050: } 1051: 1052: case ']' : 1053: { 1054: niveau--; 1055: break; 1056: } 1057: } 1058: 1059: ptr++; 1060: } 1061: 1062: if (niveau != 0) 1063: { 1064: free(s_objet); 1065: 1066: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1067: (*s_etat_processus).traitement_interruptible = 1068: registre_interruption; 1069: return; 1070: } 1071: 1072: drapeau_matrice = (niveau_maximal == 2) ? d_vrai : d_faux; 1073: 1074: switch (drapeau_matrice) 1075: { 1076: 1077: /* 1078: -------------------------------------------------------------------------------- 1079: Vecteur 1080: -------------------------------------------------------------------------------- 1081: */ 1082: 1083: case d_faux : 1084: { 1085: 1086: /* 1087: -- Sauvegarde des paramètres du processus pour analyser le vecteur ------------- 1088: -- Analyse récursive en appelant l'interprète sur le vecteur moins ------------- 1089: -- ses délimiteurs ------------------------------------------------------------- 1090: */ 1091: 1092: sauvegarde_longueur_definitions_chainees = 1093: (*s_etat_processus).longueur_definitions_chainees; 1094: 1095: tampon = (unsigned char *) malloc( 1096: (((*s_etat_processus).longueur_definitions_chainees 1097: = strlen((*s_etat_processus).instruction_courante) 1098: + 4) + 1) * sizeof(unsigned char)); 1099: 1100: if (tampon == NULL) 1101: { 1102: (*s_etat_processus).erreur_systeme = 1103: d_es_allocation_memoire; 1104: (*s_etat_processus).traitement_interruptible = 1105: registre_interruption; 1106: return; 1107: } 1108: 1109: strcpy(tampon, "<< "); 1110: ptr_ecriture = tampon + 3; 1111: ptr_lecture = (*s_etat_processus).instruction_courante + 1; 1112: 1113: while((*ptr_lecture) != d_code_fin_chaine) 1114: { 1115: *ptr_ecriture++ = *ptr_lecture++; 1116: } 1117: 1118: (*(--ptr_ecriture)) = d_code_fin_chaine; 1119: strcat(ptr_ecriture, " >>"); 1120: 1121: position_courante = (*s_etat_processus).position_courante; 1122: (*s_etat_processus).position_courante = 0; 1123: 1124: profondeur_initiale = (*s_etat_processus) 1125: .hauteur_pile_operationnelle; 1126: 1127: /* 1128: -- On met le tout dans la pile opérationnelle ---------------------------------- 1129: */ 1130: 1131: (*s_etat_processus).niveau_recursivite++; 1132: definitions_chainees_precedentes = (*s_etat_processus) 1133: .definitions_chainees; 1134: (*s_etat_processus).definitions_chainees = tampon; 1135: 1136: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; 1137: sauvegarde_niveau_courant = (*s_etat_processus) 1138: .niveau_courant; 1139: 1140: (*s_etat_processus).l_base_pile_systeme = NULL; 1141: empilement_pile_systeme(s_etat_processus); 1142: 1143: if ((*s_etat_processus).erreur_systeme != d_es) 1144: { 1145: (*s_etat_processus).traitement_interruptible = 1146: registre_interruption; 1147: return; 1148: } 1149: 1150: (*(*s_etat_processus).l_base_pile_systeme) 1151: .retour_definition = 'Y'; 1152: (*s_etat_processus).niveau_courant = 0; 1153: (*s_etat_processus).autorisation_empilement_programme = 'N'; 1154: registre_mode_execution_programme = 1155: (*s_etat_processus).mode_execution_programme; 1156: (*s_etat_processus).mode_execution_programme = 'Y'; 1157: (*s_etat_processus).erreur_scrutation = d_faux; 1158: 1159: tampon = (*s_etat_processus).instruction_courante; 1160: nombre_lignes_a_supprimer = 1161: (*s_etat_processus).hauteur_pile_operationnelle; 1162: 1163: if ((*s_etat_processus).profilage == d_vrai) 1164: { 1165: profilage(s_etat_processus, "RPL/2 internals"); 1166: 1167: if ((*s_etat_processus).erreur_systeme != d_es) 1168: { 1169: return; 1170: } 1171: } 1172: 1173: registre_recherche_type = 1174: (*s_etat_processus).recherche_type; 1175: (*s_etat_processus).recherche_type = 'Y'; 1176: 1177: if (sequenceur(s_etat_processus) == d_erreur) 1178: { 1179: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1180: (*s_etat_processus).recherche_type = 1181: registre_recherche_type; 1182: (*s_etat_processus).mode_execution_programme = 1183: registre_mode_execution_programme; 1184: nombre_lignes_a_supprimer = 1185: (*s_etat_processus).hauteur_pile_operationnelle 1186: - nombre_lignes_a_supprimer; 1187: 1188: for(i = 0; i < nombre_lignes_a_supprimer; i++) 1189: { 1190: if (depilement(s_etat_processus, 1191: &((*s_etat_processus).l_base_pile), 1192: &s_sous_objet) == d_erreur) 1193: { 1194: (*s_etat_processus).traitement_interruptible = 1195: registre_interruption; 1196: return; 1197: } 1198: 1199: liberation(s_etat_processus, s_sous_objet); 1200: } 1201: 1202: (*s_etat_processus).instruction_courante = tampon; 1203: 1204: effacement_pile_systeme(s_etat_processus); 1205: (*s_etat_processus).l_base_pile_systeme = 1206: s_sauvegarde_pile; 1207: (*s_etat_processus).niveau_courant = 1208: sauvegarde_niveau_courant; 1209: 1210: (*s_etat_processus).niveau_recursivite--; 1211: free((*s_etat_processus).definitions_chainees); 1212: 1213: (*s_etat_processus).position_courante = 1214: position_courante; 1215: (*s_etat_processus).definitions_chainees = 1216: definitions_chainees_precedentes; 1217: (*s_etat_processus).longueur_definitions_chainees = 1218: sauvegarde_longueur_definitions_chainees; 1219: 1220: free(s_objet); 1221: 1222: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1223: (*s_etat_processus).traitement_interruptible = 1224: registre_interruption; 1225: return; 1226: } 1227: 1228: (*s_etat_processus).recherche_type = 1229: registre_recherche_type; 1230: (*s_etat_processus).mode_execution_programme = 1231: registre_mode_execution_programme; 1232: 1233: if ((*s_etat_processus).erreur_scrutation == d_vrai) 1234: { 1235: nombre_lignes_a_supprimer = 1236: (*s_etat_processus).hauteur_pile_operationnelle 1237: - nombre_lignes_a_supprimer; 1238: 1239: for(i = 0; i < nombre_lignes_a_supprimer; i++) 1240: { 1241: if (depilement(s_etat_processus, 1242: &((*s_etat_processus).l_base_pile), 1243: &s_sous_objet) == d_erreur) 1244: { 1245: (*s_etat_processus).traitement_interruptible = 1246: registre_interruption; 1247: return; 1248: } 1249: 1250: liberation(s_etat_processus, s_sous_objet); 1251: } 1252: 1253: (*s_etat_processus).instruction_courante = tampon; 1254: 1255: effacement_pile_systeme(s_etat_processus); 1256: (*s_etat_processus).l_base_pile_systeme = 1257: s_sauvegarde_pile; 1258: (*s_etat_processus).niveau_courant = 1259: sauvegarde_niveau_courant; 1260: 1261: (*s_etat_processus).niveau_recursivite--; 1262: free((*s_etat_processus).definitions_chainees); 1263: 1264: (*s_etat_processus).position_courante = 1265: position_courante; 1266: (*s_etat_processus).definitions_chainees = 1267: definitions_chainees_precedentes; 1268: (*s_etat_processus).longueur_definitions_chainees = 1269: sauvegarde_longueur_definitions_chainees; 1270: 1271: free(s_objet); 1272: 1273: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1274: (*s_etat_processus).traitement_interruptible = 1275: registre_interruption; 1276: return; 1277: } 1278: 1279: (*s_etat_processus).instruction_courante = tampon; 1280: 1281: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 1282: (*s_etat_processus).niveau_courant = 1283: sauvegarde_niveau_courant; 1284: 1285: (*s_etat_processus).niveau_recursivite--; 1286: 1287: (*s_etat_processus).position_courante = position_courante; 1288: free((*s_etat_processus).definitions_chainees); 1289: (*s_etat_processus).definitions_chainees = 1290: definitions_chainees_precedentes; 1291: (*s_etat_processus).longueur_definitions_chainees = 1292: sauvegarde_longueur_definitions_chainees; 1293: 1294: /* 1295: -- On relit la pile pour remplir le vecteur ------------------------------------ 1296: */ 1297: 1298: profondeur_finale = (*s_etat_processus) 1299: .hauteur_pile_operationnelle; 1300: nombre_colonnes = profondeur_finale - profondeur_initiale; 1301: 1302: element = (void *) ((struct_vecteur *) 1303: malloc(sizeof(struct_vecteur))); 1304: 1305: if (element == NULL) 1306: { 1307: (*s_etat_processus).erreur_systeme = 1308: d_es_allocation_memoire; 1309: (*s_etat_processus).traitement_interruptible = 1310: registre_interruption; 1311: return; 1312: } 1313: 1314: (*((struct_vecteur *) element)).taille = nombre_colonnes; 1315: 1316: if (drapeau_complexe == d_vrai) 1317: { 1318: (*((struct_vecteur *) element)).tableau = (void *) 1319: ((struct_complexe16 *) malloc(nombre_colonnes * 1320: sizeof(struct_complexe16))); 1321: (*((struct_vecteur *) element)).type = 'C'; 1322: } 1323: else if (drapeau_reel == d_vrai) 1324: { 1325: (*((struct_vecteur *) element)).tableau = (void *) 1326: ((real8 *) malloc(nombre_colonnes * 1327: sizeof(real8))); 1328: (*((struct_vecteur *) element)).type = 'R'; 1329: } 1330: else 1331: { 1332: (*((struct_vecteur *) element)).tableau = (void *) 1333: ((integer8 *) malloc(nombre_colonnes * 1334: sizeof(integer8))); 1335: (*((struct_vecteur *) element)).type = 'I'; 1336: } 1337: 1338: if ((*((struct_vecteur *) element)).tableau == NULL) 1339: { 1340: (*s_etat_processus).erreur_systeme = 1341: d_es_allocation_memoire; 1342: (*s_etat_processus).traitement_interruptible = 1343: registre_interruption; 1344: return; 1345: } 1346: 1347: erreur = d_absence_erreur; 1348: free(s_objet); 1349: 1350: for(i = 0; (i < nombre_colonnes) && 1351: (erreur == d_absence_erreur); i++) 1352: { 1353: erreur = depilement(s_etat_processus, 1354: &((*s_etat_processus).l_base_pile), &s_objet); 1355: 1356: if (erreur == d_absence_erreur) 1357: { 1358: if (drapeau_complexe == d_vrai) 1359: { 1360: if ((*s_objet).type == CPL) 1361: { 1362: ((struct_complexe16 *) (*((struct_vecteur *) 1363: element)).tableau)[nombre_colonnes 1364: - i - 1] = *((struct_complexe16 *) 1365: ((*s_objet).objet)); 1366: } 1367: else if ((*s_objet).type == REL) 1368: { 1369: ((struct_complexe16 *) (*((struct_vecteur *) 1370: element)).tableau)[nombre_colonnes 1371: - i - 1].partie_reelle = 1372: *((real8 *) ((*s_objet).objet)); 1373: ((struct_complexe16 *) (*((struct_vecteur *) 1374: element)).tableau)[nombre_colonnes 1375: - i - 1].partie_imaginaire = 1376: (real8) 0; 1377: } 1378: else if ((*s_objet).type == INT) 1379: { 1380: ((struct_complexe16 *) (*((struct_vecteur *) 1381: element)).tableau)[nombre_colonnes 1382: - i - 1].partie_reelle = (real8) 1383: (*((integer8 *) ((*s_objet) 1384: .objet))); 1385: ((struct_complexe16 *) (*((struct_vecteur *) 1386: element)).tableau) [nombre_colonnes 1387: - i - 1].partie_imaginaire = 1388: (real8) 0; 1389: } 1390: else 1391: { 1392: erreur = d_erreur; 1393: } 1394: } 1395: else if (drapeau_reel == d_vrai) 1396: { 1397: if ((*s_objet).type == REL) 1398: { 1399: ((real8 *) (*((struct_vecteur *) 1400: element)).tableau) 1401: [nombre_colonnes - i - 1] = 1402: *((real8 *) ((*s_objet).objet)); 1403: } 1404: else if ((*s_objet).type == INT) 1405: { 1406: ((real8 *) (*((struct_vecteur *) 1407: element)).tableau) 1408: [nombre_colonnes - i - 1] = 1409: (real8) (*((integer8 *) 1410: ((*s_objet).objet))); 1411: } 1412: else 1413: { 1414: erreur = d_erreur; 1415: } 1416: } 1417: else 1418: { 1419: if ((*s_objet).type == INT) 1420: { 1421: ((integer8 *) (*((struct_vecteur *) 1422: element)).tableau) 1423: [nombre_colonnes - i - 1] = 1424: *((integer8 *) ((*s_objet).objet)); 1425: } 1426: else 1427: { 1428: erreur = d_erreur; 1429: } 1430: } 1431: 1432: liberation(s_etat_processus, s_objet); 1433: 1434: if (erreur == d_erreur) 1435: { 1436: for(i++; i < nombre_colonnes; i++) 1437: { 1438: if (depilement(s_etat_processus, 1439: &((*s_etat_processus).l_base_pile), 1440: &s_objet) == d_erreur) 1441: { 1442: (*s_etat_processus) 1443: .traitement_interruptible = 1444: registre_interruption; 1445: return; 1446: } 1447: 1448: liberation(s_etat_processus, s_objet); 1449: } 1450: 1451: (*s_etat_processus).erreur_execution = 1452: d_ex_syntaxe; 1453: 1454: free((*((struct_vecteur *) element)).tableau); 1455: free(element); 1456: 1457: (*s_etat_processus).traitement_interruptible = 1458: registre_interruption; 1459: return; 1460: } 1461: } 1462: else 1463: { 1464: (*s_etat_processus).erreur_systeme = d_es_pile_vide; 1465: (*s_etat_processus).traitement_interruptible = 1466: registre_interruption; 1467: return; 1468: } 1469: } 1470: 1471: s_objet = (struct_objet *) malloc(sizeof(struct_objet)); 1472: 1473: if (s_objet == NULL) 1474: { 1475: (*s_etat_processus).erreur_systeme = 1476: d_es_allocation_memoire; 1477: (*s_etat_processus).traitement_interruptible = 1478: registre_interruption; 1479: return; 1480: } 1481: 1482: initialisation_objet(s_objet); 1483: 1484: if (drapeau_complexe == d_vrai) 1485: { 1486: (*s_objet).type = VCX; 1487: } 1488: else if (drapeau_reel == d_vrai) 1489: { 1490: (*s_objet).type = VRL; 1491: } 1492: else 1493: { 1494: (*s_objet).type = VIN; 1495: } 1496: 1497: break; 1498: } 1499: 1500: /* 1501: -------------------------------------------------------------------------------- 1502: Matrice 1503: -------------------------------------------------------------------------------- 1504: */ 1505: 1506: case d_vrai : 1507: { 1508: nombre_lignes--; 1509: 1510: sauvegarde_longueur_definitions_chainees = 1511: (*s_etat_processus).longueur_definitions_chainees; 1512: 1513: tampon = (unsigned char *) malloc( 1514: (((*s_etat_processus).longueur_definitions_chainees 1515: = strlen((*s_etat_processus).instruction_courante) 1516: + 4) + 1) * sizeof(unsigned char)); 1517: 1518: if (tampon == NULL) 1519: { 1520: (*s_etat_processus).erreur_systeme = 1521: d_es_allocation_memoire; 1522: (*s_etat_processus).traitement_interruptible = 1523: registre_interruption; 1524: return; 1525: } 1526: 1527: strcpy(tampon, "<< "); 1528: ptr_ecriture = tampon + 3; 1529: ptr_lecture = (*s_etat_processus).instruction_courante + 1; 1530: 1531: while((*ptr_lecture) != d_code_fin_chaine) 1532: { 1533: *ptr_ecriture++ = *ptr_lecture++; 1534: } 1535: 1536: (*(--ptr_ecriture)) = d_code_fin_chaine; 1537: strcat(ptr_ecriture, " >>"); 1538: 1539: position_courante = (*s_etat_processus).position_courante; 1540: (*s_etat_processus).position_courante = 0; 1541: 1542: profondeur_initiale = (*s_etat_processus) 1543: .hauteur_pile_operationnelle; 1544: 1545: /* 1546: -- On met les lignes de la matrice dans la pile opérationnelle ----------------- 1547: */ 1548: 1549: (*s_etat_processus).niveau_recursivite++; 1550: definitions_chainees_precedentes = (*s_etat_processus) 1551: .definitions_chainees; 1552: (*s_etat_processus).definitions_chainees = tampon; 1553: 1554: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; 1555: sauvegarde_niveau_courant = (*s_etat_processus) 1556: .niveau_courant; 1557: 1558: (*s_etat_processus).l_base_pile_systeme = NULL; 1559: empilement_pile_systeme(s_etat_processus); 1560: 1561: if ((*s_etat_processus).erreur_systeme != d_es) 1562: { 1563: (*s_etat_processus).traitement_interruptible = 1564: registre_interruption; 1565: return; 1566: } 1567: 1568: (*(*s_etat_processus).l_base_pile_systeme) 1569: .retour_definition = 'Y'; 1570: (*s_etat_processus).niveau_courant = 0; 1571: (*s_etat_processus).autorisation_empilement_programme = 'N'; 1572: registre_mode_execution_programme = 1573: (*s_etat_processus).mode_execution_programme; 1574: (*s_etat_processus).mode_execution_programme = 'Y'; 1575: (*s_etat_processus).erreur_scrutation = d_faux; 1576: 1577: tampon = (*s_etat_processus).instruction_courante; 1578: nombre_lignes_a_supprimer = 1579: (*s_etat_processus).hauteur_pile_operationnelle; 1580: 1581: if ((*s_etat_processus).profilage == d_vrai) 1582: { 1583: profilage(s_etat_processus, "RPL/2 internals"); 1584: 1585: if ((*s_etat_processus).erreur_systeme != d_es) 1586: { 1587: return; 1588: } 1589: } 1590: 1591: registre_recherche_type = (*s_etat_processus) 1592: .recherche_type; 1593: (*s_etat_processus).recherche_type = 'Y'; 1594: 1595: if (sequenceur(s_etat_processus) == d_erreur) 1596: { 1597: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1598: (*s_etat_processus).recherche_type = 1599: registre_recherche_type; 1600: (*s_etat_processus).mode_execution_programme = 1601: registre_mode_execution_programme; 1602: nombre_lignes_a_supprimer = 1603: (*s_etat_processus).hauteur_pile_operationnelle 1604: - nombre_lignes_a_supprimer; 1605: 1606: for(i = 0; i < nombre_lignes_a_supprimer; i++) 1607: { 1608: if (depilement(s_etat_processus, 1609: &((*s_etat_processus).l_base_pile), 1610: &s_sous_objet) == d_erreur) 1611: { 1612: (*s_etat_processus).traitement_interruptible = 1613: registre_interruption; 1614: return; 1615: } 1616: 1617: liberation(s_etat_processus, s_sous_objet); 1618: } 1619: 1620: (*s_etat_processus).instruction_courante = tampon; 1621: 1622: effacement_pile_systeme(s_etat_processus); 1623: (*s_etat_processus).l_base_pile_systeme = 1624: s_sauvegarde_pile; 1625: (*s_etat_processus).niveau_courant = 1626: sauvegarde_niveau_courant; 1627: 1628: free((*s_etat_processus).definitions_chainees); 1629: (*s_etat_processus).niveau_recursivite--; 1630: 1631: (*s_etat_processus).definitions_chainees = 1632: definitions_chainees_precedentes; 1633: (*s_etat_processus).longueur_definitions_chainees = 1634: sauvegarde_longueur_definitions_chainees; 1635: 1636: (*s_etat_processus).position_courante = 1637: position_courante; 1638: 1639: free(s_objet); 1640: 1641: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1642: (*s_etat_processus).traitement_interruptible = 1643: registre_interruption; 1644: return; 1645: } 1646: 1647: (*s_etat_processus).recherche_type = 1648: registre_recherche_type; 1649: (*s_etat_processus).mode_execution_programme = 1650: registre_mode_execution_programme; 1651: 1652: if ((*s_etat_processus).erreur_scrutation == d_vrai) 1653: { 1654: nombre_lignes_a_supprimer = 1655: (*s_etat_processus).hauteur_pile_operationnelle 1656: - nombre_lignes_a_supprimer; 1657: 1658: for(i = 0; i < nombre_lignes_a_supprimer; i++) 1659: { 1660: if (depilement(s_etat_processus, 1661: &((*s_etat_processus).l_base_pile), 1662: &s_sous_objet) == d_erreur) 1663: { 1664: (*s_etat_processus).traitement_interruptible = 1665: registre_interruption; 1666: return; 1667: } 1668: 1669: liberation(s_etat_processus, s_sous_objet); 1670: } 1671: 1672: (*s_etat_processus).instruction_courante = tampon; 1673: 1674: effacement_pile_systeme(s_etat_processus); 1675: (*s_etat_processus).l_base_pile_systeme = 1676: s_sauvegarde_pile; 1677: (*s_etat_processus).niveau_courant = 1678: sauvegarde_niveau_courant; 1679: 1680: free((*s_etat_processus).definitions_chainees); 1681: (*s_etat_processus).niveau_recursivite--; 1682: 1683: (*s_etat_processus).definitions_chainees = 1684: definitions_chainees_precedentes; 1685: (*s_etat_processus).longueur_definitions_chainees = 1686: sauvegarde_longueur_definitions_chainees; 1687: 1688: (*s_etat_processus).position_courante = 1689: position_courante; 1690: 1691: free(s_objet); 1692: 1693: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1694: (*s_etat_processus).traitement_interruptible = 1695: registre_interruption; 1696: return; 1697: } 1698: 1699: (*s_etat_processus).instruction_courante = tampon; 1700: 1701: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 1702: (*s_etat_processus).niveau_courant = 1703: sauvegarde_niveau_courant; 1704: 1705: free((*s_etat_processus).definitions_chainees); 1706: (*s_etat_processus).definitions_chainees = 1707: definitions_chainees_precedentes; 1708: (*s_etat_processus).longueur_definitions_chainees = 1709: sauvegarde_longueur_definitions_chainees; 1710: 1711: (*s_etat_processus).niveau_recursivite--; 1712: 1713: (*s_etat_processus).position_courante = position_courante; 1714: 1715: /* 1716: -- On relit la pile qui contient des objets "vecteurs" contenant les ----------- 1717: -- lignes de la matrice -------------------------------------------------------- 1718: */ 1719: 1720: profondeur_finale = (*s_etat_processus) 1721: .hauteur_pile_operationnelle; 1722: 1723: nombre_lignes = profondeur_finale - profondeur_initiale; 1724: 1725: element = (void *) ((struct_matrice *) malloc( 1726: sizeof(struct_matrice))); 1727: 1728: if (element == NULL) 1729: { 1730: (*s_etat_processus).erreur_systeme = 1731: d_es_allocation_memoire; 1732: (*s_etat_processus).traitement_interruptible = 1733: registre_interruption; 1734: return; 1735: } 1736: 1737: (*((struct_matrice *) element)) 1738: .nombre_lignes = nombre_lignes; 1739: (*((struct_matrice *) element)).nombre_colonnes = 1740: (*((struct_vecteur *) ((*(*(*s_etat_processus) 1741: .l_base_pile).donnee).objet))).taille; 1742: nombre_colonnes = (*((struct_matrice *) 1743: element)).nombre_colonnes; 1744: 1745: l_element_courant = (*s_etat_processus).l_base_pile; 1746: 1747: drapeau_complexe = d_faux; 1748: drapeau_reel = d_faux; 1749: erreur = d_absence_erreur; 1750: 1751: for(i = 0; i < nombre_lignes; i++) 1752: { 1753: if (nombre_colonnes != (*((struct_vecteur *) 1754: (*(*l_element_courant).donnee).objet)).taille) 1755: { 1756: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 1757: 1758: for(j = 0; j < nombre_lignes; j++) 1759: { 1760: if (depilement(s_etat_processus, 1761: &((*s_etat_processus).l_base_pile), 1762: &s_sous_objet) == d_erreur) 1763: { 1764: (*s_etat_processus) 1765: .traitement_interruptible = 1766: registre_interruption; 1767: return; 1768: } 1769: 1770: liberation(s_etat_processus, s_sous_objet); 1771: } 1772: 1773: free(element); 1774: free(s_objet); 1775: 1776: (*s_etat_processus).traitement_interruptible = 1777: registre_interruption; 1778: return; 1779: } 1780: 1781: if ((*(*l_element_courant) 1782: .donnee).type == VRL) 1783: { 1784: drapeau_reel = d_vrai; 1785: } 1786: else if ((*(*l_element_courant) 1787: .donnee).type == VCX) 1788: { 1789: drapeau_complexe = d_vrai; 1790: } 1791: 1792: l_element_courant = (*l_element_courant).suivant; 1793: } 1794: 1795: free(s_objet); 1796: 1797: if ((*s_etat_processus).erreur_execution == d_ex) 1798: { 1799: if (drapeau_complexe == d_vrai) 1800: { 1801: if (((*((struct_matrice *) element)).tableau = 1802: (void **) ((struct_complexe16 **) 1803: malloc(nombre_lignes * sizeof( 1804: struct_complexe16 *)))) == NULL) 1805: { 1806: (*s_etat_processus).erreur_systeme = 1807: d_es_allocation_memoire; 1808: (*s_etat_processus).traitement_interruptible = 1809: registre_interruption; 1810: return; 1811: } 1812: 1813: (*((struct_matrice *) element)).type = 'C'; 1814: 1815: for(i = 0; i < nombre_lignes; i++) 1816: { 1817: if ((((*((struct_matrice *) 1818: element)).tableau)[i] = (void *) 1819: ((struct_complexe16 *) 1820: malloc(nombre_colonnes * sizeof( 1821: struct_complexe16)))) == NULL) 1822: { 1823: (*s_etat_processus).erreur_systeme = 1824: d_es_allocation_memoire; 1825: (*s_etat_processus) 1826: .traitement_interruptible = 1827: registre_interruption; 1828: return; 1829: } 1830: } 1831: } 1832: else if (drapeau_reel == d_vrai) 1833: { 1834: if (((*((struct_matrice *) element)).tableau = 1835: (void **) ((real8 **) 1836: malloc(nombre_lignes * sizeof(real8 *)))) 1837: == NULL) 1838: { 1839: (*s_etat_processus).erreur_systeme = 1840: d_es_allocation_memoire; 1841: (*s_etat_processus).traitement_interruptible = 1842: registre_interruption; 1843: return; 1844: } 1845: 1846: (*((struct_matrice *) element)).type = 'R'; 1847: 1848: for(i = 0; i < nombre_lignes; i++) 1849: { 1850: if ((((*((struct_matrice *)element)).tableau)[i] 1851: = (void *) ((real8 *) 1852: malloc(nombre_colonnes * 1853: sizeof(real8)))) == NULL) 1854: { 1855: (*s_etat_processus).erreur_systeme = 1856: d_es_allocation_memoire; 1857: (*s_etat_processus) 1858: .traitement_interruptible = 1859: registre_interruption; 1860: return; 1861: } 1862: } 1863: } 1864: else 1865: { 1866: if (((*((struct_matrice *) element)).tableau = 1867: (void **) ((integer8 **) 1868: malloc(nombre_lignes * 1869: sizeof(integer8 *)))) == NULL) 1870: { 1871: (*s_etat_processus).erreur_systeme = 1872: d_es_allocation_memoire; 1873: (*s_etat_processus).traitement_interruptible = 1874: registre_interruption; 1875: return; 1876: } 1877: 1878: (*((struct_matrice *) element)).type = 'I'; 1879: 1880: for(i = 0; i < nombre_lignes; i++) 1881: { 1882: if ((((*((struct_matrice *) 1883: element)).tableau)[i] = (void *) 1884: ((integer8 *) 1885: malloc(nombre_colonnes * 1886: sizeof(integer8)))) == NULL) 1887: { 1888: (*s_etat_processus).erreur_systeme = 1889: d_es_allocation_memoire; 1890: (*s_etat_processus) 1891: .traitement_interruptible = 1892: registre_interruption; 1893: return; 1894: } 1895: } 1896: } 1897: 1898: for(i = 0; i < nombre_lignes; i++) 1899: { 1900: if (depilement(s_etat_processus, 1901: &((*s_etat_processus) 1902: .l_base_pile), &s_objet) == 1903: d_absence_erreur) 1904: { 1905: if (drapeau_complexe == d_vrai) 1906: { 1907: if ((*s_objet).type == VCX) 1908: { 1909: for(j = 0; j < nombre_colonnes; j++) 1910: { 1911: ((struct_complexe16 **) ((*( 1912: (struct_matrice *) element)) 1913: .tableau))[nombre_lignes - i 1914: - 1][j] = 1915: ((struct_complexe16 *) 1916: (*((struct_vecteur *) 1917: (*s_objet).objet)) 1918: .tableau)[j]; 1919: } 1920: } 1921: else if ((*s_objet).type == VRL) 1922: { 1923: for(j = 0; j < nombre_colonnes; j++) 1924: { 1925: (((struct_complexe16 **) ((*( 1926: (struct_matrice *) element)) 1927: .tableau))[nombre_lignes - i 1928: - 1][j]).partie_reelle = 1929: ((real8 *) (*( 1930: (struct_vecteur *) 1931: (*s_objet).objet)) 1932: .tableau)[j]; 1933: (((struct_complexe16 **) ((*( 1934: (struct_matrice *) element)) 1935: .tableau))[nombre_lignes - i 1936: - 1][j]).partie_imaginaire = 1937: (real8) 0; 1938: } 1939: } 1940: else if ((*s_objet).type == VIN) 1941: { 1942: for(j = 0; j < nombre_colonnes; j++) 1943: { 1944: (((struct_complexe16 **) ((*( 1945: (struct_matrice *) element)) 1946: .tableau))[nombre_lignes - i 1947: - 1][j]).partie_reelle = 1948: (real8) ((integer8 *) 1949: (*((struct_vecteur *) 1950: (*s_objet).objet)).tableau) 1951: [j]; 1952: (((struct_complexe16 **) ((*( 1953: (struct_matrice *) element)) 1954: .tableau))[nombre_lignes - i 1955: - 1][j]).partie_imaginaire = 1956: (real8) 0; 1957: } 1958: } 1959: else 1960: { 1961: erreur = d_erreur; 1962: } 1963: } 1964: else if (drapeau_reel == d_vrai) 1965: { 1966: if ((*s_objet).type == VRL) 1967: { 1968: for(j = 0; j < nombre_colonnes; j++) 1969: { 1970: ((real8 **) ((*((struct_matrice *) 1971: element)).tableau)) 1972: [nombre_lignes - i - 1][j] = 1973: ((real8 *) (*( 1974: (struct_vecteur *) 1975: (*s_objet).objet)).tableau) 1976: [j]; 1977: } 1978: } 1979: else if ((*s_objet).type == VIN) 1980: { 1981: for(j = 0; j < nombre_colonnes; j++) 1982: { 1983: ((real8 **) ((*((struct_matrice *) 1984: element)).tableau)) 1985: [nombre_lignes - i - 1][j] = 1986: (real8) ((integer8 *) 1987: (*((struct_vecteur *) 1988: (*s_objet).objet)).tableau) 1989: [j]; 1990: } 1991: } 1992: else 1993: { 1994: erreur = d_erreur; 1995: } 1996: } 1997: else 1998: { 1999: if ((*s_objet).type == VIN) 2000: { 2001: for(j = 0; j < nombre_colonnes; j++) 2002: { 2003: ((integer8 **) 2004: ((*((struct_matrice *) 2005: element)).tableau)) 2006: [nombre_lignes - i - 1][j] = 2007: ((integer8 *) 2008: (*((struct_vecteur *) 2009: (*s_objet) 2010: .objet)).tableau)[j]; 2011: } 2012: } 2013: else 2014: { 2015: erreur = d_erreur; 2016: } 2017: } 2018: 2019: liberation(s_etat_processus, s_objet); 2020: 2021: if (erreur == d_erreur) 2022: { 2023: for(i++; i < nombre_lignes; i++) 2024: { 2025: if (depilement(s_etat_processus, 2026: &((*s_etat_processus) 2027: .l_base_pile), &s_objet) 2028: == d_erreur) 2029: { 2030: (*s_etat_processus) 2031: .traitement_interruptible = 2032: registre_interruption; 2033: return; 2034: } 2035: 2036: liberation(s_etat_processus, s_objet); 2037: } 2038: 2039: (*s_etat_processus).erreur_execution = 2040: d_ex_syntaxe; 2041: 2042: for(j = 0; j < (*((struct_matrice *) 2043: element)).nombre_lignes; j++) 2044: { 2045: free((*((struct_matrice *) element)) 2046: .tableau[j]); 2047: } 2048: 2049: free((*((struct_matrice *) element)) 2050: .tableau); 2051: free(element); 2052: 2053: (*s_etat_processus) 2054: .traitement_interruptible = 2055: registre_interruption; 2056: return; 2057: } 2058: } 2059: else 2060: { 2061: (*s_etat_processus).erreur_systeme = 2062: d_es_pile_vide; 2063: (*s_etat_processus).traitement_interruptible = 2064: registre_interruption; 2065: return; 2066: } 2067: } 2068: 2069: s_objet = (struct_objet *) malloc(sizeof(struct_objet)); 2070: 2071: if (s_objet == NULL) 2072: { 2073: (*s_etat_processus).erreur_systeme = 2074: d_es_allocation_memoire; 2075: (*s_etat_processus).traitement_interruptible = 2076: registre_interruption; 2077: return; 2078: } 2079: 2080: initialisation_objet(s_objet); 2081: 2082: if (drapeau_complexe == d_vrai) 2083: { 2084: (*s_objet).type = MCX; 2085: } 2086: else if (drapeau_reel == d_vrai) 2087: { 2088: (*s_objet).type = MRL; 2089: } 2090: else 2091: { 2092: (*s_objet).type = MIN; 2093: } 2094: } 2095: else 2096: { 2097: if ((*s_etat_processus).langue == 'F') 2098: { 2099: printf("+++Erreur : Matrice %s invalide [%d]\n", 2100: (*s_etat_processus).instruction_courante, 2101: (int) getpid()); 2102: } 2103: else 2104: { 2105: printf("+++Error : Invalid %s matrix [%d]\n", 2106: (*s_etat_processus).instruction_courante, 2107: (int) getpid()); 2108: } 2109: 2110: fflush(stdout); 2111: } 2112: 2113: break; 2114: } 2115: } 2116: 2117: break; 2118: } 2119: 2120: /* 2121: -------------------------------------------------------------------------------- 2122: Liste 2123: -------------------------------------------------------------------------------- 2124: */ 2125: 2126: case '{' : 2127: { 2128: sauvegarde_longueur_definitions_chainees = 2129: (*s_etat_processus).longueur_definitions_chainees; 2130: 2131: tampon = (unsigned char *) malloc( 2132: (((*s_etat_processus).longueur_definitions_chainees = 2133: strlen((*s_etat_processus).instruction_courante) + 4) + 1) 2134: * sizeof(unsigned char)); 2135: 2136: if (tampon == NULL) 2137: { 2138: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2139: (*s_etat_processus).traitement_interruptible = 2140: registre_interruption; 2141: return; 2142: } 2143: 2144: strcpy(tampon, "<< "); 2145: ptr_ecriture = tampon + 3; 2146: ptr_lecture = (*s_etat_processus).instruction_courante + 1; 2147: 2148: while((*ptr_lecture) != d_code_fin_chaine) 2149: { 2150: *ptr_ecriture++ = *ptr_lecture++; 2151: } 2152: 2153: (*(--ptr_ecriture)) = d_code_fin_chaine; 2154: strcat(ptr_ecriture, " >>"); 2155: 2156: position_courante = (*s_etat_processus).position_courante; 2157: (*s_etat_processus).position_courante = 0; 2158: 2159: profondeur_initiale = (*s_etat_processus) 2160: .hauteur_pile_operationnelle; 2161: 2162: /* 2163: -- On met le tout dans la pile opérationnelle. --------------------------------- 2164: */ 2165: 2166: (*s_etat_processus).niveau_recursivite++; 2167: definitions_chainees_precedentes = (*s_etat_processus) 2168: .definitions_chainees; 2169: (*s_etat_processus).definitions_chainees = tampon; 2170: 2171: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; 2172: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant; 2173: 2174: (*s_etat_processus).l_base_pile_systeme = NULL; 2175: empilement_pile_systeme(s_etat_processus); 2176: 2177: if ((*s_etat_processus).erreur_systeme != d_es) 2178: { 2179: (*s_etat_processus).traitement_interruptible = 2180: registre_interruption; 2181: return; 2182: } 2183: 2184: (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y'; 2185: (*(*s_etat_processus).l_base_pile_systeme) 2186: .origine_routine_evaluation = 'N'; 2187: (*s_etat_processus).niveau_courant = 0; 2188: (*s_etat_processus).autorisation_empilement_programme = 'N'; 2189: 2190: tampon = (*s_etat_processus).instruction_courante; 2191: autorisation_evaluation_nom = (*s_etat_processus) 2192: .autorisation_evaluation_nom; 2193: (*s_etat_processus).autorisation_evaluation_nom = 'N'; 2194: 2195: registre_test = (*s_etat_processus).test_instruction; 2196: (*s_etat_processus).test_instruction = 'Y'; 2197: registre_mode_execution_programme = 2198: (*s_etat_processus).mode_execution_programme; 2199: (*s_etat_processus).mode_execution_programme = 'Y'; 2200: (*s_etat_processus).erreur_scrutation = d_faux; 2201: 2202: nombre_lignes_a_supprimer = 2203: (*s_etat_processus).hauteur_pile_operationnelle; 2204: 2205: /* 2206: * Vérification de la cohérence des arguments. 2207: * Il doit y avoir autant de '<<' que de '>>' dans 2208: * l'expression candidate. 2209: */ 2210: 2211: coherence_liste = 0; 2212: drapeau_chaine = d_faux; 2213: 2214: while((*s_etat_processus).definitions_chainees 2215: [(*s_etat_processus).position_courante] != 2216: d_code_fin_chaine) 2217: { 2218: if ((*s_etat_processus).definitions_chainees 2219: [(*s_etat_processus).position_courante] == '"') 2220: { 2221: if (drapeau_chaine == d_faux) 2222: { 2223: drapeau_chaine = d_vrai; 2224: } 2225: else 2226: { 2227: drapeau_chaine = d_faux; 2228: } 2229: } 2230: else if (drapeau_chaine == d_faux) 2231: { 2232: if (((*s_etat_processus).definitions_chainees 2233: [(*s_etat_processus).position_courante] == '<') && 2234: ((*s_etat_processus).definitions_chainees 2235: [(*s_etat_processus).position_courante + 1] == '<')) 2236: { 2237: coherence_liste++; 2238: } 2239: else if (((*s_etat_processus).definitions_chainees 2240: [(*s_etat_processus).position_courante] == '>') && 2241: ((*s_etat_processus).definitions_chainees 2242: [(*s_etat_processus).position_courante + 1] == '>')) 2243: { 2244: coherence_liste--; 2245: } 2246: 2247: } 2248: 2249: (*s_etat_processus).position_courante++; 2250: } 2251: 2252: (*s_etat_processus).position_courante = 0; 2253: 2254: if ((coherence_liste != 0) || (drapeau_chaine == d_vrai)) 2255: { 2256: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2257: 2258: nombre_lignes_a_supprimer = 2259: (*s_etat_processus).hauteur_pile_operationnelle 2260: - nombre_lignes_a_supprimer; 2261: 2262: for(i = 0; i < nombre_lignes_a_supprimer; i++) 2263: { 2264: if (depilement(s_etat_processus, &((*s_etat_processus) 2265: .l_base_pile), &s_sous_objet) == d_erreur) 2266: { 2267: (*s_etat_processus).traitement_interruptible = 2268: registre_interruption; 2269: (*s_etat_processus).mode_execution_programme = 2270: registre_mode_execution_programme; 2271: return; 2272: } 2273: 2274: liberation(s_etat_processus, s_sous_objet); 2275: } 2276: 2277: (*s_etat_processus).test_instruction = registre_test; 2278: (*s_etat_processus).longueur_definitions_chainees = 2279: sauvegarde_longueur_definitions_chainees; 2280: 2281: (*s_etat_processus).instruction_courante = tampon; 2282: (*s_etat_processus).autorisation_evaluation_nom = 2283: autorisation_evaluation_nom; 2284: 2285: effacement_pile_systeme(s_etat_processus); 2286: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 2287: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 2288: 2289: free((*s_etat_processus).definitions_chainees); 2290: free(s_objet); 2291: 2292: (*s_etat_processus).definitions_chainees = 2293: definitions_chainees_precedentes; 2294: 2295: (*s_etat_processus).niveau_recursivite--; 2296: 2297: (*s_etat_processus).position_courante = position_courante; 2298: 2299: (*s_etat_processus).traitement_interruptible = 2300: registre_interruption; 2301: (*s_etat_processus).mode_execution_programme = 2302: registre_mode_execution_programme; 2303: return; 2304: } 2305: 2306: /* 2307: * Scrutation de la séquence. 2308: */ 2309: 2310: (*s_etat_processus).position_courante = 0; 2311: 2312: if ((*s_etat_processus).profilage == d_vrai) 2313: { 2314: profilage(s_etat_processus, "RPL/2 internals"); 2315: 2316: if ((*s_etat_processus).erreur_systeme != d_es) 2317: { 2318: return; 2319: } 2320: } 2321: 2322: variable_implicite = (*s_etat_processus).autorisation_nom_implicite; 2323: registre_recherche_type = (*s_etat_processus).recherche_type; 2324: (*s_etat_processus).recherche_type = 'Y'; 2325: (*s_etat_processus).autorisation_nom_implicite = 'Y'; 2326: 2327: if (sequenceur(s_etat_processus) == d_erreur) 2328: { 2329: (*s_etat_processus).autorisation_nom_implicite = 2330: variable_implicite; 2331: (*s_etat_processus).recherche_type = registre_recherche_type; 2332: (*s_etat_processus).mode_execution_programme = 2333: registre_mode_execution_programme; 2334: 2335: if ((*s_etat_processus).erreur_execution != 2336: d_ex_nom_implicite) 2337: { 2338: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2339: } 2340: 2341: nombre_lignes_a_supprimer = 2342: (*s_etat_processus).hauteur_pile_operationnelle 2343: - nombre_lignes_a_supprimer; 2344: 2345: for(i = 0; i < nombre_lignes_a_supprimer; i++) 2346: { 2347: if (depilement(s_etat_processus, &((*s_etat_processus) 2348: .l_base_pile), &s_sous_objet) == d_erreur) 2349: { 2350: (*s_etat_processus).traitement_interruptible = 2351: registre_interruption; 2352: return; 2353: } 2354: 2355: liberation(s_etat_processus, s_sous_objet); 2356: } 2357: 2358: (*s_etat_processus).test_instruction = registre_test; 2359: (*s_etat_processus).longueur_definitions_chainees = 2360: sauvegarde_longueur_definitions_chainees; 2361: 2362: (*s_etat_processus).instruction_courante = tampon; 2363: (*s_etat_processus).autorisation_evaluation_nom = 2364: autorisation_evaluation_nom; 2365: 2366: effacement_pile_systeme(s_etat_processus); 2367: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 2368: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 2369: 2370: free((*s_etat_processus).definitions_chainees); 2371: free(s_objet); 2372: 2373: (*s_etat_processus).definitions_chainees = 2374: definitions_chainees_precedentes; 2375: 2376: (*s_etat_processus).niveau_recursivite--; 2377: 2378: (*s_etat_processus).position_courante = position_courante; 2379: 2380: (*s_etat_processus).traitement_interruptible = 2381: registre_interruption; 2382: return; 2383: } 2384: 2385: (*s_etat_processus).autorisation_nom_implicite = variable_implicite; 2386: (*s_etat_processus).recherche_type = registre_recherche_type; 2387: (*s_etat_processus).mode_execution_programme = 2388: registre_mode_execution_programme; 2389: 2390: if ((*s_etat_processus).erreur_scrutation == d_vrai) 2391: { 2392: nombre_lignes_a_supprimer = 2393: (*s_etat_processus).hauteur_pile_operationnelle 2394: - nombre_lignes_a_supprimer; 2395: 2396: for(i = 0; i < nombre_lignes_a_supprimer; i++) 2397: { 2398: if (depilement(s_etat_processus, &((*s_etat_processus) 2399: .l_base_pile), &s_sous_objet) == d_erreur) 2400: { 2401: (*s_etat_processus).traitement_interruptible = 2402: registre_interruption; 2403: return; 2404: } 2405: 2406: liberation(s_etat_processus, s_sous_objet); 2407: } 2408: 2409: (*s_etat_processus).test_instruction = registre_test; 2410: (*s_etat_processus).longueur_definitions_chainees = 2411: sauvegarde_longueur_definitions_chainees; 2412: 2413: (*s_etat_processus).instruction_courante = tampon; 2414: (*s_etat_processus).autorisation_evaluation_nom = 2415: autorisation_evaluation_nom; 2416: 2417: effacement_pile_systeme(s_etat_processus); 2418: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 2419: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 2420: 2421: free((*s_etat_processus).definitions_chainees); 2422: free(s_objet); 2423: 2424: (*s_etat_processus).definitions_chainees = 2425: definitions_chainees_precedentes; 2426: 2427: (*s_etat_processus).niveau_recursivite--; 2428: (*s_etat_processus).position_courante = position_courante; 2429: 2430: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2431: (*s_etat_processus).traitement_interruptible = 2432: registre_interruption; 2433: return; 2434: } 2435: 2436: (*s_etat_processus).test_instruction = registre_test; 2437: (*s_etat_processus).longueur_definitions_chainees = 2438: sauvegarde_longueur_definitions_chainees; 2439: 2440: (*s_etat_processus).instruction_courante = tampon; 2441: (*s_etat_processus).autorisation_evaluation_nom = 2442: autorisation_evaluation_nom; 2443: 2444: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 2445: (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; 2446: 2447: free((*s_etat_processus).definitions_chainees); 2448: (*s_etat_processus).definitions_chainees = 2449: definitions_chainees_precedentes; 2450: 2451: (*s_etat_processus).niveau_recursivite--; 2452: 2453: (*s_etat_processus).position_courante = position_courante; 2454: 2455: /* 2456: -- Relecture de la pile opérationnelle ----------------------------------------- 2457: */ 2458: 2459: profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle; 2460: 2461: l_element_courant = NULL; 2462: 2463: free(s_objet); 2464: 2465: for(i = 0; i < (profondeur_finale - profondeur_initiale); i++) 2466: { 2467: if (depilement(s_etat_processus, 2468: &((*s_etat_processus).l_base_pile), 2469: &s_objet) == d_erreur) 2470: { 2471: (*s_etat_processus).traitement_interruptible = 2472: registre_interruption; 2473: return; 2474: } 2475: 2476: if (empilement(s_etat_processus, &l_element_courant, 2477: s_objet) == d_erreur) 2478: { 2479: (*s_etat_processus).traitement_interruptible = 2480: registre_interruption; 2481: return; 2482: } 2483: } 2484: 2485: s_objet = (struct_objet *) malloc(sizeof(struct_objet)); 2486: 2487: if (s_objet == NULL) 2488: { 2489: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2490: (*s_etat_processus).traitement_interruptible = 2491: registre_interruption; 2492: return; 2493: } 2494: 2495: initialisation_objet(s_objet); 2496: (*s_objet).type = LST; 2497: element = (void *) l_element_courant; 2498: 2499: break; 2500: } 2501: 2502: /* 2503: -------------------------------------------------------------------------------- 2504: Nom ou expression algébrique 2505: -------------------------------------------------------------------------------- 2506: */ 2507: 2508: case '\'' : 2509: { 2510: if ((tampon = analyse_algebrique(s_etat_processus, 2511: (*s_etat_processus).instruction_courante, 2512: &l_base_liste_fonctions)) == NULL) 2513: { 2514: /* 2515: * L'erreur est de type exécution ou système. 2516: * Dans le doute, on libère *s_objet. 2517: */ 2518: 2519: while(l_base_liste_fonctions != NULL) 2520: { 2521: l_element_courant_fonctions = l_base_liste_fonctions; 2522: l_base_liste_fonctions = (*l_base_liste_fonctions).suivant; 2523: 2524: free((*((struct_fonction *) (*l_element_courant_fonctions) 2525: .donnee)).nom_fonction); 2526: free((struct_fonction *) (*l_element_courant_fonctions) 2527: .donnee); 2528: free(l_element_courant_fonctions); 2529: } 2530: 2531: free(s_objet); 2532: 2533: (*s_etat_processus).traitement_interruptible = 2534: registre_interruption; 2535: return; 2536: } 2537: 2538: l_base_liste_decomposition = analyse_rpn(s_etat_processus, tampon); 2539: l_element_courant = l_base_liste_decomposition; 2540: nombre_elements = 0; 2541: 2542: while(l_element_courant != NULL) 2543: { 2544: nombre_elements++; 2545: l_element_courant = (*l_element_courant).suivant; 2546: } 2547: 2548: if (nombre_elements == 3) 2549: { 2550: free(tampon); 2551: 2552: (*s_objet).type = (*(*(*l_base_liste_decomposition) 2553: .suivant).donnee).type; 2554: element = (void *) (*(*(*l_base_liste_decomposition) 2555: .suivant).donnee).objet; 2556: 2557: if ((*s_objet).type == NOM) 2558: { 2559: (*((struct_nom *) (*(*(*l_base_liste_decomposition) 2560: .suivant).donnee).objet)).symbole = d_vrai; 2561: } 2562: else if ((*s_objet).type == FCT) 2563: { 2564: /* 2565: * On essaye de mettre d'utiliser une fonction 2566: * comme un nom... On convertit la fonction en nom 2567: * puis on renvoie une erreur. 2568: */ 2569: 2570: free(s_objet); 2571: 2572: l_element_courant = l_base_liste_decomposition; 2573: 2574: while(l_element_courant != NULL) 2575: { 2576: liberation(s_etat_processus, 2577: (*l_element_courant).donnee); 2578: l_element_precedent = l_element_courant; 2579: l_element_courant = (*l_element_courant).suivant; 2580: free(l_element_precedent); 2581: } 2582: 2583: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2584: (*s_etat_processus).traitement_interruptible = 2585: registre_interruption; 2586: return; 2587: } 2588: 2589: l_element_precedent = l_base_liste_decomposition; 2590: l_element_courant = (*l_element_precedent).suivant; 2591: liberation(s_etat_processus, (*l_element_precedent).donnee); 2592: free(l_element_precedent); 2593: l_element_precedent = l_element_courant; 2594: l_element_courant = (*l_element_courant).suivant; 2595: free((*l_element_precedent).donnee); 2596: free(l_element_precedent); 2597: liberation(s_etat_processus, (*l_element_courant).donnee); 2598: free(l_element_courant); 2599: } 2600: else 2601: { 2602: (*s_objet).type = ALG; 2603: 2604: if ((*s_etat_processus).debug == d_vrai) 2605: if (((*s_etat_processus).type_debug & 2606: d_debug_variables) != 0) 2607: { 2608: if ((*s_etat_processus).langue == 'F') 2609: { 2610: printf("[%d] Conversion de l'expression en " 2611: "notation polonaise inversée\n%s\n", 2612: (int) getpid(), tampon); 2613: } 2614: else 2615: { 2616: printf("[%d] Translation of expression " 2617: "into reverse polish notation\n%s", 2618: (int) getpid(), tampon); 2619: } 2620: 2621: fflush(stdout); 2622: } 2623: 2624: element = (void *) l_base_liste_decomposition; 2625: free(tampon); 2626: 2627: if (element == NULL) 2628: { 2629: (*s_etat_processus).erreur_execution = 2630: d_ex_expression_invalide; 2631: (*s_etat_processus).traitement_interruptible = 2632: registre_interruption; 2633: return; 2634: } 2635: 2636: l_element_courant = (struct_liste_chainee *) element; 2637: 2638: while(l_element_courant != NULL) 2639: { 2640: if ((*(*l_element_courant).donnee).type == FCT) 2641: { 2642: /* 2643: * Si la fonction est intrinsèque au langage, 2644: * elle est convertie en majuscules. 2645: */ 2646: 2647: tampon = conversion_majuscule((*((struct_fonction *) 2648: (*(*l_element_courant).donnee).objet)) 2649: .nom_fonction); 2650: 2651: free((*((struct_fonction *) 2652: (*(*l_element_courant).donnee).objet)) 2653: .nom_fonction); 2654: 2655: (*((struct_fonction *) (*(*l_element_courant).donnee) 2656: .objet)).nom_fonction = tampon; 2657: 2658: if (strcmp(tampon, "=") == 0) 2659: { 2660: nombre_egalites++; 2661: } 2662: } 2663: 2664: l_element_courant = (*l_element_courant).suivant; 2665: } 2666: 2667: l_element_courant = (struct_liste_chainee *) element; 2668: 2669: while(l_element_courant != NULL) 2670: { 2671: if (((*(*l_element_courant).donnee).type == FCT) 2672: || ((*(*l_element_courant).donnee).type == NOM)) 2673: { 2674: if ((*(*l_element_courant).donnee).type == FCT) 2675: { 2676: if (l_base_liste_fonctions != NULL) 2677: { 2678: l_element_courant_fonctions = 2679: l_base_liste_fonctions; 2680: 2681: while(l_element_courant_fonctions != NULL) 2682: { 2683: if ((fonction_majuscule = 2684: conversion_majuscule( 2685: (*((struct_fonction *) 2686: ((*l_element_courant_fonctions) 2687: .donnee))).nom_fonction)) == NULL) 2688: { 2689: (*s_etat_processus).erreur_systeme = 2690: d_es_allocation_memoire; 2691: (*s_etat_processus) 2692: .traitement_interruptible = 2693: registre_interruption; 2694: return; 2695: } 2696: 2697: if (strcmp(fonction_majuscule, 2698: (*((struct_fonction *) 2699: (*(*l_element_courant).donnee) 2700: .objet)).nom_fonction) == 0) 2701: { 2702: free(fonction_majuscule); 2703: break; 2704: } 2705: 2706: free(fonction_majuscule); 2707: l_element_courant_fonctions = 2708: (*l_element_courant_fonctions) 2709: .suivant; 2710: } 2711: 2712: if (l_element_courant_fonctions != NULL) 2713: { 2714: (*((struct_fonction *) 2715: (*(*l_element_courant) 2716: .donnee).objet)).nombre_arguments = 2717: (*((struct_fonction *) 2718: ((*l_element_courant_fonctions) 2719: .donnee))).nombre_arguments; 2720: } 2721: else 2722: { 2723: (*((struct_fonction *) 2724: (*(*l_element_courant).donnee) 2725: .objet)).nombre_arguments = 0; 2726: } 2727: } 2728: else 2729: { 2730: (*((struct_fonction *) 2731: (*(*l_element_courant).donnee) 2732: .objet)).nombre_arguments = 0; 2733: } 2734: } 2735: else 2736: { 2737: (*((struct_nom *) (*(*l_element_courant).donnee) 2738: .objet)).symbole = d_faux; 2739: 2740: if (l_base_liste_fonctions != NULL) 2741: { 2742: l_element_courant_fonctions = 2743: l_base_liste_fonctions; 2744: 2745: while((strcmp((*((struct_fonction *) 2746: ((*l_element_courant_fonctions) 2747: .donnee))).nom_fonction, 2748: (*((struct_nom *) 2749: (*(*l_element_courant).donnee).objet)) 2750: .nom) != 0) && 2751: ((*l_element_courant_fonctions) 2752: .suivant != NULL)) 2753: { 2754: l_element_courant_fonctions = 2755: (*l_element_courant_fonctions) 2756: .suivant; 2757: } 2758: 2759: if (((*l_element_courant_fonctions).suivant != 2760: NULL) || (strcmp((*((struct_nom *) 2761: (*(*l_element_courant).donnee).objet)) 2762: .nom, (*((struct_fonction *) 2763: ((*l_element_courant_fonctions) 2764: .donnee))).nom_fonction) == 0)) 2765: { 2766: tampon = (*((struct_nom *) 2767: (*(*l_element_courant) 2768: .donnee).objet)).nom; 2769: 2770: if ((s_sous_objet = (struct_objet *) 2771: malloc(sizeof( 2772: struct_objet))) == NULL) 2773: { 2774: (*s_etat_processus).erreur_systeme = 2775: d_es_allocation_memoire; 2776: (*s_etat_processus) 2777: .traitement_interruptible = 2778: registre_interruption; 2779: return; 2780: } 2781: 2782: initialisation_objet(s_sous_objet); 2783: (*s_sous_objet).type = FCT; 2784: 2785: if (((*s_sous_objet).objet = (void *) 2786: malloc(sizeof(struct_fonction))) 2787: == NULL) 2788: { 2789: (*s_etat_processus).erreur_systeme = 2790: d_es_allocation_memoire; 2791: (*s_etat_processus) 2792: .traitement_interruptible = 2793: registre_interruption; 2794: return; 2795: } 2796: 2797: (*((struct_fonction *) ((*s_sous_objet) 2798: .objet))).nom_fonction = tampon; 2799: 2800: (*((struct_fonction *) ((*s_sous_objet) 2801: .objet))).fonction = 2802: analyse_instruction( 2803: s_etat_processus, tampon); 2804: 2805: (*((struct_fonction *) ((*s_sous_objet) 2806: .objet))).nombre_arguments = 2807: (*((struct_fonction *) 2808: ((*l_element_courant_fonctions) 2809: .donnee))).nombre_arguments; 2810: 2811: free((struct_nom *) (*(*l_element_courant) 2812: .donnee).objet); 2813: free((*l_element_courant).donnee); 2814: 2815: (*l_element_courant).donnee = s_sous_objet; 2816: } 2817: } 2818: } 2819: } 2820: 2821: l_element_courant = (*l_element_courant).suivant; 2822: } 2823: } 2824: 2825: while(l_base_liste_fonctions != NULL) 2826: { 2827: l_element_courant_fonctions = l_base_liste_fonctions; 2828: l_base_liste_fonctions = (*l_base_liste_fonctions).suivant; 2829: 2830: free((*((struct_fonction *) (*l_element_courant_fonctions) 2831: .donnee)).nom_fonction); 2832: free((struct_fonction *) (*l_element_courant_fonctions).donnee); 2833: free(l_element_courant_fonctions); 2834: } 2835: 2836: break; 2837: } 2838: 2839: /* 2840: -------------------------------------------------------------------------------- 2841: Chaîne de caractères 2842: -------------------------------------------------------------------------------- 2843: */ 2844: 2845: case '"' : 2846: { 2847: (*s_objet).type = CHN; 2848: 2849: element = (void *) ((unsigned char *) malloc( 2850: (strlen((*s_etat_processus).instruction_courante) - 1) 2851: * sizeof(unsigned char))); 2852: 2853: if (element == NULL) 2854: { 2855: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2856: (*s_etat_processus).traitement_interruptible = 2857: registre_interruption; 2858: return; 2859: } 2860: 2861: ptr_lecture = (*s_etat_processus).instruction_courante + 1; 2862: ptr_ecriture = (unsigned char *) element; 2863: 2864: while((*ptr_lecture) != d_code_fin_chaine) 2865: { 2866: *ptr_ecriture++ = *ptr_lecture++; 2867: } 2868: 2869: (*(--ptr_ecriture)) = d_code_fin_chaine; 2870: 2871: break; 2872: } 2873: 2874: /* 2875: -------------------------------------------------------------------------------- 2876: Définition ou tableau 2877: -------------------------------------------------------------------------------- 2878: */ 2879: 2880: case '<' : 2881: { 2882: if ((*s_etat_processus).instruction_courante[1] == '[') 2883: { 2884: // Tableau 2885: 2886: sauvegarde_longueur_definitions_chainees = 2887: (*s_etat_processus).longueur_definitions_chainees; 2888: 2889: tampon = (unsigned char *) malloc( 2890: (((*s_etat_processus).longueur_definitions_chainees 2891: = strlen((*s_etat_processus).instruction_courante) 2892: + 2) + 1) * sizeof(unsigned char)); 2893: 2894: if (tampon == NULL) 2895: { 2896: (*s_etat_processus).erreur_systeme = 2897: d_es_allocation_memoire; 2898: (*s_etat_processus).traitement_interruptible = 2899: registre_interruption; 2900: return; 2901: } 2902: 2903: strcpy(tampon, "<< "); 2904: ptr_ecriture = tampon + 3; 2905: ptr_lecture = (*s_etat_processus).instruction_courante + 2; 2906: 2907: while((*ptr_lecture) != d_code_fin_chaine) 2908: { 2909: *ptr_ecriture++ = *ptr_lecture++; 2910: } 2911: 2912: ptr_ecriture -= 2; 2913: (*ptr_ecriture) = d_code_fin_chaine; 2914: strcat(ptr_ecriture, " >>"); 2915: 2916: position_courante = (*s_etat_processus).position_courante; 2917: (*s_etat_processus).position_courante = 0; 2918: 2919: profondeur_initiale = (*s_etat_processus) 2920: .hauteur_pile_operationnelle; 2921: 2922: /* 2923: -- On met les éléments du tableau dans la pile opérationnelle ------------------ 2924: */ 2925: 2926: (*s_etat_processus).niveau_recursivite++; 2927: definitions_chainees_precedentes = (*s_etat_processus) 2928: .definitions_chainees; 2929: (*s_etat_processus).definitions_chainees = tampon; 2930: 2931: s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; 2932: sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant; 2933: 2934: (*s_etat_processus).l_base_pile_systeme = NULL; 2935: empilement_pile_systeme(s_etat_processus); 2936: 2937: if ((*s_etat_processus).erreur_systeme != d_es) 2938: { 2939: (*s_etat_processus).traitement_interruptible = 2940: registre_interruption; 2941: return; 2942: } 2943: 2944: (*(*s_etat_processus).l_base_pile_systeme) 2945: .retour_definition = 'Y'; 2946: (*s_etat_processus).niveau_courant = 0; 2947: (*s_etat_processus).autorisation_empilement_programme = 'N'; 2948: registre_mode_execution_programme = 2949: (*s_etat_processus).mode_execution_programme; 2950: (*s_etat_processus).mode_execution_programme = 'Y'; 2951: (*s_etat_processus).erreur_scrutation = d_faux; 2952: 2953: tampon = (*s_etat_processus).instruction_courante; 2954: nombre_lignes_a_supprimer = 2955: (*s_etat_processus).hauteur_pile_operationnelle; 2956: 2957: if ((*s_etat_processus).profilage == d_vrai) 2958: { 2959: profilage(s_etat_processus, "RPL/2 internals"); 2960: 2961: if ((*s_etat_processus).erreur_systeme != d_es) 2962: { 2963: return; 2964: } 2965: } 2966: 2967: registre_recherche_type = (*s_etat_processus).recherche_type; 2968: (*s_etat_processus).recherche_type = 'Y'; 2969: 2970: variable_implicite = 2971: (*s_etat_processus).autorisation_nom_implicite; 2972: (*s_etat_processus).autorisation_nom_implicite = 'Y'; 2973: 2974: if (sequenceur(s_etat_processus) == d_erreur) 2975: { 2976: (*s_etat_processus).autorisation_nom_implicite = 2977: variable_implicite; 2978: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 2979: (*s_etat_processus).recherche_type = 2980: registre_recherche_type; 2981: (*s_etat_processus).mode_execution_programme = 2982: registre_mode_execution_programme; 2983: nombre_lignes_a_supprimer = 2984: (*s_etat_processus).hauteur_pile_operationnelle 2985: - nombre_lignes_a_supprimer; 2986: 2987: for(i = 0; i < nombre_lignes_a_supprimer; i++) 2988: { 2989: if (depilement(s_etat_processus, 2990: &((*s_etat_processus).l_base_pile), 2991: &s_sous_objet) == d_erreur) 2992: { 2993: (*s_etat_processus).traitement_interruptible = 2994: registre_interruption; 2995: return; 2996: } 2997: 2998: liberation(s_etat_processus, s_sous_objet); 2999: } 3000: 3001: (*s_etat_processus).instruction_courante = tampon; 3002: 3003: effacement_pile_systeme(s_etat_processus); 3004: (*s_etat_processus).l_base_pile_systeme = 3005: s_sauvegarde_pile; 3006: (*s_etat_processus).niveau_courant = 3007: sauvegarde_niveau_courant; 3008: 3009: free((*s_etat_processus).definitions_chainees); 3010: (*s_etat_processus).niveau_recursivite--; 3011: 3012: (*s_etat_processus).definitions_chainees = 3013: definitions_chainees_precedentes; 3014: (*s_etat_processus).longueur_definitions_chainees = 3015: sauvegarde_longueur_definitions_chainees; 3016: 3017: (*s_etat_processus).position_courante = 3018: position_courante; 3019: 3020: free(s_objet); 3021: 3022: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3023: (*s_etat_processus).traitement_interruptible = 3024: registre_interruption; 3025: return; 3026: } 3027: 3028: (*s_etat_processus).autorisation_nom_implicite = 3029: variable_implicite; 3030: (*s_etat_processus).recherche_type = registre_recherche_type; 3031: (*s_etat_processus).mode_execution_programme = 3032: registre_mode_execution_programme; 3033: 3034: if ((*s_etat_processus).erreur_scrutation == d_vrai) 3035: { 3036: nombre_lignes_a_supprimer = 3037: (*s_etat_processus).hauteur_pile_operationnelle 3038: - nombre_lignes_a_supprimer; 3039: 3040: for(i = 0; i < nombre_lignes_a_supprimer; i++) 3041: { 3042: if (depilement(s_etat_processus, 3043: &((*s_etat_processus).l_base_pile), 3044: &s_sous_objet) == d_erreur) 3045: { 3046: (*s_etat_processus).traitement_interruptible = 3047: registre_interruption; 3048: return; 3049: } 3050: 3051: liberation(s_etat_processus, s_sous_objet); 3052: } 3053: 3054: (*s_etat_processus).instruction_courante = tampon; 3055: 3056: effacement_pile_systeme(s_etat_processus); 3057: (*s_etat_processus).l_base_pile_systeme = 3058: s_sauvegarde_pile; 3059: (*s_etat_processus).niveau_courant = 3060: sauvegarde_niveau_courant; 3061: 3062: free((*s_etat_processus).definitions_chainees); 3063: (*s_etat_processus).niveau_recursivite--; 3064: 3065: (*s_etat_processus).definitions_chainees = 3066: definitions_chainees_precedentes; 3067: (*s_etat_processus).longueur_definitions_chainees = 3068: sauvegarde_longueur_definitions_chainees; 3069: 3070: (*s_etat_processus).position_courante = 3071: position_courante; 3072: 3073: free(s_objet); 3074: 3075: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3076: (*s_etat_processus).traitement_interruptible = 3077: registre_interruption; 3078: return; 3079: } 3080: 3081: (*s_etat_processus).instruction_courante = tampon; 3082: 3083: (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; 3084: (*s_etat_processus).niveau_courant = 3085: sauvegarde_niveau_courant; 3086: 3087: free((*s_etat_processus).definitions_chainees); 3088: (*s_etat_processus).definitions_chainees = 3089: definitions_chainees_precedentes; 3090: (*s_etat_processus).longueur_definitions_chainees = 3091: sauvegarde_longueur_definitions_chainees; 3092: 3093: (*s_etat_processus).niveau_recursivite--; 3094: 3095: (*s_etat_processus).position_courante = position_courante; 3096: 3097: /* 3098: -- On relit la pile qui contient des sous-objets contenant les ----------------- 3099: -- éléments du tableau --------------------------------------------------------- 3100: */ 3101: 3102: profondeur_finale = (*s_etat_processus) 3103: .hauteur_pile_operationnelle; 3104: 3105: nombre_lignes = profondeur_finale - profondeur_initiale; 3106: 3107: if ((element = malloc(sizeof(struct_tableau))) == NULL) 3108: { 3109: (*s_etat_processus).erreur_systeme = 3110: d_es_allocation_memoire; 3111: (*s_etat_processus).traitement_interruptible = 3112: registre_interruption; 3113: return; 3114: } 3115: 3116: (*((struct_tableau *) element)).nombre_elements = nombre_lignes; 3117: 3118: if (((*((struct_tableau *) element)).elements = 3119: malloc(nombre_lignes * sizeof(struct_objet *))) == NULL) 3120: { 3121: (*s_etat_processus).erreur_systeme = 3122: d_es_allocation_memoire; 3123: (*s_etat_processus).traitement_interruptible = 3124: registre_interruption; 3125: return; 3126: } 3127: 3128: for(i = 1; i <= nombre_lignes; i++) 3129: { 3130: if (depilement(s_etat_processus, 3131: &((*s_etat_processus).l_base_pile), 3132: &s_sous_objet) == d_erreur) 3133: { 3134: (*s_etat_processus).traitement_interruptible = 3135: registre_interruption; 3136: return; 3137: } 3138: 3139: (*((struct_tableau *) element)).elements[nombre_lignes - i] 3140: = s_sous_objet; 3141: } 3142: 3143: (*s_objet).type = TBL; 3144: 3145: (*s_etat_processus).traitement_interruptible = 3146: registre_interruption; 3147: } 3148: else 3149: { 3150: // Définition 3151: 3152: if (strlen((*s_etat_processus).instruction_courante) < 5) 3153: { 3154: free(s_objet); 3155: 3156: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3157: (*s_etat_processus).traitement_interruptible = 3158: registre_interruption; 3159: return; 3160: } 3161: 3162: if ((strncmp((*s_etat_processus).instruction_courante, "<< ", 3) 3163: != 0) && (strcmp((*s_etat_processus) 3164: .instruction_courante, "<<") != 0)) 3165: { 3166: free(s_objet); 3167: 3168: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3169: (*s_etat_processus).traitement_interruptible = 3170: registre_interruption; 3171: return; 3172: } 3173: 3174: (*s_objet).type = RPN; 3175: 3176: element = (void *) analyse_rpn(s_etat_processus, 3177: (*s_etat_processus).instruction_courante); 3178: 3179: if (element == NULL) 3180: { 3181: if ((*s_etat_processus).erreur_systeme != d_es) 3182: { 3183: (*s_etat_processus).erreur_systeme = 3184: d_es_allocation_memoire; 3185: } 3186: 3187: free(s_objet); 3188: 3189: (*s_etat_processus).traitement_interruptible = 3190: registre_interruption; 3191: return; 3192: } 3193: 3194: l_element_courant = (struct_liste_chainee *) element; 3195: 3196: while(l_element_courant != NULL) 3197: { 3198: if ((*(*l_element_courant).donnee).type == FCT) 3199: { 3200: if (strcmp((*((struct_fonction *) (*(*l_element_courant) 3201: .donnee).objet)).nom_fonction, "=") == 0) 3202: { 3203: nombre_egalites++; 3204: } 3205: } 3206: 3207: l_element_courant = (*l_element_courant).suivant; 3208: } 3209: } 3210: 3211: break; 3212: } 3213: 3214: /* 3215: -------------------------------------------------------------------------------- 3216: Entier ou réel 3217: -------------------------------------------------------------------------------- 3218: */ 3219: 3220: default : 3221: { 3222: if (((*((*s_etat_processus).instruction_courante)) == '-') || 3223: ((*((*s_etat_processus).instruction_courante)) == '+') || 3224: (((*((*s_etat_processus).instruction_courante)) >= '0') && 3225: ((*((*s_etat_processus).instruction_courante)) 3226: <= '9')) || ((*((*s_etat_processus).instruction_courante)) 3227: == '.')) 3228: { 3229: drapeau_valeur_entiere = ((*((*s_etat_processus) 3230: .instruction_courante)) != '.') ? d_vrai : d_faux; 3231: drapeau_valeur_reelle = d_vrai; 3232: 3233: nombre_points = 0; 3234: nombre_exposants = 0; 3235: 3236: conversion_format(s_etat_processus, 3237: (*s_etat_processus).instruction_courante); 3238: 3239: ptr = (*s_etat_processus).instruction_courante; 3240: 3241: while((*ptr) != d_code_fin_chaine) 3242: { 3243: switch(*ptr) 3244: { 3245: case '0' : 3246: case '1' : 3247: case '2' : 3248: case '3' : 3249: case '4' : 3250: case '5' : 3251: case '6' : 3252: case '7' : 3253: case '8' : 3254: case '9' : 3255: { 3256: break; 3257: } 3258: 3259: // Ne peut survenir qu'après un 'E', un 'e' ou au 3260: // début de la chaîne. 3261: case '+' : 3262: case '-' : 3263: { 3264: if (ptr > (*s_etat_processus).instruction_courante) 3265: { 3266: if (((*(ptr - 1)) != 'e') && 3267: ((*(ptr - 1)) != 'E')) 3268: { 3269: drapeau_valeur_entiere = d_faux; 3270: drapeau_valeur_reelle = d_faux; 3271: } 3272: } 3273: 3274: break; 3275: } 3276: 3277: // Ne peut que commencer une chaîne, suivre un 3278: // chiffre ou un signe. Ne peut constituer un 3279: // nombre seul. 3280: case '.' : 3281: { 3282: nombre_points++; 3283: 3284: if (ptr > (*s_etat_processus).instruction_courante) 3285: { 3286: switch(*(ptr - 1)) 3287: { 3288: case '+' : 3289: case '-' : 3290: case '0' : 3291: case '1' : 3292: case '2' : 3293: case '3' : 3294: case '4' : 3295: case '5' : 3296: case '6' : 3297: case '7' : 3298: case '8' : 3299: case '9' : 3300: { 3301: drapeau_valeur_entiere = d_faux; 3302: break; 3303: } 3304: 3305: default : 3306: { 3307: drapeau_valeur_entiere = d_faux; 3308: drapeau_valeur_reelle = d_faux; 3309: break; 3310: } 3311: } 3312: } 3313: else 3314: { 3315: if ((*(ptr + 1)) == d_code_fin_chaine) 3316: { 3317: drapeau_valeur_entiere = d_faux; 3318: drapeau_valeur_reelle = d_faux; 3319: } 3320: } 3321: 3322: break; 3323: } 3324: 3325: // Ne peut suivre qu'un chiffre ou un point 3326: case 'e' : 3327: case 'E' : 3328: { 3329: nombre_exposants++; 3330: 3331: if (ptr > (*s_etat_processus).instruction_courante) 3332: { 3333: switch(*(ptr - 1)) 3334: { 3335: case '0' : 3336: case '1' : 3337: case '2' : 3338: case '3' : 3339: case '4' : 3340: case '5' : 3341: case '6' : 3342: case '7' : 3343: case '8' : 3344: case '9' : 3345: { 3346: drapeau_valeur_entiere = d_faux; 3347: break; 3348: } 3349: 3350: // Le point doit suivre un chiffre 3351: case '.' : 3352: { 3353: if ((ptr - 1) > (*s_etat_processus) 3354: .instruction_courante) 3355: { 3356: switch(*(ptr - 2)) 3357: { 3358: case '0' : 3359: case '1' : 3360: case '2' : 3361: case '3' : 3362: case '4' : 3363: case '5' : 3364: case '6' : 3365: case '7' : 3366: case '8' : 3367: case '9' : 3368: { 3369: drapeau_valeur_entiere = 3370: d_faux; 3371: break; 3372: } 3373: 3374: default : 3375: { 3376: drapeau_valeur_entiere = 3377: d_faux; 3378: drapeau_valeur_reelle = 3379: d_faux; 3380: break; 3381: } 3382: } 3383: } 3384: else 3385: { 3386: drapeau_valeur_entiere = d_faux; 3387: drapeau_valeur_reelle = d_faux; 3388: } 3389: 3390: break; 3391: } 3392: 3393: default : 3394: { 3395: drapeau_valeur_entiere = d_faux; 3396: drapeau_valeur_reelle = d_faux; 3397: break; 3398: } 3399: } 3400: } 3401: else 3402: { 3403: drapeau_valeur_entiere = d_faux; 3404: drapeau_valeur_reelle = d_faux; 3405: } 3406: 3407: break; 3408: } 3409: 3410: default : 3411: { 3412: drapeau_valeur_entiere = d_faux; 3413: drapeau_valeur_reelle = d_faux; 3414: break; 3415: } 3416: } 3417: 3418: ptr++; 3419: } 3420: 3421: if ((nombre_points > 1) || (nombre_exposants > 1)) 3422: { 3423: drapeau_valeur_reelle = d_faux; 3424: drapeau_valeur_entiere = d_faux; 3425: } 3426: } 3427: else 3428: { 3429: drapeau_valeur_entiere = d_faux; 3430: drapeau_valeur_reelle = d_faux; 3431: } 3432: 3433: if ((drapeau_valeur_reelle == d_faux) && 3434: (drapeau_valeur_entiere == d_faux)) 3435: { 3436: ptr = (*s_etat_processus).instruction_courante; 3437: 3438: while((*ptr) != d_code_fin_chaine) 3439: { 3440: if ((isalnum((*ptr)) == 0) && 3441: ((*ptr) != '_') && 3442: ((*ptr) != '$')) 3443: { 3444: free(s_objet); 3445: 3446: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3447: (*s_etat_processus).traitement_interruptible = 3448: registre_interruption; 3449: 3450: return; 3451: } 3452: 3453: ptr++; 3454: } 3455: 3456: (*s_objet).type = NOM; 3457: 3458: element = malloc(sizeof(struct_nom)); 3459: 3460: if (element == NULL) 3461: { 3462: (*s_etat_processus).erreur_systeme = 3463: d_es_allocation_memoire; 3464: (*s_etat_processus).traitement_interruptible = 3465: registre_interruption; 3466: return; 3467: } 3468: 3469: (*((struct_nom *) element)).symbole = d_faux; 3470: (*((struct_nom *) element)).nom = ((unsigned char *) malloc( 3471: (strlen((*s_etat_processus) 3472: .instruction_courante) + 1) * sizeof(unsigned char))); 3473: 3474: if ((*((struct_nom *) element)).nom == NULL) 3475: { 3476: (*s_etat_processus).erreur_systeme = 3477: d_es_allocation_memoire; 3478: (*s_etat_processus).traitement_interruptible = 3479: registre_interruption; 3480: return; 3481: } 3482: 3483: strcpy((*((struct_nom *) element)).nom, (*s_etat_processus) 3484: .instruction_courante); 3485: } 3486: else 3487: { 3488: if (drapeau_valeur_entiere == d_faux) 3489: { 3490: (*s_objet).type = REL; 3491: 3492: element = (void *) ((real8 *) malloc( 3493: sizeof(real8))); 3494: 3495: if (element == NULL) 3496: { 3497: (*s_etat_processus).erreur_systeme = 3498: d_es_allocation_memoire; 3499: (*s_etat_processus).traitement_interruptible = 3500: registre_interruption; 3501: return; 3502: } 3503: 3504: nombre_elements_convertis = sscanf( 3505: (*s_etat_processus).instruction_courante, "%lg", 3506: (real8 *) element); 3507: 3508: if (nombre_elements_convertis != 1) 3509: { 3510: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3511: } 3512: } 3513: else 3514: { 3515: (*s_objet).type = INT; 3516: 3517: element = (void *) ((integer8 *) malloc( 3518: sizeof(integer8))); 3519: 3520: if (element == NULL) 3521: { 3522: (*s_etat_processus).erreur_systeme = 3523: d_es_allocation_memoire; 3524: (*s_etat_processus).traitement_interruptible = 3525: registre_interruption; 3526: return; 3527: } 3528: 3529: nombre_elements_convertis = sscanf( 3530: (*s_etat_processus).instruction_courante, "%lld", 3531: (integer8 *) element); 3532: 3533: if (nombre_elements_convertis != 1) 3534: { 3535: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3536: } 3537: } 3538: } 3539: 3540: break; 3541: } 3542: } 3543: 3544: (*s_objet).objet = element; 3545: 3546: if (nombre_egalites > 1) 3547: { 3548: liberation(s_etat_processus, s_objet); 3549: 3550: (*s_etat_processus).erreur_execution = d_ex_syntaxe; 3551: (*s_etat_processus).traitement_interruptible = registre_interruption; 3552: return; 3553: } 3554: 3555: if (empilement(s_etat_processus, 3556: &((*s_etat_processus).l_base_pile), s_objet) == d_erreur) 3557: { 3558: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 3559: (*s_etat_processus).traitement_interruptible = 3560: registre_interruption; 3561: return; 3562: } 3563: 3564: (*s_etat_processus).traitement_interruptible = registre_interruption; 3565: return; 3566: } 3567: 3568: 3569: /* 3570: ================================================================================ 3571: Conversion de la virgule 3572: ================================================================================ 3573: Entrées : structure sur l'état du processus 3574: -------------------------------------------------------------------------------- 3575: Sorties : néant 3576: -------------------------------------------------------------------------------- 3577: Effets de bord : néant 3578: ================================================================================ 3579: */ 3580: 3581: void 3582: conversion_format(struct_processus *s_etat_processus, unsigned char *chaine) 3583: { 3584: unsigned char *ptr; 3585: 3586: /* 3587: -------------------------------------------------------------------------------- 3588: Transcription du point en virgule et réciproquement selon l'indicateur 48 3589: -------------------------------------------------------------------------------- 3590: */ 3591: 3592: if (test_cfsf(s_etat_processus, 48) == d_vrai) 3593: { 3594: ptr = chaine; 3595: 3596: while((*ptr) != d_code_fin_chaine) 3597: { 3598: if ((*ptr) == '.') 3599: { 3600: (*ptr) = ','; 3601: } 3602: else if ((*ptr) == ',') 3603: { 3604: (*ptr) = '.'; 3605: } 3606: 3607: ptr++; 3608: } 3609: } 3610: 3611: return; 3612: } 3613: 3614: // vim: ts=4