16#ifndef DEMANGLE_ITANIUMDEMANGLE_H
17#define DEMANGLE_ITANIUMDEMANGLE_H
33#ifdef _LIBCXXABI_COMPILER_CLANG
34#pragma clang diagnostic push
35#pragma clang diagnostic ignored "-Wunused-template"
41 static_assert(std::is_pod<T>::value,
42 "T is required to be a plain old data type");
49 bool isInline()
const {
return First == Inline; }
57 void reserve(
size_t NewCap) {
60 auto *Tmp =
static_cast<T *
>(std::malloc(NewCap *
sizeof(
T)));
63 std::copy(First, Last, Tmp);
66 First =
static_cast<T *
>(std::realloc(First, NewCap *
sizeof(
T)));
81 if (
Other.isInline()) {
83 Last = First +
Other.size();
95 if (
Other.isInline()) {
101 Last = First +
Other.size();
136 Last = First +
Index;
142 bool empty()
const {
return First == Last; }
143 size_t size()
const {
return static_cast<size_t>(Last - First); }
165#define NODE(NodeKind) K##NodeKind,
166#include "ItaniumNodes.def"
229 template<
typename Fn>
void visit(Fn
F)
const;
270 bool StrictlyWorse =
false)
const {
312 : Elements(Elements_), NumElements(NumElements_) {}
314 bool empty()
const {
return NumElements == 0; }
315 size_t size()
const {
return NumElements; }
318 Node **
end()
const {
return Elements + NumElements; }
323 bool FirstElement =
true;
324 for (
size_t Idx = 0;
Idx != NumElements; ++
Idx) {
325 size_t BeforeComma = OB.getCurrentPosition();
328 size_t AfterComma = OB.getCurrentPosition();
333 if (AfterComma == OB.getCurrentPosition()) {
334 OB.setCurrentPosition(BeforeComma);
338 FirstElement =
false;
354 const std::string_view Suffix;
358 :
Node(KDotSuffix), Prefix(Prefix_), Suffix(Suffix_) {}
360 template<
typename Fn>
void match(Fn
F)
const {
F(Prefix, Suffix); }
372 std::string_view Ext;
377 :
Node(KVendorExtQualType), Ty(Ty_), Ext(Ext_), TA(TA_) {}
380 std::string_view
getExt()
const {
return Ext; }
383 template <
typename Fn>
void match(Fn
F)
const {
F(Ty, Ext, TA); }
459 :
Node(KConversionOperatorType), Ty(Ty_) {}
461 template<
typename Fn>
void match(Fn
F)
const {
F(Ty); }
471 const std::string_view Postfix;
475 :
Node(KPostfixQualifiedType), Ty(Ty_), Postfix(Postfix_) {}
477 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Postfix); }
486 const std::string_view Name;
491 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
493 std::string_view
getName()
const {
return Name; }
505 :
Node(KBitIntType), Size(Size_), Signed(Signed_) {}
507 template <
typename Fn>
void match(Fn
F)
const {
F(Size, Signed); }
514 Size->printAsOperand(OB);
520 std::string_view
Kind;
524 :
Node(KElaboratedTypeSpefType),
Kind(Kind_), Child(Child_) {}
536 std::string_view Transform;
540 :
Node(KTransformedType), Transform(Transform_),
BaseType(BaseType_) {}
577 :
Node(KEnableIfAttr), Conditions(Conditions_) {}
579 template<
typename Fn>
void match(Fn
F)
const {
F(Conditions); }
582 OB +=
" [enable_if:";
590 std::string_view Protocol;
596 :
Node(KObjCProtoName), Ty(Ty_), Protocol(Protocol_) {}
598 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Protocol); }
601 return Ty->
getKind() == KNameType &&
623 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee); }
626 return Pointee->hasRHSComponent(OB);
631 if (Pointee->getKind() != KObjCProtoName ||
633 Pointee->printLeft(OB);
634 if (Pointee->hasArray(OB))
636 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
640 const auto *objcProto =
static_cast<const ObjCProtoName *
>(Pointee);
642 OB += objcProto->Protocol;
648 if (Pointee->getKind() != KObjCProtoName ||
650 if (Pointee->hasArray(OB) || Pointee->hasFunction(OB))
652 Pointee->printRight(OB);
667 mutable bool Printing =
false;
676 std::pair<ReferenceKind, const Node *> collapse(
OutputBuffer &OB)
const {
677 auto SoFar = std::make_pair(RK, Pointee);
683 if (SN->
getKind() != KReferenceType)
686 SoFar.second = RT->Pointee;
687 SoFar.first = std::min(SoFar.first, RT->RK);
691 if (Prev.
size() > 1 && SoFar.second == Prev[(Prev.
size() - 1) / 2]) {
693 SoFar.second =
nullptr;
703 Pointee(Pointee_), RK(RK_) {}
705 template<
typename Fn>
void match(Fn
F)
const {
F(Pointee, RK); }
715 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
716 if (!Collapsed.second)
718 Collapsed.second->printLeft(OB);
719 if (Collapsed.second->hasArray(OB))
721 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
724 OB += (Collapsed.first == ReferenceKind::LValue ?
"&" :
"&&");
730 std::pair<ReferenceKind, const Node *> Collapsed = collapse(OB);
731 if (!Collapsed.second)
733 if (Collapsed.second->hasArray(OB) || Collapsed.second->hasFunction(OB))
735 Collapsed.second->printRight(OB);
740 const Node *ClassType;
741 const Node *MemberType;
746 ClassType(ClassType_), MemberType(MemberType_) {}
748 template<
typename Fn>
void match(Fn
F)
const {
F(ClassType, MemberType); }
760 ClassType->print(OB);
780 Base(Base_), Dimension(Dimension_) {}
782 template<
typename Fn>
void match(Fn
F)
const {
F(Base, Dimension); }
790 if (OB.back() !=
']')
794 Dimension->print(OB);
796 Base->printRight(OB);
805 const Node *ExceptionSpec;
810 :
Node(KFunctionType,
813 Ret(Ret_), Params(Params_), CVQuals(CVQuals_), RefQual(RefQual_),
814 ExceptionSpec(ExceptionSpec_) {}
816 template<
typename Fn>
void match(Fn
F)
const {
817 F(Ret, Params, CVQuals, RefQual, ExceptionSpec);
853 if (ExceptionSpec !=
nullptr) {
855 ExceptionSpec->
print(OB);
865 template<
typename Fn>
void match(Fn
F)
const {
F(E); }
879 :
Node(KDynamicExceptionSpec), Types(Types_) {}
881 template<
typename Fn>
void match(Fn
F)
const {
F(Types); }
886 Types.printWithComma(OB);
896 const Node *Requires;
902 const Node *Attrs_,
const Node *Requires_,
904 :
Node(KFunctionEncoding,
907 Ret(Ret_), Name(Name_), Params(Params_), Attrs(Attrs_),
908 Requires(Requires_), CVQuals(CVQuals_), RefQual(RefQual_) {}
910 template<
typename Fn>
void match(Fn
F)
const {
911 F(Ret, Name, Params, Attrs, Requires, CVQuals, RefQual);
927 if (!Ret->hasRHSComponent(OB))
952 if (Attrs !=
nullptr)
955 if (Requires !=
nullptr) {
972 OB +=
"operator\"\" ";
978 const std::string_view Special;
983 :
Node(KSpecialName), Special(Special_), Child(Child_) {}
985 template<
typename Fn>
void match(Fn
F)
const {
F(Special, Child); }
994 const Node *FirstType;
995 const Node *SecondType;
999 :
Node(KCtorVtableSpecialName),
1000 FirstType(FirstType_), SecondType(SecondType_) {}
1002 template<
typename Fn>
void match(Fn
F)
const {
F(FirstType, SecondType); }
1005 OB +=
"construction vtable for ";
1006 FirstType->print(OB);
1008 SecondType->
print(OB);
1035 :
Node(KMemberLikeFriendName),
Qual(Qual_),
Name(Name_) {}
1057 template <
typename Fn>
void match(Fn
F)
const {
1106 const Node *Qualifier;
1111 :
Node(KQualifiedName), Qualifier(Qualifier_), Name(Name_) {}
1113 template<
typename Fn>
void match(Fn
F)
const {
F(Qualifier, Name); }
1115 std::string_view
getBaseName()
const override {
return Name->getBaseName(); }
1118 Qualifier->print(OB);
1126 const Node *Dimension;
1130 :
Node(KVectorType),
BaseType(BaseType_), Dimension(Dimension_) {}
1141 Dimension->print(OB);
1147 const Node *Dimension;
1151 :
Node(KPixelVectorType), Dimension(Dimension_) {}
1153 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1157 OB +=
"pixel vector[";
1158 Dimension->print(OB);
1164 const Node *Dimension;
1168 :
Node(KBinaryFPType), Dimension(Dimension_) {}
1170 template<
typename Fn>
void match(Fn
F)
const {
F(Dimension); }
1174 Dimension->print(OB);
1192 :
Node(KSyntheticTemplateParamName),
Kind(Kind_), Index(Index_) {}
1198 case TemplateParamKind::Type:
1201 case TemplateParamKind::NonType:
1204 case TemplateParamKind::Template:
1219 :
Node(KTemplateParamQualifiedArg), Param(Param_), Arg(Arg_) {}
1221 template <
typename Fn>
void match(Fn
F)
const {
F(Param, Arg); }
1237 :
Node(KTypeTemplateParamDecl,
Cache::
Yes), Name(Name_) {}
1239 template<
typename Fn>
void match(Fn
F)
const {
F(Name); }
1254 Constraint(Constraint_), Name(Name_) {}
1256 template<
typename Fn>
void match(Fn
F)
const {
F(Constraint, Name); }
1259 Constraint->print(OB);
1273 :
Node(KNonTypeTemplateParamDecl,
Cache::
Yes), Name(Name_), Type(Type_) {}
1275 template<
typename Fn>
void match(Fn
F)
const {
F(Name, Type); }
1278 Type->printLeft(OB);
1279 if (!Type->hasRHSComponent(OB))
1285 Type->printRight(OB);
1298 :
Node(KTemplateTemplateParamDecl,
Cache::
Yes), Name(Name_),
1299 Params(Params_), Requires(Requires_) {}
1301 template <
typename Fn>
void match(Fn
F)
const {
F(Name, Params, Requires); }
1307 OB +=
"> typename ";
1312 if (Requires !=
nullptr) {
1314 Requires->
print(OB);
1325 :
Node(KTemplateParamPackDecl,
Cache::
Yes), Param(Param_) {}
1327 template<
typename Fn>
void match(Fn
F)
const {
F(Param); }
1330 Param->printLeft(OB);
1351 if (OB.CurrentPackMax == std::numeric_limits<unsigned>::max()) {
1352 OB.CurrentPackMax =
static_cast<unsigned>(Data.size());
1353 OB.CurrentPackIndex = 0;
1360 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1361 return P->ArrayCache == Cache::No;
1364 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1365 return P->FunctionCache == Cache::No;
1368 if (std::all_of(Data.begin(), Data.end(), [](
Node*
P) {
1369 return P->RHSComponentCache == Cache::No;
1374 template<
typename Fn>
void match(Fn
F)
const {
F(Data); }
1377 initializePackExpansion(OB);
1378 size_t Idx = OB.CurrentPackIndex;
1379 return Idx < Data.size() && Data[
Idx]->hasRHSComponent(OB);
1382 initializePackExpansion(OB);
1383 size_t Idx = OB.CurrentPackIndex;
1384 return Idx < Data.size() && Data[
Idx]->hasArray(OB);
1387 initializePackExpansion(OB);
1388 size_t Idx = OB.CurrentPackIndex;
1389 return Idx < Data.size() && Data[
Idx]->hasFunction(OB);
1392 initializePackExpansion(OB);
1393 size_t Idx = OB.CurrentPackIndex;
1394 return Idx < Data.size() ? Data[
Idx]->getSyntaxNode(OB) :
this;
1398 initializePackExpansion(OB);
1399 size_t Idx = OB.CurrentPackIndex;
1400 if (
Idx < Data.size())
1401 Data[
Idx]->printLeft(OB);
1404 initializePackExpansion(OB);
1405 size_t Idx = OB.CurrentPackIndex;
1406 if (
Idx < Data.size())
1407 Data[
Idx]->printRight(OB);
1420 :
Node(KTemplateArgumentPack), Elements(Elements_) {}
1422 template<
typename Fn>
void match(Fn
F)
const {
F(Elements); }
1427 Elements.printWithComma(OB);
1438 :
Node(KParameterPackExpansion), Child(Child_) {}
1440 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1445 constexpr unsigned Max = std::numeric_limits<unsigned>::max();
1448 size_t StreamPos = OB.getCurrentPosition();
1456 if (OB.CurrentPackMax == Max) {
1463 if (OB.CurrentPackMax == 0) {
1464 OB.setCurrentPosition(StreamPos);
1469 for (
unsigned I = 1,
E = OB.CurrentPackMax;
I <
E; ++
I) {
1471 OB.CurrentPackIndex =
I;
1483 :
Node(KTemplateArgs), Params(Params_), Requires(Requires_) {}
1485 template<
typename Fn>
void match(Fn
F)
const {
F(Params, Requires); }
1492 Params.printWithComma(OB);
1534 template<
typename Fn>
void match(Fn
F)
const =
delete;
1598 :
Node(KGlobalQualifiedName), Child(Child_) {}
1600 template<
typename Fn>
void match(Fn
F)
const {
F(Child); }
1602 std::string_view
getBaseName()
const override {
return Child->getBaseName(); }
1640 case SpecialSubKind::allocator:
1641 return {
"allocator"};
1642 case SpecialSubKind::basic_string:
1643 return {
"basic_string"};
1644 case SpecialSubKind::string:
1645 return {
"basic_string"};
1646 case SpecialSubKind::istream:
1647 return {
"basic_istream"};
1648 case SpecialSubKind::ostream:
1649 return {
"basic_ostream"};
1650 case SpecialSubKind::iostream:
1651 return {
"basic_iostream"};
1660 OB <<
"<char, std::char_traits<char>";
1661 if (
SSK == SpecialSubKind::string)
1662 OB <<
", std::allocator<char>";
1680 SV.remove_prefix(
sizeof(
"basic_") - 1);
1695 const Node *Basename;
1701 :
Node(KCtorDtorName), Basename(Basename_), IsDtor(IsDtor_),
1702 Variant(Variant_) {}
1704 template<
typename Fn>
void match(Fn
F)
const {
F(Basename, IsDtor, Variant); }
1709 OB += Basename->getBaseName();
1719 template<
typename Fn>
void match(Fn
F)
const {
F(Base); }
1723 Base->printLeft(OB);
1728 const std::string_view Count;
1732 :
Node(KUnnamedTypeName), Count(Count_) {}
1734 template<
typename Fn>
void match(Fn
F)
const {
F(Count); }
1745 const Node *Requires1;
1747 const Node *Requires2;
1748 std::string_view Count;
1753 std::string_view Count_)
1754 :
Node(KClosureTypeName), TemplateParams(TemplateParams_),
1755 Requires1(Requires1_), Params(Params_), Requires2(Requires2_),
1758 template<
typename Fn>
void match(Fn
F)
const {
1759 F(TemplateParams, Requires1, Params, Requires2, Count);
1763 if (!TemplateParams.
empty()) {
1769 if (Requires1 !=
nullptr) {
1771 Requires1->
print(OB);
1777 if (Requires2 !=
nullptr) {
1779 Requires2->
print(OB);
1796 :
Node(KStructuredBindingName), Bindings(Bindings_) {}
1798 template<
typename Fn>
void match(Fn
F)
const {
F(Bindings); }
1811 const std::string_view InfixOperator;
1817 :
Node(KBinaryExpr, Prec_),
LHS(LHS_), InfixOperator(InfixOperator_),
1820 template <
typename Fn>
void match(Fn
F)
const {
1825 bool ParenAll = OB.isGtInsideTemplateArgs() &&
1826 (InfixOperator ==
">" || InfixOperator ==
">>");
1833 if (!(InfixOperator ==
","))
1835 OB += InfixOperator;
1849 :
Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
1851 template <
typename Fn>
void match(Fn
F)
const {
1865 const std::string_view Operator;
1869 :
Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
1871 template <
typename Fn>
void match(Fn
F)
const {
1889 :
Node(KConditionalExpr, Prec_),
Cond(Cond_), Then(Then_), Else(Else_) {}
1891 template <
typename Fn>
void match(Fn
F)
const {
1898 Then->printAsOperand(OB);
1906 const std::string_view
Kind;
1914 template <
typename Fn>
void match(Fn
F)
const {
1927 const Node *SubExpr;
1928 std::string_view Offset;
1934 std::string_view Offset_,
NodeArray UnionSelectors_,
1935 bool OnePastTheEnd_)
1936 :
Node(KSubobjectExpr), Type(Type_), SubExpr(SubExpr_), Offset(Offset_),
1937 UnionSelectors(UnionSelectors_), OnePastTheEnd(OnePastTheEnd_) {}
1939 template<
typename Fn>
void match(Fn
F)
const {
1940 F(Type, SubExpr, Offset, UnionSelectors, OnePastTheEnd);
1947 OB +=
" at offset ";
1948 if (Offset.empty()) {
1950 }
else if (Offset[0] ==
'n') {
1952 OB += std::string_view(Offset.data() + 1, Offset.size() - 1);
1961 const std::string_view Prefix;
1963 const std::string_view Postfix;
1968 :
Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
1970 template <
typename Fn>
void match(Fn
F)
const {
1985 const std::string_view CastKind;
1992 :
Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_),
From(From_) {}
1994 template <
typename Fn>
void match(Fn
F)
const {
2007 From->printAsOperand(OB);
2017 :
Node(KSizeofParamPackExpr), Pack(Pack_) {}
2019 template<
typename Fn>
void match(Fn
F)
const {
F(Pack); }
2036 :
Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {}
2038 template <
typename Fn>
void match(Fn
F)
const {
2045 Args.printWithComma(OB);
2059 bool IsArray_,
Prec Prec_)
2060 :
Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
2061 InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
2063 template<
typename Fn>
void match(Fn
F)
const {
2073 if (!ExprList.
empty()) {
2080 if (!InitList.
empty()) {
2095 :
Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
2096 IsArray(IsArray_) {}
2098 template <
typename Fn>
void match(Fn
F)
const {
2114 std::string_view Prefix;
2119 :
Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
2121 template <
typename Fn>
void match(Fn
F)
const {
2132 std::string_view Number;
2152 :
Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
2154 template <
typename Fn>
void match(Fn
F)
const {
2170 const Node *SubExpr;
2171 std::string_view Offset;
2175 std::string_view Offset_,
Prec Prec_)
2176 :
Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
2177 SubExpr(SubExpr_), Offset(Offset_) {}
2179 template <
typename Fn>
void match(Fn
F)
const {
2198 :
Node(KInitListExpr), Ty(Ty_), Inits(Inits_) {}
2200 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Inits); }
2217 :
Node(KBracedExpr), Elem(Elem_), Init(Init_), IsArray(IsArray_) {}
2219 template<
typename Fn>
void match(Fn
F)
const {
F(Elem, Init, IsArray); }
2230 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2242 :
Node(KBracedRangeExpr), First(First_), Last(Last_), Init(Init_) {}
2244 template<
typename Fn>
void match(Fn
F)
const {
F(First, Last, Init); }
2252 if (Init->
getKind() != KBracedExpr && Init->
getKind() != KBracedRangeExpr)
2259 const Node *Pack, *Init;
2260 std::string_view OperatorName;
2264 FoldExpr(
bool IsLeftFold_, std::string_view OperatorName_,
const Node *Pack_,
2266 :
Node(KFoldExpr), Pack(Pack_), Init(Init_), OperatorName(OperatorName_),
2267 IsLeftFold(IsLeftFold_) {}
2269 template<
typename Fn>
void match(Fn
F)
const {
2270 F(IsLeftFold, OperatorName, Pack, Init);
2274 auto PrintPack = [&] {
2284 if (!IsLeftFold || Init !=
nullptr) {
2290 OB <<
" " << OperatorName <<
" ";
2293 if (IsLeftFold || Init !=
nullptr) {
2295 OB <<
" " << OperatorName <<
" ";
2311 template<
typename Fn>
void match(Fn
F)
const {
F(Op); }
2325 template<
typename Fn>
void match(Fn
F)
const {
F(Value); }
2328 OB += Value ? std::string_view(
"true") : std::string_view(
"false");
2338 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2353 template<
typename Fn>
void match(Fn
F)
const {
F(Type); }
2357 if (Type->getKind() == KClosureTypeName)
2366 std::string_view Integer;
2370 :
Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
2372 template<
typename Fn>
void match(Fn
F)
const {
F(Ty, Integer); }
2379 if (Integer[0] ==
'n')
2380 OB <<
'-' << std::string_view(Integer.data() + 1, Integer.size() - 1);
2387 std::string_view Type;
2388 std::string_view Value;
2392 :
Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
2394 template<
typename Fn>
void match(Fn
F)
const {
F(Type, Value); }
2397 if (Type.size() > 3) {
2403 if (Value[0] ==
'n')
2404 OB <<
'-' << std::string_view(Value.data() + 1, Value.size() - 1);
2408 if (Type.size() <= 3)
2418 :
Node(KRequiresExpr), Parameters(Parameters_),
2419 Requirements(Requirements_) {}
2421 template<
typename Fn>
void match(Fn
F)
const {
F(Parameters, Requirements); }
2425 if (!Parameters.
empty()) {
2433 for (
const Node *Req : Requirements) {
2444 const Node *TypeConstraint;
2447 const Node *TypeConstraint_)
2448 :
Node(KExprRequirement), Expr(Expr_), IsNoexcept(IsNoexcept_),
2449 TypeConstraint(TypeConstraint_) {}
2451 template <
typename Fn>
void match(Fn
F)
const {
2452 F(Expr, IsNoexcept, TypeConstraint);
2457 if (IsNoexcept || TypeConstraint)
2460 if (IsNoexcept || TypeConstraint)
2464 if (TypeConstraint) {
2466 TypeConstraint->
print(OB);
2476 :
Node(KTypeRequirement), Type(Type_) {}
2478 template <
typename Fn>
void match(Fn
F)
const {
F(Type); }
2488 const Node *Constraint;
2491 :
Node(KNestedRequirement), Constraint(Constraint_) {}
2493 template <
typename Fn>
void match(Fn
F)
const {
F(Constraint); }
2497 Constraint->
print(OB);
2506 return Node::KFloatLiteral;
2509 return Node::KDoubleLiteral;
2512 return Node::KLongDoubleLiteral;
2517 const std::string_view Contents;
2519 static constexpr Kind KindForClass =
2524 :
Node(KindForClass), Contents(Contents_) {}
2526 template<
typename Fn>
void match(Fn
F)
const {
F(Contents); }
2530 if (Contents.size() >=
N) {
2533 char buf[
sizeof(Float)];
2535 const char *t = Contents.data();
2536 const char *last = t +
N;
2538 for (; t != last; ++t, ++e) {
2539 unsigned d1 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2540 :
static_cast<unsigned>(*t -
'a' + 10);
2542 unsigned d0 = isdigit(*t) ?
static_cast<unsigned>(*t -
'0')
2543 :
static_cast<unsigned>(*t -
'a' + 10);
2544 *e =
static_cast<char>((d1 << 4) + d0);
2546#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
2547 std::reverse(buf, e);
2551 OB += std::string_view(num, n);
2562template<
typename Fn>
2567 return F(static_cast<const X *>(this));
2568#include "ItaniumNodes.def"
2576 template <> struct NodeKind<X> { \
2577 static constexpr Node::Kind Kind = Node::K##X; \
2578 static constexpr const char *name() { return #X; } \
2580#include "ItaniumNodes.def"
2602 size_t OldNumTemplateParamLists;
2607 : Parser(TheParser),
2667 void reset(
const char *First_,
const char *Last_) {
2676 for (
int I = 0;
I != 3; ++
I)
2686 size_t sz =
static_cast<size_t>(end - begin);
2688 Node **data =
new (mem)
Node *[sz];
2689 std::copy(begin, end, data);
2719 char look(
unsigned Lookahead = 0)
const {
2720 if (
static_cast<size_t>(
Last -
First) <= Lookahead)
2722 return First[Lookahead];
2740 return look() ==
'T' &&
2741 std::string_view(
"yptnk").find(
look(1)) != std::string_view::npos;
2790 for (;
I <
E; ++
I) {
2847 return *
this <
Other.Enc;
2850 return Enc[0] < Peek[0] || (
Enc[0] == Peek[0] &&
Enc[1] < Peek[1]);
2853 return Enc[0] == Peek[0] &&
Enc[1] == Peek[1];
2859 std::string_view Res =
Name;
2862 "operator name does not start with 'operator'");
2863 Res.remove_prefix(
sizeof(
"operator") - 1);
2865 Res.remove_prefix(1);
2898template <
typename Derived,
typename Alloc>
2901 return getDerived().parseNestedName(State);
2903 return getDerived().parseLocalName(State);
2905 Node *Result =
nullptr;
2906 bool IsSubst =
false;
2908 Result = getDerived().parseUnscopedName(State, &IsSubst);
2912 if (look() ==
'I') {
2917 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
2922 Result = make<NameWithTemplateArgs>(Result, TA);
2923 }
else if (IsSubst) {
2934template <
typename Derived,
typename Alloc>
2936 if (!consumeIf(
'Z'))
2938 Node *Encoding = getDerived().parseEncoding();
2939 if (Encoding ==
nullptr || !consumeIf(
'E'))
2942 if (consumeIf(
's')) {
2944 auto *StringLitName = make<NameType>(
"string literal");
2947 return make<LocalName>(Encoding, StringLitName);
2954 if (consumeIf(
'd')) {
2956 if (!consumeIf(
'_'))
2958 Node *
N = getDerived().parseName(State);
2961 return make<LocalName>(Encoding,
N);
2964 Node *Entity = getDerived().parseName(State);
2965 if (Entity ==
nullptr)
2968 return make<LocalName>(Encoding, Entity);
2974template <
typename Derived,
typename Alloc>
2979 Node *Std =
nullptr;
2980 if (consumeIf(
"St")) {
2981 Std = make<NameType>(
"std");
2986 Node *Res =
nullptr;
2988 if (look() ==
'S') {
2989 Node *S = getDerived().parseSubstitution();
2992 if (S->
getKind() == Node::KModuleName)
2994 else if (IsSubst && Std ==
nullptr) {
3002 if (Res ==
nullptr || Std !=
nullptr) {
3003 Res = getDerived().parseUnqualifiedName(State, Std,
Module);
3015template <
typename Derived,
typename Alloc>
3018 if (getDerived().parseModuleNameOpt(
Module))
3021 bool IsMemberLikeFriend = Scope && consumeIf(
'F');
3026 if (look() >=
'1' && look() <=
'9') {
3027 Result = getDerived().parseSourceName(State);
3028 }
else if (look() ==
'U') {
3029 Result = getDerived().parseUnnamedTypeName(State);
3030 }
else if (consumeIf(
"DC")) {
3032 size_t BindingsBegin = Names.
size();
3034 Node *Binding = getDerived().parseSourceName(State);
3035 if (Binding ==
nullptr)
3038 }
while (!consumeIf(
'E'));
3039 Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
3040 }
else if (look() ==
'C' || look() ==
'D') {
3042 if (Scope ==
nullptr ||
Module !=
nullptr)
3044 Result = getDerived().parseCtorDtorName(Scope, State);
3046 Result = getDerived().parseOperatorName(State);
3049 if (Result !=
nullptr &&
Module !=
nullptr)
3050 Result = make<ModuleEntity>(
Module, Result);
3051 if (Result !=
nullptr)
3052 Result = getDerived().parseAbiTags(Result);
3053 if (Result !=
nullptr && IsMemberLikeFriend)
3054 Result = make<MemberLikeFriendName>(Scope, Result);
3055 else if (Result !=
nullptr && Scope !=
nullptr)
3056 Result = make<NestedName>(Scope, Result);
3066template <
typename Derived,
typename Alloc>
3069 while (consumeIf(
'W')) {
3070 bool IsPartition = consumeIf(
'P');
3071 Node *Sub = getDerived().parseSourceName(
nullptr);
3089template <
typename Derived,
typename Alloc>
3094 if (State !=
nullptr)
3095 TemplateParams.
clear();
3097 if (consumeIf(
"Ut")) {
3098 std::string_view Count = parseNumber();
3099 if (!consumeIf(
'_'))
3101 return make<UnnamedTypeName>(Count);
3103 if (consumeIf(
"Ul")) {
3105 TemplateParams.
size());
3108 size_t ParamsBegin = Names.
size();
3109 while (getDerived().isTemplateParamDecl()) {
3111 getDerived().parseTemplateParamDecl(LambdaTemplateParams.
params());
3116 NodeArray TempParams = popTrailingNodeArray(ParamsBegin);
3140 if (TempParams.
empty())
3143 Node *Requires1 =
nullptr;
3144 if (consumeIf(
'Q')) {
3145 Requires1 = getDerived().parseConstraintExpr();
3146 if (Requires1 ==
nullptr)
3150 if (!consumeIf(
"v")) {
3152 Node *
P = getDerived().parseType();
3156 }
while (look() !=
'E' && look() !=
'Q');
3158 NodeArray Params = popTrailingNodeArray(ParamsBegin);
3160 Node *Requires2 =
nullptr;
3161 if (consumeIf(
'Q')) {
3162 Requires2 = getDerived().parseConstraintExpr();
3163 if (Requires2 ==
nullptr)
3167 if (!consumeIf(
'E'))
3170 std::string_view Count = parseNumber();
3171 if (!consumeIf(
'_'))
3173 return make<ClosureTypeName>(TempParams, Requires1, Params, Requires2,
3176 if (consumeIf(
"Ub")) {
3177 (void)parseNumber();
3178 if (!consumeIf(
'_'))
3180 return make<NameType>(
"'block-literal'");
3186template <
typename Derived,
typename Alloc>
3189 if (parsePositiveInteger(&Length))
3191 if (numLeft() < Length || Length == 0)
3193 std::string_view
Name(First, Length);
3196 return make<NameType>(
"(anonymous namespace)");
3197 return make<NameType>(
Name);
3201template <
typename Derived,
typename Alloc>
3213 "operator co_await"},
3222 "operator delete[]"},
3270 "reinterpret_cast"},
3282template <
typename Derived,
typename Alloc>
3288template <
typename Derived,
typename Alloc>
3296 size_t lower = 0u, upper = NumOps - 1;
3297 while (upper != lower) {
3298 size_t middle = (upper + lower) / 2;
3299 if (Ops[middle] < First)
3304 if (Ops[lower] != First)
3314template <
typename Derived,
typename Alloc>
3317 if (
const auto *Op = parseOperatorEncoding()) {
3318 if (Op->getKind() == OperatorInfo::CCast) {
3325 PermitForwardTemplateReferences ||
3327 Node *Ty = getDerived().parseType();
3331 return make<ConversionOperatorType>(Ty);
3334 if (Op->getKind() >= OperatorInfo::Unnameable)
3337 if (Op->getKind() == OperatorInfo::Member && !Op->getFlag())
3341 return make<NameType>(Op->getName());
3344 if (consumeIf(
"li")) {
3346 Node *SN = getDerived().parseSourceName(State);
3349 return make<LiteralOperator>(SN);
3352 if (consumeIf(
'v')) {
3354 if (look() >=
'0' && look() <=
'9') {
3356 Node *SN = getDerived().parseSourceName(State);
3359 return make<ConversionOperatorType>(SN);
3377template <
typename Derived,
typename Alloc>
3381 if (SoFar->
getKind() == Node::KSpecialSubstitution) {
3383 SoFar = make<ExpandedSpecialSubstitution>(
3389 if (consumeIf(
'C')) {
3390 bool IsInherited = consumeIf(
'I');
3391 if (look() !=
'1' && look() !=
'2' && look() !=
'3' && look() !=
'4' &&
3394 int Variant = look() -
'0';
3398 if (getDerived().parseName(State) ==
nullptr)
3401 return make<CtorDtorName>(SoFar,
false, Variant);
3404 if (look() ==
'D' && (look(1) ==
'0' || look(1) ==
'1' || look(1) ==
'2' ||
3405 look(1) ==
'4' || look(1) ==
'5')) {
3406 int Variant = look(1) -
'0';
3409 return make<CtorDtorName>(SoFar,
true, Variant);
3434template <
typename Derived,
typename Alloc>
3437 if (!consumeIf(
'N'))
3443 if (consumeIf(
'O')) {
3445 }
else if (consumeIf(
'R')) {
3451 Node *SoFar =
nullptr;
3452 while (!consumeIf(
'E')) {
3457 if (look() ==
'T') {
3459 if (SoFar !=
nullptr)
3461 SoFar = getDerived().parseTemplateParam();
3462 }
else if (look() ==
'I') {
3464 if (SoFar ==
nullptr)
3466 Node *TA = getDerived().parseTemplateArgs(State !=
nullptr);
3469 if (SoFar->
getKind() == Node::KNameWithTemplateArgs)
3476 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3477 }
else if (look() ==
'D' && (look(1) ==
't' || look(1) ==
'T')) {
3479 if (SoFar !=
nullptr)
3481 SoFar = getDerived().parseDecltype();
3485 if (look() ==
'S') {
3488 if (look(1) ==
't') {
3490 S = make<NameType>(
"std");
3492 S = getDerived().parseSubstitution();
3496 if (S->
getKind() == Node::KModuleName) {
3498 }
else if (SoFar !=
nullptr) {
3507 SoFar = getDerived().parseUnqualifiedName(State, SoFar,
Module);
3510 if (SoFar ==
nullptr)
3519 if (SoFar ==
nullptr || Subs.
empty())
3527template <
typename Derived,
typename Alloc>
3529 Node *SN = getDerived().parseSourceName(
nullptr);
3532 if (look() ==
'I') {
3533 Node *TA = getDerived().parseTemplateArgs();
3536 return make<NameWithTemplateArgs>(SN, TA);
3543template <
typename Derived,
typename Alloc>
3546 if (std::isdigit(look()))
3547 Result = getDerived().parseSimpleId();
3549 Result = getDerived().parseUnresolvedType();
3550 if (Result ==
nullptr)
3552 return make<DtorName>(Result);
3558template <
typename Derived,
typename Alloc>
3560 if (look() ==
'T') {
3561 Node *TP = getDerived().parseTemplateParam();
3567 if (look() ==
'D') {
3568 Node *DT = getDerived().parseDecltype();
3574 return getDerived().parseSubstitution();
3584template <
typename Derived,
typename Alloc>
3586 if (std::isdigit(look()))
3587 return getDerived().parseSimpleId();
3589 if (consumeIf(
"dn"))
3590 return getDerived().parseDestructorName();
3594 Node *Oper = getDerived().parseOperatorName(
nullptr);
3595 if (Oper ==
nullptr)
3597 if (look() ==
'I') {
3598 Node *TA = getDerived().parseTemplateArgs();
3601 return make<NameWithTemplateArgs>(Oper, TA);
3618template <
typename Derived,
typename Alloc>
3620 Node *SoFar =
nullptr;
3624 if (consumeIf(
"srN")) {
3625 SoFar = getDerived().parseUnresolvedType();
3626 if (SoFar ==
nullptr)
3629 if (look() ==
'I') {
3630 Node *TA = getDerived().parseTemplateArgs();
3633 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3638 while (!consumeIf(
'E')) {
3639 Node *Qual = getDerived().parseSimpleId();
3640 if (Qual ==
nullptr)
3642 SoFar = make<QualifiedName>(SoFar, Qual);
3647 Node *Base = getDerived().parseBaseUnresolvedName();
3648 if (Base ==
nullptr)
3650 return make<QualifiedName>(SoFar, Base);
3654 if (!consumeIf(
"sr")) {
3655 SoFar = getDerived().parseBaseUnresolvedName();
3656 if (SoFar ==
nullptr)
3659 SoFar = make<GlobalQualifiedName>(SoFar);
3664 if (std::isdigit(look())) {
3666 Node *Qual = getDerived().parseSimpleId();
3667 if (Qual ==
nullptr)
3670 SoFar = make<QualifiedName>(SoFar, Qual);
3672 SoFar = make<GlobalQualifiedName>(Qual);
3677 }
while (!consumeIf(
'E'));
3682 SoFar = getDerived().parseUnresolvedType();
3683 if (SoFar ==
nullptr)
3686 if (look() ==
'I') {
3687 Node *TA = getDerived().parseTemplateArgs();
3690 SoFar = make<NameWithTemplateArgs>(SoFar, TA);
3698 Node *Base = getDerived().parseBaseUnresolvedName();
3699 if (Base ==
nullptr)
3701 return make<QualifiedName>(SoFar, Base);
3706template <
typename Derived,
typename Alloc>
3708 while (consumeIf(
'B')) {
3709 std::string_view SN = parseBareSourceName();
3712 N = make<AbiTagAttr>(
N, SN);
3720template <
typename Alloc,
typename Derived>
3723 const char *Tmp = First;
3726 if (numLeft() == 0 || !std::isdigit(*First))
3727 return std::string_view();
3728 while (numLeft() != 0 && std::isdigit(*First))
3730 return std::string_view(Tmp, First - Tmp);
3734template <
typename Alloc,
typename Derived>
3737 if (look() <
'0' || look() >
'9')
3739 while (look() >=
'0' && look() <=
'9') {
3741 *Out +=
static_cast<size_t>(
consume() -
'0');
3746template <
typename Alloc,
typename Derived>
3749 if (parsePositiveInteger(&
Int) || numLeft() <
Int)
3751 std::string_view R(First,
Int);
3764template <
typename Derived,
typename Alloc>
3768 Node *ExceptionSpec =
nullptr;
3769 if (consumeIf(
"Do")) {
3770 ExceptionSpec = make<NameType>(
"noexcept");
3773 }
else if (consumeIf(
"DO")) {
3774 Node *
E = getDerived().parseExpr();
3775 if (
E ==
nullptr || !consumeIf(
'E'))
3777 ExceptionSpec = make<NoexceptSpec>(
E);
3780 }
else if (consumeIf(
"Dw")) {
3781 size_t SpecsBegin = Names.
size();
3782 while (!consumeIf(
'E')) {
3783 Node *
T = getDerived().parseType();
3789 make<DynamicExceptionSpec>(popTrailingNodeArray(SpecsBegin));
3796 if (!consumeIf(
'F'))
3799 Node *ReturnType = getDerived().parseType();
3800 if (ReturnType ==
nullptr)
3804 size_t ParamsBegin = Names.
size();
3810 if (consumeIf(
"RE")) {
3814 if (consumeIf(
"OE")) {
3818 Node *
T = getDerived().parseType();
3824 NodeArray Params = popTrailingNodeArray(ParamsBegin);
3825 return make<FunctionType>(ReturnType, Params, CVQuals,
3826 ReferenceQualifier, ExceptionSpec);
3834template <
typename Derived,
typename Alloc>
3836 if (!consumeIf(
"Dv"))
3838 if (look() >=
'1' && look() <=
'9') {
3839 Node *DimensionNumber = make<NameType>(parseNumber());
3840 if (!DimensionNumber)
3842 if (!consumeIf(
'_'))
3845 return make<PixelVectorType>(DimensionNumber);
3846 Node *ElemType = getDerived().parseType();
3847 if (ElemType ==
nullptr)
3849 return make<VectorType>(ElemType, DimensionNumber);
3852 if (!consumeIf(
'_')) {
3853 Node *DimExpr = getDerived().parseExpr();
3856 if (!consumeIf(
'_'))
3858 Node *ElemType = getDerived().parseType();
3861 return make<VectorType>(ElemType, DimExpr);
3863 Node *ElemType = getDerived().parseType();
3866 return make<VectorType>(ElemType,
nullptr);
3871template <
typename Derived,
typename Alloc>
3873 if (!consumeIf(
'D'))
3875 if (!consumeIf(
't') && !consumeIf(
'T'))
3877 Node *
E = getDerived().parseExpr();
3880 if (!consumeIf(
'E'))
3882 return make<EnclosingExpr>(
"decltype",
E);
3887template <
typename Derived,
typename Alloc>
3889 if (!consumeIf(
'A'))
3892 Node *Dimension =
nullptr;
3894 if (std::isdigit(look())) {
3895 Dimension = make<NameType>(parseNumber());
3898 if (!consumeIf(
'_'))
3900 }
else if (!consumeIf(
'_')) {
3901 Node *DimExpr = getDerived().parseExpr();
3902 if (DimExpr ==
nullptr)
3904 if (!consumeIf(
'_'))
3906 Dimension = DimExpr;
3909 Node *Ty = getDerived().parseType();
3912 return make<ArrayType>(Ty, Dimension);
3916template <
typename Derived,
typename Alloc>
3918 if (!consumeIf(
'M'))
3920 Node *ClassType = getDerived().parseType();
3921 if (ClassType ==
nullptr)
3923 Node *MemberType = getDerived().parseType();
3924 if (MemberType ==
nullptr)
3926 return make<PointerToMemberType>(ClassType, MemberType);
3933template <
typename Derived,
typename Alloc>
3935 std::string_view ElabSpef;
3936 if (consumeIf(
"Ts"))
3937 ElabSpef =
"struct";
3938 else if (consumeIf(
"Tu"))
3940 else if (consumeIf(
"Te"))
3943 Node *
Name = getDerived().parseName();
3944 if (
Name ==
nullptr)
3947 if (!ElabSpef.empty())
3948 return make<ElaboratedTypeSpefType>(ElabSpef,
Name);
3956template <
typename Derived,
typename Alloc>
3958 if (consumeIf(
'U')) {
3959 std::string_view Qual = parseBareSourceName();
3965 constexpr size_t Len =
sizeof(
"objcproto") - 1;
3966 std::string_view ProtoSourceName(Qual.data() + Len, Qual.size() - Len);
3967 std::string_view Proto;
3970 SaveLast(Last, &*ProtoSourceName.rbegin() + 1);
3971 Proto = parseBareSourceName();
3975 Node *Child = getDerived().parseQualifiedType();
3976 if (Child ==
nullptr)
3978 return make<ObjCProtoName>(Child, Proto);
3982 if (look() ==
'I') {
3983 TA = getDerived().parseTemplateArgs();
3988 Node *Child = getDerived().parseQualifiedType();
3989 if (Child ==
nullptr)
3991 return make<VendorExtQualType>(Child, Qual, TA);
3995 Node *Ty = getDerived().parseType();
3999 Ty = make<QualType>(Ty, Quals);
4023template <
typename Derived,
typename Alloc>
4025 Node *Result =
nullptr;
4032 unsigned AfterQuals = 0;
4033 if (look(AfterQuals) ==
'r') ++AfterQuals;
4034 if (look(AfterQuals) ==
'V') ++AfterQuals;
4035 if (look(AfterQuals) ==
'K') ++AfterQuals;
4037 if (look(AfterQuals) ==
'F' ||
4038 (look(AfterQuals) ==
'D' &&
4039 (look(AfterQuals + 1) ==
'o' || look(AfterQuals + 1) ==
'O' ||
4040 look(AfterQuals + 1) ==
'w' || look(AfterQuals + 1) ==
'x'))) {
4041 Result = getDerived().parseFunctionType();
4047 Result = getDerived().parseQualifiedType();
4053 return make<NameType>(
"void");
4057 return make<NameType>(
"wchar_t");
4061 return make<NameType>(
"bool");
4065 return make<NameType>(
"char");
4069 return make<NameType>(
"signed char");
4073 return make<NameType>(
"unsigned char");
4077 return make<NameType>(
"short");
4081 return make<NameType>(
"unsigned short");
4085 return make<NameType>(
"int");
4089 return make<NameType>(
"unsigned int");
4093 return make<NameType>(
"long");
4097 return make<NameType>(
"unsigned long");
4101 return make<NameType>(
"long long");
4105 return make<NameType>(
"unsigned long long");
4109 return make<NameType>(
"__int128");
4113 return make<NameType>(
"unsigned __int128");
4117 return make<NameType>(
"float");
4121 return make<NameType>(
"double");
4125 return make<NameType>(
"long double");
4129 return make<NameType>(
"__float128");
4133 return make<NameType>(
"...");
4138 std::string_view Res = parseBareSourceName();
4144 if (consumeIf(
'I')) {
4148 if (!consumeIf(
'E'))
4150 Result = make<TransformedType>(Res,
BaseType);
4152 Result = make<NameType>(Res);
4160 return make<NameType>(
"decimal64");
4164 return make<NameType>(
"decimal128");
4168 return make<NameType>(
"decimal32");
4172 return make<NameType>(
"half");
4176 Node *DimensionNumber = make<NameType>(parseNumber());
4177 if (!DimensionNumber)
4179 if (!consumeIf(
'_'))
4181 return make<BinaryFPType>(DimensionNumber);
4189 bool Signed = look(1) ==
'B';
4191 Node *
Size = std::isdigit(look()) ? make<NameType>(parseNumber())
4192 : getDerived().parseExpr();
4195 if (!consumeIf(
'_'))
4202 return make<NameType>(
"char32_t");
4206 return make<NameType>(
"char16_t");
4210 return make<NameType>(
"char8_t");
4214 return make<NameType>(
"auto");
4218 return make<NameType>(
"decltype(auto)");
4223 std::string_view Kind = look(1) ==
'k' ?
" auto" :
" decltype(auto)";
4225 Node *Constraint = getDerived().parseName();
4228 return make<PostfixQualifiedType>(Constraint, Kind);
4233 return make<NameType>(
"std::nullptr_t");
4238 Result = getDerived().parseDecltype();
4243 Result = getDerived().parseVectorType();
4249 Node *Child = getDerived().parseType();
4252 Result = make<ParameterPackExpansion>(Child);
4261 Result = getDerived().parseFunctionType();
4267 Result = getDerived().parseFunctionType();
4272 Result = getDerived().parseArrayType();
4277 Result = getDerived().parsePointerToMemberType();
4283 if (look(1) ==
's' || look(1) ==
'u' || look(1) ==
'e') {
4284 Result = getDerived().parseClassEnumType();
4288 Result = getDerived().parseTemplateParam();
4289 if (Result ==
nullptr)
4302 if (TryToParseTemplateArgs && look() ==
'I') {
4303 Node *TA = getDerived().parseTemplateArgs();
4306 Result = make<NameWithTemplateArgs>(Result, TA);
4313 Node *
Ptr = getDerived().parseType();
4316 Result = make<PointerType>(
Ptr);
4322 Node *Ref = getDerived().parseType();
4331 Node *Ref = getDerived().parseType();
4340 Node *
P = getDerived().parseType();
4343 Result = make<PostfixQualifiedType>(
P,
" complex");
4349 Node *
P = getDerived().parseType();
4352 Result = make<PostfixQualifiedType>(
P,
" imaginary");
4357 if (look(1) !=
't') {
4358 bool IsSubst =
false;
4359 Result = getDerived().parseUnscopedName(
nullptr, &IsSubst);
4373 if (look() ==
'I' && (!IsSubst || TryToParseTemplateArgs)) {
4376 Node *TA = getDerived().parseTemplateArgs();
4379 Result = make<NameWithTemplateArgs>(Result, TA);
4380 }
else if (IsSubst) {
4391 Result = getDerived().parseClassEnumType();
4399 if (Result !=
nullptr)
4404template <
typename Derived,
typename Alloc>
4408 Node *
E = getDerived().parseExpr();
4411 return make<PrefixExpr>(Kind,
E, Prec);
4414template <
typename Derived,
typename Alloc>
4418 Node *
LHS = getDerived().parseExpr();
4421 Node *
RHS = getDerived().parseExpr();
4424 return make<BinaryExpr>(
LHS, Kind,
RHS, Prec);
4427template <
typename Derived,
typename Alloc>
4429 std::string_view Lit) {
4430 std::string_view Tmp = parseNumber(
true);
4431 if (!Tmp.empty() && consumeIf(
'E'))
4432 return make<IntegerLiteral>(Lit, Tmp);
4437template <
typename Alloc,
typename Derived>
4454template <
typename Derived,
typename Alloc>
4456 if (consumeIf(
"fpT"))
4457 return make<NameType>(
"this");
4458 if (consumeIf(
"fp")) {
4459 parseCVQualifiers();
4460 std::string_view Num = parseNumber();
4461 if (!consumeIf(
'_'))
4463 return make<FunctionParam>(Num);
4465 if (consumeIf(
"fL")) {
4466 if (parseNumber().empty())
4468 if (!consumeIf(
'p'))
4470 parseCVQualifiers();
4471 std::string_view Num = parseNumber();
4472 if (!consumeIf(
'_'))
4474 return make<FunctionParam>(Num);
4481template <
typename Derived,
typename Alloc>
4483 if (!consumeIf(
"cv"))
4488 Ty = getDerived().parseType();
4494 if (consumeIf(
'_')) {
4495 size_t ExprsBegin = Names.
size();
4496 while (!consumeIf(
'E')) {
4497 Node *
E = getDerived().parseExpr();
4502 NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
4503 return make<ConversionExpr>(Ty, Exprs);
4506 Node *
E[1] = {getDerived().parseExpr()};
4507 if (
E[0] ==
nullptr)
4509 return make<ConversionExpr>(Ty, makeNodeArray(
E,
E + 1));
4519template <
typename Derived,
typename Alloc>
4521 if (!consumeIf(
'L'))
4526 return getDerived().parseIntegerLiteral(
"wchar_t");
4528 if (consumeIf(
"b0E"))
4529 return make<BoolExpr>(0);
4530 if (consumeIf(
"b1E"))
4531 return make<BoolExpr>(1);
4535 return getDerived().parseIntegerLiteral(
"char");
4538 return getDerived().parseIntegerLiteral(
"signed char");
4541 return getDerived().parseIntegerLiteral(
"unsigned char");
4544 return getDerived().parseIntegerLiteral(
"short");
4547 return getDerived().parseIntegerLiteral(
"unsigned short");
4550 return getDerived().parseIntegerLiteral(
"");
4553 return getDerived().parseIntegerLiteral(
"u");
4556 return getDerived().parseIntegerLiteral(
"l");
4559 return getDerived().parseIntegerLiteral(
"ul");
4562 return getDerived().parseIntegerLiteral(
"ll");
4565 return getDerived().parseIntegerLiteral(
"ull");
4568 return getDerived().parseIntegerLiteral(
"__int128");
4571 return getDerived().parseIntegerLiteral(
"unsigned __int128");
4574 return getDerived().template parseFloatingLiteral<float>();
4577 return getDerived().template parseFloatingLiteral<double>();
4580#if defined(__powerpc__) || defined(__s390__)
4583 return getDerived().template parseFloatingLiteral<double>();
4585 return getDerived().template parseFloatingLiteral<long double>();
4588 if (consumeIf(
"_Z")) {
4589 Node *R = getDerived().parseEncoding();
4590 if (R !=
nullptr && consumeIf(
'E'))
4595 Node *
T = getDerived().parseType();
4600 return make<StringLiteral>(
T);
4604 if (consumeIf(
"Dn") && (consumeIf(
'0'), consumeIf(
'E')))
4605 return make<NameType>(
"nullptr");
4615 Node *
T = parseUnnamedTypeName(
nullptr);
4616 if (!
T || !consumeIf(
'E'))
4618 return make<LambdaExpr>(
T);
4622 Node *
T = getDerived().parseType();
4625 std::string_view
N = parseNumber(
true);
4628 if (!consumeIf(
'E'))
4630 return make<EnumLiteral>(
T,
N);
4639template <
typename Derived,
typename Alloc>
4641 if (look() ==
'd') {
4645 Node *
Field = getDerived().parseSourceName(
nullptr);
4646 if (
Field ==
nullptr)
4648 Node *Init = getDerived().parseBracedExpr();
4649 if (Init ==
nullptr)
4651 return make<BracedExpr>(
Field, Init,
false);
4656 if (
Index ==
nullptr)
4658 Node *Init = getDerived().parseBracedExpr();
4659 if (Init ==
nullptr)
4661 return make<BracedExpr>(
Index, Init,
true);
4665 Node *RangeBegin = getDerived().parseExpr();
4666 if (RangeBegin ==
nullptr)
4668 Node *RangeEnd = getDerived().parseExpr();
4669 if (RangeEnd ==
nullptr)
4671 Node *Init = getDerived().parseBracedExpr();
4672 if (Init ==
nullptr)
4674 return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
4678 return getDerived().parseExpr();
4686template <
typename Derived,
typename Alloc>
4688 if (!consumeIf(
'f'))
4691 bool IsLeftFold =
false, HasInitializer =
false;
4697 HasInitializer =
true;
4700 HasInitializer =
true;
4710 const auto *Op = parseOperatorEncoding();
4713 if (!(Op->getKind() == OperatorInfo::Binary
4714 || (Op->getKind() == OperatorInfo::Member
4715 && Op->getName().back() ==
'*')))
4718 Node *Pack = getDerived().parseExpr();
4719 if (Pack ==
nullptr)
4722 Node *Init =
nullptr;
4723 if (HasInitializer) {
4724 Init = getDerived().parseExpr();
4725 if (Init ==
nullptr)
4729 if (IsLeftFold && Init)
4732 return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
4738template <
typename Derived,
typename Alloc>
4742 Node *Ty = getDerived().parseType();
4745 Node *Expr = getDerived().parseExpr();
4748 std::string_view
Offset = getDerived().parseNumber(
true);
4749 if (!consumeIf(
'E'))
4751 return make<PointerToMemberConversionExpr>(Ty, Expr,
Offset, Prec);
4758template <
typename Derived,
typename Alloc>
4760 Node *Ty = getDerived().parseType();
4763 Node *Expr = getDerived().parseExpr();
4766 std::string_view
Offset = getDerived().parseNumber(
true);
4767 size_t SelectorsBegin = Names.
size();
4768 while (consumeIf(
'_')) {
4769 Node *Selector = make<NameType>(parseNumber());
4774 bool OnePastTheEnd = consumeIf(
'p');
4775 if (!consumeIf(
'E'))
4777 return make<SubobjectExpr>(
4778 Ty, Expr,
Offset, popTrailingNodeArray(SelectorsBegin), OnePastTheEnd);
4781template <
typename Derived,
typename Alloc>
4786 return getDerived().parseExpr();
4789template <
typename Derived,
typename Alloc>
4792 if (consumeIf(
"rQ")) {
4794 size_t ParamsBegin = Names.
size();
4795 while (!consumeIf(
'_')) {
4796 Node *
Type = getDerived().parseType();
4797 if (
Type ==
nullptr)
4801 Params = popTrailingNodeArray(ParamsBegin);
4802 }
else if (!consumeIf(
"rq")) {
4807 size_t ReqsBegin = Names.
size();
4809 Node *Constraint =
nullptr;
4810 if (consumeIf(
'X')) {
4812 Node *Expr = getDerived().parseExpr();
4813 if (Expr ==
nullptr)
4815 bool Noexcept = consumeIf(
'N');
4816 Node *TypeReq =
nullptr;
4817 if (consumeIf(
'R')) {
4818 TypeReq = getDerived().parseName();
4819 if (TypeReq ==
nullptr)
4822 Constraint = make<ExprRequirement>(Expr, Noexcept, TypeReq);
4823 }
else if (consumeIf(
'T')) {
4825 Node *
Type = getDerived().parseType();
4826 if (
Type ==
nullptr)
4828 Constraint = make<TypeRequirement>(
Type);
4829 }
else if (consumeIf(
'Q')) {
4837 Node *NestedReq = getDerived().parseExpr();
4838 if (NestedReq ==
nullptr)
4840 Constraint = make<NestedRequirement>(NestedReq);
4842 if (Constraint ==
nullptr)
4845 }
while (!consumeIf(
'E'));
4847 return make<RequiresExpr>(Params, popTrailingNodeArray(ReqsBegin));
4894template <
typename Derived,
typename Alloc>
4896 bool Global = consumeIf(
"gs");
4898 const auto *Op = parseOperatorEncoding();
4900 auto Sym = Op->getSymbol();
4901 switch (Op->getKind()) {
4902 case OperatorInfo::Binary:
4904 return getDerived().parseBinaryExpr(
Sym, Op->getPrecedence());
4905 case OperatorInfo::Prefix:
4907 return getDerived().parsePrefixExpr(
Sym, Op->getPrecedence());
4908 case OperatorInfo::Postfix: {
4911 return getDerived().parsePrefixExpr(
Sym, Op->getPrecedence());
4912 Node *Ex = getDerived().parseExpr();
4915 return make<PostfixExpr>(Ex,
Sym, Op->getPrecedence());
4917 case OperatorInfo::Array: {
4919 Node *Base = getDerived().parseExpr();
4920 if (Base ==
nullptr)
4923 if (
Index ==
nullptr)
4925 return make<ArraySubscriptExpr>(Base,
Index, Op->getPrecedence());
4927 case OperatorInfo::Member: {
4929 Node *
LHS = getDerived().parseExpr();
4932 Node *
RHS = getDerived().parseExpr();
4935 return make<MemberExpr>(
LHS,
Sym,
RHS, Op->getPrecedence());
4937 case OperatorInfo::New: {
4943 size_t Exprs = Names.
size();
4944 while (!consumeIf(
'_')) {
4945 Node *Ex = getDerived().parseExpr();
4950 NodeArray ExprList = popTrailingNodeArray(Exprs);
4951 Node *Ty = getDerived().parseType();
4954 bool HaveInits = consumeIf(
"pi");
4955 size_t InitsBegin = Names.
size();
4956 while (!consumeIf(
'E')) {
4959 Node *Init = getDerived().parseExpr();
4960 if (Init ==
nullptr)
4964 NodeArray Inits = popTrailingNodeArray(InitsBegin);
4965 return make<NewExpr>(ExprList, Ty, Inits, Global,
4966 Op->getFlag(), Op->getPrecedence());
4968 case OperatorInfo::Del: {
4970 Node *Ex = getDerived().parseExpr();
4973 return make<DeleteExpr>(Ex, Global, Op->getFlag(),
4974 Op->getPrecedence());
4976 case OperatorInfo::Call: {
4978 Node *Callee = getDerived().parseExpr();
4979 if (Callee ==
nullptr)
4981 size_t ExprsBegin = Names.
size();
4982 while (!consumeIf(
'E')) {
4983 Node *
E = getDerived().parseExpr();