static void Main(string[] args)
{
string projectFolder = System.IO.Path.Combine(CodegenCS.Utils.IO.GetCurrentDirectory().FullName, @"..\AdventureWorks.Business");
CodegenContext context = new CodegenContext(outputFolder: projectFolder + "\\GeneratedCode");
Generator generator = new Generator(
context: context,
createConnection: () => new System.Data.SqlClient.SqlConnection(@"
Data Source=LENOVOFLEX5\SQLEXPRESS;
Initial Catalog=AdventureWorks;
Integrated Security=True;
Application Name=EntityFramework POCO Generator"
),
targetFrameworkVersion: 4.72m
);
generator.GenerateMultipleFiles(); // generates in memory
// since no errors, first modify csproj, then we save all files
// Generate all files and add each into to the csproj
MSBuildProjectEditor editor = new MSBuildProjectEditor(projectFilePath: projectFolder + @"\AdventureWorks.Business.csproj");
//string templateFile = Path.Combine(CodegenCS.Utils.IO.GetCurrentDirectory().FullName);
foreach (var o in context.OutputFilesAbsolute)
{
editor.AddItem(itemPath: o.Key, itemType: o.Value.ItemType);
}
editor.Save();
context.SaveFiles(deleteOtherFiles: true);
}
/// <inheritdoc/>
public bool Transformation(QsCompilation compilation, out QsCompilation transformed)
{
// random "diagnostic" to check if diagnostics loading works
this.GeneratedDiagnostics = new List <IRewriteStep.Diagnostic>()
{
new IRewriteStep.Diagnostic
{
Severity = CodeAnalysis.DiagnosticSeverity.Info,
Message = "Invokation of the Q# compiler extension for C# generation to demonstrate execution on the simulation framework.",
}
};
var success = true;
var outputFolder = this.AssemblyConstants.TryGetValue(ReservedKeywords.AssemblyConstants.OutputPath, out var path) ? path : null;
var allSources = GetSourceFiles.Apply(compilation.Namespaces) // also generate the code for referenced libraries...
// ... except when they are one of the packages that currently still already contains the C# code (temporary workaround):
.Where(s => !Path.GetFileName(s).StartsWith("Microsoft.Quantum"));
foreach (var source in allSources)
{
var content = SimulationCode.generate(source, CodegenContext.Create(compilation.Namespaces));
try
{
CompilationLoader.GeneratedFile(source, outputFolder ?? this.Name, ".g.cs", content);
}
catch
{
success = false;
}
}
transformed = compilation;
return(success);
}
private void Visit(IfNode node, MethodBuilder builder, CodegenContext context)
{
Visit(node.Condition, builder, context);
int label1 = builder.PrepareJump(true);
Visit(node.IfTrue, builder, context);
if (node.IfFalse != null)
{
int label2 = builder.PrepareJump(false);
int elseLabel = builder.Nop();
builder.MakeJump(label1, elseLabel, Jump.IfFalse);
Visit(node.IfFalse, builder, context);
int label3 = builder.Nop();
builder.MakeJump(label2, label3, Jump.Always);
}
else
{
int label2 = builder.Nop();
builder.MakeJump(label1, label2, Jump.IfFalse);
}
}
private TypeInfo Visit(NotNode node, MethodBuilder builder, CodegenContext context)
{
var res = Visit(node.Operand as dynamic, builder, context);
builder.Not();
return(res);
}
private void Visit(AssignNode node, MethodBuilder builder, CodegenContext context)
{
Visit(node.LValue as dynamic, builder, context);
var varInfo = context.LastVar;
Visit(node.Expression, builder, context);
builder.Assign(varInfo);
}
private TypeInfo Visit(CastNode node, MethodBuilder builder, CodegenContext context)
{
var res = Visit(node.Expression as dynamic, builder, context);
var convType = node.Type as SimpleType;
builder.Convert(convType.SType);
return(convType);
}
private TypeInfo Visit(AssignMemberCallNode node, MethodBuilder builder, CodegenContext context)
{
var whereType = Visit(node.MemberCallNode.Where as dynamic, builder, context);
VarInfo varInfo = types.GetType(whereType.Name).GetField(node.MemberCallNode.MemberName);
context.LastVar = varInfo;
return(varInfo.Type);
}
private TypeInfo Visit(ReturnNode node, MethodBuilder builder, CodegenContext context)
{
builder.ClearStack();
var res = Visit(node.Expression, builder, context);
builder.Ret();
return(res);
}
public async Task EmitArgumentWrites(CodegenContext context, FunctionEntry function)
{
var args = function.Type.Arguments;
for (int i = 0; i < args.Count; ++i)
{
var arg = args[i];
await context.EmitLine($"{CodeGenerator.DataBuffer}.write<{arg.Type}>({arg.Name});");
}
}
private void Visit(PackageDefNode node, CodegenContext context)
{
var packageType = types.GetType(node.Name) as PackageType;
var packageBuilder = builder.BuildPackage(packageType);
foreach (var item in node.Defs)
{
Visit(item, packageBuilder, context);
}
}
private TypeInfo Visit(AssignVarNode node, MethodBuilder builder, CodegenContext context)
{
context.LastVar = builder.MethodInfo.GetVar(node.VarName);
if (context.LastVar == null)
{
context.LastVar = context.CurrentClass.GetField(node.VarName);
}
return(context.LastVar.Type);
}
private void Visit(DoWhileNode node, MethodBuilder builder, CodegenContext context)
{
int nop = builder.Nop();
Visit(node.Command, builder, context);
Visit(node.Condition, builder, context);
int jmp = builder.PrepareJump(true);
builder.MakeJump(jmp, nop, Jump.IfFalse);
}
private void Visit(CodeBlockNode node, MethodBuilder builder, CodegenContext context)
{
foreach (dynamic item in node.Commands)
{
Visit(item, builder, context);
if (!(item is ReturnNode))
{
builder.ClearStack();
}
}
}
private void Visit(CommonTree node, CodegenContext context)
{
if (node == null || node.ChildCount == 0)
{
return;
}
foreach (var item in node.Children)
{
Visit(item as dynamic, context);
}
}
private TypeInfo Visit(CreateArrayNode node, MethodBuilder builder, CodegenContext context)
{
Visit(node.Length, builder, context);
var arrType = typeBuilder.GenerateArrayType(node.TypeNode);
builder.Construct(arrType, new List <TypeInfo>()
{
TypeInfo.Int
});
return(arrType);
}
private void Visit(ClassDefNode node, CodegenContext context)
{
var type = types.GetType(node.Name) as ClassType;
context.CurrentClass = type;
var classBuilder = builder.BuildClass(type);
foreach (var item in node.Defs)
{
Visit(item, classBuilder, context);
}
}
private TypeInfo Visit(MinusNode node, MethodBuilder builder, CodegenContext context)
{
if (node.isUnary)
{
var res = Visit(node.LeftOperand as dynamic, builder, context);
builder.Neg();
return(res);
}
else
{
return(BinaryOperatorVisit(node, builder, (x) => x.Minus(), context));
}
}
/// <summary>
/// Generates POCOS
/// </summary>
/// <param name="targetFolder">Absolute path of the target folder where files will be written</param>
public void Generate(string targetFolder)
{
Console.WriteLine($"TargetFolder: {targetFolder}");
_generatorContext = new CodegenContext(outputFolder: targetFolder);
Console.WriteLine("Reading Schema...");
DatabaseSchema schema = Newtonsoft.Json.JsonConvert.DeserializeObject <DatabaseSchema>(File.ReadAllText(_inputJsonSchema));
foreach (var table in schema.Tables)
{
string entityClassName = GetClassNameForTable(table);
var schemaAndtable = new Tuple <string, string>(table.TableSchema, table.TableName);
if (!_usedIdentifiers.ContainsKey(schemaAndtable))
{
_usedIdentifiers.Add(schemaAndtable, new List <string>()
{
entityClassName
});
}
string tableFilePath = GetFileNameForTable(table);
Console.WriteLine($"Generating {tableFilePath}...");
using (var writer = _generatorContext.GetOutputFile(relativePath: tableFilePath).Writer)
{
writer.WriteLine(@"using System;");
writer.WriteLine(@"using System.Collections.Generic;");
writer.WriteLine();
using (writer.WithCBlock($"namespace {Namespace}"))
{
using (writer.WithCBlock($"public partial class {entityClassName}"))
{
var columns = table.Columns.Where(c => ShouldProcessColumn(table, c));
foreach (var column in columns)
{
string propertyName = GetPropertyNameForDatabaseColumn(table, column, _usedIdentifiers[schemaAndtable]);
writer.WriteLine($"public {GetTypeDefinitionForDatabaseColumn(table, column) ?? ""} {propertyName} {{ get; set; }}");
}
}
}
}
}
// since no errors happened, let's save all files
_generatorContext.SaveFiles();
Console.WriteLine("Success!");
}
private TypeInfo Visit(MemberCallNode node, MethodBuilder builder, CodegenContext context)
{
var whereType = Visit(node.Where as dynamic, builder, context);
context.LastVar = types.GetType(whereType.Name).GetField(node.MemberName);
//lastType = whereType;
//lastVar = varInfo;
// TODO Я НЕ ПОМНЮ, ЗАЧЕМ ЭТО
builder.LoadToStack(context.LastVar);
return(context.LastVar.Type);
}
private TypeInfo Visit(CallvirtNode node, MethodBuilder builder, CodegenContext context)
{
Visit(node.Where as dynamic, builder, context);
foreach (dynamic item in node.Args)
{
Visit(item, builder, context);
}
var methodInfo = node.Method;
builder.Callvirt(methodInfo);
return(methodInfo.Ret);
}
private void Visit(WhileNode node, MethodBuilder builder, CodegenContext context)
{
int start = builder.Nop();
Visit(node.Condition, builder, context);
int exit = builder.PrepareJump(true);
Visit(node.Command, builder, context);
builder.MakeJump(builder.Nop(), start, Jump.Always);
int end = builder.Nop();
builder.MakeJump(exit, end, Jump.IfFalse);
}
private void Visit(EntryPointNode node, CodegenContext context)
{
var varList = new List <VarInfo>();
foreach (dynamic item in node.DeclareItems)
{
var varInfo = GetVar(item);
varList.Add(varInfo);
}
var entryPointBuilder = builder.BuildEntryPoint(varList);
Visit(node.CodeBlock, entryPointBuilder, context);
entryPointBuilder.ClearStack();
entryPointBuilder.Ret();
}
private TypeInfo Visit(CreateTableNode node, MethodBuilder builder, CodegenContext context)
{
TypeInfo type = null;
if (node.IsTable)
{
type = typeBuilder.GenerateTableType(node.TypeNode);
}
else
{
type = typeBuilder.GenerateDictionaryType(node.TypeNode, node.ValueTypeNode);
}
builder.DefaultConstructor(type);
return(type);
}
private TypeInfo Visit(CreateInstanceNode node, MethodBuilder builder, CodegenContext context)
{
var typeList = new List <TypeInfo>();
foreach (dynamic item in node.Arguments)
{
var type = Visit(item, builder, context);
typeList.Add(type);
}
var classType = types.GetType(node.TypeName);
builder.Construct(classType, typeList);
return(classType);
}
public string Generate(CommonTree tree, TypeStorage types, INameConvertor nameConvertor)
{
this.types = types;
typeBuilder = new TypesBuilder(types);
builder = new ModuleBuilder(types.Libs, nameConvertor);
var defs = tree.Children.Where(x => x is ClassDefNode || x is EntryPointNode);
var context = new CodegenContext();
foreach (dynamic item in defs)
{
Visit(item, context);
}
return(builder.Generate());
}
private TypeInfo Visit(MethodCallNode node, MethodBuilder builder, CodegenContext context)
{
ClassType type = Visit(node.Where as dynamic, builder, context) as ClassType;
var argList = new List <TypeInfo>();
foreach (dynamic item in node.Arguments)
{
var arg = Visit(item, builder, context);
argList.Add(arg);
}
//TODO ПЛОХО
var methodInfo = type.GetMethod(node.MethodName, argList, type is PackageType);
builder.Call(methodInfo);
return(methodInfo.Ret);
}
private void Visit(MethodDefNode node, ClassBuilder builder, CodegenContext context)
{
var methodInfo = builder
.ClassType
.GetMethod(
node.MethodDecl.MethodName,
GetArgs(node.MethodDecl),
IsStatic(node.MethodDecl.Modifier)
);
var methodBuilder = builder.BuildMethod(methodInfo);
Visit(node.Commands, methodBuilder, context);
if (methodInfo.Ret.Equals(TypeInfo.Void))
{
methodBuilder.ClearStack();
methodBuilder.Ret();
}
}
private void Visit(ForNode node, MethodBuilder builder, CodegenContext context)
{
Visit(node.Init as dynamic, builder, context);
int l1 = builder.PrepareJump(false);
int nop2 = builder.Nop();
Visit(node.CodeBlock as dynamic, builder, context);
Visit(node.Iteration as dynamic, builder, context);
int nop1 = builder.Nop();
builder.MakeJump(l1, nop1, Jump.Always);
Visit(node.Condition as dynamic, builder, context);
int l2 = builder.PrepareJump(true);
builder.MakeJump(l2, nop2, Jump.IfTrue);
}
public bool Transformation(QsCompilation compilation, out QsCompilation transformed)
{
var context = CodegenContext.Create(compilation, _assemblyConstants);
var sources = GetSourceFiles.Apply(compilation.Namespaces);
foreach (var source in sources.Where(s => !s.Value.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)))
{
var content = SimulationCode.generate(source, context);
GeneratedFiles.Add(source.Value, content);
}
if (!compilation.EntryPoints.IsEmpty)
{
var callable = context.allCallables.First(c => c.Key == compilation.EntryPoints.First()).Value;
var content = EntryPoint.generate(context, callable);
NonNullable <string> entryPointName = NonNullable <string> .New(callable.SourceFile.Value + ".EntryPoint");
GeneratedFiles.Add(entryPointName.Value, content);
}
transformed = compilation;
return(true);
}
/// <summary>
/// Generates POCOS
/// </summary>
/// <param name="targetFolder">Absolute path of the target folder where files will be written</param>
public void Generate(string targetFolder)
{
Console.WriteLine($"TargetFolder: {targetFolder}");
_generatorContext = new CodegenContext();
Console.WriteLine("Reading Schema...");
LogicalSchema schema = Newtonsoft.Json.JsonConvert.DeserializeObject <LogicalSchema>(File.ReadAllText(_inputJsonSchema));
//schema.Tables = schema.Tables.Select(t => Map<LogicalTable, Table>(t)).ToList<Table>();
CodegenOutputFile writer = null;
if (SingleFile)
{
writer = _generatorContext[singleFileName];
writer
.WriteLine(@"using System;")
.WriteLine(@"using System.Collections.Generic;")
.WriteLine(@"using System.ComponentModel.DataAnnotations;")
.WriteLine(@"using System.ComponentModel.DataAnnotations.Schema;")
.WriteLine(@"using System.Linq;");
if (GenerateActiveRecord)
{
writer.WriteLine(@"using Dapper;");
}
writer
.WriteLine()
.WriteLine($"namespace {Namespace}").WriteLine("{").IncreaseIndent();
}
if (GenerateActiveRecord)
{
using (var writerConnectionFactory = _generatorContext["..\\IDbConnectionFactory.cs"])
{
writerConnectionFactory.WriteLine($@"
using System;
using System.Data;
using System.Data.SqlClient;
namespace {Namespace}
{{
public class IDbConnectionFactory
{{
public static IDbConnection CreateConnection()
{{
string connectionString = @""Data Source=MYWORKSTATION\\SQLEXPRESS;
Initial Catalog=AdventureWorks;
Integrated Security=True;"";
return new SqlConnection(connectionString);
}}
}}
}}
");
}
}
foreach (var table in schema.Tables.OrderBy(t => GetClassNameForTable(t)))
{
if (table.TableType == "VIEW")
{
continue;
}
GeneratePOCO(table);
}
if (SingleFile)
{
writer.DecreaseIndent().WriteLine("}"); // end of namespace
}
// since no errors happened, let's save all files
_generatorContext.SaveFiles(outputFolder: targetFolder);
Console.WriteLine("Success!");
}
