fork(1) download 
  1. /* package whatever; // don't place package name! */
  2.  /**
  3. Copyright 2020 Tschallacka
  4. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  5. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  6. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  7. */
  8. import java.util.*;
  9. import java.lang.*;
  10. import java.io.*;
  11.  
  12. /* Name of the class has to be "Main" only if the class is public. */
  13. class Ideone
  14. {
  15. 	public static void main (String[] args) throws java.lang.Exception
  16. 	{
  17. 		java.lang.reflect.Field[] clFields = TreeMap.class.getDeclaredFields();
  18.         ArrayList<java.lang.reflect.Field> list = new ArrayList<>();
  19.         int mask = java.lang.reflect.Modifier.STATIC | java.lang.reflect.Modifier.TRANSIENT;
  20.  
  21.         for (int i = 0; i < clFields.length; i++) {
  22.         	// Check for non transient and non static fields.
  23.             if ((clFields[i].getModifiers() & mask) == 0) {
  24.                 list.add(clFields[i]);
  25.                 System.out.println("Found field " + clFields[i].getName());
  26.             }
  27.         }
  28.         int size = list.size();
  29.         System.out.println(size);
  30.  
  31.         BlockDataInputStream bin = new BlockDataInputStream(getTreeMapInputStream());
  32.         bin.setBlockDataMode(false);
  33.         short s0 = bin.readShort();
  34.         short s1 = bin.readShort();
  35.         if (s0 != java.io.ObjectStreamConstants.STREAM_MAGIC || s1 != java.io.ObjectStreamConstants.STREAM_VERSION) {
  36.             throw new StreamCorruptedException(
  37.                 String.format("invalid stream header: %04X%04X", s0, s1));
  38.         }
  39.         byte b = bin.readByte();
  40.         if(b == java.io.ObjectStreamConstants.TC_OBJECT) {
  41.         	bin.readByte();
  42. 	        String name = bin.readUTF();
  43. 	        System.out.println(name);
  44. 	        System.out.println("Is string ("+name+")it a java.util.TreeMap? "+(name.equals("java.util.TreeMap") ? "yes":"no"));
  45. 	        bin.readLong();
  46. 	        bin.readByte();
  47. 	        short fields = bin.readShort();
  48. 	        for(short i = 0; i < fields; i++) {
  49. 	        	bin.readByte();
  50. 	        	System.out.println("Read field name "+bin.readUTF());
  51. 	        }
  52.         }
  53.  
  54. 	}
  55.  
  56. 	public static ByteArrayInputStream getTreeMapInputStream() throws Exception {
  57. 		/* This is how to declare TreeMap */
  58.       TreeMap<Integer, String> tmap = 
  59.              new TreeMap<Integer, String>();
  60.  
  61.       /*Adding elements to TreeMap*/
  62.       tmap.put(1, "Data1");
  63.       tmap.put(23, "Data2");
  64.       tmap.put(70, "Data3");
  65.       tmap.put(4, "Data4");
  66.       tmap.put(2, "Data5");
  67.  
  68.       ByteArrayOutputStream baos = new ByteArrayOutputStream();
  69.       ObjectOutputStream oos = new ObjectOutputStream( baos );
  70.       oos.writeObject( tmap );
  71.       oos.close();
  72.       return  new ByteArrayInputStream(baos.toByteArray());
  73. 	}
  74. }
  75.  
  76. /* =========== END MIT - BELOW LICENSE APPLICABLE ON CODE BELOW ===================
  77.  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  78.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  79.  *
  80.  * This code is free software; you can redistribute it and/or modify it
  81.  * under the terms of the GNU General Public License version 2 only, as
  82.  * published by the Free Software Foundation.  Oracle designates this
  83.  * particular file as subject to the "Classpath" exception as provided
  84.  * by Oracle in the LICENSE file that accompanied this code.
  85.  *
  86.  * This code is distributed in the hope that it will be useful, but WITHOUT
  87.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  88.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  89.  * version 2 for more details (a copy is included in the LICENSE file that
  90.  * accompanied this code).
  91.  *
  92.  * You should have received a copy of the GNU General Public License version
  93.  * 2 along with this work; if not, write to the Free Software Foundation,
  94.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  95.  *
  96.  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  97.  * or visit www.oracle.com if you need additional information or have any
  98.  * questions.
  99.  */
  100.  class BlockDataInputStream
  101.         extends InputStream implements DataInput
  102.     {
  103.     	boolean defaultDataEnd = false;
  104.         /** maximum data block length */
  105.         private static final int MAX_BLOCK_SIZE = 1024;
  106.         /** maximum data block header length */
  107.         private static final int MAX_HEADER_SIZE = 5;
  108.         /** (tunable) length of char buffer (for reading strings) */
  109.         private static final int CHAR_BUF_SIZE = 256;
  110.         /** readBlockHeader() return value indicating header read may block */
  111.         private static final int HEADER_BLOCKED = -2;
  112.  
  113.         /** buffer for reading general/block data */
  114.         private final byte[] buf = new byte[MAX_BLOCK_SIZE];
  115.         /** buffer for reading block data headers */
  116.         private final byte[] hbuf = new byte[MAX_HEADER_SIZE];
  117.         /** char buffer for fast string reads */
  118.         private final char[] cbuf = new char[CHAR_BUF_SIZE];
  119.  
  120.         /** block data mode */
  121.         private boolean blkmode = false;
  122.  
  123.         // block data state fields; values meaningful only when blkmode true
  124.         /** current offset into buf */
  125.         private int pos = 0;
  126.         /** end offset of valid data in buf, or -1 if no more block data */
  127.         private int end = -1;
  128.         /** number of bytes in current block yet to be read from stream */
  129.         private int unread = 0;
  130.  
  131.         /** underlying stream (wrapped in peekable filter stream) */
  132.         private final PeekInputStream in;
  133.         /** loopback stream (for data reads that span data blocks) */
  134.         private final DataInputStream din;
  135.  
  136.         /**
  137.          * Creates new BlockDataInputStream on top of given underlying stream.
  138.          * Block data mode is turned off by default.
  139.          */
  140.         BlockDataInputStream(InputStream in) {
  141.             this.in = new PeekInputStream(in);
  142.             din = new DataInputStream(this);
  143.         }
  144.  
  145.         /**
  146.          * Sets block data mode to the given mode (true == on, false == off)
  147.          * and returns the previous mode value.  If the new mode is the same as
  148.          * the old mode, no action is taken.  Throws IllegalStateException if
  149.          * block data mode is being switched from on to off while unconsumed
  150.          * block data is still present in the stream.
  151.          */
  152.         boolean setBlockDataMode(boolean newmode) throws IOException {
  153.             if (blkmode == newmode) {
  154.                 return blkmode;
  155.             }
  156.             if (newmode) {
  157.                 pos = 0;
  158.                 end = 0;
  159.                 unread = 0;
  160.             } else if (pos < end) {
  161.                 throw new IllegalStateException("unread block data");
  162.             }
  163.             blkmode = newmode;
  164.             return !blkmode;
  165.         }
  166.  
  167.         /**
  168.          * Returns true if the stream is currently in block data mode, false
  169.          * otherwise.
  170.          */
  171.         boolean getBlockDataMode() {
  172.             return blkmode;
  173.         }
  174.  
  175.         /**
  176.          * If in block data mode, skips to the end of the current group of data
  177.          * blocks (but does not unset block data mode).  If not in block data
  178.          * mode, throws an IllegalStateException.
  179.          */
  180.         void skipBlockData() throws IOException {
  181.             if (!blkmode) {
  182.                 throw new IllegalStateException("not in block data mode");
  183.             }
  184.             while (end >= 0) {
  185.                 refill();
  186.             }
  187.         }
  188.  
  189.         /**
  190.          * Attempts to read in the next block data header (if any).  If
  191.          * canBlock is false and a full header cannot be read without possibly
  192.          * blocking, returns HEADER_BLOCKED, else if the next element in the
  193.          * stream is a block data header, returns the block data length
  194.          * specified by the header, else returns -1.
  195.          */
  196.         private int readBlockHeader(boolean canBlock) throws IOException {
  197.             if (defaultDataEnd) {
  198.                 /*
  199.                  * Fix for 4360508: stream is currently at the end of a field
  200.                  * value block written via default serialization; since there
  201.                  * is no terminating TC_ENDBLOCKDATA tag, simulate
  202.                  * end-of-custom-data behavior explicitly.
  203.                  */
  204.                 return -1;
  205.             }
  206.             try {
  207.                 for (;;) {
  208.                     int avail = canBlock ? Integer.MAX_VALUE : in.available();
  209.                     if (avail == 0) {
  210.                         return HEADER_BLOCKED;
  211.                     }
  212.  
  213.                     int tc = in.peek();
  214.                     switch (tc) {
  215.                         case java.io.ObjectStreamConstants.TC_BLOCKDATA:
  216.                             if (avail < 2) {
  217.                                 return HEADER_BLOCKED;
  218.                             }
  219.                             in.readFully(hbuf, 0, 2);
  220.                             return hbuf[1] & 0xFF;
  221.  
  222.                         case java.io.ObjectStreamConstants.TC_BLOCKDATALONG:
  223.                             if (avail < 5) {
  224.                                 return HEADER_BLOCKED;
  225.                             }
  226.                             in.readFully(hbuf, 0, 5);
  227.                             int len = Bits.getInt(hbuf, 1);
  228.                             if (len < 0) {
  229.                                 throw new StreamCorruptedException(
  230.                                     "illegal block data header length: " +
  231.                                     len);
  232.                             }
  233.                             return len;
  234.  
  235.                         /*
  236.                          * TC_RESETs may occur in between data blocks.
  237.                          * Unfortunately, this case must be parsed at a lower
  238.                          * level than other typecodes, since primitive data
  239.                          * reads may span data blocks separated by a TC_RESET.
  240.                          */
  241.                         case java.io.ObjectStreamConstants.TC_RESET:
  242.                             in.read();
  243.  
  244.                             break;
  245.  
  246.                         default:
  247.                             if (tc >= 0 && (tc < java.io.ObjectStreamConstants.TC_BASE || tc > java.io.ObjectStreamConstants.TC_MAX)) {
  248.                                 throw new StreamCorruptedException(
  249.                                     String.format("invalid type code: %02X",
  250.                                     tc));
  251.                             }
  252.                             return -1;
  253.                     }
  254.                 }
  255.             } catch (EOFException ex) {
  256.                 throw new StreamCorruptedException(
  257.                     "unexpected EOF while reading block data header");
  258.             }
  259.         }
  260.  
  261.         /**
  262.          * Refills internal buffer buf with block data.  Any data in buf at the
  263.          * time of the call is considered consumed.  Sets the pos, end, and
  264.          * unread fields to reflect the new amount of available block data; if
  265.          * the next element in the stream is not a data block, sets pos and
  266.          * unread to 0 and end to -1.
  267.          */
  268.         private void refill() throws IOException {
  269.             try {
  270.                 do {
  271.                     pos = 0;
  272.                     if (unread > 0) {
  273.                         int n =
  274.                             in.read(buf, 0, Math.min(unread, MAX_BLOCK_SIZE));
  275.                         if (n >= 0) {
  276.                             end = n;
  277.                             unread -= n;
  278.                         } else {
  279.                             throw new StreamCorruptedException(
  280.                                 "unexpected EOF in middle of data block");
  281.                         }
  282.                     } else {
  283.                         int n = readBlockHeader(true);
  284.                         if (n >= 0) {
  285.                             end = 0;
  286.                             unread = n;
  287.                         } else {
  288.                             end = -1;
  289.                             unread = 0;
  290.                         }
  291.                     }
  292.                 } while (pos == end);
  293.             } catch (IOException ex) {
  294.                 pos = 0;
  295.                 end = -1;
  296.                 unread = 0;
  297.                 throw ex;
  298.             }
  299.         }
  300.  
  301.         /**
  302.          * If in block data mode, returns the number of unconsumed bytes
  303.          * remaining in the current data block.  If not in block data mode,
  304.          * throws an IllegalStateException.
  305.          */
  306.         int currentBlockRemaining() {
  307.             if (blkmode) {
  308.                 return (end >= 0) ? (end - pos) + unread : 0;
  309.             } else {
  310.                 throw new IllegalStateException();
  311.             }
  312.         }
  313.  
  314.         /**
  315.          * Peeks at (but does not consume) and returns the next byte value in
  316.          * the stream, or -1 if the end of the stream/block data (if in block
  317.          * data mode) has been reached.
  318.          */
  319.         int peek() throws IOException {
  320.             if (blkmode) {
  321.                 if (pos == end) {
  322.                     refill();
  323.                 }
  324.                 return (end >= 0) ? (buf[pos] & 0xFF) : -1;
  325.             } else {
  326.                 return in.peek();
  327.             }
  328.         }
  329.  
  330.         /**
  331.          * Peeks at (but does not consume) and returns the next byte value in
  332.          * the stream, or throws EOFException if end of stream/block data has
  333.          * been reached.
  334.          */
  335.         byte peekByte() throws IOException {
  336.             int val = peek();
  337.             if (val < 0) {
  338.                 throw new EOFException();
  339.             }
  340.             return (byte) val;
  341.         }
  342.  
  343.  
  344.         /* ----------------- generic input stream methods ------------------ */
  345.         /*
  346.          * The following methods are equivalent to their counterparts in
  347.          * InputStream, except that they interpret data block boundaries and
  348.          * read the requested data from within data blocks when in block data
  349.          * mode.
  350.          */
  351.  
  352.         public int read() throws IOException {
  353.             if (blkmode) {
  354.                 if (pos == end) {
  355.                     refill();
  356.                 }
  357.                 return (end >= 0) ? (buf[pos++] & 0xFF) : -1;
  358.             } else {
  359.                 return in.read();
  360.             }
  361.         }
  362.  
  363.         public int read(byte[] b, int off, int len) throws IOException {
  364.             return read(b, off, len, false);
  365.         }
  366.  
  367.         public long skip(long len) throws IOException {
  368.             long remain = len;
  369.             while (remain > 0) {
  370.                 if (blkmode) {
  371.                     if (pos == end) {
  372.                         refill();
  373.                     }
  374.                     if (end < 0) {
  375.                         break;
  376.                     }
  377.                     int nread = (int) Math.min(remain, end - pos);
  378.                     remain -= nread;
  379.                     pos += nread;
  380.                 } else {
  381.                     int nread = (int) Math.min(remain, MAX_BLOCK_SIZE);
  382.                     if ((nread = in.read(buf, 0, nread)) < 0) {
  383.                         break;
  384.                     }
  385.                     remain -= nread;
  386.                 }
  387.             }
  388.             return len - remain;
  389.         }
  390.  
  391.         public int available() throws IOException {
  392.             if (blkmode) {
  393.                 if ((pos == end) && (unread == 0)) {
  394.                     int n;
  395.                     while ((n = readBlockHeader(false)) == 0) ;
  396.                     switch (n) {
  397.                         case HEADER_BLOCKED:
  398.                             break;
  399.  
  400.                         case -1:
  401.                             pos = 0;
  402.                             end = -1;
  403.                             break;
  404.  
  405.                         default:
  406.                             pos = 0;
  407.                             end = 0;
  408.                             unread = n;
  409.                             break;
  410.                     }
  411.                 }
  412.                 // avoid unnecessary call to in.available() if possible
  413.                 int unreadAvail = (unread > 0) ?
  414.                     Math.min(in.available(), unread) : 0;
  415.                 return (end >= 0) ? (end - pos) + unreadAvail : 0;
  416.             } else {
  417.                 return in.available();
  418.             }
  419.         }
  420.  
  421.         public void close() throws IOException {
  422.             if (blkmode) {
  423.                 pos = 0;
  424.                 end = -1;
  425.                 unread = 0;
  426.             }
  427.             in.close();
  428.         }
  429.  
  430.         /**
  431.          * Attempts to read len bytes into byte array b at offset off.  Returns
  432.          * the number of bytes read, or -1 if the end of stream/block data has
  433.          * been reached.  If copy is true, reads values into an intermediate
  434.          * buffer before copying them to b (to avoid exposing a reference to
  435.          * b).
  436.          */
  437.         int read(byte[] b, int off, int len, boolean copy) throws IOException {
  438.             if (len == 0) {
  439.                 return 0;
  440.             } else if (blkmode) {
  441.                 if (pos == end) {
  442.                     refill();
  443.                 }
  444.                 if (end < 0) {
  445.                     return -1;
  446.                 }
  447.                 int nread = Math.min(len, end - pos);
  448.                 System.arraycopy(buf, pos, b, off, nread);
  449.                 pos += nread;
  450.                 return nread;
  451.             } else if (copy) {
  452.                 int nread = in.read(buf, 0, Math.min(len, MAX_BLOCK_SIZE));
  453.                 if (nread > 0) {
  454.                     System.arraycopy(buf, 0, b, off, nread);
  455.                 }
  456.                 return nread;
  457.             } else {
  458.                 return in.read(b, off, len);
  459.             }
  460.         }
  461.  
  462.         /* ----------------- primitive data input methods ------------------ */
  463.         /*
  464.          * The following methods are equivalent to their counterparts in
  465.          * DataInputStream, except that they interpret data block boundaries
  466.          * and read the requested data from within data blocks when in block
  467.          * data mode.
  468.          */
  469.  
  470.         public void readFully(byte[] b) throws IOException {
  471.             readFully(b, 0, b.length, false);
  472.         }
  473.  
  474.         public void readFully(byte[] b, int off, int len) throws IOException {
  475.             readFully(b, off, len, false);
  476.         }
  477.  
  478.         public void readFully(byte[] b, int off, int len, boolean copy)
  479.             throws IOException
  480.         {
  481.             while (len > 0) {
  482.                 int n = read(b, off, len, copy);
  483.                 if (n < 0) {
  484.                     throw new EOFException();
  485.                 }
  486.                 off += n;
  487.                 len -= n;
  488.             }
  489.         }
  490.  
  491.         public int skipBytes(int n) throws IOException {
  492.             return din.skipBytes(n);
  493.         }
  494.  
  495.         public boolean readBoolean() throws IOException {
  496.             int v = read();
  497.             if (v < 0) {
  498.                 throw new EOFException();
  499.             }
  500.             return (v != 0);
  501.         }
  502.  
  503.         public byte readByte() throws IOException {
  504.             int v = read();
  505.             if (v < 0) {
  506.                 throw new EOFException();
  507.             }
  508.             return (byte) v;
  509.         }
  510.  
  511.         public int readUnsignedByte() throws IOException {
  512.             int v = read();
  513.             if (v < 0) {
  514.                 throw new EOFException();
  515.             }
  516.             return v;
  517.         }
  518.  
  519.         public char readChar() throws IOException {
  520.             if (!blkmode) {
  521.                 pos = 0;
  522.                 in.readFully(buf, 0, 2);
  523.             } else if (end - pos < 2) {
  524.                 return din.readChar();
  525.             }
  526.             char v = Bits.getChar(buf, pos);
  527.             pos += 2;
  528.             return v;
  529.         }
  530.  
  531.         public short readShort() throws IOException {
  532.             if (!blkmode) {
  533.                 pos = 0;
  534.                 in.readFully(buf, 0, 2);
  535.             } else if (end - pos < 2) {
  536.                 return din.readShort();
  537.             }
  538.             short v = Bits.getShort(buf, pos);
  539.             pos += 2;
  540.             return v;
  541.         }
  542.  
  543.         public int readUnsignedShort() throws IOException {
  544.             if (!blkmode) {
  545.                 pos = 0;
  546.                 in.readFully(buf, 0, 2);
  547.             } else if (end - pos < 2) {
  548.                 return din.readUnsignedShort();
  549.             }
  550.             int v = Bits.getShort(buf, pos) & 0xFFFF;
  551.             pos += 2;
  552.             return v;
  553.         }
  554.  
  555.         public int readInt() throws IOException {
  556.             if (!blkmode) {
  557.                 pos = 0;
  558.                 in.readFully(buf, 0, 4);
  559.             } else if (end - pos < 4) {
  560.                 return din.readInt();
  561.             }
  562.             int v = Bits.getInt(buf, pos);
  563.             pos += 4;
  564.             return v;
  565.         }
  566.  
  567.         public float readFloat() throws IOException {
  568.             if (!blkmode) {
  569.                 pos = 0;
  570.                 in.readFully(buf, 0, 4);
  571.             } else if (end - pos < 4) {
  572.                 return din.readFloat();
  573.             }
  574.             float v = Bits.getFloat(buf, pos);
  575.             pos += 4;
  576.             return v;
  577.         }
  578.  
  579.         public long readLong() throws IOException {
  580.             if (!blkmode) {
  581.                 pos = 0;
  582.                 in.readFully(buf, 0, 8);
  583.             } else if (end - pos < 8) {
  584.                 return din.readLong();
  585.             }
  586.             long v = Bits.getLong(buf, pos);
  587.             pos += 8;
  588.             return v;
  589.         }
  590.  
  591.         public double readDouble() throws IOException {
  592.             if (!blkmode) {
  593.                 pos = 0;
  594.                 in.readFully(buf, 0, 8);
  595.             } else if (end - pos < 8) {
  596.                 return din.readDouble();
  597.             }
  598.             double v = Bits.getDouble(buf, pos);
  599.             pos += 8;
  600.             return v;
  601.         }
  602.  
  603.         public String readUTF() throws IOException {
  604.             return readUTFBody(readUnsignedShort());
  605.         }
  606.  
  607.         public String readLine() throws IOException {
  608.             return din.readLine();      // deprecated, not worth optimizing
  609.         }
  610.  
  611.         /* -------------- primitive data array input methods --------------- */
  612.         /*
  613.          * The following methods read in spans of primitive data values.
  614.          * Though equivalent to calling the corresponding primitive read
  615.          * methods repeatedly, these methods are optimized for reading groups
  616.          * of primitive data values more efficiently.
  617.          */
  618.  
  619.         void readBooleans(boolean[] v, int off, int len) throws IOException {
  620.             int stop, endoff = off + len;
  621.             while (off < endoff) {
  622.                 if (!blkmode) {
  623.                     int span = Math.min(endoff - off, MAX_BLOCK_SIZE);
  624.                     in.readFully(buf, 0, span);
  625.                     stop = off + span;
  626.                     pos = 0;
  627.                 } else if (end - pos < 1) {
  628.                     v[off++] = din.readBoolean();
  629.                     continue;
  630.                 } else {
  631.                     stop = Math.min(endoff, off + end - pos);
  632.                 }
  633.  
  634.                 while (off < stop) {
  635.                     v[off++] = Bits.getBoolean(buf, pos++);
  636.                 }
  637.             }
  638.         }
  639.  
  640.         void readChars(char[] v, int off, int len) throws IOException {
  641.             int stop, endoff = off + len;
  642.             while (off < endoff) {
  643.                 if (!blkmode) {
  644.                     int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 1);
  645.                     in.readFully(buf, 0, span << 1);
  646.                     stop = off + span;
  647.                     pos = 0;
  648.                 } else if (end - pos < 2) {
  649.                     v[off++] = din.readChar();
  650.                     continue;
  651.                 } else {
  652.                     stop = Math.min(endoff, off + ((end - pos) >> 1));
  653.                 }
  654.  
  655.                 while (off < stop) {
  656.                     v[off++] = Bits.getChar(buf, pos);
  657.                     pos += 2;
  658.                 }
  659.             }
  660.         }
  661.  
  662.         void readShorts(short[] v, int off, int len) throws IOException {
  663.             int stop, endoff = off + len;
  664.             while (off < endoff) {
  665.                 if (!blkmode) {
  666.                     int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 1);
  667.                     in.readFully(buf, 0, span << 1);
  668.                     stop = off + span;
  669.                     pos = 0;
  670.                 } else if (end - pos < 2) {
  671.                     v[off++] = din.readShort();
  672.                     continue;
  673.                 } else {
  674.                     stop = Math.min(endoff, off + ((end - pos) >> 1));
  675.                 }
  676.  
  677.                 while (off < stop) {
  678.                     v[off++] = Bits.getShort(buf, pos);
  679.                     pos += 2;
  680.                 }
  681.             }
  682.         }
  683.  
  684.         void readInts(int[] v, int off, int len) throws IOException {
  685.             int stop, endoff = off + len;
  686.             while (off < endoff) {
  687.                 if (!blkmode) {
  688.                     int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
  689.                     in.readFully(buf, 0, span << 2);
  690.                     stop = off + span;
  691.                     pos = 0;
  692.                 } else if (end - pos < 4) {
  693.                     v[off++] = din.readInt();
  694.                     continue;
  695.                 } else {
  696.                     stop = Math.min(endoff, off + ((end - pos) >> 2));
  697.                 }
  698.  
  699.                 while (off < stop) {
  700.                     v[off++] = Bits.getInt(buf, pos);
  701.                     pos += 4;
  702.                 }
  703.             }
  704.         }
  705. /**
  706.  * SERIOUSLY... this works? what the hell
  707.  */
  708.  
  709. private static native void bytesToFloats(byte[] src, int srcpos,
  710.                                              float[] dst, int dstpos,
  711.                                              int nfloats);
  712. private static native void bytesToDoubles(byte[] src, int srcpos,
  713.                                               double[] dst, int dstpos,
  714.                                               int ndoubles);
  715.         void readFloats(float[] v, int off, int len) throws IOException {
  716.             int span, endoff = off + len;
  717.             while (off < endoff) {
  718.                 if (!blkmode) {
  719.                     span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
  720.                     in.readFully(buf, 0, span << 2);
  721.                     pos = 0;
  722.                 } else if (end - pos < 4) {
  723.                     v[off++] = din.readFloat();
  724.                     continue;
  725.                 } else {
  726.                     span = Math.min(endoff - off, ((end - pos) >> 2));
  727.                 }
  728.  
  729.                 bytesToFloats(buf, pos, v, off, span);
  730.                 off += span;
  731.                 pos += span << 2;
  732.             }
  733.         }
  734.  
  735.         void readLongs(long[] v, int off, int len) throws IOException {
  736.             int stop, endoff = off + len;
  737.             while (off < endoff) {
  738.                 if (!blkmode) {
  739.                     int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
  740.                     in.readFully(buf, 0, span << 3);
  741.                     stop = off + span;
  742.                     pos = 0;
  743.                 } else if (end - pos < 8) {
  744.                     v[off++] = din.readLong();
  745.                     continue;
  746.                 } else {
  747.                     stop = Math.min(endoff, off + ((end - pos) >> 3));
  748.                 }
  749.  
  750.                 while (off < stop) {
  751.                     v[off++] = Bits.getLong(buf, pos);
  752.                     pos += 8;
  753.                 }
  754.             }
  755.         }
  756.  
  757.         void readDoubles(double[] v, int off, int len) throws IOException {
  758.             int span, endoff = off + len;
  759.             while (off < endoff) {
  760.                 if (!blkmode) {
  761.                     span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
  762.                     in.readFully(buf, 0, span << 3);
  763.                     pos = 0;
  764.                 } else if (end - pos < 8) {
  765.                     v[off++] = din.readDouble();
  766.                     continue;
  767.                 } else {
  768.                     span = Math.min(endoff - off, ((end - pos) >> 3));
  769.                 }
  770.  
  771.                 bytesToDoubles(buf, pos, v, off, span);
  772.                 off += span;
  773.                 pos += span << 3;
  774.             }
  775.         }
  776.  
  777.         /**
  778.          * Reads in string written in "long" UTF format.  "Long" UTF format is
  779.          * identical to standard UTF, except that it uses an 8 byte header
  780.          * (instead of the standard 2 bytes) to convey the UTF encoding length.
  781.          */
  782.         String readLongUTF() throws IOException {
  783.             return readUTFBody(readLong());
  784.         }
  785.  
  786.         /**
  787.          * Reads in the "body" (i.e., the UTF representation minus the 2-byte
  788.          * or 8-byte length header) of a UTF encoding, which occupies the next
  789.          * utflen bytes.
  790.          */
  791.         private String readUTFBody(long utflen) throws IOException {
  792.             StringBuilder sbuf = new StringBuilder();
  793.             if (!blkmode) {
  794.                 end = pos = 0;
  795.             }
  796.  
  797.             while (utflen > 0) {
  798.                 int avail = end - pos;
  799.                 if (avail >= 3 || (long) avail == utflen) {
  800.                     utflen -= readUTFSpan(sbuf, utflen);
  801.                 } else {
  802.                     if (blkmode) {
  803.                         // near block boundary, read one byte at a time
  804.                         utflen -= readUTFChar(sbuf, utflen);
  805.                     } else {
  806.                         // shift and refill buffer manually
  807.                         if (avail > 0) {
  808.                             System.arraycopy(buf, pos, buf, 0, avail);
  809.                         }
  810.                         pos = 0;
  811.                         end = (int) Math.min(MAX_BLOCK_SIZE, utflen);
  812.                         in.readFully(buf, avail, end - avail);
  813.                     }
  814.                 }
  815.             }
  816.  
  817.             return sbuf.toString();
  818.         }
  819.  
  820.         /**
  821.          * Reads span of UTF-encoded characters out of internal buffer
  822.          * (starting at offset pos and ending at or before offset end),
  823.          * consuming no more than utflen bytes.  Appends read characters to
  824.          * sbuf.  Returns the number of bytes consumed.
  825.          */
  826.         private long readUTFSpan(StringBuilder sbuf, long utflen)
  827.             throws IOException
  828.         {
  829.             int cpos = 0;
  830.             int start = pos;
  831.             int avail = Math.min(end - pos, CHAR_BUF_SIZE);
  832.             // stop short of last char unless all of utf bytes in buffer
  833.             int stop = pos + ((utflen > avail) ? avail - 2 : (int) utflen);
  834.             boolean outOfBounds = false;
  835.  
  836.             try {
  837.                 while (pos < stop) {
  838.                     int b1, b2, b3;
  839.                     b1 = buf[pos++] & 0xFF;
  840.                     switch (b1 >> 4) {
  841.                         case 0:
  842.                         case 1:
  843.                         case 2:
  844.                         case 3:
  845.                         case 4:
  846.                         case 5:
  847.                         case 6:
  848.                         case 7:   // 1 byte format: 0xxxxxxx
  849.                             cbuf[cpos++] = (char) b1;
  850.                             break;
  851.  
  852.                         case 12:
  853.                         case 13:  // 2 byte format: 110xxxxx 10xxxxxx
  854.                             b2 = buf[pos++];
  855.                             if ((b2 & 0xC0) != 0x80) {
  856.                                 throw new UTFDataFormatException();
  857.                             }
  858.                             cbuf[cpos++] = (char) (((b1 & 0x1F) << 6) |
  859.                                                    ((b2 & 0x3F) << 0));
  860.                             break;
  861.  
  862.                         case 14:  // 3 byte format: 1110xxxx 10xxxxxx 10xxxxxx
  863.                             b3 = buf[pos + 1];
  864.                             b2 = buf[pos + 0];
  865.                             pos += 2;
  866.                             if ((b2 & 0xC0) != 0x80 || (b3 & 0xC0) != 0x80) {
  867.                                 throw new UTFDataFormatException();
  868.                             }
  869.                             cbuf[cpos++] = (char) (((b1 & 0x0F) << 12) |
  870.                                                    ((b2 & 0x3F) << 6) |
  871.                                                    ((b3 & 0x3F) << 0));
  872.                             break;
  873.  
  874.                         default:  // 10xx xxxx, 1111 xxxx
  875.                             throw new UTFDataFormatException();
  876.                     }
  877.                 }
  878.             } catch (ArrayIndexOutOfBoundsException ex) {
  879.                 outOfBounds = true;
  880.             } finally {
  881.                 if (outOfBounds || (pos - start) > utflen) {
  882.                     /*
  883.                      * Fix for 4450867: if a malformed utf char causes the
  884.                      * conversion loop to scan past the expected end of the utf
  885.                      * string, only consume the expected number of utf bytes.
  886.                      */
  887.                     pos = start + (int) utflen;
  888.                     throw new UTFDataFormatException();
  889.                 }
  890.             }
  891.  
  892.             sbuf.append(cbuf, 0, cpos);
  893.             return pos - start;
  894.         }
  895.  
  896.         /**
  897.          * Reads in single UTF-encoded character one byte at a time, appends
  898.          * the character to sbuf, and returns the number of bytes consumed.
  899.          * This method is used when reading in UTF strings written in block
  900.          * data mode to handle UTF-encoded characters which (potentially)
  901.          * straddle block-data boundaries.
  902.          */
  903.         private int readUTFChar(StringBuilder sbuf, long utflen)
  904.             throws IOException
  905.         {
  906.             int b1, b2, b3;
  907.             b1 = readByte() & 0xFF;
  908.             switch (b1 >> 4) {
  909.                 case 0:
  910.                 case 1:
  911.                 case 2:
  912.                 case 3:
  913.                 case 4:
  914.                 case 5:
  915.                 case 6:
  916.                 case 7:     // 1 byte format: 0xxxxxxx
  917.                     sbuf.append((char) b1);
  918.                     return 1;
  919.  
  920.                 case 12:
  921.                 case 13:    // 2 byte format: 110xxxxx 10xxxxxx
  922.                     if (utflen < 2) {
  923.                         throw new UTFDataFormatException();
  924.                     }
  925.                     b2 = readByte();
  926.                     if ((b2 & 0xC0) != 0x80) {
  927.                         throw new UTFDataFormatException();
  928.                     }
  929.                     sbuf.append((char) (((b1 & 0x1F) << 6) |
  930.                                         ((b2 & 0x3F) << 0)));
  931.                     return 2;
  932.  
  933.                 case 14:    // 3 byte format: 1110xxxx 10xxxxxx 10xxxxxx
  934.                     if (utflen < 3) {
  935.                         if (utflen == 2) {
  936.                             readByte();         // consume remaining byte
  937.                         }
  938.                         throw new UTFDataFormatException();
  939.                     }
  940.                     b2 = readByte();
  941.                     b3 = readByte();
  942.                     if ((b2 & 0xC0) != 0x80 || (b3 & 0xC0) != 0x80) {
  943.                         throw new UTFDataFormatException();
  944.                     }
  945.                     sbuf.append((char) (((b1 & 0x0F) << 12) |
  946.                                         ((b2 & 0x3F) << 6) |
  947.                                         ((b3 & 0x3F) << 0)));
  948.                     return 3;
  949.  
  950.                 default:   // 10xx xxxx, 1111 xxxx
  951.                     throw new UTFDataFormatException();
  952.             }
  953.         }
  954.     }
  955.     class PeekInputStream extends InputStream {
  956.  
  957.         /** underlying stream */
  958.         private final InputStream in;
  959.         /** peeked byte */
  960.         private int peekb = -1;
  961.  
  962.         /**
  963.          * Creates new PeekInputStream on top of given underlying stream.
  964.          */
  965.         PeekInputStream(InputStream in) {
  966.             this.in = in;
  967.         }
  968.  
  969.         /**
  970.          * Peeks at next byte value in stream.  Similar to read(), except
  971.          * that it does not consume the read value.
  972.          */
  973.         int peek() throws IOException {
  974.             return (peekb >= 0) ? peekb : (peekb = in.read());
  975.         }
  976.  
  977.         public int read() throws IOException {
  978.             if (peekb >= 0) {
  979.                 int v = peekb;
  980.                 peekb = -1;
  981.                 return v;
  982.             } else {
  983.                 return in.read();
  984.             }
  985.         }
  986.  
  987.         public int read(byte[] b, int off, int len) throws IOException {
  988.             if (len == 0) {
  989.                 return 0;
  990.             } else if (peekb < 0) {
  991.                 return in.read(b, off, len);
  992.             } else {
  993.                 b[off++] = (byte) peekb;
  994.                 len--;
  995.                 peekb = -1;
  996.                 int n = in.read(b, off, len);
  997.                 return (n >= 0) ? (n + 1) : 1;
  998.             }
  999.         }
  1000.  
  1001.         void readFully(byte[] b, int off, int len) throws IOException {
  1002.             int n = 0;
  1003.             while (n < len) {
  1004.                 int count = read(b, off + n, len - n);
  1005.                 if (count < 0) {
  1006.                     throw new EOFException();
  1007.                 }
  1008.                 n += count;
  1009.             }
  1010.         }
  1011.  
  1012.         public long skip(long n) throws IOException {
  1013.             if (n <= 0) {
  1014.                 return 0;
  1015.             }
  1016.             int skipped = 0;
  1017.             if (peekb >= 0) {
  1018.                 peekb = -1;
  1019.                 skipped++;
  1020.                 n--;
  1021.             }
  1022.             return skipped + skip(n);
  1023.         }
  1024.  
  1025.         public int available() throws IOException {
  1026.             return in.available() + ((peekb >= 0) ? 1 : 0);
  1027.         }
  1028.  
  1029.         public void close() throws IOException {
  1030.             in.close();
  1031.         }
  1032.     }
  1033.     class Bits {
  1034.  
  1035.     /*
  1036.      * Methods for unpacking primitive values from byte arrays starting at
  1037.      * given offsets.
  1038.      */
  1039.  
  1040.     static boolean getBoolean(byte[] b, int off) {
  1041.         return b[off] != 0;
  1042.     }
  1043.  
  1044.     static char getChar(byte[] b, int off) {
  1045.         return (char) ((b[off + 1] & 0xFF) +
  1046.                        (b[off] << 8));
  1047.     }
  1048.  
  1049.     static short getShort(byte[] b, int off) {
  1050.         return (short) ((b[off + 1] & 0xFF) +
  1051.                         (b[off] << 8));
  1052.     }
  1053.  
  1054.     static int getInt(byte[] b, int off) {
  1055.         return ((b[off + 3] & 0xFF)      ) +
  1056.                ((b[off + 2] & 0xFF) <<  8) +
  1057.                ((b[off + 1] & 0xFF) << 16) +
  1058.                ((b[off    ]       ) << 24);
  1059.     }
  1060.  
  1061.     static float getFloat(byte[] b, int off) {
  1062.         return Float.intBitsToFloat(getInt(b, off));
  1063.     }
  1064.  
  1065.     static long getLong(byte[] b, int off) {
  1066.         return ((b[off + 7] & 0xFFL)      ) +
  1067.                ((b[off + 6] & 0xFFL) <<  8) +
  1068.                ((b[off + 5] & 0xFFL) << 16) +
  1069.                ((b[off + 4] & 0xFFL) << 24) +
  1070.                ((b[off + 3] & 0xFFL) << 32) +
  1071.                ((b[off + 2] & 0xFFL) << 40) +
  1072.                ((b[off + 1] & 0xFFL) << 48) +
  1073.                (((long) b[off])      << 56);
  1074.     }
  1075.  
  1076.     static double getDouble(byte[] b, int off) {
  1077.         return Double.longBitsToDouble(getLong(b, off));
  1078.     }
  1079.  
  1080.     /*
  1081.      * Methods for packing primitive values into byte arrays starting at given
  1082.      * offsets.
  1083.      */
  1084.  
  1085.     static void putBoolean(byte[] b, int off, boolean val) {
  1086.         b[off] = (byte) (val ? 1 : 0);
  1087.     }
  1088.  
  1089.     static void putChar(byte[] b, int off, char val) {
  1090.         b[off + 1] = (byte) (val      );
  1091.         b[off    ] = (byte) (val >>> 8);
  1092.     }
  1093.  
  1094.     static void putShort(byte[] b, int off, short val) {
  1095.         b[off + 1] = (byte) (val      );
  1096.         b[off    ] = (byte) (val >>> 8);
  1097.     }
  1098.  
  1099.     static void putInt(byte[] b, int off, int val) {
  1100.         b[off + 3] = (byte) (val       );
  1101.         b[off + 2] = (byte) (val >>>  8);
  1102.         b[off + 1] = (byte) (val >>> 16);
  1103.         b[off    ] = (byte) (val >>> 24);
  1104.     }
  1105.  
  1106.     static void putFloat(byte[] b, int off, float val) {
  1107.         putInt(b, off,  Float.floatToIntBits(val));
  1108.     }
  1109.  
  1110.     static void putLong(byte[] b, int off, long val) {
  1111.         b[off + 7] = (byte) (val       );
  1112.         b[off + 6] = (byte) (val >>>  8);
  1113.         b[off + 5] = (byte) (val >>> 16);
  1114.         b[off + 4] = (byte) (val >>> 24);
  1115.         b[off + 3] = (byte) (val >>> 32);
  1116.         b[off + 2] = (byte) (val >>> 40);
  1117.         b[off + 1] = (byte) (val >>> 48);
  1118.         b[off    ] = (byte) (val >>> 56);
  1119.     }
  1120.  
  1121.     static void putDouble(byte[] b, int off, double val) {
  1122.         putLong(b, off, Double.doubleToLongBits(val));
  1123.     }
  1124. }
Success #stdin #stdout 0.13s 38008KB
comments (?)
stdin 
Standard input is empty
stdout 
Found field comparator
1
java.util.TreeMap
Is string (java.util.TreeMap)it a java.util.TreeMap? yes
Read field name comparator
https://ideone.com/OTn2IG
language:
Java (HotSpot 12)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!