rouge-lang 0.0.1

data/lib/rouge/compiler.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require 'set'
+
+module Rouge::Compiler
+  class Resolved
+    def initialize(res)
+      @res = res
+    end
+
+    attr_reader :res
+  end
+
+  def self.compile(ns, lexicals, form)
+    case form
+    when Rouge::Symbol
+      name = form.name
+      is_new = (name[-1] == ?. and name.length > 1)
+      name = name[0..-2].to_sym if is_new
+
+      if !form.ns and
+         (lexicals.include?(name) or
+          (name[0] == ?. and name.length > 1) or
+          [:|, :&].include?(name))
+        # TODO: cache found ns/var/context or no. of context parents.
+        form
+      else
+        resolved = form.ns ? Rouge[form.ns] : ns
+
+        lookups = form.name_parts
+        resolved = resolved[lookups[0]]
+        i, count = 1, lookups.length
+
+        while i < count
+          resolved = resolved.deref if resolved.is_a?(Rouge::Var)
+          resolved = resolved.const_get(lookups[i])
+          i += 1
+        end
+
+        if is_new
+          klass = resolved
+          klass = klass.deref if klass.is_a?(Rouge::Var)
+          resolved = klass.method(:new)
+        end
+
+        Resolved.new resolved
+      end
+    when Array
+      form.map {|f| compile(ns, lexicals, f)}
+    when Hash
+      Hash[form.map {|k, v| [compile(ns, lexicals, k),
+                             compile(ns, lexicals, v)]}]
+    when Rouge::Seq::ISeq
+      to_a = form.to_a
+      if to_a.empty?
+        return Rouge::Seq::Empty
+      end
+
+      head, *tail = to_a
+
+      if head.is_a?(Rouge::Symbol) and
+         (head.ns.nil? or head.ns == :"rouge.builtin") and
+         Rouge::Builtins.respond_to?("_compile_#{head.name}")
+        Rouge::Seq::Cons[*
+          Rouge::Builtins.send(
+            "_compile_#{head.name}",
+            ns, lexicals, *tail)]
+      else
+        head = compile(ns, lexicals, head)
+
+        # XXX ↓↓↓ This is insane ↓↓↓
+        if head.is_a?(Resolved) and
+           head.res.is_a?(Rouge::Var) and
+           head.res.deref.is_a?(Rouge::Macro)
+          # TODO: backtrace_fix
+          compile(ns, lexicals, head.res.deref.inner.call(*tail))
+        else
+          # Regular function call!
+          if tail.include? Rouge::Symbol[:|]
+            index = tail.index Rouge::Symbol[:|]
+            if tail.length == index + 2
+              # Function.
+              block = compile(ns, lexicals, tail[index + 1])
+            else
+              # Inline block.
+              block = compile(
+                ns, lexicals,
+                Rouge::Seq::Cons[Rouge::Symbol[:fn],
+                            *tail[index + 1..-1]])
+            end
+            tail = tail[0...index]
+          else
+            block = nil
+          end
+          Rouge::Seq::Cons[
+            head,
+            *tail.map {|f| compile(ns, lexicals, f)},
+            *(block ? [Rouge::Symbol[:|],
+                       block]
+                    : [])]
+        end
+      end
+    else
+      form
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/context.rb

@@ -0,0 +1,235 @@
+# encoding: utf-8
+require 'rouge/wrappers'
+require 'rouge/namespace'
+
+class Rouge::Context
+  class BindingNotFoundError < StandardError; end
+  class BadBindingError < StandardError; end
+  class ChangeContextException < Exception
+    def initialize(context); @context = context; end
+    attr_reader :context
+  end
+
+  def initialize(parent_or_ns)
+    case parent_or_ns
+    when Rouge::Namespace
+      @ns = parent_or_ns
+    when Rouge::Context
+      @parent = parent_or_ns
+      @ns = @parent.ns
+    end
+    @table = {}
+  end
+
+  def [](key)
+    if @table.include? key
+      @table[key]
+    elsif @parent
+      @parent[key]
+    elsif @ns
+      @ns[key]
+    else
+      raise BindingNotFoundError, key
+    end
+  end
+
+  def set_here(key, value)
+    if Rouge::Symbol[key].ns != nil
+      raise BadBindingError, "cannot bind #{key.inspect}"
+    end
+
+    @table[key] = value
+  end
+
+  def set_lexical(key, value)
+    if @table.include? key
+      @table[key] = value
+    elsif @parent
+      @parent.set_lexical key, value
+    else
+      raise BindingNotFoundError,
+          "setting #{key} to #{value.inspect}"
+    end
+  end
+
+  def lexical_keys
+    @table.keys + (@parent ? @parent.lexical_keys : [])
+  end
+
+  #   This readeval post-processes the backtrace.  Accordingly, it should only
+  # be called by consumers, and never by Rouge internally itself, lest it
+  # catches an exception and processes the backtrace too early.
+  def readeval(input)
+    reader = Rouge::Reader.new(ns, input)
+    context = self
+    r = nil
+
+    while true
+      begin
+        form = reader.lex
+      rescue Rouge::Reader::EndOfDataError
+        return r
+      end
+
+      form = Rouge::Compiler.compile(context.ns, Set[*lexical_keys], form)
+
+      begin
+        r = context.eval(form)
+      rescue ChangeContextException => cce
+        context = cce.context
+        reader.ns = context.ns
+      end
+    end
+  rescue Exception => e
+    # Remove Rouge-related lines unless the exception originated in Rouge.
+    # root = File.dirname(File.dirname(__FILE__))
+    # e.backtrace.map! {|line|
+      # line.scan(root).length > 0 ? nil : line
+    # }.compact! unless e.backtrace[0].scan(root).length > 0
+    raise e
+  end
+
+  # Internal use only -- doesn't post-process backtrace.
+  def eval(form)
+    case form
+    when Rouge::Compiler::Resolved
+      result = form.res
+      if result.is_a?(Rouge::Var)
+        result.deref
+      else
+        result
+      end
+    when Rouge::Symbol
+      eval_symbol form
+    when Rouge::Seq::Cons
+      eval_cons form
+    when Hash
+      Hash[form.map {|k,v| [eval(k), eval(v)]}].freeze
+    when Array
+      form.map {|f| eval(f)}.freeze
+    else
+      form
+    end
+  end
+
+  # +symbol+ should be a Rouge::Symbol.
+  def locate(symbol)
+    if !symbol.is_a?(Rouge::Symbol)
+      raise ArgumentError, "locate not called with R::S"
+    elsif symbol.ns
+      raise ArgumentError, "locate called with NS'd R::S #{symbol}"
+    end
+
+    if symbol.name_s[-1] == ?. and symbol.name_s.length > 1
+      lambda {|*args, &block|
+        self[symbol.name_s[0..-2].intern].new(*args, &block)
+      }
+    else
+      self[symbol.name]
+    end
+  end
+
+  attr_reader :ns
+
+  private
+
+  def eval_symbol(form)
+    if !form.ns and form.name_s[0] == ?. and form.name_s.length > 1
+      lambda {|receiver, *args, &block|
+        receiver.send(form.name_s[1..-1], *args, &block)
+      }
+    else
+      result = locate form
+      if result.is_a?(Rouge::Var)
+        result.deref
+      else
+        result
+      end
+    end
+  end
+
+  def eval_cons(form)
+    fun = eval form[0]
+
+    case fun
+    when Rouge::Builtin
+      backtrace_fix("(rouge):?:builtin: ", form) do
+        fun.inner.call self, *form.to_a[1..-1]
+      end
+    else
+      args = form.to_a[1..-1]
+
+      if args.include? Rouge::Symbol[:|]
+        index = args.index Rouge::Symbol[:|]
+        if args.length == index + 2
+          # Function.
+          block = eval args[index + 1]
+        else
+          # Inline block.
+          block = eval(Rouge::Seq::Cons[
+            Rouge::Symbol[:fn],
+            args[index + 1],
+            *args[index + 2..-1]
+          ])
+        end
+        args = args[0...index]
+      else
+        block = nil
+      end
+
+      args = args.map {|f| eval(f)}
+
+      backtrace_fix("(rouge):?:lambda: ", form) do
+        eval_call(fun, args, block)
+      end
+    end
+  end
+
+  def eval_call(fun, args, block)
+    num_args = args.length
+    case fun
+    when Symbol
+      if num_args == 1 || num_args == 2
+        default = args[1]
+        if args[0].is_a? Hash
+          args[0].fetch(fun) { default }
+        else
+          default
+        end
+      else
+        raise ArgumentError,
+          "Wrong number of args (#{num_args}) passed to ruby/Symbol :#{fun}"
+      end
+    when Hash
+      if num_args == 1 || num_args == 2
+        default = args[1]
+        fun.fetch(args[0]) { default }
+      else
+        raise ArgumentError,
+          "Wrong number of args (#{num_args}) passed to ruby/Hash"
+      end
+    else
+      fun.call(*args, &block)
+    end
+  end
+
+  def backtrace_fix(name, form, &block)
+    begin
+      block.call
+    rescue Exception => e
+      # target = block.source_location.join(':')
+      # changed = 0
+      # $!.backtrace.map! {|line|
+        # if line.scan("#{target}:").size > 0 and changed == 0
+          # changed += 1
+          # Rouge.print(form, name.dup)
+        # else
+          # line
+        # end
+      # }
+      raise e
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/metadata.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rouge::Metadata
+  class InvalidMetadataError < StandardError; end
+
+  def meta
+    @meta
+  end
+
+  def meta= m
+    if m != nil and m.class != Hash
+      raise InvalidMetadataError, "bad metadata: #{m.inspect}"
+    end
+
+    @meta = m
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/namespace.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+require 'rouge/context'
+require 'rouge/builtins'
+require 'rouge/var'
+require 'rouge/atom'
+
+class Rouge::Namespace
+  @namespaces = {}
+
+  class VarNotFoundError < StandardError; end
+  class RecursiveNamespaceError < StandardError; end
+
+  def initialize(name)
+    @name = name
+    raise ArgumentError, "bad ns name" unless @name.is_a? Symbol
+    @table = {}
+    @refers = []
+  end
+
+  def inspect
+    "#<Rouge::NS #{@name.inspect}, " \
+    "refers #{@refers.map(&:inspect).join(", ")}>"
+  end
+
+  def refer(ns)
+    if ns.name == @name
+      raise RecursiveNamespaceError, "#@name will not refer #{ns.name}"
+    end
+
+    @refers << ns if not @refers.include? ns
+  end
+
+  def [](key)
+    if @table.include? key
+      return @table[key]
+    end
+
+    @refers.each do |ns|
+      begin
+        return ns[key]
+      rescue VarNotFoundError
+        # no-op
+      end
+    end
+
+    raise VarNotFoundError, key
+  end
+
+  def set_here(key, value)
+    @table[key] = Rouge::Var.new(@name, key, value)
+  end
+
+  def intern(key)
+    @table[key] ||= Rouge::Var.new(@name, key)
+  end
+
+  def read(input)
+    Rouge::Reader.new(self, input).lex
+  end
+
+  def clear
+    @table = {}
+    self
+  end
+
+  attr_reader :name, :refers
+end
+
+class << Rouge::Namespace
+  def exists?(ns)
+    @namespaces.include? ns
+  end
+
+  def [](ns)
+    r = @namespaces[ns]
+    return r if r
+
+    self[ns] = new(ns)
+    @namespaces[ns] = new(ns)
+  end
+
+  def []=(ns, value)
+    @namespaces[ns] = value
+  end
+
+  def destroy(ns)
+    @namespaces.delete ns
+  end
+end
+
+class Rouge::Namespace::Ruby
+  @@cache = {}
+
+  def [](name)
+    return @@cache[name] if @@cache.include? name
+    if name =~ /^\$/
+      @@cache[name] = Rouge::Var.new(:ruby, name, eval(name.to_s))
+    else
+      @@cache[name] = Rouge::Var.new(:ruby, name, Kernel.const_get(name))
+    end
+  rescue NameError
+    raise Rouge::Namespace::VarNotFoundError, name
+  end
+
+  def set_here(name, value)
+    @@cache[name] = Rouge::Var.new(:ruby, name, value)
+    Kernel.const_set name, value
+  end
+
+  def name
+    :ruby
+  end
+end
+
+ns = Rouge::Namespace[:"rouge.builtin"]
+Rouge::Builtins.methods(false).reject {|s| s =~ /^_compile_/}.each do |m|
+  ns.set_here m, Rouge::Builtin[Rouge::Builtins.method(m)]
+end
+Rouge::Builtins::SYMBOLS.each do |name, val|
+  ns.set_here name, val
+end
+
+Rouge::Namespace[:ruby] = Rouge::Namespace::Ruby.new
+
+# vim: set sw=2 et cc=80: