/*
================================================================================
  RPL/2 (R) version 4.0.19
  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"


/*
================================================================================
  Boucle principale optimisé de l'interprète RPL/2
================================================================================
  Entrées : structure sur l'état du processus
--------------------------------------------------------------------------------
  Sorties : Néant
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

logical1
sequenceur_optimise(struct_processus *s_etat_processus)
{
	logical1				erreur;

	long					i;
	long					point_entree;

	unsigned char			*message;

	unsigned long			adresse_point_entree;

	if ((*s_etat_processus).debug == d_vrai)
		if (((*s_etat_processus).type_debug &
				d_debug_analyse) != 0)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("[%d] Optimisation\n", (int) getpid());
		}
		else
		{
			printf("+++Optimization [%d]\n", (int) getpid());
		}

		printf("\n");
		fflush(stdout);
	}

	point_entree = -1;
	adresse_point_entree = 0;

	empilement_pile_systeme(s_etat_processus);
	(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
	(*s_etat_processus).autorisation_empilement_programme = 'Y';
	(*s_etat_processus).mode_execution_programme = 'N';

	for(i = 0; i < (long) (*s_etat_processus).nombre_variables; i++)
	{
		if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
		{
			// Variables qui contiennent les points d'entrée des définitions.

			(*s_etat_processus).position_courante = (*((unsigned long *)
					(*((*s_etat_processus).s_liste_variables[i].objet)).objet));

			if (point_entree == -1)
			{
				adresse_point_entree = (*s_etat_processus).position_courante;
				point_entree = i;
			}
			else
			{
				if ((*s_etat_processus).position_courante <
						adresse_point_entree)
				{
					adresse_point_entree = (*s_etat_processus)
							.position_courante;
					point_entree = i;
				}
			}

			if ((erreur = recherche_instruction_suivante(s_etat_processus))
					== d_erreur)
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Optimisation impossible\n");
				}
				else
				{
					printf("+++Fatal : Optimization failed\n");
				}

				return(d_erreur);
			}

			recherche_type(s_etat_processus);

			if (((*s_etat_processus).erreur_execution != d_ex) ||
					((*s_etat_processus).erreur_systeme != d_es))
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Optimisation impossible\n");
				}
				else
				{
					printf("+++Fatal : Optimization failed\n");
				}

				return(d_erreur);
			}

			liberation(s_etat_processus,
					(*s_etat_processus).s_liste_variables[i].objet);

			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					&((*s_etat_processus).s_liste_variables[i].objet))
					== d_erreur)
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Optimisation impossible\n");
				}
				else
				{
					printf("+++Fatal : Optimization failed\n");
				}

				return(d_erreur);
			}

			(*s_etat_processus).s_liste_variables[i].origine = 'E';
			free((*s_etat_processus).instruction_courante);
		}
	}

	if (point_entree == -1)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Fatal : Optimisation impossible\n");
		}
		else
		{
			printf("+++Fatal : Optimization failed\n");
		}

		return(d_erreur);
	}

	if ((*s_etat_processus).debug == d_vrai)
	{
		if (((*s_etat_processus).type_debug &
				d_debug_analyse) != 0)
		{
			printf("\n");

			if ((*s_etat_processus).langue == 'F')
			{
				printf("[%d] Optimisation achevée\n", (int) getpid());
			}
			else
			{
				printf("[%d] Optimization done\n", (int) getpid());
			}

			printf("\n");
			fflush(stdout);
		}
	}

	(*s_etat_processus).retour_routine_evaluation = 'Y';

	free((*s_etat_processus).definitions_chainees);

	if (((*s_etat_processus).definitions_chainees =
			malloc(sizeof(unsigned char))) == NULL)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Fatal : Optimisation impossible\n");
		}
		else
		{
			printf("+++Fatal : Optimization failed\n");
		}

		return(d_erreur);
	}

	(*s_etat_processus).definitions_chainees[0] = d_code_fin_chaine;
	(*s_etat_processus).longueur_definitions_chainees = 0;
	(*s_etat_processus).evaluation_expression_compilee = 'Y';

	if ((*s_etat_processus).profilage == d_vrai)
	{
		profilage(s_etat_processus, (*s_etat_processus).s_liste_variables
				[point_entree].nom);
	}

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Système : Mémoire insuffisante\n");
		}
		else
		{
			printf("+++System : Not enough memory\n");
		}

		return(d_erreur);
	}

	erreur = evaluation(s_etat_processus, (*s_etat_processus).s_liste_variables
			[point_entree].objet, 'E');

	if ((*s_etat_processus).profilage == d_vrai)
	{
		profilage(s_etat_processus, NULL);
	}

	(*s_etat_processus).mode_execution_programme = 'N';

	if (((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep) ||
			((*s_etat_processus).erreur_systeme != d_es))
	{
		printf("%s [%d]\n", message = messages(s_etat_processus),
				(int) getpid());

		if (test_cfsf(s_etat_processus, 51) == d_faux)
		{
			printf("%s", ds_beep);
		}

		free(message);
	}

	return(erreur);
}

// vim: ts=4