Mercurial > jdk8-mips64-public > corba / file revision

 /*

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

         }

     }

 }