jruby · Jan 1, 2016 · Jan 1, 2016 · Jan 1, 2016 · Jan 2, 2016 · Jan 2, 2016
diff --git a/core/src/main/java/org/jruby/util/Pack.java b/core/src/main/java/org/jruby/util/Pack.java
@@ -78,8 +78,8 @@ public class Pack {
     private static final String sTooFew = "too few arguments";
     private static final byte[] uu_table;
     private static final byte[] b64_table;
-    private static final byte[] sHexDigits;
-    private static final int[] b64_xtable = new int[256];
+    public static final byte[] sHexDigits;
+    public static final int[] b64_xtable = new int[256];
     private static final Converter[] converters = new Converter[256];
 
     private static long num2quad(IRubyObject arg) {
@@ -1451,7 +1451,7 @@ private static int utf8Decode(ByteBuffer buffer) {
         0x80000000,                 /* 7 */
     };
 
-    private static int safeGet(ByteBuffer encode) {
+    public static int safeGet(ByteBuffer encode) {
         while (encode.hasRemaining()) {
             int got = encode.get() & 0xff;
 

diff --git a/spec/truffle/tags/core/string/unpack/m_tags.txt b/spec/truffle/tags/core/string/unpack/m_tags.txt
@@ -1,2 +1,4 @@
 fails:String#unpack with format 'M' calls #to_str to coerce the directives string
 fails:String#unpack with format 'm' calls #to_str to coerce the directives string
+fails:String#unpack with format 'M' ignores the count or '*' modifier and decodes the entire string
+fails:String#unpack with format 'm' ignores the count or '*' modifier and decodes the entire string
diff --git a/truffle/src/main/antlr4/org/jruby/truffle/format/parser/Pack.g4 b/truffle/src/main/antlr4/org/jruby/truffle/format/parser/Pack.g4
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * Copyright (c) 2015, 2016 Oracle and/or its affiliates. All rights reserved. This
  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  * redistribute it and/or modify it under the terms of the:
  *
@@ -50,7 +50,7 @@ directive : 'c' count?                                          # int8
           | 'M' INT?                                            # mimeString
           | 'm' count?                                          # base64String
           | ('p' | 'P')                                         # pointer
-          | '@' INT?                                            # at
+          | '@' count?                                          # at
           | 'X' count?                                          # back
           | 'x' count?                                          # nullByte
           | subSequence                                         # subSequenceAlternate

diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/control/AtUnpackNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/control/AtUnpackNode.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.format.nodes.control;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.jruby.truffle.format.nodes.PackNode;
+import org.jruby.truffle.format.runtime.exceptions.OutsideOfStringException;
+import org.jruby.truffle.runtime.RubyContext;
+
+public class AtUnpackNode extends PackNode {
+
+    private final int position;
+
+    public AtUnpackNode(RubyContext context, int position) {
+        super(context);
+        this.position = position;
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        if (position > getSourceLength(frame)) {
+            throw new OutsideOfStringException();
+        }
+
+        setSourcePosition(frame, position);
+
+        return null;
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/control/BackUnpackNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/control/BackUnpackNode.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.format.nodes.control;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.jruby.truffle.format.nodes.PackNode;
+import org.jruby.truffle.format.runtime.exceptions.OutsideOfStringException;
+import org.jruby.truffle.runtime.RubyContext;
+
+public class BackUnpackNode extends PackNode {
+
+    private boolean star;
+
+    public BackUnpackNode(RubyContext context, boolean star) {
+        super(context);
+        this.star = star;
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        final int position = getSourcePosition(frame);
+
+        if (star) {
+            final int remaining = getSourceLength(frame) - position;
+
+            final int target = position - remaining;
+
+            if (target < 0) {
+                CompilerDirectives.transferToInterpreter();
+                throw new OutsideOfStringException();
+            }
+
+            setSourcePosition(frame, target);
+        } else {
+            if (position == 0) {
+                CompilerDirectives.transferToInterpreter();
+                throw new OutsideOfStringException();
+            }
+
+            setSourcePosition(frame, position - 1);
+        }
+
+
+        return null;
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/control/ForwardUnpackNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/control/ForwardUnpackNode.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.format.nodes.control;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.jruby.truffle.format.nodes.PackNode;
+import org.jruby.truffle.format.runtime.exceptions.OutsideOfStringException;
+import org.jruby.truffle.runtime.RubyContext;
+
+public class ForwardUnpackNode extends PackNode {
+
+    private boolean toEnd;
+
+    public ForwardUnpackNode(RubyContext context, boolean toEnd) {
+        super(context);
+        this.toEnd = toEnd;
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        if (toEnd) {
+            setSourcePosition(frame, getSourceLength(frame));
+        } else {
+            final int position = getSourcePosition(frame);
+
+            if (position + 1 > getSourceLength(frame)) {
+                throw new OutsideOfStringException();
+            }
+
+            setSourcePosition(frame, getSourcePosition(frame) + 1);
+        }
+
+        return null;
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadBase64StringNode.java b/truffle/src/main/java/org/jruby/truffle/format/nodes/read/ReadBase64StringNode.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.format.nodes.read;
+
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.NodeChildren;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.jcodings.Encoding;
+import org.jcodings.specific.ASCIIEncoding;
+import org.jruby.RubyString;
+import org.jruby.truffle.format.nodes.PackNode;
+import org.jruby.truffle.format.nodes.SourceNode;
+import org.jruby.truffle.format.runtime.exceptions.FormatException;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
+import org.jruby.util.ByteList;
+import org.jruby.util.Pack;
+import org.jruby.util.StringSupport;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@NodeChildren({
+        @NodeChild(value = "value", type = SourceNode.class),
+})
+public abstract class ReadBase64StringNode extends PackNode {
+
+    private final int requestedLength;
+
+    public ReadBase64StringNode(RubyContext context, int requestedLength) {
+        super(context);
+        this.requestedLength = requestedLength;
+    }
+
+    @Specialization
+    public Object read(VirtualFrame frame, byte[] source) {
+        // Bit string logic copied from jruby.util.Pack - see copyright and authorship there
+
+        final ByteBuffer encode = ByteBuffer.wrap(source, getSourcePosition(frame), getSourceLength(frame) - getSourcePosition(frame));
+
+        int occurrences = requestedLength;
+
+        int length = encode.remaining()*3/4;
+        byte[] lElem = new byte[length];
+        int a = -1, b = -1, c = 0, d;
+        int index = 0;
+        int s = -1;
+
+        if (occurrences == 0){
+            if (encode.remaining()%4 != 0) {
+                throw new FormatException("invalid base64");
+            }
+            while (encode.hasRemaining() && s != '=') {
+                a = b = c = -1;
+                d = -2;
+
+                // obtain a
+                s = Pack.safeGet(encode);
+                a = Pack.b64_xtable[s];
+                if (a == -1) throw new FormatException("invalid base64");
+
+                // obtain b
+                s = Pack.safeGet(encode);
+                b = Pack.b64_xtable[s];
+                if (b == -1) throw new FormatException("invalid base64");
+
+                // obtain c
+                s = Pack.safeGet(encode);
+                c = Pack.b64_xtable[s];
+                if (s == '=') {
+                    if (Pack.safeGet(encode) != '=') throw new FormatException("invalid base64");
+                    break;
+                }
+                if (c == -1) throw new FormatException("invalid base64");
+
+                // obtain d
+                s = Pack.safeGet(encode);
+                d = Pack.b64_xtable[s];
+                if (s == '=') break;
+                if (d == -1) throw new FormatException("invalid base64");
+
+                // calculate based on a, b, c and d
+                lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
+                lElem[index++] = (byte)((c << 6 | d) & 255);
+            }
+
+            if (encode.hasRemaining()) throw new FormatException("invalid base64");
+
+            if (a != -1 && b != -1) {
+                if (c == -1 && s == '=') {
+                    if ((b & 15) > 0) throw new FormatException("invalid base64");
+                    lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                } else if(c != -1 && s == '=') {
+                    if ((c & 3) > 0) throw new FormatException("invalid base64");
+                    lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                    lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
+                }
+            }
+        }
+        else {
+
+            while (encode.hasRemaining()) {
+                a = b = c = d = -1;
+
+                // obtain a
+                s = Pack.safeGet(encode);
+                while (((a = Pack.b64_xtable[s]) == -1) && encode.hasRemaining()) {
+                    s = Pack.safeGet(encode);
+                }
+                if (a == -1) break;
+
+                // obtain b
+                s = Pack.safeGet(encode);
+                while (((b = Pack.b64_xtable[s]) == -1) && encode.hasRemaining()) {
+                    s = Pack.safeGet(encode);
+                }
+                if (b == -1) break;
+
+                // obtain c
+                s = Pack.safeGet(encode);
+                while (((c = Pack.b64_xtable[s]) == -1) && encode.hasRemaining()) {
+                    if (s == '=') break;
+                    s = Pack.safeGet(encode);
+                }
+                if ((s == '=') || c == -1) {
+                    if (s == '=') {
+                        encode.position(encode.position() - 1);
+                    }
+                    break;
+                }
+
+                // obtain d
+                s = Pack.safeGet(encode);
+                while (((d = Pack.b64_xtable[s]) == -1) && encode.hasRemaining()) {
+                    if (s == '=') break;
+                    s = Pack.safeGet(encode);
+                }
+                if ((s == '=') || d == -1) {
+                    if (s == '=') {
+                        encode.position(encode.position() - 1);
+                    }
+                    break;
+                }
+
+                // calculate based on a, b, c and d
+                lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
+                lElem[index++] = (byte)((c << 6 | d) & 255);
+            }
+
+            if (a != -1 && b != -1) {
+                if (c == -1 && s == '=') {
+                    lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                } else if(c != -1 && s == '=') {
+                    lElem[index++] = (byte)((a << 2 | b >> 4) & 255);
+                    lElem[index++] = (byte)((b << 4 | c >> 2) & 255);
+                }
+            }
+        }
+
+        final Encoding encoding = Encoding.load("ASCII");
+        final ByteList result = new ByteList(lElem, 0, index, encoding, false);
+        setSourcePosition(frame, encode.position());
+
+        return Layouts.STRING.createString(getContext().getCoreLibrary().getStringFactory(), result, StringSupport.CR_UNKNOWN, null);
+    }
+
+}