public override void Compile(Emitter.Emitter emitter)
{
var type = Expression.GetExpressionType(emitter);
if (type.IsAnyOf("int", "float", "complex"))
{
if(type == "complex")
{
// simple case: the complex is a constant
if(Expression is ComplexNode)
{
(Expression as ComplexNode).Imaginary *= -1;
Expression.Compile(emitter);
}
// complex case: complex is an expression result
else
{
Expression.Compile(emitter);
// tmp = ...
var tmpVar = emitter.CurrentMethod.Scope.Introduce("complex", emitter.FindType("complex").Type);
emitter.EmitSaveVariable(tmpVar);
// tmp.real
emitter.EmitLoadVariableAddress(tmpVar);
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("get_Real")));
// tmp.imaginary * -1
emitter.EmitLoadVariableAddress(tmpVar);
emitter.EmitCall(emitter.AssemblyImport(typeof(SN.Complex).GetMethod("get_Imaginary")));
emitter.EmitLoadFloat(-1);
emitter.EmitMul();
// new complex
emitter.EmitNewObj(emitter.FindMethod("complex", ".ctor", "float", "float"));
}
}
else
{
// multiply by -1
Expression.Compile(emitter);
if (type == "int")
emitter.EmitLoadInt(-1);
else
emitter.EmitLoadFloat(-1);
emitter.EmitMul();
}
}
else
Error(String.Format(Resources.errInvertType, type));
}
public override void Compile(Emitter.Emitter emitter)
{
// check if constructor exists
TypeNode type = null;
try
{
type = emitter.FindType(Name);
}
catch
{
Error(String.Format(Resources.errTypeNotFound, Name));
}
// check if type is an enum?
if (type.Enum)
{
// the constructor in an enum is pseudo-private
// so that it can only be called from another method
// of the same enum type
if(emitter.CurrentMethod == null || emitter.CurrentMethod.Owner != type)
Error(String.Format(Resources.errConstructEnum, Name));
}
MethodNode method = null;
var signature = GetSignature(emitter);
try
{
method = emitter.FindMethod(Name, ".ctor", signature);
}
catch
{
Error(String.Format(Resources.errConstructorNotFound, Name, signature.Join(" ")));
}
// parameters
for (int idx = 0; idx < Parameters.Count; idx++)
{
Parameters[idx].Compile(emitter);
emitter.EmitUpcastBasicType(Parameters[idx].GetExpressionType(emitter), method.Parameters[idx].Type.Signature);
}
emitter.EmitNewObj(method);
}
public override void Compile(Emitter.Emitter emitter)
{
var currType = emitter.CurrentType;
var currMethod = emitter.CurrentMethod;
emitter.CurrentType = emitter.FindType(PlannerID);
// convert the IdentifierGet to IdentifierInvoke with two faux arguments
AppendActionParameters(emitter);
// extract closured variables
var detector = new Utils.ClosureDetector();
Closures = detector.Process(Action, emitter);
DeclareClosuredVariables(emitter);
// generate closured code for emitter
CompileBody(emitter);
emitter.CurrentType = currType;
emitter.CurrentMethod = currMethod;
CompileInitiation(emitter);
}
public override void Compile(Emitter.Emitter emitter)
{
var currType = emitter.CurrentType;
var currMethod = emitter.CurrentMethod;
emitter.CurrentType = emitter.FindType(EmitterID);
// extract closured variables
var detector = new Utils.ClosureDetector();
ActionClosures = detector.Process(Action, emitter);
if (Condition != null)
ConditionClosures = detector.Process(Condition, emitter);
MergeClosures();
DeclareClosuredVariables(emitter);
// generate closured code for emitter
CompileBody(emitter);
emitter.CurrentType = currType;
emitter.CurrentMethod = currMethod;
CompileInitiation(emitter);
}
/// <summary>
/// Create fields in the emitter type to save local variables intos
/// </summary>
private void DeclareClosuredVariables(Emitter.Emitter emitter)
{
var flowSimType = emitter.FindType(PlannerID);
foreach (var curr in Closures)
{
var fld = emitter.CreateField(flowSimType, "_" + curr.Key, new SignatureNode(curr.Value));
emitter.PrepareField(fld);
}
}
/// <summary>
/// Generate code to setup the currently defined emitter
/// </summary>
/// <param name="emitter"></param>
private void CompileInitiation(Emitter.Emitter emitter)
{
var flowSimType = emitter.FindType(PlannerID);
var tmpVar = emitter.CurrentMethod.Scope.Introduce(PlannerID, flowSimType.Type);
// tmp = new flowsimN()
emitter.EmitNewObj(emitter.FindMethod(PlannerID, ".ctor"));
emitter.EmitSaveVariable(tmpVar);
SaveClosuredVariables(emitter, tmpVar);
// call FlowSimulation.Start(planner)
emitter.EmitLoadVariable(tmpVar);
var method = emitter.AssemblyImport(typeof(FlowSimulation).GetMethod("Start", new[] { typeof(Planner) }));
emitter.EmitCall(method);
}
/// <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 void Compile(Emitter.Emitter emitter)
{
var fromType = Expression.GetExpressionType(emitter);
var toType = ToType;
var simpleTypes = new[] { "bool", "int", "float", "long", "complex" };
if (emitter.ResolveType(toType) == null)
Error(String.Format(Resources.errTypeNotFound, toType));
// compile the expression itself
Expression.Compile(emitter);
// idiotic case?
if (fromType == toType) return;
if(fromType == "null")
{
if(toType.IsAnyOf(simpleTypes))
Error(String.Format(Resources.errInvalidNullCast, toType));
// no actual casting is required
}
// cast simple types
else if(fromType.IsAnyOf(simpleTypes))
{
if (toType.IsAnyOf(simpleTypes))
{
switch(toType)
{
case "bool": emitter.EmitConvertToBool(); break;
case "int": emitter.EmitConvertToInt(); break;
case "float": emitter.EmitConvertToFloat(); break;
default: throw new NotImplementedException();
}
}
else
Error(String.Format(Resources.errInvalidCast, fromType, toType));
}
else
{
// complex type to simple type: search for a conversion method
if(toType.IsAnyOf(simpleTypes))
{
// to_b, to_f, to_i
string methodName = "to_" + toType[0];
MethodNode converter = null;
try
{
converter = emitter.FindMethod(fromType, methodName);
}
catch
{
Error(String.Format(Resources.errInvalidCast, fromType, toType));
}
// call the method
emitter.EmitCall(converter);
}
else
{
if (fromType.Contains("[]") || toType.Contains("[]"))
Error(Resources.errCastArray);
if(!emitter.TypeCastable(fromType, toType))
Error(String.Format(Resources.errInvalidCast, fromType, toType));
var type = emitter.FindType(toType);
emitter.EmitCast(type.Type);
}
}
}
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);
}
public void Resolve(Emitter.Emitter emitter)
{
// build signature
var signature = GetSignature(emitter);
MethodNode method;
// type prefix ?
if(TypePrefix != null)
{
OwnerType = TypePrefix.Data;
Static = true;
// check class existence
emitter.FindType(OwnerType);
method = emitter.FindMethod(TypePrefix.Data, Name, signature);
if (!method.Static)
Error(String.Format(Resources.errNonStaticMethod, Name));
}
// expression prefix ?
else if(ExpressionPrefix != null)
{
OwnerType = ExpressionPrefix.GetExpressionType(emitter);
if (OwnerType == "null")
Error(Resources.errNullAccessor);
emitter.FindMethod(OwnerType, Name, signature);
}
// local or visible method ?
else
{
// try to find method in local type, if there's one
var tmpOwner = emitter.CurrentType != null ? emitter.CurrentType.Name : "";
method = emitter.FindMethod(tmpOwner, true, Name, signature);
OwnerType = method.Owner.Name;
Static = method.Static;
}
}
