core ¶

Hold parser state, scope bookkeeping, token helpers, and module-level orchestration for the concern-grouped parser mixins.

Classes:

ParserCore –

ParserCore ¶

ParserCore(tokens: TokenList = TokenList([]))

Bases: ParserMixinBase

Methods:

clean –
get_tok_precedence –
parse –
parse_assert_stmt –
parse_block –
parse_class_decl –
parse_declaration_prefixes –
parse_expression –
parse_extern –
parse_for_stmt –
parse_function –
parse_if_stmt –
parse_import_stmt –
parse_prototype –
parse_return_function –
parse_template_argument_list –
parse_type –
parse_var_expr –
parse_while_stmt –

Source code in src/arx/parser/core.py

def __init__(self, tokens: TokenList = TokenList([])) -> None:
    """
    title: Instantiate the Parser object.
    parameters:
      tokens:
        type: TokenList
    """
    self.bin_op_precedence = {
        "=": 2,
        "||": 5,
        "or": 5,
        "&&": 6,
        "and": 6,
        "==": 10,
        "!=": 10,
        "<": 10,
        ">": 10,
        "<=": 10,
        ">=": 10,
        "+": 20,
        "-": 20,
        "*": 40,
        "/": 40,
    }
    self.indent_level = 0
    self.known_class_names = set()
    self.template_type_scopes = []
    self.value_scopes = [set()]
    self.tokens = tokens

clean ¶

clean() -> None

Source code in src/arx/parser/core.py

def clean(self) -> None:
    """
    title: Reset the Parser static variables.
    """
    self.indent_level = 0
    self.known_class_names = set()
    self.template_type_scopes = []
    self.value_scopes = [set()]
    self.tokens = TokenList([])

get_tok_precedence ¶

get_tok_precedence() -> int

Source code in src/arx/parser/core.py

def get_tok_precedence(self) -> int:
    """
    title: Get the precedence of the pending binary operator token.
    returns:
      type: int
    """
    return self.bin_op_precedence.get(self.tokens.cur_tok.value, -1)

parse ¶

parse(
    tokens: TokenList, module_name: str = "main"
) -> Module

Source code in src/arx/parser/core.py

def parse(
    self, tokens: TokenList, module_name: str = "main"
) -> astx.Module:
    """
    title: Parse the input code.
    parameters:
      tokens:
        type: TokenList
      module_name:
        type: str
    returns:
      type: astx.Module
    """
    self.clean()
    self.known_class_names = self._collect_class_names(tokens)
    self.tokens = tokens

    tree: astx.Module = astx.Module(module_name)
    self.tokens.get_next_token()

    if self.tokens.cur_tok.kind == TokenKind.not_initialized:
        self.tokens.get_next_token()

    allow_module_docstring = True
    while True:
        if self.tokens.cur_tok.kind == TokenKind.eof:
            break
        if self.tokens.cur_tok.kind == TokenKind.docstring:
            if (
                allow_module_docstring
                and self.tokens.cur_tok.location.line == 0
                and self.tokens.cur_tok.location.col == 1
            ):
                try:
                    validate_docstring(self.tokens.cur_tok.value)
                except ValueError as err:
                    raise ParserException(
                        f"Invalid module docstring: {err}"
                    ) from err
                self.tokens.get_next_token()
                allow_module_docstring = False
                continue
            raise ParserException(
                "Module docstrings are only allowed as the first "
                "statement starting at line 1, column 1."
            )

        if self._is_operator(";"):
            self.tokens.get_next_token()
            allow_module_docstring = False
            continue

        if self._is_operator("@"):
            prefixes = self.parse_declaration_prefixes()
            if self.tokens.cur_tok.kind == TokenKind.kw_class:
                if prefixes.template_params:
                    raise ParserException(
                        "template parameter blocks are only allowed "
                        "before functions or methods"
                    )
                tree.nodes.append(
                    self.parse_class_decl(prefixes.modifiers)
                )
                allow_module_docstring = False
                continue

            if prefixes.modifiers is not None:
                raise ParserException(
                    "annotation must be followed by a declaration"
                )
            if prefixes.template_params:
                if self.tokens.cur_tok.kind != TokenKind.kw_function:
                    raise ParserException(
                        "template parameter blocks are only allowed "
                        "before functions or methods"
                    )
                tree.nodes.append(
                    self.parse_function(prefixes.template_params)
                )
                allow_module_docstring = False
                continue

            raise ParserException(
                "annotation must be followed by a declaration"
            )

        if self.tokens.cur_tok.kind == TokenKind.kw_import:
            tree.nodes.append(self.parse_import_stmt())
            allow_module_docstring = False
            continue

        if self.tokens.cur_tok.kind == TokenKind.kw_function:
            tree.nodes.append(self.parse_function())
            allow_module_docstring = False
            continue

        if self.tokens.cur_tok.kind == TokenKind.kw_extern:
            tree.nodes.append(self.parse_extern())
            allow_module_docstring = False
            continue

        if self.tokens.cur_tok.kind == TokenKind.kw_class:
            tree.nodes.append(self.parse_class_decl())
            allow_module_docstring = False
            continue

        tree.nodes.append(self.parse_expression())
        allow_module_docstring = False

    return tree