jdk8-mips64-public/corba: src/share/classes/sun/rmi/rmic/iiop/BatchEnvironment.java@9c913ea7e4a1 (annotated)

src/share/classes/sun/rmi/rmic/iiop/BatchEnvironment.java@9c913ea7e4a1 (annotated)

src/share/classes/sun/rmi/rmic/iiop/BatchEnvironment.java

Thu, 24 May 2018 16:41:12 +0800

author: aoqi
date: Thu, 24 May 2018 16:41:12 +0800
changeset 1410: 9c913ea7e4a1
parent 748: 6845b95cba6b
permissions: -rw-r--r--

Merge

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

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/sun/rmi/rmic/iiop/BatchEnvironment.java@9c913ea7e4a1 (annotated)

src/share/classes/sun/rmi/rmic/iiop/BatchEnvironment.java