/*

 * 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 java.io.File;

import java.io.IOException;

import java.text.DateFormat;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Locale;

import java.util.StringTokenizer;

import java.util.Vector;

import sun.tools.java.Identifier;

import sun.tools.java.ClassDefinition;

import sun.tools.java.CompilerError;

import sun.rmi.rmic.IndentingWriter;

import java.util.HashSet;

import sun.rmi.rmic.Main;

/**

 * An IDL generator for rmic.

 *

 * @author  Steve Newberry, Bryan Atsatt

 */

public class IDLGenerator extends sun.rmi.rmic.iiop.Generator {

    private boolean valueMethods = true;

    private boolean factory = true;                              //init==!factory

    private Hashtable ifHash = new Hashtable();              //IDL file Hashtable

    private Hashtable imHash = new Hashtable();            //IDL module Hashtable

    private boolean isThrown = true;                      //flag for writeInclude

    private boolean isException = true;       //flag for writeBanner, writeIfndef

    private boolean isForward = true;                      //flag for writeIfndef

    private boolean forValuetype = true;                 //flag for writeInherits

    /**

     * Default constructor for Main to use.

     */

    public IDLGenerator() {

    }

    /**

     * Return true if a new instance should be created for each

     * class on the command line. Subclasses which return true

     * should override newInstance() to return an appropriately

     * constructed instance.

     */

    protected boolean requireNewInstance() {

        return false;

    }

    /**

     * Return true if non-conforming types should be parsed.

     * @param stack The context stack.

     */

    protected boolean parseNonConforming(ContextStack stack) {

        return valueMethods;

    }

    /**

     * Create and return a top-level type.

     * @param cdef The top-level class definition.

     * @param stack The context stack.

     * @return An RemoteType or null if is non-conforming.

     */

    protected sun.rmi.rmic.iiop.CompoundType getTopType(ClassDefinition cdef,

                                                        ContextStack stack) {

        return CompoundType.forCompound(cdef,stack);

    }

    /**

     * Return an Identifier which contains the fully-qualified IDL filename

     * for the given OutputType.

     * The OutputType contains a filename string (not directory) and Type.

     * @param ot the OutputType for which directory nesting is to be defined.

     * @return the new identifier.

     */

    protected Identifier getOutputId (

                                      OutputType ot ) {

        Identifier id = super.getOutputId( ot );

        Type t = ot.getType();

        String fName = ot.getName();

        if ( id == idJavaLangClass )                 //java.lang.Class and array of

            if ( t.isArray() )

                return Identifier.lookup(

                                         "org.omg.boxedRMI.javax.rmi.CORBA." + fName  );

            else return idClassDesc;

        if ( id == idJavaLangString &&                  //array of java.lang.String

             t.isArray() )

            return Identifier.lookup( "org.omg.boxedRMI.CORBA." + fName );

        if ( "org.omg.CORBA.Object".equals( t.getQualifiedName() ) &&

             t.isArray() )                          //array of org.omg.CORBA.Object

            return Identifier.lookup( "org.omg.boxedRMI." + fName );

        if ( t.isArray()) {                                                 //array

            ArrayType at = (ArrayType)t;

            Type et = at.getElementType();

            if ( et.isCompound() ) {

                CompoundType ct = (CompoundType)et;

                String qName = ct.getQualifiedName();

                if ( ct.isIDLEntity() )

                    return Identifier.lookup( getQualifiedName( at ) );

            }

            return Identifier.lookup( idBoxedRMI,id );

        }

        if ( t.isCompound() ) {                                   //boxed IDLEntity

            CompoundType ct = (CompoundType)t;

            String qName = ct.getQualifiedName();

            if ( ct.isBoxed() )

                return Identifier.lookup( getQualifiedName( ct ) );

        }

        return id;

    }

    /**

     * Return the file name extension for the given file name (e.g. ".java").

     * All files generated with the ".java" extension will be compiled. To

     * change this behavior for ".java" files, override the compileJavaSourceFile

     * method to return false.

     * @param outputType One of the items returned by getOutputTypesFor(...)

     */

    protected String getFileNameExtensionFor(OutputType outputType) {

        return IDL_FILE_EXTENSION;

    }

    /**

     * Examine and consume command line arguments.

     * @param argv The command line arguments. Ignore null

     * and unknown arguments. Set each consumed argument to null.

     * @param main Report any errors using the main.error() methods.

     * @return true if no errors, false otherwise.

     */

    public boolean parseArgs(String argv[], Main main) {

        boolean result = super.parseArgs(argv,main);

        String idlFrom;

        String idlTo;

        if (result) {

        nextArg:

            for (int i = 0; i < argv.length; i++) {

                if (argv[i] != null) {

                    if (argv[i].equalsIgnoreCase("-idl")) {

                        idl = true;

                        argv[i] = null;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-valueMethods" ) ) {

                        valueMethods = true;

                        argv[i] = null;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-noValueMethods" ) ) {

                        valueMethods = false;

                        argv[i] = null;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-init" ) ) {

                        factory = false;

                        argv[i] = null;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-factory" ) ) {

                        factory = true;

                        argv[i] = null;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-idlfile" ) ) {

                        argv[i] = null;

                        if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {

                            idlFrom = argv[i];

                            argv[i] = null;

                            if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {

                                idlTo = argv[i];

                                argv[i] = null;

                                ifHash.put( idlFrom,idlTo );

                                continue nextArg;

                            }

                        }

                        main.error("rmic.option.requires.argument", "-idlfile");

                        result = false;

                    }

                    else if ( argv[i].equalsIgnoreCase( "-idlmodule" ) ) {

                        argv[i] = null;

                        if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {

                            idlFrom = argv[i];

                            argv[i] = null;

                            if ( ++i < argv.length && argv[i] != null && !argv[i].startsWith("-") ) {

                                idlTo = argv[i];

                                argv[i] = null;

                                imHash.put( idlFrom,idlTo );

                                continue nextArg;

                            }

                        }

                        main.error("rmic.option.requires.argument", "-idlmodule");

                        result = false;

                    }

                }

            }

        }

        return result;

    }

    /**

     * Return an array of OutputTypes for the IDL files that need to be

     * generated for the given top-level type.

     * OutputTypes contain filename string (not directory) and Type.

     * @param topType The type returned by getTopType().

     * @param alreadyChecked A set of Types which have already been checked.

     * @return Array of OutputTypes to generate

     */

    protected OutputType[] getOutputTypesFor(

                                             CompoundType topType,

                                             HashSet alreadyChecked ) {

        Vector refVec = getAllReferencesFor( topType );

        Vector outVec = new Vector();

        for ( int i1 = 0; i1 < refVec.size(); i1++ ) {          //forall references

            Type t = (Type)refVec.elementAt( i1 );

            if ( t.isArray() ) {

                ArrayType at = (ArrayType)t;

                int dim = at.getArrayDimension();

                Type et = at.getElementType();

                String fName = unEsc( et.getIDLName() ).replace( ' ','_' );

                for ( int i2 = 0; i2 < dim; i2++ ) {                //foreach dimension

                    String fileName = "seq" + ( i2 + 1 ) + "_" + fName;

                    outVec.addElement( new OutputType( fileName,at ) );

                }

            }

            else if ( t.isCompound() ) {

                String fName = unEsc( t.getIDLName() );

                outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) );

            if ( t.isClass() ) {

                ClassType ct = (ClassType)t;

                    if ( ct.isException() ) {                            //exception file

                        fName = unEsc( ct.getIDLExceptionName() );

                        outVec.addElement( new OutputType( fName.replace( ' ','_' ),t ) );

            }

        }

    }

    }

        OutputType[] outArr = new OutputType[outVec.size()];

        outVec.copyInto( outArr );

        return outArr;

    }

    /**

     * Get all referenced types of a given tyoe for which an IDL file needs

     * to be generated.

     * @param ct The given type.

     * @return Vector of Types for which IDL must be generated.

     */

    protected Vector getAllReferencesFor(

                                         CompoundType ct ) {

        Hashtable refHash = new Hashtable();

        Hashtable spcHash = new Hashtable();

        Hashtable arrHash = new Hashtable();

        int refSize;

        refHash.put( ct.getQualifiedName(),ct );               //put the given type

        accumulateReferences( refHash,spcHash,arrHash );

        do {

            refSize = refHash.size();

            accumulateReferences( refHash,spcHash,arrHash );

        }

        while ( refSize < refHash.size() );        //till hashtable stays same size

        Vector outVec = new Vector();

        Enumeration e = refHash.elements();                   //ordinary references

        while ( e.hasMoreElements() ) {

            CompoundType t = (CompoundType)e.nextElement();

            outVec.addElement( t );

        }

        e = spcHash.elements();                                //special references

        while ( e.hasMoreElements() ) {

            CompoundType t = (CompoundType)e.nextElement();

            outVec.addElement( t );

    }

        e = arrHash.elements();                                  //array references

                                         nextSequence:

        while ( e.hasMoreElements() ) {

            ArrayType at = (ArrayType)e.nextElement();

            int dim = at.getArrayDimension();

            Type et = at.getElementType();

            Enumeration e2 = arrHash.elements();

            while ( e2.hasMoreElements() ) {                   //eliminate duplicates

                ArrayType at2 = (ArrayType)e2.nextElement();

                if ( et == at2.getElementType() &&                //same element type &

                     dim < at2.getArrayDimension() )               //smaller dimension?

                    continue nextSequence;                              //ignore this one

            }

            outVec.addElement( at );

        }

        return outVec;

    }

    /**

     * Accumulate and filter all those types that are referenced by the given

     * referenced types.

     * Keep only those for which IDL is to be generated.

     * @param refHash Hashtable containing the given types

     * @param spcHash Hashtable containing referenced specials (IDL typedefs)

     * @param arrHash Hashtable containing referenced arrays (dimensioned)

     */

    protected void accumulateReferences(

                                        Hashtable refHash,

                                        Hashtable spcHash,

                                        Hashtable arrHash ) {

        Enumeration e = refHash.elements();

        while ( e.hasMoreElements() ) {

            CompoundType t = (CompoundType)e.nextElement();

            Vector datVec = getData( t );                     //collect and sort data

            Vector mthVec = getMethods( t );             //collect and filter methods

            getInterfaces( t,refHash );                          //collect interfaces

            getInheritance( t,refHash );                            //add inheritance

            getMethodReferences( mthVec,refHash,spcHash,arrHash,refHash );

            getMemberReferences( datVec,refHash,spcHash,arrHash );

        }

        e = arrHash.elements();                      //add array element references

        while ( e.hasMoreElements() ) {

            ArrayType at = (ArrayType)e.nextElement();

            Type et = at.getElementType();

            addReference( et,refHash,spcHash,arrHash );

        }

        e = refHash.elements();

        while ( e.hasMoreElements() ) {

            CompoundType t = (CompoundType)e.nextElement();

            if ( !isIDLGeneratedFor( t ) )              //remove if no IDL generation

                refHash.remove( t.getQualifiedName() );

    }

    }

    /**

     * Determine if IDL should be generated for a referenced type.

     * Do not generate IDL for a CORBA Object reference. It gets mapped

     * to the original IDL or to Object (if exactly org.omg.CORBA.Object)

     * Generate (boxed) IDL for an IDL Entity unless it is an IDL user

     * exception, a ValueBase, an AbstractBase (or a CORBA Object).

     * Do not generate IDL for Implementation classes..unless they inherit

     * from multiple distinct remote interfaces

     * @param t The type to check.

     * @return true or false

     */

    protected boolean isIDLGeneratedFor(

                                 CompoundType t ) {

        if ( t.isCORBAObject() ) return false;

        if ( t.isIDLEntity() )

            if ( t.isBoxed() ) return true;

            else if ( "org.omg.CORBA.portable.IDLEntity"

                      .equals( t.getQualifiedName() ) ) return true;

            else if ( t.isCORBAUserException() ) return true;

            else return false;

        Hashtable inhHash = new Hashtable();

        getInterfaces( t,inhHash );

        if ( t.getTypeCode() == TYPE_IMPLEMENTATION )

            if ( inhHash.size() < 2 ) return false;         //no multiple inheritance

            else return true;

        return true;                                   //generate IDL for this type

    }

    /**

     * Write the output for the given OutputFileName into the output stream.

     * (The IDL mapping for java.lang.Class is generated from

     * javax.rmi.CORBA.ClassDesc in the tools workspace)

     * @param ot One of the items returned by getOutputTypesFor(...)

     * @param alreadyChecked A set of Types which have already been checked.

     *  Intended to be passed to Type.collectMatching(filter,alreadyChecked).

     * @param p The output stream.

     */

    protected void writeOutputFor(

                                  OutputType ot,

                                  HashSet alreadyChecked,

                                  IndentingWriter p )

        throws IOException {

        Type t = ot.getType();

        if ( t.isArray() ) {                                //specialcase: sequence

            writeSequence( ot,p );

            return;

        }

        if ( isSpecialReference( t ) ) {                //specialcase: IDL typecode

            writeSpecial( t,p );

            return;

        }

        if ( t.isCompound() ) {                            //specialcase: boxed IDL

            CompoundType ct = (CompoundType)t;

            if ( ct.isIDLEntity() && ct.isBoxed() ) {

                writeBoxedIDL( ct,p );

                return;

            }

        }

        if ( t.isClass() ) {                               //specialcase: exception

            ClassType ct = (ClassType)t;

            if ( ct.isException() ) {

                String eName = unEsc( ct.getIDLExceptionName() );

                String fName = ot.getName();

                if ( fName.equals( eName.replace( ' ','_' ) ) ) {

                    writeException( ct,p );

                    return;

                }

            }

        }

        switch ( t.getTypeCode() ) {                                 //general case

        case TYPE_IMPLEMENTATION:

            writeImplementation( (ImplementationType)t,p );

            break;

        case TYPE_NC_CLASS:

        case TYPE_NC_INTERFACE:

            writeNCType( (CompoundType)t,p );

            break;

        case TYPE_ABSTRACT:                        //AbstractType is a RemoteType

        case TYPE_REMOTE:

            writeRemote( (RemoteType)t,p );

            break;

        case TYPE_VALUE:

            writeValue( (ValueType)t,p );

            break;

        default:

            throw new CompilerError(

                                    "IDLGenerator got unexpected type code: "

                                    + t.getTypeCode());

        }

    }

    /**

     * Write an IDL interface definition for a Java implementation class

     * @param t The current ImplementationType

     * @param p The output stream.

     */

    protected void writeImplementation(

                                       ImplementationType t,

                                       IndentingWriter p )

        throws IOException {

        Hashtable inhHash = new Hashtable();

        Hashtable refHash = new Hashtable();

        getInterfaces( t,inhHash );                            //collect interfaces

        writeBanner( t,0,!isException,p );

        writeInheritedIncludes( inhHash,p );

        writeIfndef( t,0,!isException,!isForward,p );

        writeIncOrb( p );

        writeModule1( t,p );

        p.pln();p.pI();

        p.p( "interface " + t.getIDLName() );

        writeInherits( inhHash,!forValuetype,p );

        p.pln( " {" );

        p.pln( "};" );

        p.pO();p.pln();

        writeModule2( t,p );

        writeEpilog( t,refHash,p );

    }

    /**

     * Write an IDL valuetype definition for

     * 1) a nonconforming Java class

     * 2) a nonconforming Java interface (that is not an AbstractType)

     * @param t The current NC Type (NCClassType or NCInterfaceType)

     * @param p The output stream.

     */

    protected void writeNCType(

                               CompoundType t,

                               IndentingWriter p )

        throws IOException {

        Vector conVec = getConstants( t );                      //collect constants

        Vector mthVec = getMethods( t );                          //collect methods

        Hashtable inhHash = new Hashtable();

        Hashtable refHash = new Hashtable();

        Hashtable spcHash = new Hashtable();

        Hashtable arrHash = new Hashtable();

        Hashtable excHash = new Hashtable();

        getInterfaces( t,inhHash );                            //collect interfaces

        getInheritance( t,inhHash );                              //add inheritance

        getMethodReferences( mthVec,refHash,spcHash,arrHash,excHash );

        writeProlog( t,refHash,spcHash,arrHash,excHash,inhHash,p );

        writeModule1( t,p );

        p.pln();p.pI();

        p.p( "abstract valuetype " + t.getIDLName() );

        writeInherits( inhHash,!forValuetype,p );

        p.pln( " {" );

        if ( conVec.size() + mthVec.size() > 0 ) {                   //any content?

            p.pln();p.pI();