loxxy 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1b591e9ed6ae88b4b4232c01c4f08fd4453fb499a665c368cd64ce2135a6718
-  data.tar.gz: 6bc1f01f9f0a963a2781271c46391e2c2801b61cc1b076e0b79be30450bee2af
+  metadata.gz: ed8bad2906a9ffd76c81a1fe14d89088f913f84996f0a6d98e7f104e0eccfdc9
+  data.tar.gz: 40ee48dc0f4d7e0ce1028820b9c5cf56d0c78d9853916f3bf9e5f32a7106887a
 SHA512:
-  metadata.gz: 5dd208921fc139eb5f48b182abbe64b919c514904dfab073b09c4a9656989db5c95a5e1bd6f72733a46af8351dc6f95ab94612d8016c22e13dbcedd4637db90b
-  data.tar.gz: 63ac04a1cd79335daf5dbb38de2615e89044c49ec74fd174200149ef24d829861c3af0e7bf62862cbffc03940b955a6c9336344696d432e4efaa83d2dc1e9d35
+  metadata.gz: 69c3c6e6b2a60c3f27284be820ac8f2687de0073c28719bd9414578ab37ac59de267dc1e69897966fef33d4ba725597587fe991b8e20ce6d40ec1587f3aa53c4
+  data.tar.gz: c296dcedcf97fe7426a59cfb2df2144685f2809c64becb18483e62a5aea536c2ca3ae2ab697b865c0945456e191a0a011f01123d34160acfa554761b8a2f917e

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.0.8] - 2021-01-07
+- AST node generation for arithmetic operations of number literals.
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_` methods for arithmetic operations.
+
+## Fixed
+- File `grammar.rb`: second rule for `factor` had a missing member in rhs.
+
 ## [0.0.7] - 2021-01-06
 - Lox grammar reworked, initial AST classes created.
 

data/README.md

@@ -9,6 +9,14 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 - The implementation should be mature enough to run (LoxLox)[https://github.com/benhoyt/loxlox],  
   a Lox interpreter written in Lox.
 
+## Current status
+The __loxxy__ gem hosts two distinct parsers classes (`RawParser` and `Parser`).
+- A `RawParser` instance is able to recognize valid Lox input and to generate
+  a concrete parse tree from it.
+- A `Parser` instance can also parse Lox source code but will generate an AST
+  (Abstract Syntax Tree) that will be used by the future tree-walking interpreter.
+  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.
@@ -17,14 +25,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 - [STARTED] Hierarchy classes for representing Lox expressions in AST  
 - [TODO] Interpreter or transpiler
 
-## Example
-The __loxxy__ hosts two distinct parsers classes (`RawParser` and `Parser`).  
-- A `RawParser` instance is able to recognize Lox input and to generate
-a concrete parse tree from it.
-- A `Parser` instance can also parse Lox source code but will generate an AST
-(Abstract Syntax Tree) that will be used by the future tree-walking interpreter.
-
-### Example using RawParser class
+## Example using RawParser class
 ```ruby
 require 'loxxy'
 
@@ -69,7 +70,6 @@ program
 +-- EOF: ''
 ```
 
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -91,9 +91,9 @@ Or install it yourself as:
 TODO: Write usage instructions here
 
 ## Other Lox implementations in Ruby
-An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations
+An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
-For Ruby, ther is the [lox](https://github.com/rdodson41/ruby-lox) gem.
+For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
 There are other Ruby-based projects as well:  
 - [SlowLox](https://github.com/ArminKleinert/SlowLox), described as a "1-to-1 conversion of JLox to Ruby"
 - [rulox](https://github.com/LevitatingBusinessMan/rulox)

data/lib/loxxy/ast/ast_builder.rb

@@ -72,18 +72,59 @@ module Loxxy
         node
       end
 
+      # rule('term' => 'factor additive_plus')
+      def reduce_term_additive(_production, _range, tokens, theChildren)
+        operand1 = theChildren[0]
+
+        # Second child is anray with couples [operator, operand2]
+        theChildren[1].each do |(operator, operand2)|
+          operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
+        end
+
+        operand1
+      end
+
       # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additionOp_expr(_production, _range, _tokens, theChildren)
-        (operand1, operator_node, operand2) = theChildren
-        operator = operator_node.symbol.name == 'MINUS' ? :- : :+
-        LoxBinaryExpr.new(operator_node.token.position, operator, operand1, operand2)
+      def reduce_additive_plus_more(_production, _range, _tokens, theChildren)
+        result = theChildren[0]
+        operator = theChildren[1].symbol.name == 'MINUS' ? :- : :+
+        operand2 = theChildren[2]
+        result << [operator, operand2]
+      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]]
       end
 
-      # rule('multiplicative_star' => 'multiplicative_star multOp unary').as 'multOp_expr'
-      # def reduce_multOp_expr(_production, _range, _tokens, theChildren)
-      #   (operand1, operator, operand2) = theChildren
-      #   LoxBinaryExpr.new(operator.token.position, operator, operand1, operand2)
-      # end
+      # rule('factor' => 'multiplicative_plus')
+      def reduce_factor_multiplicative(_production, _range, tokens, theChildren)
+        operand1 = theChildren[0]
+
+        # Second child is anray with couples [operator, operand2]
+        theChildren[1].each do |(operator, operand2)|
+          operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
+        end
+
+        operand1
+      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]
+      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]]
+      end
 
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
       def reduce_literal_expr(_production, _range, _tokens, theChildren)

data/lib/loxxy/front_end/grammar.rb

@@ -110,15 +110,15 @@ module Loxxy
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
       rule('term' => 'factor')
-      rule('term' => 'factor additive_plus')
-      rule('additive_plus' => 'additive_plus additionOp factor').as 'additionOp_expr'
-      rule('additive_plus' => 'additionOp 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')
-      rule('factor' => 'multiplicative_plus')
-      rule('multiplicative_plus' => 'multiplicative_plus multOp unary') # .as 'multOp_expr'
-      rule('multiplicative_plus' => 'multOp 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')

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -137,13 +137,89 @@ LOX_END
         end
       end # context
 
-      context 'Parsing literals:' do
+      context 'Parsing arithmetic operations' do
         it 'should parse the addition of two number literals' do
-          # input = '123 + 456;'
-          # ptree = subject.parse(input)
-          # term = walk_subnodes(ptree.root, [0, 0, 0, 0, 0, 0, 0])
-          # expect(leaf).to be_kind_of(Ast::LoxBinaryExpr)
-          # expect(leaf.literal).to be_equal(Datatype::False.instance)
+          input = '123 + 456;'
+          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].literal.value).to eq(123)
+          expect(expr.operands[1].literal.value).to eq(456)
+        end
+
+        it 'should parse the subtraction of two number literals' do
+          input = '4 - 3;'
+          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].literal.value).to eq(4)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse multiple additive operations' do
+          input = '5 + 2 - 3;'
+          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 eq(3)
+        end
+
+        it 'should parse the division of two number literals' do
+          input = '8 / 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(:/)
+          expect(expr.operands[0].literal.value).to eq(8)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+
+        it 'should parse the product of two number literals' do
+          input = '12.34 * 0.3;'
+          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].literal.value).to eq(12.34)
+          expect(expr.operands[1].literal.value).to eq(0.3)
+        end
+
+        it 'should parse multiple additive operations' do
+          input = '5 * 2 / 3;'
+          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 eq(3)
         end
       end # context
     end # describe

data/spec/front_end/scanner_spec.rb

@@ -223,6 +223,18 @@ LOX_END
           ]
           match_expectations(subject, expectations)
         end
+
+        it 'should cope with single slash (divide) expression' do
+          subject.start_with('8 / 2')
+
+          expectations = [
+            # [token lexeme]
+            %w[NUMBER 8],
+            %w[SLASH /],
+            %w[NUMBER 2]
+          ]
+          match_expectations(subject, expectations)
+        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.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-06 00:00:00.000000000 Z
+date: 2021-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley