rley 0.5.14 → 0.6.00

data/examples/general/calc_iter1/calc_ast_builder.rb

@@ -7,96 +7,15 @@ require_relative 'calc_ast_nodes'
 # The Builder pattern creates a complex object
 # (say, a parse tree) from simpler objects (terminal and non-terminal
 # nodes) and using a step by step approach.
-class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
+class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   Terminal2NodeClass = {
     'NUMBER' => CalcNumberNode
   }.freeze
 
   protected
-
-  def return_first_child(_range, _tokens, theChildren)
-    return theChildren[0]
-  end
-
-  def return_second_child(_range, _tokens, theChildren)
-    return theChildren[1]
-  end
-
-  def return_last_child(_range, _tokens, theChildren)
-    return theChildren[-1]
-  end
-
-  # Overriding method.
-  # Create a parse tree object with given
-  # node as root node.
-  def create_tree(aRootNode)
-    return Rley::PTree::ParseTree.new(aRootNode)
-  end
-
-  # Overriding method.
-  # Factory method for creating a node object for the given
-  # input token.
-  # @param aTerminal [Terminal] Terminal symbol associated with the token
-  # @param aTokenPosition [Integer] Position of token in the input stream
-  # @param aToken [Token] The input token
-  def new_leaf_node(_production, aTerminal, aTokenPosition, aToken)
-    klass = Terminal2NodeClass.fetch(aTerminal.name, CalcTerminalNode)
-    node = if klass
-             klass.new(aToken, aTokenPosition)
-           else
-             PTree::TerminalNode.new(aToken, aTokenPosition)
-           end
-
-    return node
-  end
-
-  # Method to override.
-  # Factory method for creating a parent node object.
-  # @param aProduction [Production] Production rule
-  # @param aRange [Range] Range of tokens matched by the rule
-  # @param theTokens [Array] The input tokens
-  # @param theChildren [Array] Children nodes (one per rhs symbol)
-  def new_parent_node(aProduction, aRange, theTokens, theChildren)
-    node = case aProduction.name
-      when 'expression_0' # rule 'expression' => 'simple_expression'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'simple_expression_0' # rule 'simple_expression' => 'term'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'simple_expression_1'
-        # rule 'simple_expression' => %w[simple_expression add_operator term]
-        reduce_simple_expression_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'term_0' # rule 'term' => 'factor'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'term_1' # rule 'term' => %w[term mul_operator factor]
-        reduce_term_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'factor_0' # rule 'factor' => 'NUMBER'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'factor_1' # rule 'factor' => %w[LPAREN expression RPAREN]
-        return_second_child(aRange, theTokens, theChildren)
-
-      when 'add_operator_0' # rule 'add_operator' => 'PLUS'
-        reduce_add_operator_0(aProduction, aRange, theTokens, theChildren)
-
-      when 'add_operator_1' # rule 'add_operator' => 'MINUS'
-        reduce_add_operator_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'mul_operator_0' # rule 'mul_operator' => 'STAR'
-         reduce_mul_operator_0(aProduction, aRange, theTokens, theChildren)
-
-      when 'mul_operator_1' # rule 'mul_operator' =>  'DIVIDE'
-         reduce_mul_operator_1(aProduction, aRange, theTokens, theChildren)
-
-      else
-        raise StandardError, "Don't know production #{aProduction.name}"
-    end
-
-    return node
+  
+  def terminal2node()
+    Terminal2NodeClass
   end
 
   def reduce_binary_operator(theChildren)
@@ -105,16 +24,41 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
     operator_node.children << theChildren[2]
     return operator_node
   end
+  
+  # rule 'expression' => 'simple_expression'
+  def reduce_expression_0(_aProd, _range, _tokens, theChildren)
+    return_first_child(_range, _tokens, theChildren)
+  end
+
+  # rule 'simple_expression' => 'term'
+  def reduce_simple_expression_0(_aProd, _range, _tokens, theChildren)
+    return_first_child(_range, _tokens, theChildren)
+  end          
 
   # rule 'simple_expression' => %w[simple_expression add_operator term]
   def reduce_simple_expression_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
   end
+  
+  # rule 'term' => 'factor' 
+  def reduce_term_0(_aProd, _range, _tokens, theChildren)
+    return_first_child(_range, _tokens, theChildren)
+  end  
 
   # rule 'term' => %w[term mul_operator factor]
   def reduce_term_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
   end
+  
+  # rule 'factor' => 'NUMBER'
+  def reduce_factor_0(_aProd, _range, _tokens, theChildren)
+    return_first_child(_range, _tokens, theChildren)
+  end
+  
+  # # rule 'factor' => %w[LPAREN expression RPAREN]
+  def reduce_factor_1(_aProd, _range, _tokens, theChildren)
+    return_second_child(_range, _tokens, theChildren)
+  end   
 
   # rule 'add_operator' => 'PLUS'
   def reduce_add_operator_0(_production, _range, _tokens, theChildren)

data/examples/general/calc_iter1/calc_demo.rb

@@ -1,4 +1,4 @@
-require_relative 'calc_parser'
+require_relative 'calc_lexer'
 require_relative 'calc_ast_builder'
 
 # Retrieve input expression to parse from command-line
@@ -17,9 +17,19 @@ END_MSG
   exit(1)
 end
 
-# Create a calculator parser object
-parser = CalcParser.new
-result = parser.parse_expression(ARGV[0])
+# Create a Rley facade object
+engine = Rley::Engine.new do |cfg|
+  cfg.repr_builder = CalcASTBuilder
+end
+
+########################################
+# Step 1. Load a grammar for calculator
+require_relative 'calc_grammar'
+engine.use_grammar(CalcGrammar)
+
+
+lexer = CalcLexer.new(ARGV[0])
+result = engine.parse(lexer.tokens)
 
 unless result.success?
   # Stop if the parse failed...
@@ -28,10 +38,9 @@ unless result.success?
   exit(1)
 end
 
-tree_builder = CalcASTBuilder
 
 # Generate a parse tree from the parse result
-ptree = result.parse_tree(tree_builder)
+ptree = engine.to_ptree(result)
 
 root = ptree.root
 puts root.interpret # Output the expression result

data/examples/general/calc_iter1/calc_lexer.rb

@@ -8,7 +8,6 @@ class CalcLexer
   attr_reader(:scanner)
   attr_reader(:lineno)
   attr_reader(:line_start)
-  attr_reader(:name2symbol)
 
   @@lexeme2name = {
     '(' => 'LPAREN',
@@ -22,9 +21,8 @@ class CalcLexer
 
   class ScanError < StandardError; end
 
-  def initialize(source, aGrammar)
+  def initialize(source)
     @scanner = StringScanner.new(source)
-    @name2symbol = aGrammar.name2symbol
     @lineno = 1
   end
 
@@ -70,8 +68,7 @@ class CalcLexer
   end
   
   def build_token(aSymbolName, aLexeme)
-    token_type = name2symbol[aSymbolName]
-    return Rley::Lexical::Token.new(aLexeme, token_type)    
+    return Rley::Lexical::Token.new(aLexeme, aSymbolName)    
   end
 
   def skip_whitespaces()

data/examples/general/calc_iter1/spec/calculator_spec.rb

@@ -1,13 +1,25 @@
 require 'rspec' # Use the RSpec framework
-require_relative '../calc_parser' # Load the class under test
+require_relative '../calc_lexer'
+require_relative '../calc_grammar'
 require_relative '../calc_ast_builder'
 
 
 describe 'Calculator' do
-  def parse_expression(anExpression)
-    # Create a calculator parser object
-    parser = CalcParser.new
-    result = parser.parse_expression(anExpression)
+  def expect_expr(anExpression)
+    # Create a Rley facade object
+    engine = Rley::Engine.new do |cfg|
+      cfg.repr_builder = CalcASTBuilder
+    end
+    
+    engine.use_grammar(CalcGrammar)
+    raw_result = parse_expression(engine, anExpression)
+    ast = engine.to_ptree(raw_result)
+    return expect(ast.root.interpret)
+  end
+  
+  def parse_expression(anEngine, anExpression)
+    lexer = CalcLexer.new(anExpression)
+    result = anEngine.parse(lexer.tokens)
 
     unless result.success?
       # Stop if the parse failed...
@@ -17,20 +29,7 @@ describe 'Calculator' do
     end
 
     return result
-  end
-
-  def build_ast(aParseResult)
-    tree_builder = CalcASTBuilder
-    # Generate an abstract syntax tree from the parse result
-    ast = aParseResult.parse_tree(tree_builder)
-    return ast.root
-  end
-
-  def expect_expr(anExpression)
-    parsing = parse_expression(anExpression)
-    ast = build_ast(parsing)
-    return expect(ast.interpret)
-  end
+  end  
 
   it 'should evaluate simple number literals' do
     expect_expr('2').to eq(2)

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -1,4 +1,3 @@
-require_relative 'ast_building'
 require_relative 'calc_ast_nodes'
 
 # The purpose of a CalcASTBuilder is to build piece by piece an AST
@@ -8,8 +7,7 @@ require_relative 'calc_ast_nodes'
 # The Builder pattern creates a complex object
 # (say, a parse tree) from simpler objects (terminal and non-terminal
 # nodes) and using a step by step approach.
-class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
-  include ASTBuilding
+class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
 
   Terminal2NodeClass = {
     # Lexical ambiguity: minus sign represents two very concepts:
@@ -26,111 +24,10 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
 
   protected
 
-  # Overriding method.
-  # Factory method for creating a node object for the given
-  # input token.
-  # @param aTerminal [Terminal] Terminal symbol associated with the token
-  # @param aTokenPosition [Integer] Position of token in the input stream
-  # @param aToken [Token] The input token
-  def new_leaf_node(aProduction, aTerminal, aTokenPosition, aToken)
-    klass = Terminal2NodeClass.fetch(aTerminal.name, CalcTerminalNode)
-    node = if klass
-             if klass.is_a?(Hash)
-              # Lexical ambiguity...
-              klass = klass.fetch(aProduction.name)
-             end
-             klass.new(aToken, aTokenPosition)
-           else
-             PTree::TerminalNode.new(aToken, aTokenPosition)
-           end
-
-    return node
+  def terminal2node()
+    Terminal2NodeClass
   end
 
-  # Method to override.
-  # Factory method for creating a parent node object.
-  # @param aProduction [Production] Production rule
-  # @param aRange [Range] Range of tokens matched by the rule
-  # @param theTokens [Array] The input tokens
-  # @param theChildren [Array] Children nodes (one per rhs symbol)
-  def new_parent_node(aProduction, aRange, theTokens, theChildren)
-    node = case aProduction.name
-      when 'expression_0' # rule 'expression' => %w[simple_expression]
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'simple_expression_0' # rule 'simple_expression' => 'term'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'simple_expression_1'
-        # rule 'simple_expression' => %w[simple_expression add_operator term]
-        reduce_simple_expression_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'term_0' # rule 'term' => 'factor'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'term_1' # rule 'term' => %w[term mul_operator factor]
-        reduce_term_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'factor_0' # rule 'factor' => 'simple_factor'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'factor_1' # rule 'factor' => %w[factor POWER simple_factor]
-        reduce_factor_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'simple_factor_0' # rule 'simple_factor' => %[sign scalar]
-        reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
-
-      when 'simple_factor_1'  # rule 'simple_factor' => %w[unary_function in_parenthesis]
-        reduce_simple_factor_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'simple_factor_2' # rule 'simple_factor' => %w[MINUS in_parenthesis]
-        reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
-
-      when 'simple_factor_3' # rule 'simple_factor' => 'in_parenthesis'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'sign_0' # rule 'sign' => 'PLUS'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'sign_1' # rule 'sign' => 'MINUS'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'sign_2' # rule 'sign' => []
-        return_epsilon(aRange, theTokens, theChildren)
-
-      when 'scalar_0' # rule 'scalar' => 'NUMBER'
-          return_first_child(aRange, theTokens, theChildren)
-
-      when 'scalar_1' # rule 'scalar' => 'PI'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'scalar_2' # rule 'scalar' => 'E'
-        return_first_child(aRange, theTokens, theChildren)
-          
-      when 'unary_function_0' # rule 'unary_function' => 'RESERVED'
-        return_first_child(aRange, theTokens, theChildren)
-      
-      when 'in_parenthesis_0' # rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
-        return_second_child(aRange, theTokens, theChildren)      
-
-      when 'add_operator_0' # rule 'add_operator' => 'PLUS'
-        reduce_add_operator_0(aProduction, aRange, theTokens, theChildren)
-
-      when 'add_operator_1' # rule 'add_operator' => 'MINUS'
-        reduce_add_operator_1(aProduction, aRange, theTokens, theChildren)
-
-      when 'mul_operator_0' # rule 'mul_operator' => 'STAR'
-        reduce_mul_operator_0(aProduction, aRange, theTokens, theChildren)
-
-      when 'mul_operator_1' # rule 'mul_operator' =>  'DIVIDE'
-         reduce_mul_operator_1(aProduction, aRange, theTokens, theChildren)
-
-      else
-        raise StandardError, "Don't know production #{aProduction.name}"
-    end
-
-    return node
-  end
 
   def reduce_binary_operator(theChildren)
     operator_node = theChildren[1]
@@ -179,12 +76,17 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
   end
 
   # rule 'simple_factor' => %w[MINUS in_parenthesis]
-  def reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
+  def reduce_simple_factor_2(aProduction, aRange, _tokens, theChildren)
     negation = CalcNegateNode.new(theChildren[0].symbol, aRange.low)
     negation.children << theChildren[1]
     return negation
   end
 
+   # rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
+  def reduce_in_parenthesis_0(_production, _range, _tokens, theChildren)
+    return_second_child(_range, _tokens, theChildren)
+  end
+
   # rule 'add_operator' => 'PLUS'
   def reduce_add_operator_0(_production, aRange, _tokens, theChildren)
     return CalcAddNode.new(theChildren[0].symbol, aRange)

data/examples/general/calc_iter2/calc_demo.rb

@@ -1,4 +1,4 @@
-require_relative 'calc_parser'
+require_relative 'calc_lexer'
 require_relative 'calc_ast_builder'
 
 def print_title(aTitle)
@@ -17,9 +17,6 @@ def print_tree(aTitle, aParseTree)
   puts ''
 end
 
-# Create a calculator parser object
-parser = CalcParser.new
-
 # Parse the input expression in command-line
 if ARGV.empty?
   my_name = File.basename(__FILE__)
@@ -41,7 +38,17 @@ END_MSG
   exit(1)
 end
 puts ARGV[0]
-result = parser.parse_expression(ARGV[0])
+
+# Create a Rley facade object
+engine = Rley::Engine.new
+
+########################################
+# Step 1. Load a grammar for calculator
+require_relative 'calc_grammar'
+engine.use_grammar(CalcGrammar)
+
+lexer = CalcLexer.new(ARGV[0])
+result = engine.parse(lexer.tokens)
 
 unless result.success?
   # Stop if the parse failed...
@@ -52,12 +59,12 @@ end
 
 
 # Generate a concrete syntax parse tree from the parse result
-cst_ptree = result.parse_tree
+cst_ptree = engine.convert(result)
 print_tree('Concrete Syntax Tree (CST)', cst_ptree)
 
 # Generate an abstract syntax parse tree from the parse result
-tree_builder = CalcASTBuilder
-ast_ptree = result.parse_tree(tree_builder)
+engine.configuration.repr_builder = CalcASTBuilder
+ast_ptree = engine.convert(result)
 print_tree('Abstract Syntax Tree (AST)', ast_ptree)
 
 # Now perform the computation of math expression