Index: trunk/src/lib/shell/shell_command.cc
===================================================================
--- trunk/src/lib/shell/shell_command.cc	(revision 5551)
+++ trunk/src/lib/shell/shell_command.cc	(revision 5552)
@@ -259,4 +259,16 @@
 tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
 
+
+
+
+
+
+
+
+
+
+////////////////////////
+// SHELL COMMAND BASE //
+////////////////////////
 /**
  * constructs and registers a new Command
@@ -282,40 +294,12 @@
   this->paramCount = paramCount;
   this->parameters = new unsigned int[paramCount];
+  this->defaultValue = new MultiType[paramCount];
 
   va_list parameterList;
   va_start(parameterList, paramCount);
 
+  // What Parameters we have got
   for (unsigned int i = 0; i < paramCount; i++)
-  {
     this->parameters[i] = va_arg(parameterList, int);
-
-    switch (this->parameters[i])
-    {
-      case ParameterBool:
-        this->defaultBools[i] = va_arg(parameterList, int);
-        break;
-      case ParameterChar:
-        this->defaultStrings[i] = new char[2];
-        sprintf(this->defaultStrings[0], "%c",  va_arg(parameterList, int));
-        break;
-      case ParameterString:
-        this->defaultStrings[i] = va_arg(parameterList, char*);
-        break;
-      case ParameterInt:
-        this->defaultInts[i] = va_arg(parameterList, int);
-        break;
-      case ParameterUInt:
-        this->defaultInts[i] = va_arg(parameterList, unsigned int);
-        break;
-      case ParameterFloat:
-        this->defaultFloats[i] = va_arg(parameterList, double);
-        break;
-      case ParameterLong:
-        this->defaultInts[i] = va_arg(parameterList, long);
-        break;
-      default:
-        break;
-    }
-  }
 }
 
@@ -327,4 +311,5 @@
 {
   delete[] this->parameters;
+  delete[] this->defaultValue;
   if (this->alias != NULL && ShellCommandClass::aliasList != NULL)
   {
@@ -598,27 +583,28 @@
   for (unsigned int i = 0; i < count; i++)
   {
+
+
     switch (this->parameters[i])
     {
       case ParameterBool:
-        this->defaultBools[i] = va_arg(defaultList, int);
+        this->defaultValue[i].setInt(va_arg(defaultList, int));
         break;
       case ParameterChar:
-        this->defaultStrings[i] = new char[2];
-        sprintf(this->defaultStrings[0], "%c",  va_arg(defaultList, int));
+        this->defaultValue[i].setChar((char)va_arg(defaultList, int));
         break;
       case ParameterString:
-        this->defaultStrings[i] = va_arg(defaultList, char*);
+        this->defaultValue[i].setString(va_arg(defaultList, char*));
         break;
       case ParameterInt:
-        this->defaultInts[i] = va_arg(defaultList, int);
+        this->defaultValue[i].setInt(va_arg(defaultList, int));
         break;
       case ParameterUInt:
-        this->defaultInts[i] = va_arg(defaultList, unsigned int);
+        this->defaultValue[i].setInt((int)va_arg(defaultList, unsigned int));
         break;
       case ParameterFloat:
-        this->defaultFloats[i] = va_arg(defaultList, double);
+        this->defaultValue[i].setFloat(va_arg(defaultList, double));
         break;
       case ParameterLong:
-        this->defaultInts[i] = va_arg(defaultList, long);
+        this->defaultValue[i].setInt((int) va_arg(defaultList, long));
         break;
       default:
@@ -626,5 +612,4 @@
     }
   }
-
   return this;
 }
Index: trunk/src/lib/shell/shell_command.h
===================================================================
--- trunk/src/lib/shell/shell_command.h	(revision 5551)
+++ trunk/src/lib/shell/shell_command.h	(revision 5552)
@@ -10,4 +10,5 @@
 
 #include "helper_functions.h"
+#include "multi_type.h"
 #include "substring.h"
 #include "functor_list.h"
@@ -133,9 +134,5 @@
     unsigned int                     paramCount;                           //!< the count of parameters.
     unsigned int*                    parameters;                           //!< Parameters the function of this Command takes.
-    char*                            defaultStrings[FUNCTOR_MAX_ARGUMENTS];//!< A list of default Strings stored.
-    int                              defaultInts[FUNCTOR_MAX_ARGUMENTS];   //!< A list of default Ints stored.
-    float                            defaultFloats[FUNCTOR_MAX_ARGUMENTS]; //!< A list of default Floats stored.
-    bool                             defaultBools[FUNCTOR_MAX_ARGUMENTS];  //!< A list of default Bools stored.
-
+    MultiType*                       defaultValue;                         //!< Default Values.
 
   private:
@@ -153,15 +150,15 @@
 /////////////////////////////////
 //! where to chek for default BOOL values
-#define   l_BOOL_DEFGRAB(i)         this->defaultBools[i]
+#define   l_BOOL_DEFGRAB(i)         this->defaultValue[i].getBool()
 //! where to chek for default INT values
-#define   l_INT_DEFGRAB(i)          this->defaultInts[i]
+#define   l_INT_DEFGRAB(i)          this->defaultValue[i].getInt()
 //! where to chek for default UINT values
-#define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultInts[i]
+#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->defaultInts[i]
+#define   l_LONG_DEFGRAB(i)         (long)this->defaultValue[i].getInt()
 //! where to chek for default FLOAT values
-#define   l_FLOAT_DEFGRAB(i)        this->defaultFloats[i]
+#define   l_FLOAT_DEFGRAB(i)        this->defaultValue[i].getFloat()
 //! where to chek for default STRING values
-#define   l_STRING_DEFGRAB(i)       this->defaultStrings[i]
+#define   l_STRING_DEFGRAB(i)       this->defaultValue[i].getString()
 
 //////////////////////////
@@ -183,45 +180,45 @@
 //! registers a command with 1 parameter
 #define ShellCommandRegister1(t1) \
-  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
+  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, d1); \
+    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), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
+  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, d1, d2); \
+    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), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
+  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, d1, d2, d3); \
+    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), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
+  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, d1, d2, d3, d4); \
+    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), 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) \
+  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, d1, d2, d3, d4, d5); \
+    return new ShellCommand<T>(commandName, className, function); \
   }
 
@@ -264,6 +261,6 @@
 //! creates a command that takes one parameter
 #define ShellCommandConstructor1(t1) \
-  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1) \
-  : ShellCommandBase(commandName, className, 1, t1##_PARAM, d1) \
+  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE)) \
+  : ShellCommandBase(commandName, className, 1, t1##_PARAM) \
   { \
     this->functorType = SHELLCOMMANDTYPE; \
@@ -273,6 +270,6 @@
 //! 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), t1##_TYPE d1, t2##_TYPE d2) \
-  : ShellCommandBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
+  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; \
@@ -282,6 +279,6 @@
 //! 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), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3) \
-  : ShellCommandBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
+  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; \
@@ -291,6 +288,6 @@
 //! 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), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4) \
-  : ShellCommandBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
+  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; \
@@ -300,6 +297,6 @@
 //! 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), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4, t5##_TYPE d5) \
-  : ShellCommandBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
+  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; \
Index: trunk/src/lib/util/multi_type.cc
===================================================================
--- trunk/src/lib/util/multi_type.cc	(revision 5551)
+++ trunk/src/lib/util/multi_type.cc	(revision 5552)
@@ -30,8 +30,6 @@
 MultiType::MultiType()
 {
-  this->type = MT_NULL;
-  this->storedString = NULL;
-}
-
+  this->init();
+}
 /**
  * creates a multiType out of a boolean
@@ -178,8 +176,18 @@
   if (this->storedString != NULL)
     delete[] this->storedString;
-  this->storedString = new char[strlen(value)+1];
-  strcpy(storedString, value);
-
-  this->value.String = this->storedString;
+
+  if (value == NULL)
+  {
+    this->storedString = new char[1];
+    this->storedString[0] = '\0';
+    this->value.String = this->storedString;
+    return;
+  }
+  else
+  {
+    this->storedString = new char[strlen(value)+1];
+    strcpy(storedString, value);
+    this->value.String = this->storedString;
+  }
 }
 
Index: trunk/src/lib/util/multi_type.h
===================================================================
--- trunk/src/lib/util/multi_type.h	(revision 5551)
+++ trunk/src/lib/util/multi_type.h	(revision 5552)
@@ -57,4 +57,6 @@
     inline MT_Type getType() const { return this->type; };
 
+
+    /* RETRIEVING FUNCTIONS */
     bool getBool() const;
     int getInt() const;
