loxxy 0.0.16 → 0.0.21

data/lib/loxxy/back_end/symbol_table.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'environment'
+
+module Loxxy
+  module BackEnd
+    # A symbol table is basically a mapping from a name onto an object
+    # that holds information associated with that name. It is a data structure
+    # that keeps track of variables and their respective environment where they are
+    # declared. The key requirements for the symbol are:
+    # - To perform fast lookup operations: given a name, retrieve the corresponding
+    #   object.
+    # - To allow the efficient insertion of names and related information
+    # - To support the nesting of environments
+    # - To handle the entry environment and exit environment events,
+    # - To cope with variable redefinition in nested environment
+    # The terminology 'symbol table' comes from the compiler design
+    # community.
+    class SymbolTable
+      # Mapping between a name and the environment(s) where it is defined
+      # @return [Hash{String => Array<Environment>}]
+      attr_reader :name2envs
+
+      # @return [Environment] The top-level environment (= root of environment tree)
+      attr_reader :root
+
+      # @return [Environment] The current environment.
+      attr_reader :current_env
+
+      # Build symbol table with given environment as root.
+      # @param anEnv [BackEnd::Environment,NilClass] The top-level Environment
+      def initialize(anEnv = nil)
+        @name2envs = {}
+        init_root(anEnv) # Set default (global) environment
+      end
+
+      # Returns iff there is no entry in the symbol table
+      # @return [Boolean]
+      def empty?
+        name2envs.empty?
+      end
+
+      # Use this method to signal the interpreter that a given environment
+      # to be a child of current environment and to be itself the new current environment.
+      # @param anEnv [BackEnd::Environment] the Environment that
+      def enter_environment(anEnv)
+        anEnv.parent = current_env
+        @current_env = anEnv
+      end
+
+      def leave_environment
+        current_env.defns.each_pair do |nm, _item|
+          environments = name2envs[nm]
+          if environments.size == 1
+            name2envs.delete(nm)
+          else
+            environments.pop
+            name2envs[nm] = environments
+          end
+        end
+        raise StandardError, 'Cannot remove root environment.' if current_env == root
+
+        @current_env = current_env.parent
+      end
+
+      # Add an entry with given name to current environment.
+      # @param anEntry [Variable]
+      # @return [String] Internal name of the entry
+      def insert(anEntry)
+        current_env.insert(anEntry)
+        name = anEntry.name
+        if name2envs.include?(name)
+          name2envs[name] << current_env
+        else
+          name2envs[name] = [current_env]
+        end
+
+        anEntry.name # anEntry.i_name
+      end
+
+      # Search for the object with the given name
+      # @param aName [String]
+      # @return [BackEnd::Variable]
+      def lookup(aName)
+        environments = name2envs.fetch(aName, nil)
+        return nil if environments.nil?
+
+        sc = environments.last
+        sc.defns[aName]
+      end
+
+      # Search for the object with the given i_name
+      # @param anIName [String]
+      # @return [BackEnd::Variable]
+      # def lookup_i_name(anIName)
+        # found = nil
+        # environment = current_env
+
+        # begin
+          # found = environment.defns.values.find { |e| e.i_name == anIName }
+          # break if found
+
+          # environment = environment.parent
+        # end while environment
+
+        # found
+      # end
+
+      # Return all variables defined in the current .. root chain.
+      # Variables are sorted top-down and left-to-right.
+      def all_variables
+        vars = []
+        skope = current_env
+        while skope
+          vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
+          vars = vars_of_environment.values.concat(vars)
+          skope = skope.parent
+        end
+
+        vars
+      end
+
+      private
+
+      def init_root(anEnv)
+        @root = valid_environment(anEnv)
+        @current_env = @root
+      end
+
+      def valid_environment(anEnv)
+        anEnv.nil? ? Environment.new : anEnv
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/variable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'entry'
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # Representation of a Lox variable.
+    # It is a named slot that can be associated with a value at the time.
+    class Variable
+      include Entry # Add expected behaviour for symbol table entries
+      
+      # @return [Datatype::BuiltinDatatype] the value assigned to the variable
+      attr_accessor :value
+
+      # 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, aValue = Datatype::Nil.instance)
+        init_name(aName)
+        @value = aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,48 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        false # Default implementation
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        true # Default implementation
+      end
+
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
+      # Negation ('not')
+      # Returns a boolean with opposite truthiness value.
+      # @return [Datatype::Boolean]
+      def !
+        falsey? ? True.instance : False.instance
+      end
+
+      # Returns the first falsey argument (if any),
+      # otherwise returns the last truthy argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def and(operand2)
+        falsey? ? self : logical_2nd_arg(operand2)
+      end
+
+      # Returns the first truthy argument (if any),
+      # otherwise returns the last falsey argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def or(operand2)
+        truthy? ? self : logical_2nd_arg(operand2)
+      end
+
       # Method called from Lox to obtain the text representation of the boolean.
       # @return [String]
       def to_str
@@ -25,6 +67,19 @@ module Loxxy
       def validated_value(aValue)
         aValue
       end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+          when false
+            False.instance # Convert to Lox equivalent
+          when nil
+            Nil.instance # Convert to Lox equivalent
+          when true
+            True.instance # Convert to Lox equivalent
+          else
+            operand2
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/datatype/false.rb

@@ -20,6 +20,20 @@ module Loxxy
         true
       end
 
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
+      end
+
       # Check for equality of a Lox False with another Lox object
       # @param other [Datatype::BuiltinDatatype, FalseClass, Object]
       # @return [Datatype::Boolean]
@@ -27,14 +41,6 @@ module Loxxy
         falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
         falsey ? True.instance : False.instance
       end
-
-      # Check for inequality of a Lox False with another Lox object
-      # @param other [Datatype::BuiltinDatatype, FalseClass, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
-        falsey ? False.instance : True.instance
-      end
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -21,20 +21,6 @@ module Loxxy
         end
       end
 
-      # Check the inequality of a Lox String with another Lox object.
-      # @param other [Datatype::LxString, String, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        case other
-        when LXString
-          (value != other.value) ? True.instance : False.instance
-        when String
-          (value != other) ? True.instance : False.instance
-        else
-          True.instance
-        end
-      end
-
       # Perform the concatenation of two Lox stings or
       # one Lox string and a Ruby String
       # @param other [Loxxy::Datatype::LXString, String]

data/lib/loxxy/datatype/nil.rb

@@ -22,12 +22,18 @@ module Loxxy
         is_nil ? True.instance : False.instance
       end
 
-      # Check the inequality with another object.
-      # @param other [Datatype::BuiltinDatatype, NilClass, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        is_nil = other.kind_of?(Nil) || other.kind_of?(NilClass)
-        is_nil ? False.instance : True.instance
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
       end
 
       # Method called from Lox to obtain the text representation of nil.

data/lib/loxxy/datatype/number.rb

@@ -71,6 +71,12 @@ module Loxxy
         end
       end
 
+      # Unary minus (return value with changed sign)
+      # @return [Loxxy::Datatype::Number]
+      def -@
+        self.class.new(-value)
+      end
+
       # Check the equality of a Lox number object with another object
       # @param other [Datatype::BuiltinDatatype, Numeric, Object]
       # @return [Datatype::Boolean]
@@ -85,20 +91,52 @@ module Loxxy
         end
       end
 
-      # Check the inequality of a Lox number object with another object
-      # @param other [Datatype::BuiltinDatatype, Numeric, Object]
+      # Check whether this Lox number has a greater value than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def >(other)
+        case other
+        when Number
+          (value > other.value) ? True.instance : False.instance
+        when Numeric
+          (value > other) ? True.instance : False.instance
+        else
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
+        end
+      end
+
+      # Check whether this Lox number has a greater or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
       # @return [Datatype::Boolean]
-      def !=(other)
+      def >=(other)
         case other
         when Number
-          (value != other.value) ? True.instance : False.instance
+          (value >= other.value) ? True.instance : False.instance
         when Numeric
-          (value != other) ? True.instance : False.instance
+          (value >= other) ? True.instance : False.instance
         else
-          True.instance
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
         end
       end
 
+      # Check whether this Lox number has a lesser value than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <(other)
+        !(self >= other)
+      end
+
+      # Check whether this Lox number has a lesser or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <=(other)
+        !(self > other)
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/true.rb

@@ -20,21 +20,13 @@ module Loxxy
         true
       end
 
-      # Check for equality of a Lox True with another Lox object
+      # Check for equality of a Lox True with another Lox object / Ruby true
       # @param other [Datatype::True, TrueClass, Object]
       # @return [Datatype::Boolean]
       def ==(other)
         thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
         thruthy ? True.instance : False.instance
       end
-
-      # Check for inequality of a Lox True with another Lox object
-      # @param other [Datatype::BuiltinDatatype, TrueClass, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
-        thruthy ? False.instance : True.instance
-      end
     end # class
 
     True.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -46,8 +46,8 @@ module Loxxy
 
       rule('funDecl' => 'FUN function')
 
-      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
-      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
+      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
+      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
 
       # Statements: produce side effects, but don't introduce bindings
       rule('statement' => 'exprStmt')
@@ -68,9 +68,9 @@ module Loxxy
       rule('forTest' => 'expression_opt SEMICOLON')
       rule('forUpdate' => 'expression_opt')
 
-      rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
-      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN')
-      rule('elsePart_opt' => 'ELSE statement')
+      rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
+      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
+      rule('elsePart_opt' => 'ELSE statement').as 'keep_symbol2'
       rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
@@ -121,7 +121,7 @@ module Loxxy
       rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
-      rule('unary' => 'unaryOp unary')
+      rule('unary' => 'unaryOp unary').as 'unary_expr'
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
@@ -138,7 +138,7 @@ module Loxxy
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
-      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules