loxxy 0.0.27 → 0.1.03

data/lib/loxxy/ast/lox_block_stmt.rb

@@ -6,11 +6,15 @@ module Loxxy
   module Ast
     class LoxBlockStmt < LoxCompoundExpr
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param operand [Loxxy::Ast::LoxSeqDecl]
+      # @param decls [Loxxy::Ast::LoxSeqDecl]
       def initialize(aPosition, decls)
         super(aPosition, [decls])
       end
 
+      def empty?
+        subnodes.size == 1 && subnodes[0].nil?
+      end
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param visitor [Ast::ASTVisitor] the visitor
       def accept(visitor)

data/lib/loxxy/ast/lox_call_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxCallExpr < LoxCompoundExpr
+      attr_accessor :callee
+      attr_reader :arguments
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param argList [Array<Loxxy::Ast::LoxNode>]
+      def initialize(aPosition, argList)
+        super(aPosition, [])
+        @arguments = argList
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_call_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_for_stmt.rb

@@ -18,7 +18,6 @@ module Loxxy
       # @param initialization [Loxxy::Ast::LoxNode]
       # @param testExpr [Loxxy::Ast::LoxNode]
       # @param updateExpr [Loxxy::Ast::LoxNode]
-      # @param body [Loxxy::Ast::LoxNode]
       def initialize(aPosition, initialization, testExpr, updateExpr)
         child = initialization ? [initialization] : []
         super(aPosition, child)

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    # rubocop: disable Style/AccessorGrouping
+    class LoxFunStmt < LoxCompoundExpr
+      attr_reader :name
+      attr_reader :params
+      attr_reader :body
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String]
+      # @param arguments [Array<String>]
+      # @param body [Ast::LoxBlockStmt]
+      def initialize(aPosition, aName, paramList, aBody)
+        super(aPosition, [])
+        @name = aName
+        @params = paramList
+        @body = aBody
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_fun_stmt(self)
+      end
+
+      alias operands subnodes
+    end # class
+    # rubocop: enable Style/AccessorGrouping
+  end # module
+end # module

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -12,7 +12,9 @@ module Loxxy
       attr_reader :else_stmt
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param subExpr [Loxxy::Ast::LoxNode]
+      # @param condExpr [Loxxy::Ast::LoxNode]
+      # @param thenStmt [Loxxy::Ast::LoxNode]
+      # @param elseStmt [Loxxy::Ast::LoxNode]
       def initialize(aPosition, condExpr, thenStmt, elseStmt)
         super(aPosition, [condExpr])
         @then_stmt = thenStmt

data/lib/loxxy/back_end/binary_operator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Loxxy
+  module BackEnd
+    Signature = Struct.new(:parameter_types)
+
+    # A Lox binary operator
+    class BinaryOperator
+      # @return [String] text representation of the operator
+      attr_reader :name
+
+      # @return [Array<Class>]
+      attr_reader :signatures
+
+      # @param aName [String] "name" of operator
+      # @param theSignatures [Array<Signature>] allowed signatures
+      def initialize(aName, theSignatures)
+        @name = aName
+        @signatures = theSignatures
+      end
+
+      # rubocop: disable Style/ClassEqualityComparison
+      def validate_operands(operand1, operand2)
+        compliant = signatures.find do |(type1, type2)|
+          next unless operand1.kind_of?(type1)
+
+          if type2 == :idem
+            (operand2.class == operand1.class)
+          else
+            operand2.kind_of?(type2)
+          end
+        end
+        # rubocop: enable Style/ClassEqualityComparison
+
+        unless compliant
+          err = Loxxy::RuntimeError
+          if signatures.size == 1 && signatures[0].last == :idem
+            raise err, "Operands must be #{datatype_name(signatures[0].first)}s."
+          elsif signatures.size == 2 && signatures.all? { |(_, second)| second == :idem }
+            type1 = datatype_name(signatures[0].first)
+            type2 = datatype_name(signatures[1].first)
+            raise err, "Operands must be two #{type1}s or two #{type2}s."
+          end
+        end
+      end
+
+      private
+
+      def datatype_name(aClass)
+        # (?:(?:[^:](?!:|(?<=LX))))+$
+        aClass.name.sub(/^.+(?=::)::(?:LX)?/, '').downcase
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -2,7 +2,10 @@
 
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
+require_relative 'binary_operator'
+require_relative 'function'
 require_relative 'symbol_table'
+require_relative 'unary_operator'
 
 module Loxxy
   module BackEnd
@@ -19,12 +22,24 @@ module Loxxy
       # @return [Array<Datatype::BuiltinDatatyp>] Stack for the values of expr
       attr_reader :stack
 
+     # @return [Hash { Symbol => UnaryOperator}]
+      attr_reader :unary_operators
+
+      # @return [Hash { Symbol => BinaryOperator}]
+      attr_reader :binary_operators
+
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
         @symbol_table = SymbolTable.new
         @stack = []
+        @unary_operators = {}
+        @binary_operators = {}
+
+        init_unary_operators
+        init_binary_operators
+        init_globals
       end
 
       # Given an abstract syntax parse tree visitor, launch the visit
@@ -80,7 +95,7 @@ module Loxxy
 
       def after_print_stmt(_printStmt)
         tos = stack.pop
-        @ostream.print tos.to_str
+        @ostream.print tos ? tos.to_str : 'nil'
       end
 
       def after_while_stmt(aWhileStmt, aVisitor)
@@ -145,9 +160,11 @@ module Loxxy
       end
 
       def after_binary_expr(aBinaryExpr)
-        op = aBinaryExpr.operator
         operand2 = stack.pop
         operand1 = stack.pop
+        op = aBinaryExpr.operator
+        operator = binary_operators[op]
+        operator.validate_operands(operand1, operand2)
         if operand1.respond_to?(op)
           stack.push operand1.send(op, operand2)
         else
@@ -157,16 +174,39 @@ module Loxxy
       end
 
       def after_unary_expr(anUnaryExpr)
-        op = anUnaryExpr.operator
         operand = stack.pop
+        op = anUnaryExpr.operator
+        operator = unary_operators[op]
+        operator.validate_operand(operand)
         if operand.respond_to?(op)
           stack.push operand.send(op)
         else
-          msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
+          msg1 = "`#{op}': Unimplemented operator for a #{operand.class}."
           raise StandardError, msg1
         end
       end
 
+      def after_call_expr(aCallExpr, aVisitor)
+        # Evaluate callee part
+        aCallExpr.callee.accept(aVisitor)
+        callee = stack.pop
+        aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
+
+        if callee.kind_of?(NativeFunction)
+          stack.push callee.call # Pass arguments
+        else
+          new_env = Environment.new(symbol_table.current_env)
+          symbol_table.enter_environment(new_env)
+          callee.parameters&.each do |param_name|
+            local = Variable.new(param_name, stack.pop)
+            symbol_table.insert(local)
+          end
+          callee.call(aVisitor)
+
+          symbol_table.leave_environment
+        end
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -184,10 +224,91 @@ module Loxxy
         stack.push(literalExpr.literal)
       end
 
-      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)
       end
+
+      def after_fun_stmt(aFunStmt, _visitor)
+        function = Function.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, stack)
+        new_var = Variable.new(aFunStmt.name, function)
+        symbol_table.insert(new_var)
+      end
+
+      private
+
+      NativeFunction = Struct.new(:callable, :interp) do
+        def accept(_visitor)
+          interp.stack.push self
+        end
+
+        def call
+          callable.call
+        end
+
+        def to_str
+          '<native fn>'
+        end
+      end
+
+      def init_unary_operators
+        negate_op = UnaryOperator.new('-', [Datatype::Number])
+        unary_operators[:-@] = negate_op
+
+        negation_op = UnaryOperator.new('!', [Datatype::BuiltinDatatype])
+        unary_operators[:!] = negation_op
+      end
+
+      def init_binary_operators
+        plus_op = BinaryOperator.new('+', [[Datatype::Number, :idem],
+          [Datatype::LXString, :idem]])
+        binary_operators[:+] = plus_op
+
+        minus_op = BinaryOperator.new('-', [[Datatype::Number, :idem]])
+        binary_operators[:-] = minus_op
+
+        star_op = BinaryOperator.new('*', [[Datatype::Number, :idem]])
+        binary_operators[:*] = star_op
+
+        slash_op = BinaryOperator.new('/', [[Datatype::Number, :idem]])
+        binary_operators[:/] = slash_op
+
+        equal_equal_op = BinaryOperator.new('==', [[Datatype::BuiltinDatatype, Datatype::BuiltinDatatype]])
+        binary_operators[:==] = equal_equal_op
+
+        not_equal_op = BinaryOperator.new('!=', [[Datatype::BuiltinDatatype, Datatype::BuiltinDatatype]])
+        binary_operators[:!=] = not_equal_op
+
+        less_op = BinaryOperator.new('<', [[Datatype::Number, :idem]])
+        binary_operators[:<] = less_op
+
+        less_equal_op = BinaryOperator.new('<=', [[Datatype::Number, :idem]])
+        binary_operators[:<=] = less_equal_op
+
+        greater_op = BinaryOperator.new('>', [[Datatype::Number, :idem]])
+        binary_operators[:>] = greater_op
+
+        greater_equal_op = BinaryOperator.new('>=', [[Datatype::Number, :idem]])
+        binary_operators[:>=] = greater_equal_op
+      end
+
+      def init_globals
+        add_native_fun('clock', native_clock)
+      end
+
+      def add_native_fun(aName, aProc)
+        native_fun = Variable.new(aName, NativeFunction.new(aProc, self))
+        symbol_table.insert(native_fun)
+      end
+
+      # Ruby-native function that returns (as float) the number of seconds since
+      # a given time reference.
+      def native_clock
+        proc do
+          now = Time.now.to_f
+          Datatype::Number.new(now)
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/back_end/function.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # rubocop: disable Style/AccessorGrouping
+    # Representation of a Lox function.
+    # It is a named slot that can be associated with a value at the time.
+    class Function
+      # @return [String]
+      attr_reader :name
+
+      # @return [Array<>] the parameters
+      attr_reader :parameters
+      attr_reader :body
+      attr_reader :stack
+
+      # Create a variable with given name and initial value
+      # @param aName [String] The name of the variable
+      # @param aValue [Datatype::BuiltinDatatype] the initial assigned value
+      def initialize(aName, parameterList, aBody, aStack)
+        @name = aName.dup
+        @parameters = parameterList
+        @body = aBody
+        @stack = aStack
+      end
+
+      def accept(_visitor)
+        stack.push self
+      end
+
+      def call(aVisitor)
+        body.empty? ? Datatype::Nil.instance : body.accept(aVisitor)
+      end
+
+      # Text representation of a Lox function
+      def to_str
+        "<fn #{name}>"
+      end
+    end # class
+    # rubocop: enable Style/AccessorGrouping
+  end # module
+end # module

data/lib/loxxy/back_end/unary_operator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Loxxy
+  module BackEnd
+    # A Lox unary operator
+    class UnaryOperator
+      # @return [String] text representation of the operator
+      attr_reader :name
+
+      # @return [Array<Class>]
+      attr_reader :signatures
+
+      # @param aName [String] "name" of operator
+      # @param theSignatures [Array<Class>] allowed signatures
+      def initialize(aName, theSignatures)
+        @name = aName
+        @signatures = theSignatures
+      end
+
+      def validate_operand(operand1)
+        compliant = signatures.find { |some_type| operand1.kind_of?(some_type) }
+
+        unless compliant
+          err = Loxxy::RuntimeError
+          # if signatures.size == 1
+          raise err, "Operand must be a #{datatype_name(signatures[0])}."
+          # end
+        end
+      end
+
+      private
+
+      def datatype_name(aClass)
+        # (?:(?:[^:](?!:|(?<=LX))))+$
+        aClass.name.sub(/^.+(?=::)::(?:LX)?/, '').downcase
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Loxxy
+  # Abstract class. Generalization of Loxxy error classes.
+  class Error < StandardError; end
+
+  # Error occurring while Loxxy executes some invalid Lox code.
+  class RuntimeError < Error; end
+end