/*
 * Copyright (c) 1999, 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:
// -11aug1997<daz> No modification: comments for type_defs will appear in
//  helper, holder classes as a result of modifications to routines
//  makeHelper(), makeHolder() in class com.sun.tools.corba.se.idl.toJava.Util.
// -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete.
// -D61056   <klr> Use Util.helperName

import java.io.PrintWriter;

import java.util.Enumeration;
import java.util.Hashtable;

import com.sun.tools.corba.se.idl.InterfaceEntry;
import com.sun.tools.corba.se.idl.InterfaceState;
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.StructEntry;
import com.sun.tools.corba.se.idl.SymtabEntry;
import com.sun.tools.corba.se.idl.TypedefEntry;
import com.sun.tools.corba.se.idl.UnionEntry;

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

// Notes:

/**
 *
 **/
public class TypedefGen implements com.sun.tools.corba.se.idl.TypedefGen, JavaGenerator
{
  /**
   * Public zero-argument constructor.
   **/
  public TypedefGen ()
  {
  } // ctor

  /**
   *
   **/
  public void generate (Hashtable symbolTable, TypedefEntry t, PrintWriter stream)
  {
    this.symbolTable = symbolTable;
    this.t           = t;

    if (t.arrayInfo ().size () > 0 || t.type () instanceof SequenceEntry)
      generateHolder ();
    generateHelper ();
  } // generator

  /**
   *
   **/
  protected void generateHolder ()
  {
    ((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, t);
  }

  /**
   *
   **/
  protected void generateHelper ()
  {
    ((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, t);
  }

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

  private boolean inStruct (TypedefEntry entry)
  {
    boolean inStruct = false;
    if (entry.container () instanceof StructEntry || entry.container () instanceof UnionEntry)
      inStruct = true;
    else if (entry.container () instanceof InterfaceEntry)
    {
      InterfaceEntry i = (InterfaceEntry)entry.container ();
      if (i.state () != null)
      {
        Enumeration e = i.state ().elements ();
        while (e.hasMoreElements ())
          if (((InterfaceState)e.nextElement ()).entry == entry)
          {
            inStruct = true;
            break;
          }
      }
    }
    return inStruct;
  } // inStruct

  public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)
  {
    TypedefEntry td = (TypedefEntry)entry;
    boolean inStruct = inStruct (td);
    if (inStruct)
      tcoffsets.setMember (entry);
    else
      tcoffsets.set (entry);

    // Print the base types typecode
    index = ((JavaGenerator)td.type ().generator ()).type (index, indent, tcoffsets, name, td.type (), stream);

    if (inStruct && td.arrayInfo ().size () != 0)
      tcoffsets.bumpCurrentOffset (4); // for array length field

    // Print the array typecodes (if there are any)
    int dimensions = td.arrayInfo ().size ();
    for (int i = 0; i < dimensions; ++i)
    {
      String size = Util.parseExpression ((Expression)td.arrayInfo ().elementAt (i));
      stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_array_tc (" + size + ", " + name + " );");
    }

    // If this typedef describes a struct/union member, don't put it
    // in an alias typedef; otherwise that's where it belongs.
    if (!inStruct)
      // <54697>
      //stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_alias_tc (id (), \"" + Util.stripLeadingUnderscores (td.name ()) + "\", " + name + ");");
      stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_alias_tc (" + Util.helperName (td, true) + ".id (), \"" + Util.stripLeadingUnderscores (td.name ()) + "\", " + name + ");"); // <d61056>

    return index;
  } // helperType

  public int type (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream)
  {
    // The type() method is invoked from other emitters instead of when an IDL
    // typedef statement is being processed.  Code generated is identical minus the
    // generation of a create_alias_tc() which is required for IDL typedef's but not
    // needed when typedef is being processed as a member of struct/union/valuetype.

    return helperType( index, indent, tcoffsets, name, entry, stream);
  } // type

  public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream)
  {
    Util.writeInitializer ("    ", "value", "", entry, stream);
    read (0, "    ", "value", entry, stream);
    stream.println ("    return value;");
  } // helperRead

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

  public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
  {
    TypedefEntry td = (TypedefEntry)entry;
    String modifier = Util.arrayInfo (td.arrayInfo ());
    if (!modifier.equals (""))
    {
      // arrayInfo is a vector of Expressions which indicate the
      // number of array dimensions for this typedef.  But what if
      // this is a typedef of a sequence?
      // The `new' statement being generated must know the full
      // number of brackets.  That can be found in td.info.
      // For instance:
      // typedef sequence<short> A[10][10];
      // void proc (out A a);
      // typeModifier = "[10][10]"
      // td.info    = "short[][][]";
      // The first new statement generated is:
      // a.value = new short[10][][];
      // Note that the 3 sets of brackets come from td.info, not
      // arrayInfo;
      // The second new statement generated is:
      // a.value[_i1] = new short[10][];
      // ------------     ---- ------
      //    \           \    \
      //    name      baseName   arrayDcl
      int closingBrackets = 0;
      String loopIndex = "";
      String baseName;
      try
      {
        baseName = (String)td.dynamicVariable (Compile.typedefInfo);
      }
      catch (NoSuchFieldException e)
      {
        baseName = td.name ();
      }
      int startArray = baseName.indexOf ('[');
      String arrayDcl = Util.sansArrayInfo (baseName.substring (startArray)) + "[]"; // Add an extra set because the first gets stripped off in the loop.
      baseName = baseName.substring (0, startArray);

      // For interfaces having state, e.g., valuetypes.
      SymtabEntry baseEntry = (SymtabEntry)Util.symbolTable.get (baseName.replace ('.', '/'));
      if (baseEntry instanceof InterfaceEntry && ((InterfaceEntry)baseEntry).state () != null)
        // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.
        //baseName = Util.javaStatefulName ((InterfaceEntry)baseEntry);
        baseName = Util.javaName ((InterfaceEntry)baseEntry);

      int end1stArray;
      while (!modifier.equals (""))
      {
        int rbracket = modifier.indexOf (']');
        String size = modifier.substring (1, rbracket);
        end1stArray = arrayDcl.indexOf (']');
        arrayDcl = '[' + size + arrayDcl.substring (end1stArray + 2);
        stream.println (indent + name + " = new " + baseName + arrayDcl + ';');
        loopIndex = "_o" + index++;
        stream.println (indent + "for (int " + loopIndex + " = 0;" + loopIndex + " < (" + size + "); ++" + loopIndex + ')');
        stream.println (indent + '{');
        ++closingBrackets;
        modifier = modifier.substring (rbracket + 1);
        indent = indent + "  ";
        name = name + '[' + loopIndex + ']';
      }
      end1stArray = arrayDcl.indexOf (']');
      if (td.type () instanceof SequenceEntry || td.type () instanceof PrimitiveEntry || td.type () instanceof StringEntry)
        index = ((JavaGenerator)td.type ().generator ()).read (index, indent, name, td.type (), stream);
      else if (td.type () instanceof InterfaceEntry && td.type ().fullName ().equals ("org/omg/CORBA/Object"))
        stream.println (indent + name + " = istream.read_Object ();");
      else
        stream.println (indent + name + " = " + Util.helperName (td.type (), true) + ".read (istream);"); // <d61056>
      for (int i = 0; i < closingBrackets; ++i)
      {
        indent = indent.substring (2);
        stream.println (indent + '}');
      }
    }
    else
    {
      SymtabEntry tdtype = Util.typeOf (td.type ());
      if (tdtype instanceof SequenceEntry || tdtype instanceof PrimitiveEntry || tdtype instanceof StringEntry)
        index = ((JavaGenerator)tdtype.generator ()).read (index, indent, name, tdtype, stream);
      else if (tdtype instanceof InterfaceEntry && tdtype.fullName ().equals ("org/omg/CORBA/Object"))
        stream.println (indent + name + " = istream.read_Object ();");
      else
        stream.println (indent + name + " = " + Util.helperName (tdtype, true) + ".read (istream);"); // <d61056>
    }
    return index;
  } // read

  public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream)
  {
    TypedefEntry td = (TypedefEntry)entry;
    String modifier = Util.arrayInfo (td.arrayInfo ());
    if (!modifier.equals (""))
    {
      int closingBrackets = 0;
      String loopIndex = "";
      while (!modifier.equals (""))
      {
        int rbracket = modifier.indexOf (']');
        String size = modifier.substring (1, rbracket);
        stream.println (indent + "if (" + name + ".length != (" + size + "))");
        stream.println (indent + "  throw new org.omg.CORBA.MARSHAL (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);");
        loopIndex = "_i" + index++;
        stream.println (indent + "for (int " + loopIndex + " = 0;" + loopIndex + " < (" + size + "); ++" + loopIndex + ')');
        stream.println (indent + '{');
        ++closingBrackets;
        modifier = modifier.substring (rbracket + 1);
        indent = indent + "  ";
        name = name + '[' + loopIndex + ']';
      }
      if (td.type () instanceof SequenceEntry || td.type () instanceof PrimitiveEntry || td.type () instanceof StringEntry)
        index = ((JavaGenerator)td.type ().generator ()).write (index, indent, name, td.type (), stream);
      else if (td.type () instanceof InterfaceEntry && td.type ().fullName ().equals ("org/omg/CORBA/Object"))
        stream.println (indent + "ostream.write_Object (" + name + ");");
      else
        stream.println (indent + Util.helperName (td.type (), true) + ".write (ostream, " + name + ");"); // <d61056>
      for (int i = 0; i < closingBrackets; ++i)
      {
        indent = indent.substring (2);
        stream.println (indent + '}');
      }
    }
    else
    {
      SymtabEntry tdtype = Util.typeOf (td.type ());
      if (tdtype instanceof SequenceEntry || tdtype instanceof PrimitiveEntry || tdtype instanceof StringEntry)
        index = ((JavaGenerator)tdtype.generator ()).write (index, indent, name, tdtype, stream);
      else if (tdtype instanceof InterfaceEntry && tdtype.fullName ().equals ("org/omg/CORBA/Object"))
        stream.println (indent + "ostream.write_Object (" + name + ");");
      else
        stream.println (indent + Util.helperName (tdtype, true) + ".write (ostream, " + name + ");"); // <d61056>
    }
    return index;
  } // write

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

  protected Hashtable     symbolTable = null;
  protected TypedefEntry  t           = null;
} // class TypedefGen