From f6f6a8305ef5c0781326cbd17983c5d1516f1bbb Mon Sep 17 00:00:00 2001 From: Jonathan Turner Date: Wed, 27 May 2009 19:56:05 +0000 Subject: [PATCH] Sugared operators and helper functions starting to work --- langkit/langkit_parser.cpp | 23 +++++++++++------ langkit/langkit_parser.hpp | 51 ++++++++++++++++++++++++++++++++------ langkit/main.cpp | 18 ++++++++------ 3 files changed, 70 insertions(+), 22 deletions(-) diff --git a/langkit/langkit_parser.cpp b/langkit/langkit_parser.cpp index 9f9a8f92..88cc8710 100644 --- a/langkit/langkit_parser.cpp +++ b/langkit/langkit_parser.cpp @@ -1,6 +1,8 @@ // This file is distributed under the BSD License. // See LICENSE.TXT for details. +#include + #include #include @@ -33,18 +35,18 @@ std::pair Type_Rule(Token_Iterator iter, Token_Iterator en return std::pair(iter, false); } -std::pair Or_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep) { +std::pair 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 result = lhs->rule(iter, end, parent); + std::pair result = lhs(iter, end, parent); if (result.second) { return std::pair(result.first, true); } else { - result = rhs->rule(iter, end, parent); + result = rhs(iter, end, parent); if (result.second) { return std::pair(result.first, true); } @@ -59,15 +61,15 @@ std::pair Or_Rule(Token_Iterator iter, Token_Iterator end, return std::pair(iter, false); } -std::pair And_Rule(Token_Iterator iter, Token_Iterator end, TokenPtr parent, const RulePtr lhs, const RulePtr rhs, bool keep) { +std::pair 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 result = lhs->rule(iter, end, parent); + std::pair 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(result.first, true); } @@ -83,5 +85,12 @@ std::pair And_Rule(Token_Iterator iter, Token_Iterator end } std::pair 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)); } diff --git a/langkit/langkit_parser.hpp b/langkit/langkit_parser.hpp index f2b72b7f..f6f51582 100644 --- a/langkit/langkit_parser.hpp +++ b/langkit/langkit_parser.hpp @@ -9,17 +9,16 @@ #include "langkit_lexer.hpp" typedef std::vector::iterator Token_Iterator; -typedef std::tr1::shared_ptr RulePtr; +typedef std::tr1::shared_ptr RuleImplPtr; typedef boost::function(Token_Iterator iter, Token_Iterator end, TokenPtr parent)> RuleFun; -struct Rule { +struct RuleImpl { int identifier; RuleFun rule; - std::pair operator()(Token_Iterator iter, Token_Iterator end, TokenPtr parent); - Rule() : identifier(-1) {} - Rule(int id) : identifier(id) {} - Rule(RuleFun fun) : rule(fun) {} + RuleImpl() : identifier(-1) {} + RuleImpl(int id) : identifier(id) {} + RuleImpl(RuleFun fun) : rule(fun) {} }; std::pair String_Rule @@ -29,10 +28,46 @@ std::pair Type_Rule (Token_Iterator iter, Token_Iterator end, TokenPtr parent, const int val, bool keep); std::pair 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 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 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_ */ diff --git a/langkit/main.cpp b/langkit/main.cpp index d90bfce1..5843cbf2 100644 --- a/langkit/main.cpp +++ b/langkit/main.cpp @@ -62,21 +62,25 @@ void parse(std::vector &tokens) { 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); + Rule lhs; + Rule rhs; + Rule rule = lhs & rhs; //(boost::bind(And_Rule, _1, _2, _3, lhs, rhs)); + lhs = Str("def", true); + rhs = Str("int", true); Token_Iterator iter = tokens.begin(), end = tokens.end(); TokenPtr parent(new Token("Root", 0, "test")); - std::pair results = (*rule)(iter, end, parent); + std::pair 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 tokens = lexer.lex(input, "INPUT"); - debug_print(tokens); + //debug_print(tokens); parse(tokens); std::cout << "Expression> ";