/*

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

// -cast() does not support longlong types yet.

// -Deal with typedef changes.

// -Scoped names for the discriminator are ignored at the moment.

// -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete.

// -D61056   <klr> Use Util.helperName

import java.io.File;

import java.io.IOException;

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.EnumEntry;

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

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;

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

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

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

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

/**

 *

 **/

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

{

  /**

   * Public zero-argument constructor.

   **/

  public UnionGen ()

  {

  } // ctor

  /**

   *

   **/

  public void generate (Hashtable symbolTable, UnionEntry u, PrintWriter s)

  {

    this.symbolTable = symbolTable;

    this.u           = u;

    init ();

    openStream ();

    if (stream == null)

      return;

    generateHelper ();

    generateHolder ();

    writeHeading ();

    writeBody ();

    writeClosing ();

    closeStream ();

    generateContainedTypes ();

  } // generate

  /**

   * Initialize members unique to this generator.

   **/

  protected void init ()

  {

    utype       = Util.typeOf (u.type ());

    unionIsEnum = utype instanceof EnumEntry;

  } // init

  /**

   *

   **/

  protected void openStream ()

  {

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

  } // openStream

  /**

   *

   **/

  protected void generateHelper ()

  {

    ((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, u);

  } // generateHelper

  /**

   *

   **/

  protected void generateHolder ()

  {

   ((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, u);

  } // generateHolder

  /**

   *

   **/

  protected void writeHeading ()

  {

    // If the discriminator is an enum, assign the typePackage string.

    if (unionIsEnum)

      typePackage = Util.javaQualifiedName (utype) + '.';

    else

      typePackage = "";

    Util.writePackage (stream, u);

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

    String className = u.name ();

    stream.println ("public final class " + u.name () + " implements org.omg.CORBA.portable.IDLEntity");

    stream.println ("{");

  } // writeHeading

  /**

   *

   **/

  protected void writeBody ()

  {

    // Write branches and populate quality arrays

    int size = u.branches ().size () + 1;

    Enumeration e = u.branches ().elements ();

    int i = 0;

    while (e.hasMoreElements ())

    {

      UnionBranch branch = (UnionBranch)e.nextElement ();

      Util.fillInfo (branch.typedef);

      // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.

      //stream.println ("  private " + Util.javaStatefulName (branch.typedef) + " ___" + branch.typedef.name () + ";");

      stream.println ("  private " + Util.javaName (branch.typedef) + " ___" + branch.typedef.name () + ";");

      ++i;

    }

    stream.println ("  private " + Util.javaName (utype) + " __discriminator;");

    stream.println ("  private boolean __uninitialized = true;");

    // Write ctor

    stream.println ();

    stream.println ("  public " + u.name () + " ()");

    stream.println ("  {");

    stream.println ("  }");

    // Write discriminator

    stream.println ();

    stream.println ("  public " + Util.javaName (utype) + " " + safeName (u, "discriminator") + " ()");

    stream.println ("  {");

    stream.println ("    if (__uninitialized)");

    stream.println ("      throw new org.omg.CORBA.BAD_OPERATION ();");

    stream.println ("    return __discriminator;");

    stream.println ("  }");

    // Write for each branch:

    // - setter

    // - getter

    // - private verifyXXX

    e = u.branches ().elements ();

    i = 0;

    while (e.hasMoreElements ())

    {

      UnionBranch branch = (UnionBranch)e.nextElement ();

      writeBranchMethods (stream, u, branch, i++);

    }

    if (u.defaultBranch () == null && !coversAll (u))

    {

      stream.println ();

      stream.println ("  public void _default ()");

      stream.println ("  {");

      stream.println ("    __discriminator = " + defaultDiscriminator (u) + ';');

      stream.println ("    __uninitialized = false;");

      stream.println ("  }");

      stream.println ();

      stream.println ("  public void _default (" + Util.javaName(utype) +

        " discriminator)");

      stream.println ("  {");

      stream.println ("    verifyDefault( discriminator ) ;" );

      stream.println ("    __discriminator = discriminator ;");

      stream.println ("    __uninitialized = false;");

      stream.println ("  }");

      writeVerifyDefault() ;

    }

    stream.println ();

  } // writeBody

  /**

   *

   **/

  protected void writeClosing ()

  {

    stream.println ("} // class " + u.name ());

  } // writeClosing

  /**

   *

   **/

  protected void closeStream ()

  {

    stream.close ();

  } // closeStream

  /**

   *

   **/

  protected void generateContainedTypes ()

  {

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

    while (e.hasMoreElements ())

    {

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

      // Don't generate contained entries if they are sequences.

      // Sequences are unnamed and since they translate to arrays,

      // no classes are generated for them, not even holders in this

      // case since they cannot be accessed outside of this union.

      if (!(entry instanceof SequenceEntry))

        entry.generate (symbolTable, stream);

    }

  } // generateContainedTypes

  private void writeVerifyDefault()

  {

    Vector labels = vectorizeLabels (u.branches (), true);

    stream.println( "" ) ;

    stream.println( "  private void verifyDefault( " + Util.javaName(utype) +

        " value )" ) ;

    stream.println( "  {" ) ;

    if (unionIsEnum)

        stream.println( "    switch (value.value()) {" ) ;

    else

        stream.println( "    switch (value) {" ) ;

    Enumeration e = labels.elements() ;

    while (e.hasMoreElements()) {

        String str = (String)(e.nextElement()) ;

        stream.println( "      case " + str + ":" ) ;

    }

    stream.println( "        throw new org.omg.CORBA.BAD_OPERATION() ;" ) ;

    stream.println( "" ) ;

    stream.println( "      default:" ) ;

    stream.println( "        return;" ) ;

    stream.println( "    }" ) ;

    stream.println( "  }" ) ;

  }

  private String defaultDiscriminator (UnionEntry u)

  {

    Vector labels = vectorizeLabels (u.branches (), false );

    String ret = null;

    SymtabEntry utype = Util.typeOf (u.type ());

    if (utype instanceof PrimitiveEntry  && utype.name ().equals ("boolean")) {

        // If it got this far, then:

        // - there is only one branch;

        // - that branch has only one label.

        if (labels.contains ("true"))

            ret = "false";

        else

            ret = "true";

    } else if (utype.name ().equals ("char")) {

        // This doesn't handle '\u0030' == '0'.  Unions are so

        // seldom used.  I don't have time to make this perfect.

        int def = 0;

        String string = "'\\u0000'";

        while (def != 0xFFFF && labels.contains (string))

            if (++def / 0x10 == 0)

                string = "'\\u000" + def + "'";

            else if (def / 0x100 == 0)

                string = "\\u00" + def + "'";

            else if (def / 0x1000 == 0)

                string = "\\u0" + def + "'";

            else

                string = "\\u" + def + "'";

        ret = string;

    } else if (utype instanceof EnumEntry) {

        Enumeration e = labels.elements ();

        EnumEntry enumEntry = (EnumEntry)utype;

        Vector enumList = (Vector)enumEntry.elements ().clone ();

        // cull out those elements in the enumeration list that are

        // in the cases of this union

        while (e.hasMoreElements ())

            enumList.removeElement (e.nextElement ());

        // If all of the enum elements are covered in this union and

        // there is a default statement, just pick one of the

        // elements for the default.  If there are enum elements

        // which are NOT covered by the cases, pick one as the

        // default.

        if (enumList.size () == 0)

            ret = typePackage + (String)enumEntry.elements ().lastElement ();

        else

            ret = typePackage + (String)enumList.firstElement ();

    } else if (utype.name ().equals ("octet")) {

        short def = Byte.MIN_VALUE;

        while (def != Byte.MAX_VALUE && labels.contains (Integer.toString (def)))

            ++def;

        ret = Integer.toString (def);

    } else if (utype.name ().equals ("short")) {

        short def = Short.MIN_VALUE;

        while (def != Short.MAX_VALUE && labels.contains (Integer.toString (def)))

            ++def;

        ret = Integer.toString (def);

    } else if (utype.name ().equals ("long")) {

        int def = Integer.MIN_VALUE;

        while (def != Integer.MAX_VALUE && labels.contains (Integer.toString (def)))

            ++def;

        ret = Integer.toString (def);

    } else if (utype.name ().equals ("long long")) {

        long def = Long.MIN_VALUE;

        while (def != Long.MAX_VALUE && labels.contains (Long.toString (def)))

            ++def;

        ret = Long.toString (def);

    } else if (utype.name ().equals ("unsigned short")) {

        short def = 0;

        while (def != Short.MAX_VALUE && labels.contains (Integer.toString (def)))

            ++def;

        ret = Integer.toString (def);

    } else if (utype.name ().equals ("unsigned long")) {

        int def = 0;

        while (def != Integer.MAX_VALUE && labels.contains (Integer.toString (def)))

            ++def;

        ret = Integer.toString (def);

    } else if (utype.name ().equals ("unsigned long long")) {

        long def = 0;

        while (def != Long.MAX_VALUE && labels.contains (Long.toString (def)))

            ++def;

        ret = Long.toString (def);

    }

    return ret;

  } // defaultDiscriminator

  /**

   *

   **/

  private Vector vectorizeLabels (Vector branchVector, boolean useIntsForEnums )

  {

    Vector mergedLabels = new Vector ();

    Enumeration branches = branchVector.elements ();

    while (branches.hasMoreElements ())

    {

      UnionBranch branch = (UnionBranch)branches.nextElement ();

      Enumeration labels = branch.labels.elements ();

      while (labels.hasMoreElements ())

      {

        Expression expr = (Expression)labels.nextElement ();

        String str ;

        if (unionIsEnum)

          if (useIntsForEnums)

            str = typePackage + "_" + Util.parseExpression( expr ) ;

          else

            str = typePackage + Util.parseExpression( expr ) ;

        else

          str = Util.parseExpression( expr ) ;

        mergedLabels.addElement (str);

      }

    }

    return mergedLabels;

  } // vectorizeLabels

  /**

   *

   **/

  private String safeName (UnionEntry u, String name)

  {

    Enumeration e = u.branches ().elements ();

    while (e.hasMoreElements ())

      if (((UnionBranch)e.nextElement ()).typedef.name ().equals (name))

      {

        name = '_' + name;

        break;

      }

    return name;

  } // safeName

  /**

   *

   **/

  private boolean coversAll (UnionEntry u)

  {

    // This assumes that it is not possible to cover types other than

    // boolean and enums.  This is not quite correct, but since octet

    // is not a valid discriminator type, it's not too bad in practice.

    // It may also be possible to cover a char type, but we won't worry

    // about that either.

    SymtabEntry utype = Util.typeOf (u.type ());

    boolean coversAll = false;

    if (utype.name ().equals ("boolean")) {

      if (u.branches ().size () == 2)

        coversAll = true;

    } else if (utype instanceof EnumEntry) {

      Vector labels = vectorizeLabels (u.branches (), true);

      if (labels.size () == ((EnumEntry)utype).elements ().size ())

        coversAll = true;

    }

    return coversAll;

  } // coversAll

  /**

   *

   **/

  private void writeBranchMethods (PrintWriter stream, UnionEntry u, UnionBranch branch, int i)

  {

    // Write getter

    stream.println ();

    // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.

    //stream.println ("  public " + Util.javaStatefulName (branch.typedef) + " " + branch.typedef.name () + " ()");

    stream.println ("  public " + Util.javaName (branch.typedef) + " " + branch.typedef.name () + " ()");

    stream.println ("  {");

    stream.println ("    if (__uninitialized)");

    stream.println ("      throw new org.omg.CORBA.BAD_OPERATION ();");

    stream.println ("    verify" + branch.typedef.name () + " (__discriminator);");

    stream.println ("    return ___" + branch.typedef.name () + ";");

    stream.println ("  }");

    // Write setter(s)

    stream.println ();

    // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.

    //stream.println ("  public void " + branch.typedef.name () + " (" + Util.javaStatefulName (branch.typedef) + " value)");

    stream.println ("  public void " + branch.typedef.name () + " (" + Util.javaName (branch.typedef) + " value)");

    stream.println ("  {");

    if (branch.labels.size () == 0)

    {

      // This is a default branch

      stream.println ("    __discriminator = " + defaultDiscriminator (u) + ";");

    }

    else

    {

      // This is a non-default branch

      if (unionIsEnum)

        stream.println ("    __discriminator = " + typePackage + Util.parseExpression ((Expression)branch.labels.firstElement ()) + ";");

      else

        stream.println ("    __discriminator = " + cast ((Expression)branch.labels.firstElement (), u.type ()) + ";");

    }

    stream.println ("    ___" + branch.typedef.name () + " = value;");

    stream.println ("    __uninitialized = false;");

    stream.println ("  }");

    SymtabEntry utype = Util.typeOf (u.type ());

    // If there are multiple labels for one branch, write the

    // setter that takes a discriminator.

    if (branch.labels.size () > 0 || branch.isDefault)

    {

      stream.println ();

      // <f46082.51> Remove -stateful feature; javaStatefulName() obsolete.

      //stream.println ("  public void " + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator, " + Util.javaStatefulName (branch.typedef) + " value)");

      stream.println ("  public void " + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator, " + Util.javaName (branch.typedef) + " value)");

      stream.println ("  {");

      stream.println ("    verify" + branch.typedef.name () + " (discriminator);");

      stream.println ("    __discriminator = discriminator;");

      stream.println ("    ___" + branch.typedef.name () + " = value;");

      stream.println ("    __uninitialized = false;");

      stream.println ("  }");

    }

    // Write verifyXXX

    stream.println ();

    stream.println ("  private void verify" + branch.typedef.name () + " (" + Util.javaName (utype) + " discriminator)");

    stream.println ("  {");

    boolean onlyOne = true;

    if (branch.isDefault && u.branches ().size () == 1)

      ;// If all that is in this union is a default branch,

      // all discriminators are legal.  Don't print any

      // body to this method in that case.

    else

    {

      // Otherwise this code is executed and a body is printed.

      stream.print ("    if (");

      if (branch.isDefault)

      {

        Enumeration eBranches = u.branches ().elements ();

        while (eBranches.hasMoreElements ())

        {

          UnionBranch b = (UnionBranch)eBranches.nextElement ();

          if (b != branch)

          {

            Enumeration eLabels = b.labels.elements ();

            while (eLabels.hasMoreElements ())

            {

              Expression label = (Expression)eLabels.nextElement ();

              if (!onlyOne)

                stream.print (" || ");

              if (unionIsEnum)

                stream.print ("discriminator == " + typePackage + Util.parseExpression (label));