Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 5558 in orxonox.OLD for branches/world_entities/src/lib/shell


Ignore:
Timestamp:
Nov 13, 2005, 3:10:49 PM (19 years ago)
Author:
bensch
Message:

orxonox/branches/world_entities: merged the Trunk to the world_entities branche
merged with command
svn merge -r5516:HEAD ../trunk/ world_entities/
no conflicts

Location:
branches/world_entities/src/lib/shell
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • branches/world_entities/src/lib/shell/Makefile.in

    r5527 r5558  
    209209          esac; \
    210210        done; \
    211         echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu  src/lib/shell/Makefile'; \
     211        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  src/lib/shell/Makefile'; \
    212212        cd $(top_srcdir) && \
    213           $(AUTOMAKE) --gnu  src/lib/shell/Makefile
     213          $(AUTOMAKE) --foreign  src/lib/shell/Makefile
    214214.PRECIOUS: Makefile
    215215Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

  • branches/world_entities/src/lib/shell/shell_command.cc

    r5374 r5558  
    259259tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
    260260
     261
     262
     263
     264
     265
     266
     267
     268
     269
     270////////////////////////
     271// SHELL COMMAND BASE //
     272////////////////////////
    261273/**
    262274 * constructs and registers a new Command
    … …  
    264276 * @param className the name of the class to apply this command to
    265277 * @param paramCount the count of parameters this command takes
    266  * @return self
    267278 */
    268279ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)
    … …  
    282293  this->paramCount = paramCount;
    283294  this->parameters = new unsigned int[paramCount];
     295  this->defaultValue = new MultiType[paramCount];
    284296
    285297  va_list parameterList;
    286298  va_start(parameterList, paramCount);
    287299
     300  // What Parameters we have got
    288301  for (unsigned int i = 0; i < paramCount; i++)
    289   {
    290302    this->parameters[i] = va_arg(parameterList, int);
    291 
    292     switch (this->parameters[i])
    293     {
    294       case ParameterBool:
    295         this->defaultBools[i] = va_arg(parameterList, int);
    296         break;
    297       case ParameterChar:
    298         this->defaultStrings[i] = new char[2];
    299         sprintf(this->defaultStrings[0], "%c",  va_arg(parameterList, int));
    300         break;
    301       case ParameterString:
    302         this->defaultStrings[i] = va_arg(parameterList, char*);
    303         break;
    304       case ParameterInt:
    305         this->defaultInts[i] = va_arg(parameterList, int);
    306         break;
    307       case ParameterUInt:
    308         this->defaultInts[i] = va_arg(parameterList, unsigned int);
    309         break;
    310       case ParameterFloat:
    311         this->defaultFloats[i] = va_arg(parameterList, double);
    312         break;
    313       case ParameterLong:
    314         this->defaultInts[i] = va_arg(parameterList, long);
    315         break;
    316       default:
    317         break;
    318     }
    319   }
    320303}
    321304
    322305/**
    323306 * deconstructs a ShellCommand
    324  * @return
    325307 */
    326308ShellCommandBase::~ShellCommandBase()
    327309{
    328310  delete[] this->parameters;
     311  delete[] this->defaultValue;
    329312  if (this->alias != NULL && ShellCommandClass::aliasList != NULL)
    330313  {
    … …  
    417400 * @return true on success, false otherwise.
    418401 */
    419 #include  "stdlibincl.h"
    420402bool ShellCommandBase::execute(const char* executionString)
    421403{
    … …  
    598580  for (unsigned int i = 0; i < count; i++)
    599581  {
     582
     583
    600584    switch (this->parameters[i])
    601585    {
    602586      case ParameterBool:
    603         this->defaultBools[i] = va_arg(defaultList, int);
     587        this->defaultValue[i].setInt(va_arg(defaultList, int));
    604588        break;
    605589      case ParameterChar:
    606         this->defaultStrings[i] = new char[2];
    607         sprintf(this->defaultStrings[0], "%c",  va_arg(defaultList, int));
     590        this->defaultValue[i].setChar((char)va_arg(defaultList, int));
    608591        break;
    609592      case ParameterString:
    610         this->defaultStrings[i] = va_arg(defaultList, char*);
     593        this->defaultValue[i].setString(va_arg(defaultList, char*));
    611594        break;
    612595      case ParameterInt:
    613         this->defaultInts[i] = va_arg(defaultList, int);
     596        this->defaultValue[i].setInt(va_arg(defaultList, int));
    614597        break;
    615598      case ParameterUInt:
    616         this->defaultInts[i] = va_arg(defaultList, unsigned int);
     599        this->defaultValue[i].setInt((int)va_arg(defaultList, unsigned int));
    617600        break;
    618601      case ParameterFloat:
    619         this->defaultFloats[i] = va_arg(defaultList, double);
     602        this->defaultValue[i].setFloat(va_arg(defaultList, double));
    620603        break;
    621604      case ParameterLong:
    622         this->defaultInts[i] = va_arg(defaultList, long);
     605        this->defaultValue[i].setInt((int) va_arg(defaultList, long));
    623606        break;
    624607      default:
    … …  
    626609    }
    627610  }
    628 
    629611  return this;
    630612}

  • branches/world_entities/src/lib/shell/shell_command.h

    r5391 r5558  
    1010
    1111#include "helper_functions.h"
     12#include "multi_type.h"
    1213#include "substring.h"
    1314#include "functor_list.h"
    … …  
    133134    unsigned int                     paramCount;                           //!< the count of parameters.
    134135    unsigned int*                    parameters;                           //!< Parameters the function of this Command takes.
    135     char*                            defaultStrings[FUNCTOR_MAX_ARGUMENTS];//!< A list of default Strings stored.
    136     int                              defaultInts[FUNCTOR_MAX_ARGUMENTS];   //!< A list of default Ints stored.
    137     float                            defaultFloats[FUNCTOR_MAX_ARGUMENTS]; //!< A list of default Floats stored.
    138     bool                             defaultBools[FUNCTOR_MAX_ARGUMENTS];  //!< A list of default Bools stored.
    139 
     136    MultiType*                       defaultValue;                         //!< Default Values.
    140137
    141138  private:
    … …  
    153150/////////////////////////////////
    154151//! where to chek for default BOOL values
    155 #define   l_BOOL_DEFGRAB(i)         this->defaultBools[i]
     152#define   l_BOOL_DEFGRAB(i)         this->defaultValue[i].getBool()
    156153//! where to chek for default INT values
    157 #define   l_INT_DEFGRAB(i)          this->defaultInts[i]
     154#define   l_INT_DEFGRAB(i)          this->defaultValue[i].getInt()
    158155//! where to chek for default UINT values
    159 #define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultInts[i]
     156#define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultValue[i].getInt()
    160157//! where to chek for default LONG values
    161 #define   l_LONG_DEFGRAB(i)         (long)this->defaultInts[i]
     158#define   l_LONG_DEFGRAB(i)         (long)this->defaultValue[i].getInt()
    162159//! where to chek for default FLOAT values
    163 #define   l_FLOAT_DEFGRAB(i)        this->defaultFloats[i]
     160#define   l_FLOAT_DEFGRAB(i)        this->defaultValue[i].getFloat()
    164161//! where to chek for default STRING values
    165 #define   l_STRING_DEFGRAB(i)       this->defaultStrings[i]
     162#define   l_STRING_DEFGRAB(i)       this->defaultValue[i].getString()
    166163
    167164//////////////////////////
    … …  
    183180//! registers a command with 1 parameter
    184181#define ShellCommandRegister1(t1) \
    185   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
     182  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
    186183  { \
    187184    if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \
    188185      return NULL; \
    189     return new SHELLCOMMAND<T>(commandName, className, function, d1); \
     186    return new SHELLCOMMAND<T>(commandName, className, function); \
    190187  }
    191188
    192189//! registers a command with 2 parameters
    193190#define ShellCommandRegister2(t1,t2) \
    194   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
     191  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
    195192  { \
    196193    if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \
    197194      return NULL; \
    198     return new SHELLCOMMAND<T>(commandName, className, function, d1, d2); \
     195    return new SHELLCOMMAND<T>(commandName, className, function); \
    199196  }
    200197
    201198//! registers a command with 3 parameters
    202199#define ShellCommandRegister3(t1,t2,t3) \
    203   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
     200  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
    204201  { \
    205202    if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \
    206203      return NULL; \
    207     return new SHELLCOMMAND<T>(commandName, className, function, d1, d2, d3); \
     204    return new SHELLCOMMAND<T>(commandName, className, function); \
    208205  }
    209206
    210207//! registers a command with 4 parameters
    211208#define ShellCommandRegister4(t1,t2,t3,t4) \
    212   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
     209  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
    213210  { \
    214211    if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \
    215212      return NULL; \
    216     return new SHELLCOMMAND<T>(commandName, className, function, d1, d2, d3, d4); \
     213    return new SHELLCOMMAND<T>(commandName, className, function); \
    217214  }
    218215
    219216//! registers a command with 5 parameters
    220217#define ShellCommandRegister5(t1,t2,t3,t4,t5) \
    221   static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT, t5##_TYPE d5 = t5##_DEFAULT) \
     218  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
    222219  { \
    223220    if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
    224221      return NULL; \
    225     return new ShellCommand<T>(commandName, className, function, d1, d2, d3, d4, d5); \
    226   }
     222    return new ShellCommand<T>(commandName, className, function); \
     223  }
     224
     225///////////////////////
     226// FUNCTION POINTERS //
     227///////////////////////
     228#define ShellCommandFunctionPoiter0() \
     229  void SHELLCOMMANDINCLASS(*functionPointer_0)();
     230
     231#define ShellCommandFunctionPoiter1(t1) \
     232  void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE);
     233
     234#define ShellCommandFunctionPoiter2(t1, t2) \
     235  void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE);
     236
     237
     238#define ShellCommandFunctionPoiter3(t1, t2, t3) \
     239  void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE);
     240
     241#define ShellCommandFunctionPoiter4(t1, t2, t3, t4) \
     242  void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE);
     243
     244
     245#define ShellCommandFunctionPoiter5(t1, t2, t3, t4, t5) \
     246  void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
     247
    227248
    228249//////////////////
    … …  
    231252//! creates a command that takes no parameters
    232253#define ShellCommandConstructor0() \
    233   void SHELLCOMMANDINCLASS(*functionPointer_0)(); \
    234254  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
    235255  : ShellCommandBase(commandName, className, 0) \
    236256  { \
    237257    this->functorType = SHELLCOMMANDTYPE; \
    238     this->functionPointer_0 = function; \
     258    this->fp.functionPointer_0 = function; \
    239259  }
    240260
    241261//! creates a command that takes one parameter
    242262#define ShellCommandConstructor1(t1) \
    243   void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE); \
    244   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1) \
    245   : ShellCommandBase(commandName, className, 1, t1##_PARAM, d1) \
    246   { \
    247     this->functorType = SHELLCOMMANDTYPE; \
    248     this->functionPointer_1_##t1 = function; \
     263  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
     264  : ShellCommandBase(commandName, className, 1, t1##_PARAM) \
     265  { \
     266    this->functorType = SHELLCOMMANDTYPE; \
     267    this->fp.functionPointer_1_##t1 = function; \
    249268  }
    250269
    251270//! creates a command that takes two parameters
    252271#define ShellCommandConstructor2(t1,t2) \
    253   void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); \
    254   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1, t2##_TYPE d2) \
    255   : ShellCommandBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
    256   { \
    257     this->functorType = SHELLCOMMANDTYPE; \
    258     this->functionPointer_2_##t1##_##t2 = function; \
     272  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
     273  : ShellCommandBase(commandName, className, 2, t1##_PARAM, t2##_PARAM) \
     274  { \
     275    this->functorType = SHELLCOMMANDTYPE; \
     276    this->fp.functionPointer_2_##t1##_##t2 = function; \
    259277  }
    260278
    261279//! creates a command that takes three parameter
    262280#define ShellCommandConstructor3(t1,t2,t3) \
    263   void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); \
    264   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3) \
    265   : ShellCommandBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
    266   { \
    267     this->functorType = SHELLCOMMANDTYPE; \
    268     this->functionPointer_3_##t1##_##t2##_##t3 = function; \
     281  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
     282  : ShellCommandBase(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \
     283  { \
     284    this->functorType = SHELLCOMMANDTYPE; \
     285    this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \
    269286  }
    270287
    271288//! creates a command that takes four parameter
    272289#define ShellCommandConstructor4(t1,t2,t3,t4) \
    273   void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); \
    274   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4) \
    275   : ShellCommandBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
    276   { \
    277     this->functorType = SHELLCOMMANDTYPE; \
    278     this->functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \
     290  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
     291  : ShellCommandBase(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \
     292  { \
     293    this->functorType = SHELLCOMMANDTYPE; \
     294    this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \
    279295  }
    280296
    281297//! creates a command that takes five parameter
    282298#define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
    283   void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
    284   SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4, t5##_TYPE d5) \
    285   : ShellCommandBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
    286   { \
    287     this->functorType = SHELLCOMMANDTYPE; \
    288     this->functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \
     299  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
     300  : ShellCommandBase(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \
     301  { \
     302    this->functorType = SHELLCOMMANDTYPE; \
     303    this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \
    289304  }
    290305
    … …  
    337352#undef SHELLCOMMANDEXECUTER
    338353#endif
    339 #define SHELLCOMMANDEXECUTER(nameExt)      (dynamic_cast<T*>(object)->*functionPointer##nameExt)
     354#define SHELLCOMMANDEXECUTER(nameExt)      (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt))
    340355#ifdef SHELLCOMMANDINCLASS
    341356#undef SHELLCOMMANDINCLASS
    … …  
    353368
    354369  private:
     370//! FUNCTOR_LIST is the List of FunctionPointers
     371    union FunctionPointers {
     372#define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
     373#include "functor_list.h"
     374#undef FUNCTOR_LIST
     375    } fp;
     376
    355377//! FUNCTOR_LIST is the List of CommandConstructors
    356378#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
    … …  
    382404#undef SHELLCOMMANDEXECUTER
    383405#endif
    384 #define SHELLCOMMANDEXECUTER(nameExt)     functionPointer##nameExt
     406#define SHELLCOMMANDEXECUTER(nameExt)     fp.functionPointer##nameExt
    385407#ifdef SHELLCOMMANDINCLASS
    386408#undef SHELLCOMMANDINCLASS
    … …  
    398420
    399421  private:
     422//! FUNCTOR_LIST is the List of FunctionPointers
     423    union FunctionPointers {
     424#define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
     425#include "functor_list.h"
     426#undef FUNCTOR_LIST
     427    } fp;
     428
    400429//! FUNCTOR_LIST is the List of CommandConstructors
    401430#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
Note: See TracChangeset for help on using the changeset viewer.