示例#1
0
        public bool TryParseNode(Genero4glParser parser,
                                 out FglStatement node,
                                 IModuleResult containingModule,
                                 List <Func <PrepareStatement, bool> > prepStatementBinders,
                                 Func <ReturnStatement, ParserResult> returnStatementBinder   = null,
                                 Action <IAnalysisResult, int, int> limitedScopeVariableAdder = null,
                                 bool returnStatementsOnly          = false,
                                 List <TokenKind> validExitKeywords = null,
                                 IEnumerable <ContextStatementFactory> contextStatementFactories = null,
                                 ExpressionParsingOptions expressionOptions = null,
                                 HashSet <TokenKind> endKeywords            = null)
        {
            node = null;
            bool result = false;

            if (returnStatementsOnly)
            {
                if (parser.PeekToken(TokenKind.ReturnKeyword))
                {
                    ReturnStatement retStmt;
                    if ((result = ReturnStatement.TryParseNode(parser, out retStmt)))
                    {
                        node = retStmt;
                    }
                }
                return(result);
            }

            if (contextStatementFactories != null)
            {
                foreach (var context in contextStatementFactories)
                {
                    node = context(parser);
                    if (node != null)
                    {
                        break;
                    }
                }
                if (node != null)
                {
                    return(true);
                }
            }

            switch (parser.PeekToken().Kind)
            {
            case TokenKind.LetKeyword:
            {
                LetStatement letStmt;
                if ((result = LetStatement.TryParseNode(parser, out letStmt, expressionOptions)))
                {
                    node = letStmt;
                }
                break;
            }

            case TokenKind.DeclareKeyword:
            {
                DeclareStatement declStmt;
                if ((result = DeclareStatement.TryParseNode(parser, out declStmt, containingModule)))
                {
                    node = declStmt;
                }
                break;
            }

            case TokenKind.DeferKeyword:
            {
                DeferStatementNode deferStmt;
                if ((result = DeferStatementNode.TryParseNode(parser, out deferStmt)))
                {
                    node = deferStmt;
                }
                break;
            }

            case TokenKind.PrepareKeyword:
            {
                PrepareStatement prepStmt;
                if ((result = PrepareStatement.TryParseNode(parser, out prepStmt, containingModule)))
                {
                    node = prepStmt;
                    foreach (var binder in prepStatementBinders)
                    {
                        if (binder(prepStmt))
                        {
                            break;
                        }
                    }
                }
                break;
            }

            case TokenKind.SqlKeyword:
            {
                SqlBlockNode sqlStmt;
                if ((result = SqlBlockNode.TryParseSqlNode(parser, out sqlStmt)))
                {
                    node = sqlStmt;
                }
                break;
            }

            case TokenKind.ReturnKeyword:
            {
                ReturnStatement retStmt;
                if ((result = ReturnStatement.TryParseNode(parser, out retStmt)))
                {
                    if (returnStatementBinder != null)
                    {
                        var parseResult = returnStatementBinder(retStmt);
                        if (!parseResult.Success && !string.IsNullOrWhiteSpace(parseResult.ErrorMessage))
                        {
                            parser.ReportSyntaxError(parseResult.ErrorMessage);
                        }
                    }
                    node = retStmt;
                }
                break;
            }

            case TokenKind.CallKeyword:
            {
                CallStatement callStmt;
                if ((result = CallStatement.TryParseNode(parser, out callStmt)))
                {
                    node = callStmt;
                }
                break;
            }

            case TokenKind.IfKeyword:
            {
                IfStatement ifStmt;
                if ((result = IfStatement.TryParseNode(parser, out ifStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                       limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, expressionOptions, endKeywords)))
                {
                    node = ifStmt;
                }
                break;
            }

            case TokenKind.WhileKeyword:
            {
                WhileStatement whileStmt;
                if ((result = WhileStatement.TryParseNode(parser, out whileStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                          limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, expressionOptions, endKeywords)))
                {
                    node = whileStmt;
                }
                break;
            }

            case TokenKind.ExitKeyword:
            {
                ExitStatement exitStatement;
                if ((result = ExitStatement.TryParseNode(parser, out exitStatement)))
                {
                    node = exitStatement;
                }
                break;
            }

            case TokenKind.ContinueKeyword:
            {
                ContinueStatement contStmt;
                if ((result = ContinueStatement.TryParseNode(parser, out contStmt)))
                {
                    node = contStmt;
                }
                break;
            }

            case TokenKind.WheneverKeyword:
            {
                WheneverStatement wheneverStmt;
                if ((result = WheneverStatement.TryParseNode(parser, out wheneverStmt)))
                {
                    node = wheneverStmt;
                }
                break;
            }

            case TokenKind.ForKeyword:
            {
                ForStatement forStmt;
                if ((result = ForStatement.TryParserNode(parser, out forStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                         limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, expressionOptions, endKeywords)))
                {
                    node = forStmt;
                }
                break;
            }

            case TokenKind.CaseKeyword:
            {
                CaseStatement caseStmt;
                if ((result = CaseStatement.TryParseNode(parser, out caseStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                         limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, expressionOptions, endKeywords)))
                {
                    node = caseStmt;
                }
                break;
            }

            case TokenKind.InitializeKeyword:
            {
                InitializeStatement initStmt;
                if ((result = InitializeStatement.TryParseNode(parser, out initStmt)))
                {
                    node = initStmt;
                }
                break;
            }

            case TokenKind.LocateKeyword:
            {
                LocateStatement locateStmt;
                if ((result = LocateStatement.TryParseNode(parser, out locateStmt)))
                {
                    node = locateStmt;
                }
                break;
            }

            case TokenKind.FreeKeyword:
            {
                FreeStatement freeStmt;
                if ((result = FreeStatement.TryParseNode(parser, out freeStmt)))
                {
                    node = freeStmt;
                }
                break;
            }

            case TokenKind.GotoKeyword:
            {
                GotoStatement gotoStmt;
                if ((result = GotoStatement.TryParseNode(parser, out gotoStmt)))
                {
                    node = gotoStmt;
                }
                break;
            }

            case TokenKind.LabelKeyword:
            {
                LabelStatement labelStmt;
                if ((result = LabelStatement.TryParseNode(parser, out labelStmt)))
                {
                    node = labelStmt;
                }
                break;
            }

            case TokenKind.SleepKeyword:
            {
                SleepStatement sleepStmt;
                if ((result = SleepStatement.TryParseNode(parser, out sleepStmt)))
                {
                    node = sleepStmt;
                }
                break;
            }

            case TokenKind.TryKeyword:
            {
                TryCatchStatement tryStmt;
                if ((result = TryCatchStatement.TryParseNode(parser, out tryStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                             limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = tryStmt;
                }
                break;
            }

            case TokenKind.ValidateKeyword:
            {
                ValidateStatement validateStmt;
                if ((result = ValidateStatement.TryParseNode(parser, out validateStmt)))
                {
                    node = validateStmt;
                }
                break;
            }

            case TokenKind.OptionsKeyword:
            {
                OptionsStatement optionsStmt;
                if ((result = OptionsStatement.TryParseNode(parser, out optionsStmt)))
                {
                    node = optionsStmt;
                }
                break;
            }

            case TokenKind.ExecuteKeyword:
            {
                ExecuteStatement exeStmt;
                if ((result = ExecuteStatement.TryParseNode(parser, out exeStmt)))
                {
                    node = exeStmt;
                }
                break;
            }

            case TokenKind.OpenKeyword:
            {
                OpenStatement openStmt;
                if ((result = OpenStatement.TryParseNode(parser, out openStmt)))
                {
                    node = openStmt;
                }
                break;
            }

            case TokenKind.FetchKeyword:
            {
                FetchStatement fetchStmt;
                if ((result = FetchStatement.TryParseNode(parser, out fetchStmt)))
                {
                    node = fetchStmt;
                }
                break;
            }

            case TokenKind.CloseKeyword:
            {
                CloseStatement closeStmt;
                if ((result = CloseStatement.TryParseNode(parser, out closeStmt)))
                {
                    node = closeStmt;
                }
                break;
            }

            case TokenKind.ClearKeyword:
            {
                ClearStatement clearStmt;
                if ((result = ClearStatement.TryParseNode(parser, out clearStmt)))
                {
                    node = clearStmt;
                }
                break;
            }

            case TokenKind.ForeachKeyword:
            {
                ForeachStatement foreachStmt;
                if ((result = ForeachStatement.TryParseNode(parser, out foreachStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                            limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = foreachStmt;
                }
                break;
            }

            case TokenKind.MessageKeyword:
            {
                MessageStatement msgStmt;
                if ((result = MessageStatement.TryParseNode(parser, out msgStmt)))
                {
                    node = msgStmt;
                }
                break;
            }

            case TokenKind.MenuKeyword:
            {
                MenuBlock menuStmt;
                if ((result = MenuBlock.TryParseNode(parser, out menuStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                     limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = menuStmt;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.InputKeyword:
            {
                InputBlock inputStmt;
                if ((result = InputBlock.TryParseNode(parser, out inputStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                      limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = inputStmt;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.ConstructKeyword:
            {
                ConstructBlock constructStmt;
                if ((result = ConstructBlock.TryParseNode(parser, out constructStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                          limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = constructStmt;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.FlushKeyword:
            {
                FlushStatement flushStmt;
                if ((result = FlushStatement.TryParseNode(parser, out flushStmt)))
                {
                    node = flushStmt;
                }
                break;
            }

            case TokenKind.DisplayKeyword:
            {
                DisplayBlock dispStmt;
                if ((result = DisplayBlock.TryParseNode(parser, out dispStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                        limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = dispStmt;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.PromptKeyword:
            {
                PromptStatement promptStmt;
                if ((result = PromptStatement.TryParseNode(parser, out promptStmt, containingModule, prepStatementBinders, returnStatementBinder,
                                                           limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = promptStmt;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.DialogKeyword:
            {
                DialogBlock dialogBlock;
                if ((result = DialogBlock.TryParseNode(parser, out dialogBlock, containingModule, prepStatementBinders, returnStatementBinder,
                                                       limitedScopeVariableAdder, validExitKeywords, contextStatementFactories, endKeywords)))
                {
                    node = dialogBlock;
                    if (limitedScopeVariableAdder != null)
                    {
                        limitedScopeVariableAdder(Genero4glAst.DialogVariable, node.StartIndex, node.EndIndex);
                    }
                }
                break;
            }

            case TokenKind.AcceptKeyword:
            {
                AcceptStatement acceptStmt;
                if ((result = AcceptStatement.TryParseNode(parser, out acceptStmt)))
                {
                    node = acceptStmt;
                }
                break;
            }

            case TokenKind.LoadKeyword:
            {
                LoadStatement loadStmt;
                if ((result = LoadStatement.TryParseNode(parser, out loadStmt)))
                {
                    node = loadStmt;
                }
                break;
            }

            case TokenKind.CreateKeyword:
            {
                CreateStatement createStmt;
                if ((result = CreateStatement.TryParseNode(parser, out createStmt, containingModule)))
                {
                    node = createStmt;
                }
                break;
            }

            case TokenKind.BreakpointKeyword:
            {
                BreakpointStatement brkStmt;
                if ((result = BreakpointStatement.TryParseNode(parser, out brkStmt)))
                {
                    node = brkStmt;
                }
                break;
            }

            case TokenKind.OutputKeyword:
            {
                OutputToReportStatement outRpt;
                if ((result = OutputToReportStatement.TryParseNode(parser, out outRpt)))
                {
                    node = outRpt;
                }
                break;
            }

            case TokenKind.StartKeyword:
            {
                StartReportStatement startRpt;
                if ((result = StartReportStatement.TryParseNode(parser, out startRpt)))
                {
                    node = startRpt;
                }
                break;
            }

            case TokenKind.FinishKeyword:
            {
                FinishReportStatement finRpt;
                if ((result = FinishReportStatement.TryParseNode(parser, out finRpt)))
                {
                    node = finRpt;
                }
                break;
            }

            case TokenKind.TerminateKeyword:
            {
                TerminateReportStatement termRpt;
                if ((result = TerminateReportStatement.TryParseNode(parser, out termRpt)))
                {
                    node = termRpt;
                }
                break;
            }

            default:
            {
                if (SqlStatementFactory.IsValidStatementStart(parser.PeekToken().Kind))
                {
                    bool dummy;
                    result = SqlStatementFactory.TryParseSqlStatement(parser, out node, out dummy);
                }
                break;
            }
            }

            if (result)
            {
                // check for semicolon
                if (parser.PeekToken(TokenKind.Semicolon))
                {
                    parser.NextToken();
                }
            }

            return(result);
        }
示例#2
0
        public static bool TryParseNode(Genero4glParser parser, out OptionsStatement node)
        {
            node = null;
            bool result = false;

            if (parser.PeekToken(TokenKind.OptionsKeyword))
            {
                result = true;
                node   = new OptionsStatement();
                parser.NextToken();
                node.StartIndex = parser.Token.Span.Start;

                while (true)
                {
                    switch (parser.PeekToken().Kind)
                    {
                    case TokenKind.SqlKeyword:
                    {
                        parser.NextToken();
                        if (parser.PeekToken(TokenKind.InterruptKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.OnKeyword) || parser.PeekToken(TokenKind.OffKeyword))
                            {
                                parser.NextToken();
                            }
                            else
                            {
                                parser.ReportSyntaxError("Invalid token found in options sql interrupt statement.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("Invalid token found in options sql statement.");
                        }
                        break;
                    }

                    case TokenKind.InputKeyword:
                    {
                        parser.NextToken();
                        if (parser.PeekToken(TokenKind.NoKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.WrapKeyword))
                            {
                                parser.NextToken();
                            }
                            else
                            {
                                parser.ReportSyntaxError("Invalid token found in options input statement.");
                            }
                        }
                        else if (parser.PeekToken(TokenKind.AttributesKeyword) || parser.PeekToken(TokenKind.AttributeKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.LeftParenthesis))
                            {
                                parser.NextToken();
                                if (parser.PeekToken(TokenKind.LeftParenthesis))
                                {
                                    while (!parser.PeekToken(TokenKind.EndOfFile) && !parser.PeekToken(TokenKind.RightParenthesis))
                                    {
                                        parser.NextToken();
                                    }
                                    if (parser.PeekToken(TokenKind.RightParenthesis))
                                    {
                                        parser.NextToken();
                                    }
                                    else
                                    {
                                        parser.ReportSyntaxError("Expected rigt-paren in options input statement.");
                                    }
                                }
                                else
                                {
                                    parser.ReportSyntaxError("Expected left-paren in options input statement.");
                                }
                            }
                            else
                            {
                                parser.ReportSyntaxError("Expected left-paren in options input statement.");
                            }
                        }
                        break;
                    }

                    case TokenKind.DisplayKeyword:
                    {
                        if (parser.PeekToken(TokenKind.AttributesKeyword) || parser.PeekToken(TokenKind.AttributeKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.LeftParenthesis))
                            {
                                while (!parser.PeekToken(TokenKind.EndOfFile) && !parser.PeekToken(TokenKind.RightParenthesis))
                                {
                                    parser.NextToken();
                                }
                                if (parser.PeekToken(TokenKind.RightParenthesis))
                                {
                                    parser.NextToken();
                                }
                                else
                                {
                                    parser.ReportSyntaxError("Expected rigt-paren in options input statement.");
                                }
                            }
                            else
                            {
                                parser.ReportSyntaxError("Expected left-paren in options input statement.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("Invalid token found in options input statement.");
                        }
                        break;
                    }

                    case TokenKind.FieldKeyword:
                    {
                        parser.NextToken();
                        if (parser.PeekToken(TokenKind.OrderKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.ConstrainedKeyword) ||
                                parser.PeekToken(TokenKind.UnconstrainedKeyword) ||
                                parser.PeekToken(TokenKind.FormKeyword))
                            {
                                parser.NextToken();
                            }
                            else
                            {
                                parser.ReportSyntaxError("Expected one of keywords \"constrained\", \"unconstrained\", or \"form\" in options field statement.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("Expected keyword \"order\" in options field statement.");
                        }
                        break;
                    }

                    case TokenKind.InsertKeyword:
                    case TokenKind.DeleteKeyword:
                    case TokenKind.NextKeyword:
                    case TokenKind.PreviousKeyword:
                    case TokenKind.AcceptKeyword:
                    case TokenKind.HelpKeyword:
                    {
                        parser.NextToken();
                        if (parser.PeekToken(TokenKind.KeyKeyword))
                        {
                            parser.NextToken();
                            VirtualKey vKey;
                            if (!VirtualKey.TryGetKey(parser, out vKey))
                            {
                                parser.ReportSyntaxError("Invalid virtual key found in options statement.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("Expected keyword \"key\" in options statement.");
                        }
                        break;
                    }

                    case TokenKind.OnKeyword:
                    {
                        parser.NextToken();
                        if (parser.PeekToken(TokenKind.TerminateKeyword) &&
                            parser.PeekToken(TokenKind.SignalKeyword, 2) &&
                            parser.PeekToken(TokenKind.CallKeyword, 3))
                        {
                            parser.NextToken();
                            parser.NextToken();
                            parser.NextToken();
                            FglNameExpression funcName;
                            if (!FglNameExpression.TryParseNode(parser, out funcName))
                            {
                                parser.ReportSyntaxError("Invalid function name found in options statement.");
                            }
                        }
                        else if (parser.PeekToken(TokenKind.CloseKeyword) &&
                                 parser.PeekToken(TokenKind.ApplicationKeyword, 2) &&
                                 parser.PeekToken(TokenKind.CallKeyword, 3))
                        {
                            parser.NextToken();
                            parser.NextToken();
                            parser.NextToken();
                            FglNameExpression funcName;
                            if (!FglNameExpression.TryParseNode(parser, out funcName))
                            {
                                parser.ReportSyntaxError("Invalid function name found in options statement.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("Invalid token found in options statement.");
                        }
                        break;
                    }

                    default:
                    {
                        parser.ReportSyntaxError("Unsupported options statement found.");
                        break;
                    }
                    }

                    if (!parser.PeekToken(TokenKind.Comma))
                    {
                        break;
                    }
                    parser.NextToken();
                }

                node.EndIndex = parser.Token.Span.End;
            }

            return(result);
        }