loxxy 0.0.4 → 0.0.9

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxBinaryExpr < LoxCompoundExpr
+      # @return [Symbol]
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand1 [Loxxy::Ast::LoxNode]
+      # @param operand2 [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand1, operand2)
+        super(aPosition, [operand1, operand2])
+        @operator = anOperator
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxCompoundExpr < LoxNode
+      # @return [Array<Ast::LoxNode>]
+      attr_reader :subnodes
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param theSubnodes [Array<Ast::LoxNode>]
+      def initialize(aPosition, theSubnodes)
+        super(aPosition)
+        @subnodes = theSubnodes
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_compound_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_literal_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxLiteralExpr < LoxNode
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      attr_reader :literal
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aLiteral [Loxxy::Datatype::BuiltinDatatype]
+      def initialize(aPosition, aLiteral)
+        super(aPosition)
+        @literal = aLiteral
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_literal_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    class LoxNode
+      # return [Rley::Lexical::Position] Position of the entry in the input stream.
+      attr_reader :position
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      def initialize(aPosition)
+        @position = aPosition
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        raise NotImplementedError
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -8,15 +8,14 @@ module Loxxy
     class BuiltinDatatype
       # @return [Object] The Ruby representation
       attr_reader :value
-      
+
       # Constructor. Initialize a Lox value from one of its built-in data type.
       def initialize(aValue)
         @value = validated_value(aValue)
       end
-      
-      
+
       protected
-      
+
       def validated_value(aValue)
         aValue
       end

data/lib/loxxy/datatype/false.rb

@@ -8,13 +8,13 @@ module Loxxy
     # Class for representing a Lox false value.
     class False < Boolean
       include Singleton # Make a singleton class
-      
+
       # Build the sole instance
       def initialize
         super(false)
       end
     end # class
-    
-    False.instance.freeze  # Make the sole instance immutable
+
+    False.instance.freeze # Make the sole instance immutable
   end # module
 end # module

data/lib/loxxy/datatype/lx_string.rb

@@ -6,12 +6,6 @@ module Loxxy
   module Datatype
     # Class for representing a Lox string of characters value.
     class LXString < BuiltinDatatype
-
-      # Build the sole instance
-      def initialize(aValue)
-        super(aValue)
-      end
-
       # Compare a Lox String with another Lox (or genuine Ruby) String
       # @param other [Datatype::LxString, String]
       # @return [Boolean]
@@ -22,7 +16,8 @@ module Loxxy
           when String
             value == other
         else
-          raise StandardError, 'Cannot compare a #{self.class} with #{other.class}'
+          err_msg = "Cannot compare a #{self.class} with #{other.class}"
+          raise StandardError, err_msg
         end
       end
 
@@ -34,8 +29,8 @@ module Loxxy
         end
 
         # Remove double quotes delimiter
-        aValue.gsub(/(^")|("$)/, '')  
+        aValue.gsub(/(^")|("$)/, '')
       end
     end # class
   end # module
-end # module
+end # module

data/lib/loxxy/datatype/nil.rb

@@ -8,13 +8,13 @@ module Loxxy
     # Class for representing a Lox nil "value".
     class Nil < BuiltinDatatype
       include Singleton # Make a singleton class
-      
+
       # Build the sole instance
       def initialize
         super(nil)
       end
     end # class
-    
-    Nil.instance.freeze  # Make the sole instance immutable
+
+    Nil.instance.freeze # Make the sole instance immutable
   end # module
 end # module

data/lib/loxxy/datatype/number.rb

@@ -6,19 +6,11 @@ module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
-
-      # Build the sole instance
-      def initialize(aValue)
-        super(aValue)
-      end
-
       protected
 
       def validated_value(aValue)
         case aValue
-          when Integer
-            result = aValue
-          when Numeric
+          when Integer, Numeric
             result = aValue
           when /^-?\d+$/
             result = aValue.to_i
@@ -32,4 +24,4 @@ module Loxxy
       end
     end # class
   end # module
-end # module
+end # module

data/lib/loxxy/datatype/true.rb

@@ -8,13 +8,13 @@ module Loxxy
     # Class for representing a Lox true value.
     class True < Boolean
       include Singleton # Make a singleton class
-      
+
       # Build the sole instance
       def initialize
         super(true)
-      end      
+      end
     end # class
-    
-    True.instance.freeze  # Make the sole instance immutable
+
+    True.instance.freeze # Make the sole instance immutable
   end # module
 end # module

data/lib/loxxy/front_end/grammar.rb

@@ -26,11 +26,12 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'declaration_star EOF')
+      rule('program' => 'EOF')
+      rule('program' => 'declaration_plus EOF')
 
       # Declarations: bind an identifier to something
-      rule('declaration_star' => 'declaration_star declaration')
-      rule('declaration_star' => [])
+      rule('declaration_plus' => 'declaration_plus declaration')
+      rule('declaration_plus' => 'declaration')
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -75,7 +76,8 @@ module Loxxy
       rule('printStmt' => 'PRINT expression SEMICOLON')
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
-      rule('block' => 'LEFT_BRACE declaration_star RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -85,53 +87,60 @@ module Loxxy
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
-      rule('logic_or' => 'logic_and disjunct_star')
-      rule('disjunct_star' => 'disjunct_star OR logic_and')
-      rule('disjunct_star' => [])
-      rule('logic_and' => 'equality conjunct_star')
-      rule('conjunct_star' => 'conjunct_star AND equality')
-      rule('conjunct_star' => [])
-      rule('equality' => 'comparison equalityTest_star')
-      rule('equalityTest_star' => 'equalityTest_star equalityTest comparison')
-      rule('equalityTest_star' => [])
+      rule('logic_or' => 'logic_and')
+      rule('logic_or' => 'logic_and disjunct_plus')
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and')
+      rule('disjunct_plus' => 'OR logic_and')
+      rule('logic_and' => 'equality')
+      rule('logic_and' => 'equality conjunct_plus')
+      rule('conjunct_plus' => 'conjunct_plus AND equality')
+      rule('conjunct_' => 'AND equality')
+      rule('equality' => 'comparison')
+      rule('equality' => 'comparison equalityTest_plus')
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
+      rule('equalityTest_star' => 'equalityTest comparison')
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
-      rule('comparison' => 'term comparisonTest_star')
-      rule('comparisonTest_star' => 'comparisonTest_star comparisonTest term')
-      rule('comparisonTest_star' => [])
+      rule('comparison' => 'term')
+      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
-      rule('term' => 'factor additive_star')
-      rule('additive_star' => 'additive_star additionOp factor')
-      rule('additive_star' => [])
+      rule('term' => 'factor')
+      rule('term' => 'factor additive_plus').as 'term_additive'
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'additive_plus_more'
+      rule('additive_plus' => 'additionOp factor').as 'additive_plus_end'
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
-      rule('factor' => 'unary multiplicative_star')
-      rule('multiplicative_star' => 'multiplicative_star multOp unary')
-      rule('multiplicative_star' => [])
+      rule('factor' => 'unary')
+      rule('factor' => 'unary multiplicative_plus').as 'factor_multiplicative'
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'multiplicative_plus_more'
+      rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary')
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
-      rule('call' => 'primary refinement_star')
-      rule('refinement_star' => 'refinement_star refinement')
-      rule('refinement_star' => [])
+      rule('call' => 'primary')
+      rule('call' => 'primary refinement_plus')
+      rule('refinement_plus' => 'refinement_plus refinement')
+      rule('refinement_plus' => 'refinement')
       rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
       rule('refinement' => 'DOT IDENTIFIER')
-      rule('primary' => 'TRUE')
-      rule('primary' => 'FALSE')
-      rule('primary' => 'NIL')
+      rule('primary' => 'TRUE').as 'literal_expr'
+      rule('primary' => 'FALSE').as 'literal_expr'
+      rule('primary' => 'NIL').as 'literal_expr'
       rule('primary' => 'THIS')
-      rule('primary' => 'NUMBER')
-      rule('primary' => 'STRING')
+      rule('primary' => 'NUMBER').as 'literal_expr'
+      rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
       rule('primary' => 'SUPER DOT IDENTIFIER')
-      
+
       # Utility rules
       rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block')
       rule('params_opt' => 'parameters')
@@ -142,11 +151,12 @@ module Loxxy
       rule('arguments_opt' => [])
       rule('arguments' => 'arguments COMMA expression')
       rule('arguments' => 'expression')
-      
     end
 
-  # And now build the grammar and make it accessible via a constant
-  # @return [Rley::Syntax::Grammar]
-  Grammar = builder.grammar
+    unless defined?(Grammar)
+      # And now build the grammar and make it accessible via a constant
+      # @return [Rley::Syntax::Grammar]
+      Grammar = builder.grammar
+    end
   end # module
 end # module

data/lib/loxxy/front_end/literal.rb

@@ -14,7 +14,7 @@ module Loxxy
       # @param theLexeme [String] the lexeme (= piece of text from input)
       # @param aTerminal [Rley::Syntax::Terminal, String]
       #   The terminal symbol corresponding to the lexeme.
-      # @param aPosition [Rley::Lexical::Position] The position of lexeme 
+      # @param aPosition [Rley::Lexical::Position] The position of lexeme
       #   in input text.
       def initialize(aValue, aLexeme, aTerminal, aPosition)
         super(aLexeme, aTerminal, aPosition)

data/lib/loxxy/front_end/parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'scanner'
+require_relative 'grammar'
+require_relative '../ast/ast_builder'
+
+module Loxxy
+  module FrontEnd
+    # A Lox parser that produce concrete parse trees.
+    # Concrete parse trees are the default kind of parse tree
+    # generated by the Rley library.
+    # They consist of two node types only:
+    # - NonTerminalNode
+    # - TerminalNode
+    # A NonTerminalNode has zero or more child nodes (called subnodes)
+    # A TerminalNode is leaf node, that is, it has no child node.
+    # While concrete parse tree nodes can be generated out of the box,
+    # they have the following drawbacks:
+    # - Generic node classes that aren't always suited for the needs of
+    #     the language being processing.
+    # - Concrete parse tree tend to be deeply nested, which may complicate
+    #   further processing.
+    class Parser
+      # @return [Rley::Engine] A facade object for the Rley parsing library
+      attr_reader(:engine)
+
+      def initialize
+        # Create a Rley facade object
+        @engine = Rley::Engine.new do |cfg|
+          cfg.diagnose = true
+          cfg.repr_builder = Ast::ASTBuilder
+        end
+
+        # Step 1. Load Lox grammar
+        @engine.use_grammar(Loxxy::FrontEnd::Grammar)
+      end
+
+      # Parse the given Lox program into a parse tree.
+      # @param source [String] Lox program to parse
+      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
+      def parse(source)
+        lexer = Scanner.new(source)
+        result = engine.parse(lexer.tokens)
+
+        unless result.success?
+          # Stop if the parse failed...
+          line1 = "Parsing failed\n"
+          line2 = "Reason: #{result.failure_reason.message}"
+          raise StandardError, line1 + line2
+        end
+
+        return engine.convert(result) # engine.to_ptree(result)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/front_end/raw_parser.rb

@@ -15,7 +15,7 @@ module Loxxy
     # A TerminalNode is leaf node, that is, it has no child node.
     # While concrete parse tree nodes can be generated out of the box,
     # they have the following drawbacks:
-    # - Generic node classes that aren't always suited for the needs of 
+    # - Generic node classes that aren't always suited for the needs of
     #     the language being processing.
     # - Concrete parse tree tend to be deeply nested, which may complicate
     #   further processing.
@@ -27,7 +27,6 @@ module Loxxy
         # Create a Rley facade object
         @engine = Rley::Engine.new do |cfg|
           cfg.diagnose = true
-          # cfg.repr_builder = SkmBuilder
         end
 
         # Step 1. Load Lox grammar
@@ -52,4 +51,4 @@ module Loxxy
       end
     end # class
   end # module
-end # module
+end # module