RubyGems - sardonyx - Versions diffs - 0.1.85 → 0.2.1 - Mend

sardonyx 0.1.85 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

checksums.yaml +4 -4
data/bin/sdx +1 -1
data/lib/sdx/compiler/parser.rb +186 -101
data/lib/sdx/vm/datatypes.rb +0 -2
data/lib/sdx/vm/vm.rb +2 -1
metadata +1 -1

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c24e6115400ff31393984b7220c4226ea6f6a4fc8f9ba146f8d9f3ce51f749b
-  data.tar.gz: e1b92b4d17872047f11fe869d988370898dbebc74f5fe2ba4cb5e8d0ede648ec
+  metadata.gz: 3b18e4b27873132c4a3c503bdd971322516681b0766d2de32c4937bfb502a0e6
+  data.tar.gz: 32ab2476bb7f1f98fee2860e721f52e3ef38e8e739652b28a74c68a6889fca47
 SHA512:
-  metadata.gz: c87037ad33284bec4da7576040d214a45978ab5e018c5ef62152a2ae31858484df6f5f2e7899d6b29f9618a875d145f45960aa8c1efa22b97e60ff661b579eea
-  data.tar.gz: 2ed22a60d030ac9236075a3f97d992956753dc9c3cda125783f3e05f5c74c9d20ce3fe84a848b96b7933b2063efc9d1dd9a899f95d26957050dd7979de75d957
+  metadata.gz: eaa1ca5fa9355b8a351556aaae7f8b997f5cd0cc22ce66bce333b21f819a9c950c1ac98ebed53d4f19bf522844ed61221b57b04dedf710974fb743b32d28fe0b
+  data.tar.gz: 9c950d38de0816ab641f36cdfbf05d958460b97b97b23ba7331c38f836cafef13102bfdf0ca16f5bcfcc89dda4d00923a83bdaffc1cd0e183c2c6da4319aabe5

data/bin/sdx CHANGED

@@ -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 CHANGED

@@ -14,7 +14,7 @@ module Parser
             /\A-?[0-9]+\.[0-9]+/ => :float,
             /\A-?[0-9]+/ => :number,
             /\A(\+|-)/ => :l1op,
-            /\A(\/|\*|%)/ => :l2op,
+            /\A(\/|\*|%|\^)/ => :l2op,
             /\A(<|>|<=|>=|==|!=)/ => :l1op,
             /\A(\+|-|\*|\/|%)?=/ => :eq,
             /\A"([^"]|\\")*"/ => :string,
@@ -125,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]
@@ -144,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
@@ -152,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
@@ -167,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
@@ -176,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
@@ -188,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
@@ -199,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
@@ -246,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
@@ -288,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)
@@ -319,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)
@@ -339,69 +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_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]
+            tokens = tokens[part..-1]
             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
+            tokens = tokens[1..-1]
+            res = self.parse_factor tokens
+            unless res
                 return nil
             end
-            rhs, part = self.parse_literal 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, :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
-            unless self.parse_term tokens
+            res = self.parse_term tokens
+            unless res
                 return nil
             end
-            lhs, part = self.parse_term tokens
+            lhs, part = res
             total += part
-            tokens = tokens[part..tokens.size]
+            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_term tokens
+            tokens = tokens[1..-1]
+            res = self.parse_term tokens
+            unless res
                 return nil
             end
-            rhs, part = self.parse_term 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)
@@ -411,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)
@@ -431,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
@@ -455,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)
@@ -480,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
@@ -502,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_term 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)
@@ -562,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 CHANGED

@@ -1,5 +1,3 @@
-require "sdx/vm/vm"
-require "sdx/vm/variables"
 require "stringio"
 class DataType

data/lib/sdx/vm/vm.rb CHANGED

@@ -165,7 +165,8 @@ class VM
             0x36 => :lt,
             0x37 => :gt,
             0x38 => :le,
-            0x39 => :ge
+            0x39 => :ge,
+            0x28 => :pow,
         }
         bytes = []
         begin

metadata CHANGED

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