/*
================================================================================
  RPL/2 (R) version 4.1.0.prerelease.1
  Copyright (C) 1989-2011 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"


/*
================================================================================
  Fonction '->table'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_fleche_table(struct_processus *s_etat_processus)
{
	struct_objet					*s_objet;

	signed long						i;
	signed long						nombre_elements;

    (*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  ->TABLE ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(création d'une table)\n\n");
		}
		else
		{
			printf("(create table)\n\n");
		}

		printf("    n: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
		printf("    ...\n");
		printf("    2: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB);
		printf("    1: %s\n", d_INT);
		printf("->  1: %s\n", d_TAB);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}
	}

	if ((*s_etat_processus).hauteur_pile_operationnelle == 0)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*(*(*s_etat_processus).l_base_pile).donnee).type != INT)
	{
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return;
	}

	nombre_elements = (*((integer8 *) (*(*(*s_etat_processus).l_base_pile)
			.donnee).objet));

	if (nombre_elements < 0)
	{

/*
-- Opération absurde autorisée sur le calculateur HP-28S -----------------------
*/

		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return;
	}

	if ((unsigned long) nombre_elements >=
			(*s_etat_processus).hauteur_pile_operationnelle)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, nombre_elements + 1)
				== d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet) == d_erreur)
	{
		return;
	}

	liberation(s_etat_processus, s_objet);

	if ((s_objet = allocation(s_etat_processus, TBL)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((struct_tableau *) (*s_objet).objet)).nombre_elements =
			nombre_elements;

	if (((*((struct_tableau *) (*s_objet).objet)).elements = malloc(
			nombre_elements * sizeof(struct_objet *))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	for(i = 0; i < nombre_elements; i++)
	{
		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				&((*((struct_tableau *) (*s_objet).objet)).elements
				[nombre_elements - (i + 1)])) == d_erreur)
		{
			return;
		}
	}

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet) == d_erreur)
	{
		return;
	}

    return;
}


/*
================================================================================
  Fonction '->diag'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_fleche_diag(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_resultat;

	unsigned long				i;
	unsigned long				j;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  ->DIAG ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(conversion d'un vecteur en matrice diaginale)\n\n");
		}
		else
		{
			printf("(vector to diagonal matrix conversion)\n\n");
		}

		printf("->  1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	/*
	 * Conversion d'un vecteur
	 */

	if ((*s_objet_argument).type == VIN)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes * sizeof(integer8 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes; i++)
		{
			if ((((integer8 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(integer8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = 0;
				}
				else
				{
					((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = ((integer8 *)
							(*((struct_vecteur *) (*s_objet_argument)
							.objet)).tableau)[i];	   
				}
			}
		}
	}
	else if ((*s_objet_argument).type == VRL)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes * sizeof(real8 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes; i++)
		{
			if ((((real8 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(real8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					((real8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = 0;
				}
				else
				{
					((real8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = ((real8 *)
							(*((struct_vecteur *) (*s_objet_argument)
							.objet)).tableau)[i];	   
				}
			}
		}
	}
	else if ((*s_objet_argument).type == VCX)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_vecteur *) (*s_objet_argument).objet)).taille;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes * sizeof(complex16 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet))
				.nombre_lignes; i++)
		{
			if ((((complex16 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(complex16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j].partie_reelle = 0;
					((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j].partie_imaginaire = 0;
				}
				else
				{
					((complex16 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = ((complex16 *)
							(*((struct_vecteur *) (*s_objet_argument)
							.objet)).tableau)[i];	   
				}
			}
		}
	}

	/*
	 * Conversion impossible impossible
	 */

	else
	{
		liberation(s_etat_processus, s_objet_argument);

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	liberation(s_etat_processus, s_objet_argument);

	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat) == d_erreur)
	{
		return;
	}

	return;
}

// vim: ts=4