rubinius-core-api 0.0.1

data/lib/rubinius/kernel/common/thread.rb

@@ -0,0 +1,118 @@
+#--
+# Be very careful about calling raise in here! Thread has its own
+# raise which, if you're calling raise, you probably don't want. Use
+# Kernel.raise to call the proper raise.
+#++
+
+class Thread
+
+  attr_reader :recursive_objects
+
+  # Implementation note: ideally, the recursive_objects
+  # lookup table would be different per method call.
+  # Currently it doesn't cause problems, but if ever
+  # a method :foo calls a method :bar which could 
+  # recurse back to :foo, it could require making
+  # the tables independant.
+
+  def self.recursion_guard(obj)
+    id = obj.object_id
+    objects = current.recursive_objects
+    objects[id] = true
+
+    begin
+      yield
+    ensure
+      objects.delete id
+    end
+  end
+
+  def self.guarding?(obj)
+    current.recursive_objects[obj.object_id]
+  end
+
+  # detect_recursion will return if there's a recursion
+  # on obj (or the pair obj+paired_obj).
+  # If there is one, it returns true.
+  # Otherwise, it will yield once and return false.
+
+  def self.detect_recursion(obj, paired_obj=undefined)
+    id = obj.object_id
+    pair_id = paired_obj.object_id
+    objects = current.recursive_objects
+
+    case objects[id]
+
+      # Default case, we haven't seen +obj+ yet, so we add it and run the block.
+    when nil
+      objects[id] = pair_id
+      begin
+        yield
+      ensure
+        objects.delete id
+      end
+
+      # We've seen +obj+ before and it's got multiple paired objects associated
+      # with it, so check the pair and yield if there is no recursion.
+    when Rubinius::LookupTable
+      return true if objects[id][pair_id]
+      objects[id][pair_id] = true
+
+      begin
+        yield
+      ensure
+        objects[id].delete pair_id
+      end
+
+      # We've seen +obj+ with one paired object, so check the stored one for
+      # recursion.
+      #
+      # This promotes the value to a LookupTable since there is another new paired
+      # object.
+    else
+      previous = objects[id]
+      return true if previous == pair_id
+
+      objects[id] = Rubinius::LookupTable.new(previous => true, pair_id => true)
+
+      begin
+        yield
+      ensure
+        objects[id] = previous
+      end
+    end
+
+    false
+  end
+
+  # Similar to detect_recursion, but will short circuit all inner recursion
+  # levels (using a throw)
+
+  class InnerRecursionDetected < Exception; end
+
+  def self.detect_outermost_recursion(obj, paired_obj=undefined, &block)
+    rec = current.recursive_objects
+
+    if rec[:__detect_outermost_recursion__]
+      if detect_recursion(obj, paired_obj, &block)
+        raise InnerRecursionDetected.new
+      end
+      false
+    else
+      begin
+        rec[:__detect_outermost_recursion__] = true
+
+        begin
+          detect_recursion(obj, paired_obj, &block)
+        rescue InnerRecursionDetected
+          return true
+        end
+
+        return nil
+      ensure
+        rec.delete :__detect_outermost_recursion__
+      end
+    end
+  end
+
+end

data/lib/rubinius/kernel/common/tuple.rb

@@ -0,0 +1,148 @@
+##
+# The tuple data type.
+# A simple storage class. Created to contain a fixed number of elements.
+#
+# Not designed to be subclassed, as it does not call initialize
+# on new instances.
+
+module Rubinius
+  class Tuple
+
+    include Enumerable
+
+    def self.[](*args)
+      start = args.start
+      tot = args.size
+      return new(tot).copy_from(args.tuple, start, tot, 0)
+    end
+
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} #{fields} elements>"
+    end
+
+    def each
+      i = 0
+      t = fields
+      while i < t
+        yield at(i)
+        i += 1
+      end
+      self
+    end
+
+    def ==(tup)
+      return super unless tup.kind_of?(Tuple)
+
+      t = fields()
+
+      return false unless t == tup.size
+
+      i = 0
+      while i < t
+        return false unless at(i) == tup.at(i)
+        i += 1
+      end
+
+      return true
+    end
+
+    def +(o)
+      t = Tuple.new(size + o.size)
+      t.copy_from(self,0,size,0)
+      t.copy_from(o,0,o.size,size)
+      t
+    end
+
+    def inspect
+      str = "#<#{self.class}"
+      if fields == 0
+        str << " empty>"
+      else
+        str << ": #{join(", ", :inspect)}>"
+      end
+      return str
+    end
+
+    def join(sep, meth=:to_s)
+      join_upto(sep, fields, meth)
+    end
+
+    def join_upto(sep, count, meth=:to_s)
+      str = ""
+      return str if count == 0 or empty?
+
+      count = fields if count >= fields
+      count -= 1
+      i = 0
+      while i < count
+        str.append at(i).__send__(meth)
+        str.append sep.dup
+        i += 1
+      end
+
+      str.append at(count).__send__(meth)
+      return str
+    end
+
+    def ===(other)
+      return false unless Tuple === other and fields == other.fields
+      i = 0
+      while i < fields
+        return false unless at(i) === other.at(i)
+        i += 1
+      end
+      true
+    end
+
+    def to_a
+      ary = []
+      ary.tuple = dup
+      ary.total = fields
+      ary.start = 0
+      return ary
+    end
+
+    def shift
+      return self unless fields > 0
+      t = Tuple.new(fields-1)
+      t.copy_from self, 1, fields-1, 0
+      return t
+    end
+
+    # Swap elements of the two indexes.
+    def swap(a, b)
+      temp = at(a)
+      put a, at(b)
+      put b, temp
+    end
+
+    alias_method :size, :fields
+    alias_method :length, :fields
+
+    def empty?
+      size == 0
+    end
+
+    def first
+      at(0)
+    end
+
+    def last
+      at(fields - 1)
+    end
+
+    # Marshal support - _dump / _load are deprecated so eventually we should figure
+    # out a better way.
+    def _dump(depth)
+      # TODO use depth
+      Marshal.dump to_a
+    end
+
+    def self._load(str)
+      ary = Marshal.load(str)
+      t = new(ary.size)
+      ary.each_with_index { |obj, idx| t[idx] = obj }
+      return t
+    end
+  end
+end

data/lib/rubinius/kernel/common/type.rb

@@ -0,0 +1,114 @@
+##
+# Namespace for coercion functions between various ruby objects.
+
+module Rubinius
+  module Type
+
+    ##
+    # Returns an object of given class. If given object already is one, it is
+    # returned. Otherwise tries obj.meth and returns the result if it is of the
+    # right kind. TypeErrors are raised if the conversion method fails or the
+    # conversion result is wrong.
+    #
+    # Uses Rubinius::Type.object_kind_of to bypass type check overrides.
+    #
+    # Equivalent to MRI's rb_convert_type().
+
+    def self.coerce_to(obj, cls, meth)
+      return obj if object_kind_of?(obj, cls)
+
+      begin
+        ret = obj.__send__(meth)
+      rescue Exception => orig
+        raise TypeError,
+              "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed",
+              orig
+      end
+
+      return ret if object_kind_of?(ret, cls)
+
+      msg = "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{object_class(ret)})"
+      raise TypeError, msg
+    end
+
+    ##
+    # Same as coerce_to but returns nil if conversion fails.
+    # Corresponds to MRI's rb_check_convert_type()
+    #
+    def self.try_convert(obj, cls, meth)
+      return obj if object_kind_of?(obj, cls)
+      return nil unless obj.respond_to?(meth)
+
+      begin
+        ret = obj.__send__(meth)
+      rescue Exception
+        return nil
+      end
+
+      return ret if ret.nil? || object_kind_of?(ret, cls)
+
+      msg = "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{object_class(ret)})"
+      raise TypeError, msg
+    end
+
+    def self.coerce_to_symbol(obj)
+      if object_kind_of?(obj, Fixnum)
+        raise ArgumentError, "Fixnums (#{obj}) cannot be used as symbols"
+      end
+      obj = obj.to_str if obj.respond_to?(:to_str)
+
+      coerce_to(obj, Symbol, :to_sym)
+    end
+
+    def self.coerce_to_comparison(a, b)
+      unless cmp = (a <=> b)
+        raise ArgumentError, "comparison of #{a.inspect} with #{b.inspect} failed"
+      end
+      cmp
+    end
+
+    # Maps to rb_num2long in MRI
+    def self.num2long(obj)
+      if obj == nil
+        raise TypeError, "no implicit conversion from nil to integer"
+      else
+        Integer(obj)
+      end
+    end
+
+    def self.each_ancestor(mod)
+      unless object_kind_of?(mod, Class) and singleton_class_object(mod)
+        yield mod
+      end
+
+      sup = mod.direct_superclass()
+      while sup
+        if object_kind_of?(sup, IncludedModule)
+          yield sup.module
+        elsif object_kind_of?(sup, Class)
+          yield sup unless singleton_class_object(sup)
+        else
+          yield sup
+        end
+        sup = sup.direct_superclass()
+      end
+    end
+
+    def self.ivar_validate(name)
+      # adapted from rb_to_id
+      case name
+      when String
+        return name.to_sym if name[0] == ?@
+      when Symbol
+        return name if name.is_ivar?
+      when Fixnum
+        raise ArgumentError, "#{name.inspect} is not a symbol"
+      else
+        name = Rubinius::Type.coerce_to(name, String, :to_str)
+        return name.to_sym if name[0] == ?@
+      end
+
+      raise NameError, "`#{name}' is not allowed as an instance variable name"
+    end
+  end
+end

data/rubinius-core-api.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+base_specification = proc do |s|
+  s.name = %q{rubinius-core-api}
+  s.version = "0.0.1"
+  s.authors = ["Charles Oliver Nutter"]
+  s.date = Time.now
+  s.description = "Cross-impl versions of interesting Rubinius core classes"
+  s.email = ["headius@headius.com"]
+  s.files = Dir['{lib,src}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
+  s.homepage = "http://github.com/rubinius/rubinius-core-api"
+  s.require_paths = ["lib"]
+  s.summary = "Cross-impl versions of interesting Rubinius core classes"
+  s.test_files = Dir["test/test*.rb"]
+end
+
+if defined?(JRUBY_VERSION)
+  Gem::Specification.new do |s|
+    s.tap(&base_specification)
+    s.platform = "java"
+  end
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  Gem::Specification.new do |s|
+    s.tap(&base_specification)
+  end
+else
+  raise "Only supported on JRuby right now."
+end

data/src/org/jruby/ext/rubinius/RubiniusByteArray.java

@@ -0,0 +1,290 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Version: CPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Common Public
+ * License Version 1.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2011 Charles O Nutter <headius@headius.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package org.jruby.ext.rubinius;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+public class RubiniusByteArray extends RubyObject {
+
+    private final byte[] bytes;
+
+    RubiniusByteArray(Ruby runtime, int size) {
+        // FIXME: need to store metaclass somewhere...
+        super(runtime, (RubyClass) runtime.getClassFromPath("Rubinius::ByteArray"));
+
+        bytes = new byte[size];
+    }
+
+    RubiniusByteArray(Ruby runtime, byte[] bytes) {
+        // FIXME: need to store metaclass somewhere...
+        super(runtime, (RubyClass) runtime.getClassFromPath("Rubinius::ByteArray"));
+
+        this.bytes = bytes;
+    }
+
+    public static void createByteArrayClass(Ruby runtime) {
+        RubyClass baClass = runtime.getOrCreateModule("Rubinius").defineClassUnder("ByteArray", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+        baClass.setReifiedClass(RubiniusByteArray.class);
+
+        baClass.defineAnnotatedMethods(RubiniusByteArray.class);
+        
+        // add "data" method to String for spec purposes; not recommended for use (raw byte[] access)
+        runtime.getString().defineAnnotatedMethods(RubiniusString.class);
+    }
+
+    static RubiniusByteArray create(ThreadContext context, int size) {
+        return new RubiniusByteArray(context.runtime, size);
+    }
+
+    private int size() {
+        return bytes.length;
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject allocate(ThreadContext state, IRubyObject baClass, IRubyObject size) {
+        throw state.runtime.newTypeError("ByteArray cannot be created via allocate()");
+    }
+
+    @JRubyMethod(name = {"new", "allocate_sized"}, meta = true)
+    public static IRubyObject allocate_sized(ThreadContext state, IRubyObject baClass, IRubyObject bytes) {
+        long size = bytes.convertToInteger().getLongValue();
+        if(size < 0) {
+          RubiniusLibrary.argument_error(state, "negative byte array size");
+        } else if (size > Integer.MAX_VALUE) {
+          RubiniusLibrary.argument_error(state, "too large byte array size");
+        }
+        return RubiniusByteArray.create(state, (int)size);
+    }
+
+    @JRubyMethod
+    public IRubyObject fetch_bytes(ThreadContext state, IRubyObject start, IRubyObject count) {
+        long src = start.convertToInteger().getLongValue();
+        long cnt = count.convertToInteger().getLongValue();
+
+        if (src < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "start less than zero");
+        } else if (cnt < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "count less than zero");
+        } else if ((src + cnt) > size()) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "fetch is more than available bytes");
+        }
+
+        RubiniusByteArray ba = RubiniusByteArray.create(state, (int) cnt + 1);
+        System.arraycopy(this.bytes, (int) src, ba.bytes, 0, (int) cnt);
+        ba.bytes[(int) cnt] = 0;
+
+        return ba;
+    }
+
+    @JRubyMethod
+    public IRubyObject move_bytes(ThreadContext state, IRubyObject start, IRubyObject count, IRubyObject dest) {
+        long src = start.convertToInteger().getLongValue();
+        long cnt = count.convertToInteger().getLongValue();
+        long dst = dest.convertToInteger().getLongValue();
+
+        if (src < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "start less than zero");
+        } else if (dst < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "dest less than zero");
+        } else if (cnt < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "count less than zero");
+        } else if ((dst + cnt) > size()) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "move is beyond end of bytearray");
+        } else if ((src + cnt) > size()) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "move is more than available bytes");
+        }
+
+        System.arraycopy(this.bytes, (int) src, this.bytes, (int) dst, (int) cnt);
+
+        return count;
+    }
+
+    @JRubyMethod
+    public IRubyObject get_byte(ThreadContext state, IRubyObject index) {
+        long idx = index.convertToInteger().getLongValue();
+
+        if (idx < 0 || idx >= size()) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "index out of bounds");
+        }
+
+        return RubyFixnum.newFixnum(state.runtime, this.bytes[(int) idx]);
+    }
+
+    @JRubyMethod
+    public IRubyObject set_byte(ThreadContext state, IRubyObject index, IRubyObject value) {
+        long idx = index.convertToInteger().getLongValue();
+
+        if (idx < 0 || idx >= size()) {
+            RubiniusLibrary.object_bounds_exceeded_error(state, "index out of bounds");
+        }
+
+        this.bytes[(int) idx] = (byte) value.convertToInteger().getLongValue();
+        return RubyFixnum.newFixnum(state.runtime, this.bytes[(int) idx]);
+    }
+
+    @JRubyMethod
+    public IRubyObject compare_bytes(ThreadContext state, IRubyObject _other, IRubyObject a, IRubyObject b) {
+        RubiniusByteArray other = (RubiniusByteArray) _other;
+        long slim = a.convertToInteger().getLongValue();
+        long olim = b.convertToInteger().getLongValue();
+
+        if (slim < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state,
+                    "bytes of self to compare is less than zero");
+        } else if (olim < 0) {
+            RubiniusLibrary.object_bounds_exceeded_error(state,
+                    "bytes of other to compare is less than zero");
+        }
+
+        // clamp limits to actual sizes
+        long m = size() < slim ? size() : slim;
+        long n = other.size() < olim ? other.size() : olim;
+
+        // only compare the shortest string
+        long len = m < n ? m : n;
+
+        long cmp = ByteList.memcmp(this.bytes, 0, other.bytes, 0, (int) len);
+
+        // even if substrings are equal, check actual requested limits
+        // of comparison e.g. "xyz", "xyzZ"
+        if (cmp == 0) {
+            if (m < n) {
+                return RubyFixnum.minus_one(state.runtime);
+            } else if (m > n) {
+                return RubyFixnum.one(state.runtime);
+            } else {
+                return RubyFixnum.zero(state.runtime);
+            }
+        } else {
+            return cmp < 0 ? RubyFixnum.minus_one(state.runtime) : RubyFixnum.one(state.runtime);
+        }
+    }
+
+    @JRubyMethod
+    public IRubyObject size(ThreadContext state) {
+        return RubyFixnum.newFixnum(state.runtime, bytes.length);
+    }
+
+    @JRubyMethod
+    public IRubyObject dup() {
+        return super.dup();
+    }
+
+    @JRubyMethod
+    public IRubyObject locate(ThreadContext state, IRubyObject pattern, IRubyObject start, IRubyObject max_o) {
+        byte[] pat = pattern.convertToString().getByteList().bytes();
+        int len = pat.length;
+        long max = max_o.convertToInteger().getLongValue();
+
+        if (len == 0) {
+            return start;
+        }
+
+        if (max == 0 || max > size()) {
+            max = size();
+        }
+
+        max -= (len - 1);
+
+        for (int i = (int) start.convertToInteger().getLongValue(); i < max; i++) {
+            if (this.bytes[i] == pat[0]) {
+                int j;
+                // match the rest of the pattern string
+                for (j = 1; j < len; j++) {
+                    if (this.bytes[i + j] != pat[j]) {
+                        break;
+                    }
+                }
+
+                // if the full pattern matched, return the index
+                // of the end of the pattern in 'this'.
+                if (j == len) {
+                    return RubyFixnum.newFixnum(state.runtime, i + len);
+                }
+            }
+        }
+
+        return state.nil;
+    }
+
+    @JRubyMethod
+    public IRubyObject prepend(ThreadContext state, IRubyObject _str) {
+        RubyString str = _str.convertToString();
+        RubiniusByteArray ba = RubiniusByteArray.create(state, size() + str.size());
+
+        System.arraycopy(str.getByteList().unsafeBytes(), str.getByteList().getBegin(), ba.bytes, 0, str.size());
+        System.arraycopy(bytes, 0, ba.bytes, str.size(), size());
+
+        return ba;
+    }
+
+    @JRubyMethod
+    public IRubyObject utf8_char(ThreadContext state, IRubyObject offset) {
+        // not sure what this is supposed to return or best way to get it in JRuby yet
+        throw state.runtime.newNotImplementedError("ByteArray#utf8_char not implemented");
+    }
+
+    @JRubyMethod
+    public IRubyObject reverse(ThreadContext state, IRubyObject o_start, IRubyObject o_total) {
+        long start = o_start.convertToInteger().getLongValue();
+        long total = o_total.convertToInteger().getLongValue();
+
+        if (total <= 0 || start < 0 || start >= size()) {
+            return this;
+        }
+
+        int pos1 = (int) start;
+        int pos2 = (int) total - 1;
+        byte tmp;
+
+        while (pos1 < pos2) {
+            tmp = bytes[pos1];
+            bytes[pos1++] = bytes[pos2];
+            bytes[pos2--] = tmp;
+        }
+
+        return this;
+    }
+    
+    public static class RubiniusString {
+        @JRubyMethod
+        public static IRubyObject data(ThreadContext context, IRubyObject string) {
+            return new RubiniusByteArray(context.runtime, ((RubyString)string).getByteList().getUnsafeBytes());
+        }
+    }
+}