Return to optimisation.c CVS log

Up to [local] / rpl / src

Correction permettant de refaire fonctionner l'option -p.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.1
    4:   Copyright (C) 1989-2011 Dr. BERTRAND Joël
    5: 
    6:   This file is part of RPL/2.
    7: 
    8:   RPL/2 is free software; you can redistribute it and/or modify it
    9:   under the terms of the CeCILL V2 License as published by the french
   10:   CEA, CNRS and INRIA.
   11:  
   12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
   13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
   15:   for more details.
   16:  
   17:   You should have received a copy of the CeCILL License
   18:   along with RPL/2. If not, write to info@cecill.info.
   19: ================================================================================
   20: */
   21: 
   22: 
   23: #include "rpl-conv.h"
   24: 
   25: 
   26: /*
   27: ================================================================================
   28:   Boucle principale optimisé de l'interprète RPL/2
   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: logical1
   39: sequenceur_optimise(struct_processus *s_etat_processus)
   40: {
   41:     int                         i;
   42:     int                         nb_variables;
   43:     int                         point_entree;
   44: 
   45:     logical1                    erreur;
   46: 
   47:     struct_objet                *programme_principal;
   48: 
   49:     struct_tableau_variables    *tableau;
   50: 
   51:     unsigned char               *message;
   52: 
   53:     unsigned long               adresse_point_entree;
   54: 
   55:     if ((*s_etat_processus).debug == d_vrai)
   56:         if (((*s_etat_processus).type_debug &
   57:                 d_debug_analyse) != 0)
   58:     {
   59:         if ((*s_etat_processus).langue == 'F')
   60:         {
   61:             printf("+++Optimisation [%d]\n", (int) getpid());
   62:         }
   63:         else
   64:         {
   65:             printf("+++Optimization [%d]\n", (int) getpid());
   66:         }
   67: 
   68:         printf("\n");
   69:         fflush(stdout);
   70:     }
   71: 
   72:     point_entree = -1;
   73:     adresse_point_entree = 0;
   74: 
   75:     empilement_pile_systeme(s_etat_processus);
   76:     (*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
   77:     (*s_etat_processus).autorisation_empilement_programme = 'Y';
   78:     (*s_etat_processus).mode_execution_programme = 'N';
   79: 
   80:     nb_variables = nombre_variables(s_etat_processus,
   81:             (*s_etat_processus).s_arbre_variables);
   82: 
   83:     if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
   84:             == NULL)
   85:     {
   86:         if ((*s_etat_processus).langue == 'F')
   87:         {
   88:             printf("+++Système : Mémoire insuffisante\n");
   89:         }
   90:         else
   91:         {
   92:             printf("+++System : Not enough memory\n");
   93:         }
   94: 
   95:         return(d_erreur);
   96:     }
   97: 
   98:     liste_variables(s_etat_processus, tableau, 0,
   99:             (*s_etat_processus).s_arbre_variables);
  100: 
  101:     for(i = 0; i < nb_variables; i++)
  102:     {
  103:         if (tableau[i].niveau == 0)
  104:         {
  105:             // Variables qui contiennent les points d'entrée des définitions.
  106: 
  107:             (*s_etat_processus).position_courante = (*((unsigned long *)
  108:                     (*(tableau[i].objet)).objet));
  109: 
  110:             if (point_entree == -1)
  111:             {
  112:                 adresse_point_entree = (*s_etat_processus).position_courante;
  113:                 point_entree = i;
  114:             }
  115:             else
  116:             {
  117:                 if ((*s_etat_processus).position_courante <
  118:                         adresse_point_entree)
  119:                 {
  120:                     adresse_point_entree = (*s_etat_processus)
  121:                             .position_courante;
  122:                     point_entree = i;
  123:                 }
  124:             }
  125: 
  126:             if ((erreur = recherche_instruction_suivante(s_etat_processus))
  127:                     == d_erreur)
  128:             {
  129:                 if ((*s_etat_processus).langue == 'F')
  130:                 {
  131:                     printf("+++Fatal : Optimisation impossible\n");
  132:                 }
  133:                 else
  134:                 {
  135:                     printf("+++Fatal : Optimization failed\n");
  136:                 }
  137: 
  138:                 free(tableau);
  139:                 return(d_erreur);
  140:             }
  141: 
  142:             recherche_type(s_etat_processus);
  143: 
  144:             if (((*s_etat_processus).erreur_execution != d_ex) ||
  145:                     ((*s_etat_processus).erreur_systeme != d_es))
  146:             {
  147:                 if ((*s_etat_processus).langue == 'F')
  148:                 {
  149:                     printf("+++Fatal : Optimisation impossible\n");
  150:                 }
  151:                 else
  152:                 {
  153:                     printf("+++Fatal : Optimization failed\n");
  154:                 }
  155: 
  156:                 free(tableau);
  157:                 return(d_erreur);
  158:             }
  159: 
  160:             // Modification de la variable. Il n'existe à cet instant
  161:             // que des variables de niveau 0.
  162: 
  163:             if (recherche_variable(s_etat_processus, tableau[i].nom) ==
  164:                     d_faux)
  165:             {
  166:                 if ((*s_etat_processus).langue == 'F')
  167:                 {
  168:                     printf("+++Fatal : Optimisation impossible\n");
  169:                 }
  170:                 else
  171:                 {
  172:                     printf("+++Fatal : Optimization failed\n");
  173:                 }
  174: 
  175:                 free(tableau);
  176:                 return(d_erreur);
  177:             }
  178: 
  179:             liberation(s_etat_processus, tableau[i].objet);
  180: 
  181:             if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  182:                     &((*(*s_etat_processus).pointeur_variable_courante).objet))
  183:                     == d_erreur)
  184:             {
  185:                 if ((*s_etat_processus).langue == 'F')
  186:                 {
  187:                     printf("+++Fatal : Optimisation impossible\n");
  188:                 }
  189:                 else
  190:                 {
  191:                     printf("+++Fatal : Optimization failed\n");
  192:                 }
  193: 
  194:                 free(tableau);
  195:                 return(d_erreur);
  196:             }
  197: 
  198:             (*(*s_etat_processus).pointeur_variable_courante).origine = 'E';
  199:             free((*s_etat_processus).instruction_courante);
  200: 
  201:             if (point_entree == i)
  202:             {
  203:                 programme_principal = (*(*s_etat_processus)
  204:                         .pointeur_variable_courante).objet;
  205:             }
  206:         }
  207:     }
  208: 
  209:     if (point_entree == -1)
  210:     {
  211:         if ((*s_etat_processus).langue == 'F')
  212:         {
  213:             printf("+++Fatal : Optimisation impossible\n");
  214:         }
  215:         else
  216:         {
  217:             printf("+++Fatal : Optimization failed\n");
  218:         }
  219: 
  220:         free(tableau);
  221:         return(d_erreur);
  222:     }
  223: 
  224:     if ((*s_etat_processus).debug == d_vrai)
  225:     {
  226:         if (((*s_etat_processus).type_debug &
  227:                 d_debug_analyse) != 0)
  228:         {
  229:             printf("\n");
  230: 
  231:             if ((*s_etat_processus).langue == 'F')
  232:             {
  233:                 printf("[%d] Optimisation achevée\n", (int) getpid());
  234:             }
  235:             else
  236:             {
  237:                 printf("[%d] Optimization done\n", (int) getpid());
  238:             }
  239: 
  240:             printf("\n");
  241:             fflush(stdout);
  242:         }
  243:     }
  244: 
  245:     (*s_etat_processus).retour_routine_evaluation = 'Y';
  246: 
  247:     free((*s_etat_processus).definitions_chainees);
  248: 
  249:     if (((*s_etat_processus).definitions_chainees =
  250:             malloc(sizeof(unsigned char))) == NULL)
  251:     {
  252:         if ((*s_etat_processus).langue == 'F')
  253:         {
  254:             printf("+++Fatal : Optimisation impossible\n");
  255:         }
  256:         else
  257:         {
  258:             printf("+++Fatal : Optimization failed\n");
  259:         }
  260: 
  261:         free(tableau);
  262:         return(d_erreur);
  263:     }
  264: 
  265:     (*s_etat_processus).definitions_chainees[0] = d_code_fin_chaine;
  266:     (*s_etat_processus).longueur_definitions_chainees = 0;
  267:     (*s_etat_processus).evaluation_expression_compilee = 'Y';
  268: 
  269:     if ((*s_etat_processus).profilage == d_vrai)
  270:     {
  271:         profilage(s_etat_processus, tableau[point_entree].nom);
  272:     }
  273: 
  274:     if ((*s_etat_processus).erreur_systeme != d_es)
  275:     {
  276:         if ((*s_etat_processus).langue == 'F')
  277:         {
  278:             printf("+++Système : Mémoire insuffisante\n");
  279:         }
  280:         else
  281:         {
  282:             printf("+++System : Not enough memory\n");
  283:         }
  284: 
  285:         free(tableau);
  286:         return(d_erreur);
  287:     }
  288: 
  289:     free(tableau);
  290: 
  291:     erreur = evaluation(s_etat_processus, programme_principal, 'E');
  292: 
  293:     if ((*s_etat_processus).profilage == d_vrai)
  294:     {
  295:         profilage(s_etat_processus, NULL);
  296:     }
  297: 
  298:     (*s_etat_processus).mode_execution_programme = 'N';
  299: 
  300:     if (((*s_etat_processus).erreur_execution != d_ex) ||
  301:             ((*s_etat_processus).exception != d_ep) ||
  302:             ((*s_etat_processus).erreur_systeme != d_es))
  303:     {
  304:         printf("%s [%d]\n", message = messages(s_etat_processus),
  305:                 (int) getpid());
  306: 
  307:         if (test_cfsf(s_etat_processus, 51) == d_faux)
  308:         {
  309:             printf("%s", ds_beep);
  310:         }
  311: 
  312:         free(message);
  313:     }
  314: 
  315:     return(erreur);
  316: }
  317: 
  318: // vim: ts=4