omextra 0.0.0.dev494__py3-none-any.whl → 0.0.0.dev495__py3-none-any.whl

omextra/text/abnf/base.py

@@ -1,4 +1,3 @@
-import abc
 import io
 import itertools
 import typing as ta
@@ -7,10 +6,12 @@ from omlish import check
 from omlish import lang
 
 from .errors import AbnfError
+from .errors import AbnfIncompleteParseError
 
 
 with lang.auto_proxy_import(globals()):
-    from . import parsers
+    from . import ops
+    from . import parsing
 
 
 ##
@@ -18,7 +19,7 @@ with lang.auto_proxy_import(globals()):
 
 @ta.final
 class Match(ta.NamedTuple):
-    parser: 'Parser'
+    op: 'Op'
     start: int
     end: int
     children: tuple['Match', ...]
@@ -32,7 +33,7 @@ class Match(ta.NamedTuple):
     def __repr__(self) -> str:
         return (
             f'{self.__class__.__name__}('
-            f'{self.parser._match_repr()}, '  # noqa
+            f'{self.op._match_repr()}, '  # noqa
             f'{self.start}, {self.end}'
             f'{f", {self.children!r}" if self.children else ""})'
         )
@@ -42,20 +43,20 @@ class Match(ta.NamedTuple):
             write: ta.Callable[[str], ta.Any],
             *,
             indent: int | None = None,
-            _level: int = 0,
+            _depth: int = 0,
     ) -> None:
-        ix: str | None = (' ' * (indent * _level)) if indent is not None else None
+        ix: str | None = (' ' * (indent * _depth)) if indent is not None else None
         if ix:
             write(ix)
-        p = self.parser
-        if isinstance(p, (parsers.StringLiteral, parsers.CaseInsensitiveStringLiteral)):
-            write(f'literal<{self.start}-{self.end}>({p.value!r})')
-        elif isinstance(p, parsers.RangeLiteral):
-            write(f'literal<{self.start}-{self.end}>({p.value.lo!r}-{p.value.hi!r})')
+        o = self.op
+        if isinstance(o, (ops.StringLiteral, ops.CaseInsensitiveStringLiteral)):
+            write(f'literal<{self.start}-{self.end}>({o.value!r})')
+        elif isinstance(o, ops.RangeLiteral):
+            write(f'literal<{self.start}-{self.end}>({o.value.lo!r}-{o.value.hi!r})')
         else:
-            write(f'{p.__class__.__name__.lower()}<{self.start}-{self.end}>')
-            if isinstance(p, parsers.RuleRef):
-                write(f':{p.name}')
+            write(f'{o.__class__.__name__.lower()}<{self.start}-{self.end}>')
+            if isinstance(o, ops.RuleRef):
+                write(f':{o.name}')
             if self.children:
                 write('(')
                 if ix is not None:
@@ -63,7 +64,7 @@ class Match(ta.NamedTuple):
                 for i, c in enumerate(self.children):
                     if i and ix is None:
                         write(', ')
-                    c.render_to(write, indent=indent, _level=_level + 1)
+                    c.render_to(write, indent=indent, _depth=_depth + 1)
                     if ix is not None:
                         write(',\n')
                 if ix:
@@ -104,13 +105,13 @@ def longest_match(ms: ta.Iterable[Match]) -> Match | None:
 ##
 
 
-class Parser(lang.Abstract, lang.PackageSealed):
+class Op(lang.Abstract, lang.PackageSealed):
     def _match_repr(self) -> str:
-        return f'{self.__class__.__name__}@{id(self)}'
+        return f'{self.__class__.__name__}@{id(self):x}'
 
-    @abc.abstractmethod
-    def _iter_parse(self, ctx: '_Context', start: int) -> ta.Iterator[Match]:
-        raise NotImplementedError
+
+class LeafOp(Op, lang.Abstract):
+    pass
 
 
 ##
@@ -120,7 +121,7 @@ class Rule(lang.Final):
     def __init__(
             self,
             name: str,
-            parser: Parser,
+            op: Op,
             *,
             insignificant: bool = False,
     ) -> None:
@@ -128,7 +129,7 @@ class Rule(lang.Final):
 
         self._name = check.non_empty_str(name)
         self._name_f = name.casefold()
-        self._parser = check.isinstance(parser, Parser)
+        self._op = check.isinstance(op, Op)
         self._insignificant = insignificant
 
     def __repr__(self) -> str:
@@ -143,8 +144,8 @@ class Rule(lang.Final):
         return self._name_f
 
     @property
-    def parser(self) -> Parser:
-        return self._parser
+    def op(self) -> Op:
+        return self._op
 
     @property
     def insignificant(self) -> bool:
@@ -162,19 +163,20 @@ class Grammar(lang.Final):
         rules_set: set[Rule] = set()
         rules_by_name: dict[str, Rule] = {}
         rules_by_name_f: dict[str, Rule] = {}
-        rules_by_parser: dict[Parser, Rule] = {}
+        rules_by_op: dict[Op, Rule] = {}
         for gr in rules:
             check.not_in(gr, rules_set)
             check.not_in(gr._name, rules_by_name)  # noqa
             check.not_in(gr._name_f, rules_by_name_f)  # noqa
-            check.not_in(gr._parser, rules_by_parser)  # noqa
+            check.not_in(gr._op, rules_by_op)  # noqa
+            rules_set.add(gr)
             rules_by_name[gr._name] = gr  # noqa
             rules_by_name_f[gr._name_f] = gr  # noqa
-            rules_by_parser[gr._parser] = gr  # noqa
+            rules_by_op[gr._op] = gr  # noqa
         self._rules = rules_set
         self._rules_by_name: ta.Mapping[str, Rule] = rules_by_name
         self._rules_by_name_f: ta.Mapping[str, Rule] = rules_by_name_f
-        self._rules_by_parser: ta.Mapping[Parser, Rule] = rules_by_parser
+        self._rules_by_op: ta.Mapping[Op, Rule] = rules_by_op
 
         if isinstance(root, str):
             root = rules_by_name_f[root.casefold()]
@@ -193,7 +195,7 @@ class Grammar(lang.Final):
             root: Rule | str | None = None,
             *,
             start: int = 0,
-            debug: bool = False,
+            debug: int = 0,
     ) -> ta.Iterator[Match]:
         if root is None:
             if (root := self._root) is None:
@@ -204,14 +206,13 @@ class Grammar(lang.Final):
             else:
                 root = check.in_(check.isinstance(root, Rule), self._rules)
 
-        ctx_cls: type[_Context]
-        if debug:
-            ctx_cls = _DebugContext
-        else:
-            ctx_cls = _Context
-        ctx = ctx_cls(self, source)
-
-        return ctx.iter_parse(root._parser, start)  # noqa
+        return parsing._iter_parse(  # noqa
+            self,
+            source,
+            root._op,  # noqa
+            start,
+            debug=debug,
+        )
 
     def parse(
             self,
@@ -219,62 +220,28 @@ class Grammar(lang.Final):
             root: str | None = None,
             *,
             start: int = 0,
-            debug: bool = False,
+            complete: bool = False,
+            debug: int = 0,
     ) -> Match | None:
-        return longest_match(self.iter_parse(
+        if (match := longest_match(self.iter_parse(
             source,
             root,
             start=start,
             debug=debug,
-        ))
-
-
-##
-
-
-class _Context:
-    def __init__(
-            self,
-            grammar: Grammar,
-            source: str,
-    ) -> None:
-        super().__init__()
-
-        self._grammar = grammar
-        self._source = source
-
-    @property
-    def grammar(self) -> Grammar:
-        return self._grammar
-
-    @property
-    def source(self) -> str:
-        return self._source
-
-    def iter_parse(self, parser: Parser, start: int) -> ta.Iterator[Match]:
-        return parser._iter_parse(self, start)  # noqa
-
+        ))) is None:
+            return None
 
-class _DebugContext(_Context):
-    _level: int = 0
+        if complete and (match.start, match.end) != (start, len(source)):
+            raise AbnfIncompleteParseError
 
-    def iter_parse(self, parser: Parser, start: int) -> ta.Iterator[Match]:
-        print(f'{"  " * self._level}enter: {parser=} {start=}')
-        try:
-            self._level += 1
-            for m in super().iter_parse(parser, start):  # noqa
-                # print(f'{"  " * (self._level - 1)}match: {parser=} {start=}')
-                yield m
-        finally:
-            self._level -= 1
-            print(f'{"  " * self._level}exit: {parser=} {start=}')
+        return match
 
 
 ##
 
 
 def iter_parse(
-        obj: Grammar | Rule | Parser,
+        obj: Grammar | Rule | Op,
         src: str,
         *,
         root: str | None = None,
@@ -285,7 +252,7 @@ def iter_parse(
     elif isinstance(obj, Rule):
         check.none(root)
         gram = Grammar(obj, root=obj)
-    elif isinstance(obj, Parser):
+    elif isinstance(obj, Op):
         check.none(root)
         gram = Grammar(Rule('root', obj), root='root')
     else:
@@ -299,7 +266,7 @@ def iter_parse(
 
 
 def parse(
-        obj: Grammar | Rule | Parser,
+        obj: Grammar | Rule | Op,
         src: str,
         *,
         root: str | None = None,

omextra/text/abnf/core.py

@@ -5,11 +5,11 @@ import typing as ta
 
 from .base import Grammar
 from .base import Rule
-from .parsers import concat
-from .parsers import either
-from .parsers import literal
-from .parsers import repeat
-from .parsers import rule
+from .ops import concat
+from .ops import either
+from .ops import literal
+from .ops import repeat
+from .ops import rule
 
 
 ##