The parser is coming alive. Now can successfully parse And and Or rules

langkit/langkit_parser.cpp

@@ -1,6 +1,7 @@
 // This file is distributed under the BSD License.
 // See LICENSE.TXT for details.
 
+#include <iostream>
 #include <utility>
 
 #include "langkit_lexer.hpp"
@@ -32,39 +33,52 @@ 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 Rule &lhs, const Rule &rhs, bool keep, int new_id) {
+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 new_iter;
+    unsigned int prev_size = parent->children.size();
 
     if (*iter != *end) {
-        new_iter = lhs.rule(iter, end, parent).first;
+        std::pair<Token_Iterator, bool> result = lhs->rule(iter, end, parent);
 
-        if (new_iter != iter) {
-            return std::pair<Token_Iterator, bool>(new_iter, true);
+        if (result.second) {
+            return std::pair<Token_Iterator, bool>(result.first, true);
         }
         else {
-            new_iter = rhs.rule(iter, end, parent).first;
-            if (new_iter != iter) {
-                return std::pair<Token_Iterator, bool>(new_iter, true);
+            result = rhs->rule(iter, end, parent);
+            if (result.second) {
+                return std::pair<Token_Iterator, bool>(result.first, true);
             }
         }
     }
+
+    if (parent->children.size() != prev_size) {
+        //Clear out the partial matches
+        parent->children.erase(parent->children.begin() + prev_size, parent->children.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 Rule &lhs, const Rule &rhs, bool keep, int new_id) {
+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 lhs_iter, rhs_iter;
+    unsigned int prev_size = parent->children.size();
 
     if (*iter != *end) {
-        lhs_iter = lhs.rule(iter, end, parent).first;
+        std::pair<Token_Iterator, bool> result = lhs->rule(iter, end, parent);
 
-        if (lhs_iter != iter) {
-            rhs_iter = rhs.rule(iter, end, parent).first;
-            if (rhs_iter != iter) {
-                return std::pair<Token_Iterator, bool>(rhs_iter, true);
+        if (result.second) {
+            result = rhs->rule(result.first, end, parent);
+            if (result.second) {
+                return std::pair<Token_Iterator, bool>(result.first, true);
             }
         }
     }
 
+    if (parent->children.size() != prev_size) {
+        //Clear out the partial matches
+        parent->children.erase(parent->children.begin() + prev_size, parent->children.end());
+    }
+
     return std::pair<Token_Iterator, bool>(iter, false);
 }
 

langkit/langkit_parser.hpp

@@ -9,14 +9,17 @@
 #include "langkit_lexer.hpp"
 
 typedef std::vector<TokenPtr>::iterator Token_Iterator;
+typedef std::tr1::shared_ptr<struct Rule> RulePtr;
+typedef boost::function<std::pair<Token_Iterator, bool>(Token_Iterator iter, Token_Iterator end, TokenPtr parent)> RuleFun;
 
 struct Rule {
     int identifier;
-    boost::function<std::pair<Token_Iterator, bool>(Token_Iterator iter, Token_Iterator end, TokenPtr parent)> rule;
+    RuleFun rule;
     std::pair<Token_Iterator, bool> operator()(Token_Iterator iter, Token_Iterator end, TokenPtr parent);
 
     Rule() : identifier(-1) {}
     Rule(int id) : identifier(id) {}
+    Rule(RuleFun fun) : rule(fun) {}
 };
 
 std::pair<Token_Iterator, bool> String_Rule
@@ -26,10 +29,10 @@ 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 Rule &lhs, const Rule &rhs, bool keep, int new_id);
+    (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, const Rule &lhs, const Rule &rhs, bool keep, int new_id);
+    (Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep);
 
 
 #endif /* LANGKIT_PARSER_HPP_ */

langkit/main.cpp

@@ -48,6 +48,7 @@ std::string load_file(const char *filename) {
 }
 
 void parse(std::vector<TokenPtr> &tokens) {
+    /*
     Rule rule;
     rule.rule = boost::bind(String_Rule, _1, _2, _3, "def", true);
 
@@ -60,6 +61,22 @@ void parse(std::vector<TokenPtr> &tokens) {
         std::cout << "Parse successful: " << std::endl;
         debug_print(parent, "");
     }
+    */
+    RulePtr lhs (new Rule());
+    RulePtr rhs (new Rule());
+    RulePtr rule (new Rule(boost::bind(Or_Rule, _1, _2, _3, lhs, rhs, true)));
+    lhs->rule = boost::bind(String_Rule, _1, _2, _3, "def", true);
+    rhs->rule = boost::bind(String_Rule, _1, _2, _3, "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);
+
+    if (results.second) {
+        std::cout << "Parse successful: " << std::endl;
+        debug_print(parent, "");
+    }
 
 }