symbol_table

The SymbolTable class offered here allows the definition of scopes, so the variable or function would be available in specifics scopes.

Classes:

• Scope –
• ScopeNode –
• ScopeNodeBase –
• SymbolTable –

Scope

Scope(scope_node_class: type[ScopeNodeBase] = ScopeNode)

Methods:

• add –
• destroy –
• get_first –
• get_last –
• set_default_parent –

Source code in packages/astx/src/astx/symbol_table.py

def __init__(
    self,
    scope_node_class: type[ScopeNodeBase] = ScopeNode,
) -> None:
    """
    title: Initialize the scope.
    parameters:
      scope_node_class:
        type: type[ScopeNodeBase]
    """
    self.nodes: dict[int, ScopeNodeBase] = {}
    self.current = None
    self.previous = None
    self.scope_node_class = scope_node_class

    self.add("root")

    self.scope_node_class.default_parent = self.current

add

add(
    name: str,
    parent: Optional[ScopeNodeBase] = None,
    change_current: bool = True,
) -> ScopeNodeBase

Source code in packages/astx/src/astx/symbol_table.py

def add(
    self,
    name: str,
    parent: Optional[ScopeNodeBase] = None,
    change_current: bool = True,
) -> ScopeNodeBase:
    """
    title: Add a new node in the scope.
    parameters:
      name:
        type: str
      parent:
        type: Optional[ScopeNodeBase]
      change_current:
        type: bool
    returns:
      type: ScopeNodeBase
    """
    node = self.scope_node_class(name, parent)

    # The use of id(node) as keys in the nodes dictionary is generally
    # fine, but be aware that this approach may lead to potential issues
    # if the id() of a node is reused after its destruction. It's #
    # unlikely to happen in the current code, but it's something to be
    # aware of.
    self.nodes[id(node)] = node

    if len(self.nodes) == 1 or change_current:
        self.previous = self.current
        self.current = self.nodes[id(node)]

    return node

destroy

destroy(node: ScopeNodeBase) -> None

Source code in packages/astx/src/astx/symbol_table.py

def destroy(self, node: ScopeNodeBase) -> None:
    """
    title: Destroy the current scope.
    parameters:
      node:
        type: ScopeNodeBase
    """
    del self.nodes[id(node)]
    self.current = self.previous
    self.previous = None

get_first

get_first() -> ScopeNodeBase

Source code in packages/astx/src/astx/symbol_table.py

def get_first(self) -> ScopeNodeBase:
    """
    title: Get the first node in the scope.
    returns:
      type: ScopeNodeBase
    """
    node_id = next(iter(self.nodes.keys()))
    return self.nodes[node_id]

get_last

get_last() -> ScopeNodeBase

Source code in packages/astx/src/astx/symbol_table.py

def get_last(self) -> ScopeNodeBase:
    """
    title: Get the latest node in the scope.
    returns:
      type: ScopeNodeBase
    """
    node_id = list(self.nodes.keys())[-1]
    return self.nodes[node_id]

set_default_parent

set_default_parent(node: ScopeNodeBase) -> None

Source code in packages/astx/src/astx/symbol_table.py

def set_default_parent(self, node: ScopeNodeBase) -> None:
    """
    title: Set default parent for the current scope.
    parameters:
      node:
        type: ScopeNodeBase
    """
    self.scope_node_class.default_parent = node

ScopeNode

ScopeNode(
    name: str, parent: Optional[ScopeNodeBase] = None
)

Bases: ScopeNodeBase

Source code in packages/astx/src/astx/symbol_table.py

def __init__(
    self, name: str, parent: Optional[ScopeNodeBase] = None
) -> None:
    """
    title: Initialize ScopeNodeBase.
    parameters:
      name:
        type: str
      parent:
        type: Optional[ScopeNodeBase]
    """
    self.parent: Optional[ScopeNodeBase] = (
        parent or ScopeNodeBase.default_parent
    )
    self.name: str = name
    self.named_expr: dict[str, NamedExpr] = {}

ScopeNodeBase

ScopeNodeBase(
    name: str, parent: Optional[ScopeNodeBase] = None
)

Source code in packages/astx/src/astx/symbol_table.py

def __init__(
    self, name: str, parent: Optional[ScopeNodeBase] = None
) -> None:
    """
    title: Initialize ScopeNodeBase.
    parameters:
      name:
        type: str
      parent:
        type: Optional[ScopeNodeBase]
    """
    self.parent: Optional[ScopeNodeBase] = (
        parent or ScopeNodeBase.default_parent
    )
    self.name: str = name
    self.named_expr: dict[str, NamedExpr] = {}

SymbolTable

SymbolTable()

Methods:

• define –
• lookup –
• update –

Source code in packages/astx/src/astx/symbol_table.py

def __init__(self) -> None:
    self.scopes = Scope()

define

define(expr: NamedExpr) -> None

Source code in packages/astx/src/astx/symbol_table.py

def define(self, expr: NamedExpr) -> None:
    """
    title: Define a new named expression inside the scoped stack.
    parameters:
      expr:
        type: NamedExpr
    """
    if not self.scopes.current:
        raise Exception("SymbolTable: No scope active.")
    self.scopes.current.named_expr[expr.name] = expr

lookup

lookup(name: str) -> NamedExpr

Source code in packages/astx/src/astx/symbol_table.py

def lookup(self, name: str) -> NamedExpr:
    """
    title: Get a named expression from the scope stack.
    parameters:
      name:
        type: str
    returns:
      type: NamedExpr
    """
    scope = self.scopes.current
    while scope is not None:
        if name in scope.named_expr:
            return scope.named_expr[name]
        scope = scope.parent
    raise NameError(f"Name '{name}' is not defined")

update

update(expr: NamedExpr) -> None

It is useful mainly for updating the comment of the expression. parameters: expr: type: NamedExpr

Source code in packages/astx/src/astx/symbol_table.py

def update(self, expr: NamedExpr) -> None:
    """
    title: Update the expression on the SymbolTable.
    summary: |-

      It is useful mainly for updating the comment of the expression.
    parameters:
      expr:
        type: NamedExpr
    """
    if not self.scopes.current:
        raise Exception("SymbolTable: No scope active.")
    if expr.name not in self.scopes.current.named_expr:
        raise Exception("This name doesn't exist in the SymbolTable.")
    self.scopes.current.named_expr[expr.name] = expr