loxxy 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eced55bddfd7918cbc7aea8eff5f7ecd37aa88baa6e5a6f7350f5bd7606e99af
-  data.tar.gz: f9b8104a0f3a273466ff568a014e345437f4c568621828de8da44961fb52f0e5
+  metadata.gz: e6628d902c258d0aa2d589fd0960ab812addbfe8f0fbf162cfb627a90fbc1a40
+  data.tar.gz: c1fe1f5ce4b3dc7109c70783b78953fd72ffbbd837d58f8350d2a03615f80222
 SHA512:
-  metadata.gz: d5b23defe380228bda4e32d9cb94909767fdc42242111f00be214bfbead6323a5e6acda0d78dcaf4e1c2e1fa7d13cd0363661af959a62b093bfcc50c34c290a0
-  data.tar.gz: 96a6a77824cd97b248ad6a78d66d4757c81549fa199021f446883d690f2702dbf4d9879950505d9aa54f45376bd7e6204be8b054e27b43a5576aca744be40047
+  metadata.gz: 301160cc1a00e819cc13cfb3273985b6af1ddadd94b236e4e7be0b346744355327be69d3b2d338ece3b6148a905d10a91dc3f6ef828912b7750efcdb0f4e5238
+  data.tar.gz: cc5bb436b6e487d7752180d42d046d5a09a6817878428d757b65b26f2955133985598b55e7d63c13d249ebef110914a3a2b8292777a2857b15dcba885c74c106

data/CHANGELOG.md

@@ -1,4 +1,13 @@
-## [0.0.18] - 2021-01-14
+## [0.0.20] - 2021-01-15
+- The interpreter supports the `if` ... `else` statement.
+
+## Added
+- Class `Ast::LoxItStmt`, AST node specific for `if` `else` statements
+- Method `Ast::ASTBuilder#reduce_if_stmt` as semantic action for if ... else
+- Method `Ast::ASTVisitor#visit_if_stmt` for visiting `LoxIfStmt` nodes
+- Method `Engine::after_if_stmt` implementation of the control flow
+
+## [0.0.19] - 2021-01-14
 - The interpreter supports expressions between parentheses (grouping).
 
 ## Added
@@ -7,6 +16,10 @@
 - Method `Ast::ASTVisitor#visit_grouping_expr` for visiting grouping expressions
 - Method `Engine::after_grouping_expr`for the evaluation of grouping expressions
 
+## Changed
+- File `grammar.rb` rules for if ... else were given names in order to activate semantic actions.
+- File `README.md` updated with little `if ... else` documentation.
+
 ## [0.0.18] - 2021-01-13
 - The interpreter can evaluate `and`, `or`expressions.
 

data/README.md

@@ -174,6 +174,7 @@ Loxxy supports the following statements:
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
+-[If Statement](#if-statement)
 -[Print Statement](#print-statement)
 
 #### Expressions
@@ -245,7 +246,7 @@ REMINDER: In __Lox__, `false` and `nil` are considered falsey, everything else i
   `!!true; // => true`  
   `!0; // => false`
 
-#####  Grouping expressions
+####  Grouping expressions
 Use parentheses `(` `)` for a better control in expression/operator precedence.
 
 ``` javascript
@@ -253,8 +254,43 @@ print 3 + 4 * 5;  // => 23
 print (3 + 4) * 5; // => 35
 ```
 
+#### If statement
 
-#####  Print Statement
+Based on a given condition, an if statement executes one of two statements:
+``` javascript
+if (condition) {
+print "then-branch";
+} else {
+print "else-branch";
+}
+```
+
+As for other languages, the `else` part is optional.
+##### Warning: nested `if`...`else`
+Call it a bug ... Nested `if` `else` control flow structure aren't yet supported by __Loxxy__.  
+The culprit has a name: [the dangling else](https://en.wikipedia.org/wiki/Dangling_else). 
+
+The problem in a nutshell: in a nested if ... else ... statement like this:
+``` javascript
+'if (true) if (false) print "bad"; else print "good";
+```
+... there is an ambiguity. Indeed, according to the __Lox__ grammar, the `else` could be bound 
+either to the first `if` or to the second one.
+This ambiguity is usually lifted by applying an ad-hoc rule: an `else` is aways bound to the most 
+recent (rightmost) `if`.  
+Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.
+As a consequence,it complains about the found ambiguity and stops the parsing...
+Although `Rley` can cope with ambiguities, this requires the use of an advanced data structure
+called `Shared Packed Parse Forest (SPPF)`.
+SPPF are much more complex to handle than the `common` parse trees present in most compiler or interpreter books.
+Therefore, a future version of `Rley` will incorporate the capability to define disambuiguation rules.  
+
+In the meantime, the `Loxxy` will progress on other __Lox__ features like:
+- Variables,
+- Block structures...
+
+
+####  Print Statement
 
 The statement print + expression + ; prints the result of the expression to stdout.
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -7,3 +7,4 @@ require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'
 require_relative 'lox_print_stmt'
+require_relative 'lox_if_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -158,6 +158,14 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
+      # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
+      def reduce_if_stmt(_production, _range, tokens, theChildren)
+        condition = theChildren[1]
+        then_stmt = theChildren[2]
+        else_stmt = theChildren[3]
+        LoxIfStmt.new(tokens[0].position, condition, then_stmt, else_stmt)
+      end
+
       # rule('printStmt' => 'PRINT expression SEMICOLON')
       def reduce_print_stmt(_production, _range, tokens, theChildren)
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,6 +51,14 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
+      # Visit event. The visitor is about to visit a if statement.
+      # @param anIfStmt [AST::LOXIfStmt] the if statement node to visit
+      def visit_if_stmt(anIfStmt)
+        broadcast(:before_if_stmt, anIfStmt)
+        traverse_subnodes(anIfStmt) # The condition is visited/evaluated here...
+        broadcast(:after_if_stmt, anIfStmt, self)
+      end
+
       # Visit event. The visitor is about to visit a print statement.
       # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
       def visit_print_stmt(aPrintStmt)

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxIfStmt < LoxCompoundExpr
+      # @return [LoxNode] code of then branch
+      attr_reader :then_stmt
+
+      # @return [LoxNode, NilClass] code of else branch
+      attr_reader :else_stmt
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param subExpr [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, condExpr, thenStmt, elseStmt)
+        super(aPosition, [condExpr])
+        @then_stmt = thenStmt
+        @else_stmt = elseStmt
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_if_stmt(self)
+      end
+
+      # Accessor to the condition expression
+      # @return [LoxNode]
+      def condition
+        subnodes[0]
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -33,7 +33,18 @@ module Loxxy
         stack.empty? ? Datatype::Nil.instance : stack.pop
       end
 
+      ##########################################################################
       # Visit event handling
+      ##########################################################################
+      def after_if_stmt(anIfStmt, aVisitor)
+        # Retrieve the result of the condition evaluation
+        condition = stack.pop
+        if condition.truthy?
+          result = anIfStmt.then_stmt.accept(aVisitor)
+        elsif anIfStmt.else_stmt
+          anIfStmt.else_stmt.accept(aVisitor)
+        end
+      end
 
       def after_print_stmt(_printStmt)
         tos = stack.pop

data/lib/loxxy/front_end/grammar.rb

@@ -68,9 +68,9 @@ module Loxxy
       rule('forTest' => 'expression_opt SEMICOLON')
       rule('forUpdate' => 'expression_opt')
 
-      rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
-      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN')
-      rule('elsePart_opt' => 'ELSE statement')
+      rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
+      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
+      rule('elsePart_opt' => 'ELSE statement').as 'keep_symbol2'
       rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'

data/lib/loxxy/version.rb

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

data/spec/interpreter_spec.rb

@@ -223,6 +223,33 @@ module Loxxy
         end
       end
 
+      it 'should evaluate an if statement' do
+        [
+          # Evaluate the 'then' expression if the condition is true.
+          ['if (true) print "then-branch";', 'then-branch'],
+          ['if (false) print "ignored";', ''],
+          # TODO: test with then block body
+          # TODO: test with assignment in if condition
+
+          # Evaluate the 'else' expression if the condition is false.
+          ['if (true) print "then-branch"; else print "else-branch";', 'then-branch'],
+          ['if (false) print "then-branch"; else print "else-branch";', 'else-branch'],
+          ['if (0) print "then-branch"; else print "else-branch";', 'then-branch'],
+          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch'],
+          # TODO: test with else block body
+
+          # TODO: A dangling else binds to the right-most if.
+          # ['if (true) if (false) print "bad"; else print "good";', 'good'],
+          # ['if (false) if (true) print "bad"; else print "worse";', 'bad']
+        ].each do |(source, predicted)|
+          io = StringIO.new
+          cfg = { ostream: io }
+          lox = Loxxy::Interpreter.new(cfg)
+          result = lox.evaluate(source)
+          expect(io.string).to eq(predicted)
+        end
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -90,6 +90,7 @@ files:
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
+- lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
 - lib/loxxy/ast/lox_logical_expr.rb
 - lib/loxxy/ast/lox_node.rb