webrtc 音视频库 头文件

//===------------------------- ItaniumDemangle.h ----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Generic itanium demangler library. This file has two byte-per-byte identical // copies in the source tree, one in libcxxabi, and the other in llvm. // //===----------------------------------------------------------------------===// #ifndef DEMANGLE_ITANIUMDEMANGLE_H #define DEMANGLE_ITANIUMDEMANGLE_H // FIXME: (possibly) incomplete list of features that clang mangles that this // file does not yet support: // - C++ modules TS #include "DemangleConfig.h" #include "StringView.h" #include "Utility.h" #include <cassert> #include <cctype> #include <cstdio> #include <cstdlib> #include <cstring> #include <numeric> #include <utility> #define FOR_EACH_NODE_KIND(X) \ X(NodeArrayNode) \ X(DotSuffix) \ X(VendorExtQualType) \ X(QualType) \ X(ConversionOperatorType) \ X(PostfixQualifiedType) \ X(ElaboratedTypeSpefType) \ X(NameType) \ X(AbiTagAttr) \ X(EnableIfAttr) \ X(ObjCProtoName) \ X(PointerType) \ X(ReferenceType) \ X(PointerToMemberType) \ X(ArrayType) \ X(FunctionType) \ X(NoexceptSpec) \ X(DynamicExceptionSpec) \ X(FunctionEncoding) \ X(LiteralOperator) \ X(SpecialName) \ X(CtorVtableSpecialName) \ X(QualifiedName) \ X(NestedName) \ X(LocalName) \ X(VectorType) \ X(PixelVectorType) \ X(BinaryFPType) \ X(SyntheticTemplateParamName) \ X(TypeTemplateParamDecl) \ X(NonTypeTemplateParamDecl) \ X(TemplateTemplateParamDecl) \ X(TemplateParamPackDecl) \ X(ParameterPack) \ X(TemplateArgumentPack) \ X(ParameterPackExpansion) \ X(TemplateArgs) \ X(ForwardTemplateReference) \ X(NameWithTemplateArgs) \ X(GlobalQualifiedName) \ X(StdQualifiedName) \ X(ExpandedSpecialSubstitution) \ X(SpecialSubstitution) \ X(CtorDtorName) \ X(DtorName) \ X(UnnamedTypeName) \ X(ClosureTypeName) \ X(StructuredBindingName) \ X(BinaryExpr) \ X(ArraySubscriptExpr) \ X(PostfixExpr) \ X(ConditionalExpr) \ X(MemberExpr) \ X(SubobjectExpr) \ X(EnclosingExpr) \ X(CastExpr) \ X(SizeofParamPackExpr) \ X(CallExpr) \ X(NewExpr) \ X(DeleteExpr) \ X(PrefixExpr) \ X(FunctionParam) \ X(ConversionExpr) \ X(PointerToMemberConversionExpr) \ X(InitListExpr) \ X(FoldExpr) \ X(ThrowExpr) \ X(BoolExpr) \ X(StringLiteral) \ X(LambdaExpr) \ X(EnumLiteral) \ X(IntegerLiteral) \ X(FloatLiteral) \ X(DoubleLiteral) \ X(LongDoubleLiteral) \ X(BracedExpr) \ X(BracedRangeExpr) DEMANGLE_NAMESPACE_BEGIN template <class T, size_t N> class PODSmallVector { static_assert(std::is_pod<T>::value, "T is required to be a plain old data type"); T *First = nullptr; T *Last = nullptr; T *Cap = nullptr; T Inline[N] = {0}; bool isInline() const { return First == Inline; } void clearInline() { First = Inline; Last = Inline; Cap = Inline + N; } void reserve(size_t NewCap) { size_t S = size(); if (isInline()) { auto *Tmp = static_cast<T *>(std::malloc(NewCap * sizeof(T))); if (Tmp == nullptr) std::terminate(); std::copy(First, Last, Tmp); First = Tmp; } else { First = static_cast<T *>(std::realloc(First, NewCap * sizeof(T))); if (First == nullptr) std::terminate(); } Last = First + S; Cap = First + NewCap; } public: PODSmallVector() : First(Inline), Last(First), Cap(Inline + N) {} PODSmallVector(const PODSmallVector &) = delete; PODSmallVector &operator=(const PODSmallVector &) = delete; PODSmallVector(PODSmallVector &&Other) : PODSmallVector() { if (Other.isInline()) { std::copy(Other.begin(), Other.end(), First); Last = First + Other.size(); Other.clear(); return; } First = Other.First; Last = Other.Last; Cap = Other.Cap; Other.clearInline(); } PODSmallVector &operator=(PODSmallVector &&Other) { if (Other.isInline()) { if (!isInline()) { std::free(First); clearInline(); } std::copy(Other.begin(), Other.end(), First); Last = First + Other.size(); Other.clear(); return *this; } if (isInline()) { First = Other.First; Last = Other.Last; Cap = Other.Cap; Other.clearInline(); return *this; } std::swap(First, Other.First); std::swap(Last, Other.Last); std::swap(Cap, Other.Cap); Other.clear(); return *this; } // NOLINTNEXTLINE(readability-identifier-naming) void push_back(const T &Elem) { if (Last == Cap) reserve(size() * 2); *Last++ = Elem; } // NOLINTNEXTLINE(readability-identifier-naming) void pop_back() { assert(Last != First && "Popping empty vector!"); --Last; } void dropBack(size_t Index) { assert(Index <= size() && "dropBack() can't expand!"); Last = First + Index; } T *begin() { return First; } T *end() { return Last; } bool empty() const { return First == Last; } size_t size() const { return static_cast<size_t>(Last - First); } T &back() { assert(Last != First && "Calling back() on empty vector!"); return *(Last - 1); } T &operator[](size_t Index) { assert(Index < size() && "Invalid access!"); return *(begin() + Index); } void clear() { Last = First; } ~PODSmallVector() { if (!isInline()) std::free(First); } }; // Base class of all AST nodes. The AST is built by the parser, then is // traversed by the printLeft/Right functions to produce a demangled string. class Node { public: enum Kind : unsigned char { #define ENUMERATOR(NodeKind) K ## NodeKind, FOR_EACH_NODE_KIND(ENUMERATOR) #undef ENUMERATOR }; /// Three-way bool to track a cached value. Unknown is possible if this node /// has an unexpanded parameter pack below it that may affect this cache. enum class Cache : unsigned char { Yes, No, Unknown, }; private: Kind K; // FIXME: Make these protected. public: /// Tracks if this node has a component on its right side, in which case we /// need to call printRight. Cache RHSComponentCache; /// Track if this node is a (possibly qualified) array type. This can affect /// how we format the output string. Cache ArrayCache; /// Track if this node is a (possibly qualified) function type. This can /// affect how we format the output string. Cache FunctionCache; public: Node(Kind K_, Cache RHSComponentCache_ = Cache::No, Cache ArrayCache_ = Cache::No, Cache FunctionCache_ = Cache::No) : K(K_), RHSComponentCache(RHSComponentCache_), ArrayCache(ArrayCache_), FunctionCache(FunctionCache_) {} /// Visit the most-derived object corresponding to this object. template<typename Fn> void visit(Fn F) const; // The following function is provided by all derived classes: // // Call F with arguments that, when passed to the constructor of this node, // would construct an equivalent node. //template<typename Fn> void match(Fn F) const; bool hasRHSComponent(OutputStream &S) const { if (RHSComponentCache != Cache::Unknown) return RHSComponentCache == Cache::Yes; return hasRHSComponentSlow(S); } bool hasArray(OutputStream &S) const { if (ArrayCache != Cache::Unknown) return ArrayCac