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