sardonyx 0.1.9 → 0.1.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c327818bc6930f9d380e18ca947ea03abcc10ce8069118649a7b181944335a4
-  data.tar.gz: ef98de56189f67a7c6d5ddbe81a6aff5bedfe2d8323df69145ee432190a17480
+  metadata.gz: ae3902bcee8c7322c0ead62c5c9e4f76fed8ff73c0bd326921360ff03f49f252
+  data.tar.gz: 587f6306aa1042d1531e5ffb6b9498185252e2db2fb2855449041b557ee34ec3
 SHA512:
-  metadata.gz: cae9757402ebf5dce3e44aa0df039d406c27b875dcac20b49f34493321c33f04a77140d09a5dfdbe2bb2ed3f5b84e4b051f769d461f20ad7ce72392e79ab9bfd
-  data.tar.gz: 6f8104b6729eff7b2e3d572ac2620a2f4589187fcdd73d152b166166fa92e2d538823987e224633fbd9f6493a69d91994bca5c5cb46c145de20e9a8b0173fbe3
+  metadata.gz: c42b9e8cc520d5e360dd7d07314030246164034035715019fc975aa00b36e9b1be5d653d1e97380f87c0a1cce46a84a5b2d3d73a66b526a0cac689736fc7f0c4
+  data.tar.gz: 6754b493b645962e86f18af568310f6291b3ef00ad8f6d01ef154202c29ef856187f284b85dc1bb0771d601f7e3a5258fde30ecd109a2f68e439ff2a1548ab76

data/bin/sdx

@@ -15,7 +15,7 @@ if ARGV.size == 1
 else
     path = [(File.expand_path Dir.pwd), *(ENV.fetch("SDX_PATH", "").split ":")]
     vm = VM.new StringIO.new ""
-    puts "Sardonyx v0.1.9"
+    puts "Sardonyx v0.1.8"
     def exit(_) end
     loop do
         print "> "
@@ -29,7 +29,7 @@ else
         val = vm.stack[-1]
         vm.clear
         if val
-            puts vm.stringify val
+            puts stringify val
         end
     end
 end

data/lib/sdx/compiler/compiler.rb

@@ -72,18 +72,6 @@ module Compiler
                     bc += "\x27"
                 when "^"
                     bc += "\x28"
-                when "=="
-                    bc += "\x34"
-                when "!="
-                    bc += "\x35"
-                when "<"
-                    bc += "\x36"
-                when ">"
-                    bc += "\x37"
-                when "<="
-                    bc += "\x38"
-                when ">="
-                    bc += "\x39"
                 end
             when :if
                 bc += self.encode_node node.value
@@ -103,12 +91,10 @@ module Compiler
                     end
                     i += "\x2a#{e.size}\x18"
                 end
-                bc += "\x2b#{i.size}\x18" + i
+                bc += "\x29#{i.size}\x18" + i
                 if e
                     bc += e
                 end
-            when :bool
-                bc += "\x21\x12#{node.value}\x18"
             when :name
                 bc += "\x20#{node.value}\x18"
             when :nil

data/lib/sdx/compiler/parser.rb

@@ -10,13 +10,11 @@ module Parser
             /\Aobject/ => :object,
             /\Anew/ => :new,
             /\Arequire/ => :require,
-            /\A(true|false)/ => :bool,
-            /\A-?[0-9]+\.[0-9]+/ => :float,
-            /\A-?[0-9]+/ => :number,
-            /\A(\+|-)/ => :l1op,
-            /\A(\/|\*|%|\^)/ => :l2op,
-            /\A(<|>|<=|>=|==|!=)/ => :l1op,
+            /\A(<|>|<=|>=|==)/ => :op,
             /\A(\+|-|\*|\/|%)?=/ => :eq,
+            /\A(\+|-|\*|\/|%)/ => :op,
+            /\A-?[0-9]+/ => :number,
+            /\A-?[0-9]+\.[0-9]+/ => :float,
             /\A"([^"]|\\")*"/ => :string,
             /\Anil/ => :nil,
             /\A\(/ => :lpar,
@@ -99,14 +97,6 @@ module Parser
             end
         end
 
-        def self.parse_bool(tokens)
-            if self.expect tokens, :bool
-                [ (Node.new :bool, tokens[0][0], []), 1 ]
-            else
-                nil
-            end
-        end
-
         def self.parse_float(tokens)
             if self.expect tokens, :float
                 [ (Node.new :float, tokens[0][0], []), 1 ]
@@ -123,23 +113,6 @@ module Parser
             end
         end
 
-        def self.parse_parens(tokens)
-            if self.expect tokens, :lpar
-                tokens = tokens[1..tokens.size]
-                unless self.parse_expr tokens
-                    return nil
-                end
-                e, part = self.parse_expr tokens
-                tokens = tokens[part..tokens.size]
-                unless self.expect tokens, :rpar
-                    return nil
-                end
-                return [e, part + 2]
-            else
-                return nil
-            end
-        end
-
         def self.parse_list(tokens)
             unless (self.expect tokens, :lbrack)
                 return nil
@@ -182,7 +155,7 @@ module Parser
             while true
                 if self.expect tokens, :rbrace
                     total += 1
-                    return [ (Node.new :block, "", children), total ]
+                    break
                 end
                 e = self.parse_expr tokens
                 if e
@@ -194,26 +167,23 @@ module Parser
                     Kernel.exit 1
                 end
             end
-            total += 1
             [ (Node.new :block, "", children), total ]
         end
 
         def self.parse_literal(tokens)
-            (self.parse_block tokens) || (self.parse_bool tokens) || (self.parse_float tokens) || (self.parse_name tokens) || (self.parse_number tokens) || (self.parse_list tokens) || (self.parse_string tokens) || (self.parse_nil tokens) || (self.parse_parens tokens)
+            (self.parse_block tokens) ||  self.parse_float(tokens) || (self.parse_name tokens) || (self.parse_number tokens) || (self.parse_list tokens) || (self.parse_string tokens) || (self.parse_nil tokens)
         end
 
         def self.parse_call(tokens)
-            unless (self.parse_literal tokens)
-                return nil
-            end
-            callee = (self.parse_literal tokens)
-            total = callee[1]
-            tokens = tokens[total..tokens.size]
-            callee = callee[0]
-            if self.expect tokens, :lpar
+            if self.lookahead tokens, :lpar, 1
+                unless (self.parse_literal tokens)
+                    return nil
+                end
+                callee = (self.parse_literal tokens)
+                callee = callee[0]
                 args = []
-                tokens = tokens[1..tokens.size]
-                total += 1
+                tokens = tokens[2..tokens.size]
+                total = 2
                 if self.expect tokens, :rpar
                     return [ (Node.new :call, callee, args), total + 1 ]
                 end
@@ -225,15 +195,14 @@ module Parser
                     total += part
                     tokens = tokens[part..tokens.size]
                     args << arg
+                    total += 1
                     if self.expect tokens, :rpar
                         tokens = tokens[1..tokens.size]
-                        total += 1
                         break
                     end
                     unless (self.expect tokens, :comma)
                         return nil
                     end
-                    total += 1
                     tokens = tokens[1..tokens.size]
                 end
                 return [ (Node.new :call, callee, args), total ]
@@ -361,92 +330,26 @@ module Parser
             return [ (Node.new :for, e, [name, block]), total ]
         end
 
-
-        def self.parse_factor(tokens)
-            (self.parse_call tokens) || 
-            (self.parse_require tokens) || 
-            (self.parse_new tokens) || 
-            (self.parse_object tokens) || 
-            (self.parse_fn tokens) || 
-            (self.parse_assign tokens) || 
-            (self.parse_literal tokens) || 
-            (self.parse_if tokens) || 
-            (self.parse_while tokens) || 
-            (self.parse_for tokens)
-        end
-
-        def self.parse_term(tokens)
-            total = 0
-            unless self.parse_factor tokens
-                return nil
-            end
-            lhs, part = self.parse_factor tokens
-            total += part
-            tokens = tokens[part..tokens.size]
-            unless self.expect tokens, :l2op
-                return [lhs, part]
-            end
-            op = tokens[0][0]
-            total += 1
-            tokens = tokens[1..tokens.size]
-            unless self.parse_factor tokens
-                return nil
-            end
-            rhs, part = self.parse_factor tokens
-            total += part
-            tokens = tokens[part..tokens.size]
-            out = (Node.new :op, op, [lhs])
-            while self.expect tokens, :l2op
-                op = tokens[0][0]
-                total += 1
-                tokens = tokens[1..tokens.size]
-                unless self.parse_term tokens
-                    return nil
-                end
-                rhs2, part = self.parse_term tokens
-                total += part
-                tokens = tokens[part..tokens.size]
-                rhs = Node.new :op, op, [rhs, rhs2]
-            end
-            out.children << rhs
-            return [out, total]
-        end
-
         def self.parse_op(tokens)
             total = 0
-            unless self.parse_term tokens
+            unless self.parse_literal tokens
                 return nil
             end
-            lhs, part = self.parse_term tokens
+            lhs, part = self.parse_literal tokens
             total += part
             tokens = tokens[part..tokens.size]
-            unless self.expect tokens, :l1op
-                return [lhs, part]
+            unless self.expect tokens, :op
+                return nil
             end
             op = tokens[0][0]
             total += 1
             tokens = tokens[1..tokens.size]
-            unless self.parse_term tokens
+            unless self.parse_expr tokens
                 return nil
             end
-            rhs, part = self.parse_term tokens
+            rhs, part = self.parse_expr tokens
             total += part
-            tokens = tokens[part..tokens.size]
-            out = (Node.new :op, op, [lhs])
-            while self.expect tokens, :l1op
-                op = tokens[0][0]
-                total += 1
-                tokens = tokens[1..tokens.size]
-                unless self.parse_term tokens
-                    return nil
-                end
-                rhs2, part = self.parse_term tokens
-                total += part
-                tokens = tokens[part..tokens.size]
-                rhs = Node.new :op, op, [rhs, rhs2]
-            end
-            out.children << rhs
-            return [out, total]
+            return [ (Node.new :op, op, [lhs, rhs]), total]
         end
 
         def self.parse_assign(tokens)
@@ -580,17 +483,7 @@ module Parser
         end
             
         def self.parse_expr(tokens)
-            (self.parse_op tokens)  || 
-            (self.parse_call tokens) || 
-            (self.parse_require tokens) || 
-            (self.parse_new tokens) || 
-            (self.parse_object tokens) || 
-            (self.parse_fn tokens) || 
-            (self.parse_assign tokens) || 
-            (self.parse_literal tokens) || 
-            (self.parse_if tokens) || 
-            (self.parse_while tokens) || 
-            (self.parse_for tokens)
+            (self.parse_require tokens) || (self.parse_new tokens) || (self.parse_object tokens) || (self.parse_fn tokens) || (self.parse_assign tokens) || (self.parse_op tokens)  || (self.parse_call tokens) || (self.parse_literal tokens) || (self.parse_if tokens) || (self.parse_while tokens) || (self.parse_for tokens)
         end
 
         def self.parse(tokens, path)

data/lib/sdx/vm/datatypes.rb

@@ -58,12 +58,6 @@ class Bool < DataType
             end)),
             "__as_code_string" => (NativeFn.new 0, (Proc.new do
                 as_string
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
             end))
         }
     end
@@ -89,40 +83,22 @@ class Int < DataType
                 as_bool
             end)),
             "__add" => (NativeFnInternal.new (Proc.new do |other|
-                add other[0]
+                add other
             end)),
             "__sub" => (NativeFnInternal.new (Proc.new do |other|
-                sub other[0]
+                sub other
             end)),
             "__mul" => (NativeFnInternal.new (Proc.new do |other|
-                mul other[0]
+                mul other
             end)),
             "__div" => (NativeFnInternal.new (Proc.new do |other|
-                div other[0]
+                div other
             end)),
             "__mod" => (NativeFnInternal.new (Proc.new do |other|
-                mod other[0]
+                mod other
             end)),
             "__pow" => (NativeFnInternal.new (Proc.new do |other|
-                pow other[0]
-            end)),
-            "__lt" => (NativeFnInternal.new (Proc.new do |other|
-                lt other[0]
-            end)),
-            "__gt" => (NativeFnInternal.new (Proc.new do |other|
-                gt other[0]
-            end)),
-            "__le" => (NativeFnInternal.new (Proc.new do |other|
-                le other[0]
-            end)),
-            "__ge" => (NativeFnInternal.new (Proc.new do |other|
-                ge other[0]
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
+                pow other
             end))
         }
     end
@@ -158,22 +134,6 @@ class Int < DataType
     def pow(other)
         Int.new @internal ** other.internal
     end
-
-    def lt(other)
-        Bool.new @internal < other.internal
-    end
-
-    def gt(other)
-        Bool.new @internal > other.internal
-    end
-
-    def le(other)
-        Bool.new @internal <= other.internal
-    end
-
-    def ge(other)
-        Bool.new @internal >= other.internal
-    end
 end
 
 class Str < DataType 
@@ -189,16 +149,10 @@ class Str < DataType
                 as_code_string
             end)),
             "__add" => (NativeFnInternal.new (Proc.new do |other|
-                add other[0]
+                add other
             end)),
             "__mul" => (NativeFnInternal.new (Proc.new do |other|
-                mul other[0]
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
+                mul other
             end))
         }
     end
@@ -236,40 +190,22 @@ class Num < DataType
                 as_bool
             end)),
             "__add" => (NativeFnInternal.new (Proc.new do |other|
-                add other[0]
+                add other
             end)),
             "__sub" => (NativeFnInternal.new (Proc.new do |other|
-                sub other[0]
+                sub other
             end)),
             "__mul" => (NativeFnInternal.new (Proc.new do |other|
-                mul other[0]
+                mul other
             end)),
             "__div" => (NativeFnInternal.new (Proc.new do |other|
-                div other[0]
+                div other
             end)),
             "__mod" => (NativeFnInternal.new (Proc.new do |other|
-                mod other[0]
+                mod other
             end)),
             "__pow" => (NativeFnInternal.new (Proc.new do |other|
-                pow other[0]
-            end)),
-            "__lt" => (NativeFnInternal.new (Proc.new do |other|
-                lt other[0]
-            end)),
-            "__gt" => (NativeFnInternal.new (Proc.new do |other|
-                gt other[0]
-            end)),
-            "__le" => (NativeFnInternal.new (Proc.new do |other|
-                le other[0]
-            end)),
-            "__ge" => (NativeFnInternal.new (Proc.new do |other|
-                ge other[0]
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
+                pow other
             end))
         }
     end
@@ -305,22 +241,6 @@ class Num < DataType
     def pow(other)
         Num.new @internal ** other.internal
     end
-
-    def lt(other)
-        Bool.new @internal < other.internal
-    end
-
-    def gt(other)
-        Bool.new @internal > other.internal
-    end
-
-    def le(other)
-        Bool.new @internal <= other.internal
-    end
-
-    def ge(other)
-        Bool.new @internal >= other.internal
-    end
 end
 
 class Nil < DataType
@@ -329,21 +249,14 @@ class Nil < DataType
         @fields = {
             "__as_bool" => (NativeFnInternal.new (Proc.new do
                 Bool.new false
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
             end))
         }
     end
 end
 
 class List < DataType
-    def initialize(val, scope=nil)
+    def initialize(val)
         @internal = val
-        @scope = scope
         @pos = 0
         @fields = {
             "__as_string" => (NativeFnInternal.new (Proc.new do 
@@ -359,40 +272,34 @@ class List < DataType
                 iter
             end)),
             "__add" => (NativeFnInternal.new (Proc.new do |other|
-                add other[0]
+                add other
             end)),
             "__mul" => (NativeFnInternal.new (Proc.new do |other|
-                mul other[0]
+                mul other
             end)),
             "__arity" => (Int.new 1),
             "__call" => (NativeFnInternal.new (Proc.new do |args, scope|
                 @internal[args[0].value.internal]
-            end)),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
             end))
         }
     end
 
     def as_string
-        s = ""
+        s = "["
         @internal.each do |item|
             s += (stringify item) + ", "
         end
-        s = "[" + s[0..-3]
+        s = s[0..-3]
         s += "]"
         Str.new s
     end
 
     def as_code_string
-        s = ""
+        s = "["
         @internal.each do |item|
             s += (codify item) + ", "
         end
-        s = "[" + s[0..-3]
+        s = s[0..-3]
         s += "]"
         Str.new s
     end
@@ -407,12 +314,12 @@ class List < DataType
         if val
             return val
         else
-            return Variable.new Nil.new, :nil, @internal[0].scope
+            return Variable.new Nil.new
         end
     end
     
     def add(other)
-        return List.new [*@internal, (Variable.new other, (get_type other), @scope || @internal[0].scope)]
+        return List.new [*@internal, other]
     end
 
     def mul(other)
@@ -454,13 +361,7 @@ class Function < DataType
             "__call" => (NativeFnInternal.new (lambda do |args, scope|
                 call args, scope
             end)),
-            "__arity" => (Int.new args.size),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
-            end))
+            "__arity" => (Int.new args.size)
         }
     end
 
@@ -486,13 +387,7 @@ class Block < DataType
             "__call" => (NativeFnInternal.new (Proc.new do |args, scope|
                 call args, scope
             end)),
-            "__arity" => (Int.new 1),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
-            end))
+            "__arity" => (Int.new 1)
         }
     end
 
@@ -519,13 +414,7 @@ class Obj < DataType
             "__new" => (NativeFnInternal.new (Proc.new do |args, scope|
                 _new args, scope
             end)),
-            "__arity" => (Int.new args.size),
-            "__eq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal == other[0].internal
-            end)),
-            "__neq" => (NativeFnInternal.new (lambda do |other|
-                Bool.new @internal != other[0].internal
-            end))
+            "__arity" => (Int.new args.size)
         }
     end
 

data/lib/sdx/vm/vm.rb

@@ -2,13 +2,17 @@ require 'sdx/vm/variables'
 require 'sdx/vm/datatypes'
 require 'sdx/vm/scope'
 
+def stringify(val)
+    if val.value.fields["__as_string"]
+        (val.value.fields["__as_string"].call).internal
+    else
+        val.value.to_s
+    end
+end
+
 def codify(val)
     if val.value.fields["__as_code_string"]
-        if val.value.fields["__as_code_string"].respond_to? :call
-            (val.value.fields["__as_code_string"].call).internal
-        else
-            (val.value.fields["__as_code_string"].fields["__call"].call [], val.scope).internal
-        end
+        (val.value.fields["__as_code_string"].call).internal
     else
         val.value.pretty_inspect
     end
@@ -18,22 +22,10 @@ class VM
     attr_accessor :bc_io
     
     def truthy(val)
-        case val.value
-        when Bool
-            return val.value.internal
-        end
         if val.value.fields["__as_bool"]
-            return (val.value.fields["__as_bool"].call).internal
+            (val.value.fields["__as_bool"].call).internal
         else
-            return true
-        end
-    end
-
-    def stringify(val)
-        if val.value.fields["__as_string"]
-            (call val.value.fields["__as_string"], [], val.scope).internal
-        else
-            val.value.to_s
+            true
         end
     end
     
@@ -59,7 +51,7 @@ class VM
         when String
             to_var (Str.new val)
         when Float
-            to_var (Num.new val)
+            to_var (Float.new val)
         when Array
             to_var (List.new val.map { |v| from_rb v })
         when Nil
@@ -143,7 +135,6 @@ class VM
             0x24 => :sub,
             0x25 => :mul,
             0x26 => :div,
-            0x27 => :mod,
             0x12 => :bool,
             0x13 => :int,
             0x14 => :str,
@@ -159,14 +150,7 @@ class VM
             0x30 => :object,
             0x31 => :new,
             0x32 => :block,
-            0x33 => :end,
-            0x34 => :eq,
-            0x35 => :ne,
-            0x36 => :lt,
-            0x37 => :gt,
-            0x38 => :le,
-            0x39 => :ge,
-            0x28 => :pow,
+            0x33 => :end
         }
         bytes = []
         begin
@@ -280,19 +264,12 @@ class VM
                         vals << pop_from_stack
                     end
                     vals.reverse!
-                    push_to_stack Variable.new (List.new vals, @global), :list, @global
+                    push_to_stack Variable.new (List.new vals), :list, @global
                 when :block
                     size = get_string.to_i
                     body = 
                         ((load_bytes size, false).map { |e| e.chr }).join ""
                     push_to_stack Variable.new (Block.new body), :block, @global
-                when :bool
-                    val = get_string
-                    t = {
-                        "true" => true,
-                        "false" => false,
-                    }
-                    push_to_stack Variable.new (Bool.new t[val]), :bool, @global
                 when :nil
                     push_to_stack Variable.new (Nil.new), :nil, @global
                 end
@@ -302,7 +279,7 @@ class VM
                     res = (call a.value.fields["__add"], b.value)
                     push_to_stack (to_var res)
                 else
-                    error "Cannot use + on #{a.type}"
+                    error "Cannot add to #{a.type}"
                 end
             when :sub
                 b, a = pop_from_stack, pop_from_stack
@@ -310,7 +287,7 @@ class VM
                     res = (call a.value.fields["__sub"], b.value)
                     push_to_stack (Variable.new res, (get_type res), @global) 
                 else
-                    error "Cannot use - on #{a.type}"
+                    error "Cannot subtract from #{a.type}"
                 end
             when :mul
                 b, a = pop_from_stack, pop_from_stack
@@ -318,7 +295,7 @@ class VM
                     res = (call a.value.fields["__mul"], b.value)
                     push_to_stack (Variable.new res, (get_type res), @global) 
                 else
-                    error "Cannot use * on #{a.type}"
+                    error "Cannot multiply #{a.type}"
                 end
             when :div
                 b, a = pop_from_stack, pop_from_stack
@@ -326,7 +303,7 @@ class VM
                     res = (call a.value.fields["__div"], b.value)
                     push_to_stack (Variable.new res, (get_type res), @global) 
                 else
-                    error "Cannot use / on #{a.type}"
+                    error "Cannot divide #{a.type}"
                 end
             when :mod
                 b, a = pop_from_stack, pop_from_stack
@@ -334,7 +311,7 @@ class VM
                     res = (call a.value.fields["__mod"], b.value)
                     push_to_stack (Variable.new res, (get_type res), @global) 
                 else
-                    error "Cannot use % on #{a.type}"
+                    error "Cannot modulo #{a.type}"
                 end
             when :pow
                 b, a = pop_from_stack, pop_from_stack
@@ -342,55 +319,7 @@ class VM
                     res = (call a.value.fields["__pow"], b.value)
                     push_to_stack (Variable.new res, (get_type res), @global) 
                 else
-                    error "Cannot use ^ on #{a.type}"
-                end
-            when :eq
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__eq"]
-                    res = (call a.value.fields["__eq"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use == on #{a.type}"
-                end
-            when :ne
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__neq"]
-                    res = (call a.value.fields["__neq"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use != on #{a.type}"
-                end
-            when :lt
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__lt"]
-                    res = (call a.value.fields["__lt"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use < on #{a.type}"
-                end
-            when :gt
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__gt"]
-                    res = (call a.value.fields["__gt"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use > on #{a.type}"
-                end
-            when :le
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__le"]
-                    res = (call a.value.fields["__le"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use <= on #{a.type}"
-                end
-            when :ge
-                b, a = pop_from_stack, pop_from_stack
-                if a.value.fields["__ge"]
-                    res = (call a.value.fields["__ge"], b.value)
-                    push_to_stack (Variable.new res, (get_type res), @global) 
-                else
-                    error "Cannot use >= on #{a.type}"
+                    error "Cannot exponentiate #{a.type}"
                 end
             when :jmpi
                 val = pop_from_stack

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sardonyx
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.81
 platform: ruby
 authors:
 - sugarfi