16 #ifndef DEMANGLE_ITANIUMDEMANGLE_H
17 #define DEMANGLE_ITANIUMDEMANGLE_H
34 static_assert(std::is_pod<T>::value,
35 "T is required to be a plain old data type");
42 bool isInline()
const {
return First == Inline; }
50 void reserve(
size_t NewCap) {
53 auto *Tmp =
static_cast<T *
>(std::malloc(NewCap *
sizeof(
T)));
59 First =
static_cast<T *
>(std::realloc(
First, NewCap *
sizeof(
T)));
74 if (
Other.isInline()) {
88 if (
Other.isInline()) {
136 size_t size()
const {
return static_cast<size_t>(Last -
First); }
138 assert(Last !=
First &&
"Calling back() on empty vector!");
158 #define NODE(NodeKind) K##NodeKind,
159 #include "ItaniumNodes.def"
218 :
Node(K_,
Prec::Primary, RHSComponentCache_, ArrayCache_,
222 template<
typename Fn>
void visit(Fn
F)
const;
263 bool StrictlyWorse =
false)
const {
265 unsigned(
getPrecedence()) >= unsigned(
P) + unsigned(StrictlyWorse);
291 virtual ~Node() =
default;
305 : Elements(Elements_), NumElements(NumElements_) {}
307 bool empty()
const {
return NumElements == 0; }
308 size_t size()
const {
return NumElements; }
311 Node **
end()
const {
return Elements + NumElements; }
316 bool FirstElement =
true;
317 for (
size_t Idx = 0; Idx != NumElements; ++Idx) {
318 size_t BeforeComma =
OB.getCurrentPosition();
321 size_t AfterComma =
OB.getCurrentPosition();
326 if (AfterComma ==
OB.getCurrentPosition()) {
327 OB.setCurrentPosition(BeforeComma);
331 FirstElement =
false;
351 :
Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
353 template<
typename Fn>
void match(Fn
F)
const {
F(Prefix, Suffix); }
370 :
Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
372 template <
typename Fn>
void match(Fn
F)
const {
F(Ty, Ext, TA); }
445 :
Node(KConversionOperatorType), Ty(Ty_) {}
447 template<
typename Fn>
void match(Fn
F)
const {
F(Ty); }
461 :
Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
463 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Postfix); }
477 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
491 :
Node(KBitIntType), Size(Size_), Signed(Signed_) {}
493 template <
typename Fn>
void match(Fn
F)
const {
F(Size, Signed); }
500 Size->printAsOperand(
OB);
510 :
Node(KElaboratedTypeSpefType),
Kind(Kind_), Child(Child_) {}
544 :
Node(KEnableIfAttr), Conditions(Conditions_) {}
546 template<
typename Fn>
void match(Fn
F)
const {
F(Conditions); }
549 OB +=
" [enable_if:";
563 :
Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
565 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Protocol); }
568 return Ty->
getKind() == KNameType &&
588 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee); }
591 return Pointee->hasRHSComponent(
OB);
596 if (Pointee->getKind() != KObjCProtoName ||
598 Pointee->printLeft(
OB);
599 if (Pointee->hasArray(
OB))
601 if (Pointee->hasArray(
OB) || Pointee->hasFunction(
OB))
605 const auto *objcProto =
static_cast<const ObjCProtoName *
>(Pointee);
607 OB += objcProto->Protocol;
613 if (Pointee->getKind() != KObjCProtoName ||
615 if (Pointee->hasArray(
OB) || Pointee->hasFunction(
OB))
617 Pointee->printRight(
OB);
632 mutable bool Printing =
false;
641 std::pair<ReferenceKind, const Node *> collapse(
OutputBuffer &
OB)
const {
642 auto SoFar = std::make_pair(RK, Pointee);
648 if (SN->
getKind() != KReferenceType)
651 SoFar.second = RT->Pointee;
652 SoFar.first =
std::min(SoFar.first, RT->RK);
656 if (Prev.
size() > 1 && SoFar.second == Prev[(Prev.
size() - 1) / 2]) {
658 SoFar.second =
nullptr;
668 Pointee(Pointee_), RK(RK_) {}
670 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee, RK); }
680 std::pair<ReferenceKind, const Node *> Collapsed = collapse(
OB);
681 if (!Collapsed.second)
683 Collapsed.second->printLeft(
OB);
684 if (Collapsed.second->hasArray(
OB))
686 if (Collapsed.second->hasArray(
OB) || Collapsed.second->hasFunction(
OB))
695 std::pair<ReferenceKind, const Node *> Collapsed = collapse(
OB);
696 if (!Collapsed.second)
698 if (Collapsed.second->hasArray(
OB) || Collapsed.second->hasFunction(
OB))
700 Collapsed.second->printRight(
OB);
705 const Node *ClassType;
706 const Node *MemberType;
711 ClassType(ClassType_), MemberType(MemberType_) {}
713 template<
typename Fn>
void match(Fn
F)
const {
F(ClassType, MemberType); }
725 ClassType->print(
OB);
745 Base(Base_), Dimension(Dimension_) {}
747 template<
typename Fn>
void match(Fn
F)
const {
F(Base, Dimension); }
755 if (
OB.back() !=
']')
759 Dimension->print(
OB);
761 Base->printRight(
OB);
770 const Node *ExceptionSpec;
775 :
Node(KFunctionType,
778 Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
779 ExceptionSpec(ExceptionSpec_) {}
781 template<
typename Fn>
void match(Fn
F)
const {
782 F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
818 if (ExceptionSpec !=
nullptr) {
830 template<
typename Fn>
void match(Fn
F)
const {
F(E); }
844 :
Node(KDynamicExceptionSpec), Types(Types_) {}
846 template<
typename Fn>
void match(Fn
F)
const {
F(Types); }
868 :
Node(KFunctionEncoding,
871 Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
872 CVQuals(CVQuals_), RefQual(RefQual_) {}
874 template<
typename Fn>
void match(Fn
F)
const {
875 F(Ret, Name, Params, Attrs, CVQuals, RefQual);
891 if (!Ret->hasRHSComponent(
OB))
916 if (Attrs !=
nullptr)
931 OB +=
"operator\"\" ";
942 :
Node(KSpecialName), Special(Special_), Child(Child_) {}
944 template<
typename Fn>
void match(Fn
F)
const {
F(Special, Child); }
953 const Node *FirstType;
954 const Node *SecondType;
958 :
Node(KCtorVtableSpecialName),
959 FirstType(FirstType_), SecondType(SecondType_) {}
961 template<
typename Fn>
void match(Fn
F)
const {
F(FirstType, SecondType); }
964 OB +=
"construction vtable for ";
965 FirstType->print(
OB);
998 template <
typename Fn>
void match(Fn
F)
const {
1047 const Node *Qualifier;
1052 :
Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
1054 template<
typename Fn>
void match(Fn
F)
const {
F(Qualifier, Name); }
1059 Qualifier->print(
OB);
1067 const Node *Dimension;
1071 :
Node(KVectorType),
BaseType(BaseType_), Dimension(Dimension_) {}
1079 Dimension->print(
OB);
1085 const Node *Dimension;
1089 :
Node(KPixelVectorType), Dimension(Dimension_) {}
1091 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1095 OB +=
"pixel vector[";
1096 Dimension->print(
OB);
1102 const Node *Dimension;
1106 :
Node(KBinaryFPType), Dimension(Dimension_) {}
1108 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1112 Dimension->print(
OB);
1130 :
Node(KSyntheticTemplateParamName),
Kind(Kind_), Index(Index_) {}
1157 :
Node(KTypeTemplateParamDecl,
Cache::Yes), Name(Name_) {}
1159 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
1173 :
Node(KNonTypeTemplateParamDecl,
Cache::Yes), Name(Name_), Type(Type_) {}
1175 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Type); }
1178 Type->printLeft(
OB);
1179 if (!Type->hasRHSComponent(
OB))
1185 Type->printRight(
OB);
1197 :
Node(KTemplateTemplateParamDecl,
Cache::Yes), Name(Name_),
1200 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Params); }
1206 OB +=
"> typename ";
1245 OB.CurrentPackMax =
static_cast<unsigned>(Data.size());
1246 OB.CurrentPackIndex = 0;
1254 return P->ArrayCache == Cache::No;
1258 return P->FunctionCache == Cache::No;
1262 return P->RHSComponentCache == Cache::No;
1267 template<
typename Fn>
void match(Fn
F)
const {
F(Data); }
1270 initializePackExpansion(
OB);
1271 size_t Idx =
OB.CurrentPackIndex;
1272 return Idx < Data.size() && Data[Idx]->hasRHSComponent(
OB);
1275 initializePackExpansion(
OB);
1276 size_t Idx =
OB.CurrentPackIndex;
1277 return Idx < Data.size() && Data[Idx]->hasArray(
OB);
1280 initializePackExpansion(
OB);
1281 size_t Idx =
OB.CurrentPackIndex;
1282 return Idx < Data.size() && Data[Idx]->hasFunction(
OB);
1285 initializePackExpansion(
OB);
1286 size_t Idx =
OB.CurrentPackIndex;
1287 return Idx < Data.size() ? Data[Idx]->getSyntaxNode(
OB) :
this;
1291 initializePackExpansion(
OB);
1292 size_t Idx =
OB.CurrentPackIndex;
1293 if (Idx < Data.size())
1294 Data[Idx]->printLeft(
OB);
1297 initializePackExpansion(
OB);
1298 size_t Idx =
OB.CurrentPackIndex;
1299 if (Idx < Data.size())
1300 Data[Idx]->printRight(
OB);
1313 :
Node(KTemplateArgumentPack), Elements(Elements_) {}
1315 template<
typename Fn>
void match(Fn
F)
const {
F(Elements); }
1320 Elements.printWithComma(
OB);
1331 :
Node(KParameterPackExpansion), Child(Child_) {}
1333 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1341 size_t StreamPos =
OB.getCurrentPosition();
1349 if (
OB.CurrentPackMax == Max) {
1356 if (
OB.CurrentPackMax == 0) {
1357 OB.setCurrentPosition(StreamPos);
1362 for (
unsigned I = 1,
E =
OB.CurrentPackMax;
I <
E; ++
I) {
1364 OB.CurrentPackIndex =
I;
1376 template<
typename Fn>
void match(Fn
F)
const {
F(Params); }
1383 Params.printWithComma(
OB);
1417 :
Node(KForwardTemplateReference,
Cache::Unknown,
Cache::Unknown,
1424 template<
typename Fn>
void match(Fn
F)
const =
delete;
1488 :
Node(KGlobalQualifiedName), Child(Child_) {}
1490 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1550 OB <<
"<char, std::char_traits<char>";
1552 OB <<
", std::allocator<char>";
1569 assert(SV.startsWith(
"basic_"));
1570 SV = SV.dropFront(
sizeof(
"basic_") - 1);
1585 const Node *Basename;
1591 :
Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
1592 Variant(Variant_) {}
1594 template<
typename Fn>
void match(Fn
F)
const {
F(Basename, IsDtor, Variant); }
1599 OB += Basename->getBaseName();
1609 template<
typename Fn>
void match(Fn
F)
const {
F(Base); }
1613 Base->printLeft(
OB);
1623 template<
typename Fn>
void match(Fn
F)
const {
F(Count); }
1640 :
Node(KClosureTypeName), TemplateParams(TemplateParams_),
1641 Params(Params_), Count(Count_) {}
1643 template<
typename Fn>
void match(Fn
F)
const {
1644 F(TemplateParams, Params, Count);
1648 if (!TemplateParams.
empty()) {
1671 :
Node(KStructuredBindingName), Bindings(Bindings_) {}
1673 template<
typename Fn>
void match(Fn
F)
const {
F(Bindings); }
1692 :
Node(KBinaryExpr, Prec_),
LHS(LHS_), InfixOperator(InfixOperator_),
1695 template <
typename Fn>
void match(Fn
F)
const {
1700 bool ParenAll =
OB.isGtInsideTemplateArgs() &&
1701 (InfixOperator ==
">" || InfixOperator ==
">>");
1708 if (!(InfixOperator ==
","))
1710 OB += InfixOperator;
1724 :
Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
1726 template <
typename Fn>
void match(Fn
F)
const {
1744 :
Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
1746 template <
typename Fn>
void match(Fn
F)
const {
1764 :
Node(KConditionalExpr, Prec_),
Cond(Cond_), Then(Then_), Else(Else_) {}
1766 template <
typename Fn>
void match(Fn
F)
const {
1773 Then->printAsOperand(
OB);
1788 template <
typename Fn>
void match(Fn
F)
const {
1801 const Node *SubExpr;
1808 NodeArray UnionSelectors_,
bool OnePastTheEnd_)
1809 :
Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
1810 UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
1812 template<
typename Fn>
void match(Fn
F)
const {
1813 F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
1820 OB +=
" at offset ";
1821 if (Offset.empty()) {
1823 }
else if (Offset[0] ==
'n') {
1825 OB += Offset.dropFront();
1841 :
Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
1843 template <
typename Fn>
void match(Fn
F)
const {
1864 :
Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_),
From(From_) {}
1866 template <
typename Fn>
void match(Fn
F)
const {
1879 From->printAsOperand(
OB);
1889 :
Node(KSizeofParamPackExpr), Pack(Pack_) {}
1891 template<
typename Fn>
void match(Fn
F)
const {
F(Pack); }
1908 :
Node(KCallExpr, Prec_),
Callee(Callee_), Args(Args_) {}
1910 template <
typename Fn>
void match(Fn
F)
const {
1917 Args.printWithComma(
OB);
1931 bool IsArray_,
Prec Prec_)
1932 :
Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
1933 InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
1935 template<
typename Fn>
void match(Fn
F)
const {
1945 if (!ExprList.
empty()) {
1952 if (!InitList.
empty()) {
1967 :
Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
1968 IsArray(IsArray_) {}
1970 template <
typename Fn>
void match(Fn
F)
const {
1991 :
Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
1993 template <
typename Fn>
void match(Fn
F)
const {
2023 :
Node(KConversionExpr, Prec_), Type(Type_),
Expressions(Expressions_) {}
2025 template <
typename Fn>
void match(Fn
F)
const {
2041 const Node *SubExpr;
2047 :
Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
2048 SubExpr(SubExpr_), Offset(Offset_) {}
2050 template <
typename Fn>
void match(Fn
F)
const {
2069 :
Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
2071 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Inits); }
2088 :
Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
2090 template<
typename Fn>
void match(Fn
F)
const {
F(Elem, Init, IsArray); }
2101 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2113 :
Node(KBracedRangeExpr),
First(First_), Last(Last_), Init(Init_) {}
2123 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2130 const Node *Pack, *Init;
2137 :
Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
2138 IsLeftFold(IsLeftFold_) {}
2140 template<
typename Fn>
void match(Fn
F)
const {
2141 F(IsLeftFold, OperatorName, Pack, Init);
2145 auto PrintPack = [&] {
2155 if (!IsLeftFold || Init !=
nullptr) {
2161 OB <<
" " << OperatorName <<
" ";
2164 if (IsLeftFold || Init !=
nullptr) {
2166 OB <<
" " << OperatorName <<
" ";
2182 template<
typename Fn>
void match(Fn
F)
const {
F(Op); }
2196 template<
typename Fn>
void match(Fn
F)
const {
F(Value); }
2209 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2224 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2228 if (Type->getKind() == KClosureTypeName)
2241 :
Node(KEnumLiteral), Ty(Ty_),
Integer(Integer_) {}
2263 :
Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
2265 template<
typename Fn>
void match(Fn
F)
const {
F(Type, Value); }
2268 if (Type.size() > 3) {
2274 if (Value[0] ==
'n') {
2276 OB += Value.dropFront(1);
2280 if (Type.size() <= 3)
2289 return Node::KFloatLiteral;
2292 return Node::KDoubleLiteral;
2295 return Node::KLongDoubleLiteral;
2302 static constexpr
Kind KindForClass =
2307 :
Node(KindForClass), Contents(Contents_) {}
2309 template<
typename Fn>
void match(Fn
F)
const {
F(Contents); }
2312 const char *first = Contents.
begin();
2313 const char *
last = Contents.
end() + 1;
2316 if (
static_cast<std::size_t
>(
last - first) >
N) {
2320 char buf[
sizeof(
Float)];
2322 const char *
t = first;
2325 unsigned d1 = isdigit(*
t) ?
static_cast<unsigned>(*
t -
'0')
2326 :
static_cast<unsigned>(*
t -
'a' + 10);
2328 unsigned d0 = isdigit(*
t) ?
static_cast<unsigned>(*
t -
'0')
2329 :
static_cast<unsigned>(*
t -
'a' + 10);
2330 *
e =
static_cast<char>((
d1 << 4) +
d0);
2332 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
2348 template<
typename Fn>
2353 return F(static_cast<const X *>(this));
2354 #include "ItaniumNodes.def"
2356 assert(0 &&
"unknown mangling node kind");
2362 template <> struct NodeKind<X> { \
2363 static constexpr Node::Kind Kind = Node::K##X; \
2364 static constexpr const char *name() { return #X; } \
2366 #include "ItaniumNodes.def"
2386 size_t OldNumTemplateParamLists;
2391 : Parser(TheParser),
2430 void reset(
const char *First_,
const char *Last_) {
2439 for (
int I = 0;
I != 3; ++
I)
2445 return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
2449 size_t sz =
static_cast<size_t>(
end -
begin);
2451 Node **data =
new (mem)
Node *[sz];
2482 char look(
unsigned Lookahead = 0)
const {
2483 if (
static_cast<size_t>(
Last -
First) <= Lookahead)
2485 return First[Lookahead];
2544 size_t I = State.ForwardTemplateRefsBegin;
2546 for (;
I <
E; ++
I) {
2603 return *
this <
Other.Enc;
2606 return Enc[0] < Peek[0] || (
Enc[0] == Peek[0] &&
Enc[1] < Peek[1]);
2609 return Enc[0] == Peek[0] &&
Enc[1] == Peek[1];
2618 "operator name does not start with 'operator'");
2619 Res = Res.
dropFront(
sizeof(
"operator") - 1);
2629 static const OperatorInfo
Ops[];
2653 template <
typename Derived,
typename Alloc>
2656 return getDerived().parseNestedName(State);
2658 return getDerived().parseLocalName(State);
2660 Node *Result =
nullptr;
2661 bool IsSubst =
false;
2663 Result = getDerived().parseUnscopedName(State, &IsSubst);
2667 if (look() ==
'I') {
2672 Node *
TA = getDerived().parseTemplateArgs(State !=
nullptr);
2676 State->EndsWithTemplateArgs =
true;
2677 Result = make<NameWithTemplateArgs>(Result,
TA);
2678 }
else if (IsSubst) {
2689 template <
typename Derived,
typename Alloc>
2691 if (!consumeIf(
'Z'))
2693 Node *Encoding = getDerived().parseEncoding();
2694 if (Encoding ==
nullptr || !consumeIf(
'E'))
2697 if (consumeIf(
's')) {
2699 auto *StringLitName = make<NameType>(
"string literal");
2702 return make<LocalName>(Encoding, StringLitName);
2705 if (consumeIf(
'd')) {
2707 if (!consumeIf(
'_'))
2709 Node *
N = getDerived().parseName(State);
2712 return make<LocalName>(Encoding,
N);
2715 Node *Entity = getDerived().parseName(State);
2716 if (Entity ==
nullptr)
2719 return make<LocalName>(Encoding, Entity);
2725 template <
typename Derived,
typename Alloc>
2730 Node *Std =
nullptr;
2731 if (consumeIf(
"St")) {
2732 Std = make<NameType>(
"std");
2737 Node *Res =
nullptr;
2739 if (look() ==
'S') {
2740 Node *
S = getDerived().parseSubstitution();
2743 if (
S->getKind() == Node::KModuleName)
2745 else if (IsSubst && Std ==
nullptr) {
2753 if (Res ==
nullptr || Std !=
nullptr) {
2754 Res = getDerived().parseUnqualifiedName(State, Std,
Module);
2766 template <
typename Derived,
typename Alloc>
2769 if (getDerived().parseModuleNameOpt(
Module))
2775 if (look() >=
'1' && look() <=
'9') {
2776 Result = getDerived().parseSourceName(State);
2777 }
else if (look() ==
'U') {
2778 Result = getDerived().parseUnnamedTypeName(State);
2779 }
else if (consumeIf(
"DC")) {
2781 size_t BindingsBegin = Names.
size();
2783 Node *Binding = getDerived().parseSourceName(State);
2784 if (Binding ==
nullptr)
2787 }
while (!consumeIf(
'E'));
2788 Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
2789 }
else if (look() ==
'C' || look() ==
'D') {
2793 Result = getDerived().parseCtorDtorName(
Scope, State);
2795 Result = getDerived().parseOperatorName(State);
2798 if (Result !=
nullptr &&
Module !=
nullptr)
2799 Result = make<ModuleEntity>(
Module, Result);
2800 if (Result !=
nullptr)
2801 Result = getDerived().parseAbiTags(Result);
2802 if (Result !=
nullptr &&
Scope !=
nullptr)
2803 Result = make<NestedName>(
Scope, Result);
2813 template <
typename Derived,
typename Alloc>
2816 while (consumeIf(
'W')) {
2817 bool IsPartition = consumeIf(
'P');
2818 Node *Sub = getDerived().parseSourceName(
nullptr);
2835 template <
typename Derived,
typename Alloc>
2840 if (State !=
nullptr)
2841 TemplateParams.
clear();
2843 if (consumeIf(
"Ut")) {
2845 if (!consumeIf(
'_'))
2847 return make<UnnamedTypeName>(Count);
2849 if (consumeIf(
"Ul")) {
2851 TemplateParams.
size());
2852 ScopedTemplateParamList LambdaTemplateParams(
this);
2854 size_t ParamsBegin = Names.
size();
2855 while (look() ==
'T' &&
2857 Node *
T = parseTemplateParamDecl();
2862 NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
2886 if (TempParams.
empty())
2889 if (!consumeIf(
"vE")) {
2891 Node *
P = getDerived().parseType();
2895 }
while (!consumeIf(
'E'));
2897 NodeArray Params = popTrailingNodeArray(ParamsBegin);
2900 if (!consumeIf(
'_'))
2902 return make<ClosureTypeName>(TempParams, Params, Count);
2904 if (consumeIf(
"Ub")) {
2905 (void)parseNumber();
2906 if (!consumeIf(
'_'))
2908 return make<NameType>(
"'block-literal'");
2914 template <
typename Derived,
typename Alloc>
2917 if (parsePositiveInteger(&Length))
2919 if (numLeft() < Length || Length == 0)
2923 if (
Name.startsWith(
"_GLOBAL__N"))
2924 return make<NameType>(
"(anonymous namespace)");
2925 return make<NameType>(
Name);
2929 template <
typename Derived,
typename Alloc>
2941 "operator co_await"},
2950 "operator delete[]"},
2998 "reinterpret_cast"},
3010 template <
typename Derived,
typename Alloc>
3016 template <
typename Derived,
typename Alloc>
3023 &Ops[0], &Ops[NumOps],
First,
3024 [](
const OperatorInfo &Op_,
const char *Enc_) {
return Op_ < Enc_; });
3035 template <
typename Derived,
typename Alloc>
3038 if (
const auto *
Op = parseOperatorEncoding()) {
3039 if (
Op->getKind() == OperatorInfo::CCast) {
3046 PermitForwardTemplateReferences ||
3048 Node *Ty = getDerived().parseType();
3051 if (State) State->CtorDtorConversion =
true;
3052 return make<ConversionOperatorType>(Ty);
3055 if (
Op->getKind() >= OperatorInfo::Unnameable)
3058 if (
Op->getKind() == OperatorInfo::Member && !
Op->getFlag())
3062 return make<NameType>(
Op->getName());
3065 if (consumeIf(
"li")) {
3067 Node *SN = getDerived().parseSourceName(State);
3070 return make<LiteralOperator>(SN);
3073 if (consumeIf(
'v')) {
3075 if (look() >=
'0' && look() <=
'9') {
3077 Node *SN = getDerived().parseSourceName(State);
3080 return make<ConversionOperatorType>(SN);
3098 template <
typename Derived,
typename Alloc>
3102 if (SoFar->
getKind() == Node::KSpecialSubstitution) {
3104 SoFar = make<ExpandedSpecialSubstitution>(
3110 if (consumeIf(
'C')) {
3111 bool IsInherited = consumeIf(
'I');
3112 if (look() !=
'1' && look() !=
'2' && look() !=
'3' && look() !=
'4' &&
3115 int Variant = look() -
'0';
3117 if (State) State->CtorDtorConversion =
true;
3119 if (getDerived().parseName(State) ==
nullptr)
3122 return make<CtorDtorName>(SoFar,
false, Variant);
3125 if (look() ==
'D' && (look(1) ==
'0' || look(1) ==
'1' || look(1) ==
'2' ||
3126 look(1) ==
'4' || look(1) ==
'5')) {
3127 int Variant = look(1) -
'0';
3129 if (State) State->CtorDtorConversion =
true;
3130 return make<CtorDtorName>(SoFar,
true, Variant);
3155 template <
typename Derived,
typename Alloc>
3158 if (!consumeIf(
'N'))
3162 if (State) State->CVQualifiers = CVTmp;
3164 if (consumeIf(
'O')) {
3166 }
else if (consumeIf(
'R')) {
3172 Node *SoFar =
nullptr;
3173 while (!consumeIf(
'E')) {
3176 State->EndsWithTemplateArgs =
false;
3178 if (look() ==
'T') {
3180 if (SoFar !=
nullptr)
3182 SoFar = getDerived().parseTemplateParam();
3183 }
else if (look() ==
'I') {
3185 if (SoFar ==
nullptr)
3187 Node *
TA = getDerived().parseTemplateArgs(State !=
nullptr);
3190 if (SoFar->
getKind() == Node::KNameWithTemplateArgs)
3196 State->EndsWithTemplateArgs =
true;
3197 SoFar = make<NameWithTemplateArgs>(SoFar,
TA);
3198 }
else if (look() ==
'D' && (look(1) ==
't' || look(1) ==
'T')) {
3200 if (SoFar !=
nullptr)
3202 SoFar = getDerived().parseDecltype();
3206 if (look() ==
'S') {
3209 if (look(1) ==
't') {
3211 S = make<NameType>(
"std");
3213 S = getDerived().parseSubstitution();
3217 if (
S->getKind() == Node::KModuleName) {
3219 }
else if (SoFar !=
nullptr) {
3228 SoFar = getDerived().parseUnqualifiedName(State, SoFar,
Module);
3231 if (SoFar ==
nullptr)
3240 if (SoFar ==
nullptr || Subs.
empty())
3248 template <
typename Derived,
typename Alloc>
3250 Node *SN = getDerived().parseSourceName(
nullptr);
3253 if (look() ==
'I') {
3254 Node *
TA = getDerived().parseTemplateArgs();
3257 return make<NameWithTemplateArgs>(SN,
TA);
3264 template <
typename Derived,
typename Alloc>
3267 if (std::isdigit(look()))
3268 Result = getDerived().parseSimpleId();
3270 Result = getDerived().parseUnresolvedType();
3271 if (Result ==
nullptr)
3273 return make<DtorName>(Result);
3279 template <
typename Derived,
typename Alloc>
3281 if (look() ==
'T') {
3282 Node *TP = getDerived().parseTemplateParam();
3288 if (look() ==
'D') {
3289 Node *DT = getDerived().parseDecltype();
3295 return getDerived().parseSubstitution();
3305 template <
typename Derived,
typename Alloc>
3307 if (std::isdigit(look()))
3308 return getDerived().parseSimpleId();
3310 if (consumeIf(
"dn"))
3311 return getDerived().parseDestructorName();
3315 Node *Oper = getDerived().parseOperatorName(
nullptr);
3316 if (Oper ==
nullptr)
3318 if (look() ==
'I') {
3319 Node *
TA = getDerived().parseTemplateArgs();
3322 return make<NameWithTemplateArgs>(Oper,
TA);
3339 template <
typename Derived,
typename Alloc>
3341 Node *SoFar =
nullptr;
3345 if (consumeIf(
"srN")) {
3346 SoFar = getDerived().parseUnresolvedType();
3347 if (SoFar ==
nullptr)
3350 if (look() ==
'I') {
3351 Node *
TA = getDerived().parseTemplateArgs();
3354 SoFar = make<NameWithTemplateArgs>(SoFar,
TA);
3359 while (!consumeIf(
'E')) {
3360 Node *Qual = getDerived().parseSimpleId();
3361 if (Qual ==
nullptr)
3363 SoFar = make<QualifiedName>(SoFar, Qual);
3368 Node *
Base = getDerived().parseBaseUnresolvedName();
3369 if (
Base ==
nullptr)
3371 return make<QualifiedName>(SoFar,
Base);
3375 if (!consumeIf(
"sr")) {
3376 SoFar = getDerived().parseBaseUnresolvedName();
3377 if (SoFar ==
nullptr)
3380 SoFar = make<GlobalQualifiedName>(SoFar);
3385 if (std::isdigit(look())) {
3387 Node *Qual = getDerived().parseSimpleId();
3388 if (Qual ==
nullptr)
3391 SoFar = make<QualifiedName>(SoFar, Qual);
3393 SoFar = make<GlobalQualifiedName>(Qual);
3398 }
while (!consumeIf(
'E'));
3403 SoFar = getDerived().parseUnresolvedType();
3404 if (SoFar ==
nullptr)
3407 if (look() ==
'I') {
3408 Node *
TA = getDerived().parseTemplateArgs();
3411 SoFar = make<NameWithTemplateArgs>(SoFar,
TA);
3417 assert(SoFar !=
nullptr);
3419 Node *
Base = getDerived().parseBaseUnresolvedName();
3420 if (
Base ==
nullptr)
3422 return make<QualifiedName>(SoFar,
Base);
3427 template <
typename Derived,
typename Alloc>
3429 while (consumeIf(
'B')) {
3433 N = make<AbiTagAttr>(
N, SN);
3441 template <
typename Alloc,
typename Derived>
3444 const char *Tmp =
First;
3447 if (numLeft() == 0 || !std::isdigit(*
First))
3449 while (numLeft() != 0 && std::isdigit(*
First))
3455 template <
typename Alloc,
typename Derived>
3458 if (look() <
'0' || look() >
'9')
3460 while (look() >=
'0' && look() <=
'9') {
3462 *Out +=
static_cast<size_t>(
consume() -
'0');
3467 template <
typename Alloc,
typename Derived>
3470 if (parsePositiveInteger(&Int) || numLeft() < Int)
3485 template <
typename Derived,
typename Alloc>
3489 Node *ExceptionSpec =
nullptr;
3490 if (consumeIf(
"Do")) {
3491 ExceptionSpec = make<NameType>(
"noexcept");
3494 }
else if (consumeIf(
"DO")) {
3495 Node *
E = getDerived().parseExpr();
3496 if (
E ==
nullptr || !consumeIf(
'E'))
3498 ExceptionSpec = make<NoexceptSpec>(
E);
3501 }
else if (consumeIf(
"Dw")) {
3502 size_t SpecsBegin = Names.
size();
3503 while (!consumeIf(
'E')) {
3504 Node *
T = getDerived().parseType();
3510 make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
3517 if (!consumeIf(
'F'))
3525 size_t ParamsBegin = Names.
size();
3531 if (consumeIf(
"RE")) {
3535 if (consumeIf(
"OE")) {
3539 Node *
T = getDerived().parseType();
3545 NodeArray Params = popTrailingNodeArray(ParamsBegin);
3546 return make<FunctionType>(
ReturnType, Params, CVQuals,
3547 ReferenceQualifier, ExceptionSpec);
3555 template <
typename Derived,
typename Alloc>
3557 if (!consumeIf(
"Dv"))
3559 if (look() >=
'1' && look() <=
'9') {
3560 Node *DimensionNumber = make<NameType>(parseNumber());
3561 if (!DimensionNumber)
3563 if (!consumeIf(
'_'))
3566 return make<PixelVectorType>(DimensionNumber);
3567 Node *ElemType = getDerived().parseType();
3568 if (ElemType ==
nullptr)
3570 return make<VectorType>(ElemType, DimensionNumber);
3573 if (!consumeIf(
'_')) {
3574 Node *DimExpr = getDerived().parseExpr();
3577 if (!consumeIf(
'_'))
3579 Node *ElemType = getDerived().parseType();
3582 return make<VectorType>(ElemType, DimExpr);
3584 Node *ElemType = getDerived().parseType();
3587 return make<VectorType>(ElemType,
nullptr);
3592 template <
typename Derived,
typename Alloc>
3594 if (!consumeIf(
'D'))
3596 if (!consumeIf(
't') && !consumeIf(
'T'))
3598 Node *
E = getDerived().parseExpr();
3601 if (!consumeIf(
'E'))
3603 return make<EnclosingExpr>(
"decltype",
E);
3608 template <
typename Derived,
typename Alloc>
3610 if (!consumeIf(
'A'))
3613 Node *Dimension =
nullptr;
3615 if (std::isdigit(look())) {
3616 Dimension = make<NameType>(parseNumber());
3619 if (!consumeIf(
'_'))
3621 }
else if (!consumeIf(
'_')) {
3622 Node *DimExpr = getDerived().parseExpr();
3623 if (DimExpr ==
nullptr)
3625 if (!consumeIf(
'_'))
3627 Dimension = DimExpr;
3630 Node *Ty = getDerived().parseType();
3633 return make<ArrayType>(Ty, Dimension);
3637 template <
typename Derived,
typename Alloc>
3639 if (!consumeIf(
'M'))
3641 Node *ClassType = getDerived().parseType();
3642 if (ClassType ==
nullptr)
3644 Node *MemberType = getDerived().parseType();
3645 if (MemberType ==
nullptr)
3647 return make<PointerToMemberType>(ClassType, MemberType);
3654 template <
typename Derived,
typename Alloc>
3657 if (consumeIf(
"Ts"))
3658 ElabSpef =
"struct";
3659 else if (consumeIf(
"Tu"))
3661 else if (consumeIf(
"Te"))
3664 Node *
Name = getDerived().parseName();
3665 if (
Name ==
nullptr)
3668 if (!ElabSpef.
empty())
3669 return make<ElaboratedTypeSpefType>(ElabSpef,
Name);
3677 template <
typename Derived,
typename Alloc>
3679 if (consumeIf(
'U')) {
3690 SaveLast(Last, ProtoSourceName.
end());
3691 Proto = parseBareSourceName();
3695 Node *Child = getDerived().parseQualifiedType();
3696 if (Child ==
nullptr)
3698 return make<ObjCProtoName>(Child, Proto);
3702 if (look() ==
'I') {
3703 TA = getDerived().parseTemplateArgs();
3708 Node *Child = getDerived().parseQualifiedType();
3709 if (Child ==
nullptr)
3711 return make<VendorExtQualType>(Child, Qual,
TA);
3715 Node *Ty = getDerived().parseType();
3719 Ty = make<QualType>(Ty, Quals);
3743 template <
typename Derived,
typename Alloc>
3745 Node *Result =
nullptr;
3752 unsigned AfterQuals = 0;
3753 if (look(AfterQuals) ==
'r') ++AfterQuals;
3754 if (look(AfterQuals) ==
'V') ++AfterQuals;
3755 if (look(AfterQuals) ==
'K') ++AfterQuals;
3757 if (look(AfterQuals) ==
'F' ||
3758 (look(AfterQuals) ==
'D' &&
3759 (look(AfterQuals + 1) ==
'o' || look(AfterQuals + 1) ==
'O' ||
3760 look(AfterQuals + 1) ==
'w' || look(AfterQuals + 1) ==
'x'))) {
3761 Result = getDerived().parseFunctionType();
3767 Result = getDerived().parseQualifiedType();
3773 return make<NameType>(
"void");
3777 return make<NameType>(
"wchar_t");
3781 return make<NameType>(
"bool");
3785 return make<NameType>(
"char");
3789 return make<NameType>(
"signed char");
3793 return make<NameType>(
"unsigned char");
3797 return make<NameType>(
"short");
3801 return make<NameType>(
"unsigned short");
3805 return make<NameType>(
"int");
3809 return make<NameType>(
"unsigned int");
3813 return make<NameType>(
"long");
3817 return make<NameType>(
"unsigned long");
3821 return make<NameType>(
"long long");
3825 return make<NameType>(
"unsigned long long");
3829 return make<NameType>(
"__int128");
3833 return make<NameType>(
"unsigned __int128");
3837 return make<NameType>(
"float");
3841 return make<NameType>(
"double");
3845 return make<NameType>(
"long double");
3849 return make<NameType>(
"__float128");
3853 return make<NameType>(
"...");
3864 Result = make<NameType>(Res);
3872 return make<NameType>(
"decimal64");
3876 return make<NameType>(
"decimal128");
3880 return make<NameType>(
"decimal32");
3884 return make<NameType>(
"half");
3888 Node *DimensionNumber = make<NameType>(parseNumber());
3889 if (!DimensionNumber)
3891 if (!consumeIf(
'_'))
3893 return make<BinaryFPType>(DimensionNumber);
3901 bool Signed = look(1) ==
'B';
3903 Node *
Size = std::isdigit(look()) ? make<NameType>(parseNumber())
3904 : getDerived().parseExpr();
3907 if (!consumeIf(
'_'))
3914 return make<NameType>(
"char32_t");
3918 return make<NameType>(
"char16_t");
3922 return make<NameType>(
"char8_t");
3926 return make<NameType>(
"auto");
3930 return make<NameType>(
"decltype(auto)");
3934 return make<NameType>(
"std::nullptr_t");
3939 Result = getDerived().parseDecltype();
3944 Result = getDerived().parseVectorType();
3950 Node *Child = getDerived().parseType();
3953 Result = make<ParameterPackExpansion>(Child);
3962 Result = getDerived().parseFunctionType();
3968 Result = getDerived().parseFunctionType();
3973 Result = getDerived().parseArrayType();
3978 Result = getDerived().parsePointerToMemberType();
3984 if (look(1) ==
's' || look(1) ==
'u' || look(1) ==
'e') {
3985 Result = getDerived().parseClassEnumType();
3989 Result = getDerived().parseTemplateParam();
3990 if (Result ==
nullptr)
4003 if (TryToParseTemplateArgs && look() ==
'I') {
4004 Node *
TA = getDerived().parseTemplateArgs();
4007 Result = make<NameWithTemplateArgs>(Result,
TA);
4014 Node *Ptr = getDerived().parseType();
4017 Result = make<PointerType>(Ptr);
4023 Node *Ref = getDerived().parseType();
4032 Node *Ref = getDerived().parseType();
4041 Node *
P = getDerived().parseType();
4044 Result = make<PostfixQualifiedType>(
P,
" complex");
4050 Node *
P = getDerived().parseType();
4053 Result = make<PostfixQualifiedType>(
P,
" imaginary");
4058 if (look(1) !=
't') {
4059 bool IsSubst =
false;
4060 Result = getDerived().parseUnscopedName(
nullptr, &IsSubst);
4074 if (look() ==
'I' && (!IsSubst || TryToParseTemplateArgs)) {
4077 Node *
TA = getDerived().parseTemplateArgs();
4080 Result = make<NameWithTemplateArgs>(Result,
TA);
4081 }
else if (IsSubst) {
4092 Result = getDerived().parseClassEnumType();
4100 if (Result !=
nullptr)
4105 template <
typename Derived,
typename Alloc>
4108 Node *
E = getDerived().parseExpr();
4111 return make<PrefixExpr>(
Kind,
E, Prec);
4114 template <
typename Derived,
typename Alloc>
4117 Node *
LHS = getDerived().parseExpr();
4120 Node *
RHS = getDerived().parseExpr();
4123 return make<BinaryExpr>(
LHS,
Kind,
RHS, Prec);
4126 template <
typename Derived,
typename Alloc>
4130 if (!Tmp.
empty() && consumeIf(
'E'))
4131 return make<IntegerLiteral>(Lit, Tmp);
4136 template <
typename Alloc,
typename Derived>
4153 template <
typename Derived,
typename Alloc>
4155 if (consumeIf(
"fpT"))
4156 return make<NameType>(
"this");
4157 if (consumeIf(
"fp")) {
4158 parseCVQualifiers();
4160 if (!consumeIf(
'_'))
4162 return make<FunctionParam>(Num);
4164 if (consumeIf(
"fL")) {
4165 if (parseNumber().
empty())
4167 if (!consumeIf(
'p'))
4169 parseCVQualifiers();
4171 if (!consumeIf(
'_'))
4173 return make<FunctionParam>(Num);
4180 template <
typename Derived,
typename Alloc>
4182 if (!consumeIf(
"cv"))
4187 Ty = getDerived().parseType();
4193 if (consumeIf(
'_')) {
4194 size_t ExprsBegin = Names.
size();
4195 while (!consumeIf(
'E')) {
4196 Node *
E = getDerived().parseExpr();
4201 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4202 return make<ConversionExpr>(Ty, Exprs);
4205 Node *
E[1] = {getDerived().parseExpr()};
4206 if (
E[0] ==
nullptr)
4208 return make<ConversionExpr>(Ty, makeNodeArray(
E,
E + 1));
4218 template <
typename Derived,
typename Alloc>
4220 if (!consumeIf(
'L'))
4225 return getDerived().parseIntegerLiteral(
"wchar_t");
4227 if (consumeIf(
"b0E"))
4228 return make<BoolExpr>(0);
4229 if (consumeIf(
"b1E"))
4230 return make<BoolExpr>(1);
4234 return getDerived().parseIntegerLiteral(
"char");
4237 return getDerived().parseIntegerLiteral(
"signed char");
4240 return getDerived().parseIntegerLiteral(
"unsigned char");
4243 return getDerived().parseIntegerLiteral(
"short");
4246 return getDerived().parseIntegerLiteral(
"unsigned short");
4249 return getDerived().parseIntegerLiteral(
"");
4252 return getDerived().parseIntegerLiteral(
"u");
4255 return getDerived().parseIntegerLiteral(
"l");
4258 return getDerived().parseIntegerLiteral(
"ul");
4261 return getDerived().parseIntegerLiteral(
"ll");
4264 return getDerived().parseIntegerLiteral(
"ull");
4267 return getDerived().parseIntegerLiteral(
"__int128");
4270 return getDerived().parseIntegerLiteral(
"unsigned __int128");
4273 return getDerived().template parseFloatingLiteral<float>();
4276 return getDerived().template parseFloatingLiteral<double>();
4279 #if defined(__powerpc__) || defined(__s390__)
4282 return getDerived().template parseFloatingLiteral<double>();
4284 return getDerived().template parseFloatingLiteral<long double>();
4287 if (consumeIf(
"_Z")) {
4288 Node *
R = getDerived().parseEncoding();
4289 if (
R !=
nullptr && consumeIf(
'E'))
4294 Node *
T = getDerived().parseType();
4299 return make<StringLiteral>(
T);
4303 if (consumeIf(
"Dn") && (consumeIf(
'0'), consumeIf(
'E')))
4304 return make<NameType>(
"nullptr");
4314 Node *
T = parseUnnamedTypeName(
nullptr);
4315 if (!
T || !consumeIf(
'E'))
4317 return make<LambdaExpr>(
T);
4321 Node *
T = getDerived().parseType();
4327 if (!consumeIf(
'E'))
4329 return make<EnumLiteral>(
T,
N);
4338 template <
typename Derived,
typename Alloc>
4340 if (look() ==
'd') {
4344 Node *
Field = getDerived().parseSourceName(
nullptr);
4345 if (
Field ==
nullptr)
4347 Node *Init = getDerived().parseBracedExpr();
4348 if (Init ==
nullptr)
4350 return make<BracedExpr>(
Field, Init,
false);
4355 if (
Index ==
nullptr)
4357 Node *Init = getDerived().parseBracedExpr();
4358 if (Init ==
nullptr)
4360 return make<BracedExpr>(
Index, Init,
true);
4364 Node *RangeBegin = getDerived().parseExpr();
4365 if (RangeBegin ==
nullptr)
4367 Node *RangeEnd = getDerived().parseExpr();
4368 if (RangeEnd ==
nullptr)
4370 Node *Init = getDerived().parseBracedExpr();
4371 if (Init ==
nullptr)
4373 return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
4377 return getDerived().parseExpr();
4385 template <
typename Derived,
typename Alloc>
4387 if (!consumeIf(
'f'))
4390 bool IsLeftFold =
false, HasInitializer =
false;
4396 HasInitializer =
true;
4399 HasInitializer =
true;
4409 const auto *
Op = parseOperatorEncoding();
4412 if (!(
Op->getKind() == OperatorInfo::Binary
4413 || (
Op->getKind() == OperatorInfo::Member
4414 &&
Op->getName().back() ==
'*')))
4417 Node *Pack = getDerived().parseExpr();
4418 if (Pack ==
nullptr)
4421 Node *Init =
nullptr;
4422 if (HasInitializer) {
4423 Init = getDerived().parseExpr();
4424 if (Init ==
nullptr)
4428 if (IsLeftFold && Init)
4431 return make<FoldExpr>(IsLeftFold,
Op->getSymbol(), Pack, Init);
4437 template <
typename Derived,
typename Alloc>
4441 Node *Ty = getDerived().parseType();
4444 Node *Expr = getDerived().parseExpr();
4448 if (!consumeIf(
'E'))
4450 return make<PointerToMemberConversionExpr>(Ty, Expr,
Offset, Prec);
4457 template <
typename Derived,
typename Alloc>
4459 Node *Ty = getDerived().parseType();
4462 Node *Expr = getDerived().parseExpr();
4466 size_t SelectorsBegin = Names.
size();
4467 while (consumeIf(
'_')) {
4468 Node *Selector = make<NameType>(parseNumber());
4473 bool OnePastTheEnd = consumeIf(
'p');
4474 if (!consumeIf(
'E'))
4476 return make<SubobjectExpr>(
4477 Ty, Expr,
Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
4524 template <
typename Derived,
typename Alloc>
4526 bool Global = consumeIf(
"gs");
4528 const auto *
Op = parseOperatorEncoding();
4530 auto Sym =
Op->getSymbol();
4531 switch (
Op->getKind()) {
4532 case OperatorInfo::Binary:
4534 return getDerived().parseBinaryExpr(Sym,
Op->getPrecedence());
4537 return getDerived().parsePrefixExpr(Sym,
Op->getPrecedence());
4538 case OperatorInfo::Postfix: {
4541 return getDerived().parsePrefixExpr(Sym,
Op->getPrecedence());
4542 Node *Ex = getDerived().parseExpr();
4545 return make<PostfixExpr>(Ex, Sym,
Op->getPrecedence());
4547 case OperatorInfo::Array: {
4549 Node *
Base = getDerived().parseExpr();
4550 if (
Base ==
nullptr)
4553 if (
Index ==
nullptr)
4555 return make<ArraySubscriptExpr>(
Base,
Index,
Op->getPrecedence());
4557 case OperatorInfo::Member: {
4559 Node *
LHS = getDerived().parseExpr();
4562 Node *
RHS = getDerived().parseExpr();
4565 return make<MemberExpr>(
LHS, Sym,
RHS,
Op->getPrecedence());
4567 case OperatorInfo::New: {
4573 size_t Exprs = Names.
size();
4574 while (!consumeIf(
'_')) {
4575 Node *Ex = getDerived().parseExpr();
4580 NodeArray ExprList = popTrailingNodeArray(Exprs);
4581 Node *Ty = getDerived().parseType();
4584 bool HaveInits = consumeIf(
"pi");
4585 size_t InitsBegin = Names.
size();
4586 while (!consumeIf(
'E')) {
4589 Node *Init = getDerived().parseExpr();
4590 if (Init ==
nullptr)
4594 NodeArray Inits = popTrailingNodeArray(InitsBegin);
4595 return make<NewExpr>(ExprList, Ty, Inits, Global,
4596 Op->getFlag(),
Op->getPrecedence());
4598 case OperatorInfo::Del: {
4600 Node *Ex = getDerived().parseExpr();
4603 return make<DeleteExpr>(Ex, Global,
Op->getFlag(),
4604 Op->getPrecedence());
4611 size_t ExprsBegin = Names.
size();
4612 while (!consumeIf(
'E')) {
4613 Node *
E = getDerived().parseExpr();
4618 return make<CallExpr>(
Callee, popTrailingNodeArray(ExprsBegin),
4619 Op->getPrecedence());
4621 case OperatorInfo::CCast: {
4626 Ty = getDerived().parseType();
4631 size_t ExprsBegin = Names.
size();
4632 bool IsMany = consumeIf(
'_');
4633 while (!consumeIf(
'E')) {
4634 Node *
E = getDerived().parseExpr();
4641 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4642 if (!IsMany && Exprs.
size() != 1)
4644 return make<ConversionExpr>(Ty, Exprs,
Op->getPrecedence());
4646 case OperatorInfo::Conditional: {
4648 Node *
Cond = getDerived().parseExpr();
4649 if (
Cond ==
nullptr)
4651 Node *
LHS = getDerived().parseExpr();
4654 Node *
RHS = getDerived().parseExpr();
4657 return make<ConditionalExpr>(
Cond,
LHS,
RHS,
Op->getPrecedence());
4659 case OperatorInfo::NamedCast: {
4661 Node *Ty = getDerived().parseType();
4664 Node *Ex = getDerived().parseExpr();
4667 return make<CastExpr>(Sym, Ty, Ex,
Op->getPrecedence());
4669 case OperatorInfo::OfIdOp: {
4672 Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
4675 return make<EnclosingExpr>(Sym,
Arg,
Op->getPrecedence());
4677 case OperatorInfo::NameOnly: {
4689 return getDerived().parseExprPrimary();
4691 return getDerived().parseTemplateParam();
4692 if (look() ==
'f') {
4694 if (look(1) ==
'p' || (look(1) ==
'L' && std::isdigit(look(2))))
4695 return getDerived().parseFunctionParam();
4696 return getDerived().parseFoldExpr();
4698 if (consumeIf(
"il")) {
4699 size_t InitsBegin = Names.
size();
4700 while (!consumeIf(
'E')) {
4701 Node *
E = getDerived().parseBracedExpr();
4706 return make<InitListExpr>(
nullptr, popTrailingNodeArray(InitsBegin));
4708 if (consumeIf(
"mc"))
4710 if (consumeIf(
"nx")) {
4711 Node *Ex = getDerived().parseExpr();
4716 if (consumeIf(
"so"))
4717 return parseSubobjectExpr();
4718 if (consumeIf(
"sp")) {
4719 Node *Child = getDerived().parseExpr();
4720 if (Child ==
nullptr)
4722 return make<ParameterPackExpansion>(Child);
4724 if (consumeIf(
"sZ")) {
4725 if (look() ==
'T') {
4726 Node *
R = getDerived().parseTemplateParam();
4729 return make<SizeofParamPackExpr>(
R);
4731 Node *
FP = getDerived().parseFunctionParam();
4734 return make<EnclosingExpr>(
"sizeof... ",
FP);
4736 if (consumeIf(
"sP")) {
4737 size_t ArgsBegin = Names.
size();
4738 while (!consumeIf(
'E')) {
4739 Node *
Arg = getDerived().parseTemplateArg();
4744 auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
4747 return make<EnclosingExpr>(
"sizeof... ", Pack);
4749 if (consumeIf(
"tl")) {
4750 Node *Ty = getDerived().parseType();
4753 size_t InitsBegin = Names.
size();
4754 while (!consumeIf(
'E')) {
4755 Node *
E = getDerived().parseBracedExpr();
4760 return make<InitListExpr>(Ty, popTrailingNodeArray(InitsBegin));
4762 if (consumeIf(
"tr"))
4763 return make<NameType>(
"throw");
4764 if (consumeIf(
"tw")) {
4765 Node *Ex = getDerived().parseExpr();
4768 return make<ThrowExpr>(Ex);
4770 if (consumeIf(
'u')) {
4771 Node *
Name = getDerived().parseSourceName(
nullptr);
4779 bool IsUUID =
false;
4781 if (
Name->getBaseName() ==
"__uuidof") {
4782 if (consumeIf(
't')) {
4783 UUID = getDerived().parseType();
4785 }
else if (consumeIf(
'z')) {
4786 UUID = getDerived().parseExpr();
4790 size_t ExprsBegin = Names.
size();
4792 if (
UUID ==
nullptr)
4796 while (!consumeIf(
'E')) {
4797 Node *
E = getDerived().parseTemplateArg();
4803 return make<CallExpr>(
Name, popTrailingNodeArray(ExprsBegin),
4808 return getDerived().parseUnresolvedName(Global);
4819 template <
typename Alloc,
typename Derived>
4824 return parseNumber(
true).empty() || !consumeIf(
'_');
4826 return parseNumber(
true).empty() || !consumeIf(
'_') ||
4827 parseNumber(
true).empty() || !consumeIf(
'_');
4852 template <
typename Derived,
typename Alloc>