wewparser.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# CAVEAT UTILITOR
#
# This file was automatically generated by TatSu.
#
#    https://pypi.python.org/pypi/tatsu/
#
# Any changes you make to it will be overwritten the next time
# the file is generated.


from __future__ import print_function, division, absolute_import, unicode_literals

from tatsu.buffering import Buffer
from tatsu.parsing import Parser
from tatsu.parsing import tatsumasu
from tatsu.util import re, generic_main  # noqa


KEYWORDS = {}  # type: ignore


class WewBuffer(Buffer):
    def __init__(
        self,
        text,
        whitespace=None,
        nameguard=None,
        comments_re='{~(\\n|.)*~}',
        eol_comments_re='\\/\\/.*?$',
        ignorecase=None,
        namechars='',
        **kwargs
    ):
        super(WewBuffer, self).__init__(
            text,
            whitespace=whitespace,
            nameguard=nameguard,
            comments_re=comments_re,
            eol_comments_re=eol_comments_re,
            ignorecase=ignorecase,
            namechars=namechars,
            **kwargs
        )


class WewParser(Parser):
    def __init__(
        self,
        whitespace=None,
        nameguard=None,
        comments_re='{~(\\n|.)*~}',
        eol_comments_re='\\/\\/.*?$',
        ignorecase=None,
        left_recursion=True,
        parseinfo=True,
        keywords=None,
        namechars='',
        buffer_class=WewBuffer,
        **kwargs
    ):
        if keywords is None:
            keywords = KEYWORDS
        super(WewParser, self).__init__(
            whitespace=whitespace,
            nameguard=nameguard,
            comments_re=comments_re,
            eol_comments_re=eol_comments_re,
            ignorecase=ignorecase,
            left_recursion=left_recursion,
            parseinfo=parseinfo,
            keywords=keywords,
            namechars=namechars,
            buffer_class=buffer_class,
            **kwargs
        )

    @tatsumasu()
    def _start_(self):  # noqa

        def block0():
            self._function_decl_()
        self._positive_closure(block0)
        self._check_eof()

    @tatsumasu()
    def _types_(self):  # noqa
        self._token('int')

    @tatsumasu()
    def _instance_types_(self):  # noqa
        self._types_()
        self.name_last_node('t')

        def block2():
            self._token('*')
        self._closure(block2)
        self.name_last_node('p')
        self.ast._define(
            ['p', 't'],
            []
        )

    @tatsumasu()
    def _typed_variable_(self):  # noqa
        self._instance_types_()
        self.name_last_node('type')
        self._identifier_()
        self.name_last_node('name')
        self.ast._define(
            ['name', 'type'],
            []
        )

    @tatsumasu()
    def _declaration_(self):  # noqa
        with self._choice():
            with self._option():
                self._instance_types_()
                self.name_last_node('type')
                self._identifier_()
                self.name_last_node('name')
                with self._optional():
                    self._token(':=')
                    self._expression_()
                    self.name_last_node('pt')
                self._token(';')
                self._constant('ident')
                self.name_last_node('ref')
            with self._option():
                self._instance_types_()
                self.name_last_node('type')
                self._identifier_()
                self.name_last_node('name')
                self._token('[')
                self._integer_()
                self.name_last_node('pt')
                self._token(']')
                self._token(';')
                self._constant('list')
                self.name_last_node('ref')
            self._error('no available options')
        self.ast._define(
            ['name', 'pt', 'ref', 'type'],
            []
        )

    @tatsumasu()
    def _function_decl_(self):  # noqa
        self._instance_types_()
        self.name_last_node('type')
        self._identifier_()
        self.name_last_node('name')
        self._token('(')

        def sep3():
            self._token(',')

        def block3():
            self._typed_variable_()
        self._gather(block3, sep3)
        self.name_last_node('params')
        self._token(')')
        self._scope_()
        self.name_last_node('stat')
        self.ast._define(
            ['name', 'params', 'stat', 'type'],
            []
        )

    @tatsumasu()
    def _scope_(self):  # noqa
        self._token('{')

        def block1():
            self._statement_()
        self._closure(block1)
        self.name_last_node('code')
        self._token('}')
        self.ast._define(
            ['code'],
            []
        )

    @tatsumasu()
    def _statement_(self):  # noqa
        with self._choice():
            with self._option():
                self._scope_()
            with self._option():
                self._if_statement_()
            with self._option():
                self._loop_statement_()
            with self._option():
                self._return_stmt_()
            with self._option():
                self._declaration_()
            with self._option():
                self._expression_stmt_()
            self._error('no available options')

    @tatsumasu()
    def _expression_stmt_(self):  # noqa
        self._expression_()
        self.name_last_node('expr')
        self._token(';')
        self.ast._define(
            ['expr'],
            []
        )

    @tatsumasu()
    def _return_stmt_(self):  # noqa
        self._token('return')
        self._cut()
        self._expression_()
        self.name_last_node('expr')
        self._token(';')
        self.ast._define(
            ['expr'],
            []
        )

    @tatsumasu()
    def _if_statement_(self):  # noqa
        self._token('if')
        self._cut()
        self._token('(')
        self._expression_()
        self.name_last_node('expr')
        self._token(')')
        self._scope_()
        self.name_last_node('stat')
        with self._optional():
            self._token('else')
            self._statement_()
            self.name_last_node('else_')
        self.ast._define(
            ['else_', 'expr', 'stat'],
            []
        )

    @tatsumasu()
    def _loop_statement_(self):  # noqa
        with self._choice():
            with self._option():
                self._token('while')
                self.name_last_node('type')
                self._cut()
                self._token('(')
                self._expression_()
                self.name_last_node('expr')
                self._token(')')
                self._scope_()
                self.name_last_node('stat')
            with self._option():
                self._token('do')
                self.name_last_node('type')
                self._cut()
                self._scope_()
                self.name_last_node('stat')
                self._token('while')
                self._token('(')
                self._expression_()
                self.name_last_node('expr')
                self._token(')')
                self._token(';')
            self._error('no available options')
        self.ast._define(
            ['expr', 'stat', 'type'],
            []
        )

    @tatsumasu()
    def _expression_(self):  # noqa
        with self._choice():
            with self._option():
                self._assign_()
            with self._option():
                self._logical_()
            self._error('no available options')

    @tatsumasu()
    def _assign_(self):  # noqa
        self._logical_()
        self.name_last_node('left')
        self._token(':=')
        self.name_last_node('op')
        self._expression_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _logical_(self):  # noqa
        with self._choice():
            with self._option():
                self._bitwise_()
            with self._option():
                self._boolean_()
            with self._option():
                self._comparison_()
            self._error('no available options')

    @tatsumasu()
    def _bitwise_(self):  # noqa
        self._comparison_()
        self.name_last_node('left')
        with self._group():
            with self._choice():
                with self._option():
                    self._token('|')
                with self._option():
                    self._token('^')
                with self._option():
                    self._token('&')
                self._error('no available options')
        self.name_last_node('op')
        self._logical_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _boolean_(self):  # noqa
        self._comparison_()
        self.name_last_node('left')
        with self._group():
            with self._choice():
                with self._option():
                    self._token('||')
                with self._option():
                    self._token('&&')
                self._error('no available options')
        self.name_last_node('op')
        self._logical_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _comparison_(self):  # noqa
        with self._choice():
            with self._option():
                self._equality_()
            with self._option():
                self._relation_()
            with self._option():
                self._shift_()
            self._error('no available options')

    @tatsumasu()
    def _equality_(self):  # noqa
        self._shift_()
        self.name_last_node('left')
        with self._group():
            with self._choice():
                with self._option():
                    self._token('!=')
                with self._option():
                    self._token('==')
                self._error('no available options')
        self.name_last_node('op')
        self._comparison_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _relation_(self):  # noqa
        self._shift_()
        self.name_last_node('left')
        with self._group():
            with self._choice():
                with self._option():
                    self._token('>=')
                with self._option():
                    self._token('<=')
                with self._option():
                    self._token('>')
                with self._option():
                    self._token('<')
                self._error('no available options')
        self.name_last_node('op')
        self._comparison_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _shift_(self):  # noqa
        with self._choice():
            with self._option():
                self._bitshift_()
            with self._option():
                self._bin_expr_()
            self._error('no available options')

    @tatsumasu()
    def _bitshift_(self):  # noqa
        self._bin_expr_()
        self.name_last_node('left')
        with self._group():
            with self._choice():
                with self._option():
                    self._token('<<')
                with self._option():
                    self._token('>>')
                self._error('no available options')
        self.name_last_node('op')
        self._shift_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _bin_expr_(self):  # noqa
        with self._choice():
            with self._option():
                self._addition_()
            with self._option():
                self._subtraction_()
            with self._option():
                self._term_()
            self._error('no available options')

    @tatsumasu()
    def _addition_(self):  # noqa
        self._term_()
        self.name_last_node('left')
        self._token('+')
        self.name_last_node('op')
        self._cut()
        self._bin_expr_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _subtraction_(self):  # noqa
        self._term_()
        self.name_last_node('left')
        self._token('-')
        self.name_last_node('op')
        self._cut()
        self._bin_expr_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _term_(self):  # noqa
        with self._choice():
            with self._option():
                self._multiplication_()
            with self._option():
                self._division_()
            with self._option():
                self._unary_()
            self._error('no available options')

    @tatsumasu()
    def _multiplication_(self):  # noqa
        self._unary_()
        self.name_last_node('left')
        self._token('*')
        self.name_last_node('op')
        self._cut()
        self._term_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _division_(self):  # noqa
        self._unary_()
        self.name_last_node('left')
        self._token('/')
        self.name_last_node('op')
        self._cut()
        self._term_()
        self.name_last_node('right')
        self.ast._define(
            ['left', 'op', 'right'],
            []
        )

    @tatsumasu()
    def _unop_(self):  # noqa
        with self._group():
            with self._choice():
                with self._option():
                    self._token('*')
                with self._option():
                    self._token('--')
                with self._option():
                    self._token('++')
                with self._option():
                    self._token('~')
                with self._option():
                    self._token('!')
                with self._option():
                    self._token('-')
                with self._option():
                    self._token('+')
                self._error('no available options')
        self.name_last_node('op')
        self._unary_()
        self.name_last_node('right')
        self.ast._define(
            ['op', 'right'],
            []
        )

    @tatsumasu()
    def _postop_(self):  # noqa
        with self._choice():
            with self._option():
                self._post_wrap_()
                self.name_last_node('left')
                self._token('(')

                def sep2():
                    self._token(',')

                def block2():
                    self._expression_()
                self._gather(block2, sep2)
                self.name_last_node('op')
                self._token(')')
                self._constant('f')
                self.name_last_node('type')
            with self._option():
                self._post_wrap_()
                self.name_last_node('left')
                self._token('[')
                self._cut()
                self._expression_()
                self.name_last_node('op')
                self._token(']')
                self._constant('b')
                self.name_last_node('type')
            with self._option():
                self._post_wrap_()
                self.name_last_node('left')
                with self._group():
                    with self._choice():
                        with self._option():
                            self._token('++')
                        with self._option():
                            self._token('--')
                        self._error('no available options')
                self.name_last_node('op')
                self._constant('a')
                self.name_last_node('type')
            self._error('no available options')
        self.ast._define(
            ['left', 'op', 'type'],
            []
        )

    @tatsumasu()
    def _post_wrap_(self):  # noqa
        with self._choice():
            with self._option():
                self._postop_()
            with self._option():
                self._factor_()
            self._error('no available options')

    @tatsumasu()
    def _unary_(self):  # noqa
        with self._choice():
            with self._option():
                self._post_wrap_()
            with self._option():
                self._unop_()
            self._error('no available options')

    @tatsumasu()
    def _factor_(self):  # noqa
        with self._choice():
            with self._option():
                self._literal_()
            with self._option():
                self._identifier_()
            with self._option():
                self._subexpression_()
            self._error('no available options')

    @tatsumasu()
    def _subexpression_(self):  # noqa
        self._token('(')
        self._expression_()
        self.name_last_node('@')
        self._token(')')

    @tatsumasu()
    def _literal_(self):  # noqa
        with self._choice():
            with self._option():
                self._integer_()
                self.name_last_node('val')
                self._constant('int')
                self.name_last_node('type')
            with self._option():
                self._string_()
                self.name_last_node('val')
                self._constant('str')
                self.name_last_node('type')
            with self._option():
                self._char_()
                self.name_last_node('val')
                self._constant('chr')
                self.name_last_node('type')
            self._error('no available options')
        self.ast._define(
            ['type', 'val'],
            []
        )

    @tatsumasu()
    def _integer_(self):  # noqa
        self._pattern(r'\d+')

    @tatsumasu()
    def _string_(self):  # noqa
        self._pattern(r'".+"')

    @tatsumasu()
    def _char_(self):  # noqa
        self._pattern(r"'.'")

    @tatsumasu()
    def _identifier_(self):  # noqa
        self._pattern(r'[A-Za-z]\w*')
        self.name_last_node('name')
        self.ast._define(
            ['name'],
            []
        )


class WewSemantics(object):
    def start(self, ast):  # noqa
        return ast

    def types(self, ast):  # noqa
        return ast

    def instance_types(self, ast):  # noqa
        return ast

    def typed_variable(self, ast):  # noqa
        return ast

    def declaration(self, ast):  # noqa
        return ast

    def function_decl(self, ast):  # noqa
        return ast

    def scope(self, ast):  # noqa
        return ast

    def statement(self, ast):  # noqa
        return ast

    def expression_stmt(self, ast):  # noqa
        return ast

    def return_stmt(self, ast):  # noqa
        return ast

    def if_statement(self, ast):  # noqa
        return ast

    def loop_statement(self, ast):  # noqa
        return ast

    def expression(self, ast):  # noqa
        return ast

    def assign(self, ast):  # noqa
        return ast

    def logical(self, ast):  # noqa
        return ast

    def bitwise(self, ast):  # noqa
        return ast

    def boolean(self, ast):  # noqa
        return ast

    def comparison(self, ast):  # noqa
        return ast

    def equality(self, ast):  # noqa
        return ast

    def relation(self, ast):  # noqa
        return ast

    def shift(self, ast):  # noqa
        return ast

    def bitshift(self, ast):  # noqa
        return ast

    def bin_expr(self, ast):  # noqa
        return ast

    def addition(self, ast):  # noqa
        return ast

    def subtraction(self, ast):  # noqa
        return ast

    def term(self, ast):  # noqa
        return ast

    def multiplication(self, ast):  # noqa
        return ast

    def division(self, ast):  # noqa
        return ast

    def unop(self, ast):  # noqa
        return ast

    def postop(self, ast):  # noqa
        return ast

    def post_wrap(self, ast):  # noqa
        return ast

    def unary(self, ast):  # noqa
        return ast

    def factor(self, ast):  # noqa
        return ast

    def subexpression(self, ast):  # noqa
        return ast

    def literal(self, ast):  # noqa
        return ast

    def integer(self, ast):  # noqa
        return ast

    def string(self, ast):  # noqa
        return ast

    def char(self, ast):  # noqa
        return ast

    def identifier(self, ast):  # noqa
        return ast


def main(filename, startrule, **kwargs):
    with open(filename) as f:
        text = f.read()
    parser = WewParser()
    return parser.parse(text, startrule, filename=filename, **kwargs)


if __name__ == '__main__':
    import json
    from tatsu.util import asjson

    ast = generic_main(main, WewParser, name='Wew')
    print('AST:')
    print(ast)
    print()
    print('JSON:')
    print(json.dumps(asjson(ast), indent=2))
    print()