Expression ILiteralEncodingStrategy.Array(EncoderVisitor visitor, IList <LiteralNode> elements)
{
NativeLiteralArrayVisitor arrayVisitor = new NativeLiteralArrayVisitor(visitor);
Expression[] items = new Expression[elements.Count];
for (int i = 0; i < items.Length; i++)
{
items[i] = elements[i].Accept(arrayVisitor);
}
Expression initializer = Expression.NewArrayInit(typeof(object), items);
NativeLiteralArrayVisitor outerArrrayVisitor = visitor.GetNativeLiteralArrayVisitor();
if (outerArrrayVisitor != null)
{
outerArrrayVisitor.HadSymbols = outerArrrayVisitor.HadSymbols | arrayVisitor.HadSymbols;
return(initializer); // Embed in outer array
}
// Root (outer-most) array visitor
if (!arrayVisitor.HadSymbols)
{
return(this.DefineLiteral(visitor, "Array", initializer));
}
// Special handling if the array contains symbols.
FieldInfo field = this.LiteralGenerator.DefineLiteralField("Array", initializer);
ArrayBinderDefinition binder = new ArrayBinderDefinition(field);
return(this.GenerateLiteralCallSite(visitor, binder, "Array"));
}
Expression ILiteralEncodingStrategy.LargeInteger(EncoderVisitor visitor, BigInteger value)
{
Expression bytes = Expression.NewArrayInit(typeof(byte),
value.ToByteArray().Select(b => Expression.Constant(b, typeof(byte))));
Expression initializer = Expression.Convert(Expression.New(NativeLiteralEncodingStrategy.BigIntegerCtor, bytes), typeof(object));
return(PreboxedConstants.GetConstant(value) ?? this.DefineLiteral(visitor, "BigInteger", string.Format("{0}", value, CultureInfo.InvariantCulture), initializer));
}
Expression ILiteralEncodingStrategy.Array(EncoderVisitor visitor, IList <LiteralNode> elements)
{
LiteralVisitorConstantValue arrayVisitor = new LiteralVisitorConstantValue(visitor);
object[] result = new object[elements.Count];
for (int i = 0; i < result.Length; i++)
{
result[i] = elements[i].Accept(arrayVisitor);
}
return(Expression.Constant(result, typeof(object)));
}
private Expression DefineLiteral(EncoderVisitor visitor, string prefix, Expression initializer)
{
// If encoding part of an array, return the initializer directly. The outer-most visitor will do the job.
if (visitor.GetNativeLiteralArrayVisitor() != null)
{
return(initializer);
}
else
{
return(Expression.Field(null, this.LiteralGenerator.DefineLiteralField(prefix, initializer)));
}
}
Expression ILiteralEncodingStrategy.ScaledDecimal(EncoderVisitor visitor, BigDecimal value)
{
// The numerator of the BigDecimal
Expression bytes = Expression.NewArrayInit(typeof(byte),
value.Numerator.ToByteArray().Select(b => Expression.Constant(b, typeof(byte))));
Expression numerator = Expression.New(NativeLiteralEncodingStrategy.BigIntegerCtor, bytes);
// The scale
Expression scale = Expression.Constant(value.Scale, typeof(int));
// Constructing a new BigDecimal
Expression initializer = Expression.Convert(Expression.New(NativeLiteralEncodingStrategy.BigDecimalCtor, numerator, scale), typeof(object));
return(PreboxedConstants.GetConstant(value) ?? this.DefineLiteral(visitor, "BigDecimal", string.Format("{0}", value, CultureInfo.InvariantCulture), initializer));
}
Expression ILiteralEncodingStrategy.Symbol(EncoderVisitor visitor, string value)
{
NativeLiteralArrayVisitor arrayVisitor = visitor.GetNativeLiteralArrayVisitor();
if (arrayVisitor != null)
{
// If inside a literal array, special handling ... return a SymbolPlaceholder instead.
arrayVisitor.HadSymbols = true;
return(Expression.Convert(Expression.New(NativeLiteralEncodingStrategy.SymbolPlaceholderCtor, Expression.Constant(value, typeof(string))), typeof(object)));
}
SymbolBinderDefinition binder = new SymbolBinderDefinition(value);
return(this.GenerateLiteralCallSite(visitor, binder, value));
}
internal static NativeLiteralEncodingStrategy.NativeLiteralArrayVisitor GetNativeLiteralArrayVisitor(this EncoderVisitor self)
{
if (self == null)
{
throw new ArgumentNullException();
}
EncoderVisitor visitor = self;
while (visitor != null)
{
if (visitor is NativeLiteralEncodingStrategy.NativeLiteralArrayVisitor)
{
return((NativeLiteralEncodingStrategy.NativeLiteralArrayVisitor)visitor);
}
visitor = visitor.ParentVisitor;
}
return(null);
}
private Expression GenerateLiteralCallSite(EncoderVisitor visitor, IBinderDefinition binder, string nameSuggestion)
{
Type delegateType = typeof(Func <CallSite, ExecutionContext, object>);
Type siteType = typeof(CallSite <>).MakeGenericType(delegateType);
Expression callSite = this.CallSiteGenerator.CreateCallSite(binder, delegateType, siteType, nameSuggestion);
List <Expression> args = new List <Expression>();
args.Add(callSite);
args.Add(visitor.Context.ExecutionContextArgument);
FieldInfo target = TypeUtilities.Field(siteType, "Target", BindingFlags.Instance | BindingFlags.Public);
MethodInfo invoke = TypeUtilities.Method(delegateType, "Invoke");
ParameterInfo[] pis = invoke.GetParameters();
// siteExpr.Target.Invoke(siteExpr, *args)
return(Expression.Call(
Expression.Field(callSite, target),
invoke,
args));
/* C# Style
* ParameterExpression site = Expression.Variable(siteType, "$site");
* List<Expression> args = new List<Expression>();
* args.Add(site);
* args.Add(context.ExecutionContext);
* args.AddRange(arguments);
*
* FieldInfo target = TypeUtilities.Field(siteType, "Target", BindingFlags.Instance | BindingFlags.Public);
* MethodInfo invoke = TypeUtilities.Method(delegateType, "Invoke");
* ParameterInfo[] pis = invoke.GetParameters();
* // ($site = siteExpr).Target.Invoke($site, *args)
* return Expression.Block(
* new[] { site },
* Expression.Call(
* Expression.Field(Expression.Assign(site, callSite), target),
* invoke,
* args));
*/
}
Expression ILiteralEncodingStrategy.Character(EncoderVisitor visitor, char value)
{
Expression initializer = Expression.Convert(Expression.Constant(value, typeof(char)), typeof(object));
return(PreboxedConstants.GetConstant(value) ?? this.DefineLiteral(visitor, "Char", string.Format("0x{0:X4}", (int)value, CultureInfo.InvariantCulture), initializer));
}
private Expression DefineLiteral(EncoderVisitor visitor, string prefix, string valueText, Expression initializer)
{
return(this.DefineLiteral(visitor, string.Format("{0}_{1}", prefix, valueText), initializer));
}
Expression ILiteralEncodingStrategy.GenericLiteral(EncoderVisitor visitor, string name, Expression value)
{
return(this.DefineLiteral(visitor, name, Expression.Convert(value, typeof(object))));
}
Expression ILiteralEncodingStrategy.True(EncoderVisitor visitor)
{
return(PreboxedConstants.True_Expression);
}
Expression ILiteralEncodingStrategy.String(EncoderVisitor visitor, string value)
{
return(Expression.Convert(Expression.Constant(value, typeof(string)), typeof(object)));
}
Expression ILiteralEncodingStrategy.FloatD(EncoderVisitor visitor, double value)
{
return(Expression.Constant(PreboxedConstants.GetValue(value) ?? value, typeof(object)));
}
Expression ILiteralEncodingStrategy.ScaledDecimal(EncoderVisitor visitor, BigDecimal value)
{
return(Expression.Constant(PreboxedConstants.GetValue(value) ?? value, typeof(object)));
}
Expression ILiteralEncodingStrategy.SmallInteger(EncoderVisitor visitor, int value)
{
Expression initializer = Expression.Convert(Expression.Constant(value, typeof(int)), typeof(object));
return(PreboxedConstants.GetConstant(value) ?? this.DefineLiteral(visitor, "Int", string.Format("{0}", value, CultureInfo.InvariantCulture), initializer));
}
Expression ILiteralEncodingStrategy.SmallInteger(EncoderVisitor visitor, int value)
{
return(Expression.Constant(PreboxedConstants.GetValue(value) ?? value, typeof(object)));
}
Expression ILiteralEncodingStrategy.GenericLiteral(EncoderVisitor visitor, string name, Expression value)
{
return(value);
}
Expression ILiteralEncodingStrategy.Symbol(EncoderVisitor visitor, string value)
{
// #'asUppercase' or #'this is a test'
return(Expression.Constant(visitor.Context.Compiler.GetSymbol(value), typeof(object)));
}
public NativeLiteralArrayVisitor(EncoderVisitor enclosingVisitor)
: base(enclosingVisitor)
{
}
Expression ILiteralEncodingStrategy.False(EncoderVisitor visitor)
{
return(Expression.Constant(PreboxedConstants.False, typeof(object)));
}
