Sugared operators and helper functions starting to work

langkit/langkit_parser.cpp

@@ -1,6 +1,8 @@
 // This file is distributed under the BSD License.
 // See LICENSE.TXT for details.
 
+#include <boost/bind.hpp>
+
 #include <iostream>
 #include <utility>
 
@@ -33,18 +35,18 @@ std::pair<Token_Iterator, bool> Type_Rule(Token_Iterator iter, Token_Iterator en
     return std::pair<Token_Iterator, bool>(iter, false);
 }
 
-std::pair<Token_Iterator, bool> Or_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep) {
+std::pair<Token_Iterator, bool> Or_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, Rule lhs, Rule rhs) {
     Token_Iterator new_iter;
     unsigned int prev_size = parent->children.size();
 
     if (*iter != *end) {
-        std::pair<Token_Iterator, bool> result = lhs->rule(iter, end, parent);
+        std::pair<Token_Iterator, bool> result = lhs(iter, end, parent);
 
         if (result.second) {
             return std::pair<Token_Iterator, bool>(result.first, true);
         }
         else {
-            result = rhs->rule(iter, end, parent);
+            result = rhs(iter, end, parent);
             if (result.second) {
                 return std::pair<Token_Iterator, bool>(result.first, true);
             }
@@ -59,15 +61,15 @@ std::pair<Token_Iterator, bool> Or_Rule(Token_Iterator iter, Token_Iterator end,
     return std::pair<Token_Iterator, bool>(iter, false);
 }
 
-std::pair<Token_Iterator, bool> And_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep) {
+std::pair<Token_Iterator, bool> And_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, Rule lhs, Rule rhs) {
     Token_Iterator lhs_iter, rhs_iter;
     unsigned int prev_size = parent->children.size();
 
     if (*iter != *end) {
-        std::pair<Token_Iterator, bool> result = lhs->rule(iter, end, parent);
+        std::pair<Token_Iterator, bool> result = lhs(iter, end, parent);
 
         if (result.second) {
-            result = rhs->rule(result.first, end, parent);
+            result = rhs(result.first, end, parent);
             if (result.second) {
                 return std::pair<Token_Iterator, bool>(result.first, true);
             }
@@ -83,5 +85,12 @@ std::pair<Token_Iterator, bool> And_Rule(Token_Iterator iter, Token_Iterator end
 }
 
 std::pair<Token_Iterator, bool> Rule::operator()(Token_Iterator iter, Token_Iterator end, TokenPtr parent) {
-    return this->rule(iter, end, parent);
+    return impl->rule(iter, end, parent);
+}
+
+Rule Str(const std::string &text, bool keep) {
+    return Rule(boost::bind(String_Rule, _1, _2, _3, text, keep));
+}
+Rule Id(int id, bool keep) {
+    return Rule(boost::bind(Type_Rule, _1, _2, _3, id, keep));
 }

langkit/langkit_parser.hpp

@@ -9,17 +9,16 @@
 #include "langkit_lexer.hpp"
 
 typedef std::vector<TokenPtr>::iterator Token_Iterator;
-typedef std::tr1::shared_ptr<struct Rule> RulePtr;
+typedef std::tr1::shared_ptr<struct RuleImpl> RuleImplPtr;
 typedef boost::function<std::pair<Token_Iterator, bool>(Token_Iterator iter, Token_Iterator end, TokenPtr parent)> RuleFun;
 
-struct Rule {
+struct RuleImpl {
     int identifier;
     RuleFun rule;
-    std::pair<Token_Iterator, bool> operator()(Token_Iterator iter, Token_Iterator end, TokenPtr parent);
 
-    Rule() : identifier(-1) {}
+    RuleImpl() : identifier(-1) {}
-    Rule(int id) : identifier(id) {}
+    RuleImpl(int id) : identifier(id) {}
-    Rule(RuleFun fun) : rule(fun) {}
+    RuleImpl(RuleFun fun) : rule(fun) {}
 };
 
 std::pair<Token_Iterator, bool> String_Rule
@@ -29,10 +28,46 @@ std::pair<Token_Iterator, bool> Type_Rule
     (Token_Iterator iter, Token_Iterator end, TokenPtr parent, const int val, bool keep);
 
 std::pair<Token_Iterator, bool> Or_Rule
-    (Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep);
+    (Token_Iterator iter, Token_Iterator end, TokenPtr parent, struct Rule lhs, struct Rule rhs);
 
 std::pair<Token_Iterator, bool> And_Rule
-    (Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep);
+    (Token_Iterator iter, Token_Iterator end, TokenPtr parent, struct Rule lhs, struct Rule rhs);
+
+struct Rule {
+    Rule() : impl(new RuleImpl(-1)) {}
+    Rule(int id) : impl(new RuleImpl(id)) {}
+    Rule(RuleFun fun) : impl(new RuleImpl(fun)) {}
+
+    std::pair<Token_Iterator, bool> operator()(Token_Iterator iter, Token_Iterator end, TokenPtr parent);
+
+    Rule &operator=(const Rule &rule) {
+        impl->identifier = rule.get_impl()->identifier;
+        impl->rule = rule.get_impl()->rule;
+
+        return *this;
+    }
+
+    Rule operator|(const Rule &rhs) {
+        return Rule(boost::bind(Or_Rule, _1, _2, _3, *this, rhs));
+    }
+
+    Rule operator&(const Rule &rhs) {
+        return Rule(boost::bind(And_Rule, _1, _2, _3, *this, rhs));
+    }
+
+    void set_rule(RuleFun fun) {
+        impl->rule = fun;
+    }
+
+    const RuleImplPtr get_impl() const { return impl; }
+
+private:
+    RuleImplPtr impl;
+};
+
+
+Rule Str(const std::string &text, bool keep);
+Rule Id(int id, bool keep);
 
 
 #endif /* LANGKIT_PARSER_HPP_ */

langkit/main.cpp

@@ -62,21 +62,25 @@ void parse(std::vector<TokenPtr> &tokens) {
         debug_print(parent, "");
     }
     */
-    RulePtr lhs (new Rule());
+    Rule lhs;
-    RulePtr rhs (new Rule());
+    Rule rhs;
-    RulePtr rule (new Rule(boost::bind(Or_Rule, _1, _2, _3, lhs, rhs, true)));
+    Rule rule = lhs & rhs; //(boost::bind(And_Rule, _1, _2, _3, lhs, rhs));
-    lhs->rule = boost::bind(String_Rule, _1, _2, _3, "def", true);
+    lhs = Str("def", true);
-    rhs->rule = boost::bind(String_Rule, _1, _2, _3, "int", true);
+    rhs = Str("int", true);
 
     Token_Iterator iter = tokens.begin(), end = tokens.end();
     TokenPtr parent(new Token("Root", 0, "test"));
 
-    std::pair<Token_Iterator, bool> results = (*rule)(iter, end, parent);
+    std::pair<Token_Iterator, bool> results = rule(iter, end, parent);
 
     if (results.second) {
         std::cout << "Parse successful: " << std::endl;
         debug_print(parent, "");
     }
+    else {
+        std::cout << "Parse failed: " << std::endl;
+        debug_print(parent, "");
+    }
 
 }
 
@@ -107,7 +111,7 @@ int main(int argc, char *argv[]) {
         std::getline(std::cin, input);
         while (input != "quit") {
             std::vector<TokenPtr> tokens = lexer.lex(input, "INPUT");
-            debug_print(tokens);
+            //debug_print(tokens);
             parse(tokens);
 
             std::cout << "Expression> ";