added FbTk::CommandRegistry, decentralized command parsing, and made them auto-register

8 files changed, 382 insertions, 1 deletions

diff --git a/src/FbTk/CommandRegistry.cc b/src/FbTk/CommandRegistry.cc
new file mode 100644
index 0000000..1d16c75
--- /dev/null
+++ b/src/FbTk/CommandRegistry.cc
@@ -0,0 +1,92 @@
+// CommandRegistry.cc for FbTk
+// Copyright (c) 2007 Fluxbox Team (fluxgen at fluxbox dot org)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+// $Id: $
+
+#include "CommandRegistry.hh"
+#include "Command.hh"
+#include "StringUtil.hh"
+
+#include <iostream>
+
+namespace FbTk {
+
+CommandRegistry &CommandRegistry::instance() {
+    static CommandRegistry s_instance;
+    return s_instance;
+}
+
+
+bool CommandRegistry::registerCommand(string name,
+                                      CreateFunction createFunction) {
+    name = StringUtil::toLower(name);
+    m_commandCreators[name] = createFunction;
+    return true;
+}
+
+bool CommandRegistry::registerBoolCommand(string name,
+                                          BoolCreateFunction createFunction) {
+    name = StringUtil::toLower(name);
+    m_boolcommandCreators[name] = createFunction;
+    return true;
+}
+
+Command *CommandRegistry::parseLine(const string &line, bool trusted) const {
+    // parse args and command
+    string command, args;
+    StringUtil::getFirstWord(line, command, args);
+
+    // now we have parsed command and args
+    command = StringUtil::toLower(command);
+    return getCommand(command, args, trusted);
+}
+
+BoolCommand *CommandRegistry::parseBoolLine(const string &line, bool trusted) const {
+    // parse args and command
+    string command, args;
+    StringUtil::getFirstWord(line, command, args);
+
+    // now we have parsed command and args
+    command = StringUtil::toLower(command);
+    return getBoolCommand(command, args, trusted);
+}
+
+Command *CommandRegistry::getCommand(const string &name, const string &args,
+                                     bool trusted) const {
+    string lc = StringUtil::toLower(name);
+    CreatorMap::const_iterator it = m_commandCreators.find(lc.c_str());
+    if (it == m_commandCreators.end())
+        return 0;
+    else
+        return it->second(name, args, trusted);
+}
+
+BoolCommand *CommandRegistry::getBoolCommand(const string &name,
+        const string &args, bool trusted) const {
+    string lc = StringUtil::toLower(name);
+    BoolCreatorMap::const_iterator it = m_boolcommandCreators.find(lc.c_str());
+    if (it == m_boolcommandCreators.end())
+        return 0;
+    else
+        return it->second(name, args, trusted);
+}
+
+}; // end namespace FbTk
diff --git a/src/FbTk/CommandRegistry.hh b/src/FbTk/CommandRegistry.hh
new file mode 100644
index 0000000..f3b6880
--- /dev/null
+++ b/src/FbTk/CommandRegistry.hh
@@ -0,0 +1,130 @@
+// CommandRegistry.hh for FbTk
+// Copyright (c) 2007 Fluxbox Team (fluxgen at fluxbox dot org)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+// $Id: $
+
+#ifndef COMMANDREGISTRY_HH
+#define COMMANDREGISTRY_HH
+
+#include <string>
+#include <map>
+
+using std::string;
+
+namespace FbTk {
+class Command;
+class BoolCommand;
+
+#define REGISTER_COMMAND_PARSER(name, parser) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerCommand(#name, parser); \
+  }
+
+#define REGISTER_BOOLCOMMAND_PARSER(name, parser) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerBoolCommand(#name, parser); \
+  }
+
+/* Include some basic command creators */
+template <typename Cmd, typename Ret>
+Ret *CommandCreator(const string &name, const string &args, bool trusted) {
+    return new Cmd();
+}
+
+#define REGISTER_COMMAND(name, classname) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerCommand(#name, FbTk::CommandCreator<classname, FbTk::Command>); \
+  }
+
+template <typename Cmd, typename Ret>
+Ret *CommandCreatorWithArgs(const string &name, const string &args,
+                            bool trusted) {
+    return new Cmd(args);
+}
+
+#define REGISTER_COMMAND_WITH_ARGS(name, classname) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerCommand(#name, FbTk::CommandCreatorWithArgs<classname, FbTk::Command>); \
+  }
+
+#define REGISTER_BOOLCOMMAND_WITH_ARGS(name, classname) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerBoolCommand(#name, FbTk::CommandCreatorWithArgs<classname, FbTk::BoolCommand>); \
+  }
+
+template <typename Cmd, typename Ret>
+Ret *UntrustedCommandCreator(const string &name, const string &args,
+                             bool trusted) {
+    if (!trusted) return 0;
+    return new Cmd();
+}
+
+#define REGISTER_UNTRUSTED_COMMAND(name, classname) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerCommand(#name, FbTk::UntrustedCommandCreator<classname, FbTk::Command>); \
+  }
+
+template <typename Cmd, typename Ret>
+Ret * UntrustedCommandCreatorWithArgs(const string &name, const string &args,
+                                      bool trusted) {
+    if (!trusted) return 0;
+    return new Cmd(args);
+}
+
+#define REGISTER_UNTRUSTED_COMMAND_WITH_ARGS(name, classname) \
+  namespace { \
+    static const bool p_register_##name = FbTk::CommandRegistry::instance().registerCommand(#name, FbTk::UntrustedCommandCreatorWithArgs<classname, FbTk::Command>); \
+  }
+
+/* Not built to be virtual at the moment */
+class CommandRegistry {
+public:
+    typedef Command * CreateFunction(const string &name, const string &args, bool trusted);
+    typedef BoolCommand * BoolCreateFunction(const string &name,
+                                             const string &args, bool trusted);
+    typedef std::map<string, CreateFunction *> CreatorMap;
+    typedef std::map<string, BoolCreateFunction *> BoolCreatorMap;
+
+    static CommandRegistry &instance();
+
+    Command *parseLine(const string &line, bool trusted = true) const;
+    BoolCommand *parseBoolLine(const string &line, bool trusted = true) const;
+    Command *getCommand(const string &name, const string &args, bool trusted) const;
+    BoolCommand *getBoolCommand(const string &name, const string &args,
+                                bool trusted) const;
+
+    /* Note: the ownership of this object passes to this class */
+    bool registerCommand(string name, CreateFunction createFunction);
+    bool registerBoolCommand(string name, BoolCreateFunction bcf);
+
+    const CreatorMap commandMap() const { return m_commandCreators; }
+
+private:
+    CommandRegistry() {}
+    ~CommandRegistry() {}
+
+    CreatorMap m_commandCreators;
+    BoolCreatorMap m_boolcommandCreators;
+};
+
+}; // end namespace FbTk
+
+#endif // COMMANDREGISTRY_HH
diff --git a/src/FbTk/LogicCommands.cc b/src/FbTk/LogicCommands.cc
index 99b5b53..1c6f238 100644
--- a/src/FbTk/LogicCommands.cc
+++ b/src/FbTk/LogicCommands.cc
@@ -23,8 +23,101 @@
 
 #include "LogicCommands.hh"
 
+#include "CommandRegistry.hh"
+#include "StringUtil.hh"
+
+using FbTk::StringUtil::removeFirstWhitespace;
+using FbTk::StringUtil::toLower;
+using std::string;
+
 namespace FbTk {
 
+namespace {
+
+template <typename M>
+M *addCommands(M *macro, const string &args, bool trusted) {
+    int pos = 0, err = 0;
+    string cmd;
+
+    while (true) {
+        RefCount<BoolCommand> tmp(0);
+        err = StringUtil::getStringBetween(cmd, args.c_str() + pos,
+                                           '{', '}', " \t\n", true);
+        pos += err;
+        if (err == 0)
+            break;
+
+        tmp = CommandRegistry::instance().parseBoolLine(cmd, trusted);
+        if (*tmp)
+            macro->add(tmp);
+    }
+
+    if (macro->size() > 0)
+        return macro;
+    delete macro;
+    return 0;
+}
+
+BoolCommand *parseLogicCommand(const string &command, const string &args,
+                               bool trusted) {
+    if (command == "not") {
+        BoolCommand *boolcmd =
+                CommandRegistry::instance().parseBoolLine(args, trusted);
+        if (!boolcmd)
+            return 0;
+        RefCount<BoolCommand> ref(boolcmd);
+        return new NotCommand(ref);
+    } else if (command == "and")
+        return addCommands<AndCommand>(new AndCommand(), args, trusted);
+    else if (command == "or")
+        return addCommands<OrCommand>(new OrCommand(), args, trusted);
+    else if (command == "xor")
+        return addCommands<XorCommand>(new XorCommand(), args, trusted);
+    return 0;
+}
+
+REGISTER_BOOLCOMMAND_PARSER(not, parseLogicCommand);
+REGISTER_BOOLCOMMAND_PARSER(and, parseLogicCommand);
+REGISTER_BOOLCOMMAND_PARSER(or, parseLogicCommand);
+REGISTER_BOOLCOMMAND_PARSER(xor, parseLogicCommand);
+
+}; // end anonymous namespace
+
+Command *IfCommand::parse(const std::string &command, const std::string &args,
+                          bool trusted) {
+    std::string cmd;
+    int err = 0, pos = 0;
+    RefCount<BoolCommand> cond(0);
+    RefCount<Command> t(0), f(0);
+
+    err = StringUtil::getStringBetween(cmd, args.c_str(),
+                                       '{', '}', " \t\n", true);
+    if (err > 0)
+        cond = CommandRegistry::instance().parseBoolLine(cmd, trusted);
+    if (err == 0 || *cond == 0)
+        return 0;
+
+    pos = err;
+    err = StringUtil::getStringBetween(cmd, args.c_str() + pos,
+                                       '{', '}', " \t\n", true);
+    if (err == 0)
+        return 0;
+    t = CommandRegistry::instance().parseLine(cmd, trusted);
+
+    pos += err;
+    err = StringUtil::getStringBetween(cmd, args.c_str() + pos,
+                                       '{', '}', " \t\n", true);
+    if (err > 0)
+        f = CommandRegistry::instance().parseLine(cmd, trusted);
+    if (err == 0 || *t == 0 && *f == 0)
+        return 0;
+
+    return new IfCommand(cond, t, f);
+}
+
+REGISTER_COMMAND_PARSER(if, IfCommand::parse);
+REGISTER_COMMAND_PARSER(cond, IfCommand::parse);
+
 void OrCommand::add(RefCount<BoolCommand> &com) {
     m_commandlist.push_back(com);
 }
diff --git a/src/FbTk/LogicCommands.hh b/src/FbTk/LogicCommands.hh
index 4f20864..3eb3e8c 100644
--- a/src/FbTk/LogicCommands.hh
+++ b/src/FbTk/LogicCommands.hh
@@ -27,6 +27,7 @@
 #include "Command.hh"
 #include "RefCount.hh"
 
+#include <string>
 #include <vector>
 
 namespace FbTk {
@@ -43,7 +44,8 @@ public:
         } else
             if (*m_f) m_f->execute();
     }
-
+    static Command *parse(const std::string &cmd, const std::string &args,
+                          bool trusted);
 private:
     RefCount<BoolCommand> m_cond;
     RefCount<Command> m_t, m_f;
diff --git a/src/FbTk/MacroCommand.cc b/src/FbTk/MacroCommand.cc
index 491b01e..20e91e4 100644
--- a/src/FbTk/MacroCommand.cc
+++ b/src/FbTk/MacroCommand.cc
@@ -23,8 +23,56 @@
 
 #include "MacroCommand.hh"
 
+#include "CommandRegistry.hh"
+#include "StringUtil.hh"
+
+#include <string>
+
 namespace FbTk {
 
+namespace {
+
+template <typename M>
+M *addCommands(M *macro, const std::string &args, bool trusted) {
+
+    std::string cmd;
+    int err = 0;
+    int pos = 0;
+
+    while (true) {
+        RefCount<Command> next(0);
+        pos += err;
+        err = StringUtil::getStringBetween(cmd, args.c_str() + pos,
+                                           '{', '}', " \t\n", true);
+        if (err == 0)
+            break;
+        if (err > 0)
+            next = CommandRegistry::instance().parseLine(cmd, trusted);
+        if (*next != 0)
+            macro->add(next);
+    }
+
+    if (macro->size() > 0)
+        return macro;
+
+    delete macro;
+    return 0;
+}
+
+Command *parseMacroCmd(const std::string &command, const std::string &args,
+                       bool trusted) {
+    if (command == "macrocmd")
+        return addCommands<MacroCommand>(new MacroCommand, args, trusted);
+    else if (command == "togglecmd")
+        return addCommands<ToggleCommand>(new ToggleCommand, args, trusted);
+    return 0;
+}
+
+REGISTER_COMMAND_PARSER(macrocmd, parseMacroCmd);
+REGISTER_COMMAND_PARSER(togglecmd, parseMacroCmd);
+
+}; // end anonymous namespace
+
 void MacroCommand::add(RefCount<Command> &com) {
     m_commandlist.push_back(com);
 }
diff --git a/src/FbTk/Makefile.am b/src/FbTk/Makefile.am
index 2bf9da7..f3e928d 100644
--- a/src/FbTk/Makefile.am
+++ b/src/FbTk/Makefile.am
@@ -16,6 +16,7 @@ imlib2_SOURCE= ImageImlib2.hh ImageImlib2.cc
 endif
 
 libFbTk_a_SOURCES = App.hh App.cc Color.cc Color.hh Command.hh \
+        CommandRegistry.hh CommandRegistry.cc \
         FileUtil.hh FileUtil.cc \
         EventHandler.hh EventManager.hh EventManager.cc \
         FbWindow.hh FbWindow.cc Font.cc Font.hh FontImp.hh \
diff --git a/src/FbTk/StringUtil.cc b/src/FbTk/StringUtil.cc
index 869a3b5..9b4928b 100644
--- a/src/FbTk/StringUtil.cc
+++ b/src/FbTk/StringUtil.cc
@@ -233,6 +233,18 @@ string::size_type removeTrailingWhitespace(string &str) {
     return first_pos;
 }
 
+void getFirstWord(const std::string &in, std::string &word, std::string &rest) {
+    word = in;
+    string::size_type first_pos = StringUtil::removeFirstWhitespace(word);
+    string::size_type second_pos = word.find_first_of(" \t", first_pos);
+    if (second_pos != string::npos) {
+        rest = word.substr(second_pos);
+        word.erase(second_pos);
+        removeFirstWhitespace(rest);
+        removeTrailingWhitespace(rest);
+    }
+}
+
 }; // end namespace StringUtil
 
 }; // end namespace FbTk
diff --git a/src/FbTk/StringUtil.hh b/src/FbTk/StringUtil.hh
index b45d6a2..7f0cf54 100644
--- a/src/FbTk/StringUtil.hh
+++ b/src/FbTk/StringUtil.hh
@@ -64,6 +64,9 @@ std::string basename(const std::string &basename);
 std::string::size_type removeFirstWhitespace(std::string &str);
 std::string::size_type removeTrailingWhitespace(std::string &str);
 
+/// removes the first part of a string and returns the two pieces
+void getFirstWord(const std::string &in, std::string &first, std::string &rest);
+
 /// Breaks a string into tokens
 template <typename Container>
 static void