Pack.java

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

  38. import java.math.BigInteger;
  39. import java.nio.ByteBuffer;
  40. import java.nio.ByteOrder;
  41. import org.jcodings.Encoding;

  43. import org.jcodings.specific.ASCIIEncoding;
  44. import org.jcodings.specific.USASCIIEncoding;
  45. import org.jcodings.specific.UTF8Encoding;
  46. import org.jruby.platform.Platform;
  47. import org.jruby.Ruby;
  48. import org.jruby.RubyArray;
  49. import org.jruby.RubyBignum;
  50. import org.jruby.RubyFixnum;
  51. import org.jruby.RubyFloat;
  52. import org.jruby.RubyNumeric;
  53. import org.jruby.RubyObject;
  54. import org.jruby.RubyString;
  55. import org.jruby.runtime.ThreadContext;
  56. import org.jruby.runtime.builtin.IRubyObject;

  58. public class Pack {
  59.     private static final byte[] sSp10 = "          ".getBytes();
  60.     private static final byte[] sNil10 = "\000\000\000\000\000\000\000\000\000\000".getBytes();
  61.     private static final int IS_STAR = -1;
  62.     private static final ASCIIEncoding ASCII = ASCIIEncoding.INSTANCE;
  63.     private static final USASCIIEncoding USASCII = USASCIIEncoding.INSTANCE;
  64.     private static final UTF8Encoding UTF8 = UTF8Encoding.INSTANCE;
  65.     /** Native pack type.
  66.      **/
  67.     private static final String NATIVE_CODES = "sSiIlL";
  68.     private static final String MAPPED_CODES = "sSiIqQ";
  69.     
  70.     private static final char BE = '>' - 1; // 61, only 1 char "free" b/w q and s
  71.     private static final char LE = '<'; // 60
  72.     private static final String ENDIANESS_CODES = new String(new char[] {
  73.             's' + BE, 'S' + BE/*n*/, 'i' + BE, 'I' + BE, 'l' + BE, 'L' + BE/*N*/, 'q' + BE, 'Q' + BE,
  74.             's' + LE, 'S' + LE/*v*/, 'i' + LE, 'I' + LE, 'l' + LE, 'L' + LE/*V*/, 'q' + LE, 'Q' + LE});
  75.     private static final String UNPACK_IGNORE_NULL_CODES = "cC";
  76.     private static final String PACK_IGNORE_NULL_CODES = "cCiIlLnNqQsSvV";
  77.     private static final String PACK_IGNORE_NULL_CODES_WITH_MODIFIERS = "lLsS";
  78.     private static final String sTooFew = "too few arguments";
  79.     private static final byte[] hex_table;
  80.     private static final byte[] uu_table;
  81.     private static final byte[] b64_table;
  82.     private static final byte[] sHexDigits;
  83.     private static final int[] b64_xtable = new int[256];
  84.     private static final Converter[] converters = new Converter[256];

  86.     private static long num2quad(IRubyObject arg) {
  87.         if (arg == arg.getRuntime().getNil()) {
  88.             return 0L;
  89.         }
  90.         else if (arg instanceof RubyBignum) {
  91.             BigInteger big = ((RubyBignum)arg).getValue();
  92.             return big.longValue();
  93.         }
  94.         return RubyNumeric.num2long(arg);
  95.     }

  97.     private static float obj2flt(Ruby runtime, IRubyObject o) {
  98.         return (float) TypeConverter.toFloat(runtime, o).getDoubleValue();        
  99.     }

  101.     private static double obj2dbl(Ruby runtime, IRubyObject o) {
  102.         return TypeConverter.toFloat(runtime, o).getDoubleValue();        
  103.     }    

  105.     static {
  106.         hex_table = ByteList.plain("0123456789ABCDEF");
  107.         uu_table =
  108.             ByteList.plain("`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_");
  109.         b64_table =
  110.             ByteList.plain("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
  111.         sHexDigits = ByteList.plain("0123456789abcdef0123456789ABCDEFx");

  113.         // b64_xtable for decoding Base 64
  114.         for (int i = 0; i < 256; i++) {
  115.             b64_xtable[i] = -1;
  116.         }
  117.         for (int i = 0; i < 64; i++) {
  118.             b64_xtable[(int)b64_table[i]] = i;
  119.         }

  121.         // single precision, little-endian
  122.         converters['e'] = new Converter(4) {
  123.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  124.                 return RubyFloat.newFloat(runtime, decodeFloatLittleEndian(enc));
  125.             }

  127.             @Override
  128.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  129.                 encodeFloatLittleEndian(result, obj2flt(runtime, o));
  130.             }
  131.         };
  132.         // single precision, big-endian
  133.         converters['g'] = new Converter(4) {
  134.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  135.                 return RubyFloat.newFloat(runtime, decodeFloatBigEndian(enc));
  136.             }

  138.             @Override
  139.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  140.                 encodeFloatBigEndian(result, obj2flt(runtime, o));
  141.             }
  142.         };
  143.         // single precision, native
  144.         Converter tmp = new Converter(4) {
  145.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  146.                 return RubyFloat.newFloat(runtime, 
  147.                         Platform.BYTE_ORDER == Platform.BIG_ENDIAN ? 
  148.                         decodeFloatBigEndian(enc) : decodeFloatLittleEndian(enc));
  149.             }

  151.             @Override
  152.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  153.                 if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {                
  154.                     encodeFloatBigEndian(result, obj2flt(runtime, o));
  155.                 } else {
  156.                     encodeFloatLittleEndian(result, obj2flt(runtime, o));
  157.                 }
  158.             }
  159.         };
  160.         converters['F'] = tmp; // single precision, native
  161.         converters['f'] = tmp; // single precision, native

  163.         // double precision, little-endian
  164.         converters['E'] = new Converter(8) {
  165.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  166.                 return RubyFloat.newFloat(runtime, decodeDoubleLittleEndian(enc));
  167.             }

  169.             @Override
  170.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  171.                 encodeDoubleLittleEndian(result, obj2dbl(runtime, o));
  172.             }               
  173.         };
  174.         // double precision, big-endian
  175.         converters['G'] = new Converter(8) {
  176.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  177.                 return RubyFloat.newFloat(runtime, decodeDoubleBigEndian(enc));
  178.             }

  180.             @Override
  181.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  182.                 encodeDoubleBigEndian(result, obj2dbl(runtime, o));
  183.             }
  184.         };
  185.         // double precision, native
  186.         tmp = new Converter(8) {
  187.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  188.                 if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  189.                     return RubyFloat.newFloat(runtime, decodeDoubleBigEndian(enc));
  190.                 } else {
  191.                     return RubyFloat.newFloat(runtime, decodeDoubleLittleEndian(enc));
  192.                 }
  193.             }

  195.             @Override
  196.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  197.                 encodeDoubleLittleEndian(result, obj2dbl(runtime, o));
  198.             }     
  199.         };
  200.         converters['D'] = tmp; // double precision, native
  201.         converters['d'] = tmp; // double precision, native

  203.         // signed short, little-endian
  204.         tmp = new QuadConverter(2, "Integer") {
  205.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  206.                 return runtime.newFixnum(decodeShortUnsignedLittleEndian(enc));
  207.             }

  209.             @Override
  210.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  211.                 encodeShortLittleEndian(result, overflowQuad(num2quad(o)));
  212.             }            
  213.         };
  214.         converters['v'] = tmp;
  215.         converters['S' + LE] = tmp;
  216.         // signed short, big-endian
  217.         tmp = new QuadConverter(2, "Integer") {
  218.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  219.                 return runtime.newFixnum(decodeShortUnsignedBigEndian(enc));
  220.             }

  222.             @Override
  223.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  224.                 encodeShortBigEndian(result, overflowQuad(num2quad(o)));
  225.             }
  226.         };
  227.         converters['n'] = tmp;
  228.         converters['S' + BE] = tmp;
  229.         // signed short, native
  230.         converters['s'] = new QuadConverter(2, "Integer") {
  231.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  232.                 return runtime.newFixnum(Platform.BYTE_ORDER == Platform.BIG_ENDIAN ? 
  233.                         decodeShortBigEndian(enc) : decodeShortLittleEndian(enc));
  234.             }

  236.             @Override
  237.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  238.                 encodeShortByByteOrder(result, overflowQuad(num2quad(o))); // XXX: 0xffff0000 on BE?
  239.             }
  240.         };
  241.         // unsigned short, native
  242.         converters['S'] = new QuadConverter(2, "Integer") {
  243.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  244.                 return runtime.newFixnum(Platform.BYTE_ORDER == Platform.BIG_ENDIAN ?
  245.                     decodeShortUnsignedBigEndian(enc) : decodeShortUnsignedLittleEndian(enc));
  246.             }

  248.             @Override
  249.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  250.                 encodeShortByByteOrder(result, overflowQuad(num2quad(o)));
  251.             }
  252.         };
  253.         // signed short, little endian
  254.         converters['s' + LE] = new QuadConverter(2, "Integer") {
  255.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  256.                 return runtime.newFixnum(decodeShortLittleEndian(enc));
  257.             }

  259.             @Override
  260.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  261.                 encodeShortLittleEndian(result, overflowQuad(num2quad(o))); // XXX: 0xffff0000 on BE?
  262.             }
  263.         };
  264.         // signed short, big endian
  265.         converters['s' + BE] = new QuadConverter(2, "Integer") {
  266.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  267.                 return runtime.newFixnum(decodeShortBigEndian(enc));
  268.             }

  270.             @Override
  271.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  272.                 encodeShortBigEndian(result, overflowQuad(num2quad(o))); // XXX: 0xffff0000 on BE?
  273.             }
  274.         };

  276.         // signed char
  277.         converters['c'] = new Converter(1, "Integer") {
  278.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  279.                 int c = enc.get();
  280.                 return runtime.newFixnum(c > (char) 127 ? c-256 : c);
  281.             }

  283.             public void encode(Ruby runtime, IRubyObject o, ByteList result) {
  284.                 byte c = (byte) (num2quad(o) & 0xff);
  285.                 result.append(c);
  286.             }
  287.         };
  288.         // unsigned char
  289.         converters['C'] = new Converter(1, "Integer") {
  290.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  291.                 return runtime.newFixnum(enc.get() & 0xFF);
  292.             }

  294.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  295.                 byte c = o == runtime.getNil() ? 0 : (byte) (num2quad(o) & 0xff);
  296.                 result.append(c);
  297.             }
  298.         };

  300.         // unsigned long, little-endian
  301.         tmp = new Converter(4, "Integer") {
  302.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  303.                 return runtime.newFixnum(decodeIntUnsignedLittleEndian(enc));
  304.             }
  305.             
  306.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  307.                 encodeIntLittleEndian(result, (int) RubyNumeric.num2long(o));
  308.             }
  309.         };
  310.         converters['V'] = tmp;
  311.         converters['L' + LE] = tmp;
  312.         converters['I' + LE] = tmp;
  313.         
  314.         // unsigned long, big-endian
  315.         tmp = new Converter(4, "Integer") {
  316.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  317.                 return runtime.newFixnum(decodeIntUnsignedBigEndian(enc));
  318.             }
  319.             
  320.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  321.                 encodeIntBigEndian(result, (int) RubyNumeric.num2long(o));
  322.             }
  323.         };
  324.         converters['N'] = tmp;
  325.         converters['L' + BE] = tmp;
  326.         converters['I' + BE] = tmp;

  328.         // unsigned int, native
  329.         tmp = new Converter(4, "Integer") {
  330.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  331.                 if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  332.                     return runtime.newFixnum(decodeIntUnsignedBigEndian(enc));
  333.                 } else {
  334.                     return runtime.newFixnum(decodeIntUnsignedLittleEndian(enc));
  335.                 }
  336.             }
  337.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  338.                 int s = o == runtime.getNil() ? 0 : (int) RubyNumeric.num2long(o);
  339.                 packInt_i(result, s);
  340.             }
  341.         };
  342.         converters['I'] = tmp; // unsigned int, native
  343.         converters['L'] = tmp; // unsigned long, native

  345.         // int, native
  346.         tmp = new Converter(4, "Integer") {
  347.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  348.                 int value = unpackInt_i(enc);
  349.                 return runtime.newFixnum(value);
  350.             }
  351.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  352.                 int s = o == runtime.getNil() ? 0 : (int)RubyNumeric.num2long(o);
  353.                 packInt_i(result, s);
  354.             }
  355.         };
  356.         converters['i'] = tmp; // int, native
  357.         converters['l'] = tmp; // long, native
  358.         
  359.         // int, little endian
  360.         tmp = new Converter(4, "Integer") {
  361.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  362.                 return runtime.newFixnum(decodeIntLittleEndian(enc));
  363.             }
  364.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  365.                 int s = o == runtime.getNil() ? 0 : (int)RubyNumeric.num2long(o);
  366.                 encodeIntLittleEndian(result, s);
  367.             }
  368.         };
  369.         converters['i' + LE] = tmp; // int, native
  370.         converters['l' + LE] = tmp; // long, native
  371.         
  372.         // int, big endian
  373.         tmp = new Converter(4, "Integer") {
  374.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  375.                 return runtime.newFixnum(decodeIntBigEndian(enc));
  376.             }
  377.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  378.                 int s = o == runtime.getNil() ? 0 : (int)RubyNumeric.num2long(o);
  379.                 encodeIntBigEndian(result, s);
  380.             }
  381.         };
  382.         converters['i' + BE] = tmp; // int, native
  383.         converters['l' + BE] = tmp; // long, native

  385.         // 64-bit number, native (as bignum)
  386.         converters['Q'] = new QuadConverter(8, "Integer") {
  387.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  388.                 long l = Platform.BYTE_ORDER == Platform.BIG_ENDIAN ? decodeLongBigEndian(enc) : decodeLongLittleEndian(enc);

  390.                 return RubyBignum.bignorm(runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));
  391.             }

  393.             @Override
  394.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  395.                 encodeLongByByteOrder(result, num2quad(o));
  396.             }
  397.         };
  398.         // 64-bit number, little endian (as bignum)
  399.         converters['Q' + LE] = new QuadConverter(8, "Integer") {
  400.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  401.                 long l = decodeLongLittleEndian(enc);
  402.                 return RubyBignum.bignorm(runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));
  403.             }

  405.             @Override
  406.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  407.                 encodeLongLittleEndian(result, num2quad(o));
  408.             }
  409.         };
  410.         // 64-bit number, big endian (as bignum)
  411.         converters['Q' + BE] = new QuadConverter(8, "Integer") {
  412.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  413.                 long l = decodeLongBigEndian(enc);
  414.                 return RubyBignum.bignorm(runtime,BigInteger.valueOf(l).and(new BigInteger("FFFFFFFFFFFFFFFF", 16)));
  415.             }

  417.             @Override
  418.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  419.                 encodeLongBigEndian(result, num2quad(o));
  420.             }
  421.         };
  422.         // 64-bit number, native (as fixnum)
  423.         converters['q'] = new QuadConverter(8, "Integer") {
  424.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  425.                 return runtime.newFixnum(Platform.BYTE_ORDER == Platform.BIG_ENDIAN ? 
  426.                         decodeLongBigEndian(enc) : decodeLongLittleEndian(enc));
  427.             }

  429.             @Override
  430.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  431.                 encodeLongByByteOrder(result, num2quad(o));
  432.             }
  433.         };
  434.         // 64-bit number, little-endian (as fixnum)
  435.         converters['q' + LE] = new QuadConverter(8, "Integer") {
  436.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  437.                 return runtime.newFixnum(decodeLongLittleEndian(enc));
  438.             }

  440.             @Override
  441.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  442.                 encodeLongLittleEndian(result, num2quad(o));
  443.             }
  444.         };
  445.         // 64-bit number, big-endian (as fixnum)
  446.         converters['q' + BE] = new QuadConverter(8, "Integer") {
  447.             public IRubyObject decode(Ruby runtime, ByteBuffer enc) {
  448.                 return runtime.newFixnum(decodeLongBigEndian(enc));
  449.             }

  451.             @Override
  452.             public void encode(Ruby runtime, IRubyObject o, ByteList result){
  453.                 encodeLongBigEndian(result, num2quad(o));
  454.             }
  455.         };
  456.     }

  458.     public static int unpackInt_i(ByteBuffer enc) {
  459.         int value;
  460.         if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  461.             value = decodeIntBigEndian(enc);
  462.         } else {
  463.             value = decodeIntLittleEndian(enc);
  464.         }
  465.         return value;
  466.     }

  468.     public static ByteList packInt_i(ByteList result, int s) {
  469.         if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  470.             encodeIntBigEndian(result, s);
  471.         } else {
  472.             encodeIntLittleEndian(result, s);
  473.         }
  474.         return result;
  475.     }

  477.     /**
  478.      * encodes a String in base64 or its uuencode variant.
  479.      * appends the result of the encoding in a StringBuffer
  480.      * @param io2Append The StringBuffer which should receive the result
  481.      * @param i2Encode The String to encode
  482.      * @param iLength The max number of characters to encode
  483.      * @param iType the type of encoding required (this is the same type as used by the pack method)
  484.      * @param tailLf true if the traililng "\n" is needed
  485.      * @return the io2Append buffer
  486.      **/
  487.     private static ByteList encodes(Ruby runtime, ByteList io2Append,byte[]charsToEncode, int startIndex, int length, int charCount, byte encodingType, boolean tailLf) {
  488.         charCount = charCount < length ? charCount : length;

  490.         io2Append.ensure(charCount * 4 / 3 + 6);
  491.         int i = startIndex;
  492.         byte[] lTranslationTable = encodingType == 'u' ? uu_table : b64_table;
  493.         byte lPadding;
  494.         if (encodingType == 'u') {
  495.             if (charCount >= lTranslationTable.length) {
  496.                 throw runtime.newArgumentError(
  497.                     ""
  498.                         + charCount
  499.                         + " is not a correct value for the number of bytes per line in a u directive.  Correct values range from 0 to "
  500.                         + lTranslationTable.length);
  501.             }
  502.             io2Append.append(lTranslationTable[charCount]);
  503.             lPadding = '`';
  504.         } else {
  505.             lPadding = '=';
  506.         }
  507.         while (charCount >= 3) {
  508.             byte lCurChar = charsToEncode[i++];
  509.             byte lNextChar = charsToEncode[i++];
  510.             byte lNextNextChar = charsToEncode[i++];
  511.             io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);
  512.             io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | ((lNextChar >>> 4) & 017))]);
  513.             io2Append.append(lTranslationTable[077 & (((lNextChar << 2) & 074) | ((lNextNextChar >>> 6) & 03))]);
  514.             io2Append.append(lTranslationTable[077 & lNextNextChar]);
  515.             charCount -= 3;
  516.         }
  517.         if (charCount == 2) {
  518.             byte lCurChar = charsToEncode[i++];
  519.             byte lNextChar = charsToEncode[i++];
  520.             io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);
  521.             io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | ((lNextChar >> 4) & 017))]);
  522.             io2Append.append(lTranslationTable[077 & (((lNextChar << 2) & 074) | (('\0' >> 6) & 03))]);
  523.             io2Append.append(lPadding);
  524.         } else if (charCount == 1) {
  525.             byte lCurChar = charsToEncode[i++];
  526.             io2Append.append(lTranslationTable[077 & (lCurChar >>> 2)]);
  527.             io2Append.append(lTranslationTable[077 & (((lCurChar << 4) & 060) | (('\0' >>> 4) & 017))]);
  528.             io2Append.append(lPadding);
  529.             io2Append.append(lPadding);
  530.         }
  531.         if (tailLf) {
  532.             io2Append.append('\n');
  533.         }
  534.         return io2Append;
  535.     }

  537.     /**
  538.      * encodes a String with the Quoted printable, MIME encoding (see RFC2045).
  539.      * appends the result of the encoding in a StringBuffer
  540.      * @param io2Append The StringBuffer which should receive the result
  541.      * @param i2Encode The String to encode
  542.      * @param iLength The max number of characters to encode
  543.      * @return the io2Append buffer
  544.      **/
  545.     private static ByteList qpencode(ByteList io2Append, ByteList i2Encode, int iLength) {
  546.         io2Append.ensure(1024);
  547.         int lCurLineLength = 0;
  548.         int lPrevChar = -1;
  549.         byte[] l2Encode = i2Encode.getUnsafeBytes();
  550.         try {
  551.             int end = i2Encode.getBegin() + i2Encode.getRealSize();
  552.             for (int i = i2Encode.getBegin(); i < end; i++) {
  553.                 int lCurChar = l2Encode[i] & 0xff;
  554.                 if (lCurChar > 126 || (lCurChar < 32 && lCurChar != '\n' && lCurChar != '\t') || lCurChar == '=') {
  555.                     io2Append.append('=');
  556.                     io2Append.append(hex_table[lCurChar >>> 4]);
  557.                     io2Append.append(hex_table[lCurChar & 0x0f]);
  558.                     lCurLineLength += 3;
  559.                     lPrevChar = -1;
  560.                 } else if (lCurChar == '\n') {
  561.                     if (lPrevChar == ' ' || lPrevChar == '\t') {
  562.                         io2Append.append('=');
  563.                         io2Append.append(lCurChar);
  564.                     }
  565.                     io2Append.append(lCurChar);
  566.                     lCurLineLength = 0;
  567.                     lPrevChar = lCurChar;
  568.                 } else {
  569.                     io2Append.append(lCurChar);
  570.                     lCurLineLength++;
  571.                     lPrevChar = lCurChar;
  572.                 }
  573.                 if (lCurLineLength > iLength) {
  574.                     io2Append.append('=');
  575.                     io2Append.append('\n');
  576.                     lCurLineLength = 0;
  577.                     lPrevChar = '\n';
  578.                 }
  579.             }
  580.         } catch (ArrayIndexOutOfBoundsException e) {
  581.             //normal exit, this should be faster than a test at each iterations for string with more than
  582.             //about 40 char
  583.         }

  585.         if (lCurLineLength > 0) {
  586.             io2Append.append('=');
  587.             io2Append.append('\n');
  588.         }
  589.         return io2Append;
  590.     }

  592.     /**
  593.      *    Decodes <i>str</i> (which may contain binary data) according to the format
  594.      *       string, returning an array of each value extracted.
  595.      *       The format string consists of a sequence of single-character directives.<br/>
  596.      *       Each directive may be followed by a number, indicating the number of times to repeat with this directive.  An asterisk (``<code>*</code>'') will use up all
  597.      *       remaining elements.  <br/>
  598.      *       The directives <code>sSiIlL</code> may each be followed by an underscore (``<code>_</code>'') to use the underlying platform's native size for the specified type; otherwise, it uses a platform-independent consistent size.  <br/>
  599.      *       Spaces are ignored in the format string.
  600.      * 
  601.      *       <table border="2" width="500" bgcolor="#ffe0e0">
  602.      *           <tr>
  603.      *             <td>
  604.      * <P></P>
  605.      *         <b>Directives for <a href="ref_c_string.html#String.unpack">
  606.      *                   <code>String#unpack</code>
  607.      *                 </a>
  608.      *               </b>        <table class="codebox" cellspacing="0" border="0" cellpadding="3">
  609.      * <tr bgcolor="#ff9999">
  610.      *   <td valign="top">
  611.      *                     <b>Format</b>
  612.      *                   </td>
  613.      *   <td valign="top">
  614.      *                     <b>Function</b>
  615.      *                   </td>
  616.      *   <td valign="top">
  617.      *                     <b>Returns</b>
  618.      *                   </td>
  619.      * </tr>
  620.      * <tr>
  621.      *   <td valign="top">A</td>
  622.      *   <td valign="top">String with trailing nulls and spaces removed.</td>
  623.      *   <td valign="top">String</td>
  624.      * </tr>
  625.      * <tr>
  626.      *   <td valign="top">a</td>
  627.      *   <td valign="top">String.</td>
  628.      *   <td valign="top">String</td>
  629.      * </tr>
  630.      * <tr>
  631.      *   <td valign="top">B</td>
  632.      *   <td valign="top">Extract bits from each character (msb first).</td>
  633.      *   <td valign="top">String</td>
  634.      * </tr>
  635.      * <tr>
  636.      *   <td valign="top">b</td>
  637.      *   <td valign="top">Extract bits from each character (lsb first).</td>
  638.      *   <td valign="top">String</td>
  639.      * </tr>
  640.      * <tr>
  641.      *   <td valign="top">C</td>
  642.      *   <td valign="top">Extract a character as an unsigned integer.</td>
  643.      *   <td valign="top">Fixnum</td>
  644.      * </tr>
  645.      * <tr>
  646.      *   <td valign="top">c</td>
  647.      *   <td valign="top">Extract a character as an integer.</td>
  648.      *   <td valign="top">Fixnum</td>
  649.      * </tr>
  650.      * <tr>
  651.      *   <td valign="top">d</td>
  652.      *   <td valign="top">Treat <em>sizeof(double)</em> characters as a native
  653.      *           double.</td>
  654.      *   <td valign="top">Float</td>
  655.      * </tr>
  656.      * <tr>
  657.      *   <td valign="top">E</td>
  658.      *   <td valign="top">Treat <em>sizeof(double)</em> characters as a double in
  659.      *           little-endian byte order.</td>
  660.      *   <td valign="top">Float</td>
  661.      * </tr>
  662.      * <tr>
  663.      *   <td valign="top">e</td>
  664.      *   <td valign="top">Treat <em>sizeof(float)</em> characters as a float in
  665.      *           little-endian byte order.</td>
  666.      *   <td valign="top">Float</td>
  667.      * </tr>
  668.      * <tr>
  669.      *   <td valign="top">f</td>
  670.      *   <td valign="top">Treat <em>sizeof(float)</em> characters as a native float.</td>
  671.      *   <td valign="top">Float</td>
  672.      * </tr>
  673.      * <tr>
  674.      *   <td valign="top">G</td>
  675.      *   <td valign="top">Treat <em>sizeof(double)</em> characters as a double in
  676.      *           network byte order.</td>
  677.      *   <td valign="top">Float</td>
  678.      * </tr>
  679.      * <tr>
  680.      *   <td valign="top">g</td>
  681.      *   <td valign="top">Treat <em>sizeof(float)</em> characters as a float in
  682.      *           network byte order.</td>
  683.      *   <td valign="top">Float</td>
  684.      * </tr>
  685.      * <tr>
  686.      *   <td valign="top">H</td>
  687.      *   <td valign="top">Extract hex nibbles from each character (most
  688.      *           significant first).</td>
  689.      *   <td valign="top">String</td>
  690.      * </tr>
  691.      * <tr>
  692.      *   <td valign="top">h</td>
  693.      *   <td valign="top">Extract hex nibbles from each character (least
  694.      *           significant first).</td>
  695.      *   <td valign="top">String</td>
  696.      * </tr>
  697.      * <tr>
  698.      *   <td valign="top">I</td>
  699.      *   <td valign="top">Treat <em>sizeof(int)</em>
  700.      *                     <sup>1</sup> successive
  701.      *           characters as an unsigned native integer.</td>
  702.      *   <td valign="top">Integer</td>
  703.      * </tr>
  704.      * <tr>
  705.      *   <td valign="top">i</td>
  706.      *   <td valign="top">Treat <em>sizeof(int)</em>
  707.      *                     <sup>1</sup> successive
  708.      *           characters as a signed native integer.</td>
  709.      *   <td valign="top">Integer</td>
  710.      * </tr>
  711.      * <tr>
  712.      *   <td valign="top">L</td>
  713.      *   <td valign="top">Treat four<sup>1</sup> successive
  714.      *           characters as an unsigned native
  715.      *           long integer.</td>
  716.      *   <td valign="top">Integer</td>
  717.      * </tr>
  718.      * <tr>
  719.      *   <td valign="top">l</td>
  720.      *   <td valign="top">Treat four<sup>1</sup> successive
  721.      *           characters as a signed native
  722.      *           long integer.</td>
  723.      *   <td valign="top">Integer</td>
  724.      * </tr>
  725.      * <tr>
  726.      *   <td valign="top">M</td>
  727.      *   <td valign="top">Extract a quoted-printable string.</td>
  728.      *   <td valign="top">String</td>
  729.      * </tr>
  730.      * <tr>
  731.      *   <td valign="top">m</td>
  732.      *   <td valign="top">Extract a base64 encoded string.</td>
  733.      *   <td valign="top">String</td>
  734.      * </tr>
  735.      * <tr>
  736.      *   <td valign="top">N</td>
  737.      *   <td valign="top">Treat four characters as an unsigned long in network
  738.      *           byte order.</td>
  739.      *   <td valign="top">Fixnum</td>
  740.      * </tr>
  741.      * <tr>
  742.      *   <td valign="top">n</td>
  743.      *   <td valign="top">Treat two characters as an unsigned short in network
  744.      *           byte order.</td>
  745.      *   <td valign="top">Fixnum</td>
  746.      * </tr>
  747.      * <tr>
  748.      *   <td valign="top">P</td>
  749.      *   <td valign="top">Treat <em>sizeof(char *)</em> characters as a pointer, and
  750.      *           return <em>len</em> characters from the referenced location.</td>
  751.      *   <td valign="top">String</td>
  752.      * </tr>
  753.      * <tr>
  754.      *   <td valign="top">p</td>
  755.      *   <td valign="top">Treat <em>sizeof(char *)</em> characters as a pointer to a
  756.      *           null-terminated string.</td>
  757.      *   <td valign="top">String</td>
  758.      * </tr>
  759.      * <tr>
  760.      *   <td valign="top">S</td>
  761.      *   <td valign="top">Treat two<sup>1</sup> successive characters as an unsigned
  762.      *           short in
  763.      *           native byte order.</td>
  764.      *   <td valign="top">Fixnum</td>
  765.      * </tr>
  766.      * <tr>
  767.      *   <td valign="top">s</td>
  768.      *   <td valign="top">Treat two<sup>1</sup> successive
  769.      *           characters as a signed short in
  770.      *           native byte order.</td>
  771.      *   <td valign="top">Fixnum</td>
  772.      * </tr>
  773.      * <tr>
  774.      *   <td valign="top">U</td>
  775.      *   <td valign="top">Extract UTF-8 characters as unsigned integers.</td>
  776.      *   <td valign="top">Integer</td>
  777.      * </tr>
  778.      * <tr>
  779.      *   <td valign="top">u</td>
  780.      *   <td valign="top">Extract a UU-encoded string.</td>
  781.      *   <td valign="top">String</td>
  782.      * </tr>
  783.      * <tr>
  784.      *   <td valign="top">V</td>
  785.      *   <td valign="top">Treat four characters as an unsigned long in little-endian
  786.      *           byte order.</td>
  787.      *   <td valign="top">Fixnum</td>
  788.      * </tr>
  789.      * <tr>
  790.      *   <td valign="top">v</td>
  791.      *   <td valign="top">Treat two characters as an unsigned short in little-endian
  792.      *           byte order.</td>
  793.      *   <td valign="top">Fixnum</td>
  794.      * </tr>
  795.      * <tr>
  796.      *   <td valign="top">X</td>
  797.      *   <td valign="top">Skip backward one character.</td>
  798.      *   <td valign="top">---</td>
  799.      * </tr>
  800.      * <tr>
  801.      *   <td valign="top">x</td>
  802.      *   <td valign="top">Skip forward one character.</td>
  803.      *   <td valign="top">---</td>
  804.      * </tr>
  805.      * <tr>
  806.      *   <td valign="top">Z</td>
  807.      *   <td valign="top">String with trailing nulls removed.</td>
  808.      *   <td valign="top">String</td>
  809.      * </tr>
  810.      * <tr>
  811.      *   <td valign="top">@</td>
  812.      *   <td valign="top">Skip to the offset given by the length argument.</td>
  813.      *   <td valign="top">---</td>
  814.      * </tr>
  815.      * <tr>
  816.      *                   <td colspan="9" bgcolor="#ff9999" height="2"><img src="dot.gif" width="1" height="1"></td>
  817.      *                 </tr>
  818.      *               </table>
  819.      * <P></P>
  820.      *         <sup>1</sup>&nbsp;May be modified by appending ``_'' to the directive.
  821.      * <P></P>
  822.      *       </td>
  823.      *           </tr>
  824.      *         </table>
  825.      *
  826.      * @see RubyArray#pack
  827.      **/
  828.     public static RubyArray unpack(Ruby runtime, ByteList encodedString, ByteList formatString) {
  829.         Encoding encoding = encodedString.getEncoding();
  830.         RubyArray result = runtime.newArray();
  831.         // FIXME: potentially could just use ByteList here?
  832.         ByteBuffer format = ByteBuffer.wrap(formatString.getUnsafeBytes(), formatString.begin(), formatString.length());
  833.         ByteBuffer encode = ByteBuffer.wrap(encodedString.getUnsafeBytes(), encodedString.begin(), encodedString.length());
  834.         int type = 0;
  835.         int next = safeGet(format);

  837.         mainLoop: while (next != 0) {
  838.             type = next;
  839.             next = safeGet(format);
  840.             if (UNPACK_IGNORE_NULL_CODES.indexOf(type) != -1 && next == 0) {
  841.                 next = safeGetIgnoreNull(format);
  842.             }
  843.             
  844.             if (type == '#') {
  845.                 while (type != '\n') {
  846.                     if (next == 0) break mainLoop;
  847.                     type = next;
  848.                     next = safeGet(format);
  849.                 }
  850.             }

  852.             // Next indicates to decode using native encoding format
  853.             if (next == '_' || next == '!') {
  854.                 int index = NATIVE_CODES.indexOf(type);
  855.                 if (index == -1) {
  856.                     throw runtime.newArgumentError("'" + next +
  857.                             "' allowed only after types " + NATIVE_CODES);
  858.                 }
  859.                 type = MAPPED_CODES.charAt(index);
  860.                 
  861.                 next = safeGet(format);
  862.             }
  863.             
  864.             if (next == '>' || next == '<') {
  865.                 next = next == '>' ? BE : LE;
  866.                 int index = ENDIANESS_CODES.indexOf(type + next);
  867.                 if (index == -1) {
  868.                     throw runtime.newArgumentError("'" + (char)next +
  869.                             "' allowed only after types sSiIlLqQ");
  870.                 }
  871.                 type = ENDIANESS_CODES.charAt(index);
  872.                 next = safeGet(format);
  873.                 
  874.                 if (next == '_' || next == '!') next = safeGet(format);
  875.             }

  877.             // How many occurrences of 'type' we want
  878.             int occurrences = 0;
  879.             if (next == 0) {
  880.                 occurrences = 1;
  881.             } else {
  882.                 if (next == '*') {
  883.                     occurrences = IS_STAR;
  884.                     next = safeGet(format);
  885.                 } else if (ASCII.isDigit(next)) {
  886.                     occurrences = 0;
  887.                     do {
  888.                         occurrences = occurrences * 10 + Character.digit((char)(next & 0xFF), 10);
  889.                         next = safeGet(format);
  890.                     } while (next != 0 && ASCII.isDigit(next));
  891.                 } else {
  892.                     occurrences = type == '@' ? 0 : 1;
  893.                 }
  894.             }

  896.             // See if we have a converter for the job...
  897.             Converter converter = converters[type];
  898.             if (converter != null) {
  899.                 decode(runtime, encode, occurrences, result, converter);
  900.                 type = next;
  901.                 continue;
  902.             }

  904.             // Otherwise the unpack should be here...
  905.             switch (type) {
  906.                 case '@' :
  907.                     try {
  908.                         if (occurrences == IS_STAR) {
  909.                             encode.position(encodedString.begin() + encode.remaining());
  910.                         } else {
  911.                             encode.position(encodedString.begin() + occurrences);
  912.                         }
  913.                     } catch (IllegalArgumentException iae) {
  914.                         throw runtime.newArgumentError("@ outside of string");
  915.                     }
  916.                     break;
  917.                 case '%' :
  918.                     throw runtime.newArgumentError("% is not supported");
  919.                 case 'A' :
  920.                     {
  921.                     if (occurrences == IS_STAR || occurrences > encode.remaining()) {
  922.                         occurrences = encode.remaining();
  923.                     }

  925.                     byte[] potential = new byte[occurrences];
  926.                     encode.get(potential);

  928.                     for (int t = occurrences - 1; occurrences > 0; occurrences--, t--) {
  929.                         byte c = potential[t];

  931.                            if (c != '\0' && c != ' ') {
  932.                                break;
  933.                            }
  934.                     }

  936.                     result.append(RubyString.newString(runtime, new ByteList(potential, 0, occurrences, encoding, false)));
  937.                     }
  938.                     break;
  939.                 case 'Z' :
  940.                     {
  941.                         boolean isStar = (occurrences == IS_STAR);

  943.                         if (occurrences == IS_STAR || occurrences > encode.remaining()) {
  944.                             occurrences = encode.remaining();
  945.                         }

  947.                         byte[] potential = new byte[occurrences];
  948.                         int t = 0;

  950.                         while (t < occurrences) {
  951.                             byte b = encode.get();
  952.                             if (b == 0) {
  953.                                 break;
  954.                             }
  955.                             potential[t] = b; 
  956.                             t++;
  957.                         }

  959.                         result.append(RubyString.newString(runtime, new ByteList(potential, 0, t, encoding, false)));

  961.                         // In case when the number of occurences is
  962.                         // explicitly specified, we have to read up
  963.                         // the remaining garbage after the '\0' to
  964.                         // satisfy the requested pattern.
  965.                         if (!isStar) {
  966.                             if (t < occurrences) {
  967.                                 // We encountered '\0' when
  968.                                 // were reading the buffer above,
  969.                                 // increment the number of read bytes.
  970.                                 t++;
  971.                             }

  973.                             while (t < occurrences) {
  974.                                 encode.get();
  975.                                 t++;
  976.                             }
  977.                         }
  978.                     }
  979.                     break;
  980.                 case 'a' :
  981.                     if (occurrences == IS_STAR || occurrences > encode.remaining()) {
  982.                         occurrences = encode.remaining();
  983.                     }
  984.                     byte[] potential = new byte[occurrences];
  985.                     encode.get(potential);
  986.                     result.append(RubyString.newString(runtime, new ByteList(potential, encoding, false)));
  987.                     break;
  988.                 case 'b' :
  989.                     {
  990.                         if (occurrences == IS_STAR || occurrences > encode.remaining() * 8) {
  991.                             occurrences = encode.remaining() * 8;
  992.                         }
  993.                         int bits = 0;
  994.                         byte[] lElem = new byte[occurrences];
  995.                         for (int lCurByte = 0; lCurByte < occurrences; lCurByte++) {
  996.                             if ((lCurByte & 7) != 0) {
  997.                                 bits >>>= 1;
  998.                             } else {
  999.                                 bits = encode.get();
  1000.                             }
  1001.                             lElem[lCurByte] = (bits & 1) != 0 ? (byte)'1' : (byte)'0';
  1002.                         }
  1003.                         result.append(RubyString.newString(runtime, new ByteList(lElem, encoding, false)));
  1004.                     }
  1005.                     break;
  1006.                 case 'B' :
  1007.                     {
  1008.                         if (occurrences == IS_STAR || occurrences > encode.remaining() * 8) {
  1009.                             occurrences = encode.remaining() * 8;
  1010.                         }
  1011.                         int bits = 0;
  1012.                         byte[] lElem = new byte[occurrences];
  1013.                         for (int lCurByte = 0; lCurByte < occurrences; lCurByte++) {
  1014.                             if ((lCurByte & 7) != 0) {
  1015.                                 bits <<= 1;
  1016.                             } else {
  1017.                                 bits = encode.get();
  1018.                             }
  1019.                             lElem[lCurByte] = (bits & 128) != 0 ? (byte)'1' : (byte)'0';
  1020.                         }

  1022.                         result.append(RubyString.newString(runtime, new ByteList(lElem, encoding, false)));
  1023.                     }
  1024.                     break;
  1025.                 case 'h' :
  1026.                     {
  1027.                         if (occurrences == IS_STAR || occurrences > encode.remaining() * 2) {
  1028.                             occurrences = encode.remaining() * 2;
  1029.                         }
  1030.                         int bits = 0;
  1031.                         byte[] lElem = new byte[occurrences];
  1032.                         for (int lCurByte = 0; lCurByte < occurrences; lCurByte++) {
  1033.                             if ((lCurByte & 1) != 0) {
  1034.                                 bits >>>= 4;
  1035.                             } else {
  1036.                                 bits = encode.get();
  1037.                             }
  1038.                             lElem[lCurByte] = sHexDigits[bits & 15];
  1039.                         }
  1040.                         result.append(RubyString.newString(runtime, new ByteList(lElem, encoding, false)));
  1041.                     }
  1042.                     break;
  1043.                 case 'H' :
  1044.                     {
  1045.                         if (occurrences == IS_STAR || occurrences > encode.remaining() * 2) {
  1046.                             occurrences = encode.remaining() * 2;
  1047.                         }
  1048.                         int bits = 0;
  1049.                         byte[] lElem = new byte[occurrences];
  1050.                         for (int lCurByte = 0; lCurByte < occurrences; lCurByte++) {
  1051.                             if ((lCurByte & 1) != 0) {
  1052.                                 bits <<= 4;
  1053.                             } else {
  1054.                                 bits = encode.get();
  1055.                             }
  1056.                             lElem[lCurByte] = sHexDigits[(bits >>> 4) & 15];
  1057.                         }
  1058.                         result.append(RubyString.newString(runtime, new ByteList(lElem, encoding, false)));
  1059.                     }
  1060.                     break;

  1062.                 case 'u':
  1063.                 {
  1064.                     int length = encode.remaining() * 3 / 4;
  1065.                     byte[] lElem = new byte[length];
  1066.                     int index = 0;
  1067.                     int s = 0;
  1068.                     int total = 0;
  1069.                     if (length > 0) s = encode.get();
  1070.                     while (encode.hasRemaining() && s > ' ' && s < 'a') {
  1071.                         int a, b, c, d;
  1072.                         byte[] hunk = new byte[3];

  1074.                         int len = (s - ' ') & 077;
  1075.                         s = safeGet(encode);
  1076.                         total += len;
  1077.                         if (total > length) {
  1078.                             len -= total - length;
  1079.                             total = length;
  1080.                         }

  1082.                         while (len > 0) {
  1083.                             int mlen = len > 3 ? 3 : len;

  1085.                             if (encode.hasRemaining() && s >= ' ') {
  1086.                                 a = (s - ' ') & 077;
  1087.                                 s = safeGet(encode);
  1088.                             } else
  1089.                                 a = 0;
  1090.                             if (encode.hasRemaining() && s >= ' ') {
  1091.                                 b = (s - ' ') & 077;
  1092.                                 s = safeGet(encode);
  1093.                             } else
  1094.                                 b = 0;
  1095.                             if (encode.hasRemaining() && s >= ' ') {
  1096.                                 c = (s - ' ') & 077;
  1097.                                 s = safeGet(encode);
  1098.                             } else
  1099.                                 c = 0;
  1100.                             if (encode.hasRemaining() && s >= ' ') {
  1101.                                 d = (s - ' ') & 077;
  1102.                                 s = safeGet(encode);
  1103.                             } else
  1104.                                 d = 0;
  1105.                             hunk[0] = (byte)((a << 2 | b >> 4) & 255);
  1106.                             hunk[1] = (byte)((b << 4 | c >> 2) & 255);
  1107.                             hunk[2] = (byte)((c << 6 | d) & 255);

  1109.                             for (int i = 0; i < mlen; i++) lElem[index++] = hunk[i];
  1110.                             len -= mlen;
  1111.                         }
  1112.                         if (s == '\r') {
  1113.                             s = safeGet(encode);
  1114.                         }
  1115.                         if (s == '\n') {
  1116.                             s = safeGet(encode);
  1117.                         }
  1118.                         else if (encode.hasRemaining()) {
  1119.                             if (safeGet(encode) == '\n') {
  1120.                                 safeGet(encode); // Possible Checksum Byte
  1121.                             } else if (encode.hasRemaining()) {
  1122.                                 encode.position(encode.position() - 1);
  1123.                             }
  1124.                         }
  1125.                     }
  1126.                     result.append(RubyString.newString(runtime, new ByteList(lElem, 0, index, encoding, false)));
  1127.                 }
  1128.                 break;

  1130.                 case 'm':
  1131.                 {
  1132.                     int length = encode.remaining()*3/4;
  1133.                     byte[] lElem = new byte[length];
  1134.                     int a = -1, b = -1, c = 0, d;
  1135.                     int index = 0;
  1136.                     int s = -1;

  1138.                     while (encode.hasRemaining()) {
  1139.                         a = b = c = d = -1;
  1140.                         
  1141.                         // obtain a
  1142.                         s = safeGet(encode);
  1143.                         while (((a = b64_xtable[s]) == -1) && encode.hasRemaining()) {
  1144.                             s = safeGet(encode);
  1145.                         }
  1146.                         if (a == -1) break;
  1147.                         
  1148.                         // obtain b
  1149.                         s = safeGet(encode);
  1150.                         while (((b = b64_xtable[s]) == -1) && encode.hasRemaining()) {
  1151.                             s = safeGet(encode);
  1152.                         }
  1153.                         if (b == -1) break;
  1154.                         
  1155.                         // obtain c
  1156.                         s = safeGet(encode);
  1157.                         while (((c = b64_xtable[s]) == -1) && encode.hasRemaining()) {
  1158.                             if (s == '=') break;
  1159.                             s = safeGet(encode);
  1160.                         }
  1161.                         if ((s == '=') || c == -1) {
  1162.                             if (s == '=') {
  1163.                                 encode.position(encode.position() - 1);
  1164.                             }
  1165.                             break;
  1166.                         }
  1167.                         
  1168.                         // obtain d
  1169.                         s = safeGet(encode);
  1170.                         while (((d = b64_xtable[s]) == -1) && encode.hasRemaining()) {
  1171.                             if (s == '=') break;
  1172.                             s = safeGet(encode);
  1173.                         }
  1174.                         if ((s == '=') || d == -1) {
  1175.                             if (s == '=') {
  1176.                                 encode.position(encode.position() - 1);
  1177.                             }
  1178.                             break;
  1179.                         }

  1181.                         // calculate based on a, b, c and d
  1182.                         lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
  1183.                         lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
  1184.                         lElem[index++] = (byte)((c << 6 | d) & 255);
  1185.                     }

  1187.                     if (a != -1 && b != -1) {
  1188.                         if (c == -1 && s == '=') {
  1189.                             lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
  1190.                         } else if(c != -1 && s == '=') {
  1191.                             lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
  1192.                             lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
  1193.                         }
  1194.                     }
  1195.                     result.append(RubyString.newString(runtime, new ByteList(lElem, 0, index,
  1196.                             ASCIIEncoding.INSTANCE, false)));
  1197.                 }
  1198.                 break;

  1200.                 case 'M' :
  1201.                     {
  1202.                         byte[] lElem = new byte[Math.max(encode.remaining(),0)];
  1203.                         int index = 0;
  1204.                         for(;;) {
  1205.                             if (!encode.hasRemaining()) break;
  1206.                             int c = safeGet(encode);
  1207.                             if (c != '=') {
  1208.                                 lElem[index++] = (byte)c;
  1209.                             } else {
  1210.                                 if (!encode.hasRemaining()) break;
  1211.                                 encode.mark();
  1212.                                 int c1 = safeGet(encode);
  1213.                                 if (c1 == '\n' || (c1 == '\r' && (c1 = safeGet(encode)) == '\n')) continue;
  1214.                                 int d1 = Character.digit(c1, 16);
  1215.                                 if (d1 == -1) {
  1216.                                     encode.reset();
  1217.                                     break;
  1218.                                 }
  1219.                                 encode.mark();
  1220.                                 if (!encode.hasRemaining()) break;
  1221.                                 int c2 = safeGet(encode);
  1222.                                 int d2 = Character.digit(c2, 16);
  1223.                                 if (d2 == -1) {
  1224.                                     encode.reset();
  1225.                                     break;
  1226.                                 }
  1227.                                 byte value = (byte)(d1 << 4 | d2);
  1228.                                 lElem[index++] = value;
  1229.                             }
  1230.                         }
  1231.                         result.append(RubyString.newString(runtime, new ByteList(lElem, 0, index,
  1232.                                 ASCIIEncoding.INSTANCE, false)));
  1233.                     }
  1234.                     break;
  1235.                 case 'U' :
  1236.                     {
  1237.                         if (occurrences == IS_STAR || occurrences > encode.remaining()) {
  1238.                             occurrences = encode.remaining();
  1239.                         }

  1241.                         while (occurrences-- > 0 && encode.remaining() > 0) {
  1242.                             try {
  1243.                                 // TODO: for now, we use a faithful
  1244.                                 // reimplementation of MRI's algorithm,
  1245.                                 // but should use UTF8Encoding facilities
  1246.                                 // from Joni, once it starts prefroming
  1247.                                 // UTF-8 content validation. 
  1248.                                 result.append(
  1249.                                         runtime.newFixnum(utf8Decode(encode)));
  1250.                             } catch (IllegalArgumentException e) {
  1251.                                 throw runtime.newArgumentError(e.getMessage());
  1252.                             }
  1253.                         }
  1254.                     }
  1255.                     break;
  1256.                  case 'X':
  1257.                      if (occurrences == IS_STAR) {
  1258.                          // MRI behavior: Contrary to what seems to be logical,
  1259.                          // when '*' is given, MRI calculates the distance
  1260.                          // to the end, in order to go backwards.
  1261.                          occurrences = /*encode.limit() - */encode.remaining();
  1262.                      }

  1264.                      try {
  1265.                          encode.position(encode.position() - occurrences);
  1266.                      } catch (IllegalArgumentException e) {
  1267.                          throw runtime.newArgumentError("in `unpack': X outside of string");
  1268.                      }
  1269.                      break;
  1270.                  case 'x':
  1271.                       if (occurrences == IS_STAR) {
  1272.                            occurrences = encode.remaining();
  1273.                       }

  1275.                       try {
  1276.                           encode.position(encode.position() + occurrences);
  1277.                       } catch (IllegalArgumentException e) {
  1278.                           throw runtime.newArgumentError("in `unpack': x outside of string");
  1279.                       }

  1281.                      break;
  1282.                 case 'w':
  1283.                     if (occurrences == IS_STAR || occurrences > encode.remaining()) {
  1284.                         occurrences = encode.remaining();
  1285.                     }

  1287.                     long ul = 0;
  1288.                     long ulmask = (0xfe << 56) & 0xffffffff;
  1289.                     RubyBignum big128 = RubyBignum.newBignum(runtime, 128);
  1290.                     int pos = encode.position();

  1292.                     while (occurrences > 0 && pos < encode.limit()) {
  1293.                         ul <<= 7;
  1294.                         ul |= encode.get(pos) & 0x7f;
  1295.                         if((encode.get(pos++) & 0x80) == 0) {
  1296.                             result.append(RubyFixnum.newFixnum(runtime, ul));
  1297.                             occurrences--;
  1298.                             ul = 0;
  1299.                         } else if((ul & ulmask) == 0) {
  1300.                             RubyBignum big = RubyBignum.newBignum(runtime, ul);
  1301.                             while(occurrences > 0 && pos < encode.limit()) {
  1302.                                 IRubyObject mulResult = big.op_mul(runtime.getCurrentContext(), big128);
  1303.                                 IRubyObject v = mulResult.callMethod(runtime.getCurrentContext(), "+",
  1304.                                         RubyBignum.newBignum(runtime, encode.get(pos) & 0x7f));
  1305.                                 if(v instanceof RubyFixnum) {
  1306.                                     big = RubyBignum.newBignum(runtime, RubyNumeric.fix2long(v));
  1307.                                 } else if (v instanceof RubyBignum) {
  1308.                                     big = (RubyBignum)v;
  1309.                                 }
  1310.                                 if((encode.get(pos++) & 0x80) == 0) {
  1311.                                     result.add(RubyBignum.bignorm(runtime, big.getValue()));
  1312.                                     occurrences--;
  1313.                                     ul = 0;
  1314.                                     break;
  1315.                                 }
  1316.                             }
  1317.                         }
  1318.                     }
  1319.                     try {
  1320.                         encode.position(pos);
  1321.                     } catch (IllegalArgumentException e) {
  1322.                         throw runtime.newArgumentError("in `unpack': poorly encoded input");
  1323.                     }
  1324.                     break;
  1325.             }
  1326.         }
  1327.         return result;
  1328.     }

  1330.     /** rb_uv_to_utf8
  1331.      *
  1332.      */
  1333.     public static int utf8Decode(Ruby runtime, byte[]to, int p, int code) {
  1334.         if (code <= 0x7f) {
  1335.             to[p] = (byte)code;
  1336.             return 1;
  1337.         }
  1338.         if (code <= 0x7ff) {
  1339.             to[p + 0] = (byte)(((code >>> 6) & 0xff) | 0xc0);
  1340.             to[p + 1] = (byte)((code & 0x3f) | 0x80);
  1341.             return 2;
  1342.         }
  1343.         if (code <= 0xffff) {
  1344.             to[p + 0] = (byte)(((code >>> 12) & 0xff) | 0xe0);
  1345.             to[p + 1] = (byte)(((code >>> 6) & 0x3f) | 0x80);
  1346.             to[p + 2] = (byte)((code & 0x3f) | 0x80);
  1347.             return 3;
  1348.         }
  1349.         if (code <= 0x1fffff) {
  1350.             to[p + 0] = (byte)(((code >>> 18) & 0xff) | 0xf0);
  1351.             to[p + 1] = (byte)(((code >>> 12) & 0x3f) | 0x80);
  1352.             to[p + 2] = (byte)(((code >>> 6) & 0x3f) | 0x80);
  1353.             to[p + 3] = (byte)((code & 0x3f) | 0x80);
  1354.             return 4;
  1355.         }
  1356.         if (code <= 0x3ffffff) {
  1357.             to[p + 0] = (byte)(((code >>> 24) & 0xff) | 0xf8);
  1358.             to[p + 1] = (byte)(((code >>> 18) & 0x3f) | 0x80);
  1359.             to[p + 2] = (byte)(((code >>> 12) & 0x3f) | 0x80);
  1360.             to[p + 3] = (byte)(((code >>> 6) & 0x3f) | 0x80);
  1361.             to[p + 4] = (byte)((code & 0x3f) | 0x80);
  1362.             return 5;
  1363.         }
  1364.         if (code <= 0x7fffffff) {
  1365.             to[p + 0] = (byte)(((code >>> 30) & 0xff) | 0xfc);
  1366.             to[p + 1] = (byte)(((code >>> 24) & 0x3f) | 0x80);
  1367.             to[p + 2] = (byte)(((code >>> 18) & 0x3f) | 0x80);
  1368.             to[p + 3] = (byte)(((code >>> 12) & 0x3f) | 0x80);
  1369.             to[p + 4] = (byte)(((code >>> 6) & 0x3f) | 0x80);
  1370.             to[p + 5] = (byte)((code & 0x3f) | 0x80);
  1371.             return 6;
  1372.         }
  1373.         throw runtime.newRangeError("pack(U): value out of range");
  1374.     }

  1376.     /** utf8_to_uv
  1377.      */
  1378.     private static int utf8Decode(ByteBuffer buffer) {        
  1379.         int c = buffer.get() & 0xFF;
  1380.         int uv = c;
  1381.         int n;

  1383.         if ((c & 0x80) == 0) {
  1384.             return c;
  1385.         }

  1387.         if ((c & 0x40) == 0) {
  1388.             throw new IllegalArgumentException("malformed UTF-8 character");
  1389.         }
  1390.         
  1391.       if      ((uv & 0x20) == 0) { n = 2; uv &= 0x1f; }
  1392.       else if ((uv & 0x10) == 0) { n = 3; uv &= 0x0f; }
  1393.       else if ((uv & 0x08) == 0) { n = 4; uv &= 0x07; }
  1394.       else if ((uv & 0x04) == 0) { n = 5; uv &= 0x03; }
  1395.       else if ((uv & 0x02) == 0) { n = 6; uv &= 0x01; }
  1396.       else {
  1397.           throw new IllegalArgumentException("malformed UTF-8 character");
  1398.       }
  1399.       if (n > buffer.remaining() + 1) {
  1400.           throw new IllegalArgumentException(
  1401.                   "malformed UTF-8 character (expected " + n + " bytes, "
  1402.                   + "given " + (buffer.remaining() + 1)  + " bytes)");
  1403.       }

  1405.       int limit = n - 1;

  1407.       n--;

  1409.       if (n != 0) {
  1410.           while (n-- != 0) {
  1411.               c = buffer.get() & 0xff;
  1412.               if ((c & 0xc0) != 0x80) {
  1413.                   throw new IllegalArgumentException("malformed UTF-8 character");
  1414.               }
  1415.               else {
  1416.                   c &= 0x3f;
  1417.                   uv = uv << 6 | c;
  1418.               }
  1419.           }
  1420.       }

  1422.       if (uv < utf8_limits[limit]) {
  1423.           throw new IllegalArgumentException("redundant UTF-8 sequence");
  1424.       }

  1426.       return uv;
  1427.     }

  1429.     private static final long utf8_limits[] = {
  1430.         0x0,                        /* 1 */
  1431.         0x80,                       /* 2 */
  1432.         0x800,                      /* 3 */
  1433.         0x10000,                    /* 4 */
  1434.         0x200000,                   /* 5 */
  1435.         0x4000000,                  /* 6 */
  1436.         0x80000000,                 /* 7 */
  1437.     };

  1439.     private static int safeGet(ByteBuffer encode) {
  1440.         while (encode.hasRemaining()) {
  1441.             int got = encode.get() & 0xff;
  1442.             
  1443.             if (got != 0) return got;
  1444.         }
  1445.         
  1446.         return 0;
  1447.     }

  1449.     private static int safeGetIgnoreNull(ByteBuffer encode) {
  1450.         int next = 0;
  1451.         while (encode.hasRemaining() && next == 0) {
  1452.             next = safeGet(encode);
  1453.         }
  1454.         return next;
  1455.     }

  1457.     public static void decode(Ruby runtime, ByteBuffer encode, int occurrences,
  1458.             RubyArray result, Converter converter) {
  1459.         int lPadLength = 0;

  1461.         if (occurrences == IS_STAR) {
  1462.             occurrences = encode.remaining() / converter.size;
  1463.         } else if (occurrences > encode.remaining() / converter.size) {
  1464.             lPadLength = occurrences - encode.remaining() / converter.size;
  1465.             occurrences = encode.remaining() / converter.size;
  1466.         }
  1467.         for (; occurrences-- > 0;) {
  1468.             result.append(converter.decode(runtime, encode));
  1469.         }

  1471.         for (; lPadLength-- > 0;)
  1472.             result.append(runtime.getNil());
  1473.     }

  1475.     public static int encode(Ruby runtime, int occurrences, ByteList result,
  1476.             RubyArray list, int index, ConverterExecutor converter) {
  1477.         int listSize = list.size();

  1479.         while (occurrences-- > 0) {
  1480.             if (listSize-- <= 0 || index >= list.size()) {
  1481.                 throw runtime.newArgumentError(sTooFew);
  1482.             }

  1484.             IRubyObject from = list.eltInternal(index++);

  1486.             converter.encode(runtime, from, result);
  1487.         }

  1489.         return index;
  1490.     }

  1492.     private abstract static class ConverterExecutor {
  1493.         protected Converter converter;
  1494.         public void setConverter(Converter converter) {
  1495.             this.converter = converter;
  1496.         }

  1498.         public abstract IRubyObject decode(Ruby runtime, ByteBuffer format);
  1499.         public abstract void encode(Ruby runtime, IRubyObject from, ByteList result);
  1500.     }

  1502.     private static ConverterExecutor executor() {
  1503.         return new ConverterExecutor() {
  1504.             @Override
  1505.             public IRubyObject decode(Ruby runtime, ByteBuffer format) {
  1506.                 return converter.decode(runtime, format);
  1507.             }

  1509.             @Override
  1510.             public void encode(Ruby runtime, IRubyObject from, ByteList result) {
  1511.                 if (from == runtime.getNil() && converter.getType() != null) throw runtime.newTypeError(from, converter.getType());                
  1512.                 converter.encode(runtime, from, result);
  1513.             }
  1514.         };
  1515.     }

  1517.     public abstract static class Converter {
  1518.         public int size;
  1519.         public String type;

  1521.         public Converter(int size) {
  1522.             this(size, null);
  1523.         }
  1524.         
  1525.         public Converter(int size, String type) {
  1526.             this.size = size;
  1527.             this.type = type;
  1528.         }
  1529.         
  1530.         public String getType() {
  1531.             return type;
  1532.         }

  1534.         public abstract IRubyObject decode(Ruby runtime, ByteBuffer format);
  1535.         public abstract void encode(Ruby runtime, IRubyObject from, ByteList result);
  1536.     }

  1538.     private abstract static class QuadConverter extends Converter{
  1539.         public QuadConverter(int size, String type) {
  1540.             super(size, type);
  1541.         }
  1542.         
  1543.         public QuadConverter(int size) {
  1544.             super(size);
  1545.         }

  1547.         protected int overflowQuad(long quad) {
  1548.             return (int) (quad & 0xffff);
  1549.         }

  1551.         protected void encodeShortByByteOrder(ByteList result, int s) {
  1552.             if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  1553.                 encodeShortBigEndian(result, s);
  1554.             } else {
  1555.                 encodeShortLittleEndian(result, s);
  1556.             }
  1557.         }

  1559.         protected void encodeLongByByteOrder(ByteList result, long l) {
  1560.             if (Platform.BYTE_ORDER == Platform.BIG_ENDIAN) {
  1561.                 encodeLongBigEndian(result, l);
  1562.             } else {
  1563.                 encodeLongLittleEndian(result, l);
  1564.             }
  1565.         }
  1566.     }

  1568.     /**
  1569.      * shrinks a stringbuffer.
  1570.      * shrinks a stringbuffer by a number of characters.
  1571.      * @param i2Shrink the stringbuffer
  1572.      * @param iLength how much to shrink
  1573.      * @return the stringbuffer
  1574.      **/
  1575.     private static final ByteList shrink(ByteList i2Shrink, int iLength) {
  1576.         iLength = i2Shrink.length() - iLength;

  1578.         if (iLength < 0) {
  1579.             throw new IllegalArgumentException();
  1580.         }
  1581.         i2Shrink.length(iLength);
  1582.         return i2Shrink;
  1583.     }

  1585.     /**
  1586.      * grows a stringbuffer.
  1587.      * uses the Strings to pad the buffer for a certain length
  1588.      * @param i2Grow the buffer to grow
  1589.      * @param iPads the string used as padding
  1590.      * @param iLength how much padding is needed
  1591.      * @return the padded buffer
  1592.      **/
  1593.     private static final ByteList grow(ByteList i2Grow, byte[]iPads, int iLength) {
  1594.         int lPadLength = iPads.length;
  1595.         while (iLength >= lPadLength) {
  1596.             i2Grow.append(iPads);
  1597.             iLength -= lPadLength;
  1598.         }
  1599.         i2Grow.append(iPads, 0, iLength);
  1600.         return i2Grow;
  1601.     }

  1603.     /**
  1604.      * Same as pack but defaults tainting of output to false.
  1605.      */
  1606.     public static RubyString pack(Ruby runtime, RubyArray list, ByteList formatString) {
  1607.         return packCommon(runtime, list, formatString, false, executor());
  1608.     }

  1610.     public static RubyString pack(ThreadContext context, Ruby runtime, RubyArray list, RubyString formatString) {
  1611.         RubyString pack = packCommon(runtime, list, formatString.getByteList(), formatString.isTaint(), executor());
  1612.         return (RubyString) pack.infectBy(formatString);
  1613.     }

  1615.     private static RubyString packCommon(Ruby runtime, RubyArray list, ByteList formatString, boolean tainted, ConverterExecutor executor) {
  1616.         ByteBuffer format = ByteBuffer.wrap(formatString.getUnsafeBytes(), formatString.begin(), formatString.length());
  1617.         ByteList result = new ByteList();
  1618.         boolean taintOutput = tainted;
  1619.         int listSize = list.size();
  1620.         int type = 0;
  1621.         int next = safeGet(format);

  1623.         int idx = 0;
  1624.         ByteList lCurElemString;

  1626.         int enc_info = 1;

  1628.         mainLoop: while (next != 0) {
  1629.             type = next;
  1630.             next = safeGet(format);
  1631.             if (PACK_IGNORE_NULL_CODES.indexOf(type) != -1 && next == 0) {
  1632.                 next = safeGetIgnoreNull(format);
  1633.             }

  1635.             // Skip all whitespace in pack format string
  1636.             while (ASCII.isSpace(type)) {
  1637.                 if (next == 0) break mainLoop;
  1638.                 type = next;
  1639.                 next = safeGet(format);
  1640.             }

  1642.             // Skip embedded comments in pack format string
  1643.             if (type == '#') {
  1644.                 while (type != '\n') {
  1645.                     if (next == 0) break mainLoop;
  1646.                     type = next;
  1647.                     next = safeGet(format);
  1648.                 }
  1649.             }

  1651.             if (next == '!' || next == '_') {
  1652.                 int index = NATIVE_CODES.indexOf(type);
  1653.                 if (index == -1) {
  1654.                     throw runtime.newArgumentError("'" + next +
  1655.                             "' allowed only after types " + NATIVE_CODES);
  1656.                 }
  1657.                 int typeBeforeMap = type;
  1658.                 type = MAPPED_CODES.charAt(index);

  1660.                 next = safeGet(format);
  1661.                 if (PACK_IGNORE_NULL_CODES_WITH_MODIFIERS.indexOf(typeBeforeMap) != -1 && next == 0) {
  1662.                     next = safeGetIgnoreNull(format);
  1663.                 }
  1664.             }
  1665.             
  1666.             if (next == '>' || next == '<') {
  1667.                 next = next == '>' ? BE : LE;
  1668.                 int index = ENDIANESS_CODES.indexOf(type + next);
  1669.                 if (index == -1) {
  1670.                     throw runtime.newArgumentError("'" + (char)next +
  1671.                             "' allowed only after types sSiIlLqQ");
  1672.                 }
  1673.                 type = ENDIANESS_CODES.charAt(index);
  1674.                 next = safeGet(format);
  1675.             }

  1677.             // Determine how many of type are needed (default: 1)
  1678.             int occurrences = 1;
  1679.             boolean isStar = false;
  1680.             boolean ignoreStar = false;
  1681.             if (next != 0) {
  1682.                 if (next == '*') {
  1683.                     if ("@XxumM".indexOf(type) != -1) {
  1684.                         occurrences = 0;
  1685.                         ignoreStar = true;
  1686.                     } else {
  1687.                         occurrences = list.size() - idx;
  1688.                         isStar = true;
  1689.                     }
  1690.                     next = safeGet(format);
  1691.                 } else if (ASCII.isDigit(next)) {
  1692.                     occurrences = 0;
  1693.                     do {
  1694.                         occurrences = occurrences * 10 + Character.digit((char)(next & 0xFF), 10);
  1695.                         next = safeGet(format);
  1696.                     } while (next != 0 && ASCII.isDigit(next));
  1697.                 }
  1698.             }

  1700.             switch (type) {
  1701.                 case 'U':
  1702.                     if (enc_info == 1) enc_info = 2;
  1703.                     break;
  1704.                 case 'm':
  1705.                 case 'M':
  1706.                 case 'u':
  1707.                     break;
  1708.                 default:
  1709.                     enc_info = 0;
  1710.                     break;
  1711.             }

  1713.             Converter converter = converters[type];

  1715.             if (converter != null) {
  1716.                 executor.setConverter(converter);
  1717.                 idx = encode(runtime, occurrences, result, list, idx, executor);
  1718.                 continue;
  1719.             }

  1721.             switch (type) {
  1722.                 case '%' :
  1723.                     throw runtime.newArgumentError("% is not supported");
  1724.                 case 'A' :
  1725.                 case 'a' :
  1726.                 case 'Z' :
  1727.                 case 'B' :
  1728.                 case 'b' :
  1729.                 case 'H' :
  1730.                 case 'h' :
  1731.                     {
  1732.                         if (listSize-- <= 0) {
  1733.                             throw runtime.newArgumentError(sTooFew);
  1734.                         }

  1736.                         IRubyObject from = list.eltInternal(idx++);
  1737.                         if(from.isTaint()) taintOutput = true;

  1739.                         lCurElemString = from == runtime.getNil() ? ByteList.EMPTY_BYTELIST : from.convertToString().getByteList();

  1741.                         if (isStar) {
  1742.                             occurrences = lCurElemString.length();
  1743.                             // 'Z' adds extra null pad (versus 'a')
  1744.                             if (type == 'Z') occurrences++;
  1745.                         }

  1747.                         switch (type) {
  1748.                             case 'a' :
  1749.                             case 'A' :
  1750.                             case 'Z' :
  1751.                                 if (lCurElemString.length() >= occurrences) {
  1752.                                     result.append(lCurElemString.getUnsafeBytes(), lCurElemString.getBegin(), occurrences);
  1753.                                 } else {//need padding
  1754.                                     //I'm fairly sure there is a library call to create a
  1755.                                     //string filled with a given char with a given length but I couldn't find it
  1756.                                     result.append(lCurElemString);
  1757.                                     occurrences -= lCurElemString.length();

  1759.                                     switch (type) {
  1760.                                       case 'a':
  1761.                                       case 'Z':
  1762.                                           grow(result, sNil10, occurrences);
  1763.                                           break;
  1764.                                       default:
  1765.                                           grow(result, sSp10, occurrences);
  1766.                                           break;
  1767.                                     }
  1768.                                 }
  1769.                             break;
  1770.                             case 'b' :
  1771.                                 {
  1772.                                     int currentByte = 0;
  1773.                                     int padLength = 0;

  1775.                                     if (occurrences > lCurElemString.length()) {
  1776.                                         padLength = (occurrences - lCurElemString.length()) / 2 + (occurrences + lCurElemString.length()) % 2;
  1777.                                         occurrences = lCurElemString.length();
  1778.                                     }

  1780.                                     for (int i = 0; i < occurrences;) {
  1781.                                         if ((lCurElemString.charAt(i++) & 1) != 0) {//if the low bit is set
  1782.                                             currentByte |= 128; //set the high bit of the result
  1783.                                         }

  1785.                                         if ((i & 7) == 0) {
  1786.                                             result.append((byte) (currentByte & 0xff));
  1787.                                             currentByte = 0;
  1788.                                             continue;
  1789.                                         }

  1791.                                            //if the index is not a multiple of 8, we are not on a byte boundary
  1792.                                            currentByte >>= 1; //shift the byte
  1793.                                     }

  1795.                                     if ((occurrences & 7) != 0) { //if the length is not a multiple of 8
  1796.                                         currentByte >>= 7 - (occurrences & 7); //we need to pad the last byte
  1797.                                         result.append((byte) (currentByte & 0xff));
  1798.                                     }

  1800.                                     //do some padding, I don't understand the padding strategy
  1801.                                     result.length(result.length() + padLength);
  1802.                                 }
  1803.                             break;
  1804.                             case 'B' :
  1805.                                 {
  1806.                                     int currentByte = 0;
  1807.                                     int padLength = 0;

  1809.                                     if (occurrences > lCurElemString.length()) {
  1810.                                         padLength = (occurrences - lCurElemString.length()) / 2 + (occurrences + lCurElemString.length()) % 2;
  1811.                                         occurrences = lCurElemString.length();
  1812.                                     }

  1814.                                     for (int i = 0; i < occurrences;) {
  1815.                                         currentByte |= lCurElemString.charAt(i++) & 1;

  1817.                                         // we filled up current byte; append it and create next one
  1818.                                         if ((i & 7) == 0) {
  1819.                                             result.append((byte) (currentByte & 0xff));
  1820.                                             currentByte = 0;
  1821.                                             continue;
  1822.                                         }

  1824.                                         //if the index is not a multiple of 8, we are not on a byte boundary
  1825.                                         currentByte <<= 1;
  1826.                                     }

  1828.                                     if ((occurrences & 7) != 0) { //if the length is not a multiple of 8
  1829.                                         currentByte <<= 7 - (occurrences & 7); //we need to pad the last byte
  1830.                                         result.append((byte) (currentByte & 0xff));
  1831.                                     }

  1833.                                     result.length(result.length() + padLength);
  1834.                                 }
  1835.                             break;
  1836.                             case 'h' :
  1837.                                 {
  1838.                                     int currentByte = 0;
  1839.                                     int padLength = 0;

  1841.                                     if (occurrences > lCurElemString.length()) {
  1842.                                         padLength = occurrences - lCurElemString.length() + 1;
  1843.                                         occurrences = lCurElemString.length();
  1844.                                     }

  1846.                                     for (int i = 0; i < occurrences;) {
  1847.                                         byte currentChar = (byte)lCurElemString.charAt(i++);

  1849.                                         if (Character.isJavaIdentifierStart(currentChar)) {
  1850.                                             //this test may be too lax but it is the same as in MRI
  1851.                                             currentByte |= (((currentChar & 15) + 9) & 15) << 4;
  1852.                                         } else {
  1853.                                             currentByte |= (currentChar & 15) << 4;
  1854.                                         }

  1856.                                         if ((i & 1) != 0) {
  1857.                                             currentByte >>= 4;
  1858.                                         } else {
  1859.                                             result.append((byte) (currentByte & 0xff));
  1860.                                             currentByte = 0;
  1861.                                         }
  1862.                                     }

  1864.                                     if ((occurrences & 1) != 0) {
  1865.                                         result.append((byte) (currentByte & 0xff));
  1866.                                         if(padLength > 0) {
  1867.                                             padLength--;
  1868.                                         }
  1869.                                     }

  1871.                                     result.length(result.length() + padLength / 2);
  1872.                                 }
  1873.                             break;
  1874.                             case 'H' :
  1875.                                 {
  1876.                                     int currentByte = 0;
  1877.                                     int padLength = 0;

  1879.                                     if (occurrences > lCurElemString.length()) {
  1880.                                         padLength = occurrences - lCurElemString.length() + 1;
  1881.                                         occurrences = lCurElemString.length();
  1882.                                     }

  1884.                                     for (int i = 0; i < occurrences;) {
  1885.                                         byte currentChar = (byte)lCurElemString.charAt(i++);

  1887.                                         if (Character.isJavaIdentifierStart(currentChar)) {
  1888.                                             //this test may be too lax but it is the same as in MRI
  1889.                                             currentByte |= ((currentChar & 15) + 9) & 15;
  1890.                                         } else {
  1891.                                             currentByte |= currentChar & 15;
  1892.                                         }

  1894.                                         if ((i & 1) != 0) {
  1895.                                             currentByte <<= 4;
  1896.                                         } else {
  1897.                                             result.append((byte) (currentByte & 0xff));
  1898.                                             currentByte = 0;
  1899.                                         }
  1900.                                     }

  1902.                                     if ((occurrences & 1) != 0) {
  1903.                                         result.append((byte) (currentByte & 0xff));
  1904.                                         if(padLength > 0) {
  1905.                                             padLength--;
  1906.                                         }
  1907.                                     }

  1909.                                     result.length(result.length() + padLength / 2);
  1910.                                 }
  1911.                             break;
  1912.                         }
  1913.                         break;
  1914.                     }

  1916.                 case 'x' :
  1917.                     grow(result, sNil10, occurrences);
  1918.                     break;
  1919.                 case 'X' :
  1920.                     try {
  1921.                         shrink(result, occurrences);
  1922.                     } catch (IllegalArgumentException e) {
  1923.                         throw runtime.newArgumentError("in `pack': X outside of string");
  1924.                     }
  1925.                     break;
  1926.                 case '@' :
  1927.                     occurrences -= result.length();
  1928.                     if (occurrences > 0) {
  1929.                         grow(result, sNil10, occurrences);
  1930.                     }
  1931.                     occurrences = -occurrences;
  1932.                     if (occurrences > 0) {
  1933.                         shrink(result, occurrences);
  1934.                     }
  1935.                     break;
  1936.                 case 'u' :
  1937.                 case 'm' : {
  1938.                         if (listSize-- <= 0) throw runtime.newArgumentError(sTooFew);

  1940.                         IRubyObject from = list.eltInternal(idx++);
  1941.                         if (from == runtime.getNil()) throw runtime.newTypeError(from, "Integer");
  1942.                         lCurElemString = from.convertToString().getByteList();
  1943.                         if (occurrences == 0 && type == 'm' && !ignoreStar) {
  1944.                             encodes(runtime, result, lCurElemString.getUnsafeBytes(),
  1945.                                     lCurElemString.getBegin(), lCurElemString.length(),
  1946.                                     lCurElemString.length(), (byte)type, false);
  1947.                             break;
  1948.                         }

  1950.                         occurrences = occurrences <= 2 ? 45 : occurrences / 3 * 3;
  1951.                         if (lCurElemString.length() == 0) break;

  1953.                         byte[] charsToEncode = lCurElemString.getUnsafeBytes();
  1954.                         for (int i = 0; i < lCurElemString.length(); i += occurrences) {
  1955.                             encodes(runtime, result, charsToEncode,
  1956.                                     i + lCurElemString.getBegin(), lCurElemString.length() - i,
  1957.                                     occurrences, (byte)type, true);
  1958.                         }
  1959.                     }
  1960.                     break;
  1961.                 case 'M' : {
  1962.                        if (listSize-- <= 0) throw runtime.newArgumentError(sTooFew);

  1964.                        IRubyObject from = list.eltInternal(idx++);
  1965.                        lCurElemString = from == runtime.getNil() ? ByteList.EMPTY_BYTELIST : from.asString().getByteList();

  1967.                        if (occurrences <= 1) {
  1968.                            occurrences = 72;
  1969.                        }

  1971.                        qpencode(result, lCurElemString, occurrences);
  1972.                     }
  1973.                     break;
  1974.                 case 'U' :
  1975.                     while (occurrences-- > 0) {
  1976.                         if (listSize-- <= 0) throw runtime.newArgumentError(sTooFew);

  1978.                         IRubyObject from = list.eltInternal(idx++);
  1979.                         int code = from == runtime.getNil() ? 0 : RubyNumeric.num2int(from);

  1981.                         if (code < 0) throw runtime.newRangeError("pack(U): value out of range");

  1983.                         result.ensure(result.getRealSize() + 6);
  1984.                         result.setRealSize(result.getRealSize() + utf8Decode(runtime, result.getUnsafeBytes(), result.getBegin() + result.getRealSize(), code));
  1985.                     }
  1986.                     break;
  1987.                 case 'w' :
  1988.                     while (occurrences-- > 0) {
  1989.                         if (listSize-- <= 0) throw runtime.newArgumentError(sTooFew);

  1991.                         ByteList buf = new ByteList();
  1992.                         IRubyObject from = list.eltInternal(idx++);

  1994.                         if (from.isNil()) throw runtime.newTypeError("pack('w') does not take nil");


  1997.                         if (from instanceof RubyBignum) {
  1998.                             RubyBignum big128 = RubyBignum.newBignum(runtime, 128);
  1999.                             while (from instanceof RubyBignum) {
  2000.                                 RubyBignum bignum = (RubyBignum)from;
  2001.                                 RubyArray ary = (RubyArray)bignum.divmod(runtime.getCurrentContext(), big128);
  2002.                                 buf.append((byte)(RubyNumeric.fix2int(ary.at(RubyFixnum.one(runtime))) | 0x80) & 0xff);
  2003.                                 from = ary.at(RubyFixnum.zero(runtime));
  2004.                             }
  2005.                         }

  2007.                         long l = RubyNumeric.num2long(from);

  2009.                         // we don't deal with negatives.
  2010.                         if (l >= 0) {

  2012.                             while(l != 0) {
  2013.                                 buf.append((byte)(((l & 0x7f) | 0x80) & 0xff));
  2014.                                 l >>= 7;
  2015.                             }

  2017.                             int left = 0;
  2018.                             int right = buf.getRealSize() - 1;

  2020.                             if (right >= 0) {
  2021.                                 buf.getUnsafeBytes()[0] &= 0x7F;
  2022.                             } else {
  2023.                                 buf.append(0);
  2024.                             }

  2026.                             while (left < right) {
  2027.                                 byte tmp = buf.getUnsafeBytes()[left];
  2028.                                 buf.getUnsafeBytes()[left] = buf.getUnsafeBytes()[right];
  2029.                                 buf.getUnsafeBytes()[right] = tmp;

  2031.                                 left++;
  2032.                                 right--;
  2033.                             }

  2035.                             result.append(buf);
  2036.                         } else {
  2037.                             throw runtime.newArgumentError("can't compress negative numbers");
  2038.                         }
  2039.                     }

  2041.                     break;
  2042.             }
  2043.         }        

  2045.         RubyString output = runtime.newString(result);
  2046.         if (taintOutput) output.taint(runtime.getCurrentContext());

  2048.         switch (enc_info)
  2049.         {
  2050.             case 1:
  2051.                 output.setEncodingAndCodeRange(USASCII, RubyObject.USER8_F);
  2052.                 break;
  2053.             case 2:
  2054.                 output.force_encoding(runtime.getCurrentContext(),
  2055.                         runtime.getEncodingService().convertEncodingToRubyEncoding(UTF8));
  2056.                 break;
  2057.             default:
  2058.                 /* do nothing, keep ASCII-8BIT */
  2059.         }

  2061.         return output;
  2062.     }

  2064.     /**
  2065.      * Retrieve an encoded int in little endian starting at index in the
  2066.      * string value.
  2067.      *
  2068.      * @param encode string to get int from
  2069.      * @return the decoded integer
  2070.      */
  2071.     private static int decodeIntLittleEndian(ByteBuffer encode) {
  2072.         encode.order(ByteOrder.LITTLE_ENDIAN);
  2073.         int value = encode.getInt();
  2074.         encode.order(ByteOrder.BIG_ENDIAN);
  2075.         return value;
  2076.     }

  2078.     /**
  2079.      * Retrieve an encoded int in little endian starting at index in the
  2080.      * string value.
  2081.      *
  2082.      * @param encode string to get int from
  2083.      * @return the decoded integer
  2084.      */
  2085.     private static int decodeIntBigEndian(ByteBuffer encode) {
  2086.         return encode.getInt();
  2087.     }

  2089.     /**
  2090.      * Retrieve an encoded int in big endian starting at index in the string
  2091.      * value.
  2092.      *
  2093.      * @param encode string to get int from
  2094.      * @return the decoded integer
  2095.      */
  2096.     private static long decodeIntUnsignedBigEndian(ByteBuffer encode) {
  2097.         return (long)encode.getInt() & 0xFFFFFFFFL;
  2098.     }

  2100.     /**
  2101.      * Retrieve an encoded int in little endian starting at index in the
  2102.      * string value.
  2103.      *
  2104.      * @param encode the encoded string
  2105.      * @return the decoded integer
  2106.      */
  2107.     private static long decodeIntUnsignedLittleEndian(ByteBuffer encode) {
  2108.         encode.order(ByteOrder.LITTLE_ENDIAN);
  2109.         long value = encode.getInt() & 0xFFFFFFFFL;
  2110.         encode.order(ByteOrder.BIG_ENDIAN);
  2111.         return value;
  2112.     }

  2114.     /**
  2115.      * Encode an int in little endian format into a packed representation.
  2116.      *
  2117.      * @param result to be appended to
  2118.      * @param s the integer to encode
  2119.      */
  2120.     private static void encodeIntLittleEndian(ByteList result, int s) {
  2121.         result.append((byte) (s & 0xff)).append((byte) ((s >> 8) & 0xff));
  2122.         result.append((byte) ((s>>16) & 0xff)).append((byte) ((s>>24) &0xff));
  2123.     }

  2125.     /**
  2126.      * Encode an int in big-endian format into a packed representation.
  2127.      *
  2128.      * @param result to be appended to
  2129.      * @param s the integer to encode
  2130.      */
  2131.     private static void encodeIntBigEndian(ByteList result, int s) {
  2132.         result.append((byte) ((s>>24) &0xff)).append((byte) ((s>>16) &0xff));
  2133.         result.append((byte) ((s >> 8) & 0xff)).append((byte) (s & 0xff));
  2134.     }

  2136.     /**
  2137.      * Decode a long in big-endian format from a packed value
  2138.      *
  2139.      * @param encode string to get int from
  2140.      * @return the long value
  2141.      */
  2142.     private static long decodeLongBigEndian(ByteBuffer encode) {
  2143.         int c1 = decodeIntBigEndian(encode);
  2144.         int c2 = decodeIntBigEndian(encode);

  2146.         return ((long) c1 << 32) + (c2 & 0xffffffffL);
  2147.     }

  2149.     /**
  2150.      * Decode a long in little-endian format from a packed value
  2151.      *
  2152.      * @param encode string to get int from
  2153.      * @return the long value
  2154.      */
  2155.     private static long decodeLongLittleEndian(ByteBuffer encode) {
  2156.         int c1 = decodeIntLittleEndian(encode);
  2157.         int c2 = decodeIntLittleEndian(encode);

  2159.         return ((long) c2 << 32) + (c1 & 0xffffffffL);
  2160.     }

  2162.     /**
  2163.      * Encode a long in little-endian format into a packed value
  2164.      *
  2165.      * @param result to pack long into
  2166.      * @param l is the long to encode
  2167.      */
  2168.     private static void encodeLongLittleEndian(ByteList result, long l) {
  2169.         encodeIntLittleEndian(result, (int) (l & 0xffffffff));
  2170.         encodeIntLittleEndian(result, (int) (l >>> 32));
  2171.     }

  2173.     /**
  2174.      * Encode a long in big-endian format into a packed value
  2175.      *
  2176.      * @param result to pack long into
  2177.      * @param l is the long to encode
  2178.      */
  2179.     private static void encodeLongBigEndian(ByteList result, long l) {
  2180.         encodeIntBigEndian(result, (int) (l >>> 32));
  2181.         encodeIntBigEndian(result, (int) (l & 0xffffffff));
  2182.     }

  2184.     /**
  2185.      * Decode a double from a packed value
  2186.      *
  2187.      * @param encode string to get int from
  2188.      * @return the double value
  2189.      */
  2190.     private static double decodeDoubleLittleEndian(ByteBuffer encode) {
  2191.         return Double.longBitsToDouble(decodeLongLittleEndian(encode));
  2192.     }

  2194.     /**
  2195.      * Decode a double in big-endian from a packed value
  2196.      *
  2197.      * @param encode string to get int from
  2198.      * @return the double value
  2199.      */
  2200.     private static double decodeDoubleBigEndian(ByteBuffer encode) {
  2201.         return Double.longBitsToDouble(decodeLongBigEndian(encode));
  2202.     }

  2204.     /**
  2205.      * Encode a double in little endian format into a packed value
  2206.      *
  2207.      * @param result to pack double into
  2208.      * @param d is the double to encode
  2209.      */
  2210.     private static void encodeDoubleLittleEndian(ByteList result, double d) {
  2211.         encodeLongLittleEndian(result, Double.doubleToRawLongBits(d));
  2212.     }

  2214.     /**
  2215.      * Encode a double in big-endian format into a packed value
  2216.      *
  2217.      * @param result to pack double into
  2218.      * @param d is the double to encode
  2219.      */
  2220.     private static void encodeDoubleBigEndian(ByteList result, double d) {
  2221.         encodeLongBigEndian(result, Double.doubleToRawLongBits(d));
  2222.     }

  2224.     /**
  2225.      * Decode a float in big-endian from a packed value
  2226.      *
  2227.      * @param encode string to get int from
  2228.      * @return the double value
  2229.      */
  2230.     private static float decodeFloatBigEndian(ByteBuffer encode) {
  2231.         return Float.intBitsToFloat(decodeIntBigEndian(encode));
  2232.     }

  2234.     /**
  2235.      * Decode a float in little-endian from a packed value
  2236.      *
  2237.      * @param encode string to get int from
  2238.      * @return the double value
  2239.      */
  2240.     private static float decodeFloatLittleEndian(ByteBuffer encode) {
  2241.         return Float.intBitsToFloat(decodeIntLittleEndian(encode));
  2242.     }

  2244.     /**
  2245.      * Encode a float in little endian format into a packed value
  2246.      * @param result to pack float into
  2247.      * @param f is the float to encode
  2248.      */
  2249.     private static void encodeFloatLittleEndian(ByteList result, float f) {
  2250.         encodeIntLittleEndian(result, Float.floatToRawIntBits(f));
  2251.     }

  2253.     /**
  2254.      * Encode a float in big-endian format into a packed value
  2255.      * @param result to pack float into
  2256.      * @param f is the float to encode
  2257.      */
  2258.     private static void encodeFloatBigEndian(ByteList result, float f) {
  2259.         encodeIntBigEndian(result, Float.floatToRawIntBits(f));
  2260.     }

  2262.     /**
  2263.      * Decode a short in little-endian from a packed value
  2264.      *
  2265.      * @param encode string to get int from
  2266.      * @return the short value
  2267.      */
  2268.     private static int decodeShortUnsignedLittleEndian(ByteBuffer encode) {
  2269.         encode.order(ByteOrder.LITTLE_ENDIAN);
  2270.         int value = encode.getShort() & 0xFFFF;
  2271.         encode.order(ByteOrder.BIG_ENDIAN);
  2272.         return value;
  2273.     }

  2275.     /**
  2276.      * Decode a short in big-endian from a packed value
  2277.      *
  2278.      * @param encode string to get int from
  2279.      * @return the short value
  2280.      */
  2281.     private static int decodeShortUnsignedBigEndian(ByteBuffer encode) {
  2282.         int value = encode.getShort() & 0xFFFF;
  2283.         return value;
  2284.     }

  2286.     /**
  2287.      * Decode a short in little-endian from a packed value
  2288.      *
  2289.      * @param encode string to get int from
  2290.      * @return the short value
  2291.      */
  2292.     private static int decodeShortLittleEndian(ByteBuffer encode) {
  2293.         encode.order(ByteOrder.LITTLE_ENDIAN);
  2294.         int value = encode.getShort();
  2295.         encode.order(ByteOrder.BIG_ENDIAN);
  2296.         return value;
  2297.     }

  2299.     /**
  2300.      * Decode a short in big-endian from a packed value
  2301.      *
  2302.      * @param encode string to get int from
  2303.      * @return the short value
  2304.      */
  2305.     private static short decodeShortBigEndian(ByteBuffer encode) {
  2306.         return encode.getShort();
  2307.     }

  2309.     /**
  2310.      * Encode an short in little endian format into a packed representation.
  2311.      *
  2312.      * @param result to be appended to
  2313.      * @param s the short to encode
  2314.      */
  2315.     private static void encodeShortLittleEndian(ByteList result, int s) {
  2316.         result.append((byte) (s & 0xff)).append((byte) ((s & 0xff00) >> 8));
  2317.     }

  2319.     /**
  2320.      * Encode an shortin big-endian format into a packed representation.
  2321.      *
  2322.      * @param result to be appended to
  2323.      * @param s the short to encode
  2324.      */
  2325.     private static void encodeShortBigEndian(ByteList result, int s) {
  2326.         result.append((byte) ((s & 0xff00) >> 8)).append((byte) (s & 0xff));
  2327.     }
  2328. }
Created with JaCoCo 0.7.3.201501050207