#include "DemangleConfig.h"
#include "StringViewExtras.h"
#include "Utility.h"
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <new>
#include <string_view>
#include <type_traits>
#include <utility>
#include "ItaniumNodes.def"

Classes
class	PODSmallVector< T, N >
class	Node
class	NodeArray
struct	NodeArrayNode
class	DotSuffix
class	VendorExtQualType
class	QualType
class	ConversionOperatorType
class	PostfixQualifiedType
class	NameType
class	BitIntType
class	ElaboratedTypeSpefType
class	TransformedType
struct	AbiTagAttr
class	EnableIfAttr
class	ObjCProtoName
class	PointerType
class	ReferenceType
class	PointerToMemberType
class	ArrayType
class	FunctionType
class	NoexceptSpec
class	DynamicExceptionSpec
class	ExplicitObjectParameter
	Represents the explicitly named object parameter. More...
class	FunctionEncoding
class	LiteralOperator
class	SpecialName
class	CtorVtableSpecialName
struct	NestedName
struct	MemberLikeFriendName
struct	ModuleName
struct	ModuleEntity
struct	LocalName
class	QualifiedName
class	VectorType
class	PixelVectorType
class	BinaryFPType
class	SyntheticTemplateParamName
	An invented name for a template parameter for which we don't have a corresponding template argument. More...
class	TemplateParamQualifiedArg
class	TypeTemplateParamDecl
	A template type parameter declaration, 'typename T'. More...
class	ConstrainedTypeTemplateParamDecl
	A constrained template type parameter declaration, 'C T'. More...
class	NonTypeTemplateParamDecl
	A non-type template parameter declaration, 'int N'. More...
class	TemplateTemplateParamDecl
	A template template parameter declaration, 'template<typename T> typename N'. More...
class	TemplateParamPackDecl
	A template parameter pack declaration, 'typename ...T'. More...
class	ParameterPack
	An unexpanded parameter pack (either in the expression or type context). More...
class	TemplateArgumentPack
	A variadic template argument. More...
class	ParameterPackExpansion
	A pack expansion. More...
class	TemplateArgs
struct	ForwardTemplateReference
	A forward-reference to a template argument that was not known at the point where the template parameter name was parsed in a mangling. More...
struct	NameWithTemplateArgs
class	GlobalQualifiedName
class	ExpandedSpecialSubstitution
class	SpecialSubstitution
class	CtorDtorName
class	DtorName
class	UnnamedTypeName
class	ClosureTypeName
class	StructuredBindingName
class	BinaryExpr
class	ArraySubscriptExpr
class	PostfixExpr
class	ConditionalExpr
class	MemberExpr
class	SubobjectExpr
class	EnclosingExpr
class	CastExpr
class	SizeofParamPackExpr
class	CallExpr
class	NewExpr
class	DeleteExpr
class	PrefixExpr
class	FunctionParam
class	ConversionExpr
class	PointerToMemberConversionExpr
class	InitListExpr
class	BracedExpr
class	BracedRangeExpr
class	FoldExpr
class	ThrowExpr
class	BoolExpr
class	StringLiteral
class	LambdaExpr
class	EnumLiteral
class	IntegerLiteral
class	RequiresExpr
class	ExprRequirement
class	TypeRequirement
class	NestedRequirement
class	FloatLiteralImpl< Float >
struct	AbstractManglingParser< Derived, Alloc >
class	AbstractManglingParser< Derived, Alloc >::ScopedTemplateParamList
class	AbstractManglingParser< Derived, Alloc >::SaveTemplateParams
struct	AbstractManglingParser< Derived, Alloc >::NameState
	Holds some extra information about a <name> that is being parsed. More...
struct	AbstractManglingParser< Derived, Alloc >::OperatorInfo
struct	FloatData< float >
struct	FloatData< double >
struct	FloatData< long double >
struct	ManglingParser< Alloc >

Namespaces
namespace	float_literal_impl

Macros
#define	NODE(NodeKind)
#define	NODE(X)
#define	NODE(X)

Typedefs
using	FloatLiteral = FloatLiteralImpl<float>
using	DoubleLiteral = FloatLiteralImpl<double>
using	LongDoubleLiteral = FloatLiteralImpl<long double>

Enumerations
enum	FunctionRefQual : unsigned char { FrefQualNone , FrefQualLValue , FrefQualRValue }
enum	Qualifiers { QualNone = 0 , QualConst = 0x1 , QualVolatile = 0x2 , QualRestrict = 0x4 }
enum class	ReferenceKind { LValue , RValue }
enum class	TemplateParamKind { Type , NonType , Template }
enum class	SpecialSubKind { allocator , basic_string , string , istream , ostream , iostream }

Functions
Qualifiers	operator\|= (Qualifiers &Q1, Qualifiers Q2)
constexpr Node::Kind	float_literal_impl::getFloatLiteralKind (float *)
constexpr Node::Kind	float_literal_impl::getFloatLiteralKind (double *)
constexpr Node::Kind	float_literal_impl::getFloatLiteralKind (long double *)
DEMANGLE_ABI const char *	parse_discriminator (const char first, const char last)

Variables
template<typename Derived, typename Alloc>
const AbstractManglingParser< Derived, Alloc >::OperatorInfo	AbstractManglingParser< Derived, Alloc >::Ops []
template<typename Derived, typename Alloc>
const size_t	AbstractManglingParser< Derived, Alloc >::NumOps

Macro Definition Documentation

◆ NODE [1/3]

#define NODE ( NodeKind )

Value:

K##NodeKind,

NodeKind

Determine the kind of a node from its type.

Definition ItaniumDemangle.h:2648

Definition at line 169 of file ItaniumDemangle.h.

Referenced by GetCodeName().

◆ NODE [2/3]

#define NODE ( X )

Value:

case K##X: \

return F(static_cast<const X *>(this));

F

#define F(x, y, z)

Definition MD5.cpp:55

X

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

Definition at line 169 of file ItaniumDemangle.h.

◆ NODE [3/3]

#define NODE ( X )

Value:

  template <> struct NodeKind<X> {                                             \
    static constexpr Node::Kind Kind = Node::K##X;                             \
    static constexpr const char *name() { return #X; }                         \
  };