aboutsummaryrefslogtreecommitdiff
path: root/contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp')
-rw-r--r--contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp408
1 files changed, 204 insertions, 204 deletions
diff --git a/contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp b/contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
index 9fe157bf0d2a..32d8dff66c3f 100644
--- a/contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
+++ b/contrib/llvm-project/llvm/lib/Demangle/MicrosoftDemangleNodes.cpp
@@ -21,97 +21,97 @@ using namespace ms_demangle;
#define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc) \
case Enum::Value: \
- OS << Desc; \
+ OB << Desc; \
break;
// Writes a space if the last token does not end with a punctuation.
-static void outputSpaceIfNecessary(OutputStream &OS) {
- if (OS.empty())
+static void outputSpaceIfNecessary(OutputBuffer &OB) {
+ if (OB.empty())
return;
- char C = OS.back();
+ char C = OB.back();
if (std::isalnum(C) || C == '>')
- OS << " ";
+ OB << " ";
}
-static void outputSingleQualifier(OutputStream &OS, Qualifiers Q) {
+static void outputSingleQualifier(OutputBuffer &OB, Qualifiers Q) {
switch (Q) {
case Q_Const:
- OS << "const";
+ OB << "const";
break;
case Q_Volatile:
- OS << "volatile";
+ OB << "volatile";
break;
case Q_Restrict:
- OS << "__restrict";
+ OB << "__restrict";
break;
default:
break;
}
}
-static bool outputQualifierIfPresent(OutputStream &OS, Qualifiers Q,
+static bool outputQualifierIfPresent(OutputBuffer &OB, Qualifiers Q,
Qualifiers Mask, bool NeedSpace) {
if (!(Q & Mask))
return NeedSpace;
if (NeedSpace)
- OS << " ";
+ OB << " ";
- outputSingleQualifier(OS, Mask);
+ outputSingleQualifier(OB, Mask);
return true;
}
-static void outputQualifiers(OutputStream &OS, Qualifiers Q, bool SpaceBefore,
+static void outputQualifiers(OutputBuffer &OB, Qualifiers Q, bool SpaceBefore,
bool SpaceAfter) {
if (Q == Q_None)
return;
- size_t Pos1 = OS.getCurrentPosition();
- SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Const, SpaceBefore);
- SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Volatile, SpaceBefore);
- SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Restrict, SpaceBefore);
- size_t Pos2 = OS.getCurrentPosition();
+ size_t Pos1 = OB.getCurrentPosition();
+ SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Const, SpaceBefore);
+ SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Volatile, SpaceBefore);
+ SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Restrict, SpaceBefore);
+ size_t Pos2 = OB.getCurrentPosition();
if (SpaceAfter && Pos2 > Pos1)
- OS << " ";
+ OB << " ";
}
-static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
- outputSpaceIfNecessary(OS);
+static void outputCallingConvention(OutputBuffer &OB, CallingConv CC) {
+ outputSpaceIfNecessary(OB);
switch (CC) {
case CallingConv::Cdecl:
- OS << "__cdecl";
+ OB << "__cdecl";
break;
case CallingConv::Fastcall:
- OS << "__fastcall";
+ OB << "__fastcall";
break;
case CallingConv::Pascal:
- OS << "__pascal";
+ OB << "__pascal";
break;
case CallingConv::Regcall:
- OS << "__regcall";
+ OB << "__regcall";
break;
case CallingConv::Stdcall:
- OS << "__stdcall";
+ OB << "__stdcall";
break;
case CallingConv::Thiscall:
- OS << "__thiscall";
+ OB << "__thiscall";
break;
case CallingConv::Eabi:
- OS << "__eabi";
+ OB << "__eabi";
break;
case CallingConv::Vectorcall:
- OS << "__vectorcall";
+ OB << "__vectorcall";
break;
case CallingConv::Clrcall:
- OS << "__clrcall";
+ OB << "__clrcall";
break;
case CallingConv::Swift:
- OS << "__attribute__((__swiftcall__)) ";
+ OB << "__attribute__((__swiftcall__)) ";
break;
case CallingConv::SwiftAsync:
- OS << "__attribute__((__swiftasynccall__)) ";
+ OB << "__attribute__((__swiftasynccall__)) ";
break;
default:
break;
@@ -119,16 +119,16 @@ static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
}
std::string Node::toString(OutputFlags Flags) const {
- OutputStream OS;
- initializeOutputStream(nullptr, nullptr, OS, 1024);
- this->output(OS, Flags);
- OS << '\0';
- std::string Owned(OS.getBuffer());
- std::free(OS.getBuffer());
+ OutputBuffer OB;
+ initializeOutputBuffer(nullptr, nullptr, OB, 1024);
+ this->output(OB, Flags);
+ OB << '\0';
+ std::string Owned(OB.getBuffer());
+ std::free(OB.getBuffer());
return Owned;
}
-void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
switch (PrimKind) {
OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool");
@@ -152,107 +152,107 @@ void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double");
OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t");
}
- outputQualifiers(OS, Quals, true, false);
+ outputQualifiers(OB, Quals, true, false);
}
-void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags) const {
- output(OS, Flags, ", ");
+void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ output(OB, Flags, ", ");
}
-void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags,
+void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags,
StringView Separator) const {
if (Count == 0)
return;
if (Nodes[0])
- Nodes[0]->output(OS, Flags);
+ Nodes[0]->output(OB, Flags);
for (size_t I = 1; I < Count; ++I) {
- OS << Separator;
- Nodes[I]->output(OS, Flags);
+ OB << Separator;
+ Nodes[I]->output(OB, Flags);
}
}
-void EncodedStringLiteralNode::output(OutputStream &OS,
+void EncodedStringLiteralNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
switch (Char) {
case CharKind::Wchar:
- OS << "L\"";
+ OB << "L\"";
break;
case CharKind::Char:
- OS << "\"";
+ OB << "\"";
break;
case CharKind::Char16:
- OS << "u\"";
+ OB << "u\"";
break;
case CharKind::Char32:
- OS << "U\"";
+ OB << "U\"";
break;
}
- OS << DecodedString << "\"";
+ OB << DecodedString << "\"";
if (IsTruncated)
- OS << "...";
+ OB << "...";
}
-void IntegerLiteralNode::output(OutputStream &OS, OutputFlags Flags) const {
+void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const {
if (IsNegative)
- OS << '-';
- OS << Value;
+ OB << '-';
+ OB << Value;
}
-void TemplateParameterReferenceNode::output(OutputStream &OS,
+void TemplateParameterReferenceNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
if (ThunkOffsetCount > 0)
- OS << "{";
+ OB << "{";
else if (Affinity == PointerAffinity::Pointer)
- OS << "&";
+ OB << "&";
if (Symbol) {
- Symbol->output(OS, Flags);
+ Symbol->output(OB, Flags);
if (ThunkOffsetCount > 0)
- OS << ", ";
+ OB << ", ";
}
if (ThunkOffsetCount > 0)
- OS << ThunkOffsets[0];
+ OB << ThunkOffsets[0];
for (int I = 1; I < ThunkOffsetCount; ++I) {
- OS << ", " << ThunkOffsets[I];
+ OB << ", " << ThunkOffsets[I];
}
if (ThunkOffsetCount > 0)
- OS << "}";
+ OB << "}";
}
-void IdentifierNode::outputTemplateParameters(OutputStream &OS,
+void IdentifierNode::outputTemplateParameters(OutputBuffer &OB,
OutputFlags Flags) const {
if (!TemplateParams)
return;
- OS << "<";
- TemplateParams->output(OS, Flags);
- OS << ">";
+ OB << "<";
+ TemplateParams->output(OB, Flags);
+ OB << ">";
}
-void DynamicStructorIdentifierNode::output(OutputStream &OS,
+void DynamicStructorIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
if (IsDestructor)
- OS << "`dynamic atexit destructor for ";
+ OB << "`dynamic atexit destructor for ";
else
- OS << "`dynamic initializer for ";
+ OB << "`dynamic initializer for ";
if (Variable) {
- OS << "`";
- Variable->output(OS, Flags);
- OS << "''";
+ OB << "`";
+ Variable->output(OB, Flags);
+ OB << "''";
} else {
- OS << "'";
- Name->output(OS, Flags);
- OS << "''";
+ OB << "'";
+ Name->output(OB, Flags);
+ OB << "''";
}
}
-void NamedIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
- OS << Name;
- outputTemplateParameters(OS, Flags);
+void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ OB << Name;
+ outputTemplateParameters(OB, Flags);
}
-void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
+void IntrinsicFunctionIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
switch (Operator) {
OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
@@ -350,188 +350,188 @@ void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
case IntrinsicFunctionKind::None:
break;
}
- outputTemplateParameters(OS, Flags);
+ outputTemplateParameters(OB, Flags);
}
-void LocalStaticGuardIdentifierNode::output(OutputStream &OS,
+void LocalStaticGuardIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
if (IsThread)
- OS << "`local static thread guard'";
+ OB << "`local static thread guard'";
else
- OS << "`local static guard'";
+ OB << "`local static guard'";
if (ScopeIndex > 0)
- OS << "{" << ScopeIndex << "}";
+ OB << "{" << ScopeIndex << "}";
}
-void ConversionOperatorIdentifierNode::output(OutputStream &OS,
+void ConversionOperatorIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
- OS << "operator";
- outputTemplateParameters(OS, Flags);
- OS << " ";
- TargetType->output(OS, Flags);
+ OB << "operator";
+ outputTemplateParameters(OB, Flags);
+ OB << " ";
+ TargetType->output(OB, Flags);
}
-void StructorIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
+void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
if (IsDestructor)
- OS << "~";
- Class->output(OS, Flags);
- outputTemplateParameters(OS, Flags);
+ OB << "~";
+ Class->output(OB, Flags);
+ outputTemplateParameters(OB, Flags);
}
-void LiteralOperatorIdentifierNode::output(OutputStream &OS,
+void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
- OS << "operator \"\"" << Name;
- outputTemplateParameters(OS, Flags);
+ OB << "operator \"\"" << Name;
+ outputTemplateParameters(OB, Flags);
}
-void FunctionSignatureNode::outputPre(OutputStream &OS,
+void FunctionSignatureNode::outputPre(OutputBuffer &OB,
OutputFlags Flags) const {
if (!(Flags & OF_NoAccessSpecifier)) {
if (FunctionClass & FC_Public)
- OS << "public: ";
+ OB << "public: ";
if (FunctionClass & FC_Protected)
- OS << "protected: ";
+ OB << "protected: ";
if (FunctionClass & FC_Private)
- OS << "private: ";
+ OB << "private: ";
}
if (!(Flags & OF_NoMemberType)) {
if (!(FunctionClass & FC_Global)) {
if (FunctionClass & FC_Static)
- OS << "static ";
+ OB << "static ";
}
if (FunctionClass & FC_Virtual)
- OS << "virtual ";
+ OB << "virtual ";
if (FunctionClass & FC_ExternC)
- OS << "extern \"C\" ";
+ OB << "extern \"C\" ";
}
if (!(Flags & OF_NoReturnType) && ReturnType) {
- ReturnType->outputPre(OS, Flags);
- OS << " ";
+ ReturnType->outputPre(OB, Flags);
+ OB << " ";
}
if (!(Flags & OF_NoCallingConvention))
- outputCallingConvention(OS, CallConvention);
+ outputCallingConvention(OB, CallConvention);
}
-void FunctionSignatureNode::outputPost(OutputStream &OS,
+void FunctionSignatureNode::outputPost(OutputBuffer &OB,
OutputFlags Flags) const {
if (!(FunctionClass & FC_NoParameterList)) {
- OS << "(";
+ OB << "(";
if (Params)
- Params->output(OS, Flags);
+ Params->output(OB, Flags);
else
- OS << "void";
+ OB << "void";
if (IsVariadic) {
- if (OS.back() != '(')
- OS << ", ";
- OS << "...";
+ if (OB.back() != '(')
+ OB << ", ";
+ OB << "...";
}
- OS << ")";
+ OB << ")";
}
if (Quals & Q_Const)
- OS << " const";
+ OB << " const";
if (Quals & Q_Volatile)
- OS << " volatile";
+ OB << " volatile";
if (Quals & Q_Restrict)
- OS << " __restrict";
+ OB << " __restrict";
if (Quals & Q_Unaligned)
- OS << " __unaligned";
+ OB << " __unaligned";
if (IsNoexcept)
- OS << " noexcept";
+ OB << " noexcept";
if (RefQualifier == FunctionRefQualifier::Reference)
- OS << " &";
+ OB << " &";
else if (RefQualifier == FunctionRefQualifier::RValueReference)
- OS << " &&";
+ OB << " &&";
if (!(Flags & OF_NoReturnType) && ReturnType)
- ReturnType->outputPost(OS, Flags);
+ ReturnType->outputPost(OB, Flags);
}
-void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
- OS << "[thunk]: ";
+void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
+ OB << "[thunk]: ";
- FunctionSignatureNode::outputPre(OS, Flags);
+ FunctionSignatureNode::outputPre(OB, Flags);
}
-void ThunkSignatureNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
+void ThunkSignatureNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
if (FunctionClass & FC_StaticThisAdjust) {
- OS << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
+ OB << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
} else if (FunctionClass & FC_VirtualThisAdjust) {
if (FunctionClass & FC_VirtualThisAdjustEx) {
- OS << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
+ OB << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
<< ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
<< ", " << ThisAdjust.StaticOffset << "}'";
} else {
- OS << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
+ OB << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
<< ThisAdjust.StaticOffset << "}'";
}
}
- FunctionSignatureNode::outputPost(OS, Flags);
+ FunctionSignatureNode::outputPost(OB, Flags);
}
-void PointerTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void PointerTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
if (Pointee->kind() == NodeKind::FunctionSignature) {
// If this is a pointer to a function, don't output the calling convention.
// It needs to go inside the parentheses.
const FunctionSignatureNode *Sig =
static_cast<const FunctionSignatureNode *>(Pointee);
- Sig->outputPre(OS, OF_NoCallingConvention);
+ Sig->outputPre(OB, OF_NoCallingConvention);
} else
- Pointee->outputPre(OS, Flags);
+ Pointee->outputPre(OB, Flags);
- outputSpaceIfNecessary(OS);
+ outputSpaceIfNecessary(OB);
if (Quals & Q_Unaligned)
- OS << "__unaligned ";
+ OB << "__unaligned ";
if (Pointee->kind() == NodeKind::ArrayType) {
- OS << "(";
+ OB << "(";
} else if (Pointee->kind() == NodeKind::FunctionSignature) {
- OS << "(";
+ OB << "(";
const FunctionSignatureNode *Sig =
static_cast<const FunctionSignatureNode *>(Pointee);
- outputCallingConvention(OS, Sig->CallConvention);
- OS << " ";
+ outputCallingConvention(OB, Sig->CallConvention);
+ OB << " ";
}
if (ClassParent) {
- ClassParent->output(OS, Flags);
- OS << "::";
+ ClassParent->output(OB, Flags);
+ OB << "::";
}
switch (Affinity) {
case PointerAffinity::Pointer:
- OS << "*";
+ OB << "*";
break;
case PointerAffinity::Reference:
- OS << "&";
+ OB << "&";
break;
case PointerAffinity::RValueReference:
- OS << "&&";
+ OB << "&&";
break;
default:
assert(false);
}
- outputQualifiers(OS, Quals, false, false);
+ outputQualifiers(OB, Quals, false, false);
}
-void PointerTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
+void PointerTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
if (Pointee->kind() == NodeKind::ArrayType ||
Pointee->kind() == NodeKind::FunctionSignature)
- OS << ")";
+ OB << ")";
- Pointee->outputPost(OS, Flags);
+ Pointee->outputPost(OB, Flags);
}
-void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
+void TagTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
if (!(Flags & OF_NoTagSpecifier)) {
switch (Tag) {
OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
@@ -539,59 +539,59 @@ void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union");
OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
}
- OS << " ";
+ OB << " ";
}
- QualifiedName->output(OS, Flags);
- outputQualifiers(OS, Quals, true, false);
+ QualifiedName->output(OB, Flags);
+ outputQualifiers(OB, Quals, true, false);
}
-void TagTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
+void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
-void ArrayTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
- ElementType->outputPre(OS, Flags);
- outputQualifiers(OS, Quals, true, false);
+void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
+ ElementType->outputPre(OB, Flags);
+ outputQualifiers(OB, Quals, true, false);
}
-void ArrayTypeNode::outputOneDimension(OutputStream &OS, OutputFlags Flags,
+void ArrayTypeNode::outputOneDimension(OutputBuffer &OB, OutputFlags Flags,
Node *N) const {
assert(N->kind() == NodeKind::IntegerLiteral);
IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
if (ILN->Value != 0)
- ILN->output(OS, Flags);
+ ILN->output(OB, Flags);
}
-void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS,
+void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB,
OutputFlags Flags) const {
if (Dimensions->Count == 0)
return;
- outputOneDimension(OS, Flags, Dimensions->Nodes[0]);
+ outputOneDimension(OB, Flags, Dimensions->Nodes[0]);
for (size_t I = 1; I < Dimensions->Count; ++I) {
- OS << "][";
- outputOneDimension(OS, Flags, Dimensions->Nodes[I]);
+ OB << "][";
+ outputOneDimension(OB, Flags, Dimensions->Nodes[I]);
}
}
-void ArrayTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
- OS << "[";
- outputDimensionsImpl(OS, Flags);
- OS << "]";
+void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
+ OB << "[";
+ outputDimensionsImpl(OB, Flags);
+ OB << "]";
- ElementType->outputPost(OS, Flags);
+ ElementType->outputPost(OB, Flags);
}
-void SymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
- Name->output(OS, Flags);
+void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ Name->output(OB, Flags);
}
-void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
- Signature->outputPre(OS, Flags);
- outputSpaceIfNecessary(OS);
- Name->output(OS, Flags);
- Signature->outputPost(OS, Flags);
+void FunctionSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ Signature->outputPre(OB, Flags);
+ outputSpaceIfNecessary(OB);
+ Name->output(OB, Flags);
+ Signature->outputPost(OB, Flags);
}
-void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
+void VariableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
const char *AccessSpec = nullptr;
bool IsStatic = true;
switch (SC) {
@@ -609,52 +609,52 @@ void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
break;
}
if (!(Flags & OF_NoAccessSpecifier) && AccessSpec)
- OS << AccessSpec << ": ";
+ OB << AccessSpec << ": ";
if (!(Flags & OF_NoMemberType) && IsStatic)
- OS << "static ";
+ OB << "static ";
- if (Type) {
- Type->outputPre(OS, Flags);
- outputSpaceIfNecessary(OS);
+ if (!(Flags & OF_NoVariableType) && Type) {
+ Type->outputPre(OB, Flags);
+ outputSpaceIfNecessary(OB);
}
- Name->output(OS, Flags);
- if (Type)
- Type->outputPost(OS, Flags);
+ Name->output(OB, Flags);
+ if (!(Flags & OF_NoVariableType) && Type)
+ Type->outputPost(OB, Flags);
}
-void CustomTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
- Identifier->output(OS, Flags);
+void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
+ Identifier->output(OB, Flags);
}
-void CustomTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
+void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
-void QualifiedNameNode::output(OutputStream &OS, OutputFlags Flags) const {
- Components->output(OS, Flags, "::");
+void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ Components->output(OB, Flags, "::");
}
-void RttiBaseClassDescriptorNode::output(OutputStream &OS,
+void RttiBaseClassDescriptorNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
- OS << "`RTTI Base Class Descriptor at (";
- OS << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
+ OB << "`RTTI Base Class Descriptor at (";
+ OB << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
<< this->Flags;
- OS << ")'";
+ OB << ")'";
}
-void LocalStaticGuardVariableNode::output(OutputStream &OS,
+void LocalStaticGuardVariableNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
- Name->output(OS, Flags);
+ Name->output(OB, Flags);
}
-void VcallThunkIdentifierNode::output(OutputStream &OS,
+void VcallThunkIdentifierNode::output(OutputBuffer &OB,
OutputFlags Flags) const {
- OS << "`vcall'{" << OffsetInVTable << ", {flat}}";
+ OB << "`vcall'{" << OffsetInVTable << ", {flat}}";
}
-void SpecialTableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
- outputQualifiers(OS, Quals, false, true);
- Name->output(OS, Flags);
+void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
+ outputQualifiers(OB, Quals, false, true);
+ Name->output(OB, Flags);
if (TargetName) {
- OS << "{for `";
- TargetName->output(OS, Flags);
- OS << "'}";
+ OB << "{for `";
+ TargetName->output(OB, Flags);
+ OB << "'}";
}
}