public QualifierTokenCodeElement(TypeCobol.Compiler.Scanner.Token token) : base((CodeElementType)0) { base.ConsumedTokens = new List <TypeCobol.Compiler.Scanner.Token>(); base.ConsumedTokens.Add(token); }
/// <summary> /// Token constructor /// </summary> /// <param name="token">The consumed token corresponding to this Picture</param> /// <param name="separateSign">a boolean value indicating whether the sign is separate character</param> public PictureType(TypeCobol.Compiler.Scanner.Token token, bool separateSign) : this() { ConsumedToken = token; IsSeparateSign = separateSign; }
/// <summary> /// Perform the qualification action /// </summary> /// <param name="sourceNode">The source Node on which to perform teh action</param> /// <param name="visitor">The Visitor which as locate teh Source Node</param> internal void Perform(Node sourceNode) { if (sourceNode.IsFlagSet(Node.Flag.HasBeenTypeCobolQualifierVisited)) { return; } //Now this Node Is Visited sourceNode.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); Tuple <int, int, int, List <int>, List <int> > sourcePositions = this.Generator.FromToPositions(sourceNode); IList <TypeCobol.Compiler.Scanner.Token> nodeTokens = sourceNode.CodeElement.ConsumedTokens; List <Tuple <int, int> > boundaries = ItemsListIndexBoundary(nodeTokens); int b = 0; bool bWasProcCall = false; foreach (var items in AllItemsList) { string hashFunction; bool bProcCall = IsProcedureStyleCallItems(items, out hashFunction); Tuple <int, int> range = boundaries[b++]; Items = items; int i = range.Item1; if (bProcCall) { //---------------------------------------------------------------------------------------------- // This is for a procedure call. // The Code below is commented. This code was used to test that in normal situation // The TypeCobolQualifierReference for the function name can be replaced by a the hash code name. //---------------------------------------------------------------------------------------------- //SymbolReference sr1 = Items[Items.Count - 1]; //SymbolReference sr2 = Items[0]; //List<TypeCobol.Compiler.Scanner.Token> consumedTokens = new List<TypeCobol.Compiler.Scanner.Token>(); //for (; i <= range.Item2; i++) //{ // if (nodeTokens[i] == sr1.NameLiteral.Token) // { // consumedTokens.Add(nodeTokens[i]); // } // else if (nodeTokens[i] == sr2.NameLiteral.Token) // { // consumedTokens.Add(nodeTokens[i]); // break; // } //} //GenerateQualifierToken item = new GenerateQualifierToken(new QualifierTokenCodeElement(consumedTokens), "'" + hashFunction + "'", // sourcePositions); //item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); //sourceNode.Add(item); //------------------------------------------------------------------------------------------------------------------------ bWasProcCall = true; //Remember that we have a Procedure Style Call Node. continue; //Continue } for (int j = 0; j < Items.Count; j++) { SymbolReference sr = Items[Items.Count - j - 1]; for (; i <= range.Item2; i++) { if (nodeTokens[i] == sr.NameLiteral.Token) { TypeCobol.Compiler.Scanner.Token tokenColonColon = null; //Look for the corresponding :: for (++i; i <= range.Item2; i++) { if (!(nodeTokens[i] is TypeCobol.Compiler.Preprocessor.ImportedToken)) { if (nodeTokens[i].TokenType == TypeCobol.Compiler.Scanner.TokenType.QualifiedNameSeparator) { tokenColonColon = nodeTokens[i]; i++; break; } } } //We got It ==> Create our Generate Nodes GenerateQualifierToken item = new GenerateQualifierToken( new QualifierTokenCodeElement(sr.NameLiteral.Token), Items[j].ToString(), sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); if (tokenColonColon != null) { item = new GenerateQualifierToken(new QualifierTokenCodeElement(tokenColonColon), string.Intern(" OF "), sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); } break;//We got it } } } } //Now Comment the Source Node, only and only if it was not a Procedure Style Call, //Because the Qualifier action is the first action performed, before any Expand action. //Expand Action does not expand Commented Nodes, it will comment theses nodes itself. if (!bWasProcCall) { sourceNode.Comment = true; } }
/// <summary> /// Perform the qualification action /// </summary> /// <param name="sourceNode">The source Node on which to perform teh action</param> /// <param name="visitor">The Visitor which as locate teh Source Node</param> internal void Perform(Node sourceNode) { if (sourceNode.IsFlagSet(Node.Flag.HasBeenTypeCobolQualifierVisited)) { return; } TypeCobol.Compiler.Nodes.DataDescription dataDescription = null; if (sourceNode is TypeCobol.Compiler.Nodes.DataDescription && IsTypeDefinition(sourceNode as TypeCobol.Compiler.Nodes.DataDescription)) { dataDescription = sourceNode as TypeCobol.Compiler.Nodes.DataDescription; if (dataDescription.QualifiedTokenSubsitutionMap == null) { dataDescription.QualifiedTokenSubsitutionMap = new Dictionary <Compiler.Scanner.Token, string>(); } } //Now this Node Is Visited sourceNode.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); Tuple <int, int, int, List <int>, List <int> > sourcePositions = this.Generator.FromToPositions(sourceNode); IList <TypeCobol.Compiler.Scanner.Token> nodeTokens = sourceNode.CodeElement.ConsumedTokens; List <Tuple <int, int> > boundaries = ItemsListIndexBoundary(nodeTokens); int b = 0; bool bWasProcCall = false; foreach (var items in AllItemsList) { string hashFunction; bool bProcCall = IsProcedureStyleCallItems(items, out hashFunction); Tuple <int, int> range = boundaries[b++]; Items = items; int i = range.Item1; if (bProcCall) { //---------------------------------------------------------------------------------------------- // This is for a procedure call. // The Code below is commented. This code was used to test that in normal situation // The TypeCobolQualifierReference for the function name can be replaced by a the hash code name. //---------------------------------------------------------------------------------------------- //SymbolReference sr1 = Items[Items.Count - 1]; //SymbolReference sr2 = Items[0]; //List<TypeCobol.Compiler.Scanner.Token> consumedTokens = new List<TypeCobol.Compiler.Scanner.Token>(); //for (; i <= range.Item2; i++) //{ // if (nodeTokens[i] == sr1.NameLiteral.Token) // { // consumedTokens.Add(nodeTokens[i]); // } // else if (nodeTokens[i] == sr2.NameLiteral.Token) // { // consumedTokens.Add(nodeTokens[i]); // break; // } //} //GenerateQualifierToken item = new GenerateQualifierToken(new QualifierTokenCodeElement(consumedTokens), "'" + hashFunction + "'", // sourcePositions); //item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); //sourceNode.Add(item); //------------------------------------------------------------------------------------------------------------------------ bWasProcCall = true; //Remember that we have a Procedure Style Call Node. continue; //Continue } if (sourceNode.IsFlagSet(Node.Flag.NodeContainsIndex)) { //So we must know if this qualified name is for an Index Name string qualified_name; bool bAreIn = AreItemsInNodeQualifiedStorageAreas(items, sourceNode, out qualified_name); if (bAreIn) { GenerateToken item = null; string hashName = GeneratorHelper.ComputeIndexHashName(qualified_name, sourceNode); //Now all items in the qualified name must be replaced with the hash name by the Generator. //So all items except the last one are replaced by a blank, the last item will be the HashName for (int r = i; r <= range.Item2 - 1; r++) { item = new GenerateToken( new TokenCodeElement(nodeTokens[r]), "", sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); } item = new GenerateToken( new TokenCodeElement(nodeTokens[range.Item2]), hashName, sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); continue; } } for (int j = 0; j < Items.Count; j++) { SymbolReference sr = Items[Items.Count - j - 1]; for (; i <= range.Item2; i++) { if (nodeTokens[i] == sr.NameLiteral.Token) { TypeCobol.Compiler.Scanner.Token tokenColonColon = null; //Look for the corresponding :: for (++i; i <= range.Item2; i++) { if (!(nodeTokens[i] is TypeCobol.Compiler.Preprocessor.ImportedToken)) { if (nodeTokens[i].TokenType == TypeCobol.Compiler.Scanner.TokenType.QualifiedNameSeparator) { tokenColonColon = nodeTokens[i]; i++; break; } } } //We got It ==> Create our Generate Nodes if (dataDescription != null) { dataDescription.QualifiedTokenSubsitutionMap[sr.NameLiteral.Token] = Items[j].ToString(); if (tokenColonColon != null) { dataDescription.QualifiedTokenSubsitutionMap[tokenColonColon] = "OF"; } } else { GenerateToken item = null; string replace_value = Items[j].ToString(); if (this.CurrentNode.IsFlagSet(Node.Flag.NodeContainsBoolean)) { if (this.CurrentNode.QualifiedStorageAreas.Keys.Any(flaggedStorageArea => flaggedStorageArea?.SymbolReference?.NameLiteral.Value == replace_value)) { replace_value = replace_value + "-value"; } } item = new GenerateToken(new TokenCodeElement(sr.NameLiteral.Token), replace_value, sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); if (tokenColonColon != null) { item = new GenerateToken(new TokenCodeElement(tokenColonColon), string.Intern(" OF "), sourcePositions); item.SetFlag(Node.Flag.HasBeenTypeCobolQualifierVisited, true); sourceNode.Add(item); } } break;//We got it } } } } //Now Comment the Source Node, only and only if it was not a Procedure Style Call, //Because the Qualifier action is the first action performed, before any Expand action. //Expand Action does not expand Commented Nodes, it will comment theses nodes itself. if (!bWasProcCall) { sourceNode.Comment = true; } }