loxxy 0.0.15 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7624afc97e5e8d3cee171dc9fbbe7a45c45698595109a5281d9f58fcaebd73ec
-  data.tar.gz: 67ec959b7758245f414314ea9c8b0a2bbf40a5e01133f17325fa40ab720858f0
+  metadata.gz: e6628d902c258d0aa2d589fd0960ab812addbfe8f0fbf162cfb627a90fbc1a40
+  data.tar.gz: c1fe1f5ce4b3dc7109c70783b78953fd72ffbbd837d58f8350d2a03615f80222
 SHA512:
-  metadata.gz: adcb9cf6b353b09cf623df330fbdff35255571f8781dfd0b46ea6ab32c02cf55bd0130f94414cd91aa8cb798b1ea7cd4aef4844acc556147b5e4b387d099b8c0
-  data.tar.gz: 47230281481b965fe1dddd74f763568a0ca125454800984c41fb29629d26c37ae8f7fa0320a38ca784abe605dfb5dc14f4a9c26b0d269240ea07c5e2feb6241b
+  metadata.gz: 301160cc1a00e819cc13cfb3273985b6af1ddadd94b236e4e7be0b346744355327be69d3b2d338ece3b6148a905d10a91dc3f6ef828912b7750efcdb0f4e5238
+  data.tar.gz: cc5bb436b6e487d7752180d42d046d5a09a6817878428d757b65b26f2955133985598b55e7d63c13d249ebef110914a3a2b8292777a2857b15dcba885c74c106

data/.rubocop.yml

@@ -250,7 +250,7 @@ Style/IfUnlessModifier:
   Enabled: false
 
 Style/InverseMethods:
-  Enabled: true
+  Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,71 @@
+## [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
+- Class `Ast::LoxLogicalExpr`
+- Method `Ast::ASTBuilder#reduce_grouping_expr` as semantic action for grouping expression
+- 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.
+
+## Added
+- Class `Ast::LoxLogicalExpr`
+- Method `Ast::ASTBuilder#reduce_logical_expr` for the semantic action require for `and`, `or`
+- Method `Ast::ASTVisitor#visit_logical_expr` for visiting logical expressions
+- Method `Backend::Engine#after_logical_expr` implements the evaluation of the logical expressions
+
+## [0.0.17] - 2021-01-12
+- The interpreter can evaluate all arithmetic and comparison operations.
+- It implements `==`, `!=` and the unary operations `!`, `-`
+
+## Added
+- Class `Ast::LoxUnaryExpr`
+- Method `Ast::ASTBuilder#reduce_unary_expr` to support the evaluation of `!` and ``-@`
+- Method `Ast::ASTVisitor#visit_unnary_expr` for visiting unary expressions
+- Method `Backend::Engine#after_unary_expr` evaluating an unary expression
+- In class `Datatype::BuiltinDatatype` the methods `falsey?`, `truthy?`, `!`, `!=`
+- In class `Datatype::Number`the methods `<`, `<=`, ´>´, `>=` and `-@`
+
+## Changed
+- File `README.md` updated.
+
+## [0.0.16] - 2021-01-11
+- The interpreter can evaluate product and division of two numbers.
+- It also implements equality `==` and inequality `!=` operators
+
+## Added
+- Method `Datatype::False#==` for equality testing
+- Method `Datatype::False#!=` for inequality testing
+- Method `Datatype::LXString#==` for equality testing
+- Method `Datatype::LXString#!=` for inequality testing
+- Method `Datatype::Nil#==` for equality testing
+- Method `Datatype::Nil#!=` for inequality testing
+- Method `Datatype::Number#==` for equality testing
+- Method `Datatype::Number#!=` for inequality testing
+- Method `Datatype::Number#*` for multiply operator
+- Method `Datatype::Number#/` for divide operator
+- Method `Datatype::True#==` for equality testing
+- Method `Datatype::True#!=` for inequality testing
+
+## Changed
+- Method `BackEnd::Engine#after_binary_expr` to allow `*`, `/`, `==`, `!=` operators
+- File `README.md` updated for the newly implemented operators
+
 ## [0.0.15] - 2021-01-11
 - The interpreter can evaluate substraction between two numbers.
 
@@ -14,7 +82,7 @@
 - The interpreter can evaluate addition of numbers and string concatenation
 
 ## Added
-- Method `Ast::ASTVisitor::visit_binary_expr` for visiting binary expressions
+- Method `Ast::ASTVisitor#visit_binary_expr` for visiting binary expressions
 - Method `Ast::LoxBinaryExpr#accept` for visitor pattern
 - Method `BackEnd::Engine#after_binary_expr` to trigger execution of binary operator
 - `Boolean` class hierarchy: added methos `true?` and `false?` to ease spec test writing

data/README.md

@@ -128,16 +128,20 @@ program
 ```
 
 ## Suppported Lox language features
-Although the interpreter should parse almost any valid Lox program,
-it currently can evaluate a tiny set of AST node (AST = Abstract Syntax Tree).
+On one hand, the parser covers the complete Lox grammar and should therefore, in principle,
+parse any valid Lox program.
+
+On the other hand, the interpreter is under development and currently it can evaluate only a tiny subset of __Lox__.
+But the situation is changing almost daily, stay tuned...
 
 Here are the language features currently supported by the interpreter:
 
 - [Comments](#comments)
 - [Keywords](#keywords)
-- [Operators and Special Chars](#operators-and-special-chars)
 - [Datatypes](#datatypes)
-- [Statements](#statements)
+- [Statements](#statements)  
+  -[Expressions](#expressions)  
+  -[Print Statement](#print-statement)
 
 ### Comments
 
@@ -148,38 +152,10 @@ Loxxy supports single line C-style comments.
 ```
 
 ### Keywords
-
-The parser knows all the __Lox__ reserved keywords:
+Loxxy implements the following __Lox__ reserved keywords:
 ```lang-none
-and, class, else, false, fun, for, if, nil, or,
-print, return, super, this, true, var, while
+and, false, nil, or, print, true
 ```
-Of these, the interpreter implements: `false`, `nil`, `true`
-
-### Operators and Special Chars
-#### Operators
-The parser recognizes all the __Lox__ operators, delimiters and separators:
-- Arithmetic operators: `+`, `-`, `*`, `/`
-- Comparison operators: `>`, `>=`, `<`, `<=`
-- Equality operators: `==`, `!=`
-
-Of these, the interpreter implements: 
-`+` (addition of two numbers or string concatenation)
-`-` (difference between two numbers)
-
-#### Delimiters
-The parser knows all the __Lox__ grouping delimiters:  
-(`, ), `{`, `}`
-
-These aren't yet implemented in the interpreter.
-
-The other characters that have a special meaning in __Lox__ are:
-- `,` Used in parameter list
-- `.` For the dot notation (i.e. calling a method)
-- `;` The semicolon is used to terminates expressions
-- `=` Assignment
-
-The parser recognizes them all but the interpreter accepts the semicolons only.
 
 ### Datatypes
 
@@ -189,22 +165,138 @@ loxxy supports  all the standard __Lox__ datatypes:
 - `String`: Sequence of characters surrounded by `"`. For example: `"Hello!"`
 - `Nil`: Used to define a null value, denoted by the `nil` keyword
 
-## Statements
-### Implemented expressions
-Loxxy implements expressions:
-- Plain literals only; or,
-- Addition of two numbers; or,
-- Subtraction of two numbers; or,  
-- Concatenation of two strings
+### Statements
+
+Loxxy supports the following statements:  
+-[Expressions](#expressions)  
+  -[Arithmetic expressions](#arithmetic-expressions)  
+  -[String concatenation](#string-concatenation)  
+  -[Comparison expressions](#comparison-expressions)  
+  -[Logical expressions](#logical-expressions)  
+  -[Grouping expressions](#grouping-expressions)  
+-[If Statement](#if-statement)
+-[Print Statement](#print-statement)
+
+#### Expressions
+
+##### Arithmetic expressions
+Loxxy supports the following operators for arithmetic expressions:
+
+- `+`: Adds of two numbers. Both operands must be of the type Number  
+  E.g. `37 + 5; // => 42`  
+  `7 + -3; // => 4`
+- `-`: (Binary) Subtracts right operand from left operand. Both operands must be numbers.  
+  E.g. `47 - 5; // => 42`
+- `-`: (Unary) Negates (= changes the sign) of the given number operand.  
+  E.g. `- -3; // => 3`
+- `*`: Multiplies two numbers  
+  E.g. `2 * 3; // => 6`
+- `/`: Divides two numbers  
+  E.g. `8 / 2; // => 4`
+  `5 / 2; // => 2.5`
+
+##### String concatenation
+- `+`: Concatenates two strings. Both operands must be of the String type.  
+  E.g. `"Hello" + ", " + "world! // => "Hello, world!"`
+
+##### Comparison expressions
+
+- `==`: Returns `true` if left operand is equal to right operand, otherwise `false`  
+  E.g. `false == false; // => true`  
+  `5 + 2 == 3 + 4; // => true`  
+  `"" == ""; // => true`
+- `!=`: Returns `true` if left operand is not equal to right operand, otherwise `false`  
+  E.g. `false != "false"; // => true`  
+  `5 + 2 != 4 + 3; // => false`
+- `<`: Returns `true` if left operand is less than right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 < 3; // => true`  
+  `1 < 0; // => false`  
+  `2 < 2; // => false`
+- `<=`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 <= 3; // => true`  
+  `1 <= 0; // => false`  
+  `2 <= 2; // => true`
+- `>`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 > 3; // => false`  
+  `1 > 0; // => true`  
+  `2 > 2; // => false`
+- `>=`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 > 3; // => false`  
+  `1 > 0; // => true`  
+  `2 > 2; // => false`
+
+##### Logical expressions
+
+REMINDER: In __Lox__, `false` and `nil` are considered falsey, everything else is truthy.
+
+- `and`: When both operands are booleans, then returns `true` if both left and right operands are truthy, otherwise `false`.   
+  If at least one operand isn't a boolean then returns first falsey operand else (both operands are truthy) returns the second operand.
+  truthy returns the second operand.  
+  E.g. `false and true; // => false`  
+  `true and nil; // => nil`  
+  `0 and true and ""; // => ""`
+- `or`: When both operands are booleans, then returns `true` if left or right operands are truthy, otherwise `false`.  
+  If at least one operand isn't a boolean then returns first truthy operand else (both operands are truthy) returns the second operand.
+  E.g. `false or true; // => true`  
+  `true or nil; // => nil`  
+  `false or nil; // => nil`  
+  `0 or true or ""; // => 0`
+- `!`: Performs a logical negation on its operand  
+  E.g. `!false; // => true`  
+  `!!true; // => true`  
+  `!0; // => false`
+
+####  Grouping expressions
+Use parentheses `(` `)` for a better control in expression/operator precedence.
+
+``` javascript
+print 3 + 4 * 5;  // => 23
+print (3 + 4) * 5; // => 35
+```
 
-### Implemented statements
-Loxxy implements the following statements:
-- Expressions (see above sub-section)
-- Print statement
+#### If 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.
+
+``` javascript
+print "Hello, world!";  // Output: Hello, world!
 
-```javascript
-// Print statement with nested concatenation
-print "Hello" + ", " + "world!";
 ```
 
 ## Installation

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'lox_print_stmt'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_grouping_expr'
+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

@@ -15,7 +15,6 @@ module Loxxy
         # @return [Hash{String => String}]
         Name2special = {
           'AND' => 'and',
-          'BANG' => '!',
           'BANG_EQUAL' => '!=',
           'COMMA' =>  ',',
           'DOT' => '.',
@@ -36,6 +35,11 @@ module Loxxy
           'SLASH' =>  '/',
           'STAR' => '*'
         }.freeze
+
+        Name2unary = {
+          'BANG' => '!',
+          'MINUS' => '-@'
+        }.freeze
       end # defined
 
       attr_reader :strict
@@ -92,6 +96,17 @@ module Loxxy
         node
       end
 
+      def reduce_logical_expr(_production, _range, tokens, theChildren)
+        operand1 = theChildren[0]
+
+        # Second child is array with couples [operator, operand2]
+        theChildren[1].each do |(operator, operand2)|
+          operand1 = LoxLogicalExpr.new(tokens[0].position, operator, operand1, operand2)
+        end
+
+        operand1
+      end
+
       # rule('lhs' => 'nonterm_i nonterm_k_plus')
       def reduce_binary_operator(_production, _range, tokens, theChildren)
         operand1 = theChildren[0]
@@ -119,6 +134,11 @@ module Loxxy
         [[operator, operand2]]
       end
 
+      # Return the AST node corresponding to the second symbol in the rhs
+      def reduce_keep_symbol2(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       #####################################
       #  SEMANTIC ACTIONS
       #####################################
@@ -138,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])
@@ -145,7 +173,7 @@ module Loxxy
 
       # rule('logic_or' => 'logic_and disjunct_plus')
       def reduce_logic_or_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+        reduce_logical_expr(production, range, tokens, theChildren)
       end
 
       # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
@@ -160,7 +188,7 @@ module Loxxy
 
       # rule('logic_and' => 'equality conjunct_plus')
       def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+        reduce_logical_expr(production, range, tokens, theChildren)
       end
 
       # rule('conjunct_plus' => 'conjunct_plus AND equality')
@@ -231,6 +259,19 @@ module Loxxy
         reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        LoxUnaryExpr.new(tokens[0].position, operator, operand)
+      end
+
+      # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      def reduce_grouping_expr(_production, _range, tokens, theChildren)
+        subexpr = theChildren[1]
+        LoxGroupingExpr.new(tokens[0].position, subexpr)
+      end
+
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
       def reduce_literal_expr(_production, _range, _tokens, theChildren)
         first_child = theChildren.first

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,7 +51,15 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
-      # Visit event. The visitor is about to visit a print statement expression.
+      # 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)
         broadcast(:before_print_stmt, aPrintStmt)
@@ -59,7 +67,21 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
-      # Visit event. The visitor is about to visit a print statement expression.
+      # Visit event. The visitor is about to visit a logical expression.
+      # Since logical expressions may take shorcuts by not evaluating all their
+      # sub-expressiosns, they are responsible for visiting or not their children.
+      # @param aBinaryExpr [AST::LOXBinaryExpr] the logical expression node to visit
+      def visit_logical_expr(aLogicalExpr)
+        broadcast(:before_logical_expr, aLogicalExpr)
+
+        # As logical connectors may take a shortcut only the first argument is visited
+        traverse_given_subnode(aLogicalExpr, 0)
+
+        # The second child could be visited: this action is deferred in handler
+        broadcast(:after_logical_expr, aLogicalExpr, self)
+      end
+
+      # Visit event. The visitor is about to visit a binary expression.
       # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
       def visit_binary_expr(aBinaryExpr)
         broadcast(:before_binary_expr, aBinaryExpr)
@@ -67,6 +89,22 @@ module Loxxy
         broadcast(:after_binary_expr, aBinaryExpr)
       end
 
+      # Visit event. The visitor is about to visit an unary expression.
+      # @param anUnaryExpr [AST::anUnaryExpr] unary expression node to visit
+      def visit_unary_expr(anUnaryExpr)
+        broadcast(:before_unary_expr, anUnaryExpr)
+        traverse_subnodes(anUnaryExpr)
+        broadcast(:after_unary_expr, anUnaryExpr)
+      end
+
+      # Visit event. The visitor is about to visit a grouping expression.
+      # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
+      def visit_grouping_expr(aGroupingExpr)
+        broadcast(:before_grouping_expr, aGroupingExpr)
+        traverse_subnodes(aGroupingExpr)
+        broadcast(:after_grouping_expr, aGroupingExpr)
+      end
+
       # Visit event. The visitor is visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
@@ -98,6 +136,20 @@ module Loxxy
         broadcast(:after_subnodes, aParentNode, subnodes)
       end
 
+      # Visit event. The visitor is about to visit one given subnode of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      # @param index [integer] index of child subnode
+      def traverse_given_subnode(aParentNode, index)
+        subnode = aParentNode.subnodes[index]
+        broadcast(:before_given_subnode, aParentNode, subnode)
+
+        # Now, let's proceed with the visit of that subnode
+        subnode.accept(self)
+
+        broadcast(:after_given_subnode, aParentNode, subnode)
+      end
+
       # Send a notification to all subscribers.
       # @param msg [Symbol] event to notify
       # @param args [Array] arguments of the notification.