/// <summary>
/// Emits the artifacts for multiple compilation units with the same compilation mode and target runtime
/// </summary>
/// <param name="units">The compilation units</param>
protected void ExecuteDoEmitSameModeSameTarget(List <Unit> units)
{
EmitterBase emitter = null;
switch (GetTargetRuntimeFor(units[0].Grammar))
{
case Runtime.Net:
emitter = new EmitterForNet(reporter, units);
break;
case Runtime.Java:
emitter = new EmitterForJava(reporter, units);
break;
case Runtime.Rust:
emitter = new EmitterForRust(reporter, units, outputTargetRust);
break;
}
bool success = emitter.Emit();
if (!success)
{
reporter.Error("Failed to emit some output");
}
}
protected override void generate(EmitterBase emitter)
{
var namespaces = _declaringAssembly.GetNamespaces(_compositionAttribute.Element as CodeElement);
var initializerMethodInfo = new TypeMethodInfo(_compositionPoint.DeclaringType, ParsingActivation.InlineMethodName,
TypeDescriptor.Void, ParameterTypeInfo.NoParams, false, TypeDescriptor.NoDescriptors);
var code = new StringBuilder();
code.AppendLine("{");
for (var i = 0; i < _compositionPoint.Parameters.Length; ++i)
{
var parameter = _compositionPoint.Parameters[i];
var argument = _compositionAttribute.GetArgument(i);
if (argument == null)
{
argument = "null";
}
code.AppendLine(" var arg" + i + " = " + argument + ";");
}
code.AppendLine("}");
var activation = new ParsingActivation(code.ToString(), initializerMethodInfo, new string[0], namespaces);
_declaringAssembly.ParsingProvider(activation, emitter);
}
/// <summary>
/// Transcript given instructions in context of given method.
/// Transcription is processed by given emitter.
/// </summary>
/// <param name="method">Context method of transcription</param>
/// <param name="instructions">Transcripted instructions</param>
/// <param name="emitter">Emitter where transcription is emitted</param>
internal static void Transcript(TypeMethodInfo method, IEnumerable <CILInstruction> instructions, EmitterBase emitter)
{
E = emitter;
Method = method;
LocalTmpVar = E.GetTemporaryVariable("local");
//prepare labels table
Labels.Clear();
foreach (var instruction in instructions)
{
var labelName = string.Format("L_0x{0:x4}", instruction.Address);
Labels.Add(instruction.Address, E.CreateLabel(labelName));
}
foreach (var instruction in instructions)
{
Instruction = instruction;
E.SetLabel(Labels[instruction.Address]);
var block = E.StartNewInfoBlock();
block.Comment = "\n---" + Instruction.ToString();
Action transcriptor;
if (_transcriptors.TryGetValue(Name, out transcriptor))
{
transcriptor();
}
else
{
unknownInstruction();
}
}
}
protected override void generate(EmitterBase emitter)
{
foreach (var action in _emitActions)
{
action(emitter);
}
}
private void emitDirector(EmitterBase emitter)
{
//emitujeme instrukci pro uložení jména
//assembly do proměnné
emitter.AssignLiteral("result", _name);
//instrukce pro vrácení uložené hodnoty
emitter.Return("result");
}
/// <inheritdoc />
protected override void generate(EmitterBase emitter)
{
if (Activation == null)
{
throw new NotSupportedException("Cannot parse abstract method: " + Activation.Method.MethodID);
}
_parsingProvider(Activation, emitter);
}
/// <inheritdoc />
public override void ParsingProvider(ParsingActivation activation, EmitterBase emitter)
{
var w = Stopwatch.StartNew();
var source = Compiler.GenerateInstructions(activation, emitter, TypeServices);
var methodID = activation.Method == null ? new MethodID("$inline", false) : activation.Method.MethodID;
VS.Log.Message("Parsing time for {0} {1}ms", methodID, w.ElapsedMilliseconds);
}
protected override void generate(EmitterBase emitter)
{
if (_method == null)
{
//nothing to emit
return;
}
var method = new CILMethod(_method, _info);
Compiler.GenerateInstructions(method, _info, emitter, _services);
}
/// <inheritdoc />
protected override void generate(EmitterBase emitter)
{
//first and only argument is parametric
var resolvedArguments = CILAssembly.ResolveCustomAttributeArgument(_attribute.ConstructorArguments[0]) as object[];
for (var i = 0; i < resolvedArguments.Length; ++i)
{
var argumentStorage = "arg" + i;
var argumentValue = resolvedArguments[i];
emitter.AssignLiteral(argumentStorage, argumentValue);
}
}
static void UpdateBaseComponent(SpriteToParticles StP, EmitterBase eb)
{
StP.spriteRenderer = eb.spriteRenderer;
StP.particlesSystem = eb.particlesSystem;
StP.PlayOnAwake = eb.PlayOnAwake;
StP.EmissionRate = eb.EmissionRate;
StP.UsePixelSourceColor = eb.UsePixelSourceColor;
StP.UseEmissionFromColor = eb.UseEmissionFromColor;
StP.EmitFromColor = eb.EmitFromColor;
StP.RedTolerance = eb.RedTolerance;
StP.GreenTolerance = eb.GreenTolerance;
StP.BlueTolerance = eb.BlueTolerance;
StP.useSpritesSharingPool = eb.useSpritesSharingCache;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompilationContext"/> class.
/// </summary>
/// <param name="emitter">The emitter.</param>
/// <param name="source">The source.</param>
/// <param name="services">The services.</param>
/// <exception cref="System.ArgumentNullException">
/// emitter
/// or
/// source
/// or
/// services
/// </exception>
internal CompilationContext(EmitterBase emitter, Source source, TypeServices services)
{
if (emitter == null)
{
throw new ArgumentNullException("emitter");
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (services == null)
{
throw new ArgumentNullException("services");
}
Emitter = emitter;
Source = source;
Services = services;
}
/// <summary>
/// Generate instructions through given emitter.
/// <remarks>Throwing any exception will immediately stops analyzing.</remarks>.
/// </summary>
/// <param name="emitter">The emitter which will be used for instruction generation.</param>
protected override void generate(EmitterBase emitter)
{
_director(emitter);
}
protected override void generate(EmitterBase emitter)
{
var activation = new ParsingActivation(SourceCode, Method, _genericParameters);
Source = Compiler.GenerateInstructions(activation, emitter, _services);
}
/// <summary> /// Provider of method parsing for assembly. /// </summary> /// <param name="activation">Activation for assembly parser.</param> /// <param name="emitter">Emitter where parsed instructions are emitted.</param> public abstract void ParsingProvider(ParsingActivation activation, EmitterBase emitter);
protected override void generate(EmitterBase emitter)
{
Compiler.GenerateInstructions(Source, Info, emitter, _services);
}
/// <summary>
/// Generates the instructions of given method.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="info">The method information.</param>
/// <param name="emitter">The emitter where instructions will be generated.</param>
/// <param name="services">The services from <see cref="MEFEditor.TypeSystem"/>.</param>
public static void GenerateInstructions(CILMethod method, TypeMethodInfo info, EmitterBase emitter, TypeServices services)
{
Console.WriteLine(method.ToString());
var compiler = new Compiler(method, info, emitter, services);
compiler.generateInstructions();
//Console.WriteLine(emitter.GetEmittedInstructions().Code);
}
/// <summary>
/// Initializes a new instance of the <see cref="Compiler"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="methodInfo">The method information.</param>
/// <param name="emitter">The emitter.</param>
/// <param name="services">The services.</param>
private Compiler(CILMethod method, TypeMethodInfo methodInfo, EmitterBase emitter, TypeServices services)
{
_method = method;
_methodInfo = methodInfo;
E = emitter;
}
protected override void generate(EmitterBase emitter)
{
emitter.DirectInvoke(set);
}
