| /* |
| * 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(); |
| } |
| } |
| } |