atomy 0.1.1 → 0.6.3

data/kernel/dynamic.ay

@@ -1,42 +1,38 @@
-Atomy::DYNAMIC_ROOTS = Hash new
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+use(require("data"))
+use(require("hash"))
 
-for-macro:
-  key(n) :=
-    Atomy::AST::Variable new $:
-      n line
-      "atomy_" + n resolve message-name
+stack-local = require("stack-local")
 
-  dynvar(x) :=
-    `(Thread current [#~key(x)] || Atomy::DYNAMIC_ROOTS [#~x])
+data(Dynvar(@default))
 
-  set-dynvar(n, v) :=
-    `(Thread current [#~key(n)] = ~v)
+def(^Dynvar): values fetch(Thread current): @default
+def(Dynvar get): values fetch(Thread current): _
+def(Dynvar set(x)):
+  if(x == _)
+    then: values delete(Thread current)
+    else: values[Thread current] = x
 
-macro(dynamic(n, root)):
-  where = Atomy::Namespace define-target
+-- TODO: this should be private
+def(Dynvar values): @values = (@values || #{})
 
-  Atomy::Namespace register(n namespace-symbol, where)
+macro(dynamic): `dynamic(_)
+macro(dynamic(~default)): `(Dynvar new(~default))
 
-  Atomy::CodeLoader when-load <<
-    [`(Atomy::Namespace register(~(n namespace-symbol), ~where)), true]
+macro(with(~*bindings): ~*body):
+  tmps = bindings collect [b]: [b, stack-local Local new]
 
-  `(Atomy::DYNAMIC_ROOTS [#~n] = ~root)
+  save = tmps collect [`(~n = ~_), tmp]: tmp set(`(~n get))
 
-macro(^x): dynvar(x)
+  set = bindings collect [`(~n = ~v)]: `(~n set(~v))
 
-macro(let(*bindings, &body)):
-  tmps = names(bindings size)
-  save = []
-  set = []
-  restore = []
-
-  bindings zip(tmps) [[`(~n = ~v), tmp]]:
-    save << `(~tmp = ~(dynvar(n)))
-    set << set-dynvar(n, v)
-    restore << set-dynvar(n, tmp)
+  restore = tmps collect [`(~n = ~_), tmp]: `(~n set(~tmp))
 
   `(do:
       ~*save
-      { ~*set
-        ~(body caller)
+      do {
+        ~*set
+        ~*body
       } ensuring: ~*restore)

data/kernel/file.ay

@@ -0,0 +1,9 @@
+use(require("core"))
+use(require("define"))
+
+file = class:
+  def(bytecode(gen, mod)):
+    gen push-scope
+    gen send(.active-path, 0)
+
+macro(__FILE__): file new

data/kernel/grammar.ay

@@ -0,0 +1,267 @@
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+use(require("dynamic"))
+use(require("particles"))
+
+stack-local = require("stack-local")
+
+require("kpeg")
+require("kpeg/compiled_parser")
+require("rubinius/processor") -- needed by compiler
+require("rubinius/melbourne") -- needed by compiler
+require("rubinius/compiler")
+require("set")
+
+
+-- lazily load these modules to prevent circular dependency
+loaded-pretty = nil
+fn(pretty): &loaded-pretty = (loaded-pretty || require("pretty"))
+
+loaded-interpolation = nil
+fn(intp): &loaded-interpolation = (loaded-interpolation || require("interpolation"))
+
+
+actions = dynamic
+setups = dynamic
+vars = dynamic
+rule = dynamic
+rule-vars = dynamic
+
+fn(const-name(c & Atomy Grammar AST Compose)): [const-name(c left), "::", const-name(c right)] join
+fn(const-name(c & Atomy Grammar AST Constant)): c text to-s
+
+fn(process-val(g, `(%(~grammar)(~name)(~*args)))):
+  `(~g foreign-invoke(
+      .~grammar
+      .~name
+      ~(args collect &.(pretty show(_)) join(", "))))
+
+fn(process-val(g, `(%(~grammar)(~name)))):
+  `(~g foreign-invoke(.~grammar, .~name))
+
+fn(process-val(g, `((~name)=(~v)))):
+  val = process-val(g, v)
+
+  when(^rule-vars):
+    ^rule-vars << name text
+
+  `(~g t(~val, ~(Atomy Grammar AST StringLiteral new(name text to-s))))
+
+fn(process-val(g, `(~a ~b))):
+  `(~g seq(~process-val(g, a), ~process-val(g, b)))
+
+fn(process-val(g, `(~a | ~b))):
+  process-val(g, `[~a, ~b])
+
+fn(process-val(g, `[~*xs])):
+  original = ^rule-vars
+  new = Set new
+  choices =
+    xs collect [x]:
+      with(rule-vars = original dup):
+        choice = process-val(g, x)
+        new merge(^rule-vars - original)
+        choice
+
+  ^rule-vars merge(new)
+
+  `(~g any(~*choices))
+
+fn(process-val(g, a & `{ ~*bs })):
+  if(^actions)
+    then:
+      vars = ^rule-vars to-a
+
+      call = [
+        "actions["
+        ^actions size to-s
+        "]["
+        vars collect &.to-s join(", ")
+        "]"
+      ] join
+
+      ^actions << [a, vars]
+      `(~g action(~(Atomy Grammar AST StringLiteral new(call))))
+    else:
+      `(~g action({ ~*bs }))
+
+fn(process-val(g, `(<(~x)>))):
+  val = process-val(g, x)
+
+  when(^rule-vars):
+    ^rule-vars << .text
+
+  `(~g collect(~val))
+
+fn(process-val(g, `(@<(~x)>))):
+  `(~g bounds(~process-val(g, x)))
+
+fn(process-val(g, `((~v)?))):
+  `(~g maybe(~process-val(g, v)))
+
+fn(process-val(g, `((~v)+))):
+  `(~g many(~process-val(g, v)))
+
+fn(process-val(g, `((~v)*))):
+  `(~g kleene(~process-val(g, v)))
+
+fn(process-val(g, `&~v)):
+  `(~g andp(~process-val(g, v)))
+
+fn(process-val(g, `!~v)):
+  `(~g notp(~process-val(g, v)))
+
+fn(process-val(g, '_)):
+  `(~g dot)
+
+fn(process-val(g, `(/(~(b & Atomy Grammar AST StringLiteral))/))):
+  if(^actions)
+    then:
+      vars = ^rule-vars to-a
+
+      -- this is a bit gross because it has to parse as a valid regexp
+      -- so we use .call() because actions[0][] is invalid
+      --
+      -- should be fine as the embedded parts are limited to numbers and words
+      call = [
+        "#{actions["
+        ^actions size to-s
+        "].call("
+        vars collect &.to-s join(", ")
+        ")}"
+      ] join
+
+      ^actions << [`{ ~(intp interpolated(b value)) }, vars]
+
+      `(~g reg(~(Atomy Grammar AST StringLiteral new(call))))
+    else:
+      `(~g reg(r~b))
+
+fn(process-val(g, s & Atomy Grammar AST StringLiteral)):
+  `(~g str(~s))
+
+fn(process-val(g, w & Atomy Grammar AST Word)):
+  `(~g ref(~(Atomy Grammar AST StringLiteral new(w text to-s))))
+
+fn(process-val(g, `@~(w & Atomy Grammar AST Word))):
+  `(~g invoke(~(Atomy Grammar AST StringLiteral new(w text to-s))))
+
+fn(process-val(g, `^~(w & Atomy Grammar AST Word))):
+  `(~g foreign-invoke("parent", ~(Atomy Grammar AST StringLiteral new(w text to-s))))
+
+fn(process-val(g, c & Atomy Grammar AST Apply)):
+  args = [
+    "("
+    c arguments collect &.(pretty show(_)) join(", ")
+    ")"
+  ] join
+
+  `(~g ref(~(Atomy Grammar AST StringLiteral new(c node text to-s)), nil, ~(Atomy Grammar AST StringLiteral new(args))))
+
+fn(process-val(g, `@~(c & Atomy Grammar AST Apply))):
+  args = [
+    "("
+    c arguments collect &.(pretty show(_)) join(", ")
+    ")"
+  ] join
+
+  `(~g invoke(~(Atomy Grammar AST StringLiteral new(c node text to-s)), ~(Atomy Grammar AST StringLiteral new(args))))
+
+fn(process-val(g, `^~(c & Atomy Grammar AST Apply))):
+  args = [
+    "("
+    c arguments collect &.(pretty show(_)) join(", ")
+    ")"
+  ] join
+
+  `(~g foreign-invoke("parent", ~(Atomy Grammar AST StringLiteral new(c node text to-s)), ~(Atomy Grammar AST StringLiteral new(args))))
+
+fn(process-val(_, s)):
+  raise(ArgumentError, "unknown parsing operator:\n" + s inspect)
+
+parser-definer = class:
+  def(initialize(@source)) {}
+
+  def(bytecode(gen, mod)):
+    gen push-rubinius
+    gen push-literal(.__parser_init__)
+    gen push-literal(CodeTools Compiler compile-string(@source))
+    gen push-scope
+    gen push-self
+    gen send(.attach-method, 4)
+    gen pop
+
+    gen push-self
+    gen send(.__parser_init__, 0)
+
+
+fn(process-toplevel(grammar, `%%{ ~*xs })):
+  call =
+    if(^setups)
+      then:
+        ^setups << `{ ~*xs }
+        Atomy Grammar AST StringLiteral new(["setups[", (^setups size - 1) to-s, "][]"] join)
+      else:
+        `{ ~*xs }
+
+  `(~grammar add-setup(~grammar action(~call)))
+
+fn(process-toplevel(grammar, `(%~name = ~const))):
+  `(~grammar add-foreign-grammar(
+      ~(Atomy Grammar AST StringLiteral new(name text to-s))
+      ~(Atomy Grammar AST StringLiteral new(const-name(const)))
+    ))
+
+fn(process-toplevel(grammar, `(rule((~name)(~*args)): ~val))):
+  with(rule = name text, rule-vars = //Set new(args collect &.text)):
+    `(~grammar set(
+        ~(Atomy Grammar AST StringLiteral new(name text to-s))
+        ~process-val(grammar, val)
+        [~*(args collect [x]: Atomy Grammar AST StringLiteral new(x text to-s))]
+      ))
+
+fn(process-toplevel(grammar, `(rule(~name): ~val))):
+  with(rule = name text, rule-vars = //Set new):
+    `(~grammar set(
+        ~(Atomy Grammar AST StringLiteral new(name text to-s))
+        ~process-val(grammar, val)
+      ))
+
+fn(process-toplevel(grammar, u)):
+  raise("unknown toplevel grammar form:\n" + u inspect)
+
+macro(grammar: ~*body):
+  grammar = stack-local Local new
+
+  `(do:
+      ~(grammar set(`(//KPeg Grammar new)))
+      ~*(body collect [n]: process-toplevel(grammar, n))
+      ~grammar)
+
+
+macro(parser(~name): ~*grammar):
+  with(actions = [], setups = [], vars = []):
+    g = evaluate(`(grammar: ~*grammar))
+
+    acts =
+      ^actions collect [action, as]:
+        args = as collect [a]: Word new(a)
+        `([~*args] ~action)
+
+    def = parser-definer new(//KPeg CodeGenerator new(const-name(name), g) output)
+
+    `(do:
+        //KPeg CompiledParser class(~name):
+          setups = [~*^setups]
+          vars = [~*^vars]
+
+          singleton:
+            def(setups): setups
+            def(vars): vars
+
+          def(actions): @actions ||= [~*acts]
+
+        ~def
+
+        ~name)

data/kernel/hash.ay

@@ -0,0 +1,17 @@
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+use(require("patterns"))
+
+stack-local = require("stack-local")
+
+-- hash literals
+macro(#{ ~*pairs }):
+  hash = stack-local Local new
+
+  init-hash = `(//Hash new-from-literal(~(Number new(pairs size))))
+
+  `(do:
+      ~(hash set(init-hash))
+      ~*(pairs collect [`(~k -> ~v)]: `(~hash [~k] = ~v))
+      ~hash)

data/kernel/interpolation.ay

@@ -0,0 +1,59 @@
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+use(require("quotes"))
+use(require("range"))
+use(require("grammar"))
+use(require("patterns"))
+
+parser(Parser):
+  %atomy = Atomy Grammar
+
+  rule(root): %atomy(wsp) es=(%atomy(expressions)) %atomy(wsp) "}" {
+    Atomy Grammar AST Sequence new(Array(es))
+  }
+
+fn(intp-segments(s)):
+  s split(Regexp new("(?<!\\\\)#\\{"), 2) match:
+    []: ['""]
+
+    [x]: [Atomy Code StringLiteral new(x, true)]
+
+    [pre, chunk]:
+      p = Parser new(chunk)
+
+      unless(p parse):
+        p raise-error
+
+      segments = [Atomy Code StringLiteral new(pre, true), `(~(p result) to-s)]
+
+      rest = p string[p pos .. -1]
+
+      if(rest nil? || rest empty?)
+        then: segments
+        else: segments + intp-segments(rest)
+
+
+interpolation = class:
+  def(initialize(@segments)) {}
+
+  def(interpolated?): @segments size > 1
+
+  def(bytecode(gen, mod)):
+    @segments each [s]:
+      mod compile(gen, s)
+
+    when(interpolated?):
+      gen string-build(@segments size)
+
+
+def(interpolated(x)): interpolation new(intp-segments(x))
+
+macro-quoter(i) [_, _, v]: interpolated(v)
+
+-- symbol literals with interpolation
+macro(.~(x & StringLiteral)):
+  i = interpolated(x value)
+  if(i interpolated?)
+    then: `(~i to-sym)
+    else: Atomy Code Symbol new(x value to-sym)

data/kernel/io.ay

@@ -1,244 +1,70 @@
-namespace(atomy)
-
--- condition kernel not loaded yet; predeclare this
-symbols(error)
-
-title"Input & Output"
-
-doc"Where to write normal output." for:
-  dynamic(output-port, $stdout)
-
-doc"Where to read input from." for:
-  dynamic(input-port, $stdin)
-
-doc"Where to write error/warning output." for:
-  dynamic(error-port, $stderr)
-
-section("Output"):
-  doc"
-    Write \hl{x to-s} to \hl{^output-port}, followed by a linebreak.
-  " spec {
-    => x
-  } for {
-    x print := x tap: ^output-port puts(x to-s)
-  } examples:
-    1 print
-    "hello" print
-
-  doc"
-    Write \hl{x to-s} to \hl{^output-port}.
-  " spec {
-    => x
-  } for {
-    x display := x tap: ^output-port send(#print, x to-s)
-  } examples:
-    1 display
-    "hello" display
-
-  doc"
-    Write \hl{x show} to \hl{^output-port}.
-  " spec {
-    => x
-  } for {
-    x write := x tap: ^output-port puts(x show)
-  } examples:
-    1 write
-    "hello" write
-
-  doc"
-    Set \hl{^output-port} to write output to \hl{filename} for the duration \
-    of \hl{action}, ensuring that the file is closed.
-
-    Returns the result of \hl{action}.
-  " spec {
-    filename is-a?(String)
-    mode is-a?(String)
-    => any
-  } for {
-    with-output-to((filename: String), mode = "w", &action) :=
-      let(output-port = File open(filename, mode)):
-        action ensuring:
-          ^output-port close
-  } examples:
-    with-output-to("foo"):
-      42 print
-
-    with-output-to("foo", "a"):
-      "hello" print
-
-    File open("foo", &#read)
-
-  doc"
-    Set \hl{^output-port} to write to \hl{io} for the duration of \hl{action}.
-
-    Returns the result of \hl{action}.
-  " spec {
-    => any
-  } for {
-    with-output-to(io, &action) :=
-      let(output-port = io, &action)
-  } examples:
-    require("stringio")
-    x = StringIO new
-    with-output-to(x):
-      "hello!" write
-    x string
-
-  doc"
-    Set \hl{^error-port} to write error output to \hl{filename} for the \
-    duration of \hl{action}, ensuring that the file is closed.
-
-    Returns the result of \hl{action}.
-  " spec {
-    filename is-a?(String)
-    mode is-a?(String)
-    => any
-  } for {
-    with-error-to((filename: String), mode = "w", &action) :=
-      let(error-port = File open(filename, mode)):
-        action ensuring:
-          ^error-port close
-  } examples:
-    with-error-to("foo", "a"):
-      warning(#some-warning)
-
-    File open("foo", &#read)
-
-  doc"
-    Set \hl{^error-port} to write to \hl{io} for the duration of \hl{action}.
-
-    Returns the result of \hl{action}.
-  " spec {
-    => any
-  } for {
-    with-error-to(io, &action) :=
-      let(error-port = io, &action)
-  } examples:
-    require("stringio")
-    x = StringIO new
-
-    with-error-to(x):
-      warning(#foo)
-
-    x string
-
-section("Input"):
-  doc"
-    Read a line of text from \hl{^input-port}, signalling \hl{EndOfFile} on \
-    end of file. Lines are separated by \hl{sep}. A separator of \hl{nil} \
-    reads the entire contents, and a zero-length separator reads the input \
-    one paragraph at a time (separated by two linebreaks).
-  " spec {
-    => String
-  } for {
-    read-line(sep = $separator) := do:
-      x = ^input-port gets(sep)
-
-      unless(x):
-        error(EndOfFile new(^input-port))
-
-      x
-  } examples:
-    with-input-from("foo"):
-      read-line
-
-  doc"
-    Read all lines of text from \hl{^input-port}. Lines are separated by \
-    \hl{sep}. A separator of \hl{nil} reads the entire contents as one \
-    segment, and a zero-length separator reads the input one paragraph at a \
-    time (separated by two linebreaks).
-  " spec {
-    => String
-  } for {
-    read-lines(sep = $separator) := do:
-      x = ^input-port readlines(sep)
-
-      unless(x):
-        error(EndOfFile new(^input-port))
-
-      x
-  } examples:
-    with-input-from("foo"):
-      read-lines
-
-  doc"
-    Read a single byte from \hl{^input-port}, signalling \hl{EndOfFile} on \
-    end of file.
-  " spec {
-    => Integer
-  } for {
-    read-byte := do:
-      x = ^input-port getc
-
-      unless(x):
-        error(EndOfFile new(^input-port))
-
-      x
-  } examples:
-    with-input-from("foo"):
-      read-byte
-
-  doc"
-    Same as \hl{read-byte chr}.
-  " spec {
-    => String
-  } for {
-    read-char := read-byte chr
-  } examples:
-    with-input-from("foo"):
-      read-char
-
-  doc"
-    Read at most \hl{length} bytes from \hl{^input-port}, or to the end of \
-    file if \hl{length} is \hl{nil}. If \hl{buffer} is given, the data read \
-    will be written to it.
-  " spec {
-    length nil? || length >= 0
-    buffer nil? || buffer is-a?(String)
-    => String || buffer || nil
-  } for {
-    read(length = nil, buffer = nil) :=
-      ^input-port send(#read, length, buffer)
-  } examples:
-    x = ""
-    with-input-from("foo"):
-      read(10)
-
-    with-input-from("foo"):
-      read(10, x)
-
-    x
-
-  doc"
-    Set \hl{^input-port} to read input from \hl{filename} for the duration \
-    of \hl{action}, ensuring that the file is closed.
-
-    Returns the result of \hl{action}.
-  " spec {
-    filename is-a?(String)
-    mode is-a?(String)
-    => any
-  } for {
-    with-input-from((filename: String), mode = "r", &action) :=
-      let(input-port = File open(filename, mode)):
-        action ensuring:
-          ^input-port close
-  } examples:
-    with-input-from("foo"):
-      read-line
-
-  doc"
-    Set \hl{^input-port} to write to \hl{io} for the duration of \hl{action}.
-
-    Returns the result of \hl{action}.
-  " spec {
-    => any
-  } for {
-    with-input-from(io, &action) :=
-      let(input-port = io, &action)
-  } examples:
-    require("stringio")
-    x = StringIO new("hello\ngoodbye\n")
-
-    with-input-from(x):
-      read-line
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
+
+use(require("dynamic"))
+
+const-set(.OutputPort, dynamic(STDOUT))
+const-set(.InputPort, dynamic(STDIN))
+const-set(.ErrorPort, dynamic(STDERR))
+
+def(puts(x)): x tap: ^OutputPort puts(x)
+def(print(x)): x tap: ^OutputPort print(x)
+
+def(with-output-to(filename & String, mode = "w") &action):
+  with(OutputPort = File open(filename, mode)):
+    action ensuring:
+      ^OutputPort close
+
+def(with-output-to(io) &action):
+  with(OutputPort = io):
+    action call
+
+def(with-error-to(filename & String, mode = "w") &action):
+  with(ErrorPort = File open(filename, mode)):
+    action ensuring:
+      ^ErrorPort close
+
+def(with-error-to(io) &action):
+  with(ErrorPort = io):
+    action call
+
+macro($separator): '(Rubinius Globals [."$/"])
+
+def(read-line(sep = $separator)):
+  x = ^InputPort gets(sep)
+
+  unless(x):
+    error(EndOfFile new(^InputPort))
+
+  x
+
+def(read-lines(sep = $separator)):
+  x = ^InputPort readlines(sep)
+
+  unless(x):
+    error(EndOfFile new(^InputPort))
+
+  x
+
+def(read-byte):
+  x = ^InputPort getc
+
+  unless(x):
+    error(EndOfFile new(^InputPort))
+
+  x
+
+def(read-char): read-byte chr
+
+def(read(length = nil, buffer = nil)):
+  ^InputPort read(length, buffer)
+
+def(with-input-from(filename & String, mode = "r") &action):
+  with(InputPort = File open(filename, mode)):
+    action ensuring:
+      ^InputPort close
+
+def(with-input-from(io) &action):
+  with(InputPort = io):
+    action call