private IConvertResult <TFrom, TTo> GetToString <TFrom, TTo>(
ExpBuilder <TFrom, TTo> expBuilder,
Expression guardedInput)
{
var method = expBuilder.UnderlyingFromType
.GetRuntimeMethods()
.Where(x => x.Name == "ToString")
.FirstOrDefault();
if (method != null)
{
MethodCallExpression callExpression = Expression.Call(
guardedInput,
method);
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
callExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.ToType == typeof(string))
{
Expression guardedInput = expBuilder.FromType.IsNullable()
? Expression.Property(expBuilder.Input, "Value")
: (Expression)expBuilder.Input;
var result = GetConvert(expBuilder, guardedInput);
if (result == null)
{
result = GetEnum(expBuilder, guardedInput);
}
if (result == null)
{
result = GetIConvertible <TFrom, TTo>();
}
if (result == null)
{
result = GetToString(expBuilder, guardedInput);
}
return(result);
}
return(null);
}
public static ExpBuilder <TFrom, TTo> AddGuards <TFrom, TTo>(
this ExpBuilder <TFrom, TTo> expBuilder)
{
if (expBuilder.FromType == typeof(string))
{
MethodCallExpression isNullOrEmpty = Expression.Call(
typeof(string),
"IsNullOrEmpty",
null,
expBuilder.Input);
var ifNullOrEmptyReturn = Expression.IfThen(
isNullOrEmpty,
Expression.Return(expBuilder.LabelTarget, expBuilder.DefaultExpression));
expBuilder.Add(ifNullOrEmptyReturn);
}
else if (!expBuilder.FromType.IsValueType)
{
var ifNullReturnExpression = Expression.IfThen(
Expression.Or(
Expression.Equal(expBuilder.Input, Expression.Constant(null, typeof(object))),
Expression.Equal(expBuilder.Input, Expression.Constant(DBNull.Value, typeof(object)))),
Expression.Return(expBuilder.LabelTarget, expBuilder.DefaultExpression));
expBuilder.Add(ifNullReturnExpression);
if (expBuilder.FromType == typeof(object))
{
if (expBuilder.ToType.IsNullable())
{
var returnIfSame = Expression.IfThen(
Expression.Or(
Expression.TypeEqual(expBuilder.Input, expBuilder.ToType),
Expression.TypeEqual(expBuilder.Input, expBuilder.UnderlyingToType)),
Expression.Return(expBuilder.LabelTarget, Expression.Convert(expBuilder.Input, expBuilder.ToType)));
expBuilder.Add(returnIfSame);
}
else
{
var returnIfSame = Expression.IfThen(
Expression.TypeEqual(expBuilder.Input, expBuilder.ToType),
Expression.Return(expBuilder.LabelTarget, Expression.Convert(expBuilder.Input, expBuilder.ToType)));
expBuilder.Add(returnIfSame);
}
}
}
else if (expBuilder.FromType.IsNullable())
{
var ifNoValueReturn = Expression.IfThen(
Expression.Not(Expression.Property(expBuilder.Input, "HasValue")),
Expression.Return(expBuilder.LabelTarget, expBuilder.DefaultExpression));
expBuilder.Add(ifNoValueReturn);
}
return(expBuilder);
}
public static BinaryExpression GetDefaultProvider <TFrom, TTo>(
this ExpBuilder <TFrom, TTo> expBuilder)
{
return(Expression.Coalesce(
expBuilder?.Provider,
Expression.Constant(CultureInfo.InvariantCulture)));
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.ToType == typeof(DBNull))
{
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
Expression.Constant(DBNull.Value));
return(expBuilder
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else if (expBuilder.FromType == typeof(DBNull))
{
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
expBuilder.DefaultExpression);
return(expBuilder
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
public Grammar( string name, Expression top,
ExpBuilder builder, Grammar parent )
: base(name,top)
{
this.Parent = parent;
this.Builder = builder;
}
private IConvertResult <TFrom, TTo> GetConvert <TFrom, TTo>(
ExpBuilder <TFrom, TTo> expBuilder,
Expression guardedInput)
{
var method = typeof(System.Convert)
.GetRuntimeMethods()
.Where(x =>
x.ReturnType == typeof(string) &&
x.GetParameters().Length == 2 &&
x.GetParameters()[0].ParameterType == expBuilder.UnderlyingFromType &&
x.GetParameters()[1].ParameterType == typeof(IFormatProvider))
.FirstOrDefault();
if (method != null)
{
MethodCallExpression callExpression = Expression.Call(
method,
guardedInput,
expBuilder.GetDefaultProvider());
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
callExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.UnderlyingToType.IsEnum)
{
MethodCallExpression callExpression;
if (expBuilder.FromType == typeof(string))
{
callExpression = Expression.Call(
typeof(EnumHelper <,>).MakeGenericType(
expBuilder.ToType,
Enum.GetUnderlyingType(expBuilder.UnderlyingToType)),
"ConvertFromString",
Array.Empty <Type>(),
expBuilder.Input,
expBuilder.GetDefaultProvider());
}
else if (expBuilder.FromType == typeof(object))
{
callExpression = Expression.Call(
typeof(EnumHelper <,>).MakeGenericType(
expBuilder.ToType,
Enum.GetUnderlyingType(expBuilder.UnderlyingToType)),
"ConvertFromObject",
Array.Empty <Type>(),
expBuilder.Input,
expBuilder.GetDefaultProvider());
}
else
{
Expression guardedInput = expBuilder.FromType.IsNullable()
? Expression.Property(expBuilder.Input, "Value")
: (Expression)expBuilder.Input;
callExpression = Expression.Call(
typeof(EnumHelper <,>).MakeGenericType(
expBuilder.ToType,
Enum.GetUnderlyingType(expBuilder.UnderlyingToType)),
"Convert",
new[] { expBuilder.UnderlyingFromType },
guardedInput,
expBuilder.GetDefaultProvider());
}
GotoExpression returnExpression = expBuilder.ToType.IsNullable()
? Expression.Return(expBuilder.LabelTarget, Expression.Convert(callExpression, expBuilder.ToType))
: Expression.Return(expBuilder.LabelTarget, callExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
protected Verifier( XmlReader document, ExpBuilder builder, ErrorHandler handler ) {
this.document = document;
this.handler = handler;
this.builder = builder;
this.attPruner = new AttPruner(builder);
emptyStringToken = new StringToken("",builder,this);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
return(expBuilder
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
protected Verifier(XmlReader document, ExpBuilder builder, ErrorHandler handler)
{
this.document = document;
this.handler = handler;
this.builder = builder;
this.attPruner = new AttPruner(builder);
emptyStringToken = new StringToken("", builder, this);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (typeof(IConvertible).IsAssignableFrom(expBuilder.UnderlyingFromType) &&
expBuilder.UnderlyingFromType != typeof(object))
{
var methodInfo = typeof(IConvertible)
.GetRuntimeMethods()
.Where(x =>
x.ReturnType == expBuilder.UnderlyingToType &&
x.GetParameters().Length == 1 &&
x.GetParameters()[0].ParameterType == typeof(IFormatProvider))
.FirstOrDefault();
if (methodInfo != null)
{
ParameterExpression converter = Expression.Variable(typeof(IConvertible), "converter");
Expression guardedInput = expBuilder.FromType.IsNullable()
? Expression.Property(expBuilder.Input, "Value")
: (Expression)expBuilder.Input;
var assignConverter = Expression.Assign(
converter,
Expression.TypeAs(guardedInput, typeof(IConvertible)));
var ifConverterNullReturn = Expression.IfThen(
Expression.Equal(converter, Expression.Constant(null, typeof(object))),
Expression.Return(expBuilder.LabelTarget, expBuilder.DefaultExpression));
var callExpression = Expression.Call(
converter,
methodInfo,
expBuilder.GetDefaultProvider());
GotoExpression returnExpression = expBuilder.ToType.IsNullable()
? Expression.Return(expBuilder.LabelTarget, Expression.Convert(callExpression, expBuilder.ToType))
: Expression.Return(expBuilder.LabelTarget, callExpression);
return(expBuilder
.AddVariable(converter)
.AddGuards()
.Add(assignConverter)
.Add(ifConverterNullReturn)
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
}
return(null);
}
public static IConvertResult <TFrom, TTo> ToResult <TFrom, TTo>(
this ExpBuilder <TFrom, TTo> expBuilder,
IConvertFactory factory)
{
var convertExpression = expBuilder?.Create();
return(new ConvertResult <TFrom, TTo>()
{
Factory = factory,
Expression = convertExpression,
Func = convertExpression?.Compile()
});
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var args = new ExpBuilder <TFrom, TTo>();
if (args.ToType == typeof(TestClass_1))
{
_count++;
args.Add(args.LabelExpression);
return(args.ToResult(this));
}
return(null);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.UnderlyingToType == typeof(T) &&
expBuilder.UnderlyingFromType != typeof(string) &&
expBuilder.UnderlyingFromType != typeof(object))
{
var methodInfo = typeof(System.Convert)
.GetRuntimeMethods()
.Where(x =>
x.ReturnType == expBuilder.UnderlyingToType &&
x.GetParameters().Length == 1 &&
x.GetParameters()[0].ParameterType == expBuilder.UnderlyingFromType)
.FirstOrDefault();
if (methodInfo != null)
{
if (_invalidCastTypes.Exists(x => x == expBuilder.UnderlyingFromType))
{
return(expBuilder
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else
{
Expression guardedInput = expBuilder.FromType.IsNullable()
? Expression.Property(expBuilder.Input, "Value")
: (Expression)expBuilder.Input;
MethodCallExpression callExpression = Expression.Call(
methodInfo,
guardedInput);
GotoExpression returnExpression = expBuilder.ToType.IsNullable()
? Expression.Return(expBuilder.LabelTarget, Expression.Convert(callExpression, expBuilder.ToType))
: Expression.Return(expBuilder.LabelTarget, callExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
}
}
return(null);
}
static void Main(string[] args)
{
//FsSqlBuilder.Exp.And()
// var asdf = new FsSqlBuilder.SqlConditionalExp(true, "A = 1", new ParameterDefinition("@A"));
var builder = new ExpBuilder();
builder.SqlCondition("A = @A", p => p.Varchar("@A", "Henrique", 50));
var a = new ConditionExpression("A = 1");
var b = new ConditionExpression("B = 2");
var c = new ConditionExpression("C = 3");
var d = new ConditionExpression("D = 4");
var r = (Op(1, false) || Op(2)) && Op(3, false) || (Op(4) && Op(5, false));
var exprA = a && (b && c) && d;
var exprB = a && b && c && d;
var exprC = a && (b || c) && d;
var exprD = a && b || c && d;
var exprE = a && (b || c && d);
var exprF = a || (b || c && d);
var exprG = a || b || c || d;
var exprH = a || b && c;
Console.WriteLine($"A) a && (b && c) && d |#####| {RenderSql(exprA)}");
Console.WriteLine($"B) a && b && c && d |#####| {RenderSql(exprB)}");
Console.WriteLine($"C) a && (b || c) && d |#####| {RenderSql(exprC)}");
Console.WriteLine($"D) a && b || c && d |#####| {RenderSql(exprD)}");
Console.WriteLine($"E) a && (b || c && d) |#####| {RenderSql(exprE)}");
Console.WriteLine($"F) a || (b || c && d) |#####| {RenderSql(exprF)}");
Console.WriteLine($"G) a || b || c || d |#####| {RenderSql(exprG)}");
Console.WriteLine($"H) a || b && c |#####| {RenderSql(exprH)}");
Console.WriteLine();
}
public GrammarReader(GrammarReaderController controller, ExpBuilder builder)
{
this.Controller = controller;
this.Builder = builder;
// this.ResManager = new ResourceManager(this.GetType());
this.ResManager = new ResourceManager("Tenuto.Reader.GrammarReader", this.GetType().Assembly);
{
// derived classes can set additional ExpReader directly to
// the ExpReaders field.
IDictionary dic = new Hashtable();
dic["notAllowed"] = new ExpReader(NotAllowed);
dic["empty"] = new ExpReader(Empty);
dic["group"] = new ExpReader(Group);
dic["choice"] = new ExpReader(Choice);
dic["interleave"] = new ExpReader(Interleave);
dic["optional"] = new ExpReader(Optional);
dic["zeroOrMore"] = new ExpReader(ZeroOrMore);
dic["oneOrMore"] = new ExpReader(OneOrMore);
dic["mixed"] = new ExpReader(Mixed);
dic["list"] = new ExpReader(List);
dic["element"] = new ExpReader(Element);
dic["attribute"] = new ExpReader(Attribute);
dic["externalRef"] = new ExpReader(ExternalRef);
dic["ref"] = new ExpReader(Ref);
dic["parentRef"] = new ExpReader(ParentRef);
dic["grammar"] = new ExpReader(GrammarElm);
dic["data"] = new ExpReader(Data);
dic["value"] = new ExpReader(Value);
dic["text"] = new ExpReader(Text);
ExpReaders = dic;
}
{
IDictionary dic = new Hashtable();
dic["choice"] = new NCReader(ChoiceName);
dic["name"] = new NCReader(SimpleName);
dic["nsName"] = new NCReader(NsName);
dic["anyName"] = new NCReader(AnyName);
NCReaders = dic;
}
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
// This will only return a func IF TFrom is an object
// or implements IConvertible and the TTo is supported by
// IConvertible.
if (expBuilder.FromType == typeof(object))
{
var methodInfo = typeof(ConvertObject <>)
.MakeGenericType(expBuilder.ToType)
.GetRuntimeMethods()
.Where(x =>
x.ReturnType == expBuilder.ToType &&
x.GetParameters().Length == 2 &&
x.GetParameters()[0].ParameterType == typeof(object) &&
x.GetParameters()[1].ParameterType == typeof(IFormatProvider))
.FirstOrDefault();
if (methodInfo != null)
{
Expression callExpression = Expression.Call(
methodInfo,
expBuilder.Input,
expBuilder.GetDefaultProvider());
GotoExpression returnExpression = Expression.Return(expBuilder.LabelTarget, callExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
}
return(null);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.FromType == typeof(string) &&
expBuilder.ToType != typeof(object))
{
var methodInfo = typeof(System.Convert)
.GetRuntimeMethods()
.Where(x =>
x.ReturnType == expBuilder.UnderlyingToType &&
x.GetParameters().Length == 2 &&
x.GetParameters()[0].ParameterType == expBuilder.FromType &&
x.GetParameters()[1].ParameterType == typeof(IFormatProvider))
.FirstOrDefault();
if (methodInfo != null)
{
MethodCallExpression convertExpression = Expression.Call(
methodInfo,
expBuilder.Input,
expBuilder.GetDefaultProvider());
GotoExpression returnExpression = expBuilder.ToType.IsNullable()
? Expression.Return(expBuilder.LabelTarget, Expression.Convert(convertExpression, expBuilder.ToType))
: Expression.Return(expBuilder.LabelTarget, convertExpression);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
}
return(null);
}
private IConvertResult <TFrom, TTo> GetEnum <TFrom, TTo>(
ExpBuilder <TFrom, TTo> expBuilder,
Expression guardedInput)
{
if (expBuilder.UnderlyingFromType.IsEnum)
{
var callExpression = Expression.Call(
typeof(EnumHelper <,>).MakeGenericType(
expBuilder.UnderlyingFromType,
Enum.GetUnderlyingType(expBuilder.UnderlyingFromType)),
"ConvertToString",
Array.Empty <Type>(),
guardedInput,
expBuilder.GetDefaultProvider());
return(expBuilder
.AddGuards()
.Add(Expression.Return(expBuilder.LabelTarget, callExpression))
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
public IConvertResult <TFrom, TTo> Create <TFrom, TTo>()
{
var expBuilder = new ExpBuilder <TFrom, TTo>();
if (expBuilder.FromType == expBuilder.ToType)
{
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
expBuilder.Input);
return(expBuilder
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else if (expBuilder.UnderlyingToType == expBuilder.UnderlyingFromType)
{
Expression guardedInput = expBuilder.FromType.IsNullable()
? Expression.Property(expBuilder.Input, "Value")
: (Expression)expBuilder.Input;
GotoExpression returnExpression = expBuilder.ToType.IsNullable()
? Expression.Return(expBuilder.LabelTarget, Expression.Convert(guardedInput, expBuilder.ToType))
: Expression.Return(expBuilder.LabelTarget, guardedInput);
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else if (expBuilder.ToType == typeof(object))
{
if (expBuilder.FromType.IsNullable())
{
var hasValue = Expression.Property(expBuilder.Input, "HasValue");
var value = Expression.Property(expBuilder.Input, "Value");
GotoExpression returnValue = Expression.Return(
expBuilder.LabelTarget,
Expression.Convert(value, expBuilder.ToType));
GotoExpression returnDefault = Expression.Return(
expBuilder.LabelTarget,
expBuilder.DefaultExpression);
var ifThenElse = Expression.IfThenElse(
hasValue,
returnValue,
returnDefault);
return(expBuilder
.Add(ifThenElse)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else
{
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
Expression.Convert(expBuilder.Input, typeof(object)));
return(expBuilder
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
}
else if (expBuilder.ToType.IsAssignableFrom(expBuilder.FromType))
{
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
Expression.Convert(expBuilder.Input, expBuilder.ToType));
return(expBuilder
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
else if (expBuilder.ToType.IsAssignableFrom(expBuilder.UnderlyingFromType))
{
var value = Expression.Property(expBuilder.Input, "Value");
GotoExpression returnExpression = Expression.Return(
expBuilder.LabelTarget,
Expression.Convert(value, expBuilder.ToType));
return(expBuilder
.AddGuards()
.Add(returnExpression)
.Add(expBuilder.LabelExpression)
.ToResult(this));
}
return(null);
}
public Grammar( ExpBuilder builder )
: this(null,builder)
{
}
public Grammar( Grammar parent, ExpBuilder builder )
: base(null)
{
this.Parent = parent;
this.Builder = builder;
}
internal StringToken(string literal, ExpBuilder builder, ValidationContext context)
{
this.literal = literal;
this.builder = builder;
this.context = context;
}
public static Expression Calc(Expression exp, Token token, ExpBuilder builder)
{
return(exp.Visit(new Residual(token, builder)));
}
public GrammarReader( GrammarReaderController controller, ExpBuilder builder )
{
this.Controller = controller;
this.Builder = builder;
// this.ResManager = new ResourceManager(this.GetType());
this.ResManager = new ResourceManager("GrammarReader",this.GetType().Assembly);
{
// derived classes can set additional ExpReader directly to
// the ExpReaders field.
IDictionary dic = new Hashtable();
dic["notAllowed"] = new ExpReader(NotAllowed);
dic["empty"] = new ExpReader(Empty);
dic["group"] = new ExpReader(Group);
dic["choice"] = new ExpReader(Choice);
dic["interleave"] = new ExpReader(Interleave);
dic["optional"] = new ExpReader(Optional);
dic["zeroOrMore"] = new ExpReader(ZeroOrMore);
dic["oneOrMore"] = new ExpReader(OneOrMore);
dic["mixed"] = new ExpReader(Mixed);
dic["list"] = new ExpReader(List);
dic["element"] = new ExpReader(Element);
dic["attribute"] = new ExpReader(Attribute);
dic["externalRef"] = new ExpReader(ExternalRef);
dic["ref"] = new ExpReader(Ref);
dic["parentRef"] = new ExpReader(ParentRef);
dic["grammar"] = new ExpReader(GrammarElm);
dic["data"] = new ExpReader(Data);
dic["value"] = new ExpReader(Value);
dic["text"] = new ExpReader(Text);
ExpReaders = dic;
}
{
IDictionary dic = new Hashtable();
dic["choice"] = new NCReader(ChoiceName);
dic["name"] = new NCReader(SimpleName);
dic["nsName"] = new NCReader(NsName);
dic["anyName"] = new NCReader(AnyName);
NCReaders = dic;
}
}
protected Residual(Token token, ExpBuilder builder)
{
this.token = token;
this.builder = builder;
}
public ExpCloner(ExpBuilder builder)
{
this.builder = builder;
}
public AttPruner(ExpBuilder builder)
{
pruner = new AttPrunerImpl(builder);
}
public AttPrunerImpl(ExpBuilder builder) : base(builder)
{
}
public AttFeeder(ExpBuilder builder, Token _token) : base(builder)
{
this.token = _token;
}
internal AttributeToken(string uri, string localName, string value, ValidationContext context, ExpBuilder builder)
{
this.uri = uri;
this.localName = localName;
this.value = value;
this.context = context;
this.builder = builder;
this.ignorable = (value.Trim().Length == 0);
}
public static Expression Calc( Expression exp, Token token, ExpBuilder builder )
{
return exp.Visit( new Residual(token,builder) );
}
protected Residual( Token token, ExpBuilder builder )
{
this.token = token;
this.builder = builder;
}
