Changeset 1427 for code/branches

Timestamp:

May 26, 2008, 3:08:39 AM (16 years ago)

Author:

landauf

Message:

CommandExecutor seems to work very well right now. yet to come: autocompletion lists

Location:

code/branches/console/src

Files:

• core/CommandEvaluation.cc (modified) (5 diffs)
• core/CommandEvaluation.h (modified) (2 diffs)
• core/CommandExecutor.cc (modified) (11 diffs)
• core/CommandExecutor.h (modified) (1 diff)
• orxonox/objects/SpaceShip.cc (modified) (1 diff)

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

@@ -57 +57 @@
         this->functionclass_ = 0;
         this->function_ = 0;
+        this->possibleArgument_ = "";
+        this->argument_ = "";
 
         this->errorMessage_ = "";
@@ -97 +99 @@
         if (!this->bNewCommand_)
         {
-std::cout << "ASDF" << std::endl;
+std::cout << "not new" << std::endl;
             switch (this->state_)
             {
@@ -106 +108 @@
                 case CS_ShortcutOrIdentifier:
                     if (this->function_)
-                        return CommandExecutor::complete(this->function_->getName() + " ");
+                    {
+                        if (this->function_->getParamCount() == 0)
+                            return /*CommandExecutor::complete*/(this->command_ = this->function_->getName());
+                        else
+                            return /*CommandExecutor::complete*/(this->command_ = this->function_->getName() + " ");
+                    }
                     else if (this->functionclass_)
-                        return CommandExecutor::complete(this->functionclass_->getName() + " ");
+                        return /*CommandExecutor::complete*/(this->command_ = this->functionclass_->getName() + " ");
                     break;
                 case CS_Function:
                     if (this->function_)
-                        return CommandExecutor::complete(this->functionclass_->getName() + " " + this->function_->getName() + " ");
-                    break;
+                    {
+                        if (this->function_->getParamCount() == 0)
+                            return /*CommandExecutor::complete*/(this->command_ = this->functionclass_->getName() + " " + this->function_->getName());
+                        else
+                            return /*CommandExecutor::complete*/(this->command_ = this->functionclass_->getName() + " " + this->function_->getName() + " ");
+                    }
+                    break;
+                case CS_ParamPreparation:
                 case CS_Params:
-                    break;
+                {
+                    unsigned int maxIndex = this->commandTokens_.size();
+                    if (this->command_[this->command_.size() - 1] != ' ')
+                        maxIndex -= 1;
+                    std::string whitespace = "";
+                    if (this->function_->getParamCount() > (maxIndex + 1 - this->getStartindex()))
+                        whitespace = " ";
+
+                    if (this->possibleArgument_ != "")
+                    {
+                        maxIndex -= 1;
+                        this->argument_ = this->possibleArgument_;
+                    }
+
+                    return /*CommandExecutor::complete*/(this->command_ = this->commandTokens_.subSet(0, maxIndex).join() + " " + this->argument_ + whitespace);
+                    break;
+                }
                 case CS_Finished:
                     break;
@@ -144 +173 @@
                 return CommandEvaluation::dump(this->listOfPossibleFunctions_);
                 break;
+            case CS_ParamPreparation:
             case CS_Params:
                 if (this->listOfPossibleArguments_.size() > 0)
@@ -241 +271 @@
     std::string CommandEvaluation::dump(const ConsoleCommand* command)
     {
-        std::string output = command->getName() + ": ";
+        std::string output = command->getName();
+        if (command->getParamCount() > 0)
+            output += ": ";
+
         for (unsigned int i = 0; i < command->getParamCount(); i++)
         {

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

@@ -46 +46 @@
         CS_ShortcutOrIdentifier,
         CS_Function,
+        CS_ParamPreparation,
         CS_Params,
         CS_Finished,
@@ -98 +99 @@
             Identifier* functionclass_;
             ConsoleCommand* function_;
+            std::string possibleArgument_;
+            std::string argument_;
 
             std::string errorMessage_;

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

@@ -146 +146 @@
     void CommandExecutor::parse(const std::string& command, bool bInitialize)
     {
-std::cout << "parse: command: >" << command << "<" << std::endl;
+std::cout << "parse (" << bInitialize << "): command: >" << command << "<" << std::endl;
         if (bInitialize)
             CommandExecutor::getEvaluation().initialize(command);
@@ -185 +185 @@
                     {
                         // It's a shortcut
-                        CommandExecutor::getEvaluation().state_ = CS_Params;
+                        CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
                         CommandExecutor::getEvaluation().functionclass_ = 0;
                         // Move on to next case
@@ -224 +224 @@
                             CommandExecutor::getEvaluation().bCommandChanged_ = true;
                         }
-                        CommandExecutor::getEvaluation().state_ = CS_Params;
+                        CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
                         CommandExecutor::getEvaluation().functionclass_ = 0;
                         CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().function_->getName();
                         if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                        {
                             CommandExecutor::getEvaluation().command_ += " ";
+                            CommandExecutor::getEvaluation().bCommandChanged_ = true;
+                        }
                         // Move on to next case
                     }
@@ -263 +266 @@
                         CommandExecutor::getEvaluation().function_ = CommandExecutor::getPossibleCommand(CommandExecutor::getArgument(0));
                         CommandExecutor::getEvaluation().functionclass_ = CommandExecutor::getPossibleIdentifier(CommandExecutor::getArgument(0));
+                        CommandExecutor::getEvaluation().bCommandChanged_ = true;
                         return;
                     }
@@ -280 +284 @@
                         {
                             // It's a function
-                            CommandExecutor::getEvaluation().state_ = CS_Params;
+                            CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
                             // Move on to next case
                         }
@@ -308 +312 @@
                                 CommandExecutor::getEvaluation().bCommandChanged_ = true;
                             }
-                            CommandExecutor::getEvaluation().state_ = CS_Params;
+                            CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
                             CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " " + CommandExecutor::getEvaluation().function_->getName();
                             if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                            {
                                 CommandExecutor::getEvaluation().command_ += " ";
+                                CommandExecutor::getEvaluation().bCommandChanged_ = true;
+                            }
                             // Move on to next case
                         }
@@ -327 +334 @@
                             CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleFunctions_);
                             CommandExecutor::getEvaluation().function_ = CommandExecutor::getPossibleCommand(CommandExecutor::getArgument(1), CommandExecutor::getEvaluation().functionclass_);
+                            CommandExecutor::getEvaluation().bCommandChanged_ = true;
                             return;
                         }
@@ -333 +341 @@
                 else
                 {
-                    // There is no classname - move on to CS_Shortcut_Params
-                }
-            }
-std::cout << "Waiting for arguments" << std::endl;
+                    // There is no classname - move on to CS_ParamPreparation
+                }
+            }
+std::cout << "1\n";
+            case CS_ParamPreparation:
+std::cout << "2\n";
+            {
+                if (CommandExecutor::getEvaluation().function_->getParamCount() == 0 || CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().function_))
+                {
+                    CommandExecutor::getEvaluation().state_ = CS_Finished;
+                    return;
+                }
+                else
+                {
+                    unsigned int argumentNumber = CommandExecutor::argumentsGiven() - 1;
+                    if (CommandExecutor::getEvaluation().functionclass_)
+                        argumentNumber -= 1;
+
+                    CommandExecutor::createListOfPossibleArguments(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().function_, argumentNumber);
+                    CommandExecutor::getEvaluation().state_ = CS_Params;
+
+                    if (CommandExecutor::getEvaluation().bCommandChanged_)
+                    {
+                        // Don't do more than one change
+                        return;
+                    }
+                }
+            }
             case CS_Params:
-            {
+std::cout << "3\n";
+            {
+                if (CommandExecutor::getEvaluation().listOfPossibleArguments_.size() == 1)
+                {
+std::cout << "3_1\n";
+                    // There is exactly one possible argument
+                    CommandExecutor::getEvaluation().argument_ = *(*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
+                    CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
+                    return;
+                }
+                else if (CommandExecutor::getEvaluation().listOfPossibleArguments_.size() == 0)
+                {
+std::cout << "3_2\n";
+                    // The user tries something new - we let him do
+                    CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
+                    CommandExecutor::getEvaluation().argument_ = CommandExecutor::getLastArgument();
+                    return;
+                }
+                else
+                {
+std::cout << "3_3\n";
+                    // There are several possibilities
+                    unsigned int argumentNumber = CommandExecutor::argumentsGiven() - 1;
+                    if (CommandExecutor::getEvaluation().functionclass_)
+                        argumentNumber -= 1;
+
+                    CommandExecutor::getEvaluation().argument_ = CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleArguments_);
+                    CommandExecutor::getEvaluation().possibleArgument_ = CommandExecutor::getPossibleArgument(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().function_, argumentNumber);
+                    CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
+                    return;
+                }
             }
             case CS_Finished:
+std::cout << "4\n";
             {
                 // Nothing more to do
@@ -373 +436 @@
     {
         if (CommandExecutor::getEvaluation().functionclass_)
-            return (CommandExecutor::getEvaluation().commandTokens_.size() >= (2 + command->getParamCount()));
-        else
-            return (CommandExecutor::getEvaluation().commandTokens_.size() >= (1 + command->getParamCount()));
+            return (CommandExecutor::argumentsGiven() > (2 + command->getParamCount()));
+        else
+            return (CommandExecutor::argumentsGiven() > (1 + command->getParamCount()));
     }
 
@@ -388 +451 @@
     std::string CommandExecutor::getLastArgument()
     {
-        return CommandExecutor::getArgument(CommandExecutor::argumentsGiven());
+        return CommandExecutor::getArgument(CommandExecutor::argumentsGiven() - 1);
     }
 
@@ -462 +525 @@
     }
 
-    const std::string* CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
+    std::string CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
     {
         std::string lowercase = getLowercase(name);
         for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(param); it != command->getArgumentCompletionListEnd(param); ++it)
             if ((*it).first == lowercase)
-                return &(*it).second;
+                return (*it).second;
 
         return 0;

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

@@ -91 +91 @@
             static Identifier* getPossibleIdentifier(const std::string& name);
             static ConsoleCommand* getPossibleCommand(const std::string& name, Identifier* identifier = 0);
-            static const std::string* getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param);
+            static std::string getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param);
 
             static std::string getCommonBegin(const std::list<std::pair<const std::string*, const std::string*> >& list);

code/branches/console/src/orxonox/objects/SpaceShip.cc

@@ -54 +54 @@
 {
     SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommandGeneric(test1, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommandGeneric(test2, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommandGeneric(test3, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test1, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test2, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test3, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
 
     CreateFactory(SpaceShip);