summaryrefslogtreecommitdiff
path: root/TAO/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Typedef.hpp
blob: 95c1403ae4391e626cabbd61ef6d72ca34788e8b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
// file      : CCF/IDL2/SemanticAction/Impl/Typedef.hpp
// author    : Boris Kolpackov <boris@dre.vanderbilt.edu>
// cvs-id    : $Id$

#ifndef CCF_IDL2_SEMANTIC_ACTION_IMPL_TYPEDEF_HPP
#define CCF_IDL2_SEMANTIC_ACTION_IMPL_TYPEDEF_HPP

#include "CCF/IDL2/SyntaxTree/Typedef.hpp"
#include "CCF/IDL2/SemanticAction/Typedef.hpp"

namespace CCF
{
  namespace IDL2
  {
    namespace SemanticAction
    {
      namespace Impl
      {
        //
        //
        //
        class Typedef : public virtual SemanticAction::Typedef
        {
        public:
          virtual
          ~Typedef () throw () {}

          Typedef (bool trace, SyntaxTree::ScopePtr& current)
              : trace_ (trace),
                scope_ (current),
                type_ ("::") //@@ this is dirty
          {
          }

          virtual void
          begin (IdentifierPtr const& id)
          {
            if (trace_) cerr << "typedef " << id << endl;

            using namespace SyntaxTree;

            Name name (id->lexeme ());

            struct Predicate : public DeclarationTable::ResolvePredicate
            {
              virtual bool
              test (DeclarationPtr const& d) const throw ()
              {
                return d->is_a<TypeDecl> ();
              }
            } p;

            try
            {
              type_ = scope_->table ().resolve (
                name,
                scope_->name (),
                scope_->peek_order (),
                p);
            }
            catch (DeclarationTable::NameNotFound const&)
            {
              cerr << "error: invalid typedef declaration" << endl;
              cerr << "no type with name \'"
                   << name << "\' visible from scope \'"
                   << scope_->name () << "\'" << endl;
            }
            catch (DeclarationTable::PredicateNotMet const&)
            {
              cerr << "error: invalid typedef declaration" << endl;
              cerr << "no 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 ("::"))
            {
              TypedefDeclPtr typedef_ (
                new TypedefDecl (SimpleName (id->lexeme ()),
                                 type_,
                                 scope_));


              scope_->insert (typedef_);
            }
          }

          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_TYPEDEF_HPP