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; } } }; } } }