RubyInteger.java

  1. /*
  2.  **** BEGIN LICENSE BLOCK *****
  3.  * Version: EPL 1.0/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Eclipse Public
  6.  * License Version 1.0 (the "License"); you may not use this file
  7.  * except in compliance with the License. You may obtain a copy of
  8.  * the License at http://www.eclipse.org/legal/epl-v10.html
  9.  *
  10.  * Software distributed under the License is distributed on an "AS
  11.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  12.  * implied. See the License for the specific language governing
  13.  * rights and limitations under the License.
  14.  *
  15.  * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>
  16.  * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  17.  * Copyright (C) 2002 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  18.  * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
  19.  * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org>
  20.  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  21.  * Copyright (C) 2005 Charles O Nutter <headius@headius.com>
  22.  * 
  23.  * Alternatively, the contents of this file may be used under the terms of
  24.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  25.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26.  * in which case the provisions of the GPL or the LGPL are applicable instead
  27.  * of those above. If you wish to allow use of your version of this file only
  28.  * under the terms of either the GPL or the LGPL, and not to allow others to
  29.  * use your version of this file under the terms of the EPL, indicate your
  30.  * decision by deleting the provisions above and replace them with the notice
  31.  * and other provisions required by the GPL or the LGPL. If you do not delete
  32.  * the provisions above, a recipient may use your version of this file under
  33.  * the terms of any one of the EPL, the GPL or the LGPL.
  34.  ***** END LICENSE BLOCK *****/
  35. package org.jruby;

  37. import org.jcodings.Encoding;
  38. import org.jcodings.exception.EncodingException;
  39. import org.jcodings.specific.ASCIIEncoding;
  40. import org.jcodings.specific.USASCIIEncoding;
  41. import org.jruby.anno.JRubyClass;
  42. import org.jruby.anno.JRubyMethod;
  43. import org.jruby.runtime.Block;
  44. import org.jruby.runtime.BlockBody;
  45. import org.jruby.runtime.ClassIndex;
  46. import org.jruby.runtime.ObjectAllocator;
  47. import org.jruby.runtime.ThreadContext;
  48. import org.jruby.runtime.builtin.IRubyObject;
  49. import org.jruby.util.ByteList;
  50. import org.jruby.util.Numeric;
  51. import org.jruby.util.StringSupport;

  53. import static org.jruby.RubyEnumerator.enumeratorizeWithSize;
  54. import static org.jruby.util.Numeric.checkInteger;
  55. import static org.jruby.util.Numeric.f_gcd;
  56. import static org.jruby.util.Numeric.f_lcm;
  57. import static org.jruby.RubyEnumerator.SizeFn;

  59. /** Implementation of the Integer class.
  60.  *
  61.  * @author  jpetersen
  62.  */
  63. @JRubyClass(name="Integer", parent="Numeric", include="Precision")
  64. public abstract class RubyInteger extends RubyNumeric { 

  66.     public static RubyClass createIntegerClass(Ruby runtime) {
  67.         RubyClass integer = runtime.defineClass("Integer", runtime.getNumeric(),
  68.                 ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
  69.         runtime.setInteger(integer);

  71.         integer.setClassIndex(ClassIndex.INTEGER);
  72.         integer.setReifiedClass(RubyInteger.class);
  73.         
  74.         integer.kindOf = new RubyModule.JavaClassKindOf(RubyInteger.class);

  76.         integer.getSingletonClass().undefineMethod("new");

  78.         integer.defineAnnotatedMethods(RubyInteger.class);
  79.         
  80.         return integer;
  81.     }

  83.     public RubyInteger(Ruby runtime, RubyClass rubyClass) {
  84.         super(runtime, rubyClass);
  85.     }

  87.     public RubyInteger(RubyClass rubyClass) {
  88.         super(rubyClass);
  89.     }
  90.     
  91.     public RubyInteger(Ruby runtime, RubyClass rubyClass, boolean useObjectSpace) {
  92.         super(runtime, rubyClass, useObjectSpace);
  93.     }     

  95.     @Deprecated
  96.     public RubyInteger(Ruby runtime, RubyClass rubyClass, boolean useObjectSpace, boolean canBeTainted) {
  97.         super(runtime, rubyClass, useObjectSpace, canBeTainted);
  98.     }     

  100.     @Override
  101.     public RubyInteger convertToInteger() {
  102.         return this;
  103.     }

  105.     // conversion
  106.     protected RubyFloat toFloat() {
  107.         return RubyFloat.newFloat(getRuntime(), getDoubleValue());
  108.     }

  110.     /*  ================
  111.      *  Instance Methods
  112.      *  ================ 
  113.      */

  115.     /** int_int_p
  116.      * 
  117.      */
  118.     @Override
  119.     @JRubyMethod(name = "integer?")
  120.     public IRubyObject integer_p() {
  121.         return getRuntime().getTrue();
  122.     }

  124.     /** int_upto
  125.      * 
  126.      */
  127.     @JRubyMethod
  128.     public IRubyObject upto(ThreadContext context, IRubyObject to, Block block) {
  129.         if (block.isGiven()) {
  130.             if (this instanceof RubyFixnum && to instanceof RubyFixnum) {
  131.                 fixnumUpto(context, ((RubyFixnum)this).getLongValue(), ((RubyFixnum)to).getLongValue(), block);
  132.             } else {
  133.                 duckUpto(context, this, to, block);
  134.             }
  135.             return this;
  136.         } else {
  137.             return enumeratorizeWithSize(context, this, "upto", new IRubyObject[] { to }, uptoSize(context, this, to));
  138.         }
  139.     }

  141.     private static void fixnumUpto(ThreadContext context, long from, long to, Block block) {
  142.         // We must avoid "i++" integer overflow when (to == Long.MAX_VALUE).
  143.         Ruby runtime = context.runtime;
  144.         if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) {
  145.             IRubyObject nil = runtime.getNil();
  146.             long i;
  147.             for (i = from; i < to; i++) {
  148.                 block.yield(context, nil);
  149.             }
  150.             if (i <= to) {
  151.                 block.yield(context, nil);
  152.             }
  153.         } else {
  154.             long i;
  155.             for (i = from; i < to; i++) {
  156.                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
  157.             }
  158.             if (i <= to) {
  159.                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
  160.             }
  161.         }
  162.     }

  164.     private static void duckUpto(ThreadContext context, IRubyObject from, IRubyObject to, Block block) {
  165.         Ruby runtime = context.runtime;
  166.         IRubyObject i = from;
  167.         RubyFixnum one = RubyFixnum.one(runtime);
  168.         while (true) {
  169.             if (i.callMethod(context, ">", to).isTrue()) {
  170.                 break;
  171.             }
  172.             block.yield(context, i);
  173.             i = i.callMethod(context, "+", one);
  174.         }
  175.     }

  177.     private static SizeFn uptoSize(final ThreadContext context, final IRubyObject from, final IRubyObject to) {
  178.         return new SizeFn() {
  179.             @Override
  180.             public IRubyObject size(IRubyObject[] args) {
  181.                 return intervalStepSize(context, from, to, RubyFixnum.one(context.runtime), false);
  182.             }
  183.         };
  184.     }

  186.     /** int_downto
  187.      * 
  188.      */
  189.     // TODO: Make callCoerced work in block context...then fix downto, step, and upto.
  190.     @JRubyMethod
  191.     public IRubyObject downto(ThreadContext context, IRubyObject to, Block block) {
  192.         if (block.isGiven()) {
  193.             if (this instanceof RubyFixnum && to instanceof RubyFixnum) {
  194.                 fixnumDownto(context, ((RubyFixnum)this).getLongValue(), ((RubyFixnum)to).getLongValue(), block);
  195.             } else {
  196.                 duckDownto(context, this, to, block);
  197.             }
  198.             return this;
  199.         } else {
  200.             return enumeratorizeWithSize(context, this, "downto", new IRubyObject[] { to }, downToSize(context, this, to));
  201.         }
  202.     }

  204.     private static void fixnumDownto(ThreadContext context, long from, long to, Block block) {
  205.         // We must avoid "i--" integer overflow when (to == Long.MIN_VALUE).
  206.         Ruby runtime = context.runtime;
  207.         if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) {
  208.             IRubyObject nil = runtime.getNil();
  209.             long i;
  210.             for (i = from; i > to; i--) {
  211.                 block.yield(context, nil);
  212.             }
  213.             if (i >= to) {
  214.                 block.yield(context, nil);
  215.             }
  216.         } else {
  217.             long i;
  218.             for (i = from; i > to; i--) {
  219.                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
  220.             }
  221.             if (i >= to) {
  222.                 block.yield(context, RubyFixnum.newFixnum(runtime, i));
  223.             }
  224.         }
  225.     }

  227.     private static void duckDownto(ThreadContext context, IRubyObject from, IRubyObject to, Block block) {
  228.         Ruby runtime = context.runtime;
  229.         IRubyObject i = from;
  230.         RubyFixnum one = RubyFixnum.one(runtime);
  231.         while (true) {
  232.             if (i.callMethod(context, "<", to).isTrue()) {
  233.                 break;
  234.             }
  235.             block.yield(context, i);
  236.             i = i.callMethod(context, "-", one);
  237.         }
  238.     }

  240.     private static SizeFn downToSize(final ThreadContext context, final IRubyObject from, final IRubyObject to) {
  241.         return new SizeFn() {
  242.             @Override
  243.             public IRubyObject size(IRubyObject[] args) {
  244.                 return intervalStepSize(context, from, to, RubyFixnum.newFixnum(context.runtime, -1), false);
  245.             }
  246.         };
  247.     }

  249.     @JRubyMethod
  250.     public IRubyObject times(ThreadContext context, Block block) {
  251.         if (block.isGiven()) {
  252.             Ruby runtime = context.runtime;
  253.             IRubyObject i = RubyFixnum.zero(runtime);
  254.             RubyFixnum one = RubyFixnum.one(runtime);
  255.             while (true) {
  256.                 if (!i.callMethod(context, "<", this).isTrue()) {
  257.                     break;
  258.                 }
  259.                 block.yield(context, i);
  260.                 i = i.callMethod(context, "+", one);
  261.             }
  262.             return this;
  263.         } else {
  264.             return enumeratorizeWithSize(context, this, "times", timesSizeFn(context.runtime));
  265.         }
  266.     }

  268.     protected SizeFn timesSizeFn(final Ruby runtime) {
  269.         final RubyInteger self = this;
  270.         return new SizeFn() {
  271.             @Override
  272.             public IRubyObject size(IRubyObject[] args) {
  273.                 RubyFixnum zero = RubyFixnum.zero(runtime);
  274.                 if ((self instanceof RubyFixnum && getLongValue() < 0)
  275.                         || self.callMethod("<", zero).isTrue()) {
  276.                     return zero;
  277.                 }

  279.                 return self;
  280.             }
  281.         };
  282.     }

  284.     /** int_succ
  285.      * 
  286.      */
  287.     @JRubyMethod(name = {"succ", "next"})
  288.     public IRubyObject succ(ThreadContext context) {
  289.         if (this instanceof RubyFixnum) {
  290.             return ((RubyFixnum) this).op_plus_one(context);
  291.         } else {
  292.             return callMethod(context, "+", RubyFixnum.one(context.runtime));
  293.         }
  294.     }

  296.     static final ByteList[] SINGLE_CHAR_BYTELISTS;
  297.     public static final ByteList[] SINGLE_CHAR_BYTELISTS19;
  298.     static {
  299.         SINGLE_CHAR_BYTELISTS = new ByteList[256];
  300.         SINGLE_CHAR_BYTELISTS19 = new ByteList[256];
  301.         for (int i = 0; i < 256; i++) {
  302.             ByteList usascii = new ByteList(new byte[]{(byte)i}, false);
  303.             SINGLE_CHAR_BYTELISTS[i] = usascii;
  304.             SINGLE_CHAR_BYTELISTS19[i] = i < 0x80 ?
  305.                 new ByteList(new byte[]{(byte)i}, USASCIIEncoding.INSTANCE)
  306.                 :
  307.                 new ByteList(
  308.                     new byte[]{(byte)i},
  309.                     ASCIIEncoding.INSTANCE);
  310.         }
  311.     }

  313.     /** int_chr
  314.      * 
  315.      */
  316.     public RubyString chr(ThreadContext context) {
  317.         return chr19(context);
  318.     }

  320.     @JRubyMethod(name = "chr")
  321.     public RubyString chr19(ThreadContext context) {
  322.         Ruby runtime = context.runtime;
  323.         int value = (int)getLongValue();
  324.         if (value >= 0 && value <= 0xFF) {
  325.             ByteList bytes = SINGLE_CHAR_BYTELISTS19[value];
  326.             return RubyString.newStringShared(runtime, bytes, bytes.getEncoding());
  327.         } else {
  328.             Encoding enc = runtime.getDefaultInternalEncoding();
  329.             if (value > 0xFF && (enc == null || enc == ASCIIEncoding.INSTANCE)) {
  330.                 throw runtime.newRangeError(this.toString() + " out of char range");
  331.             } else {
  332.                 if (enc == null) enc = USASCIIEncoding.INSTANCE;
  333.                 return RubyString.newStringNoCopy(runtime, fromEncodedBytes(runtime, enc, (int)value), enc, 0);
  334.             }
  335.         }
  336.     }

  338.     @JRubyMethod(name = "chr")
  339.     public RubyString chr19(ThreadContext context, IRubyObject arg) {
  340.         Ruby runtime = context.runtime;
  341.         long value = getLongValue();
  342.         Encoding enc;
  343.         if (arg instanceof RubyEncoding) {
  344.             enc = ((RubyEncoding)arg).getEncoding();
  345.         } else {
  346.             enc =  arg.convertToString().toEncoding(runtime);
  347.         }
  348.         if (enc == ASCIIEncoding.INSTANCE && value >= 0x80) {
  349.             return chr19(context);
  350.         }
  351.         return RubyString.newStringNoCopy(runtime, fromEncodedBytes(runtime, enc, (int)value), enc, 0);
  352.     }

  354.     private ByteList fromEncodedBytes(Ruby runtime, Encoding enc, int value) {
  355.         int n;
  356.         try {
  357.             n = value < 0 ? 0 : enc.codeToMbcLength(value);
  358.         } catch (EncodingException ee) {
  359.             n = 0;
  360.         }

  362.         if (n <= 0) throw runtime.newRangeError(this.toString() + " out of char range");
  363.         
  364.         ByteList bytes = new ByteList(n);
  365.         
  366.         try {
  367.             enc.codeToMbc(value, bytes.getUnsafeBytes(), 0);
  368.         } catch (EncodingException e) {
  369.             throw runtime.newRangeError("invalid codepoint " + String.format("0x%x in ", value) + enc.getCharsetName());
  370.         }
  371.         bytes.setRealSize(n);
  372.         return bytes;
  373.     }

  375.     /** int_ord
  376.      * 
  377.      */
  378.     @JRubyMethod(name = "ord")
  379.     public IRubyObject ord(ThreadContext context) {
  380.         return this;
  381.     }

  383.     /** int_to_i
  384.      * 
  385.      */
  386.     @JRubyMethod(name = {"to_i", "to_int", "floor", "ceil", "truncate"})
  387.     public IRubyObject to_i() {
  388.         return this;
  389.     }

  391.     @Override
  392.     public IRubyObject round() {
  393.         return this;
  394.     }

  396.     @JRubyMethod(name = "round")
  397.     public IRubyObject round19() {
  398.         return this;
  399.     }

  401.     @JRubyMethod(name = "round")
  402.     public IRubyObject round19(ThreadContext context, IRubyObject arg) {
  403.         int ndigits = RubyNumeric.num2int(arg);
  404.         if (ndigits > 0) return RubyKernel.new_float(this, this);
  405.         if (ndigits == 0) return this;
  406.         Ruby runtime = context.runtime;
  407.         
  408.         long bytes = (this instanceof RubyFixnum) ? 8 : RubyFixnum.fix2long(callMethod("size"));
  409.         /* If 10**N/2 > this, return 0 */
  410.         /* We have log_256(10) > 0.415241 and log_256(1/2)=-0.125 */
  411.         if (-0.415241 * ndigits - 0.125 > bytes) {
  412.             return RubyFixnum.zero(runtime);
  413.         }
  414.         
  415.         IRubyObject f = Numeric.int_pow(context, 10, -ndigits);

  417.         if (this instanceof RubyFixnum && f instanceof RubyFixnum) {
  418.             long x = ((RubyFixnum)this).getLongValue();
  419.             long y = ((RubyFixnum)f).getLongValue();
  420.             boolean neg = x < 0;
  421.             if (neg) x = -x;
  422.             x = (x + y / 2) / y * y;
  423.             if (neg) x = -x;
  424.             return RubyFixnum.newFixnum(runtime, x);
  425.         } else if (f instanceof RubyFloat) {
  426.             return RubyFixnum.zero(runtime);
  427.         } else {
  428.             IRubyObject h = f.callMethod(context, "/", RubyFixnum.two(runtime));
  429.             IRubyObject r = callMethod(context, "%", f);
  430.             IRubyObject n = callMethod(context, "-", r);
  431.             String op = callMethod(context, "<", RubyFixnum.zero(runtime)).isTrue() ? "<=" : "<";
  432.             if (!r.callMethod(context, op, h).isTrue()) n = n.callMethod(context, "+", f);
  433.             return n;
  434.         }
  435.     }

  437.     /** integer_to_r
  438.      * 
  439.      */
  440.     @JRubyMethod(name = "to_r")
  441.     public IRubyObject to_r(ThreadContext context) {
  442.         return RubyRational.newRationalCanonicalize(context, this);
  443.     }

  445.     /** integer_rationalize
  446.      *
  447.      */
  448.     @JRubyMethod(name = "rationalize", optional = 1)
  449.     public IRubyObject rationalize(ThreadContext context, IRubyObject[] args) {
  450.         return to_r(context);
  451.     }
  452.     

  454.     @JRubyMethod(name = "odd?")
  455.     public RubyBoolean odd_p(ThreadContext context) {
  456.         Ruby runtime = context.runtime;
  457.         if (callMethod(context, "%", RubyFixnum.two(runtime)) != RubyFixnum.zero(runtime)) {
  458.             return runtime.getTrue();
  459.         }
  460.         return runtime.getFalse();
  461.     }

  463.     @JRubyMethod(name = "even?")
  464.     public RubyBoolean even_p(ThreadContext context) {
  465.         Ruby runtime = context.runtime;
  466.         if (callMethod(context, "%", RubyFixnum.two(runtime)) == RubyFixnum.zero(runtime)) {
  467.             return runtime.getTrue();
  468.         }
  469.         return runtime.getFalse();
  470.     }

  472.     @JRubyMethod(name = "pred")
  473.     public IRubyObject pred(ThreadContext context) {
  474.         return callMethod(context, "-", RubyFixnum.one(context.runtime));
  475.     }

  477.     /** rb_gcd
  478.      * 
  479.      */
  480.     @JRubyMethod(name = "gcd")
  481.     public IRubyObject gcd(ThreadContext context, IRubyObject other) {
  482.         checkInteger(context, other);
  483.         return f_gcd(context, this, RubyRational.intValue(context, other));
  484.     }    

  486.     /** rb_lcm
  487.      * 
  488.      */
  489.     @JRubyMethod(name = "lcm")
  490.     public IRubyObject lcm(ThreadContext context, IRubyObject other) {
  491.         checkInteger(context, other);
  492.         return f_lcm(context, this, RubyRational.intValue(context, other));
  493.     }    

  495.     /** rb_gcdlcm
  496.      * 
  497.      */
  498.     @JRubyMethod(name = "gcdlcm")
  499.     public IRubyObject gcdlcm(ThreadContext context, IRubyObject other) {
  500.         checkInteger(context, other);
  501.         other = RubyRational.intValue(context, other);
  502.         return context.runtime.newArray(f_gcd(context, this, other), f_lcm(context, this, other));
  503.     }

  505.     @Override
  506.     @JRubyMethod(name = "numerator")
  507.     public IRubyObject numerator(ThreadContext context) {
  508.         return this;
  509.     }

  511.     @Override
  512.     @JRubyMethod(name = "denominator")
  513.     public IRubyObject denominator(ThreadContext context) {
  514.         return RubyFixnum.one(context.runtime);
  515.     }

  517.     /*  ================
  518.      *  Singleton Methods
  519.      *  ================ 
  520.      */

  522.     /** rb_int_induced_from
  523.      * 
  524.      */
  525.     @Deprecated
  526.     public static IRubyObject induced_from(ThreadContext context, IRubyObject recv, IRubyObject other) {
  527.         if (other instanceof RubyFixnum || other instanceof RubyBignum) {
  528.             return other;
  529.         } else if (other instanceof RubyFloat || other instanceof RubyRational) {
  530.             return other.callMethod(context, "to_i");
  531.         } else {
  532.             throw recv.getRuntime().newTypeError(
  533.                     "failed to convert " + other.getMetaClass().getName() + " into Integer");
  534.         }
  535.     }
  536. }
Created with JaCoCo 0.7.3.201501050207