db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r158176 [5/79] - in incubator/jdo/trunk/ri11: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/ejb/ src/java/org/apache/jdo/enhancer/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/enhancer/ src/java/org/apache/jdo/impl/enhancer/classfile/ src/java/org/apache/jdo/impl/enhancer/core/ src/java/org/apache/jdo/impl/enhancer/generator/ src/java/org/apache/jdo/impl/enhancer/meta/ src/java/org/apache/jdo/impl/enhancer/meta/model/ src/java/org/apache/jdo/impl/enhancer/meta/prop/ src/java/org/apache/jdo/impl/enhancer/meta/util/ src/java/org/apache/jdo/impl/enhancer/util/ src/java/org/apache/jdo/impl/fostore/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/impl/model/ src/java/org/apache/jdo/impl/model/java/ src/java/org/apache/jdo/impl/model/java/runtime/ src/java/org/apache/jdo/impl/model/jdo/ src/java/org/apache/jdo/impl/model/jdo/caching/ src/java/org/apache/jdo/impl/model/jdo/util/ src/java/org/apache/jdo/impl/model/jdo/xml/ src/java/org/apache/jdo/impl/pm/ src/java/org/apache/jdo/impl/sco/ src/java/org/apache/jdo/impl/state/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/ src/java/org/apache/jdo/model/ src/java/org/apache/jdo/model/java/ src/java/org/apache/jdo/model/jdo/ src/java/org/apache/jdo/pm/ src/java/org/apache/jdo/sco/ src/java/org/apache/jdo/state/ src/java/org/apache/jdo/store/ src/java/org/apache/jdo/util/ test/ test/conf/ test/enhancer/ test/enhancer/sempdept/ test/enhancer/sempdept/src/ test/enhancer/sempdept/src/empdept/ test/fsuid2/ test/fsuid2/org/ test/fsuid2/org/apache/ test/fsuid2/org/apache/jdo/ test/fsuid2/org/apache/jdo/pc/ test/java/ test/java/org/ test/java/org/apache/ test/java/org/apache/jdo/ test/java/org/apache/jdo/impl/ test/java/org/apache/jdo/impl/fostore/ test/java/org/apache/jdo/pc/ test/java/org/apache/jdo/pc/appid/ test/java/org/apache/jdo/pc/empdept/ test/java/org/apache/jdo/pc/serializable/ test/java/org/apache/jdo/pc/xempdept/ test/java/org/apache/jdo/test/ test/java/org/apache/jdo/test/query/ test/java/org/apache/jdo/test/util/ test/jdo/ test/jdo/org/ test/jdo/org/apache/ test/jdo/org/apache/jdo/ test/jdo/org/apache/jdo/pc/ test/jdo/org/apache/jdo/pc/appid/ test/jdo/org/apache/jdo/pc/empdept/ test/jdo/org/apache/jdo/pc/serializable/ test/jdo/org/apache/jdo/pc/xempdept/ xdocs/
Date Sat, 19 Mar 2005 01:05:57 GMT
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/PersistenceLauncher.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/PersistenceLauncher.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/PersistenceLauncher.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/PersistenceLauncher.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,284 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.impl.enhancer;
+
+import java.util.Properties;
+
+import java.io.PrintWriter;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+
+import org.apache.jdo.impl.enhancer.util.Support;
+
+
+
+/**
+ * Application launcher for persistence-capable classes.
+ *
+ * @author Martin Zaun
+ */
+public class PersistenceLauncher {
+
+    // chose whether to separate or join out and err channels
+    //static private final PrintWriter err = new PrintWriter(System.err, true);
+    static private final PrintWriter err = new PrintWriter(System.out, true);
+    static private final PrintWriter out = new PrintWriter(System.out, true);
+    static private final String prefix = "PersistenceLauncher.main() : ";
+
+    /**
+     * Creates new PersistenceLauncher.
+     */
+    private PersistenceLauncher() {
+    }
+
+    /**
+     * Prints usage message.
+     */
+    static void usage()
+    {
+        out.flush();
+        err.println("PersistenceLauncher:");
+        err.println("    usage: <options> ... <target class name> <args> ...");
+        err.println("    options:");
+        err.println("           -h | --help");
+        err.println("           -n | --noEnhancement");
+        err.println("           -q | --quiet");
+        err.println("           -w | --warn");
+        err.println("           -d | --debug");
+        err.println("           -t | --timing");
+        err.println("    class names have to be fully qualified");
+        err.println("done.");
+        err.println();
+        err.flush();
+    }
+
+    /**
+     * Creates a class loader and launches a target class.
+     * @param args the command line arguments
+     */
+    public static void main(String[] args)
+        throws ClassNotFoundException,
+        NoSuchMethodException,
+        SecurityException,
+        IllegalAccessException,
+        IllegalArgumentException,
+        InvocationTargetException {
+/*
+        message("property PersistenceExecutor.TAG_REPOSITORY = "
+                + System.getProperty("PersistenceExecutor.TAG_REPOSITORY"));
+        message("property PersistenceExecutor.TAG_CLASSPATH = "
+                + System.getProperty("PersistenceExecutor.TAG_CLASSPATH"));
+        message("property PersistenceExecutor.TAG_LIBRARY = "
+                + System.getProperty("PersistenceExecutor.TAG_LIBRARY"));
+        message("property PersistenceExecutor.TAG_CLASSNAME = "
+                + System.getProperty("PersistenceExecutor.TAG_CLASSNAME"));
+*/
+
+        // get launcher options
+        final String classpath = System.getProperty("java.class.path");
+        boolean noEnhancement = false;
+        boolean debug = false;
+        boolean timing = false;
+        Properties enhancerSettings = new Properties();
+        String targetClassname = null;
+        String[] targetClassArgs = null;
+        for (int i = 0; i < args.length; i++) {
+            String arg = args[i];
+            if (arg.equals("-h")
+                || arg.equals("--help")) {
+                usage();
+
+                // exit gently
+                return;
+            }
+            if (arg.equals("-n")
+                || arg.equals("--noEnhancement")) {
+                noEnhancement = false;
+                continue;
+            }
+            if (arg.equals("-t")
+                || arg.equals("--timing")) {
+                timing = true;
+                enhancerSettings.setProperty(EnhancerClassLoader.DO_TIMING_STATISTICS,
+                                             "true");
+                continue;
+            }
+            if (arg.equals("-d")
+                || arg.equals("--debug")) {
+                debug = true;
+                enhancerSettings.setProperty(EnhancerClassLoader.VERBOSE_LEVEL,
+                                             EnhancerClassLoader.VERBOSE_LEVEL_DEBUG);
+                continue;
+            }
+            if (arg.equals("-w")
+                || arg.equals("--warn")) {
+                debug = false;
+                enhancerSettings.setProperty(EnhancerClassLoader.VERBOSE_LEVEL,
+                                             EnhancerClassLoader.VERBOSE_LEVEL_WARN);
+                continue;
+            }
+            if (arg.equals("-q")
+                || arg.equals("--quiet")) {
+                debug = false;
+                enhancerSettings.setProperty(EnhancerClassLoader.VERBOSE_LEVEL,
+                                             EnhancerClassLoader.VERBOSE_LEVEL_QUIET);
+                continue;
+            }
+
+            // get target class name
+            targetClassname = arg;
+
+            // copy remaining arguments and leave loop
+            i++;
+            final int length = args.length - i;
+            targetClassArgs = new String[length];
+            System.arraycopy(args, i, targetClassArgs, 0, length);
+            break;
+        }
+
+        // debugging oputput
+        if (debug) {
+            out.println(prefix + "...");
+            out.println("settings and arguments:");
+            out.println("    classpath = " + classpath);
+            out.println("    noEnhancement = " + noEnhancement);
+            out.println("    debug = " + debug);
+            out.println("    enhancerSettings = {");
+            enhancerSettings.list(out);
+            out.println("    }");
+            out.println("    targetClassname = " + targetClassname);
+            out.print("    targetClassArgs = { ");
+            for (int i = 0; i < targetClassArgs.length; i++) {
+                out.print(targetClassArgs[i] + " ");
+            }
+            out.println("}");
+        }
+
+        // check options
+        if (targetClassname == null) {
+            usage();
+            throw new IllegalArgumentException("targetClassname == null");
+        }
+
+        // get class loader
+        final ClassLoader loader;
+        if (noEnhancement) {
+            if (debug) {
+                out.println(prefix + "using system class loader");
+            }
+            //out.println("using system class loader");
+            loader = PersistenceLauncher.class.getClassLoader();
+        } else {
+            if (debug) {
+                out.println(prefix + "creating enhancer class loader");
+            }
+            final Properties settings = enhancerSettings;
+            final PrintWriter out = PersistenceLauncher.out;
+            loader = new EnhancerClassLoader(classpath, settings, out);
+        }
+
+        // get target class' main method
+        Class clazz;
+        Method main;
+        try {
+            final String mname = "main";
+            final Class[] mparams = new Class[]{ String[].class };
+            final boolean init = true;
+            if (debug) {
+                out.println(prefix + "getting method "
+                            + targetClassname + "." + mname + "(String[])");
+            }
+            clazz = Class.forName(targetClassname, init, loader);
+            main = clazz.getDeclaredMethod(mname, mparams);
+        } catch (ClassNotFoundException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        } catch (NoSuchMethodException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        } catch (SecurityException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        }
+
+        // invoke target class' main method
+        try {
+            final Object[] margs = new Object[]{ targetClassArgs };
+            if (debug) {
+                out.println("invoking method " + clazz.getName()
+                            + "." + main.getName() + "(String[])");
+            }
+            main.invoke(null, margs);
+        } catch (IllegalAccessException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        } catch (IllegalArgumentException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        } catch (InvocationTargetException e) {
+            // log exception only
+            if (debug) {
+                out.flush();
+                err.println("PersistenceLauncher: EXCEPTION SEEN: " + e);
+                e.printStackTrace(err);
+                err.flush();
+            }
+            throw e;
+        } finally {
+            if (timing) {
+                Support.timer.print();
+            }
+        }
+
+        if (debug) {
+            out.println(prefix + "done.");
+            out.flush();
+            err.flush();
+        }
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedClassAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedClassAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedClassAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedClassAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * AnnotatedClassAttribute represents a class level attribute
+ * class file which identifies the level of annotation of the class.
+ */
+public class AnnotatedClassAttribute extends ClassAttribute {
+
+    /* The expected attribute name */
+    public final static String expectedAttrName = "filter.annotatedClass";
+
+    /* The expected attribute version */
+    public final static short expectedAttrVersion = 1;
+
+    /* Bit mask indicating that the class was filter generated */
+    public final static short generatedFlag = 0x1;
+
+    /* Bit mask indicating that the class was filter annotated */
+    public final static short annotatedFlag = 0x2;
+
+    /* Bit mask indicating that the class was "repackaged" or similarly
+     * modified */
+    public final static short modifiedFlag = 0x4;
+
+    /* The version of the attribute */
+    private short attrVersion;
+
+    /* Flags associated with the annotation */
+    private short annotationFlags;
+
+    /* The modification date of the class file at the time of modification */
+    private long classModTime;
+
+    /* The date of the annotation */
+    private long classAnnotationTime;
+
+    /* public accessors */
+
+    public short getVersion() {
+        return attrVersion;
+    }
+
+    public void setVersion(short version) {
+        attrVersion = version;
+    }
+
+    public short getFlags() {
+        return annotationFlags;
+    }
+
+    public void setFlags(short flags) {
+        annotationFlags = flags;
+    }
+
+    public long getModTime() {
+        return classModTime;
+    }
+
+    public void setModTime(long time) {
+        classModTime = time;
+    }
+
+    public long getAnnotationTime() {
+        return classAnnotationTime;
+    }
+
+    public void setAnnotationTime(long time) {
+        classAnnotationTime = time;
+    }
+
+    /**
+     * Constructor
+     */
+    public AnnotatedClassAttribute(
+	ConstUtf8 nameAttr, short version, short annFlags,
+	long modTime, long annTime) {
+        super(nameAttr);
+        attrVersion = version;
+        annotationFlags = annFlags;
+        classModTime = modTime;
+        classAnnotationTime = annTime;
+    }
+
+    /* package local methods */
+
+    static AnnotatedClassAttribute read(
+	ConstUtf8 attrName, DataInputStream data, ConstantPool pool)
+        throws IOException {
+        short version = data.readShort();
+        short annFlags = data.readShort();
+        long modTime = data.readLong();
+        long annTime = data.readLong();
+        return  new AnnotatedClassAttribute(attrName, version, annFlags,
+                                            modTime, annTime);
+    }
+
+    void write(DataOutputStream out) throws IOException {
+        out.writeShort(attrName().getIndex());
+        out.writeShort(20);
+        out.writeShort(attrVersion);
+        out.writeShort(annotationFlags);
+        out.writeLong(classModTime);
+        out.writeLong(classAnnotationTime);
+    }
+
+    void print(PrintStream out, int indent) {
+        ClassPrint.spaces(out, indent);
+        out.println("version: " + attrVersion);
+        out.println(" flags: " + annotationFlags);
+        out.println(" modTime: " + classModTime);
+        out.println(" annTime: " + classAnnotationTime);
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedMethodAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedMethodAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedMethodAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AnnotatedMethodAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * AnnotatedMethodAttribute represents a class level attribute
+ * class file which identifies the level of annotation of the class.
+ */
+public class AnnotatedMethodAttribute extends ClassAttribute {
+
+    /* The expected attribute name */
+    public final static String expectedAttrName = "filter.annotatedMethod";
+
+    /* The expected attribute version */
+    public final static short expectedAttrVersion = 1;
+
+    /* Bit mask indicating that the class was filter generated */
+    public final static short generatedFlag = 0x1;
+
+    /* Bit mask indicating that the class was filter annotated */
+    public final static short annotatedFlag = 0x2;
+
+    /* Bit mask indicating that the class was "repackaged" */
+    public final static short modifiedFlag = 0x4;
+
+    /* The version of the attribute */
+    private short attrVersion;
+
+    /* Flags associated with the annotation */
+    private short annotationFlags;
+
+    /* list of targets in the code sequence delimiting inserted instruction
+     * sequences.  Even index targets are a range start (inclusive) and odd
+     * targets represent a range end (exclusive) */
+    private InsnTarget annotationRanges[];
+
+    /* public accessors */
+
+    public short getVersion() {
+        return attrVersion;
+    }
+
+    public void setVersion(short version) {
+        attrVersion = version;
+    }
+
+    public short getFlags() {
+        return annotationFlags;
+    }
+
+    public void setFlags(short flags) {
+        annotationFlags = flags;
+    }
+
+    public InsnTarget[] getAnnotationRanges() {
+        return annotationRanges;
+    }
+
+    public void setAnnotationRanges(InsnTarget[] ranges) {
+        annotationRanges = ranges;
+    }
+
+    /**
+     * Constructor
+     */
+    public AnnotatedMethodAttribute(
+	ConstUtf8 nameAttr, short version, short annFlags,
+	InsnTarget[] annRanges) {
+        super(nameAttr);
+        attrVersion = version;
+        annotationFlags = annFlags;
+        annotationRanges = annRanges;
+    }
+
+    /* package local methods */
+
+    static AnnotatedMethodAttribute read(
+	ConstUtf8 attrName, DataInputStream data, CodeEnv env)
+        throws IOException {
+        short version = data.readShort();
+        short annFlags = data.readShort();
+
+        short nRanges = data.readShort();
+
+        InsnTarget ranges[] = new InsnTarget[nRanges*2];
+        for (int i=0; i<nRanges; i++) {
+            ranges[i*2] = env.getTarget(data.readShort());
+            ranges[i*2+1] = env.getTarget(data.readShort());
+        }
+        return  new AnnotatedMethodAttribute(attrName, version, annFlags, ranges);
+    }
+
+    void write(DataOutputStream out) throws IOException {
+        out.writeShort(attrName().getIndex());
+        if (annotationRanges == null)
+            out.writeShort(2);
+        else
+            out.writeShort(4 + 2 * annotationRanges.length);
+        out.writeShort(attrVersion);
+        out.writeShort(annotationFlags);
+        if (annotationRanges == null)
+            out.writeShort(0);
+        else {
+            out.writeShort(annotationRanges.length / 2);
+            for (int i=0; i<annotationRanges.length; i++)
+                out.writeShort(annotationRanges[i].offset());
+        }
+    }
+
+    void print(PrintStream out, int indent) {
+        ClassPrint.spaces(out, indent);
+        out.println("version: " + attrVersion);
+        out.println(" flags: " + annotationFlags);
+        if (annotationRanges != null) {
+            out.println("Annotations: ");
+            for (int i=0; i<annotationRanges.length/2; i++) {
+                ClassPrint.spaces(out, indent+2);
+                out.println(annotationRanges[i*2] + " to " +
+                            annotationRanges[i*2+1]);
+            }
+        }
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AttributeVector.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AttributeVector.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AttributeVector.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/AttributeVector.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+import java.util.Vector;
+import java.util.Stack;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.NoSuchElementException;
+
+/**
+ * A list of attributes within a class file.
+ * These lists occur in several places within a class file
+ *    - at class level
+ *    - at method level
+ *    - at field level
+ *    - at attribute level
+ */
+public class AttributeVector {
+
+    /* Vector of ClassAttribute */
+    private ClassAttribute attributes[] = null;
+
+    /**
+     * Returns the i'th attribute in the array
+     */
+    private ClassAttribute attrAt(int i) {
+        return attributes[i];
+    }
+
+    /**
+     * Construct an empty AttributeVector
+     */
+    public AttributeVector() { }
+
+    /**
+     * Add an element to the vector
+     */
+    public void addElement(ClassAttribute attr) {
+        if (attributes == null)
+            attributes = new ClassAttribute[1];
+        else {
+            ClassAttribute newAttributes[] = new ClassAttribute[attributes.length+1];
+            System.arraycopy(attributes, 0, newAttributes, 0, attributes.length);
+            attributes = newAttributes;
+        }
+        attributes[attributes.length-1] = attr;
+    }
+
+    public Enumeration elements() {
+        class AttributeVectorEnumeration implements Enumeration {
+            private ClassAttribute[] attributes;
+            private int current = 0;
+
+            AttributeVectorEnumeration(ClassAttribute attrs[]) {
+                attributes = attrs;
+            }
+
+            public boolean hasMoreElements() {
+                return attributes != null && current < attributes.length;
+            }
+            public Object nextElement() {
+                if (!hasMoreElements())
+                    throw new NoSuchElementException();
+                return attributes[current++];
+            }
+        }
+
+        return new AttributeVectorEnumeration(attributes);
+    }
+
+    /**
+     * Look for an attribute of a specific name
+     */
+    public ClassAttribute findAttribute(String attrName) {
+        Enumeration e = elements();
+        while (e.hasMoreElements()) {
+            ClassAttribute attr = (ClassAttribute) e.nextElement();
+            if (attr.attrName().asString().equals(attrName))
+                return attr;
+        }
+        return null;
+    }
+
+    /**
+     * Compares this instance with another for structural equality.
+     */
+    //@olsen: added method
+    public boolean isEqual(Stack msg, Object obj) {
+        if (!(obj instanceof AttributeVector)) {
+            msg.push("obj/obj.getClass() = "
+                     + (obj == null ? null : obj.getClass()));
+            msg.push("this.getClass() = "
+                     + this.getClass());
+            return false;
+        }
+        AttributeVector other = (AttributeVector)obj;
+
+        if (this.attributes.length != other.attributes.length) {
+            msg.push("attributes.length "
+                     + String.valueOf(other.attributes.length));
+            msg.push("attributes.length "
+                     + String.valueOf(this.attributes.length));
+            return false;
+        }
+
+        // sort attributes by name
+        class ClassAttributeComparator implements Comparator {
+            public int compare(Object o1, Object o2) {
+                ClassAttribute a1 = (ClassAttribute)o1;
+                ClassAttribute a2 = (ClassAttribute)o2;
+                String s1 = a1.attrName().asString();
+                String s2 = a2.attrName().asString();
+                return s1.compareTo(s2);
+            }
+        }
+        ClassAttributeComparator comparator = new ClassAttributeComparator();
+        ClassAttribute[] thisAttributes
+            = (ClassAttribute[])this.attributes.clone();
+        ClassAttribute[] otherAttributes
+            = (ClassAttribute[])other.attributes.clone();
+        Arrays.sort(thisAttributes, comparator);
+        Arrays.sort(otherAttributes, comparator);
+        for (int i = 0; i < attributes.length; i++) {
+            ClassAttribute a1 = thisAttributes[i];
+            ClassAttribute a2 = otherAttributes[i];
+            if (!a1.isEqual(msg, a2)) {
+                msg.push("attributes[i] = " + String.valueOf(a2));
+                msg.push("attributes[i] = " + String.valueOf(a1));
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * General attribute reader
+     */
+    static AttributeVector readAttributes(
+	DataInputStream data, ConstantPool constantPool)
+	throws IOException {
+        AttributeVector attribs = new AttributeVector();
+        int n_attrs = data.readUnsignedShort();
+        while (n_attrs-- > 0) {
+            attribs.addElement(ClassAttribute.read(data, constantPool));
+        }
+        return attribs;
+    }
+
+    /**
+     * ClassMethod attribute reader
+     */
+    static AttributeVector readAttributes(
+	DataInputStream data, CodeEnv codeEnv)
+	throws IOException {
+        AttributeVector attribs = new AttributeVector();
+        int n_attrs = data.readUnsignedShort();
+        while (n_attrs-- > 0) {
+            attribs.addElement(ClassAttribute.read(data, codeEnv));
+        }
+        return attribs;
+    }
+
+    /**
+     * Write the attributes to the output stream
+     */
+    void write(DataOutputStream out) throws IOException {
+        if (attributes == null) {
+            out.writeShort(0);
+        } else {
+            out.writeShort(attributes.length);
+            for (int i=0; i<attributes.length; i++)
+                attributes[i].write(out);
+        }
+    }
+
+    /**
+     * Print a description of the attributes
+     */
+    void print(PrintStream out, int indent) {
+        if (attributes != null) {
+            for (int i=0; i<attributes.length; i++)
+                attributes[i].print(out, indent);
+        }
+    }
+
+    /**
+     * Print a brief summary of the attributes
+     */
+    //@olsen: added 'out' and 'indent' parameters
+    void summarize(PrintStream out, int indent) {
+        ClassPrint.spaces(out, indent);
+        out.println((attributes == null ? 0 : attributes.length) +
+                           " attributes");
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassAttribute.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassAttribute.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassAttribute.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassAttribute.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.util.Stack;
+import java.util.Vector;
+import java.util.Hashtable;
+import java.io.*;
+
+/**
+ * An abstract base class for the attributes within a class file
+ */
+public abstract class ClassAttribute implements VMConstants {
+
+    /* The name of the attribute */
+    private ConstUtf8 attributeName;
+
+    /**
+     * Returns the name of the attribute
+     */
+    public ConstUtf8 attrName() {
+        return attributeName;
+    }
+
+    /**
+     * Compares this instance with another for structural equality.
+     */
+    //@olsen: added method
+    public boolean isEqual(Stack msg, Object obj) {
+        if (!(obj instanceof ClassAttribute)) {
+            msg.push("obj/obj.getClass() = "
+                     + (obj == null ? null : obj.getClass()));
+            msg.push("this.getClass() = "
+                     + this.getClass());
+            return false;
+        }
+        ClassAttribute other = (ClassAttribute)obj;
+
+        if (!this.attributeName.isEqual(msg, other.attributeName)) {
+            msg.push(String.valueOf("attributeName = "
+                                    + other.attributeName));
+            msg.push(String.valueOf("attributeName = "
+                                    + this.attributeName));
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Constructor
+     */
+    ClassAttribute(ConstUtf8 theAttrName) {
+        attributeName = theAttrName;
+    }
+
+    /**
+     * General attribute reader 
+     */
+    static ClassAttribute read(DataInputStream data, ConstantPool pool)
+	throws IOException {
+
+        ClassAttribute attr = null;
+        int attrNameIndex = data.readUnsignedShort();
+        ConstUtf8 attrName8 = (ConstUtf8) pool.constantAt(attrNameIndex);
+        String attrName = attrName8.asString();
+        int attrLength = data.readInt();
+
+        if (attrName.equals(CodeAttribute.expectedAttrName)) {
+            /* The old style code attribute reader uses more memory and
+               cpu when the instructions don't need to be examined than the
+               new deferred attribute reader.  We may at some point decide that
+               we want to change the default based on the current situation
+               but for now we will just use the deferred reader in all cases. */
+            if (true) {
+                attr = CodeAttribute.read(attrName8, attrLength, data, pool);
+            } else {
+                attr = CodeAttribute.read(attrName8, data, pool);
+            }
+        }
+        else if (attrName.equals(SourceFileAttribute.expectedAttrName)) {
+            attr = SourceFileAttribute.read(attrName8, data, pool);
+        }
+        else if (attrName.equals(ConstantValueAttribute.expectedAttrName)) {
+            attr = ConstantValueAttribute.read(attrName8, data, pool);
+        }
+        else if (attrName.equals(ExceptionsAttribute.expectedAttrName)) {
+            attr = ExceptionsAttribute.read(attrName8, data, pool);
+        }
+        else if (attrName.equals(AnnotatedClassAttribute.expectedAttrName)) {
+            attr = AnnotatedClassAttribute.read(attrName8, data, pool);
+        }
+        else {
+            /* Unrecognized method attribute */
+            byte attrBytes[] = new byte[attrLength];
+            data.readFully(attrBytes);
+            attr = new GenericAttribute (attrName8, attrBytes);
+        }
+
+        return attr;
+    }
+
+    /*
+     * CodeAttribute attribute reader
+     */
+
+    static ClassAttribute read(DataInputStream data, CodeEnv env)
+	throws IOException {
+        ClassAttribute attr = null;
+        int attrNameIndex = data.readUnsignedShort();
+        ConstUtf8 attrName8 = (ConstUtf8) env.pool().constantAt(attrNameIndex);
+        String attrName = attrName8.asString();
+        int attrLength = data.readInt();
+
+        if (attrName.equals(LineNumberTableAttribute.expectedAttrName)) {
+            attr = LineNumberTableAttribute.read(attrName8, data, env);
+        }
+        else if (attrName.equals(LocalVariableTableAttribute.expectedAttrName)) {
+            attr = LocalVariableTableAttribute.read(attrName8, data, env);
+        }
+        else if (attrName.equals(AnnotatedMethodAttribute.expectedAttrName)) {
+            attr = AnnotatedMethodAttribute.read(attrName8, data, env);
+        }
+        //@olsen: fix 4467428, added support for synthetic code attribute
+        else if (attrName.equals(SyntheticAttribute.expectedAttrName)) {
+            attr = SyntheticAttribute.read(attrName8, data, env.pool());
+        }
+        else {
+            /* Unrecognized method attribute */
+            byte attrBytes[] = new byte[attrLength];
+            data.readFully(attrBytes);
+            attr = new GenericAttribute (attrName8, attrBytes);
+        }
+
+        return attr;
+    }
+
+    /**
+     * Write the attribute to the output stream
+     */
+    abstract void write(DataOutputStream out) throws IOException;
+
+    /**
+     * Print a description of the attribute to the print stream
+     */
+    abstract void print(PrintStream out, int indent);
+}
+

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassField.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassField.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassField.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassField.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * ClassField models the static and non-static fields of a class within
+ * a class file.
+ */
+
+final public class ClassField extends ClassMember {
+  /* access flag bit mask - see VMConstants */
+  private int accessFlags;
+
+  /* The name of the field */
+  private ConstUtf8 fieldName;
+
+  /* The type signature of the field */
+  private ConstUtf8 fieldSignature;
+
+  /* The attributes associated with the field */
+  private AttributeVector fieldAttributes;
+  
+
+  /* public accessors */
+
+  /**
+   * Is the field transient?
+   */
+  public boolean isTransient() {
+    return (accessFlags & ACCTransient) != 0;
+  }
+
+  /**
+   * Return the access flags for the field - see VMConstants
+   */
+  public int access() {
+    return accessFlags;
+  }
+
+  /**
+   * Update the access flags for the field - see VMConstants
+   */
+  public void setAccess(int newFlags) {
+    accessFlags = newFlags;
+  }
+
+  /**
+   * Return the name of the field
+   */
+  public ConstUtf8 name() {
+    return fieldName;
+  }
+
+  /**
+   * Change the name of the field
+   */
+  public void changeName(ConstUtf8 name) {
+    fieldName = name;
+  }
+
+  /**
+   * Return the type signature of the field
+   */
+  public ConstUtf8 signature() {
+    return fieldSignature;
+  }
+
+  /**
+   * Change the type signature of the field
+   */
+  public void changeSignature(ConstUtf8 newSig) {
+    fieldSignature = newSig;
+  }
+
+  /**
+   * Return the attributes associated with the field
+   */
+  public AttributeVector attributes() {
+    return fieldAttributes;
+  }
+
+  /**
+   * Construct a class field object
+   */
+  public ClassField(int accFlags, ConstUtf8 name, ConstUtf8 sig,
+                    AttributeVector field_attrs) {
+    accessFlags = accFlags;
+    fieldName = name;
+    fieldSignature = sig;
+    fieldAttributes = field_attrs;
+  }
+
+  /* package local methods */
+
+  static ClassField read(DataInputStream data, ConstantPool pool) 
+    throws IOException {
+    ClassField f = null;
+    int accessFlags = data.readUnsignedShort();
+    int name_index = data.readUnsignedShort();
+    int sig_index = data.readUnsignedShort();
+    AttributeVector fieldAttribs = AttributeVector.readAttributes(data, pool);
+    f = new ClassField(accessFlags, 
+		       (ConstUtf8) pool.constantAt(name_index),
+		       (ConstUtf8) pool.constantAt(sig_index),
+		       fieldAttribs);
+    return f;
+  }
+
+  void write (DataOutputStream data) throws IOException {
+    data.writeShort(accessFlags);
+    data.writeShort(fieldName.getIndex());
+    data.writeShort(fieldSignature.getIndex());
+    fieldAttributes.write(data);
+  }
+
+  void print(PrintStream out, int indent) {
+    ClassPrint.spaces(out, indent);
+    out.print("'" + fieldName.asString() + "'");
+    out.print(" sig = " + fieldSignature.asString());
+    out.print(" access_flags = " + Integer.toString(accessFlags));
+    out.println(" attributes:");
+    fieldAttributes.print(out, indent+2);
+  }
+}
+

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassFile.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassFile.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassFile.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassFile.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,676 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+import java.util.Hashtable;
+import java.util.Enumeration;
+import java.io.*;
+import java.security.MessageDigest;
+import java.security.DigestOutputStream;
+import java.security.NoSuchAlgorithmException;
+import java.io.DataOutputStream;
+
+
+/**
+ * ClassFile models the structure of a class as represented within
+ * a class file.
+ */
+final public class ClassFile implements VMConstants, Serializable {
+
+    /* Class file constants */
+    public static final int magic = 0xcafebabe;
+    
+    /*@craig added more flexible version checking.
+     */
+    public static final short[] [] jdkMajorMinorVersions = new short[][] {
+        new short[] {45,3}, // jdk 1.1
+        new short[] {46,0}, // jdk 1.2
+        new short[] {47,0}, // jdk 1.3
+        new short[] {48,0}  // jdk 1.4
+    };
+    public static final List jdkVersions = 
+        convertMajorMinorVersions(jdkMajorMinorVersions);
+
+    public static final String supportedVersions = printSupportedVersions();
+    
+    private int majorVersion = 0;
+    private int minorVersion = 0;
+    
+    /* The constant pool for the class file */
+    private ConstantPool constantPool = new ConstantPool();
+
+    /* access flag bit mask - see VMConstants */
+    private int accessFlags = 0;
+
+    /* The name of the class */
+    private ConstClass thisClassName;
+
+    /* The name of the super class */
+    private ConstClass superClassName;
+
+    /* A list of the interfaces which the class implements
+     * The contents are ConstClass objects
+     */
+    private Vector classInterfaces = new Vector();
+
+    /* A list of the fields which the class contains
+     * The contents are ClassField objects
+     */
+    private Vector classFields = new Vector();
+
+    /* A list of the methods which the class defines
+     * The contents are ClassMethod objects
+     */
+    private Vector classMethods = new Vector();
+
+    /* A list of the attributes associated with the class */
+    private AttributeVector classAttributes = new AttributeVector();
+
+    /** Static methods 
+     * Added for major.minor compatibility checking
+     */
+    private static List convertMajorMinorVersions(short[][] majorMinor) {
+        int length = majorMinor.length;
+        List result = new ArrayList(length);
+        for (int i = 0; i < length; i++) {
+            result.add(new Integer(majorMinor[i][0] * 65536 + majorMinor[i][1]));
+        }
+        return result;
+    }
+    
+    private static boolean isSupportedVersion(short major, short minor) {
+        Integer version = new Integer(major*65536 + minor);
+        return jdkVersions.contains(version);
+    }
+    
+    public static final String printSupportedVersions() {
+        StringBuffer buf = new StringBuffer("{"); //NOI18N
+        int length = jdkMajorMinorVersions.length;
+        for (int i = 0; i < length; i++) {
+            int major = jdkMajorMinorVersions[i][0];
+            int minor = jdkMajorMinorVersions[i][1];
+            buf.append("{"); buf.append(major); buf.append(","); 
+            buf.append(minor); buf.append("}"); //NOI18N
+        }
+        buf.append("}"); //NOI18N
+        return buf.toString();
+    }
+
+    /* public accessors */
+
+
+
+    /**
+     * Return the constant pool for the class file
+     */
+    public ConstantPool pool() {
+        return constantPool;
+    }
+
+    /**
+     * Return the access flags for the class - see VMConstants
+     */
+    public int access() {
+        return accessFlags;
+    }
+
+    /**
+     * Is the class final?
+     */
+    final public boolean isFinal() {
+        return (accessFlags & ACCFinal) != 0;
+    }
+
+    /**
+     * Is the class an interface?
+     */
+    final public boolean isInterface() {
+        return (accessFlags & ACCInterface) != 0;
+    }
+
+    /**
+     * Is the class public?
+     */
+    final public boolean isPublic() {
+        return (accessFlags & ACCPublic) != 0;
+    }
+
+    /**
+     * Is the class abstract?
+     */
+    final public boolean isAbstract() {
+        return (accessFlags & ACCAbstract) != 0;
+    }
+
+
+    /**
+     * Set the access flags for the class - see VMConstants
+     */
+    public void setAccessFlags (int flags) {
+        accessFlags = flags;
+    }
+
+    /**
+     * Return the name of the class
+     */
+    public ConstClass className() {
+        return thisClassName;
+    }
+
+    /**
+     * Return the name of the class as a string
+     */
+    //@olsen: added method
+    public String classNameString() {
+        return (thisClassName == null) ? null : thisClassName.asString();
+    }
+
+    /**
+     * Return the name of the super class
+     */
+    public ConstClass superName() {
+        return superClassName;
+    }
+
+    /**
+     * Return the name of the super class as a string
+     */
+    public String superNameString() {
+        return (superClassName == null) ? null : superClassName.asString();
+    }
+
+    /**
+     * Set the name of the super class
+     */
+    public void setSuperName(ConstClass superCl) {
+        superClassName = superCl;
+    }
+
+    /**
+     * Return the list of the interfaces which the class implements
+     * The contents are ConstClass objects
+     */
+    public Vector interfaces() {
+        return classInterfaces;
+    }
+
+    /**
+     * Add an interface to the list of the interfaces which the class implements
+     */
+    public void addInterface (ConstClass iface) {
+        classInterfaces.addElement(iface);
+    }
+
+    /**
+     * Return the list of the fields which the class contains
+     * The contents are ClassField objects
+     */
+    public Vector fields() {
+        return classFields;
+    }
+
+    /**
+     * Add a field to the list of the fields which the class contains
+     */
+    public void addField (ClassField field) {
+        classFields.addElement(field);
+    }
+
+    /**
+     * Add a field to the list of the fields which the class contains,
+     * at the index'th position.
+     */
+    public void addField(ClassField field, int index) {
+        classFields.insertElementAt(field, index);
+    }
+
+    /**
+     * Return the list of the methods which the class defines
+     * The contents are ClassMethod objects
+     */
+    public Vector methods() {
+        return classMethods;
+    }
+
+    /**
+     * Look for a method with the specified name and type signature
+     */
+    public ClassMethod findMethod(String methodName, String methodSig) {
+        for (Enumeration e = methods().elements(); e.hasMoreElements();) {
+            ClassMethod method = (ClassMethod) e.nextElement();
+            if (method.name().asString().equals(methodName) &&
+                method.signature().asString().equals(methodSig))
+                return method;
+        }
+        return null;
+    }
+
+    /**
+     * Add a method to the list of the methods which the class defines
+     */
+    public void addMethod(ClassMethod method) {
+        classMethods.addElement(method);
+    }
+
+    /**
+     * Look for a field with the specified name
+     */
+    public ClassField findField(String fieldName) {
+        for (Enumeration e = fields().elements(); e.hasMoreElements();) {
+            ClassField field = (ClassField) e.nextElement();
+            if (field.name().asString().equals(fieldName))
+                return field;
+        }
+        return null;
+    }
+
+    /**
+     * Return the list of the attributes associated with the class
+     */
+    public AttributeVector attributes() {
+        return classAttributes;
+    }
+
+    /**
+     * Returns the class name in user ('.' delimited) form.
+     */
+    //@olsen: moved from ClassControl to ClassFile
+    public String userClassName()
+    {
+        return userClassFromVMClass(classNameString());
+    }
+  
+    /**
+     * Returns the class name in user ('.' delimited) form.
+     */
+    //@olsen: moved from ClassControl to ClassFile
+    static public String userClassFromVMClass(String vmName)
+    {
+        return vmName.replace('/', '.');
+    }
+  
+    /**
+     * Returns the class name in VM ('/' delimited) form.
+     */
+    //@olsen: moved from ClassControl to ClassFile
+    static public String vmClassFromUserClass(String userName)
+    {
+        return userName.replace('.', '/');
+    }
+  
+    /**
+     * Returns the vm package name for this class.
+     */
+    //@olsen: moved from ClassControl to ClassFile
+    public String pkg()
+    {
+        return packageOf(classNameString());
+    }
+  
+    /**
+     * Returns the vm package name for the vm class name.
+     */
+    //@olsen: moved from ClassControl to ClassFile
+    static public String packageOf(String vmName)
+    {
+        int last = vmName.lastIndexOf('/');
+        if (last < 0)
+            return "";
+        return vmName.substring(0, last);
+    }
+
+
+    /* Constructors */
+
+    /**
+     * Construct a ClassFile from an input stream
+     */
+    public ClassFile(DataInputStream data) throws ClassFormatError {
+        this(data, true);
+    }
+
+    public ClassFile(DataInputStream data,
+                     boolean allowJDK12ClassFiles) throws ClassFormatError {
+        try {
+            int thisMagic = data.readInt();
+            if (thisMagic != magic)
+                throw new ClassFormatError("Bad magic value for input");
+
+            short thisMinorVersion = data.readShort();
+            short thisMajorVersion = data.readShort();
+            /*@craig changed checking only target 1.1 and 1.2 to more
+             * general check for a list of versions.
+             */
+             if (isSupportedVersion(thisMajorVersion, thisMinorVersion)) {
+                minorVersion = thisMinorVersion;
+                majorVersion = thisMajorVersion;
+            } else {
+                throw new ClassFormatError("Bad version number: {" +
+                                           thisMajorVersion + "," + 
+                                           thisMinorVersion +
+                                           "} expected one of: " +
+                                           supportedVersions);
+            }
+
+            readConstants(data);
+            accessFlags = data.readUnsignedShort();
+            thisClassName = (ConstClass)
+                constantPool.constantAt(data.readUnsignedShort());
+            superClassName = (ConstClass)
+                constantPool.constantAt(data.readUnsignedShort());
+            readInterfaces(data);
+            readFields(data);
+            readMethods(data);
+            classAttributes = AttributeVector.readAttributes(data, constantPool);
+        } catch (IOException e) {
+            throw new ClassFormatError("IOException during reading: " + 
+                                       e.getMessage());
+        }
+        //@olsen: added println() for debugging
+        //System.out.println("ClassFile(): new class = " + 
+        //thisClassName.asString());
+    }
+
+    /**
+     * Construct a bare bones class, ready for additions
+     */
+    public ClassFile(String cname, String supername) {
+        thisClassName = constantPool.addClass(cname);
+        superClassName = constantPool.addClass(supername);
+        //@olsen: added println() for debugging
+        //System.out.println("ClassFile(): new bare class file = " + 
+        //thisClassName);
+    }
+
+    /**
+     * Write the Class file to the data output stream
+     */
+    public
+    void write (DataOutputStream buff) throws IOException {
+        buff.writeInt(magic);
+        buff.writeShort(minorVersion);
+        buff.writeShort(majorVersion);
+        constantPool.write(buff);
+        buff.writeShort(accessFlags);
+        buff.writeShort(thisClassName.getIndex());
+        //@lars: superclass may be null (java.lang.Object); 
+        //VMSpec 2nd ed., section 4.1
+        buff.writeShort(superClassName == null ? 0 : superClassName.getIndex());
+        //buff.writeShort(superClassName.getIndex());
+        writeInterfaces(buff);
+        writeFields(buff);
+        writeMethods(buff);
+        classAttributes.write(buff);
+    }
+
+    /**
+     * Returns a byte array representation of this class.
+     */
+    public byte[] getBytes() throws java.io.IOException {
+        /* Write the class bytes to a file, for debugging. */
+
+        String writeClassToDirectory =
+            System.getProperty("filter.writeClassToDirectory");
+        if (writeClassToDirectory != null) {
+            String filename = writeClassToDirectory + java.io.File.separator +
+                thisClassName.asString() + ".class";
+            System.err.println("Writing class to file " + filename);
+            DataOutputStream stream = new DataOutputStream(
+                new java.io.FileOutputStream(filename));
+            write(stream);
+            stream.close();
+        }
+
+        /* Get the class bytes and return them. */
+
+        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+        write(new DataOutputStream(byteStream));
+
+        return byteStream.toByteArray();
+    }
+
+    //@olsen: added method
+    public void print(PrintStream out) {
+        print(out, 0);
+    }
+    
+    //@olsen: added 'indent' parameter
+    public void print(PrintStream out, int indent) {
+        constantPool.print(out, indent);
+        out.println();
+
+        ClassPrint.spaces(out, indent);
+        out.println("majorVersion = " + Integer.toString(majorVersion));
+        ClassPrint.spaces(out, indent);
+        out.println("minorVersion = " + Integer.toString(minorVersion));
+        ClassPrint.spaces(out, indent);
+        out.println("accessFlags = " + Integer.toString(accessFlags));
+        ClassPrint.spaces(out, indent);
+        out.println("className = " + thisClassName.asString());
+        ClassPrint.spaces(out, indent);
+        out.println("superClassName = " + superClassName.asString());
+        ClassPrint.spaces(out, indent);
+        out.print("Interfaces =");
+        for (int i=0; i<classInterfaces.size(); i++) {
+            out.print(" "
+                      + ((ConstClass)classInterfaces.elementAt(i)).asString());
+        }
+        out.println();
+
+        ClassPrint.spaces(out, indent);
+        out.println("fields =");
+        for (int i=0; i<classFields.size(); i++) {
+            ((ClassField) classFields.elementAt(i)).print(out, indent + 3);
+        }
+
+        ClassPrint.spaces(out, indent);
+        out.println("methods =");
+        for (int i=0; i<classMethods.size(); i++) {
+            ((ClassMethod) classMethods.elementAt(i)).print(out, indent + 3);
+        }
+
+        ClassPrint.spaces(out, indent);
+        out.println("attributes =");
+        classAttributes.print(out, indent + 3);
+
+    }
+
+    //@olsen: made public
+    //@olsen: added 'out' and 'indent' parameters
+    public void summarize(PrintStream out, int indent) {
+        constantPool.summarize(out, indent);
+        int codeSize = 0;
+        for (int i=0; i<classMethods.size(); i++) {
+            codeSize += ((ClassMethod)classMethods.elementAt(i)).codeSize();
+        }
+        ClassPrint.spaces(out, indent);
+        out.println(classMethods.size() + " methods in "
+                    + codeSize + " bytes");
+        ClassPrint.spaces(out, indent);
+        out.println(classFields.size() + " fields");
+    }
+
+    /* package local methods */
+
+    /*
+     * class file reading helpers
+     */
+    private void readConstants (DataInputStream data) throws IOException {
+        constantPool = new ConstantPool(data);
+    }
+
+    private void readInterfaces(DataInputStream data) throws IOException {
+        int nInterfaces = data.readUnsignedShort();
+        while (nInterfaces-- > 0) {
+            int interfaceIndex = data.readUnsignedShort();
+            ConstClass ci = null;
+            if (interfaceIndex != 0)
+                ci = (ConstClass) constantPool.constantAt(interfaceIndex);
+            classInterfaces.addElement(ci);
+        }
+    }
+
+    private void writeInterfaces(DataOutputStream data) throws IOException {
+        data.writeShort(classInterfaces.size());
+        for (int i=0; i<classInterfaces.size(); i++) {
+            ConstClass ci = (ConstClass) classInterfaces.elementAt(i);
+            int interfaceIndex = 0;
+            if (ci != null)
+                interfaceIndex = ci.getIndex();
+            data.writeShort(interfaceIndex);
+        }
+    }
+
+    private void readFields(DataInputStream data) throws IOException {
+        int nFields = data.readUnsignedShort();
+        while (nFields-- > 0) {
+            classFields.addElement (ClassField.read(data, constantPool));
+        }
+    }
+
+    private void writeFields (DataOutputStream data) throws IOException {
+        data.writeShort(classFields.size());
+        for (int i=0; i<classFields.size(); i++)
+            ((ClassField)classFields.elementAt(i)).write(data);
+    }
+
+    private void readMethods (DataInputStream data) throws IOException {
+        int nMethods = data.readUnsignedShort();
+        while (nMethods-- > 0) {
+            classMethods.addElement (ClassMethod.read(data, constantPool));
+        }
+    }
+
+    private void writeMethods (DataOutputStream data) throws IOException {
+        data.writeShort(classMethods.size());
+        for (int i=0; i<classMethods.size(); i++)
+            ((ClassMethod)classMethods.elementAt(i)).write(data);
+    }
+
+}
+
+abstract class ArraySorter {
+    protected ArraySorter() {}
+
+    /* return the size of the array being sorted */
+    abstract int size();
+
+    /* return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2 */
+    abstract int compare(int o1Index, int o2Index);
+
+    /* Swap the elements at index o1Index and o2Index */
+    abstract void swap(int o1Index, int o2Index);
+
+    void sortArray() {
+        sortArray(0, size()-1);
+    }
+
+    private void sortArray(int start, int end) {
+        if (end > start) {
+            swap(start, (start+end)/2);
+            int last = start;
+            for (int i = start+1; i<=end; i++) {
+                if (compare(i, start) < 0)
+                    swap (++last, i);
+            }
+            swap(start, last);
+            sortArray(start, last-1);
+            sortArray(last+1, end);
+        }
+    }
+}
+
+class InterfaceArraySorter extends ArraySorter {
+    private ConstClass theArray[];
+
+    InterfaceArraySorter(ConstClass[] interfaces) {
+        theArray = interfaces;
+    }
+
+    /* return the size of the array being sorted */
+    int size() { return theArray.length; }
+
+    /* return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2 */
+    int compare(int o1Index, int o2Index) {
+        return theArray[o1Index].asString().compareTo(
+            theArray[o2Index].asString());
+    }
+
+    /* Swap the elements at index o1Index and o2Index */
+    void swap(int o1Index, int o2Index) {
+        ConstClass tmp = theArray[o1Index];
+        theArray[o1Index] = theArray[o2Index];
+        theArray[o2Index] = tmp;
+    }
+}
+
+class FieldArraySorter extends ArraySorter {
+    private ClassField theArray[];
+
+    FieldArraySorter(ClassField[] fields) {
+        theArray = fields;
+    }
+
+    /* return the size of the array being sorted */
+    int size() { return theArray.length; }
+
+    /* return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2 */
+    int compare(int o1Index, int o2Index) {
+        return theArray[o1Index].name().asString().compareTo(
+            theArray[o2Index].name().asString());
+    }
+
+    /* Swap the elements at index o1Index and o2Index */
+    void swap(int o1Index, int o2Index) {
+        ClassField tmp = theArray[o1Index];
+        theArray[o1Index] = theArray[o2Index];
+        theArray[o2Index] = tmp;
+    }
+}
+
+class MethodArraySorter extends ArraySorter {
+    private ClassMethod theArray[];
+
+    MethodArraySorter(ClassMethod[] methods) {
+        theArray = methods;
+    }
+
+    /* return the size of the array being sorted */
+    int size() { return theArray.length; }
+
+    /* return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2 */
+    int compare(int o1Index, int o2Index) {
+        int cmp = theArray[o1Index].name().asString().compareTo(
+            theArray[o2Index].name().asString());
+        if (cmp == 0) {
+            cmp = theArray[o1Index].signature().asString().compareTo(
+                theArray[o2Index].signature().asString());
+        }
+        return cmp;
+    }
+
+    /* Swap the elements at index o1Index and o2Index */
+    void swap(int o1Index, int o2Index) {
+        ClassMethod tmp = theArray[o1Index];
+        theArray[o1Index] = theArray[o2Index];
+        theArray[o2Index] = tmp;
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMember.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMember.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMember.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMember.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+import java.util.Stack;
+
+/**
+ * ClassMember is a common base class for ClassMethod and ClassField
+ */
+abstract public class ClassMember implements VMConstants {
+
+    /* public accessors */
+
+    /**
+     * Is the member static?
+     */
+    final public boolean isStatic() {
+        return (access() & ACCStatic) != 0;
+    }
+
+    /**
+     * Is the member final?
+     */
+    final public boolean isFinal() {
+        return (access() & ACCFinal) != 0;
+    }
+
+    /**
+     * Turn on or off the final qualifier for the member.
+     */
+    public void setIsFinal(boolean newFinal) {
+        if (newFinal)
+            setAccess(access() | ACCFinal);
+        else
+            setAccess(access() & ~ACCFinal);
+    }
+
+    /**
+     * Is the member private?
+     */
+    final public boolean isPrivate() {
+        return (access() & ACCPrivate) != 0;
+    }
+
+    /**
+     * Is the member protected?
+     */
+    final public boolean isProtected() {
+        return (access() & ACCProtected) != 0;
+    }
+
+    /**
+     * Is the member public?
+     */
+    final public boolean isPublic() {
+        return (access() & ACCPublic) != 0;
+    }
+
+    /* These are expected to be implemented by subtypes */
+
+    /**
+     * Return the access flags for the method - see VMConstants
+     */
+    abstract public int access();
+
+    /**
+     * Set the access flags for the method - see VMConstants
+     */
+    abstract public void setAccess(int newAccess);
+
+    /**
+     * Return the name of the member
+     */
+    abstract public ConstUtf8 name();
+
+    /**
+     * Return the type signature of the method
+     */
+    abstract public ConstUtf8 signature();
+
+    /**
+     * Return the attributes associated with the member
+     */
+    abstract public AttributeVector attributes();
+
+    /**
+     * Compares this instance with another for structural equality.
+     */
+    //@olsen: added method
+    public boolean isEqual(Stack msg, Object obj) {
+        if (!(obj instanceof ClassMember)) {
+            msg.push("obj/obj.getClass() = "
+                     + (obj == null ? null : obj.getClass()));
+            msg.push("this.getClass() = "
+                     + this.getClass());
+            return false;
+        }
+        ClassMember other = (ClassMember)obj;
+
+        return true;
+    }
+}

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMethod.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMethod.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMethod.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassMethod.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+import java.util.Vector;
+import java.util.Stack;
+import java.util.Enumeration;
+
+/**
+ * ClassMethod models the static and non-static methods of a class within
+ * a class file.  This includes constructors and initializer code.
+ */
+public class ClassMethod extends ClassMember {
+    /* The name of the constructor code */
+    public final static String intializerName = "<init>";
+
+    /* The name of the static initializer code */
+    public final static String staticIntializerName = "<clinit>";
+
+    /* access flag bit mask - see VMConstants */
+    private int accessFlags;
+
+    /* The name of the method */
+    private ConstUtf8 methodName;
+
+    /* The type signature of the method */
+    private ConstUtf8 methodSignature;
+
+    /* The attributes associated with the field */
+    private AttributeVector methodAttributes;
+  
+  
+    /* public accessors */
+
+    /**
+     * Return the access flags for the method - see VMConstants
+     */
+    public int access() {
+        return accessFlags;
+    }
+
+    /**
+     * Update the access flags for the field - see VMConstants
+     */
+    public void setAccess(int newFlags) {
+        accessFlags = newFlags;
+    }
+
+    /**
+     * Is the method abstract?
+     */
+    public boolean isAbstract() {
+        return (accessFlags & ACCAbstract) != 0;
+    }
+
+    /**
+     * Is the method native?
+     */
+    public boolean isNative() {
+        return (accessFlags & ACCNative) != 0;
+    }
+
+    /**
+     * Return the name of the method
+     */
+    public ConstUtf8 name() {
+        return methodName;
+    }
+
+    /**
+     * Change the name of the method
+     */
+    public void changeName(ConstUtf8 name) {
+        methodName = name;
+    }
+
+    /**
+     * Return the type signature of the method
+     */
+    public ConstUtf8 signature() {
+        return methodSignature;
+    }
+
+    /**
+     * Change the type signature of the method
+     */
+    public void changeSignature(ConstUtf8 newSig) {
+        methodSignature = newSig;
+    }
+
+    /**
+     * Return the attributes associated with the method
+     */
+    public AttributeVector attributes() {
+        return methodAttributes;
+    }
+
+    /**
+     * Construct a class method object
+     */
+  
+    public ClassMethod(int accFlags, ConstUtf8 name, ConstUtf8 sig,
+                       AttributeVector methodAttrs) {
+        accessFlags = accFlags;
+        methodName = name;
+        methodSignature = sig;
+        methodAttributes = methodAttrs;
+    }
+
+    /**
+     * Returns the size of the method byteCode (if any)
+     */
+    int codeSize() {
+        CodeAttribute codeAttr = codeAttribute();
+        return (codeAttr == null) ? 0  : codeAttr.codeSize();
+    }
+
+    /**
+     * Returns the CodeAttribute associated with this method (if any)
+     */
+    public CodeAttribute codeAttribute() {
+        Enumeration e = methodAttributes.elements();
+        while (e.hasMoreElements()) {
+            ClassAttribute attr = (ClassAttribute) e.nextElement();
+            if (attr instanceof CodeAttribute)
+                return (CodeAttribute) attr;
+        }
+        return null;
+    }
+
+    /**
+     * Returns the ExceptionsAttribute associated with this method (if any)
+     */
+    //@olsen: added method
+    public ExceptionsAttribute exceptionsAttribute() {
+        Enumeration e = methodAttributes.elements();
+        while (e.hasMoreElements()) {
+            ClassAttribute attr = (ClassAttribute) e.nextElement();
+            if (attr instanceof ExceptionsAttribute)
+                return (ExceptionsAttribute) attr;
+        }
+        return null;
+    }
+
+    /**
+     * Compares this instance with another for structural equality.
+     */
+    //@olsen: added method
+    public boolean isEqual(Stack msg, Object obj) {
+        if (!(obj instanceof ClassMethod)) {
+            msg.push("obj/obj.getClass() = "
+                     + (obj == null ? null : obj.getClass()));
+            msg.push("this.getClass() = "
+                     + this.getClass());
+            return false;
+        }
+        ClassMethod other = (ClassMethod)obj;
+
+        if (!super.isEqual(msg, other)) {
+            return false;
+        }
+
+        if (this.accessFlags != other.accessFlags) {
+            msg.push(String.valueOf("accessFlags = 0x"
+                                    + Integer.toHexString(other.accessFlags)));
+            msg.push(String.valueOf("accessFlags = 0x"
+                                    + Integer.toHexString(this.accessFlags)));
+            return false;
+        }
+        if (!this.methodName.isEqual(msg, other.methodName)) {
+            msg.push(String.valueOf("methodName = "
+                                    + other.methodName));
+            msg.push(String.valueOf("methodName = "
+                                    + this.methodName));
+            return false;
+        }
+        if (!this.methodSignature.isEqual(msg, other.methodSignature)) {
+            msg.push(String.valueOf("methodSignature = "
+                                    + other.methodSignature));
+            msg.push(String.valueOf("methodSignature = "
+                                    + this.methodSignature));
+            return false;
+        }
+        if (!this.methodAttributes.isEqual(msg, other.methodAttributes)) {
+            msg.push(String.valueOf("methodAttributes = "
+                                    + other.methodAttributes));
+            msg.push(String.valueOf("methodAttributes = "
+                                    + this.methodAttributes));
+            return false;
+        }
+        return true;
+    }
+
+    //@olsen: made public
+    public void print(PrintStream out, int indent) {
+        ClassPrint.spaces(out, indent);
+        out.print("'" + methodName.asString() + "'");
+        out.print(" sig = " + methodSignature.asString());
+        out.print(" accessFlags = " + Integer.toString(accessFlags));
+        out.println(" attributes:");
+        methodAttributes.print(out, indent+2);
+    }
+
+    /* package local methods */
+
+    static ClassMethod read(DataInputStream data, ConstantPool pool) 
+        throws IOException {
+        int accessFlags = data.readUnsignedShort();
+        int nameIndex = data.readUnsignedShort();
+        int sigIndex = data.readUnsignedShort();
+        ClassMethod f = 
+            new ClassMethod(accessFlags, 
+                            (ConstUtf8) pool.constantAt(nameIndex),
+                            (ConstUtf8) pool.constantAt(sigIndex),
+                            null);
+
+        f.methodAttributes = AttributeVector.readAttributes(data, pool);
+        return f;
+    }
+
+    void write(DataOutputStream data) throws IOException {
+        CodeAttribute codeAttr = codeAttribute();
+        data.writeShort(accessFlags);
+        data.writeShort(methodName.getIndex());
+        data.writeShort(methodSignature.getIndex());
+        methodAttributes.write(data);
+    }
+}
+
+

Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassPrint.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassPrint.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassPrint.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/enhancer/classfile/ClassPrint.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+
+package org.apache.jdo.impl.enhancer.classfile;
+
+import java.io.*;
+
+/**
+ * A really simple class with printing utilities
+ */
+
+class ClassPrint {
+    /**
+     * Print 'nspaces' spaces to the print stream
+     */
+    public static void spaces(PrintStream ps, int nspaces) {
+        while (nspaces-- > 0)
+            ps.print(' ');
+    }
+}



Mime
View raw message