public static AbstractType Demangle(string mangledString, out ITypeDeclaration qualifier, out bool isCFunction)
{
if (string.IsNullOrEmpty(mangledString))
{
throw new ArgumentException("input string must not be null or empty!");
}
if (!mangledString.StartsWith("_D"))
{
isCFunction = true;
if (mangledString.StartsWith("__D"))
{
mangledString = mangledString.Substring(1);
}
// C Functions
else if (mangledString.StartsWith("_"))
{
qualifier = new IdentifierDeclaration(mangledString.Substring(1));
return(null);
}
}
//TODO: What about C functions that start with 'D'?
isCFunction = false;
var dmng = new Demangler(mangledString);
return(dmng.MangledName(out qualifier));
}
bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
{
// Bottom-level reached
if (id.InnerDeclaration == null && Contains(id.IdHash) && !id.ModuleScoped)
{
// Associate template param with r
return(Set((p != null && id.IdHash == p.NameHash) ? p : null, r, id.IdHash));
}
var deducee = DResolver.StripMemberSymbols(AbstractType.Get(r)) as DSymbol;
if (id.InnerDeclaration != null && deducee != null && deducee.Definition.NameHash == id.IdHash)
{
var physicalParentType = TypeDeclarationResolver.HandleNodeMatch(deducee.Definition.Parent, ctxt, null, id.InnerDeclaration);
if (HandleDecl(p, id.InnerDeclaration, physicalParentType))
{
if (Contains(id.IdHash))
{
Set((p != null && id.IdHash == p.NameHash) ? p : null, deducee, id.IdHash);
}
return(true);
}
}
/*
* If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
*/
var _r = TypeDeclarationResolver.ResolveSingle(id, ctxt);
return(_r != null && (EnforceTypeEqualityWhenDeducing ?
ResultComparer.IsEqual(r, _r) :
ResultComparer.IsImplicitlyConvertible(r, _r)));
}
bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
{
// Bottom-level reached
if (id.InnerDeclaration == null && Contains(id.IdHash) && !id.ModuleScoped)
{
// Associate template param with r
return Set((p != null && id.IdHash == p.NameHash) ? p : null, r, id.IdHash);
}
var deducee = DResolver.StripMemberSymbols(AbstractType.Get(r)) as DSymbol;
if (id.InnerDeclaration != null && deducee != null && deducee.Definition.NameHash == id.IdHash)
{
var physicalParentType = TypeDeclarationResolver.HandleNodeMatch(deducee.Definition.Parent, ctxt, null, id.InnerDeclaration);
if (HandleDecl(p, id.InnerDeclaration, physicalParentType))
{
if (Contains(id.IdHash))
Set((p != null && id.IdHash == p.NameHash) ? p : null, deducee, id.IdHash);
return true;
}
}
/*
* If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
*/
var _r = TypeDeclarationResolver.Resolve(id, ctxt);
ctxt.CheckForSingleResult(_r, id);
return _r != null && _r.Length != 0 &&
(EnforceTypeEqualityWhenDeducing ?
ResultComparer.IsEqual(r,_r[0]) :
ResultComparer.IsImplicitlyConvertible(r,_r[0]));
}
/// <summary>
/// See <see cref="Resolve"/>
/// </summary>
public static AbstractType ResolveSingle(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
var r = Resolve(id, ctxt, resultBases, filterForTemplateArgs);
ctxt.CheckForSingleResult(r, id);
return(r != null && r.Length != 0 ? r[0] : null);
}
public static AbstractType getStringType(ResolverContextStack ctxt)
{
var str = new IdentifierDeclaration("string");
var sType = TypeDeclarationResolver.Resolve(str, ctxt);
ctxt.CheckForSingleResult(sType, str);
return(sType != null && sType.Length != 0 ? sType[0] : null);
}
ITypeDeclaration QualifiedName()
{
ITypeDeclaration td = null;
int n;
while (PeekIsDecNumber)
{
// Read number of either the first LName or TemplateInstanceName
n = (int)Number();
sb.Clear();
if ((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if ((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if ((char)r.Peek() == 'T')
{
r.Read();
// We've got to handle a Template instance:
// Number __T LName TemplateArgs Z
var tpi = new TemplateInstanceExpression(new IdentifierDeclaration(LName()));
tpi.InnerDeclaration = td;
td = tpi;
var xx = new List <IExpression>();
while (r.Peek() != -1)
{
var arg = TemplateArg();
if (arg == null)
{
break;
}
xx.Add(arg);
}
tpi.Arguments = xx.ToArray();
continue;
}
}
}
// Just an LName
if (n > sb.Length)
{
sb.Append(LName(n - sb.Length));
}
var ttd = new IdentifierDeclaration(sb.ToString());
ttd.InnerDeclaration = td;
td = ttd;
}
return(td);
}
public override void Visit(IdentifierDeclaration td)
{
if (DoPrimaryIdCheck(td.IdHash))
{
AddResult(td);
}
base.Visit(td);
}
public override void Visit(IdentifierDeclaration x)
{
if (x.Location <= caret && x.EndLocation >= caret)
{
IdNearCaret = x;
}
else
{
base.Visit(x);
}
}
public override void Visit(IdentifierDeclaration td)
{
byte type;
if (DoPrimaryIdCheck(td.IdHash, out type))
{
AddResult(td, type);
}
base.Visit(td);
}
private static void EmitDeclarationStatement(IdentifierDeclaration declaration, ILGenerator methodIL)
{
foreach (IdentifierExpression identifier in declaration.DeclaringIdentifiers)
{
EmitIdentifierExpression(identifier, methodIL);
}
if (declaration.AssingningExpression != null)
{
EmitAssignmentStatement(declaration.AssingningExpression, methodIL);
}
}
public override void Visit(IdentifierDeclaration id)
{
if (id.IdHash == searchHash || resolveAnyway)
{
ctxt.CurrentContext.Set(id.Location);
if (TryAdd(TypeDeclarationResolver.ResolveSingle(id, ctxt), id))
{
return;
}
}
base.Visit(id);
}
public static void ResolveDeclarationStatement(IdentifierDeclaration declaration, Table.Table table)
{
if (declaration.AssingningExpression != null)
{
ResolveAssignmentStatement(declaration.AssingningExpression, table);
}
else
{
foreach (IdentifierExpression identifier in declaration.DeclaringIdentifiers)
{
ResolveIdentifierExpression(identifier, table, null);
}
}
}
public override void Visit(IdentifierDeclaration td)
{
if (td.IdHash == DTokens.IncompleteIdHash)
{
halt = true;
if (td.InnerDeclaration != null)
{
prv = new MemberCompletionProvider(cdgen, td.InnerDeclaration, scopedBlock);
}
}
else
{
base.Visit(td);
}
}
ITypeDeclaration VisitDSymbol(DSymbol t)
{
var def = t.Definition;
ITypeDeclaration td = new IdentifierDeclaration(def != null ? def.NameHash : 0);
if (def != null && t.DeducedTypes != null && def.TemplateParameters != null)
{
var args = new List <IExpression>();
foreach (var tp in def.TemplateParameters)
{
IExpression argEx = null;
foreach (var tps in t.DeducedTypes)
{
if (tps != null && tps.Parameter == tp)
{
if (tps.ParameterValue != null)
{
//TODO: Convert ISymbolValues back to IExpression
}
else
{
argEx = new TypeDeclarationExpression(AcceptType(tps));
}
break;
}
}
args.Add(argEx ?? new IdentifierExpression(tp.NameHash));
}
td = new TemplateInstanceExpression(td)
{
Arguments = args.ToArray()
};
}
var ret = td;
while (def != null && def != (def = def.Parent as DNode) &&
def != null && !(def is DModule))
{
td = td.InnerDeclaration = new IdentifierDeclaration(def.NameHash);
}
return(ret);
}
public override void Visit(IdentifierDeclaration id)
{
var resolvedSymbol = TryPopPFAStack();
if (id.IdHash == searchHash)
{
if (resolvedSymbol == null)
{
resolvedSymbol = TypeDeclarationResolver.ResolveSingle(id, ctxt) as DSymbol;
}
if (resolvedSymbol != null && resolvedSymbol.Definition == symbol)
{
l.Add(id);
return;
}
}
base.Visit(id);
}
bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
{
// Bottom-level reached
if (id.InnerDeclaration == null && Contains(id.Id) && !id.ModuleScoped)
{
// Associate template param with r
return(Set(p, r, id.Id));
}
/*
* If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
*/
var _r = TypeDeclarationResolver.Resolve(id, ctxt);
ctxt.CheckForSingleResult(_r, id);
return(_r != null && _r.Length != 0 &&
(EnforceTypeEqualityWhenDeducing ?
ResultComparer.IsEqual(r, _r[0]) :
ResultComparer.IsImplicitlyConvertible(r, _r[0])));
}
public static AbstractType[] Resolve(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
AbstractType[] res;
if (id.InnerDeclaration == null && resultBases == null)
{
res = ResolveIdentifier(id.IdHash, ctxt, id, id.ModuleScoped);
}
else
{
var rbases = resultBases ?? Resolve(id.InnerDeclaration, ctxt);
if (rbases == null || rbases.Length == 0)
{
return(null);
}
res = ResolveFurtherTypeIdentifier(id.IdHash, rbases, ctxt, id);
}
if (filterForTemplateArgs && (ctxt.Options & ResolutionOptions.NoTemplateParameterDeduction) == 0)
{
var l_ = new List <AbstractType>();
if (res != null)
{
foreach (var s in res)
{
l_.Add(s);
}
}
return(TemplateInstanceHandler.DeduceParamsAndFilterOverloads(l_, null, false, ctxt));
}
else
{
return(res);
}
}
/// <summary>
/// Returns all constructors from the given class or struct.
/// If no explicit constructor given, an artificial implicit constructor method stub will be created.
/// </summary>
public static IEnumerable <DMethod> GetConstructors(TemplateIntermediateType ct)
{
bool foundExplicitCtor = false;
// Simply get all constructors that have the ctor id assigned. Makin' it faster ;)
var ch = ct.Definition[DMethod.ConstructorIdentifier];
if (ch != null)
{
foreach (var m in ch)
{
// Not to forget: 'this' aliases are also possible - so keep checking for m being a genuine ctor
var dm = m as DMethod;
if (m != null && dm.SpecialType == DMethod.MethodType.Constructor)
{
yield return(dm);
foundExplicitCtor = true;
}
}
}
if (!foundExplicitCtor)
{
yield return new DMethod(DMethod.MethodType.Constructor)
{
Name = DMethod.ConstructorIdentifier, Parent = ct.Definition, Description = "Default constructor for " + ct.Name
}
}
;
}
ISemantic E(CastExpression ce)
{
AbstractType castedType = null;
if (ce.Type != null)
{
var castedTypes = TypeDeclarationResolver.Resolve(ce.Type, ctxt);
ctxt.CheckForSingleResult(castedTypes, ce.Type);
if (castedTypes != null && castedTypes.Length != 0)
{
castedType = castedTypes[0];
}
}
else
{
castedType = AbstractType.Get(E(ce.UnaryExpression));
if (castedType != null && ce.CastParamTokens != null && ce.CastParamTokens.Length > 0)
{
//TODO: Wrap resolved type with member function attributes
}
}
return(castedType);
}
ISemantic E(UnaryExpression_Cat x) // a = ~b;
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_Increment x)
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_Decrement x)
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_Add x)
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_Sub x)
{
var v = E(x.UnaryExpression);
if (eval)
{
if (v is AbstractType)
{
v = DResolver.StripMemberSymbols((AbstractType)v);
}
if (v is PrimitiveValue)
{
var pv = (PrimitiveValue)v;
return(new PrimitiveValue(pv.BaseTypeToken, -pv.Value, x, -pv.ImaginaryPart));
}
}
return(v);
}
ISemantic E(UnaryExpression_Not x)
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_Mul x)
{
return(E(x.UnaryExpression));
}
ISemantic E(UnaryExpression_And x)
{
var ptrBase = E(x.UnaryExpression);
if (eval)
{
// Create a new pointer
//
}
// &i -- makes an int* out of an int
return(new PointerType(AbstractType.Get(ptrBase), x));
}
ISemantic E(DeleteExpression x)
{
if (eval)
{
// Reset the content of the variable
}
return(null);
}
ISemantic E(UnaryExpression_Type x)
{
var uat = x as UnaryExpression_Type;
if (uat.Type == null)
{
return(null);
}
var types = TypeDeclarationResolver.Resolve(uat.Type, ctxt);
ctxt.CheckForSingleResult(types, uat.Type);
if (types != null && types.Length != 0)
{
var id = new IdentifierDeclaration(uat.AccessIdentifier)
{
EndLocation = uat.EndLocation
};
// First off, try to resolve static properties
var statProp = StaticPropertyResolver.TryResolveStaticProperties(types[0], uat.AccessIdentifier, ctxt, eval, id);
if (statProp != null)
{
return(statProp);
}
// If it's not the case, try the conservative way
var res = TypeDeclarationResolver.Resolve(id, ctxt, types);
ctxt.CheckForSingleResult(res, x);
if (res != null && res.Length != 0)
{
return(res[0]);
}
}
return(null);
}
}
public static AbstractType ResolveKey(ArrayDecl ad, out int fixedArrayLength, out ISymbolValue keyVal, ResolutionContext ctxt)
{
keyVal = null;
fixedArrayLength = -1;
AbstractType keyType = null;
if (ad.KeyExpression != null)
{
//TODO: Template instance expressions?
var id_x = ad.KeyExpression as IdentifierExpression;
if (id_x != null && id_x.IsIdentifier)
{
var id = new IdentifierDeclaration((string)id_x.Value)
{
Location = id_x.Location,
EndLocation = id_x.EndLocation
};
keyType = TypeDeclarationResolver.ResolveSingle(id, ctxt);
if (keyType != null)
{
var tt = DResolver.StripAliasSymbol(keyType) as MemberSymbol;
if (tt == null ||
!(tt.Definition is DVariable) ||
((DVariable)tt.Definition).Initializer == null)
{
return(keyType);
}
}
}
try
{
keyVal = Evaluation.EvaluateValue(ad.KeyExpression, ctxt);
if (keyVal != null)
{
// Take the value's type as array key type
keyType = keyVal.RepresentedType;
// It should be mostly a number only that points out how large the final array should be
var pv = Evaluation.GetVariableContents(keyVal, new StandardValueProvider(ctxt)) as PrimitiveValue;
if (pv != null)
{
fixedArrayLength = System.Convert.ToInt32(pv.Value);
if (fixedArrayLength < 0)
{
ctxt.LogError(ad, "Invalid array size: Length value must be greater than 0");
}
}
//TODO Is there any other type of value allowed?
}
}
catch { }
}
else
{
var t = Resolve(ad.KeyType, ctxt);
ctxt.CheckForSingleResult(t, ad.KeyType);
if (t != null && t.Length != 0)
{
return(t[0]);
}
}
return(keyType);
}
public ulong Visit(IdentifierDeclaration identifierDeclaration)
{
return(1001531);
}
static ResolveResult[] HandleIdDeclaration(IdentifierDeclaration typeId,
ResolverContext lastResCtxt,
IAbstractSyntaxTree SyntaxTree,
CodeScanResult csr,
Dictionary <string, ResolveResult> compDict)
{
var typeString = typeId.ToString();
bool WasAlreadyResolved = false;
ResolveResult[] allCurrentResults = null;
ResolveResult rr = null;
/*
* string,wstring,dstring are highlighted by the editor's syntax definition automatically..
* Anyway, allow to resolve e.g. "object.string"
*/
if (typeString == "" || typeString == "string" || typeString == "wstring" || typeString == "dstring")
{
return(null);
}
lastResCtxt.ScopedBlock = DResolver.SearchBlockAt(SyntaxTree, typeId.Location, out lastResCtxt.ScopedStatement);
if (typeString == "th" && typeId.Location.Line == 114)
{
}
if (!(WasAlreadyResolved = compDict.TryGetValue(typeString, out rr)))
{
allCurrentResults = DResolver.ResolveType(typeId, lastResCtxt);
if (allCurrentResults != null && allCurrentResults.Length > 0)
{
rr = allCurrentResults[0];
}
}
if (rr == null)
{
if (typeId is IdentifierDeclaration)
{
csr.UnresolvedIdentifiers.Add(typeId as IdentifierDeclaration);
}
}
else
{
/*
* Note: It is of course possible to highlight more than one type in one type declaration!
* So, we scan down the result hierarchy for TypeResults and highlight all of them later.
*/
var curRes = rr;
/*
* Note: Since we want to use results multiple times,
* we at least have to 'update' their type declarations
* to ensure that the second, third, fourth etc. occurence of this result
* are also highlit (and won't(!) cause an Already-Added-Exception of our finalDict-Array)
*/
var curTypeDeclBase = typeId as ITypeDeclaration;
while (curRes != null)
{
if (curRes is MemberResult)
{
var mr = curRes as MemberResult;
// If curRes is an alias or a template parameter, highlight it
if (mr.ResolvedMember is TemplateParameterNode ||
(mr.ResolvedMember is DVariable &&
(mr.ResolvedMember as DVariable).IsAlias))
{
try
{
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
}
catch { }
// See performance reasons
//if (curRes != rr && !WasAlreadyResolved && !) compDict.Add(curTypeDeclBase.ToString(), curRes);
}
}
else if (curRes is TypeResult)
{
// Yeah, in quite all cases we do identify a class via its name ;-)
if (curTypeDeclBase is IdentifierDeclaration &&
!(curTypeDeclBase is DTokenDeclaration) &&
!csr.ResolvedIdentifiers.ContainsKey(curTypeDeclBase as IdentifierDeclaration))
{
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
// See performance reasons
//if (curRes != rr && !WasAlreadyResolved) compDict.Add(curTypeDeclBase.ToString(), curRes);
}
}
else if (curRes is ModuleResult)
{
if (curTypeDeclBase is IdentifierDeclaration &&
!csr.ResolvedIdentifiers.ContainsKey(curTypeDeclBase as IdentifierDeclaration))
{
csr.ResolvedIdentifiers.Add(curTypeDeclBase as IdentifierDeclaration, curRes);
}
}
curRes = curRes.ResultBase;
curTypeDeclBase = curTypeDeclBase.InnerDeclaration;
}
}
return(allCurrentResults);
}
public static AbstractType[] Resolve(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
AbstractType[] res;
if (id.InnerDeclaration == null && resultBases == null)
res = ResolveIdentifier(id.IdHash, ctxt, id, id.ModuleScoped);
else
{
var rbases = resultBases ?? Resolve(id.InnerDeclaration, ctxt);
if (rbases == null || rbases.Length == 0)
return null;
res = ResolveFurtherTypeIdentifier(id.IdHash, rbases, ctxt, id);
}
if (filterForTemplateArgs && (ctxt.Options & ResolutionOptions.NoTemplateParameterDeduction) == 0)
{
var l_ = new List<AbstractType>();
if (res != null)
foreach (var s in res)
l_.Add(s);
return TemplateInstanceHandler.DeduceParamsAndFilterOverloads(l_, null, false, ctxt);
}
else
return res;
}
public virtual void Visit(IdentifierDeclaration td)
{
VisitInner(td);
}
/// <summary>
/// Tries to resolve a static property's name.
/// Returns a result describing the theoretical member (".init"-%gt;MemberResult; ".typeof"->TypeResult etc).
/// Returns null if nothing was found.
/// </summary>
/// <param name="InitialResult"></param>
/// <returns></returns>
public static MemberSymbol TryResolveStaticProperties(
ISemantic InitialResult,
string propertyIdentifier,
ResolverContextStack ctxt = null,
bool Evaluate = false,
IdentifierDeclaration idContainter = null)
{
// If a pointer'ed type is given, take its base type
if (InitialResult is PointerType)
{
InitialResult = ((PointerType)InitialResult).Base;
}
if (InitialResult == null || InitialResult is ModuleSymbol)
{
return(null);
}
INode relatedNode = null;
if (InitialResult is DSymbol)
{
relatedNode = ((DSymbol)InitialResult).Definition;
}
#region init
if (propertyIdentifier == "init")
{
var prop_Init = new DVariable
{
Name = "init",
Description = "Initializer"
};
if (relatedNode != null)
{
if (!(relatedNode is DVariable))
{
prop_Init.Parent = relatedNode.Parent;
prop_Init.Type = new IdentifierDeclaration(relatedNode.Name);
}
else
{
prop_Init.Parent = relatedNode;
prop_Init.Initializer = (relatedNode as DVariable).Initializer;
prop_Init.Type = relatedNode.Type;
}
}
return(new MemberSymbol(prop_Init, DResolver.StripAliasSymbol(AbstractType.Get(InitialResult)), idContainter));
}
#endregion
#region sizeof
if (propertyIdentifier == "sizeof")
{
return(new MemberSymbol(new DVariable
{
Name = "sizeof",
Type = new DTokenDeclaration(DTokens.Int),
Initializer = new IdentifierExpression(4),
Description = "Size in bytes (equivalent to C's sizeof(type))"
}, new PrimitiveType(DTokens.Int), idContainter));
}
#endregion
#region alignof
if (propertyIdentifier == "alignof")
{
return(new MemberSymbol(new DVariable
{
Name = "alignof",
Type = new DTokenDeclaration(DTokens.Int),
Description = "Alignment size"
}, new PrimitiveType(DTokens.Int), idContainter));
}
#endregion
#region mangleof
if (propertyIdentifier == "mangleof")
{
return(new MemberSymbol(new DVariable
{
Name = "mangleof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the ‘mangled’ representation of the type"
}, getStringType(ctxt), idContainter));
}
#endregion
#region stringof
if (propertyIdentifier == "stringof")
{
return(new MemberSymbol(new DVariable
{
Name = "stringof",
Type = new IdentifierDeclaration("string"),
Description = "String representing the source representation of the type"
}, getStringType(ctxt), idContainter));
}
#endregion
#region classinfo
else if (propertyIdentifier == "classinfo")
{
var tr = DResolver.StripMemberSymbols(AbstractType.Get(InitialResult)) as TemplateIntermediateType;
if (tr is ClassType || tr is InterfaceType)
{
var ci = new IdentifierDeclaration("TypeInfo_Class")
{
InnerDeclaration = new IdentifierDeclaration("object"),
ExpressesVariableAccess = true,
};
var ti = TypeDeclarationResolver.Resolve(ci, ctxt);
ctxt.CheckForSingleResult(ti, ci);
return(new MemberSymbol(new DVariable {
Name = "classinfo", Type = ci
}, ti != null && ti.Length != 0?ti[0]:null, idContainter));
}
}
#endregion
//TODO: Resolve the types of type-specific properties (floats, ints, arrays, assocarrays etc.)
return(null);
}
public static AbstractType ResolveKey(ArrayDecl ad, out int fixedArrayLength, out ISymbolValue keyVal, ResolutionContext ctxt)
{
keyVal = null;
fixedArrayLength = -1;
AbstractType keyType = null;
if (ad.KeyExpression != null)
{
//TODO: Template instance expressions?
var id_x = ad.KeyExpression as IdentifierExpression;
if (id_x != null && id_x.IsIdentifier)
{
var id = new IdentifierDeclaration((string)id_x.Value)
{
Location = id_x.Location,
EndLocation = id_x.EndLocation
};
keyType = TypeDeclarationResolver.ResolveSingle(id, ctxt);
if (keyType != null)
{
var tt = DResolver.StripAliasSymbol(keyType) as MemberSymbol;
if (tt == null ||
!(tt.Definition is DVariable) ||
((DVariable)tt.Definition).Initializer == null)
return keyType;
}
}
try
{
keyVal = Evaluation.EvaluateValue(ad.KeyExpression, ctxt);
if (keyVal != null)
{
// Take the value's type as array key type
keyType = keyVal.RepresentedType;
// It should be mostly a number only that points out how large the final array should be
var pv = Evaluation.GetVariableContents(keyVal, new StandardValueProvider(ctxt)) as PrimitiveValue;
if (pv != null)
{
fixedArrayLength = System.Convert.ToInt32(pv.Value);
if (fixedArrayLength < 0)
ctxt.LogError(ad, "Invalid array size: Length value must be greater than 0");
}
//TODO Is there any other type of value allowed?
}
}
catch { }
}
else
{
var t = Resolve(ad.KeyType, ctxt);
ctxt.CheckForSingleResult(t, ad.KeyType);
if (t != null && t.Length != 0)
return t[0];
}
return keyType;
}
/// <summary>
/// See <see cref="Resolve"/>
/// </summary>
public static AbstractType ResolveSingle(IdentifierDeclaration id, ResolutionContext ctxt, AbstractType[] resultBases = null, bool filterForTemplateArgs = true)
{
var r = Resolve(id, ctxt, resultBases, filterForTemplateArgs);
ctxt.CheckForSingleResult(r, id);
return r != null && r.Length != 0 ? r[0] : null;
}
public ITypeDeclaration IdentifierList()
{
ITypeDeclaration td = null;
bool notInit = false;
do
{
if (notInit)
Step();
else
notInit = true;
ITypeDeclaration ttd;
if (IsTemplateInstance)
ttd = TemplateInstance(null);
else if (Expect(Identifier))
ttd = new IdentifierDeclaration(t.Value) { Location = t.Location, EndLocation = t.EndLocation };
else if (IsEOF)
{
TrackerVariables.ExpectingIdentifier = true;
return td == null ? null : new DTokenDeclaration(DTokens.INVALID, td);
}
else
ttd = null;
if (ttd != null)
ttd.InnerDeclaration = td;
td = ttd;
}
while (laKind == Dot);
return td;
}
public static AbstractType Demangle(string mangledString, out ITypeDeclaration qualifier, out bool isCFunction)
{
if(string.IsNullOrEmpty(mangledString))
throw new ArgumentException("строка ввода должна не быть пустой или null!");
if (!mangledString.StartsWith("_D"))
{
isCFunction = true;
if (mangledString.StartsWith ("__D"))
mangledString = mangledString.Substring (1);
// C Functions
else if (mangledString.StartsWith ("_")) {
qualifier = new IdentifierDeclaration (mangledString.Substring (1));
return null;
}
}
//TODO: What about C functions that start with 'D'?
isCFunction = false;
var dmng = new Demangler(mangledString);
return dmng.MangledName(out qualifier);
}
public override void Visit (IdentifierDeclaration id)
{
var resolvedSymbol = TryPopPFAStack ();
if (id.IdHash == searchHash) {
if(resolvedSymbol == null)
resolvedSymbol = TypeDeclarationResolver.ResolveSingle (id, ctxt) as DSymbol;
if (resolvedSymbol != null && resolvedSymbol.Definition == symbol) {
l.Add (id);
return;
}
}
base.Visit (id);
}
public override void Visit (IdentifierDeclaration td)
{
if (DoPrimaryIdCheck(td.IdHash))
AddResult(td);
base.Visit (td);
}
ITypeDeclaration ModuleFullyQualifiedName()
{
if (!Expect(Identifier))
return null;
var td = new IdentifierDeclaration(t.Value) { Location=t.Location,EndLocation=t.EndLocation };
while (laKind == Dot)
{
Step();
Expect(Identifier);
td = new IdentifierDeclaration(t.Value) { Location=t.Location, EndLocation=t.EndLocation, InnerDeclaration = td };
}
return td;
}
public TemplateInstanceExpression TemplateInstance(IBlockNode Scope)
{
var loc = la.Location;
var mod = INVALID;
if (DTokens.StorageClass [laKind]) {
mod = laKind;
Step ();
}
if (!Expect (Identifier))
return null;
ITypeDeclaration td = new IdentifierDeclaration (t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
};
td = new TemplateInstanceExpression(mod != DTokens.INVALID ? new MemberFunctionAttributeDecl(mod) { InnerType = td } : td) {
Location = loc
};
LastParsedObject = td;
var args = new List<IExpression>();
if (!Expect(Not))
return td as TemplateInstanceExpression;
if (laKind == (OpenParenthesis))
{
Step();
if (laKind != CloseParenthesis)
{
bool init = true;
while (laKind == Comma || init)
{
if (!init) Step();
init = false;
if (laKind == CloseParenthesis)
break;
if (IsEOF)
{
args.Add(new TokenExpression(DTokens.INVALID) { Location= la.Location, EndLocation=la.EndLocation });
break;
}
Lexer.PushLookAheadBackup();
bool wp = AllowWeakTypeParsing;
AllowWeakTypeParsing = true;
var typeArg = Type();
AllowWeakTypeParsing = wp;
if (typeArg != null && (laKind == CloseParenthesis || laKind==Comma)){
Lexer.PopLookAheadBackup();
args.Add(new TypeDeclarationExpression(typeArg));
}else
{
Lexer.RestoreLookAheadBackup();
args.Add(AssignExpression(Scope));
}
}
}
Expect(CloseParenthesis);
}
else
{
Step();
/*
* TemplateSingleArgument:
* Identifier
* BasicTypeX
* CharacterLiteral
* StringLiteral
* IntegerLiteral
* FloatLiteral
* true
* false
* null
* __FILE__
* __LINE__
*/
IExpression arg= null;
if (t.Kind == Literal)
arg = new IdentifierExpression(t.LiteralFormat == LiteralFormat.StringLiteral ||
t.LiteralFormat == LiteralFormat.VerbatimStringLiteral ?
t.Value :
t.LiteralValue,
t.LiteralFormat,
t.Subformat)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (t.Kind == Identifier)
arg = new IdentifierExpression(t.Value)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (BasicTypes[t.Kind])
arg = new TypeDeclarationExpression(new DTokenDeclaration(t.Kind)
{
Location = t.Location,
EndLocation = t.EndLocation
});
else if (
t.Kind == True ||
t.Kind == False ||
t.Kind == Null ||
t.Kind == __FILE__ ||
t.Kind == __LINE__)
arg = new TokenExpression(t.Kind)
{
Location = t.Location,
EndLocation = t.EndLocation
};
else if (IsEOF)
{
TrackerVariables.ExpectingIdentifier = false;
td.EndLocation = CodeLocation.Empty;
return td as TemplateInstanceExpression;
}
args.Add(arg);
}
(td as TemplateInstanceExpression).Arguments = args.ToArray();
td.EndLocation = t.EndLocation;
return td as TemplateInstanceExpression;
}
ImportStatement.ImportBindings ImportBindings(ImportStatement.Import imp)
{
var importBindings = new ImportStatement.ImportBindings { Module=imp };
LastParsedObject = importBindings;
bool init = true;
while (laKind == Comma || init)
{
if (init)
init = false;
else
Step();
if (Expect(Identifier))
{
var symbolAlias = new IdentifierDeclaration(t.Value){ Location = t.Location, EndLocation = t.EndLocation };
if (laKind == Assign)
{
Step();
if (Expect (Identifier))
importBindings.SelectedSymbols.Add (new ImportStatement.ImportBinding (new IdentifierDeclaration (t.Value) {
Location = t.Location,
EndLocation = t.EndLocation
}, symbolAlias));
}
else
importBindings.SelectedSymbols.Add(new ImportStatement.ImportBinding(symbolAlias));
}
}
if (!IsEOF)
LastParsedObject = null;
return importBindings;
}
ITypeDeclaration QualifiedName()
{
ITypeDeclaration td = null;
int n;
while(PeekIsDecNumber)
{
// Read number of either the first LName or TemplateInstanceName
n = (int)Number();
sb.Clear();
if((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if((char)r.Peek() == '_')
{
r.Read();
sb.Append('_');
if((char)r.Peek() == 'T')
{
r.Read();
// We've got to handle a Template instance:
// Number __T LName TemplateArgs Z
var tpi = new TemplateInstanceExpression(new IdentifierDeclaration(LName()));
tpi.InnerDeclaration = td;
td = tpi;
var xx = new List<IExpression>();
while(r.Peek() != -1)
{
var arg = TemplateArg();
if(arg == null)
break;
xx.Add(arg);
}
tpi.Arguments = xx.ToArray();
continue;
}
}
}
// Just an LName
if(n > sb.Length)
sb.Append(LName(n-sb.Length));
var ttd = new IdentifierDeclaration(sb.ToString());
ttd.InnerDeclaration = td;
td = ttd;
}
return td;
}
