/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

 * 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.

 *

 */

/*

 * COMPONENT_NAME: idl.toJava

 *

 * ORIGINS: 27

 *

 * Licensed Materials - Property of IBM

 * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999

 * RMI-IIOP v1.0

 *

 */

package com.sun.tools.corba.se.idl.toJavaPortable;

// NOTES:

// -The ctor should really throw an exception, but then it must have a

//  throws clause. How much of a ripple effect is this?

// -F46082.51<daz> Remove -stateful feature.

// -D60929   <klr> Update for RTF2.4 changes

// -D61056   <klr> Use Util.helperName

// -D62014   <klr> Move const definitions from signature to operations interf.

// -D62310   <klr> Fix declaration of interfaces extending abstract intf.

// -D62023   <klr> Move const definitions back from operations to signature.

import java.io.PrintWriter;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

import com.sun.tools.corba.se.idl.GenFileStream;

import com.sun.tools.corba.se.idl.ConstEntry;

import com.sun.tools.corba.se.idl.InterfaceEntry;

import com.sun.tools.corba.se.idl.InterfaceState;

import com.sun.tools.corba.se.idl.MethodEntry;

import com.sun.tools.corba.se.idl.PrimitiveEntry;

import com.sun.tools.corba.se.idl.SequenceEntry;

import com.sun.tools.corba.se.idl.StringEntry;

import com.sun.tools.corba.se.idl.SymtabEntry;

import com.sun.tools.corba.se.idl.TypedefEntry;

/**

 *

 **/

public class InterfaceGen implements com.sun.tools.corba.se.idl.InterfaceGen, JavaGenerator

{

  /**

   * Public zero-argument constructor.

   **/

  public InterfaceGen ()

  {

    //emit = ((Arguments)Compile.compiler.arguments).emit;

    //factories = (Factories)Compile.compiler.factories ();

  } // ctor

  /**

   * Generate the interface and all the files associated with it.

   * Provides general algorithm for binding generation:

   * 1.) Initialize symbol table and symbol table entry members, common to all generators.

   * 2.) Generate the skeleton if required by calling generateSkeletn ()

   * 3.) Generate the holder by calling generateHolder ()

   * 4.) Generate the helper by calling generateHelper ()

   * 5.) Generate the stub if required by calling generateStub ()

   * 6.) Generate the interface by calling generateInterface ()

   **/

  public void generate (Hashtable symbolTable, InterfaceEntry i, PrintWriter stream)

  {

    if (!isPseudo(i))

    {

      this.symbolTable = symbolTable;

      this.i           = i;

      init ();

      // for sun_local pragma, just generate the signature and operations interfaces

      // for sun_localservant pragma, generate the Local Stubs, and Skel, should not

      // have _invoke defined.

      // for local (is_local()) case, generate only Helpers and Holder, where they

      // have been modified to throw appropriate exceptions for read and write, and

      // narrow is modified to not invoke _is_a

      if (! (i.isLocalSignature())) {

          // generate the stubs and skeletons for non-local interfaces

          if (! (i.isLocal())) {

              // for local servant case just generate the skeleton, but

              // for others generate the stubs also

              generateSkeleton ();

              // _REVISIT_, Whenever there is time restructure the code to

              // encapsulate stub and skeleton generation.

              // If the option is -fallTie then generate the Tie class first

              // and then generate the ImplBase class to make the generation

              // complete for the Hierarchy.

              Arguments theArguments = (Arguments)Compile.compiler.arguments;

              if( (theArguments.TIEServer == true )

                &&(theArguments.emit == theArguments.All ) )

              {

                  theArguments.TIEServer = false;

                  // Generate the ImplBase class

                  generateSkeleton ();

                  // Revert in case file contains multiple interfaces

                  theArguments.TIEServer = true;

              }

              generateStub ();

          }

          generateHolder ();

          generateHelper ();

      }

      intfType = SIGNATURE;

      generateInterface ();

      intfType = OPERATIONS;

      generateInterface ();

      intfType = 0;

    }

  } // generate

  /**

   * Initialize members unique to this generator.

   **/

  protected void init ()

  {

    emit = ((Arguments)Compile.compiler.arguments).emit;

    factories = (Factories)Compile.compiler.factories ();

  } // init

  /**

   * Generate a Skeleton when the user does not want just the client-side code.

   **/

  protected void generateSkeleton ()

  {

    // <f46082.51> Remove -stateful feature.

    // The Skeleton is generated only when the user doesn't want

    // JUST the client code OR when the interface is stateful

    //if (emit != Arguments.Client || i.state () != null)

    //  factories.skeleton ().generate (symbolTable, i);

    if (emit != Arguments.Client)

      factories.skeleton ().generate (symbolTable, i);

  } // generateSkeleton

  /**

   * Generate a Stub when the user does not want just the server-side code.

   **/

  protected void generateStub ()

  {

    // <klr> According to Simon on 10/28/98, we should generate stubs for

    // abstract interfaces too.

    if (emit != Arguments.Server /* && !i.isAbstract () */)

      factories.stub ().generate (symbolTable, i);

  } // generateStub

  /**

   * Generate a Helper when the user does not want just the server-side code.

   **/

  protected void generateHelper ()

  {

    if (emit != Arguments.Server)

      factories.helper ().generate (symbolTable, i);

  } // generateHelper

  /**

   * Generate a Holder when the user does not want just the server-side code.

   **/

  protected void generateHolder ()

  {

    if (emit != Arguments.Server)

      factories.holder ().generate (symbolTable, i);

  } // generateHolder

  /**

   * Generate the interface. Provides general algorithm for binding generation:

   * 1.) Initialize members unique to this generator. - init ()

   * 2.) Open print stream - openStream ()

   * 3.) Write class heading (package, prologue, class statement, open curly - writeHeading ()

   * 4.) Write class body (member data and methods) - write*Body ()

   * 5.) Write class closing (close curly) - writeClosing ()

   * 6.) Close the print stream - closeStream ()

   *

   * For CORBA 2.3, interfaces are mapped to Operations and Signature

   * interfaces. The Operations interface contains the method definitions.

   * The Signature interface extends the Operations interface and adds

   * CORBA::Object. <klr>

   **/

  protected void generateInterface ()

  {

    init ();

    openStream ();

    if (stream == null)

      return;

    writeHeading ();

    if (intfType == OPERATIONS)

      writeOperationsBody ();

    if (intfType == SIGNATURE)

      writeSignatureBody ();

    writeClosing ();

    closeStream ();

  } // generateInterface

  /**

   *

   **/

  protected void openStream ()

  {

    if (i.isAbstract () || intfType == SIGNATURE)

       stream = Util.stream (i, ".java");

    else if (intfType == OPERATIONS)

       stream = Util.stream (i, "Operations.java");

  } // openStream

  /**

   *

   **/

  protected void writeHeading ()

  {

    Util.writePackage (stream, i, Util.TypeFile);

    Util.writeProlog (stream, ((GenFileStream)stream).name ());

    // Transfer interface comment to target <31jul1997>.

    if (i.comment () != null)

      i.comment ().generate ("", stream);

    String className = i.name ();

//  if (((Arguments)Compile.compiler.arguments).TIEServer)

//  {

//    // For the delegate model, don't make interface a subclass of CORBA.Object

//    stream.print ("public interface " + className);

//    boolean firstTime = true;

//    for (int ii = 0; ii < i.derivedFrom ().size (); ++ii)

//    {

//      SymtabEntry parent = (SymtabEntry)i.derivedFrom ().elementAt (ii);

//      if (!parent.fullName ().equals ("org/omg/CORBA/Object"))

//      {

//        if (firstTime)

//        {

//          firstTime = false;

//          stream.print (" extends ");

//        }

//        else

//          stream.print (", ");

//        stream.print (Util.javaName (parent));

//      }

//    }

//    if (i.derivedFrom ().size () > 0)

//      stream.print (", ");

//    stream.print ("org.omg.CORBA.portable.IDLEntity ");

//  }

//

//  else

//  {

      if (intfType == SIGNATURE)

         writeSignatureHeading ();

      else if (intfType == OPERATIONS)

         writeOperationsHeading ();

//  }

    stream.println ();

    stream.println ('{');

  } // writeHeading

  /**

   *

   **/

  protected void writeSignatureHeading ()

  {

    String className = i.name ();

    stream.print ("public interface " + className + " extends " + className + "Operations, ");

    boolean firstTime = true;

    boolean hasNonAbstractParent = false; // <d62310-klr>

    for (int k = 0; k < i.derivedFrom ().size (); ++k)

    {

      if (firstTime)

        firstTime = false;

      else

        stream.print (", ");

      InterfaceEntry parent = (InterfaceEntry)i.derivedFrom ().elementAt (k);

      stream.print (Util.javaName (parent));

      if (! parent.isAbstract ()) // <d62310-klr>

        hasNonAbstractParent = true; // <d62310-klr>

    }

    // <d62310-klr> - begin

    // If this interface extends only abstract interfaces,

    // it should extend both org.omg.CORBA.Object and IDLEntity.

    if (!hasNonAbstractParent) {

      stream.print (", org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity ");

    }

    else {

    // <d62310-klr> - end

        // extends IDLEntity if there's only one default parent - CORBA.Object

        if (i.derivedFrom ().size () == 1)

          stream.print (", org.omg.CORBA.portable.IDLEntity ");

    }

  } // writeSignatureHeading

  /**

   *

   **/

  protected void writeOperationsHeading ()

  {

    stream.print ("public interface " + i.name ());

    if ( !i.isAbstract ())

      stream.print ("Operations ");

    else {

        // <d60929> - base abstract interfaces extend AbstractBase

        // changed to IDLEntity by SCN per latest spec...

        if (i.derivedFrom ().size () == 0)

          stream.print (" extends org.omg.CORBA.portable.IDLEntity");

    }

    boolean firstTime = true;

    for (int k = 0; k < i.derivedFrom ().size (); ++k)

    {

      InterfaceEntry parent = (InterfaceEntry) i.derivedFrom ().elementAt (k);

      String parentName = Util.javaName (parent);

      // ignore the default parent - CORBA.Object

      if (parentName.equals ("org.omg.CORBA.Object"))

          continue;

      if (firstTime)

      {

        firstTime = false;

        stream.print (" extends ");

      }

      else

        stream.print (", ");

      // Don't append suffix Operations to the parents of abstract interface

      // or to the abstract parents of regular interface

      if (parent.isAbstract () || i.isAbstract ())

        stream.print (parentName);

      else

        stream.print (parentName + "Operations");

    }

  } // writeOperationsHeading

  /**

   *

   **/

  protected void writeOperationsBody ()

  {

    // Generate everything but constants

    Enumeration e = i.contained ().elements ();

    while (e.hasMoreElements ())

    {

      SymtabEntry contained = (SymtabEntry)e.nextElement ();

      if (contained instanceof MethodEntry)

      {

        MethodEntry element = (MethodEntry)contained;

        ((MethodGen)element.generator ()).interfaceMethod (symbolTable, element, stream);

      }

      else

        if ( !(contained instanceof ConstEntry))

          contained.generate (symbolTable, stream);

    }

  } // writeOperationsBody

  /**

   *

   **/

  protected void writeSignatureBody ()

  {

    // Generate only constants

    Enumeration e = i.contained ().elements ();

    while (e.hasMoreElements ())

    {

      SymtabEntry contained = (SymtabEntry)e.nextElement ();

      if (contained instanceof ConstEntry)

        contained.generate (symbolTable, stream);

    }

  } // writeSignatureBody

  /**

   *

   **/

  protected void writeClosing ()

  {

    String intfName = i.name ();

    if ( !i.isAbstract () && intfType == OPERATIONS)

      intfName = intfName + "Operations";

    stream.println ("} // interface " + intfName);

  } // writeClosing

  /**

   *

   **/

  protected void closeStream ()

  {

    stream.close ();

  } // closeStream

  ///////////////

  // From JavaGenerator

  // <f46082.51> Remove -stateful feature.

  /*

  public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (i.state () != null && i.state ().size () > 0)

      index = structHelperType (index, indent, tcoffsets, name, entry, stream);

    else

    {

      tcoffsets.set (entry);

      if (entry.fullName ().equals ("org/omg/CORBA/Object"))

        stream.println (indent + name

            + " = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_objref);");

      else

        stream.println (indent + name

            // <54697>

            //+ " = org.omg.CORBA.ORB.init ().create_interface_tc (_id, "

            + " = org.omg.CORBA.ORB.init ().create_interface_tc (" + Util.helperName (i, true) + ".id (), " // <d61056>

            + '\"' + Util.stripLeadingUnderscores (entry.name ()) + "\");");

    }

    return index;

  } // helperType

  */

  public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    tcoffsets.set (entry);

    if (entry.fullName ().equals ("org/omg/CORBA/Object"))

      stream.println (indent + name

          + " = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_objref);");

    else

      stream.println (indent + name

          // <54697>

          //+ " = org.omg.CORBA.ORB.init ().create_interface_tc (_id, "

          + " = org.omg.CORBA.ORB.init ().create_interface_tc (" + Util.helperName (i, true) + ".id (), " // <d61056>

          + '\"' + Util.stripLeadingUnderscores (entry.name ()) + "\");");

    return index;

  } // helperType

  public int type (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream) {

    stream.println (indent + name + " = " + Util.helperName (entry, true) + ".type ();"); // <d61056>

    return index;

  } // type

  // <f46082.51> Remove -stateful feature.

  /*

  public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (i.state () != null)

      structHelperRead (entryName, i, stream);

    else

    {

      if (i.isAbstract ())

         stream.println ("    return narrow (((org.omg.CORBA_2_3.portable.InputStream)istream).read_abstract_interface (_" + i.name () + "Stub.class));"); // <d60929>

      else

         stream.println ("    return narrow (istream.read_Object (_" + i.name () + "Stub.class));");

    }

  } // helperRead

  */

  public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (i.isAbstract ())

      stream.println ("    return narrow (((org.omg.CORBA_2_3.portable.InputStream)istream).read_abstract_interface (_" + i.name () + "Stub.class));"); // <d60929>

    else

      stream.println ("    return narrow (istream.read_Object (_" + i.name () + "Stub.class));");

  } // helperRead

  // <f46082.51> Remove -stateful feature.

  /*

  public void helperWrite (SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (i.state () != null)

      structHelperWrite (entry, stream);

    else

      write (0, "    ", "value", entry, stream);

  } // helperWrite

  */

  public void helperWrite (SymtabEntry entry, PrintWriter stream)

  {

    write (0, "    ", "value", entry, stream);

  } // helperWrite

  // <f46082.51> Remove -stateful feature.

  /*

  public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (i.state () != null)

      index = structRead (index, indent, name, i, stream);

    else

    {

      if (entry.fullName ().equals ("org/omg/CORBA/Object"))

        stream.println (indent + name + " = istream.read_Object (_" + i.name () + "Stub.class);");

      else

        stream.println (indent + name + " = " + Util.helperName (entry, false) + ".narrow (istream.read_Object (_" + i.name () + "Stub.class));"); // <d61056>

    }

    return index;

  } // read

  */

  public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)

  {

    InterfaceEntry i = (InterfaceEntry)entry;

    if (entry.fullName ().equals ("org/omg/CORBA/Object"))

      stream.println (indent + name + " = istream.read_Object (_" + i.name () + "Stub.class);");

    else

      stream.println (indent + name + " = " + Util.helperName (entry, false) + ".narrow (istream.read_Object (_" + i.name () + "Stub.class));"); // <d61056>

    return index;

  } // read