/*
* Copyright (c) 1998, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* Licensed Materials - Property of IBM
* RMI-IIOP v1.0
* Copyright IBM Corp. 1998 1999 All Rights Reserved
*
*/
package sun.rmi.rmic.iiop;
import sun.rmi.rmic.Main;
import sun.tools.java.ClassPath;
import java.io.OutputStream;
import sun.tools.java.ClassDefinition;
import sun.tools.java.ClassDeclaration;
import sun.tools.java.Identifier;
import sun.tools.java.ClassNotFound;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Iterator;
/**
* BatchEnvironment for iiop extends rmic's version to add
* parse state.
*/
public class BatchEnvironment extends sun.rmi.rmic.BatchEnvironment implements Constants {
/*
* If the following flag is true, then the IDL generator can map
* the methods and constants of non-conforming types. However,
* this is very expensive, so the default should be false.
*/
private boolean parseNonConforming = false;
/**
* This flag indicates that the stubs and ties need to be generated without
* the package prefix (org.omg.stub).
*/
private boolean standardPackage;
/* Common objects used within package */
HashSet alreadyChecked = new HashSet();
Hashtable allTypes = new Hashtable(3001, 0.5f);
Hashtable invalidTypes = new Hashtable(256, 0.5f);
DirectoryLoader loader = null;
ClassPathLoader classPathLoader = null;
Hashtable nameContexts = null;
Hashtable namesCache = new Hashtable();
NameContext modulesContext = new NameContext(false);
ClassDefinition defRemote = null;
ClassDefinition defError = null;
ClassDefinition defException = null;
ClassDefinition defRemoteException = null;
ClassDefinition defCorbaObject = null;
ClassDefinition defSerializable = null;
ClassDefinition defExternalizable = null;
ClassDefinition defThrowable = null;
ClassDefinition defRuntimeException = null;
ClassDefinition defIDLEntity = null;
ClassDefinition defValueBase = null;
sun.tools.java.Type typeRemoteException = null;
sun.tools.java.Type typeIOException = null;
sun.tools.java.Type typeException = null;
sun.tools.java.Type typeThrowable = null;
ContextStack contextStack = null;
/**
* Create a BatchEnvironment for rmic with the given class path,
* stream for messages and Main.
*/
public BatchEnvironment(OutputStream out, ClassPath path, Main main) {
super(out,path,main);
// Make sure we have our definitions...
try {
defRemote =
getClassDeclaration(idRemote).getClassDefinition(this);
defError =
getClassDeclaration(idJavaLangError).getClassDefinition(this);
defException =
getClassDeclaration(idJavaLangException).getClassDefinition(this);
defRemoteException =
getClassDeclaration(idRemoteException).getClassDefinition(this);
defCorbaObject =
getClassDeclaration(idCorbaObject).getClassDefinition(this);
defSerializable =
getClassDeclaration(idJavaIoSerializable).getClassDefinition(this);
defRuntimeException =
getClassDeclaration(idJavaLangRuntimeException).getClassDefinition(this);
defExternalizable =
getClassDeclaration(idJavaIoExternalizable).getClassDefinition(this);
defThrowable=
getClassDeclaration(idJavaLangThrowable).getClassDefinition(this);
defIDLEntity=
getClassDeclaration(idIDLEntity).getClassDefinition(this);
defValueBase=
getClassDeclaration(idValueBase).getClassDefinition(this);
typeRemoteException = defRemoteException.getClassDeclaration().getType();
typeException = defException.getClassDeclaration().getType();
typeIOException = getClassDeclaration(idJavaIoIOException).getType();
typeThrowable = getClassDeclaration(idJavaLangThrowable).getType();
classPathLoader = new ClassPathLoader(path);
} catch (ClassNotFound e) {
error(0, "rmic.class.not.found", e.name);
throw new Error();
}
}
/**
* Return whether or not to parse non-conforming types.
*/
public boolean getParseNonConforming () {
return parseNonConforming;
}
/**
* Set whether or not to parse non-conforming types.
*/
public void setParseNonConforming (boolean parseEm) {
// If we are transitioning from not parsing to
// parsing, we need to throw out any previously
// parsed types...
if (parseEm && !parseNonConforming) {
reset();
}
parseNonConforming = parseEm;
}
void setStandardPackage(boolean standardPackage) {
this.standardPackage = standardPackage;
}
boolean getStandardPackage() {
return standardPackage;
}
/**
* Clear out any data from previous executions.
*/
public void reset () {
// First, find all Type instances and call destroy()
// on them...
for (Enumeration e = allTypes.elements() ; e.hasMoreElements() ;) {
Type type = (Type) e.nextElement();
type.destroy();
}
for (Enumeration e = invalidTypes.keys() ; e.hasMoreElements() ;) {
Type type = (Type) e.nextElement();
type.destroy();
}
for (Iterator e = alreadyChecked.iterator() ; e.hasNext() ;) {
Type type = (Type) e.next();
type.destroy();
}
if (contextStack != null) contextStack.clear();
// Remove and clear all NameContexts in the
// nameContexts cache...
if (nameContexts != null) {
for (Enumeration e = nameContexts.elements() ; e.hasMoreElements() ;) {
NameContext context = (NameContext) e.nextElement();
context.clear();
}
nameContexts.clear();
}
// Now remove all table entries...
allTypes.clear();
invalidTypes.clear();
alreadyChecked.clear();
namesCache.clear();
modulesContext.clear();
// Clean up remaining...
loader = null;
parseNonConforming = false;
// REVISIT - can't clean up classPathLoader here
}
/**
* Release resources, if any.
*/
public void shutdown() {
if (alreadyChecked != null) {
//System.out.println();
//System.out.println("allTypes.size() = "+ allTypes.size());
//System.out.println(" InstanceCount before reset = "+Type.instanceCount);
reset();
//System.out.println(" InstanceCount AFTER reset = "+Type.instanceCount);
alreadyChecked = null;
allTypes = null;
invalidTypes = null;
nameContexts = null;
namesCache = null;
modulesContext = null;
defRemote = null;
defError = null;
defException = null;
defRemoteException = null;
defCorbaObject = null;
defSerializable = null;
defExternalizable = null;
defThrowable = null;
defRuntimeException = null;
defIDLEntity = null;
defValueBase = null;
typeRemoteException = null;
typeIOException = null;
typeException = null;
typeThrowable = null;
super.shutdown();
}
}
}