S283 Planetary Science &n…he Search for Life DVD 2/DVD-ROM.iso/install/jre1_3/lib/rt.jar/java/io/ObjectInputStream.class

Java Class File | 1979-12-31 | 18.8 KB | 1,296 lines

package java.io;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
import java.util.ArrayList;

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[] buf;
   private int bufpos;
   private int bufsize;
   private DataInputStream dis;
   private IOException abortIOException = null;
   private ClassNotFoundException abortClassNotFoundException = null;
   private Object currentObject;
   private ObjectStreamClass currentClassDesc;
   private Class currentClass;
   private Object currentGetFields;
   private byte[] data = new byte[1024];
   private char[] cdata = new char[50];
   private static final int CDATA_MAX_LEN = 1000;
   private StringBuffer sbuf = new StringBuffer();
   ObjectStreamClass[] classdesc;
   Class[] classes;
   int spClass;
   private ArrayList wireHandle2Object;
   private int nextWireOffset;
   private ArrayList callbacks;
   private int recursionDepth;
   private byte currCode;
   boolean enableResolve;
   private boolean enableSubclassImplementation;
   private Object[] readObjectArglist = new Object[]{this};
   // $FF: synthetic field
   static Class class$java$io$Serializable;

   public ObjectInputStream(InputStream var1) throws IOException, StreamCorruptedException {
      this.enableSubclassImplementation = false;
      this.field_0 = var1;
      this.buf = new byte[8];
      this.dis = new DataInputStream(this);
      this.readStreamHeader();
      this.resetStream();
   }

   protected ObjectInputStream() throws IOException, SecurityException {
      SecurityManager var1 = System.getSecurityManager();
      if (var1 != null) {
         var1.checkPermission(ObjectStreamConstants.SUBCLASS_IMPLEMENTATION_PERMISSION);
      }

      this.enableSubclassImplementation = true;
   }

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

   protected Object readObjectOverride() throws OptionalDataException, ClassNotFoundException, IOException {
      return null;
   }

   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 var7 = -1;
         switch (var6) {
            case 112:
               var5 = null;
               break;
            case 113:
               var7 = this.readInt() - 8257536;

               try {
                  var5 = this.wireHandle2Object.get(var7);
                  break;
               } catch (ArrayIndexOutOfBoundsException var20) {
                  throw new StreamCorruptedException("Reference to object never serialized.");
               }
            case 114:
               var5 = this.inputClassDescriptor();
               break;
            case 115:
               var7 = this.inputObject(var1);
               var5 = this.currentObject;
               if (this.currentObject != null && this.currentClassDesc != null && this.currentClassDesc.isResolvable()) {
                  var5 = ObjectStreamClass.invokeMethod(this.currentClassDesc.readResolveMethod, var5, (Object[])null);
               }

               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
               }

               if (var5 != this.currentObject) {
                  this.wireHandle2Object.set(var7, var5);
               }
               break;
            case 116:
            case 124:
               long var30 = var6 == 116 ? (long)this.readUnsignedShort() : this.readLong();
               var5 = this.readUTFBody(var30);
               Object var33 = var5;
               var7 = this.assignWireOffset(var5);
               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
               }

               if (var5 != var33) {
                  this.wireHandle2Object.set(var7, var5);
               }
               break;
            case 117:
               var7 = this.inputArray(var1);
               var5 = this.currentObject;
               if (this.enableResolve) {
                  var5 = this.resolveObject(var5);
               }

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

               var5 = var8.forClass();
               if (var5 == null && var1) {
                  throw var8.pendingException;
               }

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

                  this.count = var32 << 24 | var10 << 16 | var11 << 8 | var12;
                  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 var9 = (IOException)this.readObject();
               this.resetStream();
               throw new WriteAbortedException("Writing aborted by exception", var9);
            case 125:
               var5 = this.inputProxyClassDescriptor();
         }
      } 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.currentClass = this.currentClassDesc != null ? this.currentClassDesc.forClass() : null;
         this.setBlockData(var4);
      }

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

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

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

            return var5;
         }
      }
   }

   public void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException {
      if (this.currentObject != null && this.currentClassDesc != null) {
         ObjectStreamField[] var1 = this.currentClassDesc.getFieldsNoCopy();
         if (var1.length > 0) {
            boolean var2 = this.setBlockData(false);
            this.inputClassFields(this.currentObject, this.currentClass, var1);
            this.setBlockData(var2);
         }

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

   public GetField readFields() throws IOException, ClassNotFoundException, NotActiveException {
      if (this.currentObject != null && this.currentClassDesc != null) {
         GetFieldImpl var1 = new GetFieldImpl(this.currentClassDesc);
         this.currentGetFields = var1;
         boolean var2 = this.setBlockData(false);
         var1.read(this);
         this.setBlockData(var2);
         return 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 ArrayList();
         }

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

            for(int var5 = 0; var5 < var4; ++var5) {
               ValidationCallback var6 = (ValidationCallback)this.callbacks.get(var5);
               if (var6.priority <= var2) {
                  this.callbacks.add(var5, var3);
                  break;
               }
            }

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

   private void doValidations() throws InvalidObjectException {
      if (this.callbacks != null) {
         int var1 = this.callbacks.size();

         for(int var2 = 0; var2 < var1; ++var2) {
            ValidationCallback var3 = (ValidationCallback)this.callbacks.get(var2);
            var3.callback.validateObject();
         }

         this.callbacks.clear();
      }
   }

   protected Class resolveClass(ObjectStreamClass var1) throws IOException, ClassNotFoundException {
      ClassLoader var2 = latestUserDefinedLoader();
      return Class.forName(var1.getName(), false, var2);
   }

   protected Class resolveProxyClass(String[] var1) throws IOException, ClassNotFoundException {
      ClassLoader var2 = latestUserDefinedLoader();
      Class[] var3 = new Class[var1.length];

      for(int var4 = 0; var4 < var1.length; ++var4) {
         var3[var4] = Class.forName(var1[var4], false, var2);
      }

      try {
         return Proxy.getProxyClass(var2, var3);
      } catch (IllegalArgumentException var6) {
         throw new ClassNotFoundException((String)null, var6);
      }
   }

   private static native ClassLoader latestUserDefinedLoader() throws ClassNotFoundException;

   private Class loadClass0(Class var1, String var2) throws ClassNotFoundException {
      ClassLoader var3;
      if (var1 != null) {
         var3 = var1.getClassLoader();
      } else {
         var3 = latestUserDefinedLoader();
      }

      return Class.forName(var2, false, var3);
   }

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

   protected boolean enableResolveObject(boolean var1) throws SecurityException {
      boolean var2 = this.enableResolve;
      if (var1) {
         SecurityManager var3 = System.getSecurityManager();
         if (var3 != null) {
            var3.checkPermission(ObjectStreamConstants.SUBSTITUTION_PERMISSION);
         }

         this.enableResolve = true;
      } else {
         this.enableResolve = false;
      }

      return var2;
   }

   protected void readStreamHeader() throws IOException, StreamCorruptedException {
      short var1 = 0;
      short var2 = 0;

      try {
         var1 = this.readShort();
         var2 = this.readShort();
      } catch (EOFException var4) {
         throw new StreamCorruptedException("Caught EOFException while reading the stream header");
      }

      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);
      }
   }

   protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
      String var1 = this.readUTF();
      long var2 = this.readLong();
      ObjectStreamClass var4 = new ObjectStreamClass(var1, var2);
      var4.read(this);
      return var4;
   }

   private ObjectStreamClass inputClassDescriptor() throws IOException, InvalidClassException, ClassNotFoundException {
      ObjectStreamClass var2 = new ObjectStreamClass((String)null, 0L);
      this.assignWireOffset(var2);
      ObjectStreamClass var4 = this.readClassDescriptor();
      var2.lightCopy(var4);
      boolean var5 = this.setBlockData(true);

      Class var1;
      try {
         var1 = this.resolveClass(var2);
      } catch (ClassNotFoundException var7) {
         var1 = null;
         var2.pendingException = var7;
      }

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

   private ObjectStreamClass inputProxyClassDescriptor() throws IOException, InvalidClassException, ClassNotFoundException {
      ObjectStreamClass var1 = new ObjectStreamClass("", 0L);
      this.assignWireOffset(var1);
      int var3 = this.readInt();
      String[] var4 = new String[var3];

      for(int var5 = 0; var5 < var3; ++var5) {
         var4[var5] = this.readUTF();
      }

      boolean var7 = this.setBlockData(true);

      Class var6;
      try {
         var6 = this.resolveProxyClass(var4);
      } catch (ClassNotFoundException var9) {
         var6 = null;
         var1.pendingException = var9;
      }

      this.skipToEndOfBlockData();
      this.setBlockData(var7);
      var1.initProxyClassDesc(var6);
      var1.setClass(var6);
      ObjectStreamClass var8 = (ObjectStreamClass)this.readObject();
      var1.setSuperclass(var8);
      return var1;
   }

   private int inputArray(boolean var1) throws IOException, ClassNotFoundException {
      ObjectStreamClass var2 = (ObjectStreamClass)this.readObject();
      Class var3 = var2.forClass();
      if (var3 == null && var1) {
         throw var2.pendingException;
      } 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();
            int var21 = this.data.length;
            int var22 = this.data.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.data, 0, var11);
                     var21 = 0;
                  }

                  var10[var13] = this.data[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.data, 0, var12);
                  System.arraycopy(this.data, 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.data, 0, var31);
                     var21 = 0;
                  }

                  var24[var14] = (short)(((this.data[var21] & 255) << 8) + ((this.data[var21 + 1] & 255) << 0));
                  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 << 2, var22);
                     this.readFully(this.data, 0, var32);
                     var21 = 0;
                  }

                  var25[var15] = ((this.data[var21] & 255) << 24) + ((this.data[var21 + 1] & 255) << 16) + ((this.data[var21 + 2] & 255) << 8) + ((this.data[var21 + 3] & 255) << 0);
                  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 << 3, var22);
                     this.readFully(this.data, 0, var33);
                     var21 = 0;
                  }

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

               int var35;
               for(int var17 = 0; var17 < var4; var17 += var35) {
                  var35 = Math.min(var4 - var17, var22 >> 2);
                  this.readFully(this.data, 0, var35 << 2);
                  bytesToFloats(this.data, 0, var27, var17, var35);
               }
            } else if (var20 == Double.TYPE) {
               double[] var28 = (double[])this.currentObject;

               int var36;
               for(int var18 = 0; var18 < var4; var18 += var36) {
                  var36 = Math.min(var4 - var18, var22 >> 3);
                  this.readFully(this.data, 0, var36 << 3);
                  bytesToDoubles(this.data, 0, var28, var18, var36);
               }
            } 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 var37 = Math.min((var4 - var19) * 2, var22);
                     this.readFully(this.data, 0, var37);
                     var21 = 0;
                  }

                  var29[var19] = (char)(((this.data[var21] & 255) << 8) + ((this.data[var21 + 1] & 255) << 0));
                  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 static native void bytesToFloats(byte[] var0, int var1, float[] var2, int var3, int var4);

   private static native void bytesToDoubles(byte[] var0, int var1, double[] var2, int var3, int var4);

   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) {
         throw this.currentClassDesc.pendingException;
      } else {
         if (var1) {
            this.currentClassDesc.verifyInstanceDeserialization();
         }

         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;

               try {
                  if (this.currentClassDesc.hasExternalizableBlockDataMode()) {
                     var3 = this.setBlockData(true);
                  }

                  if (this.currentObject != null) {
                     Externalizable var4 = (Externalizable)this.currentObject;
                     var4.readExternal(this);
                  }
               } finally {
                  if (this.currentClassDesc.hasExternalizableBlockDataMode()) {
                     this.skipToEndOfBlockData();
                     this.setBlockData(var3);
                  }

               }
            } catch (NoSuchMethodError var32) {
               throw new InvalidClassException(this.currentClass.getName() + "Missing no-arg constructor for class");
            } catch (IllegalAccessException var33) {
               throw new InvalidClassException(this.currentClass.getName(), "IllegalAccessException");
            } catch (InstantiationException var34) {
               throw new InvalidClassException(this.currentClass.getName(), "InstantiationException");
            }
         } else {
            if (this.currentClassDesc.ancestors == null) {
               ObjectStreamClass var37 = this.currentClassDesc;
               Class var40 = this.currentClass;
               int var6 = this.spClass;
               var37 = this.currentClassDesc;

               for(var40 = this.currentClass; var37 != null; var37 = var37.superclass) {
                  Class var7 = var37.forClass();

                  Class var8;
                  for(var8 = var40; var8 != null && var7 != var8; var8 = var8.getSuperclass()) {
                  }

                  if (this.spClass >= this.classes.length) {
                     this.growClassStacks();
                  }

                  if (var8 == null) {
                     this.classdesc[this.spClass] = var37;
                     this.classes[this.spClass] = null;
                  } else {
                     this.classdesc[this.spClass] = var37;
                     this.classes[this.spClass] = var8;
                     var40 = var8.getSuperclass();
                  }

                  ++this.spClass;
               }

               if (var40 != null) {
                  while((class$java$io$Serializable == null ? (class$java$io$Serializable = class$("java.io.Serializable")) : class$java$io$Serializable).isAssignableFrom(var40)) {
                     var40 = var40.getSuperclass();
                  }
               }

               int var5 = this.spClass - var6;
               this.currentClassDesc.ancestors = new Class[var5 + 1];

               for(int var45 = 0; var45 < var5; ++var45) {
                  this.currentClassDesc.ancestors[var45] = this.classes[var6 + var45];
               }

               this.currentClassDesc.ancestors[var5] = var40;
               this.spClass = var6;
            }

            int var43 = this.currentClassDesc.ancestors.length - 1;
            Class var42 = this.currentClassDesc.ancestors[var43];

            try {
               this.currentObject = this.currentClass == null ? null : allocateNewObject(this.currentClass, var42);
            } catch (NoSuchMethodError var28) {
               throw new InvalidClassException(var42.getName() + "Missing no-arg constructor for class");
            } catch (IllegalAccessException var29) {
               throw new InvalidClassException(var42.getName(), "IllegalAccessException");
            } catch (InstantiationException var30) {
               throw new InvalidClassException(var42.getName(), "InstantiationException");
            }

            var2 = this.assignWireOffset(this.currentObject);
            int var44 = this.spClass;

            for(ObjectStreamClass var39 = this.currentClassDesc; var39 != null; var39 = var39.superclass) {
               if (this.spClass >= this.classes.length) {
                  this.growClassStacks();
               }

               this.classdesc[this.spClass] = var39;
               this.classes[this.spClass] = this.currentClassDesc.ancestors[this.spClass - var44];
               ++this.spClass;
            }

            try {
               --this.spClass;

               while(this.spClass >= var44) {
                  this.currentClassDesc = this.classdesc[this.spClass];
                  this.currentClass = this.classes[this.spClass];
                  if (this.classes[this.spClass] != null) {
                     this.setBlockData(true);
                     ObjectStreamClass var46 = this.currentClassDesc.localClassDescriptor();
                     if (!this.invokeObjectReader(this.currentObject)) {
                        this.defaultReadObject();
                     }
                  } else {
                     ObjectStreamField[] var47 = this.currentClassDesc.getFieldsNoCopy();
                     if (var47.length > 0) {
                        boolean var48 = this.setBlockData(false);
                        this.inputClassFields((Object)null, this.currentClass, var47);
                        this.setBlockData(var48);
                     }
                  }

                  if (this.currentClassDesc.hasWriteObject()) {
                     this.skipToEndOfBlockData();
                  }

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

         return var2;
      }
   }

   private void growClassStacks() {
      int var1 = this.classes.length * 2;
      Class[] var2 = new Class[var1];
      ObjectStreamClass[] var3 = new ObjectStreamClass[var1];
      System.arraycopy(this.classes, 0, var2, 0, this.classes.length);
      System.arraycopy(this.classdesc, 0, var3, 0, this.classes.length);
      this.classes = var2;
      this.classdesc = var3;
   }

   private void skipToEndOfBlockData() throws IOException, ClassNotFoundException {
      if (this.blockDataMode) {
         while(true) {
            while(this.count > 0) {
               ((InputStream)this).skip((long)this.count);
            }

            switch (this.peekCode()) {
               case -1:
                  return;
               case 119:
               case 122:
                  this.refill();
                  break;
               case 120:
                  this.readCode();
                  return;
               default:
                  this.readObject(false);
            }
         }
      }
   }

   private void resetStream() throws IOException {
      if (this.wireHandle2Object == null) {
         this.wireHandle2Object = new ArrayList();
      } else {
         this.wireHandle2Object.clear();
      }

      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.clear();
      }

   }

   private int assignWireOffset(Object var1) throws IOException {
      this.wireHandle2Object.add(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 <= 125) {
            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.bufpos = 0;
         this.bufsize = 0;
         this.blockDataMode = var1;
         return !var1;
      }
   }

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

         if (this.count < 0) {
            return -1;
         } else {
            try {
               int var1 = this.bufferData(1);
               return this.buf[var1] & 255;
            } catch (EOFException var2) {
               return -1;
            }
         }
      }
   }

   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 var2 = this.field_0.read();
         if (var2 < 0) {
            throw new StreamCorruptedException("EOF expecting count");
         }

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

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

         this.count = var6;
      }

   }

   int bufferData(int var1) throws IOException {
      this.ensureBufferCapacity(var1);
      if (this.blockDataMode) {
         if (var1 > this.count) {
            throw new InternalError("attempt to read past block end");
         } else {
            int var2 = this.bufsize - this.bufpos;
            if (var1 > var2) {
               if (this.bufpos > 0) {
                  System.arraycopy(this.buf, this.bufpos, this.buf, 0, var2);
                  this.bufpos = 0;
                  this.bufsize = var2;
               }

               this.ensureBufferCapacity(this.count);
               this.readFullyInternal(this.buf, this.bufsize, this.count - this.bufsize);
               this.bufsize = this.count;
            }

            int var3 = this.bufpos;
            this.bufpos += var1;
            this.count -= var1;
            return var3;
         }
      } else {
         this.readFullyInternal(this.buf, 0, var1);
         return 0;
      }
   }

   private void ensureBufferCapacity(int var1) {
      if (this.buf.length < var1) {
         byte[] var2 = new byte[var1];
         if (this.bufsize > 0) {
            System.arraycopy(this.buf, 0, var2, 0, this.bufsize);
         }

         this.buf = var2;
      }

   }

   private void readFullyInternal(byte[] var1, int var2, int var3) throws IOException {
      int var5;
      for(int var4 = 0; var4 < var3; var4 += var5) {
         var5 = this.field_0.read(var1, var2 + var4, var3 - var4);
         if (var5 < 0) {
            throw new EOFException();
         }
      }

   }

   public int read(byte[] var1, int var2, int var3) throws IOException {
      if (var1 == null) {
         throw new NullPointerException();
      } else if (var2 >= 0 && var3 >= 0 && var2 + var3 <= var1.length && var2 + var3 >= 0) {
         if (var3 == 0) {
            return 0;
         } 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 {
               var3 = Math.min(var3, this.count);
               int var4 = 0;
               int var5 = this.bufsize - this.bufpos;
               if (var5 > 0) {
                  var4 = Math.min(var3, var5);
                  System.arraycopy(this.buf, this.bufpos, var1, var2, var4);
                  this.bufpos += var4;
               }

               if (var3 > var4) {
                  var4 += this.field_0.read(var1, var2 + var4, var3 - var4);
               }

               this.count -= var4;
               return var4;
            }
         }
      } else {
         throw new IndexOutOfBoundsException();
      }
   }

   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 {
      int var1 = this.read();
      if (var1 < 0) {
         throw new EOFException();
      } else {
         return var1 != 0;
      }
   }

   public byte readByte() throws IOException {
      int var1 = this.read();
      if (var1 < 0) {
         throw new EOFException();
      } else {
         return (byte)var1;
      }
   }

   public int readUnsignedByte() throws IOException {
      int var1 = this.read();
      if (var1 < 0) {
         throw new EOFException();
      } else {
         return var1;
      }
   }

   public short readShort() throws IOException {
      if (this.blockDataMode && this.count < 2) {
         return this.dis.readShort();
      } else {
         int var1 = this.bufferData(2);
         return (short)(((this.buf[var1 + 0] & 255) << 8) + ((this.buf[var1 + 1] & 255) << 0));
      }
   }

   public int readUnsignedShort() throws IOException {
      if (this.blockDataMode && this.count < 2) {
         return this.dis.readUnsignedShort();
      } else {
         int var1 = this.bufferData(2);
         return ((this.buf[var1 + 0] & 255) << 8) + ((this.buf[var1 + 1] & 255) << 0);
      }
   }

   public char readChar() throws IOException {
      if (this.blockDataMode && this.count < 2) {
         return this.dis.readChar();
      } else {
         int var1 = this.bufferData(2);
         return (char)(((this.buf[var1 + 0] & 255) << 8) + ((this.buf[var1 + 1] & 255) << 0));
      }
   }

   public int readInt() throws IOException {
      if (this.blockDataMode && this.count < 4) {
         return this.dis.readInt();
      } else {
         int var1 = this.bufferData(4);
         return ((this.buf[var1 + 0] & 255) << 24) + ((this.buf[var1 + 1] & 255) << 16) + ((this.buf[var1 + 2] & 255) << 8) + ((this.buf[var1 + 3] & 255) << 0);
      }
   }

   public long readLong() throws IOException {
      if (this.blockDataMode && this.count < 8) {
         return this.dis.readLong();
      } else {
         int var1 = this.bufferData(8);
         return (((long)this.buf[var1 + 0] & 255L) << 56) + (((long)this.buf[var1 + 1] & 255L) << 48) + (((long)this.buf[var1 + 2] & 255L) << 40) + (((long)this.buf[var1 + 3] & 255L) << 32) + (((long)this.buf[var1 + 4] & 255L) << 24) + (((long)this.buf[var1 + 5] & 255L) << 16) + (((long)this.buf[var1 + 6] & 255L) << 8) + (((long)this.buf[var1 + 7] & 255L) << 0);
      }
   }

   public float readFloat() throws IOException {
      if (this.blockDataMode && this.count < 4) {
         return this.dis.readFloat();
      } else {
         int var1 = this.bufferData(4);
         return Float.intBitsToFloat(((this.buf[var1 + 0] & 255) << 24) + ((this.buf[var1 + 1] & 255) << 16) + ((this.buf[var1 + 2] & 255) << 8) + ((this.buf[var1 + 3] & 255) << 0));
      }
   }

   public double readDouble() throws IOException {
      if (this.blockDataMode && this.count < 8) {
         return this.dis.readDouble();
      } else {
         int var1 = this.bufferData(8);
         return Double.longBitsToDouble((((long)this.buf[var1 + 0] & 255L) << 56) + (((long)this.buf[var1 + 1] & 255L) << 48) + (((long)this.buf[var1 + 2] & 255L) << 40) + (((long)this.buf[var1 + 3] & 255L) << 32) + (((long)this.buf[var1 + 4] & 255L) << 24) + (((long)this.buf[var1 + 5] & 255L) << 16) + (((long)this.buf[var1 + 6] & 255L) << 8) + (((long)this.buf[var1 + 7] & 255L) << 0));
      }
   }

   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.readUTFBody((long)this.readUnsignedShort());
   }

   private String readUTFBody(long var1) throws IOException {
      long var4 = var1;
      int var6 = 0;
      int var7 = 0;
      int var8 = 0;
      int var9 = this.cdata.length;
      if (var1 > (long)var9 && var9 < 1000) {
         this.cdata = new char[(int)Math.min(var1, 1000L)];
         var9 = this.cdata.length;
      }

      while(var4 > 0L) {
         int var13 = var7 - var6;
         if (var13 > 0) {
            System.arraycopy(this.data, var6, this.data, 0, var13);
         }

         int var14 = (int)Math.min(var4, (long)(this.data.length - var13));
         this.dis.readFully(this.data, var13, var14);
         var7 = var13 + var14;
         var4 -= (long)var14;
         var6 = 0;

         try {
            int var15 = var4 > 0L ? var7 - 2 : var7;

            while(var6 < var15) {
               if (var8 >= var9) {
                  this.sbuf.append(this.cdata);
                  var8 = 0;
               }

               int var10 = this.data[var6++] & 255;
               switch (var10 >> 4) {
                  case 0:
                  case 1:
                  case 2:
                  case 3:
                  case 4:
                  case 5:
                  case 6:
                  case 7:
                     this.cdata[var8++] = (char)var10;
                     break;
                  case 8:
                  case 9:
                  case 10:
                  case 11:
                  default:
                     throw new UTFDataFormatException();
                  case 12:
                  case 13:
                     byte var19 = this.data[var6++];
                     if ((var19 & 192) != 128) {
                        throw new UTFDataFormatException();
                     }

                     this.cdata[var8++] = (char)((var10 & 31) << 6 | var19 & 63);
                     break;
                  case 14:
                     byte var11 = this.data[var6++];
                     byte var12 = this.data[var6++];
                     if ((var11 & 192) != 128 || (var12 & 192) != 128) {
                        throw new UTFDataFormatException();
                     }

                     this.cdata[var8++] = (char)((var10 & 15) << 12 | (var11 & 63) << 6 | (var12 & 63) << 0);
               }
            }
         } catch (IndexOutOfBoundsException var16) {
            throw new UTFDataFormatException();
         }
      }

      if (var8 > 0) {
         this.sbuf.append(this.cdata, 0, var8);
      }

      String var18 = this.sbuf.toString();
      this.sbuf.setLength(0);
      return var18;
   }

   private boolean invokeObjectReader(Object var1) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException {
      if (this.currentClassDesc.readObjectMethod == null) {
         return false;
      } else {
         try {
            this.currentClassDesc.readObjectMethod.invoke(var1, this.readObjectArglist);
            return true;
         } catch (InvocationTargetException var4) {
            Throwable var3 = var4.getTargetException();
            if (var3 instanceof ClassNotFoundException) {
               throw (ClassNotFoundException)var3;
            } else if (var3 instanceof IOException) {
               throw (IOException)var3;
            } else if (var3 instanceof RuntimeException) {
               throw (RuntimeException)var3;
            } else if (var3 instanceof Error) {
               throw (Error)var3;
            } else {
               throw new Error("interal error");
            }
         } catch (IllegalAccessException var5) {
            return false;
         }
      }
   }

   private void inputClassFields(Object var1, Class var2, ObjectStreamField[] var3) throws InvalidClassException, StreamCorruptedException, ClassNotFoundException, IOException {
      if (this.currentClassDesc.numPrimBytes > 0) {
         if (this.data.length < this.currentClassDesc.numPrimBytes) {
            this.data = new byte[this.currentClassDesc.numPrimBytes];
         }

         this.readFully(this.data, 0, this.currentClassDesc.numPrimBytes);
         if (var1 != null) {
            setPrimitiveFieldValues(var1, this.currentClassDesc.primFieldIDs, this.currentClassDesc.primFieldTypecodes, this.data);
         }
      }

      int var4 = var3.length - this.currentClassDesc.numObjFields;

      for(int var5 = 0; var5 < this.currentClassDesc.numObjFields; ++var5) {
         Field var6 = var3[var4 + var5].getField();
         boolean var7 = var6 != null;
         Object var8 = this.readObject(var7);
         if (var1 != null && var6 != null) {
            try {
               setObjectFieldValue(var1, this.currentClassDesc.objFieldIDs[var5], this.currentClassDesc.objFieldTypes[var5], var8);
            } catch (ClassCastException var11) {
               throw new ClassCastException("Assigning instance of class " + var8.getClass().getName() + " to field " + var2.getName() + '#' + var6.getName());
            } catch (Exception var12) {
               throw new InvalidClassException(var2.getName(), "Invalid field " + var6.getName());
            }
         }
      }

   }

   private static native void setPrimitiveFieldValues(Object var0, long[] var1, char[] var2, byte[] var3);

   private static native void setObjectFieldValue(Object var0, long var1, Class var3, Object var4);

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

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

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }

   // $FF: synthetic method
   static Object access$000(ObjectInputStream var0, boolean var1) throws OptionalDataException, ClassNotFoundException, IOException {
      return var0.readObject(var1);
   }
}