version 1.46, 2013/03/28 16:15:09
|
version 1.47, 2013/03/29 10:30:32
|
Line 39
|
Line 39
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
|
#define __CATCH_SYSTEM_ERROR__ \ |
|
do { if (((*rpl_arguments).erreur != 0) && \ |
|
((*rpl_arguments).type_erreur == 'S')) \ |
|
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) |
Line 56
|
Line 61
|
#define declareComplex(complex) complex16 complex |
#define declareComplex(complex) complex16 complex |
#define declareDaisyChain(daisyChain) struct_liste_chainee *daisyChain = NULL |
#define declareDaisyChain(daisyChain) struct_liste_chainee *daisyChain = NULL |
|
|
#define getDaisyChainFromList(list, daisyChain) do { \ |
#define getDaisyChainFromList(list, daisyChain) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
|
do { \ |
typeof(list) __list = list; \ |
typeof(list) __list = list; \ |
daisyChain = NULL; \ |
daisyChain = NULL; \ |
ifIsList(__list) { daisyChain = (*__list).objet; } \ |
ifIsList(__list) { daisyChain = (*__list).objet; } \ |
else executionError("Type mistmatch error"); } while(0) |
else executionError("Type mistmatch error"); } while(0) |
|
|
#define fetchElementFromDaisyChain(daisyChain) \ |
#define fetchElementFromDaisyChain(daisyChain) \ |
({ typeof(daisyChain) __daisyChain = daisyChain; \ |
({ __CATCH_SYSTEM_ERROR__; typeof(daisyChain) __daisyChain = daisyChain; \ |
if (__daisyChain == NULL) executionError("End of daisy chain"); \ |
if (__daisyChain == NULL) executionError("End of daisy chain"); \ |
(__daisyChain == NULL) ? NULL : (*__daisyChain).donnee; }) |
(__daisyChain == NULL) ? NULL : (*__daisyChain).donnee; }) |
|
|
#define replaceElementIntoDaisyChain(daisyChain, element) \ |
#define replaceElementIntoDaisyChain(daisyChain, element) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { typeof(daisyChain) __daisyChain = daisyChain; \ |
do { typeof(daisyChain) __daisyChain = daisyChain; \ |
if (__daisyChain == NULL) executionError("Nullified daisy chain"); \ |
if (__daisyChain == NULL) executionError("Nullified daisy chain"); \ |
freeObject((*__daisyChain).donnee); \ |
freeObject((*__daisyChain).donnee); \ |
(*__daisyChain).donnee = element; } while(0) |
(*__daisyChain).donnee = element; } while(0) |
|
|
#define nextElementOfDaisyChain(daisyChain) \ |
#define nextElementOfDaisyChain(daisyChain) \ |
({ typeof(daisyChain) __daisyChain = daisyChain; \ |
({ __CATCH_SYSTEM_ERROR__; typeof(daisyChain) __daisyChain = daisyChain; \ |
if (__daisyChain == NULL) executionError("End of daisy chain"); \ |
if (__daisyChain == NULL) executionError("End of daisy chain"); \ |
(__daisyChain == NULL) ? NULL : (*__daisyChain).suivant; }) |
(__daisyChain == NULL) ? NULL : (*__daisyChain).suivant; }) |
|
|
#define null NULL |
#define null NULL |
#define nullify(ptr) do { ptr = NULL; } while(0) |
#define nullify(ptr) __CATCH_SYSTEM_ERROR__; do { ptr = NULL; } while(0) |
#define nullified(ptr) ((ptr) == NULL) |
#define nullified(ptr) ((ptr) == NULL) |
|
|
#define postIncr(x) (x++) |
#define postIncr(x) (x++) |
Line 111
|
Line 119
|
#define declareUnion typedef union { |
#define declareUnion typedef union { |
#define as(name) } name; |
#define as(name) } name; |
|
|
#define __RPL__ struct_rpl_arguments rpl_arguments |
|
|
|
#define target(a) (*a) |
#define target(a) (*a) |
#define address(a) (&a) |
#define address(a) (&a) |
|
|
#define beginGroup { |
#define beginGroup { __CATCH_SYSTEM_ERROR__; |
#define endGroup } |
#define endGroup __CATCH_SYSTEM_ERROR__; } |
#define beginMacro do beginGroup |
#define beginMacro do beginGroup |
#define endMacro endGroup while(0) |
#define endMacro endGroup while(0) |
#define stopRequest test_arret((*rpl_arguments).s_etat_processus) |
#define stopRequest __CATCH_SYSTEM_ERROR__; \ |
|
test_arret((*rpl_arguments).s_etat_processus) |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 128
|
Line 135
|
--------------------------------------------------------------------------------*/ |
--------------------------------------------------------------------------------*/ |
|
|
#define blockSignals \ |
#define blockSignals \ |
{ sigset_t set, oldset; sigfillset(&set); \ |
{ __CATCH_SYSTEM_ERROR__; sigset_t set, oldset; sigfillset(&set); \ |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
pthread_sigmask(SIG_BLOCK, &set, &oldset); |
#define unblockSignals \ |
#define unblockSignals \ |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); } |
pthread_sigmask(SIG_SETMASK, &oldset, NULL); __CATCH_SYSTEM_ERROR__; } |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 165
|
Line 172
|
DISABLE_SET_BUT_NOT_USED_WARNING(__masque); |
DISABLE_SET_BUT_NOT_USED_WARNING(__masque); |
|
|
#define FUNCTION \ |
#define FUNCTION \ |
if (__validation_instruction == d_vrai) return; \ |
if (__validation_instruction == d_vrai) return 0; \ |
if (__presence_aide == d_faux) \ |
if (__presence_aide == d_faux) \ |
{ \ |
{ \ |
systemError("Help string not defined"); \ |
systemError("Help string not defined"); \ |
Line 185
|
Line 192
|
strcpy((char *) __function_name, ""); \ |
strcpy((char *) __function_name, ""); \ |
if (__constante != 0) \ |
if (__constante != 0) \ |
systemError("Constant definition error"); \ |
systemError("Constant definition error"); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
} } \ |
} } \ |
return; |
leave; |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 195
|
Line 203
|
*/ |
*/ |
|
|
#define freeObject(object) \ |
#define freeObject(object) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { \ |
do { \ |
if (object == NULL) \ |
if (object == NULL) \ |
systemError("Nullified object"); \ |
systemError("Nullified object"); \ |
Line 209
|
Line 218
|
*/ |
*/ |
|
|
#define dupObject(object) \ |
#define dupObject(object) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { if (copie_objet(object, 'P') != object) \ |
do { if (copie_objet(object, 'P') != object) \ |
systemError("Memory allocation error"); } while(0) |
systemError("Memory allocation error"); } while(0) |
|
|
Line 218
|
Line 228
|
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
#define declareInternalFunction(name, ...) \ |
#define declareInternalFunction(type, name, ...) \ |
__internal_##name(struct_rpl_arguments *rpl_arguments, __VA_ARGS__) { |
type __internal_##name(struct_rpl_arguments *rpl_arguments, __VA_ARGS__) { \ |
|
|
#define endInternalFunction } |
#define endInternalFunction leave; } |
|
|
#define useInternalFunction(name, ...) \ |
#define useInternalFunction(type, name, ...) \ |
__internal_##name(struct_rpl_arguments *rpl_arguments, __VA_ARGS__) |
type __internal_##name(struct_rpl_arguments *rpl_arguments, __VA_ARGS__) |
|
|
#define callInternalFunction(name, ...) \ |
#define callInternalFunction(name, ...) \ |
__internal_##name(rpl_arguments, __VA_ARGS__) |
__internal_##name(rpl_arguments, __VA_ARGS__) |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
|
Déclaration des fonctions C |
|
-------------------------------------------------------------------------------- |
|
*/ |
|
|
|
#define declareCFunction(type, name, ...) \ |
|
type name(__VA_ARGS__) { __RPL__ |
|
#define endCFunction leave; } |
|
|
|
/* |
|
-------------------------------------------------------------------------------- |
Déclaration des fonctions externes |
Déclaration des fonctions externes |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
#define declareExternalFunction(name) \ |
#define declareExternalFunction(name) \ |
void __external_##name(struct_rpl_arguments *rpl_arguments) { \ |
int __external_##name(struct_rpl_arguments *rpl_arguments) { \ |
char __function_name[] = "__external_"#name; \ |
char __function_name[] = "__external_"#name; \ |
__static_rpl_arguments = (*rpl_arguments); |
__static_rpl_arguments = (*rpl_arguments); |
|
|
#define useExternalFunction(function) \ |
#define useExternalFunction(function) \ |
void __external_##function(struct_rpl_arguments *rpl_arguments) |
int __external_##function(struct_rpl_arguments *rpl_arguments) |
|
|
#define libraryName(name) char __library_name[] = #name; |
#define libraryName(name) char __library_name[] = #name; |
|
|
#define __onLoading void __runOnLoading(struct_rpl_arguments *rpl_arguments) |
#define __onLoading int __runOnLoading(struct_rpl_arguments *rpl_arguments) |
#define __onClosing void __runOnClosing(struct_rpl_arguments *rpl_arguments) |
#define __onClosing int __runOnClosing(struct_rpl_arguments *rpl_arguments) |
#define declareSubroutine(when) __##when { \ |
#define declareSubroutine(when) __##when { \ |
char __function_name[] = #when; \ |
char __function_name[] = #when; \ |
__static_rpl_arguments = (*rpl_arguments); \ |
__static_rpl_arguments = (*rpl_arguments); \ |
Line 256
|
Line 276
|
FUNCTION |
FUNCTION |
#define endSubroutine END } |
#define endSubroutine END } |
|
|
#define notice(s, ...) do { ufprintf(s, __VA_ARGS__); fflush(s); } while(0) |
#define notice(s, ...) __CATCH_SYSTEM_ERROR__; \ |
#define logger(...) do { syslog(LOG_NOTICE, __VA_ARGS__); } while(0) |
do { ufprintf(s, __VA_ARGS__); fflush(s); } while(0) |
|
#define logger(...) __CATCH_SYSTEM_ERROR__; \ |
|
do { syslog(LOG_NOTICE, __VA_ARGS__); } while(0) |
|
|
#define exportExternalFunctions(...) \ |
#define exportExternalFunctions(...) \ |
char **__external_symbols(unsigned long *nb_symbols, \ |
char **__external_symbols(struct_rpl_arguments *rpl_arguments, \ |
|
integer8 *nb_symbols, \ |
const char *version) { \ |
const char *version) { \ |
char arguments[] = #__VA_ARGS__; \ |
char arguments[] = #__VA_ARGS__; \ |
char **tableau; \ |
char **tableau; \ |
Line 308
|
Line 331
|
return(tableau); \ |
return(tableau); \ |
} |
} |
|
|
#define endExternalFunction return; } |
#define endExternalFunction leave; } |
|
|
#define callExternalFunction(function) do { \ |
#define callExternalFunction(function) do { \ |
|
__CATCH_SYSTEM_ERROR__; \ |
__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 342
|
Line 366
|
if ((*rpl_arguments).affichage_arguments == 'Y') \ |
if ((*rpl_arguments).affichage_arguments == 'Y') \ |
{ \ |
{ \ |
uprintf("%s\n", h); \ |
uprintf("%s\n", h); \ |
return; \ |
return 0; \ |
} } while(0) |
} } while(0) |
|
|
#define declareSymbolicConstant do { \ |
#define declareSymbolicConstant do { \ |
Line 379
|
Line 403
|
*/ |
*/ |
|
|
#define loop(b, e, s) for(b; e; s) { |
#define loop(b, e, s) for(b; e; s) { |
#define endLoop } |
#define endLoop __CATCH_SYSTEM_ERROR__; } |
|
|
#define repeatWhile(c) while(c) { |
#define repeatWhile(c) while(c) { |
#define endWhile } |
#define endWhile __CATCH_SYSTEM_ERROR__; } |
|
|
#define doUntil do { |
#define doUntil do { |
#define repeatUntil(c) } while(!(c)); |
#define repeatUntil(c) __CATCH_SYSTEM_ERROR__; } while(!(c)); |
|
|
#define select(s) switch(s) { |
#define select(s) switch(s) { |
#define endSelect } |
#define endSelect __CATCH_SYSTEM_ERROR__; } |
#define nonExclusiveCase(c) case c: { |
#define nonExclusiveCase(c) case c: { |
#define endNonExclusiveCase } |
#define endNonExclusiveCase __CATCH_SYSTEM_ERROR__; } |
#define exclusiveCase(c) case c: { |
#define exclusiveCase(c) case c: { |
#define endExclusiveCase break; } |
#define endExclusiveCase break; __CATCH_SYSTEM_ERROR__; } |
#define defaultCase default: |
#define defaultCase default: |
#define endDefaultCase break; } |
#define endDefaultCase break; __CATCH_SYSTEM_ERROR__; } |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 406
|
Line 430
|
if ((*rpl_arguments).erreur != 0) \ |
if ((*rpl_arguments).erreur != 0) \ |
{ \ |
{ \ |
__VA_ARGS__; \ |
__VA_ARGS__; \ |
return; \ |
return 0; \ |
} } while(0) |
} } while(0) |
|
|
#define systemError(message) do { \ |
#define systemError(message) do { \ |
(*rpl_arguments).erreur = __LINE__; \ |
(*rpl_arguments).erreur = __LINE__; \ |
(*rpl_arguments).type_erreur = 'S'; \ |
(*rpl_arguments).type_erreur = 'S'; \ |
(*rpl_arguments).message_erreur = (unsigned char *) message; \ |
(*rpl_arguments).message_erreur = (unsigned char *) message; \ |
return; } while(0) |
return 0; } while(0) |
|
|
#define executionError(message) do { \ |
#define executionError(message) do { \ |
(*rpl_arguments).erreur = __LINE__; \ |
(*rpl_arguments).erreur = __LINE__; \ |
Line 421
|
Line 445
|
(*rpl_arguments).message_erreur = (unsigned char *) message; } while(0) |
(*rpl_arguments).message_erreur = (unsigned char *) message; } while(0) |
|
|
#define onSystemError(...) do { \ |
#define onSystemError(...) do { \ |
if ((*rpl_arguments).erreur != 0) \ |
if (((*rpl_arguments).erreur != 0) && \ |
|
((*rpl_arguments).type_erreur == 'S')) \ |
{ \ |
{ \ |
__VA_ARGS__; \ |
|
blockSignals; \ |
blockSignals; \ |
kill(getpid(), SIGTERM); \ |
kill(getpid(), SIGTERM); \ |
unblockSignals; \ |
unblockSignals; \ |
|
__VA_ARGS__; \ |
} } while(0) |
} } while(0) |
|
|
#define onError(...) \ |
#define onError(...) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { if (((*rpl_arguments).type_erreur == 'E') && \ |
do { if (((*rpl_arguments).type_erreur == 'E') && \ |
((*rpl_arguments).erreur != 0)) { __VA_ARGS__; \ |
((*rpl_arguments).erreur != 0)) { __VA_ARGS__; \ |
(*rpl_arguments).erreur = 0; } } while(0) |
(*rpl_arguments).erreur = 0; } } while(0) |
|
|
#define onExecution(...) \ |
#define onExecution(...) \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { if (((*rpl_arguments).type_erreur == 'E') && \ |
do { if (((*rpl_arguments).type_erreur == 'E') && \ |
((*rpl_arguments).erreur == 0)) { __VA_ARGS__; } } while(0) |
((*rpl_arguments).erreur == 0)) { __VA_ARGS__; } } while(0) |
|
|
Line 445
|
Line 472
|
*/ |
*/ |
|
|
#define pushOnStack(object) do { \ |
#define pushOnStack(object) do { \ |
|
__CATCH_SYSTEM_ERROR__; \ |
if (((*rpl_arguments).l_base_pile = \ |
if (((*rpl_arguments).l_base_pile = \ |
empilement_pile_operationnelle(rpl_arguments, object)) == NULL) \ |
empilement_pile_operationnelle(rpl_arguments, object)) == NULL) \ |
systemError("Memory allocation error"); \ |
systemError("Memory allocation error"); \ |
if ((*object).nombre_occurrences == 1) object = NULL; } while(0) |
if ((*object).nombre_occurrences == 1) object = NULL; } while(0) |
|
|
#define pullFromStack(object, ...) do { \ |
#define pullFromStack(object, ...) do { \ |
|
__CATCH_SYSTEM_ERROR__; \ |
(*rpl_arguments).l_base_pile = \ |
(*rpl_arguments).l_base_pile = \ |
depilement_pile_operationnelle(rpl_arguments, &object); \ |
depilement_pile_operationnelle(rpl_arguments, &object); \ |
if (object == NULL) \ |
if (object == NULL) \ |
Line 492
|
Line 521
|
*/ |
*/ |
|
|
#define then { |
#define then { |
#define endIf } |
#define endIf __CATCH_SYSTEM_ERROR__; } |
#define elseIf } else if |
#define elseIf __CATCH_SYSTEM_ERROR__; } else if |
#define orElse } else { |
#define orElse __CATCH_SYSTEM_ERROR__; } else { |
|
|
// Constantes symboliques |
// Constantes symboliques |
|
|
Line 508
|
Line 537
|
if (((*rpl_arguments).drapeaux_etat[__indice_bloc] & __masque) != 0) \ |
if (((*rpl_arguments).drapeaux_etat[__indice_bloc] & __masque) != 0) \ |
{ \ |
{ \ |
createNameObject(object); \ |
createNameObject(object); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
{ \ |
{ \ |
char *__constant_name; \ |
char *__constant_name; \ |
if ((__constant_name = malloc((strlen(__library_name) + \ |
if ((__constant_name = malloc((strlen(__library_name) + \ |
Line 524
|
Line 554
|
if (strcmp(#type, "integer") == 0) \ |
if (strcmp(#type, "integer") == 0) \ |
{ \ |
{ \ |
createIntegerObject(object); \ |
createIntegerObject(object); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
setInteger(object, value); \ |
setInteger(object, value); \ |
} \ |
} \ |
else if (strcmp(#type, "real") == 0) \ |
else if (strcmp(#type, "real") == 0) \ |
{ \ |
{ \ |
createRealObject(object); \ |
createRealObject(object); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
setReal(object, value); \ |
setReal(object, value); \ |
} \ |
} \ |
} \ |
} \ |
|
__CATCH_SYSTEM_ERROR__; \ |
__constante--; } while(0) |
__constante--; } while(0) |
|
|
#define createSymbolicComplexConstant(object, rp, ip) do { \ |
#define createSymbolicComplexConstant(object, rp, ip) do { \ |
Line 542
|
Line 575
|
if (((*rpl_arguments).drapeaux_etat[__indice_bloc] & __masque) != 0) \ |
if (((*rpl_arguments).drapeaux_etat[__indice_bloc] & __masque) != 0) \ |
{ \ |
{ \ |
createNameObject(object); \ |
createNameObject(object); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
{ \ |
{ \ |
char *__constant_name; \ |
char *__constant_name; \ |
if ((__constant_name = malloc((strlen(__library_name) + \ |
if ((__constant_name = malloc((strlen(__library_name) + \ |
Line 556
|
Line 590
|
else \ |
else \ |
{ \ |
{ \ |
createComplexObject(object); \ |
createComplexObject(object); \ |
|
__CATCH_SYSTEM_ERROR__; \ |
setComplex(object, rp, im); \ |
setComplex(object, rp, im); \ |
} \ |
} \ |
|
__CATCH_SYSTEM_ERROR__; \ |
__constante--; } while(0) |
__constante--; } while(0) |
|
|
// Integer |
// Integer |
Line 1092
|
Line 1128
|
*/ |
*/ |
|
|
#define pollSignalsAndInterrupts() \ |
#define pollSignalsAndInterrupts() \ |
|
__CATCH_SYSTEM_ERROR__; \ |
do { scrutation_injection((*rpl_arguments).s_etat_processus); } while(0) |
do { scrutation_injection((*rpl_arguments).s_etat_processus); } while(0) |
|
|
/* |
/* |
Line 1102
|
Line 1139
|
|
|
#define intrinsic(function) do { \ |
#define intrinsic(function) do { \ |
int __status; \ |
int __status; \ |
|
__CATCH_SYSTEM_ERROR__; \ |
__status = wrapper_instruction_intrinseque( \ |
__status = wrapper_instruction_intrinseque( \ |
instruction_##function, rpl_arguments); \ |
instruction_##function, rpl_arguments); \ |
if (__status == 1) executionError(#function); \ |
if (__status == 1) executionError(#function); \ |