public static TypeCode GetNumericLiteralType(string literal)
{
char suffix = BindHelper.GetNumericLiteralSuffix(literal);
switch (suffix)
{
case 'F':
case 'f':
return(TypeCode.Single);
case 'M':
case 'm':
return(TypeCode.Decimal);
case 'D':
case 'd':
return(TypeCode.Double);
case 'L':
case 'l':
return(TypeCode.Int64);
case 'I':
case 'i':
return(TypeCode.Int32);
case '\0':
default:
return(TypeCode.Empty);
}
}
private static object ResolveScopeWalkBindTarget(string bindAs, LambdaRepository lambdaRepo, ScopeChain scopeChain)
{
int lastIdxOf;
int depth = BindHelper.CountInstancesOfPattern(bindAs, @"..\", out lastIdxOf);
object target = BindHelper.ResolveBindTarget(bindAs.Substring(lastIdxOf + 3, bindAs.Length - (depth * 3)), lambdaRepo, scopeChain, depth);
return(target);
}
private object EnsureCharArgument(string arg, ScopeChain scopeChain, string lambdaName, int index)
{
object target = null;
if (BindHelper.IsDoubleQuoted(arg) || BindHelper.IsSingleQuoted(arg))
{
target = arg.Substring(1, (arg.Length - 2));
}
else
{
target = BindHelper.ResolveBindTarget(arg, this, scopeChain);
this.EnsureArgumentType(arg, target, TypeCode.Char, lambdaName, index);
}
return(target);
}
public static char GetNumericLiteralSuffix(string literal)
{
if (!BindHelper.IsNumericLiteral(literal))
{
return('\0');
}
int lastIndex = literal.Length - 1;
if (char.IsDigit(literal[lastIndex]) || literal[lastIndex] == '.')
{
return('\0');
}
return(literal[lastIndex]);
}
private static object ResolveVariableReferenceBindTarget(string bindAs, LambdaRepository lambdaRepo, ScopeChain scopeChain)
{
object target = null;
int dot = bindAs.IndexOf('.');
if (dot > -1)
{
target = scopeChain.AccessVariable(bindAs.Substring(0, dot));
scopeChain.Push(target);
target = BindHelper.ResolveBindTarget(bindAs.Substring(++dot, bindAs.Length - dot), lambdaRepo, scopeChain);
scopeChain.Pop();
}
else
{
target = scopeChain.AccessVariable(bindAs);
}
return(target);
}
private object EnsureUInt64Argument(string arg, ScopeChain scopeChain, string lambdaName, int index)
{
object target = null;
if (char.IsDigit(arg[0])) //must be numeric literal
{
if (!UInt64.TryParse(arg, out UInt64 u))
{
throw new MergeException(this.FormatExceptionMessageBuilder(lambdaName, arg, index, TypeCode.UInt64));
}
target = u;
}
else
{
target = BindHelper.ResolveBindTarget(arg, this, scopeChain);
this.EnsureArgumentType(arg, target, TypeCode.UInt64, lambdaName, index);
}
return(target);
}
private object EnsureSingleArgument(string arg, ScopeChain scopeChain, string lambdaName, int index)
{
object target = null;
if (char.IsDigit(arg[0]) || arg[0] == '.' || arg[0] == '-' || arg[0] == '+') //must be numeric literal
{
if (!Single.TryParse(arg, out Single s))
{
throw new MergeException(this.FormatExceptionMessageBuilder(lambdaName, arg, index, TypeCode.Single));
}
target = s;
}
else
{
target = BindHelper.ResolveBindTarget(arg, this, scopeChain);
this.EnsureArgumentType(arg, target, TypeCode.Single, lambdaName, index);
}
return(target);
}
public object EnsureBooleanArgument(string arg, ScopeChain scopeChain, string lambdaName, int index)
{
object target = null;
if (string.Compare(arg, "true", true) == 0)
{
target = true;
}
else if (string.Compare(arg, "false", true) == 0)
{
target = false;
}
else
{
target = BindHelper.ResolveBindTarget(arg, this, scopeChain);
this.EnsureArgumentType(arg, target, TypeCode.Boolean, lambdaName, index);
}
return(target);
}
private object EnsureDateTimeArgument(string arg, ScopeChain scopeChain, string lambdaName, int index)
{
object target = null;
if (BindHelper.IsDoubleQuoted(arg) || BindHelper.IsSingleQuoted(arg))
{
arg = arg.Substring(1, (arg.Length - 2));
if (!DateTime.TryParse(arg, out DateTime dt))
{
throw new MergeException(this.FormatExceptionMessageBuilder(lambdaName, arg, index, TypeCode.DateTime));
}
return(dt);
}
else
{
target = BindHelper.ResolveBindTarget(arg, this, scopeChain);
this.EnsureArgumentType(arg, target, TypeCode.DateTime, lambdaName, index);
}
return(target);
}
public static object ResolveBindTarget(string bindAs, LambdaRepository lambdaRepo, ScopeChain scopeChain, int scopeLinkDepth = 0)
{
object target = null;
object localScope = scopeChain.Peek(scopeLinkDepth);
if (bindAs.Length == 1 && bindAs[0] == '$')//append bindto obj
{
target = localScope;
}
else if (bindAs[0] == '$' && bindAs[1] == '.')//reflect from bindto object
{
target = BindHelper.ResolveRootedBindTarget(bindAs, localScope);
}
else if (bindAs[0] == ':')//variable reference
{
target = BindHelper.ResolveVariableReferenceBindTarget(bindAs, lambdaRepo, scopeChain);
}
else if (bindAs[0] == '.' && bindAs[1] == '.' && bindAs[2] == '\\')//scope chain walk ..\
{
target = BindHelper.ResolveScopeWalkBindTarget(bindAs, lambdaRepo, scopeChain);
}
else if (BindHelper.IsLambdaExpression(bindAs))//lambda expression
{
target = BindHelper.ResolveLambdaExpressionBindTarget(bindAs, lambdaRepo, scopeChain);
}
else//simple bind
{
target = ReflectionHelper.Expression.ReflectItem(localScope, bindAs);
}
return(target);
}
public static object ParseNumericLiteral(string literal)
{
Func <TypeCode, string, string> exceptionMsg = (tc, lit) =>
{
return($"attempted to parse numeric literal: {lit} as: {tc} failed");
};
TypeCode typeCode = BindHelper.GetNumericLiteralType(literal);
object value = null;
switch (typeCode)
{
case TypeCode.Decimal:
if (!decimal.TryParse(literal.TrimEnd('m', 'M'), out decimal dec))
{
throw new MergeException(exceptionMsg(TypeCode.Decimal, literal));
}
value = dec;
break;
case TypeCode.Double:
if (!double.TryParse(literal.TrimEnd('d', 'D'), out double dbl))
{
throw new MergeException(exceptionMsg(TypeCode.Double, literal));
}
value = dbl;
break;
case TypeCode.Int32:
if (!int.TryParse(literal.TrimEnd('i', 'I'), out int i))
{
throw new MergeException(exceptionMsg(TypeCode.Int32, literal));
}
value = i;
break;
case TypeCode.Int64:
if (!long.TryParse(literal.TrimEnd('l', 'L'), out long l))
{
throw new MergeException(exceptionMsg(TypeCode.Int64, literal));
}
value = l;
break;
case TypeCode.Single:
if (!Single.TryParse(literal.TrimEnd('f', 'F'), out Single s))
{
throw new MergeException(exceptionMsg(TypeCode.Single, literal));
}
value = s;
break;
case TypeCode.Empty:
default:
throw new MergeException($"attempted to parse numeric literal: {literal} type could not be determined. valid type postfix values: m,d,i,l,f");
}
return(value);
}
private object CaptureLambdaArgument(string arg, ScopeChain scopeChain, ParameterInfo paramInfo, string lambda, int index)
{
object obj = null;
TypeCode tCode = Type.GetTypeCode(paramInfo.ParameterType);
switch (tCode)
{
case TypeCode.Object:
obj = BindHelper.ResolveBindTarget(arg, this, scopeChain);
break;
case TypeCode.Boolean:
obj = this.EnsureBooleanArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Byte:
obj = this.EnsureByteArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Char:
obj = this.EnsureCharArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.String:
obj = this.EnsureStringArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.DateTime:
obj = this.EnsureDateTimeArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Decimal:
obj = this.EnsureDecimalArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Double:
obj = this.EnsureDoubleArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Int16:
obj = this.EnsureInt16Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.Int32:
obj = this.EnsureInt32Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.Int64:
obj = this.EnsureInt64Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.UInt16:
obj = this.EnsureUInt16Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.UInt32:
obj = this.EnsureUInt32Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.UInt64:
obj = this.EnsureUInt64Argument(arg, scopeChain, lambda, index);
break;
case TypeCode.SByte:
obj = this.EnsureSByteArgument(arg, scopeChain, lambda, index);
break;
case TypeCode.Single:
obj = this.EnsureSingleArgument(arg, scopeChain, lambda, index);;
break;
//case TypeCode.Empty:
// break;
//case TypeCode.DBNull:
// break;
default:
throw new MergeException($"encountered un-expected Type.TypeCode: {tCode}");
}
return(obj);
}
