public ConstantInferenceFailedException(RelinqScriptExpression root, ConstantExpression ce) : base(JSToCSharpExceptionType.ConstantInferenceFailed, root, ce) { Constant = ce.Content; TokenType = String.Format("{0}.{1} ({2})", typeof(EcmaScriptV3Lexer).Name, ce.Token.Type.GetSymbolicName<EcmaScriptV3Parser>(), ce.Token.Type); }
public UnknownList(ConstantExpression constant) : base(constant) { if (!EcmaScriptV3Syntax.IsArray(constant.Token)) { throw new ArgumentException(String.Format( "No way that constant expression '{0}' can represent " + "an object serialized as list.", this)); } }
private void InferConstant(ConstantExpression ce, TypeInferenceCache cache) { var inferred = TypeInferenceConstants.InferType(ce); if (inferred != null) { cache.Add(ce, inferred); } else { throw new ConstantInferenceFailedException(Root, ce); } }
protected UnknownConstant(ConstantExpression constant) { Constant = constant; }
public static RelinqScriptType InferType(ConstantExpression ce) { if (ce.Token.Text == "null") { return new Null(); } else if (ce.Token.Text == "false" || ce.Token.Text == "true") { return typeof(bool); } else { if (EcmaScriptV3Syntax.IsInteger(ce.Token)) { try { try { var value = (long)typeof(long).FromInvariantString(ce.Token.Text); if (long.MinValue <= value && value < int.MinValue) { return typeof(long); } else if (int.MinValue <= value && value <= int.MaxValue) { return typeof(int); } else if (value == (long)int.MaxValue + 1) { var parentIsUnaryMinus = ce.Parent is OperatorExpression && ((OperatorExpression)ce.Parent).Type == OperatorType.UnaryMinus; return parentIsUnaryMinus ? typeof(int) : typeof(long); } else if ((long)int.MaxValue + 1 < value && value <= uint.MaxValue) { return typeof(uint); } else if (uint.MaxValue < value && value <= long.MaxValue) { return typeof(long); } else { throw new ArgumentException("Something was overlooked: " + "no way a long number can have value '" + value + "'."); } } catch (OverflowException) { ulong value; if (ulong.TryParse(ce.Token.Text, out value)) { if (value == (ulong)long.MaxValue + 1) { var parentIsUnaryMinus = ce.Parent is OperatorExpression && ((OperatorExpression)ce.Parent).Type == OperatorType.UnaryMinus; return parentIsUnaryMinus ? typeof(long) : typeof(ulong); } else if ((ulong)long.MaxValue + 1 < value && value <= ulong.MaxValue) { return typeof(ulong); } else { throw new ArgumentException("Something was overlooked: " + "no way an ulong (but not long) number can have value '" + value + "'."); } } else { throw; } } } catch (Exception) { return null; } } else if (EcmaScriptV3Syntax.IsFloat(ce.Token)) { try { return typeof(double).FromInvariantString(ce.Token.Text).GetType(); } catch (Exception) { return null; } } else if (EcmaScriptV3Syntax.IsString(ce.Token)) { return new UnknownStringizedObject(ce); } else if (EcmaScriptV3Syntax.IsObject(ce.Token)) { return new UnknownPropertyBag(ce); } else if (EcmaScriptV3Syntax.IsArray(ce.Token)) { return new UnknownList(ce); } else { return null; } } }
private LinqExpression CompileConstant(ConstantExpression ce, CompilationContext ctx) { Func<Type, LinqExpression> constFactory = clrType => LinqExpression.Constant(JsonDeserializer.Deserialize(ce.Data, clrType), clrType); if (ctx.Types[ce] is ClrType) { return constFactory(((ClrType)ctx.Types[ce]).Type); } else if (ctx.Types[ce] is Null || ctx.Types[ce] is UnknownConstant) { return constFactory(AcquireExpectedTypeFromContext(ce, ctx)); } else { throw new CSharpBuilderException( JSToCSharpExceptionType.UnexpectedInferredAst, Ast, ce, ctx); } }