public ExprFieldAddress(Ctx ctx, Expr obj, FieldReference field)
: base(ctx) {
this.Obj = obj;
this.Field = field;
this.ElementType = field.FieldType.FullResolve(field);
this.type = this.ElementType.MakePointer();
}
public ExprVariableAddress(Ctx ctx, Expr variable, TypeReference type)
: base(ctx) {
//this.Index = index;
this.Variable = variable;
this.ElementType = type;
this.type = type.MakePointer();
}
public StmtTry(Ctx ctx, Instruction @try, Instruction @catch, Instruction @finally, TypeReference catchType)
: base(ctx) {
this.@try = @try;
this.@catch = @catch;
this.@finally = @finally;
this.catchType = catchType;
}
public ExprBinary(Ctx ctx, BinaryOp op, TypeReference type, Expr left, Expr right)
: base(ctx) {
this.Op = op;
this.type = type;
this.Left = left;
this.Right = right;
}
public ExprArgAddress(Ctx ctx, Expr arg, TypeReference type)
: base(ctx) {
//this.Index = index;
this.Arg = arg;
this.ElementType = type;
this.type = type.MakePointer();
}
public ExprTernary(Ctx ctx, Expr condition, Expr ifTrue, Expr ifFalse)
: base(ctx) {
this.Condition = condition;
this.IfTrue = ifTrue;
this.IfFalse = ifFalse;
this.type = TypeCombiner.Combine(ctx, ifTrue, ifFalse);
}
public ExprJsResolvedMethod(Ctx ctx, TypeReference returnType, Expr obj, string methodName, IEnumerable<Expr> args)
: base(ctx) {
this.returnType = returnType;
this.Obj = obj;
this.MethodName = methodName;
this.Args = args;
}
public static Stmt ctor(Ctx ctx) {
Expression<Func<int>> eHashCode = () => hashCode;
var field = (FieldInfo)((MemberExpression)eHashCode.Body).Member;
var f = ctx.Module.Import(field);
var fExpr = new ExprFieldAccess(ctx, null, f).Named("hashCode");
var stmt = new StmtJsExplicit(ctx, "this.$=++hashCode;", ctx.ThisNamed, fExpr);
return stmt;
}
public CilProcessor(Ctx ctx, Stack<Expr> stack, Expr[] locals, Expr[] args, Dictionary<Instruction, ExprVarInstResult> instResults) {
this.ctx = ctx;
this.stack = stack;
this.locals = locals;
this.args = args;
this.instResults = instResults;
this.localTypes = ctx.MDef.Body.Variables.Select(x => x.VariableType.FullResolve(ctx)).ToArray();
}
public StmtCil(Ctx ctx, IEnumerable<Instruction> insts, Stmt endCil, SpecialBlock blockType = SpecialBlock.Normal)
: base(ctx) {
this.Insts = insts;
this.BlockType = blockType;
this.EndCil = endCil;
this.StartStackSize = 0;
this.EndStackSize = 0;
}
//public ExprJsVirtualCall(Ctx ctx, MethodReference callMethod, Expr objInit, Expr objRef, IEnumerable<Expr> args)
public ExprJsVirtualCall(Ctx ctx, MethodReference callMethod, Expr runtimeType, Expr objRef, IEnumerable<Expr> args)
: base(ctx) {
this.CallMethod = callMethod;
//this.ObjInit = objInit;
this.RuntimeType = runtimeType;
this.ObjRef = objRef;
this.Args = args;
this.returnType = callMethod.ReturnType.FullResolve(callMethod);
}
public static Stmt IsWhiteSpace(Ctx ctx) {
// See http://msdn.microsoft.com/en-us/library/t809ektx.aspx for list
var whiteSpace = " \u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029\u0009\u000a\u000b\u000c\u000d\u0085\u00a0";
var arg0 = ctx.MethodParameter(0);
var c = new ExprJsResolvedMethod(ctx, ctx.String, null, "String.fromCharCode", arg0);
var indexOf = new ExprJsResolvedMethod(ctx, ctx.Boolean, ctx.Literal(whiteSpace), "indexOf", c);
return new StmtReturn(ctx,
new ExprBinary(ctx, BinaryOp.GreaterThanOrEqual, ctx.Boolean, indexOf, ctx.Literal(0)));
}
public ExprCall(Ctx ctx, MethodReference callMethod, Expr obj, IEnumerable<Expr> args, bool isVirtualCall, TypeReference constrainedType, TypeReference forceReturnType)
: base(ctx) {
this.CallMethod = callMethod;
this.Obj = obj;
this.Args = args;
this.IsVirtualCall = isVirtualCall;
this.ConstrainedType = constrainedType;
this.returnType = forceReturnType ?? callMethod.ReturnType.FullResolve(callMethod);
}
public static TypeReference Combine(Ctx ctx, TypeReference a, TypeReference b) {
if (a.IsSame(b)) {
return a;
}
var t = Tuple.Create(a, b);
if (t.Perms((x, y) => x.IsBoolean() && y.IsInt32())) {
return ctx.Boolean;
}
return ctx.Object;
}
public StmtBlock(Ctx ctx, IEnumerable<Stmt> statements)
: base(ctx) {
// Expand any nested blocks. Evaluate to array.
this.Statements = statements.SelectMany(x => {
if (x == null) {
return Enumerable.Empty<Stmt>();
}
if (x.StmtType == NodeType.Block) {
return ((StmtBlock)x).Statements;
}
return new[] { x };
}).Where(x => x != null).ToArray();
}
public Ctx(TypeReference tRef, MethodReference mRef, Ctx fromCtx = null) {
this.TRef = tRef;
this.TDef = tRef.Resolve();
this.MRef = mRef;
this.MDef = mRef.Resolve();
this.HasFakeThis = mRef.Parameters.FirstOrDefault().NullThru(x => x.GetCustomAttribute<JsFakeThisAttribute>() != null);
this.Module = mRef.Module;
this.TypeSystem = mRef.Module.TypeSystem;
this.ExprGen = Expr.CreateExprGen(this);
this.This = fromCtx == null ? (this.MDef.IsStatic ? null : new ExprVarThis(this, tRef)) : fromCtx.This;
this.type = new Lazy<TypeReference>(() => this.Module.Import(typeof(Type)));
this._int64 = new Lazy<TypeReference>(() => this.Module.Import(typeof(Cls._Int64)));
this._uint64 = new Lazy<TypeReference>(() => this.Module.Import(typeof(Cls._UInt64)));
}
public static Stmt Atan2(Ctx ctx) {
var arg0 = ctx.MethodParameter(0);
var arg1 = ctx.MethodParameter(1);
var eg = ctx.ExprGen;
return new StmtReturn(ctx,
new ExprTernary(ctx,
eg.And(
eg.Not(new ExprJsResolvedMethod(ctx, ctx.Boolean, null, "Number.isFinite", arg0)),
eg.Not(new ExprJsResolvedMethod(ctx, ctx.Boolean, null, "Number.isFinite", arg1))
),
ctx.Literal(Double.NaN),
new ExprJsResolvedMethod(ctx, ctx.Double, null, "Math.atan2", arg0, arg1)
)
);
}
public Stmt GetImpl(Ctx ctx) {
var a = ctx.MethodParameter(0, "a");
var b = ctx.MethodParameter(1, "b");
var hi = ctx.Local(ctx.UInt64, "hi");
var lo = ctx.Local(ctx.UInt64, "lo");
var limit = ctx.Literal(0x100000000UL, ctx._UInt64, "limit");
var js = @"
hi = a[0] - b[0];
lo = a[1] - b[1];
if (lo < 0) {
lo += limit;
hi--;
}
if (hi < 0) hi += limit;
return [hi, lo];
";
var stmt = new StmtJsExplicit(ctx, js, a, b, hi, lo, limit);
return stmt;
}
public Stmt GetImpl(Ctx ctx) {
var a = ctx.MethodParameter(0).Named("a");
var b = ctx.MethodParameter(1).Named("b");
var hi = ctx.Local(ctx.UInt64, "hi");
var lo = ctx.Local(ctx.UInt64, "lo");
var limit = ctx.Literal(0x100000000UL, ctx._UInt64, "limit");
var js = @"
hi = a[0] + b[0];
lo = a[1] + b[1];
if (lo >= limit) {
lo -= limit;
hi++;
}
if (hi >= limit) hi -= limit;
return [hi, lo];
";
var stmt = new StmtJsExplicit(ctx, js, a, b, hi, lo, limit);
return stmt;
}
public static Stmt Abs(Ctx ctx) {
var arg = ctx.MethodParameter(0);
ExprLiteral minVal;
switch (arg.Type.MetadataType) {
case MetadataType.SByte: minVal = ctx.Literal(Int8.MinValue); break;
case MetadataType.Int16: minVal = ctx.Literal(Int16.MinValue); break;
case MetadataType.Int32: minVal = ctx.Literal(Int32.MinValue); break;
case MetadataType.Int64: minVal = ctx.Literal(Int64.MinValue); break;
default: throw new InvalidOperationException("Cannot handle: " + arg.Type);
}
var exCtor = ctx.Module.Import(typeof(OverflowException).GetConstructor(Type.EmptyTypes));
return new StmtIf(ctx,
ctx.ExprGen.Equal(arg, minVal),
new StmtThrow(ctx, new ExprNewObj(ctx, exCtor)),
new StmtReturn(ctx,
arg.Type.IsInt64() ?
(Expr)new ExprCall(ctx, (Func<Int64, Int64>)_Int64.Abs, null, arg) :
(Expr)new ExprJsResolvedMethod(ctx, arg.Type, null, "Math.abs", arg))
);
}
public Stmt GetImpl(Ctx ctx) {
var a = ctx.MethodParameter(0, "a");
var b = ctx.MethodParameter(1, "b");
var aa = ctx.Local(ctx.Int32.MakeArray(), "aa");
var bb = ctx.Local(ctx.Int32.MakeArray(), "bb");
var ia = ctx.Local(ctx.Int32, "ia");
var ib = ctx.Local(ctx.Int32, "ib");
var mul = ctx.Local(ctx.Int32, "mul");
var add = ctx.Local(ctx.Int32, "add");
var mulCarry = ctx.Local(ctx.Int32, "mulCarry");
var addCarry = ctx.Local(ctx.Int32, "addCarry");
var rrOfs = ctx.Local(ctx.Int32, "rrOfs");
var rr = ctx.Local(ctx.Int32.MakeArray(), "rr");
var mask = ctx.Literal(0xffff, ctx.Int32, "mask");
var limit = ctx.Literal(0x10000, ctx.Int32, "limit");
var js = @"
aa = [a[0] >>> 16, a[0] & mask, a[1] >>> 16, a[1] & mask];
bb = [b[0] >>> 16, b[0] & mask, b[1] >>> 16, b[1] & mask];
rr = [0, 0, 0, 0];
for (ib = 3; ib >= 0; ib--) {
mulCarry = 0;
addCarry = 0;
for(ia = 3; ia >= 3 - ib; ia--) {
rrOfs = ia + ib - 3;
mul = aa[ia] * bb[ib] + mulCarry;
mulCarry = mul >>> 16;
add = rr[rrOfs] + (mul & mask) + addCarry;
if (add >= limit){
rr[rrOfs] = add - limit;
addCarry = 1;
} else {
rr[rrOfs] = add;
addCarry = 0;
}
}
}
return [rr[1] + rr[0] * limit, rr[3] + rr[2] * limit];
";
var stmt = new StmtJsExplicit(ctx, js, a, b, aa, bb, rr, mask, limit, ia, ib, mul, add, mulCarry, addCarry, rrOfs);
return stmt;
}
public ExprRuntimeHandle(Ctx ctx, MemberReference member)
: base(ctx) {
var tokenType = member.MetadataToken.TokenType;
switch (tokenType) {
case TokenType.TypeDef:
case TokenType.TypeRef:
case TokenType.TypeSpec:
case TokenType.GenericParam:
this.Member = ((TypeReference)member).FullResolve(ctx);
this.type = ctx.Module.Import(typeof(RuntimeTypeHandle));
break;
case TokenType.Method:
case TokenType.MethodSpec:
this.Member = ((MethodReference)member).FullResolve(ctx);
this.type = ctx.Module.Import(typeof(RuntimeMethodHandle));
break;
case TokenType.Field:
this.Member = ((FieldReference)member).FullResolve(ctx);
this.type = ctx.Module.Import(typeof(RuntimeFieldHandle));
break;
default:
throw new NotImplementedException("Cannot handle token type: " + tokenType);
}
}
public ExprJsExplicit(Ctx ctx, string js, TypeReference type, IEnumerable<NamedExpr> namedExprs)
: base(ctx) {
this.JavaScript = js;
this.type = type;
this.NamedExprs = namedExprs;
}
public ExprJsExplicit(Ctx ctx, string js, TypeReference type, params NamedExpr[] namedExprs)
: this(ctx, js, type, (IEnumerable<NamedExpr>)namedExprs) {
}
public ExprJsTypeVarName(Ctx ctx, TypeReference type)
: base(ctx) {
this.TypeRef = type;
}
public static Stmt Equals(Ctx ctx) {
var other = ctx.MethodParameter(0).Named("other");
var type = new ExprJsTypeVarName(ctx, ctx.Single).Named("type");
return new StmtJsExplicit(ctx, "return other._ === type && this === other.v;", ctx.ThisNamed, other, type);
}
public static Stmt GetHashCode(Ctx ctx) {
var toString = new ExprJsResolvedMethod(ctx, ctx.String, ctx.This, "toExponential");
var getHashCode = new ExprCall(ctx, typeof(string).GetMethod("GetHashCode"), toString);
var stmt = new StmtReturn(ctx, getHashCode);
return stmt;
}
public StmtEmpty(Ctx ctx)
: base(ctx) {
}
public StmtThrow(Ctx ctx, Expr expr)
: base(ctx)
{
this.Expr = expr;
}
public ExprVarParameter(Ctx ctx, ParameterDefinition parameter)
: base(ctx) {
this.Parameter = parameter;
this.type = parameter.ParameterType;
}
private void Add(TypeReference tRef, Ctx ctx) {
var cctor = tRef.Resolve().Methods.FirstOrDefault(x => x.Name == ".cctor");
if (cctor != null) {
this.staticConstructors.Add(cctor.FullResolve(ctx));
}
}
public ExprLoadIndirect(Ctx ctx, Expr expr, TypeReference loadType)
: base(ctx)
{
this.Expr = expr;
this.loadType = loadType;
}
