Changeset 5145 in orxonox.OLD

Timestamp:

Aug 27, 2005, 2:15:44 AM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: one parameter-functions should be executable…. dubugging

Location:

trunk/src

Files:

• defs/functor_list.h (modified) (1 diff)
• util/shell.cc (modified) (1 diff)
• util/shell.h (modified) (1 diff)
• util/shell_command.cc (modified) (6 diffs)
• util/shell_command.h (modified) (4 diffs)
• world_entities/player.cc (modified) (2 diffs)

trunk/src/defs/functor_list.h

@@ -34 +34 @@
 typedef enum
 {
-  ParameterNull,
-  ParameterBool,
-  ParameterChar,
-  ParameterString,
-  ParameterInt,
-  ParameterUInt,
-  ParameterFloat,
-  ParameterLong,
+  ParameterNull    = 0,
+  ParameterBool    = 1,
+  ParameterChar    = 2,
+  ParameterString  = 4,
+  ParameterInt     = 8,
+  ParameterUInt    = 16,
+  ParameterFloat   = 32,
+  ParameterLong    = 64,
   /* ... */
 } ParameterType;

trunk/src/util/shell.cc

@@ -79 +79 @@
 
   ShellCommand<Shell>::registerCommand("clear", CL_SHELL, &Shell::clear);
-}
+  ShellCommand<Shell>::registerCommand("testI", CL_SHELL, &Shell::testI);
+  ShellCommand<Shell>::registerCommand("testS", CL_SHELL, &Shell::testS);
+}
+
+
+void Shell::testI (int i)
+{
+  printf("This is the Test for one Int '%d'\n", i);
+}
+
+void Shell::testS (const char* s)
+{
+  printf("This is the Test for one String '%s'\n", s);
+
+}
+
 
 Shell* Shell::singletonRef = NULL;

trunk/src/util/shell.h

@@ -38 +38 @@
     /** @returns a Pointer to the only object of this Class */
     inline static Shell* getInstance() { if (!Shell::singletonRef) Shell::singletonRef = new Shell();  return Shell::singletonRef; };
+
+    void testI (int i);
+    void testS (const char* s);
 
     void activate();

trunk/src/util/shell_command.cc

@@ -123 +123 @@
 
 
+/**
+ * executes commands
+ * @param executionString the string containing the following input
+ * <ClassName> [<ObjectName>] <functionName> [parameter1[,parameter2[,...]]]
+ * @return true on success, false otherwise.
+ */
 bool ShellCommandBase::execute(const char* executionString)
 {
@@ -139 +145 @@
       const char* commandBegin = executionString + strlen(elem->className);
 
-      PRINTF(4)("Class %s matches\n", elem->className);
+      PRINTF(5)("Class %s matches\n", elem->className);
       BaseObject* objectPointer = NULL;
       if (elem->isSingleton)
@@ -151 +157 @@
         }
         // getting singleton-reference
-        objectPointer = ClassList::getList(elem->classID)->firstElement();
+        tList<BaseObject>* list =  ClassList::getList(elem->classID);
+        if (list)
+          objectPointer = list->firstElement();
       }
       else
@@ -158 +166 @@
         while(*commandBegin == ' ')
           commandBegin++;
-        tIterator<BaseObject>* iterBO = ClassList::getList(elem->classID)->getIterator();
+        tList<BaseObject>* list =  ClassList::getList(elem->classID);
+        if (list == NULL)
+          break;
+        tIterator<BaseObject>* iterBO = list->getIterator();
         BaseObject* enumBO = iterBO->firstElement();
         while(enumBO != NULL)
@@ -164 +175 @@
           if(!strncmp(commandBegin, enumBO->getName(), strlen(enumBO->getName())))
           {
-            PRINTF(4)("Object %s matches\n", enumBO->getName());
+            PRINTF(5)("Object %s matches\n", enumBO->getName());
             objectPointer = enumBO;
             break;
@@ -184 +195 @@
           continue;
         }
-        PRINTF(3)("Function '%s' found\n", commandBegin);
+        PRINTF(5)("Function '%s' found\n", commandBegin);
       }
       const char* paramBegin = strchr(commandBegin, ' ');

trunk/src/util/shell_command.h

@@ -11 +11 @@
 #include "helper_functions.h"
 #include "functor_list.h"
+#include "substring.h"
 
 #include <stdarg.h>
 
-#define MAX_SHELL_COMMAND_SIZE
+#define SHELL_COMMAND_MAX_SIZE
 
 
@@ -29 +30 @@
 // NO ARGUMENTS
 #define ShellCommandRegister0 \
-  static void registerCommand(const char* commandName, ClassID classID, void (T::*functionPointer)()) \
+  static void registerCommand(const char* commandName, ClassID classID, void (T::*function)()) \
   { \
     if (isRegistered(commandName, classID, 0)== true) \
       return; \
-    new ShellCommand<T>(commandName, classID, functionPointer); \
+    new ShellCommand<T>(commandName, classID, function); \
+  }
+
+#define ShellCommandRegister1(t1) \
+  static void registerCommand(const char* commandName, ClassID classID, void (T::*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
+  { \
+    if (isRegistered(commandName, classID, 1, t1##_PARAM)== true) \
+      return; \
+    new ShellCommand<T>(commandName, classID, function, d1); \
   }
 
 
 #define ShellCommandConstructor0 \
-  void (T::*functionPointer_NULL)(); \
-  ShellCommand(const char* commandName, ClassID classID, void (T::*functionPointer)()) \
-  : ShellCommandBase (commandName, classID, 0) \
+  void (T::*functionPointer_0)(); \
+  ShellCommand(const char* commandName, ClassID classID, void (T::*function)()) \
+  : ShellCommandBase(commandName, classID, 0) \
   { \
-    this->functionPointer_NULL = functionPointer; \
+    this->functionPointer_0 = function; \
+  }
+
+#define ShellCommandConstructor1(t1) \
+  void (T::*functionPointer_1_##t1)(t1##_TYPE); \
+  ShellCommand(const char* commandName, ClassID classID, void (T::*function)(t1##_TYPE), t1##_TYPE d1) \
+  : ShellCommandBase(commandName, classID, 1, t1##_PARAM, d1) \
+  { \
+    this->functionPointer_1_##t1 = function; \
   }
 
 
 
+#define ShellCommandExecute0 \
+  if (this->paramCount == 0) \
+    (dynamic_cast<T*>(object)->*functionPointer_0)()
 
-#define ShellCommandRegister2(t1, t2) \
-  static void registerCommand(const char* commandName, ClassID classID, T* object, void (T::*function)(t1##_TYPE, t2##_TYPE) \
-                              t1##_TYPE default1 = t1##_DEFAULT, t2##_TYPE default2 = t2##_DEFAULT) \
-  { \
-     if (isRegistered(commandName, classID, 2, t1##_PARAM, t2##_PARAM) == true) \
-       return; \
-     else \
-       ShellCommand<T>* newCommand = new ShellCommand<T>(commandName, classID, object, function); \
-  }
-
-// CONSTRUCTORS AND POINTERS
-#define ShellCommandConstructor2(t1, t2) \
-  void (T::*functionPointer_##t1_##t2)(t1##_TYPE, t2##_TYPE); \
-  ShellCommand(const char* commandName, ClassID classID, T* object, void (T::*function)(t1##_TYPE, t2##_TYPE) \
-                              t1##_TYPE default1 = t1##_DEFAULT, t2##_TYPE default2 = t2##_DEFAULT) \
-  { \
-    this->functionPointer_##t1_##t2 = function; \
-  }
-
-//#define ShellCommand
+#define ShellCommandExecute1(t1) \
+   else if (this->paramCount == 1 && this->parameters[0] & t1##_PARAM) \
+       (dynamic_cast<T*>(object)->*functionPointer_1_##t1)(0)//t1##_FUNC(parameters, 0))
 
 
@@ -141 +144 @@
 //#include "functor_list.h"
 FUNCTOR_LIST(0);
+FUNCTOR_LIST(1)(l_INT);
+FUNCTOR_LIST(1)(l_STRING);
 #undef FUNCTOR_LIST
 
@@ -148 +153 @@
 //#include "functor_list.h"
   FUNCTOR_LIST(0);
+  FUNCTOR_LIST(1)(l_INT);
+  FUNCTOR_LIST(1)(l_STRING);
 #undef FUNCTOR_LIST
 
     virtual void executeCommand (BaseObject* object, const char* parameters)
     {
-     printf("not implemented yet\n");
-     if (this->paramCount == 0)
-       (dynamic_cast<T*>(object)->*functionPointer_NULL)();
+      SubString params(parameters, ',');
+#define FUNCTOR_LIST(x) ShellCommandExecute ## x
+//#include "functor_list.h"
+  FUNCTOR_LIST(0);
+  FUNCTOR_LIST(1)(l_INT);
+  FUNCTOR_LIST(1)(l_STRING);
+#undef FUNCTOR_LIST
     }
-
-
-
-#define FUNCTOR_LIST(x) ShellCommand ## x
-//#include "functor_list.h"
-//FUNCTOR_LIST(2)(l_INT, l_INT);
-#undef FUNCTOR_LIST
-
 };
 
-
-
 #endif /* _SHELL_COMMAND_H */

trunk/src/world_entities/player.cc

@@ -18 +18 @@
 #include "player.h"
 
-#include "shell_command.h"
 #include "track_manager.h"
 #include "objModel.h"
@@ -115 +114 @@
 
 
-  ShellCommand<Player>::registerCommand("init", CL_PLAYER, &Player::init);
+//  ShellCommand<Player>::registerCommand("init", CL_PLAYER, &Player::init);
   //this->weaponMan->addWeapon(turret, 3, 0);