llparse 0.1.0__py3-none-any.whl

llparse/pyfront/front.py

@@ -0,0 +1,189 @@
+# NOTE The Difference with typescript llparse is that names already
+# taken by python standard library modules
+# are renamed to something else.... - Vizonex
+
+from dataclasses import dataclass, field
+from typing import Generic, Optional, TypeVar, Union
+
+T = TypeVar("T")
+
+Signature = TypeVar("Signature", bytes, str)
+
+
+@dataclass
+class IWrap(Generic[T]):
+    ref: T
+
+    def __hash__(self) -> int:
+        return hash(self.ref)
+
+
+def toCacheKey(value: Union[int, bool]) -> str:
+    if isinstance(value, int):
+        return "m" + (-value) if value < 0 else "%i" % value
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    else:
+        raise ValueError(f"Unsupported value: {value}")
+
+
+@dataclass
+class Code:
+    signature: Signature
+    cacheKey: str
+    name: str
+
+
+class External(Code):
+    """Inherits from the `Code` class as a subclass of `Code`"""
+
+    def __init__(self, signature: Signature, name: str):
+        super().__init__(signature, "external_" + name, name)
+
+
+@dataclass
+class Field(Code):
+    """Inherits from `Code`"""
+
+    field: str
+
+
+class FieldValueError(Exception):
+    """FieldValue `value` must be integer"""
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+
+class FieldValue(Field):
+    def __init__(
+        self, signature: Signature, cacheKey: str, name: str, field: str, value: int
+    ):
+        self.value = value
+        if not isinstance(self.value, int):
+            raise FieldValueError(
+                f'FieldValue "value" must be integer not {type(self.value)}'
+            )
+        super().__init__(signature, cacheKey, name, field)
+
+
+class And(FieldValue):
+    """a Subclass of `FieldValue`"""
+
+    def __init__(self, name: str, field: str, value: int):
+        super().__init__(
+            "match", f"and_{field}_{toCacheKey(value)}", name, field, value
+        )
+
+
+class IsEqual(FieldValue):
+    def __init__(self, name: str, field: str, value: int):
+        super().__init__(
+            "match", f"is_equal_{field}_{toCacheKey(value)}", name, field, value
+        )
+
+
+class Load(Field):
+    """Subclass of Field"""
+
+    def __init__(self, name: str, field: str):
+        super().__init__("match", f"load_{field}", name, field)
+
+
+class Match(External):
+    def __init__(self, name: str):
+        super().__init__("match", name)
+
+
+@dataclass
+class IMulAddOptions:
+    base: int
+    max: Optional[int]
+    signed: bool
+
+
+def toOptionsKey(options: IMulAddOptions) -> str:
+    res = f"base_{toCacheKey(options.base)}"
+    if options.max:
+        res += f"_max_{toCacheKey(options.max)}"
+    if options.signed:
+        res += f"_signed_{toCacheKey(options.signed)}"
+    return res
+
+
+class MulAdd(Field):
+    def __init__(self, name: str, field: str, options: IMulAddOptions):
+        self.options = options
+        super().__init__(
+            "value", f"mul_add_{field}_{toOptionsKey(options)}", name, field
+        )
+
+
+class Or(FieldValue):
+    def __init__(self, name: str, field: str, value: int):
+        super().__init__("match", f"or_{field}_{toCacheKey(value)}", name, field, value)
+
+
+class Span(External):
+    """A `Span` Class"""
+
+    def __init__(self, name: str):
+        self.name = name
+        super().__init__("span", name)
+
+
+@dataclass
+class SpanField:
+    index: int
+    callbacks: list[IWrap[Span]]
+
+
+class Store(Field):
+    def __init__(self, name: str, field: str):
+        super().__init__("value", f"store_{field}", name, field)
+
+
+class Test(FieldValue):
+    def __init__(self, name: str, field: str, value: int):
+        super().__init__(
+            "match", f"test_{field}_{toCacheKey(value)}", name, field, value
+        )
+
+
+class Update(FieldValue):
+    def __init__(self, name: str, field: str, value: int):
+        super().__init__(
+            "match", f"update_{field}_{toCacheKey(value)}", name, field, value
+        )
+
+
+class Value(External):
+    def __init__(self, name: str):
+        super().__init__("value", name)
+
+
+@dataclass
+class IUniqueName:
+    name: str
+    originalName: str
+
+
+@dataclass
+class Identifier:
+    prefix: str
+    postfix: str = ""
+    ns: set[str] = field(default_factory=set, init=False)
+
+    def id(self, name: str) -> IUniqueName:
+        target = self.prefix + name + self.postfix
+        if target in self.ns:
+            i = 0
+            for i in range(1, len(self.ns)):
+                if (target + "_%i" % i) not in self.ns:
+                    break
+
+            target += "_%i" % i
+
+        self.ns.add(target)
+
+        return IUniqueName(name=target, originalName=name)

llparse/pyfront/implementation.py

@@ -0,0 +1,98 @@
+from ..pyfront import front as code
+from ..pyfront import nodes as node
+from ..pyfront import transform
+from ..pyfront.front import IWrap
+
+
+class INodeImplementation:
+    def __init__(self) -> None:
+        return
+
+    def Consume(self, n: node.Consume):
+        return IWrap(n)
+
+    def Empty(self, n: node.Empty):
+        return IWrap(n)
+
+    def Error(self, n: node.Error):
+        return IWrap(n)
+
+    def Pause(self, n: node.Pause):
+        return IWrap(n)
+
+    def Invoke(self, n: node.Invoke):
+        return IWrap(n)
+
+    def Sequence(self, n: node.Sequence):
+        return IWrap(n)
+
+    def Single(self, n: node.Single):
+        return IWrap(n)
+
+    def SpanEnd(self, n: node.SpanEnd):
+        return IWrap(n)
+
+    def SpanStart(self, n: node.SpanStart):
+        return IWrap(n)
+
+    def TableLookup(self, n: node.TableLookup):
+        return IWrap(n)
+
+
+class ITransformImplementation:
+    def __init__(self) -> None:
+        return
+
+    def ID(self, t: transform.ID):
+        return IWrap(t)
+
+    def ToLower(self, t: transform.ToLower):
+        return IWrap(t)
+
+    def ToLowerUnsafe(self, t: transform.ToLowerUnsafe):
+        return IWrap(t)
+
+
+class ICodeImplementation:
+    def __init__(self) -> None:
+        return
+
+    def And(self, c: code.And):
+        return IWrap(c)
+
+    def Load(self, c: code.Load):
+        return IWrap(c)
+
+    def IsEqual(self, c: code.IsEqual):
+        return IWrap(c)
+
+    def Match(self, c: code.Match):
+        return IWrap(c)
+
+    def MulAdd(self, c: code.MulAdd):
+        return IWrap(c)
+
+    def Or(self, c: code.Or):
+        return IWrap(c)
+
+    def Span(self, c: code.Span):
+        return IWrap(c)
+
+    def Store(self, c: code.Store):
+        return IWrap(c)
+
+    def Test(self, c: code.Test):
+        return IWrap(c)
+
+    def Update(self, c: code.Update):
+        return IWrap(c)
+
+    def Value(self, c: code.Value):
+        return IWrap(c)
+
+
+class IImplementation:
+    def __init__(self) -> None:
+        self.code = ICodeImplementation()
+        self.node = INodeImplementation()
+        self.transform = ITransformImplementation()

llparse/pyfront/namespace.py

@@ -0,0 +1 @@
+from ..pyfront import transform as transform

llparse/pyfront/nodes.py

@@ -0,0 +1,243 @@
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from ..pyfront.front import Code, IWrap, Span, SpanField
+from ..pyfront.transform import Transform
+
+
+class Slot:
+    # ONLY NODE SHOULD BE ALLOWED TO BE SEEN
+
+    def __init__(self, node: IWrap["Node"], value: Any) -> None:
+        self.privNode = node
+        """Same as calling it from get and setting the value etc..."""
+        self.privUpdate = value
+
+    # TODO Vizonex Figure out how to actually implement
+    # Slots -> private readonly privUpdate: (value: IWrap<Node>) => void
+    # For Now use this backup by using the unique name to hash the values
+    # I spent 4 hours trying to figure this how this could be implemented
+    # so this is my only ideal sloution
+    def __hash__(self) -> int:
+        return hash(self.privUpdate.ref.id.name)
+
+    @property
+    def node(self):
+        return self.privNode
+
+
+@dataclass
+class IUniqueName:
+    name: str
+    originalName: str
+
+
+@dataclass
+class IOtherwiseEdge:
+    node: IWrap["Node"]
+    noAdvance: bool
+    value: Optional[int]
+
+
+@dataclass
+class Identifier:
+    prefix: str = ""
+    postfix: str = ""
+    ns: set[str] = field(default_factory=set, init=False)
+
+    def id(self, name: str):
+        """Creates a Unique name for the switches"""
+        target = self.prefix + name + self.postfix
+
+        if target in self.ns:
+            i = 1
+            for i in range(1, len(self.ns)):
+                if (target + "_%i" % i) not in self.ns:
+                    break
+            target += "_%i" % i
+
+        self.ns.add(target)
+        return IUniqueName(target, name)
+
+
+@dataclass
+class Node:
+    id: IUniqueName
+    otherwise: Optional[IOtherwiseEdge] = field(default=None, init=False)
+    Slots: Optional[list[Slot]] = field(default_factory=list, init=False)
+
+    def setOtherwise(
+        self, node: IWrap["Node"], noAdvance: bool, value: Optional[int] = None
+    ):
+        self.otherwise = IOtherwiseEdge(node, noAdvance, value)
+
+    def getSlots(self):
+        if self.Slots == []:
+            self.Slots.extend(self.buildSlots())
+        yield from self.Slots
+
+    def buildSlots(self):
+        otherwise = self.otherwise
+        if otherwise:
+            yield Slot(otherwise.node, otherwise.node)
+
+
+class Consume(Node):
+    def __init__(self, id: IUniqueName, field: str) -> None:
+        self.field = field
+        super().__init__(id)
+
+
+@dataclass
+class IInvokeEdge:
+    code: int
+    node: IWrap[Node]
+
+
+class Invoke(Node):
+    def __init__(self, id: IUniqueName, code: IWrap[Code]) -> None:
+        self.Edges: list[IInvokeEdge] = []
+        self.code = code
+        super().__init__(id)
+
+    def addEdge(self, code: int, node: IWrap[Node]):
+        self.Edges.append(IInvokeEdge(code, node))
+
+    def edges(self):
+        return self.Edges
+
+    def buildSlots(self):
+        for edge in self.Edges:
+            yield Slot(edge.node, edge.node)
+
+        for e in super().buildSlots():
+            yield e
+
+
+class Empty(Node):
+    def __init__(self, id: IUniqueName) -> None:
+        super().__init__(id)
+
+
+class Error(Node):
+    def __init__(self, id: IUniqueName, code: int, reason: str) -> None:
+        self.code = code
+        self.reason = reason
+        super().__init__(id)
+
+
+class Match(Node):
+    def __init__(self, id: IUniqueName) -> None:
+        self.transform: Optional[IWrap[Transform]] = None
+        super().__init__(id)
+
+    def setTransform(self, transform: IWrap[Transform]):
+        self.transform = transform
+
+
+class Pause(Error):
+    def __init__(self, id: IUniqueName, code: int, reason: str) -> None:
+        super().__init__(id, code, reason)
+
+
+@dataclass
+class ISeqEdge:
+    node: IWrap[Node]
+    value: Optional[int]
+
+
+# TODO Make Sure TypeHinting doesn't overlap with the Real Sequence typehint!
+# So I'll add an extra S to it for now...
+class Sequence(Match):
+    def __init__(self, id: IUniqueName, select: str) -> None:
+        self.select = select
+        self.Edge: Optional[ISeqEdge] = None
+        super().__init__(id)
+
+    def setEdge(self, node: Node, value: Optional[int]):
+        assert True if not self.Edge else False
+        self.Edge = ISeqEdge(node, value)
+
+    def buildSlots(self):
+        edge = self.Edge
+        yield Slot(edge.node, edge.node)
+        for e in super().buildSlots():
+            yield e
+
+
+class SpanStart(Node):
+    def __init__(
+        self, id: IUniqueName, field: SpanField, callback: IWrap[Span]
+    ) -> None:
+        self.field = field
+        self.callback = callback
+        super().__init__(id)
+
+
+class SpanEnd(Node):
+    def __init__(
+        self, id: IUniqueName, field: SpanField, callback: IWrap[Span]
+    ) -> None:
+        self.field = field
+        self.callback = callback
+        super().__init__(id)
+
+
+@dataclass
+class ISingleEdge:
+    key: int
+    node: IWrap[Node]
+    noAdvance: bool
+    value: Optional[int] = None
+
+
+class Single(Match):
+    def __init__(self, id: IUniqueName) -> None:
+        self.privEdges: list[ISingleEdge] = []
+
+        super().__init__(id)
+
+    def addEdge(
+        self, key: int, node: IWrap[Node], noAdvance: bool, value: Optional[int] = None
+    ):
+        self.privEdges.append(ISingleEdge(key, node, noAdvance, value))
+
+    @property
+    def edges(self):
+        return self.privEdges
+
+    def buildSlots(self):
+        for edge in self.privEdges:
+            yield Slot(edge.node, edge.node)
+        return super().buildSlots()
+
+
+@dataclass
+class ITableEdge:
+    keys: list[int]
+    node: IWrap[Node]
+    noAdvance: bool
+
+
+class TableLookup(Match):
+    def __init__(self, id: IUniqueName) -> None:
+        self.privEdges: list[ITableEdge] = []
+        super().__init__(id)
+
+    def addEdge(self, edge: ITableEdge):
+        self.privEdges.append(edge)
+
+    def buildSlots(self):
+        edge = self.privEdges
+        for e in edge:
+            yield Slot(e.node, e.node)
+        for e in super().buildSlots():
+            yield e
+
+
+# Ident = Identifier("llComment")
+
+# node = Node(Ident.id("__On_Pagesum"))
+
+# node2 = Invoke(Ident.id("Check_Flag"),IsEqual("Flag","Check_Flag",0))
+# node2.setOtherwise(IWrap(node),True,0)

llparse/pyfront/peephole.py

@@ -0,0 +1,45 @@
+from ..pyfront.front import IWrap
+from ..pyfront.nodes import Empty, Node
+
+WrapNode = IWrap[Node]
+WrapList = list[WrapNode]
+
+
+# TODO (Vizonex) Make peephole into 2 seperate functions instead of a class to
+# Optimize everything down further...
+class Peephole:
+    def optimize(self, root: WrapNode, nodes: WrapList):
+        changed = set(nodes)
+
+        while len(changed) != 0:
+            previous = changed
+            changed = set()
+
+            for node in previous:
+                if self.optimizeNode(node):
+                    changed.add(node)
+
+        while isinstance(root.ref, Empty):
+            if not root.ref.otherwise or not root.ref.otherwise.noAdvance:
+                break
+            root = root.ref.otherwise.node
+
+        return root
+
+    def optimizeNode(self, node: WrapNode):
+        changed = False
+        for slot in node.ref.getSlots():
+            # TODO Find an Actual way to check that a Node maybe empty...
+            if not isinstance(slot.node.ref, Empty) or not slot.node.ref.otherwise:
+                continue
+
+            otherwise = slot.node.ref.otherwise
+
+            # Node skips so we cannot optimize
+            if not otherwise.noAdvance:
+                continue
+
+            slot.node.ref = otherwise.node.ref
+
+            changed = True
+        return changed

llparse/pyfront/transform.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Transform:
+    name: str
+
+
+class ID(Transform):
+    def __init__(self) -> None:
+        super().__init__("id")
+
+
+class ToLowerUnsafe(Transform):
+    def __init__(self) -> None:
+        super().__init__("to_lower_unsafe")
+
+
+class ToLower(Transform):
+    def __init__(self) -> None:
+        super().__init__("to_lower")