atomy 0.1.1

data/kernel/control-flow.ay

@@ -0,0 +1,222 @@
+dynamic(labels, Hash new)
+
+macro(if(x) then(&y) else(&z)):
+  Atomy::AST::IfThenElse new(line, x, y body, z body)
+
+macro(otherwise): 'true
+
+macro(condition(&bs)):
+  bs contents reverse inject('nil) [acc, `(~x -> ~y)]:
+    `(if(~x) then: ~y; else: ~acc)
+
+macro(return(y)):
+  Atomy::AST::Return new(line, y)
+
+macro(x rescue(&y)):
+  Atomy::AST::Catch new(line, x caller, y contents)
+
+macro(x rescue(&y) else(&z)):
+  Atomy::AST::Catch new(line, x caller, y contents, z body)
+
+macro(x ensuring(&y)):
+  Atomy::AST::Ensure new(line, x caller, y body)
+
+macro(when(c, &b)):
+  Atomy::AST::When new(line, c, b body)
+
+macro(unless(c, &b)):
+  Atomy::AST::When new(line, `!~c, b body)
+
+macro(super):
+  Atomy::AST::ZSuper new(line)
+
+macro(super(*args, &blk)):
+  Atomy::AST::Super new(line, args, blk)
+
+macro(yield):
+  Atomy::AST::Yield new(line, [])
+
+macro(yield(*args)):
+  Atomy::AST::Yield new(line, args)
+
+macro(break):
+  Atomy::AST::Break new(line, 'nil)
+
+macro(break(x)):
+  Atomy::AST::Break new(line, x)
+
+macro(next):
+  Atomy::AST::Next new(line, 'nil)
+
+macro(next(x)):
+  Atomy::AST::Next new(line, x)
+
+module(Atomy::AST):
+  class(Labels < Node):
+    children([#tags])
+    generate
+
+    bytecode(g) := do:
+      pos(g)
+
+      tags = ::Hash new
+
+      labels =
+        @tags collect [t]:
+          tags [t method-name] = g new-label
+
+      let(labels = tags):
+        labels zip(@tags) each [[l, t]]:
+          l set!
+          t block body bytecode(g)
+          g pop
+
+      g push-nil
+
+  class(GoTo < Node):
+    attributes(#name)
+    generate
+
+    bytecode(g) := do:
+      pos(g)
+      g goto(^labels fetch(@name))
+
+  class(ZSuper < Node):
+    generate
+
+    bytecode(g) := do:
+      pos(g)
+
+      g push-block
+
+      if(g state super?)
+        then:
+          g zsuper(g state super name)
+        else:
+          g zsuper(nil)
+
+  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 {})

data/kernel/cosmetics.ay

@@ -0,0 +1,3 @@
+`($~(x: Atomy::AST::Block)) as-message(send) :=
+  send receiver to-send dup tap [s]:
+    s arguments += x contents

data/kernel/data-delta.ay

@@ -0,0 +1,105 @@
+namespace(atomy)
+
+macro(data(root, &children)):
+  cs = children contents map [e]:
+    e match:
+      Atomy::AST::Send -> do:
+        name =
+          Atomy::AST::Constant new(0, e method-name)
+
+        pat = name
+
+        tmps = names(e arguments size) collect [t]:
+          Atomy::AST::Unquote new(0, t)
+
+        e arguments zip(tmps) [[a, t]]:
+          pat =! `(~pat & with(~a, ~t))
+
+        cons = `(~(name)(~*tmps))
+
+        pat-def =
+          `(~(Atomy::AST::QuasiQuote new(0, cons)) pattern :=
+              ~(Atomy::AST::QuasiQuote new(0, pat)) pattern)
+
+        define =
+          `(export:
+              class(~name < ~root):
+                attr-accessor $:
+                  ~*(e arguments collect [a]:
+                      `#~(a receiver))
+
+                initialize(~*(e arguments)) := nil
+
+              ~pat-def)
+
+        if(e block)
+          then:
+            `(do:
+                ~define
+
+                data(~name):
+                  ~*(e block contents))
+          else:
+            define
+
+      Atomy::AST::Constant ->
+        `(class(~e < ~root):)
+
+      Atomy::AST::ScopedConstant ->
+        `(class(~e < ~root):)
+
+      Atomy::AST::ToplevelConstant ->
+        `(class(~e < ~root):)
+
+      _ -> raise("unknown module name: " + e to-s)
+
+  `(do: class(~root):;, ~*cs, nil)
+
+
+macro(macro-quoter(n, &x)):
+  `(evaluate-when(compile, load):
+      Atomy::Macro::Environment quoter(#~n, &~x))
+
+macro-quoter(w) [c]: c split
+
+macro-quoter(r) [c, fs]:
+  flags = 0
+
+  when(fs include?("m")):
+    flags |= Regexp::MULTILINE
+
+  when(fs include?("i")):
+    flags |= Regexp::IGNORECASE
+
+  when(fs include?("x")):
+    flags |= Regexp::EXTENDED
+
+  when(fs include?("u")):
+    flags |= Regexp::KCODE_UTF8
+
+  `(Regexp new(~c, ~flags))
+
+macro-quoter(raw) [c]: c
+
+macro(_undefined):
+  Atomy::AST::Undefined new(line)
+
+macro($(x: Primitive ? @value is-a?(::Integer) && @value > 0)):
+  Atomy::AST::NthRef new(line, x value)
+
+export:
+  module(Atomy::AST):
+    class(Undefined < Node):
+      generate
+
+      bytecode(g) := do:
+        pos(g)
+        g push-undef
+
+      pattern := Atomy::Patterns::Any new
+
+    class(NthRef < Rubinius::AST::NthRef):
+      include(NodeLike)
+      extend(SentientNode)
+      attributes(#which)
+      generate

data/kernel/data.ay

@@ -0,0 +1,56 @@
+macro(&x):
+  Atomy::AST::BlockPass new(x line, x)
+
+macro(*x):
+  Atomy::AST::Splat new(x line, x)
+
+macro(@(x: Variable)):
+  Atomy::AST::InstanceVariable new(x line, x name)
+
+macro(@@(x: Variable)):
+  Atomy::AST::ClassVariable new(x line, x name)
+
+macro($'exception):
+  Atomy::AST::GlobalVariable new(line, "!")
+
+macro($'path):
+  Atomy::AST::GlobalVariable new(line, ":")
+
+macro($'separator):
+  Atomy::AST::GlobalVariable new(line, "/")
+
+macro($'0):
+  Atomy::AST::GlobalVariable new(line, "0")
+
+macro($(x: String)):
+  Atomy::AST::GlobalVariable new(line, x value)
+
+macro($(x: Constant)):
+  Atomy::AST::GlobalVariable new(x line, x identifier)
+
+macro($(x: Variable)):
+  Atomy::AST::GlobalVariable new(x line, x name)
+
+macro(#(x: Constant)):
+  Atomy::AST::Particle new(x line, x identifier)
+
+macro(#(x: Variable)):
+  Atomy::AST::Particle new(x line, x name)
+
+macro(#(x: String)):
+  Atomy::AST::Particle new(x line, x value)
+
+macro(#(x: Primitive)):
+  Atomy::AST::Particle new(x line, x value to-s)
+
+macro(a .. b): `(Range new(~a, ~b))
+macro(a ... b): `(Range new(~a, ~b, true))
+
+macro(x for(e) in(c)): `(~c collect [~e]: ~x)
+
+macro(x for(e) in(c) if(t)):
+  names [tmp]:
+    `([] tap [~tmp]:
+        ~c each [~e]:
+          when(~t):
+            ~tmp << ~x)

data/kernel/define.ay

@@ -0,0 +1,93 @@
+macro(do(&b)): b body
+
+macro(x = y):
+  Atomy::AST::Assign new(x line, x, y)
+
+macro(x =! y):
+  Atomy::AST::Set new(x line, x, y)
+
+macro(x := y):
+  where = Atomy::Namespace define-target
+  Atomy::Namespace register(x namespace-symbol, where)
+
+  Atomy::CodeLoader when-load <<
+    [`(Atomy::Namespace register(~(x namespace-symbol), ~where)), true]
+
+  Atomy::AST::Define new(x line, x, y, where)
+
+macro(define(x, &y)):
+  `(~x := ~(y block-body))
+
+macro(x **= y): `(~x =! (~x ** ~y))
+macro(x *= y): `(~x =! (~x * ~y))
+macro(x <<= y): `(~x =! (~x << ~y))
+macro(x >>= y): `(~x =! (~x >> ~y))
+macro(x &&= y): `(~x =! (~x && ~y))
+macro(x &= y): `(~x =! (~x & ~y))
+macro(x ||= y): `(~x =! (~x || ~y))
+macro(x |= y): `(~x =! (~x | ~y))
+macro(x += y): `(~x =! (~x + ~y))
+macro(x -= y): `(~x =! (~x - ~y))
+macro(x /= y): `(~x =! (~x / ~y))
+macro(x ^= y): `(~x =! (~x ^ ~y))
+macro(x %= y): `(~x =! (~x % ~y))
+
+macro(x match(&b)):
+  Atomy::AST::Match new(line, x, b)
+
+macro(class(`(<< ~obj), &body)):
+  Atomy::AST::SingletonClass new(obj line, obj, body block-body)
+
+macro(class(`(~name < ~sup), &body)):
+  Atomy::AST::Class new(name line, name, body block-body, sup)
+
+macro(class(name, &body)):
+  Atomy::AST::Class new(name line, name, body block-body)
+
+macro(module(name, &body)):
+  Atomy::AST::Module new(name line, name, body block-body)
+
+macro(evaluate-when('compile, 'run, 'load, &x)):
+  x body evaluate
+  Atomy::CodeLoader when-load << [x block-body, true]
+  `(when(!(Atomy::CodeLoader compiled?) &&
+          Atomy::CodeLoader reason == #run):
+      ~*(x contents))
+
+macro(evaluate-when('run, 'compile, &x)):
+  x body evaluate
+  `(when(!(Atomy::CodeLoader compiled?) &&
+           Atomy::CodeLoader reason == #run):
+      ~*(x contents))
+
+macro(evaluate-when('compile, 'run, &x)):
+  x body evaluate
+  `(when(!(Atomy::CodeLoader compiled?) &&
+           Atomy::CodeLoader reason == #run):
+      ~*(x contents))
+
+macro(evaluate-when('compile, 'load, &x)):
+  x body evaluate
+  Atomy::CodeLoader when-load << [x block-body, true]
+  'nil
+
+macro(evaluate-when('compile, &x)):
+  x body evaluate
+  'nil
+
+macro(evaluate-when('run, &x)):
+  `(when(Atomy::CodeLoader reason == #run) { ~*(x contents) })
+
+macro(evaluate-when('load, &x)):
+  Atomy::CodeLoader when-load << [x block-body, false]
+  'nil
+
+macro(for-macro(&b)):
+  `(evaluate-when(compile, load):
+      ~b block call-on-instance(Atomy::Macro::Environment singleton-class))
+
+macro(let-macro(*ms, &body)):
+  macros = ms collect [`(~p = ~b)]:
+    Atomy::AST::Macro new(p line, p, b)
+
+  Atomy::AST::LetMacro new(line, body caller, macros)