private void BuildReferences(ProcedureDivision procedureDivision)
{
// Perform-Referenzen aufbauen
var allProcedures = procedureDivision.Sections.SelectMany(sec => sec.Procedures).ToList();
foreach (var procedure in allProcedures)
{
foreach (var reference in procedure.PerformReferences)
{
// procedure performs reference. Find referencedProcedure
var referencedProcedure = allProcedures.FirstOrDefault(proc => proc.Name == reference.ReferencedProcedure) ??
procedureDivision.Sections.FirstOrDefault(sec => sec.Name == reference.ReferencedProcedure + " SECTION");
if (referencedProcedure != null)
{
reference.Procedure = referencedProcedure;
referencedProcedure.IsReferencedBy.Add(new PerformReference(procedure));
}
else
{
Console.WriteLine(@"Referenz nicht gefunden: " + reference.ReferencedProcedure);
}
}
}
}
public static void CheckLibrary([NotNull] ProcedureDivision procedureDivision)
{
//A procedure or a function cannot contains another procedure or function declaration
//So we only need to check ProcedureDivision of Program
if (!(procedureDivision.Parent is Program))
{
return;
}
//If the procedure division contains a PUBLIC procedure or function then it's considered as a "Library"
bool isLibrary = procedureDivision.Children.Any(c =>
{
var f = c.CodeElement as FunctionDeclarationHeader;
return(f != null && f.Visibility == AccessModifier.Public);
});
if (isLibrary)
{
bool firstParagraphChecked = false;
foreach (var child in procedureDivision.Children)
{
//TCRFUN_ONLY_PARAGRAPH_AND_PUBLIC_FUNC_IN_LIBRARY
if (child is Paragraph)
{
if (!firstParagraphChecked &&
!child.Name.Equals("INIT-LIBRARY", StringComparison.InvariantCultureIgnoreCase))
{
DiagnosticUtils.AddError(child.CodeElement == null ? procedureDivision : child,
"First paragraph of a program which contains public procedure must be INIT-LIBRARY. Move paragraph " + child.Name + " lower in the source.");
}
firstParagraphChecked = true;
continue; //A paragraph is always accepted as a child of ProcedureDivision
}
//TCRFUN_ONLY_PARAGRAPH_AND_PUBLIC_FUNC_IN_LIBRARY
if (!(child is FunctionDeclaration || child is Declaratives))
{
DiagnosticUtils.AddError(child.CodeElement == null ?
(child is Sentence
? (child.Children.FirstOrDefault(c => c.CodeElement != null) ?? procedureDivision)
: procedureDivision) : child,
"Inside a library only function declaration or declaratives are allowed " + child.Name + " / " + child.ID);
}
}
var pdiv = procedureDivision.CodeElement as ProcedureDivisionHeader;
//TCRFUN_LIBRARY_PROCEDURE_NO_USING
if (pdiv?.UsingParameters != null && pdiv.UsingParameters.Count > 0)
{
DiagnosticUtils.AddError(procedureDivision,
"Illegal " + pdiv.UsingParameters.Count + " USING in library PROCEDURE DIVISION.");
}
}
}
public void OnNode([NotNull] Node node, ParserRuleContext context, CodeModel.Program program)
{
ProcedureDivision procedureDivision = node as ProcedureDivision;
if (procedureDivision == null)
{
return; //not our job
}
var pdiv = procedureDivision.CodeElement as ProcedureDivisionHeader;
bool isPublicLibrary = false;
var elementsInError = new List <CodeElement>();
var errorMessages = new List <string>();
foreach (var child in procedureDivision.Children)
{
if (child.CodeElement == null)
{
elementsInError.Add(procedureDivision.CodeElement);
errorMessages.Add("Illegal default section in library. " + child);
}
else
{
var function = child.CodeElement as FunctionDeclarationHeader;
if (function != null)
{
isPublicLibrary = isPublicLibrary || function.Visibility == AccessModifier.Public;
}
else
{
elementsInError.Add(child.CodeElement);
errorMessages.Add("Illegal non-function item in library");
}
}
}
if (isPublicLibrary)
{
// if (copy == null || copy.CodeElement().Name == null) // TCRFUN_LIBRARY_COPY
// DiagnosticUtils.AddError(pgm.CodeElement, "Missing library copy in IDENTIFICATION DIVISION.", context);
if (pdiv.UsingParameters != null && pdiv.UsingParameters.Count > 0)
{
DiagnosticUtils.AddError(pdiv, "Illegal " + pdiv.UsingParameters.Count + " USING in library PROCEDURE DIVISION.", context);
}
for (int c = 0; c < errorMessages.Count; c++)
{
DiagnosticUtils.AddError(elementsInError[c], errorMessages[c], context);
}
}
}
public static void CheckLibrary([NotNull] ProcedureDivision procedureDivision)
{
//A procedure or a function cannot contains another procedure or function declaration
//So we only need to check ProcedureDivision of Program
if (!(procedureDivision.Parent is Program))
{
return;
}
//If the procedure division contains a PUBLIC procedure or function then it's considered as a "Library"
bool isLibrary = procedureDivision.Children.Any(c =>
{
var f = c.CodeElement as FunctionDeclarationHeader;
return(f != null && f.Visibility == AccessModifier.Public);
});
if (isLibrary)
{
foreach (var child in procedureDivision.Children)
{
//TCRFUN_ONLY_PARAGRAPH_AND_PUBLIC_FUNC_IN_LIBRARY
if (!(child is Paragraph || child is FunctionDeclaration))
{
CodeElement ce;
if (child.CodeElement != null)
{
ce = child.CodeElement;
}
else
{
ce = procedureDivision.CodeElement;
}
DiagnosticUtils.AddError(ce, "Illegal non-function or paragraph item in library " + child.Name + " / " + child.ID);
}
}
var pdiv = procedureDivision.CodeElement as ProcedureDivisionHeader;
//TCRFUN_LIBRARY_PROCEDURE_NO_USING
if (pdiv.UsingParameters != null && pdiv.UsingParameters.Count > 0)
{
DiagnosticUtils.AddError(pdiv, "Illegal " + pdiv.UsingParameters.Count + " USING in library PROCEDURE DIVISION.");
}
}
}
private List <Section> BuildSections(ProcedureDivision procedureDivision)
{
var result = new List <Section>();
var code = procedureDivision.GetCode();
foreach (Match sectionName in Constants.SectionRegex.Matches(code))
{
var name = sectionName.Groups["sectionName"].Value;
var begin = procedureDivision.StartIndex + sectionName.Index;
var end = procedureDivision.StartIndex + (sectionName.NextMatch().Success ? sectionName.NextMatch().Index : procedureDivision.Length);
var section = new Section(procedureDivision.ParentCobolFile, name, begin, end);
section.Procedures = BuildProcedures(section);
result.Add(section);
}
return(result);
}
public override bool Visit(ProcedureDivision procedureDivision)
{
LibraryChecker.CheckLibrary(procedureDivision);
return(true);
}
public virtual bool Visit(ProcedureDivision procedureDivision)
{
return(true);
}
public override bool Visit(ProcedureDivision procedureDivision)
{
var parent = procedureDivision.Parent as Program;
return(parent != null && base.Visit(procedureDivision));
}
