llparse 0.1.2__tar.gz → 0.1.4__tar.gz

{llparse-0.1.2 → llparse-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llparse
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Parody of llparse written for writing C Parsers with Python
 Author-email: Vizonex <VizonexBusiness@gmail.com>
 Requires-Python: >=3.9
@@ -15,7 +15,7 @@ Dynamic: license-file
 
 A python parody of the typescript library llparse.
 
-I take no credit for the orginal work done by indutny and I was originally very nervous about making 
+I take no credit for the orginal work done by indutny and the other node-js contributors involved and I was originally very nervous about making 
 this python library that I made public... 
 
 Links to the original library 
@@ -49,7 +49,7 @@ do it at your own risk. They maybe incompleted or not throughly stress-tested.
 
 ## New Features
 - Throw me an issue if typescript llparse introduces something new that you want for me or another contributor to try and implement 
-just seeing llparse add new features is nothing but exciting to me.
+just seeing llparse add new features is exciting to me.
 
 - If you want a feature that typescript llparse doesn't have, be sure to try making a pull request over there as well and not just here, 
 there's a good chance they will appericate you for helping over there too and your helping make llhttp better by doing so. :)
@@ -62,7 +62,7 @@ there's a good chance they will appericate you for helping over there too and yo
 - Make it easy for me or someone else to find a problem and solve it in typescript after testing it in python
 - Typescript takes 2 commands to run a script with node-js it while python only takes one cutting the time required tremendously...
 - The orginal project was MIT licensed.
-- I wanted to write my own C Parsering tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
+- I wanted to write my own C Parser tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
 - I didn't like __Lemon Parser__ or __Yacc__ all that much and a good ide for handling them in Visual Studio Code with error checking to my knowlegde does not exist.
 - The closest thing I got to what I wanted was a project named __NMFU__ shorthand for no memory for you and even I had problems with writing things using that library...
 
@@ -131,3 +131,6 @@ print(c.c)
 open("http_parser.c", "w").write(c.c)
 open("http_parser.h", "w").write(c.header)
 ```
+
+## Video Showcasing this library
+- https://youtu.be/YQOzJ2BghQw

{llparse-0.1.2 → llparse-0.1.4}/README.md

@@ -5,7 +5,7 @@
 
 A python parody of the typescript library llparse.
 
-I take no credit for the orginal work done by indutny and I was originally very nervous about making 
+I take no credit for the orginal work done by indutny and the other node-js contributors involved and I was originally very nervous about making 
 this python library that I made public... 
 
 Links to the original library 
@@ -39,7 +39,7 @@ do it at your own risk. They maybe incompleted or not throughly stress-tested.
 
 ## New Features
 - Throw me an issue if typescript llparse introduces something new that you want for me or another contributor to try and implement 
-just seeing llparse add new features is nothing but exciting to me.
+just seeing llparse add new features is exciting to me.
 
 - If you want a feature that typescript llparse doesn't have, be sure to try making a pull request over there as well and not just here, 
 there's a good chance they will appericate you for helping over there too and your helping make llhttp better by doing so. :)
@@ -52,7 +52,7 @@ there's a good chance they will appericate you for helping over there too and yo
 - Make it easy for me or someone else to find a problem and solve it in typescript after testing it in python
 - Typescript takes 2 commands to run a script with node-js it while python only takes one cutting the time required tremendously...
 - The orginal project was MIT licensed.
-- I wanted to write my own C Parsering tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
+- I wanted to write my own C Parser tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
 - I didn't like __Lemon Parser__ or __Yacc__ all that much and a good ide for handling them in Visual Studio Code with error checking to my knowlegde does not exist.
 - The closest thing I got to what I wanted was a project named __NMFU__ shorthand for no memory for you and even I had problems with writing things using that library...
 
@@ -121,3 +121,6 @@ print(c.c)
 open("http_parser.c", "w").write(c.c)
 open("http_parser.h", "w").write(c.header)
 ```
+
+## Video Showcasing this library
+- https://youtu.be/YQOzJ2BghQw

{llparse-0.1.2 → llparse-0.1.4}/llparse/compilator.py

@@ -337,7 +337,7 @@ class Node:
         out: list[str],
         node: IWrap[_frontend.node.Node],
         noAdvance: bool,
-        value: Optional[int],
+        value: Optional[int] = None,
     ):
         ctx = self.compilation
         target = ctx.unwrapNode(node).build(ctx)
@@ -501,7 +501,7 @@ class Pause(Error):
 
         assert self.ref.otherwise
         otherwise = ctx.unwrapNode(self.ref.otherwise.node)
-        out.append(f"{ctx.currentField()} = (void*) (intptr_t) {otherwise};")
+        out.append(f"{ctx.currentField()} = (void*) (intptr_t) {otherwise.cachedDecel};")
         out.append(f"return {STATE_ERROR};")
 
 
@@ -512,7 +512,8 @@ class Sequence(Node):
 
     def doBuild(self, out: list[str]):
         ctx = self.compilation
-
+        # TODO: llparse_match_t could be easily changed around to 
+        # Something that can't be overlapped with when compiled with other parsers...
         out.append("llparse_match_t match_seq;")
         out.append("")
 
@@ -572,7 +573,7 @@ class Single(Node):
             else:
                 ch = f"'{chr(e.key)}'"
 
-            out.append(f"  case {ch}:" + "{")
+            out.append(f"  case {ch}: " + "{")
             tmp: list[str] = []
 
             # For now debug everything....
@@ -639,7 +640,7 @@ class SpanEnd(Node):
         # Invoke callback
         callback = ctx.buildCode(ctx.unwrapCode(self.ref.callback, True))
 
-        out.append(f"err = {callback}({ctx.stateArg()}, start,{ctx.posArg()});")
+        out.append(f"err = {callback}({ctx.stateArg()}, start, {ctx.posArg()});")
 
         out.append("if (err != 0) {")
         tmp = []
@@ -676,6 +677,163 @@ class SpanEnd(Node):
         out.append(f"return {STATE_ERROR};")
 
 
+# Based off arthurschreiber's work with Indutny's Tips and requests added to the mix.
+
+# 0x80 I8
+# 0x8000 I16
+# 0x800000 I24
+# 0x1000000 U24
+
+class Int(Node):
+    def __init__(self, ref: _frontend.node.Int):
+        super().__init__(ref)
+        self.ref = ref
+        self.offset = ref.byteOffset
+    # I'm going to deviate from arthurschreiber's work a bit with indutny's suggestions.
+    # we should really be using bitwise operators like rshift and lshift
+    @property
+    def pair(self):
+        return self.compilation, self.compilation.stateField(self.ref.field)
+
+    def readInt8(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        out.append(f"{index} = ((*{ctx.posArg()}) & 0x80);")
+    
+    def readUInt8(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        out.append(f"{index} = (*{ctx.posArg()});")
+    
+    # LITTLE ENDIAN
+
+    def readInt16LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            # Since BE Belongs to performing << aka left shifts we do >> right shifts 
+            out.append(f"{index} = ({index} >> 8) | ((*{ctx.posArg()}) & 0x80);")
+
+    def readUInt16LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} >> 8) | (*{ctx.posArg()});")
+
+    def readInt24LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        elif self.offset == 1:
+            out.append(f"{index} = ({index} >> 8) | (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} >> 8) | ((*{ctx.posArg()}) & 0x80);")
+
+    def readUInt24LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} >> 8) | (*{ctx.posArg()});")
+ 
+    def readInt32LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        elif self.offset in (1, 2):
+            out.append(f"{index} = ({index} >> 8) | (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} >> 8) | ((*{ctx.posArg()}) & 0x80);")
+
+    def readUInt32LE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} >> 8) | (*{ctx.posArg()});")
+    
+    # BIG ENDIAN 
+    
+    def readInt16BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            # Since LE Belongs to >> we do "<<" instead 
+            out.append(f"{index} = ({index} << 8) | ((*{ctx.posArg()}) & 0x80);")
+    
+    def readUInt16BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} << 8) | (*{ctx.posArg()});")
+
+    def readInt24BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        elif self.offset == 1:
+            out.append(f"{index} = ({index} << 8) | (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} << 8) | ((*{ctx.posArg()}) & 0x80);")
+
+    def readUInt24BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} << 8) | (*{ctx.posArg()});")
+ 
+    def readInt32BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        elif self.offset in (1, 2):
+            out.append(f"{index} = ({index} << 8) | (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} << 8) | ((*{ctx.posArg()}) & 0x80);")
+
+    def readUInt32BE(self, out: list[str]) -> None:
+        ctx, index = self.pair
+        if self.offset == 0:
+            out.append(f"{index} = (*{ctx.posArg()});")
+        else:
+            out.append(f"{index} = ({index} << 8) | (*{ctx.posArg()});")
+ 
+        
+    def doBuild(self, out:list[str]):
+        self.prologue(out)
+        # I'm still supporting 3.9 but I plan to drop it's support in favor of match case soon...
+        bits = self.ref.bits
+        
+        if self.compilation.getFieldType(self.ref.field) == 'ptr':
+            raise ValueError(f'property {self.ref.field} should not use pointers but it was given \"ptr\"')
+
+        if bits == 1:
+            self.readInt8(out) if self.ref.signed else self.readUInt8(out)
+        elif bits == 2:
+            if self.ref.littleEndian:
+                self.readInt16LE(out) if self.ref.signed else self.readUInt16LE(out)
+            else:
+                self.readInt16BE(out) if self.ref.signed else self.readUInt16BE(out)
+        elif bits == 3:
+            if self.ref.littleEndian:
+                self.readInt24LE(out) if self.ref.signed else self.readUInt24LE(out)
+            else:
+                self.readInt24BE(out) if self.ref.signed else self.readUInt24BE(out)
+        else:
+            if self.ref.littleEndian:
+                self.readInt32LE(out) if self.ref.signed else self.readUInt32LE(out)
+            else:
+                self.readInt32BE(out) if self.ref.signed else self.readUInt32BE(out)
+        # TODO: uint64 & int64
+        
+        self.tailTo(out, self.ref.otherwise.node, self.ref.otherwise.noAdvance, None)
+
+
+
+
 MAX_CHAR = 0xFF
 TABLE_GROUP = 16
 
@@ -1077,13 +1235,14 @@ class Compilation:
             r = Consume(ref)
         elif isinstance(ref, _frontend.node.Empty):
             r = Empty(ref)
+        elif isinstance(ref, _frontend.node.Pause):
+            r = Pause(ref)
+
         elif isinstance(ref, _frontend.node.Error):
             r = Error(ref)
         elif isinstance(ref, _frontend.node.Invoke):
             r = Invoke(ref)
-        elif isinstance(ref, _frontend.node.Pause):
-            r = Pause(ref)
-
+        
         elif isinstance(ref, _frontend.node.SpanStart):
             r = SpanStart(ref)
 
@@ -1096,6 +1255,8 @@ class Compilation:
             r = Sequence(ref)
         elif isinstance(ref, _frontend.node.TableLookup):
             r = TableLookup(ref)
+        elif isinstance(ref, _frontend.node.Int):
+            r = Int(ref)
         else:
             raise TypeError(
                 f'refrence "{ref}" is an Invalid Code Type , TypeName:"{ref.__class__.__name__}"'

{llparse-0.1.2 → llparse-0.1.4}/llparse/debug.py

@@ -9,9 +9,6 @@ class Debugger:
 
         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-0.1.2 → llparse-0.1.4}/llparse/frontend.py

@@ -12,11 +12,15 @@ from .pyfront.implementation import IImplementation
 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 @@ class Frontend:
         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 @@ class Frontend:
 
         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,
@@ -207,7 +211,7 @@ class Frontend:
             result = nodeImpl.Error(_frontend.node.Error(ID(), node.code, node.reason))
 
         elif isinstance(node, source.code.Pause):
-            result = nodeImpl.Pause(_frontend.node.Error(ID(), node.code, node.reason))
+            result = nodeImpl.Pause(_frontend.node.Pause(ID(), node.code, node.reason))
 
         elif isinstance(node, source.code.Comsume):
             result = nodeImpl.Consume(_frontend.node.Consume(ID(), node.field))
@@ -240,6 +244,10 @@ class Frontend:
 
         elif isinstance(node, source.code.Match):
             result = self.translateMatch(node)
+
+        elif isinstance(node, source.node.Int):
+            result = self.translateInt(node)
+
         else:
             raise Exception(f'Unknown Node Type for :"{node.name}" {type(node)}')
 
@@ -247,24 +255,26 @@ class Frontend:
 
         if isinstance(result, list):
             # result:list[WrappedNode]
-            assert isinstance(node, source.code.Match)
-            _match = node
 
-            if not otherwise:
-                raise Exception(f'Node "{node.name}" has no ".otherwise()"')
+            assert isinstance(node, (source.code.Match, source.node.Int))
+            _match = node
+        
+            assert otherwise, (f'Node "{node.name}" has no ".otherwise()"')
 
-            else:
+            if isinstance(node, source.node.Match):
                 for child in result:
                     if not child.ref.otherwise:
                         child.ref.setOtherwise(
                             self.translate(otherwise.node), otherwise.noAdvance
                         )
+                transform = self.translateTransform(_match.getTransform())
+                for child in result:
+                    # TODO Vizonex : This might break , be sure to make a workaround function here...
+                    child.ref.setTransform(transform)
 
-            transform = self.translateTransform(_match.getTransform())
-            for child in result:
-                # TODO Vizonex : This might break , be sure to make a workaround function here...
-                child.ref.setTransform(transform)
-
+            
+            else:
+                result[-1].ref.setOtherwise(self.translate(otherwise.node), otherwise.noAdvance)
             assert len(result) >= 1
             return result[0]
 
@@ -287,7 +297,6 @@ class Frontend:
 
             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),
@@ -296,6 +305,23 @@ class Frontend:
                 assert len(list(node)) == 0
 
             return single
+        
+    def translateInt(self, node: source.node.Int) -> list[IWrap[_frontend.node.Int]]:
+        inner = _frontend.node.Int(self.Id.id(node.name), node.field, node.bits, node.signed, node.little_endian, 0)
+        result = [self.implementation.node.Int(inner)]
+        # front is to avoid overlapping with python's functions (aka next)
+        front = self.Map[node] = result[0]
+        
+        for offset in range(1, node.bits):
+            unique_name = self.Id.id(f"{node.name}_byte{offset + 1}")
+            inner = _frontend.node.Int(unique_name, node.field, node.bits, node.signed, node.little_endian, offset)
+            outer = self.implementation.node.Int(inner)
+            result.append(outer)
+            # Integers will advance since they are unpacking values...
+            front.ref.setOtherwise(outer, False)
+            front = result[-1]
+        return result
+
 
     def maybeTableLookup(
         self, node: source.code.Match, trie: TrieSingle, children: MatchChildren
@@ -304,52 +330,48 @@ class Frontend:
             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 +380,11 @@ class Frontend:
         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 +430,7 @@ class Frontend:
         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 +452,7 @@ class Frontend:
                 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 +461,9 @@ class Frontend:
     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 +519,8 @@ class Frontend:
         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-0.1.2 → llparse-0.1.4}/llparse/llparse.py

@@ -67,12 +67,20 @@ class Compiler:
         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 @@ class LLParse(source.Builder):
         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 @@ class LLParse(source.Builder):
             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-0.1.4/llparse/pybuilder/__init__.py

@@ -0,0 +1,8 @@
+from ..pybuilder.builder import *
+from ..pybuilder.loopchecker import *
+from ..pybuilder.main_code import (
+# I'll add more soon I feel a little lazy at the moment.
+    Node,
+    Match,
+    Int
+)

{llparse-0.1.2 → llparse-0.1.4}/llparse/pybuilder/builder.py

@@ -1,7 +1,8 @@
 from typing import Literal, Optional, Union
-
 from ..pybuilder import main_code as code
 
+# typehinting node and code (TODO: Vizonex) Lets seperate the modules soon...
+node = code
 # from pydot import graph_from_dot_data
 
 
@@ -316,3 +317,38 @@ class Builder:
     def properties(self) -> list[Property]:
         """Return list of all allocated properties in parser's state."""
         return list(self.privProperties.values())
+
+    def intBE(self, field: str, bits:int):
+        """
+        :param field: State's property name
+        :param bits: Number of bits to use
+        """
+        return code.Int(field, bits, True, False)
+
+    def intLE(self, field: str, bits: int):
+        """
+        return a node for unpacking arrays to integers
+
+        :param field: State's property name
+        :param bits: Number of bits to use
+        """
+        return code.Int(field, bits, True, True)
+
+    def uintBE(self, field: str, bits: int):
+        """
+        return a node for unpacking arrays to integers
+        
+        :param field: State's property name
+        :param bits: Number of bits to use
+        """
+        return code.Int(field, bits, False, False)
+
+    def uintLE(self, field: str, bits: int):
+        """
+        return a node for unpacking arrays to integers
+        
+        :param field: State's property name
+        :param bits: Number of bits to use
+        """
+        return code.Int(field, bits, False, True)
+    

{llparse-0.1.2 → llparse-0.1.4}/llparse/pybuilder/main_code.py

@@ -92,6 +92,8 @@ class _Match(Code):
         super().__init__("match", name)
 
 
+
+
 @dataclass
 class IMulAddOptions:
     base: int
@@ -244,6 +246,39 @@ class Invoke(Node):
             self.addEdge(Edge(targetNode, True, numKey, None))
 
 
+
+# Not in llparse node-js (yet) But I wanted to implement 
+# this into my version since I am making a very important 
+# http2 frame parser
+
+# SEE: https://github.com/nodejs/llparse-frontend/pull/1
+
+def build_name(field:str, bits: int, signed:bool, little_endian:bool) -> str:
+    result = f"{field}_{'int' if signed else 'uint'}_{bits * 8}"
+    if bits > 1:
+        return result + ('_le' if little_endian else 'be')
+    else:
+        return result
+
+
+class Int(Node):
+    """Used for parsing bytes via unpacking"""
+    def __init__(self, field: str, bits: int, signed: bool, little_endian: bool) -> None:
+        """
+        :param field: State's property name
+        :param bits: Number of bits to use
+        :param signed: Number is signed 
+        :param little_endian: true if le, false if be
+        """
+        if bits < 0:
+            raise ValueError("bits should be a positive integer")
+        self.field =  field
+        self.bits = bits
+        self.signed = signed
+        self.little_endian  = little_endian
+        super().__init__(build_name(field, bits, signed, little_endian))
+    
+
 # -- Transfroms --
 
 TransformName = ["to_lower_unsafe", "to_lower"]

{llparse-0.1.2 → llparse-0.1.4}/llparse/pyfront/front.py

@@ -14,9 +14,6 @@ Signature = TypeVar("Signature", bytes, str)
 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):

{llparse-0.1.2 → llparse-0.1.4}/llparse/pyfront/implementation.py

@@ -37,6 +37,9 @@ class INodeImplementation:
 
     def TableLookup(self, n: node.TableLookup):
         return IWrap(n)
+    
+    def Int(self, n: node.Int):
+        return IWrap(n)
 
 
 class ITransformImplementation:

{llparse-0.1.2 → llparse-0.1.4}/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 @@ from ..pyfront.transform import Transform
 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 @@ class Slot:
     # 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 @@ class Invoke(Node):
 
 
 class Empty(Node):
-    # def __init__(self, id: IUniqueName) -> None:
-    #     super().__init__(id)
-
     def __hash__(self):
         return hash(self.id)
 
@@ -149,6 +153,26 @@ class Pause(Error):
         super().__init__(id, code, reason)
 
 
+# Not in llparse node-js (yet) But I wanted to implement 
+# this into my version since I am making a very important 
+# http2 frame parser
+
+# SEE: https://github.com/nodejs/llparse-frontend/pull/1
+
+@dataclass
+class Int(Node):
+    field: str
+    bits: int
+    signed: bool
+    littleEndian: bool
+    byteOffset: int
+
+    def __hash__(self):
+        return hash(self.id)
+
+
+
+
 @dataclass
 class ISeqEdge:
     node: IWrap[Node]
@@ -237,16 +261,7 @@ class TableLookup(Match):
         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-0.1.2 → llparse-0.1.4}/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-0.1.2 → llparse-0.1.4}/llparse/trie.py

@@ -58,7 +58,7 @@ class Trie:
         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 @@ class Trie:
     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 @@ class Trie:
                 + (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 @@ class Trie:
                     + "]"
                 )
                 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)

{llparse-0.1.2 → llparse-0.1.4}/llparse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llparse
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Parody of llparse written for writing C Parsers with Python
 Author-email: Vizonex <VizonexBusiness@gmail.com>
 Requires-Python: >=3.9
@@ -15,7 +15,7 @@ Dynamic: license-file
 
 A python parody of the typescript library llparse.
 
-I take no credit for the orginal work done by indutny and I was originally very nervous about making 
+I take no credit for the orginal work done by indutny and the other node-js contributors involved and I was originally very nervous about making 
 this python library that I made public... 
 
 Links to the original library 
@@ -49,7 +49,7 @@ do it at your own risk. They maybe incompleted or not throughly stress-tested.
 
 ## New Features
 - Throw me an issue if typescript llparse introduces something new that you want for me or another contributor to try and implement 
-just seeing llparse add new features is nothing but exciting to me.
+just seeing llparse add new features is exciting to me.
 
 - If you want a feature that typescript llparse doesn't have, be sure to try making a pull request over there as well and not just here, 
 there's a good chance they will appericate you for helping over there too and your helping make llhttp better by doing so. :)
@@ -62,7 +62,7 @@ there's a good chance they will appericate you for helping over there too and yo
 - Make it easy for me or someone else to find a problem and solve it in typescript after testing it in python
 - Typescript takes 2 commands to run a script with node-js it while python only takes one cutting the time required tremendously...
 - The orginal project was MIT licensed.
-- I wanted to write my own C Parsering tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
+- I wanted to write my own C Parser tool with llhttp styled callbacks of my own using a language I was the most comfortable with using.
 - I didn't like __Lemon Parser__ or __Yacc__ all that much and a good ide for handling them in Visual Studio Code with error checking to my knowlegde does not exist.
 - The closest thing I got to what I wanted was a project named __NMFU__ shorthand for no memory for you and even I had problems with writing things using that library...
 
@@ -131,3 +131,6 @@ print(c.c)
 open("http_parser.c", "w").write(c.c)
 open("http_parser.h", "w").write(c.header)
 ```
+
+## Video Showcasing this library
+- https://youtu.be/YQOzJ2BghQw

{llparse-0.1.2 → llparse-0.1.4}/llparse.egg-info/SOURCES.txt

@@ -33,5 +33,6 @@ llparse/pyfront/namespace.py
 llparse/pyfront/nodes.py
 llparse/pyfront/peephole.py
 llparse/pyfront/transform.py
+tests/test_frontend.py
 tests/test_loop_checker.py
 tests/test_span_allocator.py

{llparse-0.1.2 → llparse-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "llparse"
-version = "0.1.2"
+version = "0.1.4"
 description = "A Parody of llparse written for writing C Parsers with Python"
 readme = "README.md"
 authors = [

llparse-0.1.4/tests/test_frontend.py

@@ -0,0 +1,35 @@
+
+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
+
+
+def test_pausing():
+    # Ensure frotentend LoopChecker does not mark off against Pausing
+    p = LLParse("lltest")
+    s = p.node('start')
+    s2 = p.node('start2')
+    s.match('p', p.pause(1, 'parser was asked to pause').otherwise(s2)).skipTo(s)
+    s2.match('p', p.pause(2, 'parser was asked to pause again').otherwise(s)).skipTo(s2)
+    
+    p.build(s)
+
+    

llparse-0.1.2/llparse/pybuilder/__init__.py

@@ -1,2 +0,0 @@
-from ..pybuilder.builder import *
-from ..pybuilder.loopchecker import *