diff options
Diffstat (limited to 'CIAO/CCF/CCF/IDL2/Parsing/Recovery.hpp')
| -rw-r--r-- | CIAO/CCF/CCF/IDL2/Parsing/Recovery.hpp | 325 |
1 files changed, 325 insertions, 0 deletions
diff --git a/CIAO/CCF/CCF/IDL2/Parsing/Recovery.hpp b/CIAO/CCF/CCF/IDL2/Parsing/Recovery.hpp new file mode 100644 index 00000000000..d8b3739b335 --- /dev/null +++ b/CIAO/CCF/CCF/IDL2/Parsing/Recovery.hpp @@ -0,0 +1,325 @@ +// file : CCF/IDL2/Parsing/Recovery.hpp +// author : Boris Kolpackov <boris@dre.vanderbilt.edu> +// cvs-id : $Id$ + +#ifndef CCF_IDL2_PARSING_RECOVERY_HPP +#define CCF_IDL2_PARSING_RECOVERY_HPP + +#include <memory> + +#include "CCF/CompilerElements/ReferenceCounting.hpp" +#include "CCF/IDL2/Parsing/Elements.hpp" + +namespace CCF +{ + namespace IDL2 + { + namespace Parsing + { + + // + // + // + struct RecoveryMethod + { + enum Value + { + NONE, + STANDARD, + BAIL_OUT + }; + }; + + + // + // + // + struct DiagnosticType + { + enum Value + { + BEFORE, + AFTER, + NONE + }; + }; + + + // + // + // + class Thunk + { + public: + virtual + ~Thunk () {} + + virtual void + execute () = 0; + + virtual Thunk* + clone () const = 0; + }; + + + // + // + // + template<typename Object> + class ThunkImpl : public Thunk + { + public: + typedef void (Object::*Func)(); + + ThunkImpl (Object& obj, Func func) + : obj_(obj), + func_ (func) + { + } + + virtual void + execute () + { + (obj_.*func_)(); + } + + virtual Thunk* + clone () const + { + return new ThunkImpl<Object> (obj_, func_); + } + + private: + Object& obj_; + Func func_; + }; + + // + // + // + template<typename Object> + Thunk* + call_thunk (Object& obj, void (Object::*func)()) + { + return new ThunkImpl<Object> (obj, func); + } + + + // + // + // + struct RecoveryDescriptor : + public virtual ReferenceCounting::DefaultImpl <> + { + virtual ~RecoveryDescriptor () throw () {} + + RecoveryDescriptor (std::string d, + RecoveryMethod::Value recovery, + DiagnosticType::Value diagnostic) + : action_one_ (0), + action_two_ (0), + description_ (d), + recovery_ (recovery), + diagnostic_ (diagnostic) + { + } + + template<typename Object> + RecoveryDescriptor (std::string d, + RecoveryMethod::Value recovery, + DiagnosticType::Value diagnostic, + Object& obj, + void (Object::*action_one)()) + : action_one_ (call_thunk (obj, action_one)), + action_two_ (0), + description_ (d), + recovery_ (recovery), + diagnostic_ (diagnostic) + { + } + + template<typename Object> + RecoveryDescriptor (std::string d, + RecoveryMethod::Value recovery, + DiagnosticType::Value diagnostic, + Object& obj, + void (Object::*action_one)(), + void (Object::*action_two)()) + : action_one_ (call_thunk (obj, action_one)), + action_two_ (call_thunk (obj, action_two)), + description_ (d), + recovery_ (recovery), + diagnostic_ (diagnostic) + { + } + + RecoveryDescriptor (RecoveryDescriptor const& rd) + : action_one_ (rd.action_one_.get () ? rd.action_one_->clone () : 0), + action_two_ (rd.action_two_.get () ? rd.action_two_->clone () : 0), + description_ (rd.description_), + recovery_ (rd.recovery_), + diagnostic_ (rd.diagnostic_) + { + } + + + std::auto_ptr<Thunk> action_one_; + std::auto_ptr<Thunk> action_two_; + std::string description_; + RecoveryMethod::Value recovery_; + DiagnosticType::Value diagnostic_; + }; + + typedef + ReferenceCounting::StrictPtr<RecoveryDescriptor> + RecoveryDescriptorPtr; + + + // I have to use a pointer to RecoveryDescriptor instead of + // just RecoveryDescriptor to subvert constness of descriptor + // member in spirit::parser_error. + // + // + + typedef + parser_error<RecoveryDescriptorPtr, Iterator> + Error; + + + // + // + // + struct Assertion + { + typedef + assertion<RecoveryDescriptorPtr> + AssertionImpl; + + AssertionImpl + operator () (RecoveryMethod::Value recovery = RecoveryMethod::NONE) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ("", recovery, DiagnosticType::NONE))); + } + + AssertionImpl + operator () (std::string d, + RecoveryMethod::Value recovery = RecoveryMethod::STANDARD, + DiagnosticType::Value diagnostic = DiagnosticType::AFTER) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor (d, recovery, diagnostic))); + } + + AssertionImpl + operator () (std::string d, + DiagnosticType::Value diagnostic) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + d, RecoveryMethod::STANDARD, diagnostic))); + } + + template<typename Object> + AssertionImpl + operator () (std::string d, + Object& obj, + void (Object::*action_one)(), + RecoveryMethod::Value recovery = RecoveryMethod::STANDARD, + DiagnosticType::Value diagnostic = DiagnosticType::AFTER) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + d, recovery, diagnostic, obj, action_one))); + } + + template<typename Object> + AssertionImpl + operator () (std::string d, + Object& obj, + void (Object::*action_one)(), + DiagnosticType::Value diagnostic) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + d, RecoveryMethod::STANDARD, diagnostic, obj, action_one))); + } + + template<typename Object> + AssertionImpl + operator () (Object& obj, + void (Object::*action_one)(), + RecoveryMethod::Value recovery = RecoveryMethod::BAIL_OUT) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + "", recovery, DiagnosticType::NONE, obj, action_one))); + } + + template<typename Object> + AssertionImpl + operator () (std::string d, + Object& obj, + void (Object::*action_one)(), + void (Object::*action_two)(), + RecoveryMethod::Value recovery = RecoveryMethod::STANDARD, + DiagnosticType::Value diagnostic = DiagnosticType::AFTER) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + d, recovery, diagnostic, obj, action_one, action_two))); + } + + template<typename Object> + AssertionImpl + operator () (std::string d, + Object& obj, + void (Object::*action_one)(), + void (Object::*action_two)(), + DiagnosticType::Value diagnostic) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ( + d, RecoveryMethod::STANDARD, diagnostic, obj, action_one, action_two))); + } + + + template<typename Object> + AssertionImpl + operator () (Object& obj, + void (Object::*action_one)(), + void (Object::*action_two)(), + RecoveryMethod::Value recovery = RecoveryMethod::BAIL_OUT) + { + return AssertionImpl ( + RecoveryDescriptorPtr ( + new RecoveryDescriptor ("", + recovery, + DiagnosticType::NONE, + obj, + action_one, + action_two))); + } + + }; + + typedef + error_status<> + RecoveryStatus; + + typedef + guard<RecoveryDescriptorPtr> + Guard; + } + } +} + +#endif // CCF_IDL2_PARSING_RECOVERY_HPP |