public void ProcessUnit(GeneratorOutput output)
{
foreach (var template in output.Templates)
{
WriteHeader(template.FindBlock(BlockKind.Header).Text);
}
}
public IList <float> EvaluateOne(float[] noise, float[] condition)
{
//input data maps
var inputDataMap = new Dictionary <Variable, Value>();
if (InputConditionSize > 0)
{
Value inputConditiondata = Value.CreateBatch(InputConditionGenerator.Shape, condition, Device, true);
inputDataMap.Add(InputConditionGenerator, inputConditiondata);
}
if (InputNoiseSize > 0)
{
Value inputNoisedata = Value.CreateBatch(InputNoiseGenerator.Shape, noise, Device, true);
inputDataMap.Add(InputNoiseGenerator, inputNoisedata);
}
//output datamaps
var outputDataMap = new Dictionary <Variable, Value>()
{
{ GeneratorOutput, null }
};
GeneratorOutput.ToFunction().Evaluate(inputDataMap, outputDataMap, Device);
var result = outputDataMap[GeneratorOutput].GetDenseData <float>(GeneratorOutput);
return(result[0]);
}
public GeneratorOutput GeneratePremake(Module module)
{
if (module == Context.Options.SystemModule)
{
return(null);
}
var premakeGen = new QuickJSPremakeBuildGenerator(Context, module);
var output = new GeneratorOutput
{
TranslationUnit = new TranslationUnit
{
FilePath = "premake5.lua",
Module = module
},
Outputs = new List <CodeGenerator> {
premakeGen
}
};
output.Outputs[0].Process();
return(output);
}
private void OnUnitGenerated(GeneratorOutput output)
{
needsStreamInclude = false;
foreach (var template in output.Outputs)
{
foreach (var block in template.FindBlocks(CLIBlockKind.MethodBody))
{
var method = block.Object as Method;
VisitMethod(method, block);
}
if (needsStreamInclude)
{
var sourcesTemplate = template as CLISources;
if (sourcesTemplate != null)
{
foreach (var block in sourcesTemplate.FindBlocks(CLIBlockKind.Includes))
{
block.WriteLine("#include <sstream>");
block.WriteLine("");
break;
}
break;
}
}
}
}
public override GeneratorOutput GenerateModule(Module module)
{
if (module == Context.Options.SystemModule)
{
return(null);
}
var moduleGen = new NAPIModule(Context, module);
var output = new GeneratorOutput
{
TranslationUnit = new TranslationUnit
{
FilePath = $"{module.LibraryName}.cpp",
Module = module
},
Outputs = new List <CodeGenerator> {
moduleGen
}
};
output.Outputs[0].Process();
return(output);
}
public virtual void VisitGeneratorOutput(GeneratorOutput output)
{
foreach (var generator in output.Outputs)
{
VisitCodeGenerator(generator);
}
}
public IEnumerable <GeneratorOutput> GenerateOutputs(Spec spec)
{
var targetInfo = spec.Targets[Constants.CSharpTarget];
var result = new GeneratorOutput[spec.Enums.Count + spec.Entities.Count];
var index = 0;
foreach (var @enum in spec.Enums)
{
result[index++] =
new GeneratorOutput
{
Path = Path.Combine(targetInfo.Path, GetFilename(@enum.Key, targetInfo.AppendGeneratedExtension) + "." + Constants.CSharpExtension),
GenerationRoot = GenerateEnum(spec, @enum.Key)
};
}
foreach (var entity in spec.Entities)
{
result[index++] =
new GeneratorOutput
{
Path = Path.Combine(targetInfo.Path, GetFilename(entity.Key, targetInfo.AppendGeneratedExtension) + "." + Constants.CSharpExtension),
GenerationRoot = GenerateEntity(spec, entity.Key)
};
}
return(result);
}
public override void VisitGeneratorOutput(GeneratorOutput output)
{
var blocks = output.Outputs.SelectMany(i => i.FindBlocks(BlockKind.Unknown));
foreach (var block in blocks)
{
block.Text.StringBuilder.Replace("cimgui_impl", "ImGui");
block.Text.StringBuilder.Replace("cimgui", "ImGui");
}
}
private void OnUnitGenerated(GeneratorOutput output)
{
foreach (var template in output.Templates)
{
foreach (var block in template.FindBlocks(CLIBlockKind.MethodBody))
{
var method = block.Declaration as Method;
VisitMethod(method, block);
}
}
}
public override void VisitGeneratorOutput(GeneratorOutput output)
{
foreach (var template in output.Templates)
{
var blocks = template.FindBlocks(CLIBlockKind.MethodBody);
foreach (var block in blocks)
{
VisitMethodBody(block);
}
}
}
public IEnumerable <GeneratorOutput> GenerateOutputs(Spec spec)
{
var targetInfo = spec.Targets[Constants.TypeScriptTarget];
var barrelContents = new List <TypeScriptDeclarationOrStatement>();
var typeCount = spec.Enums.Count + spec.Entities.Count;
if (typeCount == 0)
{
return(Enumerable.Empty <GeneratorOutput>());
}
var result = new GeneratorOutput[typeCount + 1];
var index = 0;
foreach (var @enum in spec.Enums)
{
var enumOutput = GenerateEnum(spec, @enum.Key);
result[index++] = enumOutput;
barrelContents.Add(new TypeScriptReExportStatement {
FileName = Path.GetFileNameWithoutExtension(enumOutput.Path)
});
}
foreach (var entity in spec.Entities)
{
var entityFileName = TypeScriptFileUtilities.GetFileName(entity.Key, targetInfo.AppendGeneratedExtension);
result[index++] =
new GeneratorOutput
{
Path = Path.Combine(targetInfo.Path, entityFileName + "." + Constants.TypeScriptExtension),
GenerationRoot = GenerateEntity(spec, entity.Key)
};
barrelContents.Add(new TypeScriptReExportStatement {
FileName = entityFileName
});
}
result[index++] =
new GeneratorOutput
{
// index.ts must always have '.ts' extension. '.generated.ts' is not applicable here
// because it won't be recognized by module definition
Path = Path.Combine(targetInfo.Path, Path.ChangeExtension("index", Constants.TypeScriptExtension)),
GenerationRoot = new TypeScriptFile {
Contents = barrelContents
}
};
return(result);
}
private void SetGeneratorInOutputGenerationList(GeneratorOutput incomingGeneratorOutput)
{
if (_lsFinalGenOutput.Any(x => x.Name.Equals(incomingGeneratorOutput.Name, StringComparison.CurrentCultureIgnoreCase)))
{
var index = _lsFinalGenOutput.FindIndex(generator => string.Equals(generator.Name, incomingGeneratorOutput.Name, StringComparison.CurrentCultureIgnoreCase));
var updatedValue = new GeneratorOutput
{
Name = incomingGeneratorOutput.Name,
Total = _lsFinalGenOutput[index].Total + incomingGeneratorOutput.Total
};
_lsFinalGenOutput[index] = updatedValue;
}
else
{
_lsFinalGenOutput.Add(incomingGeneratorOutput);
}
}
public GeneratorOutput GenerateHelpers()
{
var helpersGen = new NAPIHelpers(Context);
helpersGen.Process();
var output = new GeneratorOutput
{
TranslationUnit = new TranslationUnit {
FilePath = "NAPIHelpers.h"
},
Outputs = new List <CodeGenerator> {
helpersGen
}
};
return(output);
}
private void OnUnitGenerated(GeneratorOutput generatorOutput)
{
var blocks = (from output in generatorOutput.Outputs
from block in output.FindBlocks(BlockKind.Method)
where this.events.Contains(block.Object)
select block).ToList();
foreach (var block in blocks)
{
var method = (Function)block.Object;
string @event;
if (((Class)method.Namespace).Methods.Any(m => m != method && m.OriginalName == method.OriginalName))
{
@event = method.OriginalName;
}
else
{
@event = char.ToUpperInvariant(method.OriginalName[0]) + method.OriginalName.Substring(1);
}
var blockIndex = block.Parent.Blocks.IndexOf(block);
var eventBlock = new Block(BlockKind.Event);
eventBlock.WriteLine("public event global::System.Action<object, {0}> {1};",
method.Parameters[0].Type, @event);
eventBlock.NewLine();
const string eventHandler = @"__eventHandler";
var raiseEvent = string.Format(
@"var {0} = {1};
if ({0} != null)
{0}(this, {2});
if ({2}.Handled)
return{3};
",
eventHandler, @event, method.Parameters[0].Name,
method.OriginalReturnType.Type.IsPrimitiveType(PrimitiveType.Void) ? string.Empty : " true");
if (block.Blocks.Count > 0 && block.Blocks[0].Kind == BlockKind.BlockComment)
{
eventBlock.Blocks.Add(block.Blocks[0]);
}
block.Parent.Blocks.Insert(blockIndex, eventBlock);
block.Text.StringBuilder.Replace("var __slot", raiseEvent + " var __slot");
}
}
public override void VisitGeneratorOutput(GeneratorOutput output)
{
var blocks = output.Outputs.SelectMany(i => i.FindBlocks(BlockKind.Unknown));
foreach (var namespaceBlock in blocks)
{
if (namespaceBlock.Parent.Kind == BlockKind.Class)
{
foreach (var classBlock in namespaceBlock.Parent.Blocks)
{
ProcessClassBlock(classBlock);
}
}
else if (namespaceBlock.Parent.Kind == BlockKind.InternalsClass)
{
foreach (var classBlock in namespaceBlock.Parent.Blocks)
{
ProcessClassBlock(classBlock.Parent);
}
}
}
}
private Totals TotalGeneratorsOutputPerDay(GenerationReport reportGenerated)
{
foreach (var item in reportGenerated.wind.windGenerator)
{
var windGen = new GeneratorOutput
{
Name = item.name,
Total = item.generation.day.Sum(x => x.energy * x.price * GetGeneratorFactorMapping(item.name).valueFactor)
};
SetGeneratorInOutputGenerationList(windGen);
}
foreach (var item in reportGenerated.gas.gasGenerator)
{
var gasGen = new GeneratorOutput
{
Name = item.name,
Total = item.generation.day.Sum(x => x.energy * x.price * GetGeneratorFactorMapping(item.name).valueFactor)
};
SetGeneratorInOutputGenerationList(gasGen);
}
foreach (var item in reportGenerated.coal.coalGenerator)
{
var coalGen = new GeneratorOutput
{
Name = item.name,
Total = item.generation.day.Sum(x => x.energy * x.price * GetGeneratorFactorMapping(item.name).valueFactor)
};
SetGeneratorInOutputGenerationList(coalGen);
}
var totals = new Totals();
return(new Totals()
{
GeneratorOutput = _lsFinalGenOutput
});
}
private void GenerateSignalEvents(GeneratorOutput generatorOutput)
{
foreach (var block in from output in generatorOutput.Outputs
from block in output.FindBlocks(BlockKind.Event)
select block)
{
Event @event = (Event)block.Object;
if (this.events.Contains(@event))
{
block.Text.StringBuilder.Clear();
Class @class = (Class)@event.Namespace;
int argNum = 1;
StringBuilder fullNameBuilder = new StringBuilder("global::System.Action");
foreach (Parameter parameter in @event.Parameters)
{
argNum++;
if (argNum == 2)
{
fullNameBuilder.Append('<');
}
fullNameBuilder.Append(parameter.Type);
fullNameBuilder.Append(',');
}
if (fullNameBuilder[fullNameBuilder.Length - 1] == ',')
{
fullNameBuilder[fullNameBuilder.Length - 1] = '>';
}
string signature = string.Format("{0}({1})", @event.OriginalName,
string.Join(", ",
from e in @event.Parameters
select GetOriginalParameterType(e)));
Event existing = @class.Events.FirstOrDefault(e => e.Name == @event.Name);
if (existing != null && existing != @event)
{
if (@event.Parameters.Count > 0)
{
@event.Name += GetSignalEventSuffix(@event);
}
else
{
existing.Name += GetSignalEventSuffix(@event);
}
}
else
{
if (@event.Parameters.Count > 0 &&
(@class.Methods.Any(m => m.IsGenerated && m.OriginalName == @event.Name) ||
@class.Properties.Any(p => p.IsGenerated && p.OriginalName == @event.Name)))
{
@event.Name += GetSignalEventSuffix(@event);
}
}
if (@event.OriginalDeclaration.Comment != null)
{
block.WriteLine("/// <summary>");
foreach (string line in HtmlEncoder.HtmlEncode(@event.OriginalDeclaration.Comment.BriefText).Split(
Environment.NewLine.ToCharArray()))
{
block.WriteLine("/// <para>{0}</para>", line);
}
block.WriteLine("/// </summary>");
}
var finalName = char.ToUpperInvariant(@event.Name[0]) + @event.Name.Substring(1);
if (@event.Namespace.Declarations.Exists(d => d != @event && d.Name == finalName))
{
finalName += "Signal";
}
block.WriteLine(string.Format(@"public event {0} {1}
{{
add
{{
ConnectDynamicSlot(this, ""{2}"", value);
}}
remove
{{
DisconnectDynamicSlot(this, ""{2}"", value);
}}
}}", fullNameBuilder, finalName, signature));
}
}
var qtMetacall = (from output in generatorOutput.Outputs
from block in output.FindBlocks(BlockKind.Method)
let declaration = block.Object as Declaration
where declaration != null && declaration.Name == "QtMetacall" &&
declaration.Namespace.Name == "QObject"
select block).FirstOrDefault();
if (qtMetacall != null)
{
qtMetacall.Text.StringBuilder.Replace("return __ret;", "return HandleQtMetacall(__ret, _0, _2);");
}
}
private void OnUnitGenerated(GeneratorOutput generatorOutput)
{
foreach (Block block in from template in generatorOutput.Templates
from block in template.FindBlocks(CSharpBlockKind.Event)
select block)
{
Event @event = (Event)block.Declaration;
if (this.events.Contains(@event))
{
block.Text.StringBuilder.Clear();
Class @class = (Class)@event.Namespace;
if (!this.addedEventHandlers && @class.Name == "QObject")
{
block.WriteLine("protected readonly System.Collections.Generic.List<QEventHandler> " +
"eventFilters = new System.Collections.Generic.List<QEventHandler>();");
block.NewLine();
this.addedEventHandlers = true;
}
bool isQAbstractScrollArea = @class.Name != "QAbstractScrollArea";
if (@event.OriginalDeclaration.Comment != null)
{
block.WriteLine("/// <summary>");
foreach (string line in HtmlEncoder.HtmlEncode(@event.OriginalDeclaration.Comment.BriefText).Split(
Environment.NewLine.ToCharArray()))
{
block.WriteLine("/// <para>{0}</para>", line);
}
block.WriteLine("/// </summary>");
}
block.WriteLine(@"public {0} event EventHandler<QEventArgs<{1}>> {2}
{{
add
{{
QEventArgs<{1}> qEventArgs = new QEventArgs<{1}>(new System.Collections.Generic.List<QEvent.Type> {{ {3} }});
QEventHandler<{1}> qEventHandler = new QEventHandler<{1}>(this{4}, qEventArgs, value);
foreach (QEventHandler eventFilter in eventFilters)
{{
this{4}.RemoveEventFilter(eventFilter);
}}
eventFilters.Add(qEventHandler);
for (int i = eventFilters.Count - 1; i >= 0; i--)
{{
this{4}.InstallEventFilter(eventFilters[i]);
}}
}}
remove
{{
for (int i = eventFilters.Count - 1; i >= 0; i--)
{{
QEventHandler eventFilter = eventFilters[i];
if (eventFilter.Handler == value)
{{
this{4}.RemoveEventFilter(eventFilter);
eventFilters.RemoveAt(i);
break;
}}
}}
}}
}}",
isQAbstractScrollArea ? "virtual" : "override", @event.Parameters[0].Type, @event.Name,
this.GetEventTypes(@event), isQAbstractScrollArea ? string.Empty : ".Viewport");
}
}
}
private void GenerateSignalEvents(GeneratorOutput generatorOutput)
{
foreach (Block block in from template in generatorOutput.Templates
from block in template.FindBlocks(CSharpBlockKind.Event)
select block)
{
Event @event = (Event)block.Declaration;
if (this.events.Contains(@event))
{
block.Text.StringBuilder.Clear();
Class @class = (Class)@event.Namespace;
int argNum = 1;
StringBuilder fullNameBuilder = new StringBuilder("Action");
foreach (Parameter parameter in @event.Parameters)
{
argNum++;
if (argNum == 2)
{
fullNameBuilder.Append('<');
}
fullNameBuilder.Append(parameter.Type);
fullNameBuilder.Append(',');
}
if (fullNameBuilder[fullNameBuilder.Length - 1] == ',')
{
fullNameBuilder[fullNameBuilder.Length - 1] = '>';
}
string signature = string.Format("{0}({1})", @event.OriginalName,
string.Join(", ",
from e in @event.Parameters
select GetOriginalParameterType(e)));
Event existing = @class.Events.FirstOrDefault(e => e.Name == @event.Name);
if (existing != null && existing != @event)
{
if (@event.Parameters.Count > 0)
{
@event.Name += GetSignalEventSuffix(@event);
}
else
{
existing.Name += GetSignalEventSuffix(@event);
}
}
else
{
if (@event.Parameters.Count > 0 &&
(@class.Methods.Any(m => m.IsGenerated && m.OriginalName == @event.Name) ||
@class.Properties.Any(p => p.IsGenerated && p.OriginalName == @event.Name)))
{
@event.Name += GetSignalEventSuffix(@event);
}
}
if (@event.OriginalDeclaration.Comment != null)
{
block.WriteLine("/// <summary>");
foreach (string line in HtmlEncoder.HtmlEncode(@event.OriginalDeclaration.Comment.BriefText).Split(
Environment.NewLine.ToCharArray()))
{
block.WriteLine("/// <para>{0}</para>", line);
}
block.WriteLine("/// </summary>");
}
block.WriteLine(string.Format(@"public event {0} {1}
{{
add
{{
ConnectDynamicSlot(this, ""{2}"", value);
}}
remove
{{
DisconnectDynamicSlot(this, ""{2}"", value);
}}
}}", fullNameBuilder, char.ToUpperInvariant(@event.Name[0]) + @event.Name.Substring(1), signature));
}
}
foreach (Block block in from template in generatorOutput.Templates
from block in template.FindBlocks(CSharpBlockKind.Method)
where block.Declaration != null && block.Declaration.Name == "Qt_metacall"
select block)
{
block.Text.StringBuilder.Clear();
block.WriteLine(@"public {0} unsafe int Qt_metacall(QMetaObject.Call call, int id, void** arguments)
{{
var index = Internal.Qt_metacall_0({1}, call, id, arguments);
return HandleQtMetacall(index, call, arguments);
}}", block.Declaration.Namespace.Name == "QObject" ? "virtual" : "override", Helpers.InstanceIdentifier);
}
}
private void OnUnitGenerated(GeneratorOutput generatorOutput)
{
this.GenerateSignalEvents(generatorOutput);
}
public void TestGenerateOutputWithClass()
{
// arrange
var spec =
new Spec
{
Entities = new Dictionary <string, EntityInfo>
{
{
"blog_entry",
new EntityInfo
{
Members =
new OrderedDictionary <string, IEntityMemberInfo>
{
{ "id", new EntityMemberInfo {
Type = "int"
} },
{ "title", new EntityMemberInfo {
Type = "string"
} }
}
}
}
},
Targets = new Dictionary <string, TargetInfo>
{
{ Constants.TypeScriptTarget, new TargetInfo {
Path = "some_path"
} }
}
};
var typeScriptFiles =
new GeneratorOutput[]
{
new GeneratorOutput
{
Path = Path.Combine("some_path", "blog-entry.ts"),
GenerationRoot =
TypeScriptFileBuilder.Start()
.Content(
TypeScriptExportStatementBuilder.Start()
.DefaultExport(
TypeScriptClassBuilder.Start()
.Name("BlogEntry")
.Member("id", "number")
.Member("title", "string").Build()
)
.Build())
.Build()
},
new GeneratorOutput
{
Path = Path.Combine("some_path", "index.ts"),
GenerationRoot =
TypeScriptFileBuilder.Start()
.Content(new TypeScriptReExportStatement {
FileName = "blog-entry"
})
.Build()
}
};
var ammendment = new AmmendmentFactory().CreateAmmendment(Constants.TypeScriptTarget);
ammendment.AmmedSpecification(spec);
var generator = new TypeScriptGenerator();
// act
var outputs = generator.GenerateOutputs(spec);
// assert
Assert.NotNull(outputs);
Assert.True(outputs.SequenceEqual(typeScriptFiles, EqualityComparer <GeneratorOutput> .Default));
}
public virtual void VisitGeneratorOutput(GeneratorOutput output)
{
}
private void OnUnitGenerated(GeneratorOutput output)
{
}
