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


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

void
instruction_autoscale(struct_processus *s_etat_processus)
{
	logical1						presence[3];

	struct_liste_chainee			*l_element_courant;

	struct_objet					*s_objet;

	unsigned char					*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(échelles automatiques)\n\n");
		}
		else
		{
			printf("(automatic scales)\n\n");
		}

		printf("    1: %s\n\n", d_NOM);

		printf("    1: %s\n\n", d_LST);

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

		printf("    { X Y } AUTOSCALE\n");
		printf("    { } AUTOSCALE\n");
		printf("    'Z' AUTOSCALE\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, 1) == d_erreur)
		{
			return;
		}
	}

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

	if ((*s_etat_processus).systeme_axes == 0)
	{
		(*s_etat_processus).echelle_automatique_x = d_faux;
		(*s_etat_processus).echelle_automatique_y = d_faux;
		(*s_etat_processus).echelle_automatique_z = d_faux;
	}
	else
	{
		(*s_etat_processus).echelle_automatique_x2 = d_faux;
		(*s_etat_processus).echelle_automatique_y2 = d_faux;
		(*s_etat_processus).echelle_automatique_z2 = d_faux;
	}

	if ((*s_objet).type == NOM)
	{
		tampon = conversion_majuscule((*((struct_nom *) (*s_objet).objet)).nom);

		if (tampon == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) &&
				(strcmp(tampon, "Z")!= 0))
		{
			liberation(s_etat_processus, s_objet);
			free(tampon);

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

		if (tampon[0] == 'X')
		{
			if ((*s_etat_processus).systeme_axes == 0)
			{
				(*s_etat_processus).echelle_automatique_x = d_vrai;
			}
			else
			{
				(*s_etat_processus).echelle_automatique_x2 = d_vrai;
			}
		}
		else if (tampon[0] == 'Y')
		{
			if ((*s_etat_processus).systeme_axes == 0)
			{
				(*s_etat_processus).echelle_automatique_y = d_vrai;
			}
			else
			{
				(*s_etat_processus).echelle_automatique_y2 = d_vrai;
			}
		}
		else
		{
			if ((*s_etat_processus).systeme_axes == 0)
			{
				(*s_etat_processus).echelle_automatique_z = d_vrai;
			}
			else
			{
				(*s_etat_processus).echelle_automatique_z2 = d_vrai;
			}
		}

		free(tampon);
	}
	else if ((*s_objet).type == LST)
	{
		presence[0] = d_faux;
		presence[1] = d_faux;
		presence[2] = d_faux;

		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type != NOM)
			{
				liberation(s_etat_processus, s_objet);

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

			tampon = conversion_majuscule((*((struct_nom *)
					(*(*l_element_courant).donnee).objet)).nom);

			if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y")!= 0) &&
					(strcmp(tampon, "Z")!= 0))
			{
				liberation(s_etat_processus, s_objet);
				free(tampon);

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

			if (tampon[0] == 'X')
			{
				if (presence[0] == d_vrai)
				{
					free(tampon);
					liberation(s_etat_processus, s_objet);

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

				if ((*s_etat_processus).systeme_axes == 0)
				{
					(*s_etat_processus).echelle_automatique_x = d_vrai;
				}
				else
				{
					(*s_etat_processus).echelle_automatique_x2 = d_vrai;
				}

				presence[0] = d_vrai;
			}
			else if (tampon[0] == 'Y')
			{
				if (presence[1] == d_vrai)
				{
					free(tampon);
					liberation(s_etat_processus, s_objet);

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

				if ((*s_etat_processus).systeme_axes == 0)
				{
					(*s_etat_processus).echelle_automatique_y = d_vrai;
				}
				else
				{
					(*s_etat_processus).echelle_automatique_y2 = d_vrai;
				}

				presence[1] = d_vrai;
			}
			else
			{
				if (presence[2] == d_vrai)
				{
					free(tampon);
					liberation(s_etat_processus, s_objet);

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

				if ((*s_etat_processus).systeme_axes == 0)
				{
					(*s_etat_processus).echelle_automatique_z = d_vrai;
				}
				else
				{
					(*s_etat_processus).echelle_automatique_z2 = d_vrai;
				}

				presence[2] = d_vrai;
			}

			l_element_courant = (*l_element_courant).suivant;
			free(tampon);
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

	liberation(s_etat_processus, s_objet);

	if (test_cfsf(s_etat_processus, 52) == d_faux)
	{
		if ((*s_etat_processus).fichiers_graphiques != NULL)
		{
			appel_gnuplot(s_etat_processus, 'N');
		}
	}

	return;
}


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

void
instruction_asl(struct_processus *s_etat_processus)
{
	logical8							masque;
	logical8							retenue;
	logical8							tampon;

	struct_objet						*s_copie;
	struct_objet						*s_objet;

	unsigned long						i;
	unsigned long						j;
	unsigned long						longueur;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(décalage arithmétique à gauche)\n\n");
		}
		else
		{
			printf("arithmetic shift left)\n\n");
		}

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

		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) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*s_objet).type == BIN)
	{
		if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		longueur = 1;
		j = 1;

		for(i = 37; i <= 42; i++)
		{
			longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
					== d_vrai) ? j : 0;
			j *= 2;
		}

		retenue = (tampon = (*((logical8 *) (*s_copie).objet))) & (logical8) 1;
		tampon <<= 1;

		for(masque = 0, i = 1; i < longueur; i++)
		{
			masque <<= 1;
			masque |= (logical8) 1;
		}

		masque <<= 1;
		tampon &= masque;
		(*((logical8 *) (*s_copie).objet)) = tampon | retenue;

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

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_asr(struct_processus *s_etat_processus)
{
	logical8							masque;
	logical8							tampon;

	struct_objet						*s_copie;
	struct_objet						*s_objet;

	unsigned long						i;
	unsigned long						j;
	unsigned long						longueur;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(décalage arithmétique à droite)\n\n");
		}
		else
		{
			printf("(arithmetic shift right)\n\n");
		}

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

		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) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*s_objet).type == BIN)
	{
		if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		longueur = 1;
		j = 1;

		for(i = 37; i <= 42; i++)
		{
			longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
					== d_vrai) ? j : 0;
			j *= 2;
		}

		tampon = (*((logical8 *) (*s_copie).objet));
		masque = ((logical8) 1) << (longueur - 1);

		if ((tampon & masque) == 0)
		{
			tampon >>= 1;
		}
		else
		{
			tampon >>= 1;
			tampon |= masque;
		}

		for(masque = 0, i = 0; i < longueur; i++)
		{
			masque <<= 1;
			masque |= 1;
		}

		tampon &= masque;
		(*((logical8 *) (*s_copie).objet)) = tampon;

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

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_append(struct_processus *s_etat_processus)
{
	struct_descripteur_fichier		*descripteur;

	struct_objet					*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(positionnement à la fin du fichier)\n\n");
		}
		else
		{
			printf("(to reach the end of the file)\n\n");
		}

		printf("    1: %s\n", d_FCH);

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

	if ((*s_objet_argument).type == FCH)
	{
		if ((descripteur = descripteur_fichier(s_etat_processus,
				(struct_fichier *) (*s_objet_argument).objet)) == NULL)
		{
			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if ((*descripteur).type == 'C')
		{
			if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END) != 0)
			{
				liberation(s_etat_processus, s_objet_argument);

				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else
		{
			liberation(s_etat_processus, s_objet_argument);

			(*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
			return;
		}
	}
	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);

	return;
}


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

void
instruction_axes(struct_processus *s_etat_processus)
{
	/*
	 * Prend comme argument une liste
	 */

	logical1						autorisation_trace;
	logical1						axes_principaux;
	logical1						presence_type;

	long							nombre_arguments_principaux;
	long							nombre_arguments_auxiliaires;

	struct_liste_chainee			*l_element_courant;
	struct_liste_chainee			*l_element_courant_auxiliaire;

	struct_objet					*s_objet_argument;
	struct_objet					*s_objet_auxiliaire;

	unsigned char					*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(définition des axes)\n\n");
		}
		else
		{
			printf("(axes definition)\n\n");
		}

		printf("    1: %s\n\n", d_LST);

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

		printf("    { \"MAIN\" } AXES\n");
		printf("    { \"AUXILIARY\" } AXES\n");
		printf("    { \"MAIN\" { (expression 1) (expression 2) }\n");
		printf("            { (expression 3) TICSONLY } } AXES\n\n");
		printf("    { \"MAIN\" { (expression 1) \"TICSONLY\" }\n");
		printf("            { (expression 2) } } AXES\n\n");
		printf("    { \"AUXILIARY\" { \"AUTOMATIC\" }\n");
		printf("            { \"TICSONLY\" \"AUTOMATIC\" } } AXES\n\n");
		printf("    { { (expression 1) \"DEFAULT\" } { \"AUTOMATIC\" } }\n");
		printf("            { \"TICSONLY\" (expression 2) } } AXES\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, 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;
	}

	if ((*s_objet_argument).type == LST)
	{
		l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
		nombre_arguments_principaux = 0;
		presence_type = d_faux;
		tampon = NULL;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type == CHN)
			{
				if (presence_type == d_vrai)
				{
					free(tampon);

					liberation(s_etat_processus, s_objet_argument);
					
					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}

				if ((tampon = conversion_majuscule((unsigned char *)
						(*(*l_element_courant).donnee).objet)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				presence_type = d_vrai;
			}
			else
			{
				nombre_arguments_principaux++;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (presence_type == d_faux)
		{
			if ((tampon = malloc(5 * sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if ((*s_etat_processus).systeme_axes == 0)
			{
				strcpy(tampon, "MAIN");
			}
			else
			{
				strcpy(tampon, "AUXILIARY");
			}
		}

		if (strcmp(tampon, "MAIN") == 0)
		{
			axes_principaux = d_vrai;
			(*s_etat_processus).systeme_axes = 0;
		}
		else if (strcmp(tampon, "AUXILIARY") == 0)
		{
			axes_principaux = d_faux;
			(*s_etat_processus).systeme_axes = 1;
		}
		else
		{
			free(tampon);

			liberation(s_etat_processus, s_objet_argument);

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

		free(tampon);

		if ((nombre_arguments_principaux != 0) &&
				(nombre_arguments_principaux != 2) &&
				(nombre_arguments_principaux != 3))
		{
			liberation(s_etat_processus, s_objet_argument);

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

		l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;
		nombre_arguments_principaux = 0;

		while(l_element_courant != NULL)
		{
			nombre_arguments_principaux++;

			if ((*(*l_element_courant).donnee).type == CHN)
			{
				l_element_courant = (*l_element_courant).suivant;
				nombre_arguments_principaux--;
				continue;
			}
			else if ((*(*l_element_courant).donnee).type == LST)
			{
				l_element_courant_auxiliaire = (struct_liste_chainee *)
						(*(*l_element_courant).donnee).objet;
				nombre_arguments_auxiliaires = 0;
				autorisation_trace = d_vrai;

				while(l_element_courant_auxiliaire != NULL)
				{
					nombre_arguments_auxiliaires++;

					if (((*(*l_element_courant_auxiliaire).donnee).type ==
							RPN) || ((*(*l_element_courant_auxiliaire).donnee)
							.type == ALG) || ((*(*l_element_courant_auxiliaire)
							.donnee).type == NOM))
					{
						if (evaluation(s_etat_processus,
								(*l_element_courant_auxiliaire).donnee, 'N')
								== d_erreur)
						{
							liberation(s_etat_processus, s_objet_argument);

							return;
						}

						if (depilement(s_etat_processus,
								&((*s_etat_processus).l_base_pile),
								&s_objet_auxiliaire) == d_erreur)
						{
							liberation(s_etat_processus, s_objet_argument);

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

						liberation(s_etat_processus,
								(*l_element_courant_auxiliaire).donnee);
						(*l_element_courant_auxiliaire).donnee =
								s_objet_auxiliaire;
					}

					if ((*(*l_element_courant_auxiliaire).donnee).type == INT)
					{
						if ((*((integer8 *) (*(*l_element_courant_auxiliaire)
								.donnee).objet)) <= 0)
						{
							liberation(s_etat_processus, s_objet_argument);

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

						switch(nombre_arguments_principaux)
						{
							case 1 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).x_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).x_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mx_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mx_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).x2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).x2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mx2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mx2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							case 2 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).y_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).y_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).my_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).my_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).y2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).y2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).my2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).my2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							case 3 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).z_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).z_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mz_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mz_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).z2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).z2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mz2_tics = (real8)
												(*((integer8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mz2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							default :
							{
								liberation(s_etat_processus, s_objet_argument);

								(*s_etat_processus).erreur_execution =
										d_ex_argument_invalide;
								return;
							}
						}
					}
					else if ((*(*l_element_courant_auxiliaire)
							.donnee).type == REL)
					{
						if ((*((real8 *) (*(*l_element_courant_auxiliaire)
								.donnee).objet)) <= 0)
						{
							liberation(s_etat_processus, s_objet_argument);

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

						switch(nombre_arguments_principaux)
						{
							case 1 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).x_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).x_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mx_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mx_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).x2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).x2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mx2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mx2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							case 2 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).y_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).y_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).my_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).my_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).y2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).y2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).my2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).my2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							case 3 :
							{
								if (axes_principaux == d_vrai)
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).z_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).z_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mz_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mz_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

										(*s_etat_processus).erreur_execution =
												d_ex_argument_invalide;
										return;
									}
								}
								else
								{
									if (nombre_arguments_auxiliaires == 1)
									{
										(*s_etat_processus).z2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).z2_lines =
												autorisation_trace;
									}
									else if (nombre_arguments_auxiliaires == 2)
									{
										(*s_etat_processus).mz2_tics =
												(*((real8 *) (*
												(*l_element_courant_auxiliaire)
												.donnee).objet));
										(*s_etat_processus).mz2_lines =
												autorisation_trace;
									}
									else
									{
										liberation(s_etat_processus,
												s_objet_argument);

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

								break;
							}

							default :
							{
								liberation(s_etat_processus, s_objet_argument);

								(*s_etat_processus).erreur_execution =
										d_ex_argument_invalide;
								return;
							}
						}
					}
					else if ((*(*l_element_courant_auxiliaire).donnee)
							.type == CHN)
					{
						tampon = conversion_majuscule((unsigned char *)
								(*(*l_element_courant_auxiliaire).donnee)
								.objet);

						if (tampon == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						if (strcmp(tampon, "AUTOMATIC") == 0)
						{
							switch(nombre_arguments_principaux)
							{
								case 1 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).x_tics = 0;
											(*s_etat_processus).x_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).x2_tics = 0;
											(*s_etat_processus).x2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								case 2 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).y_tics = 0;
											(*s_etat_processus).y_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).y2_tics = 0;
											(*s_etat_processus).y2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								case 3 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).z_tics = 0;
											(*s_etat_processus).z_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 1)
										{
											(*s_etat_processus).z2_tics = 0;
											(*s_etat_processus).z2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								default :
								{
									liberation(s_etat_processus,
											s_objet_argument);

									free(tampon);

									(*s_etat_processus).erreur_execution =
											d_ex_argument_invalide;
									return;
								}
							}
						}
						else if (strcmp(tampon, "DEFAULT") == 0)
						{
							switch(nombre_arguments_principaux)
							{
								case 1 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).mx_tics = 0;
											(*s_etat_processus).mx_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).mx2_tics = 0;
											(*s_etat_processus).mx2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								case 2 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).my_tics = 0;
											(*s_etat_processus).my_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).my2_tics = 0;
											(*s_etat_processus).my2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								case 3 :
								{
									if (axes_principaux == d_vrai)
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).mz_tics = 0;
											(*s_etat_processus).mz_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}
									else
									{
										if (nombre_arguments_auxiliaires
												== 2)
										{
											(*s_etat_processus).mz2_tics = 0;
											(*s_etat_processus).mz2_lines =
													autorisation_trace;
										}
										else
										{
											liberation(s_etat_processus,
													s_objet_argument);

											(*s_etat_processus).erreur_execution
													= d_ex_argument_invalide;

											return;
										}
									}

									break;
								}

								default :
								{
									liberation(s_etat_processus,
											s_objet_argument);

									free(tampon);

									(*s_etat_processus).erreur_execution =
											d_ex_argument_invalide;
									return;
								}
							}
						}
						else if (strcmp(tampon, "TICSONLY") == 0)
						{
							nombre_arguments_auxiliaires--;
							autorisation_trace = d_faux;
						}
						else
						{
							liberation(s_etat_processus, s_objet_argument);

							free(tampon);

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

						free(tampon);
					}
					else
					{
						liberation(s_etat_processus, s_objet_argument);

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

					l_element_courant_auxiliaire =
							(*l_element_courant_auxiliaire).suivant;
				}
			}
			else
			{
				liberation(s_etat_processus, s_objet_argument);

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

			l_element_courant = (*l_element_courant).suivant;
		}
	}
	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);

	return;
}

// vim: ts=4