コード例 #1
0
ファイル: InputNode.cs プロジェクト: JacobMisirian/TiBASIC
        public static InputNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "Input");
            ArgListNode variables = ArgListNode.Parse(parser);

            return new InputNode(variables);
        }
コード例 #2
0
ファイル: PrgmNode.cs プロジェクト: JacobMisirian/TiBASIC
        public static PrgmNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "Prgm");
            string prgmPath = parser.ExpectToken(TokenType.String).Value;

            return new PrgmNode(prgmPath);
        }
コード例 #3
0
ファイル: DispNode.cs プロジェクト: JacobMisirian/TiBASIC
        /// <summary>
        /// Parse the specified parser.
        /// </summary>
        /// <param name="parser">Parser.</param>
        public static DispNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "Disp");
            ArgListNode args = ArgListNode.Parse(parser);

            return new DispNode(args);
        }
コード例 #4
0
 /// <summary>
 /// Parse the specified parser.
 /// </summary>
 /// <param name="parser">Parser.</param>
 public static AstNode Parse(Parser parser)
 {
     if (parser.MatchToken(TokenType.Identifier, "If"))
         return ConditionalNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "While"))
         return WhileNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "Repeat"))
         return RepeatNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "For"))
         return ForNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "Disp"))
         return DispNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "Input"))
         return InputNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "Prompt"))
         return PromptNode.Parse(parser);
     else if (parser.MatchToken(TokenType.Identifier, "Prgm"))
         return PrgmNode.Parse(parser);
     else if (parser.AcceptToken(TokenType.Identifier, "Lbl"))
         return new LblNode(parser.ExpectToken(TokenType.Identifier).Value);
     else if (parser.AcceptToken(TokenType.Identifier, "Goto"))
         return new GotoNode(parser.ExpectToken(TokenType.Identifier).Value);
     else
         return ExpressionNode.Parse(parser);
 }
コード例 #5
0
 private static AstNode parseAdditive(Parser parser)
 {
     AstNode left = parseMultiplicitive(parser);
     while (parser.MatchToken(TokenType.Operation) || parser.MatchToken(TokenType.Identifier, "and") || parser.MatchToken(TokenType.Identifier, "or"))
     {
         switch ((string)parser.CurrentToken().Value)
         {
             case "+":
                 parser.AcceptToken(TokenType.Operation);
                 left = new BinaryOpNode(BinaryOperation.Addition, left, parseMultiplicitive(parser));
                 continue;
             case "-":
                 parser.AcceptToken(TokenType.Operation);
                 left = new BinaryOpNode(BinaryOperation.Subtraction, left, parseMultiplicitive(parser));
                 continue;
             case "and":
                 parser.AcceptToken(TokenType.Identifier);
                 left = new BinaryOpNode(BinaryOperation.And, left, parseMultiplicitive(parser));
                 continue;
             case "or":
                 parser.AcceptToken(TokenType.Identifier);
                 left = new BinaryOpNode(BinaryOperation.Or, left, parseMultiplicitive(parser));
                 continue;
             default:
                 break;
         }
         break;
     }
     return left;
 }
コード例 #6
0
ファイル: RepeatNode.cs プロジェクト: JacobMisirian/TiBASIC
        /// <summary>
        /// Parse the specified parser.
        /// </summary>
        /// <param name="parser">Parser.</param>
        public static RepeatNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "Repeat");
            AstNode predicate = ExpressionNode.Parse(parser);
            AstNode body = StatementNode.Parse(parser);

            return new RepeatNode(predicate, body);
        }
コード例 #7
0
ファイル: ArgListNode.cs プロジェクト: JacobMisirian/TiBASIC
 /// <summary>
 /// Parse the specified parser.
 /// </summary>
 /// <param name="parser">Parser.</param>
 public static ArgListNode Parse(Parser parser)
 {
     ArgListNode ret = new ArgListNode();
     ret.Children.Add(ExpressionNode.Parse(parser));
     while (parser.AcceptToken(TokenType.Comma))
         ret.Children.Add(ExpressionNode.Parse(parser));
     return ret;
 }
コード例 #8
0
        private static AstNode parseAssignment(Parser parser)
        {
            AstNode left = parseAdditive(parser);

            if (parser.AcceptToken(TokenType.Assignment))
                return new BinaryOpNode(BinaryOperation.Assignment, left, parseAssignment(parser));
            else
                return left;
        }
コード例 #9
0
        /// <summary>
        /// Parse the specified parser.
        /// </summary>
        /// <param name="parser">Parser.</param>
        public static AstNode Parse(Parser parser)
        {
            CodeBlockNode block = new CodeBlockNode();

            while (!parser.EndOfStream)
                block.Children.Add(StatementNode.Parse(parser));

            return block;
        }
コード例 #10
0
        /// <summary>
        /// Parse the specified parser.
        /// </summary>
        /// <param name="parser">Parser.</param>
        public static ConditionalNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "If");
            AstNode predicate = ExpressionNode.Parse(parser);
            AstNode body = StatementNode.Parse(parser);

            if (parser.MatchToken(TokenType.Identifier, "Else"))
                return new ConditionalNode(predicate, body, StatementNode.Parse(parser));
            return new ConditionalNode(predicate, body);
        }
コード例 #11
0
ファイル: ForNode.cs プロジェクト: JacobMisirian/TiBASIC
        public static ForNode Parse(Parser parser)
        {
            parser.ExpectToken(TokenType.Identifier, "For");
            parser.ExpectToken(TokenType.Parentheses, "(");
            string variable = parser.ExpectToken(TokenType.Identifier).Value;
            parser.ExpectToken(TokenType.Comma);
            AstNode start = ExpressionNode.Parse(parser);
            parser.ExpectToken(TokenType.Comma);
            AstNode end = ExpressionNode.Parse(parser);
            AstNode step = new NumberNode(1);
            if (parser.AcceptToken(TokenType.Comma))
                step = ExpressionNode.Parse(parser);
            parser.ExpectToken(TokenType.Parentheses, ")");
            AstNode body = StatementNode.Parse(parser);

            return new ForNode(variable, start, end, step, body);
        }
コード例 #12
0
 private static AstNode parseComparison(Parser parser)
 {
     AstNode left = parseFunctionCall(parser);
     while (parser.MatchToken(TokenType.Comparison))
     {
         switch ((string)parser.CurrentToken().Value)
         {
             case "=":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.Equal, left, parseFunctionCall(parser));
                 continue;
             case "!=":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.NotEqual, left, parseFunctionCall(parser));
                 continue;
             case ">":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.GreaterThan, left, parseFunctionCall(parser));
                 continue;
             case "<":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.LessThan, left, parseFunctionCall(parser));
                 continue;
             case ">=":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.GreaterThanOrEqual, left, parseFunctionCall(parser));
                 continue;
             case "<=":
                 parser.AcceptToken(TokenType.Comparison);
                 left = new BinaryOpNode(BinaryOperation.LessThanOrEqual, left, parseFunctionCall(parser));
                 continue;
             default:
                 break;
         }
         break;
     }
     return left;
 }
コード例 #13
0
 private static AstNode parseFunctionCall(Parser parser)
 {
     return parseFunctionCall(parser, parseTerm(parser));
 }
コード例 #14
0
 private static AstNode parseFunctionCall(Parser parser, AstNode left)
 {
     if (parser.MatchToken(TokenType.Parentheses, "("))
     {
         var functionCall = parseFunctionCall(parser, new FunctionCallNode(left, ArgListNode.Parse(parser)));
         //parser.ExpectToken(TokenType.Parentheses, ")");
         return functionCall;
     }
     else
         return left;
 }
コード例 #15
0
 private static AstNode parseMultiplicitive(Parser parser)
 {
     AstNode left = parseComparison(parser);
     while (parser.MatchToken(TokenType.Operation))
     {
         switch ((string)parser.CurrentToken().Value)
         {
             case "*":
                 parser.AcceptToken(TokenType.Operation);
                 left = new BinaryOpNode(BinaryOperation.Multiplication, left, parseComparison(parser));
                 continue;
             case "/":
                 parser.AcceptToken(TokenType.Operation);
                 left = new BinaryOpNode(BinaryOperation.Division, left, parseComparison(parser));
                 continue;
             case "%":
                 parser.AcceptToken(TokenType.Operation);
                 left = new BinaryOpNode(BinaryOperation.Modulus, left, parseComparison(parser));
                 continue;
             default:
                 break;
         }
         break;
     }
     return left;
 }
コード例 #16
0
 /// <summary>
 /// Parse the specified parser.
 /// </summary>
 /// <param name="parser">Parser.</param>
 public static AstNode Parse(Parser parser)
 {
     return parseAssignment(parser);
 }
コード例 #17
0
        private static AstNode parseTerm(Parser parser)
        {
            if (parser.MatchToken(TokenType.Number))
                return new NumberNode(Convert.ToDouble(parser.ExpectToken(TokenType.Number).Value));
            else if (parser.AcceptToken(TokenType.Parentheses, "("))
            {
                AstNode statement = ExpressionNode.Parse(parser);
                parser.ExpectToken(TokenType.Parentheses, ")");
                return statement;
            }
            else if (parser.MatchToken(TokenType.Identifier, "Then"))
            {
                CodeBlockNode block = new CodeBlockNode();
                parser.ExpectToken(TokenType.Identifier, "Then");

                while (!parser.EndOfStream && !parser.MatchToken(TokenType.Identifier, "EndIf") && !parser.MatchToken(TokenType.Identifier, "Else"))
                    block.Children.Add(StatementNode.Parse(parser));

                if (parser.MatchToken(TokenType.Identifier, "Else"))
                    return block;

                parser.ExpectToken(TokenType.Identifier, "EndIf");

                return block;
            }
            else if (parser.MatchToken(TokenType.Identifier, "Else"))
            {
                parser.ExpectToken(TokenType.Identifier, "Else");
                return StatementNode.Parse(parser);
            }
            else if (parser.MatchToken(TokenType.Identifier, "Do"))
            {
                CodeBlockNode block = new CodeBlockNode();
                parser.ExpectToken(TokenType.Identifier, "Do");

                while (!parser.EndOfStream && !parser.MatchToken(TokenType.Identifier, "End"))
                    block.Children.Add(StatementNode.Parse(parser));

                parser.ExpectToken(TokenType.Identifier, "End");

                return block;
            }
            else if (parser.MatchToken(TokenType.String))
                return new StringNode((string)parser.ExpectToken(TokenType.String).Value);
            else if (parser.MatchToken(TokenType.Identifier))
                return new IdentifierNode((string)parser.ExpectToken(TokenType.Identifier).Value);
            else
                throw new Exception("Unexpected " + parser.CurrentToken().TokenType + " in Parser: " + parser.CurrentToken().Value + ".");
        }