public override void Emit(CodeGen cg)
{
Label eoi = cg.DefineLabel();
Label next = cg.DefineLabel();
_test.Emit(cg);
cg.Emit(OpCodes.Brfalse, next);
if (_true.Type != _expressionType)
{
_true.EmitAs(cg, _expressionType);
}
else
{
_true.Emit(cg);
}
cg.Emit(OpCodes.Br, eoi);
cg.MarkLabel(next);
if (_false.Type != _expressionType)
{
_false.EmitAs(cg, _expressionType);
}
else
{
_false.Emit(cg);
}
cg.MarkLabel(eoi);
}
public override void Emit(CodeGen cg)
{
if (NodeType == AstNodeType.Convert && _operand is ConstantExpression &&
_operand.Type == typeof(bool) && _type == typeof(object))
{
_operand.EmitAs(cg, typeof(object));
}
else
{
_operand.Emit(cg);
EmitLocation(cg);
switch (NodeType)
{
case AstNodeType.Convert:
if (_type != _operand.Type && _type.Name == "Callable" && Converter != null)
{
if (_operand.Type.IsValueType)
{
cg.EmitBoxing(_operand.Type);
}
cg.EmitCall(Converter);
}
else
{
cg.EmitCast(_operand.Type, _type);
}
break;
case AstNodeType.Not:
if (_operand.Type == typeof(bool))
{
cg.Emit(OpCodes.Ldc_I4_0);
cg.Emit(OpCodes.Ceq);
}
else
{
cg.Emit(OpCodes.Not);
}
break;
case AstNodeType.Negate:
cg.Emit(OpCodes.Neg);
break;
case AstNodeType.OnesComplement:
cg.Emit(OpCodes.Not);
break;
default:
throw new NotImplementedException();
}
}
}
public override void Emit(CodeGen cg)
{
EmitLocation(cg);
_value.EmitAs(cg, _vr.Slot.Type);
//cg.Emit(OpCodes.Dup);
_vr.Slot.EmitSet(cg);
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
}
public override void Emit(CodeGen cg)
{
Nullable <Label> firstTime = null;
Label eol = cg.DefineLabel();
Label breakTarget = cg.DefineLabel();
Label continueTarget = cg.DefineLabel();
if (_increment != null)
{
firstTime = cg.DefineLabel();
cg.Emit(OpCodes.Br, firstTime.Value);
}
if (_header.IsValid)
{
//cg.EmitPosition(Start, _header);
}
cg.MarkLabel(continueTarget);
if (_increment != null)
{
_increment.EmitAs(cg, typeof(void));
cg.MarkLabel(firstTime.Value);
}
if (_test != null)
{
_test.Emit(cg);
cg.Emit(OpCodes.Brfalse, eol);
}
cg.PushTargets(breakTarget, continueTarget, this);
_body.Emit(cg);
cg.Emit(OpCodes.Br, continueTarget);
cg.PopTargets();
cg.MarkLabel(eol);
if (_else != null)
{
_else.Emit(cg);
}
cg.MarkLabel(breakTarget);
}
public override void Emit(CodeGen cg)
{
_value.EmitAs(cg, _vr.Slot.Type);
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionIn);
}
_vr.Slot.EmitSet(cg);
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
_vr.Variable.SetInitialized();
}
public override void Emit(CodeGen cg)
{
//_value.Emit(cg);
// Save the expression value - order of evaluation is different than that of the Stelem* instruction
//Slot temp = cg.GetLocalTmp(_elementType);
//temp.EmitSet(cg);
// Emit the array reference
_array.Emit(cg);
// Emit the index (as integer)
_index.Emit(cg);
// Emit the value
_value.EmitAs(cg, _elementType);
//temp.EmitGet(cg);
// Store it in the array
EmitLocation(cg);
cg.EmitStoreElement(_elementType);
//temp.EmitGet(cg); //DO NOT WANT!!!
//cg.FreeLocalTmp(temp);
}
public override void Emit(CodeGen cg)
{
_value.EmitAs(cg, _vr.Slot.Type);
//if (_vr.Variable.Type == typeof(object) && _value.Type.IsValueType && _value.Type != typeof(SymbolId))
//{
// cg.EmitBoxing(_value.Type);
//}
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionIn);
}
_vr.Slot.EmitSet(cg);
if (ScriptDomainManager.Options.LightweightDebugging && Span.IsValid)
{
cg.EmitConstant(SpanToLong(Span));
cg.EmitCall(Debugging.DebugMethods.ExpressionOut);
}
_vr.Variable.SetInitialized();
}
public override void Emit(CodeGen cg)
{
//if (NodeType == AstNodeType.Convert && _operand is BoundExpression)
//{
// var be = _operand as BoundExpression;
// var tv = be.Variable.GetTypedVariable(Type);
// if (tv != null)
// {
// tv.
// return;
// }
//}
if (NodeType == AstNodeType.Convert && _operand is ConstantExpression &&
_operand.Type == typeof(bool) && _type == typeof(object))
{
_operand.EmitAs(cg, typeof(object));
}
else
{
_operand.Emit(cg);
EmitLocation(cg);
switch (NodeType)
{
case AstNodeType.Convert:
if (_type != _operand.Type && _type.Name == "Callable" && Converter != null)
{
cg.EmitCall(Converter);
}
else
{
cg.EmitCast(_operand.Type, _type);
}
break;
case AstNodeType.Not:
if (_operand.Type == typeof(bool))
{
cg.Emit(OpCodes.Ldc_I4_0);
cg.Emit(OpCodes.Ceq);
}
else
{
cg.Emit(OpCodes.Not);
}
break;
case AstNodeType.Negate:
cg.Emit(OpCodes.Neg);
break;
case AstNodeType.OnesComplement:
cg.Emit(OpCodes.Not);
break;
default:
throw new NotImplementedException();
}
}
}
private bool EmitBranchTrue(CodeGen cg, AstNodeType nodeType, Label label)
{
switch (nodeType)
{
case AstNodeType.GreaterThan:
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Bgt, label);
cg.EmitSequencePointNone();
return(true);
case AstNodeType.GreaterThanOrEqual:
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Bge, label);
cg.EmitSequencePointNone();
return(true);
case AstNodeType.LessThan:
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Blt, label);
cg.EmitSequencePointNone();
return(true);
case AstNodeType.LessThanOrEqual:
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Ble, label);
cg.EmitSequencePointNone();
return(true);
case AstNodeType.Equal:
if (_left.IsConstant(null))
{
_right.EmitAsObject(cg);
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Brfalse, label);
cg.EmitSequencePointNone();
}
else if (_right.IsConstant(null))
{
_left.EmitAsObject(cg);
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Brfalse, label);
cg.EmitSequencePointNone();
}
else
{
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Beq, label);
cg.EmitSequencePointNone();
}
return(true);
case AstNodeType.NotEqual:
if (_left.IsConstant(null))
{
_right.EmitAsObject(cg);
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Brtrue, label);
cg.EmitSequencePointNone();
}
else if (_right.IsConstant(null))
{
_left.EmitAsObject(cg);
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Brtrue, label);
cg.EmitSequencePointNone();
}
else
{
_left.EmitAs(cg, GetEmitType());
_right.EmitAs(cg, GetEmitType());
//cg.Emit(OpCodes.Ceq);
cg.EmitSequencePointNone();
cg.Emit(OpCodes.Bne_Un, label);
cg.EmitSequencePointNone();
}
return(true);
case AstNodeType.AndAlso:
// if (left AND right) branch label
// if (left) then
// if (right) branch label
// endif
Label endif = cg.DefineLabel();
_left.EmitBranchFalse(cg, endif);
_right.EmitBranchTrue(cg, label);
cg.MarkLabel(endif);
return(true);
case AstNodeType.OrElse:
// if (left OR right) branch label
// if (left) then branch label endif
// if (right) then branch label endif
_left.EmitBranchTrue(cg, label);
_right.EmitBranchTrue(cg, label);
return(true);
default:
return(false);
}
}
