omlish 0.0.0.dev306__py3-none-any.whl → 0.0.0.dev307__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev306'
-__revision__ = 'dda70244f84192bfce2428b682f9a5e2349fb05a'
+__version__ = '0.0.0.dev307'
+__revision__ = '7fd729bd16b72af663b113712ea301f150b2449d'
 
 
 #

omlish/formats/edn/__init__.py

@@ -1,4 +1,5 @@
 from .parsing import (  # Noqa
+    MetaMaker,
     parse,
     parse_list,
 )
@@ -10,6 +11,6 @@ from .values import (  # noqa
     Map,
     Set,
     Symbol,
-    TaggedVal,
+    Tagged,
     Vector,
 )

omlish/formats/edn/lexing.py

@@ -0,0 +1,325 @@
+r"""
+https://github.com/edn-format/edn
+https://github.com/antlr/grammars-v4/blob/master/edn/edn.g4
+https://github.com/jorinvo/edn-data/blob/1e5824f63803eb58f35e98839352000053d47115/src/parse.ts
+https://clojure.org/reference/reader#_extensible_data_notation_edn
+"""
+import dataclasses as dc
+import io
+import typing as ta
+
+from ... import check
+from ...funcs.genmachine import GenMachine
+
+
+##
+
+
+TokenKind: ta.TypeAlias = ta.Literal[
+    'STRING',
+    'CHAR',
+    'WORD',
+    'COMMENT',
+
+    'LPAREN',
+    'RPAREN',
+    'LBRACKET',
+    'RBRACKET',
+    'HASH_LBRACE',
+    'LBRACE',
+    'RBRACE',
+
+    'HASH_UNDERSCORE',
+    'META',
+    'QUOTE',
+]
+
+
+class Position(ta.NamedTuple):
+    ofs: int
+    line: int
+    col: int
+
+
+class Token(ta.NamedTuple):
+    kind: TokenKind
+    src: str
+
+    pos: Position
+
+    def __iter__(self):
+        raise TypeError
+
+
+##
+
+
+SINGLE_TOKENS: ta.Mapping[str, TokenKind] = {
+    '(': 'LPAREN',
+    ')': 'RPAREN',
+    '[': 'LBRACKET',
+    ']': 'RBRACKET',
+    '{': 'LBRACE',
+    '}': 'RBRACE',
+
+    '^': 'META',
+    "'": 'QUOTE',
+}
+
+
+HASH_TOKENS: ta.Mapping[str, TokenKind] = {
+    '{': 'HASH_LBRACE',
+    '_': 'HASH_UNDERSCORE',
+}
+
+
+WORD_FIRST_SPECIAL_CHARS = ':.*+!-_?$%&=<>.'
+WORD_BODY_SPECIAL_CHARS = '/'
+
+
+##
+
+
+@dc.dataclass()
+class StreamLexError(Exception):
+    message: str
+
+    pos: Position
+
+
+class StreamLexer(GenMachine[str, Token]):
+    def __init__(self) -> None:
+        self._ofs = 0
+        self._line = 1
+        self._col = 0
+
+        self._buf = io.StringIO()
+
+        super().__init__(self._do_main())
+
+    @property
+    def pos(self) -> Position:
+        return Position(
+            self._ofs,
+            self._line,
+            self._col,
+        )
+
+    def _char_in(self, c: str) -> str:
+        if not isinstance(c, str):
+            raise TypeError(c)
+        if c and len(c) != 1:
+            raise ValueError(c)
+
+        self._ofs += 1
+
+        if c == '\n':
+            self._line += 1
+            self._col = 0
+        else:
+            self._col += 1
+
+        return c
+
+    def _make_tok(
+            self,
+            kind: TokenKind,
+            src: str,
+            pos: Position,
+    ) -> ta.Sequence[Token]:
+        tok = Token(
+            kind,
+            src,
+            pos,
+        )
+        return (tok,)
+
+    def _flip_buf(self) -> str:
+        src = self._buf.getvalue()
+        self._buf.seek(0)
+        self._buf.truncate()
+        return src
+
+    def _raise(self, msg: str, src: Exception | None = None) -> ta.NoReturn:
+        raise StreamLexError(msg, self.pos) from src
+
+    def _do_main(self, p: str | None = None):
+        while True:
+            if p is not None:
+                c = p
+                p = None
+            else:
+                c = self._char_in((yield None))  # noqa
+
+            if not c:
+                return None
+
+            if c.isspace() or c == ',':
+                continue
+
+            if c in SINGLE_TOKENS:
+                yield self._make_tok(SINGLE_TOKENS[c], c, self.pos)
+                continue
+
+            if c == ';':
+                return self._do_comment()
+
+            if c == '"':
+                return self._do_string()
+
+            if c == '\\':
+                return self._do_char()
+
+            if c == '#':
+                return self._do_hash()
+
+            if (
+                    c.isalnum() or
+                    c in WORD_FIRST_SPECIAL_CHARS
+            ):
+                return self._do_word(c)
+
+            self._raise(f'Unexpected input: {c}')
+
+    def _do_comment(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write(';')
+
+        pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or c == '\n':
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('COMMENT', src, pos)
+        return self._do_main()
+
+    def _do_string(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write('"')
+
+        pos = self.pos
+
+        esc = False
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c:
+                self._raise(f'Unterminated string literal: {self._buf.getvalue()}')
+
+            self._buf.write(c)
+            if esc:
+                esc = False
+            elif c == '\\':
+                esc = True
+            elif c == '"':
+                break
+
+        src = self._flip_buf()
+        yield self._make_tok('STRING', src, pos)
+        return self._do_main()
+
+    def _do_char(self):
+        check.state(self._buf.tell() == 0)
+        self._buf.write('\\')
+
+        pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or not (
+                    c.isalnum() or
+                    c == '\\'
+            ):
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('CHAR', src, pos)
+        return self._do_main(c)
+
+    def _do_hash(self):
+        check.state(self._buf.tell() == 0)
+
+        pos = self.pos
+
+        try:
+            c = self._char_in((yield None))  # noqa
+        except GeneratorExit:
+            self._raise('Unexpected end of input')
+
+        if (ht := HASH_TOKENS.get(c)) is not None:
+            yield self._make_tok(ht, '#' + c, pos)
+            return self._do_main()
+
+        elif (
+                c.isalnum() or
+                c == '#' or
+                c in WORD_FIRST_SPECIAL_CHARS
+        ):
+            return self._do_word('#' + c, pos=pos)
+
+        else:
+            self._raise(f'Unexpected input: {c}')
+
+    def _do_word(self, pfx: str, *, pos: Position | None = None):
+        check.state(self._buf.tell() == 0)
+        self._buf.write(pfx)
+
+        if pos is None:
+            pos = self.pos
+
+        while True:
+            try:
+                c = self._char_in((yield None))  # noqa
+            except GeneratorExit:
+                self._raise('Unexpected end of input')
+
+            if not c or not (
+                    c.isalnum() or
+                    c in WORD_FIRST_SPECIAL_CHARS or
+                    c in WORD_BODY_SPECIAL_CHARS
+            ):
+                break
+
+            self._buf.write(c)
+
+        src = self._flip_buf()
+        yield self._make_tok('WORD', src, pos)
+        return self._do_main(c)
+
+
+##
+
+
+def test_lex():
+    for s in [
+        '"abc"',
+        '{"a" "b"}',
+        '1',
+        '-1',
+        '{a :b c 420}',
+        '#{a}',
+    ]:
+        print(s)
+        with StreamLexer() as lex:
+            for c in [*s, '']:
+                for t in lex(c):
+                    print(t)
+        print()

omlish/formats/edn/parsing.py

@@ -1,28 +1,88 @@
+# ruff: noqa: PYI055 UP007
 """
 TODO:
+ - \u0123 in strings
+ - https://clojure.org/reference/reader
  - reader meta - ^:foo
+ - read table
 """
-# https://github.com/jorinvo/edn-data/blob/1e5824f63803eb58f35e98839352000053d47115/test/parse.test.ts
+import dataclasses as dc
 import datetime
 import enum
+import io
 import re
 import typing as ta
 
 from ... import check
+from ...funcs.genmachine import GenMachine
+from .lexing import Position
+from .lexing import StreamLexer
+from .lexing import Token
 from .values import Char
+from .values import Collection
 from .values import Keyword
 from .values import List
 from .values import Map
 from .values import Set
 from .values import Symbol
-from .values import TaggedVal
+from .values import Tagged
 from .values import Vector
 
 
 ##
 
 
-class ListParser:
+WORD_CONST_VALUES: ta.Mapping[str, ta.Any] = {
+    'true': True,
+    'false': False,
+    'nil': None,
+
+    '##Inf': float('inf'),
+    '##-Inf': float('-inf'),
+    '##NaN': float('nan'),
+}
+
+
+STRING_ESCAPE_MAP: ta.Mapping[str, str] = {
+    '"': '"',
+    '\\': '\\',
+    'b': '\b',
+    'f': '\f',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+}
+
+
+CHAR_ESCAPE_MAP: ta.Mapping[str, str] = {
+    'backspace': '\b',
+    'formfeed': '\f',
+    'newline': '\n',
+    'return': '\r',
+    'space': ' ',
+    'tab': '\t',
+}
+
+
+##
+
+
+@dc.dataclass()
+class StreamParseError(Exception):
+    message: str
+
+    pos: Position | None = None
+
+
+@dc.dataclass(frozen=True)
+class MetaMaker:
+    fn: ta.Callable[..., ta.Any]
+
+    def __call__(self, *args: ta.Any, meta: ta.Any | None = None) -> ta.Any:
+        return self.fn(*args, meta=meta)
+
+
+class StreamParser(GenMachine[Token, ta.Any]):
     DEFAULT_TAG_HANDLERS: ta.ClassVar[ta.Mapping[str, ta.Callable[..., ta.Any]]] = {
         'inst': lambda val: datetime.datetime.fromisoformat(val) if isinstance(val, str) else None,
     }
@@ -30,19 +90,17 @@ class ListParser:
     def __init__(
             self,
             *,
-            keyword_maker: ta.Callable[..., ta.Any] = Keyword,
-            char_maker: ta.Callable[..., ta.Any] = Char,
-            symbol_maker: ta.Callable[..., ta.Any] = Symbol,
+            keyword_maker: ta.Callable[..., ta.Any] = MetaMaker(Keyword),
+            char_maker: ta.Callable[..., ta.Any] = MetaMaker(Char),
+            symbol_maker: ta.Callable[..., ta.Any] = MetaMaker(Symbol),
 
-            list_maker: ta.Callable[..., ta.Any] = List.new,
-            vector_maker: ta.Callable[..., ta.Any] = Vector.new,
-            set_maker: ta.Callable[..., ta.Any] = Set.new,
-            map_maker: ta.Callable[..., ta.Any] = Map.new,
+            list_maker: ta.Callable[..., ta.Any] = MetaMaker(List.new),
+            vector_maker: ta.Callable[..., ta.Any] = MetaMaker(Vector.new),
+            set_maker: ta.Callable[..., ta.Any] = MetaMaker(Set.new),
+            map_maker: ta.Callable[..., ta.Any] = MetaMaker(Map.new),
 
             tag_handlers: ta.Mapping[str, ta.Callable[..., ta.Any]] | None = None,
     ) -> None:
-        super().__init__()
-
         self._keyword_maker = keyword_maker
         self._char_maker = char_maker
         self._symbol_maker = symbol_maker
@@ -57,299 +115,260 @@ class ListParser:
             **(tag_handlers or {}),
         }
 
-        self._stack: list[tuple[ListParser._ParseMode | ListParser._StackItem, ta.Any]] = []
-        self._mode: ListParser._ParseMode = ListParser._ParseMode.IDLE
-        self._state = ''
-        self._result: ta.Any = self._UNDEFINED
+        self._stack: list[
+            tuple[
+                ta.Union[
+                    type[Collection],
+                    StreamParser._StackSpecial,
+                ],
+                list[ta.Any],
+            ],
+        ] = []
 
-    #
+        super().__init__(self._do_main())
 
-    class _UNDEFINED:  # noqa
-        def __new__(cls, *args, **kwargs):  # noqa
-            raise TypeError
+    class _StackSpecial(enum.Enum):  # noqa
+        DISCARD = enum.auto()
+        TAG = enum.auto()
 
-    class _ParseMode(enum.Enum):
-        IDLE = 0
-        STRING = 1
-        ESCAPE = 2
-        COMMENT = 3
+    def _emit_value(self, value: ta.Any) -> tuple[ta.Any, ...]:
+        while self._stack and self._stack[-1][0] is StreamParser._StackSpecial.TAG:
+            cc, cl = self._stack.pop()
+            ts = check.non_empty_str(check.single(cl))
+            value = Tagged(ts, value)
 
-    class _StackItem(enum.Enum):
-        VECTOR = 0
-        LIST = 1
-        MAP = 2
-        SET = 3
-        TAG = 4
+        if not self._stack:
+            return (value,)
 
-    #
+        cc, cl = self._stack[-1]
 
-    def _update_stack(self) -> None:
-        if not self._stack or self._result is self._UNDEFINED:
-            return
+        if cc is StreamParser._StackSpecial.DISCARD:
+            check.empty(cl)
+            self._stack.pop()
+            return ()
 
-        stack_item, prev_state = self._stack[-1]
+        elif cc is StreamParser._StackSpecial.TAG:
+            ts = check.non_empty_str(check.single(cl))
+            self._stack.pop()
+            tv = Tagged(ts, value)
+            return (tv,)
 
-        if stack_item == ListParser._StackItem.VECTOR:
-            prev_state.append(self._result)
+        elif cc is Map:
+            if cl and len(cl[-1]) < 2:
+                cl[-1] = (*cl[-1], value)
+            else:
+                cl.append((value,))
+            return ()
+
+        elif isinstance(cc, type) and issubclass(cc, Collection):
+            cl.append(value)
+            return ()
+
+        else:
+            raise RuntimeError(cc)
+
+    def _do_main(self):
+        while True:
+            tok: Token
+            try:
+                tok = yield None  # noqa
+            except GeneratorExit:
+                if self._stack:
+                    raise StreamParseError('Expected value') from None
+                else:
+                    raise
 
-        elif stack_item == ListParser._StackItem.LIST:
-            prev_state.append(self._result)
+            value: ta.Any
 
-        elif stack_item == ListParser._StackItem.SET:
-            prev_state.append(self._result)
+            # scalars
 
-        elif stack_item == ListParser._StackItem.MAP:
-            if len(prev_state[1]) > 0:
-                prev_state[0].append([prev_state[1].pop(), self._result])
-            else:
-                prev_state[1].append(self._result)
+            if tok.kind == 'STRING':
+                value = self._parse_string(tok)
 
-        elif stack_item == ListParser._StackItem.TAG:
-            self._stack.pop()
+            elif tok.kind == 'CHAR':
+                value = self._parse_char(tok)
 
-            if prev_state == '_':
-                self._result = self._UNDEFINED
+            elif tok.kind == 'WORD':
+                if tok.src.startswith('#'):
+                    # FIXME: more dispatching
+                    self._stack.append((StreamParser._StackSpecial.TAG, [tok.src[1:]]))
+                    continue
 
-            else:
-                tag_handler = self._tag_handlers.get(prev_state)
-                if tag_handler:
-                    self._result = tag_handler(self._result)
                 else:
-                    self._result = TaggedVal(prev_state, self._result)
-
-            self._update_stack()
-            return
-
-        # TODO: else error
-        # Reset result after updating stack
-        self._result = self._UNDEFINED
-
-    #
-
-    _INT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)$')
-    _BIGINT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)N$')
-    _FLOAT_PAT = re.compile(r'^[-+]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?(0|[1-9][0-9]*))?M?$')
-
-    def _match(self) -> None:
-        if self._state == 'nil':
-            self._result = None
-
-        elif self._state == 'true':
-            self._result = True
-
-        elif self._state == 'false':
-            self._result = False
-
-        elif self._state.startswith(':'):
-            # Keyword
-            self._result = self._keyword_maker(self._state[1:])
-
-        elif self._state.startswith('#'):
-            # Tag
-            self._stack.append((ListParser._StackItem.TAG, self._state[1:]))
-            self._result = self._UNDEFINED
-
-        elif self._INT_PAT.match(self._state):
-            # Int
-            self._result = int(self._state)
-
-        elif self._FLOAT_PAT.match(self._state):
-            # Float
-            self._result = float(self._state)
-
-        elif self._BIGINT_PAT.match(self._state):
-            # BigInt
-            self._result = int(self._state[:-1])  # In Python we don't need special handling for bigint
-
-        elif self._state.startswith('\\'):
-            # Char
-            check.state(len(self._state) > 1)
-            if self._state == '\\space':
-                c = ' '
-            elif self._state == '\\newline':
-                c = '\n'
-            elif self._state == '\\return':
-                c = '\r'
-            elif self._state == '\\tab':
-                c = '\t'
-            elif self._state == '\\\\':
-                c = '\\'
-            elif self._state.startswith('\\u'):
-                check.state(len(self._state) == 6)
-                c = chr(int(self._state[2:], 16))
-            else:
-                check.state(len(self._state) == 2)
-                c = self._state[1:]
+                    value = self._parse_word(tok)
 
-            self._result = self._char_maker(c)
+            elif tok.kind == 'COMMENT':
+                continue
+
+            # open
+
+            elif tok.kind == 'LPAREN':
+                self._stack.append((List, []))
+                continue
 
-        elif self._state:
-            # Symbol
-            self._result = self._symbol_maker(self._state)
+            elif tok.kind == 'LBRACKET':
+                self._stack.append((Vector, []))
+                continue
 
-        self._state = ''
+            elif tok.kind == 'HASH_LBRACE':
+                self._stack.append((Set, []))
+                continue
 
-    #
+            elif tok.kind == 'LBRACE':
+                self._stack.append((Map, []))
+                continue
 
-    _SPACE_CHARS: ta.ClassVar[ta.AbstractSet[str]] = frozenset([',', ' ', '\t', '\n', '\r'])
+            elif tok.kind == 'HASH_UNDERSCORE':
+                self._stack.append((StreamParser._StackSpecial.DISCARD, []))
+                continue
 
-    _STRING_ESCAPE_MAP: ta.ClassVar[ta.Mapping[str, str]] = {
-        't': '\t',
-        'r': '\r',
-        'n': '\n',
-        '\\': '\\',
-        '"': '"',
-    }
+            # close
 
-    def parse(self, src: str) -> list[ta.Any]:
-        values = []
+            elif tok.kind == 'RPAREN':
+                cc, cl = self._stack.pop()
+                check.state(cc is List)
+                value = self._list_maker(cl)
 
-        i = -1
-        for i in range(len(src)):
-            if not self._stack and self._result is not self._UNDEFINED:
-                values.append(self._result)
-                self._result = self._UNDEFINED
+            elif tok.kind == 'RBRACKET':
+                cc, cl = self._stack.pop()
+                check.state(cc is Vector)
+                value = self._vector_maker(cl)
 
-            char = src[i]
+            elif tok.kind == 'RBRACE':
+                cc, cl = self._stack.pop()
 
-            if self._mode == ListParser._ParseMode.IDLE:
-                if char == '"':
-                    self._match()
-                    self._update_stack()
-                    self._mode = ListParser._ParseMode.STRING
-                    self._state = ''
-                    continue
+                if cc is Set:
+                    value = self._set_maker(cl)
 
-                if char == ';':
-                    self._mode = ListParser._ParseMode.COMMENT
-                    continue
+                elif cc is Map:
+                    if cl and len(cl[-1]) != 2:
+                        raise RuntimeError('Mismatched map entries')
+                    value = self._map_maker(cl)
 
-                if char in self._SPACE_CHARS:
-                    self._match()
-                    self._update_stack()
-                    continue
+                else:
+                    raise RuntimeError(cc)
 
-                if char == '}':
-                    self._match()
-                    self._update_stack()
+            # nyi
 
-                    if self._stack:
-                        stack_item, prev_state = self._stack.pop()
+            elif tok.kind == 'META':
+                raise NotImplementedError
 
-                        if stack_item == ListParser._StackItem.MAP:
-                            check.empty(prev_state[1])
-                            self._result = self._map_maker(prev_state[0])
+            elif tok.kind == 'QUOTE':
+                raise NotImplementedError
 
-                        else:  # Set
-                            # FIXME:
-                            # check.state(stack_item == ListParser._StackItem.SET)
-                            self._result = self._set_maker(prev_state)
+            # failure
 
-                    self._update_stack()
-                    continue
+            else:
+                raise ValueError(tok.kind)
+
+            # emit
+
+            if (ev := self._emit_value(value)):
+                yield ev
+
+    def _parse_string(self, tok: Token) -> str:
+        check.state(tok.kind == 'STRING')
+        src = tok.src
+        check.state(src[0] == '"')
+        check.state(src[-1] == '"')
+        check.state(len(src) > 1)
+
+        p = 1
+        end = len(src) - 1
+        if src.find('\\', p, end) < 0:
+            return src[1:-1]
+
+        sb = io.StringIO()
+        while True:
+            if (n := src.find('\\', p, end)) < 0:
+                sb.write(src[p:end])
+                break
+
+            sb.write(src[p:n])
+            p = n + 1
+            check.state(p < end)
+            x = src[p]
+            p += 1
+
+            if x == 'u':
+                check.state(p < end - 4)
+                r = chr(int(src[p:p + 4], 16))
+                p += 4
 
-                if char == ']':
-                    self._match()
-                    self._update_stack()
-                    stack_item, prev_state = self._stack.pop()
-                    self._result = self._vector_maker(tuple(prev_state))
-                    self._update_stack()
-                    continue
+            else:
+                r = STRING_ESCAPE_MAP[x]
 
-                if char == ')':
-                    self._match()
-                    self._update_stack()
-                    stack_item, prev_state = self._stack.pop()
-                    self._result = self._list_maker(prev_state)
-                    self._update_stack()
-                    continue
+            sb.write(r)
 
-                if char == '[':
-                    self._match()
-                    self._update_stack()
-                    self._stack.append((ListParser._StackItem.VECTOR, []))
-                    continue
+        return sb.getvalue()
 
-                if char == '(':
-                    self._match()
-                    self._update_stack()
-                    self._stack.append((ListParser._StackItem.LIST, []))
-                    continue
+    def _parse_char(self, tok: Token) -> ta.Any:
+        check.state(tok.kind == 'CHAR')
+        src = tok.src
+        check.state(len(src) > 1)
+        check.state(src.startswith('\\'))
 
-                state_plus_char = self._state + char
-                if state_plus_char == '#_':
-                    self._stack.append((ListParser._StackItem.TAG, char))
-                    self._result = self._UNDEFINED
-                    self._state = ''
-                    continue
+        if len(src) == 2:
+            c = src[1]
 
-                if state_plus_char.endswith('#{'):
-                    self._state = self._state[:-1]  # Remove the '#'
-                    self._match()
-                    self._update_stack()
-                    self._stack.append((ListParser._StackItem.SET, []))
-                    self._state = ''
-                    continue
+        elif src[1] == 'u':
+            check.state(len(src) == 6)
+            c = chr(int(src[2:], 16))
 
-                if char == '{':
-                    self._match()
-                    self._update_stack()
-                    self._stack.append((ListParser._StackItem.MAP, [[], []]))
-                    self._state = ''
-                    continue
+        elif src[1] == 'o':
+            # \oXXX -> octal
+            raise NotImplementedError
 
-                self._state += char
-                continue
+        else:
+            c = CHAR_ESCAPE_MAP[src[1:]]
 
-            elif self._mode == ListParser._ParseMode.STRING:  # noqa
-                if char == '\\':
-                    self._stack.append((self._mode, self._state))
-                    self._mode = ListParser._ParseMode.ESCAPE
-                    self._state = ''
-                    continue
+        return self._char_maker(c)
 
-                if char == '"':
-                    self._mode = ListParser._ParseMode.IDLE
-                    self._result = self._state
-                    self._update_stack()
-                    self._state = ''
-                    continue
+    _INT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)')
+    _BIGINT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)N')
+    _FLOAT_PAT = re.compile(r'[-+]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?(0|[1-9][0-9]*))?M?')
 
-                self._state += char
+    def _parse_word(self, tok: Token) -> ta.Any:
+        check.state(tok.kind == 'WORD')
+        src = tok.src
+        check.non_empty_str(src)
+        check.state(not src.startswith('#'))
 
-            elif self._mode == ListParser._ParseMode.ESCAPE:
-                # TODO what should happen when escaping other char
-                escaped_char = self._STRING_ESCAPE_MAP.get(char, char)
-                stack_item, prev_state = self._stack.pop()
-                self._mode = check.isinstance(stack_item, ListParser._ParseMode)
-                self._state = prev_state + escaped_char
+        if src in WORD_CONST_VALUES:
+            return WORD_CONST_VALUES[src]
 
-            elif self._mode == ListParser._ParseMode.COMMENT:
-                if char == '\n':
-                    self._mode = ListParser._ParseMode.IDLE
+        elif src.startswith(':'):
+            return self._keyword_maker(src[1:])
 
-            else:
-                raise RuntimeError(self._mode)
+        elif self._INT_PAT.fullmatch(src):
+            # FIXME: numbers lol
+            # 2r101010, 052, 8r52, 0x2a, 36r16, and 42 are all the same Long.
+            # Floating point numbers are read as Doubles; with M suffix they are read as BigDecimals.
+            # Ratios are supported, e.g. 22/7.
+            return int(src)
 
-        if i >= 0:
-            self._match()
-            self._update_stack()
+        elif self._BIGINT_PAT.fullmatch(src):
+            return int(src[:-1])
 
-        check.state(not self._stack)
+        elif self._FLOAT_PAT.fullmatch(src):
+            return float(src)
 
-        if self._result is not self._UNDEFINED:
-            values.append(self._result)
-        return values
+        else:
+            return self._symbol_maker(src)
 
 
-#
+##
 
 
 def parse_list(src: str, **kwargs: ta.Any) -> list[ta.Any]:
-    """Parse an edn string and return the corresponding Python object."""
-
-    parser = ListParser(**kwargs)
-    return parser.parse(src)
+    r: list[ta.Any] = []
+    with StreamLexer() as l:
+        with StreamParser(**kwargs) as p:
+            for c in [*src, '']:
+                for t in l(c):
+                    for o in p(t):
+                        r.append(o)  # noqa
+    return r
 
 
 def parse(src: str, **kwargs: ta.Any) -> ta.Any | None:
@@ -357,3 +376,25 @@ def parse(src: str, **kwargs: ta.Any) -> ta.Any | None:
     if not values:
         return None
     return check.single(values)
+
+
+##
+
+
+def test_parse():
+    for s in [
+        '"abc"',
+        '"a\\bc"',
+        '{"a" "b"}',
+        '1',
+        '-1',
+        '{a :b c 420}',
+        '#{a}',
+        '(1 #_ 2 3)',
+        '"foo\u1234bar"',
+        '\\x',
+        '\\u1234',
+    ]:
+        print(s)
+        print(parse(s))
+        print()

omlish/formats/edn/values.py

@@ -15,7 +15,7 @@ _DEBUG = __debug__
 
 @dc.dataclass(frozen=True)
 class Value(lang.Abstract, lang.Sealed):
-    pass
+    meta: ta.Any | None = dc.field(default=None, kw_only=True)
 
 
 #
@@ -87,8 +87,8 @@ class List(Collection, lang.Final):
             check.isinstance(self.items, tuple)
 
     @classmethod
-    def new(cls, items: ta.Iterable[ta.Any]) -> 'List':
-        return cls(tuple(items))
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'List':
+        return cls(tuple(items), meta=meta)
 
 
 @dataclass_cache_hash()
@@ -104,8 +104,8 @@ class Vector(Collection, lang.Final):
             check.isinstance(self.items, tuple)
 
     @classmethod
-    def new(cls, items: ta.Iterable[ta.Any]) -> 'Vector':
-        return cls(tuple(items))
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'Vector':
+        return cls(tuple(items), meta=meta)
 
 
 @dataclass_cache_hash()
@@ -121,8 +121,8 @@ class Set(Collection, lang.Final):
             check.isinstance(self.items, tuple)
 
     @classmethod
-    def new(cls, items: ta.Iterable[ta.Any]) -> 'Set':
-        return cls(tuple(items))
+    def new(cls, items: ta.Iterable[ta.Any], *, meta: ta.Any | None = None) -> 'Set':
+        return cls(tuple(items), meta=meta)
 
 
 @dataclass_cache_hash()
@@ -141,8 +141,8 @@ class Map(Collection, lang.Final):
                 check.equal(len(t), 2)
 
     @classmethod
-    def new(cls, items: ta.Iterable[ta.Iterable[ta.Any]]) -> 'Map':
-        return cls(tuple((k, v) for k, v in items))
+    def new(cls, items: ta.Iterable[ta.Iterable[ta.Any]], *, meta: ta.Any | None = None) -> 'Map':
+        return cls(tuple((k, v) for k, v in items), meta=meta)
 
 
 #
@@ -150,7 +150,7 @@ class Map(Collection, lang.Final):
 
 @dataclass_cache_hash()
 @dc.dataclass(frozen=True)
-class TaggedVal(Value, lang.Final):
+class Tagged(Value, lang.Final):
     t: str
     v: ta.Any
 

omlish/formats/json/__init__.py

@@ -35,11 +35,11 @@ from .json import (  # noqa
 )
 
 if _ta.TYPE_CHECKING:
-    from .render import (  # noqa
+    from .rendering import (  # noqa
         JsonRenderer,
     )
 else:
-    _lang.proxy_init(globals(), '.render', [
+    _lang.proxy_init(globals(), '.rendering', [
         'JsonRenderer',
     ])
 

omlish/formats/json/stream/{build.py → building.py}

@@ -1,13 +1,13 @@
 import typing as ta
 
-from .lex import SCALAR_VALUE_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .lexing import SCALAR_VALUE_TYPES
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/{parse.py → parsing.py}

@@ -4,11 +4,11 @@ import typing as ta
 from .... import lang
 from ....funcs.genmachine import GenMachine
 from .errors import JsonStreamError
-from .lex import SCALAR_VALUE_TYPES
-from .lex import VALUE_TOKEN_KINDS
-from .lex import Position
-from .lex import ScalarValue
-from .lex import Token
+from .lexing import SCALAR_VALUE_TYPES
+from .lexing import VALUE_TOKEN_KINDS
+from .lexing import Position
+from .lexing import ScalarValue
+from .lexing import Token
 
 
 ##

omlish/formats/json/stream/{render.py → rendering.py}

@@ -1,14 +1,14 @@
 import io
 import typing as ta
 
-from ..render import AbstractJsonRenderer
+from ..rendering import AbstractJsonRenderer
 from ..types import SCALAR_TYPES
-from .parse import BeginArray
-from .parse import BeginObject
-from .parse import EndArray
-from .parse import EndObject
-from .parse import JsonStreamParserEvent
-from .parse import Key
+from .parsing import BeginArray
+from .parsing import BeginObject
+from .parsing import EndArray
+from .parsing import EndObject
+from .parsing import JsonStreamParserEvent
+from .parsing import Key
 
 
 ##

omlish/formats/json/stream/utils.py

@@ -2,9 +2,9 @@ import dataclasses as dc
 import typing as ta
 
 from .... import lang
-from .build import JsonObjectBuilder
-from .lex import JsonStreamLexer
-from .parse import JsonStreamParser
+from .building import JsonObjectBuilder
+from .lexing import JsonStreamLexer
+from .parsing import JsonStreamParser
 
 
 ##

omlish/funcs/genmachine.py

@@ -34,7 +34,10 @@ class GenMachine(ta.Generic[I, O]):
             if initial is None:
                 raise TypeError('No initial state')
 
-        self._advance(initial)
+        self._gen = initial
+
+        if (n := next(self._gen)) is not None:  # noqa
+            raise GenMachine.NotStartedError
 
     def _initial_state(self) -> MachineGen | None:
         return None
@@ -74,33 +77,34 @@ class GenMachine(ta.Generic[I, O]):
     class Error(Exception):
         pass
 
-    class ClosedError(Exception):
+    class NotStartedError(Error):
         pass
 
-    class StateError(Exception):
+    class ClosedError(Error):
         pass
 
-    #
-
-    def _advance(self, gen: MachineGen) -> None:
-        self._gen = gen
+    class StateError(Error):
+        pass
 
-        if (n := next(self._gen)) is not None:  # noqa
-            raise GenMachine.ClosedError
+    #
 
     def __call__(self, i: I) -> ta.Iterable[O]:
         if self._gen is None:
             raise GenMachine.ClosedError
 
         gi: I | None = i
-        try:
-            while (o := self._gen.send(gi)) is not None:
-                gi = None
-                yield from o
+        while True:
+            try:
+                while (o := self._gen.send(gi)) is not None:  # type: ignore[union-attr]
+                    gi = None
+                    yield from o
 
-        except StopIteration as s:
-            if s.value is None:
-                self._gen = None
-                return None
+                break
 
-            self._advance(s.value)
+            except StopIteration as s:
+                if (sv := s.value) is None:
+                    self._gen = None
+                    return None
+
+                self._gen = sv
+                gi = None

{omlish-0.0.0.dev306.dist-info → omlish-0.0.0.dev307.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev306
+Version: 0.0.0.dev307
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev306.dist-info → omlish-0.0.0.dev307.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=orgsRvtpHu8tdhaCvlP9v3P495OJopYYiHKjK68WtWg,8587
-omlish/__about__.py,sha256=GhIrDhTYihc0evLBX7furXS9SiYupCmrYNe-MrlOL0w,3478
+omlish/__about__.py,sha256=YdK-L7JBeMEmm3Dl7hWjoFj3BouojWQPvOl_zSLUgMA,3478
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -319,21 +319,21 @@ omlish/formats/props.py,sha256=auCv-Jx79KGlWfyG1-Qo0ou-Ex0W_mF3r_lDFdsVkWI,18920
 omlish/formats/repr.py,sha256=kYrNs4o-ji8nOdp6u_L3aMgBMWN1ZAZJSAWgQQfStSQ,414
 omlish/formats/xml.py,sha256=VJfqHR60dhAtjeG8WXFMozFqesTBSGvv264d67eDFXc,3514
 omlish/formats/yaml.py,sha256=jGPQlTE0vSV-p0O7TJRNlf6o1uq4gx8PrHZe1ApJ_o8,7386
-omlish/formats/edn/LICENSE,sha256=EUHM_e21AO5QuuMYXhDE81wmeBxbxeEk_i8oToZhiJo,1078
-omlish/formats/edn/__init__.py,sha256=JXHN8RlPAl-l2OnOQOQgYO8-f2zrYy-bGS2uaHiD9x0,183
+omlish/formats/edn/__init__.py,sha256=H3q5B-dibXvQV8pmuWizTo6Xk75M7M0M7VPCLt86rpo,195
 omlish/formats/edn/codec.py,sha256=k6-Ra3P3Rlv6JA69-jPLI4nCe5XVes_QJbcsj5DYzMM,454
-omlish/formats/edn/parsing.py,sha256=EtpFdeU1DPAh9pvPjEQSBwZJ9OESeonRkUFQdjmIh2Y,11212
-omlish/formats/edn/values.py,sha256=m2mDkX0BP63-e81cBbZnB-S5zPzc-J-tYrFzycqL7AI,3488
+omlish/formats/edn/lexing.py,sha256=plwbFwHLOmrr5_QhmzvMTmTK55Ot0DxRgKY6ASSl_-Y,6966
+omlish/formats/edn/parsing.py,sha256=rtoOnDo8TuTo_GAhrNoVHu7Ys7CboALdgOF2PevAJYk,10152
+omlish/formats/edn/values.py,sha256=jf0g88KJIMALxcuH51SoaMWg1HqTUqc1ugldmyyXWoc,3707
 omlish/formats/ini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/formats/ini/codec.py,sha256=omuFg0kiDksv8rRlWd_v32ebzEcKlgmiPgGID3bRi2M,631
 omlish/formats/ini/sections.py,sha256=7wYyZdVTQbMPFpjQEACKJfAEPzUBrogINsrvFgxJoZ0,1015
-omlish/formats/json/__init__.py,sha256=1lEtsA5v3F34nlhnWCn2CtoC3cgDIubSsxGz5J9wkZs,780
+omlish/formats/json/__init__.py,sha256=HXFv4VDTBhx0k5U4JYWZqxziBwzJoPX51QK3xIboT8U,786
 omlish/formats/json/codecs.py,sha256=E5KErfqsgGZq763ixXLT3qysbk5MIsypT92xG5aSaIs,796
 omlish/formats/json/consts.py,sha256=A0cTAGGLyjo-gcYIQrL4JIaardI0yPMhQoNmh42BaRg,387
 omlish/formats/json/encoding.py,sha256=O4iIWle7W_-RwpOvJNlqOfkbnDyiQHexV5Za4hlrFzw,497
 omlish/formats/json/json.py,sha256=Mdqv2vdMi7gp96eV0BIYH5UdWpjWfsh-tSMZeywG-08,331
 omlish/formats/json/literals.py,sha256=6ptwZyfTXodEtAjDnUhsx6XU3KRZWWYWKYtZ8T7rzsQ,5625
-omlish/formats/json/render.py,sha256=r6J5YKSzcxPg_RiG5idGqJ-AIZozJQ_Awj6W_oSGRjk,4555
+omlish/formats/json/rendering.py,sha256=r6J5YKSzcxPg_RiG5idGqJ-AIZozJQ_Awj6W_oSGRjk,4555
 omlish/formats/json/types.py,sha256=ueO9-uOU2eVWowJf0LH1fHFLjZ6fTIZyq9qybcLQaiQ,147
 omlish/formats/json/backends/__init__.py,sha256=gnaNDCxy_KmmPUPDnjxO5_WjuWxLGbI9FYWx8ZJuQUU,97
 omlish/formats/json/backends/base.py,sha256=WqtyoM82pyM0NyqpPwndrebr1bUVU1QlpmVQNrcAO8c,1114
@@ -343,12 +343,12 @@ omlish/formats/json/backends/orjson.py,sha256=wR8pMGFtkhZGHcNVk7vNYUnv8lUapdK89p
 omlish/formats/json/backends/std.py,sha256=PM00Kh9ZR2XzollHMEvdo35Eml1N-zFfRW-LOCV5ftM,3085
 omlish/formats/json/backends/ujson.py,sha256=BNJCU4kluGHdqTUKLJEuHhE2m2TmqR7HEN289S0Eokg,2278
 omlish/formats/json/stream/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/formats/json/stream/build.py,sha256=EveVyYjc3lbVQRs8Y5uMGEKp0E_gJAUR5bd2ToSVnSU,2533
+omlish/formats/json/stream/building.py,sha256=SGbExmaerqOEiNSom2AERlpyXTj4dpM0QbMW-2WWM2o,2550
 omlish/formats/json/stream/errors.py,sha256=c8M8UAYmIZ-vWZLeKD2jMj4EDCJbr9QR8Jq_DyHjujQ,43
-omlish/formats/json/stream/lex.py,sha256=ItsWvtl5SZH-HwQtPy8Cpf4nszqDzvUTdIOEmSRiZ-E,6807
-omlish/formats/json/stream/parse.py,sha256=JuYmXwtTHmQJTFKoJNoEHUpCPxXdl_gvKPykVXgED34,6208
-omlish/formats/json/stream/render.py,sha256=NtmDsN92xZi5dkgSSuMeMXMAiJblmjz1arB4Ft7vBhc,3715
-omlish/formats/json/stream/utils.py,sha256=QASlxxQGscktsHrORlt8m9V3VWLDakP01QnsSPHLDQ8,1189
+omlish/formats/json/stream/lexing.py,sha256=ItsWvtl5SZH-HwQtPy8Cpf4nszqDzvUTdIOEmSRiZ-E,6807
+omlish/formats/json/stream/parsing.py,sha256=yvH5Llql3Ri_1xDhi1s9CKL6XLJVSQ8vYJ_dz3KAX-4,6223
+omlish/formats/json/stream/rendering.py,sha256=uuJc__MR0G5kypYMAAudBNjBfiIzA_GGli-DWT90428,3730
+omlish/formats/json/stream/utils.py,sha256=UhBRuWbb25wrdQWl8Ttq7xGRLoa329TvNdecGCZxgzg,1197
 omlish/formats/json5/Json5.g4,sha256=ZUmgJPvj8lSMUD_v3wijp10ZQExYB5mu5Q089dYEJSU,2389
 omlish/formats/json5/__init__.py,sha256=BsjPz5zJDji3GjQ8x8hWvcl1GYPV_ZIHnE3c2Sr8aTU,102
 omlish/formats/json5/codec.py,sha256=ldnxCRo0JP1fkGLt0mMxJlLvNxqIF_1KUCcSp1HtI-M,452
@@ -365,7 +365,7 @@ omlish/formats/toml/codec.py,sha256=5HFGWEPd9IFxPlRMRheX8FEDlRIzLe1moHEOj2_PFKU,
 omlish/formats/toml/parser.py,sha256=c6Hrf6OfVQVtgsYUXL5P5PQQqF-v7r8nkUmprxhV-lI,30536
 omlish/formats/toml/writer.py,sha256=HIp6XvriXaPTLqyLe-fkIiEf1Pyhsp0TcOg5rFBpO3g,3226
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/funcs/genmachine.py,sha256=jvctDOJd3X-S2_8C83sgWYz2llYlyhHN7P19-WsanOs,2506
+omlish/funcs/genmachine.py,sha256=8K5fNvFwxctZcVyulOqPLhZ_6Nwh8RAN6yawiE4wFio,2606
 omlish/funcs/match.py,sha256=gMLZn1enNiFvQaWrQubY300M1BrmdKWzeePihBS7Ywc,6153
 omlish/funcs/pairs.py,sha256=VCkZjDmJGtR76BsejsHNfb4TcpHCtkkmak-zWDFchAo,3904
 omlish/funcs/pipes.py,sha256=E7Sz8Aj8ke_vCs5AMNwg1I36kRdHVGTnzxVQaDyn43U,2490
@@ -852,9 +852,9 @@ omlish/typedvalues/holder.py,sha256=ZTnHiw-K38ciOBLEdwgrltr7Xp8jjEs_0Lp69DH-G-o,
 omlish/typedvalues/marshal.py,sha256=hWHRLcrGav7lvXJDtb9bNI0ickl4SKPQ6F4BbTpqw3A,4219
 omlish/typedvalues/reflect.py,sha256=Ih1YgU-srUjsvBn_P7C66f73_VCvcwqE3ffeBnZBgt4,674
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev306.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev306.dist-info/METADATA,sha256=GvMQ6j9pDWhBIlo-FffGTPzRwn6QSfgLdBRQ62RIshY,4416
-omlish-0.0.0.dev306.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-omlish-0.0.0.dev306.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev306.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev306.dist-info/RECORD,,
+omlish-0.0.0.dev307.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev307.dist-info/METADATA,sha256=UgKZG7ukJ09NYqteFnD8DCdWblMH5cosVoyewHJxBTY,4416
+omlish-0.0.0.dev307.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+omlish-0.0.0.dev307.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev307.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev307.dist-info/RECORD,,

{omlish-0.0.0.dev306.dist-info → omlish-0.0.0.dev307.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

omlish/formats/edn/LICENSE

@@ -1,16 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2020 Jorin Vogel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.