fix table lookup generation

Author: Vizonex

llparse/compilator.py

@@ -572,7 +572,7 @@ def doBuild(self, out: list[str]):
             else:
                 ch = f"'{chr(e.key)}'"
 
-            out.append(f"  case {ch}:" + "{")
+            out.append(f"  case {ch}: " + "{")
             tmp: list[str] = []
 
             # For now debug everything....

llparse/debug.py

@@ -9,9 +9,6 @@ def getAllNodes(root: Node):
 
         while queue:
             node = queue.pop()
-            print(node.name)
-            if node.name == "nmethods":
-                print(node.getEdges())
             if edges := node.getEdges():
                 for slot in edges:
                     if slot.node in nodes:

llparse/frontend.py

@@ -12,11 +12,15 @@
 from .pyfront.nodes import ITableEdge
 from .pyfront.peephole import Peephole
 from .spanalloc import SpanAllocator
-from .trie import Trie, TrieEmpty, TrieNode, TrieSequence, TrieSingle
+from .trie import Trie, TrieEmpty, TrieNode, TrieSequence, TrieSingle, ITrieSingleChild
 
 DEFAULT_MIN_TABLE_SIZE = 32
 DEFAULT_MAX_TABLE_WIDTH = 4
 
+from logging import getLogger
+
+log = getLogger("llparse.frontend")
+
 
 WrappedNode = IWrap[_frontend.node.Node]
 WrappedCode = IWrap[_frontend.code.Code]
@@ -166,7 +170,7 @@ def translateMatch(self, node: source.code.Match) -> list[WrappedNode]:
         trieNode = trie.build(list(node))
 
         if not trieNode:
-            # print("[DEBUG]", "TrieNode was nonexistant")
+            log.debug("TrieNode was nonexistant")
             return self.implementation.node.Empty(
                 _frontend.node.Empty(self.Id.id(node.name))
             )
@@ -178,7 +182,7 @@ def translateMatch(self, node: source.code.Match) -> list[WrappedNode]:
 
         return children
 
-    def registerNode(self, node: WrappedNode):
+    def registerNode(self, node: WrappedNode) -> None:
         # NOTE NO Implementations required here since this is python!
         if isinstance(
             node.ref,
@@ -287,7 +291,6 @@ def ID():
 
             if isinstance(single.ref, _frontend.node.Invoke):
                 for edge in node:
-                    # print(edge.key)
                     single.ref.addEdge(
                         ord(edge.key) if isinstance(edge.key, str) else edge.key,
                         self.translate(edge.node),
@@ -304,52 +307,48 @@ def maybeTableLookup(
             return None
 
         targets: dict[source.code.Node, ITableLookupTarget] = {}
-        bailout = False
-        for child in trie.children:
-            if isinstance(child.node, TrieEmpty):
-                # print(
-                #     'non-leaf trie child of "%s" prevents table allocation' % node.name
-                # )
-                bailout = False
-                continue
-
-            empty: TrieEmpty = child.node
-            if getattr(empty, "value", None) is None:
-                # print(
-                #     'value passing trie leaf of "%s" prevents table allocation'
-                #     % node.name
-                # )
-                bailout = False
-                continue
+
+        def check_child(child: ITrieSingleChild):
+            nonlocal targets
+            if not isinstance(child.node, TrieEmpty):
+                log.debug(
+                    'non-leaf trie child of "%s" prevents table allocation' % node.name
+                )
+                return False
+            empty = child.node
+            if empty.value is not None:
+                log.debug(
+                    'value passing trie leaf of "%s" prevents table allocation'
+                    % node.name
+                )
+                return False
 
             target = empty.node
-            if not targets.get(target):
+            if target not in targets:
                 targets[target] = ITableLookupTarget(
                     keys=[child.key], noAdvance=child.noAdvance, trie=empty
                 )
-                bailout = True
-                break
+                return True
 
             existing = targets[target]
-
             if existing.noAdvance != child.noAdvance:
-                # print('noAdvance mismatch in a trie leaf of "%s" prevents table allocation' % node.name)
-                bailout = False
-                break
-
+                log.debug(
+                    f'noAdvance mismatch in a trie leaf of "{node.name}" prevents '
+                    "table allocation"
+                )
+                return False
             existing.keys.append(child.key)
+            return True
 
-            # TODO: see if breaking or continue block after out is breakout has been determined is good ot not...
-            bailout = True
-            break
-
-        # assert len(trie.children) == len(targets), "Something went wrong"
-        if bailout:
+        if not all([check_child(child) for child in trie.children]):
             return
 
         # Weave width limit for optimization...
-        if len(targets.keys()) >= (1 << self.options["maxTableElemWidth"]):
-            # print('too many different trie targets of "%s" for a table allocation' % node.name)
+        if len(targets) >= (1 << self.options["maxTableElemWidth"]):
+            log.debug(
+                'too many different trie targets of "%s" for a table allocation'
+                % node.name
+            )
             return
 
         table = self.implementation.node.TableLookup(
@@ -358,11 +357,11 @@ def maybeTableLookup(
         children.append(table)
 
         # Break Loop
-        if self.Map.get(node):
+        if not self.Map.get(node):
             self.Map[node] = table
 
         for target in targets.values():
-            _next = self.translateTrie(node, target, children)
+            _next = self.translateTrie(node, target.trie, children)
             table.ref.addEdge(
                 ITableEdge(keys=target.keys, noAdvance=target.noAdvance, node=_next)
             )
@@ -408,9 +407,7 @@ def translateSingle(
         self, node: source.code.Match, trie: TrieSingle, children: MatchChildren
     ):
         # Check if Tablelookup could be a valid option to Optimze our code up...
-        maybeTable = self.maybeTableLookup(node, trie, children)
-
-        if maybeTable:
+        if maybeTable := self.maybeTableLookup(node, trie, children):
             return maybeTable
 
         single = self.implementation.node.Single(
@@ -432,8 +429,7 @@ def translateSingle(
                 value=child.node.value if isinstance(child.node, TrieEmpty) else None,
             )
 
-        otherwise = trie.otherwise
-        if otherwise:
+        if otherwise := trie.otherwise:
             single.ref.setOtherwise(
                 self.translateTrie(node, otherwise, children), True, otherwise.value
             )
@@ -442,8 +438,9 @@ def translateSingle(
     def translateSpanCode(self, code: source.code._Span):
         return self.translateCode(code)
 
-    # TODO Vizonex Maybe better typehining can be used in this function alone....
-    def translateCode(self, code: source.code.Code):
+    def translateCode(
+        self, code: source.code.Code
+    ):
         """Translates Builder Classes to Frontend Classes..."""
 
         prefixed = self.codeId.id(code.name).name
@@ -499,9 +496,8 @@ def translateCode(self, code: source.code.Code):
         else:
             raise Exception(f'UnSupported code:"{code.name}" type: "{type(code)}"')
 
-        if self.codeCache.get(res.ref.cacheKey):
-            return self.codeCache[res.ref.cacheKey]
-
+        if _res := self.codeCache.get(res.ref.cacheKey):
+            return _res
         self.codeCache[res.ref.cacheKey] = res
         return res
 

llparse/llparse.py

@@ -67,12 +67,20 @@ def compile(
         properties: list[source.Property],
         header_name: Optional[str] = None,
         Impl: Optional[IImplementation] = IImplementation(),
+        override_llparse_name: bool = False
     ):
         """Creates the C and header file..."""
         info = self.to_frontend(root, properties, Impl)
         hb = HeaderBuilder(self.prefix, self.headerGuard, properties, info.spans)
+        cdata =  CCompiler(header_name, self.debug).compile(info)
+        if override_llparse_name:
+            # sometimes users want to combine parsers together when compiling with C
+            # to make up for conflicts with other parsers example: llhttp
+            # there should be a fair way of compiling everything.
+            cdata = cdata.replace('llparse', self.prefix)
+
         return CompilerResult(
-            CCompiler(header_name, self.debug).compile(info), hb.build()
+           cdata , hb.build()
         )
 
 
@@ -122,6 +130,7 @@ def build(
         maxTableElemWidth: Optional[int] = None,
         minTableSize: Optional[int] = None,
         header_name: Optional[str] = None,
+        override_llparse_name:bool = False
     ):
         """Builds Graph and then compiles the data into C code , returns with the header and C file inside of a Dataclass"""
 
@@ -133,7 +142,8 @@ def build(
             minTableSize if minTableSize else DEFAULT_MIN_TABLE_SIZE,
         )
 
-        return compiler.compile(root, self.properties(), header_name=header_name)
+        return compiler.compile(root, self.properties(), header_name=header_name, override_llparse_name=override_llparse_name)
+    
 
     def to_frontend(
         self,

llparse/pyfront/nodes.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any, Optional, Callable
 
 from ..pyfront.front import Code, IWrap, Span, SpanField
 from ..pyfront.transform import Transform
@@ -8,7 +8,9 @@
 class Slot:
     # ONLY NODE SHOULD BE ALLOWED TO BE SEEN
 
-    def __init__(self, node: IWrap["Node"], value: Any) -> None:
+    def __init__(
+        self, node: IWrap["Node"], value: Callable[[IWrap["Node"]], None]
+    ) -> None:
         self.privNode = node
         """Same as calling it from get and setting the value etc..."""
         self.privUpdate = value
@@ -19,12 +21,17 @@ def __init__(self, node: IWrap["Node"], value: Any) -> None:
     # 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)
+        return hash(self.privNode.ref.id.name)
 
     @property
     def node(self):
         return self.privNode
 
+    @node.setter
+    def node(self, value: IWrap["Node"]):
+        self.privNode = value
+        self.privUpdate(value)
+
 
 @dataclass(unsafe_hash=True)
 class IUniqueName:
@@ -121,9 +128,6 @@ def buildSlots(self):
 
 
 class Empty(Node):
-    # def __init__(self, id: IUniqueName) -> None:
-    #     super().__init__(id)
-
     def __hash__(self):
         return hash(self.id)
 
@@ -237,16 +241,7 @@ 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"))
+        for e in self.privEdges:
+            yield Slot(e.node, lambda value: setattr(e, "node", value))
+        yield from super().buildSlots()
 
-# node2 = Invoke(Ident.id("Check_Flag"),IsEqual("Flag","Check_Flag",0))
-# node2.setOtherwise(IWrap(node),True,0)

llparse/pyfront/peephole.py

@@ -11,7 +11,7 @@ class Peephole:
     def optimize(self, root: WrapNode, nodes: WrapList):
         changed = set(nodes)
 
-        while len(changed) != 0:
+        while changed:
             previous = changed
             changed = set()
 

llparse/trie.py

@@ -58,7 +58,7 @@ def build(self, edges: list[Edge]):
         internalEdges: list[IEdge] = []
 
         for edge in edges:
-            key = str(edge.key) if isinstance(edge.key, int) else edge.key
+            key = chr(edge.key) if isinstance(edge.key, int) else edge.key
             internalEdges.append(
                 IEdge(
                     key=key.encode("utf-8") if isinstance(key, str) else key,
@@ -73,8 +73,8 @@ def build(self, edges: list[Edge]):
     def level(self, edges: list[IEdge], path: list[bytes] = []):
         first = edges[0].key
         last = edges[-1].key
-        # print("level",edges, first)
-        if len(edges) == 1 and len(edges[0].key) == 0:
+        # print("level", edges, first)
+        if len(edges) == 1 and (len(edges[0].key) == 0):
             return TrieEmpty(edges[0].node, edges[0].value)
 
         i = 0
@@ -112,17 +112,17 @@ def single(self, edges: list[IEdge], path: list[bytes]):
                 + (b", ".join(path).decode("utf-8"))
                 + "]"
             )
-
+        
         keys: dict[int, list[IEdge]] = {}
         otherwise = None
         for edge in edges:
-            if not len(edge.key):
+            if not edge.key:
                 otherwise = TrieEmpty(edge.node, edge.value)
                 continue
 
             key = edge.key[0]
 
-            if keys.get(key):
+            if key in keys:
                 keys[key].append(edge)
             else:
                 keys[key] = [edge]
@@ -146,7 +146,9 @@ def single(self, edges: list[IEdge], path: list[bytes]):
                     + "]"
                 )
                 raise TypeError(err)
-            child = ITrieSingleChild(key, noAdvance, self.level(sliced, subPath))
-            children.append(child)
+    
+            children.append(
+                ITrieSingleChild(key, noAdvance, self.level(sliced, subPath))
+            )
 
         return TrieSingle(children, otherwise)

tests/test_frontend.py

@@ -0,0 +1,25 @@
+
+from llparse import LLParse
+
+
+
+def test_build_tables():
+    # There was a bug with 1.2 of our version that doesn't affect the node-js one where
+    # it wouldn't building tables, this attempts to simulate the problem Currenlty this 
+    # bug is patched now :)
+    p = LLParse("lltable")
+    start = p.node('start')
+    loop = p.node('loop')
+    loop.skipTo(start)
+    start.match(
+        [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 
+65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 58, 
+59, 60, 61, 62, 63, 64, 91, 92, 93, 94, 95, 96, 123, 124, 125, 126, 32, 9, 10, 13, 11, 12],
+        loop
+    ).otherwise(p.error(0, 'im a little teapot'))
+
+    # If there is not a lookup_table this then it has failed me ;-;
+    assert "lookup_table" in p.build(start).c
+
+
+