static void Main2()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(string), (int i) => "Print",
Emit.@if((int i) => i < 10,
Emit.@return(() => "i less than 10")
),
Emit.@return(() => "i greater than 10")
);
Console.WriteLine(c.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.CSharp));
var c2 = new CodeDomGenerator();
CodeMemberMethod method = Define.Method(MemberAttributes.Public, () => "foo");
c2.AddNamespace("TestNS").AddClass("Fibonacci")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (int x) => "Calc",
Emit.@if((int x) => x <= 1,
Emit.@return(() => 1)),
Emit.@return((int x) =>
CodeDom.Call <int>("Calc")(x - 1) + CodeDom.Call <int>("Calc")(x - 2))
)
;
Console.WriteLine(c2.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.CSharp));
Console.WriteLine(c2.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.VB));
}
private CodeCompileUnit[] GetCompileUnits()
{
var compileUnits = new List <CodeCompileUnit>();
foreach (var source in _sources)
{
var parser = new CodeParser(source);
var ast = parser.Parse();
if (parser.Errors.Any()) //antlr parse errors
{
Errors.AddRange(parser.Errors);
}
if (!Errors.Any())
{
var generator = new CodeDomGenerator(ast);
compileUnits.Add(generator.Generate());
if (generator.Errors.Any()) //Semantic erros
{
Errors.AddRange(generator.Errors);
}
}
}
return(compileUnits.ToArray());
}
public void TestPartialMethodsVB()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("ee", TypeAttributes.Public, true)
.AddMember(new CodePartialMethod(Define.Method(MemberAttributes.Public,
() => "foo"
)))
//.AddMember(new CodePartialMethod(Define.Method(MemberAttributes.Public, typeof(string),
// () => "foo2"
//)))
)
.AddClass(Define.Class("ee", TypeAttributes.Public, true)
.AddMember(new CodePartialMethod(Define.Method(MemberAttributes.Public,
() => "foo", Emit.stmt(() => Console.WriteLine())
)))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile(null, CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
public void InstanceDelegate()
{
var c = new CodeDomGenerator();
c.AddReference("System.Core.dll").AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, typeof(string), () => "foo", Emit.declare("h2", () => new Func <string>("aaa".ToString)), Emit.@return((Func <string> h2) => h2()))
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
string s = (string)TestClass.InvokeMember("foo",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.InvokeMethod,
null, null, null);
Assert.AreEqual("aaa", s);
}
public void Builder_Operator()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("ee")
.AddOperators(
Define.Operator(new CodeTypeReference(typeof(int)),
(DynType t) => CodeDom.TypedSeq(OperatorType.Implicit, t.SetType("ee")),
Emit.@return(() => 10)
)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
public void ArrayCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare(typeof(int[]), "d"),
Emit.declare("d2", () => new int[] { 1, 2, 3 }),
Emit.assignVar("d", () => new int[] { 3, 4 }),
Emit.declare("d3", (int[] d) => d[0]),
Emit.declare("d4", () => new int[10])
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
private SyntaxTree[] CodeGenCore()
{
var treeList = new List <SyntaxTree>();
foreach (var source in _sources)
{
var parser = new Parser.CodeParser(source);
var ast = parser.Parse();
if (parser.Errors.Any()) //antlr parse errors
{
Errors.AddRange(parser.Errors);
}
if (!Errors.Any())
{
var generator = new CodeDomGenerator(ast);
var unit = generator.Generate();
if (generator.Errors.Any()) //Semantic erros
{
Errors.AddRange(generator.Errors);
}
else
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(ToCSharpSource(unit));
treeList.Add(tree);
}
}
}
return(treeList.ToArray());
}
public void TestReadonlyField()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("ee", TypeAttributes.Public)
.AddMember(Define.ReadOnlyField(MemberAttributes.Family, new CodeTypeReference(typeof(int)), "fld1"))
.AddMember(Define.ReadOnlyField(MemberAttributes.Private | MemberAttributes.Static, new CodeTypeReference(typeof(int)), "fld2"))
.AddMember(Define.Const(MemberAttributes.Private, "cns1", () => 1))
.AddMember(Define.Const(MemberAttributes.Public, "cns2", () => "hi!"))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile(null, CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
ass = c.Compile(null, CodeDomGenerator.Language.CSharp);
Assert.IsNotNull(ass);
eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
static void Main()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("TestClass")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (int a) => "Print",
Emit.stmt(() => Console.WriteLine("Hello, world!")),
Emit.stmt((int a) => Console.WriteLine(a)),
Emit.@if((int a) => a == 10,
Emit.stmt(() => Console.WriteLine("a equals 10")))
//Builder.ifelse((Par<int> a) => a.GetHashCode() == 10 && a < 1 && (2 + 3) < 7,
// Builder.GetStmts(Builder.stmt(() => Console.WriteLine("true"))),
// Builder.stmt(() => Console.WriteLine("false")))
);
Console.WriteLine(c.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.VB));
var method = c.Compile().GetType("Samples.TestClass").GetMethod("Print");
Console.WriteLine("Program is compiled and prints");
Console.WriteLine("-----------------------------");
method.Invoke(null, new object[] { 10 });
}
public void TestSwitch()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, (int i) => "foo",
Emit.@switch((int i) => i)
.Case(1,
Emit.stmt(() => Console.WriteLine("1")),
Emit.exitSwitch()
)
.Case(2,
Emit.stmt(() => Console.WriteLine("2")),
Emit.exitSwitch()
)
.CaseElse(
Emit.stmt((int i) => Console.WriteLine(i)),
Emit.exitSwitch()
)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestRequireVariableDeclaration()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.assignVar("i", () => 1)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNull(ass);
c.RequireVariableDeclaration = false;
ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestLock()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, (System.IO.MemoryStream ms) => "foo",
Emit.@lock((System.IO.MemoryStream ms) => ms,
Emit.stmt(() => Console.WriteLine("using"))
)
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "zoo",
Emit.@lock(() => string.Intern("asdflaskj"),
Emit.stmt(() => Console.WriteLine("using"))
)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestBreak()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, (System.IO.MemoryStream ms) => "foo",
Emit.@foreach("ch", () => "afdgfad".ToCharArray(),
Emit.stmt((char ch) => Console.WriteLine(ch)),
Emit.exitFor()
)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("continue;");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Continue For");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void TestAssignIndexer()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("b", () => new int[10]),
Emit.assignExp((int[] b) => b[0], CodeDom.GetExpression(() => 1)),
Emit.declare("a", () => new List <int>()),
Emit.assignExp((List <int> a) => a[0], CodeDom.GetExpression(() => 1))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
ass = c.Compile();
Assert.IsNotNull(ass);
TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
if (_csStatement != null)
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_csStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
if (_vbStatement != null)
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromStatement(_vbStatement, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void DefaultExpression()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.stmt(() => CodeDom.Call(CodeDom.TypeRef("cls"), "zoo")(default(int)))
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Private, (int i) => "zoo",
Emit.stmt((int i) => Console.WriteLine(i))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestAllowLateBound()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.declare(typeof(object), "a", () => new List <int>()),
Emit.stmt((List <int> a) => a.ToArray())
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
c.AllowLateBound = false;
ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNull(ass);
}
public void TestPropertyInterface()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass(Define.Class("ee", TypeAttributes.Public, true).Implements(new CodeTypeReference("Ixxx"))
.AddMember(Define.Property(new CodeTypeReference(typeof(string)), MemberAttributes.Public,
"prop",
new CodeStatement[] { Emit.@return(() => "sdfsf") },
new CodeStatement[] { Emit.assignVar("value", () => "sadfaf") }
).Implements(new CodeTypeReference("Ixxx"), "dsf"))
).AddInterface(Define.Interface("Ixxx")
.AddProperty(new CodeTypeReference(typeof(string)), MemberAttributes.Public, "dsf")
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile(null, CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
ass = c.Compile(null, CodeDomGenerator.Language.CSharp);
Assert.IsNotNull(ass);
}
public void TestVarVariable()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.declareVar("a", () => 1),
Emit.declareVar("b", () => "gfdsgf")
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestLambdaVB()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (bool f) => "foo",
Emit.declare("a", () => CodeDom.Lambda(() => 1)),
Emit.declare("c", () => CodeDom.Lambda((int aa) => aa + 10,
new LambdaParam(typeof(int), "aa"))),
Emit.stmt((int a) => CodeDom.CallDelegate(CodeDom.VarRef("c").Call("Compile"))(
CodeDom.CallDelegate(CodeDom.VarRef("a").Call("Compile"))
))
)
;
c.AddReference("System.Core.dll");
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void Builder_GetProperty()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("TestClass")
.AddGetProperty(typeof(int), MemberAttributes.Public, "Test",
Emit.@return(() => 100)
)
.AddMethod(MemberAttributes.Public, typeof(int), (int a) => "Test1", Emit.@return((int a) =>
a + [email protected] <int>("Test")))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
object t = TestClass.InvokeMember(null, System.Reflection.BindingFlags.CreateInstance, null, null, null);
Assert.IsNotNull(t);
Assert.AreEqual(104, TestClass.InvokeMember("Test1", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.InvokeMethod, null, t,
new object[] { 4 }));
}
public void TestAnonymousMethod()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("a", () => CodeDom.Lambda <Func <int, double> >(new [] { new LambdaParam("s") },
Emit.@return((double s) => s + 1)
))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
c.AddReference("System.Core.dll");
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void Builder_AccessProperty()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls1")
.AddField(typeof(int), "_i", () => 10)
.AddProperty(typeof(int), MemberAttributes.Public, "I", "_i")
.AddClass("cls2")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(int), () => "foo",
Emit.declare("cls1", "cc", () => CodeDom.@new("cls1")),
Emit.@return((Var cc) => cc.Property <int>("I")))
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls2");
Assert.IsNotNull(TestClass);
int s = (int)TestClass.InvokeMember("foo",
BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod,
null, null, null);
Assert.AreEqual(10, s);
}
public void ParamArrayTest()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public,
(ParamArray <int> i) => "foo",
Emit.declare("j", () => "zzz")
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Public,
(ParamArray <int[]> i) => "foo2",
Emit.declare("js", () => "zzz")
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type cls = ass.GetType("Samples.cls");
Assert.IsNotNull(cls);
}
public void Builder_Struct()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddStruct(Define.Struct("xxx")
.AddField(typeof(bool), "_x")
.AddField(typeof(int), "_y")
.AddCtor((bool x) => MemberAttributes.Public,
Emit.assignField("_x", (bool x) => x),
Emit.assignField("_y", () => 100)
)
.AddGetProperty(typeof(int), MemberAttributes.Public, "Z", "_y")
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.xxx");
Assert.IsNotNull(TestClass);
object t = TestClass.InvokeMember(null, BindingFlags.CreateInstance, null, null,
new object[] { false });
Assert.IsNotNull(t);
Assert.AreEqual(100, TestClass.InvokeMember("Z", BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty, null, t, null));
}
public void WorkingWithEvent()
{
var c = new CodeDomGenerator();
c.AddReference("System.Core.dll").AddNamespace("Samples").AddClass("cls")
.AddEvent(typeof(Action), MemberAttributes.Public, "ev")
.AddMethod(MemberAttributes.Public, () => "raise",
Emit.declare("cls2", "cc", () => CodeDom.@new("cls2")),
Emit.attachDelegate(CodeDom.@this, "ev", CodeDom.VarRef("cc"), "zoo"),
Emit.attachDelegate(CodeDom.@this, "ev", "cls2.foo"),
Emit.stmt(() => [email protected]("ev")()),
Emit.detachDelegate(CodeDom.@this, "ev", CodeDom.VarRef("cc"), "zoo")
)
.AddClass("cls2")
.AddMethod(MemberAttributes.Public, () => "zoo",
Emit.stmt(() => Console.WriteLine("ok"))
)
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.stmt(() => Console.WriteLine("ok"))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type cls = ass.GetType("Samples.cls");
Assert.IsNotNull(cls);
}
public void TestDefaultProperty()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("ee", TypeAttributes.Public, true)
.AddMember(Define.GetProperty(new CodeTypeReference(typeof(string)), MemberAttributes.Family,
(int idx) => "prop", true,
Emit.@return((int idx) => idx.ToString())
))
.AddMember(Define.Property(new CodeTypeReference(typeof(string)), MemberAttributes.Family,
(int idx) => "prop2", false,
CodeDom.CombineStmts(Emit.@return((int idx) => idx.ToString())),
Emit.declare("i", (int idx) => idx)
))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile(null, CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
public void CastExpression()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public, () => "foo",
Emit.declare(typeof(object), "d"),
Emit.assignVar("d", () => 10d),
Emit.declare("dr", (object d) => (decimal)d),
Emit.declare("dr2", (object d) => CodeDom.cast(typeof(decimal), d)),
Emit.stmt((object d) => CodeDom.cast <Var>("cls", d).Call("foo"))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("var {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
tw.Write(";");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Dim {0} = ", provider.CreateEscapedIdentifier(VariableName));
provider.GenerateCodeFromExpression(InitExpression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenericObjectCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass(Define.Class("TestClass").Generic("T")
.AddFields(
Define.Field(MemberAttributes.Private, "T", "_s")
)
.AddProperty("T", MemberAttributes.Public, "S", "_s")
).AddClass(Define.Class("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, CodeDom.TypeRef("TestClass", "T"), () => "foo",
Emit.declare(CodeDom.TypeRef("TestClass", "T"), "cc",
() => CodeDom.@new(CodeDom.TypeRef("TestClass", "T"))),
Emit.@return((Var cc) => cc))
.Generic("T")
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass`1");
Assert.IsNotNull(TestClass);
}
public void ObjectCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("TestClass")
.AddFields(
Define.Field(MemberAttributes.Private, typeof(string), "_s"),
Define.Field(MemberAttributes.Private, typeof(int), "_i")
)
.AddCtor(
Define.Ctor((int i, string s) => MemberAttributes.Public,
Emit.assignField("_s", (string s) => s),
Emit.assignField("_i", (int i) => i)
)
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, "TestClass", () => "Create", Emit.@return(() => CodeDom.@new("TestClass", 100, "yyy")))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
}
public void StaticDelegate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public,
() => "foo",
Emit.declare(typeof(EventHandler), "h"),
Emit.assignDelegate("h", "zoo"),
Emit.stmt((Var h) => h.Call()(null, null))
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Private, (object sender, EventArgs args) => "zoo")
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("foreach (");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" {0} in ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine(")");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("For Each {0} As ", provider.CreateValidIdentifier(IterationItemName));
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(IterationItemType), tw, opts);
tw.Write(" in ");
provider.GenerateCodeFromExpression(IterExpression, tw, opts);
tw.WriteLine();
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("Next");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.WriteLine("do");
tw.WriteLine("{");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.Write("} while (");
if (TestExpression != null)
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
tw.WriteLine(");");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.WriteLine("Do");
tw.Indent++;
if (Statements != null)
foreach (CodeStatement statement in Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.Write("Loop Until ");
if (TestExpression != null)
provider.GenerateCodeFromExpression(TestExpression, tw, opts);
tw.WriteLine();
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
GenerateCS();
break;
case CodeDomGenerator.Language.VB:
GenerateVB();
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("new ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference.ArrayElementType), tw, opts);
tw.Write("[");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
tw.Write(",");
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
}
tw.Write("]");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("(");
for (int i = 0; i < Dimensions.Count; i++)
{
if (i > 0)
tw.Write(",");
tw.Write("(");
provider.GenerateCodeFromExpression(Dimensions[i], tw, opts);
tw.Write(")-1");
}
tw.Write(") as ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(TypeReference), tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
if (!_eq)
{
tw.Write("!");
}
tw.Write("ReferenceEquals(");
provider.GenerateCodeFromExpression(_left, tw, opts);
tw.Write(", ");
provider.GenerateCodeFromExpression(_right, tw, opts);
tw.Write(")");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(_left, tw, opts);
if (_eq)
tw.Write(" Is ");
else
tw.Write(" IsNot ");
provider.GenerateCodeFromExpression(_right, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(Parameter, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
StringBuilder sb = new StringBuilder();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromExpression(Parameter, tw, opts);
switch (Option)
{
case ParamOption.Optional:
sb.Replace("ByVal " + Parameter.Name, "Optional ByVal " + Parameter.Name);
break;
case ParamOption.ParamArray:
sb.Replace("ByVal " + Parameter.Name, "ByVal ParamArray " + Parameter.Name);
break;
default:
throw new NotSupportedException(Option.ToString());
}
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
if (_method == null)
return;
if (_method.ReturnType != null && _method.ReturnType.BaseType != "System.Void")
throw new NotSupportedException("Partial methods must have a void return type");
switch (language)
{
case CodeDomGenerator.Language.CSharp:
GenerateCS();
break;
case CodeDomGenerator.Language.VB:
GenerateVB();
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(_condition, tw, opts);
tw.Write("?");
provider.GenerateCodeFromExpression(_truePart, tw, opts);
tw.Write(":");
provider.GenerateCodeFromExpression(_falsePart, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("If(");
provider.GenerateCodeFromExpression(_condition, tw, opts);
tw.Write(",");
provider.GenerateCodeFromExpression(_truePart, tw, opts);
tw.Write(",");
provider.GenerateCodeFromExpression(_falsePart, tw, opts);
tw.Write(")");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
//CodeDomProvider _provider;
public CustomCodeGenerator(CodeDomGenerator.Language lang)
{
_lang = lang;
}
public void GenerateCode(CodeDomGenerator.Language language)
{
if (m_parameters == null || m_statements == null || m_returnType == null)
return;
switch (language)
{
case CodeDomGenerator.Language.CSharp:
GenerateCS();
break;
case CodeDomGenerator.Language.VB:
GenerateVB();
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
if (_left == null) return;
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(_left, tw, opts);
if (_right != null)
{
tw.Write(_separator);
provider.GenerateCodeFromExpression(_right, tw, opts);
}
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
provider.GenerateCodeFromExpression(_left, tw, opts);
if (_right != null)
{
tw.Write(_separator);
provider.GenerateCodeFromExpression(_right, tw, opts);
}
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("switch (");
if (SwitchExpression != null)
provider.GenerateCodeFromExpression(SwitchExpression, tw, opts);
tw.WriteLine(")");
tw.WriteLine("{");
tw.Indent++;
foreach (CaseBlock c in m_cases)
{
if (c.Statements != null)
{
if (c.CaseExpression != null)
{
tw.Write("case ");
provider.GenerateCodeFromExpression(c.CaseExpression, tw, opts);
tw.WriteLine(":");
}
else
{
tw.WriteLine("default:");
}
tw.Indent++;
foreach (CodeStatement stmt in c.Statements)
{
provider.GenerateCodeFromStatement(stmt, tw, opts);
}
tw.Indent--;
}
//else
//{
// tw.Indent++;
// tw.WriteLine("break;");
// tw.Indent--;
//}
}
tw.Indent--;
tw.WriteLine("}");
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Select Case ");
if (SwitchExpression != null)
provider.GenerateCodeFromExpression(SwitchExpression, tw, opts);
tw.WriteLine();
tw.Indent++;
foreach (CaseBlock c in m_cases)
{
if (c.Statements != null)
{
if (c.CaseExpression != null)
{
tw.Write("Case ");
provider.GenerateCodeFromExpression(c.CaseExpression, tw, opts);
tw.WriteLine();
}
else
{
tw.WriteLine("Case Else");
}
tw.Indent++;
for (int i = 0; i < c.Statements.Length; i++)
{
CodeStatement stmt = c.Statements[i];
if (!(stmt is CodeExitSelectStatement) || i < c.Statements.Length-1)
provider.GenerateCodeFromStatement(stmt, tw, opts);
}
tw.Indent--;
}
//else if (i < m_cases.Count - 1)
//{
// tw.Indent++;
// tw.WriteLine("Exit Select");
// tw.Indent--;
//}
}
tw.Indent--;
tw.WriteLine("End Select");
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
if (_params.Count != 1 || _params[0].Type != null)
tw.Write("(");
for (int i = 0; i < _params.Count; i++)
{
if (i > 0)
tw.Write(", ");
if (_params[i].Type != null)
{
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(_params[i].Type), tw, opts);
tw.Write(" ");
}
tw.Write(_params[i].Name);
}
if (_params.Count != 1 || _params[0].Type != null)
tw.Write(")");
tw.Write(" => ");
provider.GenerateCodeFromExpression(Expression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions();
using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString))
{
tw.Write("Function(");
for (int i = 0; i < _params.Count; i++)
{
if (i > 0)
tw.Write(", ");
tw.Write(_params[i].Name);
if (_params[i].Type != null)
{
tw.Write(" As ");
provider.GenerateCodeFromExpression(new CodeTypeReferenceExpression(_params[i].Type), tw, opts);
}
}
tw.Write(") ");
provider.GenerateCodeFromExpression(Expression, tw, opts);
Value = tw.InnerWriter.ToString();
}
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
public void GenerateCode(CodeDomGenerator.Language language)
{
switch (language)
{
case CodeDomGenerator.Language.CSharp:
using (CSharpCodeProvider provider = new CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringBuilder sb = new StringBuilder();
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromMember(Event, tw, opts);
sb.Replace(";",string.Empty);
tw.WriteLine("{");
tw.Indent++;
GenrateMeth(opts, provider, tw, AddMethod.GetStatements, "add");
GenrateMeth(opts, provider, tw, RemoveMethod.GetStatements, "remove");
tw.Indent--;
tw.WriteLine("}");
}
Text = sb.ToString();
}
break;
case CodeDomGenerator.Language.VB:
using (Microsoft.VisualBasic.VBCodeProvider provider = new Microsoft.VisualBasic.VBCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
var args = new StringWriter();
provider.GenerateCodeFromExpression(new CodeParameterDeclarationExpression(Event.Type, "value"), args, opts);
StringBuilder sb = new StringBuilder();
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter(sb), opts.IndentString))
{
provider.GenerateCodeFromMember(Event, tw, opts);
sb.Replace(" Event ", " Custom Event ");
tw.Indent++;
tw.WriteLine("AddHandler({0})", args.GetStringBuilder());
tw.Indent++;
foreach (CodeStatement statement in AddMethod.GetStatements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("End AddHandler");
tw.WriteLine("RemoveHandler({0})", args.GetStringBuilder());
tw.Indent++;
foreach (CodeStatement statement in RemoveMethod.GetStatements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("End RemoveHandler");
//args = new StringWriter();
//provider.GenerateCodeFromMember(RaiseMethod, args, opts);
//StringReader sr = new StringReader(args.GetStringBuilder().ToString());
//string line = sr.ReadLine();
//while (string.IsNullOrEmpty(line))
// line = sr.ReadLine();
//int idx = line.IndexOf(" " + RaiseMethod.Name);
//args.GetStringBuilder().Replace(line, "RaiseEvent" + line.Substring(idx + RaiseMethod.Name.Length + 1));
//tw.Write(args.GetStringBuilder().ToString());
tw.Write("RaiseEvent(");
for (int i = 0; i < RaiseMethod.Parameters.Count;i++)
{
if (i > 0)
tw.Write(", ");
provider.GenerateCodeFromExpression(RaiseMethod.Parameters[i], tw, opts);
}
tw.WriteLine(")");
tw.Indent++;
foreach (CodeStatement statement in RaiseMethod.Statements)
{
provider.GenerateCodeFromStatement(statement, tw, opts);
}
tw.Indent--;
tw.WriteLine("End RaiseEvent");
tw.Indent--;
tw.WriteLine("End Event");
}
Text = sb.ToString();
}
break;
default:
throw new NotImplementedException(language.ToString());
}
}
