Changeset 1416 for code/branches/console/src/core

Timestamp:

May 25, 2008, 1:11:51 AM (17 years ago)

Author:

landauf

Message:

• fixed a bug in CommandExecutor
• InGameConsole wraps now too long output lines and does something similar for the input line

Location:

code/branches/console/src/core

Files:

• ArgumentCompletionFunctions.cc (modified) (1 diff)
• ArgumentCompletionFunctions.h (modified) (1 diff)
• CommandEvaluation.cc (modified) (4 diffs)
• CommandExecutor.cc (modified) (9 diffs)
• ConsoleCommand.cc (modified) (2 diffs)
• ConsoleCommand.h (modified) (3 diffs)
• Debug.h (modified) (4 diffs)
• OutputHandler.cc (modified) (1 diff)
• TclBind.cc (modified) (1 diff)
• TclThreadManager.cc (modified) (1 diff)

code/branches/console/src/core/ArgumentCompletionFunctions.cc

@@ -35 +35 @@
     namespace autocompletion
     {
-        const std::list<std::pair<std::string, std::string> >& fallback()
+        std::list<std::pair<std::string, std::string> > fallback()
         {
-std::cout << "5_1\n";
-            static std::list<std::pair<std::string, std::string> > list;
-std::cout << "5_2\n";
+            static std::list<std::pair<std::string, std::string> > list(1, std::pair<std::string, std::string>("muh", "MUH"));
             return list;
         }

code/branches/console/src/core/ArgumentCompletionFunctions.h

@@ -37 +37 @@
     namespace autocompletion
     {
-        const std::list<std::pair<std::string, std::string> >& fallback();
+        std::list<std::pair<std::string, std::string> > fallback();
     }
 }

code/branches/console/src/core/CommandEvaluation.cc

@@ -53 +53 @@
         this->listOfPossibleIdentifiers_.clear();
         this->listOfPossibleFunctions_.clear();
+        this->listOfPossibleArguments_.clear();
 
         this->functionclass_ = 0;
@@ -114 +115 @@
 std::cout << "complete: function != 0" << std::endl;
                     if (this->commandTokens_.size() > 1)
-                        return (this->function_->getName() + " " + this->commandTokens_.subSet(1, this->commandTokens_.size() - 1).join() + " " + CommandEvaluation::getCommonBegin(this->listOfPossibleArguments_));
+                    {
+                        if ((this->commandTokens_.size() - 1) >= this->function_->getParamCount())
+                            return (this->function_->getName() + " " + this->commandTokens_.subSet(1, this->commandTokens_.size()).join());
+                        else
+                            return (this->function_->getName() + " " + this->commandTokens_.subSet(1, this->commandTokens_.size()).join() + " " + CommandEvaluation::getCommonBegin(this->listOfPossibleArguments_));
+                    }
                     else
                         return (this->function_->getName() + " ");
@@ -125 +131 @@
 std::cout << "complete: function != 0" << std::endl;
                     if (this->commandTokens_.size() > 1)
-                        return (this->function_->getName() + " " + this->commandTokens_.subSet(1, this->commandTokens_.size() - 1).join());
+                        return (this->function_->getName() + " " + this->commandTokens_.subSet(1, this->commandTokens_.size()).join());
                     else
                         return (this->function_->getName());
@@ -144 +150 @@
 std::cout << "complete: function und functionclass != 0" << std::endl;
                     if (this->commandTokens_.size() > 2)
-                        return (this->functionclass_->getName() + " " + this->function_->getName() + " " + this->commandTokens_.subSet(2, this->commandTokens_.size()).join() + " " + CommandEvaluation::getCommonBegin(this->listOfPossibleArguments_));
+                    {
+                        if ((this->commandTokens_.size() - 2) >= this->function_->getParamCount())
+                            return (this->functionclass_->getName() + " " + this->function_->getName() + " " + this->commandTokens_.subSet(2, this->commandTokens_.size()).join());
+                        else
+                            return (this->functionclass_->getName() + " " + this->function_->getName() + " " + this->commandTokens_.subSet(2, this->commandTokens_.size()).join() + " " + CommandEvaluation::getCommonBegin(this->listOfPossibleArguments_));
+                    }
                     else
                         return (this->functionclass_->getName() + " " + this->function_->getName() + " ");

code/branches/console/src/core/CommandExecutor.cc

@@ -108 +108 @@
     {
         CommandExecutor::parseIfNeeded(command);
+
+        if (!CommandExecutor::getEvaluation().isNewCommand())
+            CommandExecutor::parse(CommandExecutor::getEvaluation().getCommand(), false);
+        else
+            CommandExecutor::getEvaluation().setNewCommand(false);
+
         return CommandExecutor::getEvaluation().complete();
     }
@@ -119 +125 @@
     CommandEvaluation CommandExecutor::evaluate(const std::string& command)
     {
-        CommandExecutor::parse(command, true);
+        CommandExecutor::parse(command);
         CommandExecutor::getEvaluation().evaluateParams();
         return CommandExecutor::getEvaluation();
@@ -126 +132 @@
     void CommandExecutor::parseIfNeeded(const std::string& command)
     {
-        if ((CommandExecutor::getEvaluation().getCommand() != command) || (CommandExecutor::getEvaluation().getState() == CS_Uninitialized))
+        if ((CommandExecutor::getEvaluation().getOriginalCommand() != command) || (CommandExecutor::getEvaluation().getState() == CS_Uninitialized))
             CommandExecutor::parse(command);
-        else if (!CommandExecutor::getEvaluation().isValid())
-        {
-            CommandExecutor::getEvaluation().setNewCommand(false);
-            CommandExecutor::parse(command, false);
-        }
     }
 
@@ -301 +302 @@
                 if (CommandExecutor::getEvaluation().getFunction())
                 {
-std::cout << "1\n";
                     unsigned int startindex = 0;
                     if (CommandExecutor::getEvaluation().getState() == CS_Shortcut_Params)
@@ -307 +307 @@
                     else if (CommandExecutor::getEvaluation().getState() == CS_Function_Params)
                         startindex = 2;
-std::cout << "2\n";
 
                     if (CommandExecutor::argumentsGiven() >= startindex)
                     {
-std::cout << "3\n";
-                        if (CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().getFunction()))
-                        {
-std::cout << "4\n";
+                        if ((CommandExecutor::argumentsGiven() == CommandExecutor::argumentsFinished() || !CommandExecutor::getEvaluation().isNewCommand()) && CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().getFunction()))
+                        {
                             if (CommandExecutor::getEvaluation().getState() == CS_Shortcut_Params)
                                 CommandExecutor::getEvaluation().setState(CS_Shortcut_Finished);
@@ -324 +321 @@
                         else
                         {
-std::cout << "5\n";
-std::cout << "last argument: " << CommandExecutor::getLastArgument() << std::endl;
-std::cout << "function: " << CommandExecutor::getEvaluation().getFunction() << std::endl;
-std::cout << "functionname: " << CommandExecutor::getEvaluation().getFunction()->getName() << std::endl;
-std::cout << "param nr: " << CommandExecutor::getEvaluation().getTokens().size() - startindex << std::endl;
                             CommandExecutor::createListOfPossibleArguments(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().getFunction(), CommandExecutor::getEvaluation().getTokens().size() - startindex);
-std::cout << "6\n";
                             unsigned int numArguments = CommandExecutor::getEvaluation().getListOfPossibleArguments().size();
 
                             if (numArguments == 1)
                             {
-std::cout << "7\n";
                                 // There is exactly one possible argument
                                 const std::string* possibleArgument = (*CommandExecutor::getEvaluation().getListOfPossibleArguments().begin()).second;
-                                CommandExecutor::parse(CommandExecutor::getEvaluation().getTokens().subSet(0, CommandExecutor::getEvaluation().getTokens().size() - 1 - startindex).join() + " " + (*possibleArgument) + " ");
+                                if (CommandExecutor::argumentsGiven() > CommandExecutor::argumentsFinished())
+                                    CommandExecutor::parse(CommandExecutor::getEvaluation().getTokens().subSet(0, CommandExecutor::getEvaluation().getTokens().size() - 1).join() + " " + (*possibleArgument) + " ", false);
+                                else
+                                    CommandExecutor::parse(CommandExecutor::getEvaluation().getTokens().subSet(0, CommandExecutor::getEvaluation().getTokens().size()).join() + " " + (*possibleArgument) + " ", false);
+
                                 return;
                             }
 
-std::cout << "8\n";
                             if ((CommandExecutor::argumentsGiven() > CommandExecutor::argumentsFinished()) && (!CommandExecutor::getEvaluation().isNewCommand()))
                             {
-std::cout << "9\n";
                                 // There is more than one argument, but the user wants to use this - check if there is a perfect match
                                 const std::string* possibleArgument = CommandExecutor::getPossibleArgument(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().getFunction(), CommandExecutor::getEvaluation().getTokens().size() - startindex);
                                 if (possibleArgument)
                                 {
-std::cout << "10\n";
                                     // There is such an argument - use it
                                     CommandExecutor::parse(command + " ", false);
                                     return;
                                 }
-std::cout << "11\n";
                             }
-std::cout << "12\n";
-                        }
-std::cout << "13\n";
+                        }
 
                         // Nothing to do
@@ -426 +414 @@
     void CommandExecutor::createListOfPossibleIdentifiers(const std::string& fragment)
     {
+        CommandExecutor::getEvaluation().getListOfPossibleIdentifiers().clear();
         std::string lowercase = getLowercase(fragment);
         for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseIdentifierMapBegin(); it != Identifier::getLowercaseIdentifierMapEnd(); ++it)
@@ -437 +426 @@
     void CommandExecutor::createListOfPossibleFunctions(const std::string& fragment, Identifier* identifier)
     {
+        CommandExecutor::getEvaluation().getListOfPossibleFunctions().clear();
         std::string lowercase = getLowercase(fragment);
         if (!identifier)
@@ -456 +446 @@
     void CommandExecutor::createListOfPossibleArguments(const std::string& fragment, ConsoleCommand* command, unsigned int param)
     {
-std::cout << "2_1\n";
+        CommandExecutor::getEvaluation().getListOfPossibleArguments().clear();
         std::string lowercase = getLowercase(fragment);
-std::cout << "2_2\n";
         for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(param); it != command->getArgumentCompletionListEnd(param); ++it)
-        {
-std::cout << "2_3\n";
             if ((*it).first.find(lowercase) == 0 || fragment == "")
-            {
-std::cout << "2_4\n";
                 CommandExecutor::getEvaluation().getListOfPossibleArguments().push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second));
-std::cout << "2_5\n";
-            }
-        }
-
-std::cout << "2_6\n";
+
         CommandExecutor::getEvaluation().getListOfPossibleArguments().sort(CommandExecutor::compareStringsInList);
-std::cout << "2_7\n";
     }
 

code/branches/console/src/core/ConsoleCommand.cc

@@ -41 +41 @@
     }
 
-    ConsoleCommand& ConsoleCommand::setArgumentCompletionList(unsigned int param, const std::list<std::pair<std::string, std::string> >& (*function) (void))
+    ConsoleCommand& ConsoleCommand::setArgumentCompletionList(unsigned int param, std::list<std::pair<std::string, std::string> > (*function) (void))
     {
         if (param < 5)
@@ -52 +52 @@
     }
 
-    const std::list<std::pair<std::string, std::string> >& ConsoleCommand::getArgumentCompletionList(unsigned int param) const
+    const std::list<std::pair<std::string, std::string> >& ConsoleCommand::getArgumentCompletionList(unsigned int param)
     {
         if (param < 5)
-            return (*this->autocompletionFunction_[param])();
+            this->argumentList_ = (*this->autocompletionFunction_[param])();
         else
-            return autocompletion::fallback();
+            this->argumentList_ = autocompletion::fallback();
+
+        return this->argumentList_;
     }
 
-    std::list<std::pair<std::string, std::string> >::const_iterator ConsoleCommand::getArgumentCompletionListBegin(unsigned int param) const
+    std::list<std::pair<std::string, std::string> >::const_iterator ConsoleCommand::getArgumentCompletionListBegin(unsigned int param)
     {
-std::cout << "3_1: param: " << param << "\n";
         if (param < 5)
-        {
-std::cout << "3_2: >" << this->autocompletionFunction_[param] << "<\n";
-            return (*this->autocompletionFunction_[param])().begin();
-        }
+            this->argumentList_ = (*this->autocompletionFunction_[param])();
         else
-        {
-std::cout << "3_3\n";
-            return autocompletion::fallback().begin();
-        }
+            this->argumentList_ = autocompletion::fallback();
+
+        return this->argumentList_.begin();
     }
 
-    std::list<std::pair<std::string, std::string> >::const_iterator ConsoleCommand::getArgumentCompletionListEnd(unsigned int param) const
+    std::list<std::pair<std::string, std::string> >::const_iterator ConsoleCommand::getArgumentCompletionListEnd(unsigned int param)
     {
-std::cout << "4_1: param: " << param << "\n";
         if (param < 5)
-        {
-std::cout << "4_2: >" << this->autocompletionFunction_[param] << "<\n";
-            return (*this->autocompletionFunction_[param])().end();
-        }
+            this->argumentList_ = (*this->autocompletionFunction_[param])();
         else
-        {
-std::cout << "4_3\n";
-            return autocompletion::fallback().end();
-        }
+            this->argumentList_ = autocompletion::fallback();
+
+        return this->argumentList_.end();
     }
 }

code/branches/console/src/core/ConsoleCommand.h

@@ -42 +42 @@
     SetConsoleCommandGeneric(classname##function##consolecommand__, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function), bCreateShortcut)
 
-#define SetConsoleCommandGeneric(fakevariable, classname, executor, bCreateShortcut) \
-    Executor& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ConsoleCommand*)executor, bCreateShortcut)
+#define SetConsoleCommandGeneric(fakevariable, classname, command, bCreateShortcut) \
+    ConsoleCommand& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ConsoleCommand*)command, bCreateShortcut)
 
 
@@ -52 +52 @@
     SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&function), #function))
 
-#define SetConsoleCommandShortcutGeneric(fakevariable, executor) \
-    Executor& fakevariable = CommandExecutor::addConsoleCommandShortcut((ConsoleCommand*)executor)
+#define SetConsoleCommandShortcutGeneric(fakevariable, command) \
+    ConsoleCommand& fakevariable = CommandExecutor::addConsoleCommandShortcut((ConsoleCommand*)command)
 
 
@@ -100 +100 @@
                 { return this->accessLevel_; }
 
-            ConsoleCommand& setArgumentCompletionList(unsigned int param, const std::list<std::pair<std::string, std::string> >& (*function) (void));
+            ConsoleCommand& setArgumentCompletionList(unsigned int param, std::list<std::pair<std::string, std::string> > (*function) (void));
 
-            const std::list<std::pair<std::string, std::string> >& getArgumentCompletionList(unsigned int param) const;
-            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListBegin(unsigned int param) const;
-            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListEnd(unsigned int param) const;
+            const std::list<std::pair<std::string, std::string> >& getArgumentCompletionList(unsigned int param);
+            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListBegin(unsigned int param);
+            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListEnd(unsigned int param);
 
         private:
             AccessLevel::Level accessLevel_;
-            const std::list<std::pair<std::string, std::string> >& (*autocompletionFunction_[5]) (void);
+            std::list<std::pair<std::string, std::string> > (*autocompletionFunction_[5]) (void);
+            std::list<std::pair<std::string, std::string> > argumentList_;
     };
 

code/branches/console/src/core/Debug.h

@@ -206 +206 @@
    COUT ## x
 
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
+   #define COUT0  \
+    if (getSoftDebugLevel() >= ORX_NONE)  \
+     COUT_EXEC(0)
+  #else
+   #define COUT0 if (ORX_NONE)\
+    COUT_EXEC(0)
+  #endif
+
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define COUT1  \
@@ -256 +265 @@
  #endif /* if ORX_PRINT_DEBUG_OUTPUT */
 
- #define COUT0 \
-  COUT_EXEC(0)
 #endif /* ifndef COUT */
 
@@ -274 +281 @@
    CCOUT ## x
 
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
+   #define CCOUT0  \
+    if (getSoftDebugLevel() >= ORX_NONE)  \
+     CCOUT_EXEC(0)
+  #else
+   #define CCOUT0 if (ORX_NONE)\
+    CCOUT_EXEC(0)
+  #endif
+
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define CCOUT1  \
@@ -324 +340 @@
  #endif /* if ORX_PRINT_DEBUG_OUTPUT */
 
- #define CCOUT0 \
-  CCOUT_EXEC(0)
 #endif /* ifndef CCOUT */
 

code/branches/console/src/core/OutputHandler.cc

@@ -38 +38 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcutGeneric(log,     createExecutor(createFunctor(&OutputHandler::log),     "log"    ));
-    SetConsoleCommandShortcutGeneric(error,   createExecutor(createFunctor(&OutputHandler::error),   "error"  ));
-    SetConsoleCommandShortcutGeneric(warning, createExecutor(createFunctor(&OutputHandler::warning), "warning"));
-    SetConsoleCommandShortcutGeneric(info,    createExecutor(createFunctor(&OutputHandler::info),    "info"   ));
-    SetConsoleCommandShortcutGeneric(debug,   createExecutor(createFunctor(&OutputHandler::debug),   "debug"  ));
+    SetConsoleCommandShortcutGeneric(log,     createConsoleCommand(createFunctor(&OutputHandler::log),     "log"    ));
+    SetConsoleCommandShortcutGeneric(error,   createConsoleCommand(createFunctor(&OutputHandler::error),   "error"  ));
+    SetConsoleCommandShortcutGeneric(warning, createConsoleCommand(createFunctor(&OutputHandler::warning), "warning"));
+    SetConsoleCommandShortcutGeneric(info,    createConsoleCommand(createFunctor(&OutputHandler::info),    "info"   ));
+    SetConsoleCommandShortcutGeneric(debug,   createConsoleCommand(createFunctor(&OutputHandler::debug),   "debug"  ));
 
     /**

code/branches/console/src/core/TclBind.cc

@@ -39 +39 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcutGeneric(tcl, createExecutor(createFunctor(&TclBind::tcl), "tcl"));
-    SetConsoleCommandShortcutGeneric(bgerror, createExecutor(createFunctor(&TclBind::bgerror), "bgerror"));
+    SetConsoleCommandShortcutGeneric(tcl, createConsoleCommand(createFunctor(&TclBind::tcl), "tcl"));
+    SetConsoleCommandShortcutGeneric(bgerror, createConsoleCommand(createFunctor(&TclBind::bgerror), "bgerror"));
 
     TclBind::TclBind()

code/branches/console/src/core/TclThreadManager.cc

@@ -48 +48 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcutGeneric(tclexecute, createExecutor(createFunctor(&TclThreadManager::execute), "tclexecute"));
-    SetConsoleCommandShortcutGeneric(tclquery,   createExecutor(createFunctor(&TclThreadManager::query),   "tclquery"  ));
+    SetConsoleCommandShortcutGeneric(tclexecute, createConsoleCommand(createFunctor(&TclThreadManager::execute), "tclexecute"));
+    SetConsoleCommandShortcutGeneric(tclquery,   createConsoleCommand(createFunctor(&TclThreadManager::query),   "tclquery"  ));
     SetConsoleCommand(TclThreadManager, create,  false);
     SetConsoleCommand(TclThreadManager, destroy, false);