new files, some changes

CVS:
CVS:
CVS:
CVS:

1 files changed, 321 insertions, 0 deletions

diff --git a/TAO/TAO_IDL/be/be_state_typedef.cpp b/TAO/TAO_IDL/be/be_state_typedef.cpp
new file mode 100644
index 00000000000..41f633ef0ac
--- /dev/null
+++ b/TAO/TAO_IDL/be/be_state_typedef.cpp
@@ -0,0 +1,321 @@
+// ============================================================================
+//
+// = LIBRARY
+//    TAO IDL
+//
+// = FILENAME
+//    be_state_typedef.cpp
+//
+// = DESCRIPTION
+//    state based code generation for typedefs.
+//
+// = AUTHOR
+//    Aniruddha Gokhale
+//
+// ============================================================================
+
+#include	"idl.h"
+#include	"idl_extern.h"
+#include	"be.h"
+
+// return type for typedef
+be_state_typedef::be_state_typedef (void)
+{
+}
+
+// generate code for structure member
+int
+be_state_typedef::gen_code (be_type *bt, be_decl *d, be_type *type)
+{
+  TAO_OutStream *os; // output stream
+  TAO_NL  nl;        // end line
+  TAO_CodeGen *cg = TAO_CODEGEN::instance ();
+  be_typedef *tdef;  // typedef node
+  be_decl *scope; // enclosing scope in which the typedef occurs
+
+  switch (cg->state ())
+    {
+    case TAO_CodeGen::TAO_TYPEDEF_CH:
+      os = cg->client_header (); // set the stream to be the client header
+      break;
+    case TAO_CodeGen::TAO_TYPEDEF_CI:
+      os = cg->client_inline ();
+      break;
+    case TAO_CodeGen::TAO_TYPEDEF_CS:
+      os = cg->client_stubs ();
+      break;
+    default:
+      return -1;
+    } // end of outermost switch
+
+
+  tdef = be_typedef::narrow_from_decl (d); // downcast to typedef node
+  if (!tdef)
+    return -1;
+
+  // pass the typedef node, just in case it is needed
+  cg->node (tdef);
+
+  scope = be_decl::narrow_from_decl (ScopeAsDecl (tdef->defined_in ()));
+
+  if (!type) // not a recursive call
+    type = bt;
+  else // recursively called thru a typedef. "type" will have the most primitive
+    // base class of the typedef
+    ACE_ASSERT (bt->node_type () == AST_Decl::NT_typedef);
+
+  // the typedef node has the same size type as its base type
+  tdef->size_type (bt->size_type ());
+
+  switch (type->node_type ())
+    {
+    case AST_Decl::NT_interface: // type is an obj reference
+    case AST_Decl::NT_interface_fwd: // type is an obj reference
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              os->indent (); // start from current indentation
+
+              // typedef of an interface results in 3 typedefs as shown below
+              *os << "typedef " << bt->nested_type_name (scope) << " " <<
+                d->local_name () << ";" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_ptr") << " " <<
+                d->local_name () << "_ptr;" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_var") << " " <<
+                d->local_name () << "_var;" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_out") << " " <<
+                d->local_name () << "_out;\n\n";
+            }
+            break;
+          default:  // nothing to do for other cases
+            break;
+          } // end of switch state
+      }
+      break;
+    case AST_Decl::NT_pre_defined: // type is predefined type
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              be_predefined_type *pd = be_predefined_type::narrow_from_decl (type);
+
+              if (!pd)
+                return -1;
+              os->indent (); // start from current indentation
+              *os << "typedef " << bt->nested_type_name (scope) << " " <<
+                d->local_name () << ";";
+              // if the predefined type is an ANY, we also define a typedef to _var
+              if (pd->pt () == AST_PredefinedType::PT_any)
+                {
+                  *os << nl;
+                  *os << "typedef " << bt->name () << "_var " << d->local_name
+                    () << "_var;";
+                }
+              else if (pd->pt () == AST_PredefinedType::PT_pseudo)
+                {
+                  // pseudo object
+                  *os << "typedef " << bt->nested_type_name (scope, "_ptr") <<
+                    " " << d->local_name () << "_ptr;" << nl;
+                  *os << "typedef " << bt->nested_type_name (scope, "_var") <<
+                    " " << d->local_name () << "_var;" << nl;
+                }
+              *os << "typedef " << bt->nested_type_name (scope, "_out") << " "
+                  << d->local_name () << "_out;\n\n";
+            } // end of case
+            break;
+          default: // nothing to do for other cases
+            break;
+          } // end switch
+      }
+      break;
+    case AST_Decl::NT_string: // type is a string
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              os->indent (); // start from current indentation
+              if (bt->node_type () == AST_Decl::NT_typedef)
+                {
+                  *os << "typedef " << bt->nested_type_name (scope) << " " <<
+                    d->local_name () << ";" << nl;
+                  *os << "typedef " << bt->nested_type_name (scope, "_var") <<
+                    " " << d->local_name () << "_var;" << nl;
+                  *os << "typedef " << bt->nested_type_name (scope, "_out") <<
+                    " " << d->local_name () << "_out;\n\n";
+                }
+              else
+                {
+                  *os << "typedef CORBA::String " << d->local_name () << ";" <<
+                    nl;
+                  *os << "typedef CORBA::String_var " << d->local_name
+                    () << "_var;" << nl;
+                  *os << "typedef CORBA::String_out " << d->local_name
+                    () << "_out;\n\n";
+                }
+            }
+            break;
+          default: // nothing to do for the rest of the cases
+            break;
+          } // end switch state
+      }
+      break;
+    case AST_Decl::NT_enum: // type is an enum
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              os->indent (); // start from current indentation
+              // if we are not here recursively, then we need to generate the
+              // definition first
+              if (bt->node_type () != AST_Decl::NT_typedef)
+                {
+                  if (bt->gen_client_header () == -1)
+                    {
+                      ACE_ERROR_RETURN ((LM_ERROR,
+                         "be_state_typedef - enum gen failed\n"), -1);
+                    }
+                }
+              *os << "typedef " << bt->nested_type_name (scope) << " " <<
+                d->local_name () << ";" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_out") << " "
+                  << d->local_name () << "_out;\n\n";
+            }
+            break;
+          default:
+            break;
+          } // end of switch
+      }
+      break;
+      // these are all anonymous types
+    case AST_Decl::NT_array: // type is an array
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              // if we are not here recursively, then we need to generate the
+              // definition first
+              if (bt->node_type () != AST_Decl::NT_typedef)
+                {
+                  if (bt->gen_client_header () == -1)
+                    {
+                      ACE_ERROR_RETURN ((LM_ERROR,
+                           "be_state_typedef - array gen failed\n"), -1);
+                    }
+                }
+              os->indent ();
+              *os << "typedef " << bt->name () << " " << d->local_name () <<
+                ";" << nl;
+              *os << "typedef " << bt->name () << "_forany " << d->local_name
+                () << "_forany;" << nl;
+              // typedefs for the auxiliary methods. If we are nested inside
+              // some scope, these methods become static to the enclosing scope
+              if (d->is_nested ())
+                *os << "static ";
+              *os << d->name () << "_slice* " << d->local_name () <<
+                "_alloc (void);" << nl;
+              if (d->is_nested ())
+                *os << "static ";
+              *os << d->name () << "_slice* " << d->local_name () << "_dup ("
+                  << d->name () << "_slice* " << ");" << nl;
+              if (d->is_nested ())
+                *os << "static ";
+              *os << "void " << d->name () << "_free (" << d->name () <<
+                "_slice *);\n\n";
+            }
+            break;
+          default:
+            break;
+          } // end of switch
+      }
+      break;
+    case AST_Decl::NT_sequence: // type is a sequence
+    case AST_Decl::NT_struct:   // type is a struct
+    case AST_Decl::NT_union:    // type is a union
+      {
+        switch (cg->state ())
+          {
+          case TAO_CodeGen::TAO_TYPEDEF_CH:
+            {
+              // if we are not here recursively, then we need to generate the
+              // definition first
+              if (bt->node_type () != AST_Decl::NT_typedef)
+                {
+                  if (bt->gen_client_header () == -1)
+                    {
+                      ACE_ERROR_RETURN ((LM_ERROR,
+                          "be_state_typedef - struct/union/seq gen failed\n"),
+                                        -1);
+                    }
+                }
+              os->indent (); // start from current indentation
+              *os << "typedef " << bt->nested_type_name (scope) << " " <<
+                d->local_name () << ";" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_var") << " "
+                  << d->local_name () << "_var;" << nl;
+              *os << "typedef " << bt->nested_type_name (scope, "_out") << " "
+                  << d->local_name () << "_out;\n\n";
+            }
+            break;
+          case TAO_CodeGen::TAO_TYPEDEF_CI:
+            {
+              // if we are not here recursively, then we need to generate the
+              // definition first
+              if (bt->node_type () != AST_Decl::NT_typedef)
+                {
+                  if (bt->gen_client_inline () == -1)
+                    {
+                      ACE_ERROR_RETURN ((LM_ERROR,
+                          "be_state_typedef - struct/union/seq gen failed\n"),
+                                        -1);
+                    }
+                }
+            }
+            break;
+          case TAO_CodeGen::TAO_TYPEDEF_CS:
+            {
+              // if we are not here recursively, then we need to generate the
+              // definition first
+              if (bt->node_type () != AST_Decl::NT_typedef)
+                {
+                  if (bt->gen_client_stubs () == -1)
+                    {
+                      ACE_ERROR_RETURN ((LM_ERROR,
+                          "be_state_typedef - struct/union/seq gen failed\n"),
+                                        -1);
+                    }
+                }
+            }
+            break;
+          default:
+            break;
+          } // end of switch state
+      }
+      break;
+    case AST_Decl::NT_except: // type is an exception
+      {
+        // XXXASG TODO: is this allowed ???
+      }
+      break;
+    case AST_Decl::NT_typedef: // type is a typedef
+      {
+        be_type *temp;
+        be_typedef *t = be_typedef::narrow_from_decl (bt);
+
+        if (!t)
+          return -1;
+
+        temp = t->primitive_base_type ();
+        // make a recursive call
+        return this->gen_code (t, tdef, temp);
+      } // end of case
+      break;
+    } // end of switch
+
+  return 0;
+}