sardonyx 0.1.84 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f381674f5e870ec9ac7fe8f9ce699b1e851c7314ad9480201710bcd32e665185
-  data.tar.gz: c42b1e66d327aa8bc0e39075c3778bd3b40beb7c82d47edce91a601418a82408
+  metadata.gz: b28cfaca2d8790be84bad3e1f6bffd5ead67aeaa6be749643a68828530b68bbe
+  data.tar.gz: 92a7ea6bccf98cf8099fbe8665e20c1a6548c6c7fe4a7c92289ce8dda7ca6393
 SHA512:
-  metadata.gz: 43c77a34a4edf0b6a87af9183004a57d8cb285f115159240b5798c8ce37723e2f9018c5f5a630d2f7c102cbf50a42f181eee30685f74cf2ede839f1e5a224a72
-  data.tar.gz: 83d259340d9dec63f6696de3a3d76832bc7c98880634df1139f5cd89042d7c7eb5c8cad1d27062fa027174344583a593d37698c96aac19328c7965b047d4ea34
+  metadata.gz: 89cde9393ea7e0f22af24ebe35c18a0b414c9dd115df9d378bcc98b4686f246cd550210ef3ed7f417f00e71b1bc866ccdc3611230c2d63379f8bdae93e651ba4
+  data.tar.gz: 19dc7e4ccf4700d2158d29812fedfc673ad68fb893c99d9ff98f5bc3d8044b3f0cf10efa9738fbe41931f683e2a276d5f5cf8823509428f9b75540b68f371dcc

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.8"
+    puts "Sardonyx v0.2"
     def exit(_) end
     loop do
         print "> "

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 ]
@@ -115,13 +125,15 @@ module Parser
 
         def self.parse_parens(tokens)
             if self.expect tokens, :lpar
-                tokens = tokens[1..tokens.size]
-                unless self.parse_expr tokens
+                tokens = tokens[1..-1]
+                res = self.parse_expr tokens
+                unless res
                     return nil
                 end
                 e, part = self.parse_expr tokens
-                tokens = tokens[part..tokens.size]
-                unless self.expect tokens, :rpar
+                tokens = tokens[part..-1]
+                res = self.expect tokens, :rpar
+                unless res
                     return nil
                 end
                 return [e, part + 2]
@@ -134,7 +146,7 @@ module Parser
             unless (self.expect tokens, :lbrack)
                 return nil
             end
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             children = []
             total = 1
             while true
@@ -142,13 +154,14 @@ module Parser
                     total += 1
                     break
                 end
-                unless self.parse_expr tokens
+                res = self.parse_expr tokens
+                unless res
                     return nil
                 end
-                e, part = self.parse_expr tokens
+                e, part = res
                 children << e
                 total += part
-                tokens = tokens[part..tokens.size]
+                tokens = tokens[part..-1]
                 if self.expect tokens, :rbrack
                     total += 1
                     break
@@ -157,7 +170,7 @@ module Parser
                     return nil
                 end
                 total += 1
-                tokens = tokens[1..tokens.size]
+                tokens = tokens[1..-1]
             end
             [ (Node.new :list, "", children), total ]
         end
@@ -166,7 +179,7 @@ module Parser
             unless (self.expect tokens, :lbrace)
                 return nil
             end
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             children = []
             total = 1
             while true
@@ -178,7 +191,7 @@ module Parser
                 if e
                     children << e[0]
                     total += e[1]
-                    tokens = tokens[e[1]..tokens.size]
+                    tokens = tokens[e[1]..-1]
                 else
                     puts "Syntax error at token ", tokens[0]
                     Kernel.exit 1
@@ -189,41 +202,52 @@ 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)
-            unless (self.parse_literal tokens)
+            res = (self.parse_literal tokens)
+            unless res
                 return nil
             end
-            callee = (self.parse_literal tokens)
+            callee = res
             total = callee[1]
-            tokens = tokens[total..tokens.size]
+            tokens = tokens[total..-1]
             callee = callee[0]
             if self.expect tokens, :lpar
                 args = []
-                tokens = tokens[1..tokens.size]
+                tokens = tokens[1..-1]
                 total += 1
                 if self.expect tokens, :rpar
                     return [ (Node.new :call, callee, args), total + 1 ]
                 end
                 while true
-                    unless (self.parse_expr tokens)
+                    res = (self.parse_expr tokens)
+                    unless res
                         return nil
                     end
-                    arg, part = (self.parse_expr tokens)
+                    arg, part = res
                     total += part
-                    tokens = tokens[part..tokens.size]
+                    tokens = tokens[part..-1]
                     args << arg
-                    total += 1
                     if self.expect tokens, :rpar
-                        tokens = tokens[1..tokens.size]
+                        tokens = tokens[1..-1]
+                        total += 1
                         break
                     end
                     unless (self.expect tokens, :comma)
                         return nil
                     end
-                    tokens = tokens[1..tokens.size]
+                    total += 1
+                    tokens = tokens[1..-1]
                 end
                 return [ (Node.new :call, callee, args), total ]
             else
@@ -236,36 +260,38 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             if self.lookahead tokens, :lpar, 1
-                unless (self.parse_literal tokens)
+                res = (self.parse_literal tokens)
+                unless res
                     return nil
                 end
-                callee = (self.parse_literal tokens)
+                callee = res
                 callee = callee[0]
                 args = []
-                tokens = tokens[2..tokens.size]
+                tokens = tokens[2..-1]
                 total += 2
                 if self.expect tokens, :rpar
                     return [ (Node.new :call, callee, args), total + 1 ]
                 end
                 while true
-                    unless (self.parse_expr tokens)
+                    res = (self.parse_expr tokens)
+                    unless res
                         return nil
                     end
-                    arg, part = (self.parse_expr tokens)
+                    arg, part = res
                     total += part
-                    tokens = tokens[part..tokens.size]
+                    tokens = tokens[part..-1]
                     args << arg
                     total += 1
                     if self.expect tokens, :rpar
-                        tokens = tokens[1..tokens.size]
+                        tokens = tokens[1..-1]
                         break
                     end
                     unless (self.expect tokens, :comma)
                         return nil
                     end
-                    tokens = tokens[1..tokens.size]
+                    tokens = tokens[1..-1]
                 end
                 return [ (Node.new :new, callee, args), total ]
             else
@@ -278,30 +304,33 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[1..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            e, part = self.parse_expr tokens
+            e, part = res
             total += part
-            tokens = tokens[part..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[part..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            block, part = self.parse_expr tokens
+            block, part = res
             total += part
-            tokens = tokens[part..tokens.size]
+            tokens = tokens[part..-1]
             el = nil
             if self.expect tokens, :else
                 total += 1
-                tokens = tokens[1..tokens.size]
-                unless self.parse_expr tokens
+                tokens = tokens[1..-1]
+                res = self.parse_expr tokens
+                unless res
                     return nil
                 end
-                el, part = self.parse_expr tokens 
+                el, part = res
                 total += part
             end
-            return [ (Node.new :if, e, [block, el]), total ]
+            [ (Node.new :if, e, [block, el]), total ]
         end
 
         def self.parse_while(tokens)
@@ -309,19 +338,21 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[1..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            e, part = self.parse_expr tokens
+            e, part = res
             total += part
-            tokens = tokens[part..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[part..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            block, part = self.parse_expr tokens
+            block, part = res
             total += part
-            return [ (Node.new :while, e, [block]), total ]
+            [ (Node.new :while, e, [block]), total ]
         end
 
         def self.parse_for(tokens)
@@ -329,47 +360,120 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             name = nil
             if self.expect tokens, :name and self.lookahead tokens, :in, 1
                 name = tokens[0][0]
                 total += 2
-                tokens = tokens[2..tokens.size]
+                tokens = tokens[2..-1]
             end
-            unless self.parse_expr tokens
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            e, part = self.parse_expr tokens
+            e, part = res
             total += part
-            tokens = tokens[part..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[part..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            block, part = self.parse_expr tokens
+            block, part = res
             total += part
-            return [ (Node.new :for, e, [name, block]), total ]
+            [ (Node.new :for, e, [name, block]), total ]
         end
 
-        def self.parse_op(tokens)
+        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_literal tokens
+            res = self.parse_factor tokens
+            unless res
+                return nil
+            end
+            lhs, part = res
+            total += part
+            tokens = tokens[part..-1]
+            unless self.expect tokens, :l2op
+                return [lhs, part]
+            end
+            op = tokens[0][0]
+            total += 1
+            tokens = tokens[1..-1]
+            res = self.parse_factor tokens
+            unless res
                 return nil
             end
-            lhs, part = self.parse_literal tokens
+            rhs, part = res
             total += part
-            tokens = tokens[part..tokens.size]
-            unless self.expect tokens, :op
+            tokens = tokens[part..-1]
+            out = (Node.new :op, op, [lhs])
+            while self.expect tokens, :l2op
+                op = tokens[0][0]
+                total += 1
+                tokens = tokens[1..-1]
+                res = self.parse_term tokens
+                unless res
+                    return nil
+                end
+                rhs2, part = res
+                total += part
+                tokens = tokens[part..-1]
+                rhs = Node.new :op, op, [rhs, rhs2]
+            end
+            out.children << rhs
+            [out, total]
+        end
+
+        def self.parse_op(tokens)
+            total = 0
+            res = self.parse_term tokens
+            unless res
                 return nil
             end
+            lhs, part = res
+            total += part
+            tokens = tokens[part..-1]
+            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
+            tokens = tokens[1..-1]
+            res = self.parse_term tokens
+            unless res
                 return nil
             end
-            rhs, part = self.parse_expr tokens
+            rhs, part = res
             total += part
-            return [ (Node.new :op, op, [lhs, rhs]), total]
+            tokens = tokens[part..-1]
+            out = (Node.new :op, op, [lhs])
+            while self.expect tokens, :l1op
+                op = tokens[0][0]
+                total += 1
+                tokens = tokens[1..-1]
+                res = self.parse_term tokens
+                unless res
+                    return nil
+                end
+                rhs2, part = res
+                total += part
+                tokens = tokens[part..-1]
+                rhs = Node.new :op, op, [rhs, rhs2]
+            end
+            out.children << rhs
+            [out, total]
         end
 
         def self.parse_assign(tokens)
@@ -379,19 +483,20 @@ module Parser
             end
             name = tokens[0][0]
             total += 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             unless self.expect tokens, :eq
                 return nil
             end
             eq = tokens[0][0]
             total += 1
-            tokens = tokens[1..tokens.size]
-            unless self.parse_expr tokens
+            tokens = tokens[1..-1]
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            rhs, part = self.parse_expr tokens
+            rhs, part = res
             total += part
-            return [ (Node.new :assign, eq, [name, rhs]), total]
+            [ (Node.new :assign, eq, [name, rhs]), total]
         end
 
         def self.parse_fn(tokens)
@@ -399,23 +504,23 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             unless self.expect tokens, :name
                 return nil
             end
             name = tokens[0][0]
             total += 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             unless self.expect tokens, :lpar
                 return nil
             end
             total += 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             args = []
             while true
                 if self.expect tokens, :rpar
                     total += 1
-                    tokens = tokens[1..tokens.size]
+                    tokens = tokens[1..-1]
                     break
                 end
                 unless self.expect tokens, :name
@@ -423,24 +528,25 @@ module Parser
                 end
                 args << tokens[0][0]
                 total += 1
-                tokens = tokens[1..tokens.size]
+                tokens = tokens[1..-1]
                 if self.expect tokens, :rpar
                     total += 1
-                    tokens = tokens[1..tokens.size]
+                    tokens = tokens[1..-1]
                     break
                 end
                 unless self.expect tokens, :comma
                     return nil
                 end
                 total += 1
-                tokens = tokens[1..tokens.size]
+                tokens = tokens[1..-1]
             end
-            unless self.parse_expr tokens
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            body, part = self.parse_expr tokens
+            body, part = res
             total += part
-            return [ (Node.new :fn, name, [args, body]), total ]
+            [ (Node.new :fn, name, [args, body]), total ]
         end
 
         def self.parse_object(tokens)
@@ -448,21 +554,21 @@ module Parser
                 return nil
             end
             total = 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             unless self.expect tokens, :name
                 return nil
             end
             name = tokens[0][0]
             total += 1
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             args = []
             if self.expect tokens, :lpar
                 total += 1
-                tokens = tokens[1..tokens.size]
+                tokens = tokens[1..-1]
                 while true
                     if self.expect tokens, :rpar
                         total += 1
-                        tokens = tokens[1..tokens.size]
+                        tokens = tokens[1..-1]
                         break
                     end
                     unless self.expect tokens, :name
@@ -470,40 +576,51 @@ module Parser
                     end
                     args << tokens[0][0]
                     total += 1
-                    tokens = tokens[1..tokens.size]
+                    tokens = tokens[1..-1]
                     if self.expect tokens, :rpar
                         total += 1
-                        tokens = tokens[1..tokens.size]
+                        tokens = tokens[1..-1]
                         break
                     end
                     unless self.expect tokens, :comma
                         return nil
                     end
                     total += 1
-                    tokens = tokens[1..tokens.size]
+                    tokens = tokens[1..-1]
                 end
             end
-            unless self.parse_expr tokens
+            res = self.parse_expr tokens
+            unless res
                 return nil
             end
-            body, part = self.parse_expr tokens
+            body, part = res
             total += part
-            return [ (Node.new :object, name, [args, body]), total ]
+            [ (Node.new :object, name, [args, body]), total ]
         end
 
         def self.parse_require(tokens)
             unless self.expect tokens, :require
                 return nil
             end
-            tokens = tokens[1..tokens.size]
+            tokens = tokens[1..-1]
             unless self.expect tokens, :string
                 return nil
             end
-            return [ (Node.new :require, tokens[0][0][1..-2], []), 2 ]
+            [ (Node.new :require, tokens[0][0][1..-2], []), 2 ]
         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_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)
         end
 
         def self.parse(tokens, path)
@@ -530,7 +647,7 @@ module Parser
                     else
                         parsed << e[0]
                     end
-                    tokens = tokens[e[1]..tokens.size]
+                    tokens = tokens[e[1]..-1]
                 else
                     puts "Syntax error at token ", tokens[0][1]
                     Kernel.exit 1

data/lib/sdx/vm/datatypes.rb

@@ -1,5 +1,3 @@
-require "sdx/vm/vm"
-require "sdx/vm/variables"
 require "stringio"
 
 class DataType 
@@ -341,8 +339,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 +410,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

@@ -1,10 +1,14 @@
-require 'sdx/vm/variables'
-require 'sdx/vm/datatypes'
-require 'sdx/vm/scope'
+require './lib/sdx/vm/variables'
+require './lib/sdx/vm/datatypes'
+require './lib/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
@@ -157,7 +165,8 @@ class VM
             0x36 => :lt,
             0x37 => :gt,
             0x38 => :le,
-            0x39 => :ge
+            0x39 => :ge,
+            0x28 => :pow,
         }
         bytes = []
         begin
@@ -271,12 +280,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.2.0
 platform: ruby
 authors:
 - sugarfi