protected override NodeBase expand(Context ctx, bool mustReturn)
{
if (!IsConstant)
{
return(Kind == LogicalOperatorKind.And
? Expr.If(LeftOperand, Expr.Block(Expr.Cast <bool>(RightOperand)), Expr.Block(Expr.False()))
: Expr.If(LeftOperand, Expr.Block(Expr.True()), Expr.Block(Expr.Cast <bool>(RightOperand))));
}
return(base.expand(ctx, mustReturn));
}
/// <summary>
/// Saves the value to an array location.
/// </summary>
private void emitSetArray(Context ctx)
{
var gen = ctx.CurrentMethod.Generator;
var exprType = Expression.Resolve(ctx);
var itemType = exprType.GetElementType();
Expression.Emit(ctx, true);
Expr.Cast(Index, typeof(int)).Emit(ctx, true);
Expr.Cast(Value, itemType).Emit(ctx, true);
gen.EmitSaveIndex(itemType);
}
/// <summary>
/// Emits the code for retrieving an array item by index.
/// </summary>
private void compileArray(Context ctx)
{
var gen = ctx.CurrentMethod.Generator;
var exprType = Expression.Resolve(ctx);
var itemType = exprType.GetElementType();
Expression.Emit(ctx, true);
Expr.Cast(Index, typeof(int)).Emit(ctx, true);
gen.EmitLoadIndex(itemType, RefArgumentRequired || PointerRequired);
}
protected override NodeBase expand(Context ctx, bool mustReturn)
{
var fromType = Expression.Resolve(ctx);
var toType = Resolve(ctx);
if (fromType.IsNullableType() && !toType.IsNullableType())
{
return(Expr.Cast(Expr.GetMember(Expression, "Value"), toType));
}
return(base.expand(ctx, mustReturn));
}
public void Algebraic3()
{
var src = @"
type TestType
Small of int
Large of int
fun part:TestType (x:int) ->
if x > 100 then
(new Large x) as TestType
else
new Small x
var a = part 10
new [ a is TestType; a is Small; a is Large ]";
var result = new NodeBase[]
{
Expr.Type(
"TestType",
Expr.Label("Small", "int"),
Expr.Label("Large", "int")
),
Expr.Fun(
"part",
"TestType",
new [] { Expr.Arg("x", "int") },
Expr.If(
Expr.Greater(Expr.Get("x"), Expr.Int(100)),
Expr.Block(
Expr.Cast(
Expr.New("Large", Expr.Get("x")),
"TestType"
)
),
Expr.Block(
Expr.New("Small", Expr.Get("x"))
)
)
),
Expr.Var("a", Expr.Invoke("part", Expr.Int(10))),
Expr.Array(
Expr.Is(Expr.Get("a"), "TestType"),
Expr.Is(Expr.Get("a"), "Small"),
Expr.Is(Expr.Get("a"), "Large")
)
};
TestParser(src, result);
}
/// <summary>
/// Assigns a closured variable that is declared in current scope.
/// </summary>
private void emitSetClosuredLocal(Context ctx, Local name)
{
var gen = ctx.CurrentMethod.Generator;
gen.EmitLoadLocal(ctx.Scope.ActiveClosure.ClosureVariable);
Expr.Cast(Value, name.Type).Emit(ctx, true);
var clsType = ctx.Scope.ActiveClosure.ClosureType.TypeInfo;
var clsField = ctx.ResolveField(clsType, name.ClosureFieldName);
gen.EmitSaveField(clsField.FieldInfo);
}
/// <summary>
/// Loads both arguments and converts them to the biggest common type.
/// </summary>
protected void LoadAndConvertNumerics(Context ctx, Type type = null)
{
var left = LeftOperand.Resolve(ctx);
var right = RightOperand.Resolve(ctx);
if (type == null)
{
type = TypeExtensions.GetNumericOperationType(left, right);
}
Expr.Cast(LeftOperand, type).Emit(ctx, true);
Expr.Cast(RightOperand, type).Emit(ctx, true);
}
/// <summary>
/// Emits one branch of the condition (true or false).
/// </summary>
private void EmitBranch(Context ctx, NodeBase branch, bool mustReturn)
{
var desiredType = Resolve(ctx);
mustReturn &= !desiredType.IsVoid();
var branchType = branch.Resolve(ctx, mustReturn);
if (!branchType.IsVoid() && !desiredType.IsVoid())
{
branch = Expr.Cast(branch, desiredType);
}
branch.Emit(ctx, mustReturn);
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
if (OverloadedMethod == null)
{
EmitOperator(ctx);
return;
}
var ps = OverloadedMethod.ArgumentTypes;
Expr.Cast(Operand, ps[0]).Emit(ctx, true);
gen.EmitCall(OverloadedMethod.MethodInfo);
}
/// <summary>
/// Checks all items in the array with corresponding rules.
/// </summary>
private IEnumerable <NodeBase> ExpandItemChecksIterated(Context ctx, NodeBase expression, int count, Label nextStatement)
{
if (count == 0)
{
yield break;
}
var enumerableType = typeof(IEnumerable <>).MakeGenericType(_elementType);
var enumeratorType = typeof(IEnumerator <>).MakeGenericType(_elementType);
var enumeratorVar = ctx.Scope.DeclareImplicit(ctx, enumeratorType, false);
yield return(Expr.Set(
enumeratorVar,
Expr.Invoke(
Expr.Cast(expression, enumerableType),
"GetEnumerator"
)
));
for (var idx = 0; idx < count; idx++)
{
// if not iter.MoveNext() then jump!
yield return(MakeJumpIf(
nextStatement,
Expr.Not(
Expr.Invoke(
Expr.Get(enumeratorVar),
"MoveNext"
)
)
));
var rules = ElementRules[idx].Expand(
ctx,
Expr.GetMember(
Expr.Get(enumeratorVar),
"Current"
),
nextStatement
);
foreach (var rule in rules)
{
yield return(rule);
}
}
}
public void Cast()
{
var src = "let a = (b as List<int>).Count";
var result = Expr.Let(
"a",
Expr.GetMember(
Expr.Cast(
Expr.Get("b"),
"List<int>"
),
"Count"
)
);
TestParser(src, result);
}
protected override void emitCode(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
if (_OverloadedMethod == null)
{
emitOperator(ctx);
return;
}
var ps = _OverloadedMethod.ArgumentTypes;
Expr.Cast(LeftOperand, ps[0]).Emit(ctx, true);
Expr.Cast(RightOperand, ps[1]).Emit(ctx, true);
gen.EmitCall(_OverloadedMethod.MethodInfo);
}
protected override void emitCode(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
var type = Value.Resolve(ctx);
if (_Property != null)
{
var cast = Expr.Cast(Value, type);
if (_Property.SetterMethod != null)
{
cast.Emit(ctx, true);
gen.EmitCall(_Property.SetterMethod.MethodInfo);
}
else
{
var method = typeof(GlobalPropertyHelper).GetMethod("Set").MakeGenericMethod(type);
gen.EmitConstant(ctx.ContextId);
gen.EmitConstant(_Property.PropertyId);
Expr.Cast(Value, type).Emit(ctx, true);
gen.EmitCall(method);
}
}
else
{
var nameInfo = Local ?? ctx.Scope.FindLocal(Identifier);
if (nameInfo != null)
{
if (nameInfo.IsClosured)
{
if (nameInfo.ClosureDistance == 0)
{
emitSetClosuredLocal(ctx, nameInfo);
}
else
{
emitSetClosuredRemote(ctx, nameInfo);
}
}
else
{
emitSetLocal(ctx, nameInfo);
}
}
}
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
var dictType = Resolve(ctx);
var tmpVar = ctx.Scope.DeclareImplicit(ctx, dictType, true);
var ctor = ctx.ResolveConstructor(dictType, new[] { typeof(int) });
var addMethod = ctx.ResolveMethod(dictType, "Add", new[] { _keyType, _valueType });
var count = Expressions.Count;
gen.EmitConstant(count);
gen.EmitCreateObject(ctor.ConstructorInfo);
gen.EmitSaveLocal(tmpVar.LocalBuilder);
foreach (var curr in Expressions)
{
var currKeyType = curr.Key.Resolve(ctx);
var currValType = curr.Value.Resolve(ctx);
ctx.CheckTypedExpression(curr.Key, currKeyType);
ctx.CheckTypedExpression(curr.Value, currValType, true);
if (currKeyType != _keyType)
{
Error(curr.Key, CompilerMessages.DictionaryKeyTypeMismatch, currKeyType, _keyType, _valueType);
}
if (!_valueType.IsExtendablyAssignableFrom(currValType))
{
Error(curr.Value, CompilerMessages.DictionaryValueTypeMismatch, currValType, _keyType, _valueType);
}
gen.EmitLoadLocal(tmpVar.LocalBuilder);
curr.Key.Emit(ctx, true);
Expr.Cast(curr.Value, _valueType).Emit(ctx, true);
gen.EmitCall(addMethod.MethodInfo, addMethod.IsVirtual);
}
gen.EmitLoadLocal(tmpVar.LocalBuilder);
}
protected override void emitCode(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
var tmpVar = ctx.Scope.DeclareImplicit(ctx, Resolve(ctx), true);
// create array
var count = Expressions.Count;
gen.EmitConstant(count);
gen.EmitCreateArray(_ItemType);
gen.EmitSaveLocal(tmpVar.LocalBuilder);
for (var idx = 0; idx < count; idx++)
{
var currType = Expressions[idx].Resolve(ctx);
ctx.CheckTypedExpression(Expressions[idx], currType, true);
if (!_ItemType.IsExtendablyAssignableFrom(currType))
{
error(Expressions[idx], CompilerMessages.ArrayElementTypeMismatch, currType, _ItemType);
}
gen.EmitLoadLocal(tmpVar.LocalBuilder);
gen.EmitConstant(idx);
var cast = Expr.Cast(Expressions[idx], _ItemType);
if (_ItemType.IsValueType)
{
gen.EmitLoadIndex(_ItemType, true);
cast.Emit(ctx, true);
gen.EmitSaveObject(_ItemType);
}
else
{
cast.Emit(ctx, true);
gen.EmitSaveIndex(_ItemType);
}
}
gen.EmitLoadLocal(tmpVar.LocalBuilder);
}
/// <summary>
/// Returns the code to concatenate two dictionaries.
/// </summary>
private NodeBase DictExpand(Context ctx)
{
var keyValueTypes = LeftOperand.Resolve(ctx).GetGenericArguments();
var dictType = typeof(Dictionary <,>).MakeGenericType(keyValueTypes);
var currType = typeof(KeyValuePair <,>).MakeGenericType(keyValueTypes);
var tmpDict = ctx.Scope.DeclareImplicit(ctx, dictType, false);
var tmpCurr = ctx.Scope.DeclareImplicit(ctx, currType, false);
// a = new Dictionary<T, T2>(<left>)
// foreach(var kvp in <right>)
// a[kvp.Key] = kvp.Value
return(Expr.Block(
Expr.Set(
tmpDict,
Expr.New(
dictType,
Expr.Cast(
LeftOperand,
typeof(IDictionary <,>).MakeGenericType(keyValueTypes)
)
)
),
Expr.For(
tmpCurr,
RightOperand,
Expr.Block(
Expr.SetIdx(
Expr.Get(tmpDict),
Expr.GetMember(
Expr.Get(tmpCurr),
"Key"
),
Expr.GetMember(
Expr.Get(tmpCurr),
"Value"
)
)
)
),
Expr.Get(tmpDict)
));
}
public override IEnumerable <NodeBase> Expand(Context ctx, NodeBase expression, Label nextStatement)
{
yield return(MakeJumpIf(
nextStatement,
Expr.Not(Expr.Is(expression, _type))
));
foreach (var fieldRule in FieldRules)
{
var rules = fieldRule.Rule.Expand(
ctx,
Expr.GetMember(Expr.Cast(expression, _type), fieldRule.Name.FullSignature),
nextStatement
);
foreach (var rule in rules)
{
yield return(rule);
}
}
}
protected override NodeBase Expand(Context ctx, bool mustReturn)
{
var left = LeftOperand.Resolve(ctx);
var right = RightOperand.Resolve(ctx);
var common = Resolve(ctx);
var body = Expr.Block();
var leftAccessor = LeftOperand;
if (!(LeftOperand is GetIdentifierNode))
{
var tmpVar = ctx.Scope.DeclareImplicit(ctx, left, false);
body.Add(Expr.Set(tmpVar, LeftOperand));
leftAccessor = Expr.Get(tmpVar);
}
var condition = Expr.Compare(ComparisonOperatorKind.Equals, leftAccessor, Expr.Null());
var leftResult = left.IsNullableType() && left != right
? Expr.GetMember(leftAccessor, nameof(Nullable <int> .Value))
: leftAccessor;
var rightResult = right.IsNullableType() && left != right
? Expr.GetMember(RightOperand, nameof(Nullable <int> .Value))
: RightOperand;
body.Add(
Expr.If(
condition,
Expr.Block(
Expr.Cast(rightResult, common)
),
Expr.Block(
Expr.Cast(leftResult, common)
)
)
);
return(body);
}
/// <summary>
/// Invokes the object's custom indexer setter.
/// </summary>
private void emitSetCustomIndexer(Context ctx)
{
var gen = ctx.CurrentMethod.Generator;
try
{
var idxDest = _Indexer.ArgumentTypes[0];
var valDest = _Indexer.ArgumentTypes[1];
Expression.Emit(ctx, true);
Expr.Cast(Index, idxDest).Emit(ctx, true);
Expr.Cast(Value, valDest).Emit(ctx, true);
gen.EmitCall(_Indexer.MethodInfo);
}
catch (LensCompilerException ex)
{
ex.BindToLocation(this);
throw;
}
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
if (_invocationSource != null)
{
_invocationSource.EmitNodeForAccess(ctx);
}
if (ArgTypes.Length > 0)
{
var destTypes = _method.ArgumentTypes;
for (var idx = 0; idx < Arguments.Count; idx++)
{
var arg = Arguments[idx];
var argRef = arg is IPointerProvider && (arg as IPointerProvider).RefArgumentRequired;
var targetRef = destTypes[idx].IsByRef;
if (argRef != targetRef)
{
if (argRef)
{
Error(arg, CompilerMessages.ReferenceArgUnexpected);
}
else
{
Error(arg, CompilerMessages.ReferenceArgExpected, idx + 1, destTypes[idx].GetElementType());
}
}
var expr = argRef ? Arguments[idx] : Expr.Cast(Arguments[idx], destTypes[idx]);
expr.Emit(ctx, true);
}
}
var isVirt = _invocationSource != null && _invocationSource.Resolve(ctx).IsClass;
gen.EmitCall(_method.MethodInfo, isVirt);
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
if (_constructor != null)
{
if (ArgTypes.Length > 0)
{
var destTypes = _constructor.ArgumentTypes;
for (var idx = 0; idx < Arguments.Count; idx++)
{
Expr.Cast(Arguments[idx], destTypes[idx]).Emit(ctx, true);
}
}
gen.EmitCreateObject(_constructor.ConstructorInfo);
}
else
{
Expr.Default(TypeSignature).Emit(ctx, true);
}
}
/// <summary>
/// Creates the body of Equals(object).
/// </summary>
private void CreateGenericEquals()
{
var eq = CreateMethod(
"Equals",
"bool",
new[] { Expr.Arg <object>("obj") },
false,
true
);
// if(this.ReferenceEquals null obj)
// false
// else
// (this.ReferenceEquals this obj) || ( (obj.GetType () == this.GetType()) && (this.Equals obj as <Name>))
eq.Body.Add(
Expr.If(
Expr.Invoke(Expr.This(), "ReferenceEquals", Expr.Null(), Expr.Get("obj")),
Expr.Block(Expr.False()),
Expr.Block(
Expr.Or(
Expr.Invoke(Expr.This(), "ReferenceEquals", Expr.This(), Expr.Get("obj")),
Expr.And(
Expr.Equal(
Expr.Invoke(Expr.Get("obj"), "GetType"),
Expr.Invoke(Expr.This(), "GetType")
),
Expr.Invoke(
Expr.This(),
"Equals",
Expr.Cast(Expr.Get("obj"), Name)
)
)
)
)
)
);
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
var loopType = Resolve(ctx);
var saveLast = mustReturn && !loopType.IsVoid();
var beginLabel = gen.DefineLabel();
var endLabel = gen.DefineLabel();
Local tmpVar = null;
if (saveLast)
{
tmpVar = ctx.Scope.DeclareImplicit(ctx, loopType, false);
Expr.Set(tmpVar, Expr.Default(loopType)).Emit(ctx, false);
}
gen.MarkLabel(beginLabel);
Expr.Cast(Condition, typeof(bool)).Emit(ctx, true);
gen.EmitConstant(false);
gen.EmitBranchEquals(endLabel);
Body.Emit(ctx, mustReturn);
if (saveLast)
{
gen.EmitSaveLocal(tmpVar.LocalBuilder);
}
gen.EmitJump(beginLabel);
gen.MarkLabel(endLabel);
if (saveLast)
{
gen.EmitLoadLocal(tmpVar.LocalBuilder);
}
}
public override IEnumerable <NodeBase> Expand(Context ctx, NodeBase expression, Label nextStatement)
{
// no need for temporary variable: field access is idempotent
yield return(MakeJumpIf(
nextStatement,
Expr.Not(
Expr.Is(expression, _type)
)
));
var rules = LabelRule.Expand(
ctx,
Expr.GetMember(
Expr.Cast(expression, _type),
"Tag"
),
nextStatement
);
foreach (var rule in rules)
{
yield return(rule);
}
}
/// <summary>
/// Assigns a closured variable that has been imported from outer scopes.
/// </summary>
private void emitSetClosuredRemote(Context ctx, Local name)
{
var gen = ctx.CurrentMethod.Generator;
gen.EmitLoadArgument(0);
var dist = name.ClosureDistance;
var type = (Type)ctx.CurrentType.TypeBuilder;
while (dist > 1)
{
var rootField = ctx.ResolveField(type, EntityNames.ParentScopeFieldName);
gen.EmitLoadField(rootField.FieldInfo);
type = rootField.FieldType;
dist--;
}
Expr.Cast(Value, name.Type).Emit(ctx, true);
var clsField = ctx.ResolveField(type, name.ClosureFieldName);
gen.EmitSaveField(clsField.FieldInfo);
}
protected override NodeBase expand(Context ctx, bool mustReturn)
{
if (_Wrapper.IsPartiallyApplied)
{
// (expr) _ a b _
// is transformed into
// (pa0:T1 pa1:T2) -> (expr) (pa0) (a) (b) (pa1)
var argDefs = new List <FunctionArgument>();
var argExprs = new List <NodeBase>();
for (var idx = 0; idx < _ArgTypes.Length; idx++)
{
if (_ArgTypes[idx] == typeof(UnspecifiedType))
{
var argName = ctx.Unique.AnonymousArgName();
argDefs.Add(Expr.Arg(argName, _Wrapper.ArgumentTypes[idx].FullName));
argExprs.Add(Expr.Get(argName));
}
else
{
argExprs.Add(Arguments[idx]);
}
}
return(Expr.Lambda(argDefs, recreateSelfWithArgs(argExprs)));
}
if (_Wrapper.IsVariadic)
{
var srcTypes = _ArgTypes;
var dstTypes = _Wrapper.ArgumentTypes;
var lastDst = dstTypes[dstTypes.Length - 1];
var lastSrc = srcTypes[srcTypes.Length - 1];
// compress items into an array:
// fx a b c d
// becomes
// fx a b (new[ c as X; d as X ])
if (dstTypes.Length > srcTypes.Length || lastDst != lastSrc)
{
var elemType = lastDst.GetElementType();
var simpleArgs = Arguments.Take(dstTypes.Length - 1);
var combined = Expr.Array(Arguments.Skip(dstTypes.Length - 1).Select(x => Expr.Cast(x, elemType)).ToArray());
return(recreateSelfWithArgs(simpleArgs.Union(new[] { combined })));
}
}
return(base.expand(ctx, mustReturn));
}
/// <summary>
/// Creates the body of GetHashCode().
/// </summary>
private void CreateGetHashCode()
{
var ghc = CreateMethod(
"GetHashCode",
typeof(int),
Type.EmptyTypes,
false,
true
);
// var result = 0
ghc.Body.Add(Expr.Var("result", Expr.Int(0)));
// result ^= (<field> != null ? field.GetHashCode() : 0) * 397
var id = 0;
foreach (var f in _fields.Values)
{
var fieldType = f.Type ?? Context.ResolveType(f.TypeSignature);
NodeBase expr;
if (fieldType.IsIntegerType())
{
expr = Expr.GetMember(Expr.This(), f.Name);
}
else if (fieldType.IsValueType)
{
expr = Expr.Invoke(
Expr.Cast(Expr.GetMember(Expr.This(), f.Name), typeof(object)),
"GetHashCode"
);
}
else
{
expr = Expr.If(
Expr.NotEqual(
Expr.GetMember(Expr.This(), f.Name),
Expr.Null()
),
Expr.Block(
Expr.Invoke(
Expr.GetMember(Expr.This(), f.Name),
"GetHashCode"
)
),
Expr.Block(Expr.Int(0))
);
}
if (id < _fields.Count - 1)
{
expr = Expr.Mult(expr, Expr.Int(397));
}
ghc.Body.Add(
Expr.Set("result", Expr.Xor(Expr.Get("result"), expr))
);
id++;
}
ghc.Body.Add(Expr.Get("result"));
}
public void Compile()
{
if (!globalContext.EnableClassesTypes)
{
if (type.IsClass)
{
throw new ArgumentException($"Can't compile serialization functions for type {type}. To enable classes types use SMAB(enableClassesTypes = true) constructor");
}
}
var serializeGen = new ILGen <Action <SerializeStream, object, SerializationContext, SerializationMethodsBase[]> >(type + "_serialize", true);
var deserializeGen = new ILGen <Func <SerializeStream, DeserializationContext, SerializationMethodsBase[], object> >(type + "_deserialize", true);
SerializationRule typeRule = (SerializationRule)type.GetCustomAttribute(typeof(SerializationRule));
bool defaultIsSerializable = typeRule != null ? typeRule.IsSerializable : true;
ILVar optimizationResult = deserializeGen.DeclareVar(typeof((bool, object)));
//Context optimization
if (!type.IsValueType)
{
serializeGen.If(serializeGen.args[2].CallMethod(OptimizeSerializationContextMethodInfo, serializeGen.args[0], serializeGen.args[1]));
serializeGen.Return();
serializeGen.EndIf();
deserializeGen.Line(optimizationResult.Set(deserializeGen.args[1].CallMethod(OptimizeDeserializationContextMethodInfo, deserializeGen.args[0])));
deserializeGen.If(optimizationResult.Field(OptimizationResultItem1));
deserializeGen.Return(optimizationResult.Field(OptimizationResultItem2));
deserializeGen.EndIf();
}
ILVar serializeObject = serializeGen.DeclareVar(type);
ILVar deserializeObject = deserializeGen.DeclareVar(type);
serializeGen.Line(serializeObject.Set(Expr.Cast(serializeGen.args[1], type)));
deserializeGen.Line(deserializeObject.Set(Expr.CreateUninitialized(type)));
if (!type.IsValueType)
{
deserializeGen.Line(deserializeGen.args[1].CallMethod(AddObjectDesreializationContextMethodInfo, deserializeObject));
}
foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).OrderBy((FieldInfo fieldInfo) => fieldInfo.MetadataToken))
{
SerializationRule fieldRule = (SerializationRule)fieldInfo.GetCustomAttribute(typeof(SerializationRule));
if (!(fieldRule != null ? fieldRule.IsSerializable : defaultIsSerializable))
{
continue;
}
Type fieldType = fieldInfo.FieldType;
if (SerializeStream.GetBaseTypeRWMethodsIfExists(fieldType, out RWMethodsInfo rwMethods))
{
serializeGen.Line(serializeGen.args[0].CallMethod(rwMethods.writeMethodInfo, serializeObject.Field(fieldInfo)));
deserializeGen.Line(deserializeObject.Field(fieldInfo).Set(deserializeGen.args[0].CallMethod(rwMethods.readMethodInfo)));
}
else
{
int fieldTypeSerializationIndex = GetTypeSerializationMethodsIndex(fieldType);
serializeGen.Line(serializeGen.args[3].Index(Expr.Const(fieldTypeSerializationIndex)).CallMethod(SerializeMethodInfo, serializeGen.args[0], serializeObject.Field(fieldInfo), serializeGen.args[2]));
deserializeGen.Line(deserializeObject.Field(fieldInfo).Set(Expr.Cast(deserializeGen.args[2].Index(Expr.Const(fieldTypeSerializationIndex)).CallMethod(DeserializeMethodInfo, serializeGen.args[0], serializeGen.args[1]), fieldType)));
}
}
deserializeGen.Return(deserializeObject);
serializationMethods.TypeSerializeMethod = new SerializationMethodsWithDependencies.SerializeMethod(serializeGen.compile(globalContext.WithComments));
serializationMethods.TypeDeserializeMethod = new SerializationMethodsWithDependencies.DeserializeMethod(deserializeGen.compile(globalContext.WithComments));
}
public static void Main(string[] args)
{
var expr = ExprParser.Instance.Parse("a + 'ola mundo \n \t \\'mundo\\' ola' * (6 + -9)");
var expr2 = ExprParser.Instance.Parse("-a");
var expr3 = ExprParser.Instance.Parse("-a + -(4 + 6)");
var expr4 = ExprParser.Instance.Parse("6");
var expr5 = ExprParser.Instance.Parse("6.0");
var expr6 = ExprParser.Instance.Parse("a + $a");
var expr7 = ExprParser.Instance.Parse("Articles.ArticleDescription == 'RTUY /(89)' ");
var expr8 = ExprParser.Instance.Parse(" FF1(a+b, 89, (9+1) * 2)");
var expr9 = ExprParser.Instance.Parse(" FF2(a+b )");
var expr10 = ExprParser.Instance.Parse(" a+ b >= 3 && 1");
var expr11 = ExprParser.Instance.Parse(" a+ b >= 3 && 1 ? (3 + 9) * 5: a <= 3");
var expr12 = ExprParser.Instance.Parse("-( a+ b >= 3 && 1 ? (3 + 9) * 5: a <= 3)");
var expr13 = Expr.Parse("true");
var expr14 = Expr.Parse("false");
var expr15 = Expr.Parse("!true");
Guid guid = Guid.NewGuid();
var literal = (Literal)guid;
var update = new Update <ExampleTable>(new ExampleTable {
Key = guid
});
update.Execute(new Compiler(), out int n1);
var update2 = new Update <ExampleTable>(new ExampleTable {
Key = guid
}, "Description");
var select = new Query <ExampleTable>().InnerJoin(new Query("SomeTable"),
new string[] { "ForeignKey" },
new string[] { "SomeKey" });
select.Execute(new Compiler());
var select2 = new Query <ExampleTable>().LeftJoin(new Query("SomeTable"),
new string[] { "ForeignKey" },
new string[] { "SomeKey" });
select2.Execute(new Compiler());
var select3 = new Query <ExampleTable>().LeftJoin("SomeTable", "SomeTableAlias",
new string[] { "ForeignKey" },
new string[] { "SomeKey" });
select3.Execute(new Compiler());
var select4 = new Query <ExampleTable>()
.Select("a", "b", "c")
.Where(
Expr.Eq("a", "ola")
.And(Expr.Eq("b", 3))
);
select4.Execute(new Compiler());
var insertOrUpdate = new Update <ExampleTable>(new ExampleTable {
Key = guid
}).InsertOrUpdate();
insertOrUpdate.Execute(new Compiler(), out n1);
var select5 = new Query <ExampleTable>().Where(Expr.NotNull("ForeignKey"));
select5.Execute(new Compiler());
var select6 = new Query <ExampleTable>().Where(Expr.NotIn("ForeignKey", new int[] { 8, 9, 10 }));
select6.Execute(new Compiler());
var select7 = new Query <ExampleTable>().Where(Expr.NotIn("ForeignKey", new List <string> {
"8", "9", "10"
}));
select7.Execute(new Compiler());
var select8 = new Query <ExampleTable>().Select(Expr.Count());
select8.Execute(new Compiler());
var select9 = new Query <ExampleTable>().Select(new Function("TTS", (Literal)1, (Literal)4));
select9.Execute(new Compiler());
var select10 = new Query <ExampleTable>().Select(Expr.Parse("MAX(ForeignKey)"));
select10.Execute(new Compiler());
var select11 = new Query <ExampleTable>().Select(Expr.Parse("MAX(ForeignKey)")).Select(" A ")
.OrderBy(true, "A", "C")
.OrderBy(false, "B")
.OrderBy(false, "D");
select11.Execute(new Compiler());
var select12 = new Query <ExampleTable>()
.Select("a", "b", "c")
.Where(
Expr.EqVar("a", "ola")
.And(Expr.EqVar("b", "3"))
);
select4.Execute(new Compiler());
select12.Execute(new Compiler());
Console.WriteLine(new Compiler().CompileToString(select12));
var select13 = new Query <ExampleTable>().InnerJoin <ExampleTable>(Expr.EqParam("olaColumn", "ola"));
select13.Execute(new Compiler());
var select14 = new Query().Select(Expr.Exists(select13));
select14.Execute(new Compiler());
var select15 = new Query().Select(Expr.Parse("a.b == c.d && g.h == $a"));
select15.Execute(new Compiler());
var select16 = new Query().Select(Expr.Cast((Variable)"a.b", "decimal"));
select16.Execute(new Compiler());
var select17 = new Query().Select(Expr.Parse("Cast(a.b, 'decimal')"));
select17.Execute(new Compiler());
var select18 = new Query().Select(Expr.Parse("Cast(a.b, decimal)"));
select18.Execute(new Compiler());
Console.WriteLine("Hello World!");
}
protected override void EmitInternal(Context ctx, bool mustReturn)
{
var gen = ctx.CurrentMethod.Generator;
var condType = Condition.Resolve(ctx);
if (!condType.IsExtendablyAssignableFrom(typeof(bool)))
{
Error(Condition, CompilerMessages.ConditionTypeMismatch, condType);
}
if (Condition.IsConstant && ctx.Options.UnrollConstants)
{
// result is known at compile time: just emit the corresponding branch's code
var node = Condition.ConstantValue ? (NodeBase)TrueAction : FalseAction;
if (node != null)
{
var nodeType = node.Resolve(ctx);
var desiredType = Resolve(ctx);
if (!nodeType.IsVoid() && !desiredType.IsVoid())
{
node = Expr.Cast(node, desiredType);
}
node.Emit(ctx, mustReturn);
if (!mustReturn && !node.Resolve(ctx).IsVoid())
{
gen.EmitPop();
}
}
return;
}
var endLabel = gen.DefineLabel();
var falseLabel = gen.DefineLabel();
Expr.Cast(Condition, typeof(bool)).Emit(ctx, true);
if (FalseAction == null)
{
// if (...) { ... }
gen.EmitBranchFalse(endLabel);
TrueAction.Emit(ctx, mustReturn);
if (!TrueAction.Resolve(ctx).IsVoid())
{
gen.EmitPop();
}
gen.MarkLabel(endLabel);
}
else
{
// if (...) { ... } else { ... }
gen.EmitBranchFalse(falseLabel);
EmitBranch(ctx, TrueAction, mustReturn);
gen.EmitJump(endLabel);
gen.MarkLabel(falseLabel);
EmitBranch(ctx, FalseAction, mustReturn);
gen.MarkLabel(endLabel);
}
}