/* SourceGiopRmicCompiler -- Central GIOP-based RMI stub and tie compiler class.
Copyright (C) 2006, 2008 Free Software Foundation
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., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
*/
package gnu.classpath.tools.rmic;
import gnu.classpath.tools.rmic.AbstractMethodGenerator;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.TreeSet;
/**
* Provides the extended rmic functionality to generate the POA - based classes
* for GIOP (javax.rmi.CORBA package).
*
* @author Audrius Meskauskas, Lithuania (audriusa@Bioinformatics.org)
*/
public class SourceGiopRmicCompiler
extends Generator implements Comparator, RmicBackend
{
/** The package name. */
protected String packag;
/**
* The "basic" name (normally, the interface name, unless several Remote -
* derived interfaces are implemented.
*/
protected String name;
/**
* The name (without package) of the class, passed as the parameter.
*/
protected String implName;
/**
* The proposed name for the stub.
*/
protected String stubName;
/**
* The Remote's, implemented by this class.
*/
protected Collection implementedRemotes = new HashSet();
/**
* The extra classes that must be imported.
*/
protected Collection extraImports = new HashSet();
/**
* The methods we must implement.
*/
protected Collection methods = new HashSet();
/**
* The map of all code generator variables.
*/
public Properties vars = new Properties();
/**
* If this flag is set (true by default), the compiler generates the Servant
* based classes. If set to false, the compiler generates the old style
* ObjectImpl based classes.
*/
protected boolean poaMode = true;
/**
* If this flag is set (true by default), the compiler emits warnings.
*/
protected boolean warnings = true;
/**
* If this flag is set (false by default), the compiler does not
* write output files.
*/
protected boolean noWrite = false;
/**
* If this flag is set (false by default), the compiler keeps source
* output files. For SourceGiopRmicCompiler this overrides
* -nowrite, since -nowrite doesn't apply to sources kept with
* -keep.
*/
protected boolean keep = false;
/**
* Verbose output
*/
protected boolean verbose = false;
/**
* Force mode - do not check the exceptions
*/
protected boolean force = false;
/**
* The output directory for generated files.
*/
protected String outputDirectory;
/**
* The class loader to load the class being compiled.
*/
ClassLoader classLoader;
/**
* Clear data, preparing for the next compilation.
*/
public synchronized void reset()
{
packag = name = implName = stubName = null;
implementedRemotes.clear();
extraImports.clear();
methods.clear();
vars.clear();
}
/**
* Set the class path (handle the -classpath key)
*
* @param classPath the class path to set.
*/
public void setClassPath(String classPath)
{
classLoader = Thread.currentThread().getContextClassLoader();
StringTokenizer tok = new StringTokenizer(classPath, File.pathSeparator,
true);
ArrayList urls = new ArrayList(tok.countTokens());
String s = null;
try
{
while (tok.hasMoreTokens())
{
s = tok.nextToken();
if (s.equals(File.pathSeparator))
urls.add(new File(".").toURL());
else
{
urls.add(new File(s).toURL());
if (tok.hasMoreTokens())
{
// Skip the separator.
tok.nextToken();
// If the classpath ended with a separator,
// append the current directory.
if (! tok.hasMoreTokens())
urls.add(new File(".").toURL());
}
}
}
}
catch (MalformedURLException ex)
{
System.err.println("Malformed path '" + s + "' in classpath '"
+ classPath + "'");
System.exit(1);
}
URL[] u = new URL[urls.size()];
for (int i = 0; i < u.length; i++)
{
u[i] = (URL) urls.get(i);
}
classLoader = new URLClassLoader(u, classLoader);
}
/**
* Loads the class with the given name (uses class path, if applicable)
*
* @param name the name of the class.
*/
public Class loadClass(String name)
{
ClassLoader loader = classLoader;
if (loader == null)
loader = Thread.currentThread().getContextClassLoader();
try
{
return loader.loadClass(name);
}
catch (ClassNotFoundException e)
{
System.err.println(name+" not found on "+loader);
System.exit(1);
// Unreacheable code.
return null;
}
}
/**
* Compile the given class (the instance of Remote), generating the stub and
* tie for it.
*
* @param remote
* the class to compile.
*/
public synchronized void compile(Class remote)
{
reset();
String s;
// Get the package.
s = remote.getName();
int p = s.lastIndexOf('.');
if (p < 0)
{
// Root package.
packag = "";
implName = name = s;
}
else
{
packag = s.substring(0, p);
implName = name = s.substring(p + 1);
}
name = convertStubName(name);
stubName = name;
vars.put("#name", name);
vars.put("#package", packag);
vars.put("#implName", implName);
if (verbose)
System.out.println("Package " + packag + ", name " + name + " impl "
+ implName);
// Get the implemented remotes.
Class[] interfaces = remote.getInterfaces();
for (int i = 0; i < interfaces.length; i++)
{
if (Remote.class.isAssignableFrom(interfaces[i]))
{
if (! interfaces[i].equals(Remote.class))
{
implementedRemotes.add(interfaces[i]);
}
}
}
vars.put("#idList", getIdList(implementedRemotes));
// Collect and process methods.
Iterator iter = implementedRemotes.iterator();
while (iter.hasNext())
{
Class c = (Class) iter.next();
Method[] m = c.getMethods();
// Check if throws RemoteException.
for (int i = 0; i < m.length; i++)
{
Class[] exc = m[i].getExceptionTypes();
boolean remEx = false;
for (int j = 0; j < exc.length; j++)
{
if (exc[j].isAssignableFrom(RemoteException.class))
{
remEx = true;
break;
}
}
if (! remEx && !force)
throw new CompilationError(m[i].getName() + ", defined in "
+ c.getName()
+ ", does not throw "
+ RemoteException.class.getName());
AbstractMethodGenerator mm = createMethodGenerator(m[i]);
methods.add(mm);
}
}
}
/**
* Create the method generator for the given method.
*
* @param m the method
*
* @return the created method generator
*/
protected AbstractMethodGenerator createMethodGenerator(Method m)
{
return new MethodGenerator(m, this);
}
/**
* Get the name of the given class. The class is added to imports, if not
* already present and not from java.lang and not from the current package.
*
* @param nameIt
* the class to name
* @return the name of class as it should appear in java language
*/
public synchronized String name(Class nameIt)
{
if (nameIt.isArray())
{
// Mesure dimensions:
int dimension = 0;
Class finalComponent = nameIt;
while (finalComponent.isArray())
{
finalComponent = finalComponent.getComponentType();
dimension++;
}
StringBuilder brackets = new StringBuilder();
for (int i = 0; i < dimension; i++)
{
brackets.append("[]");
}
return name(finalComponent) + " " + brackets;
}
else
{
String n = nameIt.getName();
if (! nameIt.isArray() && ! nameIt.isPrimitive())
if (! n.startsWith("java.lang")
&& ! (packag != null && n.startsWith(packag)))
extraImports.add(n);
int p = n.lastIndexOf('.');
if (p < 0)
return n;
else
return n.substring(p + 1);
}
}
/**
* Get the RMI-style repository Id for the given class.
*
* @param c
* the interface, for that the repository Id must be created.
* @return the repository id
*/
public String getId(Class c)
{
return "RMI:" + c.getName() + ":0000000000000000";
}
/**
* Get repository Id string array declaration.
*
* @param remotes
* the collection of interfaces
* @return the fully formatted string array.
*/
public String getIdList(Collection remotes)
{
StringBuilder b = new StringBuilder();
// Keep the Ids sorted, ensuring, that the same order will be preserved
// between compilations.
TreeSet sortedIds = new TreeSet();
Iterator iter = remotes.iterator();
while (iter.hasNext())
{
sortedIds.add(getId((Class) iter.next()));
}
iter = sortedIds.iterator();
while (iter.hasNext())
{
b.append(" \"" + iter.next() + "\"");
if (iter.hasNext())
b.append(", \n");
}
return b.toString();
}
/**
* Generate stub. Can only be called from {@link #compile}.
*
* @return the string, containing the text of the generated stub.
*/
public String generateStub()
{
String template = getResource("Stub.jav");
// Generate methods.
StringBuilder b = new StringBuilder();
Iterator iter = methods.iterator();
while (iter.hasNext())
{
AbstractMethodGenerator m = (AbstractMethodGenerator) iter.next();
b.append(m.generateStubMethod());
}
vars.put("#stub_methods", b.toString());
vars.put("#imports", getImportStatements());
vars.put("#interfaces", getAllInterfaces());
String output = replaceAll(template, vars);
return output;
}
/**
* Get the list of all interfaces, implemented by the class, that are
* derived from Remote.
*
* @return the string - all interfaces.
*/
public String getAllInterfaces()
{
StringBuilder b = new StringBuilder();
Iterator iter = implementedRemotes.iterator();
while (iter.hasNext())
{
b.append(name((Class) iter.next()));
if (iter.hasNext())
b.append(", ");
}
return b.toString();
}
/**
* Generate Tie. Can only be called from {@link #compile}.
*
* @return the string, containing the text of the generated Tie.
*/
public String generateTie()
{
String template;
if (poaMode)
template = getResource("Tie.jav");
else
template = getResource("ImplTie.jav");
// Generate methods.
HashFinder hashFinder = new HashFinder();
// Find the hash character position:
Iterator iter = methods.iterator();
String[] names = new String[methods.size()];
int p = 0;
for (int i = 0; i < names.length; i++)
names[i] = ((MethodGenerator) iter.next()).getGiopMethodName();
int hashCharPosition = hashFinder.findHashCharPosition(names);
iter = methods.iterator();
while (iter.hasNext())
((MethodGenerator) iter.next()).hashCharPosition = hashCharPosition;
vars.put("#hashCharPos", Integer.toString(hashCharPosition));
ArrayList sortedMethods = new ArrayList(methods);
Collections.sort(sortedMethods, this);
iter = sortedMethods.iterator();
StringBuilder b = new StringBuilder();
MethodGenerator prev = null;
while (iter.hasNext())
{
MethodGenerator m = (MethodGenerator) iter.next();
m.previous = prev;
m.hashCharPosition = hashCharPosition;
prev = m;
b.append(m.generateTieMethod());
}
vars.put("#tie_methods", b.toString());
vars.put("#imports", getImportStatements());
String output = replaceAll(template, vars);
return output;
}
public int compare(Object a, Object b)
{
MethodGenerator g1 = (MethodGenerator) a;
MethodGenerator g2 = (MethodGenerator) b;
return g1.getHashChar() - g2.getHashChar();
}
/**
* Import the extra classes, used as the method parameters and return values.
*
* @return the additional import block.
*/
protected String getImportStatements()
{
TreeSet imp = new TreeSet();
Iterator it = extraImports.iterator();
while (it.hasNext())
{
String ic = it.next().toString();
imp.add("import " + ic + ";\n");
}
StringBuilder b = new StringBuilder();
it = imp.iterator();
while (it.hasNext())
{
b.append(it.next());
}
return b.toString();
}
/**
* If this flag is set (true by default), the compiler generates the Servant
* based classes. If set to false, the compiler generates the old style
* ObjectImpl based classes.
*/
public void setPoaMode(boolean mode)
{
poaMode = mode;
}
/**
* Set the verbose output mode (false by default)
*
* @param isVerbose the verbose output mode
*/
public void setVerbose(boolean isVerbose)
{
verbose = isVerbose;
}
/**
* If this flag is set (true by default), the compiler emits warnings.
*/
public void setWarnings(boolean warn)
{
warnings = warn;
}
/**
* Set the error ignore mode.
*/
public void setForce(boolean isforce)
{
force = isforce;
}
/**
* Get the package name.
*/
public String getPackageName()
{
return packag;
}
/**
* Get the proposed stub name
*/
public String getStubName()
{
return stubName;
}
/**
* Additional processing of the stub name.
*/
public String convertStubName(String name)
{
// Drop the Impl suffix, if one exists.
if (name.endsWith("Impl"))
return name.substring(0, name.length() - "Impl".length());
else
return name;
}
/**
* Assumes that output directory is already created.
*/
protected boolean outputTie(File fw, Class c)
{
try
{
String tie = generateTie();
String tieName = "_" + name(c) + "_Tie.java";
OutputStream out = new FileOutputStream(new File(fw, tieName));
out.write(tie.getBytes());
out.close();
}
catch (IOException ioex)
{
System.err.println("Output path not accessible");
ioex.printStackTrace();
return false;
}
return true;
}
public void setup(boolean keep, boolean need11Stubs, boolean need12Stubs,
boolean iiop, boolean poa, boolean debug, boolean warnings,
boolean noWrite, boolean verbose, boolean force, String classpath,
String bootclasspath, String extdirs, String outputDirectory)
{
setWarnings(warnings);
setVerbose(verbose);
setForce(force);
setClassPath(classpath);
setPoaMode(poa);
this.outputDirectory = outputDirectory;
this.noWrite = noWrite;
this.keep = keep;
}
public boolean run(String[] inputFiles)
{
for (int i = 0; i < inputFiles.length; i++)
{
reset();
Class c = loadClass(inputFiles[i]);
compile(c);
String packag = getPackageName().replace('.', '/');
File fw = new File(outputDirectory, packag);
// Generate stub.
String stub = generateStub();
String subName = getStubName() + "_Stub.java";
// -keep overrides -nowrite for sources.
if (!noWrite || keep)
{
try
{
fw.mkdirs();
OutputStream out = new FileOutputStream(new File(fw,
subName));
out.write(stub.getBytes());
out.close();
// Generate tie
if (!outputTie(fw, c))
return false;
}
catch (IOException ioex)
{
System.err.println("Output path not accessible");
ioex.printStackTrace();
return false;
}
}
}
return true;
}
}