rpl/src/rplexternals.h - diff

Return to rplexternals.h CVS log

Up to [local] / rpl / src

Diff for /rpl/src/rplexternals.h between versions 1.64 and 1.74

version 1.64, 2015/06/08 14:11:45	version 1.74, 2017/06/29 12:33:34
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.22	RPL/2 (R) version 4.1.27
Copyright (C) 1989-2015 Dr. BERTRAND Joël	Copyright (C) 1989-2017 Dr. BERTRAND Joël

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

Line 29	Line 29
================================================================================	================================================================================
*/	*/

# define RPLARGS	// Si TYPE_DECLARATION est défini, toutes les structures internes du RPL/2
# define struct_processus void	// sont exposés pour travailler sur des nouveaux types de données.
	# ifndef TYPE_DECLARATION
	# define RPLARGS
	# define struct_processus void
	# endif

# include "rpl.h"	# include "rpl.h"

/*	/*
Line 47	Line 52
((*rpl_arguments).type_erreur == 'S')) \	((*rpl_arguments).type_erreur == 'S')) \
return 0; } while(0)	return 0; } while(0)
#define leave do { return(0); } while(0)	#define leave do { return(0); } while(0)
#define allocation(a) librpl_allocation((*rpl_arguments).s_etat_processus, a)	#define _allocation(a) librpl_allocation((*rpl_arguments).s_etat_processus, a)
#define copie_objet(a, b) librpl_copie_objet( \	#define _copie_objet(a, b) librpl_copie_objet( \
(*rpl_arguments).s_etat_processus, a, b)	(*rpl_arguments).s_etat_processus, a, b)
#define liberation(a) librpl_liberation((*rpl_arguments).s_etat_processus, a)	#define _liberation(a) librpl_liberation((*rpl_arguments).s_etat_processus, a)

#ifdef __RPLC_MAIN	#ifdef __RPLC_MAIN
struct_rpl_arguments __static_rpl_arguments;	struct_rpl_arguments __static_rpl_arguments;
Line 68	Line 73

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
	Gestion des objets
	--------------------------------------------------------------------------------
	*/

	// new, dup, drop, disp, parse
	// __type_new(struct_rpl_arguments *rpl_arguments)
	#define declareTypeExtension(fct) \
	int __type_##fct(struct_processus *s_etat_processus) { \
	unsigned char rptr, ptr; \
	rptr = (*s_etat_processus).definitions_chainees + \
	(*s_etat_processus).position_courante; \
	ptr = rptr; \
	if (ptr != rptr) goto __parse_error;
	#define parseError { goto __parse_error; } while(0)
	#define endTypeExtension __parse_error: return(0); }
	#define sizeOfParse (rptr - ptr)

	/*
	--------------------------------------------------------------------------------
Types	Types
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
Line 130	Line 154
#define logical int	#define logical int
#define string char *	#define string char *
#define integer int	#define integer int
#define object struct_objet *

#define declareStructure typedef struct {	#define declareStructure typedef struct {
#define declareUnion typedef union {	#define declareUnion typedef union {
Line 139	Line 162
#define target(a) (*a)	#define target(a) (*a)
#define address(a) (&a)	#define address(a) (&a)

	#define subroutine(name) int name()
#define beginGroup { __CATCH_SYSTEM_ERROR__;	#define beginGroup { __CATCH_SYSTEM_ERROR__;
#define endGroup __CATCH_SYSTEM_ERROR__; }	#define endGroup __CATCH_SYSTEM_ERROR__; }
#define beginMacro do beginGroup	#define beginMacro do beginGroup
Line 224	Line 248
do { \	do { \
if (rpl_object == NULL) \	if (rpl_object == NULL) \
systemError("Nullified object"); \	systemError("Nullified object"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = NULL; \	rpl_object = NULL; \
} while(0)	} while(0)

Line 236	Line 260

#define dupObject(rpl_object) \	#define dupObject(rpl_object) \
__CATCH_SYSTEM_ERROR__; \	__CATCH_SYSTEM_ERROR__; \
do { if (copie_objet(rpl_object, 'P') != rpl_object) \	do { if (_copie_objet(rpl_object, 'P') != rpl_object) \
systemError("Memory allocation error"); } while(0)	systemError("Memory allocation error"); } while(0)

/*	/*
Line 245	Line 269
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#define CONCAT(a, b) __CONCAT(a, b)	#define CONCAT(a, b) __RPL_CONCAT(a, b)
#define __CONCAT(a, b) a##b	#define __RPL_CONCAT(a, b) a##b
#define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)	#define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)
#define FIRST_HELPER(first, ...) first	#define FIRST_HELPER(first, ...) first
#define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)	#define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)
Line 327	Line 351
char ptr1, ptr2; \	char ptr1, ptr2; \
int drapeau; \	int drapeau; \
unsigned long i; \	unsigned long i; \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if (strcmp(version, _d_version_rpl) != 0) \	if (strcmp(version, _d_version_rpl) != 0) \
{ \	{ \
notice(stdout, "Versions mismatch : library %s, expected %s\n", \	notice(stdout, "Versions mismatch : library %s, expected %s\n", \
Line 566	Line 592
// Constantes symboliques	// Constantes symboliques

#define createSymbolicConstant(rpl_object, type, value) do { \	#define createSymbolicConstant(rpl_object, type, value) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if ((strcmp(#type, "integer") != 0) && (strcmp(#type, "real") != 0)) \	if ((strcmp(#type, "integer") != 0) && (strcmp(#type, "real") != 0)) \
systemError("Type not allowed for symbolic constant"); \	systemError("Type not allowed for symbolic constant"); \
__taille_bloc = sizeof(t_8_bits) * 8; \	__taille_bloc = sizeof(t_8_bits) * 8; \
Line 606	Line 634
__constante--; } while(0)	__constante--; } while(0)

#define createSymbolicComplexConstant(rpl_object, rp, ip) do { \	#define createSymbolicComplexConstant(rpl_object, rp, ip) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
__taille_bloc = sizeof(t_8_bits) * 8; \	__taille_bloc = sizeof(t_8_bits) * 8; \
__indice_bloc = (35 - 1) / __taille_bloc; \	__indice_bloc = (35 - 1) / __taille_bloc; \
__indice_bit = (35 - 1) % __taille_bloc; \	__indice_bit = (35 - 1) % __taille_bloc; \
Line 642	Line 672
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
(((integer8 ) (*rpl_object).objet)) = (integer8) value; \	(((integer8 ) (*rpl_object).objet)) = (integer8) value; \
Line 665	Line 695
#define createIntegerObject(rpl_object) do { \	#define createIntegerObject(rpl_object) do { \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(INT)) == NULL) \	if ((rpl_object = _allocation(INT)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
setInteger(rpl_object, 0); } while(0)	setInteger(rpl_object, 0); } while(0)

Line 677	Line 707
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
(((real8 ) (*rpl_object).objet)) = (real8) value; \	(((real8 ) (*rpl_object).objet)) = (real8) value; \
Line 700	Line 730
#define createRealObject(rpl_object) do { \	#define createRealObject(rpl_object) do { \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(REL)) == NULL) \	if ((rpl_object = _allocation(REL)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
setReal(rpl_object, 0); } while(0)	setReal(rpl_object, 0); } while(0)

Line 714	Line 744
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
setRealPartOfComplex(rpl_object, __rp); \	setRealPartOfComplex(rpl_object, __rp); \
Line 728	Line 758
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
ifIsComplex(rpl_object) (((complex16 ) (*rpl_object).objet)) \	ifIsComplex(rpl_object) (((complex16 ) (*rpl_object).objet)) \
Line 741	Line 771
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
(((complex16 ) (*rpl_object).objet)).partie_imaginaire = value; \	(((complex16 ) (*rpl_object).objet)).partie_imaginaire = value; \
Line 770	Line 800
#define createComplexObject(rpl_object) do { \	#define createComplexObject(rpl_object) do { \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(CPL)) == NULL) \	if ((rpl_object = _allocation(CPL)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
setComplex(rpl_object, 0, 0); } while(0)	setComplex(rpl_object, 0, 0); } while(0)

Line 778	Line 808

#define createVectorObject(rpl_object, size, otype, structure, cat) do { \	#define createVectorObject(rpl_object, size, otype, structure, cat) do { \
integer8 i; \	integer8 i; \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(cat)) == NULL) \	if ((rpl_object = _allocation(cat)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
(((structure ) (*rpl_object).objet)).taille = size; \	(((structure ) (*rpl_object).objet)).taille = size; \
if (((((structure ) (*rpl_object).objet)).tableau = \	if (((((structure ) (*rpl_object).objet)).tableau = \
Line 816	Line 848
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
__position--; \	__position--; \
Line 864	Line 896
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
__position--; \	__position--; \
Line 900	Line 932
else executionError("Type mismatch error"); } while(0)	else executionError("Type mismatch error"); } while(0)

#define createRealVectorObject(rpl_object, size) \	#define createRealVectorObject(rpl_object, size) \
createVectorObject(object, size, real8, struct_vecteur, VRL)	createVectorObject(rpl_object, size, real8, struct_vecteur, VRL)

// A FIXER	// A FIXER

Line 920	Line 952
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
(((integer8 ) (*rpl_object).objet)) = (integer8) value; \	(((integer8 ) (*rpl_object).objet)) = (integer8) value; \
Line 944	Line 976
#define createBinaryIntegerObject(rpl_object) do { \	#define createBinaryIntegerObject(rpl_object) do { \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(BIN)) == NULL) \	if ((rpl_object = _allocation(BIN)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
setBinaryInteger(rpl_object, 0); } while(0)	setBinaryInteger(rpl_object, 0); } while(0)

Line 957	Line 989
#define elseIfIsName(rpl_object) } else if (isName(rpl_object))	#define elseIfIsName(rpl_object) } else if (isName(rpl_object))

#define setName(rpl_object, value) do { \	#define setName(rpl_object, value) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
ifIsName(rpl_object) \	ifIsName(rpl_object) \
{ \	{ \
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
free((((struct_nom ) (*rpl_object).objet)).nom); \	free((((struct_nom ) (*rpl_object).objet)).nom); \
Line 982	Line 1016
(((struct_nom ) (*rpl_object).objet)).symbole = d_vrai; } while(0)	(((struct_nom ) (*rpl_object).objet)).symbole = d_vrai; } while(0)

#define createNameObject(rpl_object) do { \	#define createNameObject(rpl_object) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(NOM)) == NULL) \	if ((rpl_object = _allocation(NOM)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
(((struct_nom ) (*rpl_object).objet)).symbole = d_faux; \	(((struct_nom ) (*rpl_object).objet)).symbole = d_faux; \
if (((((struct_nom ) (*rpl_object).objet)).nom = malloc( \	if (((((struct_nom ) (*rpl_object).objet)).nom = malloc( \
Line 1001	Line 1037
#define elseIfIsString(rpl_object) else if (isString(rpl_object))	#define elseIfIsString(rpl_object) else if (isString(rpl_object))

#define setString(rpl_object, string) do { \	#define setString(rpl_object, string) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
ifIsString(rpl_object) \	ifIsString(rpl_object) \
{ \	{ \
if (string == NULL) executionError("Nullified string"); else \	if (string == NULL) executionError("Nullified string"); else \
Line 1008	Line 1046
if ((*rpl_object).nombre_occurrences > 1) \	if ((*rpl_object).nombre_occurrences > 1) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(rpl_object, 'O')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(rpl_object, 'O')) \
	== NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(rpl_object); \	_liberation(rpl_object); \
rpl_object = __tmp_rpl_object; \	rpl_object = __tmp_rpl_object; \
} \	} \
free((unsigned char ) (rpl_object).objet); \	free((unsigned char ) (rpl_object).objet); \
Line 1028	Line 1067
else executionError("Type mismatch error"); } while(0)	else executionError("Type mismatch error"); } while(0)

#define createStringObject(rpl_object) do { \	#define createStringObject(rpl_object) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(CHN)) == NULL) \	if ((rpl_object = _allocation(CHN)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
if (((*rpl_object).objet = malloc(sizeof(unsigned char))) == NULL) \	if (((*rpl_object).objet = malloc(sizeof(unsigned char))) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
Line 1047	Line 1088
#define createListObject(rpl_object) do { \	#define createListObject(rpl_object) do { \
if (rpl_object != NULL) \	if (rpl_object != NULL) \
systemError("Reallocated object"); \	systemError("Reallocated object"); \
if ((rpl_object = allocation(LST)) == NULL) \	if ((rpl_object = _allocation(LST)) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
(*rpl_object).objet = NULL; } while(0)	(*rpl_object).objet = NULL; } while(0)

#define addObjectToList(list, rpl_object) do { \	#define addObjectToList(list, rpl_object) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
ifIsList(list) \	ifIsList(list) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(list, 'N')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(list, 'N')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(list); \	_liberation(list); \
list = __tmp_rpl_object; \	list = __tmp_rpl_object; \
if ((*list).objet == NULL) \	if ((*list).objet == NULL) \
{ \	{ \
Line 1085	Line 1128
else executionError("Type mistmatch error"); } while(0)	else executionError("Type mistmatch error"); } while(0)

#define insertObjectIntoList(list, rpl_object) do { \	#define insertObjectIntoList(list, rpl_object) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
ifIsList(list) \	ifIsList(list) \
{ \	{ \
struct_objet *__tmp_rpl_object; \	struct_objet *__tmp_rpl_object; \
if ((__tmp_rpl_object = copie_objet(list, 'N')) == NULL) \	if ((__tmp_rpl_object = _copie_objet(list, 'N')) == NULL) \
systemError("Memory allocation error"); \	systemError("Memory allocation error"); \
liberation(list); \	_liberation(list); \
list = __tmp_rpl_object; \	list = __tmp_rpl_object; \
if ((*list).objet == NULL) \	if ((*list).objet == NULL) \
{ \	{ \
Line 1115	Line 1160
else executionError("Type mistmatch error"); } while(0)	else executionError("Type mistmatch error"); } while(0)

#define removeObjectFromList(list, rpl_object) do { \	#define removeObjectFromList(list, rpl_object) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
ifIsList(list) \	ifIsList(list) \
{ \	{ \
if ((*list).objet != NULL) \	if ((*list).objet != NULL) \
Line 1140	Line 1187
__current = (*__current).suivant; \	__current = (*__current).suivant; \
} \	} \
} \	} \
liberation((*__current).donnee); \	_liberation((*__current).donnee); \
free(__current); \	free(__current); \
} \	} \
} \	} \
Line 1176	Line 1223
#define size(a) sizeof(a)	#define size(a) sizeof(a)

#define allocate(a) ({ void *ptr; \	#define allocate(a) ({ void *ptr; \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
if ((ptr = malloc(a)) == NULL) \	if ((ptr = malloc(a)) == NULL) \
systemError("Memory allocation error"); ptr; })	systemError("Memory allocation error"); ptr; })

#define deallocate(a) free(a)	#define reallocate(a, s) ({ void *ptr; \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
	if ((ptr = realloc(a, s)) == NULL) \
	systemError("Memory allocation error"); ptr; })

	#define deallocate(a) do { \
	struct_processus *s_etat_processus; \
	s_etat_processus = (*rpl_arguments).s_etat_processus; \
	free(a); } while(0)

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.64
changed lines
	Added in v.1.74