示例#1
0
        public static bool TryParseNode(Genero4glParser parser, out DeclareStatement defNode, IModuleResult containingModule)
        {
            defNode = null;
            bool result = false;

            if (parser.PeekToken(TokenKind.DeclareKeyword))
            {
                result  = true;
                defNode = new DeclareStatement();
                parser.NextToken();
                defNode.StartIndex             = parser.Token.Span.Start;
                defNode._prepStatementResolver = containingModule.PreparedCursorResolver;

                if (parser.PeekToken(TokenCategory.Identifier) || parser.PeekToken(TokenCategory.Keyword))
                {
                    parser.NextToken();
                    defNode.Identifier = parser.Token.Token.Value.ToString();

                    if (parser.PeekToken(TokenKind.ScrollKeyword))
                    {
                        parser.NextToken();
                        defNode.Scroll = true;
                    }

                    if (parser.PeekToken(TokenKind.CursorKeyword))
                    {
                        parser.NextToken();

                        if (parser.PeekToken(TokenKind.WithKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.HoldKeyword))
                            {
                                parser.NextToken();
                                defNode.WithHold = true;
                            }
                            else
                            {
                                parser.ReportSyntaxError("SQL declare statement missing \"hold\" keyword.");
                            }
                        }

                        if (parser.PeekToken(TokenKind.FromKeyword))
                        {
                            parser.NextToken();
                            // We have a string expression declare
                            ExpressionNode exprNode;
                            if (FglExpressionNode.TryGetExpressionNode(parser, out exprNode) /* && exprNode is StringExpressionNode*/ && exprNode != null)
                            {
                                defNode.Children.Add(exprNode.StartIndex, exprNode);
                                defNode.EndIndex = exprNode.EndIndex;

                                containingModule.BindCursorResult(defNode, parser);
                            }
                            else
                            {
                                parser.ReportSyntaxError("String expression not found for SQl declare statement");
                            }
                        }
                        else if (parser.PeekToken(TokenKind.ForKeyword))
                        {
                            parser.NextToken();
                            if (parser.PeekToken(TokenKind.SqlKeyword))
                            {
                                // we have a sql block declare
                                SqlBlockNode sqlBlock;
                                if (SqlBlockNode.TryParseSqlNode(parser, out sqlBlock) && sqlBlock != null)
                                {
                                    defNode.Children.Add(sqlBlock.StartIndex, sqlBlock);
                                    defNode.EndIndex   = sqlBlock.EndIndex;
                                    defNode.IsComplete = true;
                                    containingModule.BindCursorResult(defNode, parser);
                                }
                            }
                            else if (parser.PeekToken(TokenKind.SelectKeyword))
                            {
                                // we have a static sql select statement
                                FglStatement sqlStmt;
                                bool         dummy;
                                if (SqlStatementFactory.TryParseSqlStatement(parser, out sqlStmt, out dummy, TokenKind.SelectKeyword) && sqlStmt != null)
                                {
                                    defNode.Children.Add(sqlStmt.StartIndex, sqlStmt);
                                    defNode.EndIndex   = sqlStmt.EndIndex;
                                    defNode.IsComplete = true;
                                    containingModule.BindCursorResult(defNode, parser);
                                }
                                else
                                {
                                    parser.ReportSyntaxError("Static SQL declare statement must specify a SELECT statement.");
                                }
                            }
                            else if (parser.PeekToken(TokenCategory.Identifier) || parser.PeekToken(TokenCategory.Keyword))
                            {
                                // we have a prepared statment
                                parser.NextToken();
                                defNode.PreparedStatementId = parser.Token.Token.Value.ToString();
                                defNode.EndIndex            = parser.Token.Span.End;
                                defNode.IsComplete          = true;
                                containingModule.BindCursorResult(defNode, parser);
                            }
                            else
                            {
                                parser.ReportSyntaxError("Invalid token found in SQL declare statment.");
                            }
                        }
                        else
                        {
                            parser.ReportSyntaxError("SQL declare statement must have either \"for\" or \"from\" keyword.");
                        }
                    }
                    else
                    {
                        parser.ReportSyntaxError("SQL declare statement missing \"cursor\" keyword.");
                    }
                }
                else
                {
                    parser.ReportSyntaxError("SQL declare statement must specify an identifier to declare.");
                }
            }

            return(result);
        }
示例#2
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);
        }