loxxy 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eed6a7de54b89c276b0f098cd7d824f26c0ce9ba957d4fb9e3a4d12e6dfbc4f
-  data.tar.gz: ba7c00f11c5b69322aec0d447c2fef9cf6d6d74b2ea7bb16096581508a786427
+  metadata.gz: 43f600b63e6a264cf14a760e82537693068118152aa41e2b6d87f99d993280ea
+  data.tar.gz: 5ea73cae221b5039ec8257ef29c49bd63d22bb2477cde37b60f4f3799fe06534
 SHA512:
-  metadata.gz: 1b2c3826f085ce3f723cdbc70c3bdc3563817270985a321db05f97ca1ff81971bf872db49631d3fa20580932f7a0e2910bf3c6c84daf7873cdcd1f04c3392a99
-  data.tar.gz: 4e3d075facaf9c370d78f3f3ac89b7226e375eb32064535e3401c5ef52b8ca43c9d4c6cfb8f027b4037c7baa7c5945b0fd0dbe1e8b1e580fc732c4a38f7c57c6
+  metadata.gz: 8d4944a0b164730ddf0839abc325fc0389d895abecb1cd37f22909dc5a17243c29965eb194c351044fb3087bebc1d3dfd319aa6188f05e7a31df09bb41326e18
+  data.tar.gz: e7f857a51b74337724fa4cfd16816d79f9a0dec2b51dcdc8c297a52773048ea2dd2349a110fbf9b0d5eea6f2c57c6397f8196d14520cff59edab1e99444d7a60

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.0.18] - 2021-01-13
+- The interpreter can evaluate `and`, `or`expressions.
+
+
+
 ## [0.0.17] - 2021-01-12
 - The interpreter can evaluate all arithmetic and comparison operations.
 - It implements `==`, `!=` and the unary operations `!`, `-`

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,36 +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`, `print`, `true`
-
-### Operators and Special Chars
-#### Operators
-The __loxxy__ interpreter supports all the __Lox__ unary and binary operators:
-- Arithmetic operators: `+`, `-`, `*`, `/`
-- Comparison operators: `>`, `>=`, `<`, `<=`
-- Equality operators: `==`, `!=`
-- Unary negate (change sign): `-`
-- Unary not: `!`
-
-#### 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
 
@@ -187,24 +165,93 @@ 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,
-- (In)equality testing between two values; or,   
-- Basic arithmetic operations (`+`, `-`, `*`, `/`, `unary -`); or,  
-- Comparison between two numbers; or,
-- Concatenation of two strings,
-- Negation `!`
-
-### Implemented statements
-Loxxy implements the following statements:
-- Expressions (see above sub-section)
-- Print statement
+### 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)  
+-[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`
+
+#####  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 string concatenation
-print "Hello" + ", " + "world!";
 ```
 
 ## Installation

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -2,6 +2,7 @@
 
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
-require_relative 'lox_binary_expr'
 require_relative 'lox_unary_expr'
+require_relative 'lox_binary_expr'
+require_relative 'lox_logical_expr'
 require_relative 'lox_print_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -96,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]
@@ -149,7 +160,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')
@@ -164,7 +175,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')

data/lib/loxxy/ast/ast_visitor.rb

@@ -59,6 +59,20 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # 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)
@@ -106,6 +120,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.

data/lib/loxxy/ast/lox_logical_expr.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxLogicalExpr < LoxCompoundExpr
+      # @return [Symbol] message name to be sent to receiver
+      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
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_logical_expr(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -40,6 +40,38 @@ module Loxxy
         @ostream.print tos.to_str
       end
 
+      def after_logical_expr(aLogicalExpr, visitor)
+        op = aLogicalExpr.operator
+        operand1 = stack.pop # only first operand was evaluated
+        result = nil
+        if ((op == :and) && operand1.falsey?) || ((op == :or) && operand1.truthy?)
+          result = operand1
+        else
+          raw_operand2 = aLogicalExpr.subnodes[1]
+          raw_operand2.accept(visitor) # Visit means operand2 is evaluated
+          operand2 = stack.pop
+          result = logical_2nd_arg(operand2)
+        end
+
+        stack.push result
+      end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+           when false
+             False.instance # Convert to Lox equivalent
+           when nil
+             Nil.instance # Convert to Lox equivalent
+           when true
+             True.instance # Convert to Lox equivalent
+           when Proc
+             # Second operand wasn't yet evaluated...
+             operand2.call
+           else
+             operand2
+        end
+      end
+
       def after_binary_expr(aBinaryExpr)
         op = aBinaryExpr.operator
         operand2 = stack.pop

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -28,6 +28,13 @@ module Loxxy
         true # Default implementation
       end
 
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
       # Negation ('not')
       # Returns a boolean with opposite truthiness value.
       # @return [Datatype::Boolean]
@@ -35,11 +42,18 @@ module Loxxy
         falsey? ? True.instance : False.instance
       end
 
-      # Check for inequality of this object with another Lox object
-      # @param other [Datatype::BuiltinDatatype, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        !(self == other)
+      # Returns the first falsey argument (if any),
+      # otherwise returns the last truthy argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def and(operand2)
+        falsey? ? self : logical_2nd_arg(operand2)
+      end
+
+      # Returns the first truthy argument (if any),
+      # otherwise returns the last falsey argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def or(operand2)
+        truthy? ? self : logical_2nd_arg(operand2)
       end
 
       # Method called from Lox to obtain the text representation of the boolean.
@@ -53,6 +67,19 @@ module Loxxy
       def validated_value(aValue)
         aValue
       end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+          when false
+            False.instance # Convert to Lox equivalent
+          when nil
+            Nil.instance # Convert to Lox equivalent
+          when true
+            True.instance # Convert to Lox equivalent
+          else
+            operand2
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -262,12 +262,12 @@ LOX_END
       end # context
 
       context 'Parsing logical expressions' do
-        it 'should parse the logical operations betweentwo sub-expression' do
+        it 'should parse the logical operations between two sub-expression' do
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
             expr = ptree.root
-            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
             expect(expr.operator).to eq(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operands[0].operator).to eq(:>)
@@ -284,9 +284,9 @@ LOX_END
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
           expr = ptree.root
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operands[0].operator).to eq(:and)
           conjuncts = expr.operands[0].operands
           expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -164,6 +164,53 @@ module Loxxy
         end
       end
 
+      it 'should evaluate the "conjunction" of two values' do
+        [
+          # Return the first falsey argument
+          ['false and 1;', false],
+          ['nil and 1;', nil],
+          ['true and 1;', 1],
+          ['1 and 2 and false;', false],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are truthy
+          ['1 and true;', true],
+          ['0 and true;', true],
+          ['"false" and 0;', 0],
+          ['1 and 2 and 3;', 3]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the "disjunction" of two values' do
+        [
+          # Return the first truthy argument
+          ['1 or true;', 1],
+          ['false or 1;', 1],
+          ['nil or 1;', 1],
+          ['false or false or true;', true],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are falsey
+          ['false or false;', false],
+          ['nil or false;', false],
+          ['false or nil;', nil],
+          ['false or false or false;', false],
+          ['false or false or nil;', nil]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        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.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-12 00:00:00.000000000 Z
+date: 2021-01-13 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_literal_expr.rb
+- lib/loxxy/ast/lox_logical_expr.rb
 - lib/loxxy/ast/lox_node.rb
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb