364 lines
12 KiB
Python
364 lines
12 KiB
Python
import t, c
|
|
from stdint import *
|
|
import memhub
|
|
import string
|
|
from .base import (
|
|
AST, ASTKind,
|
|
_init_ast, _copy_str, _set_parent_list,
|
|
_emit, _emit_str, _emit_int, _dump_list,
|
|
)
|
|
|
|
|
|
# ============================================================
|
|
# MatchCase 节点
|
|
# ============================================================
|
|
|
|
class MatchCase(AST):
|
|
"""MatchCase(pattern: AST, guard: AST)"""
|
|
pattern: AST | t.CPtr
|
|
guard: AST | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
pattern: AST | t.CPtr, guard: AST | t.CPtr):
|
|
ptr: MatchCase | t.CPtr = pool.alloc(MatchCase.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchCase.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
pattern: AST | t.CPtr, guard: AST | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.pattern = pattern
|
|
self.guard = guard
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchCase
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchCase"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchCase(pattern=")
|
|
if self.pattern is not None:
|
|
pos = self.pattern.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", guard=")
|
|
if self.guard is not None:
|
|
pos = self.guard.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", body=")
|
|
pos = _dump_list(self.children, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchValue 节点
|
|
# ============================================================
|
|
|
|
class MatchValue(AST):
|
|
"""MatchValue(value: AST)"""
|
|
value: AST | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
|
ptr: MatchValue | t.CPtr = pool.alloc(MatchValue.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchValue.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.value = value
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchValue
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchValue"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchValue(value=")
|
|
if self.value is not None:
|
|
pos = self.value.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchSingleton 节点
|
|
# ============================================================
|
|
|
|
class MatchSingleton(AST):
|
|
"""MatchSingleton(value: AST)"""
|
|
value: AST | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
|
ptr: MatchSingleton | t.CPtr = pool.alloc(MatchSingleton.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchSingleton.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr, value: AST | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.value = value
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchSingleton
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchSingleton"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchSingleton(value=")
|
|
if self.value is not None:
|
|
pos = self.value.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchSequence 节点
|
|
# ============================================================
|
|
|
|
class MatchSequence(AST):
|
|
"""MatchSequence(patterns: list[AST | t.CPtr])"""
|
|
patterns: list[AST | t.CPtr] | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr):
|
|
ptr: MatchSequence | t.CPtr = pool.alloc(MatchSequence.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchSequence.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.patterns = patterns
|
|
_set_parent_list(patterns, self)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchSequence
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchSequence"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchSequence(patterns=")
|
|
pos = _dump_list(self.patterns, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchMapping 节点
|
|
# ============================================================
|
|
|
|
class MatchMapping(AST):
|
|
"""MatchMapping(keys: list[AST | t.CPtr], patterns: list[AST | t.CPtr], rest: str)"""
|
|
keys: list[AST | t.CPtr] | t.CPtr
|
|
patterns: list[AST | t.CPtr] | t.CPtr
|
|
rest: str
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
keys: list[AST | t.CPtr] | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr,
|
|
rest: str):
|
|
ptr: MatchMapping | t.CPtr = pool.alloc(MatchMapping.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchMapping.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
keys: list[AST | t.CPtr] | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr,
|
|
rest: str):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.keys = keys
|
|
self.patterns = patterns
|
|
self.rest = _copy_str(pool, rest)
|
|
_set_parent_list(keys, self)
|
|
_set_parent_list(patterns, self)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchMapping
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchMapping"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchMapping(keys=")
|
|
pos = _dump_list(self.keys, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", patterns=")
|
|
pos = _dump_list(self.patterns, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", rest='")
|
|
pos = _emit_str(buf, size, pos, self.rest)
|
|
pos = _emit(buf, size, pos, "')")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchClass 节点
|
|
# ============================================================
|
|
|
|
class MatchClass(AST):
|
|
"""MatchClass(cls: AST, patterns: list[AST | t.CPtr],
|
|
kwd_attrs: list[AST | t.CPtr], kwd_patterns: list[AST | t.CPtr])"""
|
|
cls: AST | t.CPtr
|
|
patterns: list[AST | t.CPtr] | t.CPtr
|
|
kwd_attrs: list[AST | t.CPtr] | t.CPtr
|
|
kwd_patterns: list[AST | t.CPtr] | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
cls: AST | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr,
|
|
kwd_attrs: list[AST | t.CPtr] | t.CPtr,
|
|
kwd_patterns: list[AST | t.CPtr] | t.CPtr):
|
|
ptr: MatchClass | t.CPtr = pool.alloc(MatchClass.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchClass.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
cls: AST | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr,
|
|
kwd_attrs: list[AST | t.CPtr] | t.CPtr,
|
|
kwd_patterns: list[AST | t.CPtr] | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.cls = cls
|
|
self.patterns = patterns
|
|
self.kwd_attrs = kwd_attrs
|
|
self.kwd_patterns = kwd_patterns
|
|
_set_parent_list(patterns, self)
|
|
_set_parent_list(kwd_attrs, self)
|
|
_set_parent_list(kwd_patterns, self)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchClass
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchClass"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchClass(cls=")
|
|
if self.cls is not None:
|
|
pos = self.cls.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", patterns=")
|
|
pos = _dump_list(self.patterns, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", kwd_attrs=")
|
|
pos = _dump_list(self.kwd_attrs, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", kwd_patterns=")
|
|
pos = _dump_list(self.kwd_patterns, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchStar 节点
|
|
# ============================================================
|
|
|
|
class MatchStar(AST):
|
|
"""MatchStar(name: str)"""
|
|
name: str
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr, name: str):
|
|
ptr: MatchStar | t.CPtr = pool.alloc(MatchStar.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchStar.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr, name: str):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.name = _copy_str(pool, name)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchStar
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchStar"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchStar(name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "')")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchAs 节点
|
|
# ============================================================
|
|
|
|
class MatchAs(AST):
|
|
"""MatchAs(pattern: AST, name: str)"""
|
|
pattern: AST | t.CPtr
|
|
name: str
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
pattern: AST | t.CPtr, name: str):
|
|
ptr: MatchAs | t.CPtr = pool.alloc(MatchAs.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchAs.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
pattern: AST | t.CPtr, name: str):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.pattern = pattern
|
|
self.name = _copy_str(pool, name)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchAs
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchAs"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchAs(pattern=")
|
|
if self.pattern is not None:
|
|
pos = self.pattern.dump(buf, size, pos)
|
|
pos = _emit(buf, size, pos, ", name='")
|
|
pos = _emit_str(buf, size, pos, self.name)
|
|
pos = _emit(buf, size, pos, "')")
|
|
return pos
|
|
|
|
|
|
# ============================================================
|
|
# MatchOr 节点
|
|
# ============================================================
|
|
|
|
class MatchOr(AST):
|
|
"""MatchOr(patterns: list[AST | t.CPtr])"""
|
|
patterns: list[AST | t.CPtr] | t.CPtr
|
|
|
|
def __new__(self, pool: memhub.MemManager | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr):
|
|
ptr: MatchOr | t.CPtr = pool.alloc(MatchOr.__sizeof__())
|
|
if ptr:
|
|
string.memset(ptr, 0, MatchOr.__sizeof__())
|
|
return ptr
|
|
|
|
def __init__(self, pool: memhub.MemManager | t.CPtr,
|
|
patterns: list[AST | t.CPtr] | t.CPtr):
|
|
_init_ast(self, pool, 0, 0)
|
|
self.patterns = patterns
|
|
_set_parent_list(patterns, self)
|
|
|
|
def kind(self) -> t.CInt:
|
|
return ASTKind.MatchOr
|
|
|
|
def type_name(self) -> str:
|
|
return "MatchOr"
|
|
|
|
def dump(self, buf: t.CChar | t.CPtr, size: t.CSizeT,
|
|
pos: t.CSizeT) -> t.CSizeT:
|
|
pos = _emit(buf, size, pos, "MatchOr(patterns=")
|
|
pos = _dump_list(self.patterns, buf, size, pos)
|
|
pos = _emit(buf, size, pos, ")")
|
|
return pos
|