16#ifndef DEMANGLE_ITANIUMDEMANGLE_H
17#define DEMANGLE_ITANIUMDEMANGLE_H
36 static_assert(std::is_trivial_v<T>,
"T is required to be a trivial type");
43 bool isInline()
const {
return First == Inline; }
51 void reserve(
size_t NewCap) {
54 auto *Tmp =
static_cast<T *
>(std::malloc(NewCap *
sizeof(
T)));
57 std::copy(First, Last, Tmp);
60 First =
static_cast<T *
>(std::realloc(First, NewCap *
sizeof(
T)));
75 if (
Other.isInline()) {
77 Last = First +
Other.size();
89 if (
Other.isInline()) {
95 Last = First +
Other.size();
124 assert(Last != First &&
"Popping empty vector!");
130 Last = First +
Index;
136 bool empty()
const {
return First == Last; }
137 size_t size()
const {
return static_cast<size_t>(Last - First); }
139 assert(Last != First &&
"Calling back() on empty vector!");
159#define NODE(NodeKind) K##NodeKind,
160#include "ItaniumNodes.def"
223 template<
typename Fn>
void visit(Fn
F)
const;
264 bool StrictlyWorse =
false)
const {
306 : Elements(Elements_), NumElements(NumElements_) {}
308 bool empty()
const {
return NumElements == 0; }
309 size_t size()
const {
return NumElements; }
312 Node **
end()
const {
return Elements + NumElements; }
317 bool FirstElement =
true;
318 for (
size_t Idx = 0;
Idx != NumElements; ++
Idx) {
319 size_t BeforeComma = OB.getCurrentPosition();
322 size_t AfterComma = OB.getCurrentPosition();
327 if (AfterComma == OB.getCurrentPosition()) {
328 OB.setCurrentPosition(BeforeComma);
332 FirstElement =
false;
352 :
Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
354 template<
typename Fn>
void match(Fn
F)
const {
F(Prefix, Suffix); }
371 :
Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
377 template <
typename Fn>
void match(Fn
F)
const {
F(Ty, Ext, TA); }
453 :
Node(KConversionOperatorType), Ty(Ty_) {}
455 template<
typename Fn>
void match(Fn
F)
const {
F(Ty); }
469 :
Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
471 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Postfix); }
485 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
499 :
Node(KBitIntType), Size(Size_), Signed(Signed_) {}
501 template <
typename Fn>
void match(Fn
F)
const {
F(Size, Signed); }
508 Size->printAsOperand(OB);
518 :
Node(KElaboratedTypeSpefType),
Kind(Kind_), Child(Child_) {}
552 :
Node(KEnableIfAttr), Conditions(Conditions_) {}
554 template<
typename Fn>
void match(Fn
F)
const {
F(Conditions); }
557 OB +=
" [enable_if:";
571 :
Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
573 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Protocol); }
576 return Ty->
getKind() == KNameType &&
598 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee); }
601 return Pointee->hasRHSComponent(OB);
606 if (Pointee->getKind() != KObjCProtoName ||
608 Pointee->printLeft(OB);
609 if (Pointee->hasArray(OB))
611 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
615 const auto *objcProto =
static_cast<const ObjCProtoName *
>(Pointee);
617 OB += objcProto->Protocol;
623 if (Pointee->getKind() != KObjCProtoName ||
625 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
627 Pointee->printRight(OB);
642 mutable bool Printing =
false;
651 std::pair<ReferenceKind, const Node *> collapse(
OutputBuffer &OB)
const {
652 auto SoFar = std::make_pair(RK, Pointee);
658 if (SN->
getKind() != KReferenceType)
661 SoFar.second = RT->Pointee;
662 SoFar.first = std::min(SoFar.first, RT->RK);
666 if (Prev.
size() > 1 && SoFar.second == Prev[(Prev.
size() - 1) / 2]) {
668 SoFar.second =
nullptr;
678 Pointee(Pointee_), RK(RK_) {}
680 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee, RK); }
690 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
691 if (!Collapsed.second)
693 Collapsed.second->printLeft(OB);
694 if (Collapsed.second->hasArray(OB))
696 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
699 OB += (Collapsed.first == ReferenceKind::LValue ?
"&" :
"&&");
705 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
706 if (!Collapsed.second)
708 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
710 Collapsed.second->printRight(OB);
715 const Node *ClassType;
716 const Node *MemberType;
721 ClassType(ClassType_), MemberType(MemberType_) {}
723 template<
typename Fn>
void match(Fn
F)
const {
F(ClassType, MemberType); }
735 ClassType->print(OB);
755 Base(Base_), Dimension(Dimension_) {}
757 template<
typename Fn>
void match(Fn
F)
const {
F(Base, Dimension); }
765 if (OB.back() !=
']')
769 Dimension->print(OB);
771 Base->printRight(OB);
780 const Node *ExceptionSpec;
785 :
Node(KFunctionType,
788 Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
789 ExceptionSpec(ExceptionSpec_) {}
791 template<
typename Fn>
void match(Fn
F)
const {
792 F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
828 if (ExceptionSpec !=
nullptr) {
830 ExceptionSpec->
print(OB);
840 template<
typename Fn>
void match(Fn
F)
const {
F(E); }
854 :
Node(KDynamicExceptionSpec), Types(Types_) {}
856 template<
typename Fn>
void match(Fn
F)
const {
F(Types); }
861 Types.printWithComma(OB);
878 :
Node(KFunctionEncoding,
881 Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
882 CVQuals(CVQuals_), RefQual(RefQual_) {}
884 template<
typename Fn>
void match(Fn
F)
const {
885 F(Ret, Name, Params, Attrs, CVQuals, RefQual);
901 if (!Ret->hasRHSComponent(OB))
926 if (Attrs !=
nullptr)
941 OB +=
"operator\"\" ";
952 :
Node(KSpecialName), Special(Special_), Child(Child_) {}
954 template<
typename Fn>
void match(Fn
F)
const {
F(Special, Child); }
963 const Node *FirstType;
964 const Node *SecondType;
968 :
Node(KCtorVtableSpecialName),
969 FirstType(FirstType_), SecondType(SecondType_) {}
971 template<
typename Fn>
void match(Fn
F)
const {
F(FirstType, SecondType); }
974 OB +=
"construction vtable for ";
975 FirstType->print(OB);
977 SecondType->
print(OB);
1008 template <
typename Fn>
void match(Fn
F)
const {
1057 const Node *Qualifier;
1062 :
Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
1064 template<
typename Fn>
void match(Fn
F)
const {
F(Qualifier, Name); }
1069 Qualifier->print(OB);
1077 const Node *Dimension;
1081 :
Node(KVectorType),
BaseType(BaseType_), Dimension(Dimension_) {}
1092 Dimension->print(OB);
1098 const Node *Dimension;
1102 :
Node(KPixelVectorType), Dimension(Dimension_) {}
1104 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1108 OB +=
"pixel vector[";
1109 Dimension->print(OB);
1115 const Node *Dimension;
1119 :
Node(KBinaryFPType), Dimension(Dimension_) {}
1121 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1125 Dimension->print(OB);
1143 :
Node(KSyntheticTemplateParamName),
Kind(Kind_), Index(Index_) {}
1149 case TemplateParamKind::Type:
1152 case TemplateParamKind::NonType:
1155 case TemplateParamKind::Template:
1170 :
Node(KTypeTemplateParamDecl,
Cache::
Yes), Name(Name_) {}
1172 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
1186 :
Node(KNonTypeTemplateParamDecl,
Cache::
Yes), Name(Name_), Type(Type_) {}
1188 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Type); }
1191 Type->printLeft(OB);
1192 if (!Type->hasRHSComponent(OB))
1198 Type->printRight(OB);
1210 :
Node(KTemplateTemplateParamDecl,
Cache::
Yes), Name(Name_),
1213 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Params); }
1219 OB +=
"> typename ";
1231 :
Node(KTemplateParamPackDecl,
Cache::
Yes), Param(Param_) {}
1233 template<
typename Fn>
void match(Fn
F)
const {
F(Param); }
1236 Param->printLeft(OB);
1257 if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
1258 OB.CurrentPackMax =
static_cast<unsigned>(Data.size());
1259 OB.CurrentPackIndex = 0;
1266 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1267 return P->ArrayCache == Cache::No;
1270 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1271 return P->FunctionCache == Cache::No;
1274 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1275 return P->RHSComponentCache == Cache::No;
1280 template<
typename Fn>
void match(Fn
F)
const {
F(Data); }
1283 initializePackExpansion(OB);
1284 size_t Idx = OB.CurrentPackIndex;
1285 return Idx < Data.size() && Data[
Idx]->hasRHSComponent(OB);
1288 initializePackExpansion(OB);
1289 size_t Idx = OB.CurrentPackIndex;
1290 return Idx < Data.size() && Data[
Idx]->hasArray(OB);
1293 initializePackExpansion(OB);
1294 size_t Idx = OB.CurrentPackIndex;
1295 return Idx < Data.size() && Data[
Idx]->hasFunction(OB);
1298 initializePackExpansion(OB);
1299 size_t Idx = OB.CurrentPackIndex;
1300 return Idx < Data.size() ? Data[
Idx]->getSyntaxNode(OB) :
this;
1304 initializePackExpansion(OB);
1305 size_t Idx = OB.CurrentPackIndex;
1306 if (
Idx < Data.size())
1307 Data[
Idx]->printLeft(OB);
1310 initializePackExpansion(OB);
1311 size_t Idx = OB.CurrentPackIndex;
1312 if (
Idx < Data.size())
1313 Data[
Idx]->printRight(OB);
1326 :
Node(KTemplateArgumentPack), Elements(Elements_) {}
1328 template<
typename Fn>
void match(Fn
F)
const {
F(Elements); }
1333 Elements.printWithComma(OB);
1344 :
Node(KParameterPackExpansion), Child(Child_) {}
1346 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1351 constexpr unsigned Max = std::numeric_limits<unsigned>::max();
1354 size_t StreamPos = OB.getCurrentPosition();
1362 if (OB.CurrentPackMax == Max) {
1369 if (OB.CurrentPackMax == 0) {
1370 OB.setCurrentPosition(StreamPos);
1375 for (
unsigned I = 1,
E = OB.CurrentPackMax;
I <
E; ++
I) {
1377 OB.CurrentPackIndex =
I;
1389 template<
typename Fn>
void match(Fn
F)
const {
F(Params); }
1396 Params.printWithComma(OB);
1437 template<
typename Fn>
void match(Fn
F)
const =
delete;
1501 :
Node(KGlobalQualifiedName), Child(Child_) {}
1503 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1543 case SpecialSubKind::allocator:
1545 case SpecialSubKind::basic_string:
1547 case SpecialSubKind::string:
1549 case SpecialSubKind::istream:
1551 case SpecialSubKind::ostream:
1553 case SpecialSubKind::iostream:
1563 OB <<
"<char, std::char_traits<char>";
1564 if (
SSK == SpecialSubKind::string)
1565 OB <<
", std::allocator<char>";
1582 assert(SV.startsWith(
"basic_"));
1583 SV = SV.dropFront(
sizeof(
"basic_") - 1);
1598 const Node *Basename;
1604 :
Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
1605 Variant(Variant_) {}
1607 template<
typename Fn>
void match(Fn
F)
const {
F(Basename, IsDtor, Variant); }
1612 OB += Basename->getBaseName();
1622 template<
typename Fn>
void match(Fn
F)
const {
F(Base); }
1626 Base->printLeft(OB);
1636 template<
typename Fn>
void match(Fn
F)
const {
F(Count); }
1653 :
Node(KClosureTypeName), TemplateParams(TemplateParams_),
1654 Params(Params_), Count(Count_) {}
1656 template<
typename Fn>
void match(Fn
F)
const {
1657 F(TemplateParams, Params, Count);
1661 if (!TemplateParams.
empty()) {
1684 :
Node(KStructuredBindingName), Bindings(Bindings_) {}
1686 template<
typename Fn>
void match(Fn
F)
const {
F(Bindings); }
1705 :
Node(KBinaryExpr, Prec_),
LHS(LHS_), InfixOperator(InfixOperator_),
1708 template <
typename Fn>
void match(Fn
F)
const {
1713 bool ParenAll = OB.isGtInsideTemplateArgs() &&
1714 (InfixOperator ==
">" || InfixOperator ==
">>");
1721 if (!(InfixOperator ==
","))
1723 OB += InfixOperator;
1737 :
Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
1739 template <
typename Fn>
void match(Fn
F)
const {
1757 :
Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
1759 template <
typename Fn>
void match(Fn
F)
const {
1777 :
Node(KConditionalExpr, Prec_),
Cond(Cond_), Then(Then_), Else(Else_) {}
1779 template <
typename Fn>
void match(Fn
F)
const {
1786 Then->printAsOperand(OB);
1801 template <
typename Fn>
void match(Fn
F)
const {
1814 const Node *SubExpr;
1821 NodeArray UnionSelectors_,
bool OnePastTheEnd_)
1822 :
Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
1823 UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
1825 template<
typename Fn>
void match(Fn
F)
const {
1826 F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
1833 OB +=
" at offset ";
1834 if (Offset.empty()) {
1836 }
else if (Offset[0] ==
'n') {
1838 OB += Offset.dropFront();
1854 :
Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
1856 template <
typename Fn>
void match(Fn
F)
const {
1877 :
Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_),
From(From_) {}
1879 template <
typename Fn>
void match(Fn
F)
const {
1892 From->printAsOperand(OB);
1902 :
Node(KSizeofParamPackExpr), Pack(Pack_) {}
1904 template<
typename Fn>
void match(Fn
F)
const {
F(Pack); }
1921 :
Node(KCallExpr, Prec_),
Callee(Callee_), Args(Args_) {}
1923 template <
typename Fn>
void match(Fn
F)
const {
1930 Args.printWithComma(OB);
1944 bool IsArray_,
Prec Prec_)
1945 :
Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
1946 InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
1948 template<
typename Fn>
void match(Fn
F)
const {
1958 if (!ExprList.
empty()) {
1965 if (!InitList.
empty()) {
1980 :
Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
1981 IsArray(IsArray_) {}
1983 template <
typename Fn>
void match(Fn
F)
const {
2004 :
Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
2006 template <
typename Fn>
void match(Fn
F)
const {
2036 :
Node(KConversionExpr, Prec_), Type(Type_),
Expressions(Expressions_) {}
2038 template <
typename Fn>
void match(Fn
F)
const {
2054 const Node *SubExpr;
2060 :
Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
2061 SubExpr(SubExpr_), Offset(Offset_) {}
2063 template <
typename Fn>
void match(Fn
F)
const {
2082 :
Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
2084 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Inits); }
2101 :
Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
2103 template<
typename Fn>
void match(Fn
F)
const {
F(Elem, Init, IsArray); }
2114 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2126 :
Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
2128 template<
typename Fn>
void match(Fn
F)
const {
F(First, Last, Init); }
2136 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2143 const Node *Pack, *Init;
2150 :
Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
2151 IsLeftFold(IsLeftFold_) {}
2153 template<
typename Fn>
void match(Fn
F)
const {
2154 F(IsLeftFold, OperatorName, Pack, Init);
2158 auto PrintPack = [&] {
2168 if (!IsLeftFold || Init !=
nullptr) {
2174 OB <<
" " << OperatorName <<
" ";
2177 if (IsLeftFold || Init !=
nullptr) {
2179 OB <<
" " << OperatorName <<
" ";
2195 template<
typename Fn>
void match(Fn
F)
const {
F(Op); }
2209 template<
typename Fn>
void match(Fn
F)
const {
F(Value); }
2222 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2237 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2241 if (Type->getKind() == KClosureTypeName)
2254 :
Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
2256 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Integer); }
2263 if (Integer[0] ==
'n')
2264 OB <<
"-" << Integer.dropFront(1);
2276 :
Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
2278 template<
typename Fn>
void match(Fn
F)
const {
F(Type, Value); }
2281 if (Type.size() > 3) {
2287 if (Value[0] ==
'n') {
2289 OB += Value.dropFront(1);
2293 if (Type.size() <= 3)
2302 return Node::KFloatLiteral;
2305 return Node::KDoubleLiteral;
2308 return Node::KLongDoubleLiteral;
2315 static constexpr Kind KindForClass =
2320 :
Node(KindForClass), Contents(Contents_) {}
2322 template<
typename Fn>
void match(Fn
F)
const {
F(Contents); }
2325 const char *first = Contents.
begin();
2326 const char *last = Contents.
end() + 1;
2329 if (
static_cast<std::size_t
>(last - first) >
N) {
2333 char buf[
sizeof(Float)];
2335 const char *t = first;
2337 for (; t != last; ++t, ++e) {
2338 unsigned d1 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2339 :
static_cast<unsigned>(*t -
'a' + 10);
2341 unsigned d0 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2342 :
static_cast<unsigned>(*t -
'a' + 10);
2343 *e =
static_cast<char>((d1 << 4) + d0);
2345#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
2346 std::reverse(buf, e);
2361template<
typename Fn>
2366 return F(static_cast<const X *>(this));
2367#include "ItaniumNodes.def"
2369 assert(0 &&
"unknown mangling node kind");
2375 template <> struct NodeKind<X> { \
2376 static constexpr Node::Kind Kind = Node::K##X; \
2377 static constexpr const char *name() { return #X; } \
2379#include "ItaniumNodes.def"
2399 size_t OldNumTemplateParamLists;
2404 : Parser(TheParser),
2443 void reset(
const char *First_,
const char *Last_) {
2452 for (
int I = 0;
I != 3; ++
I)
2462 size_t sz =
static_cast<size_t>(end - begin);
2464 Node **data =
new (mem)
Node *[sz];
2465 std::copy(begin, end, data);
2495 char look(
unsigned Lookahead = 0)
const {
2496 if (
static_cast<size_t>(
Last -
First) <= Lookahead)
2498 return First[Lookahead];
2559 for (;
I <
E; ++
I) {
2616 return *
this <
Other.Enc;
2619 return Enc[0] < Peek[0] || (
Enc[0] == Peek[0] &&
Enc[1] < Peek[1]);
2622 return Enc[0] == Peek[0] &&
Enc[1] == Peek[1];
2631 "operator name does not start with 'operator'");
2632 Res = Res.
dropFront(
sizeof(
"operator") - 1);
2666template <
typename Derived,
typename Alloc>
2669 return getDerived().parseNestedName(State);
2671 return getDerived().parseLocalName(State);
2673 Node *Result =
nullptr;
2674 bool IsSubst =
false;
2676 Result = getDerived().parseUnscopedName(State, &IsSubst);
2680 if (look() ==
'I') {
2685 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
2690 Result = make<NameWithTemplateArgs>(Result, TA);
2691 }
else if (IsSubst) {
2702template <
typename Derived,
typename Alloc>
2704 if (!consumeIf(
'Z'))
2706 Node *Encoding = getDerived().parseEncoding();
2707 if (Encoding ==
nullptr || !consumeIf(
'E'))
2710 if (consumeIf(
's')) {
2712 auto *StringLitName = make<NameType>(
"string literal");
2715 return make<LocalName>(Encoding, StringLitName);
2718 if (consumeIf(
'd')) {
2720 if (!consumeIf(
'_'))
2722 Node *
N = getDerived().parseName(State);
2725 return make<LocalName>(Encoding,
N);
2728 Node *Entity = getDerived().parseName(State);
2729 if (Entity ==
nullptr)
2732 return make<LocalName>(Encoding, Entity);
2738template <
typename Derived,
typename Alloc>
2743 Node *Std =
nullptr;
2744 if (consumeIf(
"St")) {
2745 Std = make<NameType>(
"std");
2750 Node *Res =
nullptr;
2752 if (look() ==
'S') {
2753 Node *S = getDerived().parseSubstitution();
2756 if (S->
getKind() == Node::KModuleName)
2758 else if (IsSubst && Std ==
nullptr) {
2766 if (Res ==
nullptr || Std !=
nullptr) {
2767 Res = getDerived().parseUnqualifiedName(State, Std,
Module);
2779template <
typename Derived,
typename Alloc>
2782 if (getDerived().parseModuleNameOpt(
Module))
2788 if (look() >=
'1' && look() <=
'9') {
2789 Result = getDerived().parseSourceName(State);
2790 }
else if (look() ==
'U') {
2791 Result = getDerived().parseUnnamedTypeName(State);
2792 }
else if (consumeIf(
"DC")) {
2794 size_t BindingsBegin = Names.
size();
2796 Node *Binding = getDerived().parseSourceName(State);
2797 if (Binding ==
nullptr)
2800 }
while (!consumeIf(
'E'));
2801 Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2802 }
else if (look() ==
'C' || look() ==
'D') {
2804 if (Scope ==
nullptr ||
Module !=
nullptr)
2806 Result = getDerived().parseCtorDtorName(Scope, State);
2808 Result = getDerived().parseOperatorName(State);
2811 if (Result !=
nullptr &&
Module !=
nullptr)
2812 Result = make<ModuleEntity>(
Module, Result);
2813 if (Result !=
nullptr)
2814 Result = getDerived().parseAbiTags(Result);
2815 if (Result !=
nullptr && Scope !=
nullptr)
2816 Result = make<NestedName>(Scope, Result);
2826template <
typename Derived,
typename Alloc>
2829 while (consumeIf(
'W')) {
2830 bool IsPartition = consumeIf(
'P');
2831 Node *Sub = getDerived().parseSourceName(
nullptr);
2848template <
typename Derived,
typename Alloc>
2853 if (State !=
nullptr)
2854 TemplateParams.
clear();
2856 if (consumeIf(
"Ut")) {
2858 if (!consumeIf(
'_'))
2860 return make<UnnamedTypeName>(Count);
2862 if (consumeIf(
"Ul")) {
2864 TemplateParams.
size());
2867 size_t ParamsBegin = Names.
size();
2868 while (look() ==
'T' &&
2870 Node *
T = parseTemplateParamDecl();
2875 NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
2899 if (TempParams.
empty())
2902 if (!consumeIf(
"vE")) {
2904 Node *
P = getDerived().parseType();
2908 }
while (!consumeIf(
'E'));
2910 NodeArray Params = popTrailingNodeArray(ParamsBegin);
2913 if (!consumeIf(
'_'))
2915 return make<ClosureTypeName>(TempParams, Params, Count);
2917 if (consumeIf(
"Ub")) {
2918 (void)parseNumber();
2919 if (!consumeIf(
'_'))
2921 return make<NameType>(
"'block-literal'");
2927template <
typename Derived,
typename Alloc>
2930 if (parsePositiveInteger(&Length))
2932 if (numLeft() < Length || Length == 0)
2936 if (
Name.startsWith(
"_GLOBAL__N"))
2937 return make<NameType>(
"(anonymous namespace)");
2938 return make<NameType>(
Name);
2942template <
typename Derived,
typename Alloc>
2954 "operator co_await"},
2963 "operator delete[]"},
3011 "reinterpret_cast"},
3023template <
typename Derived,
typename Alloc>
3029template <
typename Derived,
typename Alloc>
3037 size_t lower = 0u, upper = NumOps - 1;
3038 while (upper != lower) {
3039 size_t middle = (upper + lower) / 2;
3040 if (Ops[middle] < First)
3045 if (Ops[lower] != First)
3055template <
typename Derived,
typename Alloc>
3058 if (
const auto *Op = parseOperatorEncoding()) {
3059 if (Op->getKind() == OperatorInfo::CCast) {
3066 PermitForwardTemplateReferences ||
3068 Node *Ty = getDerived().parseType();
3072 return make<ConversionOperatorType>(Ty);
3075 if (Op->getKind() >= OperatorInfo::Unnameable)
3078 if (Op->getKind() == OperatorInfo::Member && !Op->getFlag())
3082 return make<NameType>(Op->getName());
3085 if (consumeIf(
"li")) {
3087 Node *SN = getDerived().parseSourceName(State);
3090 return make<LiteralOperator>(SN);
3093 if (consumeIf(
'v')) {
3095 if (look() >=
'0' && look() <=
'9') {
3097 Node *SN = getDerived().parseSourceName(State);
3100 return make<ConversionOperatorType>(SN);
3118template <
typename Derived,
typename Alloc>
3122 if (SoFar->
getKind() == Node::KSpecialSubstitution) {
3124 SoFar = make<ExpandedSpecialSubstitution>(
3130 if (consumeIf(
'C')) {
3131 bool IsInherited = consumeIf(
'I');
3132 if (look() !=
'1' && look() !=
'2' && look() !=
'3' && look() !=
'4' &&
3135 int Variant = look() -
'0';
3139 if (getDerived().parseName(State) ==
nullptr)
3142 return make<CtorDtorName>(SoFar,
false, Variant);
3145 if (look() ==
'D' && (look(1) ==
'0' || look(1) ==
'1' || look(1) ==
'2' ||
3146 look(1) ==
'4' || look(1) ==
'5')) {
3147 int Variant = look(1) -
'0';
3150 return make<CtorDtorName>(SoFar,
true, Variant);
3175template <
typename Derived,
typename Alloc>
3178 if (!consumeIf(
'N'))
3184 if (consumeIf(
'O')) {
3186 }
else if (consumeIf(
'R')) {
3192 Node *SoFar =
nullptr;
3193 while (!consumeIf(
'E')) {
3198 if (look() ==
'T') {
3200 if (SoFar !=
nullptr)
3202 SoFar = getDerived().parseTemplateParam();
3203 }
else if (look() ==
'I') {
3205 if (SoFar ==
nullptr)
3207 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
3210 if (SoFar->
getKind() == Node::KNameWithTemplateArgs)
3217 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3218 }
else if (look() ==
'D' && (look(1) ==
't' || look(1) ==
'T')) {
3220 if (SoFar !=
nullptr)
3222 SoFar = getDerived().parseDecltype();
3226 if (look() ==
'S') {
3229 if (look(1) ==
't') {
3231 S = make<NameType>(
"std");
3233 S = getDerived().parseSubstitution();
3237 if (S->
getKind() == Node::KModuleName) {
3239 }
else if (SoFar !=
nullptr) {
3248 SoFar = getDerived().parseUnqualifiedName(State, SoFar,
Module);
3251 if (SoFar ==
nullptr)
3260 if (SoFar ==
nullptr || Subs.
empty())
3268template <
typename Derived,
typename Alloc>
3270 Node *SN = getDerived().parseSourceName(
nullptr);
3273 if (look() ==
'I') {
3274 Node *TA = getDerived().parseTemplateArgs();
3277 return make<NameWithTemplateArgs>(SN, TA);
3284template <
typename Derived,
typename Alloc>
3287 if (std::isdigit(look()))
3288 Result = getDerived().parseSimpleId();
3290 Result = getDerived().parseUnresolvedType();
3291 if (Result ==
nullptr)
3293 return make<DtorName>(Result);
3299template <
typename Derived,
typename Alloc>
3301 if (look() ==
'T') {
3302 Node *TP = getDerived().parseTemplateParam();
3308 if (look() ==
'D') {
3309 Node *DT = getDerived().parseDecltype();
3315 return getDerived().parseSubstitution();
3325template <
typename Derived,
typename Alloc>
3327 if (std::isdigit(look()))
3328 return getDerived().parseSimpleId();
3330 if (consumeIf(
"dn"))
3331 return getDerived().parseDestructorName();
3335 Node *Oper = getDerived().parseOperatorName(
nullptr);
3336 if (Oper ==
nullptr)
3338 if (look() ==
'I') {
3339 Node *TA = getDerived().parseTemplateArgs();
3342 return make<NameWithTemplateArgs>(Oper, TA);
3359template <
typename Derived,
typename Alloc>
3361 Node *SoFar =
nullptr;
3365 if (consumeIf(
"srN")) {
3366 SoFar = getDerived().parseUnresolvedType();
3367 if (SoFar ==
nullptr)
3370 if (look() ==
'I') {
3371 Node *TA = getDerived().parseTemplateArgs();
3374 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3379 while (!consumeIf(
'E')) {
3380 Node *Qual = getDerived().parseSimpleId();
3381 if (Qual ==
nullptr)
3383 SoFar = make<QualifiedName>(SoFar, Qual);
3388 Node *Base = getDerived().parseBaseUnresolvedName();
3389 if (Base ==
nullptr)
3391 return make<QualifiedName>(SoFar, Base);
3395 if (!consumeIf(
"sr")) {
3396 SoFar = getDerived().parseBaseUnresolvedName();
3397 if (SoFar ==
nullptr)
3400 SoFar = make<GlobalQualifiedName>(SoFar);
3405 if (std::isdigit(look())) {
3407 Node *Qual = getDerived().parseSimpleId();
3408 if (Qual ==
nullptr)
3411 SoFar = make<QualifiedName>(SoFar, Qual);
3413 SoFar = make<GlobalQualifiedName>(Qual);
3418 }
while (!consumeIf(
'E'));
3423 SoFar = getDerived().parseUnresolvedType();
3424 if (SoFar ==
nullptr)
3427 if (look() ==
'I') {
3428 Node *TA = getDerived().parseTemplateArgs();
3431 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3437 assert(SoFar !=
nullptr);
3439 Node *Base = getDerived().parseBaseUnresolvedName();
3440 if (Base ==
nullptr)
3442 return make<QualifiedName>(SoFar, Base);
3447template <
typename Derived,
typename Alloc>
3449 while (consumeIf(
'B')) {
3453 N = make<AbiTagAttr>(
N, SN);
3461template <
typename Alloc,
typename Derived>
3464 const char *Tmp = First;
3467 if (numLeft() == 0 || !std::isdigit(*First))
3469 while (numLeft() != 0 && std::isdigit(*First))
3475template <
typename Alloc,
typename Derived>
3478 if (look() <
'0' || look() >
'9')
3480 while (look() >=
'0' && look() <=
'9') {
3482 *Out +=
static_cast<size_t>(
consume() -
'0');
3487template <
typename Alloc,
typename Derived>
3490 if (parsePositiveInteger(&
Int) || numLeft() <
Int)
3505template <
typename Derived,
typename Alloc>
3509 Node *ExceptionSpec =
nullptr;
3510 if (consumeIf(
"Do")) {
3511 ExceptionSpec = make<NameType>(
"noexcept");
3514 }
else if (consumeIf(
"DO")) {
3515 Node *
E = getDerived().parseExpr();
3516 if (
E ==
nullptr || !consumeIf(
'E'))
3518 ExceptionSpec = make<NoexceptSpec>(
E);
3521 }
else if (consumeIf(
"Dw")) {
3522 size_t SpecsBegin = Names.
size();
3523 while (!consumeIf(
'E')) {
3524 Node *
T = getDerived().parseType();
3530 make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
3537 if (!consumeIf(
'F'))
3540 Node *ReturnType = getDerived().parseType();
3541 if (ReturnType ==
nullptr)
3545 size_t ParamsBegin = Names.
size();
3551 if (consumeIf(
"RE")) {
3555 if (consumeIf(
"OE")) {
3559 Node *
T = getDerived().parseType();
3565 NodeArray Params = popTrailingNodeArray(ParamsBegin);
3566 return make<FunctionType>(ReturnType, Params, CVQuals,
3567 ReferenceQualifier, ExceptionSpec);
3575template <
typename Derived,
typename Alloc>
3577 if (!consumeIf(
"Dv"))
3579 if (look() >=
'1' && look() <=
'9') {
3580 Node *DimensionNumber = make<NameType>(parseNumber());
3581 if (!DimensionNumber)
3583 if (!consumeIf(
'_'))
3586 return make<PixelVectorType>(DimensionNumber);
3587 Node *ElemType = getDerived().parseType();
3588 if (ElemType ==
nullptr)
3590 return make<VectorType>(ElemType, DimensionNumber);
3593 if (!consumeIf(
'_')) {
3594 Node *DimExpr = getDerived().parseExpr();
3597 if (!consumeIf(
'_'))
3599 Node *ElemType = getDerived().parseType();
3602 return make<VectorType>(ElemType, DimExpr);
3604 Node *ElemType = getDerived().parseType();
3607 return make<VectorType>(ElemType,
nullptr);
3612template <
typename Derived,
typename Alloc>
3614 if (!consumeIf(
'D'))
3616 if (!consumeIf(
't') && !consumeIf(
'T'))
3618 Node *
E = getDerived().parseExpr();
3621 if (!consumeIf(
'E'))
3623 return make<EnclosingExpr>(
"decltype",
E);
3628template <
typename Derived,
typename Alloc>
3630 if (!consumeIf(
'A'))
3633 Node *Dimension =
nullptr;
3635 if (std::isdigit(look())) {
3636 Dimension = make<NameType>(parseNumber());
3639 if (!consumeIf(
'_'))
3641 }
else if (!consumeIf(
'_')) {
3642 Node *DimExpr = getDerived().parseExpr();
3643 if (DimExpr ==
nullptr)
3645 if (!consumeIf(
'_'))
3647 Dimension = DimExpr;
3650 Node *Ty = getDerived().parseType();
3653 return make<ArrayType>(Ty, Dimension);
3657template <
typename Derived,
typename Alloc>
3659 if (!consumeIf(
'M'))
3661 Node *ClassType = getDerived().parseType();
3662 if (ClassType ==
nullptr)
3664 Node *MemberType = getDerived().parseType();
3665 if (MemberType ==
nullptr)
3667 return make<PointerToMemberType>(ClassType, MemberType);
3674template <
typename Derived,
typename Alloc>
3677 if (consumeIf(
"Ts"))
3678 ElabSpef =
"struct";
3679 else if (consumeIf(
"Tu"))
3681 else if (consumeIf(
"Te"))
3684 Node *
Name = getDerived().parseName();
3685 if (
Name ==
nullptr)
3688 if (!ElabSpef.
empty())
3689 return make<ElaboratedTypeSpefType>(ElabSpef,
Name);
3697template <
typename Derived,
typename Alloc>
3699 if (consumeIf(
'U')) {
3710 SaveLast(Last, ProtoSourceName.
end());
3711 Proto = parseBareSourceName();
3715 Node *Child = getDerived().parseQualifiedType();
3716 if (Child ==
nullptr)
3718 return make<ObjCProtoName>(Child, Proto);
3722 if (look() ==
'I') {
3723 TA = getDerived().parseTemplateArgs();
3728 Node *Child = getDerived().parseQualifiedType();
3729 if (Child ==
nullptr)
3731 return make<VendorExtQualType>(Child, Qual, TA);
3735 Node *Ty = getDerived().parseType();
3739 Ty = make<QualType>(Ty, Quals);
3763template <
typename Derived,
typename Alloc>
3765 Node *Result =
nullptr;
3772 unsigned AfterQuals = 0;
3773 if (look(AfterQuals) ==
'r') ++AfterQuals;
3774 if (look(AfterQuals) ==
'V') ++AfterQuals;
3775 if (look(AfterQuals) ==
'K') ++AfterQuals;
3777 if (look(AfterQuals) ==
'F' ||
3778 (look(AfterQuals) ==
'D' &&
3779 (look(AfterQuals + 1) ==
'o' || look(AfterQuals + 1) ==
'O' ||
3780 look(AfterQuals + 1) ==
'w' || look(AfterQuals + 1) ==
'x'))) {
3781 Result = getDerived().parseFunctionType();
3787 Result = getDerived().parseQualifiedType();
3793 return make<NameType>(
"void");
3797 return make<NameType>(
"wchar_t");
3801 return make<NameType>(
"bool");
3805 return make<NameType>(
"char");
3809 return make<NameType>(
"signed char");
3813 return make<NameType>(
"unsigned char");
3817 return make<NameType>(
"short");
3821 return make<NameType>(
"unsigned short");
3825 return make<NameType>(
"int");
3829 return make<NameType>(
"unsigned int");
3833 return make<NameType>(
"long");
3837 return make<NameType>(
"unsigned long");
3841 return make<NameType>(
"long long");
3845 return make<NameType>(
"unsigned long long");
3849 return make<NameType>(
"__int128");
3853 return make<NameType>(
"unsigned __int128");
3857 return make<NameType>(
"float");
3861 return make<NameType>(
"double");
3865 return make<NameType>(
"long double");
3869 return make<NameType>(
"__float128");
3873 return make<NameType>(
"...");
3884 Result = make<NameType>(Res);
3892 return make<NameType>(
"decimal64");
3896 return make<NameType>(
"decimal128");
3900 return make<NameType>(
"decimal32");
3904 return make<NameType>(
"half");
3908 Node *DimensionNumber = make<NameType>(parseNumber());
3909 if (!DimensionNumber)
3911 if (!consumeIf(
'_'))
3913 return make<BinaryFPType>(DimensionNumber);
3921 bool Signed = look(1) ==
'B';
3923 Node *
Size = std::isdigit(look()) ? make<NameType>(parseNumber())
3924 : getDerived().parseExpr();
3927 if (!consumeIf(
'_'))
3934 return make<NameType>(
"char32_t");
3938 return make<NameType>(
"char16_t");
3942 return make<NameType>(
"char8_t");
3946 return make<NameType>(
"auto");
3950 return make<NameType>(
"decltype(auto)");
3954 return make<NameType>(
"std::nullptr_t");
3959 Result = getDerived().parseDecltype();
3964 Result = getDerived().parseVectorType();
3970 Node *Child = getDerived().parseType();
3973 Result = make<ParameterPackExpansion>(Child);
3982 Result = getDerived().parseFunctionType();
3988 Result = getDerived().parseFunctionType();
3993 Result = getDerived().parseArrayType();
3998 Result = getDerived().parsePointerToMemberType();
4004 if (look(1) ==
's' || look(1) ==
'u' || look(1) ==
'e') {
4005 Result = getDerived().parseClassEnumType();
4009 Result = getDerived().parseTemplateParam();
4010 if (Result ==
nullptr)
4023 if (TryToParseTemplateArgs && look() ==
'I') {
4024 Node *TA = getDerived().parseTemplateArgs();
4027 Result = make<NameWithTemplateArgs>(Result, TA);
4034 Node *
Ptr = getDerived().parseType();
4037 Result = make<PointerType>(
Ptr);
4043 Node *Ref = getDerived().parseType();
4052 Node *Ref = getDerived().parseType();
4061 Node *
P = getDerived().parseType();
4064 Result = make<PostfixQualifiedType>(
P,
" complex");
4070 Node *
P = getDerived().parseType();
4073 Result = make<PostfixQualifiedType>(
P,
" imaginary");
4078 if (look(1) !=
't') {
4079 bool IsSubst =
false;
4080 Result = getDerived().parseUnscopedName(
nullptr, &IsSubst);
4094 if (look() ==
'I' && (!IsSubst || TryToParseTemplateArgs)) {
4097 Node *TA = getDerived().parseTemplateArgs();
4100 Result = make<NameWithTemplateArgs>(Result, TA);
4101 }
else if (IsSubst) {
4112 Result = getDerived().parseClassEnumType();
4120 if (Result !=
nullptr)
4125template <
typename Derived,
typename Alloc>
4128 Node *
E = getDerived().parseExpr();
4131 return make<PrefixExpr>(Kind,
E, Prec);
4134template <
typename Derived,
typename Alloc>
4137 Node *
LHS = getDerived().parseExpr();
4140 Node *
RHS = getDerived().parseExpr();
4143 return make<BinaryExpr>(
LHS, Kind,
RHS, Prec);
4146template <
typename Derived,
typename Alloc>
4150 if (!Tmp.
empty() && consumeIf(
'E'))
4151 return make<IntegerLiteral>(Lit, Tmp);
4156template <
typename Alloc,
typename Derived>
4173template <
typename Derived,
typename Alloc>
4175 if (consumeIf(
"fpT"))
4176 return make<NameType>(
"this");
4177 if (consumeIf(
"fp")) {
4178 parseCVQualifiers();
4180 if (!consumeIf(
'_'))
4182 return make<FunctionParam>(Num);
4184 if (consumeIf(
"fL")) {
4185 if (parseNumber().empty())
4187 if (!consumeIf(
'p'))
4189 parseCVQualifiers();
4191 if (!consumeIf(
'_'))
4193 return make<FunctionParam>(Num);
4200template <
typename Derived,
typename Alloc>
4202 if (!consumeIf(
"cv"))
4207 Ty = getDerived().parseType();
4213 if (consumeIf(
'_')) {
4214 size_t ExprsBegin = Names.
size();
4215 while (!consumeIf(
'E')) {
4216 Node *
E = getDerived().parseExpr();
4221 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4222 return make<ConversionExpr>(Ty, Exprs);
4225 Node *
E[1] = {getDerived().parseExpr()};
4226 if (
E[0] ==
nullptr)
4228 return make<ConversionExpr>(Ty, makeNodeArray(
E,
E + 1));
4238template <
typename Derived,
typename Alloc>
4240 if (!consumeIf(
'L'))
4245 return getDerived().parseIntegerLiteral(
"wchar_t");
4247 if (consumeIf(
"b0E"))
4248 return make<BoolExpr>(0);
4249 if (consumeIf(
"b1E"))
4250 return make<BoolExpr>(1);
4254 return getDerived().parseIntegerLiteral(
"char");
4257 return getDerived().parseIntegerLiteral(
"signed char");
4260 return getDerived().parseIntegerLiteral(
"unsigned char");
4263 return getDerived().parseIntegerLiteral(
"short");
4266 return getDerived().parseIntegerLiteral(
"unsigned short");
4269 return getDerived().parseIntegerLiteral(
"");
4272 return getDerived().parseIntegerLiteral(
"u");
4275 return getDerived().parseIntegerLiteral(
"l");
4278 return getDerived().parseIntegerLiteral(
"ul");
4281 return getDerived().parseIntegerLiteral(
"ll");
4284 return getDerived().parseIntegerLiteral(
"ull");
4287 return getDerived().parseIntegerLiteral(
"__int128");
4290 return getDerived().parseIntegerLiteral(
"unsigned __int128");
4293 return getDerived().template parseFloatingLiteral<float>();
4296 return getDerived().template parseFloatingLiteral<double>();
4299#if defined(__powerpc__) || defined(__s390__)
4302 return getDerived().template parseFloatingLiteral<double>();
4304 return getDerived().template parseFloatingLiteral<long double>();
4307 if (consumeIf(
"_Z")) {
4308 Node *R = getDerived().parseEncoding();
4309 if (R !=
nullptr && consumeIf(
'E'))
4314 Node *
T = getDerived().parseType();
4319 return make<StringLiteral>(
T);
4323 if (consumeIf(
"Dn") && (consumeIf(
'0'), consumeIf(
'E')))
4324 return make<NameType>(
"nullptr");
4334 Node *
T = parseUnnamedTypeName(
nullptr);
4335 if (!
T || !consumeIf(
'E'))
4337 return make<LambdaExpr>(
T);
4341 Node *
T = getDerived().parseType();
4347 if (!consumeIf(
'E'))
4349 return make<EnumLiteral>(
T,
N);
4358template <
typename Derived,
typename Alloc>
4360 if (look() ==
'd') {
4364 Node *
Field = getDerived().parseSourceName(
nullptr);
4365 if (
Field ==
nullptr)
4367 Node *Init = getDerived().parseBracedExpr();
4368 if (Init ==
nullptr)
4370 return make<BracedExpr>(
Field, Init,
false);
4375 if (
Index ==
nullptr)
4377 Node *Init = getDerived().parseBracedExpr();
4378 if (Init ==
nullptr)
4380 return make<BracedExpr>(
Index, Init,
true);
4384 Node *RangeBegin = getDerived().parseExpr();
4385 if (RangeBegin ==
nullptr)
4387 Node *RangeEnd = getDerived().parseExpr();
4388 if (RangeEnd ==
nullptr)
4390 Node *Init = getDerived().parseBracedExpr();
4391 if (Init ==
nullptr)
4393 return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
4397 return getDerived().parseExpr();
4405template <
typename Derived,
typename Alloc>
4407 if (!consumeIf(
'f'))
4410 bool IsLeftFold =
false, HasInitializer =
false;
4416 HasInitializer =
true;
4419 HasInitializer =
true;
4429 const auto *Op = parseOperatorEncoding();
4432 if (!(Op->getKind() == OperatorInfo::Binary
4433 || (Op->getKind() == OperatorInfo::Member
4434 && Op->getName().back() ==
'*')))
4437 Node *Pack = getDerived().parseExpr();
4438 if (Pack ==
nullptr)
4441 Node *Init =
nullptr;
4442 if (HasInitializer) {
4443 Init = getDerived().parseExpr();
4444 if (Init ==
nullptr)
4448 if (IsLeftFold && Init)
4451 return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
4457template <
typename Derived,
typename Alloc>
4461 Node *Ty = getDerived().parseType();
4464 Node *Expr = getDerived().parseExpr();
4468 if (!consumeIf(
'E'))
4470 return make<PointerToMemberConversionExpr>(Ty, Expr,
Offset, Prec);
4477template <
typename Derived,
typename Alloc>
4479 Node *Ty = getDerived().parseType();
4482 Node *Expr = getDerived().parseExpr();
4486 size_t SelectorsBegin = Names.
size();
4487 while (consumeIf(
'_')) {
4488 Node *Selector = make<NameType>(parseNumber());
4493 bool OnePastTheEnd = consumeIf(
'p');
4494 if (!consumeIf(
'E'))
4496 return make<SubobjectExpr>(
4497 Ty, Expr,
Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
4544template <
typename Derived,
typename Alloc>
4546 bool Global = consumeIf(
"gs");
4548 const auto *Op = parseOperatorEncoding();
4550 auto Sym = Op->getSymbol();
4551 switch (Op->getKind()) {
4552 case OperatorInfo::Binary:
4554 return getDerived().parseBinaryExpr(Sym, Op->getPrecedence());
4555 case OperatorInfo::Prefix:
4557 return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
4558 case OperatorInfo::Postfix: {
4561 return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
4562 Node *Ex = getDerived().parseExpr();
4565 return make<PostfixExpr>(Ex, Sym, Op->getPrecedence());
4567 case OperatorInfo::Array: {
4569 Node *Base = getDerived().parseExpr();
4570 if (Base ==
nullptr)
4573 if (
Index ==
nullptr)
4575 return make<ArraySubscriptExpr>(Base,
Index, Op->getPrecedence());
4577 case OperatorInfo::Member: {
4579 Node *
LHS = getDerived().parseExpr();
4582 Node *
RHS = getDerived().parseExpr();
4585 return make<MemberExpr>(
LHS, Sym,
RHS, Op->getPrecedence());
4587 case OperatorInfo::New: {
4593 size_t Exprs = Names.
size();
4594 while (!consumeIf(
'_')) {
4595 Node *Ex = getDerived().parseExpr();
4600 NodeArray ExprList = popTrailingNodeArray(Exprs);
4601 Node *Ty = getDerived().parseType();
4604 bool HaveInits = consumeIf(
"pi");
4605 size_t InitsBegin = Names.
size();
4606 while (!consumeIf(
'E')) {
4609 Node *Init = getDerived().parseExpr();
4610 if (Init ==
nullptr)
4614 NodeArray Inits = popTrailingNodeArray(InitsBegin);
4615 return make<NewExpr>(ExprList, Ty, Inits, Global,
4616 Op->getFlag(), Op->getPrecedence());
4618 case OperatorInfo::Del: {
4620 Node *Ex = getDerived().parseExpr();
4623 return make<DeleteExpr>(Ex, Global, Op->getFlag(),
4624 Op->getPrecedence());
4626 case OperatorInfo::Call: {
4631 size_t ExprsBegin = Names.
size();
4632 while (!consumeIf(
'E')) {
4633 Node *
E = getDerived().parseExpr();
4638 return make<CallExpr>(
Callee, popTrailingNodeArray(ExprsBegin),
4639 Op->getPrecedence());
4641 case OperatorInfo::CCast: {
4646 Ty = getDerived().parseType();
4651 size_t ExprsBegin = Names.
size();
4652 bool IsMany = consumeIf(
'_');
4653 while (!consumeIf(
'E')) {
4654 Node *
E = getDerived().parseExpr();
4661 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4662 if (!IsMany && Exprs.
size() != 1)
4664 return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence());
4666 case OperatorInfo::Conditional: {
4668 Node *
Cond = getDerived().parseExpr();
4669 if (
Cond ==
nullptr)
4671 Node *
LHS = getDerived().parseExpr();
4674 Node *
RHS = getDerived().parseExpr();
4677 return make<ConditionalExpr>(
Cond,
LHS,
RHS, Op->getPrecedence());
4679 case OperatorInfo::NamedCast: {
4681 Node *Ty = getDerived().parseType();
4684 Node *Ex = getDerived().parseExpr();
4687 return make<CastExpr>(Sym, Ty, Ex, Op->getPrecedence());
4689 case OperatorInfo::OfIdOp: {
4692 Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
4695 return make<EnclosingExpr>(Sym,
Arg, Op->getPrecedence());
4697 case OperatorInfo::NameOnly: {
4709 return getDerived().parseExprPrimary();
4711 return getDerived().parseTemplateParam();
4712 if (look() ==
'f') {
4714 if (look(1) ==
'p' || (look(1) ==
'L' && std::isdigit(look(2))))
4715 return getDerived().parseFunctionParam();
4716 return getDerived().parseFoldExpr();
4718 if (consumeIf(
"il")) {
4719 size_t InitsBegin = Names.
size();
4720 while (!consumeIf(
'E')) {
4721 Node *
E = getDerived().parseBracedExpr();
4726 return make<InitListExpr>(
nullptr, popTrailingNodeArray(InitsBegin));
4728 if (consumeIf(
"mc"))
4730 if (consumeIf(
"nx")) {
4731 Node *Ex = getDerived().parseExpr();
4736 if (consumeIf(
"so"))
4737 return parseSubobjectExpr();
4738 if (consumeIf(
"sp")) {
4739 Node *Child = getDerived().parseExpr();
4740 if (Child ==
nullptr)
4742 return make<ParameterPackExpansion>(Child);
4744 if (consumeIf(
"sZ")) {
4745 if (look() ==
'T') {
4746 Node *R = getDerived().parseTemplateParam();
4749 return make<SizeofParamPackExpr>(R);
4751 Node *
FP = getDerived().parseFunctionParam();
4754 return make<EnclosingExpr>(
"sizeof... ",
FP);
4756 if (consumeIf(
"sP")) {
4757 size_t ArgsBegin = Names.
size();
4758 while (!consumeIf(
'E')) {
4759 Node *
Arg = getDerived().parseTemplateArg();
4764 auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
4767 return make<EnclosingExpr>(
"sizeof... ", Pack);
4769 if (consumeIf(
"tl")) {
4770 Node *Ty = getDerived().parseType();
4773 size_t InitsBegin = Names.
size();
4774 while (!consumeIf(
'E')) {
4775 Node *
E = getDerived().parseBracedExpr();
4780 return make<InitListExpr>(Ty, popTrailingNodeArray(InitsBegin));
4782 if (consumeIf(
"tr"))
4783 return make<NameType>(
"throw");
4784 if (consumeIf(
"tw")) {
4785 Node *Ex = getDerived().parseExpr();
4788 return make<ThrowExpr>(Ex);
4790 if (consumeIf(
'u')) {
4791 Node *
Name = getDerived().parseSourceName(
nullptr);
4799 bool IsUUID =
false;
4801 if (
Name->getBaseName() ==
"__uuidof") {
4802 if (consumeIf(
't')) {
4803 UUID = getDerived().parseType();
4805 }
else if (consumeIf(
'z')) {
4806 UUID = getDerived().parseExpr();
4810 size_t ExprsBegin = Names.
size();
4812 if (
UUID ==
nullptr)
4816 while (!consumeIf(
'E')) {
4817 Node *
E = getDerived().parseTemplateArg();
4823 return make<CallExpr>(
Name, popTrailingNodeArray(ExprsBegin),
4828 return getDerived().parseUnresolvedName(Global);
4839template <
typename Alloc,
typename Derived>
4844 return parseNumber(
true).empty() || !consumeIf(
'_');
4846 return parseNumber(
true).empty() || !consumeIf(
'_') ||
4847 parseNumber(
true).empty() || !consumeIf(
'_');
4872template <
typename Derived,
typename Alloc>
4882 Node *
Arg = getDerived().parseTemplateArg();
4885 return make<SpecialName>(
"template parameter object for ",
Arg);
4890 Node *Ty = getDerived().parseType();
4893 return make<SpecialName>(
"vtable for ", Ty);
4898 Node *Ty = getDerived().parseType();
4901 return make<SpecialName>(
"VTT for ", Ty);
4906 Node *Ty = getDerived().parseType();
4909 return make<SpecialName>(
"typeinfo for ", Ty);
4914 Node *Ty = getDerived().parseType();
4917 return make<SpecialName>(
"typeinfo name for ", Ty);
4922 if (parseCallOffset() || parseCallOffset())
4924 Node *Encoding = getDerived().parseEncoding();
4925 if (Encoding ==
nullptr)
4927 return make<SpecialName>(
"covariant return thunk to ", Encoding);
4933 Node *FirstType = getDerived().parseType();
4934 if (FirstType ==
nullptr)
4936 if (parseNumber(
true).empty() || !consumeIf(
'_'))
4938 Node *SecondType = getDerived().parseType();
4939 if (SecondType ==
nullptr)
4941 return make<CtorVtableSpecialName>(SecondType, FirstType);
4946 Node *
Name = getDerived().parseName();
4947 if (
Name ==
nullptr)
4949 return make<SpecialName>(
"thread-local wrapper routine for ",
Name);
4954 Node *
Name = getDerived().parseName();
4955 if (
Name ==
nullptr)
4957 return make<SpecialName>(
"thread-local initialization routine for ",
Name);
4962 bool IsVirt = look() ==
'v';
4963 if (parseCallOffset())
4965 Node *BaseEncoding = getDerived().parseEncoding();
4966 if (BaseEncoding ==
nullptr)
4969 return make<SpecialName>(
"virtual thunk to ", BaseEncoding);
4971 return make<SpecialName>(
"non-virtual thunk to ", BaseEncoding);
4979 Node *
Name = getDerived().parseName();
4980 if (
Name ==
nullptr)