Return to gestion_pile_last.c CVS log

Up to [local] / rpl / src

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:   Procédure d'empilement des arguments d'une commande dans la pile LAST
   29: ================================================================================
   30:   Entrée : structure processus et nombre d'aguments à empiler
   31: --------------------------------------------------------------------------------
   32:   Sortie : drapeau d'erreur
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : efface le précédent contenu de la pile LAST
   35: ================================================================================
   36: */
   37: 
   38: logical1
   39: empilement_pile_last(struct_processus *s_etat_processus,
   40:         integer8 nombre_arguments)
   41: {
   42:     struct_liste_chainee            *l_element_courant;
   43:     struct_liste_chainee            *l_element_suivant;
   44: 
   45:     struct_objet                    *s_objet;
   46: 
   47:     logical1                        erreur;
   48: 
   49:     integer8                        i;
   50: 
   51:     erreur = d_absence_erreur;
   52:     l_element_courant = (*s_etat_processus).l_base_pile_last;
   53: 
   54:     while(l_element_courant != NULL)
   55:     {
   56:         liberation(s_etat_processus, (*l_element_courant).donnee);
   57:         l_element_suivant = (*l_element_courant).suivant;
   58: 
   59:         // On ne libère pas le maillon de la chaîne. On le sauvegarde
   60:         // arbitrairement dans le tampon.
   61: 
   62:         (*l_element_courant).donnee = NULL;
   63:         (*l_element_courant).suivant = (*s_etat_processus).pile_tampon;
   64:         (*s_etat_processus).pile_tampon = l_element_courant;
   65:         (*s_etat_processus).taille_pile_tampon++;
   66: 
   67:         l_element_courant = l_element_suivant;
   68:     }
   69: 
   70:     (*s_etat_processus).l_base_pile_last = NULL;
   71:     l_element_courant = (*s_etat_processus).l_base_pile;
   72: 
   73:     for(i = 0; ((i < nombre_arguments) && (erreur == d_absence_erreur)
   74:             && (l_element_courant != NULL)); i++)
   75:     {
   76:         s_objet = copie_objet(s_etat_processus,
   77:                 (*l_element_courant).donnee, 'P');
   78: 
   79:         if (s_objet != NULL)
   80:         {
   81:             erreur = empilement(s_etat_processus,
   82:                     &((*s_etat_processus).l_base_pile_last), s_objet);
   83:             l_element_courant = (*l_element_courant).suivant;
   84:         }
   85:         else
   86:         {
   87:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   88:             break;
   89:         }
   90:     }
   91: 
   92:     if (i != nombre_arguments)
   93:     {
   94:         /*
   95:          * Ne renvoie pas d'erreur si le nombre d'argument ne correspond pas
   96:          * à celui attendu pour pouvoir traiter correctement les fuites
   97:          * mémoire dans le traitement de la fonction IFERR. Le traitement
   98:          * du nombre d'arguments est fait au niveau de la fonction appelant
   99:          * "empilement_pile_last".
  100:          */
  101: 
  102:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  103: 
  104:         /*
  105:          * En cas de nombre d'arguments insuffisant, cette routine
  106:          * déclenche une erreur. Si la pile LAST est active, la récupération
  107:          * de l'erreur force la copie de la pile LAST dans la pile
  108:          * opérationnelle courante. Dans notre cas, les arguments n'ont pas
  109:          * encore été consommés pas la routine appelante et il convient
  110:          * d'éliminer les arguments de la pile opérationnelle avant de retourner
  111:          * à la routine appelante.
  112:          */
  113: 
  114:         l_element_courant = (*s_etat_processus).l_base_pile;
  115: 
  116:         for(; i > 0; i--)
  117:         {
  118:             if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  119:                     &s_objet) == d_erreur)
  120:             {
  121:                 (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  122:                 return(erreur);
  123:             }
  124: 
  125:             liberation(s_etat_processus, s_objet);
  126:         }
  127:     }
  128: 
  129:     return(erreur);
  130: }
  131: 
  132: // vim: ts=4