rsense-core 0.5.0

data/src/org/cx4a/rsense/util/NodeUtil.java

@@ -0,0 +1,198 @@
+package org.cx4a.rsense.util;
+
+import org.jrubyparser.NodeVisitor;
+import org.jrubyparser.ast.*;
+
+
+public class NodeUtil {
+
+    private NodeUtil() {}
+
+    public static int nodeHashCode(Node node) {
+        if (node == null) return 0;
+        return new NodeHashCodeCalculator(node).getHashCode();
+    }
+
+    private static class NodeHashCodeCalculator implements NodeVisitor {
+        private int hashCode;
+
+        public NodeHashCodeCalculator(Node node) {
+            hashCode = 0;
+            node.accept(this);
+        }
+
+        public int getHashCode() {
+            return hashCode;
+        }
+
+        public Object visitAliasNode(AliasNode node) { return update(0); }
+        public Object visitAndNode(AndNode node) { return update(1); }
+        public Object visitArgsNode(ArgsNode node) { return update(2); }
+        public Object visitArgsCatNode(ArgsCatNode node) { return update(3); }
+        public Object visitArgsPushNode(ArgsPushNode node) { return update(4); }
+        public Object visitArrayNode(ArrayNode node) { return update(5); }
+        public Object visitAttrAssignNode(AttrAssignNode node) { return update(6); }
+        public Object visitBackRefNode(BackRefNode node) { return update(7); }
+        public Object visitBeginNode(BeginNode node) { return update(8); }
+        public Object visitBignumNode(BignumNode node) { return update(9); }
+        public Object visitBlockArgNode(BlockArgNode node) { return update(10); }
+        public Object visitBlockNode(BlockNode node) { return update(11); }
+        public Object visitBlockPassNode(BlockPassNode node) { return update(12); }
+        public Object visitBreakNode(BreakNode node) { return update(13); }
+        public Object visitConstDeclNode(ConstDeclNode node) { return update(14); }
+        public Object visitClassVarAsgnNode(ClassVarAsgnNode node) { return update(15); }
+        public Object visitClassVarDeclNode(ClassVarDeclNode node) { return update(16); }
+        public Object visitClassVarNode(ClassVarNode node) { return update(17); }
+        public Object visitCallNode(CallNode node) { return update(18); }
+        public Object visitCaseNode(CaseNode node) { return update(19); }
+        public Object visitClassNode(ClassNode node) { return update(20); }
+        public Object visitColon2Node(Colon2Node node) { return update(21); }
+        public Object visitColon3Node(Colon3Node node) { return update(22); }
+        public Object visitConstNode(ConstNode node) { return update(23); }
+        public Object visitDAsgnNode(DAsgnNode node) { return update(24); }
+        public Object visitDRegxNode(DRegexpNode node) { return update(25); }
+        public Object visitDStrNode(DStrNode node) { return update(26); }
+        public Object visitDSymbolNode(DSymbolNode node) { return update(27); }
+        public Object visitDVarNode(DVarNode node) { return update(28); }
+        public Object visitDXStrNode(DXStrNode node) { return update(29); }
+        public Object visitDefinedNode(DefinedNode node) { return update(30); }
+        public Object visitDefnNode(DefnNode node) { return update(31); }
+        public Object visitDefsNode(DefsNode node) { return update(32); }
+        public Object visitDotNode(DotNode node) { return update(33); }
+        public Object visitEncodingNode(EncodingNode node) { return update(34); }
+        public Object visitEnsureNode(EnsureNode node) { return update(35); }
+        public Object visitEvStrNode(EvStrNode node) { return update(36); }
+        public Object visitFCallNode(FCallNode node) { return update(37); }
+        public Object visitFalseNode(FalseNode node) { return update(38); }
+        public Object visitFixnumNode(FixnumNode node) { return update(39); }
+        public Object visitFlipNode(FlipNode node) { return update(40); }
+        public Object visitFloatNode(FloatNode node) { return update(41); }
+        public Object visitForNode(ForNode node) { return update(42); }
+        public Object visitGlobalAsgnNode(GlobalAsgnNode node) { return update(43); }
+        public Object visitGlobalVarNode(GlobalVarNode node) { return update(44); }
+        public Object visitHashNode(HashNode node) { return update(45); }
+        public Object visitInstAsgnNode(InstAsgnNode node) { return update(46); }
+        public Object visitInstVarNode(InstVarNode node) { return update(47); }
+        public Object visitIfNode(IfNode node) { return update(48); }
+        public Object visitIterNode(IterNode node) { return update(49); }
+        public Object visitLocalAsgnNode(LocalAsgnNode node) { return update(50); }
+        public Object visitLocalVarNode(LocalVarNode node) { return update(51); }
+        public Object visitMultipleAsgnNode(MultipleAsgnNode node) { return update(52); }
+        public Object visitMatch2Node(Match2Node node) { return update(54); }
+        public Object visitMatch3Node(Match3Node node) { return update(55); }
+        public Object visitMatchNode(MatchNode node) { return update(56); }
+        public Object visitModuleNode(ModuleNode node) { return update(57); }
+        public Object visitNewlineNode(NewlineNode node) { return update(58); }
+        public Object visitNextNode(NextNode node) { return update(59); }
+        public Object visitNilNode(NilNode node) { return update(60); }
+        public Object visitNotNode(NotNode node) { return update(61); }
+        public Object visitNthRefNode(NthRefNode node) { return update(62); }
+        public Object visitOpElementAsgnNode(OpElementAsgnNode node) { return update(63); }
+        public Object visitOpAsgnNode(OpAsgnNode node) { return update(64); }
+        public Object visitOpAsgnAndNode(OpAsgnAndNode node) { return update(65); }
+        public Object visitOpAsgnOrNode(OpAsgnOrNode node) { return update(66); }
+        public Object visitOrNode(OrNode node) { return update(67); }
+        public Object visitPreExeNode(PreExeNode node) { return update(68); }
+        public Object visitPostExeNode(PostExeNode node) { return update(69); }
+        public Object visitRedoNode(RedoNode node) { return update(70); }
+        public Object visitRegexpNode(RegexpNode node) { return update(71); }
+        public Object visitRescueBodyNode(RescueBodyNode node) { return update(72); }
+        public Object visitRescueNode(RescueNode node) { return update(73); }
+        public Object visitRestArgNode(RestArgNode node) { return update(74); }
+        public Object visitRetryNode(RetryNode node) { return update(75); }
+        public Object visitReturnNode(ReturnNode node) { return update(76); }
+        public Object visitRootNode(RootNode node) { return update(77); }
+        public Object visitSClassNode(SClassNode node) { return update(78); }
+        public Object visitSelfNode(SelfNode node) { return update(79); }
+        public Object visitSplatNode(SplatNode node) { return update(80); }
+        public Object visitStrNode(StrNode node) { return update(81); }
+        public Object visitSuperNode(SuperNode node) { return update(82); }
+        public Object visitSValueNode(SValueNode node) { return update(83); }
+        public Object visitSymbolNode(SymbolNode node) { return update(84); }
+        public Object visitToAryNode(ToAryNode node) { return update(85); }
+        public Object visitTrueNode(TrueNode node) { return update(86); }
+        public Object visitUndefNode(UndefNode node) { return update(87); }
+        public Object visitUntilNode(UntilNode node) { return update(88); }
+        public Object visitVAliasNode(VAliasNode node) { return update(89); }
+        public Object visitVCallNode(VCallNode node) { return update(90); }
+        public Object visitWhenNode(WhenNode node) { return update(91); }
+        public Object visitWhileNode(WhileNode node) { return update(92); }
+        public Object visitXStrNode(XStrNode node) { return update(93); }
+        public Object visitYieldNode(YieldNode node) { return update(94); }
+        public Object visitZArrayNode(ZArrayNode node) { return update(95); }
+        public Object visitZSuperNode(ZSuperNode node) { return update(96); }
+
+        private Object update(int n) {
+            hashCode = hashCode * 13 + n;
+            return this;
+        }
+
+        // FIXME: I don't know this fits into the grand scheme of things...Let's see about test coverage.
+        @Override
+        public Object visitArgumentNode(ArgumentNode an) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitBlockArg18Node(BlockArg18Node node) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitCommentNode(CommentNode node) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public Object visitImplicitNilNode(ImplicitNilNode kan) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitKeywordArgNode(KeywordArgNode kan) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitKeywordRestArgNode(KeywordRestArgNode kran) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitLambdaNode(LambdaNode node) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public Object visitLiteralNode(LiteralNode node) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitListNode(ListNode ln) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitMethodNameNode(MethodNameNode mnn) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitOptArgNode(OptArgNode oan) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+        @Override
+        public Object visitSyntaxNode(SyntaxNode node) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public Object visitUnaryCallNode(UnaryCallNode kan) {
+            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+        }
+
+
+    }
+}

data/src/org/cx4a/rsense/util/SourceLocation.java

@@ -0,0 +1,70 @@
+package org.cx4a.rsense.util;
+
+import org.jrubyparser.ast.Node;
+import org.jrubyparser.SourcePosition;
+
+import org.cx4a.rsense.typing.vertex.Vertex;
+
+public class SourceLocation {
+    private String file;
+    private int line;
+
+    public SourceLocation(String file, int line) {
+        this.file = file;
+        this.line = line;
+    }
+
+    public String getFile() {
+        return file;
+    }
+
+    public int getLine() {
+        return line;
+    }
+
+    @Override
+    public int hashCode() {
+        return line ^ (file != null ? file.hashCode() : 0);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other)
+            return true;
+        else if (!(other instanceof SourceLocation))
+            return false;
+
+        SourceLocation o = (SourceLocation) other;
+        return line == o.line
+            && ((file == null && o.file == null)
+                || (file != null && file.equals(o.file)));
+    }
+
+    @Override
+    public String toString() {
+        return file + ":" + line;
+    }
+
+    public static SourceLocation of(Node node) {
+        SourcePosition pos = node.getPosition();
+        //TODO : find out about SourcePosition.INVALID_POSITION
+//        if (pos != null && pos != SourcePosition.INVALID_POSITION) {
+//            return new SourceLocation(pos.getFile(), pos.getStartLine() + 1);
+//        } else {
+//            return null;
+//        }
+        if (pos != null) {
+            return new SourceLocation(pos.getFile(), pos.getStartLine() + 1);
+        } else {
+            return null;
+        }
+    }
+
+    public static SourceLocation of(Vertex vertex) {
+        if (vertex != null && vertex.getNode() != null) {
+            return of(vertex.getNode());
+        } else {
+            return null;
+        }
+    }
+}

data/src/org/cx4a/rsense/util/StringUtil.java

@@ -0,0 +1,63 @@
+package org.cx4a.rsense.util;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class StringUtil {
+    private StringUtil() {}
+
+    public static String[] shellwords(String command) {
+        List<String> result = new ArrayList<String>();
+        char[] cs = command.toCharArray();
+        int len = cs.length;
+        StringBuilder sb = null;
+        boolean escape = false;
+        char quote = 0;
+        for (int i = 0; i < len; ) {
+            char c = cs[i++];
+
+            // Skip whitespaces
+            if (!escape && quote == 0) {
+                while (i < len && Character.isWhitespace(c)) {
+                    if (sb != null) {
+                        result.add(sb.toString());
+                        sb = null;
+                    }
+                    c = cs[i++];
+                }
+                if (i > len) {
+                    break;
+                }
+            }
+
+            // New field
+            if (sb == null) {
+                sb = new StringBuilder();
+            }
+
+            // Append character
+            if (escape) {
+                sb.append(c);
+                escape = false;
+            } else if (c == quote) {
+                quote = 0;
+            } else {
+                switch (c) {
+                case '"': case '\'':
+                    quote = c;
+                    break;
+                case '\\':
+                    escape = true;
+                    break;
+                default:
+                    sb.append(c);
+                    break;
+                }
+            }
+        }
+        if (sb != null) {
+            result.add(sb.toString());
+        }
+        return result.toArray(new String[0]);
+    }
+}

data/src/resources/org/cx4a/rsense/rsense.properties

@@ -0,0 +1 @@
+rsense.version = 0.5.0

data/stubs/1.8/_builtin.rb

@@ -0,0 +1,3006 @@
+# -*- coding: undecided -*-
+# ruby 1.8.7 builtin library stub
+# http://doc.okkez.net/187/view/library/
+
+BOOLEAN = true || false
+
+module Enumerable; end
+module Precision; end
+class IO; end
+class File < IO; end
+module File::Constants; end
+
+##% Array<t>
+class Array
+  # FIXME to_ary for +, -, &
+
+  include Enumerable
+
+  ##% self.[](*a) -> a
+  def self.[](*item) item end
+  ##% self.new(?Integer, ?a) -> Array<a>
+  ##% self.new<a | a <= Array>(?a)  -> a
+  ##% self.new<v>(Integer) {Integer -> v} -> Array<v>
+  def self.new(*) end
+
+  # FIXME to_ary
+
+  ##% &<v>(Array<v>) -> Array<t or v>
+  def &(other) self || other end
+  ##% "*"(Integer) -> Array<t>
+  ##% "*"(String) -> String
+  def *(times) self end
+  ##% +(Array<v>) -> Array<t or v>
+  def +(other) self || other end
+  ##% -(Array<v>) -> Array<t or v>
+  def -(other) self || other end
+  ##% "<<"<v | v <= t>(v) -> self
+  def <<(obj) self end
+  ##% "<=>"(a) -> Fixnum
+  def <=>(other) 0 end
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% [](Integer) -> t
+  ##% [](Range) -> Array<t>
+  ##% [](Integer, Integer) -> Array<t>
+  def [](*) at(0) end
+  ##% []=<v | v <= t>(Integer, v) -> v
+  ##% []=<v | v <= t>(Range, Array<v>) -> Array<v>
+  ##% []=<v | v <= t>(Integer, Integer, Array<v>) -> Array<v>
+  def []=(*) self end
+  # FIXME
+  ##% assoc<k, v | t <= (k, v)>(k) -> v
+  def assoc(key) [0][1] end
+  ##% at(Integer) -> t
+  def at(pos) _e end
+  ##% choice() -> t
+  def choice() [0] end
+  # FIXME
+  ##% clear() -> self
+  def clear() self end
+  ##% clone() -> Array<t>
+  def clone() self end
+  alias :dup :clone
+  # FIXME
+  ##% collect!() {t -> ?} -> self
+  ##% collect!() -> Enumerator<self, t>
+  def collect!() yield _e; self end
+  alias :map! :collect!
+  ##% combination(Integer) {Array<t> -> ?} -> Array<Array<t> >
+  ##% combination(Integer) -> Enumerator<Array<Array<t> >, Array<t> >
+  def combination(n) yield [_e]; [[_e]] end
+  ##% compact() -> Array<t>
+  def compact() self end
+  ##% compact!() -> self
+  def compact!() self end
+  ##% concat<v | v <= t>(Array<v>) -> self
+  def concat(other) self end
+  ##% cycle() {t -> ?} -> self
+  def cycle() yield _e; self end
+  ##% delete(a) -> a
+  ##% delete<v>(a) {() -> v} -> v
+  def delete(val) val end
+  ##% delete_at(Integer) -> t
+  def delete_at(pos) _e end
+  ##% delete_if() -> Enumerator<self, t>
+  ##% delete_if() {t -> ?} -> self
+  def delete_if() self end
+  alias :reject! :delete_if
+  ##% each() {t -> ?} -> self
+  ##% each() -> Enumerator<self, t>
+  def each() yield _e; self end
+  ##% each_index() {Integer -> ?} -> self
+  ##% each_index() -> Enumerator<self, Integer>
+  def each_index() yield 0; self end
+  ##% empty?() -> Boolean
+  def empty?() Boolean end
+  ##% eql?(a) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% fetch(Integer) -> t
+  ##% fetch(Integer, ifnone) -> t or ifnone
+  ##% fetch<v>(Integer) {Integer -> v} -> t or v
+  def fetch(nth, ifnone = nil) _e || ifnone end
+  ##% fill<v | v <= t>(v) -> self
+  ##% fill<v | v <= t>() {Integer -> v} -> self
+  ##% fill<v | v <= t>(v, Integer, ?Integer) -> self
+  ##% fill<v | v <= t>(v, Range) -> self
+  ##% fill<v | v <= t>(Integer, ?Integer) {Integer -> v} -> self
+  ##% fill<v | v <= t>(Range) {Integer -> v} -> self
+  def fill(*) self end
+  ##% first() -> t
+  ##% first(Integer) -> Array<t>
+  def first(n = nil) _e end
+  # FIXME
+  ##% flatten(?Integer) -> Array<t>
+  def flatten(lv = nil) self end
+  # FIXME
+  ##% flatten!(?Integer) -> self
+  def flatten!(lv = nil) self end
+  ##% hash() -> Integer
+  def hash() 0 end
+  ##% include?(a) -> Boolean
+  def include?(val) Boolean end
+  ##% index(a) -> Integer
+  ##% index() {t -> ?} -> Integer
+  def index(val) 0 end
+  ##% indexes(*a) -> Array<t>
+  def indexes(*index) self end
+  ##% insert<v | v <= Array<t> >(Integer, *v) -> self
+  def insert(nth, *val) self end
+  ##% join (?String) -> String
+  def join(sep = $,) '' end
+  ##% last() -> t
+  ##% last(Integer) -> Array<t>
+  def last(n = nil) _e end
+  ##% length() -> Integer
+  def length() 0 end
+  alias :size :length
+  ##% nitems() -> Integer
+  ##% nitems() {t -> ?} -> Integer
+  def nitems() 0 end
+  ##% pack(String) -> String
+  def pack(template) '' end
+  ##% permutation(Integer) {Array<t> -> ?} -> Array<Array<t> >
+  ##% permutation(Integer) -> Enumerator<Array<Array<t> >, Array<t> >
+  def permutation(n) yield [_e]; [[_e]] end
+  ##% pop() -> t
+  ##% pop(Integer) -> Array<t>
+  def pop(n = 1) [0] end
+  # FIXME
+  def product(*) [[_e]] end
+  ##% push<v | v <= Array<t> >(*v) -> self
+  def push(*obj) self end
+  ##% rassoc<k, v | t <= (k, v)>(v) -> k
+  def rassoc(obj) [0][0] end
+  # FIXME
+  ##% replace(Array<t>) -> self
+  def replace(another) self end
+  ##% reverse() -> Array<t>
+  def reverse() self end
+  ##% reverse!() -> self
+  def reverse!() self end
+  ##% reverse_each() {t -> ?} -> self
+  ##% reverse_each() -> Enumerator<self, t>
+  def reverse_each() yield _e; self end
+  ##% rindex<v>(v) -> Integer
+  ##% rindex<v>() {Integer -> ?} -> Integer
+  def rindex(val) end
+  ##% shift() -> t
+  ##% shift(Integer) -> Array<t>
+  def shift() _e end
+  ##% shuffle() -> Array<t>
+  def shuffle() self end
+  ##% shuffle!() -> self
+  def shuffle!() self end
+  alias :slice :[]
+  alias :slice! :[]
+  ##% sort() -> Array<t>
+  ##% sort() {(t, t) -> ?} -> Array<t>
+  def sort() self end
+  ##% sort!() -> self
+  ##% sort!() {(t, t) -> ?} -> self
+  def sort!() self end
+  ##% to_a() -> Array<t>
+  def to_a() self end
+  ##% to_ary() -> self
+  def to_ary() self end
+  ##% to_s() -> String
+  def to_s() '' end
+  # FIXME
+  def transpose() self end
+  ##% uniq() -> Array<t>
+  def uniq() self end
+  ##% uniq!() -> self
+  def uniq!() self end
+  ##% unshift<v | v <= Array<t> >(*v) -> self
+  def unshift(*obj) self end
+  # FIXME
+  ##% values_at<k, v | t <= (k, v)>(*a) -> Array<v>
+  def values_at(*index) self end
+  # FIXME zip
+  ##% "|"<v>(Array<v>) -> Array<t or v>
+  def |(other) self || other end
+end
+
+class Bignum
+  ### Precision
+  ##% self.induced_from(a) -> Bignum
+  def self.induced_from(number) 0 end
+  ##% prec(Class) -> Bignum
+  def prec(klass) 0 end
+
+  ### Numeric
+  ##% +@() -> self
+  def +@() self end
+  ##% -@() -> Bignum
+  def -@() 0 end
+  ##% "<=>"(other) -> Fixnum
+  def <=>(other) 0 end
+  ##% abs() -> Bignum
+  def abs() self end
+  ##% ceil() -> Bignum
+  def ceil() 0 end
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% coerce(Float) -> (Float, Float)
+  ##% coerce(Numeric) -> (Bignum, Bignum)
+  def coerce(other) [0.0, 0.0] end
+  ##% div(Numeric) -> Bignum
+  def div(other) 0 end
+  ##% divmod(Numeric) -> (Bignum, Numeric)
+  def divmod(other) [0, 0] end
+  ##% eql?(Numeric) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% quo(Numeric) -> Float
+  def quo(other) 0.0 end
+  ##% fdiv(Numeric) -> Float
+  def fdiv(other) 0.0 end
+  ##% floor() -> Bignum
+  def floor() 0 end
+  ##% integer?() -> Boolean
+  def integer?() BOOLEAN end
+  ##% modulo(Numeric) -> Bignum
+  def modulo(other) 0 end
+  ##% nonzero?() -> self
+  def nonzero?() self end
+  ##% remainder(Numeric) -> Bignum
+  def remainder(other) 0 end
+  ##% round() -> Integer
+  def round() 0 end
+  ##% step<a | a <= Numeric>(Numeric, ?a) {self or a or Fixnum -> ?} -> self
+  ##% step<a | a <= Numeric>(Numeric, ?a) -> Enumerable::Enumerator<self, self or a or Fixnum>
+  def step(limit, step = 1) self end
+  ##% to_int() -> Bignum
+  def to_int() 0 end
+  ##% truncate() -> Bignum
+  def truncate() 0 end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+end
+
+class Binding
+  def eval(*) end
+end
+
+class Class
+  # FIXME self.new
+
+  ##% _load(String) -> Class
+  def _load(str) Class.new end
+  def allocate() new() end
+  ##% superclass() -> Class
+  def superclass() Class.new end
+
+  private
+  def inherited(subclass) end
+end
+
+module Comparable
+  ##% "<"(a) -> Boolean
+  def <(other) BOOLEAN end
+  ##% "<="(a) -> Boolean
+  def <=(other) BOOLEAN end
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ">"(a) -> Boolean
+  def >(other) BOOLEAN end
+  ##% ">="(a) -> Boolean
+  def >=(other) BOOLEAN end
+  ##% between?(a, b) -> Boolean
+  def between?(min, max) BOOLEAN end
+end
+
+class Continuation
+  # FIXME
+end
+
+class Data
+end
+
+##% Dir<| t <= String>
+class Dir
+  include Enumerable
+
+  ##% self.[](*String) -> Array<String>
+  def self.[](*pattern) [''] end
+  ##% self.glob(String, ?Integer) -> Array<String>
+  ##% self.glob(String, ?Integer) {String -> ?} -> nil
+  def self.glob(pattern, flags = 0) [''] end
+  ##% self.chdir() -> Fixnum
+  ##% self.chdir(String) -> Fixnum
+  ##% self.chdir<v>() {String -> v} -> v
+  ##% self.chdir<v>(String) {String -> v} -> v
+  def self.chdir(path = nil) 0 end
+  ##% self.chroot(String) -> Fixnum
+  def self.chroot(path) 0 end
+  ##% self.delete(String) -> Fixnum
+  def self.delete(path) 0 end
+  ##% self.rmdir(String) -> Fixnum
+  def self.rmdir(path) 0 end
+  ##% self.unlink(String) -> Fixnum
+  def self.unlink(path) 0 end
+  ##% self.entries(String) -> Array<String>
+  def self.entires(path) [''] end
+  ##% self.foreach(String) {String -> ?} -> nil
+  ##% self.foreach(String) -> Enumerator<nil, String>
+  def foreach(path) yield ''; nil end
+  ##% self.getwd() -> String
+  def self.getwd() '' end
+  ##% self.pwd() -> String
+  def self.pwd() '' end
+  ##% self.mkdir(String, ?Integer) -> Fixnum
+  def self.mkdir(path, mode = 0777) 0 end
+  ##% self.new(String) -> Dir
+  def self.new(path) Dir.new('') end
+  ##% self.open(String) -> Dir
+  ##% self.open<v>(String) {Dir -> v} -> v
+  def self.open(path) Dir.new('') end
+
+  ##% close() -> nil
+  def close() end
+  ##% each() {String -> ?} -> self
+  ##% each() -> Enumerator<self, t>
+  def each() yield ''; self end
+  ##% path() -> String
+  def path() '' end
+  ##% pos() -> Integer
+  def pos() 0 end
+  alias :tell :pos
+  ##% pos=(Integer) -> self
+  def pos=(pos) self end
+  ##% seek(Integer) -> self
+  def seek(pos) self end
+  ##% read() -> String
+  def read() '' end
+  ##% rewind() -> self
+  def rewind() self end
+end
+
+##% Enumerable<t>
+module Enumerable
+  ##% all?() -> Boolean
+  ##% all?() {t -> ?} -> Boolean
+  def all?() yield self; BOOLEAN end
+  ##% any?() -> Boolean
+  ##% any?() {t -> ?} -> Boolean
+  def any?() yield self; BOOLEAN end
+  ##% collect<v>() {t -> v} -> Array<v>
+  def collect() [yield(self)] end
+  alias :map :collect
+  ##% count() -> Integer
+  ##% count(a) -> Integer
+  ##% count() {t -> ?} -> Integer
+  def count(item = nil) yield self; 0 end
+  ##% cycle() -> Enumerator<self, t>
+  ##% cycle() {t -> ?} -> ?
+  def cycle() yield self end
+  # FIXME ifnone
+  ##% find<v>(?a) -> Enumerator<t or a, t>
+  ##% find<v>(?a) {t -> ?} -> t or a
+  def find(ifnone = nil) yield self end
+  alias :detect :find
+  ##% drop(Integer) -> Array<t>
+  def drop(n) to_a end
+  ##% drop_while() -> Enumerator<Array<t>, t>
+  ##% drop_while() {t -> ?} -> Array<t>
+  def drop_while() yield _e end
+  # FIXME 3
+  ##% each_cons(Integer) -> Enumerator<nil, (t, t, t)>
+  ##% each_cons(Integer) {(t, t, t) -> ?} -> nil
+  def each_cons(n) yield _e, _e, _e end
+  alias :enum_cons :each_cons
+  ##% each_with_index() -> Enumerator<self, (t, Integer)>
+  ##% each_with_index() {(t, Integer) -> ?} -> self
+  def each_with_index() yield _e, 0 end
+  alias :enum_with_index :each_with_index
+  ##% to_a() -> Array<t>
+  def to_a() [_e] end
+  alias :entries :to_a
+  ##% find_all() -> Enumerator<Array<t>, t>
+  ##% find_all() {t -> ?} -> Array<t>
+  def find_all() yield _e; [_e] end
+  alias :select :find_all
+  ##% find_index() -> Enumerator<Integer, t>
+  ##% find_index() {t -> ?} -> Integer
+  def find_index() yield _e; 0 end
+  ##% first() -> t
+  ##% first(Integer) -> Array<t>
+  def first(n = nil) _e end
+  # FIXME ===
+  ##% grep(a) -> Array<t>
+  ##% grep<v>(a) {t -> v} -> Array<v>
+  def grep(pattern) [_e] end
+  ##% group_by() -> Enumerator<Hash<?, Array<t> >, t>
+  ##% group_by<v>() {t -> v} -> Hash<v, Array<t> >
+  def group_by() {(yield _e) => [_e]} end
+  # FIXME ==
+  ##% member?(a) -> Boolean
+  def member?(val) BOOLEAN end
+  alias :include? :member?
+  # FIXME sym
+  ##% inject(?a) {(r or init or t) -> r} -> r or init
+  ##% inject(Symbol) -> t
+  ##% inject(a, Symbol) -> t or a
+  def inject(*) _e end
+  alias :reduce :inject
+  ##% max() -> t
+  ##% max() {(t, t) -> ?} -> t
+  def max() _e end
+  ##% max_by() -> Enumerator<t, t>
+  ##% max_by() {t -> ?} -> t
+  def max_by() yield t; t end
+  ##% min() -> t
+  ##% min() {(t, t) -> ?} -> t
+  def min() _e end
+  ##% min_by() -> Enumerator<t, t>
+  ##% min_by() {t -> ?} -> t
+  def min_by() yield t; t end
+  ##% minmax() -> (t, t)
+  ##% minmax() {(t, t) -> ?} -> (t, t)
+  def minmax() [_e, _e] end
+  ##% minmax_by() -> Enumerator<(t, t), t>
+  ##% minmax_by() {t -> ?} -> (t, t)
+  def minmax_by() yield _e; [_e, _e] end
+  ##% none?() -> Boolean
+  ##% none?() {t -> ?} -> Boolean
+  def none?() BOOLEAN end
+  ##% one?() -> Boolean
+  ##% one?() {t -> ?} -> Boolean
+  def one?() BOOLEAN end
+  ##% partition() -> Enumerator<(t, t), t>
+  ##% partition() {t -> ?} -> (t, t)
+  def partition() yield _e; [_e, _e] end
+  ##% reject() -> Enumerator<Array<t>, t>
+  ##% reject() {t -> ?} -> Array<t>
+  def reject() yield _e; [_e] end
+  ##% sort() -> Array<t>
+  ##% sort() {(t, t) -> ?} -> Array<t>
+  def sort() [_e] end
+  ##% sort_by() -> Enumerator<Array<t>, t>
+  ##% sort_by() {t -> ?} -> Array<t>
+  def sort_by() yield _e; [_e] end
+  ##% take(Integer) -> Array<t>
+  def take(n) [_e] end
+  ##% take_while() -> Enumerator<Array<t>, t>
+  ##% take_while() {t -> ?} -> Array<t>
+  def take_while() yield _e; [_e]; end
+  # FIXME
+  def zip(*) [[_e]] end
+
+  private
+  # Special methods for internal use
+  ##% _e() -> t
+  def _e() end
+end
+
+##% Enumerator<s, t>
+class Enumerator
+  include Enumerable
+
+  # FIXME self.new
+
+  ##% each() {t -> ?} -> s
+  def each() end
+  ##% next() -> t
+  def next() end
+  ##% rewind() -> self
+  def rewind() self end
+  ##% to_splat() -> Array<t>
+  def to_splat() [] end
+  ##% with_index() -> Enumerator<s, (t, Integer)>
+  ##% with_index() {(t, Integer) -> ?} -> s
+  def with_index() end
+end
+
+# 1.8.7 <=> 1.8.8
+Enumerable::Enumerator = Enumerator
+
+module Errno
+end
+
+class FalseClass
+  ##% &(a) -> FalseClass
+  def %(other) false end
+  ##% ^(a) -> Boolean
+  def ^(other) BOOLEAN end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% "|"(a) -> Boolean
+  def |(other) BOOLEAN end
+end
+
+class File
+  ALT_SEPARATOR = ''
+  PATH_SEPARATOR = ''
+  SEPARATOR = ''
+  Separator = ''
+
+  include File::Constants
+
+  ##% self.atime(String or IO) -> Time
+  def self.atime(filename) Time.new end
+  ##% self.basename(String, ?String) -> String
+  def self.basename(filename, suffix = '') '' end
+  ##% self.blockdev?(String or IO) -> Boolean
+  def self.blockdev?(path) BOOLEAN end
+  ##% self.chardev?(String or IO) -> Boolean
+  def self.chardev?(path) BOOLEAN end
+  ##% self.chmod(Integer, *String) -> Integer
+  def self.chmod(mode, *filename) 0 end
+  ##% self.chown(Integer, Integer, *String) -> Integer
+  def self.chown(owner, group, *filename) 0 end
+  ##% self.ctime(String or IO) -> Time
+  def self.ctime(filename) Time.new end
+  ##% self.delete(*String) -> Integer
+  def self.delete(*filename) 0 end
+  ##% self.unlink(*String) -> Integer
+  def self.unlink(*filename) 0 end
+  ##% self.directory?(String or IO) -> Boolean
+  def self.directory?(path) BOOLEAN end
+  ##% self.dirname(String) -> String
+  def self.dirname(filename) '' end
+  ##% self.executable?(String or IO) ->Boolean
+  def self.executable?(path) BOOLEAN end
+  ##% self.executable_real?(String or IO) ->Boolean
+  def self.executable_real?(path) BOOLEAN end
+  ##% self.exist?(String or IO) -> Boolean
+  def self.exist?(path) BOOLEAN end
+  ##% self.exists?(String or IO) -> Boolean
+  def self.exists?(path) BOOLEAN end
+  ##% self.expand_path(String, ?String) -> String
+  def self.expand_path(path, default_dir = '.') '' end
+  ##% self.extname(String) -> String
+  def self.extname(filename) '' end
+  ##% self.file?(String or IO) -> Boolean
+  def self.file?(path) BOOLEAN end
+  ##% self.fnmatch(String, String, ?Integer) -> Boolean
+  def self.fnmatch(pattern, path, flags = 0) BOOLEAN end
+  ##% self.fnmatch?(String, String, ?Integer) -> Boolean
+  def self.fnmatch?(pattern, path, flags = 0) BOOLEAN end
+  ##% self.ftype(String) -> String
+  def self.ftype(filename) '' end
+  ##% self.grpowned?(String or IO) -> Boolean
+  def self.grpowned?(filename) BOOLEAN end
+  ##% self.identical?(String or IO, String or IO) -> Boolean
+  def self.identical?(filename1, filename2) BOOLEAN end
+  ##% self.join(*String) -> String
+  def self.join(*item) '' end
+  ##% self.lchmod(Integer, *String) -> Integer
+  def self.lchmod(mode, *filename) 0 end
+  ##% self.lchown(Integer, Integer, *String) -> Integer
+  def self.lchown(owner, group, *filename) 0 end
+  ##% self.link(String, String) -> Integer
+  def self.link(old, new) 0 end
+  ##% self.lstat(String) -> File::Stat
+  def self.lstat(filename) File::Stat.new('') end
+  ##% self.mtime(String or IO) -> Time
+  def self.mtime(filename) Time.new end
+  ##% self.new(String or Integer, ?a, ?Integer) -> File
+  def self.new(path, mode = 'r', perm = 0666) File.new('') end
+  ##% self.open(String or Integer, ?a, ?Integer) -> File
+  ##% self.open(String or Integer, ?a, ?Integer) {File -> a} -> a
+  def self.open(path, mode = 'r', perm = 0666) File.new('') end
+  ##% self.owned?(String or IO) -> Boolean
+  def self.owned?(path) BOOLEAN end
+  ##% self.pipe?(String or IO) -> Boolean
+  def self.pipe?(path) BOOLEAN end
+  ##% self.readable?(String or IO) -> Boolean
+  def self.readable?(path) BOOLEAN end
+  ##% self.readable_real?(String or IO) -> Boolean
+  def self.readable_real?(path) BOOLEAN end
+  ##% self.readlink(String) -> String
+  def self.readlink(path) '' end
+  ##% self.rename(String, String) -> Integer
+  def self.rename(from, to) 0 end
+  ##% self.setgid?(String or IO) -> Boolean
+  def self.setgid?(path) BOOLEAN end
+  ##% self.setuid?(String or IO) -> Boolean
+  def self.setuid?(path) BOOLEAN end
+  ##% self.size(String or IO) -> Integer
+  def self.size(path) 0 end
+  ##% self.size?(String or IO) -> Boolean
+  def self.size?(path) BOOLEAN end
+  ##% self.socket?(String or IO) -> Boolean
+  def self.socket?(path) BOOLEAN end
+  ##% self.split(String) -> (String, String)
+  def self.split(pathname) ['', ''] end
+  ##% self.stat(String) -> File::Stat
+  def self.stat(filename) File::Stat.new('') end
+  ##% self.sticky?(String or IO) -> Boolean
+  def self.sticky?(path) BOOLEAN end
+  ##% self.symlink(String, String) -> Integer
+  def self.symlink(old, new) 0 end
+  ##% self.symlink?(String or IO) -> Boolean
+  def self.symlinky?(path) BOOLEAN end
+  ##% self.truncate(String, Integer) -> Integer
+  def self.truncate(path, length) 0 end
+  ##% self.umask(?Integer) -> Integer
+  def self.umask(umask = 0) 0 end
+  ##% self.utime(Time or Integer, Time or Integer, *String) -> Integer
+  def self.utime(atime, mtime, *filename) 0 end
+  ##% self.writable?(String or IO) -> Boolean
+  def self.writable?(path) BOOLEAN end
+  ##% self.writable_real?(String or IO) -> Boolean
+  def self.writable_real?(path) BOOLEAN end
+  ##% self.zero?(String or IO) -> Boolean
+  def self.zero?(path) BOOLEAN end
+
+  ##% atime() -> Time
+  def atime() Time.new end
+  ##% chmod(Integer) -> Integer
+  def chmod(mode) 0 end
+  ##% chown(Integer, Integer) -> Integer
+  def chown(owner, group) 0 end
+  ##% ctime() -> Time
+  def ctime() Time.new end
+  ##% flock(Integer) -> Integer or FalseClass
+  def flock(operation) 0 || false end
+  ##% lstat() -> File::Stat
+  def lstat() File::Stat.new('') end
+  ##% mtime() -> Time
+  def mtime() Time.new end
+  ##% path() -> String
+  def path() '' end
+  ##% truncate(Integer) -> Integer
+  def truncate(length) 0 end
+end
+
+module File::Constants
+  APPEND = 0
+  BINARY = 0
+  CREAT = 0
+  EXCL = 0
+  FNM_CASEFOLD = 0
+  FNM_DOTMATCH = 0
+  FNM_NOESCAPE = 0
+  FNM_PATHNAME = 0
+  FNM_SYSCASE = 0
+  LOCK_EX = 0
+  LOCK_NB = 0
+  LOCK_SH = 0
+  LOCK_UN = 0
+  NOCTTY = 0
+  NONBLOCK = 0
+  RDONLY = 0
+  RDWR = 0
+  SYNC = 0
+  TRUNC = 0
+  WRONLY = 0
+end
+
+class File::Stat
+  include Comparable
+
+  ##% self.new(String) -> File::Stat
+  def self.new(path) super() end
+
+  ##% "<=>"(File::Stat) -> Fixnum
+  def <=>(o) 0 end
+  ##% atime() -> Time
+  def atime() Time.new end
+  ##% blksize() -> Integer
+  def blksize() 0 end
+  ##% blockdev?() -> Boolean
+  def blockdev?() BOOLEAN end
+  ##% blocks() -> Integer
+  def blocks() 0 end
+  ##% chardev?() -> Boolean
+  def chardev?() BOOLEAN end
+  ##% ctime() -> Time
+  def ctime() Time.new end
+  ##% dev() -> Integer
+  def dev() 0 end
+  ##% dev_major() -> Integer
+  def dev_major() 0 end
+  ##% dev_minor() -> Integer
+  def dev_minor() 0 end
+  ##% directory?() -> Boolean
+  def directory?() BOOLEAN end
+  ##% executable?() -> Boolean
+  def executable?() BOOLEAN end
+  ##% executable_real?() -> Boolean
+  def executable_real?() BOOLEAN end
+  ##% file?() -> Boolean
+  def file?() BOOLEAN end
+  ##% ftype() -> String
+  def ftype() '' end
+  ##% gid() -> Integer
+  def gid() 0 end
+  ##% grpowned?() -> Boolean
+  def grpowned?() BOOLEAN end
+  ##% ino() -> Integer
+  def ino() 0 end
+  ##% mode() -> Integer
+  def mode() 0 end
+  ##% mtime() -> Time
+  def mtime() Time.new end
+  ##% nlink() -> Integer
+  def nlink() 0 end
+  ##% owned?() -> Boolean
+  def owned?() BOOLEAN end
+  ##% pipe?() -> Boolean
+  def pipe?() BOOLEAN end
+  ##% rdev() -> Integer
+  def rdev() 0 end
+  ##% rdev_major() -> Integer
+  def rdev_major() 0 end
+  ##% rdev_minor() -> Integer
+  def rdev_minor() 0 end
+  ##% readable?() -> Boolean
+  def readable?() BOOLEAN end
+  ##% readable_real?() -> Boolean
+  def readable_real?() BOOLEAN end
+  ##% setgid?() -> Boolean
+  def setgid?() BOOLEAN end
+  ##% setuid?() -> Boolean
+  def setuid?() BOOLEAN end
+  ##% size() -> Integer
+  def size() 0 end
+  ##% size?() -> Integer or nil
+  def size?() 0 || nil end
+  ##% socket?() -> Boolean
+  def socket?() BOOLEAN end
+  ##% sticky?() -> Boolean
+  def sticky?() BOOLEAN end
+  ##% symlink?() -> FalseClass
+  def symlink?() false end
+  ##% uid() -> Integer
+  def uid() 0 end
+  ##% writable?() -> Boolean
+  def writable?() BOOLEAN end
+  ##% writable_real?() -> Boolean
+  def writable_real?() BOOLEAN end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+end
+
+module FileTest
+  ##% self.blockdev?(String or IO) -> Boolean
+  def self.blockdev?(path) BOOLEAN end
+  ##% self.chardev?(String or IO) -> Boolean
+  def self.chardev?(path) BOOLEAN end
+  ##% self.directory?(String or IO) -> Boolean
+  def self.directory?(path) BOOLEAN end
+  ##% self.executable?(String or IO) ->Boolean
+  def self.executable?(path) BOOLEAN end
+  ##% self.executable_real?(String or IO) ->Boolean
+  def self.executable_real?(path) BOOLEAN end
+  ##% self.exist?(String or IO) -> Boolean
+  def self.exist?(path) BOOLEAN end
+  ##% self.exists?(String or IO) -> Boolean
+  def self.exists?(path) BOOLEAN end
+  ##% self.file?(String or IO) -> Boolean
+  def self.file?(path) BOOLEAN end
+  ##% self.grpowned?(String or IO) -> Boolean
+  def self.grpowned?(filename) BOOLEAN end
+  ##% self.identical?(String or IO, String or IO) -> Boolean
+  def self.identical?(filename1, filename2) BOOLEAN end
+  ##% self.owned?(String or IO) -> Boolean
+  def self.owned?(path) BOOLEAN end  ##% self.setgid?(String or IO) -> Boolean
+  ##% self.setgid?(String or IO) -> Boolean
+  def self.setgid?(path) BOOLEAN end
+  ##% self.setuid?(String or IO) -> Boolean
+  def self.setuid?(path) BOOLEAN end
+  ##% self.size(String or IO) -> Integer
+  def self.size(path) 0 end
+  ##% self.size?(String or IO) -> Boolean
+  def self.size?(path) BOOLEAN end
+  ##% self.socket?(String or IO) -> Boolean
+  def self.socket?(path) BOOLEAN end
+  ##% self.sticky?(String or IO) -> Boolean
+  def self.sticky?(path) BOOLEAN end
+  ##% self.writable?(String or IO) -> Boolean
+  def self.writable?(path) BOOLEAN end
+  ##% self.writable_real?(String or IO) -> Boolean
+  def self.writable_real?(path) BOOLEAN end
+  ##% self.zero?(String or IO) -> Boolean
+  def self.zero?(path) BOOLEAN end
+end
+
+class Fixnum
+  ### Numeric
+  ##% +@() -> self
+  def +@() self end
+  ##% -@() -> Fixnum
+  def -@() 0 end
+  ##% "<=>"(other) -> Fixnum
+  def <=>(other) 0 end
+  ##% abs() -> Fixnum
+  def abs() self end
+  ##% ceil() -> Fixnum
+  def ceil() 0 end
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% coerce(Float) -> (Float, Float)
+  ##% coerce(Numeric) -> (Fixnum, Fixnum)
+  def coerce(other) [0.0, 0.0] end
+  ##% div(Numeric) -> Fixnum
+  def div(other) 0 end
+  ##% divmod(Numeric) -> (Fixnum, Numeric)
+  def divmod(other) [0, 0] end
+  ##% eql?(Numeric) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% quo(Numeric) -> Float
+  def quo(other) 0.0 end
+  ##% fdiv(Numeric) -> Float
+  def fdiv(other) 0.0 end
+  ##% floor() -> Fixnum
+  def floor() 0 end
+  ##% integer?() -> Boolean
+  def integer?() BOOLEAN end
+  ##% modulo(Numeric) -> Fixnum
+  def modulo(other) 0 end
+  ##% nonzero?() -> self
+  def nonzero?() self end
+  ##% remainder(Numeric) -> Fixnum
+  def remainder(other) 0 end
+  ##% round() -> Fixnum
+  def round() 0 end
+  ##% step<a | a <= Numeric>(Numeric, ?a) {self or a or Fixnum -> ?} -> self
+  ##% step<a | a <= Numeric>(Numeric, ?a) -> Enumerator<self, self or a or Fixnum>
+  def step(limit, step = 1) self end
+  ##% to_int() -> Fixnum
+  def to_int() 0 end
+  ##% truncate() -> Fixnum
+  def truncate() 0 end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+
+  ### Fixnum
+  ##% id2name() -> String
+  def id2name() '' end
+  ##% to_sym() -> Symbol
+  def to_sym() :a end
+end
+
+class Float
+  DIG = 0
+  EPSILONG = 0.0
+  MANT_DIG = 0
+  MAX = 0.0
+  MAX_10_EXP = 0
+  MAX_EXP = 0
+  MIN = 0.0
+  MIN_10_EXP = 0
+  MIN_EXP = 0
+  RADIX = 0
+  ROUNDS = 0
+
+  include Precision
+
+  ### Precision
+  ##% self.induced_from(a) -> Float
+  def self.induced_from(number) 0.0 end
+  ##% prec(Class) -> Float
+  def prec(klass) 0.0 end
+
+  ### Numeric
+  ##% +@() -> self
+  def +@() self end
+  ##% -@() -> Float
+  def -@() 0 end
+  ##% "<=>"(other) -> Fixnum
+  def <=>(other) 0 end
+  ##% abs() -> Float
+  def abs() self end
+  ##% ceil() -> Integer
+  def ceil() 0 end
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% coerce(Numeric) -> (Float, Float)
+  def coerce(other) [0.0, 0.0] end
+  ##% div(Numeric) -> Float
+  def div(other) 0.0 end
+  ##% divmod(Numeric) -> (Float, Numeric)
+  def divmod(other) [0, 0] end
+  ##% eql?(Numeric) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% quo(Numeric) -> Float
+  def quo(other) 0.0 end
+  ##% fdiv(Numeric) -> Float
+  def fdiv(other) 0.0 end
+  ##% floor() -> Integer
+  def floor() 0 end
+  ##% integer?() -> Boolean
+  def integer?() BOOLEAN end
+  ##% modulo(Numeric) -> Float
+  def modulo(other) 0.0 end
+  ##% nonzero?() -> self
+  def nonzero?() self end
+  ##% remainder(Numeric) -> Float
+  def remainder(other) 0.0 end
+  ##% round() -> Fixnum
+  def round() 0 end
+  ##% step<a | a <= Numeric>(Numeric, ?a) {self or a or Fixnum -> ?} -> self
+  ##% step<a | a <= Numeric>(Numeric, ?a) -> Enumerator<self, self or a or Fixnum>
+  def step(limit, step = 1) self end
+  ##% to_int() -> Integer
+  def to_int() 0 end
+  ##% truncate() -> Integer
+  def truncate() 0 end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+
+  ### Integer
+  ##% %(Numeric) -> Float
+  def %(other) 0.0 end
+  ##% "*"(Numeric) -> Float
+  def *(other) 0.0 end
+  ##% "**"(Numeric) -> Float
+  def **(other) 0.0 end
+  ##% +(Numeric) -> Float
+  def +(other) 0.0 end
+  ##% -(Numeric) -> Float
+  def -(other) 0.0 end
+  ##% /(Numeric) -> Float
+  def /(other) 0.0 end
+  ##% finite?() -> Boolean
+  def finite?() BOOLEAN end
+  ##% hash() -> Fixnum
+  def hash() 0 end
+  ##% infinite?() -> Fixnum
+  def infinite?() 0 end
+  ##% nan?() -> Boolean
+  def nan?() BOOLEAN end
+  ##% to_f() -> self
+  def to_f() self end
+end
+
+module GC
+  ##% self.disable() -> Boolean
+  def disable() BOOLEAN end
+  ##% self.enable() -> Boolean
+  def enable() BOOLEAN end
+  ##% start() -> nil
+  def start() end
+  ##% stress() -> Boolean
+  def stress() BOOLEAN end
+  ##% stress=(Boolean) -> nil
+  def stress=(value) end
+
+  ##% garbase_collect() -> nil
+  def garbase_collect() end
+end
+
+##% Hash<k, v, z | (k, v) <= t>
+class Hash
+  include Enumerable
+
+  # FIXME
+  ##% self.[](Hash<k', v', z'>) -> Hash<k', v', z'>
+  ##% self.[](?k1, ?v1, ?k2, ?v2, ?k3, ?v3, ?k4, ?v4, ?k5, ?v5) -> Hash<k1 or k2 or k3 or k4 or k5, v1 or v2 or v3 or v4 or v5>
+  def self.[](*) {} end
+  # FIXME
+  ##% self.new(?z') -> Hash<?, ?, z'>
+  ##% self.new() {(k', v') -> ?} -> Hash<?, ?, ?>
+  def self.new(*) {} end
+
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ===(a) -> Boolean
+  def ===(other) BOOLEAN end
+  ##% eql?(a) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% [](a) -> v
+  def [](key) _v end
+  ##% []=<v' | v' <= v>(k, v') -> v'
+  def []=(key, value) value end
+  ##% store(k, v) -> v
+  def store(key, value) value end
+  # FIXME
+  def clear() self end
+  # FIXME
+  ##% clone() -> Hash<k, v, z>
+  def clone() self end
+  alias :dup :clone
+  ##% default(?a) -> d or a
+  def default(key = nil) end
+  ##% default=<d | d <= z>(d) -> d
+  def default=(value) value end
+  # FIXME
+  def default_proc() end
+  ##% delete(a) -> v
+  ##% delete(a) {a -> b} -> b
+  def delete(key) _v end
+  ##% delete_if() -> Enumerator<self, (k, v)>
+  ##% delete_if() {(k, v) -> ?} -> self
+  def delete_if() self end
+  alias :reject! :delete_if
+  ##% each() {(k, v) -> ?} -> self
+  ##% each() -> Enumerator<self, (k, v)>
+  def each() yield _k, _v; self end
+  alias :each_pair :each
+  ##% each_key() {k -> ?} -> self
+  ##% each_key() -> Enumerator<self, k>
+  def each_key() yield _k; self end
+  ##% each_value() {v -> ?} -> self
+  ##% each_value() -> Enumerator<self, v>
+  def each_value() yield _v; self end
+  ##% empty?() -> Boolean
+  def empty?() BOOLEAN end
+  ##% equal?(a) -> Boolean
+  def equal?(other) BOOLEAN end
+  ##% fetch(a, ?b) -> v or b
+  ##% fetch(a) {a -> b} -> v or b
+  def fetch(key) _v end
+  ##% has_key?(a) -> Boolean
+  def has_key(key) BOOLEAN end
+  alias :include? :has_key?
+  alias :key? :has_key?
+  alias :member? :has_key?
+  ##% has_value?(a) -> Boolean
+  def has_value?(value) BOOLEAN end
+  alias :value? :has_value?
+  ##% hash() -> Integer
+  def hash() 0 end
+  ##% index(a) -> k
+  def index(val) _k end
+  ##% indexes(*a) -> Array<v>
+  def indexes(*index) [_v] end
+  alias :indices :indexes
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% invert() -> Hash<v, k>
+  def invert() {_v => _k} end
+  ##% keys() -> Array<k>
+  def keys() [_k] end
+  ##% length() -> Integer
+  def length() 0 end
+  alias :size :length
+  ##% merge<a | a <= Hash<k', v', z'> >(a) -> Hash<k or k', v or v', z or z'>
+  ##% merge<a | a <= Hash<k', v', z'> >(a) {(k, v, v') -> v''} -> Hash<k or k', v'', z or z'>
+  def merge(other) self end
+  ##% merge!<a | a <= Hash<k, v, z> >(a) -> self
+  ##% merge!<a | a <= Hash<k, v', z>, v'' <= v>(a) {(k, v, v') -> v''} -> self
+  def merge!(other) self end
+  ##% rehash() -> self
+  def rehash() self end
+  ##% reject() {(k, v) -> ?} -> Hash<k, v>
+  ##% reject() -> Enumerator<Hash<k, v>, (k, v)> >
+  def reject() self end
+  ##% replace<a | a <= Hash<k, v, z> >(a) -> self
+  def replace(other) self end
+  ##% select() -> Enumerator<Array<(k, v)>, (k, v)>
+  ##% select() {(k, v) -> ?} -> Array<(k, v)>
+  def select() yield _k, _v; [_k, _v] end
+  ##% shift() -> (k, v) or z
+  def shift() [_k, _v] end
+  ##% sort() -> Array<(k, v)>
+  ##% sort() {(k, v) -> ?} -> Array<k, v>
+  def sort() [[_k, _v]] end
+  ##% to_a() -> Array<(k, v)>
+  def to_a() [[_k, _v]] end
+  ##% to_hash() -> self
+  def to_hash() self end
+  ##% update<a | a <= Hash<k, v, z> >(a) -> self
+  ##% update<a | a <= Hash<k, v', z>, v'' <= v>(a) {(k, v, v') -> v''} -> self
+  def update(other) self end
+  ##% values() -> Array<v>
+  def values() [_v] end
+  ##% values_at(*a) -> Array<v or z>
+  def values_at(*key) [_v] end
+
+  private
+  # Special methods for internal use
+  ##% _k() -> k
+  def _k() end
+  ##% _v() -> v
+  def _v() end
+end
+
+##% IO<| t <= String>
+class IO
+  SEEK_CUR = 0
+  SEEK_END = 0
+  SEEK_SET = 0
+
+  include Enumerable
+
+  ##% self.new(Integer, ?a) -> IO
+  def self.new(fd, mode = 'r') IO.new(0) end
+  ##% self.for_fd(Integer, ?a) -> IO
+  def self.for_fd(fd, mode = 'r') IO.new(0) end
+  ##% self.open(Integer, ?a) -> IO
+  ##% self.open(Integer, ?a) {IO -> b} -> b
+  def self.open(fd, mode = 'r') IO.new(0) end
+  ##% self.foreach(String, ?String) {String -> ?} -> nil
+  ##% self.foreach(String, ?String) -> Enumerator<nil, String>
+  def self.foreach(path, rs = $/) yield ''; nil end
+  ##% self.pipe() -> (IO, IO)
+  def self.pipe() [IO.new(0), IO.new(0)] end
+  ##% self.popen(String, ?a) -> IO
+  ##% self.popen(String, ?a) {IO -> b} -> b
+  def self.popen(command, mode = 'r') IO.new(0) end
+  ##% self.read(String, ?Integer, ?Integer) -> String
+  def self.read(path, length = nil, offset = 0) '' end
+  ##% self.readlines(String, ?String) -> Array<String>
+  def self.readlines(path, rs = $/) [''] end
+  ##% self.select(Array<IO>, ?Array<IO>, ?Array<IO>, ?Integer) -> (Array<IO>, Array<IO>, Array<IO>)
+  def self.select(reads, writes = [], excepts = [], timeout = nil) [[IO.new(0)], [IO.new(0)], [IO.new(0)]] end
+  ##% self.sysopen(String, ?a, ?Integer) -> Integer
+  def self.sysopen(path, mode = 'r', perm = 0666) 0 end
+
+  # FIXME to_s
+  ##% "<<"(a) -> self
+  def <<(object) self end
+  ##% binmode() -> self
+  def binmode() self end
+  ##% bytes() -> Enumerator<self, Fixnum>
+  def bytes() Enumerator.new end
+  ##% each_char() {Fixnum -> ?} -> self
+  ##% each_char() -> Enumerator<self, Fixnum>
+  def each_char() yield 0; self end
+  alias :chars :each_char
+  ##% clone() -> IO
+  def clone() self end
+  alias :dup :clone
+  ##% close() -> nil
+  def close() end
+  ##% close_read() -> nil
+  def close_read() end
+  ##% close_write() -> nil
+  def close_write() end
+  ##% closed?() -> Boolean
+  def closed?() BOOLEAN end
+  ##% each(?String) {String -> ?} -> self
+  ##% each(?String) -> Enumerator<self, String>
+  def each(rs = $/) yield ''; self end
+  alias :each_line :each
+  ##% each_byte() {Fixnum -> ?} -> self
+  ##% each_byte() -> Enumerator<self, Fixnum>
+  def each_byte() yield 0; self end
+  ##% eof() -> Boolean
+  def eof() BOOLEAN end
+  alias :eof? :eof
+  ##% fcntl(Integer, ?(Integer or String or Boolean)) -> Integer
+  def fcntl(cmd, arg = 0) 0 end
+  ##% fileno() -> Integer
+  def fileno() 0 end
+  alias :to_i :fileno
+  ##% flush() -> self
+  def flush() self end
+  ##% fsync() -> Integer
+  def fsync() 0 end
+  ##% getbyte() -> Fixnum
+  def getbyte() 0 end
+  ##% getc() -> Fixnum
+  def getc() 0 end
+  ##% gets(?String) -> String
+  def gets(rs = $/) '' end
+  ##% ioctl(Integer, ?(Integer or String or Boolean)) -> Integer
+  def ioctl(cmd, arg = 0) 0 end
+  ##% isatty() -> Boolean
+  def isatty() BOOLEAN end
+  alias :tty? :isatty
+  ##% lineno() -> Integer
+  def lineno() 0 end
+  ##% lineno=(Integer) -> nil
+  def lineno=(number) end
+  ##% lines(?String) -> Enumerator<self, String>
+  def lines(rs = $/) Enumerator.new end
+  ##% pid() -> Integer
+  def pid() 0 end
+  ##% pos() -> Integer
+  alias :tell :pos
+  ##% pos=(Integer) -> Integer
+  def pos=(n) end
+  ##% print(*a) -> nil
+  def print(*arg) end
+  ##% printf(String, *a) -> nil
+  def printf(format, *arg) end
+  ##% putc<c | c <= Integer>(c) -> c
+  def putc(ch) ch end
+  ##% puts(*a) -> nil
+  def puts(*obj) end
+  ##% read(?Integer, ?String) -> String
+  def read(length = nil, outbuf = '') '' end
+  ##% read_nonblock(Integer, ?String) -> String
+  def read_nonblock(maxlen, outbuf = '') '' end
+  ##% readbyte() -> Fixnum
+  def readbyte() 0 end
+  ##% readchar() -> Fixnum
+  def readchar() 0 end
+  ##% readline(?String) -> String
+  def readline(rs = $/) '' end
+  ##% readlines(?String) -> Array<String>
+  def readlines(rs = $/) [''] end
+  ##% readpartial(?Integer, ?String) -> String
+  def readpartial(maxlen, outbuf = '') '' end
+  ##% reopen(IO) -> self
+  ##% reopen(String, ?a) -> self
+  def reopen(*) self end
+  ##% rewind() -> Integer
+  def rewind() 0 end
+  ##% seek(Integer, ?Fixnum) -> Fixnum
+  def seek(offset, whence = IO::SEEK_SET) 0 end
+  ##% stat() -> File::Stat
+  def stat() File::Stat.new('') end
+  ##% sync() -> Boolean
+  def sync() BOOLEAN end
+  ##% sync=(Boolean) -> Boolean
+  def sync=(newstate) newstate end
+  ##% sysread(Integer, ?String) -> String
+  def sysread(maxlen, outbuf = '') '' end
+  ##% sysseek(Integer, ?Fixnum) -> Fixnum
+  def sysseek(offset, whence = IO::SEEK_SET) 0 end
+  # FIXME to_s
+  ##% syswrite(a) -> Integer
+  def syswrite(string) 0 end
+  ##% to_io() -> self
+  def to_io() self end
+  ##% ungetc(a) -> nil
+  def ungetc(char) end
+  # FIXME to_s
+  ##% write(a) -> Integer
+  def write(str) 0 end
+  # FIXME to_s
+  ##% write_nonblock(a) -> Integer
+  def write_nonblock(str) 0 end
+end
+
+class Integer
+  include Precision
+
+  ### Precision
+  ##% self.induced_from(a) -> Fixnum
+  def self.induced_from(number) 0 end
+  ##% prec(Class) -> Fixnum
+  def prec(klass) 0 end
+
+  ### Numeric
+  ##% +@() -> self
+  def +@() self end
+  ##% -@() -> Integer
+  def -@() 0 end
+  ##% "<=>"(other) -> Fixnum
+  def <=>(other) 0 end
+  ##% abs() -> Integer
+  def abs() self end
+  ##% ceil() -> Integer
+  def ceil() 0 end
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% coerce(Float) -> (Float, Float)
+  ##% coerce(Numeric) -> (Integer, Integer)
+  def coerce(other) [0.0, 0.0] end
+  ##% div(Numeric) -> Integer
+  def div(other) 0 end
+  ##% divmod(Numeric) -> (Integer, Integer)
+  def divmod(other) [0, 0] end
+  ##% eql?(Numeric) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% quo(Numeric) -> Float
+  def quo(other) 0.0 end
+  ##% fdiv(Numeric) -> Float
+  def fdiv(other) 0.0 end
+  ##% floor() -> Integer
+  def floor() 0 end
+  ##% integer?() -> Boolean
+  def integer?() BOOLEAN end
+  ##% modulo(Numeric) -> Integer
+  def modulo(other) 0 end
+  ##% nonzero?() -> self
+  def nonzero?() self end
+  ##% remainder(Numeric) -> Integer
+  def remainder(other) 0 end
+  ##% round() -> Integer
+  def round() 0 end
+  ##% step<a | a <= Numeric>(Numeric, ?a) {self or a or Fixnum -> ?} -> self
+  ##% step<a | a <= Numeric>(Numeric, ?a) -> Enumerable::Enumerator<self, self or a or Fixnum>
+  def step(limit, step = 1) self end
+  ##% to_int() -> Integer
+  def to_int() 0 end
+  ##% truncate() -> Integer
+  def truncate() 0 end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+
+  ### Integer
+  ##% %(Numeric) -> Fixnum or Bignum
+  def %(other) 0 end
+  ##% &(Numeric) -> Fixnum or Bignum
+  def &(other) 0 end
+  ##% "*"(Float) -> Float
+  ##% "*"(Integer) -> Fixnum or Bignum
+  def *(other) 0 end
+  ##% "**"(Float) -> Float
+  ##% "**"(Integer) -> Fixnum or Bignum
+  def **(other) 0 end
+  ##% +(Float) -> Float
+  ##% +(Integer) -> Fixnum or Bignum
+  def +(other) 0 end
+  ##% -(Float) -> Float
+  ##% -(Integer) -> Fixnum or Bignum
+  def -(other) 0 end
+  ##% /(Float) -> Float
+  ##% /(Integer) -> Fixnum or Bignum
+  def /(other) 0 end
+  ##% ">>"(Integer) -> Fixnum or Bignum
+  def >>(bits) 0 end
+  ##% [](Integer) -> Fixnum
+  def [](nth) 0 end
+  ##% ^(Integer) -> Fixnum or Bignum
+  def ^(other) 0 end
+  ##% chr() -> String
+  def chr() '' end
+  ##% downto(Numeric) {self -> ?} -> self
+  ##% downto(Numeric) -> Enumerator<self, self>
+  def downto(limit, step = 1) self end
+  ##% even?() -> Boolean
+  def even?() BOOLEAN end
+  ##% integer?() -> TrueClass
+  def integer?() true end
+  ##% next() -> Fixnum or Bignum
+  def next() 0 end
+  alias :succ :next
+  ##% odd?() -> Boolean
+  def odd?() BOOLEAN end
+  ##% ord() -> self
+  def ord() self end
+  ##% pred() -> Fixnum or Bignum
+  def pred() 0 end
+  ##% size() -> Fixnum
+  def size() 0 end
+  ##% times() {self -> ?} -> self
+  ##% times() -> Enumerator<self, self>
+  def times() yield self end
+  ##% to_f() -> Float
+  def to_f() 0.0 end
+  ##% to_i() -> self
+  def to_i() self end
+  alias :to_int :to_i
+  ##% to_s(?Integer) -> String
+  def to_s(base = nil) '' end
+  ##% upto(Numeric) {self -> ?} -> self
+  ##% upto(Numeric) -> Enumerator<self, self>
+  def upto(limit, step = 1) self end
+  ##% "|"(Numeric) -> Fixnum or Bignum
+  def |(other) 0 end
+  ##% ~() -> Fixnum or Bignum
+  def ~() 0 end
+end
+
+module Kernel
+  private
+
+  ### Constants
+  ARGF = IO.new(0)
+  ARGV = ['']
+  DATA = File.new('')
+  ENV = Hash['', '']
+  FALSE = false
+  NIL = nil
+  PLATFORM = ''
+  RELEASE_DATE = ''
+  RUBY_COPYRIGHT = ''
+  RUBY_DESCRIPTION = ''
+  RUBY_PATCHLEVEL = 0
+  RUBY_PLATFORM = ''
+  RUBY_RELEASE_DATE = ''
+  RUBY_VERSION = ''
+  SCRIPT_LINES__ = {}
+  STDERR = IO.new(0)
+  STDIN = IO.new(0)
+  STDOUT = IO.new(0)
+  TOPLEVEL_BINDING = Binding.new
+  TRUE = true
+  VERSION = ''
+
+  ### Global Variables
+  $! = Exception.new
+  $" = ['']
+  $LOADED_FEATURES = $"
+  $$ = 0
+  #$& = ''
+  #$' = ''
+  $* = ['']
+  #$+ = ''
+  $, = ''
+  $/ = ''
+  $-0 = ''
+  $; = // || ''
+  $-F = $;
+  $: = ['']
+  $LOAD_PATH = $:
+  $-I = $:
+  $KCODE = ''
+  $-K = ''
+  $-a = BOOLEAN
+  $DEBUG = BOOLEAN
+  $-d = BOOLEAN
+  $-i = BOOLEAN
+  $-l = BOOLEAN
+  $-p = BOOLEAN
+  $VERBOSE = BOOLEAN
+  $-v = BOOLEAN
+  $-w = BOOLEAN
+  $. = 0
+  $0 = ''
+  $PROGRAM_NAME = ''
+  #$1 = ''
+  #$2 = ''
+  #$3 = ''
+  #$4 = ''
+  #$5 = ''
+  #$6 = ''
+  #$7 = ''
+  #$8 = ''
+  #$9 = ''
+  #$10 = ''
+  #$11 = ''
+  $< = IO.new(0)
+  $= = BOOLEAN
+  $> = IO.new(0)
+  $stdout = $>
+  $defout = $stdout
+  $? = Process::Status.new
+  $@ = ['']
+  $FILENAME = ''
+  $SAFE = 0
+  $\ = ''
+  $_ = ''
+  #$` = ''
+  $stderr = IO.new(0)
+  $deferr = $stderr
+  $stdin = IO.new(0)
+  $~ = MatchData
+
+  ### Module Methods
+  # FIXME to_ary
+  ##% Array<a | a <= Array>(a) -> a
+  ##% Array(a) -> a
+  def Array(arg) [] end
+  ##% Float(a) -> Float
+  def Float(arg) 0.0 end
+  ##% Integer(a) -> Integer
+  def Integer(arg) 0 end
+  ##% String(a) -> String
+  def String(arg) '' end
+  ##% __method__() -> Symbol
+  def __method__() :a end
+  ##% `(command) -> String
+  def `(command) '' end         # `
+  ##% abort(?String) -> nil
+  def abort(message = $!.message) end
+  ##% at_exit() {() -> ?} -> Proc
+  def at_exit() Proc.new end
+  ##% autoload(String or Symbol, String) -> nil
+  def autoload(const_name, feature) end
+  ##% autoload?(String or Symbol) -> String
+  def autoload?(const_name) '' end
+  ##% binding() -> Binding
+  def binding() Binding.new end
+  ##% block_given?() -> Boolean
+  def block_given() BOOLEAN end
+  alias :iterator? :block_given?
+  # FIXME
+  ##% callcc() {Continuation -> ?} -> ?
+  def callcc() end
+  ##% caller(?Integer) -> Array<String>
+  def caller(level_num = 1) [''] end
+  # FIXME
+  ##% catch(a) {a -> ?} -> ?
+  def catch(tag) yield tag end
+  ##% chomp(?String) -> String
+  def chomp(rs = $/) '' end
+  ##% chomp!(?String) -> String
+  def chomp!(rs = $/) '' end
+  ##% chop() -> String
+  def chop() '' end
+  ##% chop!() -> String
+  def chop() '' end
+  ##% eval(String, ?Proc or Binding, ?String, ?Integer) -> ?
+  def eval(expr, bind = nil, fname = __FILE__, lineno = 1) end
+  ##% exec(String) -> nil
+  ##% exec(String, *String) -> nil
+  def exec(command) end
+  ##% exit(Integer or Boolean) -> nil
+  def exit(status = true) end
+  ##% exit!(Integer or Boolean) -> nil
+  def exit!(status = true) end
+  # FIXME
+  ##% raise() -> nil
+  ##% raise(String) -> nil
+  ##% raise(?, ?String, Array<String>) -> nil
+  def raise(*) end
+  alias :fail :raise
+  ##% fork() -> Integer
+  ##% fork() {() -> ?} -> Integer
+  def fork() yield end
+  ##% sprintf(String, *a) -> String
+  def sprintf(format, *arg) '' end
+  alias :format :sprintf
+  ##% getc() -> Fixnum
+  def getc() 0 end
+  ##% gets(?String) -> String
+  def gets(rs = $/) '' end
+  ##% global_variables() -> Array<String>
+  def global_variables() [''] end
+  ##% gsub(String or Regexp, String) -> String
+  ##% gsub(String or Regexp) {String -> ?} -> String
+  ##% gsub(String or Regexp) -> Enumerator<String, String>
+  def gsub(pattern, replace = nil) '' end
+  ##% gsub!(String or Regexp, String) -> self
+  ##% gsub!(String or Regexp) {String -> ?} -> self
+  ##% gsub!(String or Regexp) -> Enumerator<String, self>
+  def gsub!(pattern, replace = nil) self end
+  # skelton
+  def proc() Proc.new end
+  alias :lambda :proc
+  ##% load(String, ?Boolean) -> TrueClass
+  def load(file, priv = false) true end
+  ##% local_varaibles() -> Array<String>
+  def local_varaibles() [''] end
+  ##% loop() {() -> a} -> a
+  def loop() yield end
+  ##% open(String or Integer, ?a, ?Integer) -> IO
+  ##% open(String or Integer, ?a, ?Integer) {IO -> ?} -> nil
+  def open(name, mode = 'r', perm = nil) IO.new(0) end
+  ##% p(*a) -> nil
+  def p(*arg) end
+  ##% print(*a) -> nil
+  def p(*arg) end
+  ##% printf(String, *a) -> nil
+  ##% printf(IO, String, *a) -> nil
+  def printf(*) end
+  ##% putc<a | a <= Integer or String>(a) -> a
+  def putc(ch) ch end
+  ##% puts(*a) -> nil
+  def puts(*arg) end
+  ##% rand(?Numeric) -> Integer or Float
+  def rand(max = 0) 0 || 0.0 end
+  ##% readline(?String) -> String
+  def readline(rs = $/) '' end
+  ##% readlines(?String) -> Array<String>
+  def readlines(rs = $/) [''] end
+  ##% require(String) -> Boolean
+  def require(feature) BOOLEAN end
+  ##% require_relative(String) -> Boolean
+  def require_relative(feature) BOOLEAN end
+  ##% scan(String or Regexp) -> Array<String> or Array<Array<String> >
+  ##% scan(String or Regexp) {String -> ?} -> self
+  def scan(re) [''] || [['']] end
+  ##% select(Array<IO>, ?Array<IO>, ?Array<IO>, ?Integer) -> (Array<IO>, Array<IO>, Array<IO>)
+  def select(reads, writes = [], excepts = [], timeout = nil) [[IO.new(0)], [IO.new(0)], [IO.new(0)]] end
+  def set_trace_func(*) end
+  ##% sleep(?Numeric) -> Integer
+  def sleep(sec = 0) 0 end
+  ##% split(?(String or Regexp), ?Integer) -> Array<String> or Array<Array<String> >
+  def split(sep = $;, limit = 0) [''] || [['']] end
+  ##% srand(?a) -> Integer
+  def srand(seed = nil) 0 end
+  ##% sub(String or Regexp, String) -> String
+  ##% sub(String or Regexp) {String -> ?} -> String
+  ##% sub(String or Regexp) -> Enumerator<String, String>
+  def sub(pattern, replace = nil) '' end
+  ##% sub!(String or Regexp, String) -> self
+  ##% sub!(String or Regexp) {String -> ?} -> self
+  ##% sub!(String or Regexp) -> Enumerator<String, self>
+  def sub!(pattern, replace = nil) self end
+  ##% syscall(Integer, *(String or Integer)) -> Integer
+  def syscall(num, *arg) 0 end
+  ##% system(String) -> Boolean
+  ##% system(String, *String) -> Boolean
+  def system(*) BOOLEAN end
+  ##% test(String or Integer, File) -> Boolean or Time or Integer
+  ##% test(String or Integer, File, File) -> Boolean
+  def test(cmd, file1, file2 = nil) BOOLEAN or Time.new or 0 end
+  # FIXME
+  ##% throw(a, ?b) -> nil
+  def throw(tag, value = nil) end
+  def trace_var(*) end
+  ##% trap(String or Symbol or Integer, String or Process) -> ?
+  ##% trap(String or Symbol or Integer) {() -> ?} -> ?
+  def trap(signal, command = nil) end
+  def untrace_var(*) end
+  ##% warn(a) -> nil
+  def warn(message) end
+end
+
+module Marshal
+  MAJOR_VERSION = 0
+  MINOR_VERSION = 0
+
+  ##% dump(Object, ?(IO or String), ?Integer) -> IO or String
+  def dump(obj, port = '', limit = -1) IO.new(0) || '' end
+  ##% load(IO or String, ?Proc) -> Object
+  def load(port, proc = nil) Object.new end
+end
+
+class MatchData
+  ##% [](Integer) -> String
+  ##% [](Range) -> String
+  ##% [](Integer, Integer) -> Array<String>
+  def [](*) '' end
+  ##% begin(Integer) -> Fixnum
+  def begin(n) 0 end
+  ##% captures() -> Array<String>
+  def captures() [''] end
+  ##% end(Integer) -> Fixnum
+  def end(n) 0 end
+  ##% end(Integer) -> Fixnum
+  def end(n) 0 end
+  ##% length() -> Fixnum
+  def length() 0 end
+  alias :size :length
+  ##% offset(Integer) -> Fixnum
+  def offset(n) 0 end
+  ##% post_match() -> String
+  def post_match() '' end
+  ##% pre_match() -> String
+  def pre_match() '' end
+  ##% select() {Strign -> ?} -> Array<String>
+  def select() yield ''; [''] end
+  ##% string() -> String
+  def string() '' end
+  ##% to_a() -> Array<String>
+  def to_a() [''] end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% values_at(*Integer) -> Array<String>
+  def values_at(*idnex) [''] end
+end
+
+module Math
+  E = 0.0
+  PI = 0.0
+
+  module_function
+
+  ##% acos(Integer or Float) -> Float
+  def acos(x) 0.0 end
+  ##% acosh(Integer or Float) -> Float
+  def acosh(x) 0.0 end
+  ##% asin(Integer or Float) -> Float
+  def asin(x) 0.0 end
+  ##% asinh(Integer or Float) -> Float
+  def asinh(x) 0.0 end
+  ##% atan(Integer or Float) -> Float
+  def atan(x) 0.0 end
+  ##% atan2(Integer or Float) -> Float
+  def atan2(x) 0.0 end
+  ##% atanh(Integer or Float) -> Float
+  def atanh(x) 0.0 end
+  ##% cos(Integer or Float) -> Float
+  def cos(x) 0.0 end
+  ##% cosh(Integer or Float) -> Float
+  def cosh(x) 0.0 end
+  ##% erf(Integer or Float) -> Float
+  def erf(x) 0.0 end
+  ##% erfc(Integer or Float) -> Float
+  def erfc(x) 0.0 end
+  ##% exp(Integer or Float) -> Float
+  def exp(x) 0.0 end
+  ##% frexp(Integer or Float) -> (Float, Fixnum)
+  def frexp(x) [0.0, 0] end
+  ##% hypot(Integer or Float, Integer or Float) -> Float
+  def hypot(x, y) 0.0 end
+  ##% ldexp(Integer or Float, Integer) -> Float
+  def ldexp(x, exp) 0.0 end
+  ##% log(Integer or Float) -> Float
+  def log(x) 0.0 end
+  ##% log10(Integer or Float) -> Float
+  def log10(x) 0.0 end
+  ##% sin(Integer or Float) -> Float
+  def sin(x) 0.0 end
+  ##% sinh(Integer or Float) -> Float
+  def sinh(x) 0.0 end
+  ##% sqrt(Integer or Float) -> Float
+  def sqrt(x) 0.0 end
+  ##% tan(Integer or Float) -> Float
+  def tan(x) 0.0 end
+  ##% tanh(Integer or Float) -> Float
+  def tanh(x) 0.0 end
+end
+
+class Method
+  # FIXME
+end
+
+class Module
+  ##% self.constants() -> Array<String>
+  def self.constants() [''] end
+  ##% self.nesting() -> Array<Module or Class>
+  def self.nesting() [Module.new || Class.new] end
+  ##% self.new() -> Module
+  ##% self.new() {Module -> ?} -> Module
+  def self.new() super end
+
+  ##% "<"(Module) -> Boolean
+  def <(other) BOOLEAN end
+  ##% "<="(Module) -> Boolean
+  def <=(other) BOOLEAN end
+  ##% "<=>"(Module) -> Integer
+  def <=>(other) 0 end
+  ##% ===(other) -> Boolean
+  def ===(other) BOOLEAN end
+  ##% ">"(Module) -> Boolean
+  def >(other) BOOLEAN end
+  ##% ">="(Module) -> Boolean
+  def >=(other) BOOLEAN end
+  ##% ancestors() -> Array<Module or Class>
+  def ancestors() [Module.new || Class.new] end
+  ##% autoload(String or Symbol, String) -> nil
+  def autoload(const_name, feature) nil end
+  ##% autoload(String or Symbol) -> String
+  def autoload?(const_name) '' end
+  ##% module_eval(String, ?String, ?Integer) -> Object
+  ##% module_eval() {self -> ?} -> Object
+  def module_eval(*) end
+  alias :class_eval :module_eval
+  ##% class_variable_defined?(String or Symbol) -> Boolean
+  def class_variable_defined?(name) BOOLEAN end
+  ##% class_variables() -> Array<String>
+  def class_variables() [''] end
+  ##% const_defined?(String or Symbol) -> Boolean
+  def const_defined?(name) BOOLEAN end
+  ##% const_get(String or Symbol) -> Object
+  def const_get(name) Object.new end
+  ##% const_missing(Symbol) -> nil
+  def const_missing(name) end
+  ##% const_set(String or Symbol, a) -> a
+  def const_set(name, value) value end
+  ##% constants() -> Array<String>
+  def constants() [''] end
+  ##% include?(Module) -> Boolean
+  def include?() BOOLEAN end
+  ##% included_modules() -> Array<Module>
+  def included_modules() [Module.new] end
+  ##% instance_method(String or Symbol) -> UnboundMethod
+  def instance_method(name) UnboundMethod.new end
+  ##% instance_methods(?Boolean) -> Array<String>
+  def instance_methods(inherited_too = true) [''] end
+  ##% method_defined(String or Symbol) -> Boolean
+  def method_defined(name) BOOLEAN end
+  ##% name() -> String
+  def name() '' end
+  alias :to_s :name
+  ##% private_class_method(*(String or Symbol)) -> self
+  def private_class_method(*name) self end
+  ##% private_instance_methods(?Boolean) -> Array<String>
+  def private_instance_methods(inherited_too = true) [''] end
+  ##% private_method_defined?(String or Symbol) -> Boolean
+  def private_method_defined?(name) BOOLEAN end
+  ##% protected_class_method(*(String or Symbol)) -> self
+  def protected_class_method(*name) self end
+  ##% protected_instance_methods(?Boolean) -> Array<String>
+  def protected_instance_methods(inherited_too = true) [''] end
+  ##% protected_method_defined?(String or Symbol) -> Boolean
+  def protected_method_defined?(name) BOOLEAN end
+  ##% public_class_method(*(String or Symbol)) -> self
+  def public_class_method(*name) self end
+  ##% public_instance_methods(?Boolean) -> Array<String>
+  def public_instance_methods(inherited_too = true) [''] end
+  ##% public_method_defined?(String or Symbol) -> Boolean
+  def public_method_defined?(name) BOOLEAN end
+
+  private
+  ##% alias_method(String or Symbol, String or Symbol) -> self
+  def alias_method(new, original) self end
+  ##% append_features(Module) -> self
+  def append_features(module_or_class) self end
+  ##% attr(String or Symbol, ?Boolean) -> nil
+  def attr(name, assignable = false) nil end
+  ##% attr_accessor(*(String or Symbol)) -> nil
+  def attr_accessor(*name) nil end
+  ##% attr_reader(*(String or Symbol)) -> nil
+  def attr_reader(*name) nil end
+  ##% attr_writer(*(String or Symbol)) -> nil
+  def attr_writer(*name) nil end
+  ##% module_exec(*args) {args -> ?} -> Object
+  def module_exec(*args) yield *args end
+  alias :class_exec :module_exec
+  ##% class_variable_get(String or Symbol) -> Object
+  def class_variable_get(name) Object.new end
+  ##% class_variable_set(String or Symbol, a) -> a
+  def class_variable_set(name, val) val end
+  ##% define_method<a | a <= Proc or Method or UnboundMethod>(String or Symbol, a) -> Proc or Method or UnboundMethod
+  ##^ define_method(String or Symbol) {() -> ?}  -> Proc
+  def define_method(*) end
+  ##% extend_object<a | a <= Module>(a) -> a
+  def extend_object(mod) mod end
+  ##% extended(Module) -> nil
+  def extended(class_or_module) end
+  ##% include(*Module) -> self
+  def include(*mod) self end
+  ##% included(Module) -> nil
+  def included(class_or_module) end
+  ##% method_added(Symbol) -> nil
+  def method_added(name) end
+  ##% method_removed(Symbol) -> nil
+  def method_removed(name) end
+  ##% method_undefined(Symbol) -> nil
+  def method_undefined(name) end
+  ##% module_function(*(String or Symbol)) -> self
+  def module_function(*name) self end
+  ##% private(*(String or Symbol)) -> self
+  def private(*name) self end
+  ##% protected(*(String or Symbol)) -> self
+  def protected(*name) self end
+  ##% public(*(String or Symbol)) -> self
+  def public(*name) self end
+  ##% remove_class_variable(String or Symbol) -> Object
+  def remove_class_variable(name) Object.new end
+  ##% remove_const(String or Symbol) -> Object
+  def remove_const(name) Object.new end
+  ##% remove_method(*(String or Symbol)) -> self
+  def remove_method(*name) self end
+  ##% undef_method(*(String or Symbol)) -> self
+  def undef_method(*name) self end
+end
+
+class NilClass
+  ##% &(a) -> FalseClass
+  def &(other) false end
+  ##% ^(a) -> Boolean
+  def ^(other) BOOLEAN end
+  ##% nil?() -> TrueClass
+  def nil?() true end
+  ##% to_a() -> Array
+  def to_a() [] end
+  ##% to_f() -> Float
+  def to_f() 0.0 end
+  ##% to_i() -> Fixnum
+  def to_i() 0 end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% "|"(a) -> Boolean
+  def |(other) BOOLEAN end
+end
+
+class Numeric
+  include Comparable
+
+  ### Comparable
+  ##% "<"(Numeric) -> Boolean
+  def <(other) BOOLEAN end
+  ##% "<="(Numeric) -> Boolean
+  def <=(other) BOOLEAN end
+  ##% ==(Numeric) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ">"(Numeric) -> Boolean
+  def >(other) BOOLEAN end
+  ##% ">="(Numeric) -> Boolean
+  def >=(other) BOOLEAN end
+  ##% between?(Numeric, Numeric) -> Boolean
+  def between?(min, max) BOOLEAN end
+
+  ### Numeric
+  ##% +@() -> self
+  def +@() self end
+  ##% -@() -> Numeric
+  def -@() Numeric end
+  ##% "<=>"(Numeric) -> Fixnum
+  def <=>(other) 0 end
+  ##% abs() -> Numeric
+  def abs() self end
+  ##% ceil() -> Integer
+  def ceil() 0 end
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% coerce(Numeric) -> (Float, Float)
+  def coerce(other) [0.0, 0.0] end
+  ##% div(Numeric) -> Integer
+  def div(other) 0 end
+  ##% divmod(Numeric) -> (Integer, Numeric)
+  def divmod(other) [0, 0] end
+  ##% eql?(Numeric) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% quo(Numeric) -> Float
+  def quo(other) 0.0 end
+  ##% fdiv(Numeric) -> Float
+  def fdiv(other) 0.0 end
+  ##% floor() -> Integer
+  def floor() 0 end
+  ##% integer?() -> Boolean
+  def integer?() BOOLEAN end
+  ##% modulo(Numeric) -> Numeric
+  def modulo(other) 0 end
+  ##% nonzero?() -> self
+  def nonzero?() self end
+  ##% remainder(Numeric) -> Numeric
+  def remainder(other) 0 end
+  ##% round() -> Integer
+  def round() 0 end
+  ##% step<a | a <= Numeric>(Numeric, ?a) {self or a or Fixnum -> ?} -> self
+  ##% step<a | a <= Numeric>(Numeric, ?a) -> Enumerable::Enumerator<self, self or a or Fixnum>
+  def step(limit, step = 1) self end
+  ##% to_int() -> Integer
+  def to_int() 0 end
+  ##% truncate() -> Integer
+  def truncate() 0 end
+  ##% zero?() -> Boolean
+  def zero?() BOOLEAN end
+end
+
+class Object
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ===(a) -> Boolean
+  def ===(other) BOOLEAN end
+  ##% =~(a) -> FalseClass
+  def =~(other) FALSE end
+  ##% __id__() -> Integer
+  def __id__() 0 end
+  alias :object_id :__id__
+  alias :id :__id__
+  ##% send(String or Symbol, *a) -> Object
+  def send(name, *args) end
+  ##% _dump(Integer) -> String
+  def _dump(limit) '' end
+  ###% class() -> Class
+  #def class() Class.new end
+  alias :type :class
+  ##% clone() -> self
+  def clone() self end
+  alias :dup :clone
+  ##% display(?IO) -> nil
+  def display(out = $stdout) nil end
+  ##% to_enum(?String, *a) -> Enumerator
+  def to_enum(method = :each, *args) Enumerator.new end
+  alias :enum_for :to_enum
+  ##% eql?(a) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% equal?(a) -> Boolean
+  def equal?(other) BOOLEAN end
+  ##% extend(*Module) -> self
+  def extend(*modules) self end
+  ##% freeze() -> self
+  def freeze() self end
+  ##% frozen?() -> Boolean
+  def frozen?() BOOLEAN end
+  ##% hash() -> Fixnum
+  def hash() 0 end
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% instance_eval(String, ?String, ?Integer) -> Object
+  ##% instance_eval() {Object -> ?} -> Object
+  def instance_eval(expr, filename = "(eval)", lineno = 1) Object.new end
+  ##% instance_of?(Class) -> Boolean
+  def instance_of?(klass) BOOLEAN end
+  ##% instance_variable_defined?(String or Symbol) -> Boolean
+  def instance_variable_defined?(var) BOOLEAN end
+  ##% instance_variable_get(String or Symbol) -> Object
+  def instance_variable_get(var) Object.new end
+  ##% instance_variable_set(String or Symbol, a) -> a
+  def instance_variable_set(var, value) value end
+  ##% instance_variables() -> Array<String>
+  def instance_variables() [''] end
+  ##% is_a?(Module) -> Boolean
+  def is_a?(mod) BOOLEAN end
+  alias :kind_of? :is_a?
+  ##% marshal_dump() -> Object
+  def marshal_dump() Object.new end
+  ##% marshal_load(Object) -> ?
+  def marshal_load(obj) end
+  ##% method(String or Symbol) -> Method
+  def method(name) Method.new end
+  def method_missing(name, *args) end
+  ##% methods(?Boolean) -> Array<String>
+  def methods(include_inherited = true) [''] end
+  ##% nil?() -> Boolean
+  def nil?() BOOLEAN end
+  ##% private_methods(?Boolean) -> Array<String>
+  def private_methods(include_inherited = true) [''] end
+  ##% protected_methods(?Boolean) -> Array<String>
+  def protected_methods(include_inherited = true) [''] end
+  ##% public_methods(?Boolean) -> Array<String>
+  def public_methods(include_inherited = true) [''] end
+  ##% respond_to?(String or Symbol, ?Boolean) -> Boolean
+  def respond_to?(name, include_private = false) BOOLEAN end
+  ##% singleton_methods(?Boolean) -> Array<String>
+  def singleton_methods(inherited_too = true) [''] end
+  ##% taint() -> self
+  def taint() self end
+  ##% tainted?() -> Boolean
+  def tainted?() BOOLEAN end
+  ##% tap() {self -> ?} -> self
+  def tap() yield self; self end
+  ##% to_a() -> Array
+  def to_a() [] end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% untaint() -> self
+  def untaint() self end
+
+  private
+  ##% to_ary() -> Array
+  def to_ary() [] end
+  ##% to_hash() -> Hash
+  def to_hash() {} end
+  ##% to_int() -> Integer
+  def to_int() 0 end
+  ##% to_io() -> IO
+  def to_io() IO.new(0) end
+  ##% to_proc() -> Proc
+  def to_proc() Proc.new end
+  ##% to_regexp() -> Regexp
+  def to_regexp() Regexp.new end
+  ##% to_str() -> String
+  def to_str() '' end
+
+  # FIXME singleton methods
+end
+
+module ObjectSpace
+  # FIXME
+end
+
+module Precision
+  ##% self.included(Module or Class) -> Precision
+  def self.included(module_or_class) self end
+  ##% self.induced_from(a) -> Object
+  def self.induced_from(number) 0 end
+
+  ##% prec(Class) -> Fixnum
+  def prec(klass) 0 end
+  ##% prec_f() -> Float
+  def prec_f() 0.0 end
+  ##% prec_i() -> Fixnum
+  def prec_i() 0 end
+end
+
+class Proc
+  ##% call(*a) -> Object
+  def call(*arg) Object.new end
+  alias :[] :call
+  ##% arity() -> Fixnum
+  def arity() 0 end
+  ##% binding() -> Binding
+  def binding() Binding.new end
+  ##% to_proc() -> self
+  def to_proc() self end
+  ##% to_s() -> String
+  def to_s() '' end
+end
+
+module Process
+  PRIO_PGRP       =  0
+  PRIO_PROCESS    =  0
+  PRIO_USER       =  0
+  RLIMIT_AS       =  0
+  RLIMIT_CORE     =  0
+  RLIMIT_CPU      =  0
+  RLIMIT_DATA     =  0
+  RLIMIT_FSIZE    =  0
+  RLIMIT_MEMLOCK  =  0
+  RLIMIT_NOFILE   =  0
+  RLIMIT_NPROC    =  0
+  RLIMIT_RSS      =  0
+  RLIMIT_SBSIZE   =  0
+  RLIMIT_STACK    =  0
+  RLIM_INFINITY   =  0
+  RLIM_SAVED_CUR  =  0
+  RLIM_SAVED_MAX  =  0
+  WNOHANG         =  0
+  WUNTRACED       =  0
+
+  ##% self.abort(?String) -> ?
+  def self.abort(message = '') end
+  ##% self.detach(Integer) -> Thread
+  def self.detach(pid) Thread.current end
+  ##% self.exec(String, *String) -> ?
+  def self.exec(command, *args) end
+  ##% self.exit(?Boolean) -> ?
+  def self.exit(status = true) end
+  ##% self.exit!(?Boolean) -> ?
+  def self.exit!(status = true) end
+  ##% self.fork() -> Integer
+  ##% self.fork() {() -> ?} -> Integer
+  def self.fork() yield; 0 end
+
+  module_function
+  ##% egid() -> Integer
+  def egid() 0 end
+  ##% egid=(Integer) -> ?
+  def egid=(gid) end
+  ##% euid() -> Integer
+  def euid() 0 end
+  ##% euid=(Integer) -> ?
+  def euid=(gid) end
+  ##% getpgid(?Integer) -> Integer
+  def getpgid(pid = 0) 0 end
+  ##% getpgrp() -> Integer
+  def getpgrp() 0 end
+  ##% getpriority(Integer, Integer) -> Integer
+  def getpriority(which, who) 0 end
+  ##% getrlimit(Integer) -> (Integer, Integer)
+  def getrlimit(resource) [0, 0] end
+  ##% gid() -> Integer
+  def gid() 0 end
+  ##% gid=(Integer) -> ?
+  def gid=(gid) end
+  ##% groups() -> Array<Integer>
+  def groups() [0] end
+  ##% groups=(a) -> ?
+  def groups=(gids) end
+  ##% initgroups(String, Integer) -> Array<Integer>
+  def initgroups(user, group) [0] end
+  ##% kill(Integer or String, Integer, *Integer) -> Integer
+  def kill(signal, pid, *rest) 0 end
+  ##% maxgroups() -> Integer
+  def maxgroups() 0 end
+  ##% maxgroups=(Integer) -> ?
+  def maxgroups=(num) end
+  ##% pid() -> Integer
+  def pid() 0 end
+  ##% ppid() -> Integer
+  def ppid() 0 end
+  ##% setpgid(Integer, Integer) -> Integer
+  def setpgid(pid, pgrp) 0 end
+  ##% setpgrp() -> Integer
+  def setpgrp() 0 end
+  ##% setpriority(Integer, Integer, Integer) -> Integer
+  def setpriority(which, who, prio) 0 end
+  ##% setrlimit(Integer, Integer, ?Integer) -> nil
+  def setrlimit(resource, cur_limit, max_limit = nil) nil end
+  ##% setsid() -> Integer
+  def setsid() 0 end
+  ##% times() -> Struct::Tms
+  def times() Struct::Tms.new end
+  ##% uid() -> Integer
+  def uid() 0 end
+  ##% uid=(Integer) -> ?
+  def uid=(id) end
+  ##% wait() -> Integer
+  def wait() 0 end
+  ##% wait2() -> (Integer, Process::Status)
+  def wait2() [0, Process::Status.new] end
+  ##% waitall() -> Array<(Integer, Process::Status)>
+  def waitall() [[0, Process::Status.new]] end
+  ##% waitpid(Integer, ?Integer) -> Integer
+  def waitpid(pid, flags = 0) 0 end
+  ##% waitpid2(Integer, ?Integer) -> (Integer, Process::Status)
+  def waitpid2(pid, flags = 0) [0, Process::Status.new] end
+end
+
+module Process::GID
+  module_function
+  ##% change_privilege(Integer) -> Integer
+  def change_privilege(id) 0 end
+  ##% eid() -> Integer
+  def eid() 0 end
+  ##% grant_privilege(Integer) -> Integer
+  def grant_privilege(id) 0 end
+  alias :eid= :grant_privilege
+  ##% re_exchange() -> Integer
+  def re_exchange() 0 end
+  ##% re_exchangeable?() -> Boolean
+  def re_exchangeable?() BOOLEAN end
+  ##% rid() -> Integer
+  def rid() 0 end
+  ##% sid_available?() -> Boolean
+  def sid_available?() BOOLEAN end
+  ##% switch() -> Integer
+  ##% switch() {() -> a} -> a
+  def switch() yield; 0 end
+end
+
+class Process::Status
+  ##% &(Integer) -> Integer
+  def &(other) Integer end
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ">>"(Integer) -> Integer
+  def >>(num) 0 end
+  ##% coredump?() -> Boolean
+  def coredump?() BOOLEAN end
+  ##% exited?() -> Boolean
+  def exited?() BOOLEAN end
+  ##% exitstatus() -> Integer
+  def exitstatus() 0 end
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% pid() -> Integer
+  def pid() 0 end
+  ##% signaled?() -> Boolean
+  def signaled?() BOOLEAN end
+  ##% stopped?() -> Boolean
+  def stopped?() BOOLEAN end
+  ##% stopsig() -> Integer
+  def stopsig() 0 end
+  ##% success?() -> Boolean
+  def success?() BOOLEAN end
+  ##% termsig() -> Integer
+  def termsig() 0 end
+  ##% to_i() -> Integer
+  def to_i() 0 end
+  alias :to_int :to_i
+  ##% to_s() -> String
+  def to_s() '' end
+end
+
+module Process::Sys
+  module_function
+  ##% getegid() -> Integer
+  def getegid() 0 end
+  ##% geteuid() -> Integer
+  def geteuid() 0 end
+  ##% getgid() -> Integer
+  def getgid() 0 end
+  ##% getuid() -> Integer
+  def getuid() 0 end
+  ##% issetugid() -> Boolean
+  def issetugid() BOOLEAN end
+  ##% setegid(Integer) -> nil
+  def setegid(id) nil end
+  ##% seteuid(Integer) -> nil
+  def seteuid(id) nil end
+  ##% setgid(Integer) -> nil
+  def setgid(id) nil end
+  ##% setregid(Integer, Integer) -> nil
+  def setregid(rid, eid) nil end
+  ##% setresgid(Integer, Integer, Integer) -> nil
+  def setresgid(rid, eid, sid) nil end
+  ##% setresuid(Integer, Integer, Integer) -> nil
+  def setresuid(rid, eid, sid) nil end
+  ##% setreuid(Integer, Integer) -> nil
+  def setreuid(rid, eid) nil end
+  ##% setrgid(Integer) -> nil
+  def setrgid(id) nil end
+  ##% setruid(Integer) -> nil
+  def setruid(id) nil end
+  ##% setuid(Integer) -> nil
+  def setuid(id) nil end
+end
+
+module Process::UID
+  module_function
+  ##% change_privilege(Integer) -> Integer
+  def change_privilege(id) 0 end
+  ##% eid() -> Integer
+  def eid() 0 end
+  ##% grant_privilege(Integer) -> Integer
+  def grant_privilege(id) 0 end
+  alias :eid= :grant_privilege
+  ##% re_exchange() -> Integer
+  def re_exchange() 0 end
+  ##% re_exchangeable?() -> Boolean
+  def re_exchangeable?() BOOLEAN end
+  ##% rid() -> Integer
+  def rid() 0 end
+  ##% sid_available?() -> Boolean
+  def sid_available?() BOOLEAN end
+  ##% switch() -> Integer
+  ##% switch() {() -> a} -> a
+  def switch() yield; 0 end
+end
+
+##% Range<t>
+class Range
+  include Enumerable
+
+  ##% self.new(a, b, ?Boolean) -> Range<a or b>
+  def self.new() end
+
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  ##% ===(a) -> Boolean
+  def ===(other) BOOLEAN end
+  alias :include? :===
+  alias :member? :===
+  ##% begin() -> t
+  def begin() end
+  alias :first :begin
+  ##% each() {t -> ?} -> self
+  ##% each() -> Enumerator<self, t>
+  def each() self end
+  ##% end() -> t
+  def end() end
+  alias :last :end
+  ##% eql?(a) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% equal?(a) -> Boolean
+  def equal?(other) BOOLEAN end
+  ##% exclude_end?() -> Boolean
+  def exclude_end?() BOOLEAN end
+  ##% hash() -> Integer
+  def hash() 0 end
+  ##% step(?Fixnum) {t -> ?} -> self
+  ##% step(?Fixnum) -> Enumerator<self, t>
+  def step(s = 1) end
+end
+
+class Regexp
+  EXTENDED = 0
+  IGNORECASE = 0
+  MULTILINE = 0
+
+  ##% self.compile(String, Fixnum or Boolean, String) -> Regexp
+  def self.compile(string, option = nil, code = nil) Regexp.new end
+  ##% self.escape(String, ?String) -> String
+  def self.escape(string, kcode = $KCODE) '' end
+  ##% self.last_match() -> MatchData
+  ##% self.last_match(Integer) -> MatchData
+  def self.last_match(n = nil) MatchData.new end
+  ##% self.union(*(String or Regexp)) -> Regexp
+  def self.union(*pattern) Regexp.new end
+
+  ##% ==(Regexp) -> Boolean
+  def ==(other) BOOLEAN end
+  alias :eql? :==
+  ##% =~(String) -> Fixnum
+  def =~(string) 0 end
+  ##% ===(string) -> Boolean
+  def ===(string) BOOLEAN end
+  ##% casefold?() -> Boolean
+  def casefold?() BOOLEAN end
+  ##% hash() -> Fixnum
+  def hash() 0 end
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% kcode() -> String
+  def kcode() '' end
+  ##% match(String) -> MatchData
+  def match(str) MatchData.new end
+  ##% options() -> Integer
+  def options() 0 end
+  ##% source() -> String
+  def source() '' end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% ~() -> Fixnum
+  def ~() 0 end
+end
+
+module Signal
+  module_function
+  ##% list() -> Hash<String, Integer>
+  def list() {'' => 1} end
+  ##% trap(String or Symbol, String or Proc) -> String or Proc
+  ##% trap(String or Symbol) {() -> ?} -> String or Proc
+  def trap(signal, command = nil) yield; '' end
+end
+
+##% String<| String <= t>
+class String
+  include Enumerable
+  include Comparable
+
+  ##% self.new(?String) -> String
+  def self.new(string = '') '' end
+
+  ##% %(a) -> String
+  def %(args) '' end
+  ##% "*"(Integer) -> String
+  def *(times) '' end
+  ##% +(String) -> String
+  def +(other) '' end
+  ##% "<<"(?Fixnum or String) -> self
+  def <<(other) self end
+  alias :concat :<<
+  ##% "<=>"(String) -> Integer
+  def <=>(other) 0 end
+  ##% ==(a) -> Boolean
+  def ==(other) BOOLEAN end
+  # FIXME =~
+  ##% =~(a) -> Integer
+  def =~(other) 0 end
+  ##% [](Integer) -> Fixnum
+  ##% [](Integer, Integer) -> String
+  ##% [](String) -> String
+  ##% [](Regexp, ?Integer) -> String
+  ##% [](Range) -> String
+  def [](*) 0 end
+  alias :slice :[]
+  ##% []=(Integer, String or Integer) -> String
+  ##% []=(Integer, Integer, String or Integer) -> String
+  ##% []=(String, String or Integer) -> String
+  ##% []=(Regexp, ?Integer, String or Integer) -> String
+  ##% []=(Range, String or Integer) -> String
+  def []=(*) '' end
+  ##% each_byte() {Fixnum -> ?} -> self
+  ##% each_byte() -> Enumerator<self, Fixnum>
+  def each_byte() yield 0; self end
+  alias :bytes :each_byte
+  ##% bytesize() -> Integer
+  def bytesize() 0 end
+  ##% capitalize() -> String
+  def capitalize() '' end
+  ##% capitalize!() -> self
+  def capitalize!() '' end
+  ##% casecmp(String) -> Integer
+  def casecmp(other) 0 end
+  ##% center(Integer, ?String) -> String
+  def center(width, padding = ' ') '' end
+  ##% each_char() {String -> ?} -> self
+  ##% each_char() -> Enumerator<self, String>
+  def each_char() yield ''; self end
+  alias :chars :each_char
+  ##% chomp(?String) -> String
+  def chomp(rs = $/) '' end
+  ##% chomp!(?String) -> self
+  def chomp!(rs = $/) self end
+  ##% chop() -> String
+  def chop() '' end
+  ##% chop!() -> self
+  def chop!() self end
+  ##% count(*String) -> Integer
+  def count(*chars) 0 end
+  ##% crypt(String) -> String
+  def crypt(salt) '' end
+  ##% delete(*String) -> String
+  def delete(*strs) '' end
+  ##% delete!(*String) -> self
+  def delete!(*strs) self end
+  ##% downcase() -> String
+  def downcase() '' end
+  ##% downcase!() -> self
+  def downcase!() self end
+  ##% dump() -> String
+  def dump() '' end
+  ##% each(?String) {String -> ?} -> self
+  ##% each(?String) -> Enumerator<self, String>
+  def each(rs = $/) yield ''; self end
+  alias :each_line :each
+  alias :lines :each
+  ##% empty?() -> Boolean
+  def empty?() Boolean end
+  ##% end_with?(String) -> Boolean
+  def end_with?(str) BOOLEAN end
+  ##% eql?(a) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% gsub(String or Regexp, String) -> String
+  ##% gsub(String or Regexp) {String -> ?} -> String
+  ##% gsub(String or Regexp) -> Enumerator<String, String>
+  def gsub(pattern, replace = nil) '' end
+  ##% gsub!(String or Regexp, String) -> self
+  ##% gsub!(String or Regexp) {String -> ?} -> self
+  ##% gsub!(String or Regexp) -> Enumerator<String, self>
+  def gsub!(pattern, replace = nil) self end
+  ##% hash() -> Integer
+  def hash() 0 end
+  ##% hex() -> Integer
+  def hex() 0 end
+  ##% include?(String or Integer) -> Boolean
+  def include?(substr) BOOLEAN end
+  ##% index(String or Regexp, ?Integer) -> Integer
+  def index(pattern, pos = 0) 0 end
+  ##% insert(Integer, String) -> self
+  def insert(pos, other) self end
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% intern() -> Symbol
+  def intern() :a end
+  alias :to_sym :intern
+  ##% length() -> Integer
+  def length() 0 end
+  alias :length :size
+  ##% ljust(Integer, ?String) -> String
+  def ljust(width, padding = ' ') '' end
+  ##% lstrip() -> String
+  def lstrip() '' end
+  ##% lstrip!() -> self
+  def lstrip!() self end
+  ##% match(String or Regexp) -> MatchData
+  def match(regexp) MatchData.new end
+  ##% succ() -> String
+  def succ() '' end
+  alias :next :succ
+  ##% succ!() -> self
+  def succ!() self end
+  alias :next! :succ!
+  ##% oct() -> Integer
+  def oct() 0 end
+  ##% partition(String or Regexp) -> (String, String, String)
+  def partition(sep) ['', '', ''] end
+  ##% replace(String) -> String
+  def replace(other) self end
+  ##% reverse() -> String
+  def reverse() '' end
+  ##% reverse!() -> self
+  def reverse!() self end
+  ##% rindex(String or Regexp, ?Integer) -> Integer
+  def rindex(pattern, pos = 0) 0 end
+  ##% rjust(Integer, ?String) -> String
+  def rjust(width, padding = ' ') '' end
+  ##% rpartition(String or Regexp) -> (String, String, String)
+  def rpartition(sep) ['', '', ''] end
+  ##% rstrip() -> String
+  def rstrip() '' end
+  ##% rstrip!() -> self
+  def rstrip!() self end
+  ##% scan(String or Regexp) -> Array<String> or Array<Array<String> >
+  ##% scan(String or Regexp) {String -> ?} -> self
+  def scan(re) [''] || [['']] end
+  alias :slice! :[]
+  ##% split(?(String or Regexp), ?Integer) -> Array<String> or Array<Array<String> >
+  def split(sep = $;, limit = 0) [''] || [['']] end
+  ##% squeeze(*String) -> String
+  def squeeze(*chars) '' end
+  ##% squeeze!(*String) -> self
+  def squeeze!(*chars) self end
+  ##% start_with?(String) -> Boolean
+  def start_with?(str) BOOLEAN end
+  ##% strip() -> String
+  def strip() '' end
+  ##% strip!() -> self
+  def strip!() self end
+  ##% sub(String or Regexp, String) -> String
+  ##% sub(String or Regexp) {String -> ?} -> String
+  ##% sub(String or Regexp) -> Enumerator<String, String>
+  def sub(pattern, replace = nil) '' end
+  ##% sub!(String or Regexp, String) -> self
+  ##% sub!(String or Regexp) {String -> ?} -> self
+  ##% sub!(String or Regexp) -> Enumerator<String, self>
+  def sub!(pattern, replace = nil) self end
+  ##% sum(?Integer) -> Integer
+  def sum(bits = 16) 0 end
+  ##% swapcase() -> String
+  def swapcase() '' end
+  ##% swapcase!() -> self
+  def swapcase!() self end
+  ##% to_f() -> Float
+  def to_f() 0.0 end
+  ##% to_i(?Integer) -> Integer
+  def to_i(base = 10) 0 end
+  ##% to_s() -> self
+  def to_s() self end
+  alias :to_str :to_s
+  ##% tr(String, String) -> String
+  def tr(pattern, replace) '' end
+  ##% tr!(String, String) -> self
+  def tr!(pattern, replace) self end
+  ##% tr_s(String, String) -> String
+  def tr_s(pattern, replace) '' end
+  ##% tr_s!(String, String) -> self
+  def tr_s!(pattern, replace) self end
+  ##% unpack(String) -> Array
+  def unpack(template) [] end
+  ##% upcase() -> String
+  def upcase() '' end
+  ##% upcase!() -> self
+  def upcase!() self end
+  ##% upto(String, ?Boolean) {String -> ?} -> self
+  def upto(max, exclusive = false) yield ''; self end
+end
+
+class Struct
+  # FIXME
+end
+
+class Struct::Tms
+  # FIXME
+end
+
+class Symbol
+  ##% self.all_symbols() -> Array<Symbol>
+  def all_symbols() [:a] end
+
+  ##% id2name() -> String
+  def id2name() '' end
+  alias :to_s :id2name
+  ##% inspect() -> String
+  def inspect() '' end
+  ##% to_i() -> Integer
+  def to_i() 0 end
+  alias :to_int :to_i
+  ##% to_proc() -> Proc
+  def to_proc() Proc.new end
+  ##% to_sym() -> self
+  def to_sym() self end
+end
+
+class Thread
+  ##% self.abort_on_exception() -> Boolean
+  def self.abort_on_exception() BOOLEAN end
+  ##% self.abort_on_exception=(Boolean) -> ?
+  def self.abort_on_exception=(newstate) end
+  ##% self.critical() -> Boolean
+  def self.critical() BOOLEAN end
+  ##% self.critical=(Boolean) -> ?
+  def self.critical=(newstate) end
+  ##% self.current() -> Thread
+  def self.current() Thread.new {} end
+  ##% self.exit() -> ?
+  def self.exit() end
+  ##% self.start(*a) {*a -> ?} -> Thread
+  def self.start(*arg) yield *arg; Thread.current end
+  ##% self.fork(*a) {*a -> ?} -> Thread
+  def self.fork(*arg) yield *arg; Thread.current end
+  ##% self.kill(Thread) -> Thread
+  def self.kill(thread) thread end
+  ##% self.list() -> [Thead]
+  def self.list() [Thread.current] end
+  ##% self.main() -> Thread
+  def self.main() Thread.current end
+  ##% self.new(*a) {*a -> ?} -> Thread
+  def self.new(*arg) yield *arg; super() end
+  ##% self.pass() -> nil
+  def self.pass() nil end
+  ##% self.stop() -> nil
+  def self.stop() nil end
+
+  ##% [](Symbol or String) -> Object
+  def [](name) Object.new end
+  ##% []=(Symbol or String, a) -> a
+  def []=(name, val) val end
+  ##% abort_on_exception() -> Boolean
+  def abort_on_exception() BOOLEAN end
+  ##% abort_on_exception=(Boolean) -> ?
+  def abort_on_exception=(newstate) end
+  ##% alive?() -> Boolean
+  def alive?() BOOLEAN end
+  ##% exit() -> self
+  def exit() self end
+  alias :kill :exit
+  alias :terminate :exit
+  ##% exit!() -> self
+  def exit!() self end
+  alias :kill! :exit!
+  alias :terminate! :exit!
+  ##% group() -> ThreadGroup
+  def group() ThreadGroup.new end
+  ##% join() -> self
+  ##% join(Numeric) -> self
+  def join(limit = nil) self end
+  ##% key?(Symbol or String) -> Boolean
+  def key?(name) BOOLEAN end
+  ##% keys() -> Array<Symbol>
+  def keys() [:a] end
+  ##% priority() -> Integer
+  def priority() 0 end
+  ##% priority=(Integer) -> nil
+  def priority=(val) nil end
+  ##% raise() -> nil
+  ##% raise(String) -> nil
+  ##% raise(?, ?String, Array<String>) -> nil
+  def raise(*) end
+  ##% run() -> self
+  def run() self end
+  ##% safe_level() -> Integer
+  def safe_level() 0 end
+  ##% status() -> String or FalseClass
+  def status() '' || false end
+  ##% stop?() -> Boolean
+  def stop?() BOOLEAN end
+  ##% value() -> Object
+  def value() Object.new end
+  ##% wakeup() -> self
+  def wakeup() self end
+end
+
+class ThreadGroup
+  Default = ThreadGroup.new
+
+  ##% add(Thread) -> self
+  def add(thread) self end
+  ##% enclose() -> self
+  def enclose() self end
+  ##% enclosed?() -> Boolean
+  def enclosed?() BOOLEAN end
+  ##% list() -> Array<Thread>
+  def list() [Thread.current] end
+end
+
+class Time
+  include Comparable
+
+  ##% self.at(Time or Integer, ?Integer) -> Time
+  def self.at(time, usec) Time.new end
+  ##% self.gm(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String) -> Time
+  ##% self.gm(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, a, b, Boolean, c) -> Time
+  def self.gm(*) Time.new end
+  ##% self.utc(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String) -> Time
+  ##% self.utc(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, a, b, Boolean, c) -> Time
+  def self.utc(*) Time.new end
+  ##% self.local(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String) -> Time
+  ##% self.local(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, a, b, Boolean, c) -> Time
+  def self.local(*) Time.new end
+  ##% self.mktime(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String) -> Time
+  ##% self.mktime(Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, Integer or String, a, b, Boolean, c) -> Time
+  def self.mktime(*) Time.new end
+  ##% self.now() -> Time
+  def self.now() Time.new end
+  ##% self.times() -> Struct::Tms
+  def self.times() Struct::Tms.new end
+
+  ##% +(Integer) -> Time
+  def +(other) Time.new end
+  ##% -(Integer or Time) -> Time
+  def -(other) Time.new end
+  ##% "<=>"(Time) -> Fixnum
+  def <=>(other) 0 end
+  ##% asctime() -> String
+  def asctime() '' end
+  alias :ctime :asctime
+  ##% mday() -> Integer
+  def mday() 0 end
+  alias :day :mday
+  ##% isdst() -> Boolean
+  def isdst() BOOLEAN end
+  alias :dst? :isdst
+  ##% eql?(Time) -> Boolean
+  def eql?(other) BOOLEAN end
+  ##% getgm() -> Time
+  def getgm() Time.new end
+  alias :getutc :getgm
+  ##% getlocal() -> Time
+  def getlocal() Time.new end
+  ##% gmt?() -> Boolean
+  def gmt?() BOOLEAN end
+  alias :utc? :gmt?
+  ##% utc_offset() -> Integer
+  def utc_offset() 0 end
+  alias :gmt_offset :utc_offset
+  alias :gmtoff :utc_offset
+  ##% gmtime() -> self
+  def gmtime() self end
+  ##% hour() -> Integer
+  def hour() 0 end
+  ##% localtime() -> self
+  def localtime() self end
+  ##% min() -> Integer
+  def min() 0 end
+  ##% mon() -> Integer
+  def mon() 0 end
+  alias :month :mon
+  ##% sec() -> Integer
+  def sec() 0 end
+  ##% strftime(String) -> String
+  def strftime(format) '' end
+  ##% succ() -> Time
+  def succ() Time.new end
+  ##% to_a() -> (Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Boolean, String)
+  def to_a() [0, 0, 0, 0, 0, 0, 0, 0, BOOLEAN, ''] end
+  ##% to_f() -> Float
+  def to_f() 0.0 end
+  ##% to_i() -> Integer
+  def to_i() 0 end
+  alias :tv_sec :to_i
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% usec() -> Integer
+  def usec() 0 end
+  alias :tv_usec :usec
+  ##% wday() -> Integer
+  def wday() 0 end
+  ##% yday() -> Integer
+  def yda() 0 end
+  ##% year() -> Integer
+  def year() 0 end
+  ##% zone() -> String
+  def zone() '' end
+end
+
+class TrueClass
+  ##% &(a) -> Boolean
+  def %(other) BOOLEAN end
+  ##% ^(a) -> Boolean
+  def ^(other) BOOLEAN end
+  ##% to_s() -> String
+  def to_s() '' end
+  ##% "|"(a) -> Boolean
+  def |(other) BOOLEAN end
+end
+
+class UnboundMethod
+  # FIXME
+end
+
+class Exception; end
+class StandardError < Exception; end
+class IOError < StandardError; end
+class SystemCallError < StandardError; end
+class RangeError < StandardError; end
+class SignalException < Exception; end
+class ScriptError < Exception; end
+
+class ArgumentError < StandardError; end
+class EOFError < IOError; end
+class Errno::E2BIG < SystemCallError; end
+class Errno::EACCES < SystemCallError; end
+class Errno::EADDRINUSE < SystemCallError; end
+class Errno::EADDRNOTAVAIL < SystemCallError; end
+class Errno::EADV < SystemCallError; end
+class Errno::EAFNOSUPPORT < SystemCallError; end
+class Errno::EAGAIN < SystemCallError; end
+class Errno::EALREADY < SystemCallError; end
+class Errno::EBADE < SystemCallError; end
+class Errno::EBADF < SystemCallError; end
+class Errno::EBADFD < SystemCallError; end
+class Errno::EBADMSG < SystemCallError; end
+class Errno::EBADR < SystemCallError; end
+class Errno::EBADRQC < SystemCallError; end
+class Errno::EBADSLT < SystemCallError; end
+class Errno::EBFONT < SystemCallError; end
+class Errno::EBUSY < SystemCallError; end
+class Errno::ECHILD < SystemCallError; end
+class Errno::ECHRNG < SystemCallError; end
+class Errno::ECOMM < SystemCallError; end
+class Errno::ECONNABORTED < SystemCallError; end
+class Errno::ECONNRESET < SystemCallError; end
+class Errno::EDEADLK < SystemCallError; end
+class Errno::EDEADLOCK < SystemCallError; end
+class Errno::EDESTADDRREQ < SystemCallError; end
+class Errno::EDOM < SystemCallError; end
+class Errno::EDOTDOT < SystemCallError; end
+class Errno::EDQUOT < SystemCallError; end
+class Errno::EEXIST < SystemCallError; end
+class Errno::EFAULT < SystemCallError; end
+class Errno::EFBIG < SystemCallError; end
+class Errno::EHOSTDOWN < SystemCallError; end
+class Errno::EHOSTUNREACH < SystemCallError; end
+class Errno::EIDRM < SystemCallError; end
+class Errno::EILSEQ < SystemCallError; end
+class Errno::EINPROGRESS < SystemCallError; end
+class Errno::EINTR < SystemCallError; end
+class Errno::EINVAL < SystemCallError; end
+class Errno::EIO < SystemCallError; end
+class Errno::EISCONN < SystemCallError; end
+class Errno::EISDIR < SystemCallError; end
+class Errno::EISNAM < SystemCallError; end
+class Errno::EL2HLT < SystemCallError; end
+class Errno::EL2NSYNC < SystemCallError; end
+class Errno::EL3HLT < SystemCallError; end
+class Errno::EL3RST < SystemCallError; end
+class Errno::ELIBACC < SystemCallError; end
+class Errno::ELIBBAD < SystemCallError; end
+class Errno::ELIBEXEC < SystemCallError; end
+class Errno::ELIBMAX < SystemCallError; end
+class Errno::ELIBSCN < SystemCallError; end
+class Errno::ELNRNG < SystemCallError; end
+class Errno::ELOOP < SystemCallError; end
+class Errno::EMFILE < SystemCallError; end
+class Errno::EMLINK < SystemCallError; end
+class Errno::EMSGSIZE < SystemCallError; end
+class Errno::EMULTIHOP < SystemCallError; end
+class Errno::ENAMETOOLONG < SystemCallError; end
+class Errno::ENAVAIL < SystemCallError; end
+class Errno::ENETDOWN < SystemCallError; end
+class Errno::ENETRESET < SystemCallError; end
+class Errno::ENETUNREACH < SystemCallError; end
+class Errno::ENFILE < SystemCallError; end
+class Errno::ENOANO < SystemCallError; end
+class Errno::ENOBUFS < SystemCallError; end
+class Errno::ENOCSI < SystemCallError; end
+class Errno::ENODATA < SystemCallError; end
+class Errno::ENODEV < SystemCallError; end
+class Errno::ENOENT < SystemCallError; end
+class Errno::ENOEXEC < SystemCallError; end
+class Errno::ENOLCK < SystemCallError; end
+class Errno::ENOLINK < SystemCallError; end
+class Errno::ENOMEM < SystemCallError; end
+class Errno::ENOMSG < SystemCallError; end
+class Errno::ENONET < SystemCallError; end
+class Errno::ENOPKG < SystemCallError; end
+class Errno::ENOPROTOOPT < SystemCallError; end
+class Errno::ENOSPC < SystemCallError; end
+class Errno::ENOSR < SystemCallError; end
+class Errno::ENOSTR < SystemCallError; end
+class Errno::ENOSYS < SystemCallError; end
+class Errno::ENOTBLK < SystemCallError; end
+class Errno::ENOTCONN < SystemCallError; end
+class Errno::ENOTDIR < SystemCallError; end
+class Errno::ENOTEMPTY < SystemCallError; end
+class Errno::ENOTNAM < SystemCallError; end
+class Errno::ENOTSOCK < SystemCallError; end
+class Errno::ENOTTY < SystemCallError; end
+class Errno::ENOTUNIQ < SystemCallError; end
+class Errno::ENXIO < SystemCallError; end
+class Errno::EOPNOTSUPP < SystemCallError; end
+class Errno::EOVERFLOW < SystemCallError; end
+class Errno::EPERM < SystemCallError; end
+class Errno::EPFNOSUPPORT < SystemCallError; end
+class Errno::EPIPE < SystemCallError; end
+class Errno::EPROTO < SystemCallError; end
+class Errno::EPROTONOSUPPORT < SystemCallError; end
+class Errno::EPROTOTYPE < SystemCallError; end
+class Errno::ERANGE < SystemCallError; end
+class Errno::EREMCHG < SystemCallError; end
+class Errno::EREMOTE < SystemCallError; end
+class Errno::EREMOTEIO < SystemCallError; end
+class Errno::ERESTART < SystemCallError; end
+class Errno::EROFS < SystemCallError; end
+class Errno::ERROR < SystemCallError; end
+class Errno::ESHUTDOWN < SystemCallError; end
+class Errno::ESOCKTNOSUPPORT < SystemCallError; end
+class Errno::ESPIPE < SystemCallError; end
+class Errno::ESRCH < SystemCallError; end
+class Errno::ESRMNT < SystemCallError; end
+class Errno::ESTALE < SystemCallError; end
+class Errno::ESTRPIPE < SystemCallError; end
+class Errno::ETIME < SystemCallError; end
+class Errno::ETIMEDOUT < SystemCallError; end
+class Errno::ETOOMANYREFS < SystemCallError; end
+class Errno::ETXTBSY < SystemCallError; end
+class Errno::EUCLEAN < SystemCallError; end
+class Errno::EUNATCH < SystemCallError; end
+class Errno::EUSERS < SystemCallError; end
+class Errno::EWOULDBLOCK < SystemCallError; end
+class Errno::EXDEV < SystemCallError; end
+class Errno::EXFULL < SystemCallError; end
+class Errno::EXXX < SystemCallError; end
+
+class Exception
+  ##% self.new(?String) -> Exception
+  def self.new(error_message = nil) super() end
+  ##% self.exception(?String) -> Exception
+  def self.exception(error_message = nil) self.new(error_message) end
+
+  ##% backtrace() -> Array<String>
+  def backtrace() [''] end
+  ##% exception() -> self
+  ##% exception(String) -> Exception
+  def exception(error_message = nil) self end
+  ##% message() -> String
+  def message() '' end
+  alias :to_s :message
+  alias :to_str :message
+  ##% set_backtrace(String or Array<String>) -> String or Array<String>
+  def set_backtrace(errinfo) '' || [''] end
+end
+
+class FloatDomainError < RangeError; end
+class IndexError < StandardError; end
+class Interrupt < SignalException; end
+class LoadError < ScriptError; end
+
+class LocalJumpError < StandardError
+  ##% exit_value() -> Object
+  def exit_value() Object.new end
+  ##% reason() -> Symbol
+  def reason() :a end
+end
+
+class NameError < StandardError
+  ##% self.new(String) -> NameError
+  def self.new(error_message) super() end
+
+  ##% name() -> Symbol
+  def name() :a end
+  ##% to_s() -> String
+  def to_s() '' end
+end
+
+class NoMemoryError < Exception; end
+
+class NoMethodError < NameError
+  ##% self.new(?String) -> Exception
+  def self.new(error_message = nil) super() end
+
+  ##% args() -> Array<Object>
+  def args() [Object.new] end
+end
+
+class NotImplementedError < ScriptError; end
+class RangeError < StandardError; end
+class RegexpError < StandardError; end
+class RuntimeError < StandardError; end
+class ScriptError < Exception; end
+class SecurityError < StandardError; end
+class SignalException < Exception; end
+class StandardError < Exception; end
+class StopIteration < IndexError; end
+class SyntaxError < ScriptError; end
+
+class SystemCallError < StandardError
+  ##% self.new(String, ?Integer) -> SystemCallError
+  ##% self.new(Integer) -> SystemCallError
+  def self.new(*) super() end
+
+  ##% errono() -> Fixnum
+  def errorno() 0 end
+end
+
+class SystemExit < Exception
+  ##% self.new(?Integer, ?String) -> SystemExit
+  def self.new(status = 0, error_message = '') super() end
+
+  ##% status() -> Fixnum
+  def status() 0 end
+  ##% success?() -> Boolean
+  def success?() BOOLEAN end
+end
+
+class SystemStackError < StandardError; end
+class ThreadError < StandardError; end
+class TypeError < StandardError; end
+class ZeroDivisionError < StandardError; end