On Mon, 2002-06-03 at 13:21, Miguel de Icaza wrote:
>
> Thanks for the good news. I did not realize that we were so close to
> have CodeDOM complete, I should add a news item to the web page.
ok, demo. nonsensical example attached.
build this on windows against the ms runtime with mono's
CSharpCodegenerator pulled in statically, i.e as follows:
csc testcodedom4.cs `cygpath -w
<mono_root>/mcs/class/System/Microsoft.CSharp/CSharpCodeGenerator.cs`
on windows, it allows for switching between
mono::csharpcodegenerator and
the original microsoft.csharp.* codegenerator implementation:
$ testcodedom4.cs [ms | mono]
i'm currently using this kind of stuff to spot differences.
works on linux, but of course won't make a difference there.
indentifying some of the bugs is left as an exercise :), but you get the
idea. so much to do, so little time...
regards,
dns
--
___________________________________________________________________________
mailto:[EMAIL PROTECTED]
namespace Test {
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Reflection;
using Microsoft.CSharp;
using Mono.CSharp;
public class TestCodeDom3
{
static void PopulateImports( object sender, EventArgs args )
{
CodeNamespace ns = (CodeNamespace)sender;
CodeNamespaceImportCollection imports = ns.Imports;
imports.Add( new CodeNamespaceImport( "System.Collections" ) );
imports.Add( new CodeNamespaceImport(
"System.Collections.Specialized" ) );
}
static void AddArrayTypes( CodeMemberMethod method )
{
CodeTypeReference type;
type = new CodeTypeReference( new CodeTypeReference(
"System.Int32", 3 ), 1 );
CodeArrayCreateExpression create = new
CodeArrayCreateExpression( type );
create.Size = 42;
create.Initializers.Add( new CodePrimitiveExpression( 1 ) );
method.Statements.Add( new CodeVariableDeclarationStatement(
type, "array1", create ) );
type = new CodeTypeReference( "System.Int32", 1 );
create = new CodeArrayCreateExpression( type );
method.Statements.Add( new CodeVariableDeclarationStatement(
type, "array2", create ) );
CodeTypeReference arrayType;
arrayType = new CodeTypeReference( "System.Int32", 2 );
type = new CodeTypeReference( arrayType, 1 );
create = new CodeArrayCreateExpression( type,
new CodeExpression[] {
new
CodeArrayCreateExpression( arrayType,
new CodeExpression[] {
new CodePrimitiveExpression( 1 )
} ),
new
CodeArrayCreateExpression( arrayType,
new CodeExpression[] {
new CodePrimitiveExpression( 2 )
} ),
new
CodeArrayCreateExpression( arrayType,
new CodeExpression[] {
new CodePrimitiveExpression( 3 )
} )
} );
create.Size = 3;
method.Statements.Add( new CodeVariableDeclarationStatement(
type, "array3", create ) );
arrayType = new CodeTypeReference( "System.Int32", 2 );
type = new CodeTypeReference( arrayType, 1 );
create = new CodeArrayCreateExpression( type, 2 );
method.Statements.Add( new CodeVariableDeclarationStatement(
type, "array4", create ) );
}
static void AddTryCatch( CodeMemberMethod method )
{
method.Statements.Add( new CodeTryCatchFinallyStatement( new
CodeStatement[] {
new CodeAssignStatement( new
CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "member" ),
new CodeBinaryOperatorExpression( new
CodeCastExpression( "System.Int64", new CodeVariableReferenceExpression( "param" ) ),
CodeBinaryOperatorType.Add,
new
CodePrimitiveExpression( 1 ) ) )
},
new CodeCatchClause[] {
new CodeCatchClause( "e",
new CodeTypeReference( "Exception" ),
new
CodeExpressionStatement(
new
CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(new CodeTypeReference(typeof(System.Console))),
"WriteLine",
new CodePrimitiveExpression("an \"error\" occurred.") ) ) )
},
new CodeStatement[] {
new CodeCommentStatement( "give up" )
} ) );
}
static void PopulateStatements( object sender, EventArgs args )
{
CodeMemberMethod method = (CodeMemberMethod)sender;
AddArrayTypes( method );
AddTryCatch( method );
method.Statements.Add( new CodeExpressionStatement( new
CodeArrayIndexerExpression( new CodeBaseReferenceExpression(),
new CodeExpression[] {
new CodePrimitiveExpression( 10 ),
new CodeFieldReferenceExpression( new
CodeThisReferenceExpression(), "arrayindexer" )
} ) ) );
method.Statements.Add( new CodeExpressionStatement( new
CodeIndexerExpression( new CodeBaseReferenceExpression(),
new CodeExpression[] {
new CodePrimitiveExpression( 10 ),
new CodeFieldReferenceExpression( new
CodeThisReferenceExpression(), "indexer" )
} ) ) );
method.Statements.Add( new CodeExpressionStatement( new
CodeSnippetExpression( "this" ) ) );
method.Statements.Add( new CodeExpressionStatement( new
CodeSnippetExpression( "\"this\"" ) ) );
}
static void PopulateTypes( object sender, EventArgs args )
{
CodeNamespace ns = (CodeNamespace)sender;
CodeTypeDeclaration test = new CodeTypeDeclaration( "Test" );
#if false
test.TypeAttributes =
TypeAttributes.Public |
TypeAttributes.Sealed |
TypeAttributes.Abstract;
#endif
test.IsClass = true;
test.BaseTypes.Add( new CodeTypeReference(
typeof(System.Array) ) );
test.BaseTypes.Add( new CodeTypeReference(
typeof(System.Collections.ICollection) ) );
test.BaseTypes.Add( new CodeTypeReference(
"System.Collections.IEnumerable" ) );
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "GetEnumerator";
method.Parameters.Add( new CodeParameterDeclarationExpression(
new CodeTypeReference( typeof(System.Collections.ICollection) ), "collection" ) );
method.Parameters.Add( new CodeParameterDeclarationExpression(
"System.Int32", "value" ) );
CodeArrayCreateExpression array = new
CodeArrayCreateExpression( new CodeTypeReference( "System.Int32", 2 ) );
#if false
array.Initializers.Add( new CodePrimitiveExpression( 1 ) );
array.Initializers.Add( new CodePrimitiveExpression( 2 ) );
array.Initializers.Add( new CodePrimitiveExpression( 3 ) );
#endif
method.Statements.Add( array );
method.Statements.Add( new CodeConditionStatement( new
CodePrimitiveExpression( true ),
new
CodeStatement[] { new CodeAssignStatement( new CodeVariableReferenceExpression( "a" ),
new CodePrimitiveExpression( 10 ) ) },
new
CodeStatement[] { new CodeAssignStatement( new CodeVariableReferenceExpression( "b" ),
new CodePrimitiveExpression( "hello" ) ) } ) );
method.PrivateImplementationType = new CodeTypeReference(
"IEnumerable" );
method.Attributes = MemberAttributes.Final |
MemberAttributes.Static | MemberAttributes.Public;
method.CustomAttributes.Add( new CodeAttributeDeclaration(
"Flags" ) );
method.CustomAttributes.Add( new CodeAttributeDeclaration(
"Serializable" ) );
method.CustomAttributes.Add( new CodeAttributeDeclaration(
"SomeOtherAttribute",
new
CodeAttributeArgument( "name",
new CodeSnippetExpression( "value" ) ) ) );
test.Members.Add( method );
method = new CodeMemberMethod();
method.PopulateStatements += new EventHandler(
PopulateStatements );
method.Name = "MoveNext";
method.Attributes = MemberAttributes.Family;
method.CustomAttributes.Add( new CodeAttributeDeclaration(
"System.ComponentModel.ReadOnly", new CodeAttributeArgument( new
CodeSnippetExpression( "true" ) ) ) );
test.Members.Add( method );
ns.Types.Add( test );
}
static ICodeGenerator GetCodeGenerator( string argv0 )
{
CSharpCodeProvider provider;
ICodeGenerator codegen = null;
switch ( argv0 ) {
case "ms":
provider = new Microsoft.CSharp.CSharpCodeProvider();
codegen = provider.CreateGenerator();
break;
case "mono":
codegen = new Mono.CSharp.CSharpCodeGenerator();
break;
default:
Console.WriteLine( "either 'ms' or 'mono'" );
break;
}
return codegen;
}
static void GenCode( CodeCompileUnit unit, string argv0 )
{
ICodeGenerator codegen = GetCodeGenerator( argv0 );
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
options.ElseOnClosing = true;
options.BracingStyle = "C";
codegen.GenerateCodeFromCompileUnit( unit, Console.Out,
options );
}
static void Main( string[] argv )
{
CodeCompileUnit unit = new CodeCompileUnit();
unit.AssemblyCustomAttributes.Add( new
CodeAttributeDeclaration( "AssemblyAttribute",
new CodeAttributeArgument[] {
new CodeAttributeArgument( "name", new CodePrimitiveExpression( "value" ) )
} ) );
unit.ReferencedAssemblies.Add( "XXXXXXXXXXXXXXXXXXXXXXXXX" );
CodeNamespaceCollection namespaces = unit.Namespaces;
CodeNamespace ns;
ns = new CodeNamespace( "System" );
namespaces.Add( ns );
ns.PopulateImports += new EventHandler( PopulateImports );
ns = new CodeNamespace( "CodeDom.Test" );
namespaces.Add( ns );
ns.Comments.Add( new CodeCommentStatement( "This program is
complete rubbish and only used for Testing System.CodeDom " +
"and
System.CodeDom.Compiler implementatations.", true ) );
ns.PopulateImports += new EventHandler( PopulateImports );
ns.PopulateTypes += new EventHandler( PopulateTypes );
GenCode( unit, argv[0] );
}
}
}
