16#ifndef DEMANGLE_ITANIUMDEMANGLE_H
17#define DEMANGLE_ITANIUMDEMANGLE_H
37 static_assert(std::is_pod<T>::value,
38 "T is required to be a plain old data type");
45 bool isInline()
const {
return First == Inline; }
53 void reserve(
size_t NewCap) {
56 auto *Tmp =
static_cast<T *
>(std::malloc(NewCap *
sizeof(
T)));
59 std::copy(First, Last, Tmp);
62 First =
static_cast<T *
>(std::realloc(First, NewCap *
sizeof(
T)));
77 if (
Other.isInline()) {
79 Last = First +
Other.size();
91 if (
Other.isInline()) {
97 Last = First +
Other.size();
126 assert(Last != First &&
"Popping empty vector!");
132 Last = First +
Index;
138 bool empty()
const {
return First == Last; }
139 size_t size()
const {
return static_cast<size_t>(Last - First); }
141 assert(Last != First &&
"Calling back() on empty vector!");
161#define NODE(NodeKind) K##NodeKind,
162#include "ItaniumNodes.def"
225 template<
typename Fn>
void visit(Fn
F)
const;
266 bool StrictlyWorse =
false)
const {
308 : Elements(Elements_), NumElements(NumElements_) {}
310 bool empty()
const {
return NumElements == 0; }
311 size_t size()
const {
return NumElements; }
314 Node **
end()
const {
return Elements + NumElements; }
319 bool FirstElement =
true;
320 for (
size_t Idx = 0;
Idx != NumElements; ++
Idx) {
321 size_t BeforeComma = OB.getCurrentPosition();
324 size_t AfterComma = OB.getCurrentPosition();
329 if (AfterComma == OB.getCurrentPosition()) {
330 OB.setCurrentPosition(BeforeComma);
334 FirstElement =
false;
350 const std::string_view Suffix;
354 :
Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
356 template<
typename Fn>
void match(Fn
F)
const {
F(Prefix, Suffix); }
368 std::string_view Ext;
373 :
Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
376 std::string_view
getExt()
const {
return Ext; }
379 template <
typename Fn>
void match(Fn
F)
const {
F(Ty, Ext, TA); }
455 :
Node(KConversionOperatorType), Ty(Ty_) {}
457 template<
typename Fn>
void match(Fn
F)
const {
F(Ty); }
467 const std::string_view Postfix;
471 :
Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
473 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Postfix); }
482 const std::string_view Name;
487 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
489 std::string_view
getName()
const {
return Name; }
501 :
Node(KBitIntType), Size(Size_), Signed(Signed_) {}
503 template <
typename Fn>
void match(Fn
F)
const {
F(Size, Signed); }
510 Size->printAsOperand(OB);
516 std::string_view
Kind;
520 :
Node(KElaboratedTypeSpefType),
Kind(Kind_), Child(Child_) {}
556 :
Node(KEnableIfAttr), Conditions(Conditions_) {}
558 template<
typename Fn>
void match(Fn
F)
const {
F(Conditions); }
561 OB +=
" [enable_if:";
569 std::string_view Protocol;
575 :
Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
577 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Protocol); }
580 return Ty->
getKind() == KNameType &&
602 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee); }
605 return Pointee->hasRHSComponent(OB);
610 if (Pointee->getKind() != KObjCProtoName ||
612 Pointee->printLeft(OB);
613 if (Pointee->hasArray(OB))
615 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
619 const auto *objcProto =
static_cast<const ObjCProtoName *
>(Pointee);
621 OB += objcProto->Protocol;
627 if (Pointee->getKind() != KObjCProtoName ||
629 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
631 Pointee->printRight(OB);
646 mutable bool Printing =
false;
655 std::pair<ReferenceKind, const Node *> collapse(
OutputBuffer &OB)
const {
656 auto SoFar = std::make_pair(RK, Pointee);
662 if (SN->
getKind() != KReferenceType)
665 SoFar.second = RT->Pointee;
666 SoFar.first = std::min(SoFar.first, RT->RK);
670 if (Prev.
size() > 1 && SoFar.second == Prev[(Prev.
size() - 1) / 2]) {
672 SoFar.second =
nullptr;
682 Pointee(Pointee_), RK(RK_) {}
684 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee, RK); }
694 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
695 if (!Collapsed.second)
697 Collapsed.second->printLeft(OB);
698 if (Collapsed.second->hasArray(OB))
700 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
703 OB += (Collapsed.first == ReferenceKind::LValue ?
"&" :
"&&");
709 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
710 if (!Collapsed.second)
712 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
714 Collapsed.second->printRight(OB);
719 const Node *ClassType;
720 const Node *MemberType;
725 ClassType(ClassType_), MemberType(MemberType_) {}
727 template<
typename Fn>
void match(Fn
F)
const {
F(ClassType, MemberType); }
739 ClassType->print(OB);
759 Base(Base_), Dimension(Dimension_) {}
761 template<
typename Fn>
void match(Fn
F)
const {
F(Base, Dimension); }
769 if (OB.back() !=
']')
773 Dimension->print(OB);
775 Base->printRight(OB);
784 const Node *ExceptionSpec;
789 :
Node(KFunctionType,
792 Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
793 ExceptionSpec(ExceptionSpec_) {}
795 template<
typename Fn>
void match(Fn
F)
const {
796 F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
832 if (ExceptionSpec !=
nullptr) {
834 ExceptionSpec->
print(OB);
844 template<
typename Fn>
void match(Fn
F)
const {
F(E); }
858 :
Node(KDynamicExceptionSpec), Types(Types_) {}
860 template<
typename Fn>
void match(Fn
F)
const {
F(Types); }
865 Types.printWithComma(OB);
882 :
Node(KFunctionEncoding,
885 Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
886 CVQuals(CVQuals_), RefQual(RefQual_) {}
888 template<
typename Fn>
void match(Fn
F)
const {
889 F(Ret, Name, Params, Attrs, CVQuals, RefQual);
905 if (!Ret->hasRHSComponent(OB))
930 if (Attrs !=
nullptr)
945 OB +=
"operator\"\" ";
951 const std::string_view Special;
956 :
Node(KSpecialName), Special(Special_), Child(Child_) {}
958 template<
typename Fn>
void match(Fn
F)
const {
F(Special, Child); }
967 const Node *FirstType;
968 const Node *SecondType;
972 :
Node(KCtorVtableSpecialName),
973 FirstType(FirstType_), SecondType(SecondType_) {}
975 template<
typename Fn>
void match(Fn
F)
const {
F(FirstType, SecondType); }
978 OB +=
"construction vtable for ";
979 FirstType->print(OB);
981 SecondType->
print(OB);
1012 template <
typename Fn>
void match(Fn
F)
const {
1061 const Node *Qualifier;
1066 :
Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
1068 template<
typename Fn>
void match(Fn
F)
const {
F(Qualifier, Name); }
1070 std::string_view
getBaseName()
const override {
return Name->getBaseName(); }
1073 Qualifier->print(OB);
1081 const Node *Dimension;
1085 :
Node(KVectorType),
BaseType(BaseType_), Dimension(Dimension_) {}
1096 Dimension->print(OB);
1102 const Node *Dimension;
1106 :
Node(KPixelVectorType), Dimension(Dimension_) {}
1108 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1112 OB +=
"pixel vector[";
1113 Dimension->print(OB);
1119 const Node *Dimension;
1123 :
Node(KBinaryFPType), Dimension(Dimension_) {}
1125 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1129 Dimension->print(OB);
1147 :
Node(KSyntheticTemplateParamName),
Kind(Kind_), Index(Index_) {}
1153 case TemplateParamKind::Type:
1156 case TemplateParamKind::NonType:
1159 case TemplateParamKind::Template:
1174 :
Node(KTypeTemplateParamDecl,
Cache::
Yes), Name(Name_) {}
1176 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
1190 :
Node(KNonTypeTemplateParamDecl,
Cache::
Yes), Name(Name_), Type(Type_) {}
1192 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Type); }
1195 Type->printLeft(OB);
1196 if (!Type->hasRHSComponent(OB))
1202 Type->printRight(OB);
1214 :
Node(KTemplateTemplateParamDecl,
Cache::
Yes), Name(Name_),
1217 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Params); }
1223 OB +=
"> typename ";
1235 :
Node(KTemplateParamPackDecl,
Cache::
Yes), Param(Param_) {}
1237 template<
typename Fn>
void match(Fn
F)
const {
F(Param); }
1240 Param->printLeft(OB);
1261 if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
1262 OB.CurrentPackMax =
static_cast<unsigned>(Data.size());
1263 OB.CurrentPackIndex = 0;
1270 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1271 return P->ArrayCache == Cache::No;
1274 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1275 return P->FunctionCache == Cache::No;
1278 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1279 return P->RHSComponentCache == Cache::No;
1284 template<
typename Fn>
void match(Fn
F)
const {
F(Data); }
1287 initializePackExpansion(OB);
1288 size_t Idx = OB.CurrentPackIndex;
1289 return Idx < Data.size() && Data[
Idx]->hasRHSComponent(OB);
1292 initializePackExpansion(OB);
1293 size_t Idx = OB.CurrentPackIndex;
1294 return Idx < Data.size() && Data[
Idx]->hasArray(OB);
1297 initializePackExpansion(OB);
1298 size_t Idx = OB.CurrentPackIndex;
1299 return Idx < Data.size() && Data[
Idx]->hasFunction(OB);
1302 initializePackExpansion(OB);
1303 size_t Idx = OB.CurrentPackIndex;
1304 return Idx < Data.size() ? Data[
Idx]->getSyntaxNode(OB) :
this;
1308 initializePackExpansion(OB);
1309 size_t Idx = OB.CurrentPackIndex;
1310 if (
Idx < Data.size())
1311 Data[
Idx]->printLeft(OB);
1314 initializePackExpansion(OB);
1315 size_t Idx = OB.CurrentPackIndex;
1316 if (
Idx < Data.size())
1317 Data[
Idx]->printRight(OB);
1330 :
Node(KTemplateArgumentPack), Elements(Elements_) {}
1332 template<
typename Fn>
void match(Fn
F)
const {
F(Elements); }
1337 Elements.printWithComma(OB);
1348 :
Node(KParameterPackExpansion), Child(Child_) {}
1350 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1355 constexpr unsigned Max = std::numeric_limits<unsigned>::max();
1358 size_t StreamPos = OB.getCurrentPosition();
1366 if (OB.CurrentPackMax == Max) {
1373 if (OB.CurrentPackMax == 0) {
1374 OB.setCurrentPosition(StreamPos);
1379 for (
unsigned I = 1,
E = OB.CurrentPackMax;
I <
E; ++
I) {
1381 OB.CurrentPackIndex =
I;
1393 template<
typename Fn>
void match(Fn
F)
const {
F(Params); }
1400 Params.printWithComma(OB);
1441 template<
typename Fn>
void match(Fn
F)
const =
delete;
1505 :
Node(KGlobalQualifiedName), Child(Child_) {}
1507 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1509 std::string_view
getBaseName()
const override {
return Child->getBaseName(); }
1547 case SpecialSubKind::allocator:
1548 return {
"allocator"};
1549 case SpecialSubKind::basic_string:
1550 return {
"basic_string"};
1551 case SpecialSubKind::string:
1552 return {
"basic_string"};
1553 case SpecialSubKind::istream:
1554 return {
"basic_istream"};
1555 case SpecialSubKind::ostream:
1556 return {
"basic_ostream"};
1557 case SpecialSubKind::iostream:
1558 return {
"basic_iostream"};
1567 OB <<
"<char, std::char_traits<char>";
1568 if (
SSK == SpecialSubKind::string)
1569 OB <<
", std::allocator<char>";
1586 assert(llvm::itanium_demangle::starts_with(SV,
"basic_"));
1587 SV.remove_prefix(
sizeof(
"basic_") - 1);
1602 const Node *Basename;
1608 :
Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
1609 Variant(Variant_) {}
1611 template<
typename Fn>
void match(Fn
F)
const {
F(Basename, IsDtor, Variant); }
1616 OB += Basename->getBaseName();
1626 template<
typename Fn>
void match(Fn
F)
const {
F(Base); }
1630 Base->printLeft(OB);
1635 const std::string_view Count;
1639 :
Node(KUnnamedTypeName), Count(Count_) {}
1641 template<
typename Fn>
void match(Fn
F)
const {
F(Count); }
1653 std::string_view Count;
1657 std::string_view Count_)
1658 :
Node(KClosureTypeName), TemplateParams(TemplateParams_),
1659 Params(Params_), Count(Count_) {}
1661 template<
typename Fn>
void match(Fn
F)
const {
1662 F(TemplateParams, Params, Count);
1666 if (!TemplateParams.
empty()) {
1689 :
Node(KStructuredBindingName), Bindings(Bindings_) {}
1691 template<
typename Fn>
void match(Fn
F)
const {
F(Bindings); }
1704 const std::string_view InfixOperator;
1710 :
Node(KBinaryExpr, Prec_),
LHS(LHS_), InfixOperator(InfixOperator_),
1713 template <
typename Fn>
void match(Fn
F)
const {
1718 bool ParenAll = OB.isGtInsideTemplateArgs() &&
1719 (InfixOperator ==
">" || InfixOperator ==
">>");
1726 if (!(InfixOperator ==
","))
1728 OB += InfixOperator;
1742 :
Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
1744 template <
typename Fn>
void match(Fn
F)
const {
1758 const std::string_view Operator;
1762 :
Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
1764 template <
typename Fn>
void match(Fn
F)
const {
1782 :
Node(KConditionalExpr, Prec_),
Cond(Cond_), Then(Then_), Else(Else_) {}
1784 template <
typename Fn>
void match(Fn
F)
const {
1791 Then->printAsOperand(OB);
1799 const std::string_view
Kind;
1807 template <
typename Fn>
void match(Fn
F)
const {
1820 const Node *SubExpr;
1821 std::string_view Offset;
1827 std::string_view Offset_,
NodeArray UnionSelectors_,
1828 bool OnePastTheEnd_)
1829 :
Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
1830 UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
1832 template<
typename Fn>
void match(Fn
F)
const {
1833 F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
1840 OB +=
" at offset ";
1841 if (Offset.empty()) {
1843 }
else if (Offset[0] ==
'n') {
1845 OB += std::string_view(Offset.data() + 1, Offset.size() - 1);
1854 const std::string_view Prefix;
1856 const std::string_view Postfix;
1861 :
Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
1863 template <
typename Fn>
void match(Fn
F)
const {
1878 const std::string_view CastKind;
1885 :
Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_),
From(From_) {}
1887 template <
typename Fn>
void match(Fn
F)
const {
1900 From->printAsOperand(OB);
1910 :
Node(KSizeofParamPackExpr), Pack(Pack_) {}
1912 template<
typename Fn>
void match(Fn
F)
const {
F(Pack); }
1929 :
Node(KCallExpr, Prec_),
Callee(Callee_), Args(Args_) {}
1931 template <
typename Fn>
void match(Fn
F)
const {
1938 Args.printWithComma(OB);
1952 bool IsArray_,
Prec Prec_)
1953 :
Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
1954 InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
1956 template<
typename Fn>
void match(Fn
F)
const {
1966 if (!ExprList.
empty()) {
1973 if (!InitList.
empty()) {
1988 :
Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
1989 IsArray(IsArray_) {}
1991 template <
typename Fn>
void match(Fn
F)
const {
2007 std::string_view Prefix;
2012 :
Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
2014 template <
typename Fn>
void match(Fn
F)
const {
2025 std::string_view Number;
2045 :
Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
2047 template <
typename Fn>
void match(Fn
F)
const {
2063 const Node *SubExpr;
2064 std::string_view Offset;
2068 std::string_view Offset_,
Prec Prec_)
2069 :
Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
2070 SubExpr(SubExpr_), Offset(Offset_) {}
2072 template <
typename Fn>
void match(Fn
F)
const {
2091 :
Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
2093 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Inits); }
2110 :
Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
2112 template<
typename Fn>
void match(Fn
F)
const {
F(Elem, Init, IsArray); }
2123 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2135 :
Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
2137 template<
typename Fn>
void match(Fn
F)
const {
F(First, Last, Init); }
2145 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2152 const Node *Pack, *Init;
2153 std::string_view OperatorName;
2157 FoldExpr(
bool IsLeftFold_, std::string_view OperatorName_,
const Node *Pack_,
2159 :
Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
2160 IsLeftFold(IsLeftFold_) {}
2162 template<
typename Fn>
void match(Fn
F)
const {
2163 F(IsLeftFold, OperatorName, Pack, Init);
2167 auto PrintPack = [&] {
2177 if (!IsLeftFold || Init !=
nullptr) {
2183 OB <<
" " << OperatorName <<
" ";
2186 if (IsLeftFold || Init !=
nullptr) {
2188 OB <<
" " << OperatorName <<
" ";
2204 template<
typename Fn>
void match(Fn
F)
const {
F(Op); }
2218 template<
typename Fn>
void match(Fn
F)
const {
F(Value); }
2221 OB += Value ? std::string_view(
"true") : std::string_view(
"false");
2231 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2246 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2250 if (Type->getKind() == KClosureTypeName)
2259 std::string_view Integer;
2263 :
Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
2265 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Integer); }
2272 if (Integer[0] ==
'n')
2273 OB <<
'-' << std::string_view(Integer.data() + 1, Integer.size() - 1);
2280 std::string_view Type;
2281 std::string_view Value;
2285 :
Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
2287 template<
typename Fn>
void match(Fn
F)
const {
F(Type, Value); }
2290 if (Type.size() > 3) {
2296 if (Value[0] ==
'n')
2297 OB <<
'-' << std::string_view(Value.data() + 1, Value.size() - 1);
2301 if (Type.size() <= 3)
2310 return Node::KFloatLiteral;
2313 return Node::KDoubleLiteral;
2316 return Node::KLongDoubleLiteral;
2321 const std::string_view Contents;
2323 static constexpr Kind KindForClass =
2328 :
Node(KindForClass), Contents(Contents_) {}
2330 template<
typename Fn>
void match(Fn
F)
const {
F(Contents); }
2334 if (Contents.size() >=
N) {
2337 char buf[
sizeof(Float)];
2339 const char *t = &*Contents.begin();
2340 const char *last = t +
N;
2342 for (; t != last; ++t, ++e) {
2343 unsigned d1 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2344 :
static_cast<unsigned>(*t -
'a' + 10);
2346 unsigned d0 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2347 :
static_cast<unsigned>(*t -
'a' + 10);
2348 *e =
static_cast<char>((d1 << 4) + d0);
2350#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
2351 std::reverse(buf, e);
2355 OB += std::string_view(num, n);
2366template<
typename Fn>
2371 return F(static_cast<const X *>(this));
2372#include "ItaniumNodes.def"
2374 assert(0 &&
"unknown mangling node kind");
2380 template <> struct NodeKind<X> { \
2381 static constexpr Node::Kind Kind = Node::K##X; \
2382 static constexpr const char *name() { return #X; } \
2384#include "ItaniumNodes.def"
2404 size_t OldNumTemplateParamLists;
2409 : Parser(TheParser),
2448 void reset(
const char *First_,
const char *Last_) {
2457 for (
int I = 0;
I != 3; ++
I)
2467 size_t sz =
static_cast<size_t>(end - begin);
2469 Node **data =
new (mem)
Node *[sz];
2470 std::copy(begin, end, data);
2483 if (llvm::itanium_demangle::starts_with(
2501 char look(
unsigned Lookahead = 0)
const {
2502 if (
static_cast<size_t>(
Last -
First) <= Lookahead)
2504 return First[Lookahead];
2565 for (;
I <
E; ++
I) {
2622 return *
this <
Other.Enc;
2625 return Enc[0] < Peek[0] || (
Enc[0] == Peek[0] &&
Enc[1] < Peek[1]);
2628 return Enc[0] == Peek[0] &&
Enc[1] == Peek[1];
2634 std::string_view Res =
Name;
2636 assert(llvm::itanium_demangle::starts_with(Res,
"operator") &&
2637 "operator name does not start with 'operator'");
2638 Res.remove_prefix(
sizeof(
"operator") - 1);
2639 if (llvm::itanium_demangle::starts_with(Res,
' '))
2640 Res.remove_prefix(1);
2673template <
typename Derived,
typename Alloc>
2676 return getDerived().parseNestedName(State);
2678 return getDerived().parseLocalName(State);
2680 Node *Result =
nullptr;
2681 bool IsSubst =
false;
2683 Result = getDerived().parseUnscopedName(State, &IsSubst);
2687 if (look() ==
'I') {
2692 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
2697 Result = make<NameWithTemplateArgs>(Result, TA);
2698 }
else if (IsSubst) {
2709template <
typename Derived,
typename Alloc>
2711 if (!consumeIf(
'Z'))
2713 Node *Encoding = getDerived().parseEncoding();
2714 if (Encoding ==
nullptr || !consumeIf(
'E'))
2717 if (consumeIf(
's')) {
2719 auto *StringLitName = make<NameType>(
"string literal");
2722 return make<LocalName>(Encoding, StringLitName);
2725 if (consumeIf(
'd')) {
2727 if (!consumeIf(
'_'))
2729 Node *
N = getDerived().parseName(State);
2732 return make<LocalName>(Encoding,
N);
2735 Node *Entity = getDerived().parseName(State);
2736 if (Entity ==
nullptr)
2739 return make<LocalName>(Encoding, Entity);
2745template <
typename Derived,
typename Alloc>
2750 Node *Std =
nullptr;
2751 if (consumeIf(
"St")) {
2752 Std = make<NameType>(
"std");
2757 Node *Res =
nullptr;
2759 if (look() ==
'S') {
2760 Node *S = getDerived().parseSubstitution();
2763 if (S->
getKind() == Node::KModuleName)
2765 else if (IsSubst && Std ==
nullptr) {
2773 if (Res ==
nullptr || Std !=
nullptr) {
2774 Res = getDerived().parseUnqualifiedName(State, Std,
Module);
2786template <
typename Derived,
typename Alloc>
2789 if (getDerived().parseModuleNameOpt(
Module))
2795 if (look() >=
'1' && look() <=
'9') {
2796 Result = getDerived().parseSourceName(State);
2797 }
else if (look() ==
'U') {
2798 Result = getDerived().parseUnnamedTypeName(State);
2799 }
else if (consumeIf(
"DC")) {
2801 size_t BindingsBegin =
Names.size();
2803 Node *Binding = getDerived().parseSourceName(State);
2804 if (Binding ==
nullptr)
2806 Names.push_back(Binding);
2807 }
while (!consumeIf(
'E'));
2808 Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2809 }
else if (look() ==
'C' || look() ==
'D') {
2811 if (Scope ==
nullptr ||
Module !=
nullptr)
2813 Result = getDerived().parseCtorDtorName(Scope, State);
2815 Result = getDerived().parseOperatorName(State);
2818 if (Result !=
nullptr &&
Module !=
nullptr)
2819 Result = make<ModuleEntity>(
Module, Result);
2820 if (Result !=
nullptr)
2821 Result = getDerived().parseAbiTags(Result);
2822 if (Result !=
nullptr && Scope !=
nullptr)
2823 Result = make<NestedName>(Scope, Result);
2833template <
typename Derived,
typename Alloc>
2836 while (consumeIf(
'W')) {
2837 bool IsPartition = consumeIf(
'P');
2838 Node *Sub = getDerived().parseSourceName(
nullptr);
2855template <
typename Derived,
typename Alloc>
2860 if (State !=
nullptr)
2861 TemplateParams.
clear();
2863 if (consumeIf(
"Ut")) {
2864 std::string_view Count = parseNumber();
2865 if (!consumeIf(
'_'))
2867 return make<UnnamedTypeName>(Count);
2869 if (consumeIf(
"Ul")) {
2871 TemplateParams.
size());
2874 size_t ParamsBegin =
Names.size();
2875 while (look() ==
'T' &&
2876 std::string_view(
"yptn").find(look(1)) != std::string_view::npos) {
2877 Node *
T = parseTemplateParamDecl();
2882 NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
2906 if (TempParams.
empty())
2909 if (!consumeIf(
"vE")) {
2911 Node *
P = getDerived().parseType();
2915 }
while (!consumeIf(
'E'));
2917 NodeArray Params = popTrailingNodeArray(ParamsBegin);
2919 std::string_view Count = parseNumber();
2920 if (!consumeIf(
'_'))
2922 return make<ClosureTypeName>(TempParams, Params, Count);
2924 if (consumeIf(
"Ub")) {
2925 (void)parseNumber();
2926 if (!consumeIf(
'_'))
2928 return make<NameType>(
"'block-literal'");
2934template <
typename Derived,
typename Alloc>
2937 if (parsePositiveInteger(&Length))
2939 if (numLeft() < Length || Length == 0)
2941 std::string_view
Name(First, Length);
2943 if (llvm::itanium_demangle::starts_with(
Name,
"_GLOBAL__N"))
2944 return make<NameType>(
"(anonymous namespace)");
2945 return make<NameType>(
Name);
2949template <
typename Derived,
typename Alloc>
2961 "operator co_await"},
2970 "operator delete[]"},
3018 "reinterpret_cast"},
3030template <
typename Derived,
typename Alloc>
3036template <
typename Derived,
typename Alloc>
3044 size_t lower = 0u, upper = NumOps - 1;
3045 while (upper != lower) {
3046 size_t middle = (upper + lower) / 2;
3047 if (Ops[middle] < First)
3052 if (Ops[lower] != First)
3062template <
typename Derived,
typename Alloc>
3065 if (
const auto *Op = parseOperatorEncoding()) {
3066 if (Op->getKind() == OperatorInfo::CCast) {
3073 PermitForwardTemplateReferences ||
3075 Node *Ty = getDerived().parseType();
3079 return make<ConversionOperatorType>(Ty);
3082 if (Op->getKind() >= OperatorInfo::Unnameable)
3085 if (Op->getKind() == OperatorInfo::Member && !Op->getFlag())
3089 return make<NameType>(Op->getName());
3092 if (consumeIf(
"li")) {
3094 Node *SN = getDerived().parseSourceName(State);
3097 return make<LiteralOperator>(SN);
3100 if (consumeIf(
'v')) {
3102 if (look() >=
'0' && look() <=
'9') {
3104 Node *SN = getDerived().parseSourceName(State);
3107 return make<ConversionOperatorType>(SN);
3125template <
typename Derived,
typename Alloc>
3129 if (SoFar->
getKind() == Node::KSpecialSubstitution) {
3131 SoFar = make<ExpandedSpecialSubstitution>(
3137 if (consumeIf(
'C')) {
3138 bool IsInherited = consumeIf(
'I');
3139 if (look() !=
'1' && look() !=
'2' && look() !=
'3' && look() !=
'4' &&
3142 int Variant = look() -
'0';
3146 if (getDerived().parseName(State) ==
nullptr)
3149 return make<CtorDtorName>(SoFar,
false, Variant);
3152 if (look() ==
'D' && (look(1) ==
'0' || look(1) ==
'1' || look(1) ==
'2' ||
3153 look(1) ==
'4' || look(1) ==
'5')) {
3154 int Variant = look(1) -
'0';
3157 return make<CtorDtorName>(SoFar,
true, Variant);
3182template <
typename Derived,
typename Alloc>
3185 if (!consumeIf(
'N'))
3191 if (consumeIf(
'O')) {
3193 }
else if (consumeIf(
'R')) {
3199 Node *SoFar =
nullptr;
3200 while (!consumeIf(
'E')) {
3205 if (look() ==
'T') {
3207 if (SoFar !=
nullptr)
3209 SoFar = getDerived().parseTemplateParam();
3210 }
else if (look() ==
'I') {
3212 if (SoFar ==
nullptr)
3214 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
3217 if (SoFar->
getKind() == Node::KNameWithTemplateArgs)
3224 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3225 }
else if (look() ==
'D' && (look(1) ==
't' || look(1) ==
'T')) {
3227 if (SoFar !=
nullptr)
3229 SoFar = getDerived().parseDecltype();
3233 if (look() ==
'S') {
3236 if (look(1) ==
't') {
3238 S = make<NameType>(
"std");
3240 S = getDerived().parseSubstitution();
3244 if (S->
getKind() == Node::KModuleName) {
3246 }
else if (SoFar !=
nullptr) {
3255 SoFar = getDerived().parseUnqualifiedName(State, SoFar,
Module);
3258 if (SoFar ==
nullptr)
3267 if (SoFar ==
nullptr || Subs.
empty())
3275template <
typename Derived,
typename Alloc>
3277 Node *SN = getDerived().parseSourceName(
nullptr);
3280 if (look() ==
'I') {
3281 Node *TA = getDerived().parseTemplateArgs();
3284 return make<NameWithTemplateArgs>(SN, TA);
3291template <
typename Derived,
typename Alloc>
3294 if (std::isdigit(look()))
3295 Result = getDerived().parseSimpleId();
3297 Result = getDerived().parseUnresolvedType();
3298 if (Result ==
nullptr)
3300 return make<DtorName>(Result);
3306template <
typename Derived,
typename Alloc>
3308 if (look() ==
'T') {
3309 Node *TP = getDerived().parseTemplateParam();
3315 if (look() ==
'D') {
3316 Node *DT = getDerived().parseDecltype();
3322 return getDerived().parseSubstitution();
3332template <
typename Derived,
typename Alloc>
3334 if (std::isdigit(look()))
3335 return getDerived().parseSimpleId();
3337 if (consumeIf(
"dn"))
3338 return getDerived().parseDestructorName();
3342 Node *Oper = getDerived().parseOperatorName(
nullptr);
3343 if (Oper ==
nullptr)
3345 if (look() ==
'I') {
3346 Node *TA = getDerived().parseTemplateArgs();
3349 return make<NameWithTemplateArgs>(Oper, TA);
3366template <
typename Derived,
typename Alloc>
3368 Node *SoFar =
nullptr;
3372 if (consumeIf(
"srN")) {
3373 SoFar = getDerived().parseUnresolvedType();
3374 if (SoFar ==
nullptr)
3377 if (look() ==
'I') {
3378 Node *TA = getDerived().parseTemplateArgs();
3381 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3386 while (!consumeIf(
'E')) {
3387 Node *Qual = getDerived().parseSimpleId();
3388 if (Qual ==
nullptr)
3390 SoFar = make<QualifiedName>(SoFar, Qual);
3395 Node *Base = getDerived().parseBaseUnresolvedName();
3396 if (Base ==
nullptr)
3398 return make<QualifiedName>(SoFar, Base);
3402 if (!consumeIf(
"sr")) {
3403 SoFar = getDerived().parseBaseUnresolvedName();
3404 if (SoFar ==
nullptr)
3407 SoFar = make<GlobalQualifiedName>(SoFar);
3412 if (std::isdigit(look())) {
3414 Node *Qual = getDerived().parseSimpleId();
3415 if (Qual ==
nullptr)
3418 SoFar = make<QualifiedName>(SoFar, Qual);
3420 SoFar = make<GlobalQualifiedName>(Qual);
3425 }
while (!consumeIf(
'E'));
3430 SoFar = getDerived().parseUnresolvedType();
3431 if (SoFar ==
nullptr)
3434 if (look() ==
'I') {
3435 Node *TA = getDerived().parseTemplateArgs();
3438 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3444 assert(SoFar !=
nullptr);
3446 Node *Base = getDerived().parseBaseUnresolvedName();
3447 if (Base ==
nullptr)
3449 return make<QualifiedName>(SoFar, Base);
3454template <
typename Derived,
typename Alloc>
3456 while (consumeIf(
'B')) {
3457 std::string_view SN = parseBareSourceName();
3460 N = make<AbiTagAttr>(
N, SN);
3468template <
typename Alloc,
typename Derived>
3471 const char *Tmp = First;
3474 if (numLeft() == 0 || !std::isdigit(*First))
3475 return std::string_view();
3476 while (numLeft() != 0 && std::isdigit(*First))
3478 return std::string_view(Tmp, First - Tmp);
3482template <
typename Alloc,
typename Derived>
3485 if (look() <
'0' || look() >
'9')
3487 while (look() >=
'0' && look() <=
'9') {
3489 *Out +=
static_cast<size_t>(
consume() -
'0');
3494template <
typename Alloc,
typename Derived>
3497 if (parsePositiveInteger(&
Int) || numLeft() <
Int)
3499 std::string_view R(First,
Int);
3512template <
typename Derived,
typename Alloc>
3516 Node *ExceptionSpec =
nullptr;
3517 if (consumeIf(
"Do")) {
3518 ExceptionSpec = make<NameType>(
"noexcept");
3521 }
else if (consumeIf(
"DO")) {
3522 Node *
E = getDerived().parseExpr();
3523 if (
E ==
nullptr || !consumeIf(
'E'))
3525 ExceptionSpec = make<NoexceptSpec>(
E);
3528 }
else if (consumeIf(
"Dw")) {
3529 size_t SpecsBegin =
Names.size();
3530 while (!consumeIf(
'E')) {
3531 Node *
T = getDerived().parseType();
3537 make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
3544 if (!consumeIf(
'F'))
3547 Node *ReturnType = getDerived().parseType();
3548 if (ReturnType ==
nullptr)
3552 size_t ParamsBegin =
Names.size();
3558 if (consumeIf(
"RE")) {
3562 if (consumeIf(
"OE")) {
3566 Node *
T = getDerived().parseType();
3572 NodeArray Params = popTrailingNodeArray(ParamsBegin);
3573 return make<FunctionType>(ReturnType, Params, CVQuals,
3574 ReferenceQualifier, ExceptionSpec);
3582template <
typename Derived,
typename Alloc>
3584 if (!consumeIf(
"Dv"))
3586 if (look() >=
'1' && look() <=
'9') {
3587 Node *DimensionNumber = make<NameType>(parseNumber());
3588 if (!DimensionNumber)
3590 if (!consumeIf(
'_'))
3593 return make<PixelVectorType>(DimensionNumber);
3594 Node *ElemType = getDerived().parseType();
3595 if (ElemType ==
nullptr)
3597 return make<VectorType>(ElemType, DimensionNumber);
3600 if (!consumeIf(
'_')) {
3601 Node *DimExpr = getDerived().parseExpr();
3604 if (!consumeIf(
'_'))
3606 Node *ElemType = getDerived().parseType();
3609 return make<VectorType>(ElemType, DimExpr);
3611 Node *ElemType = getDerived().parseType();
3614 return make<VectorType>(ElemType,
nullptr);
3619template <
typename Derived,
typename Alloc>
3621 if (!consumeIf(
'D'))
3623 if (!consumeIf(
't') && !consumeIf(
'T'))
3625 Node *
E = getDerived().parseExpr();
3628 if (!consumeIf(
'E'))
3630 return make<EnclosingExpr>(
"decltype",
E);
3635template <
typename Derived,
typename Alloc>
3637 if (!consumeIf(
'A'))
3640 Node *Dimension =
nullptr;
3642 if (std::isdigit(look())) {
3643 Dimension = make<NameType>(parseNumber());
3646 if (!consumeIf(
'_'))
3648 }
else if (!consumeIf(
'_')) {
3649 Node *DimExpr = getDerived().parseExpr();
3650 if (DimExpr ==
nullptr)
3652 if (!consumeIf(
'_'))
3654 Dimension = DimExpr;
3657 Node *Ty = getDerived().parseType();
3660 return make<ArrayType>(Ty, Dimension);
3664template <
typename Derived,
typename Alloc>
3666 if (!consumeIf(
'M'))
3668 Node *ClassType = getDerived().parseType();
3669 if (ClassType ==
nullptr)
3671 Node *MemberType = getDerived().parseType();
3672 if (MemberType ==
nullptr)
3674 return make<PointerToMemberType>(ClassType, MemberType);
3681template <
typename Derived,
typename Alloc>
3683 std::string_view ElabSpef;
3684 if (consumeIf(
"Ts"))
3685 ElabSpef =
"struct";
3686 else if (consumeIf(
"Tu"))
3688 else if (consumeIf(
"Te"))
3691 Node *
Name = getDerived().parseName();
3692 if (
Name ==
nullptr)
3695 if (!ElabSpef.empty())
3696 return make<ElaboratedTypeSpefType>(ElabSpef,
Name);
3704template <
typename Derived,
typename Alloc>
3706 if (consumeIf(
'U')) {
3707 std::string_view Qual = parseBareSourceName();
3712 if (llvm::itanium_demangle::starts_with(Qual,
"objcproto")) {
3713 constexpr size_t Len =
sizeof(
"objcproto") - 1;
3714 std::string_view ProtoSourceName(Qual.data() + Len, Qual.size() - Len);
3715 std::string_view Proto;
3718 &*ProtoSourceName.begin()),
3719 SaveLast(Last, &*ProtoSourceName.rbegin() + 1);
3720 Proto = parseBareSourceName();
3724 Node *Child = getDerived().parseQualifiedType();
3725 if (Child ==
nullptr)
3727 return make<ObjCProtoName>(Child, Proto);
3731 if (look() ==
'I') {
3732 TA = getDerived().parseTemplateArgs();
3737 Node *Child = getDerived().parseQualifiedType();
3738 if (Child ==
nullptr)
3740 return make<VendorExtQualType>(Child, Qual, TA);
3744 Node *Ty = getDerived().parseType();
3748 Ty = make<QualType>(Ty, Quals);
3772template <
typename Derived,
typename Alloc>
3774 Node *Result =
nullptr;
3781 unsigned AfterQuals = 0;
3782 if (look(AfterQuals) ==
'r') ++AfterQuals;
3783 if (look(AfterQuals) ==
'V') ++AfterQuals;
3784 if (look(AfterQuals) ==
'K') ++AfterQuals;
3786 if (look(AfterQuals) ==
'F' ||
3787 (look(AfterQuals) ==
'D' &&
3788 (look(AfterQuals + 1) ==
'o' || look(AfterQuals + 1) ==
'O' ||
3789 look(AfterQuals + 1) ==
'w' || look(AfterQuals + 1) ==
'x'))) {
3790 Result = getDerived().parseFunctionType();
3796 Result = getDerived().parseQualifiedType();
3802 return make<NameType>(
"void");
3806 return make<NameType>(
"wchar_t");
3810 return make<NameType>(
"bool");
3814 return make<NameType>(
"char");
3818 return make<NameType>(
"signed char");
3822 return make<NameType>(
"unsigned char");
3826 return make<NameType>(
"short");
3830 return make<NameType>(
"unsigned short");
3834 return make<NameType>(
"int");
3838 return make<NameType>(
"unsigned int");
3842 return make<NameType>(
"long");
3846 return make<NameType>(
"unsigned long");
3850 return make<NameType>(
"long long");
3854 return make<NameType>(
"unsigned long long");
3858 return make<NameType>(
"__int128");
3862 return make<NameType>(
"unsigned __int128");
3866 return make<NameType>(
"float");
3870 return make<NameType>(
"double");
3874 return make<NameType>(
"long double");
3878 return make<NameType>(
"__float128");
3882 return make<NameType>(
"...");
3887 std::string_view Res = parseBareSourceName();
3893 Result = make<NameType>(Res);
3901 return make<NameType>(
"decimal64");
3905 return make<NameType>(
"decimal128");
3909 return make<NameType>(
"decimal32");
3913 return make<NameType>(
"half");
3917 Node *DimensionNumber = make<NameType>(parseNumber());
3918 if (!DimensionNumber)
3920 if (!consumeIf(
'_'))
3922 return make<BinaryFPType>(DimensionNumber);
3930 bool Signed = look(1) ==
'B';
3932 Node *
Size = std::isdigit(look()) ? make<NameType>(parseNumber())
3933 : getDerived().parseExpr();
3936 if (!consumeIf(
'_'))
3943 return make<NameType>(
"char32_t");
3947 return make<NameType>(
"char16_t");
3951 return make<NameType>(
"char8_t");
3955 return make<NameType>(
"auto");
3959 return make<NameType>(
"decltype(auto)");
3963 return make<NameType>(
"std::nullptr_t");
3968 Result = getDerived().parseDecltype();
3973 Result = getDerived().parseVectorType();
3979 Node *Child = getDerived().parseType();
3982 Result = make<ParameterPackExpansion>(Child);
3991 Result = getDerived().parseFunctionType();
3997 Result = getDerived().parseFunctionType();
4002 Result = getDerived().parseArrayType();
4007 Result = getDerived().parsePointerToMemberType();
4013 if (look(1) ==
's' || look(1) ==
'u' || look(1) ==
'e') {
4014 Result = getDerived().parseClassEnumType();
4018 Result = getDerived().parseTemplateParam();
4019 if (Result ==
nullptr)
4032 if (TryToParseTemplateArgs && look() ==
'I') {
4033 Node *TA = getDerived().parseTemplateArgs();
4036 Result = make<NameWithTemplateArgs>(Result, TA);
4043 Node *
Ptr = getDerived().parseType();
4046 Result = make<PointerType>(
Ptr);
4052 Node *Ref = getDerived().parseType();
4061 Node *Ref = getDerived().parseType();
4070 Node *
P = getDerived().parseType();
4073 Result = make<PostfixQualifiedType>(
P,
" complex");
4079 Node *
P = getDerived().parseType();
4082 Result = make<PostfixQualifiedType>(
P,
" imaginary");
4087 if (look(1) !=
't') {
4088 bool IsSubst =
false;
4089 Result = getDerived().parseUnscopedName(
nullptr, &IsSubst);
4103 if (look() ==
'I' && (!IsSubst || TryToParseTemplateArgs)) {
4106 Node *TA = getDerived().parseTemplateArgs();
4109 Result = make<NameWithTemplateArgs>(Result, TA);
4110 }
else if (IsSubst) {
4121 Result = getDerived().parseClassEnumType();
4129 if (Result !=
nullptr)
4134template <
typename Derived,
typename Alloc>
4138 Node *
E = getDerived().parseExpr();
4141 return make<PrefixExpr>(Kind,
E, Prec);
4144template <
typename Derived,
typename Alloc>
4148 Node *
LHS = getDerived().parseExpr();
4151 Node *
RHS = getDerived().parseExpr();
4154 return make<BinaryExpr>(
LHS, Kind,
RHS, Prec);
4157template <
typename Derived,
typename Alloc>
4159 std::string_view Lit) {
4160 std::string_view Tmp = parseNumber(
true);
4161 if (!Tmp.empty() && consumeIf(
'E'))
4162 return make<IntegerLiteral>(Lit, Tmp);
4167template <
typename Alloc,
typename Derived>
4184template <
typename Derived,
typename Alloc>
4186 if (consumeIf(
"fpT"))
4187 return make<NameType>(
"this");
4188 if (consumeIf(
"fp")) {
4189 parseCVQualifiers();
4190 std::string_view Num = parseNumber();
4191 if (!consumeIf(
'_'))
4193 return make<FunctionParam>(Num);
4195 if (consumeIf(
"fL")) {
4196 if (parseNumber().empty())
4198 if (!consumeIf(
'p'))
4200 parseCVQualifiers();
4201 std::string_view Num = parseNumber();
4202 if (!consumeIf(
'_'))
4204 return make<FunctionParam>(Num);
4211template <
typename Derived,
typename Alloc>
4213 if (!consumeIf(
"cv"))
4218 Ty = getDerived().parseType();
4224 if (consumeIf(
'_')) {
4225 size_t ExprsBegin =
Names.size();
4226 while (!consumeIf(
'E')) {
4227 Node *
E = getDerived().parseExpr();
4232 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4233 return make<ConversionExpr>(Ty, Exprs);
4236 Node *
E[1] = {getDerived().parseExpr()};
4237 if (
E[0] ==
nullptr)
4239 return make<ConversionExpr>(Ty, makeNodeArray(
E,
E + 1));
4249template <
typename Derived,
typename Alloc>
4251 if (!consumeIf(
'L'))
4256 return getDerived().parseIntegerLiteral(
"wchar_t");
4258 if (consumeIf(
"b0E"))
4259 return make<BoolExpr>(0);
4260 if (consumeIf(
"b1E"))
4261 return make<BoolExpr>(1);
4265 return getDerived().parseIntegerLiteral(
"char");
4268 return getDerived().parseIntegerLiteral(
"signed char");
4271 return getDerived().parseIntegerLiteral(
"unsigned char");
4274 return getDerived().parseIntegerLiteral(
"short");
4277 return getDerived().parseIntegerLiteral(
"unsigned short");
4280 return getDerived().parseIntegerLiteral(
"");
4283 return getDerived().parseIntegerLiteral(
"u");
4286 return getDerived().parseIntegerLiteral(
"l");
4289 return getDerived().parseIntegerLiteral(
"ul");
4292 return getDerived().parseIntegerLiteral(
"ll");
4295 return getDerived().parseIntegerLiteral(
"ull");
4298 return getDerived().parseIntegerLiteral(
"__int128");
4301 return getDerived().parseIntegerLiteral(
"unsigned __int128");
4304 return getDerived().template parseFloatingLiteral<float>();
4307 return getDerived().template parseFloatingLiteral<double>();
4310#if defined(__powerpc__) || defined(__s390__)
4313 return getDerived().template parseFloatingLiteral<double>();
4315 return getDerived().template parseFloatingLiteral<long double>();
4318 if (consumeIf(
"_Z")) {
4319 Node *R = getDerived().parseEncoding();
4320 if (R !=
nullptr && consumeIf(
'E'))
4325 Node *
T = getDerived().parseType();
4330 return make<StringLiteral>(
T);
4334 if (consumeIf(
"Dn") && (consumeIf(
'0'), consumeIf(
'E')))
4335 return make<NameType>(
"nullptr");
4345 Node *
T = parseUnnamedTypeName(
nullptr);
4346 if (!
T || !consumeIf(
'E'))
4348 return make<LambdaExpr>(
T);
4352 Node *
T = getDerived().parseType();
4355 std::string_view
N = parseNumber(
true);
4358 if (!consumeIf(
'E'))
4360 return make<EnumLiteral>(
T,
N);
4369template <
typename Derived,
typename Alloc>
4371 if (look() ==
'd') {
4375 Node *
Field = getDerived().parseSourceName(
nullptr);
4376 if (
Field ==
nullptr)
4378 Node *Init = getDerived().parseBracedExpr();
4379 if (Init ==
nullptr)
4381 return make<BracedExpr>(
Field, Init,
false);
4386 if (
Index ==
nullptr)
4388 Node *Init = getDerived().parseBracedExpr();
4389 if (Init ==
nullptr)
4391 return make<BracedExpr>(
Index, Init,
true);
4395 Node *RangeBegin = getDerived().parseExpr();
4396 if (RangeBegin ==
nullptr)
4398 Node *RangeEnd = getDerived().parseExpr();
4399 if (RangeEnd ==
nullptr)
4401 Node *Init = getDerived().parseBracedExpr();
4402 if (Init ==
nullptr)
4404 return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
4408 return getDerived().parseExpr();
4416template <
typename Derived,
typename Alloc>
4418 if (!consumeIf(
'f'))
4421 bool IsLeftFold =
false, HasInitializer =
false;
4427 HasInitializer =
true;
4430 HasInitializer =
true;
4440 const auto *Op = parseOperatorEncoding();
4443 if (!(Op->getKind() == OperatorInfo::Binary
4444 || (Op->getKind() == OperatorInfo::Member
4445 && Op->getName().back() ==
'*')))
4448 Node *Pack = getDerived().parseExpr();
4449 if (Pack ==
nullptr)
4452 Node *Init =
nullptr;
4453 if (HasInitializer) {
4454 Init = getDerived().parseExpr();
4455 if (Init ==
nullptr)
4459 if (IsLeftFold && Init)
4462 return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
4468template <
typename Derived,
typename Alloc>
4472 Node *Ty = getDerived().parseType();
4475 Node *Expr = getDerived().parseExpr();
4478 std::string_view
Offset = getDerived().parseNumber(
true);
4479 if (!consumeIf(
'E'))
4481 return make<PointerToMemberConversionExpr>(Ty, Expr,
Offset, Prec);
4488template <
typename Derived,
typename Alloc>
4490 Node *Ty = getDerived().parseType();
4493 Node *Expr = getDerived().parseExpr();
4496 std::string_view
Offset = getDerived().parseNumber(
true);
4497 size_t SelectorsBegin =
Names.size();
4498 while (consumeIf(
'_')) {
4499 Node *Selector = make<NameType>(parseNumber());
4502 Names.push_back(Selector);
4504 bool OnePastTheEnd = consumeIf(
'p');
4505 if (!consumeIf(
'E'))
4507 return make<SubobjectExpr>(
4508 Ty, Expr,
Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
4555template <
typename Derived,
typename Alloc>
4557 bool Global = consumeIf(
"gs");
4559 const auto *Op = parseOperatorEncoding();
4561 auto Sym = Op->getSymbol();
4562 switch (Op->getKind()) {
4563 case OperatorInfo::Binary:
4565 return getDerived().parseBinaryExpr(
Sym, Op->getPrecedence());
4566 case OperatorInfo::Prefix:
4568 return getDerived().parsePrefixExpr(
Sym, Op->getPrecedence());
4569 case OperatorInfo::Postfix: {
4572 return getDerived().parsePrefixExpr(
Sym, Op->getPrecedence());
4573 Node *Ex = getDerived().parseExpr();
4576 return make<PostfixExpr>(Ex,
Sym, Op->getPrecedence());
4578 case OperatorInfo::Array: {
4580 Node *Base = getDerived().parseExpr();
4581 if (Base ==
nullptr)
4584 if (
Index ==
nullptr)
4586 return make<ArraySubscriptExpr>(Base,
Index, Op->getPrecedence());
4588 case OperatorInfo::Member: {
4590 Node *
LHS = getDerived().parseExpr();
4593 Node *
RHS = getDerived().parseExpr();
4596 return make<MemberExpr>(
LHS,
Sym,
RHS, Op->getPrecedence());
4598 case OperatorInfo::New: {
4604 size_t Exprs =
Names.size();
4605 while (!consumeIf(
'_')) {
4606 Node *Ex = getDerived().parseExpr();
4609 Names.push_back(Ex);
4611 NodeArray ExprList = popTrailingNodeArray(Exprs);
4612 Node *Ty = getDerived().parseType();
4615 bool HaveInits = consumeIf(
"pi");
4616 size_t InitsBegin =
Names.size();
4617 while (!consumeIf(
'E')) {
4620 Node *Init = getDerived().parseExpr();
4621 if (Init ==
nullptr)
4623 Names.push_back(Init);
4625 NodeArray Inits = popTrailingNodeArray(InitsBegin);
4626 return make<NewExpr>(ExprList, Ty, Inits, Global,
4627 Op->getFlag(), Op->getPrecedence());
4629 case OperatorInfo::Del: {
4631 Node *Ex = getDerived().parseExpr();
4634 return make<DeleteExpr>(Ex, Global, Op->getFlag(),
4635 Op->getPrecedence());
4637 case OperatorInfo::Call: {
4642 size_t ExprsBegin =
Names.size();
4643 while (!consumeIf(
'E')) {
4644 Node *
E = getDerived().parseExpr();
4649 return make<CallExpr>(
Callee, popTrailingNodeArray(ExprsBegin),
4650 Op->getPrecedence());
4652 case OperatorInfo::CCast: {
4657 Ty = getDerived().parseType();
4662 size_t ExprsBegin =
Names.size();
4663 bool IsMany = consumeIf(
'_');
4664 while (!consumeIf(
'E')) {
4665 Node *
E = getDerived().parseExpr();
4672 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4673 if (!IsMany && Exprs.
size() != 1)
4675 return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence());
4677 case OperatorInfo::Conditional: {
4679 Node *
Cond = getDerived().parseExpr();
4680 if (
Cond ==
nullptr)
4682 Node *
LHS = getDerived().parseExpr();
4685 Node *
RHS = getDerived().parseExpr();
4688 return make<ConditionalExpr>(
Cond,
LHS,
RHS, Op->getPrecedence());
4690 case OperatorInfo::NamedCast: {
4692 Node *Ty = getDerived().parseType();
4695 Node *Ex = getDerived().parseExpr();
4698 return make<CastExpr>(
Sym, Ty, Ex, Op->getPrecedence());
4700 case OperatorInfo::OfIdOp: {
4703 Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
4706 return make<EnclosingExpr>(
Sym,
Arg, Op->getPrecedence());
4708 case OperatorInfo::NameOnly: {
4720 return getDerived().parseExprPrimary();
4722 return getDerived().parseTemplateParam();
4723 if (look() ==
'f') {
4725 if (look(1) ==
'p' || (look(1) ==
'L' && std::isdigit(look(2))))
4726 return getDerived().parseFunctionParam();
4727 return getDerived().parseFoldExpr();
4729 if (consumeIf(
"il")) {
4730 size_t InitsBegin =
Names.size();
4731 while (!consumeIf(
'E')) {
4732 Node *
E = getDerived().parseBracedExpr();
4737 return make<InitListExpr>(
nullptr, popTrailingNodeArray(InitsBegin));
4739 if (consumeIf(
"mc"))
4741 if (consumeIf(
"nx")) {
4742 Node *Ex = getDerived().parseExpr();
4747 if (consumeIf(
"so"))
4748 return parseSubobjectExpr();
4749 if (consumeIf(
"sp")) {
4750 Node *Child = getDerived().parseExpr();
4751 if (Child ==
nullptr)
4753 return make<ParameterPackExpansion>(Child);
4755 if (consumeIf(
"sZ")) {
4756 if (look() ==
'T') {
4757 Node *R = getDerived().parseTemplateParam();
4760 return make<SizeofParamPackExpr>(R);
4762 Node *
FP = getDerived().parseFunctionParam();
4765 return make<EnclosingExpr>(
"sizeof... ",
FP);
4767 if (consumeIf(
"sP")) {
4768 size_t ArgsBegin =
Names.size();
4769 while (!consumeIf(
'E')) {
4770 Node *
Arg = getDerived().parseTemplateArg();
4775 auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
4778 return make<EnclosingExpr>(
"sizeof... ", Pack);
4780 if (consumeIf(
"tl")) {
4781 Node *Ty = getDerived().parseType();
4784 size_t InitsBegin =
Names.size();
4785 while (!consumeIf(
'E')) {
4786 Node *
E = getDerived().parseBracedExpr();
4791 return make<InitListExpr>(Ty, popTrailingNodeArray(InitsBegin));
4793 if (consumeIf(
"tr"))
4794 return make<NameType>(
"throw");
4795 if (consumeIf(
"tw")) {
4796 Node *Ex = getDerived().parseExpr();
4799 return make<ThrowExpr>(Ex);
4801 if (consumeIf(
'u')) {
4802 Node *
Name = getDerived().parseSourceName(
nullptr);
4810 bool IsUUID =
false;
4812 if (
Name->getBaseName() ==
"__uuidof") {
4813 if (consumeIf(
't')) {
4814 UUID = getDerived().parseType();
4816 }
else if (consumeIf(
'z')) {
4817 UUID = getDerived().parseExpr();
4821 size_t ExprsBegin =
Names.size();
4823 if (
UUID ==
nullptr)
4827 while (!consumeIf(
'E')) {
4828 Node *
E = getDerived().parseTemplateArg();
4834 return make<CallExpr>(
Name, popTrailingNodeArray(ExprsBegin),
4839 return getDerived().parseUnresolvedName(Global);
4850template <
typename Alloc,
typename Derived>
4855 return parseNumber(
true).empty() || !consumeIf(
'_');
4857 return parseNumber(
true).empty() || !consumeIf(
'_') ||
4858 parseNumber(
true).empty() || !consumeIf(
'_');
4883template <
typename Derived,
typename Alloc>
4893 Node *
Arg = getDerived().parseTemplateArg();
4896 return make<SpecialName>(
"template parameter object for ",
Arg);
4901 Node *Ty = getDerived().parseType();
4904 return make<SpecialName>(
"vtable for ", Ty);
4909 Node *Ty = getDerived().parseType();
4912 return make<SpecialName>(
"VTT for ", Ty);
4917 Node *Ty = getDerived().parseType();
4920 return make<SpecialName>(
"typeinfo for ", Ty);
4925 Node *Ty = getDerived().parseType();
4928 return make<SpecialName>(
"typeinfo name for ", Ty);
4933 if (parseCallOffset() || parseCallOffset())
4935 Node *Encoding = getDerived().parseEncoding();
4936 if (Encoding ==
nullptr)
4938 return make<SpecialName>(
"covariant return thunk to ", Encoding);
4944 Node *FirstType = getDerived().parseType();
4945 if (FirstType ==
nullptr)
4947 if (parseNumber(
true).empty() || !consumeIf(
'_'))
4949 Node *SecondType = getDerived().parseType();
4950 if (SecondType ==
nullptr)
4952 return make<CtorVtableSpecialName>(SecondType, FirstType);
4957 Node *
Name = getDerived().parseName();
4958 if (
Name ==
nullptr)
4960 return make<SpecialName>(
"thread-local wrapper routine for ",
Name);
4965 Node *
Name = getDerived().parseName();
4966 if (
Name ==
nullptr)
4968 return make<SpecialName>(
"thread-local initialization routine for ",
Name);
4973 bool IsVirt = look() ==
'v';
4974 if (parseCallOffset())
4976 Node *BaseEncoding = getDerived().parseEncoding();
4977 if (BaseEncoding ==
nullptr)
4980 return make<SpecialName>(
"virtual thunk to ", BaseEncoding);
4982 return make<SpecialName>(
"non-virtual thunk to ", BaseEncoding);
4990 Node *
Name = getDerived().parseName();
4991 if (
Name ==
nullptr)
4993 return make<SpecialName>(
"guard variable for ",
Name);
5000 Node *
Name = getDerived().parseName();
5001 if (
Name ==
nullptr)
5004 bool ParsedSeqId = !parseSeqId(&Count);
5005 if (!consumeIf(
'_') && ParsedSeqId)
5007 return make<SpecialName>(
"reference temporary for ",
Name);