public static bool TryParseNode(Genero4glParser parser, out DeclarativeDialogBlock node, IModuleResult containingModule) { node = 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.DialogKeyword, lookAheadBy)) { result = true; node = new DeclarativeDialogBlock(); if (accMod.HasValue) { parser.NextToken(); node.AccessModifier = accMod.Value; } else { node.AccessModifier = AccessModifier.Public; } parser.NextToken(); // move past the Function keyword node.StartIndex = parser.Token.Span.Start; // get the name if (parser.PeekToken(TokenCategory.Keyword) || parser.PeekToken(TokenCategory.Identifier)) { parser.NextToken(); node.Name = parser.Token.Token.Value.ToString(); node.LocationIndex = parser.Token.Span.Start; node.DecoratorEnd = parser.Token.Span.End; } else { parser.ReportSyntaxError("A declarative dialog must have a name."); } if (!parser.PeekToken(TokenKind.LeftParenthesis)) { parser.ReportSyntaxError("A declarative dialog 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 (!node.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 declarative dialog must specify zero or more parameters in the form: ([param1][,...])"); } else { parser.NextToken(); } List <List <TokenKind> > breakSequences = new List <List <TokenKind> > { new List <TokenKind> { TokenKind.InputKeyword }, new List <TokenKind> { TokenKind.ConstructKeyword }, new List <TokenKind> { TokenKind.DisplayKeyword }, new List <TokenKind> { TokenKind.EndKeyword, TokenKind.DialogKeyword } }; // only defines are allowed in declarative dialogs DefineNode defineNode; bool matchedBreakSequence = false; while (DefineNode.TryParseDefine(parser, out defineNode, out matchedBreakSequence, breakSequences) && defineNode != null) { node.Children.Add(defineNode.StartIndex, defineNode); foreach (var def in defineNode.GetDefinitions()) { foreach (var vardef in def.VariableDefinitions) { vardef.Scope = "local variable"; if (!node.Variables.ContainsKey(vardef.Name)) { node.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); } } } if (parser.PeekToken(TokenKind.EndOfFile) || (parser.PeekToken(TokenKind.EndKeyword) && parser.PeekToken(TokenKind.ReportKeyword, 2))) { break; } // if a break sequence was matched, we don't want to advance the token if (!matchedBreakSequence) { // TODO: not sure whether to break or keep going...for right now, let's keep going until we hit the end keyword parser.NextToken(); } } // we don't want the dialog piece itself to be outlinable, since it's a declarative block node.Dialog = new DialogBlock(false); node.Dialog.Attributes = new List <DialogAttribute>(); node.Dialog.Subdialogs = new List <FglNameExpression>(); List <Func <PrepareStatement, bool> > prepStatementBinders = new List <Func <PrepareStatement, bool> >(); prepStatementBinders.Insert(0, node.BindPrepareCursorFromIdentifier); DialogBlock.BuildDialogBlock(parser, node.Dialog, containingModule, prepStatementBinders); prepStatementBinders.RemoveAt(0); foreach (var child in node.Dialog.Children) { node.Children.Add(child.Key, child.Value); } if (!parser.PeekToken(TokenKind.EndOfFile)) { parser.NextToken(); if (parser.PeekToken(TokenKind.DialogKeyword)) { parser.NextToken(); node.EndIndex = parser.Token.Span.End; node.IsComplete = true; } else { parser.ReportSyntaxError(parser.Token.Span.Start, parser.Token.Span.End, "Invalid end of declarative dialog definition."); } } else { parser.ReportSyntaxError("Unexpected end of declarative dialog definition"); } } 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); }