File:  [local] / rpl / src / rplcore.c
Revision 1.74: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:51 2020 UTC (4 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: rpl-4_1_32, HEAD
Modification du copyright.

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

CVSweb interface <joel.bertrand@systella.fr>