ImageSource GetMemberOverlayedImage(AttributedNode attrNode, MemberIcon icon)
{
switch (attrNode.Modifiers & Modifiers.VisibilityMask) {
case Modifiers.Protected:
return Images.GetIcon(icon, AccessOverlayIcon.Protected, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static);
case Modifiers.Private:
return Images.GetIcon(icon, AccessOverlayIcon.Private, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static);
case Modifiers.Internal:
return Images.GetIcon(icon, AccessOverlayIcon.Internal, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static);
}
return Images.GetIcon(icon, AccessOverlayIcon.Public, (attrNode.Modifiers & Modifiers.Static) == Modifiers.Static);
}
bool CheckAttributedNode(ICS.AttributedNode node, ICS.Modifiers defaultVisibility)
{
if (!CheckModifiers(node.Modifiers, defaultVisibility))
{
return(false);
}
if (!string.IsNullOrEmpty(AppliedAttributeType) && node != null)
{
node.Attributes.Any(section => section.Attributes.Any(a => {
var st = a.Type as ICS.SimpleType;
return(st != null && st.Identifier == AppliedAttributeType);
}));
}
return(true);
}
protected bool MatchAttributesAndModifiers (AttributedNode o, PatternMatching.Match match)
{
return (this.Modifiers == Modifiers.Any || this.Modifiers == o.Modifiers) && this.Attributes.DoMatch (o.Attributes, match);
}
protected bool MatchAttributesAndModifiers(AttributedNode o, PatternMatching.Match match)
{
return((this.Modifiers == Modifiers.Any || this.Modifiers == o.Modifiers) && this.Attributes.DoMatch(o.Attributes, match));
}
void AddModifiers (AttributedNode parent, LocationsBag.MemberLocations location)
{
if (location == null || location.Modifiers == null)
return;
foreach (var modifier in location.Modifiers) {
ICSharpCode.NRefactory.CSharp.Modifiers mod;
if (!modifierTable.TryGetValue (modifier.Item1, out mod)) {
Console.WriteLine ("modifier "+ modifier.Item1 + " can't be converted,");
}
parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), mod), AttributedNode.ModifierRole);
}
}
void AddType (AttributedNode child)
{
if (typeStack.Count > 0) {
typeStack.Peek ().AddChild (child, TypeDeclaration.MemberRole);
} else {
AddToNamespace (child);
}
}
void AddModifiers (AttributedNode parent, LocationsBag.MemberLocations location)
{
if (location == null || location.Modifiers == null)
return;
foreach (var modifier in location.Modifiers) {
parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), modifierTable[modifier.Item1]), AttributedNode.ModifierRole);
}
}
ImageSource GetTypeOverlayedImage(AttributedNode attrNode, TypeIcon icon)
{
switch (attrNode.Modifiers & Modifiers.VisibilityMask) {
case Modifiers.Protected:
return Images.GetIcon(icon, AccessOverlayIcon.Protected);
case Modifiers.Private:
return Images.GetIcon(icon, AccessOverlayIcon.Private);
case Modifiers.Internal:
return Images.GetIcon(icon, AccessOverlayIcon.Internal);
}
return Images.GetIcon(icon, AccessOverlayIcon.Public);
}
void ConvertMember(IMember member, StringWriter writer)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
astBuilder.ShowParameterNames = (ConversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
AttributedNode node = (AttributedNode)astBuilder.ConvertEntity(member);
PrintModifiers(node.Modifiers, writer);
if ((ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
{
var rt = node.GetChildByRole(AstNode.Roles.Type);
if (rt != AstNode.Roles.Type.NullObject)
{
writer.Write(rt.AcceptVisitor(CreatePrinter(writer), null));
writer.Write(' ');
}
}
WriteMemberDeclarationName(member, writer);
if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList &&
member is IParameterizedMember && member.EntityType != EntityType.Property)
{
writer.Write((node is IndexerDeclaration) ? '[' : '(');
bool first = true;
foreach (var param in node.GetChildrenByRole(AstNode.Roles.Parameter))
{
if (first)
{
first = false;
}
else
{
writer.Write(", ");
}
param.AcceptVisitor(CreatePrinter(writer), null);
}
writer.Write((node is IndexerDeclaration) ? ']' : ')');
}
if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody)
{
IProperty property = member as IProperty;
if (property != null)
{
writer.Write(" { ");
if (property.CanGet)
{
writer.Write("get; ");
}
if (property.CanSet)
{
writer.Write("set; ");
}
writer.Write('}');
}
else
{
writer.Write(';');
}
}
}
internal static void ConvertAttributes(AttributedNode attributedNode, FieldDefinition fieldDefinition, AttributeTarget target = AttributeTarget.None)
{
ConvertCustomAttributes(attributedNode, fieldDefinition);
#region FieldOffsetAttribute
if (fieldDefinition.HasLayoutInfo) {
Ast.Attribute fieldOffset = CreateNonCustomAttribute(typeof(FieldOffsetAttribute), fieldDefinition.Module);
fieldOffset.Arguments.Add(new PrimitiveExpression(fieldDefinition.Offset));
attributedNode.Attributes.Add(new AttributeSection(fieldOffset) { AttributeTarget = target });
}
#endregion
#region NonSerializedAttribute
if (fieldDefinition.IsNotSerialized) {
Ast.Attribute nonSerialized = CreateNonCustomAttribute(typeof(NonSerializedAttribute), fieldDefinition.Module);
attributedNode.Attributes.Add(new AttributeSection(nonSerialized) { AttributeTarget = target });
}
#endregion
if (fieldDefinition.HasMarshalInfo) {
attributedNode.Attributes.Add(new AttributeSection(ConvertMarshalInfo(fieldDefinition, fieldDefinition.Module)) { AttributeTarget = target });
}
}
void ConvertAttributes(AttributedNode attributedNode, MethodDefinition methodDefinition)
{
ConvertCustomAttributes(attributedNode, methodDefinition);
MethodImplAttributes implAttributes = methodDefinition.ImplAttributes & ~MethodImplAttributes.CodeTypeMask;
#region DllImportAttribute
if (methodDefinition.HasPInvokeInfo) {
PInvokeInfo info = methodDefinition.PInvokeInfo;
Ast.Attribute dllImport = CreateNonCustomAttribute(typeof(DllImportAttribute));
dllImport.Arguments.Add(new PrimitiveExpression(info.Module.Name));
if (info.IsBestFitDisabled)
dllImport.AddNamedArgument("BestFitMapping", new PrimitiveExpression(false));
if (info.IsBestFitEnabled)
dllImport.AddNamedArgument("BestFitMapping", new PrimitiveExpression(true));
CallingConvention callingConvention;
switch (info.Attributes & PInvokeAttributes.CallConvMask) {
case PInvokeAttributes.CallConvCdecl:
callingConvention = CallingConvention.Cdecl;
break;
case PInvokeAttributes.CallConvFastcall:
callingConvention = CallingConvention.FastCall;
break;
case PInvokeAttributes.CallConvStdCall:
callingConvention = CallingConvention.StdCall;
break;
case PInvokeAttributes.CallConvThiscall:
callingConvention = CallingConvention.ThisCall;
break;
case PInvokeAttributes.CallConvWinapi:
callingConvention = CallingConvention.Winapi;
break;
default:
throw new NotSupportedException("unknown calling convention");
}
if (callingConvention != CallingConvention.Winapi)
dllImport.AddNamedArgument("CallingConvention", new IdentifierExpression("CallingConvention").Member(callingConvention.ToString()));
CharSet charSet = CharSet.None;
switch (info.Attributes & PInvokeAttributes.CharSetMask) {
case PInvokeAttributes.CharSetAnsi:
charSet = CharSet.Ansi;
break;
case PInvokeAttributes.CharSetAuto:
charSet = CharSet.Auto;
break;
case PInvokeAttributes.CharSetUnicode:
charSet = CharSet.Unicode;
break;
}
if (charSet != CharSet.None)
dllImport.AddNamedArgument("CharSet", new IdentifierExpression("CharSet").Member(charSet.ToString()));
if (!string.IsNullOrEmpty(info.EntryPoint) && info.EntryPoint != methodDefinition.Name)
dllImport.AddNamedArgument("EntryPoint", new PrimitiveExpression(info.EntryPoint));
if (info.IsNoMangle)
dllImport.AddNamedArgument("ExactSpelling", new PrimitiveExpression(true));
if ((implAttributes & MethodImplAttributes.PreserveSig) == MethodImplAttributes.PreserveSig)
implAttributes &= ~MethodImplAttributes.PreserveSig;
else
dllImport.AddNamedArgument("PreserveSig", new PrimitiveExpression(false));
if (info.SupportsLastError)
dllImport.AddNamedArgument("SetLastError", new PrimitiveExpression(true));
if (info.IsThrowOnUnmappableCharDisabled)
dllImport.AddNamedArgument("ThrowOnUnmappableChar", new PrimitiveExpression(false));
if (info.IsThrowOnUnmappableCharEnabled)
dllImport.AddNamedArgument("ThrowOnUnmappableChar", new PrimitiveExpression(true));
attributedNode.Attributes.Add(new AttributeSection(dllImport));
}
#endregion
#region PreserveSigAttribute
if (implAttributes == MethodImplAttributes.PreserveSig) {
attributedNode.Attributes.Add(new AttributeSection(CreateNonCustomAttribute(typeof(PreserveSigAttribute))));
implAttributes = 0;
}
#endregion
#region MethodImplAttribute
if (implAttributes != 0) {
Ast.Attribute methodImpl = CreateNonCustomAttribute(typeof(MethodImplAttribute));
TypeReference methodImplOptions = new TypeReference(
"System.Runtime.CompilerServices", "MethodImplOptions",
methodDefinition.Module, methodDefinition.Module.TypeSystem.Corlib);
methodImpl.Arguments.Add(MakePrimitive((long)implAttributes, methodImplOptions));
attributedNode.Attributes.Add(new AttributeSection(methodImpl));
}
#endregion
ConvertCustomAttributes(attributedNode, methodDefinition.MethodReturnType, AttributeTarget.Return);
if (methodDefinition.MethodReturnType.HasMarshalInfo) {
var marshalInfo = ConvertMarshalInfo(methodDefinition.MethodReturnType, methodDefinition.Module);
attributedNode.Attributes.Add(new AttributeSection(marshalInfo) { AttributeTarget = AttributeTarget.Return });
}
}
void ConvertAttributes(AttributedNode attributedNode, TypeDefinition typeDefinition)
{
ConvertCustomAttributes(attributedNode, typeDefinition);
// Handle the non-custom attributes:
#region SerializableAttribute
if (typeDefinition.IsSerializable)
attributedNode.Attributes.Add(new AttributeSection(CreateNonCustomAttribute(typeof(SerializableAttribute))));
#endregion
#region StructLayoutAttribute
LayoutKind layoutKind = LayoutKind.Auto;
switch (typeDefinition.Attributes & TypeAttributes.LayoutMask) {
case TypeAttributes.SequentialLayout:
layoutKind = LayoutKind.Sequential;
break;
case TypeAttributes.ExplicitLayout:
layoutKind = LayoutKind.Explicit;
break;
}
CharSet charSet = CharSet.None;
switch (typeDefinition.Attributes & TypeAttributes.StringFormatMask) {
case TypeAttributes.AnsiClass:
charSet = CharSet.Ansi;
break;
case TypeAttributes.AutoClass:
charSet = CharSet.Auto;
break;
case TypeAttributes.UnicodeClass:
charSet = CharSet.Unicode;
break;
}
LayoutKind defaultLayoutKind = (typeDefinition.IsValueType && !typeDefinition.IsEnum) ? LayoutKind.Sequential: LayoutKind.Auto;
if (layoutKind != defaultLayoutKind || charSet != CharSet.Ansi || typeDefinition.PackingSize > 0 || typeDefinition.ClassSize > 0) {
var structLayout = CreateNonCustomAttribute(typeof(StructLayoutAttribute));
structLayout.Arguments.Add(new IdentifierExpression("LayoutKind").Member(layoutKind.ToString()));
if (charSet != CharSet.Ansi) {
structLayout.AddNamedArgument("CharSet", new IdentifierExpression("CharSet").Member(charSet.ToString()));
}
if (typeDefinition.PackingSize > 0) {
structLayout.AddNamedArgument("Pack", new PrimitiveExpression((int)typeDefinition.PackingSize));
}
if (typeDefinition.ClassSize > 0) {
structLayout.AddNamedArgument("Size", new PrimitiveExpression((int)typeDefinition.ClassSize));
}
attributedNode.Attributes.Add(new AttributeSection(structLayout));
}
#endregion
}
public void AddAttributeSection (AttributedNode parent, Attributable a)
{
if (a.OptAttributes != null && a.OptAttributes.Attrs != null)
parent.AddChild (ConvertAttributeSection (a.OptAttributes), AttributedNode.AttributeRole);
}
void ConvertAttributes(AttributedNode attributedNode, FieldDefinition fieldDefinition)
{
ConvertCustomAttributes(attributedNode, fieldDefinition);
#region FieldOffsetAttribute
if (fieldDefinition.HasLayoutInfo) {
Ast.Attribute fieldOffset = CreateNonCustomAttribute(typeof(FieldOffsetAttribute));
fieldOffset.Arguments.Add(new PrimitiveExpression(fieldDefinition.Offset));
attributedNode.Attributes.Add(new AttributeSection(fieldOffset));
}
#endregion
if (fieldDefinition.HasMarshalInfo) {
attributedNode.Attributes.Add(new AttributeSection(ConvertMarshalInfo(fieldDefinition, fieldDefinition.Module)));
}
}
void ConvertAttributes(AttributedNode attributedNode, MethodReturnType methodReturnType, ModuleDefinition module)
{
ConvertCustomAttributes(attributedNode, methodReturnType, "return");
if (methodReturnType.HasMarshalInfo) {
var marshalInfo = ConvertMarshalInfo(methodReturnType, module);
attributedNode.Attributes.Add(new AttributeSection(marshalInfo) { AttributeTarget = "return" });
}
}
