sardonyx 0.1.843 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: babd36be28fd243f8478626b5e9a2d878d9b02d079a2f575a51629af835f4dcb
-  data.tar.gz: 970de1b558e7f9d98becfdc0aaafe51398f8c84dd47066b384fc7fd3c66d3a5e
+  metadata.gz: b28cfaca2d8790be84bad3e1f6bffd5ead67aeaa6be749643a68828530b68bbe
+  data.tar.gz: 92a7ea6bccf98cf8099fbe8665e20c1a6548c6c7fe4a7c92289ce8dda7ca6393
 SHA512:
-  metadata.gz: 50b2b42da15041685758cf5e07e9d6e7d7f90685d0c15bb0ac35788a938a7213e8dd5bed01a4a570a8ddd954b0e995a8a1bd8773653d323e7c0efb22f2657c71
-  data.tar.gz: e428e7703e824dfb3dfc5510c9fcaf707df710947af0dc0f8646bd64c0cfd5c90621a29d29d9b4fc92a1dd6d19be83548cf832711e58667b3870c74baaadbc71
+  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/parser.rb

@@ -11,11 +11,12 @@ module Parser
             /\Anew/ => :new,
             /\Arequire/ => :require,
             /\A(true|false)/ => :bool,
-            /\A(<|>|<=|>=|==|!=)/ => :op,
-            /\A(\+|-|\*|\/|%)?=/ => :eq,
-            /\A(\+|-|\*|\/|%)/ => :op,
-            /\A-?[0-9]+/ => :number,
             /\A-?[0-9]+\.[0-9]+/ => :float,
+            /\A-?[0-9]+/ => :number,
+            /\A(\+|-)/ => :l1op,
+            /\A(\/|\*|%|\^)/ => :l2op,
+            /\A(<|>|<=|>=|==|!=)/ => :l1op,
+            /\A(\+|-|\*|\/|%)?=/ => :eq,
             /\A"([^"]|\\")*"/ => :string,
             /\Anil/ => :nil,
             /\A\(/ => :lpar,
@@ -124,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]
@@ -143,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
@@ -151,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
@@ -166,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
@@ -175,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
@@ -187,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
@@ -198,41 +202,52 @@ module Parser
         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_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
@@ -245,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
@@ -287,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)
@@ -318,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)
@@ -338,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 = self.parse_literal tokens
+            lhs, part = res
             total += part
-            tokens = tokens[part..tokens.size]
-            unless self.expect tokens, :op
+            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
+            rhs, part = res
+            total += part
+            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)
@@ -388,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)
@@ -408,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
@@ -432,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)
@@ -457,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
@@ -479,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)
@@ -539,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 

data/lib/sdx/vm/vm.rb

@@ -1,6 +1,6 @@
-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"]
@@ -165,7 +165,8 @@ class VM
             0x36 => :lt,
             0x37 => :gt,
             0x38 => :le,
-            0x39 => :ge
+            0x39 => :ge,
+            0x28 => :pow,
         }
         bytes = []
         begin

metadata

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