private void CheckTypedef(DataTypeDescriptionEntry typedef,
CodeElementsParser.DataDescriptionEntryContext context)
{
if (typedef == null)
{
return;
}
if (typedef.LevelNumber?.Value != 1)
{
string message = "TYPEDEF clause can only be specified for level 01 entries";
DiagnosticUtils.AddError(typedef, message, context.cobol2002TypedefClause());
}
if (typedef.IsExternal)
{
string message = "EXTERNAL clause cannot be specified with TYPEDEF clause";
foreach (var external in context.externalClause())
{
DiagnosticUtils.AddError(typedef, message, external);
}
}
#if EUROINFO_LEGACY_TYPEDEF
if (typedef.RestrictionLevel != RestrictionLevel.STRICT)
{
string message = "Custom EI rule : Only TYPEDEF STRICT is allowed.";
DiagnosticUtils.AddError(typedef, message, context.cobol2002TypedefClause());
return;
}
#endif
if (typedef.RestrictionLevel == RestrictionLevel.STRICT) //Manage as a STRICT TYPEDEF
{
if (typedef.IsSynchronized != null && typedef.IsSynchronized.Value == true)
{
DiagnosticUtils.AddError(typedef, "SYNC clause cannot be used with a STRICT type definition", context.cobol2002TypedefClause());
}
}
if (typedef.RestrictionLevel == RestrictionLevel.STRONG) //Manage as a STRONG TYPEDEF
{
if (typedef.InitialValue != null)
{
string message = "STRONG TYPEDEF cannot contain VALUE clause:";
foreach (var valeuClause in context.valueClause())
{
DiagnosticUtils.AddError(typedef, message, valeuClause);
}
}
if (typedef.Picture != null)
{
string message = "Elementary TYPEDEF cannot be STRONG";
string rulestack = RuleStackBuilder.GetRuleStack(context.cobol2002TypedefClause());
DiagnosticUtils.AddError(typedef, message,
ParseTreeUtils.GetFirstToken(context.cobol2002TypedefClause().STRONG()), rulestack);
}
}
}
public override void EnterInoutPhrase(CodeElementsParser.InoutPhraseContext context)
{
var ce = (FunctionDeclarationHeader)CodeElement;
ce.Inout = new SyntaxProperty <ParameterPassingDirection>(ParameterPassingDirection.InOut,
ParseTreeUtils.GetTokenFromTerminalNode(context.IN_OUT()));
ce.Profile.InoutParameters = CreateParameters(context.parameterDescription());
}
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 EnterFunctionReturningPhrase(CodeElementsParser.FunctionReturningPhraseContext context)
{
var ce = (FunctionDeclarationHeader)CodeElement;
ce.Returning = new SyntaxProperty <ParameterPassingDirection>(ParameterPassingDirection.Returning,
ParseTreeUtils.GetTokenFromTerminalNode(context.RETURNING()));
if (context.parameterDescription().functionDataParameter() != null)
{
var entry = CreateFunctionDataParameter(context.parameterDescription().functionDataParameter());
ce.Profile.ReturningParameter = entry;
}
}
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 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 EnterSequenceNumberField(CobolCompilerDirectivesParser.SequenceNumberFieldContext context)
{
DeleteDirective deleteDirective = (DeleteDirective)CompilerDirective;
bool isFirst = true;
int previous = -42;
foreach (ITerminalNode node in context.IntegerLiteral())
{
int current = (int)ParseTreeUtils.GetIntegerLiteral(node);
if (isFirst)
{
previous = current;
isFirst = false;
}
else
{
DeleteDirective.SequenceNumberRange range = new DeleteDirective.SequenceNumberRange();
range.From = previous;
if (current < 0)
{
range.To = -current;
isFirst = true;
}
else
{
range.To = previous;
previous = current;
}
deleteDirective.SequenceNumberRangesList.Add(range);
}
}
if (!isFirst && previous >= 0)
{
DeleteDirective.SequenceNumberRange range = new DeleteDirective.SequenceNumberRange();
range.From = previous;
range.To = previous;
deleteDirective.SequenceNumberRangesList.Add(range);
}
}
public override void EnterControlCblOption(CobolCompilerDirectivesParser.ControlCblOptionContext context)
{
string option = null;
TryGetUserDefinedWord(context.enumeratedValue1().UserDefinedWord(), ref option);
if (option != null)
{
ControlCblDirective.ControlCblOption optionValue;
if (Enum.TryParse <ControlCblDirective.ControlCblOption>(option, out optionValue))
{
((ControlCblDirective)CompilerDirective).OptionsList.Add(optionValue);
}
else
{
Token errorToken = ParseTreeUtils.GetTokenFromTerminalNode(context.enumeratedValue1().UserDefinedWord());
Diagnostic diag = new Diagnostic(
MessageCode.InvalidControlCblCompilerStatementOption,
errorToken.Column, errorToken.EndColumn,
errorToken.Line, option);
CompilerDirective.AddDiagnostic(diag);
}
}
}
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);
}
}
}
////////////////////
// PROCEDURE CALL //
////////////////////
public override void EnterTcCallStatement(CodeElementsParser.TcCallStatementContext context)
{
var cbCallProc = context.procedurePointerOrFunctionPointerVariableOrfunctionNameReference;
// Register call parameters (shared storage areas) information at the CodeElement level
CallSite callSite = null;
ProcedureStyleCallStatement statement = null;
Context = context;
//Incomplete CallStatement, create an empty CodeElement and return + Error due to issue #774
if (cbCallProc == null)
{
CodeElement = new ProcedureStyleCallStatement
{
Diagnostics = new List <Diagnostic>
{
new Diagnostic(MessageCode.SyntaxErrorInParser, context.Start.Column,
context.Stop.Column, context.Start.Line, "Empty CALL is not authorized")
}
};
return;
}
//Here ambiguousSymbolReference with either CandidatesType:
// - ProgramNameOrProgramEntry
// - data, condition, UPSISwitch, TCFunctionName
var ambiguousSymbolReference = CobolExpressionsBuilder.CreateProcedurePointerOrFunctionPointerVariableOrTCFunctionProcedure(cbCallProc);
//If (inputs, inouts ou outputs).Count > 0, then it's a procedure call
if (context.callOutputParameter().Length > 0 || context.callInputParameter().Length > 0 || context.callInoutParameter().Length > 0)
{
callSite = new CallSite();
#region Setup Input Output Inout CallSitesParameters
var inputs = new List <CallSiteParameter>();
var inouts = new List <CallSiteParameter>();
var outputs = new List <CallSiteParameter>();
SyntaxProperty <ParameterSharingMode> mode = null;
foreach (var p in context.callInputParameter())
{
CreateSharingMode(p, ref mode); // TCRFUN_INPUT_BY
var callSiteParameter = new CallSiteParameter
{
SharingMode = mode,
};
if (p.sharedVariableOrFileName() != null)
{
callSiteParameter.StorageAreaOrValue = CobolExpressionsBuilder.CreateSharedVariableOrFileName(p.sharedVariableOrFileName());
}
else if (p.OMITTED() != null)
{
callSiteParameter.Omitted = new SyntaxProperty <bool>(true, ParseTreeUtils.GetFirstToken(p.OMITTED()));
}
if (p.sharedVariableOrFileName() != null || p.OMITTED() != null)
{
inputs.Add(callSiteParameter);
}
}
foreach (var p in context.callInoutParameter())
{
var callSiteParameter = new CallSiteParameter
{
// TCRFUN_CALL_INOUT_AND_OUTPUT_BY_REFERENCE
SharingMode =
new SyntaxProperty <ParameterSharingMode>(ParameterSharingMode.ByReference, null),
};
if (p.sharedStorageArea1() != null)
{
callSiteParameter.StorageAreaOrValue = new Variable(CobolExpressionsBuilder.CreateSharedStorageArea(p.sharedStorageArea1()));
}
else if (p.OMITTED() != null)
{
callSiteParameter.Omitted = new SyntaxProperty <bool>(true, ParseTreeUtils.GetFirstToken(p.OMITTED()));
}
if (p.sharedStorageArea1() != null || p.OMITTED() != null)
{
inouts.Add(callSiteParameter);
}
}
foreach (var p in context.callOutputParameter())
{
var callSiteParameter = new CallSiteParameter
{
// TCRFUN_CALL_INOUT_AND_OUTPUT_BY_REFERENCE
SharingMode =
new SyntaxProperty <ParameterSharingMode>(ParameterSharingMode.ByReference, null),
};
if (p.sharedStorageArea1() != null)
{
callSiteParameter.StorageAreaOrValue = new Variable(CobolExpressionsBuilder.CreateSharedStorageArea(p.sharedStorageArea1()));
}
else if (p.OMITTED() != null)
{
callSiteParameter.Omitted = new SyntaxProperty <bool>(true, ParseTreeUtils.GetFirstToken(p.OMITTED()));
}
if (p.sharedStorageArea1() != null || p.OMITTED() != null)
{
outputs.Add(callSiteParameter);
}
}
int parametersCount = inputs.Count + outputs.Count + inouts.Count;
callSite.Parameters = new CallSiteParameter[parametersCount];
int i = 0;
//Add inputs to global callsites parameters
if (inputs.Count > 0)
{
foreach (var param in inputs)
{
callSite.Parameters[i] = param;
i++;
}
}
//Add outputs to global callsites parameters
if (outputs.Count > 0)
{
foreach (var param in outputs)
{
callSite.Parameters[i] = param;
i++;
}
}
//Add inouts to global callsites parameters
if (inouts.Count > 0)
{
foreach (var param in inouts)
{
callSite.Parameters[i] = param;
i++;
}
}
#endregion
//Check Type or CandidatesTypes to see if a TCFunctionName is possible
if (ambiguousSymbolReference.MainSymbolReference != null &&
ambiguousSymbolReference.MainSymbolReference.IsOrCanBeOfType(SymbolType.TCFunctionName))
{
SymbolReferenceVariable TCFunctionNameRefVariable;
if (ambiguousSymbolReference.MainSymbolReference.IsQualifiedReference)
{
var nonAmbiguousHead =
new SymbolReference(
(ambiguousSymbolReference.MainSymbolReference as TypeCobolQualifiedSymbolReference)?.Head
.NameLiteral, SymbolType.TCFunctionName);
var nonAmbiguousTail =
new SymbolReference(
(ambiguousSymbolReference.MainSymbolReference as TypeCobolQualifiedSymbolReference)?.Tail
.NameLiteral, SymbolType.ProgramName);
TypeCobolQualifiedSymbolReference newQualifiedSymbolReferece =
new TypeCobolQualifiedSymbolReference(nonAmbiguousHead, nonAmbiguousTail);
TCFunctionNameRefVariable = new SymbolReferenceVariable(StorageDataType.MethodName,
newQualifiedSymbolReferece);
}
else
{
//If so, create ProcedureStyleCallStatement with a ProcedureCall and fix SymbolReference so it's not ambiguous
var nonAmbiguousSymbolRef =
new SymbolReference(ambiguousSymbolReference.MainSymbolReference.NameLiteral,
SymbolType.TCFunctionName);
TCFunctionNameRefVariable = new SymbolReferenceVariable(StorageDataType.MethodName,
nonAmbiguousSymbolRef);
}
//CobolExpressionsBuilder store every StorageArea created into storageAreaReads and then after
//storageAreaReads is set to the CodeElement
//We must remove it as TCFunctionNameRefVariable doesn't contains a StorageArea
if (ambiguousSymbolReference.StorageArea != null)
{
CobolExpressionsBuilder.storageAreaReads.Remove(ambiguousSymbolReference.StorageArea);
}
statement =
new ProcedureStyleCallStatement(new ProcedureCall(TCFunctionNameRefVariable.MainSymbolReference,
inputs, inouts, outputs))
{
ProgramOrProgramEntryOrProcedureOrFunctionOrTCProcedureFunction =
TCFunctionNameRefVariable.MainSymbolReference
};
callSite.CallTarget = TCFunctionNameRefVariable.MainSymbolReference;
}
else
{
//else it's an error
statement =
new ProcedureStyleCallStatement(new ProcedureCall(ambiguousSymbolReference.MainSymbolReference,
inputs, inouts, outputs))
{
ProgramOrProgramEntryOrProcedureOrFunctionOrTCProcedureFunction = ambiguousSymbolReference.MainSymbolReference,
Diagnostics = new List <Diagnostic>
{
new Diagnostic(MessageCode.ImplementationError, context.Start.Column,
context.Stop.Column, context.Start.Line,
"A call with arguments is not a TCFunctionName")
},
};
callSite.CallTarget = ambiguousSymbolReference.MainSymbolReference;
}
}
else
{
if (ambiguousSymbolReference.MainSymbolReference != null &&
ambiguousSymbolReference.MainSymbolReference.IsOrCanBeOfType(SymbolType.DataName, SymbolType.TCFunctionName))
{
//TODO think about uniformity of CandidateTypes inside QualifiedReference.
//Maybe just define CandidatesTypes for the Head...
if (ambiguousSymbolReference.MainSymbolReference.IsQualifiedReference)
{
var qualifiedSymbolReference = (QualifiedSymbolReference)ambiguousSymbolReference.MainSymbolReference;
AmbiguousSymbolReference.ApplyCandidatesTypes(qualifiedSymbolReference, new[] { SymbolType.DataName, SymbolType.ProgramName });
//Adjust candidate types only for the first element
if (qualifiedSymbolReference.First.IsAmbiguous)
{
((AmbiguousSymbolReference)qualifiedSymbolReference.First).CandidateTypes = new[] { SymbolType.DataName, SymbolType.TCFunctionName };
}
}
else
{
((AmbiguousSymbolReference)ambiguousSymbolReference.MainSymbolReference).CandidateTypes = new[] { SymbolType.DataName, SymbolType.TCFunctionName };
}
statement = new ProcedureStyleCallStatement(new ProcedureCall(ambiguousSymbolReference.MainSymbolReference,
null, null, null))
{
ProcdurePointerOrTCProcedureFunction = ambiguousSymbolReference.MainSymbolReference
};
callSite = new CallSite();
callSite.CallTarget = statement.ProcdurePointerOrTCProcedureFunction;
}
else //else, it's an error
{
statement =
new ProcedureStyleCallStatement(new ProcedureCall(ambiguousSymbolReference.MainSymbolReference,
null, null, null))
{
ProgramOrProgramEntryOrProcedureOrFunctionOrTCProcedureFunction =
ambiguousSymbolReference.MainSymbolReference,
};
statement.Diagnostics.Add(new Diagnostic(MessageCode.SyntaxErrorInParser, context.Start.Column,
context.Stop.Column, context.Start.Line, "Error in detecting Procedure Call type"));
callSite = new CallSite();
callSite.CallTarget = statement.ProgramOrProgramEntryOrProcedureOrFunctionOrTCProcedureFunction;
}
}
if (callSite != null)
{
if (statement.CallSites == null)
{
statement.CallSites = new List <CallSite>();
}
statement.CallSites.Add(callSite);
}
CodeElement = statement;
}
public ParameterDescriptionEntry CreateFunctionDataParameter(
CodeElementsParser.FunctionDataParameterContext context)
{
var parameter = new ParameterDescriptionEntry();
parameter.LevelNumber = new GeneratedIntegerValue(1);
parameter.DataName = CobolWordsBuilder.CreateDataNameDefinition(context.dataNameDefinition());
if (context.pictureClause() != null)
{
parameter.Picture =
CobolWordsBuilder.CreateAlphanumericValue(context.pictureClause().pictureCharacterString);
parameter.DataType = DataType.Create(parameter.Picture.Value);
}
else if (context.cobol2002TypeClause() != null)
{
parameter.UserDefinedDataType =
CobolWordsBuilder.CreateQualifiedDataTypeReference(context.cobol2002TypeClause());
if (parameter.UserDefinedDataType != null)
{
parameter.DataType = DataType.CreateCustom(parameter.UserDefinedDataType.Name);
}
}
else if (context.POINTER() != null)
{
parameter.Usage = CreateDataUsageProperty(DataUsage.Pointer, context.POINTER());
}
if (context.blankWhenZeroClause() != null)
{
var blankClauseContext = context.blankWhenZeroClause();
Token zeroToken;
if (blankClauseContext.ZERO() != null)
{
zeroToken = ParseTreeUtils.GetFirstToken(blankClauseContext.ZERO());
}
else if (blankClauseContext.ZEROS() != null)
{
zeroToken = ParseTreeUtils.GetFirstToken(blankClauseContext.ZEROS());
}
else
{
zeroToken = ParseTreeUtils.GetFirstToken(blankClauseContext.ZEROES());
}
parameter.IsBlankWhenZero = new SyntaxProperty <bool>(true, zeroToken);
}
if (context.justifiedClause() != null)
{
var justifiedClauseContext = context.justifiedClause();
Token justifiedToken = null;
if (justifiedClauseContext.JUSTIFIED() != null)
{
justifiedToken = ParseTreeUtils.GetFirstToken(justifiedClauseContext.JUSTIFIED());
}
else
{
justifiedToken = ParseTreeUtils.GetFirstToken(justifiedClauseContext.JUST());
}
parameter.IsJustified = new SyntaxProperty <bool>(true, justifiedToken);
}
if (context.synchronizedClause() != null)
{
var synchronizedClauseContext = context.synchronizedClause();
if (synchronizedClauseContext.SYNCHRONIZED() != null)
{
parameter.IsSynchronized = new SyntaxProperty <bool>(true,
ParseTreeUtils.GetFirstToken(synchronizedClauseContext.SYNCHRONIZED()));
}
else
{
parameter.IsSynchronized = new SyntaxProperty <bool>(true,
ParseTreeUtils.GetFirstToken(synchronizedClauseContext.SYNC()));
}
}
if (context.groupUsageClause() != null)
{
var groupUsageClauseContext = context.groupUsageClause();
parameter.IsJustified = new SyntaxProperty <bool>(true,
ParseTreeUtils.GetFirstToken(groupUsageClauseContext.NATIONAL()));
}
//No occurs clause because we only allow level 01
// if (context.occursClause() != null && context.occursClause().Length > 0)
// {
// var occursClauseContext = context.occursClause()[0];
// if (occursClauseContext.minNumberOfOccurences != null)
// {
// parameter.MinOccurencesCount = CobolWordsBuilder.CreateIntegerValue(occursClauseContext.minNumberOfOccurences);
// }
// if (occursClauseContext.maxNumberOfOccurences != null)
// {
// parameter.MaxOccurencesCount = CobolWordsBuilder.CreateIntegerValue(occursClauseContext.maxNumberOfOccurences);
// }
// if (parameter.MinOccurencesCount == null && parameter.MaxOccurencesCount != null)
// {
// parameter.MinOccurencesCount = parameter.MaxOccurencesCount;
// }
// if (occursClauseContext.UNBOUNDED() != null)
// {
// parameter.HasUnboundedNumberOfOccurences = new SyntaxProperty<bool>(true,
// ParseTreeUtils.GetFirstToken(occursClauseContext.UNBOUNDED()));
// }
// if (occursClauseContext.varNumberOfOccurences != null)
// {
// parameter.OccursDependingOn = CobolExpressionsBuilder.CreateNumericVariable(occursClauseContext.varNumberOfOccurences);
// }
// if (occursClauseContext.tableSortingKeys() != null && occursClauseContext.tableSortingKeys().Length > 0)
// {
// int keysCount = 0;
// foreach (var tableSortingKeysContext in occursClauseContext.tableSortingKeys())
// {
// keysCount += tableSortingKeysContext.dataNameReference().Length;
// }
// parameter.TableSortingKeys = new TableSortingKey[keysCount];
// int keyIndex = 0;
// foreach (var tableSortingKeysContext in occursClauseContext.tableSortingKeys())
// {
// SyntaxProperty<SortDirection> sortDirection = null;
// if (tableSortingKeysContext.ASCENDING() != null)
// {
// sortDirection = new SyntaxProperty<SortDirection>(SortDirection.Ascending,
// ParseTreeUtils.GetFirstToken(tableSortingKeysContext.ASCENDING()));
// }
// else
// {
// sortDirection = new SyntaxProperty<SortDirection>(SortDirection.Descending,
// ParseTreeUtils.GetFirstToken(tableSortingKeysContext.DESCENDING()));
// }
// foreach (var dataNameReference in tableSortingKeysContext.dataNameReference())
// {
// SymbolReference sortKey = CobolWordsBuilder.CreateDataNameReference(dataNameReference);
// parameter.TableSortingKeys[keyIndex] = new TableSortingKey(sortKey, sortDirection);
// keyIndex++;
// }
// }
// }
// if (occursClauseContext.indexNameDefinition() != null && occursClauseContext.indexNameDefinition().Length > 0)
// {
// parameter.Indexes = new SymbolDefinition[occursClauseContext.indexNameDefinition().Length];
// for (int i = 0; i < occursClauseContext.indexNameDefinition().Length; i++)
// {
// var indexNameDefinition = occursClauseContext.indexNameDefinition()[i];
// parameter.Indexes[i] = CobolWordsBuilder.CreateIndexNameDefinition(indexNameDefinition);
// }
// }
// }
if (context.signClause() != null)
{
var signClauseContext = context.signClause();
if (signClauseContext.LEADING() != null)
{
parameter.SignPosition = new SyntaxProperty <SignPosition>(SignPosition.Leading,
ParseTreeUtils.GetFirstToken(signClauseContext.LEADING()));
}
else
{
parameter.SignPosition = new SyntaxProperty <SignPosition>(SignPosition.Trailing,
ParseTreeUtils.GetFirstToken(signClauseContext.TRAILING()));
}
if (signClauseContext.SEPARATE() != null)
{
parameter.SignIsSeparate = new SyntaxProperty <bool>(true,
ParseTreeUtils.GetFirstToken(signClauseContext.SEPARATE()));
}
}
//As POINTER can already be defined in Usage property, we don't want to overwrite it
if (parameter.Usage == null)
{
if (context.FUNCTION_POINTER() != null)
{
parameter.Usage = CreateDataUsageProperty(DataUsage.FunctionPointer, context.FUNCTION_POINTER());
}
else if (context.PROCEDURE_POINTER() != null)
{
parameter.Usage = CreateDataUsageProperty(DataUsage.ProcedurePointer, context.PROCEDURE_POINTER());
}
else if (context.tcfuncParameterUsageClause() != null)
{
parameter.Usage = CreateTCFuncParameterUsageClause(context.tcfuncParameterUsageClause());
}
}
if (context.valueClause() != null)
{
var valueClauseContext = context.valueClause();
parameter.InitialValue = CobolWordsBuilder.CreateValue(valueClauseContext.value2());
}
if (context.QuestionMark() != null)
{
parameter.Omittable = new SyntaxProperty <bool>(true, ParseTreeUtils.GetTokenFromTerminalNode(context.QuestionMark()));
}
return(parameter);
}
internal static void AddError(Node node, string message, Antlr4.Runtime.RuleContext context, MessageCode code = MessageCode.SyntaxErrorInParser)
{
AddError(node, message, ParseTreeUtils.GetFirstToken(context), RuleStackBuilder.GetRuleStack(context), code);
}
public override void EnterCopyCompilerStatementBody(CobolCompilerDirectivesParser.CopyCompilerStatementBodyContext context)
{
var copy = (CopyDirective)CompilerDirective;
if (context.qualifiedTextName() != null)
{
var ctxt = context.qualifiedTextName();
copy.TextName = GetTextName(ctxt.textName());
copy.TextNameSymbol = ParseTreeUtils.GetFirstToken(ctxt.textName());
#if EUROINFO_LEGACY_REPLACING_SYNTAX
if (copy.TextName != null)
{
// Find the list of copy text names variations declared by previous REMARKS compiler directives
var variations = CopyTextNameVariations;
if (TypeCobolOptions.AutoRemarksEnable && (variations == null || !variations.Any(v => string.Equals(v.TextNameWithSuffix, copy.TextName, StringComparison.InvariantCultureIgnoreCase)))) //If it does not exists, create the text variation (AutoRemarks mechanism Issue #440)
{
variations = new List <RemarksDirective.TextNameVariation>
{
new RemarksDirective.TextNameVariation(copy.TextName)
};
CopyTextNameVariations.AddRange(variations);
}
if (variations != null)
{
var declaration = variations.Find(d => String.Equals(d.TextNameWithSuffix, copy.TextName, StringComparison.InvariantCultureIgnoreCase));
if (declaration != null)
{
// Declaration found => apply the legacy REPLACING semantics to the copy directive
copy.RemoveFirst01Level = true;
if (declaration.HasSuffix)
{
copy.TextName = declaration.TextName;
copy.InsertSuffixChar = true;
copy.Suffix = declaration.Suffix;
copy.PreSuffix = declaration.PreSuffix;
}
}
}
}
#endif
copy.LibraryName = GetLibraryName(ctxt.libraryName());
copy.LibraryNameSymbol = ParseTreeUtils.GetFirstToken(ctxt.libraryName());
}
copy.Suppress = (context.SUPPRESS() != null);
// REPLACING
if (context.copyReplacingOperand() != 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.CopyReplacingOperandContext replacingOperandContext in context.copyReplacingOperand())
{
// Get relevant tokens
IList <IToken> operandTokens = null;
if (replacingOperandContext.pseudoText() != null) // Pseudo-text => List of tokens
{
if (replacingOperandContext.pseudoText()._pseudoTextTokens != null)
{
operandTokens = replacingOperandContext.pseudoText()._pseudoTextTokens;
}
}
else // Single token
{
if (replacingOperandContext.literalOrUserDefinedWordOReservedWordExceptCopy() != null)
{
var terminalNode = ParseTreeUtils.GetFirstTerminalNode(replacingOperandContext.literalOrUserDefinedWordOReservedWordExceptCopy());
operandTokens = new List <IToken>(1);
operandTokens.Add(terminalNode.Symbol);
}
}
BuildReplaceOperation(copy.ReplaceOperations, ref comparisonToken, ref followingComparisonTokens, ref replacementToken, ref replacementTokens, ref pseudoTextIndex, operandTokens);
}
}
}
public override void EnterCopyCompilerStatement(CobolCompilerDirectivesParser.CopyCompilerStatementContext context)
{
CompilerDirective = new CopyDirective(CompilerDirectiveType.COPY, ParseTreeUtils.GetFirstToken(context.COPY()));
}
