Parse, print.
'''
from re import Scanner
from .utils.stack import list_to_stack
+from .utils.snippets import (
+ pat as SNIPPETS,
+ from_string,
+ Snippet,
+ )
BRACKETS = r'\[|\]'
token_scanner = Scanner([
+ (SNIPPETS, lambda _, token: from_string(token)),
(BRACKETS, lambda _, token: token),
(BLANKS, None),
(WORDS, lambda _, token: token),
frame.append(True)
elif tok == 'false':
frame.append(False)
+ elif isinstance(tok, Snippet):
+ frame.append(tok)
else:
try:
thing = int(tok)
from re import compile as RE
Snippet = namedtuple('Snippet', 'sha offset length')
-fmt = '{%s %i %i}'
+_fmt = '{%s %i %i}'
pat = (
'{'
'\s*'
'\s*'
'}'
)
-PAT = RE(pat)
+_PAT = RE(pat)
def to_string(snip):
- return fmt % _ts(*snip)
+ return _fmt % _ts(*snip)
def _ts(sha, offset, length):
return sha.decode('ascii'), offset, length
def from_string(text):
- m = PAT.match(text)
+ m = _PAT.match(text)
if not m:
raise ValueError
return _fs(**m.groupdict())
def _fs(sha, offset, length):
return Snippet(sha.encode('ascii'), int(offset), int(length))
-
'''
from .errors import NotAListError
+from .snippets import Snippet, to_string as snip_to_string
def list_to_stack(el, stack=()):
def _joy_repr(thing):
- if isinstance(thing, bool):
- return _JOY_BOOL_LITS[thing]
- return repr(thing)
+ if isinstance(thing, bool): return _JOY_BOOL_LITS[thing]
+ if isinstance(thing, Snippet): return snip_to_string(thing)
+ return repr(thing)
def _to_string(stack, f):
if not isinstance(stack, tuple): return _joy_repr(stack)
if not stack: return '' # shortcut
+ if isinstance(stack, Snippet): return snip_to_string(stack)
return ' '.join(map(_s, f(stack)))
_s = lambda s: (
'[%s]' % expression_to_string(s)
if isinstance(s, tuple)
+ and not isinstance(s, Snippet)
+ # Is it worth making a non-tuple class for Snippet?
+ # Doing this check on each tuple seems a bit much.
else _joy_repr(s)
)