diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/clang/Parse/Ownership.h | 208 | ||||
| -rw-r--r-- | include/clang/Parse/Parser.h | 4 |
2 files changed, 118 insertions, 94 deletions
diff --git a/include/clang/Parse/Ownership.h b/include/clang/Parse/Ownership.h index fc27605071..e2464ca8da 100644 --- a/include/clang/Parse/Ownership.h +++ b/include/clang/Parse/Ownership.h @@ -83,50 +83,49 @@ namespace clang /// the individual pointers, not the array holding them. template <ASTDestroyer Destroyer> class ASTMultiPtr; - /// Move emulation helper for ASTOwningResult - template <ASTDestroyer Destroyer> - class ASTResultMover - { - ASTOwningResult<Destroyer> &Moved; + namespace moving { + /// Move emulation helper for ASTOwningResult. NEVER EVER use this class + /// directly if you don't know what you're doing. + template <ASTDestroyer Destroyer> + class ASTResultMover + { + ASTOwningResult<Destroyer> &Moved; - public: - ASTResultMover(ASTOwningResult<Destroyer> &moved) : Moved(moved) {} + public: + ASTResultMover(ASTOwningResult<Destroyer> &moved) : Moved(moved) {} - ASTOwningResult<Destroyer> * operator ->() { return &Moved; } + ASTOwningResult<Destroyer> * operator ->() { return &Moved; } + }; - // For the transition phase. - operator void*(); + /// Move emulation helper for ASTOwningPtr. NEVER EVER use this class + /// directly if you don't know what you're doing. + template <ASTDestroyer Destroyer> + class ASTPtrMover + { + ASTOwningPtr<Destroyer> &Moved; - // For the transition phase. - operator ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID>(); - }; + public: + ASTPtrMover(ASTOwningPtr<Destroyer> &moved) : Moved(moved) {} - /// Move emulation helper for ASTOwningPtr - template <ASTDestroyer Destroyer> - class ASTPtrMover - { - ASTOwningPtr<Destroyer> &Moved; - - public: - ASTPtrMover(ASTOwningPtr<Destroyer> &moved) : Moved(moved) {} + ASTOwningPtr<Destroyer> * operator ->() { return &Moved; } + }; - ASTOwningPtr<Destroyer> * operator ->() { return &Moved; } + /// Move emulation helper for ASTMultiPtr. NEVER EVER use this class + /// directly if you don't know what you're doing. + template <ASTDestroyer Destroyer> + class ASTMultiMover + { + ASTMultiPtr<Destroyer> &Moved; - operator void*(); - }; + public: + ASTMultiMover(ASTMultiPtr<Destroyer> &moved) : Moved(moved) {} - /// Move emulation helper for ASTMultiPtr - template <ASTDestroyer Destroyer> - class ASTMultiMover - { - ASTMultiPtr<Destroyer> &Moved; + ASTMultiPtr<Destroyer> * operator ->() { return &Moved; } - public: - ASTMultiMover(ASTMultiPtr<Destroyer> &moved) : Moved(moved) {} - - /// Reset the moved object's internal structures. - void release(); - }; + /// Reset the moved object's internal structures. + void release(); + }; + } template <ASTDestroyer Destroyer> class ASTOwningResult @@ -135,11 +134,11 @@ namespace clang void *Node; bool Invalid; - friend class ASTResultMover<Destroyer>; + friend class moving::ASTResultMover<Destroyer>; friend class ASTOwningPtr<Destroyer>; - ASTOwningResult(const ASTOwningResult&); // DO NOT IMPLEMENT - ASTOwningResult& operator =(const ASTOwningResult&); // DO NOT IMPLEMENT + ASTOwningResult(ASTOwningResult&); // DO NOT IMPLEMENT + ASTOwningResult& operator =(ASTOwningResult&); // DO NOT IMPLEMENT void destroy() { if (Node) { @@ -148,12 +147,6 @@ namespace clang } } - void * take() { - if (Invalid) - return 0; - return Node; - } - public: typedef ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID> DumbResult; @@ -170,13 +163,13 @@ namespace clang ASTOwningResult(ActionBase &actions, const DumbResult &res) : Actions(&actions), Node(res.Val), Invalid(res.isInvalid) {} /// Move from another owning result - ASTOwningResult(ASTResultMover<Destroyer> mover) + ASTOwningResult(moving::ASTResultMover<Destroyer> mover) : Actions(mover->Actions), Node(mover->take()), Invalid(mover->Invalid) {} /// Move from an owning pointer - ASTOwningResult(ASTPtrMover<Destroyer> mover); + ASTOwningResult(moving::ASTPtrMover<Destroyer> mover); /// Move assignment from another owning result - ASTOwningResult & operator =(ASTResultMover<Destroyer> mover) { + ASTOwningResult & operator =(moving::ASTResultMover<Destroyer> mover) { Actions = mover->Actions; Node = mover->take(); Invalid = mover->Invalid; @@ -184,7 +177,7 @@ namespace clang } /// Move assignment from an owning ptr - ASTOwningResult & operator =(ASTPtrMover<Destroyer> mover); + ASTOwningResult & operator =(moving::ASTPtrMover<Destroyer> mover); /// Assignment from a raw pointer. Takes ownership - beware! ASTOwningResult & operator =(void *raw) @@ -214,9 +207,30 @@ namespace clang /// valid and non-null. bool isUsable() const { return !Invalid && Node; } + /// Take outside ownership of the raw pointer. + void * take() { + if (Invalid) + return 0; + void *tmp = Node; + Node = 0; + return tmp; + } + + /// Alias for interface familiarity with unique_ptr. + void * release() { + return take(); + } + + /// Pass ownership to a classical ActionResult. + DumbResult result() { + if (Invalid) + return true; + return Node; + } + /// Move hook - ASTResultMover<Destroyer> move() { - return ASTResultMover<Destroyer>(*this); + operator moving::ASTResultMover<Destroyer>() { + return moving::ASTResultMover<Destroyer>(*this); } }; @@ -226,11 +240,11 @@ namespace clang ActionBase *Actions; void *Node; - friend class ASTPtrMover<Destroyer>; + friend class moving::ASTPtrMover<Destroyer>; friend class ASTOwningResult<Destroyer>; - ASTOwningPtr(const ASTOwningPtr&); // DO NOT IMPLEMENT - ASTOwningPtr& operator =(const ASTOwningPtr&); // DO NOT IMPLEMENT + ASTOwningPtr(ASTOwningPtr&); // DO NOT IMPLEMENT + ASTOwningPtr& operator =(ASTOwningPtr&); // DO NOT IMPLEMENT void destroy() { if (Node) { @@ -245,20 +259,20 @@ namespace clang ASTOwningPtr(ActionBase &actions, void *node) : Actions(&actions), Node(node) {} /// Move from another owning pointer - ASTOwningPtr(ASTPtrMover<Destroyer> mover) + ASTOwningPtr(moving::ASTPtrMover<Destroyer> mover) : Actions(mover->Actions), Node(mover->take()) {} /// Move from an owning result - ASTOwningPtr(ASTResultMover<Destroyer> mover); + ASTOwningPtr(moving::ASTResultMover<Destroyer> mover); /// Move assignment from another owning pointer - ASTOwningPtr & operator =(ASTPtrMover<Destroyer> mover) { + ASTOwningPtr & operator =(moving::ASTPtrMover<Destroyer> mover) { Actions = mover->Actions; Node = mover->take(); return *this; } /// Move assignment from an owning result - ASTOwningPtr & operator =(ASTResultMover<Destroyer> mover); + ASTOwningPtr & operator =(moving::ASTResultMover<Destroyer> mover); /// Assignment from a raw pointer. Takes ownership - beware! ASTOwningPtr & operator =(void *raw) @@ -271,9 +285,21 @@ namespace clang /// Access to the raw pointer. void * get() const { return Node; } + /// Release the raw pointer. + void * take() { + void *tmp = Node; + Node = 0; + return tmp; + } + + /// Alias for interface familiarity with unique_ptr. + void * release() { + return take(); + } + /// Move hook - ASTPtrMover<Destroyer> move() { - return ASTPtrMover<Destroyer>(*this); + operator moving::ASTPtrMover<Destroyer>() { + return moving::ASTPtrMover<Destroyer>(*this); } }; @@ -284,9 +310,9 @@ namespace clang void **Nodes; unsigned Count; - friend class ASTMultiMover<Destroyer>; + friend class moving::ASTMultiMover<Destroyer>; - ASTMultiPtr(const ASTMultiPtr&); // DO NOT IMPLEMENT + ASTMultiPtr(ASTMultiPtr&); // DO NOT IMPLEMENT // Reference member prevents copy assignment. void destroy() { @@ -303,15 +329,14 @@ namespace clang ASTMultiPtr(ActionBase &actions, void **nodes, unsigned count) : Actions(actions), Nodes(nodes), Count(count) {} /// Move constructor - ASTMultiPtr(ASTMultiMover<Destroyer> mover) + ASTMultiPtr(moving::ASTMultiMover<Destroyer> mover) : Actions(mover->Actions), Nodes(mover->Nodes), Count(mover->Count) { - mover->Nodes = 0; - mover->Count = 0; + mover.release(); } /// Move assignment - ASTMultiPtr & operator =(ASTMultiMover<Destroyer> mover) { - Actions = mover->Actions; + ASTMultiPtr & operator =(moving::ASTMultiMover<Destroyer> mover) { + destroy(); Nodes = mover->Nodes; Count = mover->Count; mover.release(); @@ -325,45 +350,27 @@ namespace clang unsigned size() const { return Count; } /// Move hook - ASTMultiMover<Destroyer> move() { - return ASTMultiMover<Destroyer>(*this); + operator moving::ASTMultiMover<Destroyer>() { + return moving::ASTMultiMover<Destroyer>(*this); } }; // Out-of-line implementations due to definition dependencies template <ASTDestroyer Destroyer> inline - ASTResultMover<Destroyer>::operator void*() { - return Moved.take(); - } - - template <ASTDestroyer Destroyer> inline - ASTResultMover<Destroyer>::operator - ActionBase::ActionResult<DestroyerToUID<Destroyer>::UID>() - { - if(Moved.isInvalid()) - return true; - return Moved.take(); - } - - template <ASTDestroyer Destroyer> inline - ASTPtrMover<Destroyer>::operator void*() { - return Moved.take(); - } - - template <ASTDestroyer Destroyer> inline - void ASTMultiMover<Destroyer>::release() { + void moving::ASTMultiMover<Destroyer>::release() { Moved.Nodes = 0; Moved.Count = 0; } template <ASTDestroyer Destroyer> inline - ASTOwningResult<Destroyer>::ASTOwningResult(ASTPtrMover<Destroyer> mover) + ASTOwningResult<Destroyer>::ASTOwningResult( + moving::ASTPtrMover<Destroyer> mover) : Actions(mover->Actions), Node(mover->take()), Invalid(false) {} template <ASTDestroyer Destroyer> inline ASTOwningResult<Destroyer> & - ASTOwningResult<Destroyer>::operator =(ASTPtrMover<Destroyer> mover) { + ASTOwningResult<Destroyer>::operator =(moving::ASTPtrMover<Destroyer> mover) { Actions = mover->Actions; Node = mover->take(); Invalid = false; @@ -371,17 +378,34 @@ namespace clang } template <ASTDestroyer Destroyer> inline - ASTOwningPtr<Destroyer>::ASTOwningPtr(ASTResultMover<Destroyer> mover) + ASTOwningPtr<Destroyer>::ASTOwningPtr(moving::ASTResultMover<Destroyer> mover) : Actions(mover->Actions), Node(mover->take()) { } template <ASTDestroyer Destroyer> inline ASTOwningPtr<Destroyer> & - ASTOwningPtr<Destroyer>::operator =(ASTResultMover<Destroyer> mover) { + ASTOwningPtr<Destroyer>::operator =(moving::ASTResultMover<Destroyer> mover) { Actions = mover->Actions; Node = mover->take(); return *this; } + + // Move overloads. + + template <ASTDestroyer Destroyer> inline + ASTOwningResult<Destroyer> move(ASTOwningResult<Destroyer> &ptr) { + return ASTOwningResult<Destroyer>(moving::ASTResultMover<Destroyer>(ptr)); + } + + template <ASTDestroyer Destroyer> inline + ASTOwningPtr<Destroyer> move(ASTOwningPtr<Destroyer> &ptr) { + return ASTOwningPtr<Destroyer>(moving::ASTPtrMover<Destroyer>(ptr)); + } + + template <ASTDestroyer Destroyer> inline + ASTMultiPtr<Destroyer> move(ASTMultiPtr<Destroyer> &ptr) { + return ASTMultiPtr<Destroyer>(moving::ASTMultiMover<Destroyer>(ptr)); + } } #endif diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index dedad120ba..ffd70a8971 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -379,8 +379,8 @@ private: DeclTy *ParseDeclarationOrFunctionDefinition(); DeclTy *ParseFunctionDefinition(Declarator &D); void ParseKNRParamDeclarations(Declarator &D); - ExprResult ParseSimpleAsm(); - ExprResult ParseAsmStringLiteral(); + OwningExprResult ParseSimpleAsm(); + OwningExprResult ParseAsmStringLiteral(); // Objective-C External Declarations DeclTy *ParseObjCAtDirectives(); |