jruby · Mar 13, 2015 · Mar 13, 2015 · Mar 13, 2015 · Mar 13, 2015 · Mar 13, 2015
diff --git a/.travis.yml b/.travis.yml
@@ -69,6 +69,8 @@ matrix:
       jdk: oraclejdk8
     - env: COMMAND=tool/truffle-findbugs.sh
       jdk: oraclejdk8
+    - env: COMMAND=test/truffle/run.sh
+      jdk: oraclejdk8
   fast_finish: true
 
 

diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -920,17 +920,12 @@ public TruffleBridge getTruffleBridge() {
     }
 
     private TruffleBridge loadTruffleBridge() {
-        /*
-         * It's possible to remove Truffle classes from the JRuby distribution, so we provide a sensible
-         * explanation when the classes are not found.
-         */
-
         final Class<?> clazz;
 
         try {
             clazz = getJRubyClassLoader().loadClass("org.jruby.truffle.TruffleBridgeImpl");
         } catch (Exception e) {
-            throw new UnsupportedOperationException("Support for Truffle has been removed from this distribution", e);
+            throw new UnsupportedOperationException("Truffle classes not available", e);
         }
 
         final TruffleBridge truffleBridge;
@@ -939,7 +934,7 @@ private TruffleBridge loadTruffleBridge() {
             Constructor<?> con = clazz.getConstructor(Ruby.class);
             truffleBridge = (TruffleBridge) con.newInstance(this);
         } catch (Exception e) {
-            throw new UnsupportedOperationException("Error while calling the constructor of Truffle Bridge", e);
+            throw new UnsupportedOperationException("Error while calling the constructor of TruffleBridgeImpl", e);
         }
 
         truffleBridge.init();

diff --git a/core/src/main/java/org/jruby/TruffleBridge.java b/core/src/main/java/org/jruby/TruffleBridge.java
@@ -10,6 +10,7 @@
 package org.jruby;
 
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 
 public interface TruffleBridge {
 

diff --git a/core/src/main/java/org/jruby/util/Pack.java b/core/src/main/java/org/jruby/util/Pack.java
@@ -76,7 +76,6 @@ public class Pack {
     private static final String PACK_IGNORE_NULL_CODES = "cCiIlLnNqQsSvV";
     private static final String PACK_IGNORE_NULL_CODES_WITH_MODIFIERS = "lLsS";
     private static final String sTooFew = "too few arguments";
-    private static final byte[] hex_table;
     private static final byte[] uu_table;
     private static final byte[] b64_table;
     private static final byte[] sHexDigits;
@@ -103,7 +102,6 @@ private static double obj2dbl(Ruby runtime, IRubyObject o) {
     }    
 
     static {
-        hex_table = ByteList.plain("0123456789ABCDEF");
         uu_table =
             ByteList.plain("`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_");
         b64_table =
@@ -474,6 +472,25 @@ public static ByteList packInt_i(ByteList result, int s) {
         return result;
     }
 
+    public static void encodeUM(Ruby runtime, ByteList lCurElemString, int occurrences, boolean ignoreStar, char type, ByteList result) {
+        if (occurrences == 0 && type == 'm' && !ignoreStar) {
+            encodes(runtime, result, lCurElemString.getUnsafeBytes(),
+                    lCurElemString.getBegin(), lCurElemString.length(),
+                    lCurElemString.length(), (byte) type, false);
+            return;
+        }
+
+        occurrences = occurrences <= 2 ? 45 : occurrences / 3 * 3;
+        if (lCurElemString.length() == 0) return;
+
+        byte[] charsToEncode = lCurElemString.getUnsafeBytes();
+        for (int i = 0; i < lCurElemString.length(); i += occurrences) {
+            encodes(runtime, result, charsToEncode,
+                    i + lCurElemString.getBegin(), lCurElemString.length() - i,
+                    occurrences, (byte)type, true);
+        }
+    }
+
     /**
      * encodes a String in base64 or its uuencode variant.
      * appends the result of the encoding in a StringBuffer
@@ -534,61 +551,6 @@ private static ByteList encodes(Ruby runtime, ByteList io2Append,byte[]charsToEn
         return io2Append;
     }
 
-    /**
-     * encodes a String with the Quoted printable, MIME encoding (see RFC2045).
-     * appends the result of the encoding in a StringBuffer
-     * @param io2Append The StringBuffer which should receive the result
-     * @param i2Encode The String to encode
-     * @param iLength The max number of characters to encode
-     * @return the io2Append buffer
-     **/
-    private static ByteList qpencode(ByteList io2Append, ByteList i2Encode, int iLength) {
-        io2Append.ensure(1024);
-        int lCurLineLength = 0;
-        int lPrevChar = -1;
-        byte[] l2Encode = i2Encode.getUnsafeBytes();
-        try {
-            int end = i2Encode.getBegin() + i2Encode.getRealSize();
-            for (int i = i2Encode.getBegin(); i < end; i++) {
-                int lCurChar = l2Encode[i] & 0xff;
-                if (lCurChar > 126 || (lCurChar < 32 && lCurChar != '\n' && lCurChar != '\t') || lCurChar == '=') {
-                    io2Append.append('=');
-                    io2Append.append(hex_table[lCurChar >>> 4]);
-                    io2Append.append(hex_table[lCurChar & 0x0f]);
-                    lCurLineLength += 3;
-                    lPrevChar = -1;
-                } else if (lCurChar == '\n') {
-                    if (lPrevChar == ' ' || lPrevChar == '\t') {
-                        io2Append.append('=');
-                        io2Append.append(lCurChar);
-                    }
-                    io2Append.append(lCurChar);
-                    lCurLineLength = 0;
-                    lPrevChar = lCurChar;
-                } else {
-                    io2Append.append(lCurChar);
-                    lCurLineLength++;
-                    lPrevChar = lCurChar;
-                }
-                if (lCurLineLength > iLength) {
-                    io2Append.append('=');
-                    io2Append.append('\n');
-                    lCurLineLength = 0;
-                    lPrevChar = '\n';
-                }
-            }
-        } catch (ArrayIndexOutOfBoundsException e) {
-            //normal exit, this should be faster than a test at each iterations for string with more than
-            //about 40 char
-        }
-
-        if (lCurLineLength > 0) {
-            io2Append.append('=');
-            io2Append.append('\n');
-        }
-        return io2Append;
-    }
-
     /**
      *    Decodes <i>str</i> (which may contain binary data) according to the format
      *       string, returning an array of each value extracted.
@@ -1995,22 +1957,7 @@ private static RubyString packCommon(Ruby runtime, RubyArray list, ByteList form
                         IRubyObject from = list.eltInternal(idx++);
                         if (from == runtime.getNil()) throw runtime.newTypeError(from, "Integer");
                         lCurElemString = from.convertToString().getByteList();
-                        if (occurrences == 0 && type == 'm' && !ignoreStar) {
-                            encodes(runtime, result, lCurElemString.getUnsafeBytes(),
-                                    lCurElemString.getBegin(), lCurElemString.length(),
-                                    lCurElemString.length(), (byte)type, false);
-                            break;
-                        }
-
-                        occurrences = occurrences <= 2 ? 45 : occurrences / 3 * 3;
-                        if (lCurElemString.length() == 0) break;
-
-                        byte[] charsToEncode = lCurElemString.getUnsafeBytes();
-                        for (int i = 0; i < lCurElemString.length(); i += occurrences) {
-                            encodes(runtime, result, charsToEncode,
-                                    i + lCurElemString.getBegin(), lCurElemString.length() - i,
-                                    occurrences, (byte)type, true);
-                        }
+                        encodeUM(runtime, lCurElemString, occurrences, ignoreStar, (char) type, result);
                     }
                     break;
                 case 'M' : {
@@ -2023,7 +1970,7 @@ private static RubyString packCommon(Ruby runtime, RubyArray list, ByteList form
                            occurrences = 72;
                        }
 
-                       qpencode(result, lCurElemString, occurrences);
+                       PackUtils.qpencode(result, lCurElemString, occurrences);
                     }
                     break;
                 case 'U' :
@@ -2174,7 +2121,7 @@ private static long decodeIntUnsignedLittleEndian(ByteBuffer encode) {
      */
     private static void encodeIntLittleEndian(ByteList result, int s) {
         result.append((byte) (s & 0xff)).append((byte) ((s >> 8) & 0xff));
-        result.append((byte) ((s>>16) & 0xff)).append((byte) ((s>>24) &0xff));
+        result.append((byte) ((s>>16) & 0xff)).append((byte) ((s >> 24) & 0xff));
     }
 
     /**
@@ -2380,4 +2327,5 @@ private static void encodeShortLittleEndian(ByteList result, int s) {
     private static void encodeShortBigEndian(ByteList result, int s) {
         result.append((byte) ((s & 0xff00) >> 8)).append((byte) (s & 0xff));
     }
+
 }
diff --git a/core/src/main/java/org/jruby/util/PackUtils.java b/core/src/main/java/org/jruby/util/PackUtils.java
@@ -0,0 +1,100 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse 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/epl-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) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
+ * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
+ * Copyright (C) 2003-2004 Thomas E Enebo <enebo@acm.org>
+ * Copyright (C) 2004 Charles O Nutter <headius@headius.com>
+ * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
+ * Copyright (C) 2005 Derek Berner <derek.berner@state.nm.us>
+ * Copyright (C) 2006 Evan Buswell <ebuswell@gmail.com>
+ * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com>
+ * Copyright (C) 2009 Joseph LaFata <joe@quibb.org>
+ *
+ * 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 EPL, 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 EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package org.jruby.util;
+
+public class PackUtils {
+
+    private static final byte[] hex_table;
+
+    static {
+        hex_table = ByteList.plain("0123456789ABCDEF");
+    }
+
+    /**
+     * encodes a String with the Quoted printable, MIME encoding (see RFC2045).
+     * appends the result of the encoding in a StringBuffer
+     * @param io2Append The StringBuffer which should receive the result
+     * @param i2Encode The String to encode
+     * @param iLength The max number of characters to encode
+     * @return the io2Append buffer
+     **/
+    public static ByteList qpencode(ByteList io2Append, ByteList i2Encode, int iLength) {
+        io2Append.ensure(1024);
+        int lCurLineLength = 0;
+        int lPrevChar = -1;
+        byte[] l2Encode = i2Encode.getUnsafeBytes();
+        try {
+            int end = i2Encode.getBegin() + i2Encode.getRealSize();
+            for (int i = i2Encode.getBegin(); i < end; i++) {
+                int lCurChar = l2Encode[i] & 0xff;
+                if (lCurChar > 126 || (lCurChar < 32 && lCurChar != '\n' && lCurChar != '\t') || lCurChar == '=') {
+                    io2Append.append('=');
+                    io2Append.append(hex_table[lCurChar >>> 4]);
+                    io2Append.append(hex_table[lCurChar & 0x0f]);
+                    lCurLineLength += 3;
+                    lPrevChar = -1;
+                } else if (lCurChar == '\n') {
+                    if (lPrevChar == ' ' || lPrevChar == '\t') {
+                        io2Append.append('=');
+                        io2Append.append(lCurChar);
+                    }
+                    io2Append.append(lCurChar);
+                    lCurLineLength = 0;
+                    lPrevChar = lCurChar;
+                } else {
+                    io2Append.append(lCurChar);
+                    lCurLineLength++;
+                    lPrevChar = lCurChar;
+                }
+                if (lCurLineLength > iLength) {
+                    io2Append.append('=');
+                    io2Append.append('\n');
+                    lCurLineLength = 0;
+                    lPrevChar = '\n';
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            //normal exit, this should be faster than a test at each iterations for string with more than
+            //about 40 char
+        }
+
+        if (lCurLineLength > 0) {
+            io2Append.append('=');
+            io2Append.append('\n');
+        }
+        return io2Append;
+    }
+}
diff --git a/spec/truffle/tags/core/array/pack/c_tags.txt b/spec/truffle/tags/core/array/pack/c_tags.txt
diff --git a/spec/truffle/tags/core/array/pack/i_tags.txt b/spec/truffle/tags/core/array/pack/i_tags.txt