public static QualifiedSymbolReference ToQualifiedSymbolReference(this QualifiedTypeContext context)
{
var qualifiedSymbolReference = new QualifiedSymbolReference();
foreach (var type in context.type())
{
qualifiedSymbolReference.SymbolReferences.Add(type.ToSymbolReference());
}
return(qualifiedSymbolReference);
}
/// <summary>
/// Pre Generation calculation for collection variable path access and index variable map.
/// </summary>
/// <param name="table">The Current Symbol Table</param>
/// <param name="rootProcedures">Root procedures</param>
/// <param name="rootVariableName">All current root variable</param>
/// <param name="ownerDefinition">The Owner of the current definition</param>
/// <param name="data_def">The current definition</param>
/// <param name="bHasDependingOn">[out] true if the current variable hace depending on variables, false otherwise</param>
/// <param name="bHasIndexes">[out] true if the current variable definition have indexed variables, fals eotherwise.</param>
/// <param name="dependingOnAccessPath">[out] depending on variables access path list</param>
/// <param name="indexesMap">[out] Indexed variable map to tokens</param>
internal static void PreGenDependingOnAndIndexed(Node rootNode, SymbolTable table, List <string> rootProcedures, List <Tuple <string, string> > rootVariableName, TypeCobol.Compiler.Nodes.DataDefinition ownerDefinition, DataDefinitionEntry data_def,
out bool bHasDependingOn,
out bool bHasIndexes,
out List <string> dependingOnAccessPath,
out Dictionary <Compiler.Scanner.Token, string> indexesMap
)
{
var data = data_def as DataDescriptionEntry;
bHasDependingOn = false;
bHasIndexes = false;
dependingOnAccessPath = null;
indexesMap = null;
if (data?.OccursDependingOn != null)
{
if (!data.OccursDependingOn.MainSymbolReference.IsQualifiedReference)
{
dependingOnAccessPath = new List <string>();
if (LookupAccessPathForName(table, ownerDefinition, data.OccursDependingOn.MainSymbolReference.Name.ToLower(), dependingOnAccessPath))
{ //Remove the Type name
dependingOnAccessPath.RemoveAt(0);
dependingOnAccessPath.Reverse();
dependingOnAccessPath.AddRange(rootVariableName.ConvertAll <string>(vt => vt.Item1));
bHasDependingOn = true;
}
}
else
{
dependingOnAccessPath = new List <string>();
QualifiedSymbolReference qualSymRef = (QualifiedSymbolReference)data.OccursDependingOn.MainSymbolReference;
string tailName = qualSymRef.Tail.Name;
if (LookupAccessPathForName(table, ownerDefinition, tailName.ToLower(), dependingOnAccessPath))
{
//Remove the type name
dependingOnAccessPath.RemoveAt(0);
//Remove the variable
dependingOnAccessPath.RemoveAt(dependingOnAccessPath.Count - 1);
if (dependingOnAccessPath.Count > 0)
{
dependingOnAccessPath.Reverse();
dependingOnAccessPath.AddRange(rootVariableName.ConvertAll <string>(vt => vt.Item1));
bHasDependingOn = true;
}
}
}
}
if (data?.Indexes != null)
{
bHasIndexes = true;
//So Children of the owner definition contains all indexes
indexesMap = BuiltIndexMap(rootNode, rootProcedures, rootVariableName, data.Indexes, ownerDefinition);
}
}
public NamespaceImport(DefinitionSource definitionSource, QualifiedSymbolReference symbolReference) : base(definitionSource) => SymbolReference = symbolReference;
/// <summary>
/// Post generation calculation of data definition having depending on or indexed variables.
/// </summary>
/// <param name="ownerDefinition">The Owner of the current definition</param>
/// <param name="data_def">The current definition</param>
/// <param name="bHasDependingOn">true if the current variable hace depending on variables, false otherwise</param>
/// <param name="bHasIndexes">true if the current variable definition have indexed variables, fals eotherwise.</param>
/// <param name="dependingOnAccessPath">Depending on variables access path list</param>
/// <param name="indexesMap">Indexed variable map to tokens</param>
internal static void PostGenDependingOnAndIndexed(TypeCobol.Compiler.Nodes.DataDefinition ownerDefinition, DataDefinitionEntry data_def, bool bHasDependingOn, bool bHasIndexes,
List<string> dependingOnAccessPath,
Dictionary<Compiler.Scanner.Token, string> indexesMap,
out Func<Compiler.Scanner.Token, string> depenOnTokenFilter,
out Func<Compiler.Scanner.Token, string> indexedByTokenFilter
)
{
var data = data_def as DataDescriptionEntry;
depenOnTokenFilter = null;
indexedByTokenFilter = null;
if (bHasIndexes)
{
indexedByTokenFilter = (token) =>
{
return indexesMap.ContainsKey(token) ? indexesMap[token] : token.Text;
};
}
if (bHasDependingOn)
{
if (data != null && !data.OccursDependingOn.MainSymbolReference.IsQualifiedReference)
depenOnTokenFilter = (token) =>
{
if (bHasIndexes)
{
if (indexesMap.ContainsKey(token))
return indexesMap[token];
}
if (token == data.OccursDependingOn.MainSymbolReference.NameLiteral.Token)
{ return string.Join(" OF ", dependingOnAccessPath.ToArray()); }
else
{ return token.Text; }
};
else
{ //We have an incomplete qualification to the root variable
depenOnTokenFilter = (token) =>
{
if (bHasIndexes)
{
if (indexesMap.ContainsKey(token))
return indexesMap[token];
}
QualifiedSymbolReference qualSymRef = (QualifiedSymbolReference)data?.OccursDependingOn.MainSymbolReference;
if (qualSymRef != null && qualSymRef.IsTypeCobolQualifiedReference)
{
DataDescription dataDescription = ownerDefinition as DataDescription;
if (dataDescription?.QualifiedTokenSubsitutionMap != null && dataDescription.QualifiedTokenSubsitutionMap.ContainsKey(token))
{
if (token == qualSymRef.Head.NameLiteral.Token)
return dataDescription.QualifiedTokenSubsitutionMap[token] + " OF " + string.Join(" OF ", dependingOnAccessPath.ToArray());
else
return dataDescription.QualifiedTokenSubsitutionMap[token];
}
else
{ return token.Text; }
}
else
{ //Pure Cobol85 Qualification add left qualification to the root
if (qualSymRef != null && token == qualSymRef.Tail.NameLiteral.Token)
{
return token.Text + " OF " + string.Join(" OF ", dependingOnAccessPath.ToArray());
}
else
{
return token.Text;
}
}
};
}
}
}
