[BACK]Return to rplexternals.h CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/rplexternals.h between versions 1.28 and 1.52

version 1.28, 2011/07/25 07:45:00 version 1.52, 2013/04/10 09:07:36
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.2    RPL/2 (R) version 4.1.14
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 39 Line 39
 ================================================================================  ================================================================================
 */  */
   
   #define __RPL__ struct_rpl_arguments *rpl_arguments; \
       rpl_arguments = &__static_rpl_arguments;
   
   #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)
 #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
       struct_rpl_arguments __static_rpl_arguments;
   #   define global
   #   define initialize(a, b) a = b
   #   define declarePersistantObject(object) declareObject(object)
   #else
       extern struct_rpl_arguments __static_rpl_arguments;
   #   define global extern
   #   define initialize(a, b) a;
   #   define declarePersistantObject(object) extern struct_objet *object;
   #endif
   
   #define empty int
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Types    Types
Line 56 Line 78
 #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) { \  #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); \
     (*__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) { 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 104 Line 130
 #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 112 Line 139
 #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 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)
   
   /*
   --------------------------------------------------------------------------------
     Signaux
   --------------------------------------------------------------------------------*/
   
   #define blockSignals \
       { __CATCH_SYSTEM_ERROR__; sigset_t set, oldset; sigfillset(&set); \
       pthread_sigmask(SIG_BLOCK, &set, &oldset);
   #define unblockSignals \
       pthread_sigmask(SIG_SETMASK, &oldset, NULL); __CATCH_SYSTEM_ERROR__; }
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 124 Line 163
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
   #define DISABLE_SET_BUT_NOT_USED_WARNING(a) if (&a != ((&a) + 1));
   
 #define HEADER \  #define HEADER \
     int             __constante; \      int             __constante; \
     logical1        __evaluation; \      logical1        __evaluation; \
Line 139 Line 180
         (*rpl_arguments).instruction_valide = 'Y'; \          (*rpl_arguments).instruction_valide = 'Y'; \
         (*rpl_arguments).erreur = 0; \          (*rpl_arguments).erreur = 0; \
         __constante = 0; \          __constante = 0; \
         __evaluation = d_faux;          __evaluation = d_faux; \
           DISABLE_SET_BUT_NOT_USED_WARNING(__evaluation); \
           DISABLE_SET_BUT_NOT_USED_WARNING(__type); \
           DISABLE_SET_BUT_NOT_USED_WARNING(__indice_bit); \
           DISABLE_SET_BUT_NOT_USED_WARNING(__indice_bloc); \
           DISABLE_SET_BUT_NOT_USED_WARNING(__taille_bloc); \
           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 162 Line 209
         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;
   
   /*
   --------------------------------------------------------------------------------
     Destruction d'un objet
   --------------------------------------------------------------------------------
   */
   
   #define freeObject(object) \
       __CATCH_SYSTEM_ERROR__; \
       do { \
           if (object == NULL) \
               systemError("Nullified object"); \
           liberation(object); \
           object = NULL; \
       } while(0)
   
   /*
   --------------------------------------------------------------------------------
     Copie d'un objet
   --------------------------------------------------------------------------------
   */
   
   #define dupObject(object) \
       __CATCH_SYSTEM_ERROR__; \
       do { if (copie_objet(object, 'P') != object) \
           systemError("Memory allocation error"); } while(0)
   
   /*
   --------------------------------------------------------------------------------
     Déclaration des fonctions internes
   --------------------------------------------------------------------------------
   */
   
   #define CONCAT(a, b) __CONCAT(a, b)
   #define __CONCAT(a, b) a##b
   #define FIRST(...) FIRST_HELPER(__VA_ARGS__, throwaway)
   #define FIRST_HELPER(first, ...) first
   #define REST(...) REST_HELPER(NUM(__VA_ARGS__), __VA_ARGS__)
   #define REST_HELPER(qty, ...) REST_HELPER2(qty, __VA_ARGS__)
   #define REST_HELPER2(qty, ...) REST_HELPER_##qty(__VA_ARGS__)
   #define REST_HELPER_ONE(first)
   #define REST_HELPER_TWOORMORE(first, ...) , __VA_ARGS__
   #define NUM(...) \
           SELECT_10TH(__VA_ARGS__, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
           TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
   #define SELECT_10TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, ...) a10
   
   #define declareInternalFunction(type, ...) \
       type CONCAT(__internal_, FIRST(__VA_ARGS__)) \
               (struct_rpl_arguments *rpl_arguments REST(__VA_ARGS__)) { \
       type __internal_return; __internal_return = 0; int __type; \
       DISABLE_SET_BUT_NOT_USED_WARNING(__type);
   
   #define endInternalFunction return(__internal_return); }
   
   #define useInternalFunction(type, ...) \
       type CONCAT(__internal_, FIRST(__VA_ARGS__)) \
               (struct_rpl_arguments *rpl_arguments REST(__VA_ARGS__))
   
   #define callInternalFunction(...) \
       CONCAT(__internal_, FIRST(__VA_ARGS__))(rpl_arguments REST(__VA_ARGS__))
   
   /*
   --------------------------------------------------------------------------------
     Déclaration des fonctions C
   --------------------------------------------------------------------------------
   */
   
   #define declareCFunction(type, name, ...) \
           type name(__VA_ARGS__) { __RPL__ type __c_return;
   #define endCFunction return(__c_return); }
   
   #define useCFunction(type, name, ...) type name(__VA_ARGS__)
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 172 Line 293
 */  */
   
 #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);
   
 #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); \
     HEADER \      HEADER \
         declareHelpString(""); \          declareHelpString(""); \
         numberOfArguments(0); \          numberOfArguments(0); \
     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 242 Line 368
         return(tableau); \          return(tableau); \
     }      }
   
 #define endExternalFunction return; }  #define endExternalFunction leave; }
   
 #define callExternalFunction(function) { \  #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 271 Line 398
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define declareHelpString(h) { \  #define declareHelpString(h) do { \
     __presence_aide = d_vrai; \      __presence_aide = d_vrai; \
     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 { \  #define declareSymbolicConstant do { \
     numberOfArguments(0); \      numberOfArguments(0); \
     (*rpl_arguments).constante_symbolique = 'Y'; \      (*rpl_arguments).constante_symbolique = 'Y'; \
     __constante++; } while(0)      __constante++; } while(0)
   
 #define numberOfArguments(n) { \  #define numberOfArguments(n) do { \
     __presence_validation = d_vrai; \      __presence_validation = d_vrai; \
     if ((*rpl_arguments).test_instruction == 'Y') \      if ((*rpl_arguments).test_instruction == 'Y') \
     { \      { \
Line 313 Line 440
 */  */
   
 #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 336 Line 463
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define returnOnError(...) { \  #define returnOnError(...) do { \
     if ((*rpl_arguments).erreur != 0) \      if ((*rpl_arguments).erreur != 0) \
     { \      { \
         __VA_ARGS__; \          __VA_ARGS__; \
         return; \          return 0; \
     } } while(0)      } } while(0)
   
 #define systemError(message) { \  #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) { \  #define executionError(message) do { \
     (*rpl_arguments).erreur = __LINE__; \      (*rpl_arguments).erreur = __LINE__; \
     (*rpl_arguments).type_erreur = 'E'; \      (*rpl_arguments).type_erreur = 'E'; \
     (*rpl_arguments).message_erreur = (unsigned char *) message; } while(0)      (*rpl_arguments).message_erreur = (unsigned char *) message; } while(0)
   
   #define onSystemError(...) do { \
       if (((*rpl_arguments).erreur != 0) && \
               ((*rpl_arguments).type_erreur == 'S')) \
       { \
           blockSignals; \
               kill(getpid(), SIGTERM); \
           unblockSignals; \
           __VA_ARGS__; \
       } } 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 369 Line 508
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define pushOnStack(object) { \  #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, ...) { \  #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 417 Line 558
 */  */
   
 #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
   
 #define createSymbolicConstant(object, type, value) { \  #define createSymbolicConstant(object, type, value) do { \
     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 433 Line 574
     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 449 Line 591
         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) { \  #define createSymbolicComplexConstant(object, rp, ip) do { \
     __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 467 Line 612
     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 481 Line 627
     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
   
 #define setInteger(object, value) { \  #define setInteger(object, value) do { \
     ifIsInteger(object) \      ifIsInteger(object) \
     { \      { \
         if ((*object).nombre_occurrences > 1) \          if ((*object).nombre_occurrences > 1) \
Line 508 Line 656
 #define ifIsInteger(object) if (isInteger(object))  #define ifIsInteger(object) if (isInteger(object))
 #define elseIfIsInteger(object) } else ifIsInteger(object)  #define elseIfIsInteger(object) } else ifIsInteger(object)
   
 #define getInteger(object, value) { \  #define getInteger(object, value) do { \
     value = 0; \      value = 0; \
     ifIsInteger(object) value = (*((integer8 *) (*object).objet)); \      ifIsInteger(object) value = (*((integer8 *) (*object).objet)); \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define createIntegerObject(object) { \  #define createIntegerObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(INT)) == NULL) \      if ((object = allocation(INT)) == NULL) \
Line 522 Line 670
   
 // Real  // Real
   
 #define setReal(object, value) { \  #define setReal(object, value) do { \
     ifIsReal(object) \      ifIsReal(object) \
     { \      { \
         if ((*object).nombre_occurrences > 1) \          if ((*object).nombre_occurrences > 1) \
Line 543 Line 691
 #define ifIsReal(object) if (isReal(object))  #define ifIsReal(object) if (isReal(object))
 #define elseIfIsReal(object) } else ifIsReal(object)  #define elseIfIsReal(object) } else ifIsReal(object)
   
 #define getReal(object, value) { \  #define getReal(object, value) do { \
     value = 0; \      value = 0; \
     ifIsReal(object) value = (*((real8 *) (*object).objet)); \      ifIsReal(object) value = (*((real8 *) (*object).objet)); \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define createRealObject(object) { \  #define createRealObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(REL)) == NULL) \      if ((object = allocation(REL)) == NULL) \
Line 557 Line 705
   
 // Complex  // Complex
   
 #define setComplex(object, rp, ip) { \  #define setComplex(object, rp, ip) do { \
     typeof(rp) __rp = rp; \      typeof(rp) __rp = rp; \
     typeof(ip) __ip = ip; \      typeof(ip) __ip = ip; \
     ifIsComplex(object) \      ifIsComplex(object) \
Line 575 Line 723
     } \      } \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define setRealPartOfComplex(object, value) { \  #define setRealPartOfComplex(object, value) do { \
     if ((*object).nombre_occurrences > 1) \      if ((*object).nombre_occurrences > 1) \
     { \      { \
         struct_objet *__tmp_object; \          struct_objet *__tmp_object; \
Line 588 Line 736
             value; \              value; \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define setImaginaryPartOfComplex(object, value) { \  #define setImaginaryPartOfComplex(object, value) do { \
     if ((*object).nombre_occurrences > 1) \      if ((*object).nombre_occurrences > 1) \
     { \      { \
         struct_objet *__tmp_object; \          struct_objet *__tmp_object; \
Line 612 Line 760
 #define ifIsComplex(object) if (isComplex(object))  #define ifIsComplex(object) if (isComplex(object))
 #define elseIfIsComplex(object) } else ifIsComplex(object)  #define elseIfIsComplex(object) } else ifIsComplex(object)
   
 #define getComplex(object, value) { \  #define getComplex(object, value) do { \
     value.partie_reelle = 0; \      value.partie_reelle = 0; \
     value.partie_imaginaire = 0; \      value.partie_imaginaire = 0; \
     ifIsComplex(object) value = (*((complex16 *) (*object).objet)); \      ifIsComplex(object) value = (*((complex16 *) (*object).objet)); \
     else systemError("Not a complex"); } while(0)      else systemError("Not a complex"); } while(0)
   
 #define createComplexObject(object) { \  #define createComplexObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(CPL)) == NULL) \      if ((object = allocation(CPL)) == NULL) \
Line 627 Line 775
   
 // Generalized vectors  // Generalized vectors
   
 #define createVectorObject(object, size, otype, structure, cat) { \  #define createVectorObject(object, size, otype, structure, cat) do { \
     integer8 i; \      integer8 i; \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
Line 660 Line 808
   
 // Integer vector  // Integer vector
   
 #define setIntegerIntoVector(object, value, position) { \  #define setIntegerIntoVector(object, value, position) do { \
     typeof(position) __position = position; \      typeof(position) __position = position; \
     ifIsIntegerVector(object) \      ifIsIntegerVector(object) \
     { \      { \
Line 688 Line 836
 #define ifIsIntegerVector(object) if (isIntegerVector(object))  #define ifIsIntegerVector(object) if (isIntegerVector(object))
 #define elseIfIsIntegerVector(object) } else ifIsIntegerVector(object)  #define elseIfIsIntegerVector(object) } else ifIsIntegerVector(object)
   
 #define getIntegerFromVector(object, value, position) { \  #define getIntegerFromVector(object, value, position) do { \
     typeof(position) __position = position; \      typeof(position) __position = position; \
     value = 0; \      value = 0; \
     ifIsIntegerVector(object) \      ifIsIntegerVector(object) \
Line 708 Line 856
   
 // Real vector  // Real vector
   
 #define setRealIntoVector(object, value, position) { \  #define setRealIntoVector(object, value, position) do { \
     typeof(position) __position = position; \      typeof(position) __position = position; \
     ifIsRealVector(object) \      ifIsRealVector(object) \
     { \      { \
Line 736 Line 884
 #define ifIsRealVector(object) if (isRealVector(object))  #define ifIsRealVector(object) if (isRealVector(object))
 #define elseIfIsRealVector(object) } else ifIsRealVector(object)  #define elseIfIsRealVector(object) } else ifIsRealVector(object)
   
 #define getRealFromVector(object, value, position) { \  #define getRealFromVector(object, value, position) do { \
     typeof(position) __position = position; \      typeof(position) __position = position; \
     value = 0; \      value = 0; \
     ifIsRealVector(object) \      ifIsRealVector(object) \
Line 765 Line 913
   
 // Binary integer  // Binary integer
   
 #define setBinaryInteger(object, value) { \  #define setBinaryInteger(object, value) do { \
     ifIsBinaryInteger(object) \      ifIsBinaryInteger(object) \
     { \      { \
         if ((*object).nombre_occurrences > 1) \          if ((*object).nombre_occurrences > 1) \
Line 786 Line 934
 #define ifIsBinaryInteger(object) if (isBinaryInteger(object))  #define ifIsBinaryInteger(object) if (isBinaryInteger(object))
 #define elseIfIsBinaryInteger(object) } else ifIsBinaryInteger(object)  #define elseIfIsBinaryInteger(object) } else ifIsBinaryInteger(object)
   
 #define getBinaryInteger(object, value) { \  #define getBinaryInteger(object, value) do { \
     value = 0; \      value = 0; \
     ifIsBinaryInteger(object) value = (*((integer8 *) (*object).objet)); \      ifIsBinaryInteger(object) value = (*((integer8 *) (*object).objet)); \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define createBinaryIntegerObject(object) { \  #define createBinaryIntegerObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(BIN)) == NULL) \      if ((object = allocation(BIN)) == NULL) \
Line 806 Line 954
 #define ifIsName(object) if (isName(object))  #define ifIsName(object) if (isName(object))
 #define elseIfIsName(object)  } else if (isName(object))  #define elseIfIsName(object)  } else if (isName(object))
   
 #define setName(object, value) { \  #define setName(object, value) do { \
     ifIsName(object) \      ifIsName(object) \
     { \      { \
         if ((*object).nombre_occurrences > 1) \          if ((*object).nombre_occurrences > 1) \
Line 827 Line 975
     } \      } \
     else executionError("Type mistmatch error"); } while(0)      else executionError("Type mistmatch error"); } while(0)
   
 #define createNameObject(object) { \  #define createNameObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(NOM)) == NULL) \      if ((object = allocation(NOM)) == NULL) \
Line 846 Line 994
 #define ifIsString(object) if (isString(object))  #define ifIsString(object) if (isString(object))
 #define elseIfIsString(object) else if (isString(objet))  #define elseIfIsString(object) else if (isString(objet))
   
 #define setString(object, string) { \  #define setString(object, string) do { \
     ifIsString(object) \      ifIsString(object) \
     { \      { \
         if ((*object).nombre_occurrences > 1) \          if (string == NULL) executionError("Nullified string"); else \
         { \          { \
             struct_objet *__tmp_object; \              if ((*object).nombre_occurrences > 1) \
             if ((__tmp_object = copie_objet(object, 'O')) == NULL) \              { \
                   struct_objet *__tmp_object; \
                   if ((__tmp_object = copie_objet(object, 'O')) == NULL) \
                       systemError("Memory allocation error"); \
                   liberation(object); \
                   object = __tmp_object; \
               } \
               free((unsigned char *) (*object).objet); \
               if (((*object).objet = malloc((strlen(string) + 1) * \
                       sizeof(unsigned char))) == NULL) \
                 systemError("Memory allocation error"); \                  systemError("Memory allocation error"); \
             liberation(object); \              strcpy((char *) (*object).objet, string); \
             object = __tmp_object; \  
         } \          } \
         free((unsigned char *) (*object).objet); \  
         if (((*object).objet = malloc((strlen(string) + 1) * \  
                 sizeof(unsigned char))) == NULL) \  
             systemError("Memory allocation error"); \  
         strcpy((char *) (*object).objet, string); \  
     } \      } \
     else executionError("Type mistmatch error"); } while(0)      else executionError("Type mistmatch error"); } while(0)
   
 #define getString(object, string) { \  #define getString(object, string) do { \
     string = NULL; \      string = NULL; \
     ifIsString(object) string = (char *) (*object).objet; \      ifIsString(object) string = (char *) (*object).objet; \
     else executionError("Type mismatch error"); } while(0)      else executionError("Type mismatch error"); } while(0)
   
 #define createStringObject(object) { \  #define createStringObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(CHN)) == NULL) \      if ((object = allocation(CHN)) == NULL) \
Line 887 Line 1038
 #define ifIsList(object) if (isList(object))  #define ifIsList(object) if (isList(object))
 #define elseIfIsList(object) else if (isList(object))  #define elseIfIsList(object) else if (isList(object))
   
 #define createListObject(object) { \  #define createListObject(object) do { \
     if (object != NULL) \      if (object != NULL) \
         systemError("Reallocated object"); \          systemError("Reallocated object"); \
     if ((object = allocation(LST)) == NULL) \      if ((object = allocation(LST)) == NULL) \
         systemError("Memory allocation error"); \          systemError("Memory allocation error"); \
     (*object).objet = NULL; } while(0)      (*object).objet = NULL; } while(0)
   
 #define addObjectToList(list, object) { \  #define addObjectToList(list, object) do { \
     ifIsList(list) \      ifIsList(list) \
     { \      { \
         struct_objet *__tmp_object; \          struct_objet *__tmp_object; \
Line 927 Line 1078
     } \      } \
     else executionError("Type mistmatch error"); } while(0)      else executionError("Type mistmatch error"); } while(0)
   
 #define insertObjectIntoList(list, object) { \  #define insertObjectIntoList(list, object) do { \
     ifIsList(list) \      ifIsList(list) \
     { \      { \
         struct_objet *__tmp_object; \          struct_objet *__tmp_object; \
Line 957 Line 1108
     } \      } \
     else executionError("Type mistmatch error"); } while(0)      else executionError("Type mistmatch error"); } while(0)
   
 #define removeObjectFromList(list, object) \  #define removeObjectFromList(list, object) do { \
     ifIsList(list) \      ifIsList(list) \
     { \      { \
         if ((*object).objet == NULL) \          if ((*list).objet != NULL) \
         { \          { \
             struct_objet *__tmp_object; \              struct_liste_chainee    *__current; \
             if ((__tmp_object = copie_objet(list, 'N')) == NULL) \              struct_liste_chainee    *__previous; \
                 systemError("Memory allocation error"); \              __current = (*list).objet; \
             liberation(object); \              __previous = NULL; \
             object = __tmp_object; \              if ((*__current).donnee == object) \
             \              { \
             \                  (*list).objet = (*__current).suivant; \
             \              } \
             \              else \
         } \              { \
                   while(__current != NULL) \
                   { \
                       if ((*__current).donnee == object) \
                       { \
                           (*__previous).suivant = (*__current).suivant; \
                           break; \
                       } \
                       __previous = __current; \
                       __current = (*__current).suivant; \
                   } \
               } \
               liberation((*__current).donnee); \
               free(__current); \
           } \
     } \      } \
     else executionError("Type mistmatch error"); } while(0)      else executionError("Type mistmatch error"); } while(0)
   
Line 981 Line 1146
   
 #define getListFromList(list, position1, position2, object)  #define getListFromList(list, position1, position2, object)
   
 #define listLength(list, length) { \  #define listLength(list, length) do { \
     if (list == NULL) executionError("Nullified object"); \      if (list == NULL) executionError("Nullified object"); \
     if ((*list).type != LST) \      if ((*list).type != LST) \
             executionError("Type mistmatch error"); \              executionError("Type mistmatch error"); \
Line 996 Line 1161
         } \          } \
     } } while(0)      } } while(0)
   
   
 /*  
 --------------------------------------------------------------------------------  
   Destruction d'un objet  
 --------------------------------------------------------------------------------  
 */  
   
 #define freeObject(object) \  
     { \  
         if (object == NULL) \  
             systemError("Nullified object"); \  
         liberation(object); \  
         object = NULL; \  
     } while(0)  
   
 /*  
 --------------------------------------------------------------------------------  
   Copie d'un objet  
 --------------------------------------------------------------------------------  
 */  
   
 #define dupObject(object) \  
     { if (copie_objet(object, 'P') != object) \  
         systemError("Memory allocation error"); } while(0)  
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Allocation mémoire    Allocation mémoire
Line 1037 Line 1177
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Récupération des interruptions et des signaux
   --------------------------------------------------------------------------------
   */
   
   #define pollSignalsAndInterrupts() \
       __CATCH_SYSTEM_ERROR__; \
       do { scrutation_injection((*rpl_arguments).s_etat_processus); } while(0)
   
   /*
   --------------------------------------------------------------------------------
   Exécution d'une fonction intrinsèque    Exécution d'une fonction intrinsèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define intrinsic(function) { \  #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); \
Removed from v.1.28  
changed lines
  Added in v.1.52

CVSweb interface <joel.bertrand@systella.fr>