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