loxxy 0.0.21 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd4cbf32f4ee44a60c45630a76318425850dc35b4d9f6129274cefcbf4e91fcc
-  data.tar.gz: 711e0ae07d2a0b3a080c2fe408d9adf4f7b96bb070af686d66dd3f9dbae8391d
+  metadata.gz: acd7b65477866aee4f022731a70f67cad63f482eae6ae5e3f5a35cd56c43f9b0
+  data.tar.gz: 4980c1dafbd83c1ed0a41cf5da09d0decba43e912722c5052fc3e4f63626d73a
 SHA512:
-  metadata.gz: 131f6fe3b23dc0a84b063efe70744b02ecc9edb68742540799964311298f35494a0d48db75bb18a240ddeed039286ab08ba2ef99e2ae4857d2b4d5dc4403d5ba
-  data.tar.gz: b46c18f54147fd01f9819e3ad06564ee78fe72de5c91d6ef8a5bef5945d9f1ad622cad848c4d521ae66f00c91b7825d01e57c831b2a097da830bec0d99f2cf06
+  metadata.gz: e8853388df750173e1a9e818e3aac92f33f98ff75cf5c575d0b583758c59938810a593823a73a6914a28413ba697d53147d7317b744484d43b4026c76a182bc4
+  data.tar.gz: 3426ce17792625f908f2a31c879b0a312cbefbe18c82848f769d78bcac550d3700349fc1408bbeddb7738b47735ed583fd89355636c8c377a7cde3baf2f5071f

data/CHANGELOG.md

@@ -1,4 +1,19 @@
-## [0.0.21] - 2021-01-1x
+## [0.0.22] - 2021-01-17
+- The interpreter can retrieve the value of a variable.
+
+## Added
+- Method `Ast::ASTBuilder#declaration_plus_more` and `Ast::ASTBuilder#declaration_plus_end` to allow multiple expressions/statements
+- Method `Ast::ASTBuilder#reduce_var_expression` creates an `Ast::LoxVariableExpr` node
+- Method `Ast::ASTVisitor#visit_var_expr` for visiting `Ast::LoxVariableExpr` nodes
+- Class `Ast::LoxSeqDecl` a node that represents a sequence of declarations/statements
+- Class `Ast::LoxVarExpr` a node that represents a variable occurrence in an expression
+- Method `Engine::after_variable_expr`: retrieve the value of variable with given name
+
+## Changed
+- Method `Ast::ASTBuilder#reduce_lox_program` to support multiple statements/declarations
+- File `README.md` updated.
+
+## [0.0.21] - 2021-01-16
 - The interpreter supports the declaration global variables.
 
 ## Added

data/README.md

@@ -176,6 +176,7 @@ Loxxy supports the following statements:
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
+  -[Variable expressions](#variable-expressions)
   
 -[Variable declarations](#var-statement)  
 -[If Statement](#if-statement)  
@@ -258,13 +259,20 @@ print 3 + 4 * 5;  // => 23
 print (3 + 4) * 5; // => 35
 ```
 
+####  Variable expressions
+In __Lox__, a variable expression is nothing than retrieving the value of a variable.
+``` javascript
+var foo = "bar;" // Variable declaration
+foo;  // Varible expression (= retrieving its value)
+```
+
 #### Variable declarations
 ``` javascript
 var iAmAVariable = "my-initial-value";
 var iAmNil; // __Lox__ initializes variables to nil by default;
 ```
 
-Warning: current version cannot retrieve the value of a variable.
+Warning: current version cannot assign a value to an existing variable.  
 Expect this capability to be implemented in the coming days.
 
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
 require_relative 'lox_grouping_expr'
@@ -9,3 +10,4 @@ require_relative 'lox_logical_expr'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
 require_relative 'lox_var_stmt'
+require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -150,7 +150,17 @@ module Loxxy
 
       # rule('program' => 'declaration_plus EOF').as ''
       def reduce_lox_program(_production, range, tokens, theChildren)
-        return_first_child(range, tokens, theChildren) # Discard the semicolon
+        LoxSeqDecl.new(tokens[0].position, theChildren[0])
+      end
+
+      # rule('declaration_plus' => 'declaration_plus declaration').as ''
+      def reduce_declaration_plus_more(_production, range, tokens, theChildren)
+        theChildren[0] << theChildren[1]
+      end
+
+      # rule('declaration_plus' => 'declaration')
+      def reduce_declaration_plus_end(_production, range, tokens, theChildren)
+        [ theChildren[0] ]
       end
 
       # rule('exprStmt' => 'expression SEMICOLON')
@@ -292,6 +302,13 @@ module Loxxy
         literal = first_child.token.value
         LoxLiteralExpr.new(pos, literal)
       end
+
+      # rule('primary' => 'IDENTIFIER')
+      def reduce_variable_expr(_production, _range, tokens, theChildren)
+        var_name = theChildren[0].token.lexeme
+        LoxVariableExpr.new(tokens[0].position, var_name)
+      end#
+
     end # class
   end # module
 end # module

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 variable declaration statement.
+      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      def visit_seq_decl(aSeqDecls)
+        broadcast(:before_seq_decl, aSeqDecls)
+        traverse_subnodes(aSeqDecls)
+        broadcast(:after_seq_decl, aSeqDecls)
+      end
+
       # Visit event. The visitor is about to visit a variable declaration statement.
       # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
       def visit_var_stmt(aVarStmt)
@@ -121,8 +129,15 @@ module Loxxy
         broadcast(:after_literal_expr, aLiteralExpr)
       end
 
+      # Visit event. The visitor is visiting a variable reference node
+      # @param aLiteralExpr [AST::LoxVariableExpr] the variable reference node to visit.
+      def visit_variable_expr(aVariableExpr)
+        broadcast(:before_variable_expr, aVariableExpr)
+        broadcast(:after_variable_expr, aVariableExpr, self)
+      end
+
       # Visit event. The visitor is about to visit the given non terminal node.
-      # @param aNonTerminalNode [Rley::PTre::NonTerminalNode] the node to visit.
+      # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
       def visit_nonterminal(_non_terminal_node)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.

data/lib/loxxy/ast/lox_seq_decl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxSeqDecl < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param declarations [Arrya<Loxxy::Ast::LoxNode>]
+      def initialize(aPosition, declarations)
+        super(aPosition, declarations)
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_seq_decl(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_variable_expr.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    # This AST node represents a mention of a variable
+    class LoxVariableExpr < LoxNode
+      # @return [String] variable name
+      attr_reader :name
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String] name of the variable
+      def initialize(aPosition, aName)
+        super(aPosition)
+        @name = aName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_variable_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -41,6 +41,11 @@ module Loxxy
       ##########################################################################
       # Visit event handling
       ##########################################################################
+
+      def after_seq_decl(aSeqDecls)
+        # Do nothing, subnodes were already evaluated
+      end
+
       def after_var_stmt(aVarStmt)
         new_var = Variable.new(aVarStmt.name, aVarStmt.subnodes[0])
         symbol_table.insert(new_var)
@@ -120,6 +125,13 @@ module Loxxy
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
 
+      def after_variable_expr(aVarExpr, aVisitor)
+        var_name = aVarExpr.name
+        var = symbol_table.lookup(var_name)
+        raise StandardError, "Unknown variable #{var_name}" unless var
+        var.value.accept(aVisitor) # Evaluate the variable value
+      end
+
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)

data/lib/loxxy/front_end/grammar.rb

@@ -30,8 +30,8 @@ module Loxxy
       rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration')
-      rule('declaration_plus' => 'declaration')
+      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
+      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -137,7 +137,7 @@ module Loxxy
       rule('primary' => 'THIS')
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
-      rule('primary' => 'IDENTIFIER')
+      rule('primary' => 'IDENTIFIER').as 'variable_expr'
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -34,6 +34,7 @@ module Loxxy
         let(:var_decl) { Ast::LoxVarStmt.new(sample_pos, 'greeting', greeting) }
         let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
 
+
         it "should react to 'after_var_stmt' event" do
           expect { subject.after_var_stmt(var_decl) }.not_to raise_error
           current_env = subject.symbol_table.current_env

data/spec/front_end/parser_spec.rb

@@ -64,7 +64,8 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +73,8 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +83,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[0]
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::Number)
             expect(leaf.literal.value).to eq(source.to_f)
@@ -96,7 +98,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[0]
             expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
             expect(leaf.literal).to be_kind_of(Datatype::LXString)
             expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
@@ -106,7 +108,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,7 +121,7 @@ module Loxxy
             print "Hello, world!";
 LOX_END
           ptree = subject.parse(program)
-          prnt_stmt = ptree.root
+          prnt_stmt = ptree.root.subnodes[0]
           expect(prnt_stmt).to be_kind_of(Ast::LoxPrintStmt)
           expect(prnt_stmt.subnodes[0]).to be_kind_of(Ast::LoxLiteralExpr)
           expect(prnt_stmt.subnodes[0].literal).to be_kind_of(Loxxy::Datatype::LXString)
@@ -131,7 +133,7 @@ LOX_END
         it 'should parse the addition of two number literals' do
           input = '123 + 456;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -141,7 +143,7 @@ LOX_END
         it 'should parse the subtraction of two number literals' do
           input = '4 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -151,7 +153,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -164,7 +166,7 @@ LOX_END
         it 'should parse the division of two number literals' do
           input = '8 / 2;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -174,7 +176,7 @@ LOX_END
         it 'should parse the product of two number literals' do
           input = '12.34 * 0.3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -184,7 +186,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -197,7 +199,7 @@ LOX_END
         it 'should parse combination of terms and factors' do
           input = '5 + 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -212,7 +214,7 @@ LOX_END
         it 'should parse the concatenation of two string literals' do
           input = '"Lo" + "ve";'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -225,7 +227,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -239,7 +241,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.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)
@@ -250,7 +252,7 @@ LOX_END
         it 'should parse combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -266,7 +268,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.subnodes[0]
             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)
@@ -283,7 +285,7 @@ LOX_END
         it 'should parse a combinations of logical expressions' do
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           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::LoxLogicalExpr)

data/spec/interpreter_spec.rb

@@ -52,7 +52,12 @@ module Loxxy
     end # context
 
     context 'Evaluating Lox code:' do
-      let(:hello_world) { 'print "Hello, world!";' }
+      let(:hello_world) do
+        lox =<<-LOX_END
+        var greeting = "Hello"; // Declaring a variable
+        print greeting + ", " + "world!"; // ... Playing with concatenation
+LOX_END
+      end
 
       it 'should evaluate core data types' do
         result = subject.evaluate('true; // Not false')
@@ -259,6 +264,15 @@ module Loxxy
         expect { subject.evaluate('var iAmNil;') }.not_to raise_error
       end
 
+      it 'should accept variable mention' do
+        program = <<-LOX_END
+        var foo = "bar";
+        print foo;
+LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('bar')
+      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.21
+  version: 0.0.22
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-16 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -96,8 +96,10 @@ files:
 - lib/loxxy/ast/lox_node.rb
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/ast/lox_seq_decl.rb
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
+- lib/loxxy/ast/lox_variable_expr.rb
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb