internal IEnumerable <MemberResult> GetMembersInternal(GetMultipleMembersInput input)
{
List <MemberResult> results = new List <MemberResult>();
if (input.GetArrayTypeMembers)
{
if (Children.Count == 1)
{
var node = Children[Children.Keys[0]];
if (node is TypeReference)
{
var newInput = new GetMultipleMembersInput
{
AST = input.AST,
MemberType = input.MemberType
// We don't want to continue getting array type members further down
};
results.AddRange((node as TypeReference).GetMembers(newInput));
}
}
}
else
{
results.AddRange(Genero4glAst.DictionaryFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion)
.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, input.AST)));
}
return(results);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
if (_childRegisters != null)
{
return(_childRegisters.Values.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Variable, input.AST)));
}
return(null);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
List <MemberResult> dot = new List <MemberResult> {
new MemberResult("*", GeneroMemberType.DbColumn, input.AST)
};
return(dot.Union(_columns.Values.Select(x => new MemberResult(x.Name, x, GeneroMemberType.DbColumn, input.AST))));
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
if (_returns != null && _returns.Count == 1)
{
var typeRef = new TypeReference(_returns[0]);
return(typeRef.GetMembers(input));
}
return(new MemberResult[0]);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
if (Children.Count == 1 &&
Children[Children.Keys[0]] is TypeReference)
{
return((Children[Children.Keys[0]] as TypeReference).GetMembers(input));
}
return(null);
}
internal IEnumerable <MemberResult> GetArrayMembers(GetMultipleMembersInput input)
{
List <MemberResult> members = new List <MemberResult>();
if (Children.Count == 1)
{
// we have an array type or a record type definition
var node = Children[Children.Keys[0]];
if (node is ArrayTypeReference)
{
return((node as ArrayTypeReference).GetMembersInternal(input));
}
}
return(members);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
if (MemberDictionary.Count == 0 && MimicTableName != null)
{
// get the table's columns
if (input.AST._databaseProvider != null)
{
return(input.AST._databaseProvider.GetColumns(MimicTableName.Name).Select(x => new MemberResult(x.Name, x, GeneroMemberType.DbColumn, input.AST)));
}
}
else
{
List <MemberResult> dot = new List <MemberResult> {
new MemberResult("*", GeneroMemberType.Variable, input.AST)
};
return(dot.Union(MemberDictionary.Values.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Variable, input.AST))));
}
return(new MemberResult[0]);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(Type.GetMembers(input));
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(new List <MemberResult>());
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(_functions.Values.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, input.AST)));
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(null);
}
private bool TryMemberAccess(int index, IReverseTokenizer revTokenizer, out List <MemberResult> results)
{
results = new List <MemberResult>();
bool skipGettingNext = false;
var enumerator = revTokenizer.GetReversedTokens().Where(x => x.SourceSpan.Start.Index < index).GetEnumerator();
while (true)
{
if (!skipGettingNext)
{
if (!enumerator.MoveNext())
{
results.Clear();
return(false);
}
}
else
{
skipGettingNext = false;
}
var tokInfo = enumerator.Current;
if (tokInfo.Equals(default(TokenInfo)) || tokInfo.Token.Kind == TokenKind.NewLine || tokInfo.Token.Kind == TokenKind.NLToken || tokInfo.Token.Kind == TokenKind.Comment)
{
continue; // linebreak
}
if (tokInfo.Token.Kind == TokenKind.Dot || tokInfo.Token.VerbatimImage.EndsWith("."))
{
if (tokInfo.Category == TokenCategory.NumericLiteral)
{
return(true);
}
// now we need to analyze the variable reference to get its members
int startIndex, endIndex;
bool isFunctionCallOrDefinition;
string var = revTokenizer.GetExpressionText(out startIndex, out endIndex, out isFunctionCallOrDefinition);
if (var != null)
{
int dotDiff = endIndex - tokInfo.SourceSpan.End.Index;
var = var.Substring(0, (var.Length - dotDiff));
if (var.EndsWith("."))
{
var = var.Substring(0, var.Length - 1);
IGeneroProject dummyProj;
IProjectEntry projEntry;
bool dummyDef;
var analysisRes = GetValueByIndex(var, index, _functionProvider, _databaseProvider, _programFileProvider, false, out dummyDef, out dummyProj, out projEntry);
if (analysisRes != null)
{
// Get suggested member type based on what comes before the member we're doing access on
MemberType memberType = GetSuggestedMemberType(startIndex - 1, revTokenizer);
var gmi = new GetMultipleMembersInput
{
AST = this,
MemberType = memberType,
GetArrayTypeMembers = var[var.Length - 1].Equals(']'),
IsMemberAccess = true
};
IEnumerable <MemberResult> memberList = analysisRes.GetMembers(gmi);
if (memberList != null)
{
results.AddRange(memberList);
}
}
return(true);
}
}
}
return(false);
}
return(false);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(this.Children.Values.Cast <CreatedTableColumn>().Select(x => new MemberResult(x.ColumnName.Name, x, GeneroMemberType.DbColumn, SyntaxTree)));
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
bool dummyDef;
List <MemberResult> members = new List <MemberResult>();
if (Children.Count == 1)
{
// we have an array type or a record type definition
var node = Children[Children.Keys[0]];
if (node is ArrayTypeReference)
{
return((node as ArrayTypeReference).GetMembersInternal(input));
}
else if (node is RecordDefinitionNode)
{
return((node as RecordDefinitionNode).GetMembers(input));
}
else if (node is DictionaryDefinitionNode)
{
return((node as DictionaryDefinitionNode).GetMembersInternal(input));
}
}
else if (!string.IsNullOrEmpty(_typeNameString))
{
if (!string.IsNullOrWhiteSpace(TableName))
{
// TODO: return the table's columns
}
else if (_typeNameString.Equals("string", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.StringFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion)
.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, input.AST)));
}
else if (_typeNameString.Equals("text", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.TextFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion)
.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, input.AST)));
}
else if (_typeNameString.Equals("byte", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.ByteFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion)
.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Method, input.AST)));
}
else
{
if (ResolvedType != null)
{
return(ResolvedType.GetMembers(input));
}
// try to determine if the _typeNameString is a user defined type (or package class), in which case we need to call its GetMembers function
IAnalysisResult udt = (input.AST as Genero4glAst).TryGetUserDefinedType(_typeNameString, LocationIndex);
if (udt != null)
{
return(udt.GetMembers(input));
}
foreach (var includedFile in input.AST.ProjectEntry.GetIncludedFiles())
{
if (includedFile.Analysis != null)
{
IGeneroProject dummyProj;
IProjectEntry dummyProjEntry;
var res = includedFile.Analysis.GetValueByIndex(_typeNameString, 1, null, null, null, false, out dummyDef, out dummyProj, out dummyProjEntry);
if (res != null)
{
return(res.GetMembers(input));
}
}
}
if (input.AST.ProjectEntry.ParentProject.ReferencedProjects.Count > 0)
{
foreach (var refProj in input.AST.ProjectEntry.ParentProject.ReferencedProjects.Values)
{
if (refProj is GeneroProject)
{
IProjectEntry dummyProj;
udt = (refProj as GeneroProject).GetMemberOfType(_typeNameString, input.AST, false, true, false, false, out dummyProj);
if (udt != null)
{
return(udt.GetMembers(input));
}
}
}
}
// check for package class
IGeneroProject dummyProject;
IProjectEntry projEntry;
udt = input.AST.GetValueByIndex(_typeNameString, LocationIndex, input.AST._functionProvider, input.AST._databaseProvider, input.AST._programFileProvider, false, out dummyDef, out dummyProject, out projEntry);
if (udt != null)
{
return(udt.GetMembers(input));
}
}
}
return(members);
}
internal IEnumerable <IAnalysisResult> GetAnalysisMembers(MemberType memberType, GetMemberInput input)
{
bool dummyDef;
List <IAnalysisResult> members = new List <IAnalysisResult>();
if (Children.Count == 1)
{
// we have an array type or a record type definition
var node = Children[Children.Keys[0]];
if (node is ArrayTypeReference)
{
return((node as ArrayTypeReference).GetAnalysisResults(memberType, input));
}
else if (node is RecordDefinitionNode)
{
return((node as RecordDefinitionNode).GetAnalysisResults(input.AST));
}
else if (node is DictionaryDefinitionNode)
{
return((node as DictionaryDefinitionNode).GetAnalysisResults(memberType, input));
}
}
else
{
if (!string.IsNullOrWhiteSpace(TableName))
{
// TODO: return the table's columns
int i = 0;
}
else if (_typeNameString != null && _typeNameString.Equals("string", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.StringFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion));
}
else if (_typeNameString != null && _typeNameString.Equals("text", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.TextFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion));
}
else if (_typeNameString != null && _typeNameString.Equals("byte", StringComparison.OrdinalIgnoreCase))
{
return(Genero4glAst.ByteFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion));
}
else
{
if (ResolvedType != null &&
ResolvedType is TypeDefinitionNode &&
(ResolvedType as TypeDefinitionNode).TypeRef != null)
{
return((ResolvedType as TypeDefinitionNode).TypeRef.GetAnalysisMembers(memberType, input));
}
var gmi = new GetMultipleMembersInput
{
AST = input.AST,
MemberType = memberType,
GetArrayTypeMembers = input.IsFunction
};
// try to determine if the _typeNameString is a user defined type, in which case we need to call its GetMembers function
IAnalysisResult udt = (input.AST as Genero4glAst).TryGetUserDefinedType(_typeNameString, LocationIndex);
if (udt != null)
{
return(udt.GetMembers(gmi).Select(x => x.Var).Where(y => y != null));
}
IGeneroProject definingProject;
IProjectEntry projectEntry;
if (input.AST.ProjectEntry != null)
{
foreach (var includedFile in input.AST.ProjectEntry.GetIncludedFiles())
{
if (includedFile.Analysis != null)
{
var res = includedFile.Analysis.GetValueByIndex(_typeNameString, 1, null, null, null, false, out dummyDef, out definingProject, out projectEntry);
if (res != null)
{
input.DefiningProject = definingProject;
input.ProjectEntry = projectEntry;
return(res.GetMembers(gmi).Select(x => x.Var).Where(y => y != null));
}
}
}
// try to get the _typeNameString from types available in imported modules
if (input.AST.ProjectEntry.ParentProject.ReferencedProjects.Count > 0)
{
foreach (var refProj in input.AST.ProjectEntry.ParentProject.ReferencedProjects.Values)
{
if (refProj is GeneroProject)
{
IProjectEntry dummyProj;
udt = (refProj as GeneroProject).GetMemberOfType(_typeNameString, input.AST, false, true, false, false, out dummyProj);
if (udt != null)
{
input.DefiningProject = refProj;
input.ProjectEntry = dummyProj;
return(udt.GetMembers(gmi).Select(x => x.Var).Where(y => y != null));
}
}
}
}
}
// check for package class
udt = input.AST.GetValueByIndex(_typeNameString, LocationIndex, input.AST._functionProvider, input.AST._databaseProvider, input.AST._programFileProvider, false, out dummyDef, out definingProject, out projectEntry);
if (udt != null)
{
input.DefiningProject = definingProject;
input.ProjectEntry = projectEntry;
return(udt.GetMembers(gmi).Select(x => x.Var).Where(y => y != null));
}
}
}
return(members);
}
public IEnumerable <MemberResult> GetMembers(GetMultipleMembersInput input)
{
return(_memberFunctions.Values.Where(x => input.AST.LanguageVersion >= x.MinimumLanguageVersion && input.AST.LanguageVersion <= x.MaximumLanguageVersion)
.Select(x => new MemberResult(x.Name, x, GeneroMemberType.Function, input.AST)));
}
