Exemple #1
0
        private static bool TryGetMenuStatement(Genero4glParser parser, out MenuStatement node, bool returnFalseInsteadOfErrors = false)
        {
            bool result = false;

            node = null;

            MenuStatement menuStmt;

            if ((result = MenuStatement.TryParseNode(parser, out menuStmt, returnFalseInsteadOfErrors)))
            {
                node = menuStmt;
            }

            return(result);
        }
Exemple #2
0
        public static bool TryParseNode(Genero4glParser parser, out MenuStatement node, bool returnFalseInsteadOfErrors = false)
        {
            node             = new MenuStatement();
            node.StartIndex  = parser.Token.Span.Start;
            node.OptionNames = new List <ExpressionNode>();
            bool result = true;

            switch (parser.PeekToken().Kind)
            {
            case TokenKind.ContinueKeyword:
            case TokenKind.ExitKeyword:
            {
                if (parser.PeekToken(TokenKind.MenuKeyword, 2))
                {
                    parser.NextToken();
                    node.StartIndex = parser.Token.Span.Start;
                    parser.NextToken();
                }
                else
                {
                    result = false;
                }
                break;
            }

            case TokenKind.NextKeyword:
            {
                parser.NextToken();
                if (parser.PeekToken(TokenKind.OptionKeyword))
                {
                    parser.NextToken();
                    FglNameExpression nameExpr;
                    if (FglNameExpression.TryParseNode(parser, out nameExpr))
                    {
                        node.OptionNames.Add(nameExpr);
                    }
                    else
                    {
                        parser.ReportSyntaxError("Invalid option name found in menu statement.");
                    }
                }
                else
                {
                    if (!returnFalseInsteadOfErrors)
                    {
                        parser.ReportSyntaxError("Expecting \"option\" keyword in menu statement.");
                    }
                    else
                    {
                        return(false);
                    }
                }

                break;
            }

            case TokenKind.ShowKeyword:
            case TokenKind.HideKeyword:
            {
                parser.NextToken();
                if (parser.PeekToken(TokenKind.OptionKeyword))
                {
                    parser.NextToken();
                    if (parser.PeekToken(TokenKind.AllKeyword))
                    {
                        parser.NextToken();
                    }
                    else
                    {
                        FglNameExpression nameExpr;
                        ExpressionNode    strExpr;
                        while (true)
                        {
                            if (FglNameExpression.TryParseNode(parser, out nameExpr))
                            {
                                node.OptionNames.Add(nameExpr);
                            }
                            else if (parser.PeekToken(TokenCategory.StringLiteral) &&
                                     FglExpressionNode.TryGetExpressionNode(parser, out strExpr, new List <TokenKind> {
                                    TokenKind.Comma
                                }))
                            {
                                node.OptionNames.Add(strExpr);
                            }
                            else
                            {
                                break;
                            }
                            if (!parser.PeekToken(TokenKind.Comma))
                            {
                                break;
                            }
                            parser.NextToken();
                        }
                    }
                }
                else
                {
                    if (!returnFalseInsteadOfErrors)
                    {
                        parser.ReportSyntaxError("Expecting \"option\" keyword in menu statement.");
                    }
                    else
                    {
                        return(false);
                    }
                }
                break;
            }

            default:
            {
                result = false;
                break;
            }
            }

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

            return(result);
        }