/*
================================================================================
  RPL/2 (R) version 4.1.32
  Copyright (C) 1989-2020 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ée 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, struct_liste_chainee
		*l_bibliotheques)
{
	integer8					adresse_point_entree;
	integer8					i;
	integer8					j;
	integer8					nb_variables;
	integer8					point_entree;

	logical1					erreur;

	struct_objet				*programme_principal;

	struct_tableau_variables	*tableau;

	unsigned char				*message;
	unsigned char				registre;

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

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

	point_entree = -1;
	adresse_point_entree = 0;
	programme_principal = NULL;

	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';

	nb_variables = nombre_variables(s_etat_processus);

	if ((tableau = malloc(((size_t) nb_variables) *
			sizeof(struct_tableau_variables))) == NULL)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Système : Mémoire insuffisante\n");
		}
		else
		{
			printf("+++System : Not enough memory\n");
		}

		liberation_mutexes_arbre_variables_partagees(s_etat_processus,
				(*(*s_etat_processus).s_arbre_variables_partagees));
		return(d_erreur);
	}

	nb_variables = liste_variables(s_etat_processus, tableau);

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

			(*s_etat_processus).position_courante = (*((integer8 *)
					(*(tableau[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 : Compilation impossible\n");
				}
				else
				{
					printf("+++Fatal : Compilation failed\n");
				}

				for(j = 0; j < nb_variables; j++)
				{
					if (tableau[j].mutex != NULL)
					{
						pthread_mutex_unlock(tableau[j].mutex);
					}
				}

				free(tableau);
				return(d_erreur);
			}

			// Il faut désactiver la vérification des variables
			// implicites car aucune variable de niveau strictement
			// positif étant créée, la fonction recherche_type() pourrait
			// échouer.

			registre = (*s_etat_processus).autorisation_nom_implicite;
			(*s_etat_processus).autorisation_nom_implicite = 'Y';
			(*s_etat_processus).type_en_cours = NON;
			recherche_type(s_etat_processus);
			(*s_etat_processus).autorisation_nom_implicite = registre;

			if (((*s_etat_processus).erreur_execution != d_ex) ||
					((*s_etat_processus).erreur_systeme != d_es))
			{
				if ((*s_etat_processus).core == d_vrai)
				{
					if ((*s_etat_processus).langue == 'F')
					{
						printf("+++Information : "
								"Génération du fichier rpl-core "
								"[%d]\n", (int) getpid());
					}
					else
					{
						printf("+++Information : "
								"Writing rpl-core file [%d]\n",
								(int) getpid());
					}

					rplcore(s_etat_processus);

					if ((*s_etat_processus).langue == 'F')
					{
						printf("+++Information : "
								"Processus tracé [%d]\n",
								(int) getpid());
					}
					else
					{
						printf("+++Information : Done [%d]\n",
								(int) getpid());
					}

					fflush(stdout);
				}

				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Compilation impossible\n");
				}
				else
				{
					printf("+++Fatal : Compilation failed\n");
				}

				for(j = 0; j < nb_variables; j++)
				{
					if (tableau[j].mutex != NULL)
					{
						pthread_mutex_unlock(tableau[j].mutex);
					}
				}

				free(tableau);
				return(d_erreur);
			}

			// Modification de la variable. Il n'existe à cet instant
			// que des variables de niveau 0.

			if (recherche_variable(s_etat_processus, tableau[i].nom) ==
					d_faux)
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Compilation impossible\n");
				}
				else
				{
					printf("+++Fatal : Compilation failed\n");
				}

				for(j = 0; j < nb_variables; j++)
				{
					if (tableau[j].mutex != NULL)
					{
						pthread_mutex_unlock(tableau[j].mutex);
					}
				}

				free(tableau);
				return(d_erreur);
			}

			liberation(s_etat_processus, tableau[i].objet);

			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					&((*(*s_etat_processus).pointeur_variable_courante).objet))
					== d_erreur)
			{
				if ((*s_etat_processus).langue == 'F')
				{
					printf("+++Fatal : Compilation impossible\n");
				}
				else
				{
					printf("+++Fatal : Compilation failed\n");
				}

				for(j = 0; j < nb_variables; j++)
				{
					if (tableau[j].mutex != NULL)
					{
						pthread_mutex_unlock(tableau[j].mutex);
					}
				}

				free(tableau);
				return(d_erreur);
			}

			(*(*s_etat_processus).pointeur_variable_courante).origine = 'E';
			free((*s_etat_processus).instruction_courante);

			if (point_entree == i)
			{
				programme_principal = (*(*s_etat_processus)
						.pointeur_variable_courante).objet;
			}
		}
	}

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

		for(j = 0; j < nb_variables; j++)
		{
			if (tableau[j].mutex != NULL)
			{
				pthread_mutex_unlock(tableau[j].mutex);
			}
		}

		free(tableau);
		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] Compilation achevée\n", (int) getpid());
			}
			else
			{
				printf("[%d] Compilation 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 : Compilation impossible\n");
		}
		else
		{
			printf("+++Fatal : Compilation failed\n");
		}

		for(j = 0; j < nb_variables; j++)
		{
			if (tableau[j].mutex != NULL)
			{
				pthread_mutex_unlock(tableau[j].mutex);
			}
		}

		free(tableau);
		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, tableau[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");
		}

		for(j = 0; j < nb_variables; j++)
		{
			if (tableau[j].mutex != NULL)
			{
				pthread_mutex_unlock(tableau[j].mutex);
			}
		}

		free(tableau);
		return(d_erreur);
	}

	for(j = 0; j < nb_variables; j++)
	{
		if (tableau[j].mutex != NULL)
		{
			pthread_mutex_unlock(tableau[j].mutex);
		}
	}

	free(tableau);

	erreur = evaluation(s_etat_processus, programme_principal, '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