loxxy 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74cd4aa3bd58cad64cad8ac452535052c761f166da883b06b593590310edd97d
-  data.tar.gz: 15af4b4a4c86c7b8e6a14bda16433a9d1663ab581eae78331d29adeed02313d3
+  metadata.gz: e4f33203580d2b83ee7139e449787b439c0fb56c5a8c3dcc8035d114ffd957d3
+  data.tar.gz: 46c9fb2f55849c6aa9b9e4d58588746ddb3ac3353f7ed09922d9394a9fc512c6
 SHA512:
-  metadata.gz: 0dbd9244c36913eed955b1ff92bdc63fd77cc6f7cda3d6b037f3ee87cdcc8d4450673f852426a7395d968711aaf9a3a539efeeaf5e2a0d46865f4f4fa7276c74
-  data.tar.gz: c8c65b58fa53d0cce81a3e7508317dfbeb5d8e10f883a0a011d278ca33ee647967bfd34e79fc4703ad7a5b4a3a88aece8d17ca0d0db107f0ec0fcb9ac12e4280
+  metadata.gz: 30f554af6338b50297ce6befaa62c86c8406df681e25098cc95dc28da64bb6feabbb9e085846eb8032f51d8d3655332105eb1d7165903bbd0d6be24cb13c4d0b
+  data.tar.gz: d9d9a69a010d16807f6c4bf24b15e8135367bb62b6d2e052943e0d6030751f282c777f652dd3fced08093aee8abae228e63d365cae156fa6e87ac7f52fc7e2e6

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.0.10] - 2021-01-08
+- AST node generation for equality expression.
+
+## Changed
+- Class `AST::ASTBuilder` refactoring and added `reduce_` methods for equality operations.
+- File `grammar.rb`added name to equality rules
+- File `README.md` added gem version and license badges, expanded roadmap section.
+
+## Fixed
+- File `grammar.rb`: a rule had still the discarded non-terminal `equalityTest_star` in its lhs.
+
 ## [0.0.9] - 2021-01-07
 - AST node generation for comparison expression.
 

data/README.md

@@ -1,4 +1,7 @@
-# Loxxy
+# loxxy
+[![Gem Version](https://badge.fury.io/rb/loxxy.svg)](https://badge.fury.io/rb/loxxy)
+[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/loxxy/blob/main/LICENSE.txt)
+
 
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
 a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
@@ -6,7 +9,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 ## Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
   (from the scanner, parser, code generation).
-- The implementation should be mature enough to run (LoxLox)[https://github.com/benhoyt/loxlox],  
+- The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
 ## Current status
@@ -18,12 +21,48 @@ The __loxxy__ gem hosts two distinct parsers classes (`RawParser` and `Parser`).
   Currently it generates AST for arithmetic expressions with literal numbers only.
 
 ## Roadmap
-- [DONE] Scanner (tokenizer)
-- [DONE] Raw parser. It parses Lox programs and generates a parse tree.
-- [DONE] Tailored parser for generating AST (Abstract Syntax Tree)
-- [STARTED] Custom AST builder class  
-- [STARTED] Hierarchy classes for representing Lox expressions in AST  
-- [TODO] Interpreter or transpiler
+### Done
+- Scanner (tokenizer)
+- Lox grammar (in format required by Rley gem)   
+- Raw parser. It parses Lox programs and generates a raw parse tree.
+- Tailored parser for generating AST (Abstract Syntax Tree)
+  
+### Started
+-  Custom AST builder class  
+-  Classes for representing Lox expressions in AST
+
+### TODO
+AST Node generation
+Goal: parser should generate AST for any input Lox program
+- [X] Equality operator
+- [] Logical operator (and, or)
+- [] Unary expressions (negate, not)
+- [] Grouping expressions
+- [] Print statement
+- [] Simple assignment expressions
+- [] Variable declaration
+- [] Dot notation
+- [] Block statement
+- [] If statement
+- [] For statement
+- [] While statement
+- [] Function declaration
+- [] Call expression
+- [] Return statement
+- [] Class declaration
+- [] AST generation covers complete grammar
+
+Tree-walking:
+- [] Tree visitor recognizes all AST node types
+
+Interpreter:
+- Keywords: symbol table, scope, activation record, class & object model, Lox test suite
+- [] Milestone: Interpreter handles expressions but function calls
+- [] Milestone: Interpreter handles `for`, `if`, `print`, `while` and block statements
+- [] Milestone: Interpreter handles variable declarations (global, block)
+- [] Milestone: Interpreter handles function declarations and calls
+- [] Milestone: Interpreter supports class and object definition
+- [] Milestone: Lox interpreter complete
 
 ## Example using RawParser class
 ```ruby

data/lib/loxxy/ast/ast_builder.rb

@@ -10,13 +10,31 @@ module Loxxy
     # (Abstract Syntax Tree) from a sequence of input tokens and
     # visit events produced by walking over a GFGParsing object.
     class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-      # Terminal2NodeClass = {
-      #   'FALSE' => Datatype::False,
-      #   'NIL' => Datatype::Nil,
-      #   'NUMBER' => Datatype::Number,
-      #   'STRING' => Datatype::LXString,
-      #   'TRUE' => Datatype::True
-      # }.freeze
+      # Mapping Token name => operator | separator | delimiter characters
+      # @return [Hash{String => String}]
+      Name2special = {
+        'AND' => 'and',
+        'BANG' => '!',
+        'BANG_EQUAL' => '!=',
+        'COMMA' =>  ',',
+        'DOT' => '.',
+        'EQUAL' => '=',
+        'EQUAL_EQUAL' => '==',
+        'GREATER' => '>',
+        'GREATER_EQUAL' => '>=',
+        'LEFT_BRACE' =>  '{',
+        'LEFT_PAREN' => '(',
+        'LESS' => '<',
+        'LESS_EQUAL' => '<=',
+        'MINUS' => '-',
+        'OR' => 'or',
+        'PLUS' => '+',
+        'RIGHT_BRACE' => '}',
+        'RIGHT_PAREN' => ')',
+        'SEMICOLON' => ';',
+        'SLASH' =>  '/',
+        'STAR' => '*'
+      }.freeze
 
       attr_reader :strict
 
@@ -76,7 +94,7 @@ module Loxxy
       def reduce_binary_operator(_production, _range, tokens, theChildren)
         operand1 = theChildren[0]
 
-        # Second child is anray with couples [operator, operand2]
+        # Second child is array with couples [operator, operand2]
         theChildren[1].each do |(operator, operand2)|
           operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
         end
@@ -84,6 +102,36 @@ module Loxxy
         operand1
       end
 
+      # rule('something_plus' => 'something_plus operator symbol')
+      def reduce_binary_plus_more(_production, _range, _tokens, theChildren)
+        result = theChildren[0]
+        operator = Name2special[theChildren[1].symbol.name].to_sym
+        operand2 = theChildren[2]
+        result << [operator, operand2]
+      end
+
+      # rule('something_plus' => 'something_plus symbol')
+      def reduce_binary_plus_end(_production, _range, _tokens, theChildren)
+        operator = Name2special[theChildren[0].symbol.name].to_sym
+        operand2 = theChildren[1]
+        [[operator, operand2]]
+      end
+
+      # rule('equality' => 'comparison equalityTest_plus')
+      def reduce_equality_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
+      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
+      end
+
+      # rule('equalityTest_star' => 'equalityTest comparison')
+      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
       # rule('comparison' => 'term comparisonTest_plus')
       def reduce_comparison_plus(production, range, tokens, theChildren)
         reduce_binary_operator(production, range, tokens, theChildren)
@@ -93,16 +141,8 @@ module Loxxy
       # TODO: is it meaningful to implement this rule?
 
       # rule('comparisonTest_plus' => 'comparisonTest term')
-      def reduce_comparison_t_plus_end(_production, _range, _tokens, theChildren)
-        name2operators = {
-          'GREATER' => '>',
-          'GREATER_EQUAL' => '>=',
-          'LESS' =>  '<',
-          'LESS_EQUAL' => '<='
-        }
-        operator = name2operators[theChildren[0].symbol.name].to_sym
-        operand2 = theChildren[1]
-        [[operator, operand2]]
+      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
       # rule('term' => 'factor additive_plus')
@@ -111,18 +151,13 @@ module Loxxy
       end
 
       # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(_production, _range, _tokens, theChildren)
-        result = theChildren[0]
-        operator = theChildren[1].symbol.name == 'MINUS' ? :- : :+
-        operand2 = theChildren[2]
-        result << [operator, operand2]
+      def reduce_additive_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
       end
 
       # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(_production, _range, _tokens, theChildren)
-        operator = theChildren[0].symbol.name == 'MINUS' ? :- : :+
-        operand2 = theChildren[1]
-        [[operator, operand2]]
+      def reduce_additive_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
       # rule('factor' => 'multiplicative_plus')
@@ -131,18 +166,13 @@ module Loxxy
       end
 
       # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(_production, _range, _tokens, theChildren)
-        result = theChildren[0]
-        operator = theChildren[1].symbol.name == 'SLASH' ? :/ : :*
-        operand2 = theChildren[2]
-        result << [operator, operand2]
+      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
       end
 
       # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(_production, _range, _tokens, theChildren)
-        operator = theChildren[0].symbol.name == 'SLASH' ? :/ : :*
-        operand2 = theChildren[1]
-        [[operator, operand2]]
+      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'

data/lib/loxxy/front_end/grammar.rb

@@ -96,9 +96,9 @@ module Loxxy
       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('equality' => 'comparison equalityTest_plus').as 'equality_plus'
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'equality_t_plus_more'
+      rule('equalityTest_plus' => 'equalityTest comparison').as 'equality_t_plus_end'
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
       rule('comparison' => 'term')

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/spec/front_end/parser_spec.rb

@@ -255,8 +255,25 @@ LOX_END
       end # context
 
       context 'Parsing comparison expressions' do
-        it 'should parse the comparison of two number literals' do
-          %w[> >= < <=].each do |predicate|
+      it 'should parse the comparison of two number literals' do
+        %w[> >= < <=].each do |predicate|
+          input = "3 #{predicate} 2;"
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(predicate.to_sym)
+          expect(expr.operands[0].literal.value).to eq(3)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+      end
+      end # context
+
+      context 'Parsing equality expressions' do
+        it 'should parse the equality of two number literals' do
+          %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
             parent = ptree.root.subnodes[0]
@@ -269,6 +286,22 @@ LOX_END
             expect(expr.operands[1].literal.value).to eq(2)
           end
         end
+
+        it 'should parse combination of equality expressions' do
+          input = '5 != 2 == false; // A bit contrived example'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:==)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:!=)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to be_falsey
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley