S283 Planetary Science &… the Search for Life CD 3/0_CD-ROM.iso/install/jre1_3/lib/rt.jar/java/io/ObjectStreamClass.class

Java Class File | 1979-12-31 | 16.0 KB | 892 lines

package java.io;

import java.lang.ref.SoftReference;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.security.AccessController;
import java.security.DigestOutputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Comparator;

public class ObjectStreamClass implements Serializable {
   private static ObjectStreamClassEntry[] descriptorFor = new ObjectStreamClassEntry[61];
   private String name;
   ObjectStreamClass superclass;
   private boolean serializable;
   private boolean externalizable;
   private ObjectStreamField[] fields;
   private Class ofClass;
   boolean forProxyClass;
   private long suid;
   int numPrimBytes;
   int numObjFields;
   private boolean hasWriteObjectMethod;
   private boolean hasExternalizableBlockData;
   Method writeObjectMethod;
   Method readObjectMethod;
   Method readResolveMethod;
   Method writeReplaceMethod;
   private ObjectStreamClass localClassDesc;
   private boolean disableInstanceDeserialization = false;
   ClassNotFoundException pendingException;
   Class[] ancestors;
   long[] primFieldIDs;
   char[] primFieldTypecodes;
   long[] objFieldIDs;
   Class[] objFieldTypes;
   private Object lock = new Object();
   private static final long serialVersionUID = -6120832682080437368L;
   public static final ObjectStreamField[] NO_FIELDS;
   private static final ObjectStreamField[] serialPersistentFields;
   private static Comparator compareClassByName;
   private static Comparator compareMemberByName;
   private static final Class[] NULL_ARGS;
   private static Class[] OIS_ARGS;
   private static Class[] OOS_ARGS;
   // $FF: synthetic field
   static Class class$java$io$Serializable;
   // $FF: synthetic field
   static Class class$java$io$Externalizable;
   // $FF: synthetic field
   static Class class$java$io$ObjectOutputStream;
   // $FF: synthetic field
   static Class class$java$io$ObjectInputStream;

   public static ObjectStreamClass lookup(Class var0) {
      ObjectStreamClass var1 = lookupInternal(var0);
      return !var1.isSerializable() && !var1.isExternalizable() ? null : var1;
   }

   static ObjectStreamClass lookupInternal(Class var0) {
      ObjectStreamClass var1 = null;
      ObjectStreamClassEntry[] var2 = descriptorFor;
      synchronized(var2) {
         var1 = findDescriptorFor(var0);
         if (var1 == null) {
            boolean var3 = (class$java$io$Serializable == null ? (class$java$io$Serializable = class$("java.io.Serializable")) : class$java$io$Serializable).isAssignableFrom(var0);
            ObjectStreamClass var4 = null;
            if (var3) {
               Class var5 = var0.getSuperclass();
               if (var5 != null) {
                  var4 = lookup(var5);
               }
            }

            boolean var9 = false;
            if (var3) {
               var9 = var4 != null && var4.isExternalizable() || (class$java$io$Externalizable == null ? (class$java$io$Externalizable = class$("java.io.Externalizable")) : class$java$io$Externalizable).isAssignableFrom(var0);
               if (var9) {
                  var3 = false;
               }
            }

            var1 = new ObjectStreamClass(var0, var4, var3, var9);
         }
      }

      var1.init();
      return var1;
   }

   public String getName() {
      return this.name;
   }

   public long getSerialVersionUID() {
      return this.suid;
   }

   public Class forClass() {
      return this.ofClass;
   }

   public ObjectStreamField[] getFields() {
      if (this.fields.length > 0) {
         ObjectStreamField[] var1 = new ObjectStreamField[this.fields.length];
         System.arraycopy(this.fields, 0, var1, 0, this.fields.length);
         return var1;
      } else {
         return this.fields;
      }
   }

   final ObjectStreamField[] getFieldsNoCopy() {
      return this.fields;
   }

   public ObjectStreamField getField(String var1) {
      ObjectStreamField var2 = ObjectStreamField.constructSearchKey(var1, Byte.TYPE);
      int var3 = -1;
      if (this.numObjFields != this.fields.length) {
         var3 = Arrays.binarySearch(this.fields, var2);
      }

      if (var3 < 0 && this.numObjFields > 0) {
         var2.setSearchKeyTypeString(false);
         var3 = Arrays.binarySearch(this.fields, var2);
      }

      return var3 < 0 ? null : this.fields[var3];
   }

   ObjectStreamField getField(String var1, Class var2) {
      ObjectStreamField var3 = ObjectStreamField.constructSearchKey(var1, var2);
      int var4 = Arrays.binarySearch(this.fields, var3);
      return var4 < 0 ? null : this.fields[var4];
   }

   public String toString() {
      StringBuffer var1 = new StringBuffer();
      var1.append(this.name);
      var1.append(": static final long serialVersionUID = ");
      var1.append(Long.toString(this.suid));
      var1.append("L;");
      return var1.toString();
   }

   private ObjectStreamClass(Class var1, ObjectStreamClass var2, boolean var3, boolean var4) {
      this.ofClass = var1;
      if (Proxy.isProxyClass(var1)) {
         this.forProxyClass = true;
      }

      this.name = var1.getName();
      this.superclass = var2;
      this.serializable = var3;
      if (!this.forProxyClass) {
         this.externalizable = var4;
      }

      this.hasExternalizableBlockData = true;
      insertDescriptorFor(this);
   }

   private void init() {
      Object var1 = this.lock;
      synchronized(var1) {
         Class var2 = this.ofClass;
         if (this.fields == null) {
            if (this.serializable && !this.externalizable && !this.forProxyClass) {
               if (this.serializable) {
                  AccessController.doPrivileged(new 1(this, var2));
                  if (this.fields.length > 1) {
                     Arrays.sort(this.fields);
                  }

                  this.computeFieldInfo();
               }
            } else {
               this.fields = NO_FIELDS;
            }

            if (this.isNonSerializable()) {
               this.suid = 0L;
            } else {
               AccessController.doPrivileged(new 2(this, var2));
            }

         }
      }
   }

   ObjectStreamClass(String var1, long var2) {
      this.name = var1;
      this.suid = var2;
      this.superclass = null;
   }

   private void validateLocalClass(Class var1) throws InvalidClassException {
      if (this.localClassDesc == null) {
         throw new InvalidClassException(var1.getName(), "Local class not compatible");
      } else {
         if (this.suid != this.localClassDesc.suid) {
            boolean var2 = this.isNonSerializable() || this.localClassDesc.isNonSerializable();
            boolean var3 = var1.isArray() && !var1.getName().equals(this.name);
            if (!var3 && !var2) {
               throw new InvalidClassException(var1.getName(), "Local class not compatible: stream classdesc serialVersionUID=" + this.suid + " local class serialVersionUID=" + this.localClassDesc.suid);
            }
         }

         if (!compareClassNames(this.name, var1.getName(), '.')) {
            throw new InvalidClassException(var1.getName(), "Incompatible local class name. Expected class name compatible with " + this.name);
         } else if (this.serializable && this.localClassDesc.externalizable || this.externalizable && this.localClassDesc.serializable) {
            throw new InvalidClassException(var1.getName(), "Serializable is incompatible with Externalizable");
         }
      }
   }

   void setClass(Class var1) throws InvalidClassException {
      if (var1 == null) {
         this.localClassDesc = null;
         this.ofClass = null;
         this.computeFieldInfo();
      } else {
         this.localClassDesc = lookupInternal(var1);
         this.validateLocalClass(var1);
         if (this.serializable == this.localClassDesc.serializable && this.externalizable == this.localClassDesc.externalizable && (this.serializable || this.externalizable)) {
            ObjectStreamField[] var2 = this.localClassDesc.fields;
            ObjectStreamField[] var3 = this.fields;
            int var4 = 0;

            for(int var5 = 0; var5 < var3.length; ++var5) {
               for(int var6 = var4; var6 < var2.length; ++var6) {
                  if (var3[var5].getName().equals(var2[var6].getName())) {
                     if (var3[var5].isPrimitive() && !var3[var5].typeEquals(var2[var6])) {
                        throw new InvalidClassException(var1.getName(), "The type of field " + var2[var5].getName() + " of class " + this.name + " is incompatible.");
                     }

                     var4 = var6;
                     var3[var5].setField(var2[var6].getField());
                     break;
                  }
               }
            }

            this.ofClass = var1;
            this.computeFieldInfo();
            this.readObjectMethod = this.localClassDesc.readObjectMethod;
            this.readResolveMethod = this.localClassDesc.readResolveMethod;
         } else {
            this.disableInstanceDeserialization = true;
            this.ofClass = var1;
         }
      }
   }

   static boolean compareClassNames(String var0, String var1, char var2) {
      int var3 = var0.lastIndexOf(var2);
      if (var3 < 0) {
         var3 = 0;
      }

      int var4 = var1.lastIndexOf(var2);
      if (var4 < 0) {
         var4 = 0;
      }

      return var0.regionMatches(false, var3, var1, var4, var0.length() - var3);
   }

   boolean typeEquals(ObjectStreamClass var1) {
      return this.suid == var1.suid && compareClassNames(this.name, var1.name, '.');
   }

   void setSuperclass(ObjectStreamClass var1) {
      this.superclass = var1;
   }

   ObjectStreamClass getSuperclass() {
      return this.superclass;
   }

   boolean hasWriteObject() {
      return this.hasWriteObjectMethod;
   }

   boolean hasExternalizableBlockDataMode() {
      return this.hasExternalizableBlockData;
   }

   ObjectStreamClass localClassDescriptor() {
      return this.localClassDesc;
   }

   boolean isSerializable() {
      return this.serializable;
   }

   boolean isExternalizable() {
      return this.externalizable;
   }

   boolean isNonSerializable() {
      return !this.externalizable && !this.serializable;
   }

   private void computeFieldInfo() {
      this.numPrimBytes = 0;
      this.numObjFields = 0;

      for(int var1 = 0; var1 < this.fields.length; ++var1) {
         switch (this.fields[var1].getTypeCode()) {
            case 'B':
            case 'Z':
               this.fields[var1].setOffset(this.numPrimBytes);
               ++this.numPrimBytes;
               break;
            case 'C':
            case 'S':
               this.fields[var1].setOffset(this.numPrimBytes);
               this.numPrimBytes += 2;
               break;
            case 'D':
            case 'J':
               this.fields[var1].setOffset(this.numPrimBytes);
               this.numPrimBytes += 8;
            case 'E':
            case 'G':
            case 'H':
            case 'K':
            case 'M':
            case 'N':
            case 'O':
            case 'P':
            case 'Q':
            case 'R':
            case 'T':
            case 'U':
            case 'V':
            case 'W':
            case 'X':
            case 'Y':
            default:
               break;
            case 'F':
            case 'I':
               this.fields[var1].setOffset(this.numPrimBytes);
               this.numPrimBytes += 4;
               break;
            case 'L':
            case '[':
               this.fields[var1].setOffset(this.numObjFields);
               ++this.numObjFields;
         }
      }

      if (this.ofClass != null) {
         int var2 = this.fields.length - this.numObjFields;
         if (var2 > 0) {
            this.primFieldIDs = new long[var2];
            this.primFieldTypecodes = new char[var2];
         }

         if (this.numObjFields > 0) {
            this.objFieldIDs = new long[this.numObjFields];
            this.objFieldTypes = new Class[this.numObjFields];
         }

         getFieldIDs(this.fields, this.primFieldIDs, this.objFieldIDs);
         int var3 = 0;
         int var4 = 0;

         try {
            for(int var5 = 0; var5 < this.fields.length; ++var5) {
               char var6 = this.fields[var5].getTypeCode();
               switch (var6) {
                  case 'L':
                  case '[':
                     Field var7 = this.fields[var5].getField();
                     this.objFieldTypes[var3++] = var7 != null ? var7.getType() : null;
                     break;
                  default:
                     this.primFieldTypecodes[var4++] = var6;
               }
            }
         } catch (ArrayIndexOutOfBoundsException var8) {
            throw new InternalError("field count mismatch for class " + this.ofClass.getName());
         }

         if (var3 != this.numObjFields || var4 != var2) {
            throw new InternalError("field count mismatch for class " + this.ofClass.getName());
         }
      }

   }

   private static long computeSerialVersionUID(Class var0) {
      ByteArrayOutputStream var1 = new ByteArrayOutputStream(512);
      long var2 = 0L;

      try {
         MessageDigest var4 = MessageDigest.getInstance("SHA");
         DigestOutputStream var5 = new DigestOutputStream(var1, var4);
         DataOutputStream var6 = new DataOutputStream(var5);
         var6.writeUTF(var0.getName());
         int var7 = var0.getModifiers();
         var7 &= 1553;
         Method[] var8 = var0.getDeclaredMethods();
         if ((var7 & 512) != 0) {
            var7 &= -1025;
            if (var8.length > 0) {
               var7 |= 1024;
            }
         }

         var6.writeInt(var7);
         if (!var0.isArray()) {
            Class[] var9 = var0.getInterfaces();
            Arrays.sort(var9, compareClassByName);

            for(int var10 = 0; var10 < var9.length; ++var10) {
               var6.writeUTF(var9[var10].getName());
            }
         }

         Field[] var20 = var0.getDeclaredFields();
         Arrays.sort(var20, compareMemberByName);

         for(int var21 = 0; var21 < var20.length; ++var21) {
            Field var11 = var20[var21];
            int var12 = var11.getModifiers();
            if (!Modifier.isPrivate(var12) || !Modifier.isTransient(var12) && !Modifier.isStatic(var12)) {
               var6.writeUTF(var11.getName());
               var6.writeInt(var12);
               var6.writeUTF(getSignature(var11.getType()));
            }
         }

         if (hasStaticInitializer(var0)) {
            var6.writeUTF("<clinit>");
            var6.writeInt(8);
            var6.writeUTF("()V");
         }

         MethodSignature[] var22 = java.io.ObjectStreamClass.MethodSignature.removePrivateAndSort(var0.getDeclaredConstructors());

         for(int var23 = 0; var23 < var22.length; ++var23) {
            MethodSignature var13 = var22[var23];
            String var14 = "<init>";
            String var15 = var13.signature;
            var15 = var15.replace('/', '.');
            var6.writeUTF(var14);
            var6.writeInt(var13.member.getModifiers());
            var6.writeUTF(var15);
         }

         MethodSignature[] var24 = java.io.ObjectStreamClass.MethodSignature.removePrivateAndSort(var8);

         for(int var25 = 0; var25 < var24.length; ++var25) {
            MethodSignature var27 = var24[var25];
            String var16 = var27.signature;
            var16 = var16.replace('/', '.');
            var6.writeUTF(var27.member.getName());
            var6.writeInt(var27.member.getModifiers());
            var6.writeUTF(var16);
         }

         var6.flush();
         byte[] var28 = var4.digest();

         for(int var30 = 0; var30 < Math.min(8, var28.length); ++var30) {
            var2 += (long)(var28[var30] & 255) << var30 * 8;
         }
      } catch (IOException var17) {
         var2 = -1L;
      } catch (NoSuchAlgorithmException var18) {
         throw new SecurityException(((Throwable)var18).getMessage());
      }

      return var2;
   }

   static String getSignature(Class var0) {
      String var1 = null;
      if (var0.isArray()) {
         Class var2 = var0;

         int var3;
         for(var3 = 0; var2.isArray(); var2 = var2.getComponentType()) {
            ++var3;
         }

         StringBuffer var4 = new StringBuffer();

         for(int var5 = 0; var5 < var3; ++var5) {
            var4.append("[");
         }

         var4.append(getSignature(var2));
         var1 = var4.toString();
      } else if (var0.isPrimitive()) {
         if (var0 == Integer.TYPE) {
            var1 = "I";
         } else if (var0 == Byte.TYPE) {
            var1 = "B";
         } else if (var0 == Long.TYPE) {
            var1 = "J";
         } else if (var0 == Float.TYPE) {
            var1 = "F";
         } else if (var0 == Double.TYPE) {
            var1 = "D";
         } else if (var0 == Short.TYPE) {
            var1 = "S";
         } else if (var0 == Character.TYPE) {
            var1 = "C";
         } else if (var0 == Boolean.TYPE) {
            var1 = "Z";
         } else if (var0 == Void.TYPE) {
            var1 = "V";
         }
      } else {
         var1 = "L" + var0.getName().replace('.', '/') + ";";
      }

      return var1;
   }

   static String getSignature(Method var0) {
      StringBuffer var1 = new StringBuffer();
      var1.append("(");
      Class[] var2 = var0.getParameterTypes();

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var1.append(getSignature(var2[var3]));
      }

      var1.append(")");
      var1.append(getSignature(var0.getReturnType()));
      return var1.toString();
   }

   static String getSignature(Constructor var0) {
      StringBuffer var1 = new StringBuffer();
      var1.append("(");
      Class[] var2 = var0.getParameterTypes();

      for(int var3 = 0; var3 < var2.length; ++var3) {
         var1.append(getSignature(var2[var3]));
      }

      var1.append(")V");
      return var1.toString();
   }

   void write(ObjectOutputStream var1) throws IOException {
      int var2 = 0;
      if (this.hasWriteObjectMethod) {
         var2 |= 1;
      }

      if (this.serializable) {
         var2 |= 2;
      }

      if (this.externalizable) {
         var2 |= 4;
         if (!var1.useDeprecatedExternalizableFormat) {
            var2 |= 8;
         }
      }

      var1.writeByte(var2);
      if (this.fields == null) {
         var1.writeShort(0);
      } else {
         var1.writeShort(this.fields.length);

         for(int var3 = 0; var3 < this.fields.length; ++var3) {
            ObjectStreamField var4 = this.fields[var3];
            var1.writeByte(var4.getTypeCode());
            var1.writeUTF(var4.getName());
            if (!var4.isPrimitive()) {
               var1.writeTypeString(var4.getTypeString());
            }
         }

      }
   }

   void read(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      byte var2 = var1.readByte();
      this.serializable = (var2 & 2) != 0;
      this.externalizable = (var2 & 4) != 0;
      this.hasWriteObjectMethod = this.serializable ? (var2 & 1) != 0 : false;
      this.hasExternalizableBlockData = this.externalizable ? (var2 & 8) != 0 : false;
      short var3 = var1.readShort();
      this.fields = new ObjectStreamField[var3];
      boolean var4 = var1.enableResolve;
      var1.enableResolve = false;

      try {
         for(int var5 = 0; var5 < var3; ++var5) {
            char var6 = (char)var1.readByte();
            String var7 = var1.readUTF();
            String var8 = null;
            switch (var6) {
               case 'E':
               case 'G':
               case 'H':
               case 'K':
               case 'M':
               case 'N':
               case 'O':
               case 'P':
               case 'Q':
               case 'R':
               case 'T':
               case 'U':
               case 'V':
               case 'W':
               case 'X':
               case 'Y':
               default:
                  throw new StreamCorruptedException("illegal field descriptor typecode: " + var6);
               case 'L':
               case '[':
                  var8 = (String)var1.readObject();
               case 'B':
               case 'C':
               case 'D':
               case 'F':
               case 'I':
               case 'J':
               case 'S':
               case 'Z':
                  this.fields[var5] = new ObjectStreamField(var7, var6, (Field)null, var8);
            }
         }
      } finally {
         var1.enableResolve = var4;
      }

   }

   void lightCopy(ObjectStreamClass var1) {
      this.name = var1.name;
      this.serializable = var1.serializable;
      this.externalizable = var1.externalizable;
      this.fields = new ObjectStreamField[var1.fields.length];

      for(int var2 = 0; var2 < this.fields.length; ++var2) {
         ObjectStreamField var3 = var1.fields[var2];
         this.fields[var2] = new ObjectStreamField(var3.getName(), var3.getTypeCode(), (Field)null, var3.getTypeString());
      }

      this.suid = var1.suid;
      this.hasWriteObjectMethod = var1.hasWriteObjectMethod;
      this.hasExternalizableBlockData = var1.hasExternalizableBlockData;
   }

   void initProxyClassDesc(Class var1) {
      this.forProxyClass = true;
      if (var1 != null) {
         this.name = var1.getName();
      }

      this.serializable = true;
      this.externalizable = false;
      this.fields = NO_FIELDS;
      this.hasWriteObjectMethod = false;
      this.hasExternalizableBlockData = true;
   }

   void verifyInstanceDeserialization() throws InvalidClassException {
      if (this.disableInstanceDeserialization) {
         String var1 = !this.serializable && !this.externalizable ? this.getName() : this.localClassDesc.getName();
         String var2 = !this.serializable && !this.localClassDesc.serializable ? (!this.externalizable && !this.localClassDesc.externalizable ? "Serializable or Externalizable" : "Externalizable") : "Serializable";
         throw new InvalidClassException(var1, "is not " + var2);
      }
   }

   private static ObjectStreamClass findDescriptorFor(Class var0) {
      int var1 = var0.hashCode();

      ObjectStreamClassEntry var3;
      for(int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length; (var3 = descriptorFor[var2]) != null && ((SoftReference)var3).get() == null; descriptorFor[var2] = var3.next) {
      }

      for(ObjectStreamClassEntry var4 = var3; var3 != null; var3 = var3.next) {
         ObjectStreamClass var5 = (ObjectStreamClass)((SoftReference)var3).get();
         if (var5 == null) {
            var4.next = var3.next;
         } else {
            if (var5.ofClass == var0) {
               return var5;
            }

            var4 = var3;
         }
      }

      return null;
   }

   private static void insertDescriptorFor(ObjectStreamClass var0) {
      if (findDescriptorFor(var0.ofClass) == null) {
         int var1 = var0.ofClass.hashCode();
         int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length;
         ObjectStreamClassEntry var3 = new ObjectStreamClassEntry(var0);
         var3.next = descriptorFor[var2];
         descriptorFor[var2] = var3;
      }
   }

   private static native void initNative();

   private static native void getFieldIDs(ObjectStreamField[] var0, long[] var1, long[] var2);

   private static native boolean hasStaticInitializer(Class var0);

   boolean isResolvable() {
      return this.readResolveMethod != null;
   }

   boolean isReplaceable() {
      return this.writeReplaceMethod != null;
   }

   static Object invokeMethod(Method var0, Object var1, Object[] var2) throws IOException {
      Object var3 = null;

      try {
         var3 = var0.invoke(var1, var2);
         return var3;
      } catch (InvocationTargetException var6) {
         Throwable var5 = var6.getTargetException();
         if (var5 instanceof IOException) {
            throw (IOException)var5;
         } else if (var5 instanceof RuntimeException) {
            throw (RuntimeException)var5;
         } else if (var5 instanceof Error) {
            throw (Error)var5;
         } else {
            throw new Error("interal error");
         }
      } catch (IllegalAccessException var7) {
         throw new Error("interal error");
      }
   }

   private Method getDeclaredMethod(String var1, Class[] var2, int var3, int var4) {
      Method var5 = null;

      try {
         var5 = this.ofClass.getDeclaredMethod(var1, var2);
         if (var5 != null) {
            int var6 = var5.getModifiers();
            if ((var6 & var4) == 0 && (var6 & var3) == var3) {
               ((AccessibleObject)var5).setAccessible(true);
            } else {
               var5 = null;
            }
         }
      } catch (NoSuchMethodException var7) {
      }

      return var5;
   }

   private boolean checkSuperMethodAccess(Method var1) {
      if (var1 == null) {
         return false;
      } else {
         int var2 = var1.getModifiers();
         if (!Modifier.isPublic(var2) && !Modifier.isProtected(var2)) {
            return Modifier.isPrivate(var2) ? false : isSameClassPackage(var1.getDeclaringClass(), this.ofClass);
         } else {
            return true;
         }
      }
   }

   private static boolean isSameClassPackage(Class var0, Class var1) {
      if (var0.getClassLoader() != var1.getClassLoader()) {
         return false;
      } else {
         String var2 = var0.getName();
         String var3 = var1.getName();
         int var4 = var2.lastIndexOf(46);
         int var5 = var3.lastIndexOf(46);
         if (var4 != -1 && var5 != -1) {
            return var2.regionMatches(false, 0, var3, 0, var4 - 1);
         } else {
            return var4 == var5;
         }
      }
   }

   private static void initStaticMethodArgs() {
      OOS_ARGS = new Class[1];
      OOS_ARGS[0] = class$java$io$ObjectOutputStream == null ? (class$java$io$ObjectOutputStream = class$("java.io.ObjectOutputStream")) : class$java$io$ObjectOutputStream;
      OIS_ARGS = new Class[1];
      OIS_ARGS[0] = class$java$io$ObjectInputStream == null ? (class$java$io$ObjectInputStream = class$("java.io.ObjectInputStream")) : class$java$io$ObjectInputStream;
   }

   // $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 ObjectStreamField[] access$002(ObjectStreamClass var0, ObjectStreamField[] var1) {
      return var0.fields = var1;
   }

   // $FF: synthetic method
   static ObjectStreamField[] access$000(ObjectStreamClass var0) {
      return var0.fields;
   }

   // $FF: synthetic method
   static long access$102(ObjectStreamClass var0, long var1) {
      return var0.suid = var1;
   }

   // $FF: synthetic method
   static long access$200(Class var0) {
      return computeSerialVersionUID(var0);
   }

   // $FF: synthetic method
   static Class[] access$300() {
      return NULL_ARGS;
   }

   // $FF: synthetic method
   static Method access$400(ObjectStreamClass var0, String var1, Class[] var2, int var3, int var4) {
      return var0.getDeclaredMethod(var1, var2, var3, var4);
   }

   // $FF: synthetic method
   static boolean access$500(ObjectStreamClass var0, Method var1) {
      return var0.checkSuperMethodAccess(var1);
   }

   // $FF: synthetic method
   static boolean access$600(ObjectStreamClass var0) {
      return var0.serializable;
   }

   // $FF: synthetic method
   static Class[] access$700() {
      return OOS_ARGS;
   }

   // $FF: synthetic method
   static Class[] access$800() {
      return OIS_ARGS;
   }

   // $FF: synthetic method
   static void access$900() {
      initStaticMethodArgs();
   }

   // $FF: synthetic method
   static boolean access$1002(ObjectStreamClass var0, boolean var1) {
      return var0.hasWriteObjectMethod = var1;
   }

   static {
      initNative();
      NO_FIELDS = new ObjectStreamField[0];
      serialPersistentFields = NO_FIELDS;
      compareClassByName = new CompareClassByName((1)null);
      compareMemberByName = new CompareMemberByName((1)null);
      NULL_ARGS = new Class[0];
      OIS_ARGS = null;
      OOS_ARGS = null;
   }
}