atomy 0.1.1 → 0.6.3

data/kernel/control-flow.ay

@@ -1,222 +1,227 @@
-dynamic(labels, Hash new)
+use(require("core"))
+use(require("define"))
 
-macro(if(x) then(&y) else(&z)):
-  Atomy::AST::IfThenElse new(line, x, y body, z body)
+and = class:
+  def(initialize(a, b)):
+    instance-variable-set("@a", a)
+    instance-variable-set("@b", b)
 
-macro(otherwise): 'true
+  def(bytecode(gen, mod)):
+    done = gen new-label
 
-macro(condition(&bs)):
-  bs contents reverse inject('nil) [acc, `(~x -> ~y)]:
-    `(if(~x) then: ~y; else: ~acc)
+    mod compile(gen, @a)
+    gen dup
+    gen gif(done)
 
-macro(return(y)):
-  Atomy::AST::Return new(line, y)
+    gen pop
+    mod compile(gen, @b)
 
-macro(x rescue(&y)):
-  Atomy::AST::Catch new(line, x caller, y contents)
+    done set!
 
-macro(x rescue(&y) else(&z)):
-  Atomy::AST::Catch new(line, x caller, y contents, z body)
+macro(~a && ~b):
+  and new(a, b)
 
-macro(x ensuring(&y)):
-  Atomy::AST::Ensure new(line, x caller, y body)
+or = class:
+  def(initialize(a, b)):
+    instance-variable-set("@a", a)
+    instance-variable-set("@b", b)
 
-macro(when(c, &b)):
-  Atomy::AST::When new(line, c, b body)
+  def(bytecode(gen, mod)):
+    done = gen new-label
 
-macro(unless(c, &b)):
-  Atomy::AST::When new(line, `!~c, b body)
+    mod compile(gen, @a)
+    gen dup
+    gen git(done)
 
-macro(super):
-  Atomy::AST::ZSuper new(line)
+    gen pop
+    mod compile(gen, @b)
 
-macro(super(*args, &blk)):
-  Atomy::AST::Super new(line, args, blk)
+    done set!
 
-macro(yield):
-  Atomy::AST::Yield new(line, [])
+macro(~a || ~b):
+  or new(a, b)
 
-macro(yield(*args)):
-  Atomy::AST::Yield new(line, args)
+if-then-else = class:
+  def(initialize(if, then, else)):
+    instance-variable-set("@if", if)
+    instance-variable-set("@then", then)
+    instance-variable-set("@else", else)
 
-macro(break):
-  Atomy::AST::Break new(line, 'nil)
+  def(bytecode(gen, mod)):
+    else = gen new-label
+    done = gen new-label
 
-macro(break(x)):
-  Atomy::AST::Break new(line, x)
+    mod compile(gen, @if)
+    gen gif(else)
 
-macro(next):
-  Atomy::AST::Next new(line, 'nil)
+    mod compile(gen, @then)
+    gen goto(done)
 
-macro(next(x)):
-  Atomy::AST::Next new(line, x)
+    else set!
+    mod compile(gen, @else)
 
-module(Atomy::AST):
-  class(Labels < Node):
-    children([#tags])
-    generate
+    done set!
 
-    bytecode(g) := do:
-      pos(g)
+macro(if(~x) then: ~*y; else: ~*z):
+  if-then-else new(x, `(do: ~*y), `(do: ~*z))
 
-      tags = ::Hash new
+macro(when(~x): ~*y):
+  `(if(~x) then: ~*y; else: nil)
 
-      labels =
-        @tags collect [t]:
-          tags [t method-name] = g new-label
+macro(unless(~x): ~*y):
+  `(if(~x) then: nil; else: ~*y)
 
-      let(labels = tags):
-        labels zip(@tags) each [[l, t]]:
-          l set!
-          t block body bytecode(g)
-          g pop
+negate = class:
+  def(initialize(node)):
+    instance-variable-set("@node", node)
 
-      g push-nil
+  def(bytecode(gen, mod)):
+    done = gen new-label
+    yes = gen new-label
 
-  class(GoTo < Node):
-    attributes(#name)
-    generate
+    mod compile(gen, @node)
+    gen git(yes)
 
-    bytecode(g) := do:
-      pos(g)
-      g goto(^labels fetch(@name))
+    gen push-true
+    gen goto(done)
 
-  class(ZSuper < Node):
-    generate
+    yes set!
+    gen push-false
 
-    bytecode(g) := do:
-      pos(g)
+    done set!
 
-      g push-block
+macro(!~node):
+  negate new(node)
 
-      if(g state super?)
-        then:
-          g zsuper(g state super name)
-        else:
-          g zsuper(nil)
+return-class = class:
+  def(initialize(node)):
+    instance-variable-set("@node", node)
+
+  def(bytecode(gen, mod)):
+    mod compile(gen, @node)
+    gen ret
+
+macro(return): return-class new('nil)
+macro(return(~node)): return-class new(node)
+
+ensure = class:
+  def(initialize(node, ensured)):
+    instance-variable-set("@node", node)
+    instance-variable-set("@ensured", ensured)
 
-  class(Super < Node):
-    children([#arguments], #block?)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-
-      block = @block
-      splat = nil
-
-      args = 0
-      @arguments each [a]:
-        e = a prepare
-        e match:
-          BlockPass -> do:
-            block =! e
-            -- break
-
-          Splat -> do:
-            splat =! e
-            -- break
-
-          _ -> do:
-            e bytecode(g)
-            args += 1
-
-      when(splat):
-        splat compile(g)
-        g cast-array
-
-      if(block)
-        then: block compile(g)
-        else: g push-nil
-
-      g send-super(nil, args, splat)
-
-  class(Yield < Node):
-    children([#arguments])
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-
-      splat = nil
-
-      args = 0
-      @arguments each [a]:
-        e = a prepare
-        e match:
-          Splat -> do:
-            splat =! e
-            -- break
-
-          _ -> do:
-            e bytecode(g)
-            args += 1
-
-      if(splat)
-        then:
-          splat compile(g)
-          g cast-array
-          g yield-splat(args)
-        else:
-          g yield-stack(args)
-
-  class(Break < Node):
-    children(#value)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-      @value compile(g)
-      g raise-break
-
-  class(Next < Node):
-    children(#value)
-    generate
-
-    bytecode(g) := do:
-      pos(g)
-      @value compile(g)
-      g ret
-
-macro(labels(&body)):
-  `(let-macro(go(name) = Atomy::AST::GoTo new(line, name name)):
-      ~(Atomy::AST::Labels new(line, body contents)))
-
-macro(while(test, &body)):
-  names [loop, done]:
-    `(let-macro(break = 'go(~done),
-                next = 'go(~loop)):
-        labels:
-          ~loop:
-            unless(~test):
-              go(~done)
-
-            ~(body caller)
-            go(~loop)
-
-          ~done {})
-
-macro(until(test, &body)):
-  names [loop, done]:
-    `(let-macro(break = 'go(~done),
-                next = 'go(~loop)):
-        labels:
-          ~loop:
-            when(~test):
-              go(~done)
-
-            ~(body caller)
-            go(~loop)
-
-          ~done {})
-
-macro(loop(&body)):
-  names [loop, done]:
-    `(let-macro(break = 'go(~done),
-                next = 'go(~loop)):
-        labels:
-          ~loop:
-            ~(body caller)
-            go(~loop)
-
-          ~done {})
+  -- TODO: this is pretty barebones compared to:
+  -- https://github.com/rubinius/rubinius-ast/blob/aa5ff6260a7647a9ef1035feb66b6d4b632d4211/lib/rubinius/ast/exceptions.rb
+  -- i'd rather prove out the complexity than blindly mirror it
+  def(bytecode(gen, mod)):
+    ok = gen new-label
+    ex = gen new-label
+
+    gen setup-unwind(ex, 1) -- EnsureType
+
+    mod compile(gen, @node)
+
+    gen pop-unwind
+    gen goto(ok)
+
+    ex set!
+    gen push-exception-state
+    mod compile(gen, @ensured)
+    gen pop
+    gen restore-exception-state
+    gen reraise
+
+    ok set!
+    mod compile(gen, @ensured)
+    gen pop
+
+macro(~node ensuring: ~*ensured):
+  ensure new(node, `(do: ~*ensured))
+
+macro(~(x & Word) ||= ~y): `(&~x = (~x || ~y))
+macro(~(x & Word) &&= ~y): `(&~x = (~x && ~y))
+
+macro(~x ||= ~y): `(~x = (~x || ~y))
+macro(~x &&= ~y): `(~x = (~x && ~y))
+
+super-code = class:
+  def(initialize(form)):
+    structure = Atomy MessageStructure new(form)
+    instance-variable-set("@arguments", structure arguments)
+    instance-variable-set("@splat_argument", structure splat-argument)
+    instance-variable-set("@proc_argument", structure proc-argument)
+    instance-variable-set("@block", structure block)
+
+  def(bytecode(gen, mod)):
+    @arguments each [a]:
+      mod compile(gen, a)
+
+    when(@splat-argument):
+      mod compile(gen, @splat-argument)
+      gen cast-array
+
+    if(@block)
+      then:
+        mod compile(
+          gen
+          Atomy Code Block new(
+            `(do: ~*(@block body))
+            @block arguments
+            nil
+            false
+          )
+        )
+      else:
+        if(@proc-argument)
+          then: push-proc-argument(gen, mod)
+          else: gen push-nil
+
+    gen send-super(nil, @arguments size, !!@splat-argument)
+
+  def(push-proc-argument(gen, mod)):
+    nil-proc-arg = gen new-label
+    mod compile(gen, @proc-argument)
+    gen dup
+    gen is-nil
+    gen git(nil_proc_arg)
+    gen push-cpath-top
+    gen find-const(.Proc)
+    gen swap
+    gen send(.__from_block__, 1)
+    nil-proc-arg set!
+
+macro(super): super-code new('super)
+macro(super(~*args)): super-code new(`super(~*args))
+macro(super &~blk): super-code new(`(super &~blk))
+macro(super: ~*blk): super-code new(`(super: ~*blk))
+macro(super [~*bargs]: ~*blk): super-code new(`(super [~*bargs]: ~*blk))
+macro(super(~*args) &~blk): super-code new(`(super(~*args) &~blk))
+macro(super(~*args): ~*blk): super-code new(`(super(~*args): ~*blk))
+macro(super(~*args) [~*bargs]: ~*blk): super-code new(`(super(~*args) [~*bargs]: ~*blk))
+
+break-class = class:
+  def(initialize(value)):
+    instance-variable-set("@value", value)
+
+  def(bytecode(gen, mod)):
+    mod compile(gen, @value)
+    gen raise-break
+
+macro(break): break-class new('nil)
+macro(break(~value)): break-class new(value)
+
+next-class = class:
+  def(initialize(value)):
+    instance-variable-set("@value", value)
+
+  def(bytecode(gen, mod)):
+    mod compile(gen, @value)
+    gen ret
+
+macro(next): next-class new('nil)
+macro(next(~value)): next-class new(value)
+
+macro(condition: ~*branches):
+  branches reverse inject('nil) [else, `(~cond: ~*branch)]:
+    if(cond == 'otherwise)
+      then: `(do: ~*branch)
+      else: `(if(~cond) then: ~*branch; else: ~else)

data/kernel/core.ay

@@ -0,0 +1,120 @@
+-- a macro for defining macros!
+evaluate(macro-definer(
+  '`(macro(~pat): ~*body)
+  'macro-definer(make-quasiquote(pat), make-sequence(body))))
+
+-- pattern definition
+macro(pattern(~pat): ~*body):
+  pattern-definer(make-quasiquote(pat), make-sequence(body))
+
+-- sequences
+macro(do: ~*nodes):
+  make-sequence(nodes)
+
+-- constant scoping
+macro(~parent ~(name & Constant)):
+  make-constant(name text, parent)
+
+-- booleans
+macro(false): Atomy Code False new
+macro(true): Atomy Code True new
+
+-- nils
+macro(nil): Atomy Code Nil new
+
+-- undefined
+macro(_): Atomy Code Undefined new
+
+-- symbols
+macro(.~(sym & Word)): Atomy Code Symbol new(sym text)
+macro(.(~(sym & Word))!): Atomy Code Symbol new((sym text to-s + "!") to-sym)
+macro(.(~(sym & Word))?): Atomy Code Symbol new((sym text to-s + "?") to-sym)
+macro(.~(sym & Constant)): Atomy Code Symbol new(sym text)
+macro(.~(str & StringLiteral)): Atomy Code Symbol new(str value to-sym)
+macro(.[]): Atomy Code Symbol new("[]" to-sym)
+macro(.[]=): Atomy Code Symbol new("[]=" to-sym)
+
+-- assignment
+macro(~pat = ~val):
+  Atomy Code Assign new(pat, val)
+
+-- block literals
+macro({ ~*body }):
+  Atomy Code Block new(`(do: ~*body))
+
+macro([~*args]: ~*body):
+  Atomy Code Block new(`(do: ~*body), args)
+
+macro(&~blk { ~*body }):
+  Atomy Code Block new(`(do: ~*body), [], blk)
+
+macro([~*args] &~blk { ~*body }):
+  Atomy Code Block new(`(do: ~*body), args, blk)
+
+-- toplevel constant access
+macro(//~(name & Constant)):
+  Atomy Code Constant new(name text, 'Object)
+
+-- accessing instance variables
+macro(@~(name & Word)):
+  Atomy Code InstanceVariable new(name text)
+
+macro(@(~(name & Word))!):
+  Atomy Code InstanceVariable new((name text to-s + "!") to-sym)
+
+macro(@(~(name & Word))?):
+  Atomy Code InstanceVariable new((name text to-s + "?") to-sym)
+
+-- accessing class variables
+macro(@@~(name & Word)):
+  Atomy Code ClassVariable new(name text)
+
+macro(@@(~(name & Word))!):
+  Atomy Code ClassVariable new((name text to-s + "!") to-sym)
+
+macro(@@(~(name & Word))?):
+  Atomy Code ClassVariable new((name text to-s + "?") to-sym)
+
+-- accessing global variables
+macro($~(name & Word)):
+  `(//Rubinius Globals[~(Atomy Code Symbol new(("$" + name text to-s) to-sym))])
+
+macro($(~(name & Word))?):
+  `(//Rubinius Globals[~(Atomy Code Symbol new(("$" + (name text to-s + "?")) to-sym))])
+
+macro($(~(name & Word))!):
+  `(//Rubinius Globals[~(Atomy Code Symbol new(("$" + (name text to-s + "!")) to-sym))])
+
+macro($~(name & Constant)):
+  `(//Rubinius Globals[~(Atomy Code Symbol new(("$" + name text to-s) to-sym))])
+
+macro($~(name & StringLiteral)):
+  `(//Rubinius Globals[~(Atomy Code Symbol new(("$" + name value to-s) to-sym))])
+
+-- foo! access/sending
+macro((~(msg & Word))!):
+  Atomy Code Variable new((msg text to-s + "!") to-sym)
+
+-- foo? access/sending
+macro((~(msg & Word))?):
+  Atomy Code Variable new((msg text to-s + "?") to-sym)
+
+-- pattern for assigning foo!
+pattern((~(name & Word))!):
+  Atomy Code Pattern Wildcard new((name text to-s + "!") to-sym)
+
+-- pattern for assigning foo?
+pattern((~(name & Word))?):
+  Atomy Code Pattern Wildcard new((name text to-s + "?") to-sym)
+
+-- pattern for re-assigning existing local
+pattern(&(~(name & Word))):
+  Atomy Code Pattern Wildcard new(name text, true)
+
+-- pattern for re-assigning existing local ending in !
+pattern(&(~(name & Word))!):
+  Atomy Code Pattern Wildcard new((name text to-s + "!") to-sym, true)
+
+-- pattern for re-assigning existing local ending in ?
+pattern(&(~(name & Word))?):
+  Atomy Code Pattern Wildcard new((name text to-s + "?") to-sym, true)