path: root/TAO/tests/IDL_Test/union.idl

//=============================================================================
/**
 *  @file    union.idl
 *
 *  This file contains examples of IDL code that has
 *  caused problems in the past for the TAO IDL
 *  compiler. This test is to make sure the problems
 *  stay fixed.
 *
 *
 *  @author Jeff Parsons <parsons@cs.wustl.edu> and TAO users.
 */
//=============================================================================


// Implicit default case

enum DataType
{
  dtEmpty,
  dtLong,
  dtShort
};

union Data switch (DataType)
{
  case dtLong: long longData;
  case dtShort: short shortData;
  // by default, empty union
};

// Explicit default case

module Necessary
{
  // It is important to have a module, in which
  // the following union is declared.

  typedef long Result;

  enum Kind
    {
      e_Result,
      e_Unused
    };

  union WhichResult switch (Kind )
    {
      case e_Result: Result  m_Result;
      default: long m_Unused;
    };
};

// Union with negative cases
// At the moment, the SunCC preprocessor separates the negative
// sign from the number.  This causes problems for the scanner/lexer
// used by tao_idl.
#if !defined (__SUNPRO_CC) || (__SUNPRO_CC > 0x5140)
union foo switch (short)
{
  case -3:
  case  4:
  case -1: string foo_str_member;
  default: long   foo_iface_member;
  case  0: long   foo_iface_member2;
};
#endif // !__SUNPRO_CC || __SUNPRO_CC > 0x5120

// Make sure that CORBA_Any::to_* is used everywhere.
module UnionDiscTest
{
  union BooleanUnion switch (boolean)
    {
      case TRUE: string value;
    };

  union CharUnion switch (char)
    {
      case 'a': string value;
    };
};

module AllBoolUnions
{
  union OneBranchT switch (boolean) { case TRUE: octet val; };
  union OneBranchF switch (boolean) { case FALSE: octet val; };
  union OneBranchD switch (boolean) { default: octet val; };
  union OneBranchTF switch (boolean) { case TRUE: case FALSE: octet val; };
  union OneBranchFT switch (boolean) { case FALSE: case TRUE: octet val; };
  union OneBranchTD switch (boolean) { case TRUE: default: octet val; };
  union OneBranchDT switch (boolean) { default: case TRUE: octet val; };
  union OneBranchFD switch (boolean) { case FALSE: default : octet val; };
  union OneBranchDF switch (boolean) { default: case FALSE: octet val; };
  union TwoBranchesTF switch (boolean) { case TRUE: octet val1; case FALSE: char val2; };
  union TwoBranchesFT switch (boolean) { case FALSE: octet val1; case TRUE: char val2; };
  union TwoBranchesTD switch (boolean) { case TRUE: octet val1; default: char val2; };
  union TwoBranchesDT switch (boolean) { default: octet val1; case TRUE: char val2; };
  union TwoBranchesFD switch (boolean) { case FALSE: octet val1; default: char val2; };
  union TwoBranchesDF switch (boolean) { default: octet val1; case FALSE: char val2; };
};

// Nested unions

enum disc1
{
  one,
  two
};

enum disc2
{
  a,
  b
};

enum disc_outer
{
  out1,
  out2
};

union inner1 switch (disc1)
{
  case one: short s;
  case two: long l;
};

union inner2 switch (disc2)
{
  case a: char c;
  case b: long lng;
};

union outer switch (disc_outer)
{
  case out1: inner1 first;
  case out2: inner2 second;
};

module UnionTest3
{
   enum ValChoice
     {
       intVal,
       realVal
     };

   union ValType switch(ValChoice)
     {
       case intVal: long integerValue;
       case realVal: double realValue;
     };

   struct UpType
     {
       ValType high;
       ValType low;
     };

   struct DownType
     {
       ValType high;
       ValType low;
     };

   enum IndChoice
     {
       up_Level,
       down_Level
     };

   union IndType switch(IndChoice)
     {
       case up_Level: UpType up;
       case down_Level: DownType down;
     };
};

// Make sure inner union is generated in header file with
// proper scoping (or lack thereof) in its name, depending
// on the platform.
enum XType
{
  X_A
};

enum ZType
{
  Z_A
};

union X switch (XType)
{
  case X_A:
    struct Y
      {
        union Z switch (ZType)
        {
          case Z_A: long a;
        } u;
      } a;
};

// Example involving union members with multiple case labels.
enum FieldType
{
    FTYPE_CHAR,
    FTYPE_VARCHAR,
    FTYPE_DEFCHAR
};

union FieldValue switch (FieldType)
{
    case FTYPE_CHAR:
    case FTYPE_VARCHAR:
       string strValue;
    default:
       string defstr;
};


struct Field
{
  FieldValue value;
};

// A fix to the IDL compiler's typecode generation created
// a problem with unions that have more than one member,
// where any member except the last is itself a scoped type.
// This is the simplest example that will reproduce the problem,
// if it ever reappears.
enum TestOneEnum
{
  TALL,
  SCHORT
};

enum TestTwoEnum
{
  LIGHT,
  DARK
};

union TestUnion switch (short)
{
  case 1: TestOneEnum oneEnum;
  case 2: TestTwoEnum twoEnum;
};

typedef long U41[2][3];
typedef long U42[2];

union U85 switch (long) {
  case 1: U41 b_85_1;
  case 2: U42 b_85_2;
};

typedef string UString[2];
union U86 switch (long) {
  case 1: string b_86_1;
  case 2: long b_86_2;
};
union U88 switch (long) {
  case 1: UString b_86_1;
  case 2: long b_86_2;
};

struct UBar {
  long foo;
};
typedef UBar UBarArray[2];

union U87 switch (long) {
  case 1: UBar b_87_1;
  case 2: long b_87_2;
};
union U89 switch (long) {
  case 1: UBarArray b_87_1;
  case 2: long b_87_2;
};

enum U90
{
  U90_1,
  U90_2
};

typedef U90 U90Array[2];

union U91 switch (long) {
  case 1: U90Array b_91_1;
  case 2: long b_92_2;
};

union U92 switch (long) {
  case 1: UBar b_92_1;
  case 2: long b_92_2;
  default: UBar b_92_3;
};

union U93 switch (long) {
  case 1: UBarArray b_93_1;
  case 2: long b_93_2;
  default: UBarArray b_93_3;
};

union U94 switch (long) {
  case 1: U90Array b_94_1;
  case 2: long b_94_2;
  default: U90Array b_94_3;
};