diff options
Diffstat (limited to 'CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Elements.hpp')
| -rw-r--r-- | CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Elements.hpp | 320 |
1 files changed, 320 insertions, 0 deletions
diff --git a/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Elements.hpp b/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Elements.hpp new file mode 100644 index 00000000000..51da2657b5d --- /dev/null +++ b/CIAO/CCF/CCF/IDL2/SemanticAction/Impl/Elements.hpp @@ -0,0 +1,320 @@ +// file : CCF/IDL2/SemanticAction/Impl/Elements.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL2_SEMANTIC_ACTION_IMPL_ELEMENTS_HPP +#define CCF_IDL2_SEMANTIC_ACTION_IMPL_ELEMENTS_HPP + +#include <stack> + +#include "CCF/IDL2/SemanticGraph/Translation.hpp" +#include "CCF/IDL2/SemanticGraph/IntExpression.hpp" + +#include "CCF/IDL2/SemanticAction/Elements.hpp" + +/* + Design notes: + + (1) I am using stack-based approach to handle cases like this: + + struct A + { + struct B + { + struct C + { + ... + } c; + + } b; + }; + + Even though you can't write the same let's say for interface + I am still using stack approach for consistency and possible + meta-coding. + +*/ + +namespace CCF +{ + namespace IDL2 + { + namespace SemanticAction + { + namespace Impl + { + + // + // + // + class Context + { + public: + Context (bool trace, + SemanticGraph::TranslationUnit& tu, + CompilerElements::Context& parsing_context) + : trace_ (trace), + tu_ (tu), + parsing_context_ (parsing_context) + { + } + + bool + trace () + { + return trace_; + } + + SemanticGraph::TranslationUnit& + tu () const + { + return tu_; + } + + SemanticGraph::Scope& + scope () const + { + return *scope_; + } + + void + scope (SemanticGraph::Scope& scope) + { + scope_ = &scope; + } + + SemanticGraph::TranslationRegion& + region () const + { + return *region_; + } + + void + region (SemanticGraph::TranslationRegion& r) + { + region_ = &r; + } + + CompilerElements::Context& + parsing_context () const + { + return parsing_context_; + } + + SemanticGraph::Path const& + file () const + { + return parsing_context_.get<SemanticGraph::Path> ("file-path"); + } + + public: + void + int_exp_push (SemanticGraph::IntExpression& e) + { + int_exp_stack_.push (&e); + } + + SemanticGraph::IntExpression& + int_exp_pop () + { + SemanticGraph::IntExpression& e (*int_exp_stack_.top ()); + int_exp_stack_.pop (); + return e; + } + + std::size_t + int_exp_size () + { + return int_exp_stack_.size (); + } + + void + int_exp_flush () + { + while (int_exp_stack_.size ()) + int_exp_stack_.pop (); + } + + private: + bool trace_; + SemanticGraph::TranslationUnit& tu_; + SemanticGraph::TranslationRegion* region_; + SemanticGraph::Scope* scope_; + + CompilerElements::Context& parsing_context_; + + std::stack<SemanticGraph::IntExpression*> int_exp_stack_; + + private: + Context (Context const&); + void operator= (Context const&); + }; + + + // + // + // + class Base + { + protected: + virtual + ~Base () + { + } + + Base (Context& c) + : ctx (c) + { + } + + protected: + + class Resolve {}; + + template <typename Id> + struct ExceptionTemplate : Resolve + { + explicit + ExceptionTemplate (SemanticGraph::ScopedName name) + : name_ (name) + { + } + + SemanticGraph::ScopedName + name () const + { + return name_; + } + + private: + SemanticGraph::ScopedName name_; + }; + + + struct NotFound : Resolve {}; + + class WrongType_ {}; + typedef ExceptionTemplate<WrongType_> WrongType; + + class NotUnique : Resolve {}; + + class NotDefined_ {}; + typedef ExceptionTemplate<NotDefined_> NotDefined; + + class NotComplete_ {}; + typedef ExceptionTemplate<NotComplete_> NotComplete; + + struct Flags + { + enum Value + { + none = 0x00, + complete = 0x01, + defined = 0x02 + }; + }; + + template <typename T> + T& + resolve (SemanticGraph::ScopedName const& from, + SemanticGraph::Name const& name, + Flags::Value flags = Flags::none) + throw (NotFound, NotUnique, WrongType, NotDefined, NotComplete); + + + class AlreadyInherited_ {}; + typedef ExceptionTemplate<AlreadyInherited_> AlreadyInherited; + + class AlreadySupported_ {}; + typedef ExceptionTemplate<AlreadySupported_> AlreadySupported; + + template<typename I> + void + check_inheritance (I begin, I end, SemanticGraph::Nameable& t) + throw (AlreadyInherited); + + template<typename I> + void + check_support (I begin, I end, SemanticGraph::Nameable& t) + throw (AlreadySupported); + + protected: + Context& ctx; + }; + + + // + // + // + template <typename T> + class ScopeBase : public Base + { + protected: + ScopeBase (Context& c) + : Base (c) + { + } + + protected: + T& + now () const + { + return *now_; + } + + void + now (T& t) + { + now_ = &t; + } + + void + push (SemanticGraph::Scope& t) + { + stack_.push (&t); + } + + void + pop () + { + stack_.pop (); + } + + SemanticGraph::Scope& + top () + { + return *stack_.top (); + } + + private: + T* now_; + std::stack<SemanticGraph::Scope*> stack_; + }; + + + // + // + // + class NotFound {}; + class NotUnique {}; + + SemanticGraph::Nameables + resolve (SemanticGraph::TranslationUnit& tu, + SemanticGraph::ScopedName const& from, + SemanticGraph::Name const& name) throw (NotFound); + + + + + SemanticGraph::Nameable* + lookup (SemanticGraph::TranslationUnit& tu, + SemanticGraph::Scope& in, + SemanticGraph::SimpleName const& name) throw (NotUnique); + } + } + } +} + +#include "CCF/IDL2/SemanticAction/Impl/Elements.tpp" + +#endif // CCF_IDL2_SEMANTIC_ACTION_IMPL_ELEMENTS_HPP |