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);
}
}
/// <summary>
/// Output handler.
/// </summary>
/// <param name="when">When the output occurred.</param>
/// <param name="flags">The output flags.</param>
/// <param name="text">The output text.</param>
public void Output(DateTime when, OutputFlags flags, string text)
{
for (int i = 0; i < text.Length; ++i)
{
if (text[i] == '\r' || text[i] == '\n')
{
if (i + 1 < text.Length && text[i + 1] == '\n')
{
++i;
}
_start = true;
if (_written == 0)
{
AppendTimestamp(when);
}
_sw.WriteLine();
_written = 0;
}
else
{
if (_start)
{
_start = false;
AppendTimestamp(when);
}
_sw.Write(text[i]);
++_written;
}
}
_sw.Flush();
}
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 (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)
{
os.Append('[');
OutputDimensionsImpl(os, flags);
os.Append(']');
ElementType.OutputPost(os, flags);
}
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 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);
}
private void AssertOutput(Action f, string expectedOutput, OutputFlags flags)
{
var error = CompareOutput(f, expectedOutput, flags);
if (error != null)
{
Assert(false, error);
}
}
public void OutputTest(
[PexAssumeUnderTest] StreamOutputListener target,
DateTime when,
OutputFlags flags,
string text
)
{
target.Output(when, flags, text);
// TODO: add assertions to method StreamOutputListenerTest.OutputTest(StreamOutputListener, DateTime, OutputFlags, String)
}
void OutputOneDimension(OutputStream os, OutputFlags flags, Node n)
{
Assert.True(n.Kind == NodeKind.IntegerLiteral);
IntegerLiteralNode iln = (IntegerLiteralNode)n;
if (iln.Value != 0)
{
iln.Output(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 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 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 MemberCompletionData(INode member, OutputFlags flags)
{
this.flags = flags;
SetMember(member);
DisplayFlags = DisplayFlags.DescriptionHasMarkup;
IMember m = Member as IMember;
if (m != null && m.IsObsolete)
{
DisplayFlags |= DisplayFlags.Obsolete;
}
}
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 override void OutputPre(OutputStream os, OutputFlags flags)
{
switch (PrimKind)
{
case PrimitiveKind.Void: os.Append("void"); break;
case PrimitiveKind.Bool: os.Append("bool"); break;
case PrimitiveKind.Char: os.Append("char"); break;
case PrimitiveKind.Schar: os.Append("signed char"); break;
case PrimitiveKind.Uchar: os.Append("unsigned char"); break;
case PrimitiveKind.Char16: os.Append("char16_t"); break;
case PrimitiveKind.Char32: os.Append("char32_t"); break;
case PrimitiveKind.Short: os.Append("short"); break;
case PrimitiveKind.Ushort: os.Append("unsigned short"); break;
case PrimitiveKind.Int: os.Append("int"); break;
case PrimitiveKind.Uint: os.Append("unsigned int"); break;
case PrimitiveKind.Long: os.Append("long"); break;
case PrimitiveKind.Ulong: os.Append("unsigned long"); break;
case PrimitiveKind.Int64: os.Append("__int64"); break;
case PrimitiveKind.Uint64: os.Append("unsigned __int64"); break;
case PrimitiveKind.Wchar: os.Append("wchar_t"); break;
case PrimitiveKind.Float: os.Append("float"); break;
case PrimitiveKind.Double: os.Append("double"); break;
case PrimitiveKind.Ldouble: os.Append("long double"); break;
case PrimitiveKind.Nullptr: os.Append("std::nullptr_t"); break;
}
OutputQualifiers(os, Quals, true, 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 CompletionData Add (object obj, OutputFlags additionalFlags)
{
Namespace ns = obj as Namespace;
if (ns != null) {
if (!data.ContainsKey (ns.Name))
data.Add (ns.Name, null);
if (namespacesInList.Contains (ns.Name)) {
return null;
}
namespacesInList.Add (ns.Name);
return CompletionList.Add (ns.Name, ns.StockIcon, ns.Documentation);
}
IReturnType rt = obj as IReturnType;
if (rt != null) {
OutputFlags flags = OutputFlags.ClassBrowserEntries | OutputFlags.HideArrayBrackets;
bool foundNamespace = IsNamespaceInScope (rt.Namespace);
if (FullyQualify || !foundNamespace && (NamePrefix.Length == 0 || !rt.Namespace.StartsWith (NamePrefix)) && !rt.Namespace.EndsWith ("." + NamePrefix))
flags |= OutputFlags.UseFullName;
IType resolvedType = dom.GetType (rt);
if (inheritanceTree == null && declaringType != null)
inheritanceTree = new List<IType>(dom.GetInheritanceTree (declaringType));
if (resolvedType != null && resolvedType.DeclaringType != null && inheritanceTree != null && inheritanceTree.Any (t => resolvedType.DeclaringType.DecoratedFullName == t.DecoratedFullName)) {
return CompletionList.Add (rt.Name, "md-class");
}
string returnTypeString = ambience.GetString (rt, flags);
if (!data.ContainsKey (returnTypeString))
data.Add (returnTypeString, null);
return CompletionList.Add (returnTypeString, "md-class");
}
IMember member = obj as IMember;
if (member != null && !String.IsNullOrEmpty (member.Name)) {
OutputFlags flags = OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | additionalFlags;
return AddMemberCompletionData (member, flags);
}
if (obj is IParameter || obj is LocalVariable)
AddMemberCompletionData (obj, OutputFlags.IncludeParameterName);
if (obj is string) {
string str = (string)obj;
if (!data.ContainsKey (str))
data.Add (str, null);
return CompletionList.Add (str, "md-literal");
}
return null;
}
MemberCompletionData AddMemberCompletionData (object member, OutputFlags flags)
{
MemberCompletionData newData = new MemberCompletionData (member as INode, flags);
newData.HideExtensionParameter = HideExtensionParameter;
string memberKey = newData.CompletionText;
if (member is IMember) {
newData.CompletionCategory = GetCompletionCategory (((IMember)member).DeclaringType);
}
List<MemberCompletionData> existingData;
data.TryGetValue (memberKey, out existingData);
if (existingData != null) {
IBaseMember a = member as IBaseMember;
foreach (MemberCompletionData md in existingData) {
IBaseMember b = md.Member as IBaseMember;
if (a == null || b == null || a.MemberType == b.MemberType) {
md.AddOverload (newData);
newData = null;
break;
}
}
if (newData != null) {
CompletionList.Add (newData);
data[memberKey].Add (newData);
}
} else {
CompletionList.Add (newData);
data[memberKey] = new List<MemberCompletionData> ();
data[memberKey].Add (newData);
}
return newData;
}
public OutputSettings(OutputFlags outputFlags)
{
this.OutputFlags = outputFlags;
}
public string GetString (string nameSpace, OutputFlags flags)
{
return GetString (nameSpace, new OutputSettings (flags));
}
public string GetString (IParameterizedMember member, IParameter parameter, OutputFlags flags)
{
return GetParameterString (member, parameter, new OutputSettings (flags));
}
public string GetString (ITypeDefinition type, OutputFlags flags)
{
return GetString ((IEntity)type, new OutputSettings (flags));
}
public string GetString (IType type, OutputFlags flags)
{
return GetString (type, new OutputSettings (flags));
}
/* public string GetString (ITypeReference reference, OutputSettings settings)
{
var result = GetTypeReferenceString (reference, settings);
return settings.PostProcess (reference, result);
}*/
public string GetString (IEntity entity, OutputFlags flags)
{
return GetString (entity, new OutputSettings (flags));
}
public string GetString (INode domVisitable, OutputFlags flags)
{
return GetString (domVisitable, new OutputSettings (flags));
}
MemberCompletionData AddMemberCompletionData(object member, OutputFlags flags)
{
MemberCompletionData newData = new MemberCompletionData (member as INode, flags);
newData.HideExtensionParameter = HideExtensionParameter;
string memberKey = newData.CompletionText;
MemberCompletionData existingData;
if (data.TryGetValue (memberKey, out existingData)) {
if (existingData == null)
return null;
existingData.AddOverload (newData);
} else {
CompletionList.Add (newData);
data [memberKey] = newData;
}
return newData;
}
