rley 0.5.01 → 0.5.02

data/examples/general/calc_iter1/calc_ast_nodes.rb

@@ -0,0 +1,151 @@
+# Classes that implement nodes of Abstract Syntax Trees (AST) representing
+# calculator parse results.
+
+
+CalcTerminalNode = Struct.new(:token, :value, :position) do
+  def initialize(aToken, aPosition)
+    self.token = aToken
+    self.position = aPosition
+    init_value(aToken.lexeme)
+  end
+
+  # This method can be overriden
+  def init_value(aLiteral)
+    self.value = aLiteral.dup
+  end
+
+  def symbol()
+    self.token.terminal
+  end
+
+  def interpret()
+    return value
+  end
+  
+  # Part of the 'visitee' role in Visitor design pattern.
+  # @param aVisitor[ParseTreeVisitor] the visitor
+  def accept(aVisitor)
+    aVisitor.visit_terminal(self)
+  end  
+end
+
+class CalcNumberNode  < CalcTerminalNode
+  def init_value(aLiteral)
+    case aLiteral
+      when /^[+-]?\d+$/
+        self.value = aLiteral.to_i
+
+      when /^[+-]?\d+(\.\d+)?([eE][+-]?\d+)?$/
+        self.value = aLiteral.to_f
+    end
+  end
+end
+
+class CalcCompositeNode
+  attr_accessor(:children)
+  attr_accessor(:symbol)
+
+  def initialize(aSymbol)
+    @symbol = aSymbol
+    @children = []    
+  end
+
+  # Part of the 'visitee' role in Visitor design pattern.
+  # @param aVisitor[ParseTreeVisitor] the visitor
+  def accept(aVisitor)
+    aVisitor.visit_nonterminal(self)
+  end
+  
+  alias subnodes children
+
+end # class
+
+class CalcUnaryOpNode < CalcCompositeNode
+  def initialize(aSymbol)
+    super(aSymbol)
+  end
+
+  # Convert this tree node in a simpler Ruby representation.
+  # Basically a Calc object corresponds to a Ruhy Hash
+  def to_ruby()
+    rep = {}
+    members.each do |pair|
+      rep[pair.name.to_ruby] = pair.value.to_ruby
+    end
+
+    return rep
+  end
+
+  alias members children
+end # class
+
+class CalcNegateNode < CalcUnaryOpNode
+end # class
+
+class CalcBinaryOpNode < CalcCompositeNode
+  def initialize(aSymbol)
+    super(aSymbol)
+  end
+  
+  protected
+  
+  def get_operands()
+    operands = []
+    children.each do |child|
+      oper = child.respond_to?(:interpret) ? child.interpret : child
+      operands << oper
+    end
+
+    return operands
+  end
+
+end # class
+
+class CalcAddNode < CalcBinaryOpNode
+
+  # TODO
+  def interpret()
+    operands = get_operands
+
+    sum = operands[0] + operands[1]
+    return sum
+  end
+end # class
+
+
+class CalcSubtractNode < CalcBinaryOpNode
+
+  # TODO
+  def interpret()
+    operands = get_operands
+
+    substraction = operands[0] - operands[1]
+    return substraction
+  end
+end # class
+
+class CalcMultiplyNode < CalcBinaryOpNode
+
+  # TODO
+  def interpret()
+    operands = get_operands
+    multiplication = operands[0] * operands[1]
+    return multiplication
+  end
+end # class
+
+class CalcDivideNode < CalcBinaryOpNode
+
+  # TODO
+  def interpret()
+    operands = get_operands
+    numerator = operands[0].to_f
+    denominator = operands[1]
+    division =  numerator / denominator
+    return division    
+  end
+end # class
+
+
+
+

data/examples/general/calc_iter1/calc_demo.rb

@@ -0,0 +1,38 @@
+require_relative 'calc_parser'
+require_relative 'calc_ast_builder'
+
+# Retrieve input expression to parse from command-line
+if ARGV.empty?
+  my_name = File.basename(__FILE__)
+  msg = <<-END_MSG
+Command-line symtax:
+  ruby #{my_name} "arithmetic expression"
+  where:
+    the arithmetic expression is enclosed between double quotes (")
+
+  Example:
+  ruby #{my_name} "2 * 3 + (4 - 1)"
+END_MSG
+  puts msg
+  exit(1)
+end
+
+# Create a calculator parser object
+parser = CalcParser.new
+result = parser.parse_expression(ARGV[0])
+
+unless result.success?
+  # Stop if the parse failed...
+  puts "Parsing of '#{ARGV[0]}' failed"
+  puts "Reason: #{result.failure_reason.message}"
+  exit(1)
+end
+
+tree_builder = CalcASTBuilder
+
+# Generate a parse tree from the parse result
+ptree = result.parse_tree(tree_builder)
+
+root = ptree.root
+puts root.interpret # Output the expression result
+# End of file

data/examples/general/calc_iter1/calc_grammar.rb

@@ -0,0 +1,25 @@
+# Grammar for simple arithmetical expressions
+require 'rley' # Load the gem
+
+########################################
+# Define a grammar for basic arithmetical expressions
+builder = Rley::Syntax::GrammarBuilder.new do
+  add_terminals('NUMBER')
+  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters
+  add_terminals('PLUS', 'MINUS') # For '+', '-' operators
+  add_terminals('STAR', 'DIVIDE') # For '*', '/' operators
+  rule 'expression' => 'simple_expression'
+  rule 'simple_expression' => 'term'
+  rule 'simple_expression' => %w[simple_expression add_operator term]
+  rule 'term' => 'factor'
+  rule 'term' => %w[term mul_operator factor]
+  rule 'factor' => 'NUMBER'
+  rule 'factor' => %w[LPAREN expression RPAREN]
+  rule 'add_operator' => 'PLUS'
+  rule 'add_operator' => 'MINUS'  
+  rule 'mul_operator' => 'STAR'
+  rule 'mul_operator' => 'DIVIDE'   
+end
+
+# And now build the grammar...
+CalcGrammar = builder.grammar

data/examples/general/calc_iter1/calc_lexer.rb

@@ -0,0 +1,81 @@
+# File: calc_lexer.rb
+# Lexer for a basic arithmetical expression parser
+require 'strscan'
+require 'rley' # Load the gem
+
+
+class CalcLexer
+  attr_reader(:scanner)
+  attr_reader(:lineno)
+  attr_reader(:line_start)
+  attr_reader(:name2symbol)
+
+  @@lexeme2name = {
+    '(' => 'LPAREN',
+    ')' => 'RPAREN',
+    '+' => 'PLUS',
+    '-' => 'MINUS',
+    '*' => 'STAR',
+    '/' => 'DIVIDE',
+    '**' => 'POWER'
+  }.freeze
+
+  class ScanError < StandardError; end
+
+  def initialize(source, aGrammar)
+    @scanner = StringScanner.new(source)
+    @name2symbol = aGrammar.name2symbol
+    @lineno = 1
+  end
+
+  def tokens()
+    tok_sequence = []
+    until @scanner.eos?
+      token = _next_token
+      tok_sequence << token unless token.nil?
+    end
+
+    return tok_sequence
+  end
+
+  private
+
+  def _next_token()
+    skip_whitespaces
+    curr_ch = scanner.peek(1)
+    return nil if curr_ch.nil?
+    
+    token = nil
+
+    if '()+/'.include? curr_ch
+      # Single character token
+      token = build_token(@@lexeme2name[curr_ch], scanner.getch)
+      
+    elsif lexeme = scanner.scan(/\*\*/)
+      token = build_token(@@lexeme2name[lexeme], lexeme)
+    elsif lexeme = scanner.scan(/\*/)
+      token = build_token(@@lexeme2name[lexeme], lexeme)
+    elsif lexeme = scanner.scan(/-?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/)
+      token = build_token('NUMBER', lexeme)
+    elsif lexeme = scanner.scan(/-/)
+      token = build_token(@@lexeme2name[curr_ch], lexeme)
+    else # Unknown token
+      erroneous = curr_ch.nil? ? '' : curr_ch
+      sequel = scanner.scan(/.{1,20}/)
+      erroneous += sequel unless sequel.nil?
+      raise ScanError.new("Unknown token #{erroneous}")
+    end
+
+    return token
+  end
+  
+  def build_token(aSymbolName, aLexeme)
+    token_type = name2symbol[aSymbolName]
+    return Rley::Tokens::Token.new(aLexeme, token_type)    
+  end
+
+  def skip_whitespaces()
+    scanner.scan(/[ \t\f\n\r]+/)
+  end
+
+end # class

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

@@ -0,0 +1,73 @@
+require 'rspec' # Use the RSpec framework
+require_relative '../calc_parser' # Load the class under test
+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)
+
+    unless result.success?
+      # Stop if the parse failed...
+      puts "Parsing of '#{anExpression}' failed"
+      puts "Reason: #{result.failure_reason.message}"
+      exit(1)
+    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
+
+  it 'should evaluate simple number literals' do
+    expect_expr('2').to eq(2)
+  end
+
+  it 'should evaluate addition' do
+    expect_expr('2 + 2').to eq(4)
+  end
+
+  it 'should evaluate subtraction' do
+    expect_expr('2.1 - 2').to be_within(0.000000000000001).of(0.1)
+  end
+
+  it 'should evaluate division' do
+    expect_expr('10.5 / 5').to eq(2.1)
+  end
+
+  it 'should evaluate multiplication' do
+    expect_expr('2 * 3.1').to eq(6.2)
+  end
+
+  it 'should evaluate parentheses' do
+    expect_expr('2 * (2.1 + 1)').to eq(6.2)
+  end
+  
+  it 'should evaluate regardless of whitespace' do
+    expect_expr("2*(1+\t1)").to eq(4)
+  end
+
+  it 'should evaluate order of operations' do
+    expect_expr('2 * 2.1 + 1 / 2').to eq 4.7
+  end
+
+  it 'should evaluate multiple levels of parentheses' do
+    expect_expr('2*(1/(1+3))').to eq(0.5)
+  end  
+
+end # describe
+# End of file
+

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -0,0 +1,186 @@
+require_relative 'calc_ast_nodes'
+
+# The purpose of a CalcASTBuilder is to build piece by piece an AST
+# (Abstract Syntax Tree) from a sequence of input tokens and
+# visit events produced by walking over a GFGParsing object.
+# Uses the Builder GoF pattern.
+# 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
+  Terminal2NodeClass = {
+    # Plus sign character is ambiguous. It can represent an operator 
+    # or a positive value
+    '+' => { 'add_operator[0]' => CalcAddNode, 'sign[0]' => PTree::TerminalNode },
+    # Minus sign character is ambiguous. It can represent an operator 
+    # or a negative value
+    '-' => { 'add_operator[1]' => CalcSubtractNode, 'sign[1]' => CalcNegateNode },
+    '*' => CalcMultiplyNode,
+    '/' => CalcDivideNode,
+    'number' => CalcNumberNode
+  }
+
+  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(aProduction, aTerminal, aTokenPosition, aToken)
+    klass = Terminal2NodeClass.fetch(aTerminal.name, CalcTerminalNode)
+    klass = klass[aProduction.name] if klass.is_a?(Hash) # Lexical ambiguity
+    return klass.new(aToken, aTokenPosition)
+  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[sign simple_expression]
+        reduce_expression_0(aProduction, aRange, theTokens, theChildren)
+
+      # when /value\[\d\]/
+        # return_first_child(aRange, theTokens, theChildren)
+
+      # when 'object[0]'
+        # reduce_object_0(aProduction, aRange, theTokens, theChildren)
+
+      # when 'object[1]'
+        # reduce_object_1(aRange, theTokens, theChildren)
+
+      # when 'member-list[0]'
+        # reduce_member_list_0(aRange, theTokens, theChildren)
+
+      # when 'member-list[1]'
+        # reduce_member_list_1(aProduction, aRange, theTokens, theChildren)
+
+      # when 'member[0]'
+        # reduce_member_0(aProduction, aRange, theTokens, theChildren)
+
+      # when 'array[0]'
+        # reduce_array_0(aProduction, aRange, theTokens, theChildren)
+
+      # when 'array[1]'
+        # reduce_array_1(aRange, theTokens, theChildren)
+
+      # when 'array-items[0]'
+        # reduce_array_items_0(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' => []
+        reduce_sign_2(aProduction, aRange, theTokens, theChildren)
+      else
+        raise StandardError, "Don't know production #{aProduction.name}"
+    end
+
+    return node
+  end
+
+  # rule 'expression' => %w[sign simple_expression]
+  def reduce_expression_0(aProduction, aRange, theTokens, theChildren)
+    sign = theChildren[0]
+    # Check type of sign
+    node = if sign && sign.kind_of?(CalcNegateNode)
+      sign.members << theChildren.last
+    else
+      theChildren.last
+    end
+
+    return node
+  end
+
+  # rule 'sign' => []
+  def reduce_sign_2(aProduction, aRange, theTokens, theChildren)
+    return nil # TODO; check whether this make sense
+  end
+=begin
+    second_child = theChildren[1]
+    second_child.symbol = aProduction.lhs
+    return second_child
+  end
+
+  # rule 'object' => %w[begin-object end-object]
+  def reduce_object_1(aRange, theTokens, theChildren)
+    return CalcObjectNode.new(aProduction.lhs)
+  end
+
+  # rule 'member-list' => %w[member-list value-separator member]
+  def reduce_member_list_0(aRange, theTokens, theChildren)
+    node = theChildren[0]
+    node.members << theChildren.last
+    return node
+  end
+
+  # rule 'member-list' => 'member'
+  def reduce_member_list_1(aProduction, aRange, theTokens, theChildren)
+    node = CalcObjectNode.new(aProduction.lhs)
+    node.members << theChildren[0]
+    return node
+  end
+
+  # rule 'member' => %w[string name-separator value]
+  def reduce_member_0(aProduction, aRange, theTokens, theChildren)
+    return CalcPair.new(theChildren[0], theChildren[2], aProduction.lhs)
+  end
+
+  # rule 'object' => %w[begin-object member-list end-object]
+  def reduce_array_0(aProduction, aRange, theTokens, theChildren)
+    second_child = theChildren[1]
+    second_child.symbol = aProduction.lhs
+    return second_child
+  end
+
+
+  # rule 'array' => %w[begin-array end-array]
+  def reduce_array_1(aRange, theTokens, theChildren)
+    return CalcArrayNode.new
+  end
+
+  # rule 'array-items' => %w[array-items value-separator value]
+  def reduce_array_items_0(aRange, theTokens, theChildren)
+    node = theChildren[0]
+    node.children << theChildren[2]
+    return node
+  end
+
+
+
+  #   rule 'array-items' => %w[value]
+  def reduce_array_items_1(aProduction, aRange, theTokens, theChildren)
+    node = CalcArrayNode.new(aProduction.lhs)
+    node.children << theChildren[0]
+    return node
+  end
+=end
+end # class