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