public static Expr ctor(ICall call)
{
// Value-type ctors can be called as ctors or as methods. Handle both types
if (call.Obj == null)
{
// Called as ctor
return(call.Arg(0));
}
else
{
// Called as method
ExprVar var;
// Pointers need de-referencing
switch (call.Obj.ExprType)
{
case Expr.NodeType.VariableAddress:
var = (ExprVar)((ExprVariableAddress)call.Obj).Variable;
break;
case Expr.NodeType.ArgAddress:
var = (ExprVar)((ExprArgAddress)call.Obj).Arg;
break;
default:
var = (ExprVar)call.Obj;
break;
}
return(new ExprAssignment(call.Ctx, var, call.Arg(0)));
}
}
public static Expr Insert(ICall call)
{
var ctx = call.Ctx;
var array = GetNamedArrayField(call);
var index = call.Arg(0, "index");
var value = call.Arg(1, "value");
return(new ExprJsExplicit(ctx, "array.splice(index, 0, value)", ctx.Void, array, index, value));
}
public static Expr set_Item(ICall call)
{
var ctx = call.Ctx;
var genType = call.CallMethod.DeclaringType.GetGenericArgument(0);
var array = GetNamedArrayField(call);
var index = call.Arg(0, "index");
var value = call.Arg(1, "value");
return(new ExprJsExplicit(ctx, "array[index] = value", genType, array, index, value));
}
public static Expr Join(ICall call)
{
var ctx = call.Ctx;
var separator = call.Arg(0, "separator");
var values = call.Arg(1);
var sepExpr = new ExprJsExplicit(ctx, "separator || \"\"", ctx.String, separator);
var expr = new ExprJsResolvedMethod(ctx, ctx.String, values, "join", sepExpr);
return(expr);
}
public static Expr InternalReplaceString(ICall call)
{
var ctx = call.Ctx;
var args = new[] {
call.Arg(1),
new ExprJsResolvedMethod(ctx, ctx.String, call.Arg(2), "replace", ctx.Literal("$"), ctx.Literal("$$$$"))
};
return(new ExprJsResolvedMethod(ctx, ctx.String, call.Arg(0), "replace", args));
}
public static Expr SortArrayComparer(ICall call)
{
var ctx = call.Ctx;
var genType = call.CallMethod.GetGenericArgument(0);
var array = call.Arg(0, "array");
var comparer = call.Arg(1);
var comparerType = call.CallMethod.Parameters.ElementAt(1).ParameterType.FullResolve(call.CallMethod);
var mCompare = comparerType.EnumResolvedMethods().First(x => x.Name == "Compare");
var a = ctx.Local(genType, "a");
var b = ctx.Local(genType, "b");
var comparerCall = new ExprCall(ctx, mCompare, comparer, new[] { a.Expr, b.Expr }, true).Named("comparerCall");
var js = "array.sort(function(a, b) { return comparerCall; })";
return(new ExprJsExplicit(ctx, js, ctx.Void, array, comparerCall, a, b));
}
public static Expr Abs(ICall call)
{
var ctx = call.Ctx;
var arg = call.Arg(0);
return(new ExprJsResolvedMethod(ctx, arg.Type, null, "Math.abs", arg));
}
public static Expr ParseInt32(ICall call)
{
var ctx = call.Ctx;
var number = call.Arg(0, "number");
return(new ExprJsExplicit(ctx, "(+number)", ctx.Int32, number));
}
public static Expr Add(ICall call)
{
var ctx = call.Ctx;
var array = GetNamedArrayField(call);
var value = call.Arg(0, "value");
return(new ExprJsExplicit(ctx, "array.push(value)", ctx.Void, array, value));
}
public static Expr RemoveAt(ICall call)
{
var ctx = call.Ctx;
var array = GetNamedArrayField(call);
var index = call.Arg(0, "index");
return(new ExprJsExplicit(ctx, "array.splice(index, 1)", ctx.Void, array, index));
}
public static Expr Min(ICall call)
{
var ctx = call.Ctx;
var arg0 = call.Arg(0);
var arg1 = call.Arg(1);
if (arg0.Type.IsInt64())
{
return(new ExprCall(ctx, (Func <Int64, Int64, Int64>)_Int64.Min, null, arg0, arg1));
}
else if (arg0.Type.IsUInt64())
{
return(new ExprCall(ctx, (Func <UInt64, UInt64, UInt64>)_UInt64.Min, null, arg0, arg1));
}
else
{
return(new ExprJsResolvedMethod(ctx, arg0.Type, null, "Math.min", arg0, arg1));
}
}
public static Expr GetValueOrDefaultParam(ICall call)
{
var ctx = call.Ctx;
var @default = call.Arg(0, "default");
var objIsVar = call.Obj.IsVar();
var temp = objIsVar ? null : ctx.Local(call.Obj.Type);
var js = objIsVar ? "obj !== null ? obj : default" : "(temp = obj) !== null ? temp : default";
return(new ExprJsExplicit(ctx, js, call.Type, temp.Named("temp"), call.Obj.Named("obj"), @default));
}
public static Expr SortComparer(ICall call)
{
var ctx = call.Ctx;
var t = call.CallMethod.DeclaringType.GetGenericArgument(0);
var tComparer = call.CallMethod.Parameters.First().ParameterType.FullResolve(call.CallMethod);
var mGenSort = ((Action <T[], IComparer <T> >)Array.Sort <T>).Method.GetGenericMethodDefinition();
var mSort = ctx.Module.Import(mGenSort).MakeGeneric(t);
var comparer = call.Arg(0, "comparer");
var mDefaultComparerNet = typeof(Comparer <T>).GetProperty("Default").GetMethod;
var mDefaultComparer = ctx.Module.Import(mDefaultComparerNet);
var defaultComparerCall = new ExprCall(ctx, mDefaultComparer, null).Named("defaultComparerCall");
var ensureComparer = new ExprJsExplicit(ctx, "(comparer || defaultComparerCall)", tComparer, comparer, defaultComparerCall);
return(new ExprCall(ctx, mSort, null, GetNamedArrayField(call).Expr, ensureComparer));
}
public static Expr IsPositiveInfinity(ICall call)
{
var ctx = call.Ctx;
return(ctx.ExprGen.Equal(call.Arg(0), ctx.Literal(Single.PositiveInfinity)));
}
public static Expr IsPositiveInfinity(ICall call) {
var ctx = call.Ctx;
return ctx.ExprGen.Equal(call.Arg(0), ctx.Literal(Single.PositiveInfinity));
}
public static Expr IsNegativeInfinity(ICall call)
{
var ctx = call.Ctx;
return(ctx.ExprGen.Equal(call.Arg(0), ctx.Literal(Double.NegativeInfinity)));
}
public static Expr ParseInt32(ICall call) {
var ctx = call.Ctx;
var number = call.Arg(0, "number");
return new ExprJsExplicit(ctx, "(+number)", ctx.Int32, number);
}
public static Expr BinarySearchItemComparer(ICall call)
{
var ctx = call.Ctx;
var t = call.CallMethod.DeclaringType.GetGenericArgument(0);
var mGenBinarySearch = ((Func <T[], T, IComparer <T>, int>)Array.BinarySearch <T>).Method.GetGenericMethodDefinition();
var mBinarySearch = ctx.Module.Import(mGenBinarySearch).MakeGeneric(t);
return(new ExprCall(ctx, mBinarySearch, null, GetNamedArrayField(call).Expr, call.Arg(0), call.Arg(1)));
}
public static Expr Abs(ICall call) {
var ctx = call.Ctx;
var arg = call.Arg(0);
return new ExprJsResolvedMethod(ctx, arg.Type, null, "Math.abs", arg);
}
public static Expr Min(ICall call) {
var ctx = call.Ctx;
var arg0 = call.Arg(0);
var arg1 = call.Arg(1);
if (arg0.Type.IsInt64()) {
return new ExprCall(ctx, (Func<Int64, Int64, Int64>)_Int64.Min, null, arg0, arg1);
} else if (arg0.Type.IsUInt64()) {
return new ExprCall(ctx, (Func<UInt64, UInt64, UInt64>)_UInt64.Min, null, arg0, arg1);
} else {
return new ExprJsResolvedMethod(ctx, arg0.Type, null, "Math.min", arg0, arg1);
}
}
public static NamedExpr Arg(this ICall call, int argIndex, string name)
{
return(call.Arg(argIndex).Named(name));
}
public static Expr IsNegativeInfinity(ICall call) {
var ctx = call.Ctx;
return ctx.ExprGen.Equal(call.Arg(0), ctx.Literal(Double.NegativeInfinity));
}
