Example #1
0
        public Node ProcedureDeclaration()
        {
            Expect(TokenCategory.PROCEDURE);
            var procedure_node = new Procedure_Declaration()
            {
                AnchorToken = Expect(TokenCategory.IDENTIFIER)
            };
            Expect(TokenCategory.PARENTHESIS_OPEN);

            procedure_node.Add(new Parameter_Declaration()
            {
                ZeroOrMore(TokenCategory.IDENTIFIER, ParameterDeclaration)
            });

            Expect(TokenCategory.PARENTHESIS_CLOSE);

            var typeNode = Optional(TokenCategory.COLON, Type, true);
            if (typeNode == null)
            {
                typeNode = new VoidTypeNode();
            }
            procedure_node.Add(typeNode);

            Expect(TokenCategory.SEMICOLON);
            procedure_node.Add(Optional(TokenCategory.CONST, () =>
            {
                var node = new Constant_List()
                {
                    AnchorToken = Expect(TokenCategory.CONST)
                };
                node.Add(OneOrMore(TokenCategory.IDENTIFIER, ConstantDeclaration));
                return node;
            }));

            procedure_node.Add(Optional(TokenCategory.VAR, () =>
            {
                var node = new Variable_Declaration()
                {
                    AnchorToken = Expect(TokenCategory.VAR)
                };
                node.Add(OneOrMore(TokenCategory.IDENTIFIER, VariableDeclaration));
                return node;
            }));

            Expect(TokenCategory.BEGIN);

            procedure_node.Add(new Statement_List()
            {
                ZeroOrMore(firstOfStatement, Statement)
            });

            Expect(TokenCategory.END);
            Expect(TokenCategory.SEMICOLON);

            return procedure_node;
        }
Example #2
0
        public Node VariableDeclaration()
        {
            var varNode = new Variable_Declaration();

            varNode.AnchorToken = Expect(TokenCategory.VAR);

            while (CurrentToken == TokenCategory.IDENTIFIER)
            {
                var id1Node = new Identifier()
                {
                    AnchorToken = Expect(TokenCategory.IDENTIFIER)
                };
                while (CurrentToken == TokenCategory.COMMA)
                {
                    var commaNode = new Identifier()
                    {
                        AnchorToken = Expect(TokenCategory.COMMA)
                    };
                    var id2Node = new Identifier()
                    {
                        AnchorToken = Expect(TokenCategory.IDENTIFIER)
                    };

                    commaNode.Add(id1Node);
                    commaNode.Add(id2Node);

                    id1Node = commaNode;
                }
                var declNode = new Identifier()
                {
                    AnchorToken = Expect(TokenCategory.DECL)
                };
                declNode.Add(id1Node);
                declNode.Add(Type());

                Expect(TokenCategory.EOL);
                varNode.Add(declNode);
            }

            return(varNode);
        }