sardonyx 0.1.84 → 0.1.85

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f381674f5e870ec9ac7fe8f9ce699b1e851c7314ad9480201710bcd32e665185
-  data.tar.gz: c42b1e66d327aa8bc0e39075c3778bd3b40beb7c82d47edce91a601418a82408
+  metadata.gz: 8c24e6115400ff31393984b7220c4226ea6f6a4fc8f9ba146f8d9f3ce51f749b
+  data.tar.gz: e1b92b4d17872047f11fe869d988370898dbebc74f5fe2ba4cb5e8d0ede648ec
 SHA512:
-  metadata.gz: 43c77a34a4edf0b6a87af9183004a57d8cb285f115159240b5798c8ce37723e2f9018c5f5a630d2f7c102cbf50a42f181eee30685f74cf2ede839f1e5a224a72
-  data.tar.gz: 83d259340d9dec63f6696de3a3d76832bc7c98880634df1139f5cd89042d7c7eb5c8cad1d27062fa027174344583a593d37698c96aac19328c7965b047d4ea34
+  metadata.gz: c87037ad33284bec4da7576040d214a45978ab5e018c5ef62152a2ae31858484df6f5f2e7899d6b29f9618a875d145f45960aa8c1efa22b97e60ff661b579eea
+  data.tar.gz: 2ed22a60d030ac9236075a3f97d992956753dc9c3cda125783f3e05f5c74c9d20ce3fe84a848b96b7933b2063efc9d1dd9a899f95d26957050dd7979de75d957

data/lib/sdx/compiler/compiler.rb

@@ -103,10 +103,12 @@ module Compiler
                     end
                     i += "\x2a#{e.size}\x18"
                 end
-                bc += "\x29#{i.size}\x18" + i
+                bc += "\x2b#{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,11 +10,13 @@ module Parser
             /\Aobject/ => :object,
             /\Anew/ => :new,
             /\Arequire/ => :require,
-            /\A(<|>|<=|>=|==|!=)/ => :op,
-            /\A(\+|-|\*|\/|%)?=/ => :eq,
-            /\A(\+|-|\*|\/|%)/ => :op,
-            /\A-?[0-9]+/ => :number,
+            /\A(true|false)/ => :bool,
             /\A-?[0-9]+\.[0-9]+/ => :float,
+            /\A-?[0-9]+/ => :number,
+            /\A(\+|-)/ => :l1op,
+            /\A(\/|\*|%)/ => :l2op,
+            /\A(<|>|<=|>=|==|!=)/ => :l1op,
+            /\A(\+|-|\*|\/|%)?=/ => :eq,
             /\A"([^"]|\\")*"/ => :string,
             /\Anil/ => :nil,
             /\A\(/ => :lpar,
@@ -97,6 +99,14 @@ 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 ]
@@ -189,7 +199,7 @@ module Parser
         end
 
         def self.parse_literal(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) || (self.parse_parens 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)
         end
 
         def self.parse_call(tokens)
@@ -350,7 +360,7 @@ module Parser
             return [ (Node.new :for, e, [name, block]), total ]
         end
 
-        def self.parse_op(tokens)
+        def self.parse_term(tokens)
             total = 0
             unless self.parse_literal tokens
                 return nil
@@ -358,16 +368,38 @@ module Parser
             lhs, part = self.parse_literal tokens
             total += part
             tokens = tokens[part..tokens.size]
-            unless self.expect tokens, :op
+            unless self.expect tokens, :l2op
+                return [lhs, part]
+            end
+            op = tokens[0][0]
+            total += 1
+            tokens = tokens[1..tokens.size]
+            unless self.parse_literal tokens
+                return nil
+            end
+            rhs, part = self.parse_literal tokens
+            total += part
+            return [ (Node.new :op, op, [lhs, rhs]), total]
+        end
+
+        def self.parse_op(tokens)
+            total = 0
+            unless self.parse_term tokens
                 return nil
             end
+            lhs, part = self.parse_term tokens
+            total += part
+            tokens = tokens[part..tokens.size]
+            unless self.expect tokens, :l1op
+                return [lhs, part]
+            end
             op = tokens[0][0]
             total += 1
             tokens = tokens[1..tokens.size]
-            unless self.parse_expr tokens
+            unless self.parse_term tokens
                 return nil
             end
-            rhs, part = self.parse_expr tokens
+            rhs, part = self.parse_term tokens
             total += part
             return [ (Node.new :op, op, [lhs, rhs]), total]
         end
@@ -503,7 +535,7 @@ module Parser
         end
             
         def self.parse_expr(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)
+            (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_term 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

@@ -341,8 +341,9 @@ class Nil < DataType
 end
 
 class List < DataType
-    def initialize(val)
+    def initialize(val, scope=nil)
         @internal = val
+        @scope = scope
         @pos = 0
         @fields = {
             "__as_string" => (NativeFnInternal.new (Proc.new do 
@@ -411,7 +412,7 @@ class List < DataType
     end
     
     def add(other)
-        return List.new [*@internal, (Variable.new other, (get_type other), @internal[0].scope)]
+        return List.new [*@internal, (Variable.new other, (get_type other), @scope || @internal[0].scope)]
     end
 
     def mul(other)

data/lib/sdx/vm/vm.rb

@@ -4,7 +4,11 @@ require 'sdx/vm/scope'
 
 def codify(val)
     if val.value.fields["__as_code_string"]
-        (val.value.fields["__as_code_string"].call).internal
+        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
     else
         val.value.pretty_inspect
     end
@@ -14,10 +18,14 @@ 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"]
-            (val.value.fields["__as_bool"].call).internal
+            return (val.value.fields["__as_bool"].call).internal
         else
-            true
+            return true
         end
     end
 
@@ -51,7 +59,7 @@ class VM
         when String
             to_var (Str.new val)
         when Float
-            to_var (Float.new val)
+            to_var (Num.new val)
         when Array
             to_var (List.new val.map { |v| from_rb v })
         when Nil
@@ -271,12 +279,19 @@ class VM
                         vals << pop_from_stack
                     end
                     vals.reverse!
-                    push_to_stack Variable.new (List.new vals), :list, @global
+                    push_to_stack Variable.new (List.new vals, @global), :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

metadata

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