ISemantic HandleSingleMathOp(OperatorBasedExpression x, ISemantic l, ISemantic r, MathOp2 m, bool UnorderedCheck = true)
{
var pl = l as PrimitiveValue;
var pr = r as PrimitiveValue;
//TODO: imaginary/complex parts
if (pl != null && pr != null)
{
if (UnorderedCheck && (pl.IsNaN || pr.IsNaN))
{
return(PrimitiveValue.CreateNaNValue(x, pl.IsNaN ? pl.BaseTypeToken : pr.BaseTypeToken));
}
return(m(pl, pr, x));
}
throw new NotImplementedException("Operator overloading not implemented yet.");
}
/// <summary>
/// Handles mathemathical operation.
/// If l and r are both primitive values, the MathOp delegate is executed.
///
/// TODO: Operator overloading.
/// </summary>
ISemantic HandleSingleMathOp(IExpression x, ISemantic l, ISemantic r, MathOp m)
{
var pl = l as PrimitiveValue;
var pr = r as PrimitiveValue;
//TODO: imaginary/complex parts
if (pl != null && pr != null)
{
// If one
if (pl.IsNaN || pr.IsNaN)
{
return(PrimitiveValue.CreateNaNValue(x, pl.IsNaN ? pl.BaseTypeToken : pr.BaseTypeToken));
}
return(new PrimitiveValue(pl.BaseTypeToken, m(pl, pr), x));
}
throw new NotImplementedException("Operator overloading not implemented yet.");
}
static PrimitiveValue mult(PrimitiveValue a, PrimitiveValue b, OperatorBasedExpression x)
{
decimal v = 0;
decimal im=0;
switch (x.OperatorToken)
{
case DTokens.Pow:
v = (decimal)Math.Pow((double)a.Value, (double)b.Value);
v = (decimal)Math.Pow((double)a.ImaginaryPart, (double)b.ImaginaryPart);
break;
case DTokens.Times:
v= a.Value * b.Value;
im=a.ImaginaryPart * b.ImaginaryPart;
break;
case DTokens.Div:
if ((a.Value!=0 && b.Value == 0) || (a.ImaginaryPart!=0 && b.ImaginaryPart==0))
throw new DivideByZeroException();
if(b.Value!=0)
v= a.Value / b.Value;
if(b.ImaginaryPart!=0)
im=a.ImaginaryPart / b.ImaginaryPart;
break;
case DTokens.Mod:
if ((a.Value!=0 && b.Value == 0) || (a.ImaginaryPart!=0 && b.ImaginaryPart==0))
throw new DivideByZeroException();
if(b.Value!=0)
v= a.Value % b.Value;
if(b.ImaginaryPart!=0)
im=a.ImaginaryPart % b.ImaginaryPart;
break;
default:
return null;
//EvalError(x, "Invalid token for multiplication expression (*,/,% only)");
}
return new PrimitiveValue(a.BaseTypeToken, v, x, im);
}
public static AbstractType EvalMethodCall(AbstractType[] baseExpression, ISymbolValue baseValue, TemplateInstanceExpression tix,
ResolutionContext ctxt,
PostfixExpression_MethodCall call, out List <ISemantic> callArguments, out ISymbolValue delegateValue,
bool returnBaseTypeOnly, AbstractSymbolValueProvider ValueProvider = null)
{
//TODO: Refactor this crap!
delegateValue = null;
callArguments = null;
var methodOverloads = new List <AbstractType>();
#region Search possible methods, opCalls or delegates that could be called
bool requireStaticItems = true; //TODO: What if there's an opCall and a foreign method at the same time? - and then this variable would be bullshit
IEnumerable <AbstractType> scanResults = baseExpression;
var nextResults = new List <AbstractType>();
while (scanResults != null)
{
foreach (var b in scanResults)
{
if (b is AmbiguousType)
{
nextResults.AddRange((b as AmbiguousType).Overloads);
}
else if (b is TemplateParameterSymbol)
{
nextResults.Add((b as TemplateParameterSymbol).Base);
}
else if (b is MemberSymbol)
{
var mr = (MemberSymbol)b;
if (mr.Definition is DMethod)
{
methodOverloads.Add(mr);
continue;
}
else if (mr.Definition is DVariable)
{
// If we've got a variable here, get its base type/value reference
if (ValueProvider != null)
{
var dgVal = ValueProvider[(DVariable)mr.Definition] as DelegateValue;
if (dgVal != null)
{
nextResults.Add(dgVal.Definition);
continue;
}
else
{
ValueProvider.LogError(call, "Variable must be a delegate, not anything else");
return(null);
}
}
else
{
var bt = mr.Base ?? TypeDeclarationResolver.ResolveSingle(mr.Definition.Type, ctxt);
// Must be of type delegate
if (bt is DelegateType)
{
var ret = HandleCallDelegateType(ValueProvider, bt as DelegateType, methodOverloads, returnBaseTypeOnly);
if (ret is ISymbolValue)
{
delegateValue = ret as ISymbolValue;
return(null);
}
else if (ret is AbstractType)
{
return(ret as AbstractType);
}
}
else
{
/*
* If mr.Node is not a method, so e.g. if it's a variable
* pointing to a delegate
*
* class Foo
* {
* string opCall() { return "asdf"; }
* }
*
* Foo f=new Foo();
* f(); -- calls opCall, opCall is not static
*/
nextResults.Add(bt);
requireStaticItems = false;
}
//TODO: Can other types work as function/are callable?
}
}
}
else if (b is DelegateType)
{
var ret = HandleCallDelegateType(ValueProvider, b as DelegateType, methodOverloads, returnBaseTypeOnly);
if (ret is ISymbolValue)
{
delegateValue = ret as ISymbolValue;
return(null);
}
else if (ret is AbstractType)
{
return(ret as AbstractType);
}
}
else if (b is ClassType || b is StructType)
{
var tit = (TemplateIntermediateType)b;
/*
* auto a = MyStruct(); -- opCall-Overloads can be used
*/
var classDef = tit.Definition;
if (classDef == null)
{
continue;
}
foreach (var i in ExpressionTypeEvaluation.GetOpCalls(tit, requireStaticItems))
{
methodOverloads.Add(TypeDeclarationResolver.HandleNodeMatch(i, ctxt, b, call) as MemberSymbol);
}
/*
* Every struct can contain a default ctor:
*
* struct S { int a; bool b; }
*
* auto s = S(1,true); -- ok
* auto s2= new S(2,false); -- error, no constructor found!
*/
if (b is StructType && methodOverloads.Count == 0)
{
//TODO: Deduce parameters
return(b);
}
}
/*
* If the overload is a template, it quite exclusively means that we'll handle a method that is the only
* child inside a template + that is named as the template.
*/
else if (b is TemplateType)
{
methodOverloads.Add(b);
}
else if (b is PrimitiveType) // dmd 2.066: Uniform Construction Syntax. creal(3) is of type creal.
{
methodOverloads.Add(b);
}
}
scanResults = nextResults.Count == 0 ? null : nextResults.ToArray();
nextResults.Clear();
}
#endregion
if (methodOverloads.Count == 0)
{
return(null);
}
// Get all arguments' types
callArguments = new List <ISemantic>();
if (call.Arguments != null)
{
if (ValueProvider != null)
{
foreach (var arg in call.Arguments)
{
callArguments.Add(arg != null ? Evaluation.EvaluateValue(arg, ValueProvider) : null);
}
}
else
{
foreach (var arg in call.Arguments)
{
callArguments.Add(arg != null ? ExpressionTypeEvaluation.EvaluateType(arg, ctxt) : null);
}
}
}
#region If explicit template type args were given, try to associate them with each overload
if (tix != null)
{
var args = TemplateInstanceHandler.PreResolveTemplateArgs(tix, ctxt);
var deducedOverloads = TemplateInstanceHandler.DeduceParamsAndFilterOverloads(methodOverloads, args, true, ctxt);
methodOverloads.Clear();
if (deducedOverloads != null)
{
methodOverloads.AddRange(deducedOverloads);
}
}
#endregion
#region Filter by parameter-argument comparison
var argTypeFilteredOverloads = new List <AbstractType>();
bool hasHandledUfcsResultBefore = false;
AbstractType untemplatedMethodResult = null;
foreach (var ov in methodOverloads)
{
if (ov is MemberSymbol)
{
HandleDMethodOverload(ctxt, ValueProvider != null, baseValue, callArguments, returnBaseTypeOnly, argTypeFilteredOverloads, ref hasHandledUfcsResultBefore,
ov as MemberSymbol, ref untemplatedMethodResult);
}
else if (ov is DelegateType)
{
var dg = ov as DelegateType;
var bt = dg.Base ?? TypeDeclarationResolver.GetMethodReturnType(dg, ctxt);
//TODO: Param-Arg check
if (returnBaseTypeOnly)
{
argTypeFilteredOverloads.Add(bt);
}
else
{
if (dg.Base == null)
{
if (dg.IsFunctionLiteral)
{
dg = new DelegateType(bt, dg.DeclarationOrExpressionBase as FunctionLiteral, dg.Parameters);
}
else
{
dg = new DelegateType(bt, dg.DeclarationOrExpressionBase as DelegateDeclaration, dg.Parameters);
}
}
argTypeFilteredOverloads.Add(new DelegateCallSymbol(dg, call));
}
}
else if (ov is PrimitiveType) // dmd 2.066: Uniform Construction Syntax. creal(3) is of type creal.
{
if (ValueProvider != null)
{
if (callArguments == null || callArguments.Count != 1)
{
ValueProvider.LogError(call, "Uniform construction syntax expects exactly one argument");
}
else
{
var pv = callArguments[0] as PrimitiveValue;
if (pv == null)
{
ValueProvider.LogError(call, "Uniform construction syntax expects one built-in scalar value as first argument");
}
else
{
delegateValue = new PrimitiveValue(pv.Value, ov as PrimitiveType, pv.ImaginaryPart);
}
}
}
argTypeFilteredOverloads.Add(ov);
}
}
// Prefer untemplated methods over templated ones
if (untemplatedMethodResult != null)
{
return(untemplatedMethodResult);
}
#endregion
return(AmbiguousType.Get(argTypeFilteredOverloads, tix));
}
bool EnsureIntegralType(IExpression x,PrimitiveValue v)
{
if (!DTokens.IsBasicType_Integral(v.BaseTypeToken)){
EvalError(x,"Literal must be of integral type",new[]{(ISemantic)v});
return false;
}
return true;
}
void EnsureIntegralType(PrimitiveValue v)
{
if (!DTokens.BasicTypes_Integral[v.BaseTypeToken])
throw new EvaluationException(v.BaseExpression, "Literal must be of integral type",v);
}