ChangeLogTag: Thu Oct 16 16:45:35 2003 Boris Kolpackov <boris@dre.vanderbilt.edu>

34 files changed, 1212 insertions, 38 deletions

diff --git a/TAO/CIAO/CCF/CCF/IDL2/LexicalAnalyzer.cpp b/TAO/CIAO/CCF/CCF/IDL2/LexicalAnalyzer.cpp
index 586faa76387..2a0817b57b2 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/LexicalAnalyzer.cpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/LexicalAnalyzer.cpp
@@ -32,6 +32,7 @@ namespace CCF
       keyword_table_.insert ("out"       );
       keyword_table_.insert ("sequence"  );
       keyword_table_.insert ("sinclude"  );
+      keyword_table_.insert ("struct"    );
       keyword_table_.insert ("supports"  );
       keyword_table_.insert ("typedef"   );
       keyword_table_.insert ("typeid"    );
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Makefile.archive b/TAO/CIAO/CCF/CCF/IDL2/Makefile.archive
index e4793978cbd..2eb1e41b8df 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Makefile.archive
+++ b/TAO/CIAO/CCF/CCF/IDL2/Makefile.archive
@@ -17,9 +17,11 @@ cxx_translation_units := LexicalAnalyzer.cpp Parser.cpp
 translated_units := SyntaxTree/BuiltIn.o      \
                     SyntaxTree/Elements.o     \
                     SyntaxTree/Interface.o    \
+                    SyntaxTree/Member.o       \
                     SyntaxTree/Module.o       \
                     SyntaxTree/Operation.o    \
                     SyntaxTree/Sequence.o     \
+                    SyntaxTree/Struct.o       \
                     SyntaxTree/Translation.o  \
                     SyntaxTree/TypeId.o       \
                     SyntaxTree/Typedef.o      \
@@ -28,9 +30,11 @@ translated_units := SyntaxTree/BuiltIn.o      \
 translated_units += Traversal/BuiltIn.o       \
                     Traversal/Elements.o      \
                     Traversal/Interface.o     \
+                    Traversal/Member.o        \
                     Traversal/Module.o        \
                     Traversal/Operation.o     \
                     Traversal/Sequence.o      \
+                    Traversal/Struct.o        \
                     Traversal/Translation.o
 
 translated_units += SemanticAction/Operation.o
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Parser.cpp b/TAO/CIAO/CCF/CCF/IDL2/Parser.cpp
index 9873d5720e7..28dda99f4c6 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Parser.cpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/Parser.cpp
@@ -32,22 +32,23 @@ namespace CCF
 
           error_handler (context, dout),
 
-          ABSTRACT   ("abstract"),
-          ATTRIBUTE  ("attribute"),
-          FACTORY    ("factory"),
-          IN         ("in"),
-          INCLUDE    ("include"),
-          INOUT      ("inout"),
-          INTERFACE  ("interface"),
-          LOCAL      ("local"),
-          MODULE     ("module"),
-          OUT        ("out"),
-          SEQUENCE   ("sequence"),
-          SINCLUDE   ("sinclude"),
-          SUPPORTS   ("supports"),
-          TYPEDEF    ("typedef"),
-          TYPEID     ("typeid"),
-          TYPEPREFIX ("typeprefix"),
+          ABSTRACT   ("abstract"   ),
+          ATTRIBUTE  ("attribute"  ),
+          FACTORY    ("factory"    ),
+          IN         ("in"         ),
+          INCLUDE    ("include"    ),
+          INOUT      ("inout"      ),
+          INTERFACE  ("interface"  ),
+          LOCAL      ("local"      ),
+          MODULE     ("module"     ),
+          OUT        ("out"        ),
+          SEQUENCE   ("sequence"   ),
+          SINCLUDE   ("sinclude"   ),
+          STRUCT     ("struct"     ),
+          SUPPORTS   ("supports"   ),
+          TYPEDEF    ("typedef"    ),
+          TYPEID     ("typeid"     ),
+          TYPEPREFIX ("typeprefix" ),
 
           COLON  (":"),
           COMMA  (","),
@@ -101,6 +102,19 @@ namespace CCF
           act_interface_end (f.interface (), &SemanticAction::Interface::end),
 
 
+          // Member
+          //
+          //
+          act_member_begin (
+            f.member (), &SemanticAction::Member::begin),
+
+          act_member_declarator (
+            f.member (), &SemanticAction::Member::declarator),
+
+          act_member_end (
+            f.member (), &SemanticAction::Member::end),
+
+
           // Module
           //
           //
@@ -126,6 +140,19 @@ namespace CCF
 
           act_operation_end (f.operation (), &SemanticAction::Operation::end),
 
+          // Struct
+          //
+          //
+          act_struct_begin (f.struct_ (), &SemanticAction::Struct::begin),
+
+          act_struct_open_scope (
+            f.struct_ (), &SemanticAction::Scope::open_scope),
+
+          act_struct_close_scope (
+            f.struct_ (), &SemanticAction::Scope::close_scope),
+
+          act_struct_end (f.struct_ (), &SemanticAction::Struct::end),
+
 
           // Typedef
           //
@@ -189,6 +216,7 @@ namespace CCF
         | extension
         | local_type_decl
         | module_decl
+        | struct_decl
         | typedef_
         | type_id
         | type_prefix
@@ -283,9 +311,9 @@ namespace CCF
         ;
 
 
-      //
       // interface
       //
+      //
       abstract_interface_decl =
         guard
         (
@@ -383,9 +411,9 @@ namespace CCF
         )
         ;
 
-      //
       // attribute
       //
+      //
       attribute_decl =
            ATTRIBUTE
         >> identifier[act_attribute_type]
@@ -394,9 +422,9 @@ namespace CCF
         ;
 
 
-      //
       // direction specifier
       //
+      //
       direction_specifier =
            IN
         |  OUT
@@ -404,9 +432,28 @@ namespace CCF
         ;
 
 
+      // member
       //
+      //
+      member_decl =
+           identifier[act_member_begin]
+        >> member_declarator_list
+        >> SEMI[act_member_end]
+        ;
+
+
+      member_declarator_list =
+           identifier[act_member_declarator]
+        >> *(
+                 COMMA
+              >> identifier[act_member_declarator]
+            )
+        ;
+
+
       // operation
       //
+      //
       operation_decl =
            (identifier >> simple_identifier)[act_operation_begin]
         >> LPAREN
@@ -431,6 +478,57 @@ namespace CCF
         ;
 
 
+      // struct
+      //
+      //
+      struct_decl =
+        guard
+        (
+             STRUCT
+          >> assertion ("struct name expected")
+             (
+               simple_identifier[act_struct_begin]
+             )
+          >> struct_decl_trailer
+
+        )[error_handler]
+        ;
+
+
+      struct_decl_trailer =
+        assertion ("\';\' or \'{\' expected",
+                   f.struct_ (),
+                   &SemanticAction::Struct::end)
+        (
+            SEMI[act_struct_end]
+          | (
+                 LBRACE[act_struct_open_scope]
+              >> struct_body
+              >> assertion ("member or \'}\' expected",
+                            f.struct_ (),
+                            &SemanticAction::Struct::close_scope,
+                            &SemanticAction::Struct::end,
+                            RecoveryMethod::STANDARD,
+                            DiagnosticType::BEFORE)
+                 (
+                   RBRACE[act_struct_close_scope]
+                 )
+              >> assertion ("\';\' is missing",
+                            f.struct_ (),
+                            &SemanticAction::Struct::end,
+                            RecoveryMethod::NONE)
+                 (
+                   SEMI[act_struct_end]
+                 )
+            )
+        )
+        ;
+
+
+      struct_body =
+        +member_decl
+        ;
+
       // typedef
       //
       //
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Parser.hpp b/TAO/CIAO/CCF/CCF/IDL2/Parser.hpp
index d43dcaae5bd..390f8fb3184 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Parser.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/Parser.hpp
@@ -311,6 +311,7 @@ namespace CCF
       KeywordParser OUT;
       KeywordParser SEQUENCE;
       KeywordParser SINCLUDE;
+      KeywordParser STRUCT;
       KeywordParser SUPPORTS;
       KeywordParser TYPEDEF;
       KeywordParser TYPEID;
@@ -363,10 +364,17 @@ namespace CCF
 
       Rule direction_specifier;
 
+      Rule member_decl;
+      Rule member_declarator_list;
+
       Rule operation_decl;
       Rule operation_parameter_list;
       Rule operation_parameter;
 
+      Rule struct_decl;
+      Rule struct_decl_trailer;
+      Rule struct_body;
+
       Rule typedef_;
       Rule typedef_type_spec;
       Rule typedef_declarator_list;
@@ -441,6 +449,19 @@ namespace CCF
       act_interface_end;
 
 
+      // Member
+      //
+      //
+      OneArgAction<IdentifierPtr, SemanticAction::Member>
+      act_member_begin;
+
+      OneArgAction<SimpleIdentifierPtr, SemanticAction::Member>
+      act_member_declarator;
+
+      NoArgAction<SemanticAction::Member>
+      act_member_end;
+
+
       // Module
       //
       //
@@ -498,6 +519,21 @@ namespace CCF
       NoArgAction<SemanticAction::Operation>
       act_operation_end;
 
+      // Struct
+      //
+      //
+      OneArgAction<SimpleIdentifierPtr, SemanticAction::Struct>
+      act_struct_begin;
+
+      ScopeAction
+      act_struct_open_scope;
+
+      ScopeAction
+      act_struct_close_scope;
+
+      NoArgAction<SemanticAction::Struct>
+      act_struct_end;
+
 
       // Typedef
       //
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction.hpp
index cc8a27311f9..d12d18e4911 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction.hpp
@@ -9,8 +9,10 @@
 #include "CCF/IDL2/SemanticAction/Elements.hpp"
 #include "CCF/IDL2/SemanticAction/Include.hpp"
 #include "CCF/IDL2/SemanticAction/Interface.hpp"
+#include "CCF/IDL2/SemanticAction/Member.hpp"
 #include "CCF/IDL2/SemanticAction/Module.hpp"
 #include "CCF/IDL2/SemanticAction/Operation.hpp"
+#include "CCF/IDL2/SemanticAction/Struct.hpp"
 #include "CCF/IDL2/SemanticAction/Typedef.hpp"
 #include "CCF/IDL2/SemanticAction/TypeId.hpp"
 
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Factory.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Factory.hpp
index c19a7ae1f37..a25e0a31db7 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Factory.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Factory.hpp
@@ -14,8 +14,10 @@ namespace CCF
       class Attribute;
       class Include;
       class Interface;
+      class Member;
       class Module;
       class Operation;
+      class Struct;
       class Typedef;
       class TypeId;
       class TypePrefix;
@@ -38,12 +40,18 @@ namespace CCF
         virtual Interface&
         interface () = 0;
 
+        virtual Member&
+        member () = 0;
+
         virtual Module&
         module () = 0;
 
         virtual Operation&
         operation () = 0;
 
+        virtual Struct&
+        struct_ () = 0;
+
         virtual Typedef&
         typedef_ () = 0;
 
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Factory.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Factory.hpp
index 0d0f5a49074..2b885c7694d 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Factory.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Factory.hpp
@@ -10,8 +10,10 @@
 #include "CCF/IDL2/SemanticAction/Impl/Attribute.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/Include.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/Interface.hpp"
+#include "CCF/IDL2/SemanticAction/Impl/Member.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/Module.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/Operation.hpp"
+#include "CCF/IDL2/SemanticAction/Impl/Struct.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/Typedef.hpp"
 #include "CCF/IDL2/SemanticAction/Impl/TypeId.hpp"
 
@@ -43,8 +45,10 @@ namespace CCF
                 attribute_ (trace_, scope_),
                 include_ (trace_, *this, r, scope_),
                 interface_ (trace_, scope_),
+                member_ (trace_, scope_),
                 module_ (trace_, scope_),
                 operation_ (trace_, scope_),
+                struct__ (trace_, scope_),
                 typedef__ (trace_, scope_),
                 type_id_ (trace_, scope_),
                 type_prefix_ (trace_, scope_)
@@ -69,6 +73,12 @@ namespace CCF
             return interface_;
           }
 
+          virtual SemanticAction::Member&
+          member ()
+          {
+            return member_;
+          }
+
           virtual SemanticAction::Module&
           module ()
           {
@@ -81,6 +91,12 @@ namespace CCF
             return operation_;
           }
 
+          virtual SemanticAction::Struct&
+          struct_ ()
+          {
+            return struct__;
+          }
+
           virtual SemanticAction::Typedef&
           typedef_ ()
           {
@@ -108,8 +124,10 @@ namespace CCF
           Attribute attribute_;
           Include include_;
           Interface interface_;
+          Member member_;
           Module module_;
           Operation operation_;
+          Struct struct__;
           Typedef typedef__;
           TypeId type_id_;
           TypePrefix type_prefix_;
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Interface.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Interface.hpp
index e0cdeea6597..d199a39ddb9 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Interface.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Interface.hpp
@@ -259,6 +259,8 @@ namespace CCF
               }
 
               scope_->insert (decl);
+
+              name_ = SimpleName ("::"); //indicate that we are done
             }
             else
             {
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.cpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.cpp
new file mode 100644
index 00000000000..088bf03bd3f
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.cpp
@@ -0,0 +1,18 @@
+// file      : CCF/IDL2/SemanticAction/Impl/Member.cpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/SemanticAction/Impl/Member.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      namespace Impl
+      {
+      }
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.hpp
new file mode 100644
index 00000000000..f3f5b9e89b1
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Member.hpp
@@ -0,0 +1,120 @@
+// file      : CCF/IDL2/SemanticAction/Impl/Member.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SEMANTIC_ACTION_IMPL_MEMBER_HPP
+#define CCF_IDL2_SEMANTIC_ACTION_IMPL_MEMBER_HPP
+
+#include "CCF/IDL2/SyntaxTree/Member.hpp"
+#include "CCF/IDL2/SemanticAction/Member.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      namespace Impl
+      {
+        //
+        //
+        //
+        class Member : public virtual SemanticAction::Member
+        {
+        public:
+          virtual
+          ~Member () throw () {}
+
+          Member (bool trace, SyntaxTree::ScopePtr& current)
+              : trace_ (trace),
+                scope_ (current),
+                type_ ("::") //@@ this is dirty
+          {
+          }
+
+          virtual void
+          begin (IdentifierPtr const& id)
+          {
+            if (trace_) cerr << "member " << id << endl;
+
+            using namespace SyntaxTree;
+
+            Name name (id->lexeme ());
+
+            struct Predicate : public DeclarationTable::ResolvePredicate
+            {
+              virtual bool
+              test (DeclarationPtr const& d) const throw ()
+              {
+                //@@ loosing information (completeness)
+                //
+
+                return d->is_a<TypeDecl> () &&
+                  d->dynamic_type<TypeDecl> ()->complete ();
+              }
+            } p;
+
+            try
+            {
+              type_ = scope_->table ().resolve (
+                name,
+                scope_->name (),
+                scope_->peek_order (),
+                p);
+            }
+            catch (DeclarationTable::NameNotFound const&)
+            {
+              cerr << "error: invalid member declaration" << endl;
+              cerr << "no type with name \'"
+                   << name << "\' visible from scope \'"
+                   << scope_->name () << "\'" << endl;
+            }
+            catch (DeclarationTable::PredicateNotMet const&)
+            {
+              cerr << "error: invalid member declaration" << endl;
+              cerr << "no complete type with name \'"
+                   << name << "\' visible from scope \'"
+                   << scope_->name () << "\'" << endl;
+            }
+          }
+
+
+          virtual void
+          declarator (SimpleIdentifierPtr const& id)
+          {
+            if (trace_) cerr << "  " << id << endl;
+
+            using namespace SyntaxTree;
+
+            if (type_ != ScopedName ("::"))
+            {
+              MemberDeclPtr member_ (
+                new MemberDecl (SimpleName (id->lexeme ()),
+                                type_,
+                                scope_));
+
+              scope_->insert (member_);
+            }
+          }
+
+          virtual void
+          end ()
+          {
+            if (trace_) cerr << "end" << endl;
+
+            // Indicate that we are done.
+            //
+            type_ = SyntaxTree::ScopedName ("::");
+          }
+
+        private:
+          bool trace_;
+          SyntaxTree::ScopePtr& scope_;
+          SyntaxTree::ScopedName type_;
+        };
+      }
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SEMANTIC_ACTION_IMPL_MEMBER_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.cpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.cpp
new file mode 100644
index 00000000000..0506ab5e363
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.cpp
@@ -0,0 +1,18 @@
+// file      : CCF/IDL2/SemanticAction/Impl/Struct.cpp
+// author    : Jeff Parsons <j.parsons@vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/SemanticAction/Impl/Struct.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      namespace Impl
+      {
+      }
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.hpp
new file mode 100644
index 00000000000..f744ca12886
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Struct.hpp
@@ -0,0 +1,99 @@
+// file      : CCF/IDL2/SemanticAction/Impl/Struct.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SEMANTIC_ACTION_IMPL_STRUCT_HPP
+#define CCF_IDL2_SEMANTIC_ACTION_IMPL_STRUCT_HPP
+
+#include "CCF/IDL2/SyntaxTree/Struct.hpp"
+#include "CCF/IDL2/SemanticAction/Struct.hpp"
+#include "CCF/IDL2/SemanticAction/Impl/Elements.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      namespace Impl
+      {
+        //
+        //
+        //
+        class Struct : public virtual SemanticAction::Struct,
+                       public virtual ScopeBase<SyntaxTree::StructDeclPtr>
+        {
+        public:
+          virtual
+          ~Struct () throw () {}
+
+
+          Struct (bool trace,
+                  SyntaxTree::ScopePtr& scope)
+              : ScopeBase<SyntaxTree::StructDeclPtr> (scope),
+                trace_ (trace),
+                name_ ("::") //@@ dirty
+          {
+          }
+
+          virtual void
+          begin (SimpleIdentifierPtr const& id)
+          {
+            if (trace_) cerr << "struct " << id << endl;
+            name_ = SyntaxTree::SimpleName (id->lexeme ());
+          }
+
+          virtual void
+          open_scope ()
+          {
+            if (trace_) cerr << "scope open" << endl;
+
+            using namespace SyntaxTree;
+
+            StructDefPtr s (new StructDef (name_, scope_));
+
+            scope_->insert (s);
+            push (s);
+            scope_ = s;
+
+            name_ = SimpleName ("::"); //indicate that we are done
+          }
+
+          virtual void
+          close_scope ()
+          {
+            scope_ = scope_->scope ();
+            if (trace_) cerr << "scope close" << endl;
+          }
+
+          virtual void
+          end ()
+          {
+            if (trace_) cerr << "end" << endl;
+
+            using namespace SyntaxTree;
+
+            if (name_ != SimpleName ("::"))
+            {
+              scope_->insert (
+                StructForwardDeclPtr(
+                  new SyntaxTree::StructForwardDecl (name_, scope_)));
+
+              name_ = SimpleName ("::"); //indicate that we are done
+            }
+            else
+            {
+              pop ();
+            }
+          }
+
+        private:
+          bool trace_;
+          SyntaxTree::SimpleName name_;
+        };
+      }
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SEMANTIC_ACTION_IMPL_STRUCT_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Member.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Member.hpp
new file mode 100644
index 00000000000..594e3625622
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Member.hpp
@@ -0,0 +1,35 @@
+// file      : CCF/IDL2/SemanticAction/Member.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SEMANTIC_ACTION_MEMBER_HPP
+#define CCF_IDL2_SEMANTIC_ACTION_MEMBER_HPP
+
+#include "CCF/IDL2/SemanticAction/Elements.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      class Member
+      {
+      public:
+        virtual
+        ~Member () throw () {}
+
+        virtual void
+        begin (IdentifierPtr const& id) = 0;
+
+        virtual void
+        declarator (SimpleIdentifierPtr const& id) = 0;
+
+        virtual void
+        end () = 0;
+      };
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SEMANTIC_ACTION_MEMBER_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Struct.hpp b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Struct.hpp
new file mode 100644
index 00000000000..0ac9aaab095
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Struct.hpp
@@ -0,0 +1,38 @@
+// file      : CCF/IDL2/SemanticAction/Struct.hpp
+// author    : Jeff Parsons <j.parsons@vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SEMANTIC_ACTION_STRUCT_HPP
+#define CCF_IDL2_SEMANTIC_ACTION_STRUCT_HPP
+
+#include "CCF/IDL2/SemanticAction/Elements.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SemanticAction
+    {
+      class Struct : public virtual Scope
+      {
+      public:
+        virtual
+        ~Struct () throw () {}
+
+        virtual void
+        begin (SimpleIdentifierPtr const& id) = 0;
+
+        virtual void
+        open_scope () = 0;
+
+        virtual void
+        close_scope () = 0;
+
+        virtual void
+        end () = 0;
+      };
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SEMANTIC_ACTION_STRUCT_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree.hpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree.hpp
index 1ef90bc9715..735e607abff 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree.hpp
@@ -8,8 +8,10 @@
 #include "CCF/IDL2/SyntaxTree/Elements.hpp"
 #include "CCF/IDL2/SyntaxTree/BuiltIn.hpp"
 #include "CCF/IDL2/SyntaxTree/Interface.hpp"
+#include "CCF/IDL2/SyntaxTree/Member.hpp"
 #include "CCF/IDL2/SyntaxTree/Module.hpp"
 #include "CCF/IDL2/SyntaxTree/Operation.hpp"
+#include "CCF/IDL2/SyntaxTree/Struct.hpp"
 #include "CCF/IDL2/SyntaxTree/Sequence.hpp"
 #include "CCF/IDL2/SyntaxTree/Translation.hpp"
 #include "CCF/IDL2/SyntaxTree/Typedef.hpp"
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Makefile.alt b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Makefile.alt
index c55ae599f83..6e7c918412f 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Makefile.alt
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Makefile.alt
@@ -13,9 +13,11 @@ $(call include, $(UTILITY_ROOT)/BuildRules/Object.pre.rules)
 cxx_translation_units := BuiltIn.cpp      \
                          Elements.cpp     \
                          Interface.cpp    \
+                         Member.cpp       \
                          Module.cpp       \
                          Operation.cpp    \
-                         Sequence.cpp      \
+                         Sequence.cpp     \
+                         Struct.cpp       \
                          Translation.cpp  \
                          Typedef.cpp      \
                          TypeId.cpp       \
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.cpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.cpp
new file mode 100644
index 00000000000..caf43db139f
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.cpp
@@ -0,0 +1,33 @@
+// file      : CCF/IDL2/SyntaxTree/Member.cpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/SyntaxTree/Member.hpp"
+
+using namespace Introspection;
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SyntaxTree
+    {
+      namespace
+      {
+        TypeInfo
+        member_decl_init_ ()
+        {
+          TypeInfo ti (typeid (MemberDecl));
+          ti.add_base (
+            Access::PUBLIC, true, Declaration::static_type_info ());
+          return ti;
+        }
+
+        TypeInfo member_decl_ (member_decl_init_ ());
+      }
+
+      TypeInfo const& MemberDecl::
+      static_type_info () { return member_decl_; }
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.hpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.hpp
new file mode 100644
index 00000000000..87933f1d4cc
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Member.hpp
@@ -0,0 +1,61 @@
+// file      : CCF/IDL2/SyntaxTree/Member.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SYNTAX_TREE_MEMBER_HPP
+#define CCF_IDL2_SYNTAX_TREE_MEMBER_HPP
+
+#include "CCF/IDL2/SyntaxTree/Elements.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SyntaxTree
+    {
+      class MemberDecl : public virtual Declaration
+      {
+      public:
+        virtual
+        ~MemberDecl () throw () {}
+
+        MemberDecl (SimpleName const& name,
+                    ScopedName const& type,
+                    ScopePtr const& scope)
+            : Declaration (name, scope),
+              type_ (table (), type)
+          
+        {
+          type_info (static_type_info ());
+        }
+        
+      public:
+        TypeDeclPtr
+        type () const
+        {
+          return type_.resolve ();
+        }
+        
+      public:
+        virtual std::string
+        declaration_class ()
+        {
+          return "member";
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+
+      private:
+        TypeDeclRef type_;
+      };
+
+      typedef
+      StrictPtr<MemberDecl>
+      MemberDeclPtr;
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SYNTAX_TREE_MEMBER_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Operation.hpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Operation.hpp
index 4c18575d728..d49b9e7bba6 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Operation.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Operation.hpp
@@ -35,7 +35,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -108,7 +108,7 @@ namespace CCF
         }
 
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -168,7 +168,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.cpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.cpp
new file mode 100644
index 00000000000..4c0999cee8f
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.cpp
@@ -0,0 +1,118 @@
+// file      : CCF/IDL2/SyntaxTree/Struct.cpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/SyntaxTree/Struct.hpp"
+
+using namespace Introspection;
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SyntaxTree
+    {
+      //  StructDecl
+      //
+      //
+
+      bool StructDecl::
+      complete () const
+      {
+        try
+        {
+          //@@ I probably should add something like exists into
+          //   DeclTable.
+
+          //@@ gcc bug
+          table ().template lookup<StructDef> (name ());
+
+          return true;
+        }
+        catch (DeclarationTable::DeclarationNotFound const& e)
+        {
+          //@@ ICE
+          abort ();
+        }
+        catch (DeclarationTable::TypeMismatch const& e)
+        {
+          return false;
+        }
+      }
+
+      namespace
+      {
+        TypeInfo
+        struct_decl_init_ ()
+        {
+          TypeInfo ti (typeid (StructDecl));
+          ti.add_base (Access::PUBLIC,
+                       true,
+                       ForwardDeclarableTypeDecl::static_type_info ());
+          return ti;
+        }
+
+        TypeInfo struct_decl_ (struct_decl_init_ ());
+      }
+
+      TypeInfo const& StructDecl::
+      static_type_info () { return struct_decl_; }
+
+
+      //  StructForwardDecl
+      //
+      //
+      namespace
+      {
+        TypeInfo
+        struct_forward_decl_init_ ()
+        {
+          TypeInfo ti (typeid (StructForwardDecl));
+
+          ti.add_base (
+            Access::PUBLIC, true, StructDecl::static_type_info ());
+
+          ti.add_base (
+            Access::PUBLIC, true, TypeForwardDecl::static_type_info ());
+
+          return ti;
+        }
+
+        TypeInfo struct_forward_decl_ (struct_forward_decl_init_ ());
+      }
+
+      TypeInfo const& StructForwardDecl::
+      static_type_info () { return struct_forward_decl_; }
+
+
+      //  StructDef
+      //
+      //
+      namespace
+      {
+        TypeInfo
+        struct_def_init_ ()
+        {
+          TypeInfo ti (typeid (StructDef));
+
+          ti.add_base (
+            Access::PUBLIC, true, StructDecl::static_type_info ());
+
+          ti.add_base (
+            Access::PUBLIC, true, TypeDef::static_type_info ());
+
+          ti.add_base (
+            Access::PUBLIC, true, Scope::static_type_info ());
+
+          return ti;
+        }
+
+        TypeInfo struct_def_ (struct_def_init_ ());
+      }
+
+      TypeInfo const& StructDef::
+      static_type_info () { return struct_def_; }
+
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.hpp b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.hpp
new file mode 100644
index 00000000000..bb41c481b75
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/SyntaxTree/Struct.hpp
@@ -0,0 +1,148 @@
+// file      : CCF/IDL2/SyntaxTree/Struct.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_SYNTAX_TREE_STRUCT_HPP
+#define CCF_IDL2_SYNTAX_TREE_STRUCT_HPP
+
+#include "CCF/IDL2/SyntaxTree/Elements.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace SyntaxTree
+    {
+      //
+      //
+      //
+      class StructDecl : public virtual ForwardDeclarableTypeDecl
+      {
+      protected:
+        virtual
+        ~StructDecl () throw () {}
+
+        StructDecl ()
+        {
+          type_info (static_type_info ());
+        }
+
+      public:
+        virtual bool
+        complete () const;
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+      };
+
+      typedef
+      StrictPtr<StructDecl>
+      StructDeclPtr;
+
+
+      //
+      //
+      //
+      class StructForwardDecl : public virtual StructDecl,
+                                public virtual TypeForwardDecl
+      {
+      public:
+        virtual
+        ~StructForwardDecl () throw () {}
+
+        StructForwardDecl (SimpleName const& name, ScopePtr const& scope)
+            : Declaration (name, scope)
+        {
+          type_info (static_type_info ());
+        }
+
+      protected:
+        StructForwardDecl (SimpleName const& name,
+                           Order const& order,
+                           ScopePtr const& scope)
+            : Declaration (name, order, scope)
+        {
+          type_info (static_type_info ());
+        }
+
+      public:
+        virtual TypeDeclPtr
+        clone_typedef_temporary (SimpleName const& name,
+                                 Order const& order,
+                                 ScopePtr const& scope)
+        {
+          return TypeDeclPtr (new StructForwardDecl (name, order, scope));
+        }
+
+      public:
+        virtual std::string
+        declaration_class ()
+        {
+          return "struct";
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+      };
+
+      typedef
+      StrictPtr<StructForwardDecl>
+      StructForwardDeclPtr;
+
+      //
+      //
+      //
+      class StructDef : public virtual StructDecl,
+                        public virtual TypeDef,
+                        public virtual Scope
+      {
+      public:
+        virtual
+        ~StructDef () throw () {}
+
+        StructDef (SimpleName const& name, ScopePtr const& scope)
+            : Declaration (name, scope)
+        {
+          type_info (static_type_info ());
+        }
+
+      protected:
+        StructDef (SimpleName const& name,
+                   Order const& order,
+                   ScopePtr const& scope)
+            : Declaration (name, order, scope)
+        {
+          type_info (static_type_info ());
+        }
+
+      public:
+        virtual TypeDeclPtr
+        clone_typedef_temporary (SimpleName const& name,
+                                 Order const& order,
+                                 ScopePtr const& scope)
+        {
+          return TypeDeclPtr (new StructDef (name, order, scope));
+        }
+
+      public:
+        virtual std::string
+        declaration_class ()
+        {
+          return "struct";
+        }
+
+      public:
+        static Introspection::TypeInfo const&
+        static_type_info ();
+      };
+
+      typedef
+      StrictPtr<StructDef>
+      StructDefPtr;
+    }
+  }
+}
+
+#endif  // CCF_IDL2_SYNTAX_TREE_STRUCT_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal.hpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal.hpp
index 3efa40686a7..8f92146e8da 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Traversal.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal.hpp
@@ -8,9 +8,11 @@
 #include "CCF/IDL2/Traversal/Elements.hpp"
 #include "CCF/IDL2/Traversal/BuiltIn.hpp"
 #include "CCF/IDL2/Traversal/Interface.hpp"
+#include "CCF/IDL2/Traversal/Member.hpp"
 #include "CCF/IDL2/Traversal/Module.hpp"
 #include "CCF/IDL2/Traversal/Operation.hpp"
 #include "CCF/IDL2/Traversal/Sequence.hpp"
+#include "CCF/IDL2/Traversal/Struct.hpp"
 #include "CCF/IDL2/Traversal/Translation.hpp"
 #include "CCF/IDL2/Traversal/Typedef.hpp"
 #include "CCF/IDL2/Traversal/TypeId.hpp"
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Makefile.alt b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Makefile.alt
index dcd59368c3f..4cadfa560a2 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Makefile.alt
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Makefile.alt
@@ -13,9 +13,11 @@ $(call include, $(UTILITY_ROOT)/BuildRules/Object.pre.rules)
 cxx_translation_units := BuiltIn.cpp     \
                          Elements.cpp    \
                          Interface.cpp   \
+                         Member.cpp      \
                          Module.cpp      \
                          Operation.cpp   \
                          Sequence.cpp    \
+                         Struct.cpp      \
                          Translation.cpp
 
 
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.cpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.cpp
new file mode 100644
index 00000000000..298e028f86e
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.cpp
@@ -0,0 +1,43 @@
+// file      : CCF/IDL2/Traversal/Member.cpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/Traversal/Member.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace Traversal
+    {
+      void MemberDecl::
+      traverse (NodePtr const& n)
+      {
+        if (!delegate (n))
+        {
+          pre (n);
+          type (n);
+          post (n);
+        }
+      }
+
+
+      void MemberDecl::
+      pre (NodePtr const&)
+      {
+      }
+
+      void MemberDecl::
+      type (NodePtr const& n)
+      {
+        if (type_ != 0) type_->dispatch (n->type ());
+        else dispatch (n->type ());
+      }
+
+      void MemberDecl::
+      post (NodePtr const&)
+      {
+      }
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.hpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.hpp
new file mode 100644
index 00000000000..81757983686
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Member.hpp
@@ -0,0 +1,55 @@
+// file      : CCF/IDL2/Traversal/Member.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_TRAVERSAL_MEMBER_HPP
+#define CCF_IDL2_TRAVERSAL_MEMBER_HPP
+
+#include "CCF/IDL2/Traversal/Elements.hpp"
+#include "CCF/IDL2/SyntaxTree/Member.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace Traversal
+    {
+      struct MemberDecl : Traverser
+      {
+        typedef
+        SyntaxTree::MemberDeclPtr
+        NodePtr;
+
+        MemberDecl (Dispatcher* type = 0)
+            : type_ (type)
+        {
+          map (typeid (SyntaxTree::MemberDecl), this);
+        }
+
+        virtual bool
+        traverse (SyntaxTree::NodePtr const& n)
+        {
+          traverse (n->dynamic_type<SyntaxTree::MemberDecl> ());
+	  return true;
+        }
+
+        virtual void
+        traverse (NodePtr const&);
+
+        virtual void
+        pre (NodePtr const&);
+
+        virtual void
+        type (NodePtr const&);
+
+        virtual void
+        post (NodePtr const&);
+
+      private:
+        Dispatcher* type_;
+      };
+    }
+  }
+}
+
+#endif  // CCF_IDL2_TRAVERSAL_MEMBER_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.cpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.cpp
new file mode 100644
index 00000000000..f709db2c9ec
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.cpp
@@ -0,0 +1,45 @@
+// file      : CCF/IDL2/Traversal/Struct.cpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#include "CCF/IDL2/Traversal/Struct.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace Traversal
+    {
+      // StructDef
+      //
+      //
+
+      void StructDef::
+      traverse (NodePtr const& n)
+      {
+        if (!delegate (n))
+        {
+          pre (n);
+          scope (n);
+          post (n);
+        }
+      }
+
+      void StructDef::
+      pre (NodePtr const&)
+      {
+      }
+
+      void StructDef::
+      scope (NodePtr const& n)
+      {
+        delegate_scope (n);
+      }
+
+      void StructDef::
+      post (NodePtr const&)
+      {
+      }
+    }
+  }
+}
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.hpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.hpp
new file mode 100644
index 00000000000..f34344a9707
--- /dev/null
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Struct.hpp
@@ -0,0 +1,113 @@
+// file      : CCF/IDL2/Traversal/Struct.hpp
+// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
+// cvs-id    : $Id$
+
+#ifndef CCF_IDL2_TRAVERSAL_STRUCT_HPP
+#define CCF_IDL2_TRAVERSAL_STRUCT_HPP
+
+#include "CCF/IDL2/Traversal/Elements.hpp"
+#include "CCF/IDL2/SyntaxTree/Struct.hpp"
+
+namespace CCF
+{
+  namespace IDL2
+  {
+    namespace Traversal
+    {
+
+      //
+      //
+      //
+      struct StructDecl : Traverser
+      {
+        typedef
+        SyntaxTree::StructDeclPtr
+        NodePtr;
+
+        StructDecl ()
+        {
+          map (typeid (SyntaxTree::StructDecl), this);
+        }
+
+        virtual bool
+        traverse (SyntaxTree::NodePtr const& n)
+        {
+          traverse (n->dynamic_type<SyntaxTree::StructDecl> ());
+	  return true;
+        }
+
+        virtual void
+        traverse (NodePtr const& n)
+        {
+          delegate (n);
+        }
+      };
+
+
+      //
+      //
+      //
+      struct StructForwardDecl : Traverser
+      {
+        typedef
+        SyntaxTree::StructForwardDeclPtr
+        NodePtr;
+
+        StructForwardDecl ()
+        {
+          map (typeid (SyntaxTree::StructForwardDecl), this);
+        }
+
+        virtual bool
+        traverse (SyntaxTree::NodePtr const& n)
+        {
+          traverse (n->dynamic_type<SyntaxTree::StructForwardDecl> ());
+	  return true;
+        }
+
+        virtual void
+        traverse (NodePtr const& n)
+        {
+          delegate (n);
+        }
+      };
+
+
+      //
+      //
+      //
+      struct StructDef : ScopeTraverser
+      {
+        typedef
+        SyntaxTree::StructDefPtr
+        NodePtr;
+
+        StructDef ()
+        {
+          map (typeid (SyntaxTree::StructDef), this);
+        }
+
+        virtual bool
+        traverse (SyntaxTree::NodePtr const& n)
+        {
+          traverse (n->dynamic_type<SyntaxTree::StructDef> ());
+          return true;
+        }
+
+        virtual void
+        traverse (NodePtr const&);
+
+        virtual void
+        pre (NodePtr const&);
+
+        virtual void
+        scope (NodePtr const&);
+
+        virtual void
+        post (NodePtr const&);
+      };
+    }
+  }
+}
+
+#endif  // CCF_IDL2_TRAVERSAL_STRUCT_HPP
diff --git a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Typedef.hpp b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Typedef.hpp
index 76f00170787..2c7736a8127 100644
--- a/TAO/CIAO/CCF/CCF/IDL2/Traversal/Typedef.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL2/Traversal/Typedef.hpp
@@ -21,7 +21,7 @@ namespace CCF
       struct TypedefDecl : Traverser
       {
         typedef
-        SyntaxTree::StrictPtr<T>
+        SyntaxTree::TypedefDeclPtr
         NodePtr;
 
         TypedefDecl ()
@@ -35,7 +35,7 @@ namespace CCF
           //@@ gcc bug
           if (n->template is_a<T> ())
           {
-            traverse (n->template dynamic_type<T> ());
+            traverse (n);
             return true;
           }
           else
diff --git a/TAO/CIAO/CCF/CCF/IDL3/SyntaxTree/Operation.hpp b/TAO/CIAO/CCF/CCF/IDL3/SyntaxTree/Operation.hpp
index 17b8c46565b..913b73c33ac 100644
--- a/TAO/CIAO/CCF/CCF/IDL3/SyntaxTree/Operation.hpp
+++ b/TAO/CIAO/CCF/CCF/IDL3/SyntaxTree/Operation.hpp
@@ -38,7 +38,7 @@ namespace CCF
 
       public:
         InterfaceDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -86,7 +86,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -132,7 +132,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -179,7 +179,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
@@ -226,7 +226,7 @@ namespace CCF
 
       public:
         TypeDeclPtr
-        type ()
+        type () const
         {
           return type_.resolve ();
         }
diff --git a/TAO/CIAO/CCF/Documentation/TODO b/TAO/CIAO/CCF/Documentation/TODO
index 2c6ca5795da..a82edb08574 100644
--- a/TAO/CIAO/CCF/Documentation/TODO
+++ b/TAO/CIAO/CCF/Documentation/TODO
@@ -48,7 +48,7 @@ Legend:
    since scoped name in general case denotes a bunch of declarations. 
    Same for TypePrefix.
    
-@@ Perhaps add reference to declaration table to every SyntaxTree::Node 
+%% Perhaps add reference to declaration table to every SyntaxTree::Node 
    (and not just scopes).
 
 @@ Replace all i++ with ++i.
@@ -63,7 +63,7 @@ Legend:
 
 @%++ XML indentation buffer
 
-@@+++ Anonymous types and typedef's model (2)
+@%+++ Anonymous types and typedef's model (2)
 
 @@+++ Introduction (injection) of names into scope
 
@@ -79,9 +79,9 @@ Legend:
 
 %% IDL feature: built-in types
 
-@@ IDL feature: sequences; depends on 2,3
+@% IDL feature: sequences; depends on 2,3
 
-@@ IDL feature: struct
+%% IDL feature: struct
 
 @% IDL feature: oprations (completion)
 
diff --git a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/ExecutorMappingGenerator.cpp b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/ExecutorMappingGenerator.cpp
index bc8227271de..9ab4992a1e9 100644
--- a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/ExecutorMappingGenerator.cpp
+++ b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/ExecutorMappingGenerator.cpp
@@ -405,7 +405,7 @@ namespace
     traverse (ConsumesDeclPtr const& p)
     {
       os << "void push_" << p->name ().simple () << " ("
-         << "in " << p->type()->name () << " ev);";
+         << "in " << p->type ()->name () << " ev);";
     }
 
     virtual void
diff --git a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2.idl b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2.idl
index 64d65d1e7d1..f2ef0b00126 100644
--- a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2.idl
+++ b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2.idl
@@ -14,13 +14,23 @@ module M2
   };
 
   typedef sequence<octet> OctetSeq;
+
+  struct S
+  {
+    long l;
+    OctetSeq octet_seq;
+  };
+  
+  typedef sequence<S> S_Seq;
   
   home H2 : M1::H1 manages C2
   {
     attribute long l;
     attribute M::I i;
     attribute OctetSeq seq;
-    void foo (in long l, inout boolean b, out long ol, in M::I i, out unsigned long long ull);
+    attribute S_Seq s_seq;
+    
+    void foo (in long l, inout boolean b, out long ol, in M::I i, out unsigned long long ull, inout S_Seq s_seq);
     factory new (in long l, in OctetSeq s);
   };
 };
diff --git a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2_exec.idl.orig b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2_exec.idl.orig
index 7cffd205c67..19148a1b5f0 100644
--- a/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2_exec.idl.orig
+++ b/TAO/CIAO/CCF/Example/CIDL/LocalExecutorMapping/test-2_exec.idl.orig
@@ -58,7 +58,8 @@ module M2
     attribute long l;
     attribute ::M::I i;
     attribute ::M2::OctetSeq seq;
-    void foo (in long l, inout boolean b, out long ol, in ::M::I i, out unsigned long long ull);
+    attribute ::M2::S_Seq s_seq;
+    void foo (in long l, inout boolean b, out long ol, in ::M::I i, out unsigned long long ull, inout ::M2::S_Seq s_seq);
     ::Components::EnterpriseComponent new (in long l, in ::M2::OctetSeq s);
   };
 
diff --git a/TAO/CIAO/ChangeLog b/TAO/CIAO/ChangeLog
index a21320db5f2..1a8f7201c91 100644
--- a/TAO/CIAO/ChangeLog
+++ b/TAO/CIAO/ChangeLog
@@ -1,9 +1,51 @@
+Thu Oct 16 16:45:35 2003  Boris Kolpackov  <boris@dre.vanderbilt.edu>
+
+	* CCF/CCF/IDL2/LexicalAnalyzer.cpp:
+	* CCF/CCF/IDL2/Makefile.archive:
+	* CCF/CCF/IDL2/Parser.cpp:
+	* CCF/CCF/IDL2/Parser.hpp:
+	* CCF/CCF/IDL2/SemanticAction.hpp:
+	* CCF/CCF/IDL2/SyntaxTree.hpp:
+	* CCF/CCF/IDL2/Traversal.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Factory.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Member.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Struct.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Factory.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Interface.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Member.cpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Member.hpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Struct.cpp:
+	* CCF/CCF/IDL2/SemanticAction/Impl/Struct.hpp:
+	* CCF/CCF/IDL2/SyntaxTree/Makefile.alt:
+	* CCF/CCF/IDL2/SyntaxTree/Member.cpp:
+	* CCF/CCF/IDL2/SyntaxTree/Member.hpp:
+	* CCF/CCF/IDL2/SyntaxTree/Operation.hpp:
+	* CCF/CCF/IDL2/SyntaxTree/Struct.cpp:
+	* CCF/CCF/IDL2/SyntaxTree/Struct.hpp:
+	* CCF/CCF/IDL2/Traversal/Makefile.alt:
+	* CCF/CCF/IDL2/Traversal/Member.cpp:
+	* CCF/CCF/IDL2/Traversal/Member.hpp:
+	* CCF/CCF/IDL2/Traversal/Struct.cpp:
+	* CCF/CCF/IDL2/Traversal/Struct.hpp:
+	* CCF/CCF/IDL2/Traversal/Typedef.hpp:
+	* CCF/CCF/IDL3/SyntaxTree/Operation.hpp:
+	* CCF/Example/CIDL/LocalExecutorMapping/ExecutorMappingGenerator.cpp:
+	  Added support for struct.
+	
+
+	* CCF/Example/CIDL/LocalExecutorMapping/test-2.idl:
+	* CCF/Example/CIDL/LocalExecutorMapping/test-2_exec.idl.orig:
+	  Added a few structs for testing.
+
+	* CCF/Documentation/TODO: Marked some items as done or 
+	  partially done.
+
 Thu Oct 16 12:55:06 2003  Boris Kolpackov  <boris@dre.vanderbilt.edu>
 
 	* CCF/CCF/IDL2/SyntaxTree/ElementsCtor.cpp:
 	* CCF/CCF/IDL2/SyntaxTree/InterfaceCtor.cpp:
 	* CCF/CCF/IDL2/SyntaxTree/ValueTypeCtor.cpp: Added fake ctor
-	  definition for some compilers (like MSVC) that insist it 
+	  definition for some compilers (like MSVC) that insist they
 	  should be defined (even though never used).
 
 Thu Oct 16 12:07:01 2003  Boris Kolpackov  <boris@dre.vanderbilt.edu>