public override void Compile(Emitter.Emitter emitter)
{
try
{
Resolve(emitter);
if (!emitter.TypeIsParent(IdentifierType, Expression.GetExpressionType(emitter)))
Error(String.Format(Resources.errAssignTypeMismatch, Expression.GetExpressionType(emitter), IdentifierType));
}
catch(CompilerException ex)
{
ex.AffixToLexem(Lexem);
throw;
}
switch (Kind)
{
case IdentifierKind.StaticField: Expression.Compile(emitter);
emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break;
case IdentifierKind.Field: if (ExpressionPrefix != null)
ExpressionPrefix.Compile(emitter);
else
emitter.EmitLoadThis();
Expression.Compile(emitter);
emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break;
case IdentifierKind.Variable: Expression.Compile(emitter);
emitter.EmitSaveVariable(emitter.CurrentMethod.Scope.Find(Name)); break;
case IdentifierKind.Parameter: Expression.Compile(emitter);
emitter.EmitSaveParameter(emitter.CurrentMethod.Parameters[Name].Id); break;
}
}
public override void Compile(Emitter.Emitter emitter)
{
try
{
Resolve(emitter);
}
catch (CompilerException ex)
{
ex.AffixToLexem(Lexem);
throw;
}
switch (Kind)
{
case IdentifierKind.StaticField: emitter.EmitLoadField(emitter.FindField(OwnerType, Name)); break;
case IdentifierKind.Field: if(ExpressionPrefix != null)
ExpressionPrefix.Compile(emitter);
else
emitter.EmitLoadThis();
emitter.EmitLoadField(emitter.FindField(OwnerType, Name)); break;
case IdentifierKind.StaticMethod: emitter.EmitCall(emitter.FindMethod(OwnerType, Name)); break;
case IdentifierKind.Method: if (ExpressionPrefix != null)
ExpressionPrefix.Compile(emitter);
else
emitter.EmitLoadThis();
emitter.EmitCall(emitter.FindMethod(OwnerType, Name)); break;
case IdentifierKind.Variable: emitter.EmitLoadVariable(emitter.CurrentMethod.Scope.Find(Name)); break;
case IdentifierKind.Parameter: emitter.EmitLoadParameter(emitter.CurrentMethod.Parameters[Name].Id); break;
case IdentifierKind.SizeProperty: ExpressionPrefix.Compile(emitter);
emitter.EmitLoadArraySize(); break;
}
}
/// <summary>
/// Emit code for saving local variables into fields
/// </summary>
private void SaveClosuredVariables(Emitter.Emitter emitter, Utils.ScopeVariable variable)
{
foreach (var curr in Closures)
{
emitter.EmitLoadVariable(variable);
// load variable
var currVar = emitter.CurrentMethod.Scope.Find(curr.Key);
emitter.EmitLoadVariable(currVar);
// save into field
var currField = emitter.FindField(PlannerID, "_" + curr.Key);
emitter.EmitSaveField(currField);
}
}
/// <summary>
/// Emit code for loading local variables from fields
/// </summary>
/// <param name="list">List of closures</param>
private void LoadClosuredVariables(Dictionary<string, string> list, Emitter.Emitter emitter)
{
foreach (var curr in list)
{
emitter.EmitLoadThis();
// load field
var currField = emitter.FindField(PlannerID, "_" + curr.Key);
emitter.EmitLoadField(currField);
// save into variable
var currVar = emitter.CurrentMethod.Scope.Introduce(curr.Value, emitter.ResolveType(curr.Value), curr.Key);
emitter.EmitSaveVariable(currVar);
}
}
/// <summary>
/// Resolve the identifier meaning
/// </summary>
public void Resolve(Emitter.Emitter emitter)
{
// already resolved?
if (Kind != IdentifierKind.Unresolved) return;
// atmark?
if (AtmarkPrefix)
{
if (emitter.CurrentType == null)
Error(Resources.errFieldOutsideType);
OwnerType = emitter.CurrentType.Name;
var field = emitter.FindField(emitter.CurrentType.Name, Name);
if (field != null)
Kind = field.Static ? IdentifierKind.StaticField : IdentifierKind.Field;
else
Error(String.Format(Resources.errFieldNotFound, Name, emitter.CurrentType.Name));
// additional check: dynamic field from static method
if (emitter.CurrentMethod.Static && !field.Static)
Error(String.Format(Resources.errDynamicFromStatic, field.Name));
}
// other prefix?
else if (TypePrefix != null || ExpressionPrefix != null)
{
OwnerType = (TypePrefix != null ? TypePrefix.Data : ExpressionPrefix.GetExpressionType(emitter));
if (OwnerType == "null")
Error(Resources.errNullAccessor);
if(OwnerType.EndsWith("[]") && Name == "size")
{
Kind = IdentifierKind.SizeProperty;
return;
}
// check class existence
emitter.FindType(OwnerType);
// field ?
try
{
emitter.FindField(OwnerType, Name);
Kind = (TypePrefix != null ? IdentifierKind.StaticField : IdentifierKind.Field);
return;
}
catch { }
// method ?!
MethodNode method = null;
try
{
method = emitter.FindMethod(OwnerType, Name);
}
catch
{
Error(String.Format(Resources.errTypeIdentifierUnresolved, OwnerType, Name));
}
if (ExpressionPrefix == null && !method.Static)
Error(String.Format(Resources.errNonStaticMethod, Name));
Kind = (TypePrefix != null ? IdentifierKind.StaticMethod : IdentifierKind.Method);
}
else
{
MethodNode method = null;
// local variable
if (emitter.CurrentMethod.Scope.Exists(Name))
{
Kind = IdentifierKind.Variable;
return;
}
// parameter
if(emitter.CurrentMethod.Parameters.Contains(Name))
{
Kind = IdentifierKind.Parameter;
return;
}
// search for a method
try
{
method = emitter.FindMethod(emitter.CurrentType != null ? emitter.CurrentType.Name : "", true, Name);
}
catch
{
Error(String.Format(Resources.errIdentifierUnresolved, Name));
}
OwnerType = method.Owner.Name;
if(method.Static)
Kind = IdentifierKind.StaticMethod;
else
{
// additional check for invoking a dynamic method from static context
if (emitter.CurrentMethod == null || emitter.CurrentMethod.Static)
Error(String.Format(Resources.errDynamicFromStatic, Name));
Kind = IdentifierKind.Method;
}
}
}
public override string GetExpressionType(Emitter.Emitter emitter)
{
if (ExpressionType != "")
return ExpressionType;
try
{
Resolve(emitter);
}
catch (CompilerException ex)
{
ex.AffixToLexem(Lexem);
throw;
}
switch(Kind)
{
case IdentifierKind.StaticField:
case IdentifierKind.Field: ExpressionType = emitter.FindField(OwnerType, Name).Type.Signature; break;
case IdentifierKind.StaticMethod:
case IdentifierKind.Method: ExpressionType = emitter.FindMethod(OwnerType, Name).Type.Signature; break;
case IdentifierKind.Variable: ExpressionType = emitter.CurrentMethod.Scope.Find(Name).Type; break;
case IdentifierKind.Parameter: ExpressionType = emitter.CurrentMethod.Parameters[Name].Type.Signature; break;
case IdentifierKind.SizeProperty: ExpressionType = "int"; break;
}
return ExpressionType;
}
private void Resolve(Emitter.Emitter emitter)
{
// already resolved?
if (Kind != IdentifierKind.Unresolved) return;
// atmark?
if (AtmarkPrefix)
{
OwnerType = emitter.CurrentType.Name;
var field = emitter.FindField(emitter.CurrentType.Name, Name);
if (field != null)
Kind = field.Static ? IdentifierKind.StaticField : IdentifierKind.Field;
else
Error(String.Format(Resources.errFieldNotFound, Name, emitter.CurrentType.Name));
// additional check: dynamic field from static method
if (emitter.CurrentMethod.Static && !field.Static)
Error(String.Format(Resources.errDynamicFromStatic, field.Name));
IdentifierType = field.Type.Signature;
}
// other prefix?
else if (TypePrefix != null || ExpressionPrefix != null)
{
OwnerType = (TypePrefix != null ? TypePrefix.Data : ExpressionPrefix.GetExpressionType(emitter));
// check class existence
var type = emitter.FindType(OwnerType);
if (type == null)
Error(String.Format(Resources.errTypeNotFound, OwnerType), TypePrefix);
// field ?
var field = emitter.FindField(OwnerType, Name);
Kind = (TypePrefix != null ? IdentifierKind.StaticField : IdentifierKind.Field);
IdentifierType = field.Type.Signature;
}
else
{
// local variable
if (emitter.CurrentMethod.Scope.Exists(Name))
{
Kind = IdentifierKind.Variable;
IdentifierType = emitter.CurrentMethod.Scope.Find(Name).Type;
}
// parameter
else if (emitter.CurrentMethod.Parameters.Contains(Name))
{
Kind = IdentifierKind.Parameter;
IdentifierType = emitter.CurrentMethod.Parameters[Name].Type.Signature;
}
// no luck at all
else
Error(String.Format(Resources.errIdentifierUnresolved, Name));
}
}
/// <summary>
/// Generate code to setup the currently defined emitter
/// </summary>
/// <param name="emitter"></param>
private void CompileInitiation(Emitter.Emitter emitter)
{
var emitterType = emitter.FindType(EmitterID);
var tmpVar = emitter.CurrentMethod.Scope.Introduce(EmitterID, emitterType.Type);
// tmp = new emitterN()
emitter.EmitNewObj(emitter.FindMethod(EmitterID, ".ctor"));
emitter.EmitSaveVariable(tmpVar);
// step
if (Step != null)
{
// validate step
var stepType = Step.GetExpressionType(emitter);
if (!stepType.IsAnyOf("int", "float"))
Error(Resources.errEmitStepExpected);
// tmp.Step = step
emitter.EmitLoadVariable(tmpVar);
Step.Compile(emitter);
if (stepType == "int")
emitter.EmitConvertToFloat();
emitter.EmitSaveField(emitter.FindField(EmitterID, "step"));
}
// distribution
if (Distribution != null)
{
// validate distr
if (Distribution.GetExpressionType(emitter) != "distr")
Error(Resources.errEmitDistributionExpected);
// tmp.Distr = distr
emitter.EmitLoadVariable(tmpVar);
Distribution.Compile(emitter);
emitter.EmitSaveField(emitter.FindField(EmitterID, "distr"));
}
// limit
if (Limit != null)
{
// validate distr
if (Limit.GetExpressionType(emitter) != "int")
Error(Resources.errEmitLimitExpected);
// tmp.Distr = distr
emitter.EmitLoadVariable(tmpVar);
Limit.Compile(emitter);
emitter.EmitSaveField(emitter.FindField(EmitterID, "limit"));
}
SaveClosuredVariables(emitter, tmpVar);
// register emitter in the system
emitter.EmitLoadVariable(tmpVar);
var registerMethod = emitter.AssemblyImport(typeof(Simulation).GetMethod("RegisterEmitter", new[] { typeof(EventEmitter) }));
emitter.EmitCall(registerMethod);
}
