rouge-lang 0.0.1

data/lib/rouge/repl.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require 'readline'
+
+module Rouge::REPL; end
+
+class << Rouge::REPL
+  def repl_error(e)
+    STDOUT.puts "!! #{e.class}: #{e.message}"
+    STDOUT.puts "#{e.backtrace.join "\n"}"
+  end
+  
+  def repl(argv)
+    context = Rouge::Context.new Rouge[:user]
+
+    if ARGV == ["--time-startup"]
+      STDOUT.puts Time.now - Rouge.start
+      exit(0)
+    elsif argv.length == 1
+      f = File.read(argv[0])
+      if f[0] == ?#
+        f = f[f.index("\n") + 1..-1]
+      end
+
+      context.readeval(f)
+      exit(0)
+    elsif argv.length > 1
+      STDERR.puts "!! usage: #$0 [FILE]"
+      exit(1)
+    end
+
+    count = 0
+    chaining = false
+    while true
+      if not chaining
+        prompt = "#{context.ns.name}=> "
+        input = Readline.readline(prompt, true)
+      else
+        prompt = "#{" " * [0, context.ns.name.length - 2].max}#_=> "
+        input += "\n" + Readline.readline(prompt, true)
+      end
+
+      if input.nil?
+        STDOUT.print "\n"
+        break
+      end
+
+      begin
+        form = context.ns.read(input)
+      rescue Rouge::Reader::EndOfDataError
+        chaining = true
+        next
+      rescue Rouge::Reader::UnexpectedCharacterError => reader_err
+        repl_error reader_err
+      end
+
+      chaining = false
+      begin
+        form = Rouge::Compiler.compile(
+          context.ns,
+          Set[*context.lexical_keys],
+          form)
+        result = context.eval(form)
+
+        Rouge.print(result, STDOUT)
+        STDOUT.puts
+
+        count += 1 if count < 10
+        count.downto(2) do |i|
+          context.set_here :"*#{i}", context[:"*#{i - 1}"]
+        end
+        context.set_here :"*1", result
+      rescue Rouge::Context::ChangeContextException => cce
+        context = cce.context
+        count = 0
+      rescue => e
+        repl_error e
+      end
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/seq.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+module Rouge::Seq
+  Empty = Object.new
+
+  class Cons; end
+
+  module ISeq; end
+
+  module ASeq
+    include ISeq
+
+    def inspect
+      "(#{to_a.map(&:inspect).join " "})"
+    end
+
+    def to_s; inspect; end
+
+    def seq; self; end
+
+    def first; raise NotImplementedError; end
+    def next; raise NotImplementedError; end
+
+    def more
+      s = self.next
+      if s.nil?
+        Empty
+      else
+        s
+      end
+    end
+
+    def cons(o)
+      Cons.new(o, self)
+    end
+
+    def length
+      l = 0
+      cursor = self
+
+      while cursor != Empty
+        l += 1
+        cursor = cursor.more
+      end
+
+      l
+    end
+
+    alias count length
+
+    def [](i)
+      return to_a[i] if i.is_a? Range
+
+      cursor = self
+
+      i += self.length if i < 0
+
+      while i > 0
+        i -= 1
+        cursor = cursor.more
+        return nil if cursor == Empty
+      end
+
+      cursor.first
+    end
+
+    def ==(seq)
+      (seq.is_a?(ISeq) and self.to_a == seq.to_a) or
+        (seq.is_a?(::Array) and self.to_a == seq)
+    end
+
+    def each(&block)
+      return self.enum_for(:each) if block.nil?
+
+      yield self.first
+
+      cursor = self.more
+      while cursor != Empty
+        yield cursor.first
+        cursor = cursor.more
+      end
+
+      self
+    end
+
+    def map(&block)
+      return self.enum_for(:map) if block.nil?
+
+      r = []
+      self.each {|e| r << block.call(e)}
+      r
+    end
+
+    def to_a
+      r = []
+      self.each {|e| r << e}
+      r
+    end
+
+    def map(&block)
+      Cons[*to_a.map(&block)]
+    end
+  end
+
+  class << Empty
+    include ASeq
+
+    def inspect; "()"; end
+    def to_s; inspect; end
+
+    def seq; nil; end
+    def first; nil; end
+    def next; nil; end
+
+    def each(&block)
+      return self.enum_for(:each) if block.nil?
+    end
+  end
+
+  Empty.freeze
+
+  class Cons
+    include ASeq
+
+    def initialize(head, tail)
+      if tail and !tail.is_a?(ISeq)
+        raise ArgumentError,
+            "tail should be an ISeq, not #{tail.inspect} (#{tail.class})"
+      end
+
+      @head, @tail = head, tail
+    end
+
+    def first; @head; end
+    def next; Rouge::Seq.seq @tail; end
+
+    def self.[](*elements)
+      return Empty if elements.length.zero?
+
+      head = nil
+      (elements.length - 1).downto(0).each do |i|
+        head = new(elements[i], head.freeze)
+      end
+
+      head.freeze
+    end
+
+    attr_reader :head, :tail
+  end
+
+  class Array
+    include ASeq
+
+    def initialize(array, i)
+      @array, @i = array, i
+    end
+
+    def first
+      @array[@i]
+    end
+
+    def next
+      if @i + 1 < @array.length
+        Array.new(@array, @i + 1)
+      end
+    end
+  end
+
+  class Lazy
+    include ISeq
+
+    def initialize(body)
+      @body = body
+      @realized = false
+    end
+
+    def seq
+      if @realized
+        @result
+      else
+        @result = Rouge::Seq.seq(@body.call) || Empty
+        @realized = true
+        @result
+      end
+    rescue UnknownSeqError
+      @realized = true
+      @result = Empty
+      raise
+    end
+
+    def method_missing(sym, *args, &block)
+      seq.send(sym, *args, &block)
+    end
+
+    def inspect; seq.inspect; end
+    def to_s; seq.to_s; end
+  end
+
+  UnknownSeqError = Class.new(StandardError)
+
+  def self.seq(form)
+    case form
+    when ISeq
+      form.seq
+    when NilClass
+      form
+    when ::Array
+      if form.empty?
+        nil
+      else
+        Rouge::Seq::Array.new(form, 0)
+      end
+    when Enumerator
+      seq(form.to_a)
+    else
+      raise UnknownSeqError, form.inspect
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/symbol.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+require 'rouge/metadata'
+
+class Rouge::Symbol
+  include Rouge::Metadata
+
+  # The symbols for t/f/n are the Ruby objects themselves.
+  LOOKUP = {
+    :true => true,
+    :false => false,
+    :nil => nil,
+  }
+  
+  KNOWNS = {
+    :/ => [nil, :/],
+    :"./" => [nil, :"./"],
+    :"rouge.core//" => [:"rouge.core", :/],
+    :"rouge.core/./" => [:"rouge.core", :"./"]
+  }
+
+  CACHE = {}
+
+  def initialize(sym)
+    if r = KNOWNS[sym]
+      @ns = r[0]
+      @name = r[1]
+    else
+      str = sym.to_s
+      solidus = str.rindex('/')
+      if solidus
+        @ns = str[0...solidus].intern
+        @name = str[solidus + 1..-1].intern
+      else
+        @ns = nil
+        @name = sym
+      end
+    end
+
+    @ns_s = @ns.to_s unless @ns.nil?
+    @name_s = @name.to_s
+
+    # split(sep, 0) means a trailing '.' won't become an empty component.  (0
+    # is default)  Contrast with split(sep, -1).
+    @name_parts =
+      @name_s.length > 1 ? @name_s.split('.', 0).map(&:intern) : [@name]
+
+    @new_sym = (@name_s[-1] == ?. and @name_s.length > 1)
+  end
+
+  def self.[](inner)
+    return LOOKUP[inner] if LOOKUP.include? inner
+    c = CACHE[inner]
+    return c.dup if c
+    # Note: don't cache symbols themselves, they may have metadata.
+    c = new inner
+    CACHE[inner] = c.dup.freeze
+    c
+  end
+
+  def to_sym
+    :"#{@ns ? "#@ns/" : ""}#@name"
+  end
+
+  def inspect
+    "Rouge::Symbol[#{to_sym.inspect}]"
+  end
+
+  def to_s; inspect; end
+
+  def ==(right)
+    right.is_a?(Rouge::Symbol) and right.ns == @ns and right.name == @name
+  end
+
+  attr_reader :ns, :name, :ns_s, :name_s, :name_parts, :new_sym
+end
+
+# vim: set sw=2 et cc=80:

data/lib/rouge/var.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+class Rouge::Var
+  @@stack = []
+
+  def initialize(ns, name, root=Rouge::Var::UnboundSentinel)
+    @ns = ns
+    @name = name
+    raise ArgumentError, "bad var ns" unless ns.is_a? Symbol
+    raise ArgumentError, "bad var name" unless name.is_a? Symbol
+    if root == Rouge::Var::UnboundSentinel
+      @root = Rouge::Var::Unbound.new self
+    else
+      @root = root
+    end
+  end
+
+  def ==(var)
+    var.is_a?(Rouge::Var) and @ns == var.ns and @name == var.name
+  end
+
+  attr_reader :ns, :name
+  
+  def deref
+    @@stack.reverse_each do |map|
+      if map.include? @name
+        return map[@name]
+      end
+    end
+
+    @root
+  end
+
+  def inspect
+    "Rouge::Var.new(#{@ns.inspect}, #{@name.inspect}, #{@root.inspect})"
+  end
+
+  def to_s
+    inspect
+  end
+
+  def self.push(map)
+    @@stack << map
+  end
+
+  def self.pop
+    @@stack.pop
+  end
+end
+
+Rouge::Var::UnboundSentinel = Object.new
+class << Rouge::Var::UnboundSentinel
+  def inspect; "#<Rouge::Var::UnboundSentinel>"; end
+  def to_s; inspect; end
+end
+
+class Rouge::Var::Unbound
+  def initialize(var)
+    @var = var
+  end
+
+  def ==(ub)
+    @var == ub.var
+  end
+
+  attr_reader :var
+end
+
+# vim: set sw=2 et cc=80: