Revize 5c81df14

#7768 Simplified jdeserialize main with args. Project implemented

demo_jh/Deserializer_tests/src/SampleClassesNOK/Simple.java

@@ -1 @@
-package SampleClassesNOK;
-
-import java.io.Serializable;
-
-public class Simple implements Serializable
-{
-	private static final long serialVersionUID = 1L;
-
-    private String pozdrav = "AHOJ";
-    private int testInt = 123;
-    private double testDouble = 1.00;
-
-    public Simple() 
-    {
-        int locInt = 5;
-    }
-}

demo_jh/Deserializer_tests/src/SampleClassesOK/Simple.java

@@ -1 @@
-package SampleClassesOK;
-
-import java.io.Serializable;
-
-public class Simple implements Serializable
-{
-	private static final long serialVersionUID = 1L;
-
-    private String pozdrav = "AHOJ";
-    private int testInt = 123;
-    private double testDouble = 1.00;
-
-    public Simple() 
-    {
-        int locInt = 5;
-    }
-}

demo_jh/Deserializer_tests/src/app/App.java

@@ -16 +16 @@
     * When they are 
     * **/
     public static void main(String[] args) throws Exception 
+    {
+        App thisApp = new App();
+
+        //thisApp.pureSerializationDeserialization();
+
+        //https://code.google.com/archive/p/jdeserialize/wikis/Documentation.wiki
+        String[] myArgs= new String[1];
+        myArgs[0] = "serialized/simple.out";    
+        //testing call without any options. Outputs the deserialized data into console.
+        jdeserialize.jdeserialize.main(myArgs); 
+    }
+
+
+    private void pureSerializationDeserialization()
     {
         try{
             System.out.println("Starting...");
 
-            App thisApp = new App();
-            //thisApp.Serialize(new SampleClassesOK.Simple(), "serialized/simple.out");
+            this.serialize(new samples.ok.Simple(), "serialized/simple.out");
             
-            SampleClassesOK.Simple test1 = thisApp.Deserialize("serialized/simple.out");
+            samples.nok.Simple test1 = this.deserialize("serialized/simple.out");
 
         }catch(Exception e)
         {
@@ -32 +45 @@
         }
     }
 
-    private <T> T Deserialize(String inputFilePath)
+    /** 
+     * Standard way  of deserializing objects with java.
+     * 
+     * Taken from example method, doc
+    **/
+    private <T> T deserialize(String inputFilePath)
     {
         try 
         {
@@ -60 +78 @@
      * 
      * Taken from example method, doc
     **/
-    private void Serialize(Object obj, String outputPath) 
+    private void serialize(Object obj, String outputPath) 
     {
         try
         {

demo_jh/Deserializer_tests/src/jdeserialize/ExceptionReadException.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Exception used to signal that an exception object was successfully read from the 
+ * stream.  This object holds a reference to the serialized exception object.
+ */
+public class ExceptionReadException extends IOException {
+    public static final long serialVersionUID = 2277356908919221L;
+    public content exceptionobj;
+    /**
+     * Constructor.
+     * @param c the serialized exception object that was read
+     */
+    public ExceptionReadException(content c) {
+        super("serialized exception read during stream");
+        this.exceptionobj = c;
+    }
+    /**
+     * Gets the Exception object that was thrown.
+     * @return the content representing the serialized exception object
+     */
+    public content getExceptionObject() {
+        return exceptionobj;
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/Getopt.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Simple getopt()-like implementation.
+ */
+public class Getopt {
+    private Map<String, Integer> options;
+    private List<String> otherargs;
+    private Map<String, String> descriptions;
+    private Map<String, List<String>> optvals;
+
+    public class OptionParseException extends Exception {
+        public static final long serialVersionUID = 2898924890585885551L;
+        public OptionParseException(String message) {
+            super(message);
+        }
+    }
+
+    /**
+     * Gets the list arguments specified that were *not* options or their arguments, in
+     * the order they were specified.
+     * 
+     * @return the list of non-option String arguments
+     */
+    public List<String> getOtherArguments() {
+        return otherargs;
+    }
+
+    /**
+     * Gets the set of all options specified, as well as the list of their arguments.
+     *
+     * @return a map of all options specified; values are lists of arguments
+     */
+    public Map<String, List<String>> getOptionValues() {
+        return optvals;
+    }
+
+    /**
+     * Constructor.  
+     *
+     * @param options Map of options to parse.  The key should be an option string (including
+     * any initial dashes), and the value should be an Integer representing the number of
+     * arguments to parse following the option.
+     * @param descriptions Map of option descriptions.
+     */
+    public Getopt(Map<String, Integer> options, Map<String, String> descriptions) {
+        this.options = options;
+        this.descriptions = descriptions;
+    }
+    /**
+     * Constructor.  
+     */
+    public Getopt() {
+        this.options = new HashMap<String, Integer>();
+        this.descriptions = new HashMap<String, String>();
+    }
+
+    /**
+     * Determines whether or not the option was specified when the arguments were parsed.
+     *
+     * @return true iff the argument was specified (with the correct number of arguments).
+     */
+    public boolean hasOption(String opt) {
+        return optvals.containsKey(opt);
+    }
+
+    /**
+     * Gets the list of arguments for a given option, or null if the option wasn't
+     * specified.
+     * 
+     * @param option the option 
+     * @return the list of arguments for option
+     */
+    public List<String> getArguments(String option) {
+        return optvals.get(option);
+    }
+
+    /**
+     * Add an option to the internal set, including the number of arguments and the
+     * description. 
+     *
+     * @param option option string, including any leading dashes
+     * @param arguments number of arguments
+     * @param description description of the option
+     */
+    public void addOption(String option, int arguments, String description) {
+        options.put(option, arguments);
+        descriptions.put(option, description);
+    }
+
+    /**
+     * Do the parsing/validation.
+     * @param args arguments to parse
+     * @throws OptionParseException if a parse error occurs (the exception message will
+     * have details)
+     */
+    public void parse(String[] args) throws OptionParseException {
+        this.otherargs = new ArrayList<String>();
+        this.optvals = new HashMap<String, List<String>>();
+
+        for(int i = 0; i < args.length; i++) {
+            if(optvals != null) {
+                Integer count = options.get(args[i]);
+                if(count != null) {
+                    ArrayList<String> al = new ArrayList<String>(count.intValue());
+                    for(int j = 0; j < count; j++) {
+                        if(i+1+j >= args.length) {
+                            throw new OptionParseException("expected " + count + " arguments after " + args[i]);
+                        }
+                        al.add(args[i+1+j]);
+                    }
+                    List<String> oldal = optvals.get(args[i]);
+                    if(oldal == null) {
+                        optvals.put(args[i], al);
+                    } else {
+                        oldal.addAll(al);
+                    }
+                    i += count;
+                    continue;
+                }
+            }
+            otherargs.add(args[i]);
+        }
+    }
+
+    /**
+     * Get a tabular description of all options and their descriptions, one per line.
+     */
+    public String getDescriptionString() {
+        String linesep = System.getProperty("line.separator");
+        StringBuffer sb = new StringBuffer();
+        if(options != null && options.size() > 0) {
+            sb.append("Options:").append(linesep);
+            TreeSet<String> opts = new TreeSet<String>(this.options.keySet());
+            for(String opt: opts) {
+                sb.append("    ").append(opt);
+                for(int i = 0; i < options.get(opt); i++) {
+                    sb.append(" arg").append(i+1);
+                }
+                sb.append(": ").append(descriptions.get(opt)).append(linesep);
+            }
+        }
+        return sb.toString();
+    }
+
+    public static void main(String[] args) {
+        try {
+            HashMap<String, Integer> options = new HashMap<String, Integer>();
+            Getopt go = new Getopt();
+            go.addOption("-optzero", 0, "zero-arg constructor");
+            go.addOption("-optone", 1, "one-arg constructor");
+            go.addOption("-opttwo", 2, "two-arg constructor");
+            go.parse(args);
+            System.out.println(go.getDescriptionString());
+            System.out.println("options:");
+            Map<String, List<String>> optvals = go.getOptionValues();
+            for(String opt: optvals.keySet()) {
+                System.out.print("    " + opt);
+                for(String optval: optvals.get(opt)) {
+                    System.out.print(" " + optval);
+                }
+                System.out.println("");
+            }
+            System.out.println("");
+            System.out.println("otherargs:");
+            for(String arg: go.getOtherArguments()) {
+                System.out.println("    " + arg);
+            }
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/LoggerInputStream.java

@@ +1 @@
+package jdeserialize;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * An InputStream designed to record data passing through the stream after a call to
+ * record() is made.  After record() is called, the results from every read will 
+ * be stored in an * internal buffer.  The contents of the buffer can be 
+ * retrieved by getRecordedData(); to stop recording and clear the internal 
+ * buffer, call stopRecording().
+ * </p>
+ *
+ * <p>
+ * <b>Note</b>: calls to mark() and reset() are merely passed through to the inner stream; if
+ * recording is active, the buffer won't be backtracked by reset().
+ * </p>
+ */
+public class LoggerInputStream extends InputStream {
+    private InputStream innerStream = null;
+    private ByteArrayOutputStream baos = null;
+    private boolean recording = false; 
+
+    public LoggerInputStream(InputStream innerStream) {
+        super();
+        this.innerStream = innerStream;
+    }
+    public synchronized int read() throws IOException {
+        int i = innerStream.read();
+        if(recording && i != -1) {
+            if(i > 255 || i < 0) {
+                throw new IOException("non-byte, non--1 value read from inner stream: " + i);
+            }
+            baos.write((byte)i);
+        }
+        return i;
+    }
+    public synchronized int read(byte[] b) throws IOException {
+        return this.read(b, 0, b.length);
+    }
+    public synchronized int read(byte[] b, int off, int len) throws IOException {
+        int retval = innerStream.read(b, off, len);
+        if(recording && retval > 0) {
+            if(retval > len) {
+                throw new IOException("inner stream read(byte[], int, int) violating contract; return value > len: " + retval);
+            }
+            baos.write(b, off, retval);
+        }
+        return retval;
+    }
+    public synchronized long skip(long n) throws IOException {
+        if(n < 0) {
+            throw new IOException("can't skip negative number of bytes");
+        }
+        if(recording == false) {
+            return innerStream.skip(n);
+        }
+        long nskipped = 0;
+        while(n > Integer.MAX_VALUE) {
+            long ret = skip(Integer.MAX_VALUE);
+            nskipped += ret;
+            if(ret < Integer.MAX_VALUE) {
+                return nskipped;
+            }
+            n -= ret;
+        }
+        int toread = (int)n, actuallyread = 0;
+        byte[] buf = new byte[10240];
+        while(toread > 0) {
+            int r = Math.min(toread, buf.length);
+            int rret = this.read(buf, 0, r);
+            actuallyread += rret;
+            toread -= rret;
+            if(rret < r) {
+                break;
+            }
+        }
+        return actuallyread;
+    }
+    public synchronized int available() throws IOException {
+        return innerStream.available();
+    }
+    public synchronized void close() throws IOException {
+        innerStream.close();
+    }
+    public synchronized void mark(int readlimit) {
+        innerStream.mark(readlimit);
+    }
+    public synchronized void reset() throws IOException {
+        innerStream.reset();
+    }
+    public boolean markSupported() {
+        return innerStream.markSupported();
+    }
+    /**
+     * If not currently recording, start recording.  If the stream is currently recording,
+     * the current buffer is cleared.
+     */
+    public synchronized void record() {
+        recording = true;
+        baos = new ByteArrayOutputStream();
+    }
+    /**
+     * Stops recording and clears the internal buffer.  If recording is not active, an
+     * IOException is thrown.
+     *
+     * @throws IOException if recording is not currently active
+     */
+    public synchronized void stopRecording() throws IOException {
+        if(recording == false) {
+            throw new IOException("recording not active");
+        }
+        try {
+            baos.close();
+        } catch (IOException ignore) {}
+        baos = null;
+        recording = false;
+    }
+    /**
+     * Returns the data recorded so far; if recording is not active, an empty buffer
+     * is returned.
+     */
+    public synchronized byte[] getRecordedData() {
+        if(recording == false) {
+            return new byte[0];
+        }
+        return baos.toByteArray();
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/ValidityException.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Exception that denotes that data in the stream did not conform to the constraints
+ * imposed by the specification.
+ */
+public class ValidityException extends IOException {
+    public static final long serialVersionUID = 2277356908919241L;
+    public ValidityException(String msg) {
+        super(msg);
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/arraycoll.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>Typed collection used for storing the values of a serialized array.  </p>
+ *
+ * <p>Primitive types are stored using their corresponding objects; for instance, an int is
+ * stored as an Integer.  To determine whether or not this is an array of ints or of
+ * Integer instances, check the name in the arrayobj's class description.</p>
+ */
+public class arraycoll extends ArrayList<Object> {
+    public static final long serialVersionUID = 2277356908919248L;
+
+    private fieldtype ftype;
+
+    /**
+     * Constructor.
+     * @param ft field type of the array
+     */
+    public arraycoll(fieldtype ft) {
+        super();
+        this.ftype = ft;
+    }
+
+    /**
+     * Gets the field type of the array.
+     *
+     * @return the field type of the array
+     */
+    public fieldtype getFieldType() {
+        return ftype;
+    }
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append("[arraycoll sz ").append(this.size());
+        boolean first = true;
+        for(Object o: this) {
+            if(first) {
+                first = false;
+                sb.append(' ');
+            } else {
+                sb.append(", ");
+            }
+            sb.append(o.toString());
+        }
+        return sb.toString();
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/arrayobj.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>Represents an array instance, including the values the comprise the array.  </p>
+ *
+ * <p>Note that in arrays of primitives, the classdesc will be named "[x", where x is the
+ * field type code representing the primitive type.  See jdeserialize.resolveJavaType()
+ * for an example of analysis/generation of human-readable names from these class names.</p>
+ */
+public class arrayobj extends contentbase {
+    /**
+     * Type of the array instance.
+     */
+    public classdesc classdesc;
+
+    /**
+     * Values of the array, in the order they were read from the stream.
+     */
+    public arraycoll data;
+
+    public arrayobj(int handle, classdesc cd, arraycoll data) {
+        super(contenttype.ARRAY);
+        this.handle = handle;
+        this.classdesc = cd;
+        this.data = data;
+    }
+    public String toString() {
+        return "[array " + jdeserialize.hex(handle) + " classdesc " + classdesc.toString() + ": " 
+            + data.toString() + "]";
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/blockdata.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+
+/**
+ * Represents an opaque block of data written to the stream.  Primarily, these are used to
+ * write class and object annotations by ObjectOutputStream overrides; they can also occur
+ * inside an object, when the object overrides Serializable.writeObject().  Their
+ * interpretation is hereby left to users.
+ */
+public class blockdata extends contentbase {
+    /**
+     * The block data read from the stream.
+     */
+    public byte[] buf;
+
+    /**
+     * Constructor.
+     *
+     * @param buf the block data
+     */
+    public blockdata(byte[] buf) {
+        super(contenttype.BLOCKDATA);
+        this.buf = buf;
+    }
+    public String toString() {
+        return "[blockdata " + jdeserialize.hex(handle) + ": " + buf.length + " bytes]";
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/classdesc.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * Represents the entire serialized prototype of the class, including all fields,
+ * inner classes, class annotations, and inheritance hierarchy.  This includes proxy class
+ * descriptions.
+ * </p>
+ *
+ * <p>
+ * Generally, this class is used to represent the type of an instance written to an
+ * ObjectOutputStream with its writeObject() method, or of a related array or field type.
+ * However, there's a notable exception: when instances of type java.io.ObjectStreamClass
+ * are written with writeObject(), only their class description is written (cf. Object
+ * Serialization Specification, 4.3).  They will be represented with an instance of
+ * classdesc as well.
+ * </p>
+ */
+public class classdesc extends contentbase {
+    /**
+     * Type of the class being represented; either a normal class or a proxy class.
+     */
+    public classdesctype classtype;
+
+    /**
+     * Class name.
+     */
+    public String name;
+
+    /**
+     * Serial version UID, as recorded in the stream.
+     */
+    public long serialVersionUID;
+
+    /**
+     * Description flags byte; this should be a mask of values from the ObjectStreamContants 
+     * class.  Refer to chapter 6 of the Object Stream Serialization Protocol for details.
+     */
+    public byte descflags;
+
+    /**
+     * Array of fields in the class, in the order serialized by the stream writer.
+     */
+    public field[] fields;
+
+    /**
+     * List of inner classes, in the order serialized by the stream writer.
+     */
+    public List<classdesc> innerclasses;
+    
+    /**
+     * List of annotation objects; these are *not* Java annotations, but data written by
+     * the <pre>annotateClass(Class<?>)<pre> and <pre>annotateProxyClass(Class<?>)</pre> methods of an
+     * ObjectOutputStream.  
+     */
+    public List<content> annotations;
+
+    /**
+     * The superclass of the object, if available.
+     */
+    public classdesc superclass;
+
+    /**
+     * Array of serialized interfaces, in the order serialized by the stream writer.
+     */
+    public String[] interfaces;
+
+    /**
+     * Set of enum constants, for enum classes.
+     */
+    public Set<String> enumconstants;
+
+    private boolean isInnerClass = false;
+    /**
+     * True if this class has been determined to be an inner class; this determination is
+     * generally made by connectMemberClasses().
+     * 
+     * @return true if the class is an inner class
+     */
+    public boolean isInnerClass() {
+        return isInnerClass;
+    }
+    /**
+     * Sets the value that denotes that the class is an inner class.
+     *
+     * @param nis the value to set
+     */
+    public void setIsInnerClass(boolean nis) {
+        this.isInnerClass = nis;
+    }
+
+    private boolean isLocalInnerClass = false;
+    /**
+     * True if this class has been determined to be a local inner class; this
+     * determination is generally made by connectMemberClasses().
+     *
+     * @return true if the class is a local inner class
+     */
+    public boolean isLocalInnerClass() {
+        return isLocalInnerClass;
+    }
+    /**
+     * Sets the flag that denotes whether this class is a local inner class.
+     * 
+     * @param nis the value to set
+     */
+    public void setIsLocalInnerClass(boolean nis) {
+        this.isLocalInnerClass = nis;
+    }
+
+    private boolean isStaticMemberClass = false;
+    /**
+     * <p>
+     * True if this class has been determined to be a static member class; this
+     * determination is generally made by connectMemberClasses().
+     * </p>
+     *
+     * <p>
+     * Note that in some cases, static member classes' descriptions will be serialized
+     * even though their enclosing class is not.  In these cases, this may return false.
+     * See connectMemberClasses() for details.
+     * </p>
+     *
+     * @return true if this is a static member class
+     */
+    public boolean isStaticMemberClass() {
+        return isStaticMemberClass;
+    }
+    /**
+     * Sets the flag that denotes whether this class is a static member class.
+     *
+     * @param nis the value to set
+     */
+    public void setIsStaticMemberClass(boolean nis) {
+        this.isStaticMemberClass = nis;
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param classtype the type of the class
+     */
+    public classdesc(classdesctype classtype) {
+        super(contenttype.CLASSDESC);
+        this.classtype = classtype;
+        this.enumconstants = new HashSet<String>();
+        this.innerclasses = new ArrayList<classdesc>();
+    }
+
+    /**
+     * Add an inner class to the description's list.
+     * @param cd inner class to add
+     */
+    public void addInnerClass(classdesc cd) {
+        innerclasses.add(cd);
+    }
+
+    /**
+     * Add an enum constant to the description's set.
+     *
+     * @param constval enum constant string
+     */
+    public void addEnum(String constval) {
+        this.enumconstants.add(constval);
+    }
+
+    /**
+     * Determines whether this is an array type. 
+     * @return true if this is an array type.
+     */
+    public boolean isArrayClass() {
+        if(name != null && name.length() > 1 && name.charAt(0) == '[') {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append("[cd ").append(jdeserialize.hex(handle)).append(": name ").append(name);
+        sb.append(" uid ").append(serialVersionUID);
+        sb.append("]");
+        return sb.toString();
+    }
+
+    /**
+     * Generates a list of all class descriptions in this class's hierarchy, in the order
+     * described by the Object Stream Serialization Protocol.  This is the order in which
+     * fields are read from the stream.
+     * 
+     * @param classes a list to be filled in with the hierarchy
+     */
+    public void getHierarchy(ArrayList<classdesc> classes) {
+        if(superclass != null) {
+            if(superclass.classtype == classdesctype.PROXYCLASS) {
+                jdeserialize.debugerr("warning: hit a proxy class in superclass hierarchy");
+            } else {
+                superclass.getHierarchy(classes);
+            }
+        } 
+        classes.add(this);
+    }
+    public void validate() throws ValidityException {
+        // If neither SC_SERIALIZABLE nor SC_EXTERNALIZABLE is set, then the number of
+        // fields is always zero.  (spec section 4.3)
+        if((descflags & (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) == 0 && fields != null && fields.length > 0) {
+            throw new ValidityException("non-serializable, non-externalizable class has fields!");
+        }
+        if((descflags & (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) == (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) {
+            throw new ValidityException("both Serializable and Externalizable are set!");
+        }
+        if((descflags & ObjectStreamConstants.SC_ENUM) != 0) {
+            // we're an enum; shouldn't have any fields/superinterfaces
+            if((fields != null && fields.length > 0) || interfaces != null) {
+                throw new ValidityException("enums shouldn't implement interfaces or have non-constant fields!");
+            }
+        } else {
+            // non-enums shouldn't have enum constant fields.  
+            if(enumconstants != null && enumconstants.size() > 0) {
+                throw new ValidityException("non-enum classes shouldn't have enum constants!");
+            }
+        }
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/classdesctype.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * Enum for class description types.
+ */
+public enum classdesctype {
+    NORMALCLASS, PROXYCLASS
+}

demo_jh/Deserializer_tests/src/jdeserialize/classobj.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * This represents a Class object (i.e. an instance of type Class) serialized in the
+ * stream.
+ */
+public class classobj extends contentbase {
+    /**
+     * The class description, including its name.
+     */
+    public classdesc classdesc;
+
+    /**
+     * Constructor.
+     *
+     * @param handle the instance's handle
+     * @param cd the instance's class description
+     */
+    public classobj(int handle, classdesc cd) {
+        super(contenttype.CLASS);
+        this.handle = handle;
+        this.classdesc = cd;
+    }
+    public String toString() {
+        return "[class " + jdeserialize.hex(handle) + ": " + classdesc.toString() + "]";
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/content.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * Generic interface for all data that may be read from the stream (except null).  
+ * </p>
+ *
+ * <p>
+ * A successful read of the stream will result in a series of content instances or null
+ * references.  For details on specific metadata, see documentation on implementing
+ * classes/subinterfaces.
+ * </p>
+ */
+public interface content {
+    /**
+     * @return the type of instance represented by this object.
+     */
+    public contenttype getType();
+
+    /**
+     * <p>
+     * Get the numeric handle by which this object was referred to in the object stream.
+     * These handles are used internally by Object{Output,Input}Stream as a mechanism to
+     * avoid costly duplication.
+     * </p>
+     *
+     * <p>
+     * CAUTION: they are *not* necessarily unique across all objects in a given stream!
+     * If an exception was thrown during serialization (which is most likely to happen
+     * during a serialized objct's writeObject() implementation), then the stream resets
+     * before and after the exception is serialized.  
+     * </p>
+     *
+     * @return the handle assigned in the stream
+     */
+    public int getHandle();
+
+    /**
+     * Performs extra object-specific validity checks.  
+     *
+     * @throws ValidityException if the object's state is invalid
+     */
+    public void validate() throws ValidityException;
+
+    /**
+     * <p>
+     * Tells whether or not this object is an exception that was caught during
+     * serialization.  
+     * </p>
+     *
+     * <p>
+     * <b>Note</b>:  Not every Throwable or Exception in the stream will have this flag set to
+     * true; only those which were thrown <i>during serialization</i> will
+     * </p>
+     * 
+     * @return true iff the object was an exception thrown during serialization
+     */
+    public boolean isExceptionObject();
+
+    /**
+     * Sets the flag that tells whether or not this object is an exception that was caught
+     * during serialization.
+     *
+     * @param value the new value to use
+     */
+    public void setIsExceptionObject(boolean value);
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/contentbase.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Provides a skeleton content implementation.
+ */
+public class contentbase implements content {
+    public int handle;
+    public boolean isExceptionObject;
+    protected contenttype type;
+    public contentbase(contenttype type) {
+        this.type = type;
+    }
+    public boolean isExceptionObject() {
+        return isExceptionObject;
+    }
+    public void setIsExceptionObject(boolean value) {
+        isExceptionObject = value;
+    }
+    public contenttype getType() {
+        return type;
+    }
+    public int getHandle() {
+        return this.handle;
+    }
+    public void validate() throws ValidityException {
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/contenttype.java

@@ +1 @@
+package jdeserialize;
+
+public enum contenttype {
+    INSTANCE, CLASS, ARRAY, STRING, ENUM, CLASSDESC, BLOCKDATA, EXCEPTIONSTATE
+}

demo_jh/Deserializer_tests/src/jdeserialize/enumobj.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * Represents an enum instance.  As noted in the serialization spec, this consists of
+ * merely the class description (represented by a classdesc) and the string corresponding
+ * to the enum's value.  No other fields are ever serialized.
+ * </p>
+ */
+public class enumobj extends contentbase {
+    /**
+     * The enum's class description.
+     */
+    public classdesc classdesc;
+
+    /**
+     * The string that represents the enum's value.
+     */
+    public stringobj value;
+
+    /**
+     * Constructor.
+     *
+     * @param handle the enum's handle
+     * @param cd the enum's class description
+     * @param so the enum's value
+     */
+    public enumobj(int handle, classdesc cd, stringobj so) {
+        super(contenttype.ENUM);
+        this.handle = handle;
+        this.classdesc = cd;
+        this.value = so;
+    }
+    public String toString() {
+        return "[enum " + jdeserialize.hex(handle) + ": " + value.value + "]";
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/exceptionstate.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * This object contains embedded information about a serialization that failed, throwing
+ * an exception.  It includes the actual exception object (which was serialized by the
+ * ObjectOutputStream) and the raw bytes of the stream data that was read before the
+ * exception was recognized.
+ * </p>
+ *
+ * <p>
+ * For the mechanics of exception serialization, see the Object Serialization
+ * Specification.
+ * </p>
+ */
+public class exceptionstate extends contentbase {
+    /**
+     * The serialized exception object.
+     */
+    public content exceptionobj;
+    
+    /**
+     * <p>
+     * An array of bytes representing the data read before the exception was encountered.
+     * Generally, this starts with the first "tc" byte (cf. protocol spec), which is an
+     * ObjectStreamConstants value and ends with 0x78 (the tc byte corresponding to
+     * TC_EXCEPTION).  However, this isn't guaranteed; it may include *more* data.  
+     * </p>
+     *
+     * <p>
+     * In other words, this is the incomplete object that was being written while the
+     * exception was caught by the ObjectOutputStream.  It is not likely to be cleanly
+     * parseable.
+     * </p>
+     *
+     * <p>
+     * The uncertainty centers around the fact that this data is gathered by jdeserialize
+     * using a LoggerInputStream, and the underlying DataInputStream may have read more
+     * than is necessary.  In all tests conducted so far, the above description is
+     * accurate.
+     * </p>
+     */
+    public byte[] streamdata;
+
+    /**
+     * Consturctor.
+     * @param exobj the serialized exception object 
+     * @param data the array of stream bytes that led up to the exception
+     */
+    public exceptionstate(content exobj, byte[] data) {
+        super(contenttype.EXCEPTIONSTATE);
+        this.exceptionobj = exobj;
+        this.streamdata = data;
+        this.handle = exobj.getHandle();
+    }
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append("[exceptionstate object " + exceptionobj.toString() + "  buflen " + streamdata.length);
+        if(streamdata.length > 0) {
+            for(int i = 0; i < streamdata.length; i++) {
+                if((i % 16) == 0) {
+                    sb.append(jdeserialize.linesep).append(String.format("%7x: ", Integer.valueOf(i)));
+                }
+                sb.append(" ").append(jdeserialize.hexnoprefix(streamdata[i]));
+            }
+            sb.append(jdeserialize.linesep);
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/field.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * This class represents a field within a class description/declaration (classdesc).  It
+ * contains information about the type and name of the field.  Fields themselves don't
+ * have a handle; inside the stream, they exist only as part of a class description.
+ */
+public class field {
+    /**
+     * The type of the field.
+     */
+    public fieldtype type;
+
+    /**
+     * The name of the field.
+     */
+    public String name; 
+
+    /**
+     * The string object representing the class name.
+     */
+    public stringobj classname; 
+
+    private boolean isInnerClassReference = false;
+
+    /**
+     * Tells whether or not this class is an inner class reference.  This value is set by
+     * connectMemberClasses() -- if this hasn't been called, or if the field hasn't been
+     * otherwise set by setIsInnerClassReference(), it will be false;
+     *
+     * @return true if the class is an inner class reference
+     */
+    public boolean isInnerClassReference() {
+        return isInnerClassReference;
+    }
+
+    /**
+     * Sets the flag that denotes whether this class is an inner class reference.
+     *
+     * @param nis the value to set; true iff the class is an inner class reference.
+     */
+    public void setIsInnerClassReference(boolean nis) {
+        this.isInnerClassReference = nis;
+    }
+
+    /**
+     * Constructor.  
+     *
+     * @param type the field type
+     * @param name the field name
+     * @param classname the class name
+     */
+    public field(fieldtype type, String name, stringobj classname) throws ValidityException {
+        this.type = type;
+        this.name = name;
+        this.classname = classname;
+        if(classname != null) {
+            validate(classname.value);
+        }
+    }
+
+    /**
+     * Constructor for simple fields.
+     * 
+     * @param type the field type
+     * @param name the field name
+     */
+    public field(fieldtype type, String name) throws ValidityException {
+        this(type, name, null);
+    }
+
+    /**
+     * Get a string representing the type for this field in Java (the language)
+     * format.
+     * @return a string representing the fully-qualified type of the field
+     * @throws IOException if a validity or I/O error occurs
+     */
+    public String getJavaType() throws IOException {
+        return jdeserialize.resolveJavaType(this.type, this.classname == null ? null : this.classname.value, true, false);
+    }
+    
+    /**
+     * Changes the name of an object reference to the name specified.  This is used by
+     * the inner-class-connection code to fix up field references.
+     * @param newname the fully-qualified class 
+     * @throws ValidityException if the field isn't a reference type, or another
+     * validity error occurs
+     */
+    public void setReferenceTypeName(String newname) throws ValidityException {
+        if(this.type != fieldtype.OBJECT) {
+            throw new ValidityException("can't fix up a non-reference field!");
+        }
+        String nname = "L" + newname.replace('.', '/') + ";";
+        this.classname.value = nname;
+    }
+    public void validate(String jt) throws ValidityException {
+        if(this.type == fieldtype.OBJECT) {
+            if(jt == null) {
+                throw new ValidityException("classname can't be null");
+            }
+            if(jt.charAt(0) != 'L') {
+                throw new ValidityException("invalid object field type descriptor: " + classname.value);
+            }
+            int end = jt.indexOf(';');
+            if(end == -1 || end != (jt.length()-1)) {
+                throw new ValidityException("invalid object field type descriptor (must end with semicolon): " + classname.value);
+            }
+        }
+    }
+}

demo_jh/Deserializer_tests/src/jdeserialize/fieldtype.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * <p>
+ * Enum class that describes the type of a field encoded inside a classdesc description.
+ * </p>
+ *
+ * <p>
+ * This stores both information on the type (reference/array vs. primitive) and, in cases
+ * of reference or array types, the name of the class being referred to.  
+ * </p>
+ */
+public enum fieldtype {
+    BYTE ('B', "byte"),
+    CHAR ('C', "char"),
+    DOUBLE ('D', "double"), 
+    FLOAT ('F', "float"),
+    INTEGER ('I', "int"),
+    LONG ('J', "long"),
+    SHORT ('S', "String"),
+    BOOLEAN ('Z', "boolean"),
+    ARRAY ('['),
+    OBJECT ('L');
+    private final char ch;
+    private final String javatype;
+
+    /**
+     * Constructor for non-object (primitive) types.
+     *
+     * @param ch the character representing the type (must match one of those listed in
+     * prim_typecode or obj_typecode in the Object Serialization Stream Protocol)
+     */
+    fieldtype(char ch) {
+        this(ch, null);
+    }
+
+    /**
+     * Constructor.
+     *
+     * @param ch the character representing the type (must match one of those listed in
+     * prim_typecode or obj_typecode in the Object Serialization Stream Protocol)
+     * @param javatype the name of the object class, where applicable (or null if not)
+     */
+    fieldtype(char ch, String javatype) {
+        this.ch = ch;
+        this.javatype = javatype;
+    }
+
+    /**
+     * Gets the class name for a reference or array type.
+     *
+     * @return the name of the class being referred to, or null if this is not a
+     * reference/array type
+     */
+    public String getJavaType() {
+        return this.javatype;
+    }
+
+    /**
+     * Gets the type character for this field.
+     *
+     * @return the type code character for this field; values will be one of those in
+     * prim_typecode or obj_typecode in the protocol spec
+     */
+    public char ch() { return ch; }
+
+    /**
+     * Given a byte containing a type code, return the corresponding enum.
+     *
+     * @param b the type code; must be one of the charcaters in obj_typecode or
+     * prim_typecode in the protocol spec
+     * @return the corresponding fieldtype enum
+     * @throws ValidityException if the type code is invalid
+     */
+    public static fieldtype get(byte b) throws ValidityException {
+        switch(b) {
+            case 'B': 
+                return BYTE;
+            case 'C':
+                return CHAR;
+            case 'D':
+                return DOUBLE;
+            case 'F':
+                return FLOAT;
+            case 'I':
+                return INTEGER;
+            case 'J':
+                return LONG;
+            case 'S':
+                return SHORT;
+            case 'Z':
+                return BOOLEAN;
+            case '[':
+                return ARRAY;
+            case 'L':
+                return OBJECT;
+            default:
+                throw new ValidityException("invalid field type char: " + b);
+        }
+    }
+}
+

demo_jh/Deserializer_tests/src/jdeserialize/instance.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Represents an instance of a non-enum, non-Class, non-ObjectStreamClass, 
+ * non-array class, including the non-transient field values, for all classes in its
+ * hierarchy and inner classes.
+ */
+public class instance extends contentbase {
+    /**
+     * Collection of field data, organized by class description.  
+     */
+    public Map<classdesc, Map<field, Object>> fielddata;
+
+    /**
+     * Class description for this instance.
+     */
+    public classdesc classdesc;
+
+    /**
+     * Constructor.
+     */
+    public instance() {
+        super(contenttype.INSTANCE);
+        this.fielddata = new HashMap<classdesc, Map<field, Object>>();
+    }
+    public String toString() {
+        StringBuffer sb = new StringBuffer();
+        sb.append(classdesc.name).append(' ').append("_h").append(jdeserialize.hex(handle))
+            .append(" = r_").append(jdeserialize.hex(classdesc.handle)).append(";  ");
+        //sb.append("// [instance " + jdeserialize.hex(handle) + ": " + jdeserialize.hex(classdesc.handle) + "/" + classdesc.name).append("]");
+        return sb.toString();
+    }
+    /**
+     * Object annotation data.
+     */
+    public Map<classdesc, List<content>> annotations;
+}

demo_jh/Deserializer_tests/src/jdeserialize/jdeserialize.java

@@ +1 @@
+package jdeserialize;
+
+import java.io.*;
+import java.util.*;
+import java.util.regex.*;
+
+/**
+ * The main user-facing class for the jdeserialize library.  Also the implementation of
+ * the command-line tool.<br/>
+ * <br/>
+ * Library:<br/>
+ * <br/>
+ * The jdeserialize class parses the stream (method run()).  From there, call the
+ * getContent() method to get an itemized list of all items written to the stream, 
+ * or getHandleMaps() to get a list of all handle->content maps generated during parsing.
+ * The objects are generally instances that implement the interface "content"; see the
+ * documentation of various implementors to get more information about the inner
+ * representations.<br/>
+ * <br/>
+ * To enable debugging on stdout, use the enableDebug() or disableDebug() options.   <br/> 
+ * <br/>
+ * <br/>
+ * Command-line tool:   <br/>
+ * <br/>
+ * The tool reads in a set of files and generates configurable output on stdout.  The
+ * primary output consists of three separate stages.  The first stage is  a textual 
+ * description of every piece of content in the stream, in the order it was written.
+ * There is generally a one-to-one mapping between ObjectOutputStream.writeXXX() calls and
+ * items printed in the first stage.  The first stage may be suppressed with the
+ * -nocontent command-line option. <br/>
+ * <br/>
+ * The second stage is a list of every class declaration serialized in the file.  These
+ * are formatted as normal Java language class declarations.  Several options are
+ * available to govern this stage, including -filter, -showarrays, -noclasses, and
+ * -fixnames. <br/>
+ * <br/>
+ * The third stage is a dump of every instance embedded inside the stream, including
+ * textual descriptions of field values.  This is useful for casual viewing of class data. 
+ * To suppress this stage, use -noinstances. <br/>
+ * <br/>
+ * You can also get debugging information generated during the parse phase by supplying
+ * -debug.
+ * <br/>
+ * The data from block data objects can be extracted with the -blockdata <file> option.
+ * Additionally, a manifest describing the size of each individual block can be generated
+ * with the -blockdatamanifest <file> option.
+ * <br/>
+ * References: <br/>
+ *     - Java Object Serialization Specification ch. 6 (Object Serialization Stream
+ *       Protocol): <br/>
+ *       http://download.oracle.com/javase/6/docs/platform/serialization/spec/protocol.html <br/>
+ *     - "Modified UTF-8 Strings" within the JNI specification: 
+ *       http://download.oracle.com/javase/1.5.0/docs/guide/jni/spec/types.html#wp16542 <br/>
+ *     - "Inner Classes Specification" within the JDK 1.1.8 docs:
+ *       http://java.sun.com/products/archive/jdk/1.1/ <br/>
+ *     - "Java Language Specification", third edition, particularly section 3:
+ *       http://java.sun.com/docs/books/jls/third_edition/html/j3TOC.html <br/>
+ *
+ * @see content
+ */
+public class jdeserialize {
+    public static final long serialVersionUID = 78790714646095L;
+    public static final String INDENT = "    ";
+    public static final int CODEWIDTH = 90;
+    public static final String linesep = System.getProperty("line.separator");
+    public static final String[] keywords = new String[] {
+        "abstract", "continue", "for", "new", "switch", "assert", "default", "if",
+        "package", "synchronized", "boolean", "do", "goto", "private", "this",
+        "break", "double", "implements", "protected", "throw", "byte", "else",
+        "import", "public", "throws", "case", "enum", "instanceof", "return",
+        "transient", "catch", "extends", "int", "short", "try", "char", "final",
+        "interface", "static", "void", "class", "finally", "long", "strictfp",
+        "volatile", "const", "float", "native", "super", "while" };