home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / io / ObjectStreamClass.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  22.4 KB  |  1,321 lines
  1. package java.io;
  2.  
  3. import java.lang.ref.Reference;
  4. import java.lang.ref.ReferenceQueue;
  5. import java.lang.ref.SoftReference;
  6. import java.lang.ref.WeakReference;
  7. import java.lang.reflect.Constructor;
  8. import java.lang.reflect.Field;
  9. import java.lang.reflect.InvocationTargetException;
  10. import java.lang.reflect.Method;
  11. import java.lang.reflect.Proxy;
  12. import java.security.AccessController;
  13. import java.security.MessageDigest;
  14. import java.security.NoSuchAlgorithmException;
  15. import java.util.ArrayList;
  16. import java.util.Arrays;
  17. import java.util.Collections;
  18. import java.util.HashSet;
  19. import java.util.concurrent.ConcurrentMap;
  20. import sun.reflect.ReflectionFactory;
  21.  
  22. public class ObjectStreamClass implements Serializable {
  23.    public static final ObjectStreamField[] NO_FIELDS = new ObjectStreamField[0];
  24.    private static final long serialVersionUID = -6120832682080437368L;
  25.    private static final ObjectStreamField[] serialPersistentFields;
  26.    private static final ReflectionFactory reflFactory;
  27.    // $FF: renamed from: cl java.lang.Class
  28.    private Class field_0;
  29.    private String name;
  30.    private volatile Long suid;
  31.    private boolean isProxy;
  32.    private boolean isEnum;
  33.    private boolean serializable;
  34.    private boolean externalizable;
  35.    private boolean hasWriteObjectData;
  36.    private boolean hasBlockExternalData = true;
  37.    private ClassNotFoundException resolveEx;
  38.    private InvalidClassException deserializeEx;
  39.    private InvalidClassException serializeEx;
  40.    private InvalidClassException defaultSerializeEx;
  41.    private ObjectStreamField[] fields;
  42.    private int primDataSize;
  43.    private int numObjFields;
  44.    private FieldReflector fieldRefl;
  45.    private volatile ClassDataSlot[] dataLayout;
  46.    private Constructor cons;
  47.    private Method writeObjectMethod;
  48.    private Method readObjectMethod;
  49.    private Method readObjectNoDataMethod;
  50.    private Method writeReplaceMethod;
  51.    private Method readResolveMethod;
  52.    private ObjectStreamClass localDesc;
  53.    private ObjectStreamClass superDesc;
  54.  
  55.    private static native void initNative();
  56.  
  57.    public static ObjectStreamClass lookup(Class<?> var0) {
  58.       return lookup(var0, false);
  59.    }
  60.  
  61.    public static ObjectStreamClass lookupAny(Class<?> var0) {
  62.       return lookup(var0, true);
  63.    }
  64.  
  65.    public String getName() {
  66.       return this.name;
  67.    }
  68.  
  69.    public long getSerialVersionUID() {
  70.       if (this.suid == null) {
  71.          this.suid = (Long)AccessController.doPrivileged(new 1(this));
  72.       }
  73.  
  74.       return this.suid;
  75.    }
  76.  
  77.    public Class<?> forClass() {
  78.       return this.field_0;
  79.    }
  80.  
  81.    public ObjectStreamField[] getFields() {
  82.       return this.getFields(true);
  83.    }
  84.  
  85.    public ObjectStreamField getField(String var1) {
  86.       return this.getField(var1, (Class)null);
  87.    }
  88.  
  89.    public String toString() {
  90.       return this.name + ": static final long serialVersionUID = " + this.getSerialVersionUID() + "L;";
  91.    }
  92.  
  93.    static ObjectStreamClass lookup(Class var0, boolean var1) {
  94.       if (!var1 && !Serializable.class.isAssignableFrom(var0)) {
  95.          return null;
  96.       } else {
  97.          processQueue(java.io.ObjectStreamClass.Caches.access$200(), java.io.ObjectStreamClass.Caches.localDescs);
  98.          WeakClassKey var2 = new WeakClassKey(var0, java.io.ObjectStreamClass.Caches.access$200());
  99.          Reference var3 = (Reference)java.io.ObjectStreamClass.Caches.localDescs.get(var2);
  100.          Object var4 = null;
  101.          if (var3 != null) {
  102.             var4 = var3.get();
  103.          }
  104.  
  105.          EntryFuture var5 = null;
  106.          if (var4 == null) {
  107.             EntryFuture var6 = new EntryFuture((1)null);
  108.             SoftReference var7 = new SoftReference(var6);
  109.  
  110.             do {
  111.                if (var3 != null) {
  112.                   java.io.ObjectStreamClass.Caches.localDescs.remove(var2, var3);
  113.                }
  114.  
  115.                var3 = (Reference)java.io.ObjectStreamClass.Caches.localDescs.putIfAbsent(var2, var7);
  116.                if (var3 != null) {
  117.                   var4 = var3.get();
  118.                }
  119.             } while(var3 != null && var4 == null);
  120.  
  121.             if (var4 == null) {
  122.                var5 = var6;
  123.             }
  124.          }
  125.  
  126.          if (var4 instanceof ObjectStreamClass) {
  127.             return (ObjectStreamClass)var4;
  128.          } else {
  129.             if (var4 instanceof EntryFuture) {
  130.                var5 = (EntryFuture)var4;
  131.                if (var5.getOwner() == Thread.currentThread()) {
  132.                   var4 = null;
  133.                } else {
  134.                   var4 = var5.get();
  135.                }
  136.             }
  137.  
  138.             if (var4 == null) {
  139.                try {
  140.                   var4 = new ObjectStreamClass(var0);
  141.                } catch (Throwable var8) {
  142.                   var4 = var8;
  143.                }
  144.  
  145.                if (var5.set(var4)) {
  146.                   java.io.ObjectStreamClass.Caches.localDescs.put(var2, new SoftReference(var4));
  147.                } else {
  148.                   var4 = var5.get();
  149.                }
  150.             }
  151.  
  152.             if (var4 instanceof ObjectStreamClass) {
  153.                return (ObjectStreamClass)var4;
  154.             } else if (var4 instanceof RuntimeException) {
  155.                throw (RuntimeException)var4;
  156.             } else if (var4 instanceof Error) {
  157.                throw (Error)var4;
  158.             } else {
  159.                throw new InternalError("unexpected entry: " + var4);
  160.             }
  161.          }
  162.       }
  163.    }
  164.  
  165.    private ObjectStreamClass(Class var1) {
  166.       this.field_0 = var1;
  167.       this.name = var1.getName();
  168.       this.isProxy = Proxy.isProxyClass(var1);
  169.       this.isEnum = Enum.class.isAssignableFrom(var1);
  170.       this.serializable = Serializable.class.isAssignableFrom(var1);
  171.       this.externalizable = Externalizable.class.isAssignableFrom(var1);
  172.       Class var2 = var1.getSuperclass();
  173.       this.superDesc = var2 != null ? lookup(var2, false) : null;
  174.       this.localDesc = this;
  175.       if (this.serializable) {
  176.          AccessController.doPrivileged(new 2(this, var1));
  177.       } else {
  178.          this.suid = 0L;
  179.          this.fields = NO_FIELDS;
  180.       }
  181.  
  182.       try {
  183.          this.fieldRefl = getReflector(this.fields, this);
  184.       } catch (InvalidClassException var4) {
  185.          throw new InternalError();
  186.       }
  187.  
  188.       if (this.deserializeEx == null) {
  189.          if (this.isEnum) {
  190.             this.deserializeEx = new InvalidClassException(this.name, "enum type");
  191.          } else if (this.cons == null) {
  192.             this.deserializeEx = new InvalidClassException(this.name, "no valid constructor");
  193.          }
  194.       }
  195.  
  196.       for(int var3 = 0; var3 < this.fields.length; ++var3) {
  197.          if (this.fields[var3].getField() == null) {
  198.             this.defaultSerializeEx = new InvalidClassException(this.name, "unmatched serializable field(s) declared");
  199.          }
  200.       }
  201.  
  202.    }
  203.  
  204.    ObjectStreamClass() {
  205.    }
  206.  
  207.    void initProxy(Class var1, ClassNotFoundException var2, ObjectStreamClass var3) throws InvalidClassException {
  208.       this.field_0 = var1;
  209.       this.resolveEx = var2;
  210.       this.superDesc = var3;
  211.       this.isProxy = true;
  212.       this.serializable = true;
  213.       this.suid = 0L;
  214.       this.fields = NO_FIELDS;
  215.       if (var1 != null) {
  216.          this.localDesc = lookup(var1, true);
  217.          if (!this.localDesc.isProxy) {
  218.             throw new InvalidClassException("cannot bind proxy descriptor to a non-proxy class");
  219.          }
  220.  
  221.          this.name = this.localDesc.name;
  222.          this.externalizable = this.localDesc.externalizable;
  223.          this.cons = this.localDesc.cons;
  224.          this.writeReplaceMethod = this.localDesc.writeReplaceMethod;
  225.          this.readResolveMethod = this.localDesc.readResolveMethod;
  226.          this.deserializeEx = this.localDesc.deserializeEx;
  227.       }
  228.  
  229.       this.fieldRefl = getReflector(this.fields, this.localDesc);
  230.    }
  231.  
  232.    void initNonProxy(ObjectStreamClass var1, Class var2, ClassNotFoundException var3, ObjectStreamClass var4) throws InvalidClassException {
  233.       this.field_0 = var2;
  234.       this.resolveEx = var3;
  235.       this.superDesc = var4;
  236.       this.name = var1.name;
  237.       this.suid = var1.getSerialVersionUID();
  238.       this.isProxy = false;
  239.       this.isEnum = var1.isEnum;
  240.       this.serializable = var1.serializable;
  241.       this.externalizable = var1.externalizable;
  242.       this.hasBlockExternalData = var1.hasBlockExternalData;
  243.       this.hasWriteObjectData = var1.hasWriteObjectData;
  244.       this.fields = var1.fields;
  245.       this.primDataSize = var1.primDataSize;
  246.       this.numObjFields = var1.numObjFields;
  247.       if (var2 != null) {
  248.          this.localDesc = lookup(var2, true);
  249.          if (this.localDesc.isProxy) {
  250.             throw new InvalidClassException("cannot bind non-proxy descriptor to a proxy class");
  251.          }
  252.  
  253.          if (this.isEnum != this.localDesc.isEnum) {
  254.             throw new InvalidClassException(this.isEnum ? "cannot bind enum descriptor to a non-enum class" : "cannot bind non-enum descriptor to an enum class");
  255.          }
  256.  
  257.          if (this.serializable == this.localDesc.serializable && !var2.isArray() && this.suid != this.localDesc.getSerialVersionUID()) {
  258.             throw new InvalidClassException(this.localDesc.name, "local class incompatible: stream classdesc serialVersionUID = " + this.suid + ", local class serialVersionUID = " + this.localDesc.getSerialVersionUID());
  259.          }
  260.  
  261.          if (!classNamesEqual(this.name, this.localDesc.name)) {
  262.             throw new InvalidClassException(this.localDesc.name, "local class name incompatible with stream class name \"" + this.name + "\"");
  263.          }
  264.  
  265.          if (!this.isEnum) {
  266.             if (this.serializable == this.localDesc.serializable && this.externalizable != this.localDesc.externalizable) {
  267.                throw new InvalidClassException(this.localDesc.name, "Serializable incompatible with Externalizable");
  268.             }
  269.  
  270.             if (this.serializable != this.localDesc.serializable || this.externalizable != this.localDesc.externalizable || !this.serializable && !this.externalizable) {
  271.                this.deserializeEx = new InvalidClassException(this.localDesc.name, "class invalid for deserialization");
  272.             }
  273.          }
  274.  
  275.          this.cons = this.localDesc.cons;
  276.          this.writeObjectMethod = this.localDesc.writeObjectMethod;
  277.          this.readObjectMethod = this.localDesc.readObjectMethod;
  278.          this.readObjectNoDataMethod = this.localDesc.readObjectNoDataMethod;
  279.          this.writeReplaceMethod = this.localDesc.writeReplaceMethod;
  280.          this.readResolveMethod = this.localDesc.readResolveMethod;
  281.          if (this.deserializeEx == null) {
  282.             this.deserializeEx = this.localDesc.deserializeEx;
  283.          }
  284.       }
  285.  
  286.       this.fieldRefl = getReflector(this.fields, this.localDesc);
  287.       this.fields = this.fieldRefl.getFields();
  288.    }
  289.  
  290.    void readNonProxy(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  291.       this.name = var1.readUTF();
  292.       this.suid = var1.readLong();
  293.       this.isProxy = false;
  294.       byte var2 = var1.readByte();
  295.       this.hasWriteObjectData = (var2 & 1) != 0;
  296.       this.hasBlockExternalData = (var2 & 8) != 0;
  297.       this.externalizable = (var2 & 4) != 0;
  298.       boolean var3 = (var2 & 2) != 0;
  299.       if (this.externalizable && var3) {
  300.          throw new InvalidClassException(this.name, "serializable and externalizable flags conflict");
  301.       } else {
  302.          this.serializable = this.externalizable || var3;
  303.          this.isEnum = (var2 & 16) != 0;
  304.          if (this.isEnum && this.suid != 0L) {
  305.             throw new InvalidClassException(this.name, "enum descriptor has non-zero serialVersionUID: " + this.suid);
  306.          } else {
  307.             short var4 = var1.readShort();
  308.             if (this.isEnum && var4 != 0) {
  309.                throw new InvalidClassException(this.name, "enum descriptor has non-zero field count: " + var4);
  310.             } else {
  311.                this.fields = var4 > 0 ? new ObjectStreamField[var4] : NO_FIELDS;
  312.  
  313.                for(int var5 = 0; var5 < var4; ++var5) {
  314.                   char var6 = (char)var1.readByte();
  315.                   String var7 = var1.readUTF();
  316.                   String var8 = var6 != 'L' && var6 != '[' ? new String(new char[]{var6}) : var1.readTypeString();
  317.  
  318.                   try {
  319.                      this.fields[var5] = new ObjectStreamField(var7, var8, false);
  320.                   } catch (RuntimeException var10) {
  321.                      throw (IOException)(new InvalidClassException(this.name, "invalid descriptor for field " + var7)).initCause(var10);
  322.                   }
  323.                }
  324.  
  325.                this.computeFieldOffsets();
  326.             }
  327.          }
  328.       }
  329.    }
  330.  
  331.    void writeNonProxy(ObjectOutputStream var1) throws IOException {
  332.       var1.writeUTF(this.name);
  333.       var1.writeLong(this.getSerialVersionUID());
  334.       byte var2 = 0;
  335.       if (this.externalizable) {
  336.          var2 = (byte)(var2 | 4);
  337.          int var3 = var1.getProtocolVersion();
  338.          if (var3 != 1) {
  339.             var2 = (byte)(var2 | 8);
  340.          }
  341.       } else if (this.serializable) {
  342.          var2 = (byte)(var2 | 2);
  343.       }
  344.  
  345.       if (this.hasWriteObjectData) {
  346.          var2 = (byte)(var2 | 1);
  347.       }
  348.  
  349.       if (this.isEnum) {
  350.          var2 = (byte)(var2 | 16);
  351.       }
  352.  
  353.       var1.writeByte(var2);
  354.       var1.writeShort(this.fields.length);
  355.  
  356.       for(int var5 = 0; var5 < this.fields.length; ++var5) {
  357.          ObjectStreamField var4 = this.fields[var5];
  358.          var1.writeByte(var4.getTypeCode());
  359.          var1.writeUTF(var4.getName());
  360.          if (!var4.isPrimitive()) {
  361.             var1.writeTypeString(var4.getTypeString());
  362.          }
  363.       }
  364.  
  365.    }
  366.  
  367.    ClassNotFoundException getResolveException() {
  368.       return this.resolveEx;
  369.    }
  370.  
  371.    void checkDeserialize() throws InvalidClassException {
  372.       if (this.deserializeEx != null) {
  373.          InvalidClassException var1 = new InvalidClassException(this.deserializeEx.classname, this.deserializeEx.getMessage());
  374.          var1.initCause(this.deserializeEx);
  375.          throw var1;
  376.       }
  377.    }
  378.  
  379.    void checkSerialize() throws InvalidClassException {
  380.       if (this.serializeEx != null) {
  381.          InvalidClassException var1 = new InvalidClassException(this.serializeEx.classname, this.serializeEx.getMessage());
  382.          var1.initCause(this.serializeEx);
  383.          throw var1;
  384.       }
  385.    }
  386.  
  387.    void checkDefaultSerialize() throws InvalidClassException {
  388.       if (this.defaultSerializeEx != null) {
  389.          InvalidClassException var1 = new InvalidClassException(this.defaultSerializeEx.classname, this.defaultSerializeEx.getMessage());
  390.          var1.initCause(this.defaultSerializeEx);
  391.          throw var1;
  392.       }
  393.    }
  394.  
  395.    ObjectStreamClass getSuperDesc() {
  396.       return this.superDesc;
  397.    }
  398.  
  399.    ObjectStreamClass getLocalDesc() {
  400.       return this.localDesc;
  401.    }
  402.  
  403.    ObjectStreamField[] getFields(boolean var1) {
  404.       return var1 ? (ObjectStreamField[])((ObjectStreamField[])this.fields.clone()) : this.fields;
  405.    }
  406.  
  407.    ObjectStreamField getField(String var1, Class var2) {
  408.       for(int var3 = 0; var3 < this.fields.length; ++var3) {
  409.          ObjectStreamField var4 = this.fields[var3];
  410.          if (var4.getName().equals(var1)) {
  411.             if (var2 == null || var2 == Object.class && !var4.isPrimitive()) {
  412.                return var4;
  413.             }
  414.  
  415.             Class var5 = var4.getType();
  416.             if (var5 != null && var2.isAssignableFrom(var5)) {
  417.                return var4;
  418.             }
  419.          }
  420.       }
  421.  
  422.       return null;
  423.    }
  424.  
  425.    boolean isProxy() {
  426.       return this.isProxy;
  427.    }
  428.  
  429.    boolean isEnum() {
  430.       return this.isEnum;
  431.    }
  432.  
  433.    boolean isExternalizable() {
  434.       return this.externalizable;
  435.    }
  436.  
  437.    boolean isSerializable() {
  438.       return this.serializable;
  439.    }
  440.  
  441.    boolean hasBlockExternalData() {
  442.       return this.hasBlockExternalData;
  443.    }
  444.  
  445.    boolean hasWriteObjectData() {
  446.       return this.hasWriteObjectData;
  447.    }
  448.  
  449.    boolean isInstantiable() {
  450.       return this.cons != null;
  451.    }
  452.  
  453.    boolean hasWriteObjectMethod() {
  454.       return this.writeObjectMethod != null;
  455.    }
  456.  
  457.    boolean hasReadObjectMethod() {
  458.       return this.readObjectMethod != null;
  459.    }
  460.  
  461.    boolean hasReadObjectNoDataMethod() {
  462.       return this.readObjectNoDataMethod != null;
  463.    }
  464.  
  465.    boolean hasWriteReplaceMethod() {
  466.       return this.writeReplaceMethod != null;
  467.    }
  468.  
  469.    boolean hasReadResolveMethod() {
  470.       return this.readResolveMethod != null;
  471.    }
  472.  
  473.    Object newInstance() throws InstantiationException, InvocationTargetException, UnsupportedOperationException {
  474.       if (this.cons != null) {
  475.          try {
  476.             return this.cons.newInstance();
  477.          } catch (IllegalAccessException var2) {
  478.             throw new InternalError();
  479.          }
  480.       } else {
  481.          throw new UnsupportedOperationException();
  482.       }
  483.    }
  484.  
  485.    void invokeWriteObject(Object var1, ObjectOutputStream var2) throws IOException, UnsupportedOperationException {
  486.       if (this.writeObjectMethod != null) {
  487.          try {
  488.             this.writeObjectMethod.invoke(var1, var2);
  489.          } catch (InvocationTargetException var5) {
  490.             Throwable var4 = var5.getTargetException();
  491.             if (var4 instanceof IOException) {
  492.                throw (IOException)var4;
  493.             }
  494.  
  495.             throwMiscException(var4);
  496.          } catch (IllegalAccessException var6) {
  497.             throw new InternalError();
  498.          }
  499.  
  500.       } else {
  501.          throw new UnsupportedOperationException();
  502.       }
  503.    }
  504.  
  505.    void invokeReadObject(Object var1, ObjectInputStream var2) throws ClassNotFoundException, IOException, UnsupportedOperationException {
  506.       if (this.readObjectMethod != null) {
  507.          try {
  508.             this.readObjectMethod.invoke(var1, var2);
  509.          } catch (InvocationTargetException var5) {
  510.             Throwable var4 = var5.getTargetException();
  511.             if (var4 instanceof ClassNotFoundException) {
  512.                throw (ClassNotFoundException)var4;
  513.             }
  514.  
  515.             if (var4 instanceof IOException) {
  516.                throw (IOException)var4;
  517.             }
  518.  
  519.             throwMiscException(var4);
  520.          } catch (IllegalAccessException var6) {
  521.             throw new InternalError();
  522.          }
  523.  
  524.       } else {
  525.          throw new UnsupportedOperationException();
  526.       }
  527.    }
  528.  
  529.    void invokeReadObjectNoData(Object var1) throws IOException, UnsupportedOperationException {
  530.       if (this.readObjectNoDataMethod != null) {
  531.          try {
  532.             this.readObjectNoDataMethod.invoke(var1, (Object[])null);
  533.          } catch (InvocationTargetException var4) {
  534.             Throwable var3 = var4.getTargetException();
  535.             if (var3 instanceof ObjectStreamException) {
  536.                throw (ObjectStreamException)var3;
  537.             }
  538.  
  539.             throwMiscException(var3);
  540.          } catch (IllegalAccessException var5) {
  541.             throw new InternalError();
  542.          }
  543.  
  544.       } else {
  545.          throw new UnsupportedOperationException();
  546.       }
  547.    }
  548.  
  549.    Object invokeWriteReplace(Object var1) throws IOException, UnsupportedOperationException {
  550.       if (this.writeReplaceMethod != null) {
  551.          try {
  552.             return this.writeReplaceMethod.invoke(var1, (Object[])null);
  553.          } catch (InvocationTargetException var4) {
  554.             Throwable var3 = var4.getTargetException();
  555.             if (var3 instanceof ObjectStreamException) {
  556.                throw (ObjectStreamException)var3;
  557.             } else {
  558.                throwMiscException(var3);
  559.                throw new InternalError();
  560.             }
  561.          } catch (IllegalAccessException var5) {
  562.             throw new InternalError();
  563.          }
  564.       } else {
  565.          throw new UnsupportedOperationException();
  566.       }
  567.    }
  568.  
  569.    Object invokeReadResolve(Object var1) throws IOException, UnsupportedOperationException {
  570.       if (this.readResolveMethod != null) {
  571.          try {
  572.             return this.readResolveMethod.invoke(var1, (Object[])null);
  573.          } catch (InvocationTargetException var4) {
  574.             Throwable var3 = var4.getTargetException();
  575.             if (var3 instanceof ObjectStreamException) {
  576.                throw (ObjectStreamException)var3;
  577.             } else {
  578.                throwMiscException(var3);
  579.                throw new InternalError();
  580.             }
  581.          } catch (IllegalAccessException var5) {
  582.             throw new InternalError();
  583.          }
  584.       } else {
  585.          throw new UnsupportedOperationException();
  586.       }
  587.    }
  588.  
  589.    ClassDataSlot[] getClassDataLayout() throws InvalidClassException {
  590.       if (this.dataLayout == null) {
  591.          this.dataLayout = this.getClassDataLayout0();
  592.       }
  593.  
  594.       return this.dataLayout;
  595.    }
  596.  
  597.    private ClassDataSlot[] getClassDataLayout0() throws InvalidClassException {
  598.       ArrayList var1 = new ArrayList();
  599.       Class var2 = this.field_0;
  600.  
  601.       Class var3;
  602.       for(var3 = this.field_0; var3 != null && Serializable.class.isAssignableFrom(var3); var3 = var3.getSuperclass()) {
  603.       }
  604.  
  605.       for(ObjectStreamClass var4 = this; var4 != null; var4 = var4.superDesc) {
  606.          String var5 = var4.field_0 != null ? var4.field_0.getName() : var4.name;
  607.          Class var6 = null;
  608.  
  609.          for(Class var7 = var2; var7 != var3; var7 = var7.getSuperclass()) {
  610.             if (var5.equals(var7.getName())) {
  611.                var6 = var7;
  612.                break;
  613.             }
  614.          }
  615.  
  616.          if (var6 != null) {
  617.             for(Class var9 = var2; var9 != var6; var9 = var9.getSuperclass()) {
  618.                var1.add(new ClassDataSlot(lookup(var9, true), false));
  619.             }
  620.  
  621.             var2 = var6.getSuperclass();
  622.          }
  623.  
  624.          var1.add(new ClassDataSlot(var4.getVariantFor(var6), true));
  625.       }
  626.  
  627.       for(Class var8 = var2; var8 != var3; var8 = var8.getSuperclass()) {
  628.          var1.add(new ClassDataSlot(lookup(var8, true), false));
  629.       }
  630.  
  631.       Collections.reverse(var1);
  632.       return (ClassDataSlot[])var1.toArray(new ClassDataSlot[var1.size()]);
  633.    }
  634.  
  635.    int getPrimDataSize() {
  636.       return this.primDataSize;
  637.    }
  638.  
  639.    int getNumObjFields() {
  640.       return this.numObjFields;
  641.    }
  642.  
  643.    void getPrimFieldValues(Object var1, byte[] var2) {
  644.       this.fieldRefl.getPrimFieldValues(var1, var2);
  645.    }
  646.  
  647.    void setPrimFieldValues(Object var1, byte[] var2) {
  648.       this.fieldRefl.setPrimFieldValues(var1, var2);
  649.    }
  650.  
  651.    void getObjFieldValues(Object var1, Object[] var2) {
  652.       this.fieldRefl.getObjFieldValues(var1, var2);
  653.    }
  654.  
  655.    void setObjFieldValues(Object var1, Object[] var2) {
  656.       this.fieldRefl.setObjFieldValues(var1, var2);
  657.    }
  658.  
  659.    private void computeFieldOffsets() throws InvalidClassException {
  660.       this.primDataSize = 0;
  661.       this.numObjFields = 0;
  662.       int var1 = -1;
  663.  
  664.       for(int var2 = 0; var2 < this.fields.length; ++var2) {
  665.          ObjectStreamField var3 = this.fields[var2];
  666.          switch (var3.getTypeCode()) {
  667.             case 'B':
  668.             case 'Z':
  669.                var3.setOffset(this.primDataSize++);
  670.                break;
  671.             case 'C':
  672.             case 'S':
  673.                var3.setOffset(this.primDataSize);
  674.                this.primDataSize += 2;
  675.                break;
  676.             case 'D':
  677.             case 'J':
  678.                var3.setOffset(this.primDataSize);
  679.                this.primDataSize += 8;
  680.                break;
  681.             case 'E':
  682.             case 'G':
  683.             case 'H':
  684.             case 'K':
  685.             case 'M':
  686.             case 'N':
  687.             case 'O':
  688.             case 'P':
  689.             case 'Q':
  690.             case 'R':
  691.             case 'T':
  692.             case 'U':
  693.             case 'V':
  694.             case 'W':
  695.             case 'X':
  696.             case 'Y':
  697.             default:
  698.                throw new InternalError();
  699.             case 'F':
  700.             case 'I':
  701.                var3.setOffset(this.primDataSize);
  702.                this.primDataSize += 4;
  703.                break;
  704.             case 'L':
  705.             case '[':
  706.                var3.setOffset(this.numObjFields++);
  707.                if (var1 == -1) {
  708.                   var1 = var2;
  709.                }
  710.          }
  711.       }
  712.  
  713.       if (var1 != -1 && var1 + this.numObjFields != this.fields.length) {
  714.          throw new InvalidClassException(this.name, "illegal field order");
  715.       }
  716.    }
  717.  
  718.    private ObjectStreamClass getVariantFor(Class var1) throws InvalidClassException {
  719.       if (this.field_0 == var1) {
  720.          return this;
  721.       } else {
  722.          ObjectStreamClass var2 = new ObjectStreamClass();
  723.          if (this.isProxy) {
  724.             var2.initProxy(var1, (ClassNotFoundException)null, this.superDesc);
  725.          } else {
  726.             var2.initNonProxy(this, var1, (ClassNotFoundException)null, this.superDesc);
  727.          }
  728.  
  729.          return var2;
  730.       }
  731.    }
  732.  
  733.    private static Constructor getExternalizableConstructor(Class var0) {
  734.       try {
  735.          Constructor var1 = var0.getDeclaredConstructor((Class[])null);
  736.          var1.setAccessible(true);
  737.          return (var1.getModifiers() & 1) != 0 ? var1 : null;
  738.       } catch (NoSuchMethodException var2) {
  739.          return null;
  740.       }
  741.    }
  742.  
  743.    private static Constructor getSerializableConstructor(Class var0) {
  744.       Class var1 = var0;
  745.  
  746.       while(Serializable.class.isAssignableFrom(var1)) {
  747.          if ((var1 = var1.getSuperclass()) == null) {
  748.             return null;
  749.          }
  750.       }
  751.  
  752.       try {
  753.          Constructor var2 = var1.getDeclaredConstructor((Class[])null);
  754.          int var3 = var2.getModifiers();
  755.          if ((var3 & 2) == 0 && ((var3 & 5) != 0 || packageEquals(var0, var1))) {
  756.             var2 = reflFactory.newConstructorForSerialization(var0, var2);
  757.             var2.setAccessible(true);
  758.             return var2;
  759.          } else {
  760.             return null;
  761.          }
  762.       } catch (NoSuchMethodException var4) {
  763.          return null;
  764.       }
  765.    }
  766.  
  767.    private static Method getInheritableMethod(Class var0, String var1, Class[] var2, Class var3) {
  768.       Method var4 = null;
  769.  
  770.       Class var5;
  771.       for(var5 = var0; var5 != null; var5 = var5.getSuperclass()) {
  772.          try {
  773.             var4 = var5.getDeclaredMethod(var1, var2);
  774.             break;
  775.          }
  776.       }
  777.  
  778.       if (var4 != null && var4.getReturnType() == var3) {
  779.          var4.setAccessible(true);
  780.          int var6 = var4.getModifiers();
  781.          if ((var6 & 1032) != 0) {
  782.             return null;
  783.          } else if ((var6 & 5) != 0) {
  784.             return var4;
  785.          } else if ((var6 & 2) != 0) {
  786.             return var0 == var5 ? var4 : null;
  787.          } else {
  788.             return packageEquals(var0, var5) ? var4 : null;
  789.          }
  790.       } else {
  791.          return null;
  792.       }
  793.    }
  794.  
  795.    private static Method getPrivateMethod(Class var0, String var1, Class[] var2, Class var3) {
  796.       try {
  797.          Method var4 = var0.getDeclaredMethod(var1, var2);
  798.          var4.setAccessible(true);
  799.          int var5 = var4.getModifiers();
  800.          return var4.getReturnType() == var3 && (var5 & 8) == 0 && (var5 & 2) != 0 ? var4 : null;
  801.       } catch (NoSuchMethodException var6) {
  802.          return null;
  803.       }
  804.    }
  805.  
  806.    private static boolean packageEquals(Class var0, Class var1) {
  807.       return var0.getClassLoader() == var1.getClassLoader() && getPackageName(var0).equals(getPackageName(var1));
  808.    }
  809.  
  810.    private static String getPackageName(Class var0) {
  811.       String var1 = var0.getName();
  812.       int var2 = var1.lastIndexOf(91);
  813.       if (var2 >= 0) {
  814.          var1 = var1.substring(var2 + 2);
  815.       }
  816.  
  817.       var2 = var1.lastIndexOf(46);
  818.       return var2 >= 0 ? var1.substring(0, var2) : "";
  819.    }
  820.  
  821.    private static boolean classNamesEqual(String var0, String var1) {
  822.       var0 = var0.substring(var0.lastIndexOf(46) + 1);
  823.       var1 = var1.substring(var1.lastIndexOf(46) + 1);
  824.       return var0.equals(var1);
  825.    }
  826.  
  827.    static String getClassSignature(Class var0) {
  828.       StringBuilder var1;
  829.       for(var1 = new StringBuilder(); var0.isArray(); var0 = var0.getComponentType()) {
  830.          var1.append('[');
  831.       }
  832.  
  833.       if (var0.isPrimitive()) {
  834.          if (var0 == Integer.TYPE) {
  835.             var1.append('I');
  836.          } else if (var0 == Byte.TYPE) {
  837.             var1.append('B');
  838.          } else if (var0 == Long.TYPE) {
  839.             var1.append('J');
  840.          } else if (var0 == Float.TYPE) {
  841.             var1.append('F');
  842.          } else if (var0 == Double.TYPE) {
  843.             var1.append('D');
  844.          } else if (var0 == Short.TYPE) {
  845.             var1.append('S');
  846.          } else if (var0 == Character.TYPE) {
  847.             var1.append('C');
  848.          } else if (var0 == Boolean.TYPE) {
  849.             var1.append('Z');
  850.          } else {
  851.             if (var0 != Void.TYPE) {
  852.                throw new InternalError();
  853.             }
  854.  
  855.             var1.append('V');
  856.          }
  857.       } else {
  858.          var1.append('L' + var0.getName().replace('.', '/') + ';');
  859.       }
  860.  
  861.       return var1.toString();
  862.    }
  863.  
  864.    private static String getMethodSignature(Class[] var0, Class var1) {
  865.       StringBuilder var2 = new StringBuilder();
  866.       var2.append('(');
  867.  
  868.       for(int var3 = 0; var3 < var0.length; ++var3) {
  869.          var2.append(getClassSignature(var0[var3]));
  870.       }
  871.  
  872.       var2.append(')');
  873.       var2.append(getClassSignature(var1));
  874.       return var2.toString();
  875.    }
  876.  
  877.    private static void throwMiscException(Throwable var0) throws IOException {
  878.       if (var0 instanceof RuntimeException) {
  879.          throw (RuntimeException)var0;
  880.       } else if (var0 instanceof Error) {
  881.          throw (Error)var0;
  882.       } else {
  883.          IOException var1 = new IOException("unexpected exception type");
  884.          var1.initCause(var0);
  885.          throw var1;
  886.       }
  887.    }
  888.  
  889.    private static ObjectStreamField[] getSerialFields(Class var0) throws InvalidClassException {
  890.       ObjectStreamField[] var1;
  891.       if (Serializable.class.isAssignableFrom(var0) && !Externalizable.class.isAssignableFrom(var0) && !Proxy.isProxyClass(var0) && !var0.isInterface()) {
  892.          if ((var1 = getDeclaredSerialFields(var0)) == null) {
  893.             var1 = getDefaultSerialFields(var0);
  894.          }
  895.  
  896.          Arrays.sort(var1);
  897.       } else {
  898.          var1 = NO_FIELDS;
  899.       }
  900.  
  901.       return var1;
  902.    }
  903.  
  904.    private static ObjectStreamField[] getDeclaredSerialFields(Class var0) throws InvalidClassException {
  905.       ObjectStreamField[] var1 = null;
  906.  
  907.       try {
  908.          Field var2 = var0.getDeclaredField("serialPersistentFields");
  909.          byte var3 = 26;
  910.          if ((var2.getModifiers() & var3) == var3) {
  911.             var2.setAccessible(true);
  912.             var1 = (ObjectStreamField[])var2.get((Object)null);
  913.          }
  914.       } catch (Exception var9) {
  915.       }
  916.  
  917.       if (var1 == null) {
  918.          return null;
  919.       } else if (var1.length == 0) {
  920.          return NO_FIELDS;
  921.       } else {
  922.          ObjectStreamField[] var10 = new ObjectStreamField[var1.length];
  923.          HashSet var11 = new HashSet(var1.length);
  924.  
  925.          for(int var4 = 0; var4 < var1.length; ++var4) {
  926.             ObjectStreamField var5 = var1[var4];
  927.             String var6 = var5.getName();
  928.             if (var11.contains(var6)) {
  929.                throw new InvalidClassException("multiple serializable fields named " + var6);
  930.             }
  931.  
  932.             var11.add(var6);
  933.  
  934.             try {
  935.                Field var7 = var0.getDeclaredField(var6);
  936.                if (var7.getType() == var5.getType() && (var7.getModifiers() & 8) == 0) {
  937.                   var10[var4] = new ObjectStreamField(var7, var5.isUnshared(), true);
  938.                }
  939.             } catch (NoSuchFieldException var8) {
  940.             }
  941.  
  942.             if (var10[var4] == null) {
  943.                var10[var4] = new ObjectStreamField(var6, var5.getType(), var5.isUnshared());
  944.             }
  945.          }
  946.  
  947.          return var10;
  948.       }
  949.    }
  950.  
  951.    private static ObjectStreamField[] getDefaultSerialFields(Class var0) {
  952.       Field[] var1 = var0.getDeclaredFields();
  953.       ArrayList var2 = new ArrayList();
  954.       short var3 = 136;
  955.  
  956.       for(int var4 = 0; var4 < var1.length; ++var4) {
  957.          if ((var1[var4].getModifiers() & var3) == 0) {
  958.             var2.add(new ObjectStreamField(var1[var4], false, true));
  959.          }
  960.       }
  961.  
  962.       int var5 = var2.size();
  963.       return var5 == 0 ? NO_FIELDS : (ObjectStreamField[])((ObjectStreamField[])var2.toArray(new ObjectStreamField[var5]));
  964.    }
  965.  
  966.    private static Long getDeclaredSUID(Class var0) {
  967.       try {
  968.          Field var1 = var0.getDeclaredField("serialVersionUID");
  969.          byte var2 = 24;
  970.          if ((var1.getModifiers() & var2) == var2) {
  971.             var1.setAccessible(true);
  972.             return var1.getLong((Object)null);
  973.          }
  974.       } catch (Exception var3) {
  975.       }
  976.  
  977.       return null;
  978.    }
  979.  
  980.    private static long computeDefaultSUID(Class var0) {
  981.       if (Serializable.class.isAssignableFrom(var0) && !Proxy.isProxyClass(var0)) {
  982.          try {
  983.             ByteArrayOutputStream var1 = new ByteArrayOutputStream();
  984.             DataOutputStream var2 = new DataOutputStream(var1);
  985.             var2.writeUTF(var0.getName());
  986.             int var3 = var0.getModifiers() & 1553;
  987.             Method[] var4 = var0.getDeclaredMethods();
  988.             if ((var3 & 512) != 0) {
  989.                var3 = var4.length > 0 ? var3 | 1024 : var3 & -1025;
  990.             }
  991.  
  992.             var2.writeInt(var3);
  993.             if (!var0.isArray()) {
  994.                Class[] var5 = var0.getInterfaces();
  995.                String[] var6 = new String[var5.length];
  996.  
  997.                for(int var7 = 0; var7 < var5.length; ++var7) {
  998.                   var6[var7] = var5[var7].getName();
  999.                }
  1000.  
  1001.                Arrays.sort(var6);
  1002.  
  1003.                for(int var19 = 0; var19 < var6.length; ++var19) {
  1004.                   var2.writeUTF(var6[var19]);
  1005.                }
  1006.             }
  1007.  
  1008.             Field[] var17 = var0.getDeclaredFields();
  1009.             MemberSignature[] var18 = new MemberSignature[var17.length];
  1010.  
  1011.             for(int var20 = 0; var20 < var17.length; ++var20) {
  1012.                var18[var20] = new MemberSignature(var17[var20]);
  1013.             }
  1014.  
  1015.             Arrays.sort(var18, new 3());
  1016.  
  1017.             for(int var21 = 0; var21 < var18.length; ++var21) {
  1018.                MemberSignature var8 = var18[var21];
  1019.                int var9 = var8.member.getModifiers() & 223;
  1020.                if ((var9 & 2) == 0 || (var9 & 136) == 0) {
  1021.                   var2.writeUTF(var8.name);
  1022.                   var2.writeInt(var9);
  1023.                   var2.writeUTF(var8.signature);
  1024.                }
  1025.             }
  1026.  
  1027.             if (hasStaticInitializer(var0)) {
  1028.                var2.writeUTF("<clinit>");
  1029.                var2.writeInt(8);
  1030.                var2.writeUTF("()V");
  1031.             }
  1032.  
  1033.             Constructor[] var22 = var0.getDeclaredConstructors();
  1034.             MemberSignature[] var23 = new MemberSignature[var22.length];
  1035.  
  1036.             for(int var24 = 0; var24 < var22.length; ++var24) {
  1037.                var23[var24] = new MemberSignature(var22[var24]);
  1038.             }
  1039.  
  1040.             Arrays.sort(var23, new 4());
  1041.  
  1042.             for(int var25 = 0; var25 < var23.length; ++var25) {
  1043.                MemberSignature var10 = var23[var25];
  1044.                int var11 = var10.member.getModifiers() & 3391;
  1045.                if ((var11 & 2) == 0) {
  1046.                   var2.writeUTF("<init>");
  1047.                   var2.writeInt(var11);
  1048.                   var2.writeUTF(var10.signature.replace('/', '.'));
  1049.                }
  1050.             }
  1051.  
  1052.             MemberSignature[] var26 = new MemberSignature[var4.length];
  1053.  
  1054.             for(int var27 = 0; var27 < var4.length; ++var27) {
  1055.                var26[var27] = new MemberSignature(var4[var27]);
  1056.             }
  1057.  
  1058.             Arrays.sort(var26, new 5());
  1059.  
  1060.             for(int var28 = 0; var28 < var26.length; ++var28) {
  1061.                MemberSignature var30 = var26[var28];
  1062.                int var12 = var30.member.getModifiers() & 3391;
  1063.                if ((var12 & 2) == 0) {
  1064.                   var2.writeUTF(var30.name);
  1065.                   var2.writeInt(var12);
  1066.                   var2.writeUTF(var30.signature.replace('/', '.'));
  1067.                }
  1068.             }
  1069.  
  1070.             var2.flush();
  1071.             MessageDigest var29 = MessageDigest.getInstance("SHA");
  1072.             byte[] var31 = var29.digest(var1.toByteArray());
  1073.             long var32 = 0L;
  1074.  
  1075.             for(int var14 = Math.min(var31.length, 8) - 1; var14 >= 0; --var14) {
  1076.                var32 = var32 << 8 | (long)(var31[var14] & 255);
  1077.             }
  1078.  
  1079.             return var32;
  1080.          } catch (IOException var15) {
  1081.             throw new InternalError();
  1082.          } catch (NoSuchAlgorithmException var16) {
  1083.             throw new SecurityException(var16.getMessage());
  1084.          }
  1085.       } else {
  1086.          return 0L;
  1087.       }
  1088.    }
  1089.  
  1090.    private static native boolean hasStaticInitializer(Class var0);
  1091.  
  1092.    private static FieldReflector getReflector(ObjectStreamField[] var0, ObjectStreamClass var1) throws InvalidClassException {
  1093.       Class var2 = var1 != null && var0.length > 0 ? var1.field_0 : null;
  1094.       processQueue(java.io.ObjectStreamClass.Caches.access$2500(), java.io.ObjectStreamClass.Caches.reflectors);
  1095.       FieldReflectorKey var3 = new FieldReflectorKey(var2, var0, java.io.ObjectStreamClass.Caches.access$2500());
  1096.       Reference var4 = (Reference)java.io.ObjectStreamClass.Caches.reflectors.get(var3);
  1097.       Object var5 = null;
  1098.       if (var4 != null) {
  1099.          var5 = var4.get();
  1100.       }
  1101.  
  1102.       EntryFuture var6 = null;
  1103.       if (var5 == null) {
  1104.          EntryFuture var7 = new EntryFuture((1)null);
  1105.          SoftReference var8 = new SoftReference(var7);
  1106.  
  1107.          do {
  1108.             if (var4 != null) {
  1109.                java.io.ObjectStreamClass.Caches.reflectors.remove(var3, var4);
  1110.             }
  1111.  
  1112.             var4 = (Reference)java.io.ObjectStreamClass.Caches.reflectors.putIfAbsent(var3, var8);
  1113.             if (var4 != null) {
  1114.                var5 = var4.get();
  1115.             }
  1116.          } while(var4 != null && var5 == null);
  1117.  
  1118.          if (var5 == null) {
  1119.             var6 = var7;
  1120.          }
  1121.       }
  1122.  
  1123.       if (var5 instanceof FieldReflector) {
  1124.          return (FieldReflector)var5;
  1125.       } else {
  1126.          if (var5 instanceof EntryFuture) {
  1127.             var5 = ((EntryFuture)var5).get();
  1128.          } else if (var5 == null) {
  1129.             try {
  1130.                var5 = new FieldReflector(matchFields(var0, var1));
  1131.             } catch (Throwable var9) {
  1132.                var5 = var9;
  1133.             }
  1134.  
  1135.             var6.set(var5);
  1136.             java.io.ObjectStreamClass.Caches.reflectors.put(var3, new SoftReference(var5));
  1137.          }
  1138.  
  1139.          if (var5 instanceof FieldReflector) {
  1140.             return (FieldReflector)var5;
  1141.          } else if (var5 instanceof InvalidClassException) {
  1142.             throw (InvalidClassException)var5;
  1143.          } else if (var5 instanceof RuntimeException) {
  1144.             throw (RuntimeException)var5;
  1145.          } else if (var5 instanceof Error) {
  1146.             throw (Error)var5;
  1147.          } else {
  1148.             throw new InternalError("unexpected entry: " + var5);
  1149.          }
  1150.       }
  1151.    }
  1152.  
  1153.    private static ObjectStreamField[] matchFields(ObjectStreamField[] var0, ObjectStreamClass var1) throws InvalidClassException {
  1154.       ObjectStreamField[] var2 = var1 != null ? var1.fields : NO_FIELDS;
  1155.       ObjectStreamField[] var3 = new ObjectStreamField[var0.length];
  1156.  
  1157.       for(int var4 = 0; var4 < var0.length; ++var4) {
  1158.          ObjectStreamField var5 = var0[var4];
  1159.          ObjectStreamField var6 = null;
  1160.  
  1161.          for(int var7 = 0; var7 < var2.length; ++var7) {
  1162.             ObjectStreamField var8 = var2[var7];
  1163.             if (var5.getName().equals(var8.getName())) {
  1164.                if ((var5.isPrimitive() || var8.isPrimitive()) && var5.getTypeCode() != var8.getTypeCode()) {
  1165.                   throw new InvalidClassException(var1.name, "incompatible types for field " + var5.getName());
  1166.                }
  1167.  
  1168.                if (var8.getField() != null) {
  1169.                   var6 = new ObjectStreamField(var8.getField(), var8.isUnshared(), false);
  1170.                } else {
  1171.                   var6 = new ObjectStreamField(var8.getName(), var8.getSignature(), var8.isUnshared());
  1172.                }
  1173.             }
  1174.          }
  1175.  
  1176.          if (var6 == null) {
  1177.             var6 = new ObjectStreamField(var5.getName(), var5.getSignature(), false);
  1178.          }
  1179.  
  1180.          var6.setOffset(var5.getOffset());
  1181.          var3[var4] = var6;
  1182.       }
  1183.  
  1184.       return var3;
  1185.    }
  1186.  
  1187.    static void processQueue(ReferenceQueue<Class<?>> var0, ConcurrentMap<? extends WeakReference<Class<?>>, ?> var1) {
  1188.       Reference var2;
  1189.       while((var2 = var0.poll()) != null) {
  1190.          var1.remove(var2);
  1191.       }
  1192.  
  1193.    }
  1194.  
  1195.    // $FF: synthetic method
  1196.    static Class access$000(ObjectStreamClass var0) {
  1197.       return var0.field_0;
  1198.    }
  1199.  
  1200.    // $FF: synthetic method
  1201.    static long access$100(Class var0) {
  1202.       return computeDefaultSUID(var0);
  1203.    }
  1204.  
  1205.    // $FF: synthetic method
  1206.    static boolean access$400(ObjectStreamClass var0) {
  1207.       return var0.isEnum;
  1208.    }
  1209.  
  1210.    // $FF: synthetic method
  1211.    static Long access$502(ObjectStreamClass var0, Long var1) {
  1212.       return var0.suid = var1;
  1213.    }
  1214.  
  1215.    // $FF: synthetic method
  1216.    static ObjectStreamField[] access$602(ObjectStreamClass var0, ObjectStreamField[] var1) {
  1217.       return var0.fields = var1;
  1218.    }
  1219.  
  1220.    // $FF: synthetic method
  1221.    static Long access$700(Class var0) {
  1222.       return getDeclaredSUID(var0);
  1223.    }
  1224.  
  1225.    // $FF: synthetic method
  1226.    static ObjectStreamField[] access$800(Class var0) throws InvalidClassException {
  1227.       return getSerialFields(var0);
  1228.    }
  1229.  
  1230.    // $FF: synthetic method
  1231.    static void access$900(ObjectStreamClass var0) throws InvalidClassException {
  1232.       var0.computeFieldOffsets();
  1233.    }
  1234.  
  1235.    // $FF: synthetic method
  1236.    static InvalidClassException access$1002(ObjectStreamClass var0, InvalidClassException var1) {
  1237.       return var0.serializeEx = var1;
  1238.    }
  1239.  
  1240.    // $FF: synthetic method
  1241.    static InvalidClassException access$1102(ObjectStreamClass var0, InvalidClassException var1) {
  1242.       return var0.deserializeEx = var1;
  1243.    }
  1244.  
  1245.    // $FF: synthetic method
  1246.    static boolean access$1200(ObjectStreamClass var0) {
  1247.       return var0.externalizable;
  1248.    }
  1249.  
  1250.    // $FF: synthetic method
  1251.    static Constructor access$1302(ObjectStreamClass var0, Constructor var1) {
  1252.       return var0.cons = var1;
  1253.    }
  1254.  
  1255.    // $FF: synthetic method
  1256.    static Constructor access$1400(Class var0) {
  1257.       return getExternalizableConstructor(var0);
  1258.    }
  1259.  
  1260.    // $FF: synthetic method
  1261.    static Constructor access$1500(Class var0) {
  1262.       return getSerializableConstructor(var0);
  1263.    }
  1264.  
  1265.    // $FF: synthetic method
  1266.    static Method access$1602(ObjectStreamClass var0, Method var1) {
  1267.       return var0.writeObjectMethod = var1;
  1268.    }
  1269.  
  1270.    // $FF: synthetic method
  1271.    static Method access$1700(Class var0, String var1, Class[] var2, Class var3) {
  1272.       return getPrivateMethod(var0, var1, var2, var3);
  1273.    }
  1274.  
  1275.    // $FF: synthetic method
  1276.    static Method access$1802(ObjectStreamClass var0, Method var1) {
  1277.       return var0.readObjectMethod = var1;
  1278.    }
  1279.  
  1280.    // $FF: synthetic method
  1281.    static Method access$1902(ObjectStreamClass var0, Method var1) {
  1282.       return var0.readObjectNoDataMethod = var1;
  1283.    }
  1284.  
  1285.    // $FF: synthetic method
  1286.    static boolean access$2002(ObjectStreamClass var0, boolean var1) {
  1287.       return var0.hasWriteObjectData = var1;
  1288.    }
  1289.  
  1290.    // $FF: synthetic method
  1291.    static Method access$1600(ObjectStreamClass var0) {
  1292.       return var0.writeObjectMethod;
  1293.    }
  1294.  
  1295.    // $FF: synthetic method
  1296.    static Method access$2102(ObjectStreamClass var0, Method var1) {
  1297.       return var0.writeReplaceMethod = var1;
  1298.    }
  1299.  
  1300.    // $FF: synthetic method
  1301.    static Method access$2200(Class var0, String var1, Class[] var2, Class var3) {
  1302.       return getInheritableMethod(var0, var1, var2, var3);
  1303.    }
  1304.  
  1305.    // $FF: synthetic method
  1306.    static Method access$2302(ObjectStreamClass var0, Method var1) {
  1307.       return var0.readResolveMethod = var1;
  1308.    }
  1309.  
  1310.    // $FF: synthetic method
  1311.    static String access$2400(Class[] var0, Class var1) {
  1312.       return getMethodSignature(var0, var1);
  1313.    }
  1314.  
  1315.    static {
  1316.       serialPersistentFields = NO_FIELDS;
  1317.       reflFactory = (ReflectionFactory)AccessController.doPrivileged(new ReflectionFactory.GetReflectionFactoryAction());
  1318.       initNative();
  1319.    }
  1320. }
  1321.