/*
 * Copyright (c) 1999, 2001, 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.
 */
/*
 * 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

  // <f46082.51> Remove -stateful feature.
  /*
  public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
  {
    InterfaceEntry i = (InterfaceEntry)entry;
    if (i.state () != null)
      index = structWrite (index, indent, name, entry, stream);
    else
    {
      if (i.isAbstract ())
         stream.println (indent + "((org.omg.CORBA_2_3.portable.OutputStream)ostream).write_abstract_interface ((java.lang.Object) " + name + ");"); // <d60929>
      else
         stream.println (indent + "ostream.write_Object ((org.omg.CORBA.Object) " + name + ");");
    }
    return index;
  } // write
  */
  public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
  {
    InterfaceEntry i = (InterfaceEntry)entry;
    if (i.isAbstract ())
      stream.println (indent + "((org.omg.CORBA_2_3.portable.OutputStream)ostream).write_abstract_interface ((java.lang.Object) " + name + ");"); // <d60929>
    else
      stream.println (indent + "ostream.write_Object ((org.omg.CORBA.Object) " + name + ");");
    return index;
  } // write

  // <f46082.51> Remove -stateful feature.
  /*
  // These methods are cobbled from StructGen.  Stateful interfaces
  // are sent across the wire as if they were structs, with the first
  // element being a string - the Java name of the class.

  public int structHelperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)
  {
    TCOffsets innerOffsets = new TCOffsets ();
    innerOffsets.set (entry);
    int offsetForStruct = innerOffsets.currentOffset ();
    InterfaceEntry i = (InterfaceEntry)entry;
    String membersName = "_members" + index++;
    Vector state = i.state ();
    stream.println (indent + "org.omg.CORBA.StructMember[] " + membersName + " = new org.omg.CORBA.StructMember [" + (state.size () + 1) + "];");
    String tcOfMembers = "_tcOf" + membersName;
    stream.println (indent + "org.omg.CORBA.TypeCode " + tcOfMembers + ';');

    // The name string is the first element of the struct
    String memberName = "_name";
    StringEntry stringEntry = Compile.compiler.factory.stringEntry ();
    index = ((JavaGenerator)stringEntry.generator ()).helperType (index, indent, innerOffsets, tcOfMembers, stringEntry, stream);
    stream.println (indent + membersName + "[0] = new org.omg.CORBA.StructMember (");
    stream.println (indent + "  \"" + memberName + "\",");
    stream.println (indent + "  " + tcOfMembers + ',');
    stream.println (indent + "  null);");
    int offsetSoFar = innerOffsets.currentOffset ();
    innerOffsets = new TCOffsets ();
    innerOffsets.set (entry);
    innerOffsets.bumpCurrentOffset (offsetSoFar - offsetForStruct);

    for (int idx = 0; idx < state.size (); ++idx)
    {
      TypedefEntry member = ((InterfaceState)state.elementAt (idx)).entry;
      memberName = member.name ();
      index = ((JavaGenerator)member.generator ()).helperType (index, indent, innerOffsets, tcOfMembers, member, stream);
      stream.println (indent + membersName + '[' + (idx + 1) + "] = new org.omg.CORBA.StructMember (");
      stream.println (indent + "  \"" + memberName + "\",");
      stream.println (indent + "  " + tcOfMembers + ',');
      stream.println (indent + "  null);");
      offsetSoFar = innerOffsets.currentOffset ();
      innerOffsets = new TCOffsets ();
      innerOffsets.set (entry);
      innerOffsets.bumpCurrentOffset (offsetSoFar - offsetForStruct);
    }
    tcoffsets.bumpCurrentOffset (innerOffsets.currentOffset ());
    stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_struct_tc (id (), \"" + entry.name () + "\", " + membersName + ");");
    return index;
  } // structHelperType

  public void structHelperRead (String entryName, InterfaceEntry entry, PrintWriter stream)
  {
    String impl = implName ((InterfaceEntry)entry);
    stream.println ("      " + Util.javaStatefulName (entry) + " value = null;");
    structRead (0, "      ", "value", entry, stream);
    stream.println ("      return value;");
  } // structHelperRead

  private String implName (InterfaceEntry entry)
  {
    String name;
    if (entry.container ().name ().equals (""))
      name =  '_' + entry.name () + "Impl";
    else
      name = Util.containerFullName (entry.container ()) + "._" + entry.name () + "Impl";
    return name.replace ('/', '.');
  } // implName

  public int structRead (int index, String indent, String name, InterfaceEntry entry, PrintWriter stream)
  {
    // The first element will be the name of the Java implementation class.
    String stringName = "_name" + index++;
    stream.println (indent + "String " + stringName + " = istream.read_string ();");
    stream.println (indent + "try");
    stream.println (indent + "{");
    stream.println (indent + "  " + name + " = (" + Util.javaStatefulName (entry) + ")com.sun.CORBA.iiop.ORB.getImpl (" + stringName + ".replace ('/', '.'));");
    stream.println (indent + "}");
    stream.println (indent + "catch (Exception e)");
    stream.println (indent + "{");
    stream.println (indent + "  " + name + " = null;");
    stream.println (indent + "}");
    stream.println (indent + "if (" + name + " == null)");
    stream.println (indent + "  throw new org.omg.CORBA.NO_IMPLEMENT (0, org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
    stream.println ();

    stream.println (indent + "if (!" + stringName + ".equals (\"" + entry.fullName () + "\"))");
    stream.println (indent + '{');
    stream.println (indent + "  Class _cls = " + name + ".getClass ();");
    stream.println (indent + "  boolean _found = false;");
    stream.println (indent + "  while (!_found && _cls != null)");
    stream.println (indent + "  {");
    stream.println (indent + "    Class[] interfaces = _cls.getInterfaces ();");
    stream.println (indent + "    for (int i = 0; i < interfaces.length; ++i)");
    stream.println (indent + "      if (interfaces[i].getName ().indexOf (\"State\") > 0)");
    stream.println (indent + "      {");
    stream.println (indent + "        _cls = interfaces[i];");
    stream.println (indent + "        _found = true;");
    stream.println (indent + "        break;");
    stream.println (indent + "      }");
    stream.println (indent + "    if (!_found)");
    stream.println (indent + "      _cls = _cls.getSuperclass ();");
    stream.println (indent + "  }");
    stream.println (indent + "  if (_cls == null)");
    stream.println (indent + "    throw new org.omg.CORBA.NO_IMPLEMENT (0, org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
    stream.println ();
    stream.println (indent + "  String _className = _cls.getName ();");
    stream.println (indent + "  int _index = _className.lastIndexOf ('.');");
    stream.println (indent + "  String _helperName = _className.substring (0, _index + 1) + _className.substring (_index + 2, _className.length () - 5) + \"Helper\"; // 5 == \"State\".length");
    stream.println (indent + "  try");
    stream.println (indent + "  {");
    stream.println (indent + "    Class _helperClass = Class.forName (_helperName);");
    stream.println (indent + "    Class[] _formalParms = new Class [1];");
    stream.println (indent + "    _formalParms[0] = Class.forName (\"org.omg.CORBA.portable.InputStream\");");
    stream.println (indent + "    java.lang.reflect.Method _read = _helperClass.getMethod (\"read\", _formalParms);");
    stream.println (indent + "    Object[] _actualParms = new Object [1];");
    stream.println (indent + "    _actualParms[0] = istream;");
    stream.println (indent + "      " + name + " = (" + Util.javaStatefulName (entry) + ")_read.invoke (null, _actualParms);");
    stream.println (indent + "  }");
    stream.println (indent + "  catch (Exception e)");
    stream.println (indent + "  {");
    stream.println (indent + "    throw new org.omg.CORBA.NO_IMPLEMENT (0, org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
    stream.println (indent + "  }");
    stream.println (indent + '}');

    // instantiate an implementation
    stream.println (indent + "else");
    stream.println (indent + '{');

    // Load the state
    readState (index, indent, name, (InterfaceEntry)entry, stream);

    stream.println (indent + '}');
    return index;
  } // structRead

  private void readState (int index, String indent, String name, InterfaceEntry entry, PrintWriter stream)
  {
    // First write the state from all parents
    Enumeration e = entry.derivedFrom ().elements ();
    while (e.hasMoreElements ())
    {
      InterfaceEntry parent = (InterfaceEntry)e.nextElement ();
      if (parent.state () != null)
      {
        if (parent.state ().size () > 0)
          readState (index, indent, name, parent, stream);
        break;
      }
    }

    // Now write the state for the local entry
    e = entry.state ().elements ();
    while (e.hasMoreElements ())
    {
      TypedefEntry member = ((InterfaceState)e.nextElement ()).entry;
      String tmpName = '_' + member.name () + "Tmp";
      Util.writeInitializer (indent + "  ", tmpName, "", member, stream);
      if (!member.arrayInfo ().isEmpty () || member.type () instanceof SequenceEntry || member.type () instanceof PrimitiveEntry || member.type () instanceof StringEntry)
        index = ((JavaGenerator)member.generator ()).read (index, indent + "  ", tmpName, member, stream);
      else
        stream.println (indent + "  " + tmpName + " = " + Util.helperName (member.type (), true) + ".read (istream);"); // <d61056>
      stream.println (indent + "  " + name + '.' + member.name () + " (" + tmpName + ");");
    }
  } // readState

  public void structHelperWrite (SymtabEntry entry, PrintWriter stream)
  {
    structWrite (0, "      ", "value", entry, stream);
  } // structHelperWrite

  public int structWrite (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
  {
    // The first element of the struct must be the name of the real interface.
    stream.println (indent + "Class _cls = " + name + ".getClass ();");
    stream.println (indent + "boolean _found = false;");
    stream.println (indent + "while (!_found && _cls != null)");
    stream.println (indent + "{");
    stream.println (indent + "  Class[] interfaces = _cls.getInterfaces ();");
    stream.println (indent + "  for (int i = 0; i < interfaces.length; ++i)");
    stream.println (indent + "    if (interfaces[i].getName ().indexOf (\"State\") > 0)");
    stream.println (indent + "    {");
    stream.println (indent + "      _cls = interfaces[i];");
    stream.println (indent + "      _found = true;");
    stream.println (indent + "      break;");
    stream.println (indent + "    }");
    stream.println (indent + "  if (!_found)");
    stream.println (indent + "    _cls = _cls.getSuperclass ();");
    stream.println (indent + '}');
    stream.println ();
    stream.println (indent + "if (_cls == null)");
    stream.println (indent + "  throw new org.omg.CORBA.MARSHAL (0, org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
    stream.println ();
    stream.println (indent + "String _className = _cls.getName ();");
    stream.println (indent + "int _index = _className.lastIndexOf ('.');");
    stream.println (indent + "String _interfaceName = _className.substring (0, _index + 1) + _className.substring (_index + 2, _className.length () - 5); // 5 == \"State\".length");
    stream.println (indent + "ostream.write_string (_interfaceName.replace ('.', '/'));");

    // If _className != Util.javaName (entry), then call that class's helper class.
    stream.println ();
    stream.println (indent + "if (!_interfaceName.equals (\"" + Util.javaName (entry) + "\"))");
    stream.println (indent + '{');
    stream.println (indent + "  try");
    stream.println (indent + "  {");
    stream.println (indent + "    Class _helperClass = Class.forName (_interfaceName + \"Helper\");");
    stream.println (indent + "    Class[] _formalParms = new Class [2];");
    stream.println (indent + "    _formalParms[0] = Class.forName (\"org.omg.CORBA.portable.OutputStream\");");
    stream.println (indent + "    _formalParms[1] = _cls;");
    stream.println (indent + "    java.lang.reflect.Method _write = _helperClass.getMethod (\"write\", _formalParms);");
    stream.println (indent + "    Object[] _actualParms = new Object [2];");
    stream.println (indent + "    _actualParms[0] = ostream;");
    stream.println (indent + "    _actualParms[1] = " + name + ';');
    stream.println (indent + "    _write.invoke (null, _actualParms);");
    stream.println (indent + "  }");
    stream.println (indent + "  catch (Exception e)");
    stream.println (indent + "  {");
    stream.println (indent + "    throw new org.omg.CORBA.MARSHAL (0, org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
    stream.println (indent + "  }");
    stream.println (indent + '}');

    stream.println (indent + "else");
    stream.println (indent + '{');

    writeState (index, indent, name, (InterfaceEntry)entry, stream);

    stream.println (indent + '}');
    return index;
  } // structWrite

  private void writeState (int index, String indent, String name, InterfaceEntry entry, PrintWriter stream)
  {
    // First write the state from all parents
    Enumeration e = entry.derivedFrom ().elements ();
    while (e.hasMoreElements ())
    {
      InterfaceEntry parent = (InterfaceEntry)e.nextElement ();
      if (parent.state () != null)
      {
        if (parent.state ().size () > 0)
          writeState (index, indent, name, parent, stream);
        break;
      }
    }

    // Now write the state for the local entry
    Vector members = entry.state ();
    for (int i = 0; i < members.size (); ++i)
    {
      TypedefEntry member = ((InterfaceState)members.elementAt (i)).entry;
      if (!member.arrayInfo ().isEmpty () || member.type () instanceof SequenceEntry || member.type () instanceof PrimitiveEntry || member.type () instanceof StringEntry)
        index = ((JavaGenerator)member.generator ()).write (index, indent + "  ", name + '.' + member.name () + "()", member, stream);
      else
        stream.println (indent + "  " + Util.helperName (member.type (), true) + ".write (ostream, " + name + '.' + member.name () + " ());"); // <d61056>
    }
  } // writeState
  */

  /**
   * @return true if the entry is for a CORBA pseudo-object.
   **/
  private boolean isPseudo(InterfaceEntry i) {
    java.lang.String fullname = i.fullName();
    if (fullname.equalsIgnoreCase("CORBA/TypeCode"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/Principal"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/ORB"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/Any"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/Context"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/ContextList"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/DynamicImplementation"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/Environment"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/ExceptionList"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/NVList"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/NamedValue"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/Request"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/ServerRequest"))
        return true;
    if (fullname.equalsIgnoreCase("CORBA/UserException"))
        return true;
    return false;
  }

  // From JavaGenerator
  ///////////////

  protected int            emit        = 0;
  protected Factories      factories   = null;

  protected Hashtable      symbolTable = null;
  protected InterfaceEntry i           = null;
  protected PrintWriter    stream      = null;

  // <f46082.03, f46838.1/.2/.3> Modify access to protected.
  protected static final   int SIGNATURE  = 1;
  protected static final   int OPERATIONS = 2;
  protected                int intfType   = 0;
} // class InterfaceGen