Пример #1
0
        public static bool TryParseNode(IParser parser, out SkipStatement node)
        {
            node = null;
            bool result = false;

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

                if (parser.PeekToken(TokenKind.ToKeyword))
                {
                    parser.NextToken();
                    if (parser.PeekToken(TokenKind.TopKeyword) &&
                        parser.PeekToken(TokenKind.OfKeyword, 2) &&
                        parser.PeekToken(TokenKind.PageKeyword, 3))
                    {
                        parser.NextToken();
                        parser.NextToken();
                        parser.NextToken();
                    }
                    else
                    {
                        parser.ReportSyntaxError("Expected \"top of page\" in skip statement.");
                    }
                }
                else
                {
                    ExpressionNode numLines;
                    if (FglExpressionNode.TryGetExpressionNode(parser, out numLines))
                    {
                        node.NumLines = numLines;
                    }
                    else
                    {
                        parser.ReportSyntaxError("Invalid expression found in skip statement.");
                    }

                    if (parser.PeekToken(TokenKind.LineKeyword) || parser.PeekToken(TokenKind.LinesKeyword))
                    {
                        parser.NextToken();
                    }
                }

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

            return(result);
        }
Пример #2
0
        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);
        }