rpl/src/instructions_d1.c - diff

Return to instructions_d1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d1.c between versions 1.2 and 1.49

version 1.2, 2010/01/27 22:22:12	version 1.49, 2014/01/26 18:21:31
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.10	RPL/2 (R) version 4.1.17
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 20	Line 20
*/	*/


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


/*	/*
Line 420 instruction_drop2(struct_processus *s_et	Line 420 instruction_drop2(struct_processus *s_et
{	{
struct_objet *s_objet;	struct_objet *s_objet;

logical1 erreur;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

if ((*s_etat_processus).affichage_arguments == 'Y')	if ((*s_etat_processus).affichage_arguments == 'Y')
Line 488 instruction_drop2(struct_processus *s_et	Line 486 instruction_drop2(struct_processus *s_et
}	}
}	}

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

erreur = depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet);
liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);

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

liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);

return;	return;
Line 523 instruction_dropn(struct_processus *s_et	Line 525 instruction_dropn(struct_processus *s_et
{	{
struct_objet *s_objet;	struct_objet *s_objet;

signed long nombre_suppressions;	integer8 nombre_suppressions;

unsigned long i;	integer8 i;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 622 instruction_dropn(struct_processus *s_et	Line 624 instruction_dropn(struct_processus *s_et
return;	return;
}	}

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

for(i = 0; i < (unsigned long) nombre_suppressions; i++)	for(i = 0; i < nombre_suppressions; i++)
{	{
if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet) == d_erreur)	&s_objet) == d_erreur)
Line 760 instruction_dup2(struct_processus *s_eta	Line 761 instruction_dup2(struct_processus *s_eta
{	{
struct_objet *s_objet;	struct_objet *s_objet;

unsigned long i;	integer8 i;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 877 instruction_dupn(struct_processus *s_eta	Line 878 instruction_dupn(struct_processus *s_eta
struct_objet *s_objet;	struct_objet *s_objet;
struct_objet *s_nouvel_objet;	struct_objet *s_nouvel_objet;

signed long nombre_duplications;	integer8 nombre_duplications;
unsigned long i;	integer8 i;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 977 instruction_dupn(struct_processus *s_eta	Line 978 instruction_dupn(struct_processus *s_eta

l_element_courant = (*s_etat_processus).l_base_pile;	l_element_courant = (*s_etat_processus).l_base_pile;

for(i = 0; i < (unsigned long) nombre_duplications; i++)	for(i = 0; i < nombre_duplications; i++)
{	{
if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
Line 1003 instruction_dupn(struct_processus *s_eta	Line 1004 instruction_dupn(struct_processus *s_eta
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}

for(i = 0; i < (unsigned long) nombre_duplications; i++)	for(i = 0; i < nombre_duplications; i++)
{	{
if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)	if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)
{	{
Line 1055 instruction_division(struct_processus *s	Line 1056 instruction_division(struct_processus *s
struct_objet *s_objet_argument_2;	struct_objet *s_objet_argument_2;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long nombre_elements;	integer8 nombre_elements;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 2052 instruction_division(struct_processus *s	Line 2053 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(integer8))) == NULL)	.objet))).taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2082 instruction_division(struct_processus *s	Line 2083 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2149 instruction_division(struct_processus *s	Line 2150 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2210 instruction_division(struct_processus *s	Line 2211 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2278 instruction_division(struct_processus *s	Line 2279 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2371 instruction_division(struct_processus *s	Line 2372 instruction_division(struct_processus *s
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2382 instruction_division(struct_processus *s	Line 2383 instruction_division(struct_processus *s
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((integer8 *) (((struct_matrice ) (s_objet_resultat)	if ((((integer8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc(((((struct_matrice )	.objet)).tableau)[i] = malloc(((size_t)
(s_objet_resultat).objet))).nombre_colonnes	((((struct_matrice )
	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(integer8))) == NULL)	sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2419 instruction_division(struct_processus *s	Line 2421 instruction_division(struct_processus *s
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2451 instruction_division(struct_processus *s	Line 2453 instruction_division(struct_processus *s
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((real8 *) (((struct_matrice ) (s_objet_resultat)	if ((((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc(((((struct_matrice )	.objet)).tableau)[i] = malloc(((size_t)
(s_objet_resultat).objet))).nombre_colonnes	((((struct_matrice )
	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2504 instruction_division(struct_processus *s	Line 2507 instruction_division(struct_processus *s
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2528 instruction_division(struct_processus *s	Line 2532 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2583 instruction_division(struct_processus *s	Line 2587 instruction_division(struct_processus *s
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2615 instruction_division(struct_processus *s	Line 2620 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2669 instruction_division(struct_processus *s	Line 2674 instruction_division(struct_processus *s
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2693 instruction_division(struct_processus *s	Line 2699 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2755 instruction_division(struct_processus *s	Line 2761 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(real8))) == NULL)	(s_objet_resultat).objet)).taille) sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2806 instruction_division(struct_processus *s	Line 2812 instruction_division(struct_processus *s
(*s_objet_resultat).objet))	(*s_objet_resultat).objet))
.tableau)[i] += ((real8 *) (((struct_matrice *)	.tableau)[i] += ((real8 *) (((struct_matrice *)
(s_objet_argument_1).objet)).tableau)[i][j]	(s_objet_argument_1).objet)).tableau)[i][j]
((integer8 ) (((struct_vecteur *)	(real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[j];	(*s_objet_argument_2).objet)).tableau)[j];
}	}
else	else
Line 2853 instruction_division(struct_processus *s	Line 2859 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2966 instruction_division(struct_processus *s	Line 2972 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3066 instruction_division(struct_processus *s	Line 3072 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3170 instruction_division(struct_processus *s	Line 3176 instruction_division(struct_processus *s
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes sizeof(real8 *)))	(s_objet_resultat).objet)).nombre_lignes) sizeof(real8 *)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3212 instruction_division(struct_processus *s	Line 3218 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]	if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]
= malloc((((struct_matrice )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3236 instruction_division(struct_processus *s	Line 3242 instruction_division(struct_processus *s
.tableau)[i][j] += ((real8 **)	.tableau)[i][j] += ((real8 **)
(((struct_matrice )	(((struct_matrice )
(s_objet_argument_1).objet)).tableau)[i][k]	(s_objet_argument_1).objet)).tableau)[i][k]
((integer8 *) (((struct_matrice *)	(real8) ((integer8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[k][j];	(*s_objet_argument_2).objet)).tableau)[k][j];
}	}
else	else
Line 3287 instruction_division(struct_processus *s	Line 3293 instruction_division(struct_processus *s
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes	(s_objet_resultat).objet)).nombre_lignes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3328 instruction_division(struct_processus *s	Line 3334 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]	if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]
= malloc((((struct_matrice )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3414 instruction_division(struct_processus *s	Line 3420 instruction_division(struct_processus *s
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes	(s_objet_resultat).objet)).nombre_lignes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3455 instruction_division(struct_processus *s	Line 3461 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]	if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]
= malloc((((struct_matrice )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3531 instruction_division(struct_processus *s	Line 3537 instruction_division(struct_processus *s
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3572 instruction_division(struct_processus *s	Line 3578 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]	if ((((((struct_matrice ) (*s_objet_resultat).objet)).tableau)[i]
= malloc((((struct_matrice )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3668 instruction_division(struct_processus *s	Line 3674 instruction_division(struct_processus *s

if ((*s_objet_argument_1).type == BIN)	if ((*s_objet_argument_1).type == BIN)
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) = (logical8)
(((integer8 ) (*s_objet_argument_2).objet))	((((integer8 ) (*s_objet_argument_2).objet))
/ (((logical8 ) (*s_objet_argument_1).objet));	/ ((integer8) (((logical8 )
	(*s_objet_argument_1).objet))));
}	}
else	else
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) = (logical8)
(((logical8 ) (*s_objet_argument_2).objet))	(((integer8) (((logical8 ) (*s_objet_argument_2).objet)))
/ (((integer8 ) (*s_objet_argument_1).objet));	/ (((integer8 ) (*s_objet_argument_1).objet)));
}	}
}	}

Line 3815 instruction_default(struct_processus *s_	Line 3822 instruction_default(struct_processus *s_
unsigned char *instruction_majuscule;	unsigned char *instruction_majuscule;
unsigned char *tampon;	unsigned char *tampon;

unsigned long niveau;	integer8 niveau;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 3940 instruction_default(struct_processus *s_	Line 3947 instruction_default(struct_processus *s_
{	{
if ((*s_etat_processus).mode_execution_programme == 'Y')	if ((*s_etat_processus).mode_execution_programme == 'Y')
{	{
(*s_etat_processus).position_courante -= (strlen(	(*s_etat_processus).position_courante -=
	(integer8) (strlen(
instruction_majuscule) + 1);	instruction_majuscule) + 1);
}	}
else	else

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.2
changed lines
	Added in v.1.49