corba/src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/MethodGen.java

/*
 * Copyright (c) 1999, 2002, 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:
// -After demarshalling an IOR, think about how to deal with the exceptions.
// -catching Exception throws a string which should be in a properties file.
// -30jul1997<daz> Modified to write comment immediately preceding method signature.
// -07May1998<ktp> Modified to support RMI Portable Stub
// -26Aug1998<klr> Modified to pass helper instance to read_Value.
// -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete.
// -D56554   <klr> Port bounded string checks from toJava to toJavaPortable
// -D58549   <klr> bounded string checks on in/inout parms throw BAD_PARAM
// -D57112<daz> Valuetype initializers map to ctor, regardless of name, and
//  "void _init(...)" methods now mapped correctly.
// -D59297   <klr> pass context parm when Remarshalling
// -D59560   <klr> call read/write_Context
// -D60929   <klr> Update for RTF2.4 changes
// -D61056   <klr> Use Util.helperName
// -D61650<daz> Remove '\n' from generated strings; use println()'s.

import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.Hashtable;

import com.sun.tools.corba.se.idl.EnumEntry;
import com.sun.tools.corba.se.idl.ExceptionEntry;
import com.sun.tools.corba.se.idl.InterfaceEntry;
import com.sun.tools.corba.se.idl.MethodEntry;
import com.sun.tools.corba.se.idl.ParameterEntry;
import com.sun.tools.corba.se.idl.PrimitiveEntry;
import com.sun.tools.corba.se.idl.StringEntry;
import com.sun.tools.corba.se.idl.SymtabEntry;
import com.sun.tools.corba.se.idl.SequenceEntry;
import com.sun.tools.corba.se.idl.ValueEntry;
import com.sun.tools.corba.se.idl.ValueBoxEntry;
import com.sun.tools.corba.se.idl.InterfaceState;
import com.sun.tools.corba.se.idl.TypedefEntry;
import com.sun.tools.corba.se.idl.AttributeEntry;

import com.sun.tools.corba.se.idl.constExpr.Expression;

/**
 *
 **/
public class MethodGen implements com.sun.tools.corba.se.idl.MethodGen
{
  private static final String ONE_INDENT   = "    ";
  private static final String TWO_INDENT   = "        ";
  private static final String THREE_INDENT = "            ";
  private static final String FOUR_INDENT  = "                ";
  private static final String FIVE_INDENT  = "                    ";
  // This is the length of _get_ and _set_
  private static final int ATTRIBUTE_METHOD_PREFIX_LENGTH  = 5;
  /**
   * Public zero-argument constructor.
   **/
  public MethodGen ()
  {
  } // ctor

  /**
   * Method generate() is not used in MethodGen.  They are replaced by the
   * more granular interfaceMethod, stub, skeleton, dispatchSkeleton.
   **/
  public void generate (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
  {
  } // generate

  /**
   *
   **/
  protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
  {
    this.symbolTable = symbolTable;
    this.m           = m;
    this.stream      = stream;
    if (m.comment () != null)
      m.comment ().generate ("", stream);
    stream.print ("  ");
    SymtabEntry container = (SymtabEntry)m.container ();
    boolean isAbstract = false;
    boolean valueContainer = false;
    if (container instanceof ValueEntry)
    {
      isAbstract = ((ValueEntry)container).isAbstract ();
      valueContainer = true;
    }
    if (valueContainer && !isAbstract)
      stream.print ("public ");
    writeMethodSignature ();
    if (valueContainer && !isAbstract)
    {
      stream.println ();
      stream.println ("  {");
      stream.println ("  }");
      stream.println ();
    }
    else
      stream.println (";");
  } // interfaceMethod

  /**
   *
   **/
  protected void stub (String className, boolean isAbstract,
      Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
  {
    localOptimization =
        ((Arguments)Compile.compiler.arguments).LocalOptimization;
    this.isAbstract  = isAbstract;
    this.symbolTable = symbolTable;
    this.m           = m;
    this.stream      = stream;
    this.methodIndex = index;
    if (m.comment () != null)
      m.comment ().generate ("  ", stream);
    stream.print ("  public ");
    writeMethodSignature ();
    stream.println ();
    stream.println ("  {");
    writeStubBody ( className );
    stream.println ("  } // " + m.name ());
    stream.println ();
  } // stub

  /**
   *
   **/
  protected void localstub (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index, InterfaceEntry i)
  {
    this.symbolTable = symbolTable;
    this.m           = m;
    this.stream      = stream;
    this.methodIndex = index;
    if (m.comment () != null)
      m.comment ().generate ("  ", stream);
    stream.print ("  public ");
    writeMethodSignature ();
    stream.println ();
    stream.println ("  {");
    writeLocalStubBody (i);
    stream.println ("  } // " + m.name ());
    stream.println ();
  } // stub
  /**
   *
   **/
  protected void skeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
  {
    this.symbolTable = symbolTable;
    this.m           = m;
    this.stream      = stream;
    this.methodIndex = index;
    if (m.comment () != null)
      m.comment ().generate ("  ", stream);
    stream.print ("  public ");
    writeMethodSignature ();
    stream.println ();
    stream.println ("  {");
    writeSkeletonBody ();
    stream.println ("  } // " + m.name ());
  } // skeleton

  /**
   *
   **/
  protected void dispatchSkeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
  {
    this.symbolTable = symbolTable;
    this.m           = m;
    this.stream      = stream;
    this.methodIndex = index;
    if (m.comment () != null)
      m.comment ().generate ("  ", stream);
    writeDispatchCall ();
  } // dispatchSkeleton

  // <d57112>
  /**
   * Determine whether method entry m is a valuetype initializer.
   * @return true if is m is valuetype initializer, false otherwise.
   **/
  protected boolean isValueInitializer ()
  {
    MethodEntry currentInit = null;
    if ((m.container () instanceof ValueEntry))
    {
      Enumeration e = ((ValueEntry)m.container ()).initializers ().elements ();
      while (currentInit != m && e.hasMoreElements ())
        currentInit = (MethodEntry)e.nextElement ();
    }
    return (currentInit == m) && (null != m);  // True ==> yes, false ==> no.
  } // isValueInitializer

  /**
   *
   **/
  protected void writeMethodSignature ()
  {
    boolean isValueInitializer = isValueInitializer ();  // <d57112>

    // Step 0.  Print the return type and name.
    // A return type of null indicates the "void" return type. If m is a
    // Valuetype intitializer, it has name "init" and a null return type,
    // but it maps to a ctor.
    // <d57112>
    //if (m.type () == null)
    //{
    //  if (m.name ().compareTo ("init") != 0)
    //    stream.print ("void");
    //}
    if (m.type () == null)
    {
      if (!isValueInitializer)
        stream.print ("void");
    }
    else
    {
      // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
      //stream.print (Util.javaStatefulName (m.type ()));
      stream.print (Util.javaName (m.type ()));
    }
    // <d57112> Value initializers map to constructors.
    // If the value has an 'init' method with a return type, handle
    // the method like other regular methods
    //if (m.valueMethod () && m.name ().compareTo ("init") == 0 &&
    //    m.type () == null)
    if (isValueInitializer)
      stream.print (' ' + m.container ().name () + " (");
    else
      stream.print (' ' + m.name () + " (");

    // Step 1.  Print the parameter list.
    boolean firstTime = true;
    Enumeration e = m.parameters ().elements ();
    while (e.hasMoreElements ())
    {
      if (firstTime)
        firstTime = false;
      else
        stream.print (", ");
      ParameterEntry parm = (ParameterEntry)e.nextElement ();

      writeParmType (parm.type (), parm.passType ());

      // Print parm name
      stream.print (' ' + parm.name ());
    }

    // Step 2.  Add the context parameter if necessary.
    if (m.contexts ().size () > 0)
    {
      if (!firstTime)
        stream.print (", ");
      stream.print ("org.omg.CORBA.Context $context");
    }

    // Step 3.  Print the throws clause (if necessary).
    if (m.exceptions ().size () > 0)
    {
      stream.print (") throws ");
      e = m.exceptions ().elements ();
      firstTime = true;
      while (e.hasMoreElements ())
      {
        if (firstTime)
          firstTime = false;
        else
          stream.print (", ");
        stream.print (Util.javaName ((SymtabEntry)e.nextElement ()));
      }
    }
    else
      stream.print (')');
  } // writeMethodSignature

  /**
   *
   **/
  protected void writeParmType (SymtabEntry parm, int passType)
  {
    if (passType != ParameterEntry.In)
    {
      parm = Util.typeOf (parm);
      stream.print (Util.holderName (parm));
    }
    else // passType is `in'
      // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
      //stream.print (Util.javaStatefulName (parm));
      stream.print (Util.javaName (parm));
  } // writeParmType

  /**
   *
   **/
  protected void writeDispatchCall ()
  {
    String indent = "       ";
    String fullMethodName = m.fullName ();
    if (m instanceof AttributeEntry)
    {
      // determine the index at which the attribute name starts in the full name
      int index = fullMethodName.lastIndexOf ('/') + 1;
      if (m.type () == null)          // if it's a modifier
        fullMethodName = fullMethodName.substring (0, index) + "_set_" + m.name ();
      else
        fullMethodName = fullMethodName.substring (0, index) + "_get_" + m.name ();
    }
    stream.println (indent + "case " + methodIndex + ":  // " + fullMethodName);
    stream.println (indent + "{");
    indent = indent + "  ";
    if (m.exceptions ().size () > 0)
    {
      stream.println (indent + "try {");
      indent = indent + "  ";
    }

    // Step 1 Read arguments from the input stream
    SymtabEntry mtype = Util.typeOf (m.type ());
    Enumeration parms = m.parameters ().elements ();
    parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm     = (ParameterEntry) parms.nextElement ();
      String         name     = parm.name ();
      String         anyName  = '_' + name;
      SymtabEntry    type     = parm.type ();
      int            passType = parm.passType ();

      if (passType == ParameterEntry.In)
        Util.writeInitializer (indent, name, "", type, writeInputStreamRead ("in", type), stream);

      else // the parm is a holder
      {
        String holderName = Util.holderName (type);
        stream.println (indent + holderName + ' ' + name + " = new " + holderName + " ();");
        if (passType == ParameterEntry.Inout)
        {
          if (type instanceof ValueBoxEntry)
          {
            ValueBoxEntry v = (ValueBoxEntry) type;
            TypedefEntry member = ((InterfaceState) v.state ().elementAt (0)).entry;
            SymtabEntry mType = member.type ();
            if (mType instanceof PrimitiveEntry)
              stream.println (indent + name + ".value = (" + writeInputStreamRead ("in", parm.type ()) + ").value;");
            else
              stream.println (indent + name + ".value = " + writeInputStreamRead ("in", parm.type ()) + ";");
          }
          else
            stream.println (indent +  name  + ".value = " + writeInputStreamRead ("in", parm.type ()) + ";");
        }
      }
    }

    // Step 1a.  Read the context parameter if necessary. <d59560>
    if (m.contexts ().size () > 0)
    {
      stream.println (indent + "org.omg.CORBA.Context $context = in.read_Context ();");
    }

    // Step 2 Load return if necessary
    if (mtype != null)
      Util.writeInitializer (indent, "$result", "", mtype, stream);

    // Step 3 Call the method with the list of parameters
    writeMethodCall (indent);

    parms = m.parameters ().elements ();
    boolean firstTime = true;
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      if (firstTime)
        firstTime = false;
      else
        stream.print (", ");
      stream.print (parm.name ());
    }

    // Step 3a.  Add the context parameter if necessary. <d59560>
    if (m.contexts ().size () > 0)
    {
      if (!firstTime)
        stream.print (", ");
      stream.print ("$context");
    }

    stream.println (");");

    //Step 3b. Create reply;
    writeCreateReply (indent);

    // Step 4 Write method's result to the output stream
    if (mtype != null)
    {
      writeOutputStreamWrite (indent, "out", "$result", mtype, stream);
    }

    // Step 5 Write inout/out value to the output stream
    parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      int passType = parm.passType ();
      if (passType != ParameterEntry.In)
      {
        writeOutputStreamWrite (indent, "out", parm.name () + ".value", parm.type (), stream);
      }
    }

    // Step 6 Handle exception
    if (m.exceptions ().size () > 0)
    {
      Enumeration exceptions = m.exceptions ().elements ();
      while (exceptions.hasMoreElements ())
      {
        indent = "         ";
        ExceptionEntry exc = (ExceptionEntry) exceptions.nextElement ();
        String fullName = Util.javaQualifiedName (exc);
        stream.println (indent + "} catch (" +  fullName + " $ex) {");
        indent = indent + "  ";
        stream.println (indent + "out = $rh.createExceptionReply ();");
        stream.println (indent + Util.helperName (exc, true) + ".write (out, $ex);"); // <d61056>
      }

      indent = "         ";
      stream.println (indent + "}");
    }

    stream.println ("         break;");
    stream.println ("       }");
    stream.println ();
  } // writeDispatchCall

  /**
   *
   **/
  protected void writeStubBody ( String className )
  {
    // Step 1  Create a request
    String methodName = Util.stripLeadingUnderscores (m.name ());
    if (m instanceof AttributeEntry)
    {
      if (m.type () == null)          // if it's a modifier
        methodName = "_set_" + methodName;
      else
        methodName = "_get_" + methodName;
    }
    if( localOptimization && !isAbstract ) {
        stream.println (ONE_INDENT + "while(true) {" );
        stream.println(TWO_INDENT + "if(!this._is_local()) {" );
    }
    stream.println(THREE_INDENT +
        "org.omg.CORBA.portable.InputStream $in = null;");
    stream.println(THREE_INDENT + "try {");
    stream.println(FOUR_INDENT + "org.omg.CORBA.portable.OutputStream $out =" +
        " _request (\"" +  methodName + "\", " + !m.oneway() + ");");

    // Step 1.b.  Check string bounds <d56554 - klr>
    // begin <d56554> in/inout string bounds check
    Enumeration parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      SymtabEntry parmType = Util.typeOf (parm.type ());
      if (parmType instanceof StringEntry)
        if ((parm.passType () == ParameterEntry.In) ||
            (parm.passType () == ParameterEntry.Inout))
        {
          StringEntry string = (StringEntry)parmType;
          if (string.maxSize () != null)
          {
            stream.print (THREE_INDENT + "if (" + parm.name ());
            if (parm.passType () == ParameterEntry.Inout)
              stream.print (".value"); // get from holder
            stream.print (" == null || " + parm.name ());
            if (parm.passType () == ParameterEntry.Inout)
              stream.print (".value"); // get from holder
            stream.println (".length () > (" +
                Util.parseExpression (string.maxSize ()) + "))");
            stream.println (THREE_INDENT +
                "throw new org.omg.CORBA.BAD_PARAM (0," +
                " org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
          }
        }
    }
    // end <d56554> in/inout string bounds check

    // Step 2  Load the parameters into the outputStream
    parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      if (parm.passType () == ParameterEntry.In)
        writeOutputStreamWrite(FOUR_INDENT, "$out", parm.name (), parm.type (),
            stream);
      else if (parm.passType () == ParameterEntry.Inout)
        writeOutputStreamWrite(FOUR_INDENT, "$out", parm.name () + ".value",
            parm.type (), stream);
    }

    // Step 2a.  Write the context parameter if necessary. <d59560>
    if (m.contexts ().size () > 0)
    {
      stream.println(FOUR_INDENT + "org.omg.CORBA.ContextList $contextList =" +
         "_orb ().create_context_list ();");

      for (int cnt = 0; cnt < m.contexts ().size (); cnt++)
      {
          stream.println(FOUR_INDENT +
             "$contextList.add (\"" + m.contexts (). elementAt (cnt) + "\");");
      }
      stream.println(FOUR_INDENT +
          "$out.write_Context ($context, $contextList);");
    }

    // Step 3 Invoke the method with the output stream
    stream.println (FOUR_INDENT + "$in = _invoke ($out);");

    SymtabEntry mtype = m.type ();
    if (mtype != null)
      Util.writeInitializer (FOUR_INDENT, "$result", "", mtype,
          writeInputStreamRead ("$in", mtype), stream);

    // Step 4  Read the inout/out values
    parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      if (parm.passType () != ParameterEntry.In)
      {
        if (parm.type () instanceof ValueBoxEntry)
        {
          ValueBoxEntry v = (ValueBoxEntry) parm.type ();
          TypedefEntry member =
              ((InterfaceState) v.state ().elementAt (0)).entry;
          SymtabEntry mType = member.type ();
          if (mType instanceof PrimitiveEntry)
            stream.println(FOUR_INDENT +  parm.name () +
                ".value = (" + writeInputStreamRead ("$in", parm.type ()) +
                ").value;");
          else
            stream.println(FOUR_INDENT +  parm.name () +
                ".value = " + writeInputStreamRead ("$in", parm.type ()) +";");
        }
        else
          stream.println (FOUR_INDENT +  parm.name () + ".value = " +
              writeInputStreamRead ("$in", parm.type ()) + ";");
      }
    }
    // Step 4.b.  Check string bounds <d56554 - klr>
    // begin <d56554> out/inout/return string bounds check
    parms = m.parameters ().elements ();
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      SymtabEntry parmType = Util.typeOf (parm.type ());
      if (parmType instanceof StringEntry)
        if ((parm.passType () == ParameterEntry.Out) ||
            (parm.passType () == ParameterEntry.Inout))
        {
          StringEntry string = (StringEntry)parmType;
          if (string.maxSize () != null)
          {
            stream.print (FOUR_INDENT + "if (" + parm.name () +
                ".value.length ()");
            stream.println ("         > (" +
                Util.parseExpression (string.maxSize ()) + "))");
            stream.println (FIVE_INDENT + "throw new org.omg.CORBA.MARSHAL(0,"+
                "org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
          }
        }
    }
    if (mtype instanceof StringEntry)
    {
      StringEntry string = (StringEntry)mtype;
      if (string.maxSize () != null)
      {
        stream.println(FOUR_INDENT + "if ($result.length () > (" +
            Util.parseExpression (string.maxSize ()) + "))");
        stream.println (FIVE_INDENT + "throw new org.omg.CORBA.MARSHAL (0," +
            " org.omg.CORBA.CompletionStatus.COMPLETED_NO);");
      }
    }
    // end <d56554> out/inout/return string bounds check

    // Step 5  Handle return if necessary
    if (mtype != null) {
      stream.println(FOUR_INDENT + "return $result;");
    } else {
      stream.println(FOUR_INDENT + "return;");
    }

    // Step 6  Handle exceptions
    stream.println(THREE_INDENT +
        "} catch (org.omg.CORBA.portable.ApplicationException " + "$ex) {");
    stream.println(FOUR_INDENT + "$in = $ex.getInputStream ();");
    stream.println(FOUR_INDENT + "String _id = $ex.getId ();");

    if (m.exceptions ().size () > 0)
    {
      Enumeration exceptions = m.exceptions ().elements ();
      boolean firstExc = true;
      while (exceptions.hasMoreElements ())
      {
        ExceptionEntry exc = (ExceptionEntry)exceptions.nextElement ();
        if (firstExc)
        {
          stream.print(FOUR_INDENT + "if ");
          firstExc = false;
        }
        else
          stream.print(FOUR_INDENT + "else if ");

        stream.println( "(_id.equals (\"" + exc.repositoryID ().ID () + "\"))");
        stream.println (FIVE_INDENT + "throw " +
            Util.helperName ((SymtabEntry)exc, false) + ".read ($in);");
      }
      stream.println(FOUR_INDENT + "else");
      stream.println(FIVE_INDENT + "throw new org.omg.CORBA.MARSHAL (_id);");
    }
    else
      stream.println(FOUR_INDENT + "throw new org.omg.CORBA.MARSHAL (_id);");

    stream.println(THREE_INDENT +
        "} catch (org.omg.CORBA.portable.RemarshalException $rm) {");
    stream.print( FOUR_INDENT );
    if (m.type () != null) // not a void method
      stream.print ("return ");
    stream.print (m.name () + " (");
    {
      // write parm names
      boolean firstTime = true;
      Enumeration e = m.parameters ().elements ();
      while (e.hasMoreElements ())
      {
        if (firstTime)
          firstTime = false;
        else
          stream.print (", ");
        ParameterEntry parm = (ParameterEntry)e.nextElement ();
        stream.print (parm.name ());
      }
      // Step 2.  Add the context parameter if necessary. <d59297>
      if (m.contexts ().size () > 0)
      {
        if (!firstTime)
          stream.print (", ");
        stream.print ("$context");
      }
    }
    stream.println (TWO_INDENT + ");");
    stream.println (THREE_INDENT + "} finally {");
    stream.println (FOUR_INDENT + "_releaseReply ($in);");
    stream.println (THREE_INDENT + "}");
    if( localOptimization && !isAbstract ) {
        stream.println (TWO_INDENT + "}");
        writeStubBodyForLocalInvocation( className, methodName );
    }

  } // writeStubBody


  /**
   * This method writes the else part of the stub method invocation to
   * enable local invocation in case of collocation.
   * NOTE: This will only be invoked from writeStubBody.
   */
  private void writeStubBodyForLocalInvocation( String className,
      String methodName )
  {
    stream.println (TWO_INDENT + "else {" );
    stream.println (THREE_INDENT +
        "org.omg.CORBA.portable.ServantObject _so =");
    stream.println (FOUR_INDENT + "_servant_preinvoke(\"" + methodName +
                    "\", _opsClass);" );
    stream.println(THREE_INDENT + "if (_so == null ) {");
    stream.println(FOUR_INDENT + "continue;" );
    stream.println(THREE_INDENT + "}");
    stream.println(THREE_INDENT + className + "Operations _self =" );
    stream.println(FOUR_INDENT + "(" + className + "Operations) _so.servant;");
    stream.println(THREE_INDENT + "try {" );
    Enumeration parms = m.parameters ().elements ();
    if (m instanceof AttributeEntry)
    {
        // Local Method Name should drop _get_ or _set_ prefix for attribute
        // entry
        methodName = methodName.substring( ATTRIBUTE_METHOD_PREFIX_LENGTH );
    }
    boolean voidReturnType = (this.m.type() == null);
    if ( !voidReturnType ) {
        stream.println (FOUR_INDENT + Util.javaName (this.m.type ()) +
            " $result;");
    }
    if( !isValueInitializer() ) {
        if ( voidReturnType ) {
            stream.print(FOUR_INDENT + "_self." + methodName + "( " );
        } else {
            stream.print(FOUR_INDENT + "$result = _self." +
                     methodName + "( " );
        }
        while (parms.hasMoreElements ()) {
            ParameterEntry param = (ParameterEntry)parms.nextElement ();
            if( parms.hasMoreElements( ) ) {
                stream.print( " " + param.name() +  "," );
            } else  {
                stream.print( " " + param.name() );
            }
        }
        stream.print( ");" );
        stream.println( " " );
        if( voidReturnType ) {
            stream.println(FOUR_INDENT + "return;" );
        } else {
            stream.println(FOUR_INDENT + "return $result;" );
        }
    }
    stream.println(" ");
    stream.println (THREE_INDENT + "}" );
    stream.println (THREE_INDENT + "finally {" );
    stream.println (FOUR_INDENT + "_servant_postinvoke(_so);" );
    stream.println (THREE_INDENT + "}" );
    stream.println (TWO_INDENT + "}" );
    stream.println (ONE_INDENT + "}" );
  }


  protected void writeLocalStubBody (InterfaceEntry i)
  {
    // Step 1  Create a request
    String methodName = Util.stripLeadingUnderscores (m.name ());
    if (m instanceof AttributeEntry)
    {
      if (m.type () == null)          // if it's a modifier
        methodName = "_set_" + methodName;
      else
        methodName = "_get_" + methodName;
    }
    //stream.println ("    while(true) {");
    stream.println ("      org.omg.CORBA.portable.ServantObject $so = " +
                    "_servant_preinvoke (\"" + methodName + "\", " + "_opsClass);");
    //stream.println ("      if ($so == null) {");
    //stream.println ("          continue;");
    //stream.println ("      }");
    String opsName = i.name() + "Operations";
    stream.println ("      " + opsName + "  $self = " + "(" + opsName + ") " + "$so.servant;");
    stream.println ();
    stream.println ("      try {");
    stream.print ("         ");
    if (m.type () != null) // not a void method
        stream.print ("return ");
    stream.print ("$self." + m.name () + " (");
    {
        // write parm names
        boolean firstTime = true;
        Enumeration e = m.parameters ().elements ();
        while (e.hasMoreElements ())
        {
          if (firstTime)
            firstTime = false;
          else
            stream.print (", ");
          ParameterEntry parm = (ParameterEntry)e.nextElement ();
          stream.print (parm.name ());
        }
        // Step 2.  Add the context parameter if necessary. <d59297>
        if (m.contexts ().size () > 0)
        {
          if (!firstTime)
            stream.print (", ");
          stream.print ("$context");
        }
    }
    stream.println (");");
    //stream.println ("      } catch (org.omg.CORBA.portable.RemarshalException $rm) {");
    //stream.println ("         continue; ");
    stream.println ("      } finally {");
    stream.println ("          _servant_postinvoke ($so);");
    stream.println ("      }");
    //stream.println ("    }");

  } // writeLocalStubBody



  /**
   *
   **/
  private void writeInsert (String indent, String target, String source, SymtabEntry type, PrintWriter stream)
  {
    String typeName = type.name ();
    if (type instanceof PrimitiveEntry)
    {
      // RJB does something have to be done with TC offsets?
      if (typeName.equals ("long long"))
        stream.println (indent + source + ".insert_longlong (" + target + ");");
      else if (typeName.equals ("unsigned short"))
        stream.println (indent + source + ".insert_ushort (" + target + ");");
      else if (typeName.equals ("unsigned long"))
        stream.println (indent + source + ".insert_ulong (" + target + ");");
      else if (typeName.equals ("unsigned long long"))
        stream.println (indent + source + ".insert_ulonglong (" + target + ");");
      else
        stream.println (indent + source + ".insert_" + typeName + " (" + target + ");");
    }
    else if (type instanceof StringEntry)
      stream.println (indent + source + ".insert_" + typeName + " (" + target + ");");
    else
      stream.println (indent + Util.helperName (type, true) + ".insert (" + source + ", " + target + ");"); // <d61056>
  } // writeInsert

  /**
   *
   **/
  private void writeType (String indent, String name, SymtabEntry type, PrintWriter stream)
  {
    if (type instanceof PrimitiveEntry)
    {
      // RJB does something have to be done with TC offsets?
      if (type.name ().equals ("long long"))
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_longlong));");
      else if (type.name ().equals ("unsigned short"))
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ushort));");
      else if (type.name ().equals ("unsigned long"))
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulong));");
      else if (type.name ().equals ("unsigned long long"))
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulonglong));");
      else
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_" + type.name () + "));");
    }
    else if (type instanceof StringEntry)
    {
      StringEntry s = (StringEntry)type;
      Expression e  = s.maxSize ();
      if (e == null)
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().create_" + type.name () + "_tc (" + Util.parseExpression (e) + "));");
     else
        stream.println (indent + name + " (org.omg.CORBA.ORB.init ().create_" + type.name () + "_tc (0));");
    }
    else
      stream.println (indent + name + '(' + Util.helperName (type, true) + ".type ());"); // <d61056>
  } // writeType

  /**
   *
   **/
  private void writeExtract (String indent, String target, String source, SymtabEntry type, PrintWriter stream)
  {
    if (type instanceof PrimitiveEntry)
    {
      if (type.name ().equals ("long long"))
        stream.println (indent + target + " = " + source + ".extract_longlong ();");
      else if (type.name ().equals ("unsigned short"))
        stream.println (indent + target + " = " + source + ".extract_ushort ();");
      else if (type.name ().equals ("unsigned long"))
        stream.println (indent + target + " = " + source + ".extract_ulong ();");
      else if (type.name ().equals ("unsigned long long"))
        stream.println (indent + target + " = " + source + ".extract_ulonglong ();");
      else
        stream.println (indent + target + " = " + source + ".extract_" + type.name () + " ();");
    }
    else if (type instanceof StringEntry)
      stream.println (indent + target + " = " + source + ".extract_" + type.name () + " ();");
    else
      stream.println (indent + target + " = " + Util.helperName (type, true) + ".extract (" + source + ");"); // <d61056>
  } // writeExtract

  /**
   *
   **/
  private String writeExtract (String source, SymtabEntry type)
  {
    String extract;
    if (type instanceof PrimitiveEntry)
    {
      if (type.name ().equals ("long long"))
        extract = source + ".extract_longlong ()";
      else if (type.name ().equals ("unsigned short"))
        extract = source + ".extract_ushort ()";
      else if (type.name ().equals ("unsigned long"))
        extract = source + ".extract_ulong ()";
      else if (type.name ().equals ("unsigned long long"))
        extract = source + ".extract_ulonglong ()";
      else
        extract = source + ".extract_" + type.name () + " ()";
    }
    else if (type instanceof StringEntry)
      extract = source + ".extract_" + type.name () + " ()";
    else
      extract = Util.helperName (type, true) + ".extract (" + source + ')'; // <d61056>
    return extract;
  } // writeExtract

  /**
   *
   **/
  private void writeSkeletonBody ()
  {
    SymtabEntry mtype = Util.typeOf (m.type ());

    // If there is a return value, increment the appropriate counter
    stream.print ("    ");
    if (mtype != null)
      stream.print ("return ");
    stream.print ("_impl." + m.name () + '(');

    // Load the parameters
    Enumeration parms = m.parameters ().elements ();
    boolean first = true;
    while (parms.hasMoreElements ())
    {
      ParameterEntry parm = (ParameterEntry)parms.nextElement ();
      if (first)
        first = false;
      else
        stream.print (", ");
      stream.print (parm.name ());
    }
    if (m.contexts ().size () != 0)
    {
      if (!first)
        stream.print (", ");
      stream.print ("$context");
    }

    stream.println (");");
  } // writeSkeletonBody

  /**
   *
   **/
  protected String passType (int passType)
  {
    String type;
    switch (passType)
    {
      case ParameterEntry.Inout:
        type = "org.omg.CORBA.ARG_INOUT.value";
        break;
      case ParameterEntry.Out:
        type = "org.omg.CORBA.ARG_OUT.value";
        break;
      case ParameterEntry.In:
      default:
        type = "org.omg.CORBA.ARG_IN.value";
        break;
    }
    return type;
  } // passType

  /**
   * This is only used by AttributeGen.  The java mapping says
   * the names should be getXXX and setXXX, but CORBA says they
   * should be _get_XXX and _set_XXX.  this.name () will be
   * getXXX.  realName is set by AttributeGen to _get_XXX.
   **/
  protected void serverMethodName (String name)
  {
    realName = (name == null) ? "" : name;
  } // serverMethodName

  /**
   *
   **/
  private void writeOutputStreamWrite (String indent, String oStream, String name, SymtabEntry type, PrintWriter stream)
  {
    String typeName = type.name ();
    stream.print (indent);
    if (type instanceof PrimitiveEntry)
    {
      if (typeName.equals ("long long"))
        stream.println (oStream + ".write_longlong (" + name +");");
      else if (typeName.equals ("unsigned short"))
        stream.println (oStream + ".write_ushort (" + name + ");");
      else if (typeName.equals ("unsigned long"))
        stream.println (oStream + ".write_ulong (" + name + ");");
      else if (typeName.equals ("unsigned long long"))
        stream.println (oStream + ".write_ulonglong (" + name + ");");
      else
        stream.println (oStream + ".write_" + typeName + " (" + name + ");");
    }
    else if (type instanceof StringEntry)
      stream.println (oStream + ".write_" + typeName + " (" + name + ");");
    else if (type instanceof SequenceEntry)
      stream.println (oStream + ".write_" + type.type().name() + " (" + name + ");");
    else if (type instanceof ValueBoxEntry)
    {
      ValueBoxEntry v = (ValueBoxEntry) type;
      TypedefEntry member = ((InterfaceState) v.state ().elementAt (0)).entry;
      SymtabEntry mType = member.type ();

      // if write value to the boxed holder indicated by the name ending with ".value"
      if (mType instanceof PrimitiveEntry && name.endsWith (".value"))
        stream.println (Util.helperName (type, true) + ".write (" + oStream + ", "  // <d61056>
        + " new " + Util.javaQualifiedName (type) + " (" + name + "));"); //<d60929>
      else
        stream.println (Util.helperName (type, true) + ".write (" + oStream + ", " + name + ");"); //<d60929> // <d61056>
    }
    else if (type instanceof ValueEntry)
        stream.println (Util.helperName (type, true) + ".write (" + oStream + ", " + name + ");"); //<d60929> // <d61056>
    else
      stream.println (Util.helperName (type, true) + ".write (" + oStream + ", " + name + ");"); // <d61056>
  } // writeOutputStreamWrite

  /**
   *
   **/
  private String writeInputStreamRead (String source, SymtabEntry type)
  {
    String read = "";
    if (type instanceof PrimitiveEntry)
    {
      if (type.name ().equals ("long long"))
        read = source + ".read_longlong ()";
      else if (type.name ().equals ("unsigned short"))
        read = source + ".read_ushort ()";
      else if (type.name ().equals ("unsigned long"))
        read = source + ".read_ulong ()";
      else if (type.name ().equals ("unsigned long long"))
        read = source + ".read_ulonglong ()";
      else
        read = source + ".read_" + type.name () + " ()";
    }
    else if (type instanceof StringEntry)
      read = source + ".read_" + type.name () + " ()";
    else
      read = Util.helperName (type, true) + ".read (" + source + ')'; // <d61056>
    return read;
  } // writeInputStreamRead

  /**
   *
   **/
  protected void writeMethodCall (String indent)
  {
    SymtabEntry mtype = Util.typeOf (m.type ());
    if (mtype == null)
      stream.print (indent + "this." + m.name () + " (");
    else
      stream.print (indent + "$result = this." + m.name () + " (");
  } // writeMethodCall

  /**
   *
   **/
  protected void writeCreateReply(String indent){
    stream.println(indent + "out = $rh.createReply();");
  }

  protected int           methodIndex = 0;
  protected String        realName    = "";
  protected Hashtable     symbolTable = null;
  protected MethodEntry   m           = null;
  protected PrintWriter   stream      = null;
  protected boolean localOptimization = false;
  protected boolean isAbstract        = false;
} // class MethodGen