loxby 0.0.2 → 0.0.3

data/lib/loxby/interpreter.rb

@@ -2,14 +2,24 @@
 
 require_relative 'helpers/environment'
 require_relative 'helpers/errors'
+require_relative 'helpers/callable'
+require_relative 'helpers/native_functions'
+require_relative 'helpers/functions'
 require_relative 'visitors/base'
 
 # Interpreter class. Walks the AST using
 # the Visitor pattern.
 class Interpreter < Visitor
+  attr_reader :globals
+
   def initialize(process) # rubocop:disable Lint/MissingSuper
     @process = process
-    @environment = Lox::Environment.new
+    # `@globals` always refers to the same environment regardless of scope.
+    @globals = Lox::Environment.new
+    # `@environment` changes based on scope.
+    @environment = @globals
+
+    define_native_functions
   end
 
   def interpret(statements)
@@ -18,6 +28,7 @@ class Interpreter < Visitor
     result
   rescue Lox::RunError => e
     @process.runtime_error e
+    nil
   end
 
   def lox_eval(expr)
@@ -25,7 +36,7 @@ class Interpreter < Visitor
   end
 
   # Lox's definition of truthiness follows
-  # Ruby's by definition. This does nothing.
+  # Ruby's (for now), so this is a no-op (for now)
   def truthy?(obj)
     obj
   end
@@ -49,16 +60,43 @@ class Interpreter < Visitor
     lox_eval statement.expression
   end
 
+  def visit_function_statement(statement)
+    function = Lox::Function.new(statement, @environment)
+    @environment[statement.name] = function if statement.name
+    function
+  end
+
+  def visit_if_statement(statement)
+    if truthy? lox_eval(statement.condition)
+      lox_eval statement.then_branch
+    elsif !statement.else_branch.nil?
+      lox_eval statement.else_branch
+    end
+  end
+
   def visit_print_statement(statement)
     value = lox_eval statement.expression
     puts lox_obj_to_str(value)
   end
 
+  def visit_return_statement(statement)
+    value = statement.value.nil? ? nil : lox_eval(statement.value)
+    throw :return, value # This is not an error, just sending a message up the callstack
+  end
+
   def visit_var_statement(statement)
     value = statement.initializer ? lox_eval(statement.initializer) : nil
     @environment[statement.name] = value
   end
 
+  def visit_while_statement(statement)
+    catch :break do # Jump beacon for break statements
+      value = nil
+      (value = lox_eval statement.body) while truthy?(lox_eval(statement.condition))
+      value
+    end
+  end
+
   def visit_variable_expression(expr)
     @environment[expr.name]
   end
@@ -70,13 +108,22 @@ class Interpreter < Visitor
   end
 
   def visit_block_statement(statement)
+    # Pull out a copy of the environment
+    # so that blocks are closures
     execute_block(statement.statements, Lox::Environment.new(@environment))
   end
 
+  def visit_break_statement(_)
+    throw :break
+  end
+
   def execute_block(statements, environment)
     previous = @environment
     @environment = environment
     statements.each { lox_eval _1 }
+    nil
+  rescue Lox::RunError
+    nil
   ensure
     @environment = previous
   end
@@ -87,8 +134,19 @@ class Interpreter < Visitor
     expr.value
   end
 
+  def visit_logical_expression(expr)
+    left = lox_eval expr.left
+
+    case expr.operator.type
+    when :or
+      left if truthy? left
+    else # Just and, for now
+      truthy?(left) ? lox_eval(expr.right) : left
+    end
+  end
+
   def visit_grouping_expression(expr)
-    lox_eval expr
+    lox_eval expr.expression
   end
 
   def visit_unary_expression(expr)
@@ -150,4 +208,19 @@ class Interpreter < Visitor
 
     left ? lox_eval(expr.center) : lox_eval(expr.right)
   end
+
+  def visit_call_expression(expr) # rubocop:disable Metrics/AbcSize
+    callee = lox_eval expr.callee
+    arguments = expr.arguments.map { lox_eval _1 }
+
+    unless callee.class.include? Lox::Callable
+      raise Lox::RunError.new(expr.paren, 'Can only call functions and classes.')
+    end
+
+    unless arguments.size == callee.arity
+      raise Lox::RunError.new(expr.paren, "Expected #{callee.arity} arguments but got #{arguments.size}.")
+    end
+
+    callee.call(self, arguments)
+  end
 end

data/lib/loxby/parser.rb

@@ -4,11 +4,11 @@ require_relative 'helpers/ast'
 require_relative 'helpers/errors'
 
 class Lox
-  # Lox::Parser converts a list of tokens
-  # from Lox::Scanner to a syntax tree.
+  # `Lox::Parser` converts a list of tokens
+  # from `Lox::Scanner` to a syntax tree.
   # This tree can be interacted with using
-  # the Visitor pattern. (See the Visitor
-  # class in visitors/base.rb.)
+  # the Visitor pattern. (See `Visitor`
+  # in lib/visitors/base.rb.)
   class Parser
     def initialize(tokens, interpreter)
       @tokens = tokens
@@ -24,7 +24,9 @@ class Lox
     end
 
     def declaration
-      if matches?(:var)
+      if matches? :fun
+        function 'function'
+      elsif matches? :var
         var_declaration
       else
         statement
@@ -34,6 +36,33 @@ class Lox
       nil
     end
 
+    def function(kind) # rubocop:disable Metrics/MethodLength
+      name = nil
+      if check :identifier
+        # Named function
+        name = consume :identifier, "Expect #{kind} name."
+      end
+      consume :left_paren, "Expect '(' after #{kind} name."
+      parameters = []
+      loop do
+        break if check :right_paren
+
+        # This is mostly arbitrary but it keeps execution time down
+        error(peek, "Can't have more than 255 parameters.") if parameters.size > 255
+
+        parameters << consume(:identifier, 'Expect parameter name.')
+        break unless matches? :comma
+      end
+      consume :right_paren, "Expect ')' after parameters."
+
+      # Have to consume the first part of the block since
+      # it assumes it's already been matched
+      consume :left_brace, 'Expect block after parameter list.'
+      body = block
+
+      Lox::AST::Statement::Function.new(name:, params: parameters, body:)
+    end
+
     def var_declaration
       name = consume :identifier, 'Expect variable name.'
       initializer = matches?(:equal) ? expression : nil
@@ -41,9 +70,19 @@ class Lox
       Lox::AST::Statement::Var.new(name:, initializer:)
     end
 
-    def statement
-      if matches? :print
+    def statement # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      if matches? :for
+        for_statement
+      elsif matches? :if
+        if_statement
+      elsif matches? :print
         print_statement
+      elsif matches? :return
+        return_statement
+      elsif matches? :while
+        while_statement
+      elsif matches? :fun
+        function 'function'
       elsif matches? :left_brace
         Lox::AST::Statement::Block.new(statements: block)
       else
@@ -51,9 +90,17 @@ class Lox
       end
     end
 
+    def break_or_declaration
+      if matches? :break
+        break_statement
+      else
+        declaration
+      end
+    end
+
     def block
       statements = []
-      statements << declaration until check(:right_brace) || end_of_input?
+      statements << break_or_declaration until check(:right_brace) || end_of_input?
       consume :right_brace, "Expect '}' after block."
       statements
     end
@@ -64,6 +111,92 @@ class Lox
       Lox::AST::Statement::Print.new(expression: value)
     end
 
+    def return_statement
+      keyword = previous
+      value = nil
+      value = expression unless check :semicolon
+
+      consume :semicolon, "Expect ';' after return value."
+      Lox::AST::Statement::Return.new(keyword:, value:)
+    end
+
+    def if_statement
+      consume :left_paren, "Expect '(' after 'if'."
+      condition = expression_list
+      consume :right_paren, "Expect ')' after if condition."
+
+      # We don't go up to var declaration because variables
+      # declared inside an if statement should be inside a
+      # *block* inside the if statement.
+      then_branch = statement
+      else_branch = matches?(:else) ? statement : nil
+
+      Lox::AST::Statement::If.new(condition:, then_branch:, else_branch:)
+    end
+
+    def while_statement
+      consume :left_paren, "Expect '(' after 'while'."
+      condition = expression_list
+      consume :right_paren, "Expect ')' after condition."
+      body = statement
+
+      Lox::AST::Statement::While.new(condition:, body:)
+    end
+
+    # `for` loops in loxby are syntactic sugar
+    # for `while` loops. Yay!
+
+    def for_statement # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      consume :left_paren, "Expect '(' after 'for'."
+
+      initializer =
+        if matches? :semicolon
+          nil
+        elsif matches? :var
+          var_declaration
+        else
+          expression_statement
+        end
+
+      condition = nil
+      condition = expression unless check :semicolon
+      consume :semicolon, "Expect ';' after loop condition."
+
+      increment = nil
+      increment = expression unless check :right_paren
+      consume :right_paren, "Expect ')' after for clauses."
+
+      body = statement
+
+      unless increment.nil?
+        body = Lox::AST::Statement::Block.new(
+          statements: [
+            body,
+            Lox::AST::Statement::Expression.new(expression: increment)
+          ]
+        )
+      end
+
+      condition = Lox::AST::Expression::Literal.new(value: true) if condition.nil?
+      body = Lox::AST::Statement::While.new(condition:, body:)
+
+      unless initializer.nil?
+        body = Lox::AST::Statement::Block.new(
+          statements: [
+            initializer,
+            body
+          ]
+        )
+      end
+
+      body
+    end
+
+    def break_statement
+      consume :semicolon, "Expect ';' after break."
+      Lox::AST::Statement::Break.new
+    end
+
     def expression_statement
       expr = expression_list
       consume :semicolon, "Expect ';' after expression."
@@ -89,7 +222,7 @@ class Lox
       if matches? :question
         left_operator = previous
         center = check(:colon) ? Lox::AST::Expression::Literal.new(value: nil) : expression_list
-        consume :colon, "Expect ':' after expression (ternary operator)."
+        consume :colon, "Expect ':' after expression: incomplete ternary operator."
         right_operator = previous
         right = conditional # Recurse, right-associative
         expr = Lox::AST::Expression::Ternary.new(left: expr, left_operator:, center:, right_operator:, right:)
@@ -103,7 +236,7 @@ class Lox
     end
 
     def assignment # rubocop:disable Metrics/MethodLength
-      expr = equality
+      expr = logical_or
 
       if matches? :equal
         equals = previous
@@ -120,6 +253,30 @@ class Lox
       expr
     end
 
+    def logical_or
+      expr = logical_and
+
+      while matches? :or
+        operator = previous
+        right = logical_and
+        expr = Lox::AST::Expression::Logical.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
+    def logical_and
+      expr = equality
+
+      while matches? :and
+        operator = previous
+        right = logical_and
+        expr = Lox::AST::Expression::Logical.new(left: expr, operator:, right:)
+      end
+
+      expr
+    end
+
     def equality
       expr = comparison
       while matches?(:bang_equal, :equal_equal)
@@ -176,8 +333,31 @@ class Lox
 
         Lox::AST::Expression::Unary.new(operator:, right:)
       else
-        primary
+        function_call
+      end
+    end
+
+    def function_call
+      expr = primary
+      loop do
+        break unless matches? :left_paren
+
+        expr = finish_call expr
+      end
+      expr
+    end
+
+    def finish_call(callee)
+      arguments = []
+      unless check :right_paren
+        loop do
+          error(peek, "Can't have more than 255 arguments.") if arguments.size > 255
+          arguments << expression
+          break unless matches? :comma
+        end
       end
+      paren = consume :right_paren, "Expect ')' after arguments."
+      Lox::AST::Expression::Call.new(callee:, paren:, arguments:)
     end
 
     def primary # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
@@ -187,8 +367,12 @@ class Lox
         Lox::AST::Expression::Literal.new(value: true)
       elsif matches? :nil
         Lox::AST::Expression::Literal.new(value: nil)
+      elsif matches? :fun
+        function 'inline function'
       elsif matches? :number, :string
         Lox::AST::Expression::Literal.new(value: previous.literal)
+      elsif matches? :break
+        raise error(previous, "Invalid 'break' not in loop.")
       elsif matches? :identifier
         Lox::AST::Expression::Variable.new(name: previous)
       elsif matches? :left_paren
@@ -202,6 +386,7 @@ class Lox
         raise err
       elsif matches? :question
         err = error(previous, 'Expect expression before ternary operator.')
+        # Parse and throw away
         expression_list
         consume :colon, "Expect ':' after '?' (ternary operator)."
         conditional

data/lib/loxby/runner.rb

@@ -1,15 +1,23 @@
 # frozen_string_literal: true
 
 require_relative '../loxby'
+require_relative 'config'
 
 class Lox
-  # Lox::Runner is the interactive runner
+  # `Lox::Runner` is the interactive runner
   # which kickstarts the interpreter.
   # An instance is created when loxby is
-  # initialized from the command line.
+  # initialized from the command line,
+  # though it can be instantiated from
+  # code as well.
   class Runner
     def initialize(out = $stdout, err = $stderr)
-      trap('SIGINT') { exit } # Exit cleanly on Ctrl-C
+      # Exit cleanly. 130 is for interrupted scripts
+      trap('INT') do
+        puts
+        exit Lox.config.exit_code.interrupt
+      end
+
       @interpreter = Lox.new
       @out = out
       @err = err
@@ -17,8 +25,8 @@ class Lox
 
     def run(args)
       if args.size > 1
-        @out.puts 'Usage: loxby.rb [script]'
-        exit 64
+        @out.puts 'Usage: loxby [script]'
+        exit Lox.config.exit_code.usage
       elsif args.size == 1
         @interpreter.run_file args[0]
       else

data/lib/loxby/scanner.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 require_relative 'helpers/token_type'
+require_relative 'config'
 
 class Lox
+  # `Lox::Scanner` converts a string to
+  # a series of tokens using a giant
+  # `case` statement.
   class Scanner
-    EXPRESSIONS = {
-      whitespace: /\s/,
-      number_literal: /\d/,
-      identifier: /[a-zA-Z_]/
-    }.freeze
-    KEYWORDS = %w[and class else false for fun if nil or print return super this true var while]
-               .map { [_1, _1.to_sym] }
-               .to_h
+    # Custom character classes for certain tokens.
+    EXPRESSIONS = Lox.config.scanner.expressions.to_h
+
+    # Map of keywords to token types.
+    # Right now, all keywords have
+    # their own token type.
+    KEYWORDS = Lox.config.scanner.keywords.map { [_1, _1.to_sym] }.to_h
 
     attr_accessor :line
 
@@ -25,6 +28,8 @@ class Lox
       @line = 1
     end
 
+    # Process text source into
+    # a list of tokens.
     def scan_tokens
       until end_of_source?
         # Beginnning of next lexeme
@@ -33,38 +38,28 @@ class Lox
       end
 
       # Implicitly return @tokens
-      @tokens << Lox::Token.new(:eof, "", nil, @line)
+      @tokens << Lox::Token.new(:eof, '', nil, @line)
     end
 
+    # Consume enough characters for the next token.
+
     def scan_token # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       character = advance_character
 
       case character
+      # '/' is division, '//' is comment, '/* ... */'
+      # is block comment. Needs special care.
+      when '/'
+        if match('/') # comment line
+          advance_character until peek == "\n" || end_of_source?
+        elsif match('*') # block comment
+          scan_block_comment
+        else
+          add_token :slash
+        end
       # Single-character tokens
-      when '('
-        add_token :left_paren
-      when ')'
-        add_token :right_paren
-      when '{'
-        add_token :left_brace
-      when '}'
-        add_token :right_brace
-      when ','
-        add_token :comma
-      when '.'
-        add_token :dot
-      when '-'
-        add_token :minus
-      when '+'
-        add_token :plus
-      when ';'
-        add_token :semicolon
-      when '*'
-        add_token :star
-      when '?'
-        add_token :question
-      when ':'
-        add_token :colon
+      when Regexp.union(Lox::Token::SINGLE_TOKENS.keys)
+        add_token Lox::Token::SINGLE_TOKENS[character]
       # 1-2 character tokens
       when '!'
         add_token match('=') ? :bang_equal : :bang
@@ -74,16 +69,6 @@ class Lox
         add_token match('=') ? :less_equal : :less
       when '>'
         add_token match('=') ? :greater_equal : :greater
-      when '/'
-        # '/' is division, '//' is comment, '/* ... */'
-        # is block comment. Needs special care.
-        if match('/') # comment line
-          advance_character until peek == "\n" || end_of_source?
-        elsif match('*') # block comment
-          scan_block_comment
-        else
-          add_token :slash
-        end
       # Whitespace
       when "\n"
         @line += 1
@@ -105,7 +90,7 @@ class Lox
     def scan_block_comment # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       advance_character until (peek == '*' && peek_next == '/') || (peek == '/' && peek_next == '*') || end_of_source?
 
-      if end_of_source? || peek_next == "\0"
+      if end_of_source? || peek_next == "\0" # If 0 or 1 characters are left
         @interpreter.error(line, 'Unterminated block comment.')
         return
       elsif peek == '/' && peek_next == '*'
@@ -123,7 +108,7 @@ class Lox
 
     def scan_string # rubocop:disable Metrics/MethodLength
       until peek == '"' || end_of_source?
-        @line += 1 if peek == "\n"
+        @line += 1 if peek == "\n" # Multiline strings are valid
         advance_character
       end
 
@@ -159,17 +144,20 @@ class Lox
       add_token(KEYWORDS[text] || :identifier)
     end
 
+    # Move the pointer ahead one character and return it.
     def advance_character
       character = @source[@current]
       @current += 1
       character
     end
 
+    # Emit a token.
     def add_token(type, literal = nil)
       text = @source[@start...@current]
       @tokens << Lox::Token.new(type, text, literal, @line)
     end
 
+    # Move the pointer ahead if character matches expected character; error otherwise.
     def match(expected)
       return false unless @source[@current] == expected || end_of_source?
 

data/lib/loxby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Loxby
-  VERSION = '0.0.2'
+class Lox
+  VERSION = '0.0.3'
 end

data/lib/loxby/visitors/ast_printer.rb

@@ -2,6 +2,8 @@
 
 require_relative 'base'
 
+# This visitor prints a given AST
+# for easier viewing and debugging.
 class ASTPrinter < Visitor
   def print(expression)
     expression.accept self
@@ -34,4 +36,20 @@ class ASTPrinter < Visitor
   def visit_unary_expression(expr)
     parenthesize expr.operator.lexeme, expr.right
   end
+
+  def visit_assign_expression(expr)
+    parenthesize 'assign', expr.name, expr.value
+  end
+
+  def visit_call_expression(expr)
+    parenthesize 'call', expr.callee, expr.arguments
+  end
+
+  def visit_logical_expression(expr)
+    visit_binary_expression(expr)
+  end
+
+  def visit_variable_expression(expr)
+    parenthesize 'var', expr.name
+  end
 end

data/lib/loxby/visitors/base.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Visitable adds #accept, the only
+# Visitable adds `#accept`, the only
 # method required to implement the
 # visitor pattern on a class.
 # To use the visitor pattern,

data/lib/loxby/visitors/rpn_converter.rb

@@ -2,6 +2,8 @@
 
 require_relative 'base'
 
+# This visitor converts single expression
+# ASTs to Reverse Polish Notation.
 class RPNConverter < Visitor
   def print(expr)
     expr.accept self