Return to chainage.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:   Routine de chaînage du programme (lecture du fichier puis constitution
   29:   de la chaîne exécutable)
   30: ================================================================================
   31:   Entrées: structure processus
   32: --------------------------------------------------------------------------------
   33:   Sortie: drapeau d'erreur
   34: --------------------------------------------------------------------------------
   35:   Effets de bord: néant
   36: ================================================================================
   37: */
   38: 
   39: logical1
   40: chainage(struct_processus *s_etat_processus)
   41: {
   42:     char                    *nom_fichier_temporaire;
   43: 
   44:     file                    *f_source;
   45: 
   46:     int                     caractere;
   47:     int                     erreur;
   48:     int                     erreur_os;
   49: 
   50:     logical1                drapeau_fin;
   51:     logical1                existence;
   52:     logical1                initialisation;
   53:     logical1                ouverture;
   54:     logical1                presence_chaine;
   55: 
   56:     long                    i;
   57:     long                    nombre_caracteres_source;
   58: 
   59:     unsigned char           *commande;
   60:     unsigned char           *executable_candidat;
   61: 
   62: #   ifndef OS2
   63:     unsigned char           *instructions = "%s/bin/%s %s | "
   64:                                     "%s/bin/rpliconv `%s/bin/rplfile "
   65:                                     "-m %s/share/rplfiles -i %s | "
   66:                                     "%s/bin/rplawk "
   67:                                     "'{ print $3; }' | %s/bin/rplawk -F= "
   68:                                     "'{ if ($2 != \"\") printf(\"-f %%s\", "
   69:                                     "$2); }'` -t %s//IGNORE > %s";
   70: #   else
   71:     unsigned char           *instructions = BOURNE_SHELL " -c \""
   72:                                     "%s/bin/%s %s | "
   73:                                     "%s/bin/rpliconv `%s/bin/rplfile "
   74:                                     "-m %s/share/rplfiles -i %s | "
   75:                                     "%s/bin/rplawk "
   76:                                     "'{ print $3; }' | %s/bin/rplawk -F= "
   77:                                     "'{ if ($2 != \\\"\\\") "
   78:                                     "printf(\\\"-f %%s\\\", "
   79:                                     "$2); }'` -t %s//IGNORE > %s\"";
   80: #   endif
   81: 
   82:     unsigned long           unite_fichier;
   83: 
   84:     if ((*s_etat_processus).debug == d_vrai)
   85:         if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
   86:     {
   87:         printf("\n");
   88: 
   89:         if ((*s_etat_processus).langue == 'F')
   90:         {
   91:             printf("[%d] Appel au préprocesseur\n", (int) getpid());
   92:         }
   93:         else
   94:         {
   95:             printf("[%d] Preprocessing\n", (int) getpid());
   96:         }
   97: 
   98:         fflush(stdout);
   99:     }
  100: 
  101:     erreur = caracteristiques_fichier(s_etat_processus,
  102:             (*s_etat_processus).nom_fichier_source, &existence,
  103:             &ouverture, &unite_fichier);
  104: 
  105:     erreur_os = d_absence_erreur;
  106: 
  107:     if ((existence == d_vrai) && (erreur == 0))
  108:     {
  109:         if ((nom_fichier_temporaire = creation_nom_fichier(
  110:                 s_etat_processus, (*s_etat_processus)
  111:                 .chemin_fichiers_temporaires)) == NULL)
  112:         {
  113:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  114:             return(d_erreur);
  115:         }
  116: 
  117:         // Avant d'exécuter la commande, on teste les sommes de hashage
  118:         // des utilitaires de la famille RPL/2.
  119: 
  120:         if ((*s_etat_processus).rpl_home == NULL)
  121:         {
  122:             if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
  123:                     (2 * strlen((*s_etat_processus).nom_fichier_source)) +
  124:                     (6 * strlen(d_exec_path)) + strlen(d_locale) +
  125:                     strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
  126:                     * sizeof(unsigned char))) == NULL)
  127:             {
  128:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  129: 
  130:                 free(nom_fichier_temporaire);
  131:                 return(d_erreur);
  132:             }
  133: 
  134:             sprintf(commande, instructions,
  135:                     d_exec_path, ds_preprocesseur,
  136:                     (*s_etat_processus).nom_fichier_source,
  137:                     d_exec_path, d_exec_path,
  138:                     d_exec_path, (*s_etat_processus).nom_fichier_source,
  139:                     d_exec_path, d_exec_path, d_locale, nom_fichier_temporaire);
  140: 
  141:             if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
  142:                     d_exec_path) < 0)
  143:             {
  144:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  145:                 return(d_erreur);
  146:             }
  147: 
  148:             if (controle(s_etat_processus, executable_candidat, "md5",
  149:                     rpliconv_md5) != d_vrai)
  150:             {
  151:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  152:                 return(d_erreur);
  153:             }
  154: 
  155:             if (controle(s_etat_processus, executable_candidat, "sha1",
  156:                     rpliconv_sha1) != d_vrai)
  157:             {
  158:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  159:                 return(d_erreur);
  160:             }
  161: 
  162:             free(executable_candidat);
  163: 
  164:             if (alsprintf(&executable_candidat, "%s/bin/rplfile",
  165:                     d_exec_path) < 0)
  166:             {
  167:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  168:                 return(d_erreur);
  169:             }
  170: 
  171:             if (controle(s_etat_processus, executable_candidat, "md5",
  172:                     rplfile_md5) != d_vrai)
  173:             {
  174:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  175:                 return(d_erreur);
  176:             }
  177: 
  178:             if (controle(s_etat_processus, executable_candidat, "sha1",
  179:                     rplfile_sha1) != d_vrai)
  180:             {
  181:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  182:                 return(d_erreur);
  183:             }
  184: 
  185:             free(executable_candidat);
  186: 
  187:             if (alsprintf(&executable_candidat, "%s/bin/rplpp",
  188:                     d_exec_path) < 0)
  189:             {
  190:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  191:                 return(d_erreur);
  192:             }
  193: 
  194:             if (controle(s_etat_processus, executable_candidat, "md5",
  195:                     rplpp_md5) != d_vrai)
  196:             {
  197:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  198:                 return(d_erreur);
  199:             }
  200: 
  201:             if (controle(s_etat_processus, executable_candidat, "sha1",
  202:                     rplpp_sha1) != d_vrai)
  203:             {
  204:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  205:                 return(d_erreur);
  206:             }
  207: 
  208:             free(executable_candidat);
  209: 
  210:             if (alsprintf(&executable_candidat, "%s/bin/rplawk",
  211:                     d_exec_path) < 0)
  212:             {
  213:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  214:                 return(d_erreur);
  215:             }
  216: 
  217:             if (controle(s_etat_processus, executable_candidat, "md5",
  218:                     rplawk_md5) != d_vrai)
  219:             {
  220:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  221:                 return(d_erreur);
  222:             }
  223: 
  224:             if (controle(s_etat_processus, executable_candidat, "sha1",
  225:                     rplawk_sha1) != d_vrai)
  226:             {
  227:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  228:                 return(d_erreur);
  229:             }
  230: 
  231:             free(executable_candidat);
  232:         }
  233:         else
  234:         {
  235:             if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
  236:                     (2 * strlen((*s_etat_processus).nom_fichier_source)) +
  237:                     (6 * strlen((*s_etat_processus).rpl_home)) +
  238:                     strlen(d_locale) +
  239:                     strlen(nom_fichier_temporaire) + strlen(instructions) - 21)
  240:                     * sizeof(unsigned char))) == NULL)
  241:             {
  242:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  243: 
  244:                 free(nom_fichier_temporaire);
  245:                 return(d_erreur);
  246:             }
  247: 
  248:             sprintf(commande, instructions,
  249:                     (*s_etat_processus).rpl_home, ds_preprocesseur,
  250:                     (*s_etat_processus).nom_fichier_source,
  251:                     (*s_etat_processus).rpl_home,
  252:                     (*s_etat_processus).rpl_home,
  253:                     (*s_etat_processus).rpl_home,
  254:                     (*s_etat_processus).nom_fichier_source,
  255:                     (*s_etat_processus).rpl_home,
  256:                     (*s_etat_processus).rpl_home,
  257:                     d_locale, nom_fichier_temporaire);
  258: 
  259:             if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
  260:                     (*s_etat_processus).rpl_home) < 0)
  261:             {
  262:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  263:                 return(d_erreur);
  264:             }
  265: 
  266:             if (controle(s_etat_processus, executable_candidat, "md5",
  267:                     rpliconv_md5) != d_vrai)
  268:             {
  269:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  270:                 return(d_erreur);
  271:             }
  272: 
  273:             if (controle(s_etat_processus, executable_candidat, "sha1",
  274:                     rpliconv_sha1) != d_vrai)
  275:             {
  276:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  277:                 return(d_erreur);
  278:             }
  279: 
  280:             free(executable_candidat);
  281: 
  282:             if (alsprintf(&executable_candidat, "%s/bin/rplfile",
  283:                     (*s_etat_processus).rpl_home) < 0)
  284:             {
  285:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  286:                 return(d_erreur);
  287:             }
  288: 
  289:             if (controle(s_etat_processus, executable_candidat, "md5",
  290:                     rplfile_md5) != d_vrai)
  291:             {
  292:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  293:                 return(d_erreur);
  294:             }
  295: 
  296:             if (controle(s_etat_processus, executable_candidat, "sha1",
  297:                     rplfile_sha1) != d_vrai)
  298:             {
  299:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  300:                 return(d_erreur);
  301:             }
  302: 
  303:             free(executable_candidat);
  304: 
  305:             if (alsprintf(&executable_candidat, "%s/bin/rplpp",
  306:                     (*s_etat_processus).rpl_home) < 0)
  307:             {
  308:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  309:                 return(d_erreur);
  310:             }
  311: 
  312:             if (controle(s_etat_processus, executable_candidat, "md5",
  313:                     rplpp_md5) != d_vrai)
  314:             {
  315:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  316:                 return(d_erreur);
  317:             }
  318: 
  319:             if (controle(s_etat_processus, executable_candidat, "sha1",
  320:                     rplpp_sha1) != d_vrai)
  321:             {
  322:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  323:                 return(d_erreur);
  324:             }
  325: 
  326:             free(executable_candidat);
  327: 
  328:             if (alsprintf(&executable_candidat, "%s/bin/rplawk",
  329:                     (*s_etat_processus).rpl_home) < 0)
  330:             {
  331:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  332:                 return(d_erreur);
  333:             }
  334: 
  335:             if (controle(s_etat_processus, executable_candidat, "md5",
  336:                     rplawk_md5) != d_vrai)
  337:             {
  338:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  339:                 return(d_erreur);
  340:             }
  341: 
  342:             if (controle(s_etat_processus, executable_candidat, "sha1",
  343:                     rplawk_sha1) != d_vrai)
  344:             {
  345:                 (*s_etat_processus).erreur_systeme = d_es_somme_controle;
  346:                 return(d_erreur);
  347:             }
  348: 
  349:             free(executable_candidat);
  350:         }
  351: 
  352:         if ((f_source = popen(commande, "r")) == NULL)
  353:         {
  354:             (*s_etat_processus).erreur_systeme = d_es_processus;
  355: 
  356:             free(nom_fichier_temporaire);
  357:             return(d_erreur);
  358:         }
  359: 
  360:         if (pclose(f_source) != EXIT_SUCCESS)
  361:         {
  362:             (*s_etat_processus).erreur_systeme = d_es_processus;
  363: 
  364:             free(nom_fichier_temporaire);
  365:             return(d_erreur);
  366:         }
  367: 
  368:         free(commande);
  369: 
  370:         if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
  371:         {
  372:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  373: 
  374:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  375:             {
  376:                 free(nom_fichier_temporaire);
  377:                 return(d_erreur);
  378:             }
  379: 
  380:             free(nom_fichier_temporaire);
  381:             return(d_erreur);
  382:         }
  383: 
  384:         nombre_caracteres_source = 0;
  385: 
  386:         while(getc(f_source) != EOF)
  387:         {
  388:             nombre_caracteres_source++;
  389:         }
  390: 
  391:         (*s_etat_processus).definitions_chainees = (unsigned char *)
  392:                 malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
  393:         
  394:         if ((*s_etat_processus).definitions_chainees == NULL)
  395:         {
  396:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  397: 
  398:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  399:             {
  400:                 free(nom_fichier_temporaire);
  401:                 return(d_erreur);
  402:             }
  403: 
  404:             return(d_erreur);
  405:         }
  406:         else
  407:         {
  408:             rewind(f_source);
  409:             presence_chaine = d_faux;
  410: 
  411:             i = 0;
  412:             drapeau_fin = d_faux;
  413:             initialisation = d_vrai;
  414: 
  415:             /*
  416:              * Élimination du sharp-bang si nécessaire et des caractères
  417:              * inutiles. Conversion de caractères.
  418:              */
  419: 
  420:             while(drapeau_fin == d_faux)
  421:             {
  422:                 if ((caractere = getc(f_source)) != EOF)
  423:                 {
  424:                     if (initialisation == d_vrai)
  425:                     {
  426:                         if (caractere == '#')
  427:                         {
  428:                             if ((caractere = getc(f_source)) != EOF)
  429:                             {
  430:                                 if (caractere == '!')
  431:                                 {
  432:                                     do
  433:                                     {
  434:                                         caractere = getc(f_source);
  435:                                     } while((caractere != EOF) &&
  436:                                             (caractere !=
  437:                                             d_code_retour_chariot));
  438:                                 }
  439:                                 else
  440:                                 {
  441:                                     rewind(f_source);
  442:                                     caractere = getc(f_source);
  443:                                 }
  444:                             }
  445:                         }
  446: 
  447:                         initialisation = d_faux;
  448:                     }
  449: 
  450:                     if ((caractere == d_code_retour_chariot) ||
  451:                             (caractere == d_code_tabulation) ||
  452:                             ((caractere == d_code_espace) &&
  453:                             (presence_chaine == d_faux)))
  454:                     {
  455:                         do
  456:                         {
  457:                             caractere = getc(f_source);
  458:                         } while(((caractere == d_code_retour_chariot) ||
  459:                                 (caractere == d_code_tabulation) ||
  460:                                 ((caractere == d_code_espace) &&
  461:                                 (presence_chaine == d_faux))) &&
  462:                                 (caractere != EOF));
  463: 
  464:                         if (caractere != EOF)
  465:                         {
  466:                             ((*s_etat_processus).definitions_chainees)[i++] =
  467:                                     d_code_espace;
  468:                         }
  469:                         else
  470:                         {
  471:                             drapeau_fin = d_vrai;
  472:                         }
  473:                     }
  474: 
  475:                     if ((((*s_etat_processus).definitions_chainees)[i] =
  476:                             caractere) == '\"')
  477:                     {
  478:                         if (i > 0)
  479:                         {
  480:                             if (((*s_etat_processus).definitions_chainees)
  481:                                     [i - 1] != '\\')
  482:                             {
  483:                                 presence_chaine = (presence_chaine == d_faux)
  484:                                         ? d_vrai : d_faux;
  485:                             }
  486:                         }
  487: 
  488:                         i++;
  489:                     }
  490:                     else
  491:                     {
  492:                         i++;
  493:                     }
  494:                 }
  495:                 else
  496:                 {
  497:                     drapeau_fin = d_vrai;
  498:                 }
  499:             }
  500: 
  501:             if ((caractere == EOF) && (i > 0))
  502:             {
  503:                 i--;
  504:             }
  505: 
  506:             ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
  507: 
  508:             erreur_os = d_absence_erreur;
  509:         }
  510: 
  511:         (*s_etat_processus).longueur_definitions_chainees =
  512:                 strlen((*s_etat_processus).definitions_chainees);
  513: 
  514:         if (fclose(f_source) != 0)
  515:         {
  516:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  517: 
  518:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  519:             {
  520:                 free(nom_fichier_temporaire);
  521:                 return(d_erreur);
  522:             }
  523: 
  524:             free(nom_fichier_temporaire);
  525:             return(d_erreur);
  526:         }
  527: 
  528:         if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  529:         {
  530:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  531: 
  532:             free(nom_fichier_temporaire);
  533:             return(d_erreur);
  534:         }
  535: 
  536:         free(nom_fichier_temporaire);
  537:     }
  538:     else
  539:     {
  540:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  541:         erreur_os = d_erreur;
  542:     }
  543: 
  544:     if (((*s_etat_processus).definitions_chainees =
  545:             realloc((*s_etat_processus).definitions_chainees,
  546:             ((*s_etat_processus).longueur_definitions_chainees + 1) *
  547:             sizeof(unsigned char))) == NULL)
  548:     {
  549:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  550:         return(d_erreur);
  551:     }
  552: 
  553:     return(erreur_os);
  554: }
  555: 
  556: 
  557: /*
  558: ================================================================================
  559:   Routine de compactage d'une chaîne de caractères
  560:   Tous les espaces et les retours à ligne surnuméraires sont enlevés.
  561: ================================================================================
  562:   Entrées: structure processus
  563: --------------------------------------------------------------------------------
  564:   Sortie: drapeau d'erreur
  565: --------------------------------------------------------------------------------
  566:   Effets de bord: néant
  567: ================================================================================
  568: */
  569: 
  570: unsigned char *
  571: compactage(unsigned char *chaine)
  572: {
  573:     logical1        drapeau_fin;
  574:     logical1        presence_chaine;
  575: 
  576:     unsigned char   caractere;
  577:     unsigned char   *ptr_ecriture;
  578:     unsigned char   *ptr_lecture;
  579: 
  580:     if (chaine == NULL)
  581:     {
  582:         return(NULL);
  583:     }
  584: 
  585:     presence_chaine = d_faux;
  586: 
  587:     drapeau_fin = d_faux;
  588:     ptr_lecture = chaine;
  589:     ptr_ecriture = chaine;
  590: 
  591:     while(drapeau_fin == d_faux)
  592:     {
  593:         if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
  594:         {
  595:             if ((caractere == d_code_retour_chariot) ||
  596:                     (caractere == d_code_tabulation) ||
  597:                     ((caractere == d_code_espace) &&
  598:                     (presence_chaine == d_faux)))
  599:             {
  600:                 do
  601:                 {
  602:                     caractere = (*ptr_lecture++);
  603:                 } while(((caractere == d_code_retour_chariot) ||
  604:                         (caractere == d_code_tabulation) ||
  605:                         ((caractere == d_code_espace) &&
  606:                         (presence_chaine == d_faux))) &&
  607:                         (caractere != d_code_fin_chaine));
  608: 
  609:                 if (caractere != d_code_fin_chaine)
  610:                 {
  611:                     (*ptr_ecriture++) = d_code_espace;
  612:                 }
  613:                 else
  614:                 {
  615:                     drapeau_fin = d_vrai;
  616:                 }
  617:             }
  618: 
  619:             if (((*ptr_ecriture++) = caractere) == '\"')
  620:             {
  621:                 presence_chaine = (presence_chaine == d_faux)
  622:                         ? d_vrai : d_faux;
  623:             }
  624:         }
  625:         else
  626:         {
  627:             drapeau_fin = d_vrai;
  628:         }
  629:     }
  630: 
  631:     (*ptr_ecriture) = d_code_fin_chaine;
  632: 
  633:     return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
  634: }
  635: 
  636: // vim: ts=4