Return to rplcore.c CVS log

Up to [local] / rpl / src

Correction d'un bug majeur de la routine d'évaluation (n'arrivait qu'en
cas d'erreur en raison d'entrées non dépilées de la pile système). Ajout
d'un drapeau pour éviter la translitération des chaînes dans la génération
des fichiers rpl-core. En effet, si l'erreur était due à un problème
de translitération, le fichier rpl-core n'était jamais écrit car les routines
de translitération bouclaient indéfiniment).

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.13
    4:   Copyright (C) 1989-2013 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:   Fonction 'rplcore' générant un fichier de débogage
   29: ================================================================================
   30:   Entrées : pointeur sur une structure struct_processus
   31: --------------------------------------------------------------------------------
   32:   Sorties :
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: void
   39: rplcore(struct_processus *s_etat_processus)
   40: {
   41:     file                        *fichier;
   42: 
   43:     logical1                    erreur;
   44:     logical1                    fin_boucle;
   45: 
   46:     long                        i;
   47:     long                        j;
   48:     long                        longueur_lignes = 65;
   49: 
   50:     struct_liste_chainee        *l_base_pile;
   51:     struct_liste_chainee        *l_element_courant;
   52: 
   53:     struct_objet                *s_objet_last;
   54: 
   55:     unsigned char               *expression;
   56:     unsigned char               *nom;
   57:     unsigned char               *message_erreur;
   58:     unsigned char               *pile;
   59:     unsigned char               *ptr;
   60:     unsigned char               *ptr_bis;
   61:     unsigned char               registre;
   62:     unsigned char               registre_langue;
   63: 
   64:     (*s_etat_processus).core = d_faux;
   65: 
   66:     cf(s_etat_processus, 34);
   67: 
   68:     sf(s_etat_processus, 37);
   69:     sf(s_etat_processus, 38);
   70:     sf(s_etat_processus, 39);
   71:     sf(s_etat_processus, 40);
   72:     sf(s_etat_processus, 41);
   73:     sf(s_etat_processus, 42);
   74: 
   75:     cf(s_etat_processus, 43);
   76:     cf(s_etat_processus, 44);
   77: 
   78:     sf(s_etat_processus, 45);
   79: 
   80:     cf(s_etat_processus, 48);
   81: 
   82:     cf(s_etat_processus, 49);
   83:     cf(s_etat_processus, 50);
   84: 
   85:     cf(s_etat_processus, 53);
   86:     cf(s_etat_processus, 54);
   87:     cf(s_etat_processus, 55);
   88:     cf(s_etat_processus, 56);
   89: 
   90:     sf(s_etat_processus, 60);
   91: 
   92:     registre_langue = (*s_etat_processus).langue;
   93:     (*s_etat_processus).langue = 'E';
   94: 
   95:     message_erreur = messages(s_etat_processus);
   96: 
   97:     (*s_etat_processus).langue = registre_langue;
   98: 
   99:     if ((nom = malloc((strlen(ds_rplcore) + 64 + 1) * sizeof(unsigned char)))
  100:             == NULL)
  101:     {
  102:         free(message_erreur);
  103:         return;
  104:     }
  105: 
  106:     snprintf(nom, strlen(ds_rplcore) + 64 + 1,
  107:             "%s-%lu-%lu", ds_rplcore, (unsigned long) getpid(),
  108:             (unsigned long) pthread_self());
  109: 
  110:     if ((fichier = fopen(nom, "w+")) == NULL)
  111:     {
  112:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  113:         free(message_erreur);
  114:         free(nom);
  115: 
  116:         return;
  117:     }
  118: 
  119:     free(nom);
  120: 
  121:     if (fprintf(fichier, "// RPL/2 version %s process image\n",
  122:             d_version_rpl) < 0)
  123:     {
  124:         free(message_erreur);
  125: 
  126:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  127:         return;
  128:     }
  129: 
  130:     if (fprintf(fichier, "// Process %d\n", (int) getpid()) < 0)
  131:     {
  132:         free(message_erreur);
  133: 
  134:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  135:         return;
  136:     }
  137: 
  138:     if (fprintf(fichier, "// Source file : %s\n\n",
  139:             (*s_etat_processus).nom_fichier_source) < 0)
  140:     {
  141:         free(message_erreur);
  142: 
  143:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  144:         return;
  145:     }
  146: 
  147:     if ((*s_etat_processus).instruction_derniere_erreur != NULL)
  148:     {
  149:         if (fprintf(fichier, "// Error :\n%s [level %lu]\n\n",
  150:                 message_erreur, (*s_etat_processus).niveau_derniere_erreur) < 0)
  151:         {
  152:             free(message_erreur);
  153: 
  154:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  155:             return;
  156:         }
  157:     }
  158:     else if ((*s_etat_processus).instruction_derniere_erreur[0] ==
  159:             d_code_fin_chaine)
  160:     {
  161:         if (fprintf(fichier, "// Error :\n%s [level %lu]\n\n",
  162:                 message_erreur, (*s_etat_processus).niveau_derniere_erreur) < 0)
  163:         {
  164:             free(message_erreur);
  165: 
  166:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  167:             return;
  168:         }
  169:     }
  170:     else if (fprintf(fichier, "// Error :\n%s [%s at level %lu]\n\n",
  171:             message_erreur, (*s_etat_processus).instruction_derniere_erreur,
  172:             (*s_etat_processus).niveau_derniere_erreur) < 0)
  173:     {
  174:         free(message_erreur);
  175: 
  176:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  177:         return;
  178:     }
  179: 
  180:     free(message_erreur);
  181: 
  182:     if (fprintf(fichier, "// System stack\n\n") < 0)
  183:     {
  184:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  185:         return;
  186:     }
  187: 
  188:     trace(s_etat_processus, fichier);
  189: 
  190:     if (fprintf(fichier, "// Process stack\n\n") < 0)
  191:     {
  192:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  193:         return;
  194:     }
  195: 
  196:     l_element_courant = (struct_liste_chainee *)
  197:             (*s_etat_processus).l_base_pile_processus;
  198:     i = 0;
  199: 
  200:     if (pthread_mutex_trylock(&((*s_etat_processus).mutex)) == 0)
  201:     {
  202:         while(l_element_courant != NULL)
  203:         {
  204:             if ((*(*((struct_processus_fils *)
  205:                     (*(*l_element_courant).donnee).objet)).thread)
  206:                     .processus_detache == d_vrai)
  207:             {
  208:                 if (fprintf(fichier, "%ld: Process [%d]\n",
  209:                         i++, (int) (*(*((struct_processus_fils *)
  210:                         (*(*l_element_courant).donnee).objet)).thread).pid) < 0)
  211:                 {
  212:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  213:                     return;
  214:                 }
  215:             }
  216:             else
  217:             {
  218:                 if (fprintf(fichier, "%ld: Thread [%llu] from [%llu]\n",
  219:                         i++, (unsigned long long) (*(*((struct_processus_fils *)
  220:                         (*(*l_element_courant).donnee).objet)).thread)
  221:                         .tid, (unsigned long long)
  222:                         (*(*((struct_processus_fils *) (*(*l_element_courant)
  223:                         .donnee).objet)).thread).pid) < 0)
  224:                 {
  225:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  226:                     return;
  227:                 }
  228:             }
  229: 
  230:             l_element_courant = (*l_element_courant).suivant;
  231:         }
  232: 
  233:         if (fprintf(fichier, "%ld: Process [%d]\n\n", i,
  234:                 (int) getpid()) < 0)
  235:         {
  236:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  237:             return;
  238:         }
  239: 
  240:         pthread_mutex_unlock(&((*s_etat_processus).mutex));
  241:     }
  242: 
  243:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  244:     {
  245:         // LAST valide
  246: 
  247:         if (fprintf(fichier, "// Arguments\n\n") < 0)
  248:         {
  249:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  250:             return;
  251:         }
  252: 
  253:         l_base_pile = NULL;
  254: 
  255:         while((*s_etat_processus).l_base_pile_last != NULL)
  256:         {
  257:             if (depilement(s_etat_processus, &((*s_etat_processus)
  258:                     .l_base_pile_last), &s_objet_last) == d_erreur)
  259:             {
  260:                 return;
  261:             }
  262: 
  263:             if (empilement(s_etat_processus, &l_base_pile, s_objet_last)
  264:                     == d_erreur)
  265:             {
  266:                 return;
  267:             }
  268:         }
  269: 
  270:         if ((*s_etat_processus).l_base_pile != NULL)
  271:         {
  272:             registre = (*s_etat_processus).autorisation_conversion_chaine;
  273:             (*s_etat_processus).autorisation_conversion_chaine = 'N';
  274: 
  275:             ecriture_pile(s_etat_processus, fichier, l_base_pile, 1);
  276: 
  277:             (*s_etat_processus).autorisation_conversion_chaine = registre;
  278:         }
  279:         else
  280:         {
  281:             if (fprintf(fichier, "   No argument\n") < 0)
  282:             {
  283:                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  284:                 return;
  285:             }
  286:         }
  287: 
  288:         while(l_base_pile != NULL)
  289:         {
  290:             if (depilement(s_etat_processus, &l_base_pile,
  291:                     &s_objet_last) == d_erreur)
  292:             {
  293:                 return;
  294:             }
  295: 
  296:             if (empilement(s_etat_processus, &((*s_etat_processus)
  297:                     .l_base_pile_last), s_objet_last) == d_erreur)
  298:             {
  299:                 return;
  300:             }
  301:         }
  302:     }
  303:     else
  304:     {
  305:         // LAST invalide
  306: 
  307:         if (fprintf(fichier, "// Current stack (LAST disabled)\n") < 0)
  308:         {
  309:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  310:             return;
  311:         }
  312:     }
  313: 
  314:     if (fprintf(fichier, "\n// Stack\n\n") < 0)
  315:     {
  316:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  317:         return;
  318:     }
  319: 
  320:     if ((*s_etat_processus).l_base_pile != NULL)
  321:     {
  322:         registre = (*s_etat_processus).autorisation_conversion_chaine;
  323:         (*s_etat_processus).autorisation_conversion_chaine = 'N';
  324: 
  325:         ecriture_pile(s_etat_processus, fichier,
  326:                 (*s_etat_processus).l_base_pile, 1);
  327: 
  328:         (*s_etat_processus).autorisation_conversion_chaine = registre;
  329:     }
  330:     else
  331:     {
  332:         if (fprintf(fichier, "   Empty stack\n") < 0)
  333:         {
  334:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  335:             return;
  336:         }
  337:     }
  338: 
  339:     if ((*s_etat_processus).s_objet_errone != NULL)
  340:     {
  341:         if (fprintf(fichier, "\n// Current evaluation\n") < 0)
  342:         {
  343:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  344:             return;
  345:         }
  346: 
  347:         // L'objet ne peut être qu'une expression algébrique ou RPN
  348: 
  349:         if (((*(*s_etat_processus).s_objet_errone).type == RPN) ||
  350:                 ((*(*s_etat_processus).s_objet_errone).type == ALG))
  351:         {
  352:             l_element_courant = (*(*s_etat_processus).s_objet_errone).objet;
  353: 
  354:             if (fprintf(fichier, "\n") < 0)
  355:             {
  356:                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  357:                 return;
  358:             }
  359: 
  360:             while(l_element_courant != NULL)
  361:             {
  362:                 if ((*l_element_courant).donnee ==
  363:                         (*s_etat_processus).s_objet_erreur)
  364:                 {
  365:                     if ((expression = formateur(s_etat_processus, 4,
  366:                             (*l_element_courant).donnee)) == NULL)
  367:                     {
  368:                         return;
  369:                     }
  370: 
  371:                     if ((*(*l_element_courant).donnee).type == CHN)
  372:                     {
  373:                         if (fprintf(fichier, " -> \"%s\"\n", expression) < 0)
  374:                         {
  375:                             (*s_etat_processus).erreur_systeme =
  376:                                     d_es_erreur_fichier;
  377:                             return;
  378:                         }
  379:                     }
  380:                     else
  381:                     {
  382:                         if (fprintf(fichier, " -> %s\n", expression) < 0)
  383:                         {
  384:                             (*s_etat_processus).erreur_systeme =
  385:                                     d_es_erreur_fichier;
  386:                             return;
  387:                         }
  388:                     }
  389:                 }
  390:                 else
  391:                 {
  392:                     if ((expression = formateur(s_etat_processus, 4,
  393:                             (*l_element_courant).donnee)) == NULL)
  394:                     {
  395:                         return;
  396:                     }
  397: 
  398:                     if ((*(*l_element_courant).donnee).type == CHN)
  399:                     {
  400:                         if (fprintf(fichier, "    \"%s\"\n", expression) < 0)
  401:                         {
  402:                             (*s_etat_processus).erreur_systeme =
  403:                                     d_es_erreur_fichier;
  404:                             return;
  405:                         }
  406:                     }
  407:                     else
  408:                     {
  409:                         if (fprintf(fichier, "    %s\n", expression) < 0)
  410:                         {
  411:                             (*s_etat_processus).erreur_systeme =
  412:                                     d_es_erreur_fichier;
  413:                             return;
  414:                         }
  415:                     }
  416:                 }
  417: 
  418:                 free(expression);
  419:                 l_element_courant = (*l_element_courant).suivant;
  420:             }
  421:         }
  422:         else
  423:         {
  424:             if ((expression = formateur(s_etat_processus, 4,
  425:                     (*s_etat_processus).s_objet_errone)) == NULL)
  426:             {
  427:                 return;
  428:             }
  429: 
  430:             if (fprintf(fichier, "\n%s\n", expression) < 0)
  431:             {
  432:                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  433:                 return;
  434:             }
  435: 
  436:             free(expression);
  437:         }
  438:     }
  439: 
  440:     if ((*s_etat_processus).longueur_definitions_chainees != 0)
  441:     {
  442:         if (fprintf(fichier, "\n// Definitions\n") < 0)
  443:         {
  444:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  445:             return;
  446:         }
  447: 
  448:         ptr = (*s_etat_processus).definitions_chainees;
  449:         i = 0;
  450:         erreur = d_faux;
  451: 
  452:         while(((*ptr) != d_code_fin_chaine) || (erreur == d_vrai))
  453:         {
  454:             if ((i % longueur_lignes) == 0)
  455:             {
  456:                 if (fprintf(fichier, "\n") < 0)
  457:                 {
  458:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  459:                     return;
  460:                 }
  461: 
  462:                 if (erreur == d_vrai)
  463:                 {
  464:                     if (fprintf(fichier, "PC     :") < 0)
  465:                     {
  466:                         (*s_etat_processus).erreur_systeme =
  467:                                 d_es_erreur_fichier;
  468:                         return;
  469:                     }
  470: 
  471:                     if ((j = i - longueur_lignes) < 0)
  472:                     {
  473:                         j = 0;
  474:                         ptr_bis = (*s_etat_processus).definitions_chainees;
  475:                     }
  476:                     else
  477:                     {
  478:                         ptr_bis = ptr - longueur_lignes;
  479:                     }
  480: 
  481:                     fin_boucle = d_faux;
  482: 
  483:                     while(((*ptr_bis) != d_code_fin_chaine) &&
  484:                             (fin_boucle == d_faux))
  485:                     {
  486:                         if (j == (long) (*s_etat_processus).position_courante)
  487:                         {
  488:                             if (fprintf(fichier, ">|<") < 0)
  489:                             {
  490:                                 (*s_etat_processus).erreur_systeme =
  491:                                         d_es_erreur_fichier;
  492:                                 return;
  493:                             }
  494: 
  495:                             fin_boucle = d_vrai;
  496:                         }
  497:                         else
  498:                         {
  499:                             if (fprintf(fichier, " ") < 0)
  500:                             {
  501:                                 (*s_etat_processus).erreur_systeme =
  502:                                         d_es_erreur_fichier;
  503:                                 return;
  504:                             }
  505:                         }
  506: 
  507:                         j++;
  508:                         ptr_bis++;
  509:                     }
  510: 
  511:                     if (fprintf(fichier, "\n") < 0)
  512:                     {
  513:                         (*s_etat_processus).erreur_systeme =
  514:                                 d_es_erreur_fichier;
  515:                         return;
  516:                     }
  517:                 }
  518: 
  519:                 if ((*ptr) != d_code_fin_chaine)
  520:                 {
  521:                     if (erreur == d_vrai)
  522:                     {
  523:                         if (fprintf(fichier, "\n") < 0)
  524:                         {
  525:                             (*s_etat_processus).erreur_systeme =
  526:                                     d_es_erreur_fichier;
  527:                             return;
  528:                         }
  529:                     }
  530: 
  531:                     if ((i <= (long) (*s_etat_processus).position_courante) &&
  532:                             ((i + longueur_lignes) > (long) (*s_etat_processus)
  533:                             .position_courante))
  534:                     {
  535:                         if (fprintf(fichier, "\nError  : ") < 0)
  536:                         {
  537:                             (*s_etat_processus).erreur_systeme =
  538:                                     d_es_erreur_fichier;
  539:                             return;
  540:                         }
  541: 
  542:                         erreur = d_vrai;
  543:                     }
  544:                     else
  545:                     {
  546:                         if (fprintf(fichier, "         ") < 0)
  547:                         {
  548:                             (*s_etat_processus).erreur_systeme =
  549:                                     d_es_erreur_fichier;
  550:                             return;
  551:                         }
  552: 
  553:                         erreur = d_faux;
  554:                     }
  555:                 }
  556:                 else
  557:                 {
  558:                     erreur = d_faux;
  559:                 }
  560:             }
  561: 
  562:             if ((*ptr) != d_code_fin_chaine)
  563:             {
  564:                 if (ufprintf(fichier, "%c", *ptr) < 0)
  565:                 {
  566:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  567:                     return;
  568:                 }
  569: 
  570:                 ptr++;
  571:             }
  572: 
  573:             i++;
  574:         }
  575: 
  576:         if (fprintf(fichier, "\n// End of definitions\n") < 0)
  577:         {
  578:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  579:             return;
  580:         }
  581:     }
  582: 
  583:     if (fprintf(fichier, "\n// Externals\n\n") < 0)
  584:     {
  585:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  586:         return;
  587:     }
  588: 
  589:     instruction_externals(s_etat_processus);
  590: 
  591:     if (fprintf(fichier, "%s\n", pile =
  592:             formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
  593:             .donnee)) < 0)
  594:     {
  595:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  596:         return;
  597:     }
  598: 
  599:     free(pile);
  600: 
  601:     if (fprintf(fichier, "\n// Variables\n\n") < 0)
  602:     {
  603:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  604:         return;
  605:     }
  606: 
  607:     instruction_vars(s_etat_processus);
  608: 
  609:     if (fprintf(fichier, "%s\n", pile =
  610:             formateur(s_etat_processus, 0, (*(*s_etat_processus).l_base_pile)
  611:             .donnee)) < 0)
  612:     {
  613:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  614:         return;
  615:     }
  616: 
  617:     free(pile);
  618: 
  619:     instruction_drop2(s_etat_processus);
  620: 
  621:     if (fclose(fichier) != 0)
  622:     {
  623:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  624:         return;
  625:     }
  626: 
  627:     free((*s_etat_processus).instruction_derniere_erreur);
  628:     (*s_etat_processus).instruction_derniere_erreur = NULL;
  629: 
  630:     return;
  631: }
  632: 
  633: // vim: ts=4