public static bool TryGetStatement(Genero4glParser parser, out FglStatement node,
IModuleResult containingModule,
ReportBlockNode reportNode,
List <Func <PrepareStatement, bool> > prepStatementBinders,
Func <ReturnStatement, ParserResult> returnStatementBinder = null,
Action <IAnalysisResult, int, int> limitedScopeVariableAdder = null,
List <TokenKind> validExitKeywords = null,
IEnumerable <ContextStatementFactory> contextStatementFactories = null)
{
bool result = false;
node = null;
if (!(result = TryGetReportStatement(parser, out node, reportNode)))
{
List <ContextStatementFactory> csfs = new List <ContextStatementFactory>();
if (contextStatementFactories != null)
{
csfs.AddRange(contextStatementFactories);
}
csfs.Add((x) =>
{
FglStatement testNode;
TryGetReportStatement(x, out testNode, reportNode, true);
return(testNode);
});
result = parser.StatementFactory.TryParseNode(parser, out node, containingModule, prepStatementBinders, returnStatementBinder,
limitedScopeVariableAdder, false, validExitKeywords, csfs,
new ExpressionParsingOptions
{
AllowStarParam = true,
AdditionalExpressionParsers = new ExpressionParser[] { (x) => ParseAggregateReportFunction(x, reportNode) }
});
}
return(result);
}
public static bool TryParseNode(IParser parser, out PrintStatement node, ReportBlockNode reportNode)
{
node = null;
bool result = false;
if (parser.PeekToken(TokenKind.PrintKeyword))
{
result = true;
node = new PrintStatement();
parser.NextToken();
node.StartIndex = parser.Token.Span.Start;
node.WhereExpressions = new List <ExpressionNode>();
node.ColumnExpressions = new List <ExpressionNode>();
node.VariableNames = new List <ExpressionNode>();
node.Filenames = new List <ExpressionNode>();
node.OtherExpressions = new List <ExpressionNode>();
TokenKind nextTokKind = parser.PeekToken().Kind;
if (ReportStatementFactory.StatementStartKeywords.Contains(nextTokKind) ||
Genero4glAst.ValidStatementKeywords.Contains(nextTokKind) ||
parser.PeekToken(TokenKind.OnKeyword) ||
parser.PeekToken(TokenKind.EveryKeyword) ||
(parser.PeekToken(TokenKind.FirstKeyword) && parser.PeekToken(TokenKind.PageKeyword, 2)) ||
parser.PeekToken(TokenKind.PageKeyword) ||
parser.PeekToken(TokenKind.BeforeKeyword) ||
parser.PeekToken(TokenKind.AfterKeyword))
{
node.EndIndex = parser.Token.Span.End;
return(true);
}
List <TokenKind> breaks = new List <TokenKind> {
TokenKind.Comma
};
while (true)
{
if (parser.PeekToken(TokenKind.GroupKeyword))
{
parser.NextToken();
}
switch (parser.PeekToken().Kind)
{
case TokenKind.PagenoKeyword:
case TokenKind.LinenoKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.UsingKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenCategory.StringLiteral))
{
parser.NextToken();
}
if (parser.PeekToken(TokenKind.ClippedKeyword))
{
parser.NextToken();
}
}
break;
case TokenKind.ColumnKeyword:
{
parser.NextToken();
ExpressionNode colExpr;
if (FglExpressionNode.TryGetExpressionNode(parser, out colExpr, breaks))
{
node.ColumnExpressions.Add(colExpr);
}
break;
}
case TokenKind.CountKeyword:
case TokenKind.PercentKeyword:
{
parser.NextToken();
if (parser.PeekToken(TokenKind.LeftParenthesis))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.Multiply))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.RightParenthesis))
{
parser.NextToken();
}
else
{
parser.ReportSyntaxError("Expected right-paren in print statement.");
}
}
else
{
parser.ReportSyntaxError("Expected '*' in print statement.");
}
}
else
{
parser.ReportSyntaxError("Expected left-paren in print statement.");
}
if (parser.PeekToken(TokenKind.WhereKeyword))
{
parser.NextToken();
ExpressionNode whereClause;
if (FglExpressionNode.TryGetExpressionNode(parser, out whereClause, breaks))
{
node.WhereExpressions.Add(whereClause);
}
}
if (parser.PeekToken(TokenKind.UsingKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenCategory.StringLiteral))
{
parser.NextToken();
}
if (parser.PeekToken(TokenKind.ClippedKeyword))
{
parser.NextToken();
}
}
break;
}
case TokenKind.SumKeyword:
case TokenKind.MinKeyword:
case TokenKind.MaxKeyword:
case TokenKind.AvgKeyword:
{
parser.NextToken();
if (parser.PeekToken(TokenKind.LeftParenthesis))
{
parser.NextToken();
ExpressionNode varName;
if (FglExpressionNode.TryGetExpressionNode(parser, out varName))
{
node.VariableNames.Add(varName);
if (parser.PeekToken(TokenKind.RightParenthesis))
{
parser.NextToken();
}
else
{
parser.ReportSyntaxError("Expected right-paren in print statement.");
}
}
else
{
parser.ReportSyntaxError("Invalid variable name found in print statement.");
}
}
else
{
parser.ReportSyntaxError("Expected left-paren in print statement.");
}
if (parser.PeekToken(TokenKind.WhereKeyword))
{
parser.NextToken();
ExpressionNode whereClause;
if (FglExpressionNode.TryGetExpressionNode(parser, out whereClause, breaks))
{
node.WhereExpressions.Add(whereClause);
}
}
if (parser.PeekToken(TokenKind.UsingKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenCategory.StringLiteral))
{
parser.NextToken();
}
if (parser.PeekToken(TokenKind.ClippedKeyword))
{
parser.NextToken();
}
}
break;
}
case TokenKind.FileKeyword:
{
parser.NextToken();
ExpressionNode filename;
if (FglExpressionNode.TryGetExpressionNode(parser, out filename, breaks))
{
node.Filenames.Add(filename);
}
break;
}
default:
{
ExpressionNode expr;
if (FglExpressionNode.TryGetExpressionNode(parser, out expr, breaks, new ExpressionParsingOptions
{
AllowStarParam = true,
AdditionalExpressionParsers = new ExpressionParser[] { (x) => ReportStatementFactory.ParseAggregateReportFunction(x, reportNode) }
}))
{
node.OtherExpressions.Add(expr);
if (parser.PeekToken(TokenKind.SpacesKeyword))
{
parser.NextToken();
}
else if (parser.PeekToken(TokenKind.WordwrapKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.RightKeyword) && parser.PeekToken(TokenKind.MarginKeyword, 2))
{
parser.NextToken();
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr, breaks))
{
node.OtherExpressions.Add(expr);
}
else
{
parser.ReportSyntaxError("Invalid expression found in print statement.");
}
}
}
}
break;
}
}
var tokKind = parser.PeekToken().Kind;
if (tokKind == TokenKind.Comma)
{
parser.NextToken();
}
else if (tokKind == TokenKind.Semicolon)
{
parser.NextToken();
break;
}
else if (tokKind >= TokenKind.FirstOperator &&
tokKind <= TokenKind.LastOperator)
{
parser.NextToken();
}
else
{
break;
}
}
node.EndIndex = parser.Token.Span.End;
}
return(result);
}
public static bool TryParseNode(Genero4glParser parser, out ModuleNode defNode)
{
defNode = new ModuleNode();
if (!string.IsNullOrWhiteSpace(parser.Filename))
{
defNode.ProgramName = Path.GetFileName(Path.GetDirectoryName(parser.Filename));
}
NodesProcessed processed = NodesProcessed.None;
while (!parser.PeekToken(TokenKind.EndOfFile))
{
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
CompilerOptionsNode compOptionsNode;
if (CompilerOptionsNode.TryParseNode(parser, out compOptionsNode) && compOptionsNode != null)
{
if (processed == NodesProcessed.None)
{
defNode.Children.Add(compOptionsNode.StartIndex, compOptionsNode);
}
else
{
parser.ReportSyntaxError("Compiler options statement found in incorrect position.");
}
}
if (processed == NodesProcessed.None)
{
processed = NodesProcessed.CompilerOption;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
ImportModuleNode importNode;
if (ImportModuleNode.TryParseNode(parser, out importNode) && importNode != null)
{
if (processed == NodesProcessed.CompilerOption)
{
if (!defNode.Children.ContainsKey(importNode.StartIndex))
{
defNode.Children.Add(importNode.StartIndex, importNode);
if (!string.IsNullOrWhiteSpace(importNode.ImportName))
{
if (importNode.ImportType == ImportModuleType.C)
{
defNode.CExtensionImports.Add(importNode.ImportName);
}
else if (importNode.ImportType == ImportModuleType.Java)
{
defNode.JavaImports.Add(importNode.ImportName);
}
else
{
defNode.FglImports.Add(importNode.ImportName);
}
}
}
continue;
}
else
{
parser.ReportSyntaxError("Import statement found in incorrect position.");
}
}
if (processed == NodesProcessed.CompilerOption)
{
processed = NodesProcessed.Imports;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
SchemaSpecificationNode schemaNode;
if (SchemaSpecificationNode.TryParseDefine(parser, out schemaNode) && schemaNode != null)
{
if (processed == NodesProcessed.Imports)
{
if (!defNode.Children.ContainsKey(schemaNode.StartIndex))
{
defNode.Children.Add(schemaNode.StartIndex, schemaNode);
}
}
else
{
parser.ReportSyntaxError("Schema statement found in incorrect position.");
}
}
if (processed == NodesProcessed.Imports)
{
processed = NodesProcessed.SchemaSpec;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
GlobalsNode globalNode;
if (GlobalsNode.TryParseNode(parser, out globalNode) && globalNode != null)
{
if (processed == NodesProcessed.SchemaSpec || processed == NodesProcessed.MemberDefinitions)
{
defNode.Children.Add(globalNode.StartIndex, globalNode);
foreach (var cGlobKVP in globalNode.Constants)
{
if (!defNode.GlobalConstants.ContainsKey(cGlobKVP.Key))
{
defNode.GlobalConstants.Add(cGlobKVP);
}
else
{
parser.ReportSyntaxError(cGlobKVP.Value.LocationIndex, cGlobKVP.Value.LocationIndex + cGlobKVP.Value.Name.Length, string.Format("Global constant {0} defined more than once.", cGlobKVP.Key), Severity.Error);
}
}
foreach (var tGlobKVP in globalNode.Types)
{
if (!defNode.GlobalTypes.ContainsKey(tGlobKVP.Key))
{
defNode.GlobalTypes.Add(tGlobKVP);
}
else
{
parser.ReportSyntaxError(tGlobKVP.Value.LocationIndex, tGlobKVP.Value.LocationIndex + tGlobKVP.Value.Name.Length, string.Format("Global type {0} defined more than once.", tGlobKVP.Key), Severity.Error);
}
}
foreach (var vGlobKVP in globalNode.Variables)
{
if (!defNode.GlobalVariables.ContainsKey(vGlobKVP.Key))
{
defNode.GlobalVariables.Add(vGlobKVP);
}
else
{
parser.ReportSyntaxError(vGlobKVP.Value.LocationIndex, vGlobKVP.Value.LocationIndex + vGlobKVP.Value.Name.Length, string.Format("Global variable {0} defined more than once.", vGlobKVP.Key), Severity.Error);
}
}
continue;
}
else
{
parser.ReportSyntaxError("Globals statement found in incorrect position.");
}
}
if (processed == NodesProcessed.SchemaSpec)
{
processed = NodesProcessed.MemberDefinitions;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
bool matchedBreakSequence = false;
ConstantDefNode constNode;
List <List <TokenKind> > breakSequences = new List <List <TokenKind> >()
{
new List <TokenKind> {
TokenKind.GlobalsKeyword
},
new List <TokenKind> {
TokenKind.PublicKeyword
},
new List <TokenKind> {
TokenKind.PrivateKeyword
},
new List <TokenKind> {
TokenKind.ConstantKeyword
},
new List <TokenKind> {
TokenKind.DefineKeyword
},
new List <TokenKind> {
TokenKind.TypeKeyword
},
new List <TokenKind> {
TokenKind.FunctionKeyword
},
new List <TokenKind> {
TokenKind.MainKeyword
},
new List <TokenKind> {
TokenKind.ReportKeyword
}
};
if (ConstantDefNode.TryParseNode(parser, out constNode, out matchedBreakSequence, breakSequences) && constNode != null)
{
if (processed == NodesProcessed.SchemaSpec || processed == NodesProcessed.MemberDefinitions)
{
defNode.Children.Add(constNode.StartIndex, constNode);
foreach (var def in constNode.GetDefinitions())
{
def.Scope = "module constant";
if (!defNode.Constants.ContainsKey(def.Name))
{
defNode.Constants.Add(def.Name, def);
}
else
{
parser.ReportSyntaxError(def.LocationIndex, def.LocationIndex + def.Name.Length, string.Format("Module constant {0} defined more than once.", def.Name), Severity.Error);
}
}
continue;
}
else
{
parser.ReportSyntaxError("Constant definition found in incorrect position.");
}
}
if (processed == NodesProcessed.SchemaSpec)
{
processed = NodesProcessed.MemberDefinitions;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
TypeDefNode typeNode;
if (TypeDefNode.TryParseNode(parser, out typeNode, out matchedBreakSequence, breakSequences) && typeNode != null)
{
if (processed == NodesProcessed.SchemaSpec || processed == NodesProcessed.MemberDefinitions)
{
if (!defNode.Children.ContainsKey(typeNode.StartIndex))
{
defNode.Children.Add(typeNode.StartIndex, typeNode);
}
foreach (var def in typeNode.GetDefinitions())
{
def.Scope = "module type";
if (!defNode.Types.ContainsKey(def.Name))
{
defNode.Types.Add(def.Name, def);
}
else
{
parser.ReportSyntaxError(def.LocationIndex, def.LocationIndex + def.Name.Length, string.Format("Module type {0} defined more than once.", def.Name), Severity.Error);
}
}
continue;
}
else
{
parser.ReportSyntaxError("Type definition found in incorrect position.");
}
}
if (processed == NodesProcessed.SchemaSpec)
{
processed = NodesProcessed.MemberDefinitions;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
DefineNode defineNode;
if (DefineNode.TryParseDefine(parser, out defineNode, out matchedBreakSequence, breakSequences) && defineNode != null)
{
if (processed == NodesProcessed.SchemaSpec || processed == NodesProcessed.MemberDefinitions)
{
defNode.Children.Add(defineNode.StartIndex, defineNode);
foreach (var def in defineNode.GetDefinitions())
{
foreach (var vardef in def.VariableDefinitions)
{
vardef.Scope = "module variable";
vardef.SetIsPublic(defineNode.AccessModifier == AccessModifier.Public);
if (!defNode.Variables.ContainsKey(vardef.Name))
{
defNode.Variables.Add(vardef.Name, vardef);
}
else
{
parser.ReportSyntaxError(vardef.LocationIndex, vardef.LocationIndex + vardef.Name.Length, string.Format("Module variable {0} defined more than once.", vardef.Name), Severity.Error);
}
}
}
continue;
}
else
{
parser.ReportSyntaxError("Variable definition found in incorrect position.");
}
}
if (processed == NodesProcessed.SchemaSpec)
{
processed = NodesProcessed.MemberDefinitions;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
MainBlockNode mainBlock;
if (MainBlockNode.TryParseNode(parser, out mainBlock, defNode) && mainBlock != null)
{
if (processed == NodesProcessed.MemberDefinitions)
{
defNode.Children.Add(mainBlock.StartIndex, mainBlock);
defNode.Functions.Add(mainBlock.Name, mainBlock);
foreach (var cursor in mainBlock.Children.Values.Where(x => x is PrepareStatement || x is DeclareStatement))
{
IAnalysisResult curRes = cursor as IAnalysisResult;
if (!defNode.Cursors.ContainsKey(curRes.Name))
{
defNode.Cursors.Add(curRes.Name, curRes);
}
}
}
else
{
parser.ReportSyntaxError("Main block found in incorrect position.");
}
}
if (processed == NodesProcessed.MemberDefinitions)
{
processed = NodesProcessed.Main;
}
if (CheckForPreprocessorNode(parser, defNode))
{
continue;
}
FunctionBlockNode funcNode;
ReportBlockNode repNode;
DeclarativeDialogBlock dialogNode;
int dummy;
if (FunctionBlockNode.TryParseNode(parser, out funcNode, out dummy, defNode) && funcNode != null)
{
defNode.Children.Add(funcNode.StartIndex, funcNode);
funcNode.Scope = "function";
if (string.IsNullOrWhiteSpace(funcNode.Name))
{
parser.ReportSyntaxError(funcNode.LocationIndex, funcNode.LocationIndex, "Invalid function definition found.");
}
else if (!defNode.Functions.ContainsKey(funcNode.Name))
{
defNode.Functions.Add(funcNode.Name, funcNode);
}
else
{
parser.ReportSyntaxError(funcNode.LocationIndex, funcNode.LocationIndex + funcNode.Name.Length, string.Format("Function {0} defined more than once.", funcNode.Name), Severity.Error);
}
}
else if (ReportBlockNode.TryParseNode(parser, out repNode, defNode) && repNode != null)
{
defNode.Children.Add(repNode.StartIndex, repNode);
repNode.Scope = "report";
if (string.IsNullOrWhiteSpace(repNode.Name))
{
parser.ReportSyntaxError(repNode.LocationIndex, repNode.LocationIndex, "Invalid report definition found.");
}
else if (!defNode.Functions.ContainsKey(repNode.Name))
{
defNode.Functions.Add(repNode.Name, repNode);
}
else
{
parser.ReportSyntaxError(repNode.LocationIndex, repNode.LocationIndex + repNode.Name.Length, string.Format("Report {0} defined more than once.", repNode.Name), Severity.Error);
}
}
else if (DeclarativeDialogBlock.TryParseNode(parser, out dialogNode, defNode) && dialogNode != null)
{
defNode.Children.Add(dialogNode.StartIndex, dialogNode);
dialogNode.Scope = "dialog";
if (string.IsNullOrWhiteSpace(dialogNode.Name))
{
parser.ReportSyntaxError(dialogNode.LocationIndex, dialogNode.LocationIndex, "Invalid declarative dialog definition found.");
}
else if (!defNode.Functions.ContainsKey(dialogNode.Name))
{
defNode.Functions.Add(dialogNode.Name, dialogNode);
}
else
{
parser.ReportSyntaxError(dialogNode.LocationIndex, dialogNode.LocationIndex + dialogNode.Name.Length, string.Format("Declarative dialog {0} defined more than once.", dialogNode.Name), Severity.Error);
}
}
else
{
parser.NextToken();
}
}
if (defNode.Children.Count > 0)
{
defNode.StartIndex = defNode.Children[defNode.Children.Keys[0]].StartIndex;
defNode.EndIndex = defNode.Children[defNode.Children.Keys[defNode.Children.Count - 1]].EndIndex;
defNode.IsComplete = true;
}
return(true);
}
internal static ExpressionNode ParseAggregateReportFunction(IParser parser, ReportBlockNode reportNode)
{
ExpressionNode node = null;
if (reportNode != null)
{
var tokStr = parser.PeekToken().Value.ToString();
if (reportNode.Variables.ContainsKey(tokStr))
{
switch (tokStr.ToLower())
{
case "group":
{
var nextTokKind = parser.PeekToken(2).Kind;
if (nextTokKind != TokenKind.CountKeyword &&
nextTokKind != TokenKind.PercentKeyword &&
nextTokKind != TokenKind.SumKeyword &&
nextTokKind != TokenKind.AvgKeyword &&
nextTokKind != TokenKind.MinKeyword &&
nextTokKind != TokenKind.MaxKeyword)
{
return(null);
}
break;
}
case "count":
case "percent":
case "sum":
case "avg":
case "min":
case "max":
{
if (!parser.PeekToken(TokenKind.LeftParenthesis, 2))
{
return(null);
}
break;
}
}
}
}
if (parser.PeekToken(TokenKind.GroupKeyword))
{
parser.NextToken();
node = new TokenExpressionNode(parser.Token);
}
switch (parser.PeekToken().Kind)
{
case TokenKind.CountKeyword:
case TokenKind.PercentKeyword:
{
parser.NextToken();
if (node == null)
{
node = new TokenExpressionNode(parser.Token);
}
else
{
node.AppendExpression(new TokenExpressionNode(parser.Token));
}
if (parser.PeekToken(TokenKind.LeftParenthesis))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
if (parser.PeekToken(TokenKind.Multiply))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
if (parser.PeekToken(TokenKind.RightParenthesis))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
}
else
{
parser.ReportSyntaxError("Expected right-paren in report aggregate function.");
}
}
else
{
parser.ReportSyntaxError("Expected '*' in report aggregate function.");
}
}
else
{
parser.ReportSyntaxError("Expected left-paren in report aggregate function.");
}
// get the optional where clause
if (parser.PeekToken(TokenKind.WhereKeyword))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
ExpressionNode whereExpr;
if (FglExpressionNode.TryGetExpressionNode(parser, out whereExpr))
{
node.AppendExpression(whereExpr);
}
else
{
parser.ReportSyntaxError("Invalid expression in report aggregate function.");
}
}
break;
}
case TokenKind.SumKeyword:
case TokenKind.AvgKeyword:
case TokenKind.MinKeyword:
case TokenKind.MaxKeyword:
{
parser.NextToken();
if (node == null)
{
node = new TokenExpressionNode(parser.Token);
}
if (parser.PeekToken(TokenKind.LeftParenthesis))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
ExpressionNode expr;
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
node.AppendExpression(expr);
if (parser.PeekToken(TokenKind.RightParenthesis))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
}
else
{
parser.ReportSyntaxError("Expected right-paren in report aggregate function.");
}
}
else
{
parser.ReportSyntaxError("Invalid expression in report aggregate function.");
}
}
else
{
parser.ReportSyntaxError("Expected left-paren in report aggregate function.");
}
// get the optional where clause
if (parser.PeekToken(TokenKind.WhereKeyword))
{
parser.NextToken();
node.AppendExpression(new TokenExpressionNode(parser.Token));
ExpressionNode whereExpr;
if (FglExpressionNode.TryGetExpressionNode(parser, out whereExpr))
{
node.AppendExpression(whereExpr);
}
else
{
parser.ReportSyntaxError("Invalid expression in report aggregate function.");
}
}
break;
}
}
return(node);
}
private static bool TryGetReportStatement(IParser parser, out FglStatement node, ReportBlockNode reportNode, bool returnFalseInsteadOfErrors = false)
{
bool result = false;
node = null;
switch (parser.PeekToken().Kind)
{
case TokenKind.PrintKeyword:
{
PrintStatement prtStmt;
if ((result = PrintStatement.TryParseNode(parser, out prtStmt, reportNode)))
{
node = prtStmt;
}
break;
}
case TokenKind.PrintxKeyword:
{
PrintxStatement prtxStmt;
if ((result = PrintxStatement.TryParseNode(parser, out prtxStmt)))
{
node = prtxStmt;
}
break;
}
case TokenKind.NeedKeyword:
{
NeedStatement needStmt;
if ((result = NeedStatement.TryParseNode(parser, out needStmt)))
{
node = needStmt;
}
break;
}
case TokenKind.PauseKeyword:
{
PauseStatement pauseStmt;
if ((result = PauseStatement.TryParseNode(parser, out pauseStmt)))
{
node = pauseStmt;
}
break;
}
case TokenKind.SkipKeyword:
{
SkipStatement skipStmt;
if ((result = SkipStatement.TryParseNode(parser, out skipStmt)))
{
node = skipStmt;
}
break;
}
default:
result = false;
break;
}
return(result);
}
public static bool TryParseNode(Genero4glParser parser, out ReportBlockNode defNode, IModuleResult containingModule)
{
defNode = null;
bool result = false;
AccessModifier?accMod = null;
string accModToken = null;
if (parser.PeekToken(TokenKind.PublicKeyword))
{
accMod = AccessModifier.Public;
accModToken = parser.PeekToken().Value.ToString();
}
else if (parser.PeekToken(TokenKind.PrivateKeyword))
{
accMod = AccessModifier.Private;
accModToken = parser.PeekToken().Value.ToString();
}
uint lookAheadBy = (uint)(accMod.HasValue ? 2 : 1);
if (parser.PeekToken(TokenKind.ReportKeyword, lookAheadBy))
{
result = true;
defNode = new ReportBlockNode();
if (accMod.HasValue)
{
parser.NextToken();
defNode.AccessModifier = accMod.Value;
}
else
{
defNode.AccessModifier = AccessModifier.Public;
}
parser.NextToken(); // move past the Function keyword
defNode.StartIndex = parser.Token.Span.Start;
defNode.OrderVarNames = new List <FglNameExpression>();
// get the name
if (parser.PeekToken(TokenCategory.Keyword) || parser.PeekToken(TokenCategory.Identifier))
{
parser.NextToken();
defNode.Name = parser.Token.Token.Value.ToString();
defNode.LocationIndex = parser.Token.Span.Start;
defNode.DecoratorEnd = parser.Token.Span.End;
}
else
{
parser.ReportSyntaxError("A report must have a name.");
}
if (!parser.PeekToken(TokenKind.LeftParenthesis))
{
parser.ReportSyntaxError("A report must specify zero or more parameters in the form: ([param1][,...])");
}
else
{
parser.NextToken();
}
// get the parameters
while (parser.PeekToken(TokenCategory.Keyword) || parser.PeekToken(TokenCategory.Identifier))
{
parser.NextToken();
string errMsg;
if (!defNode.AddArgument(parser.Token, out errMsg))
{
parser.ReportSyntaxError(errMsg);
}
if (parser.PeekToken(TokenKind.Comma))
{
parser.NextToken();
}
// TODO: probably need to handle "end" "function" case...won't right now
}
if (!parser.PeekToken(TokenKind.RightParenthesis))
{
parser.ReportSyntaxError("A report must specify zero or more parameters in the form: ([param1][,...])");
}
else
{
parser.NextToken();
}
List <List <TokenKind> > breakSequences =
new List <List <TokenKind> >(Genero4glAst.ValidStatementKeywords
.Where(x => x != TokenKind.EndKeyword && x != TokenKind.ReportKeyword)
.Select(x => new List <TokenKind> {
x
}))
{
new List <TokenKind> {
TokenKind.EndKeyword, TokenKind.ReportKeyword
},
new List <TokenKind> {
TokenKind.OutputKeyword
},
new List <TokenKind> {
TokenKind.OrderKeyword
},
new List <TokenKind> {
TokenKind.FormatKeyword
}
};
while (!parser.PeekToken(TokenKind.EndOfFile) &&
!(parser.PeekToken(TokenKind.EndKeyword) && parser.PeekToken(TokenKind.ReportKeyword, 2)))
{
DefineNode defineNode;
TypeDefNode typeNode;
ConstantDefNode constNode;
bool matchedBreakSequence = false;
bool inDefSection = true;
switch (parser.PeekToken().Kind)
{
case TokenKind.TypeKeyword:
{
if (TypeDefNode.TryParseNode(parser, out typeNode, out matchedBreakSequence, breakSequences) && typeNode != null)
{
defNode.Children.Add(typeNode.StartIndex, typeNode);
foreach (var def in typeNode.GetDefinitions())
{
def.Scope = "local type";
if (!defNode.Types.ContainsKey(def.Name))
{
defNode.Types.Add(def.Name, def);
}
else
{
parser.ReportSyntaxError(def.LocationIndex, def.LocationIndex + def.Name.Length, string.Format("Type {0} defined more than once.", def.Name), Severity.Error);
}
}
}
break;
}
case TokenKind.ConstantKeyword:
{
if (ConstantDefNode.TryParseNode(parser, out constNode, out matchedBreakSequence, breakSequences) && constNode != null)
{
defNode.Children.Add(constNode.StartIndex, constNode);
foreach (var def in constNode.GetDefinitions())
{
def.Scope = "local constant";
if (!defNode.Constants.ContainsKey(def.Name))
{
defNode.Constants.Add(def.Name, def);
}
else
{
parser.ReportSyntaxError(def.LocationIndex, def.LocationIndex + def.Name.Length, string.Format("Constant {0} defined more than once.", def.Name), Severity.Error);
}
}
}
break;
}
case TokenKind.DefineKeyword:
{
if (DefineNode.TryParseDefine(parser, out defineNode, out matchedBreakSequence, breakSequences, defNode.BindArgument) && defineNode != null)
{
defNode.Children.Add(defineNode.StartIndex, defineNode);
foreach (var def in defineNode.GetDefinitions())
{
foreach (var vardef in def.VariableDefinitions)
{
vardef.Scope = "local variable";
if (!defNode.Variables.ContainsKey(vardef.Name))
{
defNode.Variables.Add(vardef.Name, vardef);
}
else
{
parser.ReportSyntaxError(vardef.LocationIndex, vardef.LocationIndex + vardef.Name.Length, string.Format("Variable {0} defined more than once.", vardef.Name), Severity.Error);
}
}
}
}
break;
}
default:
inDefSection = false;
break;
}
if (!inDefSection)
{
break;
}
}
if (parser.PeekToken(TokenKind.OutputKeyword))
{
parser.NextToken();
bool isValid = true;
ExpressionNode expr;
while (isValid)
{
if (parser.PeekToken(TokenKind.ReportKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.ToKeyword))
{
parser.NextToken();
switch (parser.PeekToken().Kind)
{
case TokenKind.ScreenKeyword:
case TokenKind.PrinterKeyword:
parser.NextToken();
break;
case TokenKind.FileKeyword:
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.OutputFilename = expr;
}
else
{
parser.ReportSyntaxError("Invalid filename found in report.");
}
break;
case TokenKind.PipeKeyword:
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.OutputProgram = expr;
}
else
{
parser.ReportSyntaxError("Invalid program name found in report.");
}
if (parser.PeekToken(TokenKind.InKeyword))
{
parser.NextToken();
if ((parser.PeekToken(TokenKind.FormKeyword) || parser.PeekToken(TokenKind.LineKeyword)) &&
parser.PeekToken(TokenKind.ModeKeyword, 2))
{
parser.NextToken();
parser.NextToken();
}
else
{
parser.ReportSyntaxError("Expected \"form mode\" or \"line mode\" in report.");
}
}
break;
default:
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.OutputFilename = expr;
}
else
{
parser.ReportSyntaxError("Invalid filename found in report.");
}
break;
}
}
else
{
parser.ReportSyntaxError("Expected \"to\" keyword in report.");
}
}
switch (parser.PeekToken().Kind)
{
case TokenKind.WithKeyword:
parser.NextToken();
break;
case TokenKind.LeftKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.MarginKeyword))
{
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.MarginLeft = expr;
}
else
{
parser.ReportSyntaxError("Invalid margin value found in report.");
}
}
else
{
parser.ReportSyntaxError("Expected \"margin\" keyword in report.");
}
break;
case TokenKind.RightKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.MarginKeyword))
{
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.MarginRight = expr;
}
else
{
parser.ReportSyntaxError("Invalid margin value found in report.");
}
}
else
{
parser.ReportSyntaxError("Expected \"margin\" keyword in report.");
}
break;
case TokenKind.BottomKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.MarginKeyword))
{
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.MarginBottom = expr;
}
else
{
parser.ReportSyntaxError("Invalid margin value found in report.");
}
}
else
{
parser.ReportSyntaxError("Expected \"margin\" keyword in report.");
}
break;
case TokenKind.PageKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.LengthKeyword))
{
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.PageLength = expr;
}
else
{
parser.ReportSyntaxError("Invalid page length value found in report.");
}
}
else
{
parser.ReportSyntaxError("Expected \"length\" keyword in report.");
}
break;
case TokenKind.TopKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.OfKeyword) && parser.PeekToken(TokenKind.PageKeyword, 2))
{
parser.NextToken();
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.TopOfPage = expr;
}
else
{
parser.ReportSyntaxError("Invalid top of page value found in report.");
}
}
else if (parser.PeekToken(TokenKind.MarginKeyword))
{
parser.NextToken();
if (FglExpressionNode.TryGetExpressionNode(parser, out expr))
{
defNode.MarginTop = expr;
}
else
{
parser.ReportSyntaxError("Invalid margin value found in report.");
}
}
else
{
parser.ReportSyntaxError("Invalid token found in report.");
}
break;
default:
isValid = false;
parser.ReportSyntaxError("Invalid token found in output section of report.");
break;
}
if (parser.PeekToken(TokenKind.OrderKeyword) ||
parser.PeekToken(TokenKind.FormatKeyword) ||
parser.PeekToken(TokenKind.EndOfFile) ||
(parser.PeekToken(TokenKind.EndKeyword) && parser.PeekToken(TokenKind.ReportKeyword, 2)))
{
break;
}
}
}
if (parser.PeekToken(TokenKind.OrderKeyword))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.ExternalKeyword))
{
parser.NextToken();
}
if (parser.PeekToken(TokenKind.ByKeyword))
{
parser.NextToken();
}
else
{
parser.ReportSyntaxError("Expected \"by\" keyword in order section of report.");
}
// collect report variables
FglNameExpression varName;
while (FglNameExpression.TryParseNode(parser, out varName))
{
defNode.OrderVarNames.Add(varName);
if (parser.PeekToken(TokenKind.AscKeyword) || parser.PeekToken(TokenKind.DescKeyword))
{
parser.NextToken();
}
if (parser.PeekToken(TokenKind.Comma))
{
parser.NextToken();
}
else
{
break;
}
}
}
List <TokenKind> validExits = new List <TokenKind> {
TokenKind.ProgramKeyword, TokenKind.ReportKeyword
};
ReportFormatSection rfs;
while (ReportFormatSection.TryParseNode(parser, out rfs, containingModule, defNode, null, defNode.StoreReturnStatement,
defNode.AddLimitedScopeVariable, validExits) && rfs != null)
{
defNode.Children.Add(rfs.StartIndex, rfs);
if (parser.PeekToken(TokenKind.EndOfFile) ||
(parser.PeekToken(TokenKind.EndKeyword) && parser.PeekToken(TokenKind.ReportKeyword, 2)))
{
break;
}
}
if (!parser.PeekToken(TokenKind.EndOfFile))
{
parser.NextToken();
if (parser.PeekToken(TokenKind.ReportKeyword))
{
parser.NextToken();
defNode.EndIndex = parser.Token.Span.End;
defNode.IsComplete = true;
defNode.AddLimitedScopeVariable(Genero4glAst.PagenoVariable, defNode.StartIndex, defNode.EndIndex);
}
else
{
parser.ReportSyntaxError(parser.Token.Span.Start, parser.Token.Span.End, "Invalid end of report definition.");
}
}
else
{
parser.ReportSyntaxError("Unexpected end of report definition");
}
}
return(result);
}
public static bool TryParseNode(Genero4glParser parser, out ReportFormatSection node,
IModuleResult containingModule,
ReportBlockNode reportNode,
Action <PrepareStatement> prepStatementBinder = null,
Func <ReturnStatement, ParserResult> returnStatementBinder = null,
Action <IAnalysisResult, int, int> limitedScopeVariableAdder = null,
List <TokenKind> validExitKeywords = null,
IEnumerable <ContextStatementFactory> contextStatementFactories = null)
{
node = null;
bool result = false;
if (parser.PeekToken(TokenKind.FormatKeyword))
{
parser.NextToken();
result = true;
node = new ReportFormatSection();
node.StartIndex = parser.Token.Span.Start;
bool isValid = true;
while (isValid)
{
if (parser.PeekToken(TokenKind.EveryKeyword) && parser.PeekToken(TokenKind.RowKeyword, 2))
{
parser.NextToken();
parser.NextToken();
node._canOutline = false;
}
else
{
node._canOutline = true;
switch (parser.PeekToken().Kind)
{
case TokenKind.FirstKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.PageKeyword) && parser.PeekToken(TokenKind.HeaderKeyword, 2))
{
parser.NextToken();
parser.NextToken();
if (node.DecoratorEnd == 0)
{
node.DecoratorEnd = parser.Token.Span.End;
}
}
else
{
parser.ReportSyntaxError("Expected \"page header\" in format section of report.");
}
break;
case TokenKind.PageKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.HeaderKeyword))
{
parser.NextToken();
if (node.DecoratorEnd == 0)
{
node.DecoratorEnd = parser.Token.Span.End;
}
}
else if (parser.PeekToken(TokenKind.TrailerKeyword))
{
parser.NextToken();
if (node.DecoratorEnd == 0)
{
node.DecoratorEnd = parser.Token.Span.End;
}
}
else
{
parser.ReportSyntaxError("Expected \"header\" or \"trailer\" in format section of report.");
}
break;
case TokenKind.OnKeyword:
parser.NextToken();
if ((parser.PeekToken(TokenKind.EveryKeyword) || parser.PeekToken(TokenKind.LastKeyword)) &&
parser.PeekToken(TokenKind.RowKeyword, 2))
{
parser.NextToken();
parser.NextToken();
if (node.DecoratorEnd == 0)
{
node.DecoratorEnd = parser.Token.Span.End;
}
}
else
{
parser.ReportSyntaxError("Expected \"every row\" or \"last row\" in format section of report.");
}
break;
case TokenKind.BeforeKeyword:
case TokenKind.AfterKeyword:
parser.NextToken();
if (parser.PeekToken(TokenKind.GroupKeyword) &&
parser.PeekToken(TokenKind.OfKeyword, 2))
{
parser.NextToken();
parser.NextToken();
// TODO: get report variable
FglNameExpression name;
if (FglNameExpression.TryParseNode(parser, out name))
{
node.ReportVariable = name;
}
else
{
parser.ReportSyntaxError("Invalid name expression found in format section of report.");
}
if (node.DecoratorEnd == 0)
{
node.DecoratorEnd = parser.Token.Span.End;
}
}
else
{
parser.ReportSyntaxError("Expected \"group of\" in format section of report.");
}
break;
default:
isValid = false;
break;
}
if (isValid)
{
// collect statements
FglStatement rptStmt;
while (ReportStatementFactory.TryGetStatement(parser, out rptStmt, containingModule, reportNode, new List <Func <PrepareStatement, bool> >(), returnStatementBinder,
limitedScopeVariableAdder, validExitKeywords) && rptStmt != null)
{
if (rptStmt.StartIndex < 0)
{
continue;
}
node.Children.Add(rptStmt.StartIndex, rptStmt);
}
}
}
node.EndIndex = parser.Token.Span.End;
}
}
return(result);
}
