/*
================================================================================
  RPL/2 (R) version 4.0.20
  Copyright (C) 1989-2010 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Procédure d'empilement des arguments d'une commande dans la pile LAST
================================================================================
  Entrée : structure processus et nombre d'aguments à empiler
--------------------------------------------------------------------------------
  Sortie : drapeau d'erreur
--------------------------------------------------------------------------------
  Effets de bord : efface le précédent contenu de la pile LAST
================================================================================
*/

logical1
empilement_pile_last(struct_processus *s_etat_processus,
		unsigned long nombre_arguments)
{
	struct_liste_chainee			*l_element_courant;
	struct_liste_chainee			*l_element_suivant;

	struct_objet					*s_objet;

	logical1						erreur;

	unsigned long					i;

	erreur = d_absence_erreur;

	l_element_courant = (*s_etat_processus).l_base_pile_last;
	while(l_element_courant != NULL)
	{
		liberation(s_etat_processus, (*l_element_courant).donnee);
		l_element_suivant = (*l_element_courant).suivant;

		// On ne libère pas le maillon de la chaîne. On le sauvegarde
		// arbitrairement dans le tampon.

		(*l_element_courant).donnee = NULL;
		(*l_element_courant).suivant = (*s_etat_processus).pile_tampon;
		(*s_etat_processus).pile_tampon = l_element_courant;
		(*s_etat_processus).taille_pile_tampon++;

		l_element_courant = l_element_suivant;
	}

	(*s_etat_processus).l_base_pile_last = NULL;
	l_element_courant = (*s_etat_processus).l_base_pile;

	for(i = 0; ((i < nombre_arguments) && (erreur == d_absence_erreur)
			&& (l_element_courant != NULL)); i++)
	{
		s_objet = copie_objet(s_etat_processus,
				(*l_element_courant).donnee, 'P');

		if (s_objet != NULL)
		{
			erreur = empilement(s_etat_processus,
					&((*s_etat_processus).l_base_pile_last), s_objet);
			l_element_courant = (*l_element_courant).suivant;
		}
		else
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			break;
		}
	}

	if (i != nombre_arguments)
	{
		/*
		 * Ne renvoie pas d'erreur si le nombre d'argument ne correspond pas
		 * à celui attendu pour pouvoir traiter correctement les fuites
		 * mémoire dans le traitement de la fonction IFERR. Le traitement
		 * du nombre d'arguments est fait au niveau de la fonction appelant
		 * "empilement_pile_last".
		 */

		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
	}

	return(erreur);
}

// vim: ts=4