asm4/src/org/objectweb/asm/commons/SerialVersionUIDAdder.java - toolchain/jill - Git at Google

 /***
  * ASM: a very small and fast Java bytecode manipulation framework
  * Copyright (c) 2000-2011 INRIA, France Telecom
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holders nor the names of its
  *    contributors may be used to endorse or promote products derived from
  *    this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 package org.objectweb.asm.commons;

 import java.io.ByteArrayOutputStream;
 import java.io.DataOutput;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;

 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.FieldVisitor;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;

 /**
  * A {@link ClassVisitor} that adds a serial version unique identifier to a
  * class if missing. Here is typical usage of this class:
  *
  * <pre>
  *   ClassWriter cw = new ClassWriter(...);
  *   ClassVisitor sv = new SerialVersionUIDAdder(cw);
  *   ClassVisitor ca = new MyClassAdapter(sv);
  *   new ClassReader(orginalClass).accept(ca, false);
  * </pre>
  *
  * The SVUID algorithm can be found <a href=
  * "http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html"
  * >http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html</a>:
  *
  * <pre>
  * The serialVersionUID is computed using the signature of a stream of bytes
  * that reflect the class definition. The National Institute of Standards and
  * Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a
  * signature for the stream. The first two 32-bit quantities are used to form a
  * 64-bit hash. A java.lang.DataOutputStream is used to convert primitive data
  * types to a sequence of bytes. The values input to the stream are defined by
  * the Java Virtual Machine (VM) specification for classes.
  *
  * The sequence of items in the stream is as follows:
  *
  * 1. The class name written using UTF encoding.
  * 2. The class modifiers written as a 32-bit integer.
  * 3. The name of each interface sorted by name written using UTF encoding.
  * 4. For each field of the class sorted by field name (except private static
  * and private transient fields):
  * 1. The name of the field in UTF encoding.
  * 2. The modifiers of the field written as a 32-bit integer.
  * 3. The descriptor of the field in UTF encoding
  * 5. If a class initializer exists, write out the following:
  * 1. The name of the method, &lt;clinit&gt;, in UTF encoding.
  * 2. The modifier of the method, java.lang.reflect.Modifier.STATIC,
  * written as a 32-bit integer.
  * 3. The descriptor of the method, ()V, in UTF encoding.
  * 6. For each non-private constructor sorted by method name and signature:
  * 1. The name of the method, &lt;init&gt;, in UTF encoding.
  * 2. The modifiers of the method written as a 32-bit integer.
  * 3. The descriptor of the method in UTF encoding.
  * 7. For each non-private method sorted by method name and signature:
  * 1. The name of the method in UTF encoding.
  * 2. The modifiers of the method written as a 32-bit integer.
  * 3. The descriptor of the method in UTF encoding.
  * 8. The SHA-1 algorithm is executed on the stream of bytes produced by
  * DataOutputStream and produces five 32-bit values sha[0..4].
  *
  * 9. The hash value is assembled from the first and second 32-bit values of
  * the SHA-1 message digest. If the result of the message digest, the five
  * 32-bit words H0 H1 H2 H3 H4, is in an array of five int values named
  * sha, the hash value would be computed as follows:
  *
  * long hash = ((sha[0] &gt;&gt;&gt; 24) &amp; 0xFF) |
  * ((sha[0] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 8 |
  * ((sha[0] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 16 |
  * ((sha[0] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 24 |
  * ((sha[1] &gt;&gt;&gt; 24) &amp; 0xFF) &lt;&lt; 32 |
  * ((sha[1] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 40 |
  * ((sha[1] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 48 |
  * ((sha[1] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 56;
  * </pre>
  *
  * @author Rajendra Inamdar, Vishal Vishnoi
  */
 public class SerialVersionUIDAdder extends ClassVisitor {

     /**
      * Flag that indicates if we need to compute SVUID.
      */
     private boolean computeSVUID;

     /**
      * Set to true if the class already has SVUID.
      */
     private boolean hasSVUID;

     /**
      * Classes access flags.
      */
     private int access;

     /**
      * Internal name of the class
      */
     private String name;

     /**
      * Interfaces implemented by the class.
      */
     private String[] interfaces;

     /**
      * Collection of fields. (except private static and private transient
      * fields)
      */
     private Collection<Item> svuidFields;

     /**
      * Set to true if the class has static initializer.
      */
     private boolean hasStaticInitializer;

     /**
      * Collection of non-private constructors.
      */
     private Collection<Item> svuidConstructors;

     /**
      * Collection of non-private methods.
      */
     private Collection<Item> svuidMethods;

     /**
      * Creates a new {@link SerialVersionUIDAdder}. <i>Subclasses must not use
      * this constructor</i>. Instead, they must use the
      * {@link #SerialVersionUIDAdder(int, ClassVisitor)} version.
      *
      * @param cv
      *            a {@link ClassVisitor} to which this visitor will delegate
      *            calls.
      */
     public SerialVersionUIDAdder(final ClassVisitor cv) {
         this(Opcodes.ASM4, cv);
     }

     /**
      * Creates a new {@link SerialVersionUIDAdder}.
      *
      * @param api
      *            the ASM API version implemented by this visitor. Must be one
      *            of {@link Opcodes#ASM4}.
      * @param cv
      *            a {@link ClassVisitor} to which this visitor will delegate
      *            calls.
      */
     protected SerialVersionUIDAdder(final int api, final ClassVisitor cv) {
         super(api, cv);
         svuidFields = new ArrayList<Item>();
         svuidConstructors = new ArrayList<Item>();
         svuidMethods = new ArrayList<Item>();
     }

     // ------------------------------------------------------------------------
     // Overriden methods
     // ------------------------------------------------------------------------

     /*
      * Visit class header and get class name, access , and interfaces
      * information (step 1,2, and 3) for SVUID computation.
      */
     @Override
     public void visit(final int version, final int access, final String name,
             final String signature, final String superName,
             final String[] interfaces) {
         computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;

         if (computeSVUID) {
             this.name = name;
             this.access = access;
             this.interfaces = interfaces;
         }

         super.visit(version, access, name, signature, superName, interfaces);
     }

     /*
      * Visit the methods and get constructor and method information (step 5 and
      * 7). Also determine if there is a class initializer (step 6).
      */
     @Override
     public MethodVisitor visitMethod(final int access, final String name,
             final String desc, final String signature, final String[] exceptions) {
         if (computeSVUID) {
             if ("<clinit>".equals(name)) {
                 hasStaticInitializer = true;
             }
             /*
              * Remembers non private constructors and methods for SVUID
              * computation For constructor and method modifiers, only the
              * ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
              * ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags
              * are used.
              */
             int mods = access
                     & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                             | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                             | Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED
                             | Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_STRICT);

             // all non private methods
             if ((access & Opcodes.ACC_PRIVATE) == 0) {
                 if ("<init>".equals(name)) {
                     svuidConstructors.add(new Item(name, mods, desc));
                 } else if (!"<clinit>".equals(name)) {
                     svuidMethods.add(new Item(name, mods, desc));
                 }
             }
         }

         return super.visitMethod(access, name, desc, signature, exceptions);
     }

     /*
      * Gets class field information for step 4 of the algorithm. Also determines
      * if the class already has a SVUID.
      */
     @Override
     public FieldVisitor visitField(final int access, final String name,
             final String desc, final String signature, final Object value) {
         if (computeSVUID) {
             if ("serialVersionUID".equals(name)) {
                 // since the class already has SVUID, we won't be computing it.
                 computeSVUID = false;
                 hasSVUID = true;
             }
             /*
              * Remember field for SVUID computation For field modifiers, only
              * the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
              * ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
              * computing serialVersionUID values.
              */
             if ((access & Opcodes.ACC_PRIVATE) == 0
                     || (access & (Opcodes.ACC_STATIC | Opcodes.ACC_TRANSIENT)) == 0) {
                 int mods = access
                         & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                                 | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                                 | Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE | Opcodes.ACC_TRANSIENT);
                 svuidFields.add(new Item(name, mods, desc));
             }
         }

         return super.visitField(access, name, desc, signature, value);
     }

     /**
      * Handle a bizarre special case. Nested classes (static classes declared
      * inside another class) that are protected have their access bit set to
      * public in their class files to deal with some odd reflection situation.
      * Our SVUID computation must do as the JVM does and ignore access bits in
      * the class file in favor of the access bits InnerClass attribute.
      */
     @Override
     public void visitInnerClass(final String aname, final String outerName,
             final String innerName, final int attr_access) {
         if ((name != null) && name.equals(aname)) {
             this.access = attr_access;
         }
         super.visitInnerClass(aname, outerName, innerName, attr_access);
     }

     /*
      * Add the SVUID if class doesn't have one
      */
     @Override
     public void visitEnd() {
         // compute SVUID and add it to the class
         if (computeSVUID && !hasSVUID) {
             try {
                 addSVUID(computeSVUID());
             } catch (Throwable e) {
                 throw new RuntimeException("Error while computing SVUID for "
                         + name, e);
             }
         }

         super.visitEnd();
     }

     // ------------------------------------------------------------------------
     // Utility methods
     // ------------------------------------------------------------------------

     /**
      * Returns true if the class already has a SVUID field. The result of this
      * method is only valid when visitEnd is or has been called.
      *
      * @return true if the class already has a SVUID field.
      */
     public boolean hasSVUID() {
         return hasSVUID;
     }

     protected void addSVUID(long svuid) {
         FieldVisitor fv = super.visitField(Opcodes.ACC_FINAL
                 + Opcodes.ACC_STATIC, "serialVersionUID", "J", null, new Long(
                 svuid));
         if (fv != null) {
             fv.visitEnd();
         }
     }

     /**
      * Computes and returns the value of SVUID.
      *
      * @return Returns the serial version UID
      * @throws IOException
      *             if an I/O error occurs
      */
     protected long computeSVUID() throws IOException {
         ByteArrayOutputStream bos;
         DataOutputStream dos = null;
         long svuid = 0;

         try {
             bos = new ByteArrayOutputStream();
             dos = new DataOutputStream(bos);

             /*
              * 1. The class name written using UTF encoding.
              */
             dos.writeUTF(name.replace('/', '.'));

             /*
              * 2. The class modifiers written as a 32-bit integer.
              */
             dos.writeInt(access
                     & (Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL
                             | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT));

             /*
              * 3. The name of each interface sorted by name written using UTF
              * encoding.
              */
             Arrays.sort(interfaces);
             for (int i = 0; i < interfaces.length; i++) {
                 dos.writeUTF(interfaces[i].replace('/', '.'));
             }

             /*
              * 4. For each field of the class sorted by field name (except
              * private static and private transient fields):
              *
              * 1. The name of the field in UTF encoding. 2. The modifiers of the
              * field written as a 32-bit integer. 3. The descriptor of the field
              * in UTF encoding
              *
              * Note that field signatures are not dot separated. Method and
              * constructor signatures are dot separated. Go figure...
              */
             writeItems(svuidFields, dos, false);

             /*
              * 5. If a class initializer exists, write out the following: 1. The
              * name of the method, <clinit>, in UTF encoding. 2. The modifier of
              * the method, java.lang.reflect.Modifier.STATIC, written as a
              * 32-bit integer. 3. The descriptor of the method, ()V, in UTF
              * encoding.
              */
             if (hasStaticInitializer) {
                 dos.writeUTF("<clinit>");
                 dos.writeInt(Opcodes.ACC_STATIC);
                 dos.writeUTF("()V");
             } // if..

             /*
              * 6. For each non-private constructor sorted by method name and
              * signature: 1. The name of the method, <init>, in UTF encoding. 2.
              * The modifiers of the method written as a 32-bit integer. 3. The
              * descriptor of the method in UTF encoding.
              */
             writeItems(svuidConstructors, dos, true);

             /*
              * 7. For each non-private method sorted by method name and
              * signature: 1. The name of the method in UTF encoding. 2. The
              * modifiers of the method written as a 32-bit integer. 3. The
              * descriptor of the method in UTF encoding.
              */
             writeItems(svuidMethods, dos, true);

             dos.flush();

             /*
              * 8. The SHA-1 algorithm is executed on the stream of bytes
              * produced by DataOutputStream and produces five 32-bit values
              * sha[0..4].
              */
             byte[] hashBytes = computeSHAdigest(bos.toByteArray());

             /*
              * 9. The hash value is assembled from the first and second 32-bit
              * values of the SHA-1 message digest. If the result of the message
              * digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of
              * five int values named sha, the hash value would be computed as
              * follows:
              *
              * long hash = ((sha[0] >>> 24) & 0xFF) | ((sha[0] >>> 16) & 0xFF)
              * << 8 | ((sha[0] >>> 8) & 0xFF) << 16 | ((sha[0] >>> 0) & 0xFF) <<
              * 24 | ((sha[1] >>> 24) & 0xFF) << 32 | ((sha[1] >>> 16) & 0xFF) <<
              * 40 | ((sha[1] >>> 8) & 0xFF) << 48 | ((sha[1] >>> 0) & 0xFF) <<
              * 56;
              */
             for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
                 svuid = (svuid << 8) | (hashBytes[i] & 0xFF);
             }
         } finally {
             // close the stream (if open)
             if (dos != null) {
                 dos.close();
             }
         }

         return svuid;
     }

     /**
      * Returns the SHA-1 message digest of the given value.
      *
      * @param value
      *            the value whose SHA message digest must be computed.
      * @return the SHA-1 message digest of the given value.
      */
     protected byte[] computeSHAdigest(final byte[] value) {
         try {
             return MessageDigest.getInstance("SHA").digest(value);
         } catch (Exception e) {
             throw new UnsupportedOperationException(e.toString());
         }
     }

     /**
      * Sorts the items in the collection and writes it to the data output stream
      *
      * @param itemCollection
      *            collection of items
      * @param dos
      *            a <code>DataOutputStream</code> value
      * @param dotted
      *            a <code>boolean</code> value
      * @exception IOException
      *                if an error occurs
      */
     private static void writeItems(final Collection<Item> itemCollection,
             final DataOutput dos, final boolean dotted) throws IOException {
         int size = itemCollection.size();
         Item[] items = itemCollection.toArray(new Item[size]);
         Arrays.sort(items);
         for (int i = 0; i < size; i++) {
             dos.writeUTF(items[i].name);
             dos.writeInt(items[i].access);
             dos.writeUTF(dotted ? items[i].desc.replace('/', '.')
                     : items[i].desc);
         }
     }

     // ------------------------------------------------------------------------
     // Inner classes
     // ------------------------------------------------------------------------

     private static class Item implements Comparable<Item> {

         final String name;

         final int access;

         final String desc;

         Item(final String name, final int access, final String desc) {
             this.name = name;
             this.access = access;
             this.desc = desc;
         }

         public int compareTo(final Item other) {
             int retVal = name.compareTo(other.name);
             if (retVal == 0) {
                 retVal = desc.compareTo(other.desc);
             }
             return retVal;
         }

         @Override
         public boolean equals(final Object o) {
             if (o instanceof Item) {
                 return compareTo((Item) o) == 0;
             }
             return false;
         }

         @Override
         public int hashCode() {
             return (name + desc).hashCode();
         }
     }
 }
	/***
	* ASM: a very small and fast Java bytecode manipulation framework
	* Copyright (c) 2000-2011 INRIA, France Telecom
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/
	package org.objectweb.asm.commons;

	import java.io.ByteArrayOutputStream;
	import java.io.DataOutput;
	import java.io.DataOutputStream;
	import java.io.IOException;
	import java.security.MessageDigest;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;

	import org.objectweb.asm.ClassVisitor;
	import org.objectweb.asm.FieldVisitor;
	import org.objectweb.asm.MethodVisitor;
	import org.objectweb.asm.Opcodes;

	/**
	* A {@link ClassVisitor} that adds a serial version unique identifier to a
	* class if missing. Here is typical usage of this class:
	*
	* <pre>
	* ClassWriter cw = new ClassWriter(...);
	* ClassVisitor sv = new SerialVersionUIDAdder(cw);
	* ClassVisitor ca = new MyClassAdapter(sv);
	* new ClassReader(orginalClass).accept(ca, false);
	* </pre>
	*
	* The SVUID algorithm can be found <a href=
	* "http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html"
	* >http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html</a>:
	*
	* <pre>
	* The serialVersionUID is computed using the signature of a stream of bytes
	* that reflect the class definition. The National Institute of Standards and
	* Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a
	* signature for the stream. The first two 32-bit quantities are used to form a
	* 64-bit hash. A java.lang.DataOutputStream is used to convert primitive data
	* types to a sequence of bytes. The values input to the stream are defined by
	* the Java Virtual Machine (VM) specification for classes.
	*
	* The sequence of items in the stream is as follows:
	*
	* 1. The class name written using UTF encoding.
	* 2. The class modifiers written as a 32-bit integer.
	* 3. The name of each interface sorted by name written using UTF encoding.
	* 4. For each field of the class sorted by field name (except private static
	* and private transient fields):
	* 1. The name of the field in UTF encoding.
	* 2. The modifiers of the field written as a 32-bit integer.
	* 3. The descriptor of the field in UTF encoding
	* 5. If a class initializer exists, write out the following:
	* 1. The name of the method, <clinit>, in UTF encoding.
	* 2. The modifier of the method, java.lang.reflect.Modifier.STATIC,
	* written as a 32-bit integer.
	* 3. The descriptor of the method, ()V, in UTF encoding.
	* 6. For each non-private constructor sorted by method name and signature:
	* 1. The name of the method, <init>, in UTF encoding.
	* 2. The modifiers of the method written as a 32-bit integer.
	* 3. The descriptor of the method in UTF encoding.
	* 7. For each non-private method sorted by method name and signature:
	* 1. The name of the method in UTF encoding.
	* 2. The modifiers of the method written as a 32-bit integer.
	* 3. The descriptor of the method in UTF encoding.
	* 8. The SHA-1 algorithm is executed on the stream of bytes produced by
	* DataOutputStream and produces five 32-bit values sha[0..4].
	*
	* 9. The hash value is assembled from the first and second 32-bit values of
	* the SHA-1 message digest. If the result of the message digest, the five
	* 32-bit words H0 H1 H2 H3 H4, is in an array of five int values named
	* sha, the hash value would be computed as follows:
	*
	* long hash = ((sha[0] >>> 24) & 0xFF) \|
	* ((sha[0] >>> 16) & 0xFF) << 8 \|
	* ((sha[0] >>> 8) & 0xFF) << 16 \|
	* ((sha[0] >>> 0) & 0xFF) << 24 \|
	* ((sha[1] >>> 24) & 0xFF) << 32 \|
	* ((sha[1] >>> 16) & 0xFF) << 40 \|
	* ((sha[1] >>> 8) & 0xFF) << 48 \|
	* ((sha[1] >>> 0) & 0xFF) << 56;
	* </pre>
	*
	* @author Rajendra Inamdar, Vishal Vishnoi
	*/
	public class SerialVersionUIDAdder extends ClassVisitor {

	/**
	* Flag that indicates if we need to compute SVUID.
	*/
	private boolean computeSVUID;

	/**
	* Set to true if the class already has SVUID.
	*/
	private boolean hasSVUID;

	/**
	* Classes access flags.
	*/
	private int access;

	/**
	* Internal name of the class
	*/
	private String name;

	/**
	* Interfaces implemented by the class.
	*/
	private String[] interfaces;

	/**
	* Collection of fields. (except private static and private transient
	* fields)
	*/
	private Collection<Item> svuidFields;

	/**
	* Set to true if the class has static initializer.
	*/
	private boolean hasStaticInitializer;

	/**
	* Collection of non-private constructors.
	*/
	private Collection<Item> svuidConstructors;

	/**
	* Collection of non-private methods.
	*/
	private Collection<Item> svuidMethods;

	/**
	* Creates a new {@link SerialVersionUIDAdder}. <i>Subclasses must not use
	* this constructor</i>. Instead, they must use the
	* {@link #SerialVersionUIDAdder(int, ClassVisitor)} version.
	*
	* @param cv
	* a {@link ClassVisitor} to which this visitor will delegate
	* calls.
	*/
	public SerialVersionUIDAdder(final ClassVisitor cv) {
	this(Opcodes.ASM4, cv);
	}

	/**
	* Creates a new {@link SerialVersionUIDAdder}.
	*
	* @param api
	* the ASM API version implemented by this visitor. Must be one
	* of {@link Opcodes#ASM4}.
	* @param cv
	* a {@link ClassVisitor} to which this visitor will delegate
	* calls.
	*/
	protected SerialVersionUIDAdder(final int api, final ClassVisitor cv) {
	super(api, cv);
	svuidFields = new ArrayList<Item>();
	svuidConstructors = new ArrayList<Item>();
	svuidMethods = new ArrayList<Item>();
	}

	// ------------------------------------------------------------------------
	// Overriden methods
	// ------------------------------------------------------------------------

	/*
	* Visit class header and get class name, access , and interfaces
	* information (step 1,2, and 3) for SVUID computation.
	*/
	@Override
	public void visit(final int version, final int access, final String name,
	final String signature, final String superName,
	final String[] interfaces) {
	computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;

	if (computeSVUID) {
	this.name = name;
	this.access = access;
	this.interfaces = interfaces;
	}

	super.visit(version, access, name, signature, superName, interfaces);
	}

	/*
	* Visit the methods and get constructor and method information (step 5 and
	* 7). Also determine if there is a class initializer (step 6).
	*/
	@Override
	public MethodVisitor visitMethod(final int access, final String name,
	final String desc, final String signature, final String[] exceptions) {
	if (computeSVUID) {
	if ("<clinit>".equals(name)) {
	hasStaticInitializer = true;
	}
	/*
	* Remembers non private constructors and methods for SVUID
	* computation For constructor and method modifiers, only the
	* ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
	* ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags
	* are used.
	*/
	int mods = access
	& (Opcodes.ACC_PUBLIC \| Opcodes.ACC_PRIVATE
	\| Opcodes.ACC_PROTECTED \| Opcodes.ACC_STATIC
	\| Opcodes.ACC_FINAL \| Opcodes.ACC_SYNCHRONIZED
	\| Opcodes.ACC_NATIVE \| Opcodes.ACC_ABSTRACT \| Opcodes.ACC_STRICT);

	// all non private methods
	if ((access & Opcodes.ACC_PRIVATE) == 0) {
	if ("<init>".equals(name)) {
	svuidConstructors.add(new Item(name, mods, desc));
	} else if (!"<clinit>".equals(name)) {
	svuidMethods.add(new Item(name, mods, desc));
	}
	}
	}

	return super.visitMethod(access, name, desc, signature, exceptions);
	}

	/*
	* Gets class field information for step 4 of the algorithm. Also determines
	* if the class already has a SVUID.
	*/
	@Override
	public FieldVisitor visitField(final int access, final String name,
	final String desc, final String signature, final Object value) {
	if (computeSVUID) {
	if ("serialVersionUID".equals(name)) {
	// since the class already has SVUID, we won't be computing it.
	computeSVUID = false;
	hasSVUID = true;
	}
	/*
	* Remember field for SVUID computation For field modifiers, only
	* the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
	* ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
	* computing serialVersionUID values.
	*/
	if ((access & Opcodes.ACC_PRIVATE) == 0
	\|\| (access & (Opcodes.ACC_STATIC \| Opcodes.ACC_TRANSIENT)) == 0) {
	int mods = access
	& (Opcodes.ACC_PUBLIC \| Opcodes.ACC_PRIVATE
	\| Opcodes.ACC_PROTECTED \| Opcodes.ACC_STATIC
	\| Opcodes.ACC_FINAL \| Opcodes.ACC_VOLATILE \| Opcodes.ACC_TRANSIENT);
	svuidFields.add(new Item(name, mods, desc));
	}
	}

	return super.visitField(access, name, desc, signature, value);
	}

	/**
	* Handle a bizarre special case. Nested classes (static classes declared
	* inside another class) that are protected have their access bit set to
	* public in their class files to deal with some odd reflection situation.
	* Our SVUID computation must do as the JVM does and ignore access bits in
	* the class file in favor of the access bits InnerClass attribute.
	*/
	@Override
	public void visitInnerClass(final String aname, final String outerName,
	final String innerName, final int attr_access) {
	if ((name != null) && name.equals(aname)) {
	this.access = attr_access;
	}
	super.visitInnerClass(aname, outerName, innerName, attr_access);
	}

	/*
	* Add the SVUID if class doesn't have one
	*/
	@Override
	public void visitEnd() {
	// compute SVUID and add it to the class
	if (computeSVUID && !hasSVUID) {
	try {
	addSVUID(computeSVUID());
	} catch (Throwable e) {
	throw new RuntimeException("Error while computing SVUID for "
	+ name, e);
	}
	}

	super.visitEnd();
	}

	// ------------------------------------------------------------------------
	// Utility methods
	// ------------------------------------------------------------------------

	/**
	* Returns true if the class already has a SVUID field. The result of this
	* method is only valid when visitEnd is or has been called.
	*
	* @return true if the class already has a SVUID field.
	*/
	public boolean hasSVUID() {
	return hasSVUID;
	}

	protected void addSVUID(long svuid) {
	FieldVisitor fv = super.visitField(Opcodes.ACC_FINAL
	+ Opcodes.ACC_STATIC, "serialVersionUID", "J", null, new Long(
	svuid));
	if (fv != null) {
	fv.visitEnd();
	}
	}

	/**
	* Computes and returns the value of SVUID.
	*
	* @return Returns the serial version UID
	* @throws IOException
	* if an I/O error occurs
	*/
	protected long computeSVUID() throws IOException {
	ByteArrayOutputStream bos;
	DataOutputStream dos = null;
	long svuid = 0;

	try {
	bos = new ByteArrayOutputStream();
	dos = new DataOutputStream(bos);

	/*
	* 1. The class name written using UTF encoding.
	*/
	dos.writeUTF(name.replace('/', '.'));

	/*
	* 2. The class modifiers written as a 32-bit integer.
	*/
	dos.writeInt(access
	& (Opcodes.ACC_PUBLIC \| Opcodes.ACC_FINAL
	\| Opcodes.ACC_INTERFACE \| Opcodes.ACC_ABSTRACT));

	/*
	* 3. The name of each interface sorted by name written using UTF
	* encoding.
	*/
	Arrays.sort(interfaces);
	for (int i = 0; i < interfaces.length; i++) {
	dos.writeUTF(interfaces[i].replace('/', '.'));
	}

	/*
	* 4. For each field of the class sorted by field name (except
	* private static and private transient fields):
	*
	* 1. The name of the field in UTF encoding. 2. The modifiers of the
	* field written as a 32-bit integer. 3. The descriptor of the field
	* in UTF encoding
	*
	* Note that field signatures are not dot separated. Method and
	* constructor signatures are dot separated. Go figure...
	*/
	writeItems(svuidFields, dos, false);

	/*
	* 5. If a class initializer exists, write out the following: 1. The
	* name of the method, <clinit>, in UTF encoding. 2. The modifier of
	* the method, java.lang.reflect.Modifier.STATIC, written as a
	* 32-bit integer. 3. The descriptor of the method, ()V, in UTF
	* encoding.
	*/
	if (hasStaticInitializer) {
	dos.writeUTF("<clinit>");
	dos.writeInt(Opcodes.ACC_STATIC);
	dos.writeUTF("()V");
	} // if..

	/*
	* 6. For each non-private constructor sorted by method name and
	* signature: 1. The name of the method, <init>, in UTF encoding. 2.
	* The modifiers of the method written as a 32-bit integer. 3. The
	* descriptor of the method in UTF encoding.
	*/
	writeItems(svuidConstructors, dos, true);

	/*
	* 7. For each non-private method sorted by method name and
	* signature: 1. The name of the method in UTF encoding. 2. The
	* modifiers of the method written as a 32-bit integer. 3. The
	* descriptor of the method in UTF encoding.
	*/
	writeItems(svuidMethods, dos, true);

	dos.flush();

	/*
	* 8. The SHA-1 algorithm is executed on the stream of bytes
	* produced by DataOutputStream and produces five 32-bit values
	* sha[0..4].
	*/
	byte[] hashBytes = computeSHAdigest(bos.toByteArray());

	/*
	* 9. The hash value is assembled from the first and second 32-bit
	* values of the SHA-1 message digest. If the result of the message
	* digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of
	* five int values named sha, the hash value would be computed as
	* follows:
	*
	* long hash = ((sha[0] >>> 24) & 0xFF) \| ((sha[0] >>> 16) & 0xFF)
	* << 8 \| ((sha[0] >>> 8) & 0xFF) << 16 \| ((sha[0] >>> 0) & 0xFF) <<
	* 24 \| ((sha[1] >>> 24) & 0xFF) << 32 \| ((sha[1] >>> 16) & 0xFF) <<
	* 40 \| ((sha[1] >>> 8) & 0xFF) << 48 \| ((sha[1] >>> 0) & 0xFF) <<
	* 56;
	*/
	for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
	svuid = (svuid << 8) \| (hashBytes[i] & 0xFF);
	}
	} finally {
	// close the stream (if open)
	if (dos != null) {
	dos.close();
	}
	}

	return svuid;
	}

	/**
	* Returns the SHA-1 message digest of the given value.
	*
	* @param value
	* the value whose SHA message digest must be computed.
	* @return the SHA-1 message digest of the given value.
	*/
	protected byte[] computeSHAdigest(final byte[] value) {
	try {
	return MessageDigest.getInstance("SHA").digest(value);
	} catch (Exception e) {
	throw new UnsupportedOperationException(e.toString());
	}
	}

	/**
	* Sorts the items in the collection and writes it to the data output stream
	*
	* @param itemCollection
	* collection of items
	* @param dos
	* a <code>DataOutputStream</code> value
	* @param dotted
	* a <code>boolean</code> value
	* @exception IOException
	* if an error occurs
	*/
	private static void writeItems(final Collection<Item> itemCollection,
	final DataOutput dos, final boolean dotted) throws IOException {
	int size = itemCollection.size();
	Item[] items = itemCollection.toArray(new Item[size]);
	Arrays.sort(items);
	for (int i = 0; i < size; i++) {
	dos.writeUTF(items[i].name);
	dos.writeInt(items[i].access);
	dos.writeUTF(dotted ? items[i].desc.replace('/', '.')
	: items[i].desc);
	}
	}

	// ------------------------------------------------------------------------
	// Inner classes
	// ------------------------------------------------------------------------

	private static class Item implements Comparable<Item> {

	final String name;

	final int access;

	final String desc;

	Item(final String name, final int access, final String desc) {
	this.name = name;
	this.access = access;
	this.desc = desc;
	}

	public int compareTo(final Item other) {
	int retVal = name.compareTo(other.name);
	if (retVal == 0) {
	retVal = desc.compareTo(other.desc);
	}
	return retVal;
	}

	@Override
	public boolean equals(final Object o) {
	if (o instanceof Item) {
	return compareTo((Item) o) == 0;
	}
	return false;
	}

	@Override
	public int hashCode() {
	return (name + desc).hashCode();
	}
	}
	}