loxxy 0.0.27 → 0.1.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47ae4c0af1698de7187c530ec5feec9390a664ff681aae6c47a36e351bda229d
-  data.tar.gz: ff309645b8e71608e6a3801d4a4be558b8e86d59d658af4ec2eb796989e88455
+  metadata.gz: 2bf956c6e2d6736535acd1e9b0cb29df6b55a8d9002be073cb70bbf753fb06c9
+  data.tar.gz: 1f635dc69e588f01406cd988bf98d12b9ea398f36e249113a37b089788ef21cb
 SHA512:
-  metadata.gz: 73bea958f39a8cb97ed2e59c049ab58006845519a642d20e72cbdd554be60cb3b553f84dcdd64a36410796f83e87bb3239eee9933148b821b074916f4198a810
-  data.tar.gz: a3235fd86a5c99c0ecf581be106e53d59a0643b3ac6299fbd0eccd0f5eacc5a15b63df3a22fb4edef8b30314fa0360432b017d9a2417668e365e2b9dd3f8b2b8
+  metadata.gz: dce93451a9efc548df45683f5772a5d5509c25a57969465f3ff9f48f8b5adcc642b7bb92b25d43658869b5b62d3108796964226c35130cb1492335dc6eaf8fe1
+  data.tar.gz: 881dfd881db0d2ec3e56b91ad14bc6dd0e0b91ba3839fa1efe09c3636aac575856e3e8c4d4a64a55e913a757a4f1d275cc843734ceda3a23ef597591cb282f3f

data/CHANGELOG.md

@@ -1,3 +1,67 @@
+## [0.1.03] - 2021-02-26
+- Runtime argument chacking for arithmetic and comparison operators
+
+### Added
+- Test suite for arithmetic and comparison operators (in project repository)
+- Class `BackEnd::UnaryOperator`:  runtime argument validation
+- Class `BackEnd::BinaryOperator`: runtime argument validation
+
+### Changed
+- File `console` renamed to `loxxy`. Very basic command-line interface.
+- Custom exception classes 
+- File `README.md` updated list of supported `Lox` keywords.
+
+
+## [0.1.02] - 2021-02-21
+- Function definition and call documented in `README.md`
+
+### Changed
+- File `README.md` updated description of function definition and function call.
+
+### Fixed
+- Method `BackEnd::Engine#after_print_stmt` now handles of empty stack or nil data.
+- Method `BackEnd::Engine#after_call_expr` was pushing one spurious item onto data stack.
+
+## [0.1.01] - 2021-02-20
+### Fixed
+- Fixed most offences for Rubocop.
+
+
+## [0.1.00] - 2021-02-20
+- Version number bumped, `Loxxy` supports function definitions
+
+### Added
+- Class `Ast::LoxFunStmt` a node that represents a function declaration
+- Method `Ast::ASTBuilder#reduce_fun_decl`
+- Method `Ast::ASTBuilder#reduce_function` creates a `LoxFunStmt` instance
+- Method `Ast::ASTBuilder#reduce_parameters_plus_more` for dealing with function parameters
+- Method `Ast::ASTBuilder#reduce_parameters_plus_end`
+- Method `Ast::ASTVisitor#visit_fun_stmt` for visiting an `Ast::LoxFunStmt` node
+- Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
+- Method `BackEnd::Engine#after_fun_stmt`
+- Method `Backend::NativeFunction#call` 
+- Method `Backend::NativeFunction#to_str` 
+- Method `Backend::Function` implementation of a function object.
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr`
+
+### Fixed
+- Fixed inconsistencies in documentation comments.
+
+## [0.0.28] - 2021-02-15
+- The interpreter implements function calls (to a native function).
+
+### Added
+- Class `Ast::LoxCallExpr` a node that represents a function call expression
+- Method `Ast::ASTBuilder#reduce_call_expr`
+- Method `Ast::ASTBuilder#reduce_refinement_plus_end`
+- Method `Ast::ASTBuilder#reduce_call_arglist` creates a `LoxCallExpr` node
+- Method `Ast::ASTBuilder#reduce_arguments_plus_more` builds the function argument array
+- Method `Ast::ASTVisitor#visit_call_expr` for visiting an `Ast::LoxCallExpr` node
+- Method `BackEnd::Engine#after_call_expr`implements the evaluation of a function call.
+- Method `BackEnd::Engine#after_for_stmt` implements most of the `for` control flow
+
 ## [0.0.27] - 2021-01-24
 - The interpreter implements `while` loops.
 

data/README.md

@@ -14,9 +14,12 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Current status
 The project is still in inception and the interpreter is being implemented...  
-Currently it can execute a subset of __Lox__ language.
+Currently it can execute all allowed __Lox__ expressions and statements except:
+- Closures,  
+- Classes and objects.
+
+These will be implemented soon.
 
-But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
 ## What's the fuss about Lox?
 ... Nothing...  
@@ -32,11 +35,11 @@ Although __Lox__ is fairly simple, it is far from a toy language:
 - Functions and closures
 - Object-orientation (classes, methods, inheritance).
 
-In other words, __Lox__ contains interesting features expected from most general-purpose 
+In other words, __Lox__ contains interesting features found in most general-purpose 
 languages.
 
 ### What's missing in Lox?
-__Lox__ was constrained by design and therefore was not aimed to be a language used in real-world applications.
+__Lox__ was constrained by design and was therefore not aimed to be a language used in real-world applications.
 Here are some missing parts to make it a _practical_ language:
 - Collections (arrays, maps, ...)
 - Modules (importing stuff from other packages/files)
@@ -66,6 +69,23 @@ lox = Loxxy::Interpreter.new
 lox.evaluate(lox_program) # Output: Hello, world!
 ```
 
+## A function definition example
+```ruby
+require 'loxxy'
+
+lox_program = <<LOX_END
+  fun add4(n) {
+    n + 4;
+  }
+
+  print add4(6); // Output: 10
+LOX_END
+
+lox = Loxxy::Interpreter.new
+lox.evaluate(lox_program) # Output 10
+```
+
+
 ## Retrieving the result from a Lox program
 The __Loxxy__ interpreter returns the value of the last evaluated expression. 
 
@@ -147,6 +167,7 @@ Here are the language features currently supported by the interpreter:
 - [Print Statement](#print-statement)
 - [While Statement](#while-statement)  
 - [Block Statement](#block-statement)
+- [Function declaration](#func-statement)
 
 ### Comments
 
@@ -159,7 +180,8 @@ Loxxy supports single line C-style comments.
 ### Keywords
 Loxxy implements the following __Lox__ reserved keywords:
 ```lang-none
-and, false, nil, or, print, true
+and, else, false, for, fun, if,
+nil, or, print, true, var, while
 ```
 
 ### Datatypes
@@ -173,19 +195,21 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
-- [Expressions](#expressions)  
+- [Expressions](#expressions)
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
-  -[Variable expressions and assignments](#variable-expressions)
-  
+  -[Variable expressions and assignments](#variable-expressions)  
+  -[Function call](#function-call)
+
 -[Variable declarations](#var-statement)  
 -[If Statement](#if-statement)  
 -[Print Statement](#print-statement)  
--[While Statement](#while-statement)
--[Block Statement](#block-statement)
+-[While Statement](#while-statement)  
+-[Block Statement](#block-statement)  
+-[Function Declaration](#function-declaration)
 
 #### Expressions
 
@@ -280,6 +304,15 @@ var iAmNil; // __Lox__ initializes variables to nil by default;
 print iAmNil; // output: nil
 ```
 
+#### Function call
+``` javascript
+// Calling a function without argument
+print clock();
+
+// Assumption: there exists a function `add` that takes two arguments
+print add(2, 3);
+```
+
 #### For statement
 
 Similar to the `for` statement in `C` language
@@ -358,6 +391,19 @@ var a = "outer";
 print a; // output: outer
 ```
 
+#### Function Declaration
+The keyword `fun` is used to begin a function declaration.
+In __Lox__ a function has a name and a body (which may be empty).
+
+``` javascript
+fun add4(n) // `add4` will be the name of the function
+{
+  n + 4;
+}
+
+print add4(6); // output: 10
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/bin/loxxy

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'loxxy'
+
+if ARGV[0]
+lox = Loxxy::Interpreter.new
+File.open(ARGV[0], 'r') do |f|
+lox.evaluate(f.read)
+end
+end

data/lib/loxxy.rb

@@ -6,8 +6,6 @@ require_relative 'loxxy/front_end/raw_parser'
 
 # Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
-  class Error < StandardError; end
-
   # Shorthand method. Returns the sole object that represents
   # a Lox false literal.
   # @return [Loxxy::Datatype::False]

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'lox_fun_stmt'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -163,6 +163,11 @@ module Loxxy
         [theChildren[0]]
       end
 
+      # rule('funDecl' => 'FUN function')
+      def reduce_fun_decl(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       # rule('exprStmt' => 'expression SEMICOLON')
       def reduce_exprStmt(_production, range, tokens, theChildren)
       return_first_child(range, tokens, theChildren) # Discard the semicolon
@@ -227,105 +232,46 @@ module Loxxy
         Ast::LoxBlockStmt.new(tokens[1].position, decls)
       end
 
+      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      def reduce_block_empty(_production, _range, tokens, _children)
+        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+      end
+
       # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         var_name = theChildren[1].token.lexeme.dup
         Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
       end
 
-      # rule('logic_or' => 'logic_and disjunct_plus')
-      def reduce_logic_or_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
-      def reduce_logic_or_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'OR logic_and')
-      def reduce_logic_or_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('logic_and' => 'equality conjunct_plus')
-      def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'conjunct_plus AND equality')
-      def reduce_logic_and_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'AND equality')
-      def reduce_logic_and_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('equality' => 'comparison equalityTest_plus')
-      def reduce_equality_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_star' => 'equalityTest comparison')
-      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('comparison' => 'term comparisonTest_plus')
-      def reduce_comparison_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
 
-      # rule('comparisonTest_plus' => 'comparisonTest term')
-      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
+      # 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('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # rule('call' => 'primary refinement_plus').as 'call_expr'
+      def reduce_call_expr(_production, _range, _tokens, theChildren)
+        theChildren[1].callee = theChildren[0]
+        theChildren[1]
       end
 
-      # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
+      # rule('refinement_plus' => 'refinement').
+      def reduce_refinement_plus_end(_production, _range, _tokens, theChildren)
+        theChildren[0]
       end
 
-      # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
+      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      def reduce_call_arglist(_production, _range, tokens, theChildren)
+        args = theChildren[1] || []
+        if args.size > 255
+          raise StandardError, "Can't have more than 255 arguments."
+        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)
+        LoxCallExpr.new(tokens[0].position, args)
       end
 
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
@@ -347,6 +293,33 @@ module Loxxy
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
+
+      # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
+      def reduce_function(_production, _range, _tokens, theChildren)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
+      end
+
+      # rule('parameters' => 'parameters COMMA IDENTIFIER')
+      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2].token.lexeme
+      end
+
+      # rule('parameters' => 'IDENTIFIER')
+      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0].token.lexeme]
+      end
+
+      # rule('arguments' => 'arguments COMMA expression')
+      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2]
+      end
+
+      # rule('arguments' => 'expression')
+      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
+        theChildren
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -12,7 +12,7 @@ module Loxxy
       # attr_reader(:runtime)
 
       # Build a visitor for the given top.
-      # @param aRoot [AST::LoxNode] the parse tree to visit.
+      # @param aTop [AST::LoxNode] the parse tree to visit.
       def initialize(aTop)
         raise StandardError if aTop.nil?
 
@@ -52,7 +52,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aSeqDecls [AST::LOXSeqDecl] the variable declaration node to visit
       def visit_seq_decl(aSeqDecls)
         broadcast(:before_seq_decl, aSeqDecls)
         traverse_subnodes(aSeqDecls)
@@ -60,7 +60,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aVarStmt [AST::LOXVarStmt] the variable declaration node to visit
       def visit_var_stmt(aVarStmt)
         broadcast(:before_var_stmt, aVarStmt)
         traverse_subnodes(aVarStmt)
@@ -103,12 +103,12 @@ module Loxxy
       # @param aBlockStmt [AST::LOXBlockStmt] the print statement node to visit
       def visit_block_stmt(aBlockStmt)
         broadcast(:before_block_stmt, aBlockStmt)
-        traverse_subnodes(aBlockStmt)
+        traverse_subnodes(aBlockStmt) unless aBlockStmt.empty?
         broadcast(:after_block_stmt, aBlockStmt)
       end
 
       # Visit event. The visitor is visiting an assignment node
-      # @param aLiteralExpr [AST::LoxAssignExpr] the variable assignment node to visit.
+      # @param anAssignExpr [AST::LoxAssignExpr] the variable assignment node to visit.
       def visit_assign_expr(anAssignExpr)
         broadcast(:before_assign_expr, anAssignExpr)
         traverse_subnodes(anAssignExpr)
@@ -118,7 +118,7 @@ module Loxxy
       # 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
+      # @param aLogicalExpr [AST::LOXLogicalExpr] the logical expression node to visit
       def visit_logical_expr(aLogicalExpr)
         broadcast(:before_logical_expr, aLogicalExpr)
 
@@ -145,6 +145,14 @@ module Loxxy
         broadcast(:after_unary_expr, anUnaryExpr)
       end
 
+      # Visit event. The visitor is about to visit a call expression.
+      # @param aCallExpr [AST::LoxCallExpr] call expression to visit
+      def visit_call_expr(aCallExpr)
+        broadcast(:before_call_expr, aCallExpr)
+        traverse_subnodes(aCallExpr)
+        broadcast(:after_call_expr, aCallExpr, self)
+      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)
@@ -162,25 +170,35 @@ module Loxxy
       end
 
       # Visit event. The visitor is visiting a variable usage node
-      # @param aLiteralExpr [AST::LoxVariableExpr] the variable reference node to visit.
+      # @param aVariableExpr [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 terminal datatype value.
-      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def visit_builtin(aValue)
         broadcast(:before_visit_builtin, aValue)
         broadcast(:after_visit_builtin, aValue)
       end
 
+      # Visit event. The visitor is about to visit a function statement node.
+      # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
+      def visit_fun_stmt(aFunStmt)
+        broadcast(:before_fun_stmt, aFunStmt)
+        traverse_subnodes(aFunStmt)
+        broadcast(:after_fun_stmt, aFunStmt, self)
+      end
+
       # Visit event. The visitor is about to visit the given non terminal node.
       # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
-      def visit_nonterminal(_non_terminal_node)
+      def visit_nonterminal(aNonTerminalNode)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
-        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
+        symb = aNonTerminalNode.symbol.name
+        msg = "Loxxy cannot execute this code yet for non-terminal symbol '#{symb}'."
+        raise NotImplementedError, msg
       end
 
       private