static string ToCode (Action<CSharpWriter> writer)
{
var @string = new StringWriter ();
var csharp = new CSharpWriter (new TextFormatter (@string));
writer (csharp);
return @string.ToString ();
}
public void LanguageWriterTypeSourceTest()
{
ILanguageWriter writer = new CSharpWriter();
string s;
Type type;
type = typeof(double[][, ]);
s = writer.TypeSource(CodeBuilder.Instance.TypeRef(type));
Assert.Equal("double[][,]", s);
type = typeof(KeyValuePair <double[, ][], double[][, ]>[][, ]);
s = writer.TypeSource(CodeBuilder.Instance.TypeRef(type));
Assert.Equal("KeyValuePair<double[,][],double[][,]>[][,]", s);
}
public void InterfaceCheck()
{
var tmpProject = new ProjectInformation();
var tmpClass = Create.AddClass("IAttribute");
tmpClass.ModifierList.Add("public");
tmpClass.ModifierList.Add("interface");
tmpProject.ClassList.Add(tmpClass);
new AnalyzerCore().LinkProjectInformation(tmpProject);
var tmpObjectInformation = CSharpWriter.CreateClassesFromObjectInformation(tmpProject, new ConverterBase()).ToList();
Assert.AreEqual(1, tmpObjectInformation.Count);
Assert.AreEqual(true, tmpObjectInformation[0].Content.Contains("public interface IAttribute"));
}
public static void GenerateExterns(IEnumerable <Type> types, string className, string filePath)
{
CSharpWriter writer = new CSharpWriter();
writer.Write($"public static {className}");
using (new CSharpWriter.Scop(writer))
{
foreach (var type in types)
{
GenerateContextExtern(type, writer);
}
}
FileUtil.WriteFileWithCreateFolder(filePath, writer.ToString());
}
public override string ToCSharp(List <string> definedVariables, ConfigSettings settings)
{
using var writer = new StringWriter();
writer.Write("await ");
switch (RequestParams)
{
case StandardRequestParams x:
writer.Write("HttpRequestStandard(data, new StandardHttpRequestOptions { ");
writer.Write("Content = " + CSharpWriter.FromSetting(x.Content) + ", ");
writer.Write("ContentType = " + CSharpWriter.FromSetting(x.ContentType) + ", ");
break;
case RawRequestParams x:
writer.Write("HttpRequestRaw(data, new RawHttpRequestOptions { ");
writer.Write("Content = " + CSharpWriter.FromSetting(x.Content) + ", ");
writer.Write("ContentType = " + CSharpWriter.FromSetting(x.ContentType) + ", ");
break;
case BasicAuthRequestParams x:
writer.Write("HttpRequestBasicAuth(data, new BasicAuthHttpRequestOptions { ");
writer.Write("Username = "******", ");
writer.Write("Password = "******", ");
break;
case MultipartRequestParams x:
writer.Write("HttpRequestMultipart(data, new MultipartHttpRequestOptions { ");
writer.Write("Boundary = " + CSharpWriter.FromSetting(x.Boundary) + ", ");
writer.Write("Contents = " + SerializeMultipart(x.Contents) + ", ");
break;
}
writer.Write("Url = " + GetSettingValue("url") + ", ");
writer.Write("Method = " + GetSettingValue("method") + ", ");
writer.Write("AutoRedirect = " + GetSettingValue("autoRedirect") + ", ");
writer.Write("MaxNumberOfRedirects = " + GetSettingValue("maxNumberOfRedirects") + ", ");
writer.Write("UrlEncodeContent = " + GetSettingValue("urlEncodeContent") + ", ");
writer.Write("AbsoluteUriInFirstLine = " + GetSettingValue("absoluteUriInFirstLine") + ", ");
writer.Write("SecurityProtocol = " + GetSettingValue("securityProtocol") + ", ");
writer.Write("CustomCookies = " + GetSettingValue("customCookies") + ", ");
writer.Write("CustomHeaders = " + GetSettingValue("customHeaders") + ", ");
writer.Write("TimeoutMilliseconds = " + GetSettingValue("timeoutMilliseconds") + ", ");
writer.Write("HttpVersion = " + GetSettingValue("httpVersion") + ", ");
writer.Write("UseCustomCipherSuites = " + GetSettingValue("useCustomCipherSuites") + ", ");
writer.Write("CustomCipherSuites = " + GetSettingValue("customCipherSuites") + " ");
writer.WriteLine("}).ConfigureAwait(false);");
return(writer.ToString());
}
private void GenRemoveSystem(Type type, CSharpWriter writer, string className)
{
writer.Write($"private readonly {className}Context context;").NewLine();
writer.Write($"public {className}({context.Name}Context context)");
using (new CSharpWriter.Scop(writer))
{
writer.Write("this.context = context;");
}
writer.Write($"public void OnCleanup()");
using (new CSharpWriter.Scop(writer))
{
writer.Write($"context.RemoveAll<TComponent>();");
}
}
private void BuildTree(string stem, string content)
{
Environment.CurrentDirectory = DirRef.ProjectDir().Dir("Grammar");
var grammarSource = FileRef.From($"./{stem}.Grammar");
var dests = FileRef.From(grammarSource.Directory + "/Out/" + grammarSource.BaseName).With(".Out");
var raw = Parser.Parse(grammarSource);
if (raw != null)
{
var builder = new Build.GrammarBuilder(raw);
var grammar = builder.Build();
new Dumper(grammar).Dump(dests);
var ccOut = DirRef.ProjectDir().Dir("..").Dir("Lingu.CC").Dir("Gen");
var csharp = new CSharpWriter(grammar, grammarSource, ccOut);
csharp.Write();
Debug.Assert(grammar.Eof != null);
var dfaSet = new CompactDfaReader(new BinReader(new CompactDfaWriter(grammar).Write())).Read();
//var dfaSet = new DfaSet(grammar.Dfas.Select(dfa => dfa.Convert()).ToArray(), grammar.StateToDfa, grammar.SpacingDfa.Convert());
var context = new LinguContext(
grammar.Symbols,
grammar.Productions,
grammar.ParseTable,
dfaSet);
Source source;
if (File.Exists(content))
{
source = Source.FromFile(content);
}
else
{
source = Source.FromString(content);
}
var tree = context.Try(source);
new TreeDumper(dests.Add(".Tree")).Dump(tree);
}
}
internal void GenerateForClass(CSharpWriter stream, UmlAttributeNode attributeNode)
{
stream.WriteSummary(attributeNode.Documentation);
var visibility = CSharpHelper.ConvertVisibility(attributeNode.Visibility, true, true);
var attrType = CSharpHelper.ResolveType(attributeNode);
if (attributeNode.IsReadOnly)
{
stream.WriteCodeLine($"{visibility} {attrType} {attributeNode.Name} {{ get; private set; }}");
}
else
{
stream.WriteCodeLine($"{visibility} {attrType} {attributeNode.Name} {{ get; set; }}");
}
}
public void CheckMitableValueEquals()
{
var tmpObjectInformation = ProjectInformationHelper.DoFullRun(
ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader()
{
LoadDefaultData = true
},
EqualsString);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last();
Assert.AreEqual("MutableValue", tmpResult.FullName);
Assert.AreEqual(true, tmpResult.Content.Contains(" return ((GetType() == inOther.GetType()) && this.equalsSameType(inOther));"));
}
internal void GenerateForClass(CSharpWriter stream, UmlAssociationEndNode associationEndNode)
{
stream.WriteSummary(associationEndNode.Documentation);
var visibility = CSharpHelper.ConvertVisibility(associationEndNode.Visibility, true, true);
var opositeType = CSharpHelper.ResolveType(associationEndNode.OpositeEnd);
if (associationEndNode.IsReadOnly)
{
stream.WriteCodeLine($"{visibility} IEnumerable<{opositeType}> {associationEndNode.Name} {{ get; private set; }}");
}
else
{
stream.WriteCodeLine($"{visibility} IEnumerable<{opositeType}> {associationEndNode.Name} {{ get; set; }}");
}
}
public void DoubleGenericClassReplace()
{
var tmpObjectInformation = ProjectInformationHelper.DoFullRun(
ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader()
{
LoadDefaultData = true
},
DoubleReplacement);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last();
Assert.AreEqual("Bits", tmpResult.FullName);
Assert.AreEqual(CSharpResultDouble, tmpResult.Content);
}
public void IfWIthConstant()
{
var tmpIniData = DataHelper.LoadIni("");
var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> {
JavaClass
}, tmpIniData);
new AnalyzerCore().LinkProjectInformation(tmpObjectInformation);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp()).ToList();
Assert.AreEqual(1, tmpResult.Count);
Assert.AreEqual("Class1", tmpResult[0].FullName);
Assert.AreEqual(CSharpResult1, tmpResult[0].Content);
}
public void GenCode(CSharpWriter csw, string ns, string cls)
{
csw.Begin("namespace {0}", ns);
foreach (var rule in Rules)
{
rule.GenClassDefs(csw);
}
csw.Begin("public partial class {0}", cls);
foreach (var rule in Rules)
{
rule.GenParserMethods(csw);
}
csw.End();
csw.End();
}
public override void VisitTypeSpec(TypeSpec typeSpec, bool writeByRefModifier)
{
var stringWriter = new StringWriter();
var csharpWriter = new CSharpWriter(stringWriter);
csharpWriter.VisitTypeSpec(typeSpec, writeByRefModifier);
Writer.Write("<span class=\"typespec\" title=\"");
Writer.WriteEscaped(stringWriter.ToString());
Writer.Write("\">");
base.VisitTypeSpec(typeSpec, writeByRefModifier);
Writer.Write("</span>");
}
public void CheckMitableValueCompareTo()
{
var tmpObjectInformation = ProjectInformationHelper.DoFullRun(
ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader()
{
LoadDefaultData = true
},
CompareToString);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last();
Assert.AreEqual("MutableValue", tmpResult.FullName);
Assert.AreEqual(true, tmpResult.Content.Contains("Type c1 = this.GetType()"));
Assert.AreEqual(true, tmpResult.Content.Contains(" - c2.GetHashCode()"));
}
private static void WriteArgsDescription(XElement request, CSharpWriter w)
{
if (GenerateComments)
{
var args = request.Elements(ArgElement);
foreach (var a in args)
{
var name = a.Attribute(NameAttrib)?.Value;
var descr = a.Attribute(SummaryAttrib)?.Value;
if (descr != null)
{
w.Line($"/// <param name=\"{name}\">{descr}</param>");
}
}
}
}
public void Test()
{
var tmpClass = @"
package java.lang;
public class Collection<T>{
}";
var tmpObjectInformation = ProjectInformationHelper.DoFullRun(ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader()
{
LoadDefaultData = true
}, tmpClass);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList();
///Write to JSON to add additional Java Base Classes
var b = ExportHelper.CreateJsonFromClassList(tmpObjectInformation.ClassList.Where(inItem => inItem.ClassType == CodeConverterCore.Enum.ClassTypeEnum.Normal).ToList());
}
private RegexCSharpCompiler(TextWriter writer, string pattern, RegexOptions options, CultureInfo culture, string @namespace, string className)
{
Pattern = pattern;
Tree = RegexParser.Parse(pattern, options, culture);
Code = RegexWriter.Write(Tree);
Writer = new CSharpWriter(writer);
Codes = Code.Codes;
Operations = Operation.GenerateFromCodes(Codes);
Strings = Code.Strings;
FirstCharacterPrefix = Code.FCPrefix;
BoyerMoorePrefix = Code.BMPrefix;
Anchors = new Anchors(Code.Anchors);
TrackCount = Code.TrackCount;
Options = options;
Namespace = @namespace;
ClassName = className;
}
public static void GenReactiveExecuteSystem(CSharpWriter writer, string className, string context, string componentName)
{
if (string.IsNullOrEmpty(componentName))
{
componentName = $"I{context}Component";
}
writer.Write($"using TComponent = {componentName};").NewLine();
writer.Write($"public class {className} : LiteECS.ReactiveExecuteSystem<{context}Entity, TComponent>");
using (new CSharpWriter.Scop(writer))
{
writer.Write($" private {context}Context Context => context as {context}Context;").NewLine();
writer.Write($"public {className}({context}Context context):base(context)");
writer.EmptyScop();
writer.Write($"protected override void OnExecuteEntity({context}Entity entity, TComponent component)");
writer.EmptyScop();
}
}
internal static string DeclarationToString(ITypeDeclaration declaration)
{
try
{
StringWriter sw = new StringWriter();
ILanguageWriter lw = new CSharpWriter() as ILanguageWriter;
SourceNode sn = lw.GenerateSource(declaration);
LanguageWriter.WriteSourceNode(sw, sn);
sw.Close();
string s = sw.ToString();
return(s);
}
catch (Exception ex)
{
return("[ERROR WRITING DECLARATION: " + ex.Message + "]"); // +ist;
}
}
public void SimpleFor()
{
var tmpClass = @"
package org;
public class Class1 {
public void forIInLength(int len){
for(int i=0;i<len;i++) {
i--;
}
return false;
}
";
var tmpIniData = DataHelper.LoadIni("");
var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> {
tmpClass
}, tmpIniData);
new AnalyzerCore().LinkProjectInformation(tmpObjectInformation);
new NamingConvertionHelper(new ConverterLucene()).ConvertProject(tmpObjectInformation);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp())
.ToList()
.Last();
var tmpExpectedResult = @"
namespace org
{
public class Class1
{
public void ForIInLength(int inLen)
{
for (int i = 0:(i < inLen):i++)
{
i--;
}
return false;
}
}
}
";
//Check Elvis Result
Assert.AreEqual(tmpExpectedResult, tmpResult.Content);
}
public void PropertyGet()
{
var tmpProject = new ProjectInformation();
var tmpClass = Create.AddClass("v1");
var tmpMethode = tmpClass.AddMethode("Name", new TypeContainer("string"));
tmpMethode.IsProperty = true;
tmpProject.FillClasses(new System.Collections.Generic.List <ClassContainer> {
tmpClass
});
var tmpObjectInformation = CSharpWriter.CreateClassesFromObjectInformation(tmpProject, new ConverterBase()).ToList();
Assert.AreEqual(1, tmpObjectInformation.Count);
Assert.AreEqual(true, tmpObjectInformation[0].Content.Contains("string Name{"));
Assert.AreEqual(false, tmpObjectInformation[0].Content.Contains("string Name()"));
}
private static String DecompileMethod(String methodName)
{
MethodInfo netMethodInfo = typeof(MethodBodyTest).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
if (netMethodInfo == null)
{
netMethodInfo = typeof(MethodBodyTest).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
}
IMethodReference methodReferece = AssemblyManager.FindMethod(netMethodInfo);
CSharpWriter languageWriter = new CSharpWriter();
PlainTextWriter formattedCodeWriter = new PlainTextWriter();
languageWriter.WriteMethodDeclaration(methodReferece.Resolve(), formattedCodeWriter);
return(formattedCodeWriter.ToString());
}
public void SimpleWhile()
{
var tmpClass = @"
package org;
public class Class1 {
public void OneSmallerThanTwo(){
while(true){
return true;
}
}
}
";
var tmpIniData = DataHelper.LoadIni("");
var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> {
tmpClass
}, tmpIniData);
new AnalyzerCore().LinkProjectInformation(tmpObjectInformation);
new NamingConvertionHelper(new ConverterLucene()).ConvertProject(tmpObjectInformation);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp())
.ToList()
.Last();
var tmpExpectedResult = @"
namespace org
{
public class Class1
{
public void OneSmallerThanTwo()
{
while (true)
{
return true;
}
}
}
}
";
//Check Elvis Result
Assert.AreEqual(tmpExpectedResult, tmpResult.Content);
}
public void PropertyInInterfaceWithDefaultValue()
{
var tmpAnalyerSettings = new AnalyzerSettings();
var tmpObjectInformation = ProjectInformationHelper.DoFullRun(ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader()
{
LoadDefaultData = true
}, JavaClass);
var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene())
.Where(inItem => inItem.FullName == "MutableValue")
.ToList();
Assert.AreEqual(1, tmpResult.Count);
Assert.AreEqual("MutableValue", tmpResult[0].FullName);
Assert.AreEqual(CSharpResult1, tmpResult[0].Content);
}
internal void WriteParserMembers(CSharpWriter csw, RuleCompiler cmp)
{
foreach (RuleItem item in Items)
{
item.WriteParserMembers(csw, cmp);
}
csw.Begin("public bool {0}({1} args)", ParseFuncName, cmp.Rule.ArgsClassName);
csw.WriteLine("var beginMark = MarkPosition();");
foreach (RuleItem item in Items)
{
csw.Begin("if (!{0}(args))", item.ParseFuncName);
csw.WriteLine("GoToMark(beginMark);");
csw.WriteLine("return false;");
csw.End();
}
csw.WriteLine("return true;");
csw.End();
}
private static int Main(string[] args)
{
if (args.Length < 2 || (args.Length > 0 && (args[0] == "-h" || args[0] == "--help")))
{
Console.WriteLine("usage: dotnet WaylandSharpGen.dll [protocol] [output]");
return(0);
}
if (args.Length == 0)
{
Console.WriteLine("No protocol path specified, using default path.");
}
var path = args[0];
Console.WriteLine($"Using protocol at '{path}'.");
if (!File.Exists(path))
{
Console.WriteLine("Protocol file not found. Exiting...");
return(1);
}
var fp = args[1];
var doc = XDocument.Load(path);
var w = new CSharpWriter();
w.Line("// This file was generated from an xml Wayland protocol specification");
w.Line("// by WaylandSharpGen. https://github.com/Jjagg/OpenWindow/tree/master/generators/WaylandSharpGen");
w.Line();
w.Line("#pragma warning disable CS0649");
w.Line();
WriteProtocol(doc, w);
var dirName = Path.GetDirectoryName(fp);
if (!string.IsNullOrWhiteSpace(dirName))
{
Directory.CreateDirectory(dirName);
}
File.WriteAllText(fp, w.ToString());
Console.WriteLine($"Wrote output to '{fp}'.");
return(0);
}
private void GenDestroySystem(Type type, CSharpWriter writer, string className)
{
writer.Write($"private readonly {context.Name}Context context;").NewLine();
writer.Write($"public {className}({context.Name}Context context)");
using (new CSharpWriter.Scop(writer))
{
writer.Write($"this.context = context;");
}
writer.Write($"public void OnCleanup()");
using (new CSharpWriter.Scop(writer))
{
writer.Write("var group = context.CreatGroup<TComponent>();").NewLine();
writer.Write("while (group.MoveNext())");
using (new CSharpWriter.Scop(writer))
{
writer.Write("group.Entity.Destroy();");
}
}
}
public static object ProcessQueryClass(InferenceEngine engine, Type type, MethodInfo singleQuery)
{
var typeDecl = RoslynDeclarationProvider.GetTypeDeclaration(type, false);
var queryTransform = new QueryTransform(engine, singleQuery);
var compiledQueries = queryTransform.Transform(typeDecl);
bool showCode = false;
if (showCode)
{
var sw = new StringWriter();
var lw = new CSharpWriter();
var sn = lw.GenerateSource(compiledQueries);
LanguageWriter.WriteSourceNode(sw, sn);
var sourceCode = sw.ToString();
}
return(engine.Compiler.CompileWithoutParams <object>(new[] { compiledQueries }.ToList()));
}
static void Main (string [] args)
{
var a = Expression.Parameter (typeof (int), "a");
var b = Expression.Parameter (typeof (int), "b");
var return_label = Expression.Label (typeof (int), "ret");
var c = Expression.Parameter (typeof (int), "c");
var d = Expression.Parameter (typeof (int), "d");
var left = Expression.Block (
new [] { c },
Expression.Assign (c, Expression.AddChecked (a, b)),
Expression.AddAssignChecked (c, Expression.Constant (42)),
c);
var right = Expression.Block (
new [] { d },
Expression.Assign (d, Expression.SubtractChecked (a, b)),
Expression.SubtractAssignChecked (d, Expression.Constant (42)),
d);
var conditional = Expression.Condition (
Expression.GreaterThan (a, b),
left, right);
var lambda = Expression.Lambda<Func<int, int, int>> (conditional, a, b);
var add = lambda.Compile ();
Console.WriteLine (add (2, 2));
Console.WriteLine ("--------------------");
var csharp = new CSharpWriter (new TextFormatter (Console.Out));
csharp.Write (lambda);
Console.WriteLine ("--------------------");
Console.WriteLine (typeof (Expression).GetProperty ("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue (lambda, new object [0]));
}
static void Main(string [] args)
{
var a = Expression.Parameter(typeof(int), "a");
var b = Expression.Parameter(typeof(int), "b");
var return_label = Expression.Label(typeof(int), "ret");
var c = Expression.Parameter(typeof(int), "c");
var d = Expression.Parameter(typeof(int), "d");
var left = Expression.Block(
new [] { c },
Expression.Assign(c, Expression.AddChecked(a, b)),
Expression.AddAssignChecked(c, Expression.Constant(42)),
c);
var right = Expression.Block(
new [] { d },
Expression.Assign(d, Expression.SubtractChecked(a, b)),
Expression.SubtractAssignChecked(d, Expression.Constant(42)),
d);
var conditional = Expression.Condition(
Expression.GreaterThan(a, b),
left, right);
var lambda = Expression.Lambda <Func <int, int, int> > (conditional, a, b);
var add = lambda.Compile();
Console.WriteLine(add(2, 2));
Console.WriteLine("--------------------");
var csharp = new CSharpWriter(new TextFormatter(Console.Out));
csharp.Write(lambda);
Console.WriteLine("--------------------");
Console.WriteLine(typeof(Expression).GetProperty("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(lambda, new object [0]));
}
private static void WriteDescription(XElement e, CSharpWriter w)
{
if (GenerateComments)
{
var summary = e.Attribute(SummaryAttrib);
var descr = e.Element(DescriptionElement);
if (descr != null)
{
var descrStr = descr.Value;
var summaryStr = summary == null ? string.Empty : summary.Value + "\n";
descrStr = $"{summaryStr}<p>" + descrStr + "</p>";
var lines = descrStr
.Trim()
.Split('\n')
.SelectMany(l => string.IsNullOrEmpty(l) ? new [] { "</p>", "<p>" } : new [] { l })
.Select(s => s.Trim());
w.DocSummary(lines);
}
}
}
static void Main (string [] args)
{
var a = Expression.Parameter (typeof (int), "a");
var b = Expression.Parameter (typeof (int), "b");
var scope = Expression.Parameter(typeof(object), "scope");
var instance = Expression.Constant(scope);
var binder = Binder.GetMember(
CSharpBinderFlags.None,
"Text",
typeof(object),
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
);
var expArgs = new List<Expression>() { instance };
var binderM = Binder.InvokeMember(
CSharpBinderFlags.None,
"ToString",
null,
typeof(object),
expArgs.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null))
);
Expression resultm = Expression.Dynamic(binderM, typeof(object), expArgs);
Expression result = Expression.Dynamic(binder, typeof(object), instance);
var return_label = Expression.Label (typeof (int), "ret");
var c = Expression.Parameter (typeof (int), "c");
var d = Expression.Parameter (typeof (int), "d");
var left = Expression.Block (
new [] { c },
Expression.Assign (c, Expression.AddChecked (a, b)),
Expression.AddAssignChecked (c, Expression.Constant (42)),
c);
var right = Expression.Block (
new [] { d },
Expression.Assign (d, Expression.SubtractChecked (a, b)),
Expression.SubtractAssignChecked (d, Expression.Constant (42)),
result,
resultm,
d);
var conditional = Expression.Condition (
Expression.GreaterThan (a, b),
left, right);
var lambda = Expression.Lambda<Func<int, int, int>> (conditional, a, b);
var add = lambda.Compile ();
//Console.WriteLine (add (2, 2));
Console.WriteLine ("--------------------");
var csharp = new CSharpWriter (new TextFormatter (Console.Out));
csharp.Write (lambda);
Console.WriteLine ("--------------------");
Console.WriteLine (typeof (Expression).GetProperty ("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue (lambda, new object [0]));
}
