public override ISymbolValue this[DVariable n]
{
get
{
if (n == null)
{
return(new ErrorValue(new EvaluationException("There must be a valid variable node given in order to retrieve its value")));
}
if (n.IsConst)
{
if (varsBeingResolved.Contains(n))
{
return(new ErrorValue(new EvaluationException("Cannot reference itself")));
}
varsBeingResolved.Add(n);
// .. resolve it's pre-compile time value and make the returned value the given argument
ISymbolValue val;
try{
val = Evaluation.EvaluateValue(n.Initializer, this);
}
finally{
varsBeingResolved.Remove(n);
}
// If it's null, then the initializer is null - which is equal to e.g. 0 or null !;
if (val != null)
{
return(val);
}
}
return(new ErrorValue(new EvaluationException(n + " must have a constant initializer")));
}
set
{
throw new NotImplementedException();
}
}
/// <summary>
/// Since most expressions should return a single type only, it's not needed to use this function unless you might
/// want to pay attention on (illegal) multiple overloads.
/// </summary>
public static AbstractType[] EvaluateTypes(IExpression x, ResolutionContext ctxt)
{
var ev = new Evaluation(ctxt);
ISemantic t = null;
if (!Debugger.IsAttached)
{
try { t = ev.E(x); }
catch { }
}
else
{
t = ev.E(x);
}
if (t is InternalOverloadValue)
{
return(((InternalOverloadValue)t).Overloads);
}
return(t == null ? null : new[] { AbstractType.Get(t) });
}
public static ISymbolValue EvaluateValue(IExpression x, AbstractSymbolValueProvider vp)
{
if (vp == null)
vp = new StandardValueProvider(null);
var ev = new Evaluation(vp);
var v = ev.E(x) as ISymbolValue;
if(v == null && ev.Errors.Count != 0)
return new ErrorValue(ev.Errors.ToArray());
return v;
}
public static AbstractType EvaluateType(IExpression x, ResolutionContext ctxt)
{
var ev = new Evaluation(ctxt);
ISemantic t = null;
if(!Debugger.IsAttached)
try { t = ev.E(x); }
catch { }
else
t = ev.E(x);
return AbstractType.Get(t);
}
/// <summary>
/// Since most expressions should return a single type only, it's not needed to use this function unless you might
/// want to pay attention on (illegal) multiple overloads.
/// </summary>
public static AbstractType[] EvaluateTypes(IExpression x, ResolutionContext ctxt)
{
var ev = new Evaluation(ctxt);
ISemantic t = null;
if(!Debugger.IsAttached)
try { t = ev.E(x); }
catch { }
else
t = ev.E(x);
if (t is InternalOverloadValue)
return ((InternalOverloadValue)t).Overloads;
return t == null ? null : new[]{ AbstractType.Get(t) };
}
public static AbstractType[] GetUnfilteredMethodOverloads(IExpression foreExpression, ResolutionContext ctxt, IExpression supExpression = null)
{
AbstractType[] overloads = null;
if (foreExpression is TemplateInstanceExpression)
{
overloads = Evaluation.GetOverloads(foreExpression as TemplateInstanceExpression, ctxt, null);
}
else if (foreExpression is IdentifierExpression)
{
overloads = Evaluation.GetOverloads(foreExpression as IdentifierExpression, ctxt, false);
}
else if (foreExpression is PostfixExpression_Access)
{
overloads = Evaluation.GetAccessedOverloads((PostfixExpression_Access)foreExpression, ctxt, null, false);
}
else if (foreExpression is TokenExpression)
{
overloads = GetResolvedConstructorOverloads((TokenExpression)foreExpression, ctxt);
}
else
{
overloads = new[] { Evaluation.EvaluateType(foreExpression, ctxt) }
};
var l = new List <AbstractType>();
bool staticOnly = true;
foreach (var ov in DResolver.StripAliasSymbols(overloads))
{
var t = ov;
if (ov is MemberSymbol)
{
var ms = ov as MemberSymbol;
if (ms.Definition is Dom.DMethod)
{
l.Add(ms);
continue;
}
staticOnly = false;
t = DResolver.StripAliasSymbol(ms.Base);
}
if (t is TemplateIntermediateType)
{
var tit = t as TemplateIntermediateType;
var m = TypeDeclarationResolver.HandleNodeMatches(
GetOpCalls(tit, staticOnly), ctxt,
null, supExpression ?? foreExpression);
/*
* On structs, there must be a default () constructor all the time.
* If there are (other) constructors in structs, the explicit member initializer constructor is not
* provided anymore. This will be handled in the GetConstructors() method.
* If there are opCall overloads, canCreateeExplicitStructCtor overrides the ctor existence check in GetConstructors()
* and enforces that the explicit ctor will not be generated.
* An opCall overload with no parameters supersedes the default ctor.
*/
var canCreateExplicitStructCtor = m == null || m.Length == 0;
if (!canCreateExplicitStructCtor)
{
l.AddRange(m);
}
m = TypeDeclarationResolver.HandleNodeMatches(
GetConstructors(tit, canCreateExplicitStructCtor), ctxt,
null, supExpression ?? foreExpression);
if (m != null && m.Length != 0)
{
l.AddRange(m);
}
}
else
{
l.Add(ov);
}
}
return(l.ToArray());
}
