public void VisitNode(JSUnaryOperatorExpression uoe) { var exType = uoe.Expression.GetActualType(TypeSystem); var opType = uoe.ActualType; if (IsLongOrULong(exType) && IsLongOrULong(opType)) //exType == TypeSystem.Int64 && opType == TypeSystem.Int64) { string verb; switch (uoe.Operator.Token) { case "-": verb = "op_UnaryNegation"; break; case "~": verb = "op_OnesComplement"; break; default: throw new NotSupportedException(); } var method = new JSFakeMethod(verb, TypeSystem.Int64, new[] { TypeSystem.Int64 }, MethodTypeFactory); var replacement = JSInvocationExpression.InvokeStatic(exType, method, new[] { uoe.Expression }, true); ParentNode.ReplaceChild(uoe, replacement); VisitReplacement(replacement); return; } VisitChildren(uoe); }
public JSSpecialIdentifiers(MethodTypeFactory methodTypes, TypeSystem typeSystem) { TypeSystem = typeSystem; MethodTypes = methodTypes; prototype = Object("prototype"); eval = new JSFakeMethod("eval", TypeSystem.Object, new[] { TypeSystem.String }, methodTypes); toString = new JSFakeMethod("toString", TypeSystem.String, null, methodTypes); floor = new JSDotExpression(Object("Math"), new JSFakeMethod("floor", TypeSystem.Int32, null, methodTypes)); fromCharCode = new JSDotExpression(Object("String"), new JSFakeMethod("fromCharCode", TypeSystem.Char, new[] { TypeSystem.Int32 }, methodTypes)); charCodeAt = new JSFakeMethod("charCodeAt", TypeSystem.Int32, new[] { TypeSystem.Char }, methodTypes); }
public void VisitNode(JSFakeMethod fakeMethod) { Output.Identifier(fakeMethod.Name); var ga = fakeMethod.GenericArguments; if (ga != null) { Output.LPar(); CommaSeparatedList(ga); Output.RPar(); } }
private void VisitFakeMethod(JSInvocationExpression ie, JSFakeMethod fakeMethod) { if (TypeUtil.IsDelegateType(fakeMethod.ReturnType) && fakeMethod.Name == "New") { var type = (JSType)ie.Arguments[0]; // FIXME: What the heck is in arg1???? var method = UnwrapDeferred <JSMethod>(ie.Arguments[2]); var methodDef = method.Reference.Resolve(); var memberName = WasmUtil.FormatMemberName(methodDef); Formatter.WriteRaw("(i32.const {0} (; {1} ;))", AssemblyEmitter.GetFunctionIndex(methodDef), methodDef.FullName); return; } Console.WriteLine("Can't translate fake method {0}", ie); Formatter.WriteSExpr("untranslatable.call"); return; }
public void VisitNode(JSBinaryOperatorExpression boe) { var leftType = boe.Left.GetActualType(TypeSystem); var rightType = boe.Right.GetActualType(TypeSystem); TypeReference expectedType; try { // GetExpectedType can throw NoExpectedTypeException // Shouldn't it return null or something like a NoType instead? expectedType = boe.GetActualType(TypeSystem); } catch (NoExpectedTypeException) { expectedType = null; } var isLongExpression = IsLongOrULong(leftType) || IsLongOrULong(rightType); bool isUnsigned = (leftType.MetadataType == MetadataType.UInt64) || (rightType.MetadataType == MetadataType.UInt64); var resultType = isUnsigned ? TypeSystem.UInt64 : TypeSystem.Int64; var assignmentOperator = boe.Operator as JSAssignmentOperator; if ((assignmentOperator != null) && (isLongExpression)) { if (assignmentOperator == JSOperator.Assignment) { VisitChildren(boe); return; } // Deconstruct the mutation assignment so we can insert the appropriate operator call. var replacement = IntroduceEnumCasts.DeconstructMutationAssignment(boe, TypeSystem, resultType); ParentNode.ReplaceChild(boe, replacement); VisitReplacement(replacement); } else if (isLongExpression) { var verb = GetVerb(boe.Operator); if (verb == null) { throw new NotImplementedException("Int64 operator not yet supported: " + boe.Operator.Token); } JSIdentifier method = new JSFakeMethod( verb, resultType, new[] { leftType, rightType }, MethodTypeFactory ); var replacement = JSInvocationExpression .InvokeStatic(leftType, method, new[] { boe.Left, boe.Right }, true); ParentNode.ReplaceChild(boe, replacement); VisitReplacement(replacement); } else { VisitChildren(boe); } }