public override void OutputPre(OutputStream os, OutputFlags flags)
{
if (!flags.HasFlag(OutputFlags.NoTagSpecifier))
{
switch (Tag)
{
case TagKind.Class:
os.Append("class");
break;
case TagKind.Struct:
os.Append("struct");
break;
case TagKind.Union:
os.Append("union");
break;
case TagKind.Enum:
os.Append("enum");
break;
}
os.Append(' ');
}
QualifiedName.Output(os, flags);
OutputQualifiers(os, Quals, true, false);
}
public override void Output(OutputStream os, OutputFlags flags)
{
os.Append("operator");
OutputTemplateParameters(os, flags);
os.Append(' ');
TargetType.Output(os, flags);
}
public override void Output(OutputStream os, OutputFlags flags)
{
switch (sc)
{
case StorageClass.PrivateStatic:
os.Append("private: static ");
break;
case StorageClass.PublicStatic:
os.Append("public: static ");
break;
case StorageClass.ProtectedStatic:
os.Append("protected: static ");
break;
default:
break;
}
if (Type != null)
{
Type.OutputPre(os, flags);
OutputSpaceIfNecessary(os);
}
Name.Output(os, flags);
if (Type != null)
{
Type.OutputPost(os, flags);
}
}
public override void PrintLeft(OutputStream sb)
{
sb.UsingParameterPack(int.MaxValue, int.MaxValue, () => {
int oldLength = sb.Length;
child.Print(sb);
if (sb.CurrentPackMax == int.MaxValue)
{
sb.Append("...");
return;
}
if (sb.CurrentPackMax == 0)
{
sb.Length = oldLength;
}
for (int i = 1, e = sb.CurrentPackMax; i < e; i++)
{
sb.Append(", ");
sb.CurrentPackIndex = i;
child.Print(sb);
}
});
}
public override void Output(OutputStream os, OutputFlags flags)
{
if (IsNegative)
{
os.Append('-');
}
os.Append(Value);
}
public override void OutputPost(OutputStream os, OutputFlags flags)
{
os.Append('[');
OutputDimensionsImpl(os, flags);
os.Append(']');
ElementType.OutputPost(os, flags);
}
public override void Output(OutputStream os, OutputFlags flags)
{
os.Append("`local static guard'");
if (ScopeIndex > 0)
{
os.Append('{');
os.Append(ScopeIndex);
os.Append('}');
}
}
public void OutputTemplateParameters(OutputStream os, OutputFlags flags)
{
if (TemplateParams == null)
{
return;
}
os.Append('<');
TemplateParams.Output(os, flags);
os.Append('>');
}
public override void Output(OutputStream os, OutputFlags flags)
{
OutputQualifiers(os, Quals, false, true);
Name.Output(os, flags);
if (TargetName != null)
{
os.Append("{for `");
TargetName.Output(os, flags);
os.Append("'}");
}
}
public override void OutputPre(OutputStream os, OutputFlags flags)
{
if (Pointee.Kind == NodeKind.FunctionSignature)
{
FunctionSignatureNode sig = (FunctionSignatureNode)Pointee;
sig.OutputPre(os, OutputFlags.NoCallingConvention);
}
else
{
Pointee.OutputPre(os, flags);
}
OutputSpaceIfNecessary(os);
if (Quals.HasFlag(Qualifiers.Unaligned))
{
os.Append("__unaligned ");
}
if (Pointee.Kind == NodeKind.ArrayType)
{
os.Append('(');
}
else if (Pointee.Kind == NodeKind.FunctionSignature)
{
os.Append('(');
FunctionSignatureNode sig = (FunctionSignatureNode)Pointee;
OutputCallingConvention(os, sig.CallConvention);
os.Append(' ');
}
if (ClassParent != null)
{
ClassParent.Output(os, flags);
os.Append("::");
}
switch (Affinity)
{
case PointerAffinity.Pointer:
os.Append('*');
break;
case PointerAffinity.Reference:
os.Append('&');
break;
case PointerAffinity.RValueReference:
os.Append("&&");
break;
default:
Assert.True(false);
break;
}
OutputQualifiers(os, Quals, false, false);
}
public override void Output(OutputStream os, OutputFlags flags)
{
os.Append("`RTTI Base Class Descriptor at (");
os.Append(NVOffset);
os.Append(", ");
os.Append(VBPtrOffset);
os.Append(", ");
os.Append(VBTableOffset);
os.Append(", ");
os.Append(Flags);
os.Append(")'");
}
public override void Output(OutputStream os, OutputFlags flags)
{
switch (Char)
{
case CharKind.Wchar:
os.Append("L\"");
break;
case CharKind.Char:
os.Append("\"");
break;
case CharKind.Char16:
os.Append("u\"");
break;
case CharKind.Char32:
os.Append("U\"");
break;
}
os.Append(DecodedString);
os.Append("\"");
if (IsTruncated)
{
os.Append("...");
}
}
public override void OutputPost(OutputStream os, OutputFlags flags)
{
if (Pointee.Kind == NodeKind.ArrayType || Pointee.Kind == NodeKind.FunctionSignature)
{
os.Append(')');
}
Pointee.OutputPost(os, flags);
}
public override void Output(OutputStream os, OutputFlags flags)
{
if (IsDestructor)
{
os.Append('~');
}
Class.Output(os, flags);
OutputTemplateParameters(os, flags);
}
public override void OutputPost(OutputStream os, OutputFlags flags)
{
if (!FunctionClass.HasFlag(FuncClass.NoParameterList))
{
os.Append('(');
if (Params != null)
{
Params.Output(os, flags);
}
else
{
os.Append("void");
}
os.Append(')');
}
if (Quals.HasFlag(Qualifiers.Const))
{
os.Append(" const");
}
if (Quals.HasFlag(Qualifiers.Volatile))
{
os.Append(" volatile");
}
if (Quals.HasFlag(Qualifiers.Restrict))
{
os.Append(" __restrict");
}
if (Quals.HasFlag(Qualifiers.Unaligned))
{
os.Append(" __unaligned");
}
if (RefQualifier == FunctionRefQualifier.Reference)
{
os.Append(" &");
}
else if (RefQualifier == FunctionRefQualifier.RValueReference)
{
os.Append(" &&");
}
if (ReturnType != null)
{
ReturnType.OutputPost(os, flags);
}
}
public void OutputCallingConvention(OutputStream os, CallingConv cc)
{
OutputSpaceIfNecessary(os);
switch (cc)
{
case CallingConv.Cdecl:
os.Append("__cdecl");
break;
case CallingConv.Fastcall:
os.Append("__fastcall");
break;
case CallingConv.Pascal:
os.Append("__pascal");
break;
case CallingConv.Regcall:
os.Append("__regcall");
break;
case CallingConv.Stdcall:
os.Append("__stdcall");
break;
case CallingConv.Thiscall:
os.Append("__thiscall");
break;
case CallingConv.Eabi:
os.Append("__eabi");
break;
case CallingConv.Vectorcall:
os.Append("__vectorcall");
break;
case CallingConv.Clrcall:
os.Append("__clrcall");
break;
default:
break;
}
}
public bool OutputSingleQualifier(OutputStream os, Qualifiers Q)
{
switch (Q)
{
case Qualifiers.Const:
os.Append("const");
return(true);
case Qualifiers.Volatile:
os.Append("volatile");
return(true);
case Qualifiers.Restrict:
os.Append("__restrict");
return(true);
default:
break;
}
return(false);
}
public void OutputSpaceIfNecessary(OutputStream os)
{
if (os.Length == 0)
{
return;
}
char c = os[os.Length - 1];
if (char.IsLetterOrDigit(c) || c == '>')
{
os.Append(' ');
}
}
void OutputDimensionsImpl(OutputStream os, OutputFlags flags)
{
if (Dimensions.Count() == 0)
{
return;
}
OutputOneDimension(os, flags, Dimensions[0]);
for (int i = 1; i < Dimensions.Count(); i++)
{
os.Append("][");
OutputOneDimension(os, flags, Dimensions[i]);
}
}
public bool OutputQualifierIfPresent(OutputStream os, Qualifiers Q, Qualifiers Mask, bool needSpace)
{
if (!(Q.HasFlag(Mask)))
{
return(needSpace);
}
if (needSpace)
{
os.Append(' ');
}
OutputSingleQualifier(os, Mask);
return(true);
}
public void OutputQualifiers(OutputStream os, Qualifiers Q, bool spaceBefore, bool spaceAfter)
{
if (Q == Qualifiers.None)
{
return;
}
int pos1 = os.Length;
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Const, spaceBefore);
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Volatile, spaceBefore);
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Restrict, spaceBefore);
int pos2 = os.Length;
if (spaceAfter && pos2 > pos1)
{
os.Append(' ');
}
}
public override void OutputPre(OutputStream os, OutputFlags flags)
{
if (FunctionClass.HasFlag(FuncClass.Public))
{
os.Append("public: ");
}
if (FunctionClass.HasFlag(FuncClass.Protected))
{
os.Append("protected: ");
}
if (FunctionClass.HasFlag(FuncClass.Private))
{
os.Append("private: ");
}
if (!(FunctionClass.HasFlag(FuncClass.Global)))
{
if (FunctionClass.HasFlag(FuncClass.Static))
{
os.Append("static ");
}
}
if (FunctionClass.HasFlag(FuncClass.Virtual))
{
os.Append("virtual ");
}
if (FunctionClass.HasFlag(FuncClass.ExternC))
{
os.Append("extern \"C\" ");
}
if (ReturnType != null)
{
ReturnType.Output(os, flags);
os.Append(' ');
}
if (!(flags.HasFlag(OutputFlags.NoCallingConvention)))
{
OutputCallingConvention(os, CallConvention);
}
}
public void PrintWithComma(OutputStream sb)
{
bool firstElement = true;
for (int i = 0; i < Elements.Length; i++)
{
int beforeComma = sb.Length;
if (!firstElement)
{
sb.Append(", ");
}
int afterComma = sb.Length;
Elements[i].Print(sb);
if (afterComma == sb.Length)
{
sb.Length -= (afterComma - beforeComma);
continue;
}
firstElement = false;
}
}
public override void Output(OutputStream os, OutputFlags flags)
{
if (ThunkOffsetCount > 0)
{
os.Append('{');
}
else if (Affinity == PointerAffinity.Pointer)
{
os.Append('&');
}
if (Symbol != null)
{
Symbol.Output(os, flags);
if (ThunkOffsetCount > 0)
{
os.Append(", ");
}
}
if (ThunkOffsetCount > 0)
{
os.Append(ThunkOffsets[0]);
}
for (int i = 1; i < ThunkOffsetCount; i++)
{
os.Append(", ");
os.Append(ThunkOffsets[i]);
}
if (ThunkOffsetCount > 0)
{
os.Append('}');
}
}
public override void Output(OutputStream os, OutputFlags flags)
{
if (IsDestructor)
{
os.Append("`dynamic atexit destructor for ");
}
else
{
os.Append("`dynamic initializer for ");
}
if (Variable != null)
{
os.Append('`');
Variable.Output(os, flags);
os.Append("''");
}
else
{
os.Append("'");
Name.Output(os, flags);
os.Append("''");
}
}
public override void Output(OutputStream os, OutputFlags flags)
{
os.Append("`vcall'{");
os.Append(OffsetInVtable);
os.Append(", {flat}}");
}
public override void Output(OutputStream os, OutputFlags flags)
{
os.Append(Name);
OutputTemplateParameters(os, flags);
}
public override void Output(OutputStream os, OutputFlags flags)
{
switch (Operator)
{
case IntrinsicFunctionKind.New:
os.Append("operator new");
break;
case IntrinsicFunctionKind.Delete:
os.Append("operator delete");
break;
case IntrinsicFunctionKind.Assign:
os.Append("operator=");
break;
case IntrinsicFunctionKind.RightShift:
os.Append("operator>>");
break;
case IntrinsicFunctionKind.LeftShift:
os.Append("operator<<");
break;
case IntrinsicFunctionKind.LogicalNot:
os.Append("operator!");
break;
case IntrinsicFunctionKind.Equals:
os.Append("operator==");
break;
case IntrinsicFunctionKind.NotEquals:
os.Append("operator!=");
break;
case IntrinsicFunctionKind.ArraySubscript:
os.Append("operator[]");
break;
case IntrinsicFunctionKind.Pointer:
os.Append("operator->");
break;
case IntrinsicFunctionKind.Increment:
os.Append("operator++");
break;
case IntrinsicFunctionKind.Decrement:
os.Append("operator--");
break;
case IntrinsicFunctionKind.Minus:
os.Append("operator-");
break;
case IntrinsicFunctionKind.Plus:
os.Append("operator+");
break;
case IntrinsicFunctionKind.Dereference:
os.Append("operator*");
break;
case IntrinsicFunctionKind.BitwiseAnd:
os.Append("operator&");
break;
case IntrinsicFunctionKind.MemberPointer:
os.Append("operator->*");
break;
case IntrinsicFunctionKind.Divide:
os.Append("operator/");
break;
case IntrinsicFunctionKind.Modulus:
os.Append("operator%");
break;
case IntrinsicFunctionKind.LessThan:
os.Append("operator<");
break;
case IntrinsicFunctionKind.LessThanEqual:
os.Append("operator<=");
break;
case IntrinsicFunctionKind.GreaterThan:
os.Append("operator>");
break;
case IntrinsicFunctionKind.GreaterThanEqual:
os.Append("operator>=");
break;
case IntrinsicFunctionKind.Comma:
os.Append("operator,");
break;
case IntrinsicFunctionKind.Parens:
os.Append("operator()");
break;
case IntrinsicFunctionKind.BitwiseNot:
os.Append("operator~");
break;
case IntrinsicFunctionKind.BitwiseXor:
os.Append("operator^");
break;
case IntrinsicFunctionKind.BitwiseOr:
os.Append("operator|");
break;
case IntrinsicFunctionKind.LogicalAnd:
os.Append("operator&&");
break;
case IntrinsicFunctionKind.LogicalOr:
os.Append("operator||");
break;
case IntrinsicFunctionKind.TimesEqual:
os.Append("operator*=");
break;
case IntrinsicFunctionKind.PlusEqual:
os.Append("operator+=");
break;
case IntrinsicFunctionKind.MinusEqual:
os.Append("operator-=");
break;
case IntrinsicFunctionKind.DivEqual:
os.Append("operator/=");
break;
case IntrinsicFunctionKind.ModEqual:
os.Append("operator%=");
break;
case IntrinsicFunctionKind.RshEqual:
os.Append("operator>>=");
break;
case IntrinsicFunctionKind.LshEqual:
os.Append("operator<<=");
break;
case IntrinsicFunctionKind.BitwiseAndEqual:
os.Append("operator&=");
break;
case IntrinsicFunctionKind.BitwiseOrEqual:
os.Append("operator|=");
break;
case IntrinsicFunctionKind.BitwiseXorEqual:
os.Append("operator^=");
break;
case IntrinsicFunctionKind.VbaseDtor:
os.Append("`vbase dtor'");
break;
case IntrinsicFunctionKind.VecDelDtor:
os.Append("`vector deleting dtor'");
break;
case IntrinsicFunctionKind.DefaultCtorClosure:
os.Append("`default ctor closure'");
break;
case IntrinsicFunctionKind.ScalarDelDtor:
os.Append("`scalar deleting dtor'");
break;
case IntrinsicFunctionKind.VecCtorIter:
os.Append("`vector ctor iterator'");
break;
case IntrinsicFunctionKind.VecDtorIter:
os.Append("`vector dtor iterator'");
break;
case IntrinsicFunctionKind.VecVbaseCtorIter:
os.Append("`vector vbase ctor iterator'");
break;
case IntrinsicFunctionKind.VdispMap:
os.Append("`virtual displacement map'");
break;
case IntrinsicFunctionKind.EHVecCtorIter:
os.Append("`eh vector ctor iterator'");
break;
case IntrinsicFunctionKind.EHVecDtorIter:
os.Append("`eh vector dtor iterator'");
break;
case IntrinsicFunctionKind.EHVecVbaseCtorIter:
os.Append("`eh vector vbase ctor iterator'");
break;
case IntrinsicFunctionKind.CopyCtorClosure:
os.Append("`copy ctor closure'");
break;
case IntrinsicFunctionKind.LocalVftableCtorClosure:
os.Append("`local vftable ctor closure'");
break;
case IntrinsicFunctionKind.ArrayNew:
os.Append("operator new[]");
break;
case IntrinsicFunctionKind.ArrayDelete:
os.Append("operator delete[]");
break;
case IntrinsicFunctionKind.ManVectorCtorIter:
os.Append("`managed vector ctor iterator'");
break;
case IntrinsicFunctionKind.ManVectorDtorIter:
os.Append("`managed vector dtor iterator'");
break;
case IntrinsicFunctionKind.EHVectorCopyCtorIter:
os.Append("`EH vector copy ctor iterator'");
break;
case IntrinsicFunctionKind.EHVectorVbaseCopyCtorIter:
os.Append("`EH vector vbase copy ctor iterator'");
break;
case IntrinsicFunctionKind.VectorCopyCtorIter:
os.Append("`vector copy ctor iterator'");
break;
case IntrinsicFunctionKind.VectorVbaseCopyCtorIter:
os.Append("`vector vbase copy constructor iterator'");
break;
case IntrinsicFunctionKind.ManVectorVbaseCopyCtorIter:
os.Append("`managed vector vbase copy constructor iterator'");
break;
case IntrinsicFunctionKind.CoAwait:
os.Append("co_await");
break;
case IntrinsicFunctionKind.Spaceship:
os.Append("operator <=>");
break;
case IntrinsicFunctionKind.MaxIntrinsic:
case IntrinsicFunctionKind.None:
break;
}
OutputTemplateParameters(os, flags);
}
public override void OutputPost(OutputStream os, OutputFlags flags) {
if (FunctionClass.HasFlag(FuncClass.StaticThisAdjust)) {
os.Append("`adjustor{");
os.Append(ThisAdjust.StaticOffset);
os.Append("}'");
} else if (FunctionClass.HasFlag(FuncClass.VirtualThisAdjust)) {
if (FunctionClass.HasFlag(FuncClass.VirtualThisAdjustEx)) {
os.Append("`vtordispex{");
os.Append(ThisAdjust.VBPtrOffset);
os.Append(", ");
os.Append(ThisAdjust.VBOffsetOffset);
os.Append(", ");
os.Append(ThisAdjust.VtordispOffset);
os.Append(", ");
os.Append(ThisAdjust.StaticOffset);
os.Append("}'");
} else {
os.Append("`vtordisp{");
os.Append(ThisAdjust.VtordispOffset);
os.Append(", ");
os.Append(ThisAdjust.StaticOffset);
os.Append("}'");
}
}
base.OutputPost(os, flags);
}
public override void OutputPre(OutputStream os, OutputFlags flags) {
os.Append("[thunk]: ");
base.OutputPre(os, flags);
}
