rley 0.5.04 → 0.5.05

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5c84e4d5e47e769c76da705abef632e4748311c
-  data.tar.gz: 876569a22741aa76f5d9b7bec8404c0a518e02b3
+  metadata.gz: 5fdf5f08878706a50fe9b024c7ffed95b3cb08fd
+  data.tar.gz: 92265adccb7cb660b56ac2b060aee4a5facdd777
 SHA512:
-  metadata.gz: da13f9f5924752adc98be8822f079e078ff4e5345a1cbf63dcd3f6d0c28c695397abf4f80db6fa38e549615cb1db264baadcb4b3fdc1428ef45ac3aa490459cf
-  data.tar.gz: 84b73e987ffb98f5ce5cf1a57f62a743507bff497c8c8c3294e887310036ba9893796ec5f3b9d1d8f2335b7c33bb47cda3e6455e7f66ce0dfcb3c85b90e629a4
+  metadata.gz: 936959f76b1b2dc9fe6db68e4a0372f6aa421ea143876421c0ee90ab95852f71dad9fc166d80269af070fe84dfcbdef3848cb29be321e474afd40dae9e3bce59
+  data.tar.gz: 4e2f8a16366d4771e6d8506d3333adc40329c01a21952ee2002d432a5d0205c6ab6658b96d245bd4688227c6cf2c053fa66a57a9bdbeaeca4ef4969425b21457

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+### 0.5.05 / 2017-11-04
+* [FIX] Method `GFGParsing#call_rule` didn't handle properly the case of nullable symbols appearing in more than one production rule.
+* [New] New calculator example. In addition to the basic arithmetic operators (+, -, *, /) it accepts the unary minus
+  and the exponentiation operator. As a convenience it displays both CST and AST parse representations.
+* [CHANGE] Method `ParseWalkerFactory#build_walker` added one argument that controls the way the visit when reaching anew an end vertex.
+* [CHANGE] Method `ParseWalkerFactory#visit_entry` when re-visit an end vertex, the jump to related start vertex is now conditional.
+* [CHANGE] File `parse_walker_factory_spec.rb` Added test to validate the different ways to walk over the parse entries.
+* [CHANGE] Class `GrmFlowGraph`: Added more documentation.
+* [CHANGE] Class `Vertex`: Documentation refined.
+
 ### 0.5.04 / 2017-10-26
 * [Fix] Method GrmFlowGraph#traverse_df code terminated prematurely with nested call edges.
 * [CHANGE] Method Grammar#name_production: suffix in default production name is changed (e.g. 'expression[3]' changed to expression_3)

data/examples/general/calc_iter1/calc_demo.rb

@@ -11,7 +11,7 @@ Command-line symtax:
     the arithmetic expression is enclosed between double quotes (")
 
   Example:
-  ruby #{my_name} "2 * 3 + (4 - 1)"
+  ruby #{my_name} "2 * 3 + (1 + 3 ** 2)"
 END_MSG
   puts msg
   exit(1)

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -0,0 +1,200 @@
+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 = {
+    # Lexical ambiguity: minus sign represents two very concepts:
+    # The unary negation operator on one hand, the binary substraction operator
+    'MINUS' => { 'add_operator_1' =>  Rley::PTree::TerminalNode,
+                 'factor_2' => CalcNegateNode,
+                 'sign_1' => CalcNegateNode
+               },
+    '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
+
+  def return_epsilon(_range, _tokens, _children)
+    return nil
+  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)
+    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
+  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[simple_factor POWER simple_factor]
+        reduce_factor_1(aProduction, aRange, theTokens, theChildren)        
+
+      when 'simple_factor_0' # rule 'simple_factor' => %[sign NUMBER]
+        reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
+
+      when 'simple_factor_1' # rule 'simple_factor' => %w[LPAREN expression RPAREN]
+        return_second_child(aRange, theTokens, theChildren)
+        
+      when 'simple_factor_2' # rule 'simple_factor' => %w[MINUS LPAREN expression RPAREN]
+        reduce_simple_factor_2(aProduction, 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'
+        return_epsilon(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]
+    operator_node.children << theChildren[0]
+    operator_node.children << theChildren[2]
+    return operator_node
+  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' => %w[term mul_operator factor]
+  def reduce_term_1(_production, _range, _tokens, theChildren)
+    reduce_binary_operator(theChildren)
+  end
+  
+  # rule 'factor' => %w[simple_factor POWER simple_factor]]
+  def reduce_factor_1(aProduction, aRange, theTokens, theChildren)
+    result = PowerNode.new(theChildren[1].symbol, aRange)
+    result.children << theChildren[0]
+    result.children << theChildren[2]
+    
+    return result
+  end  
+
+  # rule 'simple_factor' => %[sign NUMBER]
+  def reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
+    first_child = theChildren[0]
+    result = if first_child.kind_of?(CalcNegateNode)
+               -theChildren[1]
+             else
+               theChildren[1]
+             end
+
+    return result
+  end
+  
+  # rule 'simple_factor' => %w[MINUS LPAREN expression RPAREN] 
+  def reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
+    negation = CalcNegateNode.new(theChildren[0].symbol, aRange.low)
+    negation.children << theChildren[2]
+    return negation
+  end
+
+  # rule 'add_operator' => 'PLUS'
+  def reduce_add_operator_0(_production, aRange, _tokens, theChildren)
+    return CalcAddNode.new(theChildren[0].symbol, aRange)
+  end
+
+  # rule 'add_operator' => 'MINUS'
+  def reduce_add_operator_1(_production, aRange, _tokens, theChildren)
+    return CalcSubtractNode.new(theChildren[0].symbol, aRange)
+  end
+
+  # rule 'mul_operator' => 'STAR'
+  def reduce_mul_operator_0(_production, aRange, _tokens, theChildren)
+    return CalcMultiplyNode.new(theChildren[0].symbol, aRange)
+  end
+
+  # rule 'mul_operator' => 'DIVIDE'
+  def reduce_mul_operator_1(_production, aRange, _tokens, theChildren)
+    return CalcDivideNode.new(theChildren[0].symbol, aRange)
+  end
+end # class
+# End of file

data/examples/general/calc_iter2/calc_ast_nodes.rb

@@ -0,0 +1,156 @@
+# 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()
+    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
+  
+  # Overriding the unary minus operator
+  def -@()
+    self.value = - self.value
+    return self
+  end
+end
+
+class CalcCompositeNode
+  attr_accessor(:children)
+  attr_accessor(:symbol)
+  attr_accessor(:aPosition)
+
+  def initialize(aSymbol, aPosition)
+    @symbol = aSymbol
+    @children = []
+    @position = aPosition
+  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, aPosition)
+    super(aSymbol,aPosition)
+  end
+
+  alias members children
+end # class
+
+class CalcNegateNode < CalcUnaryOpNode
+  def initialize(aSymbol, aPosition)
+    super(aSymbol,aPosition)
+  end
+  
+  def interpret()
+    return -(children[0].interpret)
+  end
+end # class
+
+class CalcBinaryOpNode < CalcCompositeNode
+  def initialize(aSymbol, aRange)
+    super(aSymbol, aRange)
+  end
+
+  protected
+
+  def retrieve_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 = retrieve_operands
+
+    sum = operands[0] + operands[1]
+    return sum
+  end
+end # class
+
+
+class CalcSubtractNode < CalcBinaryOpNode
+  # TODO
+  def interpret()
+    operands = retrieve_operands
+
+    substraction = operands[0] - operands[1]
+    return substraction
+  end
+end # class
+
+class CalcMultiplyNode < CalcBinaryOpNode
+  # TODO
+  def interpret()
+    operands = retrieve_operands
+    multiplication = operands[0] * operands[1]
+    return multiplication
+  end
+end # class
+
+class CalcDivideNode < CalcBinaryOpNode
+  # TODO
+  def interpret()
+    operands = retrieve_operands
+    numerator = operands[0].to_f
+    denominator = operands[1]
+    division =  numerator / denominator
+    return division
+  end
+end # class
+
+
+class PowerNode < CalcBinaryOpNode
+  # TODO
+  def interpret()
+    operands = retrieve_operands
+    exponentiation = operands[0] ** operands[1]
+    return exponentiation
+  end
+end # class
+# End of file

data/examples/general/calc_iter2/calc_demo.rb

@@ -0,0 +1,66 @@
+require_relative 'calc_parser'
+require_relative 'calc_ast_builder'
+
+def print_title(aTitle)
+  puts aTitle
+  puts '=' * aTitle.size
+end
+
+def print_tree(aTitle, aParseTree)
+  # Let's create a parse tree visitor
+  visitor = Rley::ParseTreeVisitor.new(aParseTree)
+
+  # Now output formatted parse tree
+  print_title(aTitle)
+  renderer = Rley::Formatter::Asciitree.new($stdout)
+  renderer.render(visitor)
+  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__)
+  msg = <<-END_MSG
+Demo calculator that prints:
+- The Concrete and Abstract Syntax Trees of the math expression.
+- The result of the math expression.
+
+Command-line symtax:
+  ruby #{my_name} "arithmetic expression"
+  where:
+    the arithmetic expression is enclosed between double quotes (")
+
+  Example:
+  ruby #{my_name} "2 * 3 + (1 + 3 ** 2)"
+END_MSG
+  puts msg
+  exit(1)
+end
+puts ARGV[0]
+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
+
+
+# Generate a concrete syntax parse tree from the parse result
+cst_ptree = result.parse_tree
+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)
+print_tree('Abstract Syntax Tree (AST)', ast_ptree)
+
+# Now perform the computation of math expression
+root = ast_ptree.root
+print_title('Result:')
+puts root.interpret.to_s # Output the expression result
+# End of file