public void BaseTypes()
{
CodeTypeDelegate delegateType = new CodeTypeDelegate((string)null);
Assert.AreEqual(1, delegateType.BaseTypes.Count);
Assert.AreEqual("System.Delegate", delegateType.BaseTypes[0].BaseType);
}
static CodeTypeDeclaration CreateDelegateDeclaration(TypeDefinition publicType)
{
var invokeMethod = publicType.Methods.Single(m => m.Name == "Invoke");
var name = publicType.Name;
var index = name.IndexOf('`');
if (index != -1)
{
name = name.Substring(0, index);
}
var declaration = new CodeTypeDelegate(name)
{
Attributes = MemberAttributes.Public,
CustomAttributes = CreateCustomAttributes(publicType),
ReturnType = CreateCodeTypeReference(invokeMethod.ReturnType),
};
// CodeDOM. No support. Return type attributes.
PopulateCustomAttributes(invokeMethod.MethodReturnType, declaration.CustomAttributes, type => ModifyCodeTypeReference(type, "return:"));
PopulateGenericParameters(publicType, declaration.TypeParameters);
PopulateMethodParameters(invokeMethod, declaration.Parameters);
// Of course, CodeDOM doesn't support generic type parameters for delegates. Of course.
if (declaration.TypeParameters.Count > 0)
{
var parameterNames = from parameterType in declaration.TypeParameters.Cast <CodeTypeParameter>()
select parameterType.Name;
declaration.Name = string.Format(CultureInfo.InvariantCulture, "{0}<{1}>", declaration.Name, string.Join(", ", parameterNames));
}
return(declaration);
}
/// <summary>
/// Generate a delegate in code
/// </summary>
/// <param name="ntFuncPtr"></param>
/// <returns></returns>
/// <remarks></remarks>
public CodeTypeDelegate GenerateDelegate(NativeFunctionPointer ntFuncPtr)
{
if (ntFuncPtr == null)
{
throw new ArgumentNullException("ntFuncPtr");
}
string comment = "Return Type: ";
CodeTypeDelegate del = new CodeTypeDelegate();
del.Name = ntFuncPtr.Name;
del.Attributes = MemberAttributes.Public;
del.ReturnType = GenerateTypeReferenceImpl(ntFuncPtr.Signature.ReturnType, ref comment);
del.Parameters.AddRange(GenerateParameters(ntFuncPtr.Signature, ref comment));
// If there is a non-default calling convention we need to generate the attribute
if (ntFuncPtr.CallingConvention == NativeCallingConvention.CDeclaration || ntFuncPtr.CallingConvention == NativeCallingConvention.Standard)
{
del.CustomAttributes.Add(MarshalAttributeFactory.CreateUnmanagedFunctionPointerAttribute(ntFuncPtr.CallingConvention));
}
del.UserData[TransformConstants.DefinedType] = ntFuncPtr;
del.UserData[TransformConstants.ReturnType] = ntFuncPtr.Signature.ReturnType;
del.UserData[TransformConstants.ReturnTypeSal] = ntFuncPtr.Signature.ReturnTypeSalAttribute;
del.Comments.Add(new CodeCommentStatement(comment, true));
return(del);
}
public ChildVisitResult Visit(Cursor cursor, Cursor parent)
{
if (!cursor.GetLocation().IsFromMainFile())
{
return(ChildVisitResult.Continue);
}
CursorKind curKind = cursor.Kind;
if (curKind == CursorKind.TypedefDecl)
{
var nativeName = cursor.GetSpelling();
var clrName = NameConversions.ToClrName(nativeName, NameConversion.Type);
// if we've printed these previously, skip them
if (this.generator.NameMapping.ContainsKey(nativeName))
{
return(ChildVisitResult.Continue);
}
TypeInfo type = cursor.GetTypedefDeclUnderlyingType().GetCanonicalType();
// we handle enums and records in struct and enum visitors with forward declarations also
if (type.Kind == TypeKind.Record || type.Kind == TypeKind.Enum)
{
return(ChildVisitResult.Continue);
}
if (type.Kind == TypeKind.Pointer)
{
var pointee = type.GetPointeeType();
if (pointee.Kind == TypeKind.Record || pointee.Kind == TypeKind.Void)
{
var types = Handles.CreateSafeHandle(clrName, this.generator).ToArray();
this.generator.AddType(nativeName, types[0]);
for (int i = 1; i < types.Length; i++)
{
this.generator.AddType(types[i].Name, types[i]);
}
return(ChildVisitResult.Continue);
}
if (pointee.Kind == TypeKind.FunctionProto)
{
var functionType = cursor.GetTypedefDeclUnderlyingType();
var pt = functionType.GetPointeeType();
CodeTypeDelegate delegateType = pt.ToDelegate(nativeName, cursor, this.generator);
this.generator.AddType(nativeName, delegateType);
return(ChildVisitResult.Continue);
}
}
return(ChildVisitResult.Continue);
}
return(ChildVisitResult.Recurse);
}
/// <summary>
/// Run all of the marshaling hueristiscs on the type and it's members
/// </summary>
/// <param name="ctd"></param>
/// <remarks></remarks>
public void Process(CodeTypeDeclaration ctd)
{
// First check and see if it is a delegate type, if so run the delegate hueristics
CodeTypeDelegate ctdDel = ctd as CodeTypeDelegate;
if (ctdDel != null && ctdDel.UserData.Contains(TransformConstants.DefinedType))
{
ProcessDelegate(ctdDel);
return;
}
// Now run the hueristics over the actual members of the type
if (ctd.UserData.Contains(TransformConstants.DefinedType))
{
NativeDefinedType nt = ctd.UserData[TransformConstants.DefinedType] as NativeDefinedType;
if (nt != null)
{
switch (nt.Kind)
{
case NativeSymbolKind.StructType:
ProcessStruct(ctd);
break;
case NativeSymbolKind.UnionType:
RunPluginUnionMembers(ctd);
break;
case NativeSymbolKind.EnumType:
RunPluginEnumMembers(ctd);
break;
}
}
}
// Now process the methods on the type. First step is to convert all of them into
// best PInvoke signature. Then create wrapper methods for them
CodeTypeMemberCollection col = new CodeTypeMemberCollection(ctd.Members);
List <CodeMemberMethod> list = new List <CodeMemberMethod>();
foreach (CodeTypeMember mem in col)
{
// Look at procedures
CodeMemberMethod codeProc = mem as CodeMemberMethod;
if (codeProc != null && codeProc.UserData.Contains(TransformConstants.Procedure))
{
list.Add(codeProc);
}
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessParameters(codeProc);
ProcessReturnType(codeProc);
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessWrapperMethods(ctd, codeProc);
}
}
public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent)
{
if (!cursor.Location.IsFromMainFile)
{
return(CXChildVisitResult.CXChildVisit_Continue);
}
CXCursorKind curKind = cursor.Kind;
if (curKind == CXCursorKind.CXCursor_TypedefDecl)
{
var nativeName = cursor.Spelling.CString;
var clrName = NameConversions.ToClrName(nativeName, NameConversion.Type);
// if we've printed these previously, skip them
if (this.generator.NameMapping.ContainsKey(nativeName))
{
return(CXChildVisitResult.CXChildVisit_Continue);
}
CXType type = cursor.TypedefDeclUnderlyingType.CanonicalType;
// we handle enums and records in struct and enum visitors with forward declarations also
if (type.kind == CXTypeKind.CXType_Record || type.kind == CXTypeKind.CXType_Enum)
{
return(CXChildVisitResult.CXChildVisit_Continue);
}
if (type.kind == CXTypeKind.CXType_Pointer)
{
var pointee = type.PointeeType;
if (pointee.kind == CXTypeKind.CXType_Record || pointee.kind == CXTypeKind.CXType_Void)
{
var types = Handles.CreateSafeHandle(clrName, this.generator).ToArray();
this.generator.AddType(nativeName, types[0]);
for (int i = 1; i < types.Length; i++)
{
this.generator.AddType(types[i].Name, types[i]);
}
return(CXChildVisitResult.CXChildVisit_Continue);
}
if (pointee.kind == CXTypeKind.CXType_FunctionProto)
{
var functionType = cursor.TypedefDeclUnderlyingType;
var pt = functionType.PointeeType;
CodeTypeDelegate delegateType = pt.ToDelegate(nativeName, cursor, this.generator);
this.generator.AddType(nativeName, new CodeDomGeneratedType(delegateType));
return(CXChildVisitResult.CXChildVisit_Continue);
}
}
return(CXChildVisitResult.CXChildVisit_Continue);
}
return(CXChildVisitResult.CXChildVisit_Recurse);
}
private void IterateTypeDeclarationImpl(CodeTypeDeclaration ctd, List <object> list)
{
ThrowIfNull(ctd);
ThrowIfNull(list);
// Don't add to the list because this is added in the member iterater
foreach (CodeTypeReference ctdRef in ctd.BaseTypes)
{
IterateTypeRefImpl(ctdRef, list);
}
foreach (CodeTypeMember member in ctd.Members)
{
IterateTypeMemberImpl(member, list);
}
IterateTypeParametersImpl(ctd.TypeParameters, list);
CodeTypeDelegate delType = ctd as CodeTypeDelegate;
if (delType != null)
{
list.Add(delType.ReturnType);
IterateParametersImpl(delType.Parameters, list);
}
}
private static void TranslateReturnValue(CodeTypeDelegate d)
{
CodeTypeReference s;
if (d.ReturnType.BaseType == "void")
{
d.ReturnType.BaseType = "System.Void";
}
if (GLTypes.TryGetValue(d.ReturnType.BaseType, out s))
{
d.ReturnType = s;
}
if (d.ReturnType.BaseType == "GLstring")
{
d.ReturnType = new CodeTypeReference("IntPtr");
d.ReturnType.UserData.Add("Wrapper", WrapperTypes.StringReturnValue);
}
if (d.ReturnType.BaseType.ToLower().Contains("object"))
{
d.ReturnType.BaseType = "IntPtr";
d.ReturnType.UserData.Add("Wrapper", WrapperTypes.GenericReturnValue);
d.ReturnType.ArrayRank = 0;
}
if (d.ReturnType.UserData.Contains("Wrapper"))
{
d.UserData.Add("Wrapper", null);
}
}
private CodeTypeDeclaration GetCodeTypeDelegate(TypeDefinition typeDefinition)
{
if (typeDefinition.IsClass && typeDefinition.BaseType.FullName == "System.MulticastDelegate")
{
CodeTypeDelegate codeTypeDelegate = new CodeTypeDelegate()
{
Name = GetTypeName(typeDefinition)
};
if (typeDefinition.IsPublic || typeDefinition.IsNestedPublic)
{
codeTypeDelegate.TypeAttributes = TypeAttributes.Public;
}
FillCustomAttribute(codeTypeDelegate.CustomAttributes, typeDefinition.CustomAttributes);
FillGenericParameters(codeTypeDelegate.TypeParameters, typeDefinition.GenericParameters);
MethodDefinition methodDefinition = typeDefinition.Methods.First(i => i.Name == "Invoke");
codeTypeDelegate.ReturnType = new CodeTypeReference(GetTypeReferenceName(methodDefinition.ReturnType));
codeTypeDelegate.Parameters.AddRange(methodDefinition.Parameters.Select(i => GetParameterExpression(i)).ToArray());
if (typeDefinition.HasGenericParameters)
{
string sign = string.Join(",", typeDefinition.GenericParameters.Select(i => i.FullName));
codeTypeDelegate.Name += '<' + sign + '>';
}
return(codeTypeDelegate);
}
return(null);
}
public void Constructor1_Deny_Unrestricted()
{
CodeTypeDelegate ctd = new CodeTypeDelegate("mono");
Assert.AreEqual(0, ctd.Parameters.Count, "Parameters");
Assert.AreEqual("System.Void", ctd.ReturnType.BaseType, "ReturnType");
ctd.ReturnType = new CodeTypeReference("System.Int32");
}
private void HandleDelegate(CodeTypeDelegate obj, Context ctx)
{
ctx.Writer.Write("delegate ");
ctx.HandlerProvider.TypeReferenceHandler.Handle(obj.ReturnType, ctx);
ctx.Writer.Write($" {obj.Name.AsCsId()}(");
GeneralUtils.HandleCollectionCommaSeparated(obj.Parameters.Cast<CodeExpression>(),
ctx.HandlerProvider.ExpressionHandler, ctx);
ctx.Writer.WriteLine(");");
}
protected override void GenerateTypeStart(
CodeTypeDeclaration declaration)
{
TextWriter output = Output;
CodeTypeDelegate del = declaration as CodeTypeDelegate;
if (declaration.CustomAttributes.Count > 0)
{
OutputAttributeDeclarations(declaration.CustomAttributes);
}
TypeAttributes attributes = declaration.TypeAttributes;
if (del != null)
{
LocalOutputTypeAttributes(attributes,
declaration.IsStruct,
declaration.IsEnum);
output.Write("callable ");
output.Write(GetSafeName(declaration.Name));
output.Write('(');
OutputParameters(del.Parameters);
output.Write(')');
}
else
{
OutputTypeAttributes(attributes,
declaration.IsStruct,
declaration.IsEnum);
output.Write(GetSafeName(declaration.Name));
output.Write('(');
IEnumerator enumerator = declaration.BaseTypes.GetEnumerator();
if (enumerator.MoveNext())
{
CodeTypeReference type = (CodeTypeReference)enumerator.Current;
currentType = GetTypeOutput(type);
OutputType(type);
while (enumerator.MoveNext())
{
type = (CodeTypeReference)enumerator.Current;
output.Write(", ");
OutputType(type);
}
output.Write(')');
}
output.WriteLine(":");
}
++Indent;
}
internal static void AddDelegate(CodeTypeDeclarationCollection codeClasses, string handlerType, string handlerArgs)
{
CodeTypeDelegate delegate2 = new CodeTypeDelegate(handlerType);
delegate2.CustomAttributes.Add(GeneratedCodeAttribute);
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(handlerArgs, "e"));
delegate2.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true));
codeClasses.Add(delegate2);
}
private void ProcessDelegate(CodeTypeDelegate del)
{
foreach (TransformPlugin plugin in _list)
{
if (0 != (plugin.TransformKind & TransformKindFlags.Signature))
{
plugin.ProcessParameters(del);
}
}
}
public EventGenerator(string name, CodeTypeDelegate type)
{
this.Name = name;
Member = new CodeMemberEvent()
{
Name = name,
Type = new CodeTypeReference(type.Name)
};
Member.Attributes = MemberAttributes.Final | MemberAttributes.Public;
}
internal static CodeTypeDelegate NewDelegate(string name, string comment, params CodeParameterDeclarationExpression[] parameters)
{
CodeTypeDelegate dlgt = new CodeTypeDelegate(name);
CreateCommont(dlgt.Comments, comment);
foreach (CodeParameterDeclarationExpression parameter in parameters)
{
dlgt.Parameters.Add(parameter);
}
return(dlgt);
}
private void Generate(CodeTypeDelegate @delegate)
{
this.WriteCustomAttributes(@delegate.CustomAttributes);
this.WriteAttributes(@delegate.Attributes);
this.Write("delegate ");
this.Generate(@delegate.ReturnType);
this.Write(" ");
this.WriteName(@delegate.Name);
this.Write("(");
this.Generate(@delegate.Parameters);
this.WriteLine(");");
}
static CodeTypeDelegate createDelegateType(CodeTypeDeclaration ret, string delName)
{
CodeTypeDelegate ctd2;
ret.Members.Add(ctd2 = new CodeTypeDelegate(delName));
ctd2.Parameters.AddRange(
new CodeParameterDeclarationExpression[] {
new CodeParameterDeclarationExpression(typeof(object), "sender"),
new CodeParameterDeclarationExpression(typeof(EventArgs), "ea")
});
return(ctd2);
}
public static CodeTypeDelegate Delegate <T>(MemberAttributes ma,
Expression <Func <T, string> > paramsAndName)
{
var c = new CodeTypeDelegate()
{
Attributes = ma
};
c.Name = CodeDom.GetMethodName <string>(paramsAndName, c.Parameters);
return(c);
}
public static CodeTypeDelegate Delegate(Type returnType, MemberAttributes ma,
Expression <Func <string> > paramsAndName)
{
var c = new CodeTypeDelegate()
{
Attributes = ma,
ReturnType = new CodeTypeReference(returnType),
};
c.Name = CodeDom.GetMethodName <string>(paramsAndName, c.Parameters);
return(c);
}
static CodeMemberEvent createEvent(CodeTypeDeclaration ret, CodeTypeDelegate ctd2, string v)
{
CodeMemberEvent cme;
cme = new CodeMemberEvent();
cme.Name = v;
cme.Type = new CodeTypeReference(ctd2.Name);
cme.Attributes = MemberAttributes.Public;
ret.Members.Add(cme);
cme.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "events"));
cme.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "events"));
return(cme);
}
public CodeTypeMember ToCodeDom()
{
CodeTypeDelegate d = new CodeTypeDelegate();
d.Name = this.Name;
foreach (ParameterDeclaration p in signature.Parameters)
{
d.Parameters.Add(p.ToCodeDom());
}
d.ReturnType = signature.ReturnType.TypeReference;
base.ToCodeDom(d);
return(d);
}
private EventModuleData ReadEventModuleData(CodeTypeDelegate eventDelegate, CodeMemberEvent eventField)
{
EventModuleData data = new EventModuleData();
data.name = eventField.Name;
data.returnType = eventDelegate.ReturnType.BaseType;
data.paramTypes = new string[eventDelegate.Parameters.Count];
for (int i = 0; i < eventDelegate.Parameters.Count; i++)
{
data.paramTypes[i] = eventDelegate.Parameters[i].Type.BaseType;
}
if (eventField.Comments.Count > 0)
{
data.comment = eventField.Comments[0].Comment.Text;
}
return(data);
}
private CodeTypeReference CheckForFunctionPointer(string typeString)
{
Match match = MatchFunctionPointer(typeString);
if (match.Success)
{
string returnType = match.Groups[1].Value;
StringBuilder delegateNameBuilder = new StringBuilder();
CodeTypeDelegate @delegate = new CodeTypeDelegate();
@delegate.ReturnType = this.CppToCSharp(returnType);
if (returnType == "void")
{
delegateNameBuilder.Append("Action");
}
else
{
delegateNameBuilder.Append("Func");
CodeTypeReference returnTypeReference = this.CppToCSharp(returnType);
delegateNameBuilder.Append(
returnTypeReference.BaseType.Substring(returnTypeReference.BaseType.LastIndexOf('.') + 1));
}
foreach (string argumentType in match.Groups[2].Value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
CodeTypeReference argType = this.CppToCSharp(argumentType);
string argTypeName = argType.BaseType.Substring(argType.BaseType.LastIndexOf('.') + 1);
string arg = argTypeName[0].ToString(CultureInfo.InvariantCulture).ToLowerInvariant() +
argTypeName.Substring(1);
@delegate.Parameters.Add(new CodeParameterDeclarationExpression(argType, arg));
delegateNameBuilder.Append(argTypeName);
}
@delegate.Name = delegateNameBuilder.ToString();
if (@delegate.Name == "Action")
{
return(new CodeTypeReference(typeof(Action)));
}
CodeTypeDeclaration globalType = this.data.CSharpTypeMap[this.data.GlobalSpaceClassName];
if (globalType.Members.Cast <CodeTypeMember>().All(m => m.Name != @delegate.Name))
{
globalType.Members.Add(@delegate);
}
delegateNameBuilder.Insert(0, globalType.Name + '.');
return(new CodeTypeReference(delegateNameBuilder.ToString()));
}
throw new NotSupportedException(typeString);
}
public static CodeCompileUnit TestDelegateAndEventCompileUnit()
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace("Test.Namespace");
CodeTypeDeclaration declaration = new CodeTypeDeclaration("TestClass")
{
IsClass = true,
IsPartial = true
};
declaration.TypeAttributes =
(declaration.TypeAttributes & ~TypeAttributes.VisibilityMask) | TypeAttributes.Public;
CodeTypeDelegate delegateDeclaration = new CodeTypeDelegate("TestDelegate")
{
ReturnType = Types.Int
};
delegateDeclaration.TypeAttributes =
(delegateDeclaration.TypeAttributes & ~TypeAttributes.VisibilityMask) | TypeAttributes.NestedFamily;
delegateDeclaration.Parameters.Add(
new CodeParameterDeclarationExpression(Types.Int, "a"));
delegateDeclaration.Parameters.Add(
new CodeParameterDeclarationExpression(Types.Int, "b"));
CodeTypeDelegate delegateDeclaration2 = new CodeTypeDelegate("TestDelegate2");
delegateDeclaration2.TypeAttributes =
(delegateDeclaration2.TypeAttributes & ~TypeAttributes.VisibilityMask) | TypeAttributes.NestedFamily;
CodeMemberEvent memberEvent = new CodeMemberEvent()
{
Name = "TestEvent",
Type = new CodeTypeReference("TestDelegate2"),
Attributes = MemberAttributes.Family | MemberAttributes.Static
};
declaration.Members.Add(delegateDeclaration);
declaration.Members.Add(delegateDeclaration2);
declaration.Members.Add(memberEvent);
codeNamespace.Types.Add(declaration);
compileUnit.Namespaces.Add(codeNamespace);
return(compileUnit);
}
protected override void GenerateTypeStart(CodeTypeDeclaration e)
{
OutputAttributeDeclarations(e.CustomAttributes);
if (!IsCurrentDelegate)
{
OutputTypeAttributes
(e.TypeAttributes, IsCurrentStruct, IsCurrentEnum);
OutputIdentifier(e.Name);
String sep = " : ";
foreach (CodeTypeReference type in e.BaseTypes)
{
Output.Write(sep);
OutputType(type);
sep = ",";
}
StartBlock();
}
else
{
switch (e.TypeAttributes & TypeAttributes.VisibilityMask)
{
case TypeAttributes.NestedPrivate:
Output.Write("private "); break;
case TypeAttributes.Public:
case TypeAttributes.NestedPublic:
Output.Write("public "); break;
}
Output.Write("delegate ");
CodeTypeDelegate d = (CodeTypeDelegate)e;
if (d.ReturnType != null)
{
OutputType(d.ReturnType);
}
else
{
Output.Write("void");
}
Output.Write(" ");
OutputIdentifier(d.Name);
Output.Write("(");
OutputParameters(d.Parameters);
Output.WriteLine(");");
}
}
private static CodeMemberMethod CreatePrototype(CodeTypeDelegate d)
{
CodeMemberMethod f = new CodeMemberMethod();
f.Name = "gl" + d.Name;
f.Parameters.AddRange(d.Parameters);
f.ReturnType = d.ReturnType;
f.Attributes = MemberAttributes.Static | MemberAttributes.Public;
//f.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, f.Name));
//f.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, f.Name));
/*f.Comments.Add(new CodeCommentStatement("<summary>", true));
* f.Comments.Add(new CodeCommentStatement(" ", true));
* f.Comments.Add(new CodeCommentStatement("</summary>", true));*/
return(f);
}
private CodeTypeDelegate GenerateTypedRowEventHandler(DesignTable table)
{
CodeTypeDelegate delegate2;
if (table == null)
{
throw new InternalException("DesignTable should not be null.");
}
string generatorRowClassName = table.GeneratorRowClassName;
delegate2 = new CodeTypeDelegate(table.GeneratorRowEvHandlerName)
{
TypeAttributes = delegate2.TypeAttributes | TypeAttributes.Public
};
delegate2.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.GlobalType(typeof(object)), "sender"));
delegate2.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(table.GeneratorRowEvArgName), "e"));
delegate2.CustomAttributes.Add(CodeGenHelper.GeneratedCodeAttributeDecl());
return(delegate2);
}
public static CodeTypeDelegate ToDelegate(this TypeInfo type, string nativeName, Cursor cursor, ModuleGenerator generator)
{
if (type.Kind != TypeKind.FunctionProto &&
type.Kind != TypeKind.Unexposed)
{
throw new InvalidOperationException();
}
var clrName = NameConversions.ToClrName(nativeName, NameConversion.Type);
CodeTypeDelegate delegateType = new CodeTypeDelegate();
delegateType.CustomAttributes.Add(
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(UnmanagedFunctionPointerAttribute)),
new CodeAttributeArgument(
new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(typeof(CallingConvention)),
type.GetCallingConvention().ToString()))));
delegateType.Attributes = MemberAttributes.Public | MemberAttributes.Final;
delegateType.Name = clrName;
delegateType.ReturnType = new CodeTypeReference(type.GetResultType().ToClrType());
uint argumentCounter = 0;
var cursorVisitor = new DelegatingCursorVisitor(
delegate(Cursor c, Cursor parent1)
{
if (c.Kind == CursorKind.ParmDecl)
{
delegateType.Parameters.Add(Argument.GenerateArgument(generator, type, c, argumentCounter++, FunctionType.Delegate));
}
return(ChildVisitResult.Continue);
});
cursorVisitor.VisitChildren(cursor);
return(delegateType);
}
public CodeTypeDeclaration[] CreateTypes(SyntaxList <MemberDeclarationSyntax> typeDeclarationList)
{
List <CodeTypeDeclaration> classes = new List <CodeTypeDeclaration>();
for (int i = 0; i < typeDeclarationList.Count; i++)
{
MemberDeclarationSyntax syntax = typeDeclarationList[i];
CodeTypeDeclaration type = new CodeTypeDeclaration();
if (syntax is ClassDeclarationSyntax classDeclaration)
{
type.Name = classDeclaration.Identifier.Text;
type.Members.AddRange(CreateClassMembers(type, classDeclaration.Members));
classes.Add(type);
}
else if (syntax is StructDeclarationSyntax structDeclaration)
{
type.Name = structDeclaration.Identifier.Text;
type.IsStruct = true;
classes.Add(type);
}
else if (syntax is InterfaceDeclarationSyntax interfaceDeclaration)
{
type.Name = interfaceDeclaration.Identifier.Text;
type.IsInterface = true;
classes.Add(type);
}
else if (syntax is EnumDeclarationSyntax enumDeclaration)
{
type.Name = enumDeclaration.Identifier.Text;
type.IsEnum = true;
classes.Add(type);
}
else if (syntax is DelegateDeclarationSyntax delegateDeclaration)
{
type = new CodeTypeDelegate(delegateDeclaration.Identifier.Text);
classes.Add(type);
}
}
return(classes.ToArray());
}
public void RegionsSnippetsAndLinePragmas()
{
var cu = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Namespace1");
cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cu.Namespaces.Add(ns);
var cd = new CodeTypeDeclaration("Class1");
ns.Types.Add(cd);
cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField(typeof(String), "field1");
CodeMemberField field2 = new CodeMemberField(typeof(String), "field2");
field1.Comments.Add(new CodeCommentStatement("Field 1 Comment"));
field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference(typeof(System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference(typeof(System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method1.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500);
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty();
property1.Name = "Property1";
property1.Type = new CodeTypeReference(typeof(string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty();
property2.Name = "Property2";
property2.Type = new CodeTypeReference(typeof(string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2")));
property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1"),
new CodePrimitiveExpression("value1"));
conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add(conState1);
CodeStatement conState2 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2"),
new CodePrimitiveExpression("value2"));
conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
constructor1.Statements.Add(conState2);
constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1"));
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor();
typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment"));
nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
var snippet1 = new CodeSnippetTypeMember();
var snippet2 = new CodeSnippetTypeMember();
CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add(regionStart);
snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Members.Add(field1);
cd.Members.Add(method1);
cd.Members.Add(constructor1);
cd.Members.Add(property1);
cd.Members.Add(methodMain);
cd.Members.Add(evt1);
cd.Members.Add(nestedClass1);
cd.Members.Add(delegate1);
cd.Members.Add(snippet1);
cd.Members.Add(field2);
cd.Members.Add(method2);
cd.Members.Add(constructor2);
cd.Members.Add(property2);
cd.Members.Add(typeConstructor2);
cd.Members.Add(evt2);
cd.Members.Add(nestedClass2);
cd.Members.Add(delegate2);
cd.Members.Add(snippet2);
AssertEqual(cu,
@"#region Compile Unit Region
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Namespace1 {
#region Outer Type Region
// Outer Type Comment
public class Class1 {
// Field 1 Comment
private string field1;
#region Field Region
private string field2;
#endregion
#region Snippet Region
#endregion
#region Type Constructor Region
static Class1() {
}
#endregion
#region Constructor Region
public Class1() {
#region Statements Region
this.field1 = ""value1"";
this.field2 = ""value2"";
#endregion
}
#endregion
public Class1(string value1, string value2)
{
}
public string Property1
{
get
{
return this.field1;
}
}
#region Property Region
public string Property2
{
get
{
return this.field2;
}
}
#endregion
public event System.EventHandler Event1;
#region Event Region
public event System.EventHandler Event2;
#endregion
public void Method1()
{
this.Event1(this, System.EventArgs.Empty);
}
public static void Main()
{
}
#region Method Region
// Method 2 Comment
#line 500 ""MethodLinePragma.txt""
public void Method2()
{
this.Event2(this, System.EventArgs.Empty);
}
#line default
#line hidden
#endregion
public class NestedClass1
{
}
public delegate void nestedDelegate1(object sender, System.EventArgs e);
#region Nested Type Region
// Nested Type Comment
#line 400 ""NestedTypeLinePragma.txt""
public class NestedClass2
{
}
#line default
#line hidden
#endregion
#region Delegate Region
public delegate void nestedDelegate2(object sender, System.EventArgs e);
#endregion
}
#endregion
}
#endregion");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
if (!(provider is JScriptCodeProvider)) {
// GENERATES (C#):
//
// #region Compile Unit Region
//
// namespace Namespace1 {
//
//
// #region Outer Type Region
// // Outer Type Comment
// public class Class1 {
//
// // Field 1 Comment
// private string field1;
//
// public void Method1() {
// this.Event1(this, System.EventArgs.Empty);
// }
//
// #region Constructor Region
// public Class1() {
// #region Statements Region
// this.field1 = "value1";
// this.field2 = "value2";
// #endregion
// }
// #endregion
//
// public string Property1 {
// get {
// return this.field1;
// }
// }
//
// public static void Main() {
// }
//
// public event System.EventHandler Event1;
//
// public class NestedClass1 {
// }
//
// public delegate void nestedDelegate1(object sender, System.EventArgs e);
//
//
//
// #region Field Region
// private string field2;
// #endregion
//
// #region Method Region
// // Method 2 Comment
//
// #line 500 "MethodLinePragma.txt"
// public void Method2() {
// this.Event2(this, System.EventArgs.Empty);
// }
//
// #line default
// #line hidden
// #endregion
//
// public Class1(string value1, string value2) {
// }
//
// #region Property Region
// public string Property2 {
// get {
// return this.field2;
// }
// }
// #endregion
//
// #region Type Constructor Region
// static Class1() {
// }
// #endregion
//
// #region Event Region
// public event System.EventHandler Event2;
// #endregion
//
// #region Nested Type Region
// // Nested Type Comment
//
// #line 400 "NestedTypeLinePragma.txt"
// public class NestedClass2 {
// }
//
// #line default
// #line hidden
// #endregion
//
// #region Delegate Region
// public delegate void nestedDelegate2(object sender, System.EventArgs e);
// #endregion
//
// #region Snippet Region
//
// #endregion
// }
// #endregion
// }
// #endregion
CodeNamespace ns = new CodeNamespace ("Namespace1");
cu.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cu.Namespaces.Add (ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1");
ns.Types.Add (cd);
cd.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Comments.Add (new CodeCommentStatement ("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField (typeof (String), "field1");
CodeMemberField field2 = new CodeMemberField (typeof (String), "field2");
field1.Comments.Add (new CodeCommentStatement ("Field 1 Comment"));
field2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent ();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference (typeof (System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent ();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference (typeof (System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method1.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
CodeMemberMethod method2 = new CodeMemberMethod ();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (provider.Supports (GeneratorSupport.DeclareEvents)) {
method2.Statements.Add (
new CodeDelegateInvokeExpression (
new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
method2.LinePragma = new CodeLinePragma ("MethodLinePragma.txt", 500);
method2.Comments.Add (new CodeCommentStatement ("Method 2 Comment"));
method2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty ();
property1.Name = "Property1";
property1.Type = new CodeTypeReference (typeof (string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty ();
property2.Name = "Property2";
property2.Type = new CodeTypeReference (typeof (string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add (
new CodeMethodReturnStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2")));
property2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor ();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field1"),
new CodePrimitiveExpression ("value1"));
conState1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add (conState1);
CodeStatement conState2 = new CodeAssignStatement (
new CodeFieldReferenceExpression (
new CodeThisReferenceExpression (),
"field2"),
new CodePrimitiveExpression ("value2"));
conState2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
constructor1.Statements.Add (conState2);
constructor1.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor ();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value1"));
constructor2.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor ();
typeConstructor2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod ();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration ("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration ("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma ("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add (new CodeCommentStatement ("Nested Type Comment"));
nestedClass2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate ();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate1.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate ();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.Object"), "sender"));
delegate2.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference ("System.EventArgs"), "e"));
delegate2.StartDirectives.Add (new CodeRegionDirective (CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
CodeSnippetTypeMember snippet1 = new CodeSnippetTypeMember ();
CodeSnippetTypeMember snippet2 = new CodeSnippetTypeMember ();
CodeRegionDirective regionStart = new CodeRegionDirective (CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add (regionStart);
snippet2.EndDirectives.Add (new CodeRegionDirective (CodeRegionMode.End, string.Empty));
cd.Members.Add (field1);
cd.Members.Add (method1);
cd.Members.Add (constructor1);
cd.Members.Add (property1);
cd.Members.Add (methodMain);
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt1);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass1);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate1);
}
}
cd.Members.Add (snippet1);
cd.Members.Add (field2);
cd.Members.Add (method2);
cd.Members.Add (constructor2);
cd.Members.Add (property2);
if (Supports (provider, GeneratorSupport.StaticConstructors)) {
cd.Members.Add (typeConstructor2);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add (evt2);
}
if (Supports (provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add (nestedClass2);
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add (delegate2);
}
}
cd.Members.Add (snippet2);
}
#endif
}
public void RegionsSnippetsAndLinePragmas()
{
CodeCompileUnit cu = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace("Namespace1");
cu.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Compile Unit Region"));
cu.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cu.Namespaces.Add(ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration("Class1");
ns.Types.Add(cd);
cd.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Outer Type Region"));
cd.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField(typeof(String), "field1");
CodeMemberField field2 = new CodeMemberField(typeof(String), "field2");
field1.Comments.Add(new CodeCommentStatement("Field 1 Comment"));
field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Field Region"));
field2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberEvent evt1 = new CodeMemberEvent();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference(typeof(System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference(typeof(System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
evt2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Event Region"));
evt2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method1.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method2.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500);
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
method2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Method Region"));
method2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeMemberProperty property1 = new CodeMemberProperty();
property1.Name = "Property1";
property1.Type = new CodeTypeReference(typeof(string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty();
property2.Name = "Property2";
property2.Type = new CodeTypeReference(typeof(string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2")));
property2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Property Region"));
property2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeStatement conState1 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1"),
new CodePrimitiveExpression("value1"));
conState1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Statements Region"));
constructor1.Statements.Add(conState1);
CodeStatement conState2 = new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2"),
new CodePrimitiveExpression("value2"));
conState2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
constructor1.Statements.Add(conState2);
constructor1.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Constructor Region"));
constructor1.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeConstructor constructor2 = new CodeConstructor();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1"));
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor();
typeConstructor2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Type Constructor Region"));
typeConstructor2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment"));
nestedClass2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Nested Type Region"));
nestedClass2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
CodeTypeDelegate delegate1 = new CodeTypeDelegate();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
delegate2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Delegate Region"));
delegate2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
var snippet1 = new CodeSnippetTypeMember();
var snippet2 = new CodeSnippetTypeMember();
CodeRegionDirective regionStart = new CodeRegionDirective(CodeRegionMode.End, "");
regionStart.RegionText = "Snippet Region";
regionStart.RegionMode = CodeRegionMode.Start;
snippet2.StartDirectives.Add(regionStart);
snippet2.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
cd.Members.Add(field1);
cd.Members.Add(method1);
cd.Members.Add(constructor1);
cd.Members.Add(property1);
cd.Members.Add(methodMain);
cd.Members.Add(evt1);
cd.Members.Add(nestedClass1);
cd.Members.Add(delegate1);
cd.Members.Add(snippet1);
cd.Members.Add(field2);
cd.Members.Add(method2);
cd.Members.Add(constructor2);
cd.Members.Add(property2);
cd.Members.Add(typeConstructor2);
cd.Members.Add(evt2);
cd.Members.Add(nestedClass2);
cd.Members.Add(delegate2);
cd.Members.Add(snippet2);
AssertEqual(cu,
@"#Region ""Compile Unit Region""
'------------------------------------------------------------------------------
' <auto-generated>
' This code was generated by a tool.
' Runtime Version:4.0.30319.42000
'
' Changes to this file may cause incorrect behavior and will be lost if
' the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------
Option Strict Off
Option Explicit On
Namespace Namespace1
#Region ""Outer Type Region""
'Outer Type Comment
Public Class Class1
'Field 1 Comment
Private field1 As String
#Region ""Field Region""
Private field2 As String
#End Region
#Region ""Snippet Region""
#End Region
#Region ""Type Constructor Region""
Shared Sub New()
End Sub
#End Region
#Region ""Constructor Region""
Public Sub New()
MyBase.New
Me.field1 = ""value1""
Me.field2 = ""value2""
End Sub
#End Region
Public Sub New(ByVal value1 As String, ByVal value2 As String)
MyBase.New
End Sub
Public ReadOnly Property Property1() As String
Get
Return Me.field1
End Get
End Property
#Region ""Property Region""
Public ReadOnly Property Property2() As String
Get
Return Me.field2
End Get
End Property
#End Region
Public Event Event1 As System.EventHandler
#Region ""Event Region""
Public Event Event2 As System.EventHandler
#End Region
Public Sub Method1()
RaiseEvent Event1(Me, System.EventArgs.Empty)
End Sub
Public Shared Sub Main()
End Sub
#Region ""Method Region""
'Method 2 Comment
#ExternalSource(""MethodLinePragma.txt"",500)
Public Sub Method2()
RaiseEvent Event2(Me, System.EventArgs.Empty)
End Sub
#End ExternalSource
#End Region
Public Class NestedClass1
End Class
Public Delegate Sub nestedDelegate1(ByVal sender As Object, ByVal e As System.EventArgs)
#Region ""Nested Type Region""
'Nested Type Comment
#ExternalSource(""NestedTypeLinePragma.txt"",400)
Public Class NestedClass2
End Class
#End ExternalSource
#End Region
#Region ""Delegate Region""
Public Delegate Sub nestedDelegate2(ByVal sender As Object, ByVal e As System.EventArgs)
#End Region
End Class
#End Region
End Namespace
#End Region");
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// Namespace to hold test scenarios
// GENERATES (C#):
// namespace NSPC {
// using System;
// using System.Drawing;
// using System.Windows.Forms;
// using System.ComponentModel;
// }
AddScenario ("FindNamespaceComment");
CodeNamespace nspace = new CodeNamespace ("NSPC");
nspace.Comments.Add (new CodeCommentStatement (new CodeComment ("Namespace to hold test scenarios")));
nspace.Imports.Add (new CodeNamespaceImport ("System"));
nspace.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
nspace.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
nspace.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
cu.Namespaces.Add (nspace);
cu.ReferencedAssemblies.Add ("System.Drawing.dll");
cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");
// GENERATES (C#):
// // Class has a method to test static constructors
// public class ClassWithMethod {
// // This method is used to test a static constructor
// public static int TestStaticConstructor(int a) {
// // Testing a line comment
// TestClass t = new TestClass();
// t.i = a;
// return t.i;
// }
// }
AddScenario ("FindClassComment");
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("ClassWithMethod");
class1.IsClass = true;
class1.Comments.Add (new CodeCommentStatement ("Class has a method to test static constructors"));
nspace.Types.Add (class1);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "TestStaticConstructor";
AddScenario ("FindMethodComment");
cmm.Comments.Add (new CodeCommentStatement (new CodeComment ("This method is used to test a static constructor")));
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference (typeof (int));
AddScenario ("FindLineComment");
cmm.Statements.Add (new CodeCommentStatement ("Testing a line comment"));
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (typeof (int), "a");
cmm.Parameters.Add (param);
// utilize constructor
cmm.Statements.Add (new CodeVariableDeclarationStatement ("TestClass", "t", new CodeObjectCreateExpression ("TestClass")));
// set then get number
cmm.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeVariableReferenceExpression ("t"), "i")
, new CodeArgumentReferenceExpression ("a")));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodePropertyReferenceExpression (new CodeVariableReferenceExpression ("t"), "i")));
class1.Members.Add (cmm);
// GENERATES (C#):
// public class TestClass {
// // This field is an integer counter
// private int number;
// static TestClass() {
// }
// // This property allows us to access the integer counter
// // We are able to both get and set the value of the counter
// public int i {
// get {
// return number;
// }
// set {
// number = value;
// }
// }
// }
class1 = new CodeTypeDeclaration ();
class1.Name = "TestClass";
class1.IsClass = true;
nspace.Types.Add (class1);
AddScenario ("FindFieldComment");
CodeMemberField mfield = new CodeMemberField (new CodeTypeReference (typeof (int)), "number");
mfield.Comments.Add (new CodeCommentStatement ("This field is an integer counter"));
class1.Members.Add (mfield);
AddScenario ("FindPropertyComment");
CodeMemberProperty prop = new CodeMemberProperty ();
prop.Name = "i";
prop.Comments.Add (new CodeCommentStatement ("This property allows us to access the integer counter"));
prop.Comments.Add (new CodeCommentStatement ("We are able to both get and set the value of the counter"));
prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
prop.Type = new CodeTypeReference (typeof (int));
prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (null, "number")));
prop.SetStatements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (null, "number"),
new CodePropertySetValueReferenceExpression ()));
class1.Members.Add (prop);
CodeTypeConstructor ctc = new CodeTypeConstructor ();
class1.Members.Add (ctc);
// ************* code a comment on an event *************
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
// GENERATES (C#):
// public class Test : Form {
// private Button b = new Button();
// public Test() {
// this.Size = new Size(600, 600);
// b.Text = "Test";
// b.TabIndex = 0;
// b.Location = new Point(400, 525);
// this.MyEvent += new EventHandler(this.b_Click);
// }
// // This is a comment on an event
// public event System.EventHandler MyEvent;
// private void b_Click(object sender, System.EventArgs e) {
// }
// }
class1 = new CodeTypeDeclaration ("Test");
class1.IsClass = true;
class1.BaseTypes.Add (new CodeTypeReference ("Form"));
nspace.Types.Add (class1);
mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
class1.Members.Add (mfield);
CodeConstructor ctor = new CodeConstructor ();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (),
"Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Text"), new CodePrimitiveExpression ("Test")));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"TabIndex"), new CodePrimitiveExpression (0)));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
, new CodeThisReferenceExpression (), "b_Click")));
class1.Members.Add (ctor);
AddScenario ("FindEventComment");
CodeMemberEvent evt = new CodeMemberEvent ();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference ("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
evt.Comments.Add (new CodeCommentStatement ("This is a comment on an event"));
class1.Members.Add (evt);
cmm = new CodeMemberMethod ();
cmm.Name = "b_Click";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
class1.Members.Add (cmm);
}
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
// GENERATES (C#):
//
// // This is a delegate comment
// public delegate void Delegate();
AddScenario ("FindDelegateComment");
CodeTypeDelegate del = new CodeTypeDelegate ("Delegate");
del.Comments.Add (new CodeCommentStatement ("This is a delegate comment"));
nspace.Types.Add (del);
}
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu)
{
// GENERATES (C#):
//
// namespace NSPC {
// public class DelegateClass {
//
// public virtual int Sum(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20) {
// int mySum = 0;
// mySum = (mySum + val1);
// mySum = (mySum + val2);
// mySum = (mySum + val3);
// mySum = (mySum + val4);
// mySum = (mySum + val5);
// mySum = (mySum + val6);
// mySum = (mySum + val7);
// mySum = (mySum + val8);
// mySum = (mySum + val9);
// mySum = (mySum + val10);
// mySum = (mySum + val11);
// mySum = (mySum + val12);
// mySum = (mySum + val13);
// mySum = (mySum + val14);
// mySum = (mySum + val15);
// mySum = (mySum + val16);
// mySum = (mySum + val17);
// mySum = (mySum + val18);
// mySum = (mySum + val19);
// mySum = (mySum + val20);
// return mySum;
// }
//
// public virtual int Do() {
// MyDelegate myDel = new DelegateClass.MyDelegate(this.Sum);
// return myDel(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765);
// }
// }
//
// public delegate int MyDelegate(
// int val1,
// int val2,
// int val3,
// int val4,
// int val5,
// int val6,
// int val7,
// int val8,
// int val9,
// int val10,
// int val11,
// int val12,
// int val13,
// int val14,
// int val15,
// int val16,
// int val17,
// int val18,
// int val19,
// int val20);
// }
CodeNamespace nspace = new CodeNamespace ("NSPC");
cu.Namespaces.Add (nspace);
// only produce code if the generator can declare delegates
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
CodeTypeDeclaration class1 = new CodeTypeDeclaration ("DelegateClass");
class1.IsClass = true;
nspace.Types.Add (class1);
CodeTypeDelegate td = new CodeTypeDelegate ("MyDelegate");
td.ReturnType = new CodeTypeReference (typeof (Int32));
for (int i = 1; i <= 5; i++)
td.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (Int32)), "val" + i));
nspace.Types.Add (td);
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "Sum";
cmm.ReturnType = new CodeTypeReference (typeof (Int32));
for (int i = 1; i <= 5; i++)
cmm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference (typeof (Int32)), "val" + i));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (typeof (int), "mySum", new CodePrimitiveExpression (0)));
for (int i = 1; i <= 5; i++)
cmm.Statements.Add (CDHelper.CreateIncrementByStatement ("mySum", new CodeArgumentReferenceExpression ("val" + i)));
cmm.Statements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("mySum")));
class1.Members.Add (cmm);
#if !WHIDBEY
if (!(provider is VBCodeProvider)) {
#endif
AddScenario ("CheckDo", "Check Do()'s return value.");
cmm = new CodeMemberMethod ();
cmm.Name = "Do";
cmm.ReturnType = new CodeTypeReference (typeof (Int32));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("MyDelegate"), "myDel",
new CodeDelegateCreateExpression (new CodeTypeReference ("NSPC.MyDelegate"),
new CodeThisReferenceExpression (), "Sum")));
CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression ();
delegateInvoke.TargetObject = new CodeVariableReferenceExpression ("myDel");
for (int i = 1; i <= 5; i++)
delegateInvoke.Parameters.Add (new CodePrimitiveExpression (fib (i)));
cmm.Statements.Add (new CodeMethodReturnStatement (delegateInvoke));
class1.Members.Add (cmm);
#if !WHIDBEY
}
#endif
}
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
#if WHIDBEY
CodeNamespace ns = new CodeNamespace("Namespace1");
cu.Namespaces.Add(ns);
CodeTypeDeclaration cd = new CodeTypeDeclaration ("Class1");
ns.Types.Add(cd);
cd.Comments.Add(new CodeCommentStatement("Outer Type Comment"));
CodeMemberField field1 = new CodeMemberField(typeof(String), "field1");
CodeMemberField field2 = new CodeMemberField(typeof(String), "field2");
field2.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Foo"));
field2.EndDirectives.Add(new CodeRegionDirective (CodeRegionMode.End, String.Empty));
field1.Comments.Add(new CodeCommentStatement("Field 1 Comment"));
CodeMemberEvent evt1 = new CodeMemberEvent();
evt1.Name = "Event1";
evt1.Type = new CodeTypeReference(typeof(System.EventHandler));
evt1.Attributes = (evt1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberEvent evt2 = new CodeMemberEvent();
evt2.Name = "Event2";
evt2.Type = new CodeTypeReference(typeof(System.EventHandler));
evt2.Attributes = (evt2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Method1";
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (Supports(provider, GeneratorSupport.DeclareEvents)) {
method1.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event1"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Method2";
method2.Attributes = (method2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
if (Supports(provider, GeneratorSupport.DeclareEvents)) {
method2.Statements.Add(
new CodeDelegateInvokeExpression(
new CodeEventReferenceExpression(new CodeThisReferenceExpression(), "Event2"),
new CodeExpression[] {
new CodeThisReferenceExpression(),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("System.EventArgs"), "Empty")
}));
}
method2.LinePragma = new CodeLinePragma("MethodLinePragma.txt", 500);
method2.Comments.Add(new CodeCommentStatement("Method 2 Comment"));
CodeMemberProperty property1 = new CodeMemberProperty();
property1.Name = "Property1";
property1.Type = new CodeTypeReference(typeof(string));
property1.Attributes = (property1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property1.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1")));
CodeMemberProperty property2 = new CodeMemberProperty();
property2.Name = "Property2";
property2.Type = new CodeTypeReference(typeof(string));
property2.Attributes = (property2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
property2.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2")));
CodeConstructor constructor1 = new CodeConstructor();
constructor1.Attributes = (constructor1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor1.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field1"),
new CodePrimitiveExpression("value1")));
constructor1.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
"field2"),
new CodePrimitiveExpression("value2")));
CodeConstructor constructor2 = new CodeConstructor();
constructor2.Attributes = (constructor2.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value1"));
constructor2.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "value2"));
CodeTypeConstructor typeConstructor2 = new CodeTypeConstructor();
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeDeclaration nestedClass1 = new CodeTypeDeclaration ("NestedClass1");
CodeTypeDeclaration nestedClass2 = new CodeTypeDeclaration ("NestedClass2");
nestedClass2.LinePragma = new CodeLinePragma("NestedTypeLinePragma.txt", 400);
nestedClass2.Comments.Add(new CodeCommentStatement("Nested Type Comment"));
CodeTypeDelegate delegate1 = new CodeTypeDelegate();
delegate1.Name = "nestedDelegate1";
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate1.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
CodeTypeDelegate delegate2 = new CodeTypeDelegate();
delegate2.Name = "nestedDelegate2";
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.Object"), "sender"));
delegate2.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference("System.EventArgs"), "e"));
cd.Members.Add(field1);
cd.Members.Add(method1);
cd.Members.Add(constructor1);
cd.Members.Add(property1);
if (Supports (provider, GeneratorSupport.EntryPointMethod))
cd.Members.Add(methodMain);
if (Supports(provider, GeneratorSupport.DeclareEvents))
cd.Members.Add(evt1);
if (Supports(provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add(nestedClass1);
if (Supports(provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add(delegate1);
}
}
cd.Members.Add(field2);
cd.Members.Add(method2);
cd.Members.Add(constructor2);
cd.Members.Add(property2);
if (Supports(provider, GeneratorSupport.StaticConstructors)) {
cd.Members.Add(typeConstructor2);
}
if (Supports(provider, GeneratorSupport.DeclareEvents)) {
cd.Members.Add(evt2);
}
if (Supports(provider, GeneratorSupport.NestedTypes)) {
cd.Members.Add(nestedClass2);
if (Supports(provider, GeneratorSupport.DeclareDelegates)) {
cd.Members.Add(delegate2);
}
}
#endif
}
public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
// GENERATES (C#):
// [assembly: System.Reflection.AssemblyTitle("MyAssembly")]
// [assembly: System.Reflection.AssemblyVersion("1.0.6.2")]
// [assembly: System.CLSCompliantAttribute(false)]
//
// namespace MyNamespace {
// using System;
// using System.Drawing;
// using System.Windows.Forms;
// using System.ComponentModel;
//
CodeNamespace ns = new CodeNamespace ();
ns.Name = "MyNamespace";
ns.Imports.Add (new CodeNamespaceImport ("System"));
ns.Imports.Add (new CodeNamespaceImport ("System.Drawing"));
ns.Imports.Add (new CodeNamespaceImport ("System.Windows.Forms"));
ns.Imports.Add (new CodeNamespaceImport ("System.ComponentModel"));
cu.Namespaces.Add (ns);
cu.ReferencedAssemblies.Add ("System.Xml.dll");
cu.ReferencedAssemblies.Add ("System.Drawing.dll");
cu.ReferencedAssemblies.Add ("System.Windows.Forms.dll");
// Assembly Attributes
if (Supports (provider, GeneratorSupport.AssemblyAttributes)) {
AddScenario ("CheckAssemblyAttributes", "Check that assembly attributes get generated properly.");
CodeAttributeDeclarationCollection attrs = cu.AssemblyCustomAttributes;
attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyTitle", new
CodeAttributeArgument (new CodePrimitiveExpression ("MyAssembly"))));
attrs.Add (new CodeAttributeDeclaration ("System.Reflection.AssemblyVersion", new
CodeAttributeArgument (new CodePrimitiveExpression ("1.0.6.2"))));
attrs.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new
CodeAttributeArgument (new CodePrimitiveExpression (false))));
}
// GENERATES (C#):
// [System.Serializable()]
// [System.Obsolete("Don\'t use this Class")]
// [System.Windows.Forms.AxHost.ClsidAttribute("Class.ID")]
// public class MyClass {
//
#if !WHIDBEY
// Everett versions of C# and VB code providers will never have these generated properly
if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider))
AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly.");
#else
AddScenario ("CheckClassAttributes", "Check that class attributes get generated properly.");
#endif
CodeTypeDeclaration class1 = new CodeTypeDeclaration ();
class1.Name = "MyClass";
class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Serializable"));
class1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Class"))));
class1.CustomAttributes.Add (new
CodeAttributeDeclaration (typeof (System.Windows.Forms.AxHost.ClsidAttribute).FullName,
new CodeAttributeArgument (new CodePrimitiveExpression ("Class.ID"))));
ns.Types.Add (class1);
// GENERATES (C#):
// [System.Serializable()]
// public class NestedClass {
// }
if (Supports (provider, GeneratorSupport.NestedTypes)) {
#if !WHIDBEY
// Everett versions of C# and VB code providers will never have these generated properly
if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider))
AddScenario ("CheckNestedClassAttributes", "Check that nested class attributes get generated properly.");
#else
AddScenario ("CheckNestedClassAttributes", "Check that nested class attributes get generated properly.");
#endif
CodeTypeDeclaration nestedClass = new CodeTypeDeclaration ("NestedClass");
nestedClass.TypeAttributes = TypeAttributes.NestedPublic;
nestedClass.IsClass = true;
nestedClass.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Serializable"));
class1.Members.Add (nestedClass);
}
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Method")]
// [System.ComponentModel.Editor("This", "That")]
// public void MyMethod([System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] string blah, [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=false)] int[] arrayit) {
// }
AddScenario ("CheckMyMethodAttributes", "Check that attributes are generated properly on MyMethod().");
CodeMemberMethod method1 = new CodeMemberMethod ();
method1.Attributes = (method1.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
method1.Name = "MyMethod";
method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Method"))));
method1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.ComponentModel.Editor", new
CodeAttributeArgument (new CodePrimitiveExpression ("This")), new CodeAttributeArgument (new
CodePrimitiveExpression ("That"))));
CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression (typeof (string), "blah");
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
AddScenario ("CheckParameterAttributes", "Check that parameter attributes are generated properly.");
param1.CustomAttributes.Add (
new CodeAttributeDeclaration (
"System.Xml.Serialization.XmlElement",
new CodeAttributeArgument (
"Form",
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument (
"IsNullable",
new CodePrimitiveExpression (false))));
}
method1.Parameters.Add (param1);
CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression (typeof (int[]), "arrayit");
if (Supports (provider, GeneratorSupport.ParameterAttributes)) {
param2.CustomAttributes.Add (
new CodeAttributeDeclaration (
"System.Xml.Serialization.XmlElement",
new CodeAttributeArgument (
"Form",
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression ("System.Xml.Schema.XmlSchemaForm"), "Unqualified")),
new CodeAttributeArgument (
"IsNullable",
new CodePrimitiveExpression (false))));
}
//param2.CustomAttributes.Add(new CodeAttributeDeclaration("System.ParamArray"));
method1.Parameters.Add (param2);
class1.Members.Add (method1);
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Function")]
// [return: System.Xml.Serialization.XmlIgnoreAttribute()]
// [return: System.Xml.Serialization.XmlRootAttribute(Namespace="Namespace Value", ElementName="Root, hehehe")]
// public string MyFunction() {
// return "Return";
// }
//
if (Supports (provider, GeneratorSupport.ReturnTypeAttributes)) {
AddScenario ("CheckMyFunctionAttributes", "Check return type attributes.");
CodeMemberMethod function1 = new CodeMemberMethod ();
function1.Attributes = MemberAttributes.Public;
function1.Name = "MyFunction";
function1.ReturnType = new CodeTypeReference (typeof (string));
function1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Function"))));
function1.ReturnTypeCustomAttributes.Add (new
CodeAttributeDeclaration ("System.Xml.Serialization.XmlIgnoreAttribute"));
function1.ReturnTypeCustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlRootAttribute", new
CodeAttributeArgument ("Namespace", new CodePrimitiveExpression ("Namespace Value")), new
CodeAttributeArgument ("ElementName", new CodePrimitiveExpression ("Root, hehehe"))));
function1.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression ("Return")));
class1.Members.Add (function1);
}
// GENERATES (C#):
// [System.Xml.Serialization.XmlElementAttribute()]
// private string myField = "hi!";
//
AddScenario ("CheckMyFieldAttributes", "Check that attributes are generated properly on MyField.");
CodeMemberField field1 = new CodeMemberField ();
field1.Name = "myField";
field1.Attributes = MemberAttributes.Public;
field1.Type = new CodeTypeReference (typeof (string));
field1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlElementAttribute"));
field1.InitExpression = new CodePrimitiveExpression ("hi!");
class1.Members.Add (field1);
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Property")]
// public string MyProperty {
// get {
// return this.myField;
// }
// }
AddScenario ("CheckMyPropertyAttributes", "Check that attributes are generated properly on MyProperty.");
CodeMemberProperty prop1 = new CodeMemberProperty ();
prop1.Attributes = MemberAttributes.Public;
prop1.Name = "MyProperty";
prop1.Type = new CodeTypeReference (typeof (string));
prop1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Property"))));
prop1.GetStatements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "myField")));
class1.Members.Add (prop1);
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Constructor")]
// public MyClass() {
// }
if (!(provider is JScriptCodeProvider))
AddScenario ("CheckConstructorAttributes", "Check that attributes are generated properly on the constructor.");
CodeConstructor const1 = new CodeConstructor ();
const1.Attributes = MemberAttributes.Public;
const1.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Constructor"))));
class1.Members.Add (const1);
// GENERATES (C#):
// [System.Obsolete("Don\'t use this Constructor")]
// static MyClass() {
// }
if (Supports (provider, GeneratorSupport.StaticConstructors)) {
// C#, VB and JScript code providers don't generate this properly. This will
// be fixed in Beta2 (with the exception of JScript code provider. JScript doesn't
// support static constructor custom attributes)
//if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) {
AddScenario ("CheckStaticConstructorAttributes", "Check that attributes are generated properly on type constructors.");
//}
CodeTypeConstructor typecons = new CodeTypeConstructor ();
typecons.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this Constructor"))));
class1.Members.Add (typecons);
}
// GENERATES (C#):
// [System.Obsolete ("Don\'t use this entry point")]
// public static void Main () {
// }
if (Supports (provider, GeneratorSupport.EntryPointMethod)) {
// C#, VB and JScript code providers don't generate this properly. This will
// be fixed in Beta2 (with the exception of JScript code provider. JScript doesn't
// support static constructor custom attributes)
///if (!(provider is CSharpCodeProvider) && !(provider is VBCodeProvider) && !(provider is JScriptCodeProvider)) {
AddScenario ("CheckEntryPointMethodAttributes", "Check that attributes are generated properly on entry point methods.");
//}
CodeEntryPointMethod entpoint = new CodeEntryPointMethod ();
entpoint.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this entry point"))));
class1.Members.Add (entpoint);
}
if (Supports (provider, GeneratorSupport.DeclareDelegates)) {
AddScenario ("CheckDelegateAttributes");
CodeTypeDelegate del = new CodeTypeDelegate ("MyDelegate");
del.TypeAttributes = TypeAttributes.Public;
del.CustomAttributes.Add (new CodeAttributeDeclaration ("System.Obsolete", new
CodeAttributeArgument (new CodePrimitiveExpression ("Don't use this delegate"))));
ns.Types.Add (del);
}
if (Supports (provider, GeneratorSupport.DeclareEvents)) {
// GENERATES (C#):
// public class Test : Form {
//
// private Button b = new Button();
//
//
AddScenario ("CheckEventAttributes", "test attributes on an event");
class1 = new CodeTypeDeclaration ("Test");
class1.IsClass = true;
class1.BaseTypes.Add (new CodeTypeReference ("Form"));
ns.Types.Add (class1);
CodeMemberField mfield = new CodeMemberField (new CodeTypeReference ("Button"), "b");
mfield.InitExpression = new CodeObjectCreateExpression (new CodeTypeReference ("Button"));
class1.Members.Add (mfield);
// GENERATES (C#):
// public Test() {
// this.Size = new Size(600, 600);
// b.Text = "Test";
// b.TabIndex = 0;
// b.Location = new Point(400, 525);
// this.MyEvent += new EventHandler(this.b_Click);
// }
//
CodeConstructor ctor = new CodeConstructor ();
ctor.Attributes = MemberAttributes.Public;
ctor.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression (new CodeThisReferenceExpression (),
"Size"), new CodeObjectCreateExpression (new CodeTypeReference ("Size"),
new CodePrimitiveExpression (600), new CodePrimitiveExpression (600))));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Text"), new CodePrimitiveExpression ("Test")));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"TabIndex"), new CodePrimitiveExpression (0)));
ctor.Statements.Add (new CodeAssignStatement (new CodePropertyReferenceExpression (new CodeFieldReferenceExpression (null, "b"),
"Location"), new CodeObjectCreateExpression (new CodeTypeReference ("Point"),
new CodePrimitiveExpression (400), new CodePrimitiveExpression (525))));
ctor.Statements.Add (new CodeAttachEventStatement (new CodeEventReferenceExpression (new
CodeThisReferenceExpression (), "MyEvent"), new CodeDelegateCreateExpression (new CodeTypeReference ("EventHandler")
, new CodeThisReferenceExpression (), "b_Click")));
class1.Members.Add (ctor);
// GENERATES (C#):
// [System.CLSCompliantAttribute(false)]
// public event System.EventHandler MyEvent;
CodeMemberEvent evt = new CodeMemberEvent ();
evt.Name = "MyEvent";
evt.Type = new CodeTypeReference ("System.EventHandler");
evt.Attributes = MemberAttributes.Public;
evt.CustomAttributes.Add (new CodeAttributeDeclaration ("System.CLSCompliantAttribute", new CodeAttributeArgument (new CodePrimitiveExpression (false))));
class1.Members.Add (evt);
// GENERATES (C#):
// private void b_Click(object sender, System.EventArgs e) {
// }
// }
// }
//
CodeMemberMethod cmm = new CodeMemberMethod ();
cmm.Name = "b_Click";
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
cmm.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
class1.Members.Add (cmm);
}
}
