PC Pro 1999 April/DPPCPRO0499.ISO/April/Notes/50b2wic.exe/DATA1.CAB/NotesProgramFilesJavaSupport/rt.jar/java/io/ObjectInputStream.class

Java Class File | 1998-04-23 | 15.1 KB | 866 lines

package java.io;

import java.util.Vector;
import sun.io.ObjectInputStreamDelegate;

public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants {
   // $FF: renamed from: in java.io.InputStream
   private InputStream field_0;
   private int count;
   private boolean blockDataMode;
   private byte[] buffer;
   private DataInputStream dis;
   private IOException abortIOException;
   private ClassNotFoundException abortClassNotFoundException;
   private Object currentObject;
   private ObjectStreamClass currentClassDesc;
   private Class currentClass;
   ObjectStreamClass[] classdesc;
   Class[] classes;
   int spClass;
   private Vector wireHandle2Object;
   private int nextWireOffset;
   private Vector callbacks;
   private int recursionDepth;
   private byte currCode;
   boolean enableResolve;
   private boolean isTrustedSubclass = false;

   public ObjectInputStream(InputStream var1) throws IOException, StreamCorruptedException {
      if (this instanceof ObjectInputStreamDelegate && this.getClass().getClassLoader() == null) {
         this.isTrustedSubclass = true;
      } else {
         this.field_0 = var1;
         this.dis = new DataInputStream(this);
         this.readStreamHeader();
         this.resetStream();
      }
   }

   public final Object readObject() throws OptionalDataException, ClassNotFoundException, IOException {
      return this.isTrustedSubclass ? ((ObjectInputStreamDelegate)this).readObjectDelegate() : this.readObject(true);
   }

   private final Object readObject(boolean var1) throws OptionalDataException, ClassNotFoundException, IOException {
      if (this.blockDataMode) {
         if (this.count == 0) {
            this.refill();
         }

         if (this.count > 0) {
            throw new OptionalDataException(this.count);
         }
      }

      this.peekCode();
      Object var2 = this.currentObject;
      ObjectStreamClass var3 = this.currentClassDesc;
      boolean var4 = this.setBlockData(false);
      ++this.recursionDepth;
      Object var5 = null;
      byte var6 = this.readCode();

      try {
         int var9 = -1;
         switch (var6) {
            case 112:
               var5 = null;
               break;
            case 113:
               var9 = this.readInt() - 8257536;

               try {
                  var5 = this.wireHandle2Object.elementAt(var9);
                  break;
               } catch (ArrayIndexOutOfBoundsException var20) {
                  throw new StreamCorruptedException("Reference to object never serialized.");
               }
            case 114:
               var5 = this.inputClassDescriptor();
               break;
            case 115:
               var9 = this.inputObject(var1);
               var5 = this.currentObject;
               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
                  this.wireHandle2Object.setElementAt(var5, var9);
               }
               break;
            case 116:
               var5 = this.readUTF();
               Object var29 = var5;
               var9 = this.assignWireOffset(var5);
               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
               }

               if (var5 != var29) {
                  this.wireHandle2Object.setElementAt(var5, var9);
               }
               break;
            case 117:
               var9 = this.inputArray(var1);
               var5 = this.currentObject;
               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
               }

               if (var5 != this.currentObject) {
                  this.wireHandle2Object.setElementAt(var5, var9);
               }
               break;
            case 118:
               ObjectStreamClass var10 = (ObjectStreamClass)this.readObject(var1);
               if (var10 == null) {
                  throw new StreamCorruptedException("Class not in stream");
               }

               var5 = var10.forClass();
               if (var5 == null && var1) {
                  throw new ClassNotFoundException(var10.getName());
               }

               this.assignWireOffset(var5);
               break;
            case 119:
            case 122:
               if (var6 == 122) {
                  int var30 = this.field_0.read();
                  int var12 = this.field_0.read();
                  int var13 = this.field_0.read();
                  int var14 = this.field_0.read();
                  if ((var30 | var12 | var13 | var14) < 0) {
                     throw new StreamCorruptedException("EOF expecting count");
                  }

                  this.count = var30 << 24 | var12 << 16 | var13 << 8 | var14;
                  if (this.count < 0) {
                     throw new StreamCorruptedException("Negative block data size");
                  }
               } else {
                  this.count = this.field_0.read();
                  if (this.count < 0) {
                     throw new StreamCorruptedException("EOF expecting count");
                  }
               }

               if (!var4) {
                  throw new StreamCorruptedException("Unexpected blockdata");
               }

               throw new OptionalDataException(this.count);
            case 120:
               if (!var4) {
                  throw new StreamCorruptedException("Unexpected end of block data");
               }

               this.pushbackCode((byte)120);
               this.count = -1;
               throw new OptionalDataException(true);
            case 121:
            default:
               throw new StreamCorruptedException("Unknown code in readObject " + var6);
            case 123:
               this.resetStream();
               IOException var11 = (IOException)this.readObject();
               this.resetStream();
               throw new WriteAbortedException("Writing aborted by exception", var11);
         }
      } catch (OptionalDataException var21) {
         throw var21;
      } catch (IOException var22) {
         if (this.abortIOException == null && this.abortClassNotFoundException == null) {
            this.abortIOException = var22;
         }
      } catch (ClassNotFoundException var23) {
         if (this.abortIOException == null && this.abortClassNotFoundException == null) {
            this.abortClassNotFoundException = var23;
         }
      } finally {
         --this.recursionDepth;
         this.currentObject = var2;
         this.currentClassDesc = var3;
         this.setBlockData(var4);
      }

      IOException var7 = this.abortIOException;
      if (this.recursionDepth == 0) {
         this.abortIOException = null;
      }

      if (var7 != null) {
         throw var7;
      } else {
         ClassNotFoundException var8 = this.abortClassNotFoundException;
         if (this.recursionDepth == 0) {
            this.abortClassNotFoundException = null;
         }

         if (var8 != null) {
            throw var8;
         } else {
            if (this.recursionDepth == 0) {
               this.doValidations();
            }

            return var5;
         }
      }
   }

   public final void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException {
      if (this.isTrustedSubclass) {
         ((ObjectInputStreamDelegate)this).defaultReadObjectDelegate();
      } else if (this.currentObject != null && this.currentClassDesc != null) {
         if (this.currentClassDesc.getFieldSequence() != null) {
            boolean var1 = this.setBlockData(false);
            this.inputClassFields(this.currentObject, this.currentClass, this.currentClassDesc.getFieldSequence());
            this.setBlockData(var1);
         }

      } else {
         throw new NotActiveException("defaultReadObject");
      }
   }

   public synchronized void registerValidation(ObjectInputValidation var1, int var2) throws NotActiveException, InvalidObjectException {
      if (this.recursionDepth == 0) {
         throw new NotActiveException("readObject not Active");
      } else if (var1 == null) {
         throw new InvalidObjectException("Null is not a valid callback object");
      } else {
         ValidationCallback var3 = new ValidationCallback(var1, var2);
         if (this.callbacks == null) {
            this.callbacks = new Vector(100, 100);
         }

         if (!this.callbacks.isEmpty() && ((ValidationCallback)this.callbacks.lastElement()).priority < var2) {
            int var4 = this.callbacks.size();

            for(int var5 = 0; var5 < var4; ++var5) {
               ValidationCallback var6 = (ValidationCallback)this.callbacks.elementAt(var5);
               if (var6.priority <= var2) {
                  this.callbacks.insertElementAt(var3, var5);
                  return;
               }
            }

         } else {
            this.callbacks.addElement(var3);
         }
      }
   }

   private void doValidations() throws InvalidObjectException {
      if (this.callbacks != null) {
         int var1 = this.callbacks.size();
         if (var1 != 0) {
            for(int var2 = 0; var2 < var1; ++var2) {
               ValidationCallback var3 = (ValidationCallback)this.callbacks.elementAt(var2);
               var3.callback.validateObject();
            }

            this.callbacks.setSize(0);
         }
      }
   }

   protected Class resolveClass(ObjectStreamClass var1) throws IOException, ClassNotFoundException {
      return this.loadClass0((Class)null, var1.getName());
   }

   private native Class loadClass0(Class var1, String var2) throws ClassNotFoundException;

   protected Object resolveObject(Object var1) throws IOException {
      return var1;
   }

   protected final boolean enableResolveObject(boolean var1) throws SecurityException {
      if (this.isTrustedSubclass) {
         return ((ObjectInputStreamDelegate)this).enableResolveObjectDelegate(var1);
      } else {
         boolean var2 = this.enableResolve;
         if (var1) {
            ClassLoader var3 = this.getClass().getClassLoader();
            if (var3 == null) {
               this.enableResolve = true;
               return var2;
            } else {
               throw new SecurityException("Not trusted class");
            }
         } else {
            this.enableResolve = false;
            return var2;
         }
      }
   }

   protected void readStreamHeader() throws IOException, StreamCorruptedException {
      short var1 = this.readShort();
      short var2 = this.readShort();
      if (var1 != -21267) {
         throw new StreamCorruptedException("InputStream does not contain a serialized object");
      } else if (var2 != 5) {
         throw new StreamCorruptedException("Version Mismatch, Expected " + 5 + " and got " + var2);
      }
   }

   private ObjectStreamClass inputClassDescriptor() throws IOException, InvalidClassException, ClassNotFoundException {
      String var2 = this.readUTF();
      long var3 = this.readLong();
      ObjectStreamClass var5 = new ObjectStreamClass(var2, var3);
      this.assignWireOffset(var5);
      var5.read(this);
      boolean var6 = this.setBlockData(true);

      Class var1;
      try {
         var1 = this.resolveClass(var5);
      } catch (ClassNotFoundException var8) {
         var1 = null;
      } catch (NoClassDefFoundError var9) {
         var1 = null;
      }

      this.SkipToEndOfBlockData();
      this.setBlockData(var6);
      var5.setClass(var1);
      ObjectStreamClass var7 = (ObjectStreamClass)this.readObject();
      var5.setSuperclass(var7);
      return var5;
   }

   private int inputArray(boolean var1) throws IOException, ClassNotFoundException {
      ObjectStreamClass var2 = (ObjectStreamClass)this.readObject();
      Class var3 = var2.forClass();
      if (var3 == null && var1) {
         throw new ClassNotFoundException(var2.getName());
      } else {
         int var4 = this.readInt();
         this.currentObject = var3 == null ? null : allocateNewArray(var3, var4);
         int var5 = this.assignWireOffset(this.currentObject);
         if (var3 != null && var3.getComponentType().isPrimitive()) {
            Class var20 = var3.getComponentType();
            if (this.buffer == null) {
               this.buffer = new byte[1024];
            }

            int var21 = this.buffer.length;
            int var22 = this.buffer.length;
            if (var20 == Boolean.TYPE) {
               boolean[] var10 = (boolean[])this.currentObject;

               for(int var13 = 0; var13 < var4; ++var13) {
                  if (var21 >= var22) {
                     int var11 = Math.min(var4 - var13, var22);
                     this.readFully(this.buffer, 0, var11);
                     var21 = 0;
                  }

                  var10[var13] = this.buffer[var21] != 0;
                  ++var21;
               }
            } else if (var20 == Byte.TYPE) {
               byte[] var23 = (byte[])this.currentObject;

               int var12;
               for(int var30 = 0; var30 < var4; var30 += var12) {
                  var12 = Math.min(var4 - var30, var22);
                  this.readFully(this.buffer, 0, var12);
                  System.arraycopy(this.buffer, 0, var23, var30, var12);
               }
            } else if (var20 == Short.TYPE) {
               short[] var24 = (short[])this.currentObject;

               for(int var14 = 0; var14 < var4; ++var14) {
                  if (var21 > var22 - 2) {
                     int var31 = Math.min((var4 - var14) * 2, var22);
                     this.readFully(this.buffer, 0, var31);
                     var21 = 0;
                  }

                  var24[var14] = (short)(((this.buffer[var21] & 255) << 8) + (this.buffer[var21 + 1] & 255));
                  var21 += 2;
               }
            } else if (var20 == Integer.TYPE) {
               int[] var25 = (int[])this.currentObject;

               for(int var15 = 0; var15 < var4; ++var15) {
                  if (var21 > var22 - 4) {
                     int var32 = Math.min((var4 - var15) * 4, var22);
                     this.readFully(this.buffer, 0, var32);
                     var21 = 0;
                  }

                  var25[var15] = ((this.buffer[var21] & 255) << 24) + ((this.buffer[var21 + 1] & 255) << 16) + ((this.buffer[var21 + 2] & 255) << 8) + (this.buffer[var21 + 3] & 255);
                  var21 += 4;
               }
            } else if (var20 == Long.TYPE) {
               long[] var26 = (long[])this.currentObject;

               for(int var16 = 0; var16 < var4; ++var16) {
                  if (var21 > var22 - 8) {
                     int var33 = Math.min((var4 - var16) * 8, var22);
                     this.readFully(this.buffer, 0, var33);
                     var21 = 0;
                  }

                  int var34 = ((this.buffer[var21] & 255) << 24) + ((this.buffer[var21 + 1] & 255) << 16) + ((this.buffer[var21 + 2] & 255) << 8) + (this.buffer[var21 + 3] & 255);
                  int var40 = ((this.buffer[var21 + 4] & 255) << 24) + ((this.buffer[var21 + 5] & 255) << 16) + ((this.buffer[var21 + 6] & 255) << 8) + (this.buffer[var21 + 7] & 255);
                  var26[var16] = ((long)var34 << 32) + ((long)var40 & 4294967295L);
                  var21 += 8;
               }
            } else if (var20 == Float.TYPE) {
               float[] var27 = (float[])this.currentObject;

               for(int var17 = 0; var17 < var4; ++var17) {
                  if (var21 > var22 - 4) {
                     int var35 = Math.min((var4 - var17) * 4, var22);
                     this.readFully(this.buffer, 0, var35);
                     var21 = 0;
                  }

                  int var36 = ((this.buffer[var21] & 255) << 24) + ((this.buffer[var21 + 1] & 255) << 16) + ((this.buffer[var21 + 2] & 255) << 8) + (this.buffer[var21 + 3] & 255);
                  var21 += 4;
                  var27[var17] = Float.intBitsToFloat(var36);
               }
            } else if (var20 == Double.TYPE) {
               double[] var28 = (double[])this.currentObject;

               for(int var18 = 0; var18 < var4; ++var18) {
                  if (var21 > var22 - 8) {
                     int var37 = Math.min((var4 - var18) * 8, var22);
                     this.readFully(this.buffer, 0, var37);
                     var21 = 0;
                  }

                  int var38 = ((this.buffer[var21] & 255) << 24) + ((this.buffer[var21 + 1] & 255) << 16) + ((this.buffer[var21 + 2] & 255) << 8) + (this.buffer[var21 + 3] & 255);
                  int var41 = ((this.buffer[var21 + 4] & 255) << 24) + ((this.buffer[var21 + 5] & 255) << 16) + ((this.buffer[var21 + 6] & 255) << 8) + (this.buffer[var21 + 7] & 255);
                  var21 += 8;
                  var28[var18] = Double.longBitsToDouble(((long)var38 << 32) + ((long)var41 & 4294967295L));
               }
            } else {
               if (var20 != Character.TYPE) {
                  throw new InvalidClassException(var3.getName());
               }

               char[] var29 = (char[])this.currentObject;

               for(int var19 = 0; var19 < var4; ++var19) {
                  if (var21 > var22 - 2) {
                     int var39 = Math.min((var4 - var19) * 2, var22);
                     this.readFully(this.buffer, 0, var39);
                     var21 = 0;
                  }

                  var29[var19] = (char)(((this.buffer[var21] & 255) << 8) + (this.buffer[var21 + 1] & 255));
                  var21 += 2;
               }
            }
         } else {
            Object[] var7 = this.currentObject;
            boolean var8 = var3 != null;

            for(int var6 = 0; var6 < var4; ++var6) {
               Object var9 = this.readObject(var8);
               if (var7 != null) {
                  var7[var6] = var9;
               }
            }
         }

         return var5;
      }
   }

   private int inputObject(boolean var1) throws IOException, ClassNotFoundException {
      int var2 = -1;
      this.currentClassDesc = (ObjectStreamClass)this.readObject();
      this.currentClass = this.currentClassDesc.forClass();
      if (this.currentClass != null || !var1 && (!this.currentClassDesc.isExternalizable() || this.currentClassDesc.hasExternalizableBlockDataMode())) {
         if (this.currentClassDesc.isExternalizable()) {
            try {
               this.currentObject = this.currentClass == null ? null : allocateNewObject(this.currentClass, this.currentClass);
               var2 = this.assignWireOffset(this.currentObject);
               boolean var3 = this.blockDataMode;
               if (this.currentClassDesc.hasExternalizableBlockDataMode()) {
                  var3 = this.setBlockData(true);
               }

               try {
                  if (this.currentObject != null) {
                     Externalizable var6 = (Externalizable)this.currentObject;
                     var6.readExternal(this);
                  }
               } finally {
                  if (this.currentClassDesc.hasExternalizableBlockDataMode()) {
                     this.SkipToEndOfBlockData();
                     this.setBlockData(var3);
                  }

               }
            } catch (IllegalAccessException var29) {
               throw new InvalidClassException(this.currentClass.getName(), "IllegalAccessException");
            } catch (InstantiationException var30) {
               throw new InvalidClassException(this.currentClass.getName(), "InstantiationException");
            }
         } else {
            ObjectStreamClass var33 = this.currentClassDesc;
            Class var4 = this.currentClass;
            int var5 = this.spClass;
            var33 = this.currentClassDesc;

            for(var4 = this.currentClass; var33 != null; var33 = var33.getSuperclass()) {
               Class var36 = var33.forClass();

               Class var7;
               for(var7 = var4; var7 != null && var36 != var7; var7 = var7.getSuperclass()) {
               }

               ++this.spClass;
               if (this.spClass >= this.classes.length) {
                  int var8 = this.classes.length * 2;
                  Class[] var9 = new Class[var8];
                  ObjectStreamClass[] var10 = new ObjectStreamClass[var8];
                  System.arraycopy(this.classes, 0, var9, 0, this.classes.length);
                  System.arraycopy(this.classdesc, 0, var10, 0, this.classes.length);
                  this.classes = var9;
                  this.classdesc = var10;
               }

               if (var7 == null) {
                  this.classdesc[this.spClass] = var33;
                  this.classes[this.spClass] = null;
               } else {
                  this.classdesc[this.spClass] = var33;
                  this.classes[this.spClass] = var7;
                  var4 = var7.getSuperclass();
               }
            }

            try {
               this.currentObject = this.currentClass == null ? null : allocateNewObject(this.currentClass, var4);
            } catch (NoSuchMethodError var25) {
               throw new InvalidClassException(var4.getName(), "NoSuchMethodError");
            } catch (IllegalAccessException var26) {
               throw new InvalidClassException(var4.getName(), "IllegalAccessException");
            } catch (InstantiationException var27) {
               throw new InvalidClassException(var4.getName(), "InstantiationException");
            }

            var2 = this.assignWireOffset(this.currentObject);

            try {
               for(this.spClass = this.spClass; this.spClass > var5; --this.spClass) {
                  this.currentClassDesc = this.classdesc[this.spClass];
                  this.currentClass = this.classes[this.spClass];
                  if (this.classes[this.spClass] != null) {
                     this.setBlockData(true);
                     this.currentClassDesc.localClassDescriptor();
                     if (!this.invokeObjectReader(this.currentObject, this.currentClass)) {
                        this.defaultReadObject();
                     }
                  } else if (this.currentClassDesc.getFieldSequence() != null) {
                     boolean var37 = this.setBlockData(false);
                     this.inputClassFields((Object)null, this.currentClass, this.currentClassDesc.getFieldSequence());
                     this.setBlockData(var37);
                  }

                  if (this.currentClassDesc.hasWriteObject()) {
                     this.setBlockData(true);
                     this.SkipToEndOfBlockData();
                  }

                  this.setBlockData(false);
               }
            } finally {
               this.spClass = var5;
            }
         }

         return var2;
      } else {
         throw new ClassNotFoundException(this.currentClassDesc.getName());
      }
   }

   private void SkipToEndOfBlockData() throws IOException, ClassNotFoundException {
      while(this.peekCode() != 120) {
         try {
            this.readObject(false);
         } catch (OptionalDataException var2) {
            if (var2.length > 0) {
               ((InputStream)this).skip((long)var2.length);
            }
         }
      }

      this.readCode();
   }

   private void resetStream() throws IOException {
      if (this.wireHandle2Object == null) {
         this.wireHandle2Object = new Vector(100, 100);
      } else {
         this.wireHandle2Object.setSize(0);
      }

      this.nextWireOffset = 0;
      if (this.classes == null) {
         this.classes = new Class[20];
      } else {
         for(int var1 = 0; var1 < this.classes.length; ++var1) {
            this.classes[var1] = null;
         }
      }

      if (this.classdesc == null) {
         this.classdesc = new ObjectStreamClass[20];
      } else {
         for(int var2 = 0; var2 < this.classdesc.length; ++var2) {
            this.classdesc[var2] = null;
         }
      }

      this.spClass = 0;
      this.setBlockData(true);
      if (this.callbacks != null) {
         this.callbacks.setSize(0);
      }

   }

   private int assignWireOffset(Object var1) throws IOException {
      this.wireHandle2Object.addElement(var1);
      if (++this.nextWireOffset != this.wireHandle2Object.size()) {
         throw new StreamCorruptedException("Elements not assigned in order");
      } else {
         return this.nextWireOffset - 1;
      }
   }

   private byte peekCode() throws IOException, StreamCorruptedException {
      while(this.currCode == 0) {
         int var1 = this.field_0.read();
         if (var1 < 0) {
            throw new EOFException("Expecting code");
         }

         this.currCode = (byte)var1;
         if (this.currCode >= 112 && this.currCode <= 123) {
            if (this.currCode != 121) {
               continue;
            }

            if (this.recursionDepth == 0 && this.currentObject == null && this.currentClassDesc == null) {
               this.resetStream();
               this.currCode = 0;
               continue;
            }

            throw new StreamCorruptedException("Illegal stream state for reset");
         }

         throw new StreamCorruptedException("Type code out of range, is " + this.currCode);
      }

      return this.currCode;
   }

   private byte readCode() throws IOException, StreamCorruptedException {
      byte var1 = this.peekCode();
      this.currCode = 0;
      return var1;
   }

   private void pushbackCode(byte var1) {
      this.currCode = var1;
   }

   private boolean setBlockData(boolean var1) throws IOException {
      if (this.blockDataMode == var1) {
         return var1;
      } else if (this.blockDataMode && this.count > 0) {
         throw new StreamCorruptedException("Unread data");
      } else {
         this.count = var1 ? 0 : -1;
         this.blockDataMode = var1;
         return !var1;
      }
   }

   public int read() throws IOException {
      int var1;
      if (!this.blockDataMode) {
         var1 = this.field_0.read();
      } else {
         while(this.count == 0) {
            this.refill();
         }

         if (this.count < 0) {
            return -1;
         }

         var1 = this.field_0.read();
         if (var1 >= 0) {
            --this.count;
         }
      }

      return var1;
   }

   private void refill() throws IOException {
      this.count = -1;

      byte var1;
      try {
         var1 = this.peekCode();
      } catch (EOFException var7) {
         return;
      }

      if (var1 == 119) {
         var1 = this.readCode();
         int var10 = this.field_0.read();
         if (var10 < 0) {
            throw new StreamCorruptedException("EOF expecting count");
         } else {
            this.count = var10 & 255;
         }
      } else {
         if (var1 == 122) {
            var1 = this.readCode();
            int var2 = this.field_0.read();
            int var3 = this.field_0.read();
            int var4 = this.field_0.read();
            int var5 = this.field_0.read();
            if ((var2 | var3 | var4 | var5) < 0) {
               throw new StreamCorruptedException("EOF expecting count");
            }

            int var6 = var2 << 24 | var3 << 16 | var4 << 8 | var5;
            if (var6 < 0) {
               throw new StreamCorruptedException("Negative block data size");
            }

            this.count = var6;
         }

      }
   }

   public int read(byte[] var1, int var2, int var3) throws IOException {
      if (var3 < 0) {
         throw new IndexOutOfBoundsException();
      } else if (!this.blockDataMode) {
         return this.field_0.read(var1, var2, var3);
      } else {
         while(this.count == 0) {
            this.refill();
         }

         if (this.count < 0) {
            return -1;
         } else {
            int var5 = Math.min(var3, this.count);
            int var4 = this.field_0.read(var1, var2, var5);
            if (var4 > 0) {
               this.count -= var4;
            }

            return var4;
         }
      }
   }

   public int available() throws IOException {
      if (this.blockDataMode) {
         if (this.count == 0 && this.field_0.available() > 0) {
            this.refill();
         }

         return this.count >= 0 ? this.count : 0;
      } else {
         return 0;
      }
   }

   public void close() throws IOException {
      this.field_0.close();
   }

   public boolean readBoolean() throws IOException {
      return this.dis.readBoolean();
   }

   public byte readByte() throws IOException {
      return this.dis.readByte();
   }

   public int readUnsignedByte() throws IOException {
      return this.dis.readUnsignedByte();
   }

   public short readShort() throws IOException {
      return this.dis.readShort();
   }

   public int readUnsignedShort() throws IOException {
      return this.dis.readUnsignedShort();
   }

   public char readChar() throws IOException {
      return this.dis.readChar();
   }

   public int readInt() throws IOException {
      return this.dis.readInt();
   }

   public long readLong() throws IOException {
      return this.dis.readLong();
   }

   public float readFloat() throws IOException {
      return this.dis.readFloat();
   }

   public double readDouble() throws IOException {
      return this.dis.readDouble();
   }

   public void readFully(byte[] var1) throws IOException {
      this.dis.readFully(var1);
   }

   public void readFully(byte[] var1, int var2, int var3) throws IOException {
      if (var3 < 0) {
         throw new IndexOutOfBoundsException();
      } else {
         this.dis.readFully(var1, var2, var3);
      }
   }

   public int skipBytes(int var1) throws IOException {
      return this.dis.skipBytes(var1);
   }

   public String readLine() throws IOException {
      return this.dis.readLine();
   }

   public String readUTF() throws IOException {
      return this.dis.readUTF();
   }

   private native void inputClassFields(Object var1, Class var2, int[] var3) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException;

   private static native Object allocateNewObject(Class var0, Class var1) throws InstantiationException, IllegalAccessException;

   private static native Object allocateNewArray(Class var0, int var1);

   private native boolean invokeObjectReader(Object var1, Class var2) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException;
}