/*
================================================================================
  RPL/2 (R) version 4.1.12
  Copyright (C) 1989-2012 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 'dupcntxt'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_dupcntxt(struct_processus *s_etat_processus)
{
	struct_objet			*s_objet;
	struct_objet			*s_pile;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(duplication du contexte)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(context duplication)\n\n");
			printf("  No argument\n");
		}

		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_objet = allocation(s_etat_processus, LST)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*s_objet).objet = (*s_etat_processus).l_base_pile;

	if ((s_pile = copie_objet(s_etat_processus, s_objet, 'N')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

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

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

	(*((integer8 *) (*s_objet).objet)) = (*s_etat_processus)
			.hauteur_pile_operationnelle;

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

	/*
	 * Copie de la pile opérationnelle
	 */

	(*s_etat_processus).l_base_pile = (*s_pile).objet;

	(*s_pile).objet = NULL;
	liberation(s_etat_processus, s_pile);

	return;
}


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

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

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement d'un contexte)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(drops context)\n\n");
			printf("  No argument\n");
		}

		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).l_base_pile_contextes == NULL) ||
			((*s_etat_processus).l_base_pile_taille_contextes == NULL))
	{
		(*s_etat_processus).erreur_execution = d_ex_contexte;
		return;
	}

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

	liberation(s_etat_processus, s_objet);

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_dgtiz(struct_processus *s_etat_processus)
{
	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(mouse support in plot functions)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(support de la souris dans les fonctions graphiques)\n\n");
			printf("  No argument\n");
		}

		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).fichiers_graphiques != NULL)
	{
		(*s_etat_processus).souris_active = d_vrai;
		appel_gnuplot(s_etat_processus, 'N');
		(*s_etat_processus).souris_active = d_faux;
	}

	return;
}


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

void
instruction_daemonize(struct_processus *s_etat_processus)
{
	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(basculement en mode daemon)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(convert to daemon)\n\n");
			printf("  No argument\n");
		}

		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).var_volatile_processus_pere == -1) &&
			((*s_etat_processus).l_base_pile_processus == NULL))
	{
		lancement_daemon(s_etat_processus);
	}
	else
	{
		(*s_etat_processus).erreur_execution = d_ex_daemon;
		return;
	}

	return;
}


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

void
instruction_diag_fleche(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'une matrice diagonale en vecteur)\n\n");
		}
		else
		{
			printf("(diagonal matrix to vector conversion)\n\n");
		}

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

		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'une matrice
	 */

	if ((*s_objet_argument).type == MIN)
	{
		if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_colonnes)
		{
			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

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

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

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

		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_lignes; i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					if (((integer8 **) (*((struct_matrice *) (*s_objet_argument)
							.objet)).tableau)[i][j] != 0)
					{
						liberation(s_etat_processus, s_objet_argument);
						liberation(s_etat_processus, s_objet_resultat);

						(*s_etat_processus).erreur_execution =
								d_ex_matrice_non_diagonale;
						return;
					}
				}
				else
				{
					((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
							.objet)).tableau)[i] = ((integer8 **)
							(*((struct_matrice *) (*s_objet_argument)
							.objet)).tableau)[i][j];
				}
			}
		}
	}
	else if ((*s_objet_argument).type == MRL)
	{
		if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_colonnes)
		{
			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

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

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

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

		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_lignes; i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					if (((real8 **) (*((struct_matrice *) (*s_objet_argument)
							.objet)).tableau)[i][j] != 0)
					{
						liberation(s_etat_processus, s_objet_argument);
						liberation(s_etat_processus, s_objet_resultat);

						(*s_etat_processus).erreur_execution =
								d_ex_matrice_non_diagonale;
						return;
					}
				}
				else
				{
					((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
							.objet)).tableau)[i] = ((real8 **)
							(*((struct_matrice *) (*s_objet_argument)
							.objet)).tableau)[i][j];
				}
			}
		}
	}
	else if ((*s_objet_argument).type == MCX)
	{
		if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_colonnes)
		{
			(*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

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

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

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

		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_lignes; i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
					.nombre_colonnes; j++)
			{
				if (i != j)
				{
					if ((((complex16 **) (*((struct_matrice *)
							(*s_objet_argument).objet)).tableau)[i][j]
							.partie_reelle != 0) ||
							(((complex16 **) (*((struct_matrice *)
							(*s_objet_argument).objet)).tableau)[i][j]
							.partie_imaginaire != 0))
					{
						liberation(s_etat_processus, s_objet_argument);
						liberation(s_etat_processus, s_objet_resultat);

						(*s_etat_processus).erreur_execution =
								d_ex_matrice_non_diagonale;
						return;
					}
				}
				else
				{
					((complex16 *) (*((struct_vecteur *) (*s_objet_resultat)
							.objet)).tableau)[i] = ((complex16 **)
							(*((struct_matrice *) (*s_objet_argument)
							.objet)).tableau)[i][j];
				}
			}
		}
	}

	/*
	 * 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;
}


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

void
instruction_digest(struct_processus *s_etat_processus)
{
	EVP_MD_CTX					contexte;

	const EVP_MD *				(*EVP_sum)();

	logical1					somme_invalide;

	long						longueur_chaine;

	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat;

	unsigned char				*chaine;
	unsigned char				*fonction;
	unsigned char				somme[EVP_MAX_MD_SIZE];

	unsigned int				longueur_somme;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme d'authentification)\n\n");
		}
		else
		{
			printf("(hash algorithm)\n\n");
		}

		printf("    2: %s\n", d_CHN);
		printf("    1: %s\n", d_CHN);
		printf("->  1: %s\n\n", d_CHN);

		printf("    2: %s\n", d_CHN);
		printf("    1: %s\n", d_LST);
		printf("->  1: %s\n\n", d_CHN);

		if ((*s_etat_processus).langue == 'F')
		{
			printf("  Algorithmes :\n\n");
		}
		else
		{
			printf("  Algorithms:\n\n");
		}

#		ifndef OPENSSL_NO_SHA
		printf("    - DSS\n");
		printf("    - DSS1\n");
		printf("    - ECDSA\n");
#		endif
#		ifndef OPENSSL_NO_MD2
		printf("    - MD2\n");
#		endif
#		ifndef OPENSSL_NO_MD4
		printf("    - MD4\n");
#		endif
#		ifndef OPENSSL_NO_MD5
		printf("    - MD5\n");
#		endif
#		ifndef OPENSSL_NO_SHA
		printf("    - SHA\n");
		printf("    - SHA1\n");
#		endif

		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, 2) == d_erreur)
		{
			return;
		}
	}

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	if (((*s_objet_argument_1).type == CHN) &&
			((*s_objet_argument_2).type == CHN))
	{
		// Liste des sommes disponibles :
		// - EVP_dss
		// - EVP_dss1
		// - EVP_ecdsa
		// - EVP_md2
		// - EVP_md4
		// - EVP_md5
		// - EVP_mdc2
		// - EVP_ripemd160
		// - EVP_sha
		// - EVP_sha1
		// - EVP_sha224
		// - EVP_sha256
		// - EVP_sha384
		// - EVP_sha512
		// - EVP_whirlpool

		if ((fonction = conversion_majuscule((unsigned char *)
				(*s_objet_argument_1).objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		somme_invalide = d_faux;

		switch(fonction[0])
		{
			case 'D':
			{
				switch(fonction[1])
				{
					case 'S': // ds
					{
						switch(fonction[2])
						{
#							ifndef OPENSSL_NO_SHA
							case 'S': // dss
							{
								switch(fonction[3])
								{
									case d_code_fin_chaine:
									{
										EVP_sum = EVP_dss;
										break;
									}

									case '1': // dss1
									{
										if (fonction[4] == d_code_fin_chaine)
										{
											EVP_sum = EVP_dss1;
										}
										else
										{
											somme_invalide = d_vrai;
										}

										break;
									}

									default:
									{
										somme_invalide = d_vrai;
										break;
									}
								}

								break;
							}
#							endif

							default:
							{
								somme_invalide = d_vrai;
								break;
							}
						}

						break;
					}

					default:
					{
						somme_invalide = d_vrai;
						break;
					}
				}

				break;
			}

			case 'E':
			{
				switch(fonction[1])
				{
					case 'C': // ec
					{
						switch(fonction[2])
						{
							case 'D': // ecd
							{
								switch(fonction[3])
								{
									case 'S': // ecds
									{
										switch(fonction[4])
										{
#											ifndef OPENSSL_NO_SHA
											case 'A': // ecdsa
											{
												if (fonction[5] ==
														d_code_fin_chaine)
												{
													EVP_sum = EVP_ecdsa;
												}
												else
												{
													somme_invalide = d_vrai;
												}

												break;
											}
#											endif

											default:
											{
												somme_invalide = d_vrai;
												break;
											}
										}

										break;
									}

									default:
									{
										somme_invalide = d_vrai;
										break;
									}
								}

								break;
							}

							default:
							{
								somme_invalide = d_vrai;
								break;
							}
						}

						break;
					}

					default:
					{
						somme_invalide = d_vrai;
						break;
					}
				}

				break;
			}

			case 'M':
			{
				switch(fonction[1])
				{
					case 'D': // md
					{
						switch(fonction[2])
						{
#							ifndef OPENSSL_NO_MD2
							case '2': // md2
							{
								if (fonction[3] == d_code_fin_chaine)
								{
									EVP_sum = EVP_md2;
								}
								else
								{
									somme_invalide = d_vrai;
								}

								break;
							}
#							endif

#							ifndef OPENSSL_NO_MD4
							case '4': // md4
							{
								if (fonction[3] == d_code_fin_chaine)
								{
									EVP_sum = EVP_md4;
								}
								else
								{
									somme_invalide = d_vrai;
								}

								break;
							}
#							endif

#							ifndef OPENSSL_NO_MD4
							case '5': // md5
							{
								if (fonction[3] == d_code_fin_chaine)
								{
									EVP_sum = EVP_md5;
								}
								else
								{
									somme_invalide = d_vrai;
								}

								break;
							}
#							endif

							case 'C': // mdc
							{
								switch(fonction[3])
								{
#									ifndef OPENSSL_NO_MDC2
									case '2': // mdc2
									{
										if (fonction[4] == d_code_fin_chaine)
										{
											EVP_sum = EVP_mdc2;
										}
										else
										{
											somme_invalide = d_vrai;
										}

										break;
									}
#									endif

									default:
									{
										somme_invalide = d_vrai;
										break;
									}
								}

								break;
							}

							default:
							{
								somme_invalide = d_vrai;
								break;
							}
						}

						break;
					}

					default:
					{
						somme_invalide = d_vrai;
						break;
					}
				}

				break;
			}

#			ifndef OPENSSL_NO_RIPEMD
			case 'R':
			{
				if (strcmp(fonction, "RIPEMD160") == 0)
				{
					EVP_sum = EVP_ripemd160;
				}
				else
				{
					somme_invalide = d_vrai;
				}

				break;
			}
#			endif

			case 'S':
			{
				switch(fonction[1])
				{
					case 'H': // sh
					{
						switch(fonction[2])
						{
#							ifndef OPENSSL_NO_SHA
							case 'A':
							{
								switch(fonction[3])
								{
									case d_code_fin_chaine:
									{
										EVP_sum = EVP_sha;
										break;
									}

									case '1': // sha1
									{
										if (fonction[4] == d_code_fin_chaine)
										{
											EVP_sum = EVP_sha1;
										}
										else
										{
											somme_invalide = d_vrai;
										}

										break;
									}

#									ifndef OPENSSL_NO_SHA256
									case '2': // sha2
									{
										switch(fonction[4])
										{
											case '2': // sha22
											{
												switch(fonction[5])
												{
													case '4': // sha224
													{
														if (fonction[6] ==
															d_code_fin_chaine)
														{
															EVP_sum =
																	EVP_sha224;
														}
														else
														{
															somme_invalide =
																	d_vrai;
														}

														break;
													}

													default:
													{
														somme_invalide = d_vrai;
														break;
													}
												}

												break;
											}

											case '5':
											{
												switch(fonction[5])
												{
													case '6': // sha256
													{
														if (fonction[6] ==
															d_code_fin_chaine)
														{
															EVP_sum =
																	EVP_sha256;
														}
														else
														{
															somme_invalide =
																	d_vrai;
														}

														break;
													}

													default:
													{
														somme_invalide = d_vrai;
														break;
													}
												}

												break;
											}

											default:
											{
												somme_invalide = d_vrai;
												break;
											}
										}

										break;
									}
#									endif

#									ifndef OPENSSL_NO_SHA512
									case '3': // sha3
									{
										switch(fonction[4])
										{
											case '8': // sha38
											{
												switch(fonction[5])
												{
													case '4': // sha384
													{
														if (fonction[6] ==
															d_code_fin_chaine)
														{
															EVP_sum =
																	EVP_sha384;
														}
														else
														{
															somme_invalide =
																	d_vrai;
														}

														break;
													}

													default:
													{
														somme_invalide = d_vrai;
														break;
													}
												}

												break;
											}

											default:
											{
												somme_invalide = d_vrai;
												break;
											}
										}

										break;
									}

									case '5': // sha5
									{
										switch(fonction[4])
										{
											case '1': // sha51
											{
												switch(fonction[5])
												{
													case '2': // sha512
													{
														if (fonction[6] ==
															d_code_fin_chaine)
														{
															EVP_sum =
																	EVP_sha512;
														}
														else
														{
															somme_invalide =
																	d_vrai;
														}

														break;
													}

													default:
													{
														somme_invalide = d_vrai;
														break;
													}
												}

												break;
											}

											default:
											{
												somme_invalide = d_vrai;
												break;
											}
										}

										break;
									}
#									endif

									default:
									{
										somme_invalide = d_vrai;
										break;
									}
								}

								break;
							}
#							endif

							default:
							{
								somme_invalide = d_vrai;
								break;
							}
						}

						break;
					}

					default:
					{
						somme_invalide = d_vrai;
						break;
					}
				}

				break;
			}

#			ifndef OPENSSL_NO_WHIRLPOOL
			case 'W':
			{
				if (strcmp(fonction, "WHIRLPOOL") == 0)
				{
					EVP_sum = EVP_whirlpool;
				}
				else
				{
					somme_invalide = d_vrai;
				}

				break;
			}
#			endif

			default:
			{
				somme_invalide = d_vrai;
				break;
			}
		}

		free(fonction);

		if (somme_invalide == d_vrai)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
		{
			EVP_MD_CTX_cleanup(&contexte);

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
				(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
		{
			EVP_MD_CTX_cleanup(&contexte);

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			return;
		}

		if (EVP_DigestUpdate(&contexte, chaine, longueur_chaine) != 1)
		{
			free(chaine);
			EVP_MD_CTX_cleanup(&contexte);

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
		{
			free(chaine);
			EVP_MD_CTX_cleanup(&contexte);

			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		free(chaine);
		EVP_MD_CTX_cleanup(&contexte);

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

		if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
				somme, longueur_somme)) == NULL)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

			return;
		}
	}
	else if (((*s_objet_argument_1).type == CHN) &&
			((*s_objet_argument_2).type == LST))
	{
		BUG(1, uprintf("Oops\n"));
		s_objet_resultat = NULL;
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

	return;
}

// vim: ts=4