Return to optimisation.c CVS log

Up to [local] / rpl / src

Correction d'une réinitialisation sauvage de la pile des variables par niveau
dans la copie de la structure de description du processus. Cela corrige
la fonction SPAWN qui échouait sur un segmentation fault car la pile des
variables par niveau était vide alors même que l'arbre des variables contenait
bien les variables. Passage à la prerelease 2.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.0.prerelease.2
    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