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

Diff for /rpl/src/rplexternals.h between versions 1.45 and 1.46

version 1.45, 2013/03/27 15:47:36 version 1.46, 2013/03/28 16:15:09
Line 56 Line 56
 #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) do { \
     typeof(list) __list = list; \      typeof(list) __list = list; \
     daisyChain = NULL; \      daisyChain = NULL; \
     ifIsList(__list) { daisyChain = (*__list).objet; } \      ifIsList(__list) { daisyChain = (*__list).objet; } \
Line 79 Line 79
     (__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) do { ptr = NULL; } while(0)
 #define nullified(ptr) ((ptr) == NULL)  #define nullified(ptr) ((ptr) == NULL)
   
 #define postIncr(x) (x++)  #define postIncr(x) (x++)
Line 118 Line 118
   
 #define beginGroup {  #define beginGroup {
 #define endGroup }  #define endGroup }
 #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 test_arret((*rpl_arguments).s_etat_processus)
   
Line 195 Line 195
 */  */
   
 #define freeObject(object) \  #define freeObject(object) \
     { \      do { \
         if (object == NULL) \          if (object == NULL) \
             systemError("Nullified object"); \              systemError("Nullified object"); \
         liberation(object); \          liberation(object); \
Line 209 Line 209
 */  */
   
 #define dupObject(object) \  #define dupObject(object) \
     { 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 310 Line 310
   
 #define endExternalFunction return; }  #define endExternalFunction return; }
   
 #define callExternalFunction(function) { \  #define callExternalFunction(function) 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 337 Line 337
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #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') \
     { \      { \
Line 345 Line 345
         return; \          return; \
     } } 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 402 Line 402
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define returnOnError(...) { \  #define returnOnError(...) do { \
     if ((*rpl_arguments).erreur != 0) \      if ((*rpl_arguments).erreur != 0) \
     { \      { \
         __VA_ARGS__; \          __VA_ARGS__; \
         return; \          return; \
     } } 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; } 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(...) { \  #define onSystemError(...) do { \
     if ((*rpl_arguments).erreur != 0) \      if ((*rpl_arguments).erreur != 0) \
     { \      { \
         __VA_ARGS__; \          __VA_ARGS__; \
Line 444 Line 444
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define pushOnStack(object) { \  #define pushOnStack(object) do { \
     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 { \
     (*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 498 Line 498
   
 //  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 534 Line 534
     } \      } \
     __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 562 Line 562
   
 // 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 583 Line 583
 #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 597 Line 597
   
 // 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 618 Line 618
 #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 632 Line 632
   
 // 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 650 Line 650
     } \      } \
     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 663 Line 663
             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 687 Line 687
 #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 702 Line 702
   
 // 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 735 Line 735
   
 // 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 763 Line 763
 #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 783 Line 783
   
 // 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 811 Line 811
 #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 840 Line 840
   
 // 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 861 Line 861
 #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 881 Line 881
 #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 902 Line 902
     } \      } \
     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 921 Line 921
 #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 ((*object).nombre_occurrences > 1) \
Line 940 Line 940
     } \      } \
     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 962 Line 962
 #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 1002 Line 1002
     } \      } \
     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 1032 Line 1032
     } \      } \
     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 ((*object).objet == NULL) \
Line 1056 Line 1056
   
 #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 1092 Line 1092
 */  */
   
 #define pollSignalsAndInterrupts() \  #define pollSignalsAndInterrupts() \
     { scrutation_injection((*rpl_arguments).s_etat_processus); } while(0)      do { scrutation_injection((*rpl_arguments).s_etat_processus); } while(0)
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1100 Line 1100
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define intrinsic(function) { \  #define intrinsic(function) do { \
     int __status; \      int __status; \
     __status = wrapper_instruction_intrinseque( \      __status = wrapper_instruction_intrinseque( \
             instruction_##function, rpl_arguments); \              instruction_##function, rpl_arguments); \
Removed from v.1.45  
changed lines
  Added in v.1.46

CVSweb interface <joel.bertrand@systella.fr>