/*
================================================================================
  RPL/2 (R) version 4.1.26
  Copyright (C) 1989-2016 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.
================================================================================
*/


#define MESSAGES
#include "rpl-conv.h"


/*
================================================================================
  Affichage des messages d'erreur
================================================================================
  Entrées : structure sur l'état du processus
--------------------------------------------------------------------------------
  Sorties : néant
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

unsigned char *
messages(struct_processus *s_etat_processus)
{
	logical1				erreur_fonction_externe;

	unsigned char			*message;
	unsigned char			*chaine;
	unsigned char			*argument;

	chaine = NULL;
	argument = NULL;

	erreur_fonction_externe = d_faux;

	(*s_etat_processus).derniere_exception = d_ep;
	(*s_etat_processus).derniere_erreur_execution = d_ex;
	(*s_etat_processus).derniere_erreur_systeme = d_es;

	if ((*s_etat_processus).erreur_execution != d_ex)
	{
		(*s_etat_processus).derniere_erreur_execution =
				(*s_etat_processus).erreur_execution;

/*
--------------------------------------------------------------------------------
  Erreurs dues aux définitions
--------------------------------------------------------------------------------
*/

		switch((*s_etat_processus).erreur_execution)
		{
			case d_ex_pile_vide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Pile opérationnelle vide";
				}
				else
				{
					chaine = "+++Error : Empty stack";
				}

				break;
			}

			case d_ex_manque_argument :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine ="+++Erreur : Arguments insuffisants pour la "
							"commande '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Too few arguments for '%s' "
							"command";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_argument_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Argument invalide pour la "
							"commande '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Invalid argument for "
							"'%s' command";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_nom_reserve :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "Erreur : Nom '%s' réservé";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "Error : '%s' reserved name";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_erreur_type_argument :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Type d'argument invalide pour la "
							"commande '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Invalid argument type for "
							"'%s' command";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_nombre_arguments :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Une même fonction apparaît avec "
							"des nombres d'arguments différents (%s)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : The same function seems to have "
							"different numbers of arguments (%s)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_dimensions_invalides :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Dimensions invalides pour "
							"l'instruction '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Erreur : Invalid dimensions for "
							"'%s' instruction";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_expression_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Expression '%s' invalide";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Invalid '%s' expression";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_erreur_traitement_condition :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Traitement impossible d'une clause "
							"conditionnelle";
				}
				else
				{
					chaine = "+++Error : Illegal conditional structure";
				}

				break;
			}

			case d_ex_erreur_traitement_boucle :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Traitement impossible "
							"d'une boucle";
				}
				else
				{
					chaine = "+++Error : Illegal loop structure";
				}

				break;
			}

			case d_ex_variable_non_definie :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable non définie";
				}
				else
				{
					chaine = "+++Error : Undefined variable";
				}

				break;
			}

			case d_ex_drapeau_inexistant :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Drapeau inexistant";
				}
				else
				{
					chaine = "+++Error : Non-existent flag";
				}

				break;
			}

			case d_ex_nom_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Nom de variable invalide (%s)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Invalid variable name (%s)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_element_inexistant :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Indice invalide";
				}
				else
				{
					chaine = "+++Error : Invalid index";
				}

				break;
			}

			case d_ex_absence_variable :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Absence de variable";
				}
				else
				{
					chaine = "+++Error : Variable omission";
				}

				break;
			}

			case d_ex_erreur_evaluation :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur dans l'évaluation d'une "
							"expression";
				}
				else
				{
					chaine = "+++Error : Error in expression evaluation";
				}

				break;
			}

			case d_ex_longueur_fft :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Longueur de FFT invalide";
				}
				else
				{
					chaine = "+++Error : Invalid FFT length";
				}

				break;
			}

			case d_ex_longueur_dft :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Longueur de DFT invalide";
				}
				else
				{
					chaine = "+++Error : Invalid DFT length";
				}

				break;
			}

			case d_ex_queue_impression :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Queue d'impression vide";
				}
				else
				{
					chaine = "+++Error : Empty printing spool queue";
				}

				break;
			}

			case d_ex_type_trace_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Type de tracé invalide";
				}
				else
				{
					chaine = "+++Error : Invalid graph type";
				}

				break;
			}

			case d_ex_erreur_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur d'entrée/sortie sur un"
							" fichier ou une socket";
				}
				else
				{
					chaine = "+++Error : file or socket input/output error";
				}

				break;
			}

			case d_ex_absence_equation :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Absence d'équation";
				}
				else
				{
					chaine = "+++Error : Equation omission";
				}

				break;
			}

			case d_ex_erreur_bibliotheque :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur portant sur une "
							"bibliothèque dynamique";
				}
				else
				{
					chaine = "+++Error : Dynamic library error";
				}

				break;
			}

			case d_ex_execution_bibliotheque :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Problème lors de l'exécution d'une "
							"fonction externe";
				}
				else
				{
					chaine = "+++Error : External function execution "
							"error";
				}

				break;
			}

			case d_ex_matrice_statistique_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Matrice statistique invalide";
				}
				else
				{
					chaine = "+++Error : Invalid statistical matrix";
				}

				break;
			}

			case d_ex_dimensions_matrice_statistique :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Dimensions différentes des "
							"observations et de la matrice statistique";
				}
				else
				{
					chaine = "+++Error : Invalid dimensions between "
							"observations and statistical matrix";
				}

				break;
			}

			case d_ex_absence_observations :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Absence de matrice statistique";
				}
				else
				{
					chaine = "+++Error : Statistical matrix omission";
				}

				break;
			}

			case d_ex_statistiques_echantillon :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Echantillon trop restreint pour un "
							"calcul de statistique";
				}
				else
				{
					chaine = "+++Error : Too few statistical observations";
				}

				break;
			}

			case d_ex_observations_inexistantes :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Colonne d'observations "
							"inexistante";
				}
				else
				{
					chaine = "+++Error : Non-existent observations column";
				}

				break;
			}

			case d_ex_syntaxe :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur de syntaxe";
				}
				else
				{
					chaine = "+++Error : Syntax error";
				}

				break;
			}

			case d_ex_cycle_hors_boucle :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Instruction 'CYCLE' hors d'une"
							" boucle définie";
				}
				else
				{
					chaine = "+++Error : 'CYCLE' instruction out of any "
							"defined loop";
				}

				break;
			}

			case d_ex_conversion_unite :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Conversion d'unité impossible";
				}
				else
				{
					chaine = "+++Error : Unit translation impossible";
				}

				break;
			}

			case d_ex_erreur_parametre_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Paramètre de fichier ou de socket "
							"invalide";
				}
				else
				{
					chaine = "+++Error : Invalid file or socket parameter";
				}

				break;
			}

			case d_ex_erreur_acces_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur d'accès à un fichier ou à une"
							" socket";
				}
				else
				{
					chaine = "+++Error : File or socket access error";
				}

				break;
			}

			case d_ex_erreur_requete_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur de requête envers un "
							"fichier";
				}
				else
				{
					chaine = "+++Error : File request error";
				}

				break;
			}

			case d_ex_erreur_format_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur de format";
				}
				else
				{
					chaine = "+++Error : Format error";
				}

				break;
			}

			case d_ex_fichier_verrouille :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fichier verrouillé";
				}
				else
				{
					chaine = "+++Error : Locked file";
				}

				break;
			}

			case d_ex_verrou_indefini :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Verrou indéfini";
				}
				else
				{
					chaine = "+++Error : Undefined lock";
				}

				break;
			}

			case d_ex_fin_de_fichier_atteinte :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fin de fichier atteinte";
				}
				else
				{
					chaine = "+++Error : End of file reached";
				}

				break;
			}

			case d_ex_debut_de_fichier_atteint :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Début de fichier atteint";
				}
				else
				{
					chaine = "+++Error : Beginning of file reached";
				}

				break;
			}

			case d_ex_erreur_type_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Type de fichier invalide";
				}
				else
				{
					chaine = "+++Error : Invalid file type";
				}

				break;
			}

			case d_ex_fichier_vide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fichier vide";
				}
				else
				{
					chaine = "+++Error : Empty file";
				}

				break;
			}

			case d_ex_dimensions_differentes :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Dimensions différentes pour "
							"deux graphiques à superposer";
				}
				else
				{
					chaine = "+++Error : Invalid graphical dimension";
				}

				break;
			}

			case d_ex_routines_mathematiques :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur interne dans la routine"
							" mathématique '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}
				else
				{
					chaine = "+++Error : Internal error in mathematical"
						 " subroutine '%s'";
					argument = (*s_etat_processus).instruction_derniere_erreur;
				}

				break;
			}

			case d_ex_exit_hors_boucle :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Instruction 'EXIT' hors d'une"
							" boucle";
				}
				else
				{
					chaine = "+++Error : 'EXIT' instruction out of any "
							"loop";
				}

				break;
			}

			case d_ex_processus :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Processus inexistant";
				}
				else
				{
					chaine = "+++Error : Non-existent process";
				}

				break;
			}

			case d_ex_image_processus :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Création impossible de l'image"
							" du processus courant";
				}
				else
				{
					chaine = "+++Error : Cannot create dump of current process";
				}

				break;
			}

			case d_ex_erreur_sql :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Requête SQL invalide";
				}
				else
				{
					chaine = "+++Error : Invalid SQL query";
				}

				break;
			}

			case d_ex_variable_verrouillee :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable verrouillée";
				}
				else
				{
					chaine = "+++Error : Locked variable";
				}

				break;
			}

			case d_ex_variable_volatile :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable volatile";
				}
				else
				{
					chaine = "+++Error : Volatile variable";
				}

				break;
			}

			case d_ex_erreur_processus :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Commande inconnue";
				}
				else
				{
					chaine = "+++Error : Unknown command";
				}

				break;
			}

			case d_ex_erreur_impression :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fichier d'impression erroné";
				}
				else
				{
					chaine = "+++Error : Erroneous print file";
				}

				break;
			}

			case d_ex_nombre_arguments_fonction :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Nombre d'arguments invalide";
				}
				else
				{
					chaine = "+++Error : Invalid number of arguments";
				}

				break;
			}

			case d_ex_fonction_indisponible :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fonction indisponible";
				}
				else
				{
					chaine = "+++Error : Unavailable function";
				}

				break;
			}

			case d_ex_bibliotheque_chargee :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Bibliothèque ouverte";
				}
				else
				{
					chaine = "+++Error : Opened library";
				}

				break;
			}

			case d_ex_aucun_symbole :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Aucun symbole déclaré";
				}
				else
				{
					chaine = "+++Error : Too few symbols";
				}

				break;
			}

			case d_ex_definition_ambigue :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Définition externe ambiguë";
				}
				else
				{
					chaine = "+++Error : Ambiguous external definition";
				}

				break;
			}

			case d_ex_fichier_hors_contexte :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Descripteur hors contexte";
				}
				else
				{
					chaine = "+++Error : Context mismatch";
				}

				break;
			}

			case d_ex_socket_en_ecoute :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Connexion refusée sur une socket"
							" en attente";
				}
				else
				{
					chaine = "+++Error : Connexion refused on a"
							" waiting socket";
				}

				break;
			}

			case d_ex_interruption_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Interruption invalide";
				}
				else
				{
					chaine = "+++Error : Unavailable interrupt";
				}

				break;
			}

			case d_ex_erreur_transcodage :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur de transcodage";
				}
				else
				{
					chaine = "+++Error : Transcodage error";
				}

				break;
			}

			case d_ex_contexte :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Aucun contexte sauvegardé";
				}
				else
				{
					chaine = "+++Error : No stacked context";
				}

				break;
			}

			case d_ex_absence_processus_pere :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Absence de processus père";
				}
				else
				{
					chaine = "+++Error : No parent process";
				}

				break;
			}

			case d_ex_creation_variable :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Création de variable impossible";
				}
				else
				{
					chaine = "+++Error : Variable initialization failed";
				}

				break;
			}

			case d_ex_fusible :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fusible préexistant";
				}
				else
				{
					chaine = "+++Error : Fuse error";
				}

				break;
			}

			case d_ex_iswi_hors_interruption :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Aucune interruption en cours";
				}
				else
				{
					chaine = "+++Error : No current interrupt";
				}

				break;
			}

			case d_ex_daemon :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Conversion en daemon impossible";
				}
				else
				{
					chaine = "+++Error : Unable to convert to daemon";
				}

				break;
			}

			case d_ex_mutex :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Mutex non initialisé";
				}
				else
				{
					chaine = "+++Error : Uninitialized mutex";
				}

				break;
			}

			case d_ex_semaphore :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur d'accès à un sémaphore";
				}
				else
				{
					chaine = "+++Error : Semaphore access error";
				}

				break;
			}

			case d_ex_variable_statique_partagee :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable statique partagée";
				}
				else
				{
					chaine = "+++Error : Static shared variable";
				}

				break;
			}

			case d_ex_variable_partagee :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable partagée";
				}
				else
				{
					chaine = "+++Error : Shared variable";
				}

				break;
			}

			case d_ex_graphique_memorise :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Données mémorisées non affichées";
				}
				else
				{
					chaine = "+++Error : Non plotted buffered data";
				}

				break;
			}

			case d_ex_absence_graphique_courant :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Aucun graphique en cours";
				}
				else
				{
					chaine = "+++Error : No current graphic";
				}

				break;
			}

			case d_ex_stop :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Masque du signal STOP";
				}
				else
				{
					chaine = "+++Error : STOP signal mask";
				}

				break;
			}

			case d_ex_matrice_non_diagonale :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Matrice non diagonale";
				}
				else
				{
					chaine = "+++Error : Non diagonal matrix";
				}

				break;
			}

			case d_ex_locales :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Variable de localisation "
							"indisponible";
				}
				else
				{
					chaine = "+++Error : Unavailable locale";
				}

				break;
			}

			case d_ex_representation :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur de représentation";
				}
				else
				{
					chaine = "+++Error : Mapping error";
				}

				break;
			}

			case d_ex_erreur_profilage :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Pile de profilage vide";
				}
				else
				{
					chaine = "+++Error : Empty profiles stack";
				}

				break;
			}

			case d_ex_enregistrement_inexistant :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Enregistrement inexistant";
				}
				else
				{
					chaine = "+++Error : Record not found";
				}

				break;
			}

			case d_ex_clef_inexistante :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Clef inexistante";
				}
				else
				{
					chaine = "+++Error : Key not found";
				}

				break;
			}

			case d_ex_nom_implicite :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Nom implicite indéfini";
				}
				else
				{
					chaine = "+++Error : Undefined implicit name";
				}

				break;
			}

			case d_ex_version_bibliotheque :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Version de bibliothèque incompatible";
				}
				else
				{
					chaine = "+++Error : Library version mismatch";
				}

				break;
			}

			case d_ex_creation_variable_globale :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Création de variable globale "
							"impossible";
				}
				else
				{
					chaine = "+++Error : Cannot create global variable";
				}

				break;
			}

			case d_ex_erreur_interne_rplcas :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur interne RPL/CAS";
				}
				else
				{
					chaine = "+++Error : Internal RPL/CAS error";
				}

				break;
			}

			case d_ex_fichier_corrompu :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fichier corrompu";
				}
				else
				{
					chaine = "+++Error : Corrupted file";
				}

				break;
			}

			case d_ex_mutex_acquis_autre_thread :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Mutex acquis par un autre thread";
				}
				else
				{
					chaine = "+++Error : Mutex owned by another thread";
				}

				break;
			}

			case d_ex_expression_reguliere :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Expression régulière";
				}
				else
				{
					chaine = "+++Error : Regular expression";
				}

				break;
			}

			case d_ex_instruction_indisponible :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Instruction intrinsèque non "
							"disponible";
				}
				else
				{
					chaine = "+++Error : Unavailable intrinsic instruction";
				}

				break;
			}

			case d_ex_chiffrement :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur dans les routines "
							"de chiffrement";
				}
				else
				{
					chaine = "+++Error : Cipher error";
				}

				break;
			}

			case d_ex_chiffrement_indisponible :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Algorithme de chiffrement "
							"indisponible";
				}
				else
				{
					chaine = "+++Error : Unavailable cipher algorithm";
				}

				break;
			}

			case d_ex_longueur_clef_chiffrement :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Longueur invalide de la clef "
							"de chiffrement";
				}
				else
				{
					chaine = "+++Error : Invalide key length";
				}

			case d_ex_taille_message :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Message trop long";
				}
				else
				{
					chaine = "+++Error : Message size";
				}

				break;
			}

				break;
			}

			case -1 : // Fonction externe
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Fonction dynamique '%s' (ligne %lld)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
					erreur_fonction_externe = d_vrai;
				}
				else
				{
					chaine = "+++Error : '%s' dynamic function (line %lld)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
					erreur_fonction_externe = d_vrai;
				}

				break;
			}

			default :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Erreur : Erreur d'exécution";
				}
				else
				{
					chaine = "+++Error : Execution error";
				}

				break;
			}
		}
	}
	else if ((*s_etat_processus).erreur_systeme != d_es)
	{
		(*s_etat_processus).derniere_erreur_systeme =
				(*s_etat_processus).erreur_systeme;

/*
--------------------------------------------------------------------------------
  Erreurs dues au système et au séquenceur
--------------------------------------------------------------------------------
*/

		switch((*s_etat_processus).erreur_systeme)
		{
			case d_es_allocation_memoire :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur d'allocation mémoire";
				}
				else
				{
					chaine = "+++System : Memory allocation error";
				}

				break;
			}

			case d_es_variable_introuvable :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Variable non définie";
				}
				else
				{
					chaine = "+++System : Undefined variable";
				}

				break;
			}

			case d_es_pile_vide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Pile système vide";
				}
				else
				{
					chaine = "+++System : Empty system stack";
				}

				break;
			}

			case d_es_pile_operationnelle_vide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Pile vide";
				}
				else
				{
					chaine = "+++System : Empty stack";
				}

				break;
			}

			case d_es_end_incoherent :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Instruction END incohérente";
				}
				else
				{
					chaine = "+++Systeme : Incoherent END instruction";
				}

				break;
			}

			case d_es_peripherique_stdin :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur de lecture sur stdin";
				}
				else
				{
					chaine = "+++System : Read error on stdin";
				}

				break;
			}

			case d_es_erreur_fichier :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur d'entrée/sortie sur un"
							" fichier";
				}
				else
				{
					chaine = "+++System : File input/output error";
				}

				break;
			}

			case d_es_execution_bibliotheque :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Problème lors de l'exécution "
							"d'une fonction externe";
				}
				else
				{
					chaine = "+++System : Extern function execution error";
				}

				break;
			}

			case d_es_signal :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Problème de gestion de signaux "
							"POSIX";
				}
				else
				{
					chaine = "+++System : POSIX signal error";
				}

				break;
			}

		case d_es_processus :
		{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur dans la gestion des"
							" processus";
				}
				else
				{
					chaine = "+++System : Process management error";
				}

				break;
			}

			case d_es_nombre_max_descripteurs :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Nombre maximal de descripteurs"
							" de fichiers atteint";
				}
				else
				{
					chaine = "+++System : Too much file descriptors";
				}

				break;
			}

			case d_es_interruption_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Interruption invalide";
				}
				else
				{
					chaine = "+++System : Unavailable interrupt";
				}

				break;
			}

			case d_es_contexte :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur dans la gestion des"
							" contextes";
				}
				else
				{
					chaine = "+++System : Context management error";
				}

				break;
			}

			case d_es_somme_controle :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Somme de contrôle invalide";
				}
				else
				{
					chaine = "+++System : Invalid hash sum";
				}

				break;
			}

			case d_es_semaphore :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur d'accès à un sémaphore";
				}
				else
				{
					chaine = "+++System : Semaphore access error";
				}

				break;
			}

			case d_es_mutex_acquis_autre_thread :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Mutex acquis par un autre thread";
				}
				else
				{
					chaine = "+++System : Mutex owned by another thread";
				}

				break;
			}

			case -1 : // Fonction externe
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Fonction dynamique '%s' "
							"(ligne %lld)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
					erreur_fonction_externe = d_vrai;
				}
				else
				{
					chaine = "+++System : '%s' dynamic function (line %lld)";
					argument = (*s_etat_processus).instruction_derniere_erreur;
					erreur_fonction_externe = d_vrai;
				}

				break;
			}

			default :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Système : Erreur interne";
				}
				else
				{
					chaine = "+++System : Internal error";
				}

				break;
			}
		}
	}
	else if ((*s_etat_processus).exception != d_ep)
	{
		(*s_etat_processus).derniere_exception =
				(*s_etat_processus).exception;

/*
--------------------------------------------------------------------------------
  Exceptions mathématiques
--------------------------------------------------------------------------------
*/

		switch((*s_etat_processus).exception)
		{
			case d_ep_division_par_zero :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Division par zéro";
				}
				else
				{
					chaine = "+++Exception : Division by zero";
				}

				break;
			}

			case d_ep_matrice_non_inversible :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Matrice non inversible";
				}
				else
				{
					chaine = "+++Exception : Non inversible matrix";
				}

				break;
			}

			case d_ep_resultat_indefini :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Résultat indéfini";
				}
				else
				{
					chaine = "+++Exception : Undefined result";
				}

				break;
			}

			case d_ep_underflow :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Dépassement de capacité"
							" (underflow)";
				}
				else
				{
					chaine = "+++Exception : Underflow exception";
				}

				break;
			}

			case d_ep_overflow :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Dépassement de capacité"
							" (overflow)";
				}
				else
				{
					chaine = "+++Exception : Overflow exception";
				}

				break;
			}

			case d_ep_domaine_definition :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Domaine de définition";
				}
				else
				{
					chaine = "+++Exception : Domain exception";
				}

				break;
			}

			case d_ep_perte_precision :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Perte de précision";
				}
				else
				{
					chaine = "+++Exception : Loss of precision";
				}

				break;
			}

			case d_ep_decomposition_QR :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Décomposition QR impossible";
				}
				else
				{
					chaine = "+++Exception : QR decomposition failed";
				}

				break;
			}

			case d_ep_matrice_non_definie_positive :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Matrice non définie positive";
				}
				else
				{
					chaine = "+++Exception : Non positive defined matrix";
				}

				break;
			}

			case d_ep_decomposition_QZ :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Décomposition QZ impossible";
				}
				else
				{
					chaine = "+++Exception : QZ decomposition failed";
				}

				break;
			}

			case d_ep_decomposition_SVD :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Décomposition SVD impossible";
				}
				else
				{
					chaine = "+++Exception : SVD decomposition failed";
				}

				break;
			}

			default :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Exception : Exception mathématique";
				}
				else
				{
					chaine = "+++Exception : Mathematical exception";
				}

				break;
			}
		}
	}
	else if ((*s_etat_processus).erreur_compilation != d_ec)
	{

/*
--------------------------------------------------------------------------------
  Erreurs de compilation
--------------------------------------------------------------------------------
*/

		switch((*s_etat_processus).erreur_compilation)
		{
			case d_ec_niveau_definition_negatif :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Niveau de définition négatif";
				}
				else
				{
					chaine = "+++Fatal : Negative definition level";
				}

				break;
			}

			case d_ec_nom_definition_invalide :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Nom de définition invalide";
				}
				else
				{
					chaine = "+++Fatal : Invalid definition name";
				}

				break;
			}

			case d_ec_erreur_boucle_definie :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Définition illégale "
							"d'une boucle définie";
				}
				else
				{
					chaine = "+++Fatal : Illegal use of a defined loop";
				}

				break;
			}

			case d_ec_erreur_instruction_end :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure terminée "
							"par l'instruction END";
				}
				else
				{
					chaine = "+++Fatal : Error in an END-closed structure";
				}

				break;
			}

			case d_ec_erreur_instruction_until :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une boucle DO/UNTIL/END";
				}
				else
				{
					chaine = "+++Fatal : Error in a DO/UNTIL/END loop";
				}

				break;
			}

			case d_ec_source_incoherent :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Définitions incohérentes";
				}
				else
				{
					chaine = "+++Fatal : Incoherent definitions";
				}

				break;
			}

			case d_ec_erreur_instruction_while :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une boucle WHILE/REPEAT/"
							"END";
				}
				else
				{
					chaine = "+++Fatal : Error in a WHILE/REPEAT/END loop";
				}

				break;
			}

			case d_ec_erreur_instruction_select :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure SELECT"
							"/DEFAULT/END";
				}
				else
				{
					chaine = "+++Fatal : Error in a SELECT/DEFAULT/END "
							"structure";
				}

				break;
			}

			case d_ec_erreur_instruction_case :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure CASE"
							"/THEN/END";
				}
				else
				{
					chaine = "+++Fatal : Error in a CASE/THEN/END "
							"structure";
				}

				break;
			}

			case d_ec_erreur_instruction_then :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure IF, "
							"IFERR ou CASE/THEN/END";
				}
				else
				{
					chaine = "+++Fatal : Error in a IF, IFERR or "
							"CASE/THEN/END structure";
				}

				break;
			}

			case d_ec_erreur_instruction_else :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure ELSE";
				}
				else
				{
					chaine = "+++Fatal : Error in a ELSE structure";
				}

				break;
			}

			case d_ec_erreur_instruction_elseif :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur dans une structure ELSEIF";
				}
				else
				{
					chaine = "+++Fatal : Error in a ELSEIF structure";
				}

				break;
			}

			default :
			{
				if ((*s_etat_processus).langue == 'F')
				{
					chaine = "+++Fatal : Erreur de compilation";
				}
				else
				{
					chaine = "+++Fatal : compilation error";
				}

				break;
			}
		}
	}
	else
	{
		if ((*s_etat_processus).langue == 'F')
		{
			chaine = "";
		}
		else
		{
			chaine = "";
		}
	}

	if (argument == NULL)
	{
		if ((message = malloc((strlen(chaine) + 1) * sizeof(unsigned char)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return NULL;
		}

		strcpy(message, chaine);
	}
	else
	{
		if (erreur_fonction_externe == d_faux)
		{
			if ((message = malloc((strlen(chaine) + strlen(argument) - 1) *
					sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return NULL;
			}

			sprintf(message, chaine, argument);
		}
		else
		{
			if ((message = malloc((strlen(chaine) + strlen(argument) + 64
					- 1) * sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return NULL;
			}

			sprintf(message, chaine, argument,
					(*s_etat_processus).derniere_erreur_fonction_externe);
		}
	}

	return(message);
}

// vim: ts=4