rmic.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

/*
  Copyright (c) 1996, 1997, 1998, 1999, 2001, 2002 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package gnu.java.rmi.rmic;

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Arrays;
import java.lang.Comparable;
import gnu.java.rmi.server.RMIHashes;

public class RMIC {

private String[] args;
private int next;
private Exception exception;

private boolean keep = false;
private boolean need11Stubs = true;
private boolean need12Stubs = true;
private boolean compile = true;
private boolean verbose;
private String destination;

private PrintWriter out;
private TabbedWriter ctrl;

private Class clazz;
private String classname;
private String fullclassname;
private MethodRef[] remotemethods;
private String stubname;
private String skelname;

public RMIC(String[] a) {
	args = a;
}

public static void main(String args[]) {
	RMIC r = new RMIC(args);
	if (r.run() == false) {
		Exception exception = r.getException();
		if (exception != null) {
			exception.printStackTrace();
		}
		else {
			System.exit(1);
		}
	}
}

public boolean run() {
	parseOptions();
	if (next >= args.length) {
		error("no class names found");
	}
	for (int i = next; i < args.length; i++) {
		try {
			if (verbose) {
				System.out.println("[Processing class " + args[i] + ".class]");
			}
			processClass(args[i]);
		}
		catch (Exception e) {
			exception = e;
			return (false);
		}
	}
	return (true);
}

private boolean processClass(String classname) throws Exception {
	analyzeClass(classname);
	generateStub();
	if (need11Stubs) {
		generateSkel();
	}
	if (compile) {
		compile(stubname + ".java");
		if (need11Stubs) {
			compile(skelname + ".java");
		}
	}
	if (!keep) {
		(new File(stubname + ".java")).delete();
		if (need11Stubs) {
			(new File(skelname + ".java")).delete();
		}
	}
	return (true);
}

private void analyzeClass(String cname) throws Exception {
	int p = cname.lastIndexOf('.');
	if (p != -1) {
		classname = cname.substring(p+1);
	}
	else {
		classname = cname;
	}
	fullclassname = cname;

	HashSet rmeths = new HashSet();
	findClass();
	for (Class cls = clazz; cls != null; cls = cls.getSuperclass()) {
		// Keep going down the inheritence tree until we hit the system
		if (cls.getName().startsWith("java.")) {
			break;
		}

		Method[] meths = cls.getDeclaredMethods();
		for (int i = 0; i < meths.length; i++) {
			// Only include public methods
			int mods = meths[i].getModifiers();
			if (Modifier.isPublic(mods) && !Modifier.isStatic(mods)) {
				// Should check exceptions here. - XXX

				// Add this one in.
				rmeths.add(meths[i]);
			}
		}
	}

	// Convert into a MethodRef array and sort them
	remotemethods = new MethodRef[rmeths.size()];
	int c = 0;
	for (Iterator i = rmeths.iterator(); i.hasNext(); ) {
		remotemethods[c++] = new MethodRef((Method)i.next());
	}
	Arrays.sort(remotemethods);
}

public Exception getException() {
	return (exception);
}

private void findClass() throws ClassNotFoundException {
	clazz = Class.forName(fullclassname);
}

private void generateStub() throws IOException {
	stubname = classname + "_Stub";
	ctrl = new TabbedWriter(new FileWriter(stubname + ".java"));
	out = new PrintWriter(ctrl);

	if (verbose) {
		System.out.println("[Generating class " + stubname + ".java]");
	}

	out.println("// Stub class generated by rmic - DO NOT EDIT!");
	out.println();
	if (fullclassname != classname) {
		String pname = fullclassname.substring(0, fullclassname.lastIndexOf('.'));
		out.println("package " + pname + ";");
		out.println();
	}

	out.print("public final class " + stubname);
	ctrl.indent();
	out.println("extends java.rmi.server.RemoteStub");
	
	// Output interfaces we implement
	out.print("implements ");
	Class[] ifaces = clazz.getInterfaces(); 
	for (int i = 0; i < ifaces.length; i++) {
		out.print(ifaces[i].getName());
		if (i+1 < ifaces.length) {
			out.print(", ");
		}
	}

	ctrl.unindent();
	out.print("{");
	ctrl.indent();

	// UID
	if (need12Stubs) {
		out.println("private static final long serialVersionUID = 2L;");
		out.println();
	}

	// InterfaceHash - don't know how to calculate this - XXX
	if (need11Stubs) {
		out.println("private static final long interfaceHash = " + RMIHashes.getInterfaceHash(clazz) + "L;");
		out.println();
		if (need12Stubs) {
			out.println("private static boolean useNewInvoke;");
			out.println();
		}

		// Operation table
		out.print("private static final java.rmi.server.Operation[] operations = {");

		ctrl.indent();
		for (int i = 0; i < remotemethods.length; i++) {
			Method m = remotemethods[i].meth;
			out.print("new java.rmi.server.Operation(\"");
			out.print(getPrettyName(m.getReturnType()) + " ");
			out.print(m.getName() + "(");
			// Output signature
			Class[] sig = m.getParameterTypes();
			for (int j = 0; j < sig.length; j++) {
				out.print(getPrettyName(sig[j]));
				if (j+1 < sig.length) {
					out.print(", ");
				}
			}
			out.print(")\")");
			if (i + 1 < remotemethods.length) {
				out.println(",");
			}
		}
		ctrl.unindent();
		out.println("};");
		out.println();
	}

	// Set of method references.
	if (need12Stubs) {
		for (int i = 0; i < remotemethods.length; i++) {
			Method m = remotemethods[i].meth;
			out.println("private static java.lang.reflect.Method $method_" + m.getName() + "_" + i + ";");
		}

		// Initialize the methods references.
		out.println();
		out.print("static {");
		ctrl.indent();

		out.print("try {");
		ctrl.indent();

		if (need11Stubs) {
			out.println("java.rmi.server.RemoteRef.class.getMethod(\"invoke\", new java.lang.Class[] { java.rmi.Remote.class, java.lang.reflect.Method.class, java.lang.Object[].class, long.class });");
			out.println("useNewInvoke = true;");
		}

		for (int i = 0; i < remotemethods.length; i++) {
			Method m = remotemethods[i].meth;
			out.print("$method_" + m.getName() + "_" + i + " = ");
			out.print(fullclassname + ".class.getMethod(\"" + m.getName() + "\"");
			out.print(", new java.lang.Class[] {");
			// Output signature
			Class[] sig = m.getParameterTypes();
			for (int j = 0; j < sig.length; j++) {
				out.print(getPrettyName(sig[j]) + ".class");
				if (j+1 < sig.length) {
					out.print(", ");
				}
			}
			out.println("});");
		}
		ctrl.unindent();
		out.println("}");
		out.print("catch (java.lang.NoSuchMethodException e) {");
		ctrl.indent();
		if (need11Stubs) {
			out.print("useNewInvoke = false;");
		}
		else {
			out.print("throw new java.lang.NoSuchMethodError(\"stub class initialization failed\");");
		}

		ctrl.unindent();
		out.print("}");

		ctrl.unindent();
		out.println("}");
		out.println();
	}

	// Constructors
	if (need11Stubs) {
		out.print("public " + stubname + "() {");
		ctrl.indent();
		out.print("super();");
		ctrl.unindent();
		out.println("}");
	}

	if (need12Stubs) {
		out.print("public " + stubname + "(java.rmi.server.RemoteRef ref) {");
		ctrl.indent();
		out.print("super(ref);");
		ctrl.unindent();
		out.println("}");
	}

	// Method implementations
	for (int i = 0; i < remotemethods.length; i++) {
		Method m = remotemethods[i].meth;
		Class[] sig = m.getParameterTypes();
		Class returntype = m.getReturnType();
		Class[] except = sortExceptions(m.getExceptionTypes());

		out.println();
		out.print("public " + getPrettyName(returntype) + " " + m.getName() + "(");
		for (int j = 0; j < sig.length; j++) {
			out.print(getPrettyName(sig[j]));
			out.print(" $param_" + j);
			if (j+1 < sig.length) {
				out.print(", ");
			}
		}
		out.print(") ");
		out.print("throws ");
		for (int j = 0; j < except.length; j++) {
			out.print(getPrettyName(except[j]));
			if (j+1 < except.length) {
				out.print(", ");
			}
		}
		out.print(" {");
		ctrl.indent();

		out.print("try {");
		ctrl.indent();

		if (need12Stubs) {
			if (need11Stubs) {
				out.print("if (useNewInvoke) {");
				ctrl.indent();
			}
			if (returntype != Void.TYPE) {
				out.print("java.lang.Object $result = ");
			}
			out.print("ref.invoke(this, $method_" + m.getName() + "_" + i + ", ");
			if (sig.length == 0) {
				out.print("null, ");
			}
			else {
				out.print("new java.lang.Object[] {");
				for (int j = 0; j < sig.length; j++) {
					if (sig[j] == Boolean.TYPE) {
						out.print("new java.lang.Boolean($param_" + j + ")");
					}
					else if (sig[j] == Byte.TYPE) {
						out.print("new java.lang.Byte($param_" + j + ")");
					}
					else if (sig[j] == Character.TYPE) {
						out.print("new java.lang.Character($param_" + j + ")");
					}
					else if (sig[j] == Short.TYPE) {
						out.print("new java.lang.Short($param_" + j + ")");
					}
					else if (sig[j] == Integer.TYPE) {
						out.print("new java.lang.Integer($param_" + j + ")");
					}
					else if (sig[j] == Long.TYPE) {
						out.print("new java.lang.Long($param_" + j + ")");
					}
					else if (sig[j] == Float.TYPE) {
						out.print("new java.lang.Float($param_" + j + ")");
					}
					else if (sig[j] == Double.TYPE) {
						out.print("new java.lang.Double($param_" + j + ")");
					}
					else {
						out.print("$param_" + j);
					}
					if (j+1 < sig.length) {
						out.print(", ");
					}
				}
				out.print("}, ");
			}
			out.print(Long.toString(remotemethods[i].hash) + "L");
			out.print(");");

			if (returntype != Void.TYPE) {
				out.println();
				out.print("return (");
				if (returntype == Boolean.TYPE) {
					out.print("((java.lang.Boolean)$result).booleanValue()");
				}
				else if (returntype == Byte.TYPE) {
					out.print("((java.lang.Byte)$result).byteValue()");
				}
				else if (returntype == Character.TYPE) {
					out.print("((java.lang.Character)$result).charValue()");
				}
				else if (returntype == Short.TYPE) {
					out.print("((java.lang.Short)$result).shortValue()");
				}
				else if (returntype == Integer.TYPE) {
					out.print("((java.lang.Integer)$result).intValue()");
				}
				else if (returntype == Long.TYPE) {
					out.print("((java.lang.Long)$result).longValue()");
				}
				else if (returntype == Float.TYPE) {
					out.print("((java.lang.Float)$result).floatValue()");
				}
				else if (returntype == Double.TYPE) {
					out.print("((java.lang.Double)$result).doubleValue()");
				}
				else {
					out.print("(" + getPrettyName(returntype) + ")$result");
				}
				out.print(");");
			}

			if (need11Stubs) {
				ctrl.unindent();
				out.println("}");
				out.print("else {");
				ctrl.indent();
			}
		}

		if (need11Stubs) {
			out.println("java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, " + i + ", interfaceHash);");
			out.print("try {");
			ctrl.indent();
			out.print("java.io.ObjectOutput out = call.getOutputStream();");
			for (int j = 0; j < sig.length; j++) {
				out.println();
				if (sig[j] == Boolean.TYPE) {
					out.print("out.writeBoolean(");
				}
				else if (sig[j] == Byte.TYPE) {
					out.print("out.writeByte(");
				}
				else if (sig[j] == Character.TYPE) {
					out.print("out.writeChar(");
				}
				else if (sig[j] == Short.TYPE) {
					out.print("out.writeShort(");
				}
				else if (sig[j] == Integer.TYPE) {
					out.print("out.writeInt(");
				}
				else if (sig[j] == Long.TYPE) {
					out.print("out.writeLong(");
				}
				else if (sig[j] == Float.TYPE) {
					out.print("out.writeFloat(");
				}
				else if (sig[j] == Double.TYPE) {
					out.print("out.writeDouble(");
				}
				else {
					out.print("out.writeObject(");
				}
				out.print("$param_" + j + ");");
			}
			ctrl.unindent();
			out.println("}");
			out.print("catch (java.io.IOException e) {");
			ctrl.indent();
			out.print("throw new java.rmi.MarshalException(\"error marshalling arguments\", e);");
			ctrl.unindent();
			out.println("}");
			out.println("ref.invoke(call);");
			if (returntype != Void.TYPE) {
				out.println(getPrettyName(returntype) + " $result;");
			}
			out.print("try {");
			ctrl.indent();
			out.print("java.io.ObjectInput in = call.getInputStream();");
			boolean needcastcheck = false;
			if (returntype != Void.TYPE) {
				out.println();
				out.print("$result = ");
				if (returntype == Boolean.TYPE) {
					out.print("in.readBoolean();");
				}
				else if (returntype == Byte.TYPE) {
					out.print("in.readByte();");