Changeset 7221

Timestamp:

Aug 26, 2010, 2:06:16 AM (14 years ago)

Author:

landauf

Message:

adapted CommandExecutor and CommandEvaluation to make it compile again, but it doesn't run yet. ready for refactoring.

Location:

code/branches/consolecommands3/src/libraries/core/command

Files:

• CommandEvaluation.cc (modified) (10 diffs)
• CommandEvaluation.h (modified) (3 diffs)
• CommandExecutor.cc (modified) (13 diffs)
• CommandExecutor.h (modified) (3 diffs)
• ConsoleCommand.cc (modified) (1 diff)
• ConsoleCommand.h (modified) (2 diffs)

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.cc

@@ -67 +67 @@
     }
 
-    bool CommandEvaluation::isValid() const
-    {
-        return (this->function_);
-    }
-
     bool CommandEvaluation::execute() const
     {
@@ -84 +79 @@
             *success = false;
 
-        if (!this->isValid())
+        if (!this->function_ || !this->function_->isActive())
             return MT_Type::Null;
 
@@ -92 +87 @@
                 *success = true;
             COUT(6) << "CE_execute (evaluation): " << this->function_->getName() << ' ' << this->param_[0] << ' ' << this->param_[1] << ' ' << this->param_[2] << ' ' << this->param_[3] << ' ' << this->param_[4] << std::endl;
-            return (*this->function_)(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
+            return (*this->function_->getExecutor())(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
         }
 
@@ -101 +96 @@
             unsigned int startindex = this->getStartindex();
             if (this->commandTokens_.size() > startindex)
-                return this->function_->parse(removeSlashes(this->commandTokens_.subSet(startindex).join() + this->getAdditionalParameter()), success);
+                return this->function_->getExecutor()->parse(removeSlashes(this->commandTokens_.subSet(startindex).join() + this->getAdditionalParameter()), success);
             else
-                return this->function_->parse(removeSlashes(this->additionalParameter_), success);
+                return this->function_->getExecutor()->parse(removeSlashes(this->additionalParameter_), success);
         }
 
@@ -122 +117 @@
                     if (this->function_)
                     {
-                        if (this->function_->getParamCount() == 0)
+                        if (this->function_->getExecutor()->getParamCount() == 0)
                             return (this->command_ = this->function_->getName());
                         else
@@ -133 +128 @@
                     if (this->function_)
                     {
-                        if (this->function_->getParamCount() == 0)
+                        if (this->function_->getExecutor()->getParamCount() == 0)
                             return (this->command_ = this->functionclass_->getName() + ' ' + this->function_->getName());
                         else
@@ -153 +148 @@
                     {
                         this->argument_ = this->possibleArgument_;
-                        if (this->function_->getParamCount() > (maxIndex + 1 - this->getStartindex()))
+                        if (this->function_->getExecutor()->getParamCount() > (maxIndex + 1 - this->getStartindex()))
                             whitespace = " ";
                     }
@@ -213 +208 @@
             this->param_[i] = MT_Type::Null;
 
-        if (!this->isValid())
+        if (!this->function_)
             return;
 
@@ -220 +215 @@
         if (this->commandTokens_.size() <= startindex)
         {
-            if (this->function_->evaluate(this->getAdditionalParameter(), this->param_, " "))
+            if (this->function_->getBaseExecutor()->evaluate(this->getAdditionalParameter(), this->param_, " "))
                 this->bEvaluatedParams_ = true;
         }
         else if (this->commandTokens_.size() > startindex)
         {
-            if (this->function_->evaluate(this->commandTokens_.subSet(startindex).join() + this->getAdditionalParameter(), this->param_, " "))
+            if (this->function_->getBaseExecutor()->evaluate(this->commandTokens_.subSet(startindex).join() + this->getAdditionalParameter(), this->param_, " "))
                 this->bEvaluatedParams_ = true;
         }
@@ -280 +275 @@
     }
 
-    std::string CommandEvaluation::dump(const ConsoleCommand* command)
+    std::string CommandEvaluation::dump(const _ConsoleCommand* command)
     {
         std::string output = command->getName();
-        if (command->getParamCount() > 0)
+        if (command->getExecutor()->getParamCount() > 0)
             output += ": ";
 
-        for (unsigned int i = 0; i < command->getParamCount(); i++)
+        for (unsigned int i = 0; i < command->getExecutor()->getParamCount(); i++)
         {
             if (i != 0)
                 output += ' ';
 
-            if (command->defaultValueSet(i))
+            if (command->getExecutor()->defaultValueSet(i))
                 output += '[';
             else
                 output += '{';
 
-            output += command->getTypenameParam(i);
-
-            if (command->defaultValueSet(i))
-                output += '=' + command->getDefaultValue(i).getString() + ']';
+            output += command->getExecutor()->getTypenameParam(i);
+
+            if (command->getExecutor()->defaultValueSet(i))
+                output += '=' + command->getExecutor()->getDefaultValue(i).getString() + ']';
             else
                 output += '}';

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.h

@@ -72 +72 @@
             void evaluateParams();
 
-            bool isValid() const;
+            bool isValid() const
+                { return this->function_; }
 
-            inline ConsoleCommand* getConsoleCommand() const
+            inline _ConsoleCommand* getConsoleCommand() const
                 { return this->function_; }
             inline const std::string& getOriginalCommand() const
@@ -93 +94 @@
             static std::string dump(const std::list<std::pair<const std::string*, const std::string*> >& list);
             static std::string dump(const ArgumentCompletionList& list);
-            static std::string dump(const ConsoleCommand* command);
+            static std::string dump(const _ConsoleCommand* command);
 
 
@@ -109 +110 @@
 
             Identifier* functionclass_;
-            ConsoleCommand* function_;
+            _ConsoleCommand* function_;
             std::string possibleArgument_;
             std::string argument_;

code/branches/consolecommands3/src/libraries/core/command/CommandExecutor.cc

@@ -49 +49 @@
     }
 
-    const CommandEvaluation& CommandExecutor::getLastEvaluation()
-    {
-        return CommandExecutor::getInstance().evaluation_;
-    }
-
     bool CommandExecutor::execute(const std::string& command, bool useTcl)
     {
@@ -216 +211 @@
                         CommandExecutor::getEvaluation().functionclass_ = 0;
                         CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().function_->getName();
-                        if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                        if (CommandExecutor::getEvaluation().function_->getExecutor()->getParamCount() > 0)
                         {
                             CommandExecutor::getEvaluation().command_ += ' ';
@@ -303 +298 @@
                             CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
                             CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + ' ' + CommandExecutor::getEvaluation().function_->getName();
-                            if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                            if (CommandExecutor::getEvaluation().function_->getExecutor()->getParamCount() > 0)
                             {
                                 CommandExecutor::getEvaluation().command_ += ' ';
@@ -335 +330 @@
             case CommandState::ParamPreparation:
             {
-                if (CommandExecutor::getEvaluation().function_->getParamCount() == 0 || CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().function_))
+                if (CommandExecutor::getEvaluation().function_->getExecutor()->getParamCount() == 0 || CommandExecutor::enoughArgumentsGiven(CommandExecutor::getEvaluation().function_))
                 {
                     CommandExecutor::getEvaluation().state_ = CommandState::Finished;
@@ -418 +413 @@
     }
 
-    bool CommandExecutor::enoughArgumentsGiven(ConsoleCommand* command)
+    bool CommandExecutor::enoughArgumentsGiven(_ConsoleCommand* command)
     {
         if (CommandExecutor::getEvaluation().functionclass_)
-            return (CommandExecutor::argumentsGiven() > (2 + command->getParamCount()));
-        else
-            return (CommandExecutor::argumentsGiven() > (1 + command->getParamCount()));
+            return (CommandExecutor::argumentsGiven() > (2 + command->getExecutor()->getParamCount()));
+        else
+            return (CommandExecutor::argumentsGiven() > (1 + command->getExecutor()->getParamCount()));
     }
 
@@ -441 +436 @@
     void CommandExecutor::createListOfPossibleIdentifiers(const std::string& fragment)
     {
+/*
         CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.clear();
         const std::string& lowercase = getLowercase(fragment);
@@ -447 +443 @@
                 if (it->first.find(lowercase) == 0 || fragment.empty())
                     CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
+*/
     }
 
     void CommandExecutor::createListOfPossibleFunctions(const std::string& fragment, Identifier* identifier)
     {
+/*
         CommandExecutor::getEvaluation().listOfPossibleFunctions_.clear();
         const std::string& lowercase = getLowercase(fragment);
         if (!identifier)
         {
-            for (std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMapBegin(); it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd(); ++it)
+            for (std::map<std::string, _ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMapBegin(); it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd(); ++it)
                 if (it->first.find(lowercase) == 0 || fragment.empty())
                     CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
@@ -461 +459 @@
         else
         {
-            for (std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMapBegin(); it != identifier->getLowercaseConsoleCommandMapEnd(); ++it)
+            for (std::map<std::string, _ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMapBegin(); it != identifier->getLowercaseConsoleCommandMapEnd(); ++it)
                 if (it->first.find(lowercase) == 0 || fragment.empty())
                     CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
         }
-    }
-
-    void CommandExecutor::createListOfPossibleArguments(const std::string& fragment, ConsoleCommand* command, unsigned int param)
-    {
+*/
+    }
+
+    void CommandExecutor::createListOfPossibleArguments(const std::string& fragment, _ConsoleCommand* command, unsigned int param)
+    {
+/*
         CommandExecutor::createArgumentCompletionList(command, param);
 
@@ -486 +486 @@
             }
         }
+*/
     }
 
     Identifier* CommandExecutor::getPossibleIdentifier(const std::string& name)
     {
+/*
         const std::string& lowercase = getLowercase(name);
         std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMap().find(lowercase);
         if ((it != Identifier::getLowercaseStringIdentifierMapEnd()) && it->second->hasConsoleCommands())
             return it->second;
-
+*/
         return 0;
     }
 
-    ConsoleCommand* CommandExecutor::getPossibleCommand(const std::string& name, Identifier* identifier)
-    {
+    _ConsoleCommand* CommandExecutor::getPossibleCommand(const std::string& name, Identifier* identifier)
+    {
+/*
         const std::string& lowercase = getLowercase(name);
         if (!identifier)
         {
-            std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMap().find(lowercase);
+            std::map<std::string, _ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMap().find(lowercase);
             if (it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd())
                 return it->second;
@@ -509 +512 @@
         else
         {
-            std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMap().find(lowercase);
+            std::map<std::string, _ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMap().find(lowercase);
             if (it != identifier->getLowercaseConsoleCommandMapEnd())
                 return it->second;
         }
+*/
         return 0;
     }
 
-    const std::string& CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
-    {
+    const std::string& CommandExecutor::getPossibleArgument(const std::string& name, _ConsoleCommand* command, unsigned int param)
+    {
+/*
         CommandExecutor::createArgumentCompletionList(command, param);
 
@@ -534 +539 @@
             }
         }
-
+*/
         return BLANKSTRING;
     }
 
-    void CommandExecutor::createArgumentCompletionList(ConsoleCommand* command, unsigned int param)
-    {
+    void CommandExecutor::createArgumentCompletionList(_ConsoleCommand* command, unsigned int param)
+    {
+/*
         std::string params[5];
 
@@ -554 +560 @@
 
         command->createArgumentCompletionList(param, params[0], params[1], params[2], params[3], params[4]);
+*/
     }
 
@@ -643 +650 @@
         }
     }
-
-    void CommandExecutor::destroyExternalCommands()
-    {
-        for (std::set<ConsoleCommand*>::const_iterator it = CommandExecutor::getInstance().consoleCommandExternals_.begin();
-            it != CommandExecutor::getInstance().consoleCommandExternals_.end(); ++it)
-            delete *it;
-    }
 }

code/branches/consolecommands3/src/libraries/core/command/CommandExecutor.h

@@ -55 +55 @@
 
             static CommandEvaluation evaluate(const std::string& command);
-            static const CommandEvaluation& getLastEvaluation();
 
         private:
@@ -70 +69 @@
             static unsigned int argumentsFinished();
             static unsigned int argumentsGiven();
-            static bool enoughArgumentsGiven(ConsoleCommand* command);
+            static bool enoughArgumentsGiven(_ConsoleCommand* command);
             static const std::string& getArgument(unsigned int index);
             static const std::string& getLastArgument();
@@ -76 +75 @@
             static void createListOfPossibleIdentifiers(const std::string& fragment);
             static void createListOfPossibleFunctions(const std::string& fragment, Identifier* identifier = 0);
-            static void createListOfPossibleArguments(const std::string& fragment, ConsoleCommand* command, unsigned int param);
+            static void createListOfPossibleArguments(const std::string& fragment, _ConsoleCommand* command, unsigned int param);
 
             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 _ConsoleCommand* getPossibleCommand(const std::string& name, Identifier* identifier = 0);
+            static const std::string& getPossibleArgument(const std::string& name, _ConsoleCommand* command, unsigned int param);
 
-            static void createArgumentCompletionList(ConsoleCommand* command, unsigned int param);
+            static void createArgumentCompletionList(_ConsoleCommand* command, unsigned int param);
             static std::string getCommonBegin(const std::list<std::pair<const std::string*, const std::string*> >& list);
             static std::string getCommonBegin(const ArgumentCompletionList& list);

code/branches/consolecommands3/src/libraries/core/command/ConsoleCommand.cc

@@ -343 +343 @@
     }
 
-    void _ConsoleCommand::createArgumentCompletionList(unsigned int param, const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5)
-    {
-        if (param < 5 && this->argumentCompleter_[param])
-            this->argumentList_ = (*this->argumentCompleter_[param])(param1, param2, param3, param4, param5);
-        else
-            this->argumentList_.clear();
-    }
-
     _ConsoleCommand& _ConsoleCommand::description(const std::string& description)
     {

code/branches/consolecommands3/src/libraries/core/command/ConsoleCommand.h

@@ -268 +268 @@
             ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
 
-            void createArgumentCompletionList(unsigned int param, const std::string& param1 = "", const std::string& param2 = "", const std::string& param3 = "", const std::string& param4 = "", const std::string& param5 = "");
-            const ArgumentCompletionList& getArgumentCompletionList() const
-                { return this->argumentList_; }
-            ArgumentCompletionList::const_iterator getArgumentCompletionListBegin() const
-                { return this->argumentList_.begin(); }
-            ArgumentCompletionList::const_iterator getArgumentCompletionListEnd() const
-                { return this->argumentList_.end(); }
-
             inline _ConsoleCommand& setAsInputCommand()
             {
@@ -325 +317 @@
 
             ArgumentCompleter* argumentCompleter_[5];
-            ArgumentCompletionList argumentList_;
 
             KeybindMode::Value keybindMode_;