public ILIf(ILValue c, ILStatement t, ILStatement f)
{
condition = c;
if_true_statement = t;
if_false_statement = f;
}
static public ILBody Write(MethodBase method, ILGenerator generator, ILStatement statement)
{
ILBody body = new ILBody(method, statement);
body.Write(generator);
return(body);
}
public ILSwitch(ILValue i, ILStatement d, IEnumerable <ILCase> c)
{
input = i;
cases = c.Sort(z => (IComparable)z.GetLabelValue()).ToList();
default_statement = d;
}
public void AddStatement(ILStatement to_add)
{
if (to_add == null)
{
throw new ArgumentNullException("to_add");
}
statements.Add(to_add);
}
private void RenderIL_ExecuteInternal(ILCanvas canvas, ILValue value, ILStatement else_statement)
{
int index = cases.Count / 2;
canvas.UseValue(value, delegate(ILValue local) {
cases[index].GenerateStatement(local, cases, else_statement, 0, cases.Count, index)
.RenderIL_Execute(canvas);
});
}
public ILLoadStatement(Operation <ILValue, ILBlock> o)
{
ILBlock block = new ILBlock();
ILValue value = o(block);
block.AddStatement(new ILLoad(value));
type = value.GetValueType();
statement = block;
}
public ILStatement GenerateStatement(ILValue value, IList <ILCase> cases, ILStatement else_statement, int min_index, int max_index, int index)
{
int less_index = (index + min_index) / 2;
int greater_index = (index + max_index) / 2;
if (index == min_index || index == max_index)
{
return(new ILIf(
value.GetILEqualTo(label),
statement,
else_statement
));
}
return(new ILIf(
value.GetILLessThan(label),
cases[less_index].GenerateStatement(value, cases, else_statement, min_index, index, less_index),
cases[greater_index].GenerateStatement(value, cases, else_statement, index, max_index, greater_index)
));
}
static public ILBody Write(MethodBuilderEX builder, ILStatement statement)
{
return(Write(builder, builder.GetILGenerator(), statement));
}
static public ILBody Write(DynamicMethod method, ILStatement statement)
{
return(Write(method, method.GetILGenerator(), statement));
}
static public void RenderText_StatementEX(this ILStatement item, ILTextCanvas canvas)
{
item.IfNotNull(i => i.RenderText_Statement(canvas), () => canvas.AppendToLine("?????;"));
}
static public T CreateDynamicMethodDelegate <T>(this Type item, string name, ILStatement statement)
{
return(item.CreateDynamicMethodDelegate <T>(name, delegate(MethodBase method) {
return statement;
}));
}
public ILWhile(ILValue c, ILStatement w)
{
condition = c;
while_statement = w;
}
public ILCase(ILLiteral l, ILStatement s)
{
label = l;
statement = s;
}
public ILSwitch(ILValue i, ILStatement d, params ILCase[] c) : this(i, d, (IEnumerable <ILCase>)c)
{
}
public ILBody(MethodBase m, ILStatement s)
{
method = m;
statement = s;
}
static public ConstructorBuilderEX CreateConstructor(this TypeBuilder item, MethodAttributes attributes, ILStatement statement, params Type[] parameter_types)
{
return(item.CreateConstructor(attributes, statement, (IEnumerable <Type>)parameter_types));
}
public ILIf(ILValue c, ILStatement t) : this(c, t, null)
{
}
static public MethodBuilderEX CreateMethod(this TypeBuilder item, string name, MethodAttributes method_attributes, ILStatement statement, params Type[] parameter_types)
{
return(item.CreateMethod(name, method_attributes, statement, (IEnumerable <Type>)parameter_types));
}
public ILLoadStatement(Type t, ILStatement s)
{
type = t;
statement = s;
}
static public T CreateDynamicMethodDelegate <T>(this Type item, ILStatement statement)
{
return(item.CreateDynamicMethodDelegate <T>(typeof(T).Name, statement));
}
public ILInjectCave(ILStatement s)
{
entry_label = new ILLabel();
statement = s;
}
