Return to chainage.c CVS log

Up to [local] / rpl / src

Changement de version pour la 4.0.10.
Correction d'un dysfonctionnement dans le retour des erreurs des fonctions
RPL/C lorsque le programme est compilé (routine evaluation()).

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.0.10
    4:   Copyright (C) 1989-2010 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 chainage du programme (lecture du fichier puis constitution
   29:   de la chaine executable)
   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                ouverture;
   53:     logical1                presence_chaine;
   54: 
   55:     long                    i;
   56:     long                    nombre_caracteres_source;
   57: 
   58:     unsigned char           *commande;
   59:     unsigned char           *instructions = "sed -e '1,1s/^#!/\\/\\//g' %s | "
   60:                                     "%s/bin/%s | "
   61:                                     "%s/bin/rpliconv `%s/bin/rplfile "
   62:                                     "-m %s/share/rplfiles -i %s | awk "
   63:                                     "'{ print $3; }' | awk -F= "
   64:                                     "'{ if ($2 != \"\") printf(\"-f %%s\", "
   65:                                     "$2); }'` -t `locale charmap`//IGNORE > %s";
   66: 
   67:     unsigned long           unite_fichier;
   68: 
   69:     if ((*s_etat_processus).debug == d_vrai)
   70:         if (((*s_etat_processus).type_debug & d_debug_analyse) != 0)
   71:     {
   72:         printf("\n");
   73: 
   74:         if ((*s_etat_processus).langue == 'F')
   75:         {
   76:             printf("[%d] Appel au préprocesseur\n", (int) getpid());
   77:         }
   78:         else
   79:         {
   80:             printf("[%d] Preprocessing\n", (int) getpid());
   81:         }
   82: 
   83:         fflush(stdout);
   84:     }
   85: 
   86:     erreur = caracteristiques_fichier(s_etat_processus,
   87:             (*s_etat_processus).nom_fichier_source, &existence,
   88:             &ouverture, &unite_fichier);
   89: 
   90:     erreur_os = d_absence_erreur;
   91: 
   92:     if ((existence == d_vrai) && (erreur == 0))
   93:     {
   94:         if ((nom_fichier_temporaire = creation_nom_fichier(
   95:                 s_etat_processus, (*s_etat_processus)
   96:                 .chemin_fichiers_temporaires)) == NULL)
   97:         {
   98:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
   99:             return(d_erreur);
  100:         }
  101: 
  102:         if ((commande = (unsigned char *) malloc((strlen(ds_preprocesseur) +
  103:                 (2 * strlen((*s_etat_processus).nom_fichier_source)) +
  104:                 (4 * strlen(d_exec_path)) +
  105:                 strlen(nom_fichier_temporaire) + strlen(instructions) - 11) *
  106:                 sizeof(unsigned char))) == NULL)
  107:         {
  108:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  109: 
  110:             free(nom_fichier_temporaire);
  111:             return(d_erreur);
  112:         }
  113: 
  114:         sprintf(commande, instructions, (*s_etat_processus).nom_fichier_source,
  115:                 d_exec_path, ds_preprocesseur, d_exec_path, d_exec_path,
  116:                 d_exec_path, (*s_etat_processus).nom_fichier_source,
  117:                 nom_fichier_temporaire);
  118: 
  119:         if ((f_source = popen(commande, "r")) == NULL)
  120:         {
  121:             (*s_etat_processus).erreur_systeme = d_es_processus;
  122: 
  123:             free(nom_fichier_temporaire);
  124:             return(d_erreur);
  125:         }
  126: 
  127:         if (pclose(f_source) != EXIT_SUCCESS)
  128:         {
  129:             (*s_etat_processus).erreur_systeme = d_es_processus;
  130: 
  131:             free(nom_fichier_temporaire);
  132:             return(d_erreur);
  133:         }
  134: 
  135:         free(commande);
  136: 
  137:         if ((f_source = fopen(nom_fichier_temporaire, "r")) == NULL)
  138:         {
  139:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  140: 
  141:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  142:             {
  143:                 free(nom_fichier_temporaire);
  144:                 return(d_erreur);
  145:             }
  146: 
  147:             free(nom_fichier_temporaire);
  148:             return(d_erreur);
  149:         }
  150: 
  151:         nombre_caracteres_source = 0;
  152: 
  153:         while(getc(f_source) != EOF)
  154:         {
  155:             nombre_caracteres_source++;
  156:         }
  157: 
  158:         (*s_etat_processus).definitions_chainees = (unsigned char *)
  159:                 malloc((nombre_caracteres_source + 1) * sizeof(unsigned char));
  160:         
  161:         if ((*s_etat_processus).definitions_chainees == NULL)
  162:         {
  163:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  164: 
  165:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  166:             {
  167:                 free(nom_fichier_temporaire);
  168:                 return(d_erreur);
  169:             }
  170: 
  171:             return(d_erreur);
  172:         }
  173:         else
  174:         {
  175:             rewind(f_source);
  176:             presence_chaine = d_faux;
  177: 
  178:             i = 0;
  179:             drapeau_fin = d_faux;
  180: 
  181:             while(drapeau_fin == d_faux)
  182:             {
  183:                 if ((caractere = getc(f_source)) != EOF)
  184:                 {
  185:                     if ((caractere == d_code_retour_chariot) ||
  186:                             (caractere == d_code_tabulation) ||
  187:                             ((caractere == d_code_espace) &&
  188:                             (presence_chaine == d_faux)))
  189:                     {
  190:                         do
  191:                         {
  192:                             caractere = getc(f_source);
  193:                         } while(((caractere == d_code_retour_chariot) ||
  194:                                 (caractere == d_code_tabulation) ||
  195:                                 ((caractere == d_code_espace) &&
  196:                                 (presence_chaine == d_faux))) &&
  197:                                 (caractere != EOF));
  198: 
  199:                         if (caractere != EOF)
  200:                         {
  201:                             ((*s_etat_processus).definitions_chainees)[i++] =
  202:                                     d_code_espace;
  203:                         }
  204:                         else
  205:                         {
  206:                             drapeau_fin = d_vrai;
  207:                         }
  208:                     }
  209: 
  210:                     if ((((*s_etat_processus).definitions_chainees)[i] =
  211:                             caractere) == '\"')
  212:                     {
  213:                         if (i > 0)
  214:                         {
  215:                             if (((*s_etat_processus).definitions_chainees)
  216:                                     [i - 1] != '\\')
  217:                             {
  218:                                 presence_chaine = (presence_chaine == d_faux)
  219:                                         ? d_vrai : d_faux;
  220:                             }
  221:                         }
  222: 
  223:                         i++;
  224:                     }
  225:                     else
  226:                     {
  227:                         i++;
  228:                     }
  229:                 }
  230:                 else
  231:                 {
  232:                     drapeau_fin = d_vrai;
  233:                 }
  234:             }
  235: 
  236:             if ((caractere == EOF) && (i > 0))
  237:             {
  238:                 i--;
  239:             }
  240: 
  241:             ((*s_etat_processus).definitions_chainees)[i] = d_code_fin_chaine;
  242: 
  243:             erreur_os = d_absence_erreur;
  244:         }
  245: 
  246:         (*s_etat_processus).longueur_definitions_chainees =
  247:                 strlen((*s_etat_processus).definitions_chainees);
  248: 
  249:         if (fclose(f_source) != 0)
  250:         {
  251:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  252: 
  253:             if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  254:             {
  255:                 free(nom_fichier_temporaire);
  256:                 return(d_erreur);
  257:             }
  258: 
  259:             free(nom_fichier_temporaire);
  260:             return(d_erreur);
  261:         }
  262: 
  263:         if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
  264:         {
  265:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  266: 
  267:             free(nom_fichier_temporaire);
  268:             return(d_erreur);
  269:         }
  270: 
  271:         free(nom_fichier_temporaire);
  272:     }
  273:     else
  274:     {
  275:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  276:         erreur_os = d_erreur;
  277:     }
  278: 
  279:     if (((*s_etat_processus).definitions_chainees =
  280:             realloc((*s_etat_processus).definitions_chainees,
  281:             ((*s_etat_processus).longueur_definitions_chainees + 1) *
  282:             sizeof(unsigned char))) == NULL)
  283:     {
  284:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  285:         return(d_erreur);
  286:     }
  287: 
  288:     return(erreur_os);
  289: }
  290: 
  291: 
  292: /*
  293: ================================================================================
  294:   Routine de compactage d'une chaîne de caractères
  295:   Tous les espaces et les retours à ligne surnuméraires sont enlevés.
  296: ================================================================================
  297:   Entrées: structure processus
  298: --------------------------------------------------------------------------------
  299:   Sortie: drapeau d'erreur
  300: --------------------------------------------------------------------------------
  301:   Effets de bord: néant
  302: ================================================================================
  303: */
  304: 
  305: unsigned char *
  306: compactage(unsigned char *chaine)
  307: {
  308:     logical1        drapeau_fin;
  309:     logical1        presence_chaine;
  310: 
  311:     unsigned char   caractere;
  312:     unsigned char   *ptr_ecriture;
  313:     unsigned char   *ptr_lecture;
  314: 
  315:     if (chaine == NULL)
  316:     {
  317:         return(NULL);
  318:     }
  319: 
  320:     presence_chaine = d_faux;
  321: 
  322:     drapeau_fin = d_faux;
  323:     ptr_lecture = chaine;
  324:     ptr_ecriture = chaine;
  325: 
  326:     while(drapeau_fin == d_faux)
  327:     {
  328:         if ((caractere = (*ptr_lecture++)) != d_code_fin_chaine)
  329:         {
  330:             if ((caractere == d_code_retour_chariot) ||
  331:                     (caractere == d_code_tabulation) ||
  332:                     ((caractere == d_code_espace) &&
  333:                     (presence_chaine == d_faux)))
  334:             {
  335:                 do
  336:                 {
  337:                     caractere = (*ptr_lecture++);
  338:                 } while(((caractere == d_code_retour_chariot) ||
  339:                         (caractere == d_code_tabulation) ||
  340:                         ((caractere == d_code_espace) &&
  341:                         (presence_chaine == d_faux))) &&
  342:                         (caractere != d_code_fin_chaine));
  343: 
  344:                 if (caractere != d_code_fin_chaine)
  345:                 {
  346:                     (*ptr_ecriture++) = d_code_espace;
  347:                 }
  348:                 else
  349:                 {
  350:                     drapeau_fin = d_vrai;
  351:                 }
  352:             }
  353: 
  354:             if (((*ptr_ecriture++) = caractere) == '\"')
  355:             {
  356:                 presence_chaine = (presence_chaine == d_faux)
  357:                         ? d_vrai : d_faux;
  358:             }
  359:         }
  360:         else
  361:         {
  362:             drapeau_fin = d_vrai;
  363:         }
  364:     }
  365: 
  366:     (*ptr_ecriture) = d_code_fin_chaine;
  367: 
  368:     return(realloc(chaine, (strlen(chaine) + 1) * sizeof(unsigned char)));
  369: }
  370: 
  371: // vim: ts=4