public override void GenerateCode(Emit.MethodBodyGenerator generator)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals()
{
NonDefaultBreakStatementBehavior = true, NonDefaultSourceSpanBehavior = true
};
GenerateStartOfStatement(generator, statementLocals);
// Set up some labels.
var continueTarget = generator.CreateLabel();
var breakTarget = generator.CreateLabel();
// Emit the initialization statement.
if (Initialization != null)
{
Initialization.GenerateCode(generator);
}
// The inner loop starts here.
var startOfLoop = generator.CreateLabel();
var startOfCondition = generator.CreateLabel();
if (CheckConditionAtEnd == false)
{
generator.Branch(startOfCondition);
}
//start of loop
generator.DefineLabelPosition(startOfLoop);
// Emit the loop body.
generator.PushBreakOrContinueInfo(Labels, breakTarget, continueTarget, false);
Body.GenerateCode(generator);
generator.PopBreakOrContinueInfo();
// The continue statement jumps here.
generator.DefineLabelPosition(continueTarget);
// Increment the loop variable.
if (Increments != null)
{
Increments.ForEach(e => e.Accept(generator).GenerateCode(generator));
}
generator.DefineLabelPosition(startOfCondition);
// Check the condition and jump to the end if it is false.
if (Condition != null)
{
// generator.MarkSequencePoint(ConditionStatement.Span);
Condition.Accept(generator).GenerateCode(generator);
generator.CallStatic(Utils.ReflectionHelpers.BoooleanToBool);
generator.BranchIfTrue(startOfLoop);
}
// Define the end of the loop (actually just after).
generator.DefineLabelPosition(breakTarget);
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, statementLocals);
}
/// <inheritdoc/>
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption options)
{
Type = VariableType != null?VariableType.ResolveType(generator.Context) : TypeProvider.AnyType;
if (Value != null)
{
var defValue = Value.Accept(generator);
defValue.GenerateCode(generator, AssignOption);
if (VariableType == null)
{
Type = defValue.Type;
}
else if (!TypeUtils.AreReferenceAssignable(Type, defValue.Type) && defValue.Type.TryImplicitConvert(Type, out System.Reflection.MethodInfo opConvert))
{
// When converting value type to Any, must do Box
if (defValue.Type.IsValueType && opConvert.GetParameters()[0].ParameterType.IsValueType == false)
{
generator.Box(defValue.Type);
}
generator.CallStatic(opConvert);
}
else if (defValue.Type.IsValueType && !Type.IsValueType)
{
generator.Box(defValue.Type);
}
}
//initialize
var variable = generator.DeclareVariable(Type, Name);
generator.StoreVariable(variable);
return;
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption option)
{
Target.GenerateCode(generator);
if (TypeSyntax is null || (TypeSyntax is RefTypeSyntax refType && refType.Name.Equals(LiteralExpression.NullString)))
{
generator.LoadNull();
generator.CompareEqual();
}
/// <inheritdoc/>
public override void GenerateCode(Emit.MethodBodyGenerator generator)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals();
GenerateStartOfStatement(generator, statementLocals);
var condition = Condition.Accept(generator);
// Generate code for condition convert to System.Boolean
condition.GenerateCode(generator, Emit.MethodCompileOption.Return);
if (condition.Type != typeof(bool))
{
if (condition.Type == TypeProvider.BooleanType)
{
generator.CallStatic(Utils.ReflectionHelpers.BoooleanToBool);
}
else if (condition.Type.TryImplicitConvert(TypeProvider.BooleanType, out MethodInfo op_Implicit))
{
generator.CallStatic(op_Implicit);
generator.CallStatic(Utils.ReflectionHelpers.BoooleanToBool);
}
else
{
throw new System.InvalidCastException($"Unable to cast object of type {condition.Type} to {TypeProvider.BooleanType}");
}
}
// We will need a label at the end of the if statement.
var endOfEverything = generator.CreateLabel();
if (Else == null)
{
//jump to end of if clause
generator.BranchIfFalse(endOfEverything);
//generate code for then clause
Then.GenerateCode(generator);
}
else
{
//branch to else clause if false
var startOfElseClause = generator.CreateLabel();
generator.BranchIfFalse(startOfElseClause);
//generate code for then clause
Then.GenerateCode(generator);
//brach to end of everything
generator.Branch(endOfEverything);
//generate code of else clause
generator.DefineLabelPosition(startOfElseClause);
Else.GenerateCode(generator);
}
//define label at end of statement
generator.DefineLabelPosition(endOfEverything);
//generate code for end of statement
GenerateEndOfStatement(generator, statementLocals);
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption options)
{
Target.GenerateCode(generator);
if (Method != null)
{
// implicit conversion
generator.CallStatic(Method);
}
else
{
generator.CastClass(Type);
}
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption options)
{
if (generator.Method is Generators.DynamicMethodGenerator)
{
// for annonymous type
// if this is used in anonymous function or objects
var variable = generator.GetLocalVariable("__value");
generator.LoadVariable(variable);
}
else
{
generator.LoadArgument(0);
}
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption option)
{
generator.NewObject(ReflectionHelpers.AnonymousObj);
for (int i = 0; i < Members.Count; i++)
{
var member = Members[i];
generator.Duplicate();
generator.LoadString(member.Name);
member.Expression.GenerateCode(generator, AssignOption);
if (member.Expression.Type.IsValueType)
{
generator.Box(member.Expression.Type);
}
generator.CallVirtual(ReflectionHelpers.AnonymousObj_SetItem);
}
generator.NewObject(ReflectionHelpers.Any_New);
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption option)
{
Left.GenerateCode(generator);
generator.Duplicate();
var end = generator.CreateLabel();
if (Left.Type.IsValueType)
{
if (Left.Type.TryImplicitConvert(TypeProvider.BooleanType, out System.Reflection.MethodInfo op_Implicit))
{
generator.CallStatic(op_Implicit);
generator.CallStatic(Utils.ReflectionHelpers.BoooleanToBool);
}
else
{
throw new System.InvalidCastException($"Unable to cast object of type {Left.Type} to {TypeProvider.BooleanType}");
}
}
generator.BranchIfTrue(end);
generator.Pop();
Right.GenerateCode(generator, Emit.MethodCompileOption.Dupplicate);
generator.DefineLabelPosition(end);
}
/// <summary>
/// Creates IL code
/// </summary>
/// <param name="generator">The generator to output the CIL to.</param>
public virtual void GenerateCode(Emit.MethodBodyGenerator generator)
{
generator.NoOperation();
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption option)
{
CustomGeneration(this, generator);
}
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption option = 0)
{
generator.EmitArguments(Arguments, Conversions);
generator.NewObject(Constructor);
}
/// <inheritdoc/>
public override void GenerateCode(Emit.MethodBodyGenerator generator, Emit.MethodCompileOption options)
{
//todo unsigned to signed
switch (Value)
{
case sbyte b:
generator.LoadByte(b);
break;
case byte b:
generator.LoadByte(b);
break;
case short s:
generator.LoadInt16(s);
break;
case ushort s:
generator.LoadInt16(s);
break;
case int i:
generator.LoadInt32(i);
break;
case uint i:
generator.LoadInt32(i);
break;
case long l:
generator.LoadInt64(l);
break;
case ulong l:
generator.LoadInt64(l);
break;
case float f:
generator.LoadSingle(f);
break;
case double d:
generator.LoadDouble(d);
break;
case bool b:
generator.LoadBool(b);
break;
case char c:
generator.LoadChar(c);
break;
case string s:
generator.LoadString(s);
break;
case null:
generator.LoadNull();
break;
}
}
public override void GenerateCode(Emit.MethodBodyGenerator generator)
{
Expression.Accept(generator).GenerateCode(generator);
}
