Changeset 994 for code/branches/core2/src/orxonox/core/CommandExecutor.cc

Timestamp:

Apr 5, 2008, 5:54:24 PM (16 years ago)

Author:

landauf

Message:

• added some symbols to the CommandExecutor: a) expression | expression: the pipe leads the output from the right expression into the left one b) expression > file: writes the output of the expression into a file c) expression < file: reads a file and uses it's content as input for the expression

• added new console commands: a) echo text: returns the input b) read file: reads a file and returns the content c) write file text: writes text into a file d) append file text: appends text to a file

• added stripEnclosingQuotes function to String.h, that removes enclosing quotes (if there are some). whitespaces outside the quotes are stripped, whitespaces inside the quotes stay. removes the quotes only if there is nothing else than whitespaces outside of them. what it changes: "expression" → expression what it let unchanged:
  • ex"press"ion
  • a"expression"b
  • a"expression"
  • "expression"b
  • express"ion

• extended SubString: added some bools to determine the behaviour when dividing a string like the following up into pieces: mytext "this is a quoted area" blub (0, 1, 2)

this usually results in:
mytext / this is a quoted area / blub / 0, 1, 2

but now you can change it to:
mytext / "this is a quoted area" / blub / (0, 1, 2)

this is important if the string wents through several substring splitups and the quotes and brackets should stay.

File:

• code/branches/core2/src/orxonox/core/CommandExecutor.cc (modified) (8 diffs)

code/branches/core2/src/orxonox/core/CommandExecutor.cc

@@ -46 +46 @@
 
     ConsoleCommandShortcutExtern(exec, AccessLevel::None);
+    ConsoleCommandShortcutExtern(echo, AccessLevel::None);
+
+    ConsoleCommandShortcutExtern(read, AccessLevel::None);
+    ConsoleCommandShortcutExtern(append, AccessLevel::None);
+    ConsoleCommandShortcutExtern(write, AccessLevel::None);
 
     void exec(const std::string& filename)
@@ -79 +84 @@
 
         executingFiles.erase(filename);
+        file.close();
+    }
+
+    std::string echo(const std::string& text)
+    {
+        return text;
+    }
+
+    void write(const std::string& filename, const std::string& text)
+    {
+        std::ofstream file;
+        file.open(filename.c_str(), std::fstream::out);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't write to file \"" << filename << "\"." << std::endl;
+            return;
+        }
+
+        file << text << std::endl;
+        file.close();
+    }
+
+    void append(const std::string& filename, const std::string& text)
+    {
+        std::ofstream file;
+        file.open(filename.c_str(), std::fstream::app);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't append to file \"" << filename << "\"." << std::endl;
+            return;
+        }
+
+        file << text << std::endl;
+        file.close();
+    }
+
+    std::string read(const std::string& filename)
+    {
+        std::ifstream file;
+        file.open(filename.c_str(), std::fstream::in);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't read from file \"" << filename << "\"." << std::endl;
+            return "";
+        }
+
+        std::string output = "";
+        char line[1024];
+        while (file.good() && !file.eof())
+        {
+            file.getline(line, 1024);
+            output += line;
+            output += "\n";
+        }
+
+        file.close();
+
+        return output;
     }
 
@@ -200 +266 @@
     }
 
+    MultiTypeMath CommandEvaluation::getReturnvalue() const
+    {
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+            if (this->shortcut_)
+                return this->shortcut_->getReturnvalue();
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+            if (this->function_)
+                return this->function_->getReturnvalue();
+        }
+
+        return MT_null;
+    }
+
 
     /////////////////////
@@ -252 +334 @@
     bool CommandExecutor::execute(const std::string& command)
     {
-        if ((CommandExecutor::getEvaluation().processedCommand_ != command) || (CommandExecutor::getEvaluation().state_ == CS_Uninitialized))
-            CommandExecutor::parse(command);
+        std::string strippedCommand = getStrippedEnclosingQuotes(command);
+
+        SubString tokensIO(strippedCommand, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
+        if (tokensIO.size() >= 2)
+        {
+            if (tokensIO[tokensIO.size() - 2] == ">")
+            {
+                bool success = CommandExecutor::execute(tokensIO.subSet(0, tokensIO.size() - 2).join());
+                write(tokensIO[tokensIO.size() - 1], CommandExecutor::getEvaluation().getReturnvalue());
+                return success;
+            }
+            else if (tokensIO[tokensIO.size() - 2] == "<")
+            {
+                std::string input = read(tokensIO[tokensIO.size() - 1]);
+                if (input == "" || input.size() == 0)
+                    return CommandExecutor::execute(tokensIO.subSet(0, tokensIO.size() - 2).join());
+                else
+                    return CommandExecutor::execute(tokensIO.subSet(0, tokensIO.size() - 2).join() + " " + input);
+            }
+        }
+
+
+        SubString tokensPipeline(strippedCommand, "|", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
+        if (tokensPipeline.size() > 1)
+        {
+            bool success = true;
+            std::string returnValue = "";
+            for (int i = tokensPipeline.size() - 1; i >= 0; i--)
+            {
+                if (returnValue == "" || returnValue.size() == 0)
+                {
+                    //CommandEvaluation evaluation = CommandExecutor::evaluate(tokens[i]);
+                    if (!CommandExecutor::execute(tokensPipeline[i]))
+                        success = false;
+                }
+                else
+                {
+                    //CommandEvaluation evaluation = CommandExecutor::evaluate(tokens[i] + " " + returnValue);
+                    if (!CommandExecutor::execute(tokensPipeline[i] + " " + returnValue))
+                        success = false;
+                }
+
+                //CommandExecutor::execute(evaluation);
+                //returnValue = evaluation.getReturnvalue();
+                returnValue = CommandExecutor::getEvaluation().getReturnvalue().toString();
+            }
+            return success;
+        }
+
+        if ((CommandExecutor::getEvaluation().processedCommand_ != strippedCommand) || (CommandExecutor::getEvaluation().state_ == CS_Uninitialized))
+            CommandExecutor::parse(strippedCommand);
 
         return CommandExecutor::execute(CommandExecutor::getEvaluation());
@@ -261 +392 @@
     bool CommandExecutor::execute(const CommandEvaluation& evaluation)
     {
-        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
 
         if (evaluation.bEvaluatedParams_ && evaluation.evaluatedExecutor_)
@@ -353 +484 @@
     std::string CommandExecutor::complete(const CommandEvaluation& evaluation)
     {
-        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
 
         std::list<std::pair<const std::string*, const std::string*> > temp;
@@ -444 +575 @@
     std::string CommandExecutor::hint(const CommandEvaluation& evaluation)
     {
-        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        SubString tokens(evaluation.processedCommand_, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
 
         switch (evaluation.state_)
@@ -516 +647 @@
     void CommandExecutor::parse(const std::string& command, bool bInitialize)
     {
-        CommandExecutor::getEvaluation().tokens_.split((command + COMMAND_EXECUTOR_CURSOR), " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        CommandExecutor::getEvaluation().tokens_.split((command + COMMAND_EXECUTOR_CURSOR), " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
         CommandExecutor::getEvaluation().processedCommand_ = command;