public virtual void StartSkipCompilerStatement(CompilerDirectiveType type)
{
System.Diagnostics.Debug.Assert(type == CompilerDirectiveType.SKIP1 ||
type == CompilerDirectiveType.SKIP2 ||
type == CompilerDirectiveType.SKIP3);
CompilerDirective = new SkipDirective(type);
}
/// <summary>
/// Group all the tokens contributing to a compiler directive on the same line
/// </summary>
public CompilerDirectiveToken(CompilerDirective compilerDirective, IList <Token> originalTokens, bool hasError)
: base((compilerDirective.Type == CompilerDirectiveType.COPY || compilerDirective.Type == CompilerDirectiveType.EXEC_SQL_INCLUDE) ? TokenType.CopyImportDirective :
(compilerDirective.Type == CompilerDirectiveType.REPLACE || compilerDirective.Type == CompilerDirectiveType.REPLACE_OFF) ? TokenType.ReplaceDirective :
TokenType.CompilerDirective, originalTokens)
{
CompilerDirective = compilerDirective;
HasError = hasError;
}
public override void EnterTitleCompilerStatement(CobolCompilerDirectivesParser.TitleCompilerStatementContext context)
{
TitleDirective titleDirective = new TitleDirective();
CompilerDirective = titleDirective;
string title = ParseTreeUtils.GetAlphanumericLiteral(context.alphanumericValue2());
titleDirective.Title = title;
}
public override void EnterServiceReloadCompilerStatement(CobolCompilerDirectivesParser.ServiceReloadCompilerStatementContext context)
{
ServiceReloadDirective serviceReloadDirective = new ServiceReloadDirective();
CompilerDirective = serviceReloadDirective;
string userDefinedWord = null;
TryGetUserDefinedWord(context.UserDefinedWord(), ref userDefinedWord);
serviceReloadDirective.UserDefinedWord = userDefinedWord;
}
public override void EnterBasisCompilerStatement(CobolCompilerDirectivesParser.BasisCompilerStatementContext context)
{
var basisDirective = new BasisDirective();
CompilerDirective = basisDirective;
if (context.textName() != null)
{
basisDirective.BasisName = GetTextName(context.textName());
basisDirective.TextNameSymbol = ParseTreeUtils.GetFirstToken(context.textName());
}
}
public override void EnterSkipCompilerStatement(CobolCompilerDirectivesParser.SkipCompilerStatementContext context)
{
if (context.SKIP1() != null)
{
CompilerDirective = new SkipDirective(CompilerDirectiveType.SKIP1);
}
else if (context.SKIP2() != null)
{
CompilerDirective = new SkipDirective(CompilerDirectiveType.SKIP2);
}
else if (context.SKIP3() != null)
{
CompilerDirective = new SkipDirective(CompilerDirectiveType.SKIP3);
}
}
public override void EnterEnterCompilerStatement(CobolCompilerDirectivesParser.EnterCompilerStatementContext context)
{
EnterDirective enterDirective = new EnterDirective();
CompilerDirective = enterDirective;
if (context.languageName() != null)
{
string languageName = null;
TryGetUserDefinedWord(context.languageName().UserDefinedWord(), ref languageName);
enterDirective.LanguageName = languageName;
}
if (context.routineName() != null)
{
string routineName = null;
TryGetUserDefinedWord(context.routineName().UserDefinedWord(), ref routineName);
enterDirective.RoutineName = routineName;
}
}
public override void EnterInsertCompilerStatement(CobolCompilerDirectivesParser.InsertCompilerStatementContext context)
{
InsertDirective insertDirective = new InsertDirective();
CompilerDirective = insertDirective;
if (context.sequenceNumber() != null && context.sequenceNumber().IntegerLiteral() != null)
{
insertDirective.SequenceNumber = (int)ParseTreeUtils.GetIntegerLiteral(context.sequenceNumber().IntegerLiteral());
if (insertDirective.SequenceNumber < 0)
{
Token errorToken = ParseTreeUtils.GetTokenFromTerminalNode(context.sequenceNumber().IntegerLiteral());
Diagnostic error = new Diagnostic(
MessageCode.InvalidNumericLiteralFormat,
errorToken.Column, errorToken.EndColumn,
errorToken.Line, "TODO");
CompilerDirective.AddDiagnostic(error);//TODO proper diagnostic error
}
}
}
public override void EnterExecSqlIncludeStatement(CobolCompilerDirectivesParser.ExecSqlIncludeStatementContext context)
{
var copyDirective = new CopyDirective(CompilerDirectiveType.EXEC_SQL_INCLUDE, ParseTreeUtils.GetFirstToken(context.EXEC()));
CompilerDirective = copyDirective;
if (context.copyCompilerStatementBody() != null)
{
var textNameContext = context.copyCompilerStatementBody().qualifiedTextName().textName();
if (textNameContext != null)
{
string textName = GetTextName(textNameContext);
copyDirective.TextName = textName;
copyDirective.TextNameSymbol = ParseTreeUtils.GetFirstToken(textNameContext);
}
var libraryNameContext = context.copyCompilerStatementBody().qualifiedTextName().libraryName();
if (libraryNameContext != null)
{
copyDirective.LibraryName = GetLibraryName(libraryNameContext);
copyDirective.LibraryNameSymbol = ParseTreeUtils.GetFirstToken(libraryNameContext);
}
}
}
public virtual void StartServiceLabelCompilerStatement()
{
CompilerDirective = new ServiceLabelDirective();
}
public virtual void StartReplaceCompilerStatement(CompilerDirectiveType type)
{
ReplaceDirective replaceDirective = new ReplaceDirective(type);
CompilerDirective = replaceDirective;
}
public override void EnterReplaceCompilerStatement(CobolCompilerDirectivesParser.ReplaceCompilerStatementContext context)
{
ReplaceDirective replaceDirective = new ReplaceDirective(context.OFF() == null ? CompilerDirectiveType.REPLACE : CompilerDirectiveType.REPLACE_OFF);
CompilerDirective = replaceDirective;
if (context.pseudoText() != null)
{
// Data used to build the current replace operation
Token comparisonToken = null;
Token[] followingComparisonTokens = null;
Token replacementToken = null;
Token[] replacementTokens = null;
// Used to distinguish pseudo-text1 and pseudo-text2
int pseudoTextIndex = 0;
foreach (CobolCompilerDirectivesParser.PseudoTextContext pseudoTextContext in context.pseudoText())
{
/*// Comparison tokens
* if (pseudoTextIndex % 2 == 0)
* {
* if (pseudoTextContext._pseudoTextTokens != null && pseudoTextContext._pseudoTextTokens.Count > 0)
* {
* comparisonToken = (Token)pseudoTextContext._pseudoTextTokens[0];
* if(pseudoTextContext._pseudoTextTokens.Count > 1)
* {
* followingComparisonTokens = new Token[pseudoTextContext._pseudoTextTokens.Count - 1];
* for(int i = 1 ; i < pseudoTextContext._pseudoTextTokens.Count ; i++)
* {
* followingComparisonTokens[i - 1] = (Token)pseudoTextContext._pseudoTextTokens[i];
* }
* }
* }
*
* pseudoTextIndex++;
* }
* // Replacement tokens
* else
* {
* if (pseudoTextContext._pseudoTextTokens != null && pseudoTextContext._pseudoTextTokens.Count > 0)
* {
* if (followingComparisonTokens == null && pseudoTextContext._pseudoTextTokens.Count == 1)
* {
* replacementToken = (Token)pseudoTextContext._pseudoTextTokens[0];
* }
* else
* {
* replacementTokens = new Token[pseudoTextContext._pseudoTextTokens.Count];
* for (int i = 0; i < pseudoTextContext._pseudoTextTokens.Count; i++)
* {
* replacementTokens[i] = (Token)pseudoTextContext._pseudoTextTokens[i];
* }
* }
* }
*
* // Build replace operation
* ReplaceOperation replaceOperation = null;
* if(followingComparisonTokens == null)
* {
* if(replacementTokens == null)
* {
* if (comparisonToken == null || comparisonToken.TokenType != TokenType.PartialCobolWord)
* {
* replaceOperation = new SingleTokenReplaceOperation(comparisonToken, replacementToken);
* }
* else
* {
* replaceOperation = new PartialWordReplaceOperation(comparisonToken, replacementToken);
* }
* }
* else
* {
* replaceOperation = new SingleToMultipleTokensReplaceOperation(comparisonToken, replacementTokens);
* }
* }
* else
* {
* replaceOperation = new MultipleTokensReplaceOperation(comparisonToken, followingComparisonTokens, replacementTokens);
* }
* replaceDirective.ReplaceOperations.Add(replaceOperation);
*
* // Reset everything for the next replace operation
* pseudoTextIndex = 0;
* comparisonToken = null;
* followingComparisonTokens = null;
* replacementToken = null;
* replacementTokens = null;
* }*/
BuildReplaceOperation(replaceDirective.ReplaceOperations, ref comparisonToken, ref followingComparisonTokens, ref replacementToken, ref replacementTokens, ref pseudoTextIndex, pseudoTextContext._pseudoTextTokens);
}
}
}
public override void EnterServiceLabelCompilerStatement(CobolCompilerDirectivesParser.ServiceLabelCompilerStatementContext context)
{
CompilerDirective = new ServiceLabelDirective();
}
// --- Visiting the tree ---
public override void EnterCompilerDirectingStatement(CobolCompilerDirectivesParser.CompilerDirectingStatementContext context)
{
CompilerDirective = null;
}
public override void EnterReadyOrResetTraceCompilerStatement(CobolCompilerDirectivesParser.ReadyOrResetTraceCompilerStatementContext context)
{
CompilerDirective = new ReadyOrResetTraceDirective(context.READY() != null ? CompilerDirectiveType.READY_TRACE : CompilerDirectiveType.RESET_TRACE);
}
public override void EnterControlCblCompilerStatement(CobolCompilerDirectivesParser.ControlCblCompilerStatementContext context)
{
CompilerDirective = new ControlCblDirective(context.ASTERISK_CONTROL() != null ? CompilerDirectiveType.ASTERISK_CONTROL : CompilerDirectiveType.ASTERISK_CBL);
}
public virtual void StartControlCblCompilerStatement(CompilerDirectiveType type)
{
CompilerDirective = new ControlCblDirective(type);
}
internal TokensGroup InsertCompilerDirectiveTokenOnFirstLine(IList <Token> tokensOnFirstLineBeforeCompilerDirective, CompilerDirective compilerDirective, bool hasError, IList <Token> compilerDirectiveTokensOnFirstLine, IList <Token> tokensOnFirstLineAfterCompilerDirective, bool hasDirectiveTokenContinuedOnNextLine)
{
// Register compiler listing control directive
if (compilerDirective.Type == CompilerDirectiveType.ASTERISK_CBL ||
compilerDirective.Type == CompilerDirectiveType.ASTERISK_CONTROL ||
compilerDirective.Type == CompilerDirectiveType.EJECT ||
compilerDirective.Type == CompilerDirectiveType.SKIP1 ||
compilerDirective.Type == CompilerDirectiveType.SKIP2 ||
compilerDirective.Type == CompilerDirectiveType.SKIP3 ||
compilerDirective.Type == CompilerDirectiveType.TITLE)
{
CompilerListingControlDirective = compilerDirective;
}
// Register COPY directives
// Prepare dictionary for COPY imported documents
if (compilerDirective.Type == CompilerDirectiveType.COPY ||
compilerDirective.Type == CompilerDirectiveType.EXEC_SQL_INCLUDE)
{
if (ImportedDocuments == null)
{
ImportedDocuments = new Dictionary <CopyDirective, ImportedTokensDocument>(1);
}
ImportedDocuments.Add((CopyDirective)compilerDirective, null);
}
// Register REPLACE compiler directive
if (compilerDirective.Type == CompilerDirectiveType.REPLACE)
{
ReplaceDirective = (ReplaceDirective)compilerDirective;
}
// Initialize tokensWithCompilerDirectives
// (first compiler directive found on this line)
if (!HasCompilerDirectives)
{
// Initialize tokens list
tokensWithCompilerDirectives = new List <Token>();
// Keep tokens before compiler directive
if (tokensOnFirstLineBeforeCompilerDirective != null)
{
foreach (Token token in tokensOnFirstLineBeforeCompilerDirective)
{
tokensWithCompilerDirectives.Add(token);
}
}
}
// Update tokensWithCompilerDirectives
// (several compiler directives on the same line)
else
{
// Reset tokens list
IList <Token> previousTokens = tokensWithCompilerDirectives;
tokensWithCompilerDirectives = new List <Token>();
// Keep tokens before compiler directive
Token firstTokenOfCompilerDirective = compilerDirectiveTokensOnFirstLine[0];
foreach (Token token in previousTokens)
{
if (token == firstTokenOfCompilerDirective)
{
break;
}
tokensWithCompilerDirectives.Add(token);
}
}
// Build a CompilerDirectiveToken wrapping all matched tokens on the first line
CompilerDirectiveToken directiveToken = new CompilerDirectiveToken(
compilerDirective,
compilerDirectiveTokensOnFirstLine,
hasError);
// Add the compilerDirectiveToken
tokensWithCompilerDirectives.Add(directiveToken);
// Keep tokens after compiler directive
if (tokensOnFirstLineAfterCompilerDirective != null)
{
foreach (Token token in tokensOnFirstLineAfterCompilerDirective)
{
tokensWithCompilerDirectives.Add(token);
}
}
// Register line continuation properties
HasDirectiveTokenContinuedOnNextLine = HasDirectiveTokenContinuedOnNextLine || hasDirectiveTokenContinuedOnNextLine;
// Return potentially continued compiler directive token
if (tokensOnFirstLineAfterCompilerDirective == null)
{
return(directiveToken);
}
else
{
return(null);
}
}
public virtual void EnterExecSqlIncludeStatement(Token execToken)
{
var copyDirective = new CopyDirective(CompilerDirectiveType.EXEC_SQL_INCLUDE, execToken);
CompilerDirective = copyDirective;
}
public override void EnterDeleteCompilerStatement(CobolCompilerDirectivesParser.DeleteCompilerStatementContext context)
{
CompilerDirective = new DeleteDirective();
}
public override void EnterCopyCompilerStatement(CobolCompilerDirectivesParser.CopyCompilerStatementContext context)
{
CompilerDirective = new CopyDirective(CompilerDirectiveType.COPY, ParseTreeUtils.GetFirstToken(context.COPY()));
}
public virtual void EnterCopyCompilerStatement(TypeCobol.Compiler.Scanner.Token copy)
{
CompilerDirective = new CopyDirective(CompilerDirectiveType.COPY, copy);
}
public virtual void StartReadyOrResetTraceCompilerStatement(CompilerDirectiveType type)
{
CompilerDirective = new ReadyOrResetTraceDirective(type);
}
public virtual void StartBasisCompilerStatement()
{
var basisDirective = new BasisDirective();
CompilerDirective = basisDirective;
}
public virtual void StartInsertCompilerStatement()
{
InsertDirective insertDirective = new InsertDirective();
CompilerDirective = insertDirective;
}
public virtual void StartTitleCompilerStatement()
{
TitleDirective titleDirective = new TitleDirective();
CompilerDirective = titleDirective;
}
public override void EnterEjectCompilerStatement(CobolCompilerDirectivesParser.EjectCompilerStatementContext context)
{
CompilerDirective = new EjectDirective();
}
public virtual void StartServiceReloadCompilerStatement()
{
ServiceReloadDirective serviceReloadDirective = new ServiceReloadDirective();
CompilerDirective = serviceReloadDirective;
}
/// <summary>
/// Incremental preprocessing of a set of tokens lines changes
/// </summary>
internal static IList <DocumentChange <IProcessedTokensLine> > ProcessTokensLinesChanges(TextSourceInfo textSourceInfo, ISearchableReadOnlyList <ProcessedTokensLine> documentLines, IList <DocumentChange <ITokensLine> > tokensLinesChanges, PrepareDocumentLineForUpdate prepareDocumentLineForUpdate, TypeCobolOptions compilerOptions, IProcessedTokensDocumentProvider processedTokensDocumentProvider, List <RemarksDirective.TextNameVariation> copyTextNameVariations, PerfStatsForParserInvocation perfStatsForParserInvocation, List <CopyDirective> missingCopies)
{
// Collect all changes applied to the processed tokens lines during the incremental scan
IList <DocumentChange <IProcessedTokensLine> > processedTokensLinesChanges = new List <DocumentChange <IProcessedTokensLine> >();
// There are 2 reasons to a preprocess a tokens line after a change :
// 1. A tokens line changed : these lines were already reset during the previous steps
// 2. If a tokens line that changed was involved in the parsing of a multiline compiler directive, the whole group of lines must be parsed again
// Then, if a new COPY directive was parsed : the CompilationDocument to include must be prepared
// --- PREPARATION PHASE : reset all processed tokens lines which were involved in a multiline compiler directive where at least one line changed ---
// Iterate over all tokens changes detected by the ScannerStep :
// refresh all the adjacent lines participating in a ContinuationTokensGroup
if (tokensLinesChanges != null)
{
int lastLineIndexReset = -1;
foreach (DocumentChange <ITokensLine> tokensChange in tokensLinesChanges)
{
processedTokensLinesChanges.Add(new DocumentChange <IProcessedTokensLine>(tokensChange.Type, tokensChange.LineIndex, (IProcessedTokensLine)tokensChange.NewLine));
if (tokensChange.LineIndex > lastLineIndexReset)
{
lastLineIndexReset = CheckIfAdjacentLinesNeedRefresh(tokensChange.Type, tokensChange.LineIndex, documentLines, prepareDocumentLineForUpdate, processedTokensLinesChanges, lastLineIndexReset);
}
}
}
// --- COMPILER DIRECTIVES PHASE : Find and parse all compiler directives ---
// Init. Prepare a compiler directive parser
// Create a token iterator on top of tokens lines
TokensLinesIterator tokensIterator = new TokensLinesIterator(
textSourceInfo.Name,
documentLines,
null,
Token.CHANNEL_SourceTokens);
// Crate an Antlr compatible token source on top a the token iterator
TokensLinesTokenSource tokenSource = new TokensLinesTokenSource(
textSourceInfo.Name,
tokensIterator);
// Init a compiler directive parser
CommonTokenStream tokenStream = new TokensLinesTokenStream(tokenSource, Token.CHANNEL_SourceTokens);
CobolCompilerDirectivesParser directivesParser = new CobolCompilerDirectivesParser(tokenStream);
// Optionnaly activate Antlr Parser performance profiling
// WARNING : use this in a single-treaded context only (uses static field)
if (AntlrPerformanceProfiler == null && perfStatsForParserInvocation.ActivateDetailedAntlrPofiling)
{
AntlrPerformanceProfiler = new AntlrPerformanceProfiler(directivesParser);
}
if (AntlrPerformanceProfiler != null)
{
// Replace the generated parser by a subclass which traces all rules invocations
directivesParser = new CobolCompilerDirectivesTracingParser(tokenStream);
AntlrPerformanceProfiler.BeginParsingFile(textSourceInfo, null);
}
IAntlrErrorStrategy compilerDirectiveErrorStrategy = new CompilerDirectiveErrorStrategy();
directivesParser.ErrorHandler = compilerDirectiveErrorStrategy;
// Register all parse errors in a list in memory
ParserDiagnosticErrorListener errorListener = new ParserDiagnosticErrorListener();
directivesParser.RemoveErrorListeners();
directivesParser.AddErrorListener(errorListener);
// Prepare to analyze the parse tree
ParseTreeWalker walker = new ParseTreeWalker();
CompilerDirectiveBuilder directiveBuilder = new CompilerDirectiveBuilder(compilerOptions, copyTextNameVariations);
// 1. Iterate over all compiler directive starting tokens found in the lines which were updated
foreach (Token compilerDirectiveStartingToken in documentLines
.Where(line => line.PreprocessingState == ProcessedTokensLine.PreprocessorState.NeedsCompilerDirectiveParsing)
.SelectMany(line => line.SourceTokens)
.Where(token => token.TokenFamily == TokenFamily.CompilerDirectiveStartingKeyword))
{
// 2. Reset the compiler directive parser state
// Reset tokens iterator position before parsing
// -> seek just before the compiler directive starting token
tokensIterator.SeekToToken(compilerDirectiveStartingToken);
tokensIterator.PreviousToken();
// Special case : for efficiency reasons, in EXEC SQL INCLUDE directives
// only the third token INCLUDE is recognized as a compiler directive
// starting keyword by the scanner. In this case, we must rewind the
// iterator two tokens backwards to start parsing just before the EXEC token.
if (compilerDirectiveStartingToken.TokenType == TokenType.EXEC_SQL_INCLUDE)
{
tokensIterator.PreviousToken();
tokensIterator.PreviousToken();
}
// Reset Antlr BufferedTokenStream position
tokenStream.SetTokenSource(tokenSource);
// Reset parsing error diagnostics
compilerDirectiveErrorStrategy.Reset(directivesParser);
// 3. Try to parse a compiler directive starting with the current token
perfStatsForParserInvocation.OnStartAntlrParsing();
if (AntlrPerformanceProfiler != null)
{
AntlrPerformanceProfiler.BeginParsingSection();
}
CobolCompilerDirectivesParser.CompilerDirectingStatementContext directiveParseTree = directivesParser.compilerDirectingStatement();
if (AntlrPerformanceProfiler != null)
{
AntlrPerformanceProfiler.EndParsingSection(directiveParseTree.ChildCount);
}
perfStatsForParserInvocation.OnStopAntlrParsing(
AntlrPerformanceProfiler != null ? (int)AntlrPerformanceProfiler.CurrentFileInfo.DecisionTimeMs : 0,
AntlrPerformanceProfiler != null ? AntlrPerformanceProfiler.CurrentFileInfo.RuleInvocations.Sum() : 0);
perfStatsForParserInvocation.OnStartTreeBuilding();
// 4. Visit the parse tree to build a first class object representing the compiler directive
walker.Walk(directiveBuilder, directiveParseTree);
CompilerDirective compilerDirective = directiveBuilder.CompilerDirective;
bool errorFoundWhileParsingDirective = compilerDirective == null || compilerDirective.Diagnostics != null || directiveParseTree.Diagnostics != null;
// 5. Get all tokens consumed while parsing the compiler directive
// and partition them line by line
Token startToken = (Token)directiveParseTree.Start;
Token stopToken = (Token)directiveParseTree.Stop;
if (stopToken == null)
{
stopToken = startToken;
}
MultilineTokensGroupSelection tokensSelection = tokensIterator.SelectAllTokensBetween(startToken, stopToken);
if (compilerDirective != null)
{
// 6. Replace all matched tokens by :
// - a CompilerDirectiveToken on the first line
ProcessedTokensLine firstProcessedTokensLine = documentLines[tokensSelection.FirstLineIndex];
if (tokensSelection.SelectedTokensOnSeveralLines.Length == 1)
{
firstProcessedTokensLine.InsertCompilerDirectiveTokenOnFirstLine(
tokensSelection.TokensOnFirstLineBeforeStartToken,
compilerDirective, errorFoundWhileParsingDirective,
tokensSelection.SelectedTokensOnSeveralLines[0],
tokensSelection.TokensOnLastLineAfterStopToken, false);
}
else
{
TokensGroup continuedTokensGroup = firstProcessedTokensLine.InsertCompilerDirectiveTokenOnFirstLine(
tokensSelection.TokensOnFirstLineBeforeStartToken,
compilerDirective, errorFoundWhileParsingDirective,
tokensSelection.SelectedTokensOnSeveralLines[0],
null, true);
// - a ContinuationTokensGroup on the following lines
int selectionLineIndex = 1;
int lastLineIndex = tokensSelection.FirstLineIndex + tokensSelection.SelectedTokensOnSeveralLines.Length - 1;
for (int nextLineIndex = tokensSelection.FirstLineIndex + 1; nextLineIndex <= lastLineIndex; nextLineIndex++, selectionLineIndex++)
{
IList <Token> compilerDirectiveTokensOnNextLine = tokensSelection.SelectedTokensOnSeveralLines[selectionLineIndex];
if (compilerDirectiveTokensOnNextLine.Count > 0)
{
ProcessedTokensLine nextProcessedTokensLine = documentLines[nextLineIndex];
if (nextLineIndex != lastLineIndex)
{
continuedTokensGroup = nextProcessedTokensLine.InsertCompilerDirectiveTokenOnNextLine(
continuedTokensGroup,
compilerDirectiveTokensOnNextLine,
null, true);
}
else
{
continuedTokensGroup = nextProcessedTokensLine.InsertCompilerDirectiveTokenOnNextLine(
continuedTokensGroup,
compilerDirectiveTokensOnNextLine,
tokensSelection.TokensOnLastLineAfterStopToken, false);
}
}
}
}
}
// 7. Register compiler directive parse errors
if (errorFoundWhileParsingDirective)
{
ProcessedTokensLine compilerDirectiveLine = documentLines[tokensSelection.FirstLineIndex];
if (compilerDirective != null && compilerDirective.Diagnostics != null)
{
foreach (Diagnostic directiveDiag in compilerDirective.Diagnostics)
{
compilerDirectiveLine.AddDiagnostic(directiveDiag);
}
}
else if (directiveParseTree.Diagnostics != null)
{
foreach (Diagnostic directiveDiag in directiveParseTree.Diagnostics)
{
if (compilerDirective != null)
{
compilerDirective.AddDiagnostic(directiveDiag);
}
compilerDirectiveLine.AddDiagnostic(directiveDiag);
}
}
}
}
if (AntlrPerformanceProfiler != null)
{
AntlrPerformanceProfiler.EndParsingFile(directivesParser.ParseInfo.DecisionInfo, (int)(directivesParser.ParseInfo.GetTotalTimeInPrediction() / 1000000));
}
// 8. Advance the state off all ProcessedTokensLines :
// NeedsCompilerDirectiveParsing => NeedsCopyDirectiveProcessing if it contains a COPY directive
IList <ProcessedTokensLine> parsedLinesWithCopyDirectives = null;
// NeedsCompilerDirectiveParsing => Ready otherwise
foreach (ProcessedTokensLine parsedLine in documentLines
.Where(line => line.PreprocessingState == ProcessedTokensLine.PreprocessorState.NeedsCompilerDirectiveParsing))
{
if (parsedLine.ImportedDocuments != null)
{
if (parsedLinesWithCopyDirectives == null)
{
parsedLinesWithCopyDirectives = new List <ProcessedTokensLine>();
}
parsedLine.PreprocessingState = ProcessedTokensLine.PreprocessorState.NeedsCopyDirectiveProcessing;
parsedLinesWithCopyDirectives.Add(parsedLine);
}
else
{
parsedLine.PreprocessingState = ProcessedTokensLine.PreprocessorState.Ready;
}
}
perfStatsForParserInvocation.OnStopTreeBuilding();
// --- COPY IMPORT PHASE : Process COPY (REPLACING) directives ---
foreach (var lineChange in processedTokensLinesChanges)
{
missingCopies.Remove(missingCopies.FirstOrDefault(c => c.COPYToken.Line == lineChange.LineIndex + 1));
}
// 1. Iterate over all updated lines containing a new COPY directive
if (parsedLinesWithCopyDirectives != null)
{
foreach (ProcessedTokensLine tokensLineWithCopyDirective in parsedLinesWithCopyDirectives)
{
// Iterate over all COPY directives found on one updated line
foreach (CopyDirective copyDirective in tokensLineWithCopyDirective.ImportedDocuments.Keys.Where(c => c.TextName != null || c.COPYToken.TokenType == TokenType.EXEC).ToArray())
{
try
{
PerfStatsForImportedDocument perfStats;
// Load (or retrieve in cache) the document referenced by the COPY directive
//Issue #315: tokensLineWithCopyDirective.ScanState must be passed because special names paragraph such as "Decimal point is comma" are declared in the enclosing program and can affect the parsing of COPY
ProcessedTokensDocument importedDocumentSource =
processedTokensDocumentProvider.GetProcessedTokensDocument(copyDirective.LibraryName,
copyDirective.TextName,
tokensLineWithCopyDirective.ScanStateBeforeCOPYToken[copyDirective.COPYToken], copyTextNameVariations, out perfStats);
// Store it on the current line after applying the REPLACING directive
ImportedTokensDocument importedDocument = new ImportedTokensDocument(copyDirective,
importedDocumentSource, perfStats);
tokensLineWithCopyDirective.ImportedDocuments[copyDirective] = importedDocument;
}
catch (Exception e)
{
if (missingCopies != null && copyDirective != null && copyDirective.COPYToken != null && !missingCopies.Contains(copyDirective)) //If list already contains the copy directive just ignore
{
var missingCopieToReplace = missingCopies.FirstOrDefault(c => c.COPYToken.Line == copyDirective.COPYToken.Line);
missingCopies.Remove(missingCopieToReplace);
missingCopies.Add(copyDirective);
}
// Text name refenced by COPY directive was not found
// => register a preprocessor error on this line
Token failedDirectiveToken = tokensLineWithCopyDirective.TokensWithCompilerDirectives
.First(
token =>
token.TokenType == TokenType.CopyImportDirective &&
((CompilerDirectiveToken)token).CompilerDirective == copyDirective);
Diagnostic diag = new Diagnostic(
MessageCode.FailedToLoadTextDocumentReferencedByCopyDirective,
failedDirectiveToken.Column, failedDirectiveToken.EndColumn,
failedDirectiveToken.Line, e.Message, e);
tokensLineWithCopyDirective.AddDiagnostic(diag);
}
}
// Advance processing status of the line
tokensLineWithCopyDirective.PreprocessingState = ProcessedTokensLine.PreprocessorState.Ready;
}
}
// --- REPLACE PHASE : REPLACE directives are implemented in ReplaceTokensLinesIterator ---
/* Algorithm :
*
* one REPLACE directive can express several replacement operations
* one replacement operation can be of several types (distinguished for optimization purposes)
* - SimpleTokenReplace : one source token / zero or one replacement token
* - PartialWordReplace : one pure partial word / zero or one replacement token
* - SimpleToMultipleTokenReplace : one source token / several replacement tokens
* - MultipleTokenReplace : one first + several following source tokens / zero to many replacement tokens
*
* an iterator maintains a current set of replacement operations
*
* if nextToken is replace directive
* the current set of replacement operations is updated
* else
* nextToken is compared to each replacement operation in turn
* if single -> single source token operation : return replacement token
* if single -> multiple operation : setup a secondary iterator with the list of replacement tokens
* if multiple -> multiple operation
* snapshot of the underlying iterator
* try to match all of the following source tokens
* if failure : restore snapshot and try next operation
* if success : setup a secondary iterator
*
* token comparison sourceToken / replacementCandidate :
* 1. Compare Token type
* 2. If same token type and for families
* AlphanumericLiteral
* NumericLiteral
* SyntaxLiteral
* Symbol
* => compare also Token text
*
* PartialCobolWord replacement :
* p535 : The COPY statement with REPLACING phrase can be used to replace parts of words.
* By inserting a dummy operand delimited by colons into the program text,
* the compiler will replace the dummy operand with the required text.
* Example 3 shows how this is used with the dummy operand :TAG:.
* The colons serve as separators and make TAG a stand-alone operand.
*/
return(processedTokensLinesChanges);
}
public virtual void StartEnterCompilerStatement()
{
EnterDirective enterDirective = new EnterDirective();
CompilerDirective = enterDirective;
}
