llvm/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

//===- MicrosoftDemangle.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines a demangler for MSVC-style mangled symbols.
//
//===----------------------------------------------------------------------===//

#include "llvm/Demangle/MicrosoftDemangleNodes.h"
#include "llvm/Demangle/Utility.h"
#include <cctype>
#include <string>

usingnamespacellvm;
usingnamespacems_demangle;

#define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc) …

// Writes a space if the last token does not end with a punctuation.
static void outputSpaceIfNecessary(OutputBuffer &OB) { … }

static void outputSingleQualifier(OutputBuffer &OB, Qualifiers Q) { … }

static bool outputQualifierIfPresent(OutputBuffer &OB, Qualifiers Q,
                                     Qualifiers Mask, bool NeedSpace) { … }

static void outputQualifiers(OutputBuffer &OB, Qualifiers Q, bool SpaceBefore,
                             bool SpaceAfter) { … }

static void outputCallingConvention(OutputBuffer &OB, CallingConv CC) { … }

std::string Node::toString(OutputFlags Flags) const { … }

void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }

void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags,
                           std::string_view Separator) const { … }

void EncodedStringLiteralNode::output(OutputBuffer &OB,
                                      OutputFlags Flags) const { … }

void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void TemplateParameterReferenceNode::output(OutputBuffer &OB,
                                            OutputFlags Flags) const { … }

void IdentifierNode::outputTemplateParameters(OutputBuffer &OB,
                                              OutputFlags Flags) const { … }

void DynamicStructorIdentifierNode::output(OutputBuffer &OB,
                                           OutputFlags Flags) const { … }

void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void IntrinsicFunctionIdentifierNode::output(OutputBuffer &OB,
                                             OutputFlags Flags) const { … }

void LocalStaticGuardIdentifierNode::output(OutputBuffer &OB,
                                            OutputFlags Flags) const { … }

void ConversionOperatorIdentifierNode::output(OutputBuffer &OB,
                                              OutputFlags Flags) const { … }

void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
                                           OutputFlags Flags) const { … }

void FunctionSignatureNode::outputPre(OutputBuffer &OB,
                                      OutputFlags Flags) const { … }

void FunctionSignatureNode::outputPost(OutputBuffer &OB,
                                       OutputFlags Flags) const { … }

void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }

void ThunkSignatureNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { … }

void PointerTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }

void PointerTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { … }

void TagTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }

void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { … }

void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }

void ArrayTypeNode::outputOneDimension(OutputBuffer &OB, OutputFlags Flags,
                                       Node *N) const { … }

void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB,
                                         OutputFlags Flags) const { … }

void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { … }

void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void FunctionSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void VariableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const { … }
void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const { … }

void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }

void RttiBaseClassDescriptorNode::output(OutputBuffer &OB,
                                         OutputFlags Flags) const { … }

void LocalStaticGuardVariableNode::output(OutputBuffer &OB,
                                          OutputFlags Flags) const { … }

void VcallThunkIdentifierNode::output(OutputBuffer &OB,
                                      OutputFlags Flags) const { … }

void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const { … }