Index: /trunk/src/lib/shell/shell_command.cc
===================================================================
--- /trunk/src/lib/shell/shell_command.cc	(revision 5635)
+++ /trunk/src/lib/shell/shell_command.cc	(revision 5636)
@@ -40,5 +40,5 @@
   this->className = className;
   this->classID = CL_NULL;
-  this->commandList = new tList<ShellCommandBase>;
+  this->commandList = new tList<ShellCommand>;
 
   ShellCommandClass::commandClassList->add(this);
@@ -50,6 +50,6 @@
 ShellCommandClass::~ShellCommandClass()
 {
-  tIterator<ShellCommandBase>* iterator = this->commandList->getIterator();
-  ShellCommandBase* elem = iterator->firstElement();
+  tIterator<ShellCommand>* iterator = this->commandList->getIterator();
+  ShellCommand* elem = iterator->firstElement();
   while(elem != NULL)
   {
@@ -78,6 +78,6 @@
     if (!strcmp (elem->getName(), className))
     {
-      tIterator<ShellCommandBase>* itFkt = elem->commandList->getIterator();
-      ShellCommandBase* command = itFkt->firstElement();
+      tIterator<ShellCommand>* itFkt = elem->commandList->getIterator();
+      ShellCommand* command = itFkt->firstElement();
       while (command != NULL)
       {
@@ -120,40 +120,71 @@
 void ShellCommandClass::unregisterAllCommands()
 {
-  // unregister all commands
+  if (ShellCommandClass::commandClassList != NULL)
+  {
+    // unregister all commands
+    tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
+    ShellCommandClass* elem = iterator->firstElement();
+    while(elem != NULL)
+    {
+      delete elem;
+
+      elem = iterator->nextElement();
+    }
+    delete iterator;
+
+    delete ShellCommandClass::commandClassList;
+    ShellCommandClass::commandClassList = NULL;
+  }
+
+  // unregister all aliases (there should be nothing to do here :))
+  if (ShellCommandClass::aliasList != NULL)
+  {
+    tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
+    ShellCommandAlias* elemAL = itAL->firstElement();
+    while(elemAL != NULL)
+    {
+      delete elemAL;
+      elemAL = itAL->nextElement();
+    }
+    delete itAL;
+    delete ShellCommandClass::aliasList;
+    ShellCommandClass::aliasList = NULL;
+  }
+}
+
+/**
+ * checks if a Class is already registered to the Commands' class-stack
+ * @param className the Name of the Class to check for
+ * @returns the CommandClass if found, NULL otherwise
+ */
+const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
+{
+  if (ShellCommandClass::commandClassList == NULL)
+    initCommandClassList();
+
   tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
   ShellCommandClass* elem = iterator->firstElement();
   while(elem != NULL)
   {
-    delete elem;
-
+    if (!strcmp(className, elem->className))
+    {
+      if (elem->classID == CL_NULL)
+        elem->classID = ClassList::StringToID(className);
+
+      delete iterator;
+      return elem;
+    }
     elem = iterator->nextElement();
   }
   delete iterator;
-
-  delete ShellCommandClass::commandClassList;
-  ShellCommandClass::commandClassList = NULL;
-
-  // unregister all aliases (there should be nothing to do here :))
-  if (ShellCommandClass::aliasList != NULL)
-  {
-    tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
-    ShellCommandAlias* elemAL = itAL->firstElement();
-    while(elemAL != NULL)
-    {
-      delete elemAL;
-      elemAL = itAL->nextElement();
-    }
-    delete itAL;
-    delete ShellCommandClass::aliasList;
-    ShellCommandClass::aliasList = NULL;
-  }
-}
-
-/**
- * checks if a Class is already registered to the Commands' class-stack
- * @param className the Name of the Class to check for
- * @returns the CommandClass if found, NULL otherwise
- */
-const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
+  return NULL;
+}
+
+/**
+ * searches for a CommandClass
+ * @param className the name of the CommandClass
+ * @returns the CommandClass if found, or a new CommandClass if not
+ */
+ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -166,7 +197,4 @@
     if (!strcmp(className, elem->className))
     {
-      if (elem->classID == CL_NULL)
-        elem->classID = ClassList::StringToID(className);
-
       delete iterator;
       return elem;
@@ -175,41 +203,16 @@
   }
   delete iterator;
-  return NULL;
-}
-
-/**
- * searches for a CommandClass
- * @param className the name of the CommandClass
- * @returns the CommandClass if found, or a new CommandClass if not
- */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+  return new ShellCommandClass(className);
+}
+
+/**
+ * initializes the CommandList (if it is NULL)
+ */
+void ShellCommandClass::initCommandClassList()
 {
   if (ShellCommandClass::commandClassList == NULL)
-    initCommandClassList();
-
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp(className, elem->className))
-    {
-      delete iterator;
-      return elem;
-    }
-    elem = iterator->nextElement();
-  }
-  delete iterator;
-  return new ShellCommandClass(className);
-}
-
-/**
- * initializes the CommandList (if it is NULL)
- */
-void ShellCommandClass::initCommandClassList()
-{
-  if (ShellCommandClass::commandClassList == NULL)
   {
     ShellCommandClass::commandClassList = new tList<ShellCommandClass>;
-    ShellCommandStatic<ShellCommandBase>::registerCommand("debug", "ShellCommand", ShellCommandBase::debug);
+    ShellCommand::registerCommand("debug", "ShellCommand", new ExecutorStatic<ShellCommand>(ShellCommand::debug));
   }
 }
@@ -228,11 +231,11 @@
       {
         PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-        tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
-        const ShellCommandBase* elem = iterator->firstElement();
+        tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
+        const ShellCommand* elem = iterator->firstElement();
         while(elem != NULL)
         {
           PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
           for (unsigned int i = 0; i< elem->paramCount; i++)
-            PRINT(0)("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
+            PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));
           if (elem->description != NULL)
             PRINT(0)("- %s", elem->description);
@@ -277,5 +280,5 @@
  * @param paramCount the count of parameters this command takes
  */
-ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)
+ShellCommand::ShellCommand(const char* commandName, const char* className, unsigned int paramCount, ...)
 {
   this->setClassID(CL_SHELL_COMMAND, "ShellCommand");
@@ -306,5 +309,5 @@
  * deconstructs a ShellCommand
  */
-ShellCommandBase::~ShellCommandBase()
+ShellCommand::~ShellCommand()
 {
   delete[] this->parameters;
@@ -318,9 +321,21 @@
 
 /**
+ * registers a new ShellCommand
+ */
+ShellCommand* ShellCommand::registerCommand(const char* commandName, const char* className, Executor* executor)
+{
+  return NULL;
+
+}
+
+
+
+
+/**
  * unregister an existing commandName
  * @param className the name of the Class the command belongs to.
  * @param commandName the name of the command itself
  */
-void ShellCommandBase::unregisterCommand(const char* commandName, const char* className)
+void ShellCommand::unregisterCommand(const char* commandName, const char* className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -331,6 +346,6 @@
  if (checkClass != NULL)
   {
-    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
-    ShellCommandBase* elem = iterator->firstElement();
+    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
+    ShellCommand* elem = iterator->firstElement();
     while(elem != NULL)
     {
@@ -363,5 +378,5 @@
  * This is checked in the registerCommand-function.
  */
-bool ShellCommandBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
+bool ShellCommand::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -374,6 +389,6 @@
   if (checkClass != NULL)
   {
-    tIterator<ShellCommandBase>* iterator = checkClass->commandList->getIterator();
-    ShellCommandBase* elem = iterator->firstElement();
+    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
+    ShellCommand* elem = iterator->firstElement();
     while(elem != NULL)
    {
@@ -400,5 +415,5 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommandBase::execute(const char* executionString)
+bool ShellCommand::execute(const char* executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -489,6 +504,6 @@
       if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
       {
-        tIterator<ShellCommandBase>* itCMD = commandClass->commandList->getIterator();
-        ShellCommandBase* enumCMD = itCMD->firstElement();
+        tIterator<ShellCommand>* itCMD = commandClass->commandList->getIterator();
+        ShellCommand* enumCMD = itCMD->firstElement();
         while (enumCMD != NULL)
         {
@@ -520,5 +535,5 @@
  * @param description the description of the Given command
  */
-ShellCommandBase* ShellCommandBase::describe(const char* description)
+ShellCommand* ShellCommand::describe(const char* description)
 {
   if (this == NULL)
@@ -536,5 +551,5 @@
  * @returns itself
  */
-ShellCommandBase* ShellCommandBase::setAlias(const char* alias)
+ShellCommand* ShellCommand::setAlias(const char* alias)
 {
   if (this == NULL)
@@ -566,5 +581,5 @@
  * count, [EXACTLY THE SAME AS IF YOU WOULD CALL THE FUNCTION UP TO count ARGUMENTS]
  */
-ShellCommandBase* ShellCommandBase::defaultValues(unsigned int count, ...)
+ShellCommand* ShellCommand::defaultValues(unsigned int count, ...)
 {
   if (this == NULL)
@@ -615,5 +630,5 @@
  * prints out nice information about the Shells Commands
  */
-void ShellCommandBase::debug()
+void ShellCommand::debug()
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -628,11 +643,11 @@
   {
     PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-    tIterator<ShellCommandBase>* iterator = elemCL->commandList->getIterator();
-    const ShellCommandBase* elem = iterator->firstElement();
+    tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
+    const ShellCommand* elem = iterator->firstElement();
     while(elem != NULL)
     {
       PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->paramCount);
       for (unsigned int i = 0; i< elem->paramCount; i++)
-       printf("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
+       printf("%s ", ShellCommand::paramToString(elem->parameters[i]));
       if (elem->description != NULL)
        printf("- %s", elem->description);
@@ -652,5 +667,5 @@
  * @returns the Name of the Parameter at Hand
  */
-const char* ShellCommandBase::paramToString(long parameter)
+const char* ShellCommand::paramToString(long parameter)
 {
   return MultiType::MultiTypeToString((MT_Type)parameter);
Index: /trunk/src/lib/shell/shell_command.h
===================================================================
--- /trunk/src/lib/shell/shell_command.h	(revision 5635)
+++ /trunk/src/lib/shell/shell_command.h	(revision 5636)
@@ -13,5 +13,5 @@
 #include "substring.h"
 #include "functor_list.h"
-
+#include "executor/executor.h"
 #include <stdarg.h>
 
@@ -30,5 +30,5 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
+ *  ShellCommand* someUniqueVarName =
  *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
@@ -36,6 +36,9 @@
  * $ ClassName [ObjectName] commandNameInShell [parameters]
  */
+//#define SHELL_COMMAND(command, class, function) \
+//        ShellCommand* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
 #define SHELL_COMMAND(command, class, function) \
-        ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
+           ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorObjective<class>(&class::function))
+
 /**
  * an easy to use Macro to create a Command
@@ -45,5 +48,5 @@
  *
  * MEANING:
- *  ShellCommandBase* someUniqueVarName =
+ *  ShellCommand* someUniqueVarName =
  *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
  *
@@ -52,5 +55,5 @@
  */
 #define SHELL_COMMAND_STATIC(command, class, function) \
-                         ShellCommandBase* shell_command_##class##_##command = ShellCommandStatic<class>::registerCommand(#command, #class, function)
+           ShellCommand* shell_command_##class##_##command = ShellCommand::registerCommand(#command, #class, new ExecutorStatic<class>(function))
 
 
@@ -64,5 +67,5 @@
 // BASE CLASS //
 ////////////////
-class ShellCommandBase;
+class ShellCommand;
 class ShellCommandAlias;
 
@@ -70,5 +73,5 @@
 class ShellCommandClass : public BaseObject
 {
-  friend class ShellCommandBase;
+  friend class ShellCommand;
 
   public:
@@ -93,5 +96,5 @@
     const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                             classID;                   //!< The classID of this Class
-    tList<ShellCommandBase>*         commandList;               //!< A list of Commands from this Class
+    tList<ShellCommand>*         commandList;               //!< A list of Commands from this Class
     static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
     static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
@@ -100,5 +103,5 @@
 
 //! a baseClass for all possible ShellCommands
-class ShellCommandBase : public BaseObject
+class ShellCommand : public BaseObject
 {
   friend class ShellCommandClass;
@@ -106,9 +109,10 @@
     static bool execute (const char* executionString);
 
-    ShellCommandBase* describe(const char* description);
-    ShellCommandBase* setAlias(const char* alias);
-    ShellCommandBase* defaultValues(unsigned int count, ...);
+    ShellCommand* describe(const char* description);
+    ShellCommand* setAlias(const char* alias);
+    ShellCommand* defaultValues(unsigned int count, ...);
 
-    /** @returns the CommandList of the Shell */
+    static ShellCommand* registerCommand(const char* commandName, const char* className, Executor* executor);
+
     static void unregisterCommand(const char* commandName, const char* className);
 
@@ -116,6 +120,6 @@
 
   protected:
-    ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);
-    ~ShellCommandBase();
+    ShellCommand(const char* commandName, const char* className, unsigned int paramCount, ...);
+    ~ShellCommand();
 
     /** @returns the Type of this Function (either static or objective) */
@@ -141,303 +145,6 @@
 
     const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
-};
+    Executor*                        executor;
 
-///////////////////////////////////////////////////
-///////////////////////////////////////////////////
-
-/////////////////////////////////
-// MACRO DEFINITION EXTENSIONS //
-/////////////////////////////////
-//! where to chek for default BOOL values
-#define   l_BOOL_DEFGRAB(i)         this->defaultValue[i].getBool()
-//! where to chek for default INT values
-#define   l_INT_DEFGRAB(i)          this->defaultValue[i].getInt()
-//! where to chek for default UINT values
-#define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultValue[i].getInt()
-//! where to chek for default LONG values
-#define   l_LONG_DEFGRAB(i)         (long)this->defaultValue[i].getInt()
-//! where to chek for default FLOAT values
-#define   l_FLOAT_DEFGRAB(i)        this->defaultValue[i].getFloat()
-//! where to chek for default STRING values
-#define   l_STRING_DEFGRAB(i)       this->defaultValue[i].getString()
-
-//////////////////////////
-// COMMAND REGISTRATION //
-//////////////////////////
-// SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic
-// SHELLCOMMANDEXECUTER can be redefined too.
-// SHELLCOMMANDINCLASS
-// SHELLCOMMANDTYPE
-//! registers a command without any parameters
-#define ShellCommandRegister0() \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
-  { \
-    if (isRegistered(commandName, className, 0)== true) \
-      return NULL; \
-    return new SHELLCOMMAND<T>(commandName, className, function); \
-  }
-
-//! registers a command with 1 parameter
-#define ShellCommandRegister1(t1) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
-  { \
-    if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \
-      return NULL; \
-    return new SHELLCOMMAND<T>(commandName, className, function); \
-  }
-
-//! registers a command with 2 parameters
-#define ShellCommandRegister2(t1,t2) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
-  { \
-    if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \
-      return NULL; \
-    return new SHELLCOMMAND<T>(commandName, className, function); \
-  }
-
-//! registers a command with 3 parameters
-#define ShellCommandRegister3(t1,t2,t3) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
-  { \
-    if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \
-      return NULL; \
-    return new SHELLCOMMAND<T>(commandName, className, function); \
-  }
-
-//! registers a command with 4 parameters
-#define ShellCommandRegister4(t1,t2,t3,t4) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
-  { \
-    if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \
-      return NULL; \
-    return new SHELLCOMMAND<T>(commandName, className, function); \
-  }
-
-//! registers a command with 5 parameters
-#define ShellCommandRegister5(t1,t2,t3,t4,t5) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
-  { \
-    if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
-      return NULL; \
-    return new ShellCommand<T>(commandName, className, function); \
-  }
-
-///////////////////////
-// FUNCTION POINTERS //
-///////////////////////
-#define ShellCommandFunctionPoiter0() \
-  void SHELLCOMMANDINCLASS(*functionPointer_0)();
-
-#define ShellCommandFunctionPoiter1(t1) \
-  void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE);
-
-#define ShellCommandFunctionPoiter2(t1, t2) \
-  void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE);
-
-
-#define ShellCommandFunctionPoiter3(t1, t2, t3) \
-  void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE);
-
-#define ShellCommandFunctionPoiter4(t1, t2, t3, t4) \
-  void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE);
-
-
-#define ShellCommandFunctionPoiter5(t1, t2, t3, t4, t5) \
-  void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
-
-
-//////////////////
-// CONSTRUCTORS //
-/////////////////
-//! creates a command that takes no parameters
-#define ShellCommandConstructor0() \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
-  : ShellCommandBase(commandName, className, 0) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_0 = function; \
-  }
-
-//! creates a command that takes one parameter
-#define ShellCommandConstructor1(t1) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
-  : ShellCommandBase(commandName, className, 1, t1##_PARAM) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_1_##t1 = function; \
-  }
-
-//! creates a command that takes two parameters
-#define ShellCommandConstructor2(t1,t2) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
-  : ShellCommandBase(commandName, className, 2, t1##_PARAM, t2##_PARAM) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_2_##t1##_##t2 = function; \
-  }
-
-//! creates a command that takes three parameter
-#define ShellCommandConstructor3(t1,t2,t3) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
-  : ShellCommandBase(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_3_##t1##_##t2##_##t3 = function; \
-  }
-
-//! creates a command that takes four parameter
-#define ShellCommandConstructor4(t1,t2,t3,t4) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
-  : ShellCommandBase(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \
-  }
-
-//! creates a command that takes five parameter
-#define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
-  : ShellCommandBase(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \
-  { \
-    this->functorType = SHELLCOMMANDTYPE; \
-    this->fp.functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \
-  }
-
-///////////////
-// EXECUTION //
-///////////////
-//! execute-macro for functions with no parameters
-#define ShellCommandExecute0() \
-  if (this->paramCount == 0) \
-    SHELLCOMMANDEXECUTER(_0)()
-
-//! execute-macro for functions with one parameter
-#define ShellCommandExecute1(t1) \
-   else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
-    SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
-
-//! execute-macro for functions with two parameters
-#define ShellCommandExecute2(t1,t2) \
-   else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
-    SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
-
-//! execute-macro for functions with three parameters
-#define ShellCommandExecute3(t1,t2,t3) \
-   else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
-    SHELLCOMMANDEXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)))
-
-//! execute-macro for functions with four parameters
-#define ShellCommandExecute4(t1,t2,t3,t4) \
-   else if (this->paramCount == 4 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM) \
-    SHELLCOMMANDEXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)))
-
-//! execute-macro for functions with five parameters
-#define ShellCommandExecute5(t1,t2,t3,t4,t5) \
-   else if (this->paramCount == 5 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM && this->parameters[4] == t5##_PARAM) \
-    SHELLCOMMANDEXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)), t5##_FUNC(sub.getString(4), t5##_DEFGRAB(4)))
-
-
-//! keeps information about a ShellCommand
-template<class T> class ShellCommand : public ShellCommandBase
-{
-  public:
-#ifdef FUNCTOR_LIST
-#undef FUNCTOR_LIST
-#endif
-#ifdef SHELLCOMMAND
-#undef SHELLCOMMAND
-#endif
-#define SHELLCOMMAND                       ShellCommand
-#ifdef SHELLCOMMANDEXECUTER
-#undef SHELLCOMMANDEXECUTER
-#endif
-#define SHELLCOMMANDEXECUTER(nameExt)      (dynamic_cast<T*>(object)->*(fp.functionPointer##nameExt))
-#ifdef SHELLCOMMANDINCLASS
-#undef SHELLCOMMANDINCLASS
-#endif
-#define SHELLCOMMANDINCLASS(FUNCTION)      (T::FUNCTION)
-#ifdef SHELLCOMMANDTYPE
-#undef SHELLCOMMANDTYPE
-#endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Objective
-//! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-
-
-  private:
-//! FUNCTOR_LIST is the List of FunctionPointers
-    union FunctionPointers {
-#define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-    } fp;
-
-//! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-
-    virtual void executeCommand (BaseObject* object, const char* parameters)
-    {
-      SubString sub(parameters, true);
-//! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-    }
-};
-
-//! keeps information about a ShellCommand, that points to a Static Function
-template<class T> class ShellCommandStatic : public ShellCommandBase
-{
-  public:
-#ifdef FUNCTOR_LIST
-#undef FUNCTOR_LIST
-#endif
-#ifdef SHELLCOMMAND
-#undef SHELLCOMMAND
-#endif
-#define SHELLCOMMAND                      ShellCommandStatic
-#ifdef SHELLCOMMANDEXECUTER
-#undef SHELLCOMMANDEXECUTER
-#endif
-#define SHELLCOMMANDEXECUTER(nameExt)     fp.functionPointer##nameExt
-#ifdef SHELLCOMMANDINCLASS
-#undef SHELLCOMMANDINCLASS
-#endif
-#define SHELLCOMMANDINCLASS(FUNCTION)     (FUNCTION)
-#ifdef SHELLCOMMANDTYPE
-#undef SHELLCOMMANDTYPE
-#endif
-#define SHELLCOMMANDTYPE                   ShellCommand_Static
-
-//! FUNCTOR_LIST is the List of command-registerers
-#define FUNCTOR_LIST(x) ShellCommandRegister ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-
-  private:
-//! FUNCTOR_LIST is the List of FunctionPointers
-    union FunctionPointers {
-#define FUNCTOR_LIST(x) ShellCommandFunctionPoiter ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-    } fp;
-
-//! FUNCTOR_LIST is the List of CommandConstructors
-#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-
-    virtual void executeCommand (BaseObject* object, const char* parameters)
-    {
-  SubString sub(parameters, true);
-//! FUNCTOR_LIST is the List of Executive Functions
-#define FUNCTOR_LIST(x) ShellCommandExecute ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-    }
 };
 
@@ -445,18 +152,18 @@
 class ShellCommandAlias
 {
-  friend class ShellCommandBase;
+  friend class ShellCommand;
   public:
     /** @returns the Name of the Alias. */
     const char* getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
-    ShellCommandBase* getCommand() const { return this->command; };
+    ShellCommand* getCommand() const { return this->command; };
 
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommandBase* command) { this->aliasName = aliasName; this->command = command; };
+    ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
     const char*         aliasName;       //!< the name of the Alias
-    ShellCommandBase*   command;         //!< a pointer to the command, this alias executes.
+    ShellCommand*   command;         //!< a pointer to the command, this alias executes.
 };
 
Index: /trunk/src/lib/shell/shell_input.cc
===================================================================
--- /trunk/src/lib/shell/shell_input.cc	(revision 5635)
+++ /trunk/src/lib/shell/shell_input.cc	(revision 5636)
@@ -214,5 +214,5 @@
   strcpy(newCommand, this->inputLine);
 
-  ShellCommandBase::execute(newCommand);
+  ShellCommand::execute(newCommand);
 
   // removing the eventually added Entry (from scrolling) to the List
Index: /trunk/src/lib/util/executor/executor.cc
===================================================================
--- /trunk/src/lib/util/executor/executor.cc	(revision 5635)
+++ /trunk/src/lib/util/executor/executor.cc	(revision 5636)
@@ -38,11 +38,8 @@
  * @param paramCount the count of parameters this command takes
  */
-Executor::Executor(const char* commandName, const char* className, unsigned int paramCount, ...)
+Executor::Executor(unsigned int paramCount, ...)
 {
   this->setClassID(CL_EXECUTOR, "Executor");
-  this->setName(commandName);
 
-//  this->classID = classID;
-  // handling parameters, and storing them:
   if (paramCount > FUNCTOR_MAX_ARGUMENTS)
     paramCount = FUNCTOR_MAX_ARGUMENTS;
Index: /trunk/src/lib/util/executor/executor.h
===================================================================
--- /trunk/src/lib/util/executor/executor.h	(revision 5635)
+++ /trunk/src/lib/util/executor/executor.h	(revision 5636)
@@ -41,5 +41,5 @@
 
   protected:
-    Executor(const char* commandName, const char* className, unsigned int paramCount, ...);
+    Executor(unsigned int paramCount, ...);
     ~Executor();
 
@@ -77,8 +77,9 @@
 // COMMAND REGISTRATION //
 //////////////////////////
-// EXECUTOR can be redefined as Executor or ExecutorStatic
-// EXECUTOREXECUTER can be redefined too.
+// EXECUTOR             can be redefined as Executor or ExecutorStatic
+// EXECUTOREXECUTER     can be redefined too.
 // EXECUTORINCLASS
 // EXECUTORTYPE
+
 
 ///////////////////////
@@ -111,6 +112,6 @@
 //! creates a command that takes no parameters
 #define ExecutorConstructor0() \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)()) \
-  : Executor(commandName, className, 0) \
+  EXECUTOR(void EXECUTORINCLASS(*function)()) \
+  : Executor(0) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -120,6 +121,6 @@
 //! creates a command that takes one parameter
 #define ExecutorConstructor1(t1) \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE)) \
-  : Executor(commandName, className, 1, t1##_PARAM) \
+  EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE)) \
+  : Executor(1, t1##_PARAM) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -129,6 +130,6 @@
 //! creates a command that takes two parameters
 #define ExecutorConstructor2(t1,t2) \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
-  : Executor(commandName, className, 2, t1##_PARAM, t2##_PARAM) \
+  EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE)) \
+  : Executor(2, t1##_PARAM, t2##_PARAM) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -138,6 +139,6 @@
 //! creates a command that takes three parameter
 #define ExecutorConstructor3(t1,t2,t3) \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
-  : Executor(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \
+  EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE)) \
+  : Executor(3, t1##_PARAM, t2##_PARAM, t3##_PARAM) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -147,6 +148,6 @@
 //! creates a command that takes four parameter
 #define ExecutorConstructor4(t1,t2,t3,t4) \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
-  : Executor(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \
+  EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE)) \
+  : Executor(4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -156,6 +157,6 @@
 //! creates a command that takes five parameter
 #define ExecutorConstructor5(t1,t2,t3,t4,t5) \
-  EXECUTOR(const char* commandName, const char* className, void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
-  : Executor(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \
+  EXECUTOR(void EXECUTORINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE)) \
+  : Executor(5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM) \
   { \
     this->functorType = EXECUTORTYPE; \
@@ -292,5 +293,5 @@
 
 
-    virtual void executeCommand (BaseObject* object, const char* parameters)
+    virtual void execute (BaseObject* object, const char* parameters)
     {
   SubString sub(parameters, true);
Index: /trunk/src/world_entities/player.cc
===================================================================
--- /trunk/src/world_entities/player.cc	(revision 5635)
+++ /trunk/src/world_entities/player.cc	(revision 5636)
@@ -119,6 +119,4 @@
 void Player::init()
 {
-  Executor* test =  new ExecutorObjective<Player>("test", "Player", &Player::ADDWEAPON);
-
 //  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
   this->setClassID(CL_PLAYER, "Player");
