loxxy 0.1.15 → 0.2.02

data/bin/loxxy

@@ -3,9 +3,57 @@
 
 require 'loxxy'
 
-if ARGV[0]
-lox = Loxxy::Interpreter.new
-File.open(ARGV[0], 'r') do |f|
-lox.evaluate(f.read)
-end
-end
+class LoxxyRunner
+  DefaultLoxExtension = 'lox'
+  attr_reader(:cli_options)
+
+  def initialize(prog_name, args)
+    my_version = Loxxy::VERSION
+    cli = Loxxy::CLIParser.new(prog_name, my_version)
+    @cli_options = cli.parse!(args)
+  end
+
+  def run!(file_names)
+    return if file_names.nil? || file_names.empty?
+
+    lox = Loxxy::Interpreter.new
+    begin
+      file_names.each do |lox_file|
+        fname = validate_filename(lox_file)
+        next unless file_exist?(fname)
+
+        File.open(fname, 'r') { |f| lox.evaluate(f.read) }
+      end
+    rescue Loxxy::ScanError => e
+      $stderr.puts e.message
+    end
+  end
+
+  private
+
+  def validate_filename(raw_fname)
+    # When necessary add extension to file name
+    fname = raw_fname.dup
+    basename = File.basename(fname)
+    has_extension = basename =~ /(?<=[^.])\.[^.]+$/
+    fname << '.' << DefaultLoxExtension unless has_extension
+
+    fname
+  end
+
+  def file_exist?(fname)
+    exists = File.exist?(fname)
+    $stderr.puts "No such file '#{fname}'" unless exists
+
+    exists
+  end
+end # class
+
+########################################
+# ENTRY POINT
+########################################
+program = LoxxyRunner.new(File.basename(__FILE__), ARGV)
+
+# All options from CLI gobbled from ARGV, remains only file name
+program.run!(ARGV)
+# End of file

data/lib/loxxy.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'loxxy/version'
+require_relative 'loxxy/cli_parser'
 require_relative 'loxxy/interpreter'
 require_relative 'loxxy/front_end/raw_parser'
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'lox_fun_stmt'
+require_relative 'lox_super_expr'
 require_relative 'lox_this_expr'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -165,7 +165,14 @@ module Loxxy
 
       # rule('classDecl' => 'CLASS classNaming class_body')
       def reduce_class_decl(_production, _range, _tokens, theChildren)
-        Ast::LoxClassStmt.new(tokens[1].position, theChildren[1], theChildren[2])
+        if theChildren[1].kind_of?(Array)
+          name = theChildren[1].first
+          parent = theChildren[1].last
+        else
+          name = theChildren[1]
+          parent = nil
+        end
+        Ast::LoxClassStmt.new(tokens[1].position, name, parent, theChildren[2])
       end
 
       # rule('classNaming' => 'IDENTIFIER')
@@ -173,6 +180,13 @@ module Loxxy
         theChildren[0].token.lexeme
       end
 
+      # rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
+      def reduce_class_subclassing(_production, _range, _tokens, theChildren)
+        super_token = theChildren[2].token
+        super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+        [theChildren[0].token.lexeme, super_var]
+      end
+
       # rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE')
       def reduce_class_body(_production, _range, _tokens, theChildren)
         theChildren[1].nil? ? [] : theChildren[1]
@@ -368,6 +382,11 @@ module Loxxy
         LoxThisExpr.new(tokens[0].position)
       end
 
+      # rule('primary' => 'SUPER DOT IDENTIFIER')
+      def reduce_super_expr(_production, _range, _tokens, theChildren)
+        LoxSuperExpr.new(theChildren[0].token.position, theChildren[2].token.lexeme)
+      end
+
       # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
       def reduce_function(_production, _range, _tokens, theChildren)
         first_child = theChildren.first

data/lib/loxxy/ast/ast_visitor.rb

@@ -212,6 +212,13 @@ module Loxxy
         broadcast(:after_this_expr, aThisExpr, self)
       end
 
+      # Visit event. The visitor is about to visit the super keyword.
+      # @param aSuperExpr [Ast::LoxSuperExpr] super expression
+      def visit_super_expr(aSuperExpr)
+        broadcast(:before_super_expr, aSuperExpr)
+        broadcast(:after_super_expr, aSuperExpr, self)
+      end
+
       # Visit event. The visitor is about to visit the given terminal datatype value.
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def visit_builtin(aValue)

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -8,15 +8,19 @@ module Loxxy
       # @return [String] the class name
       attr_reader :name
 
+      # @return [Ast::LoxVariableExpr] variable referencing the superclass (if any)
+      attr_reader :superclass
+
       # @return [Array<Ast::LoxFunStmt>] the methods
       attr_reader :body
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
       # @param theBody [Array<Loxxy::Ast::LoxNode>]
-      def initialize(aPosition, aName, theMethods)
+      def initialize(aPosition, aName, aSuperclassName, theMethods)
         super(aPosition, [])
         @name = aName.dup
+        @superclass = aSuperclassName
         @body = theMethods
       end
 

data/lib/loxxy/ast/lox_super_expr.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxSuperExpr < LoxNode
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_accessor :object
+
+      # @return [String] Name of a method name
+      attr_reader :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aMethodName [String] Name of a method
+      def initialize(aPosition, aMethodName)
+        super(aPosition)
+        @property = aMethodName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_super_expr(self)
+      end
+
+      # Quack like a LoxVariableExpr
+      # @return [String] the `super` keyword
+      def name
+        'super'
+      end
+      alias callee= object=
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -70,30 +70,46 @@ module Loxxy
       end
 
       def after_class_stmt(aClassStmt, aVisitor)
+        if aClassStmt.superclass
+          aClassStmt.superclass.accept(aVisitor)
+          parent = stack.pop
+          unless parent.kind_of?(LoxClass)
+            raise StandardError, 'Superclass must be a class.'
+          end
+        else
+          parent = nil
+        end
+
+        if parent # Create an environment specific for 'super'
+          super_env = Environment.new(symbol_table.current_env)
+          symbol_table.enter_environment(super_env)
+        end
+
         # Convert LoxFunStmt into LoxFunction
         meths = aClassStmt.body.map do |func_node|
           func_node.is_method = true
           func_node.accept(aVisitor)
-          stack.pop
+          mth = stack.pop
+          mth.is_initializer = true if mth.name == 'init'
+          mth
         end
 
-        klass = LoxClass.new(aClassStmt.name, meths, self)
+        klass = LoxClass.new(aClassStmt.name, parent, meths, self)
+        if parent
+          super_var = Variable.new('super', klass)
+          symbol_table.insert(super_var)
+          symbol_table.leave_environment
+        end
         new_var = Variable.new(aClassStmt.name, klass)
         symbol_table.insert(new_var)
       end
 
-      def before_var_stmt(aVarStmt)
+      def after_var_stmt(aVarStmt)
         new_var = Variable.new(aVarStmt.name, Datatype::Nil.instance)
         symbol_table.insert(new_var)
-      end
-
-      def after_var_stmt(aVarStmt)
-        var_name = aVarStmt.name
-        variable = symbol_table.lookup(var_name)
-        raise StandardError, "Unknown variable #{var_name}" unless variable
 
         value = stack.pop
-        variable.assign(value)
+        new_var.assign(value)
       end
 
       def before_for_stmt(aForStmt)
@@ -240,15 +256,13 @@ module Loxxy
         case callee
         when NativeFunction
           stack.push callee.call # Pass arguments
-        when LoxFunction
+        when LoxFunction, LoxClass
           arg_count = aCallExpr.arguments.size
           if arg_count != callee.arity
             msg = "Expected #{callee.arity} arguments but got #{arg_count}."
             raise Loxxy::RuntimeError, msg
           end
           callee.call(self, aVisitor)
-        when LoxClass
-          callee.call(self, aVisitor)
         else
           raise Loxxy::RuntimeError, 'Can only call functions and classes.'
         end
@@ -286,6 +300,20 @@ module Loxxy
         var.value.accept(aVisitor) # Evaluate this value then push on stack
       end
 
+      def after_super_expr(aSuperExpr, aVisitor)
+        offset = resolver.locals[aSuperExpr]
+        env = symbol_table.current_env
+        (offset - 1).times { env = env.enclosing }
+        instance = env.defns['this'].value.accept(aVisitor)[0]
+        superklass = variable_lookup(aSuperExpr).value.superclass
+        method = superklass.find_method(aSuperExpr.property)
+        unless method
+          raise StandardError, "Undefined property '#{aSuperExpr.property}'."
+        end
+
+        stack.push method.bind(instance)
+      end
+
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)

data/lib/loxxy/back_end/lox_class.rb

@@ -7,17 +7,23 @@ module Loxxy
   module BackEnd
     # Runtime representation of a Lox class.
     class LoxClass
+      # rubocop: disable Style/AccessorGrouping
+
       # @return [String] The name of the class
       attr_reader :name
+      attr_reader :superclass
 
       # @return [Hash{String => LoxFunction}] the list of methods
       attr_reader :meths
       attr_reader :stack
 
+      # rubocop: enable Style/AccessorGrouping
+
       # Create a class with given name
       # @param aName [String] The name of the class
-      def initialize(aName, theMethods, anEngine)
+      def initialize(aName, aSuperclass, theMethods, anEngine)
         @name = aName.dup
+        @superclass = aSuperclass
         @meths = {}
         theMethods.each do |func|
           meths[func.name] = func
@@ -30,17 +36,29 @@ module Loxxy
       end
 
       def arity
-        0
+        initializer = find_method('init')
+        initializer ? initializer.arity : 0
       end
 
-      def call(engine, _visitor)
+      def call(engine, visitor)
         instance = LoxInstance.new(self, engine)
+        initializer = find_method('init')
+        if initializer
+          constructor = initializer.bind(instance)
+          constructor.call(engine, visitor)
+        end
+
         engine.stack.push(instance)
       end
 
       # @param aName [String] the method name to search for
       def find_method(aName)
-        meths[aName]
+        found = meths[aName]
+        unless found || superclass.nil?
+          found = superclass.find_method(aName)
+        end
+
+        found
       end
 
       # Logical negation.

data/lib/loxxy/back_end/lox_function.rb

@@ -15,6 +15,7 @@ module Loxxy
       attr_reader :body
       attr_reader :stack
       attr_reader :closure
+      attr_accessor :is_initializer
 
       # Create a function with given name
       # @param aName [String] The name of the function
@@ -24,6 +25,7 @@ module Loxxy
         @body = aBody.kind_of?(Ast::LoxNoopExpr) ? aBody : aBody.subnodes[0]
         @stack = anEngine.stack
         @closure = anEngine.symbol_table.current_env
+        @is_initializer = false
         anEngine.symbol_table.current_env.embedding = true
       end
 
@@ -48,6 +50,10 @@ module Loxxy
           (body.nil? || body.kind_of?(Ast::LoxNoopExpr)) ? Datatype::Nil.instance : body.accept(aVisitor)
           throw(:return)
         end
+        if is_initializer
+          enclosing_env = engine.symbol_table.current_env.enclosing
+          engine.stack.push(enclosing_env.defns['this'].value)
+        end
 
         engine.symbol_table.leave_environment
       end

data/lib/loxxy/back_end/lox_instance.rb

@@ -47,10 +47,6 @@ module Loxxy
       # Set the value of property with given name
       # aName [String] name of object property
       def set(aName, aValue)
-        unless fields.include? aName
-          raise StandardError, "Undefined property '#{aName}'."
-        end
-
         fields[aName] = aValue
       end
     end # class

data/lib/loxxy/back_end/resolver.rb

@@ -67,12 +67,24 @@ module Loxxy
         previous_class = current_class
         @current_class = :class
         define(aClassStmt.name)
+        if aClassStmt.superclass
+          if aClassStmt.name == aClassStmt.superclass.name
+            raise StandardError, "'A class can't inherit from itself."
+          end
+
+          @current_class = :subclass
+          aClassStmt.superclass.accept(aVisitor)
+          begin_scope
+          define('super')
+        end
         begin_scope
         define('this')
         aClassStmt.body.each do |fun_stmt|
-          resolve_function(fun_stmt, :method, aVisitor)
+          mth_type = fun_stmt.name == 'init' ? :initializer : :method
+          resolve_function(fun_stmt, mth_type, aVisitor)
         end
         end_scope
+        end_scope if aClassStmt.superclass
         @current_class = previous_class
       end
 
@@ -92,7 +104,7 @@ module Loxxy
         anIfStmt.else_stmt&.accept(aVisitor)
       end
 
-      def before_return_stmt(_returnStmt)
+      def before_return_stmt(returnStmt)
         if scopes.size < 2
           msg = "Error at 'return': Can't return from top-level code."
           raise StandardError, msg
@@ -102,6 +114,11 @@ module Loxxy
           msg = "Error at 'return': Can't return from outside a function."
           raise StandardError, msg
         end
+
+        if current_function == :initializer
+          msg = "Error at 'return': Can't return a value from an initializer."
+          raise StandardError, msg unless returnStmt.subnodes[0].kind_of?(Datatype::Nil)
+        end
       end
 
       def after_while_stmt(aWhileStmt, aVisitor)
@@ -163,6 +180,25 @@ module Loxxy
         resolve_local(aThisExpr, aVisitor)
       end
 
+      # rubocop: disable Style/CaseLikeIf
+      # rubocop: disable Style/StringConcatenation
+      def after_super_expr(aSuperExpr, aVisitor)
+        msg_prefix = "Error at 'super': Can't use 'super' "
+        if current_class == :none
+          err_msg = msg_prefix + 'outside of a class.'
+          raise StandardError, err_msg
+
+        elsif current_class == :class
+          err_msg = msg_prefix + 'in a class without superclass.'
+          raise StandardError, err_msg
+
+        end
+        # 'super' behaves closely to a local variable
+        resolve_local(aSuperExpr, aVisitor)
+      end
+      # rubocop: enable Style/StringConcatenation
+      # rubocop: enable Style/CaseLikeIf
+
       # function declaration creates a new scope for its body & binds its parameters for that scope
       def before_fun_stmt(aFunStmt, aVisitor)
         declare(aFunStmt.name)