Skip to content

Instantly share code, notes, and snippets.

@cellularmitosis

cellularmitosis/Makefile

Last active Jun 16, 2020
Embed
What would you like to do?
mklexer.py part 3: the `refine` pragma

Blog 2020/6/15

<- previous | index | next ->

mklexer.py part 3: the refine pragma

See also: Part 1, 2

In part 3, I've add a refine pragma statement, which will make a second pass over specific types of tokens and further refine them into more specific types of tokens.

TL;DR:

You can use #pragma refine TOKENTYPE to implement a second pass to further refine a token's type:

IDENTIFIER
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+

#pragma refine IDENTIFIER
WHILE
while
CONTINUE
continue
BREAK
break

#pragma refine WSPACE
NEWLINE
\n

The problem: recognizing keywords as being separate from identifiers

Take a trivial lexer grammar which recognizes identifiers and numbers:

grammar.txt:

IDENTIFIER
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+

Generate a lexer using this grammar:

./mklexer.py grammar.txt > lexer.py
chmod +x lexer.py

If we feed it this input:

input.txt:

foo 42
continue

we'll get this JSON:

$ ./lexer.py input.txt | jq .
[
  {
    "type": "format",
    "format": "tokens"
  },
  [
    {
      "type": "token",
      "token_type": "IDENTIFIER",
      "text": "foo"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": " "
    },
    {
      "type": "token",
      "token_type": "NUMBER",
      "text": "42"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": "\n"
    },
    {
      "type": "token",
      "token_type": "IDENTIFIER",
      "text": "continue"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": "\n"
    }
  ]
]

Let's say we want our tokenizer to reconize certain language keywords, like while, break, continue, etc.

We run into problems if we try to implement this directly in the lexer grammar:

grammar.txt:

IDENTIFIER
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+
CONTINUE
continue
$ echo continue > input.txt
$ ./lexer.py input.txt | jq .
[
  {
    "type": "format",
    "format": "tokens"
  },
  [
    {
      "type": "token",
      "token_type": "IDENTIFIER",
      "text": "continue"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": "\n"
    }
  ]
]

Here, continue was mistakenly recognized as an IDENTIFIER token, because the IDENTIFER rule precedes the CONTINUE rule.

"So let's just move CONTINUE to come before IDENTIFIER." you say?

That leads to a different problem:

grammar.txt:

CONTINUE
continue
IDENTIFIER
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+
$ ./mklexer.py grammar.txt > lexer.py
$ echo continuezzz > input.txt
$ ./lexer.py input.txt | jq .
[
  {
    "type": "format",
    "format": "tokens"
  },
  [
    {
      "type": "token",
      "token_type": "CONTINUE",
      "text": "continue"
    },
    {
      "type": "token",
      "token_type": "IDENTIFIER",
      "text": "zzz"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": "\n"
    }
  ]
]

Here, continuezzz should have been recognized as an IDENTIFIER, rather than CONTINUE followed by IDENTIFIER('zzz').

"Ok, well we could add negative lookahead to implement a word boundary at the end of CONTINUE tokens" you say.

We could! But for me, this is straying into what I consider to be the job of the parser.

A solution: the refine pragma

The approach I've implemented is to use second passes to refine some token types into more specific token types. This is done by adding a #pragma refine section to the lexer grammar.

For example, let's recognize while, continue and break as keywords, and make a specific token for newlines:

grammar.txt:

IDENTIFIER
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+

#pragma refine IDENTIFIER
WHILE
while
CONTINUE
continue
BREAK
break

#pragma refine WSPACE
NEWLINE
\n

input.txt:

whilezzz while
42
$ ./mklexer.py grammar.txt > lexer.py
$ ./lexer.py input.txt | jq .
[
  {
    "type": "format",
    "format": "tokens"
  },
  [
    {
      "type": "token",
      "token_type": "IDENTIFIER",
      "text": "whilezzz"
    },
    {
      "type": "token",
      "token_type": "WSPACE",
      "text": " "
    },
    {
      "type": "token",
      "token_type": "WHILE",
      "text": "while"
    },
    {
      "type": "token",
      "token_type": "NEWLINE",
      "text": "\n"
    },
    {
      "type": "token",
      "token_type": "NUMBER",
      "text": "42"
    },
    {
      "type": "token",
      "token_type": "NEWLINE",
      "text": "\n"
    }
  ]
]

Bingo!

Note however that this isn't perfect! As with every decision in tech, this solution is a trade-off:

Positives:

  • Easy to understand
  • Easy to implement

Negatives:

  • Performance: this is not the fastest way to implement a lexer.
#!/usr/bin/env python
import base64
import sys
import os
infile = sys.argv[1]
outfile = os.path.basename(infile).rstrip('.base64')
s64 = open(infile,'rb').read()
s = base64.b64decode(s64)
open(outfile,'wb').write(s)
#!/usr/bin/env python
import base64
import sys
import os
infile = sys.argv[1]
outfile = os.path.basename(infile) + ".base64"
s = open(infile,'rb').read()
s64 = base64.b64encode(s)
open(outfile,'wb').write(s64)
lexer.py: mklexer.py tokendefs.txt
./mklexer.py tokendefs.txt > lexer.py
chmod +x lexer.py
test:
./test.sh
tests.tar.base64:
tar c tests > tests.tar
python b64enc.py tests.tar
rm -f tests.tar
clean:
rm -f lexer.py tests.tar
.PHONY: clean test tests.tar.base64
#!/usr/bin/env python
# mklexer.py: generate a Python lexer based on a token definitions file.
# See https://gist.github.com/cellularmitosis/1da62db09d41703c5a505d0bac9d9056
# Copyright (c) 2020 Jason Pepas
# Released under the terms of the MIT license.
# See https://opensource.org/licenses/MIT
import sys
import os
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
def usage(fd):
"""Prints the usage help to the given file descriptor."""
exe = os.path.basename(sys.argv[0])
w = fd.write
if fd is sys.stderr:
w("Error: bad usage.\n")
w("\n")
else:
w("%s: generate a Python lexer based on a token definitions file.\n" % exe)
w("\n")
w("Display help:\n")
w(" %s -h\n" % exe)
w(" %s --help\n" % exe)
w("\n")
w("Generate a lexer using tokendefs.txt:\n")
w(" %s tokendefs.txt > lexer.py\n" % exe)
w(" chmod +x lexer.py\n")
w("""
tokendefs.txt consists of pairs of TOKENTYPE and <regex> lines.
Example tokendefs.txt:
NUMBER
-?\\d+(\\.\\d+)?
SYMBOL
[a-zA-Z_][a-zA-Z0-9_-]*
Use the lexer on input.txt, producing the standard JSON token format:
./lexer.py input.txt | jq .
Two example tokens in standard JSON format:
{'type': 'TOKEN', 'token_type': 'NUMBER', 'text': '3.14159'}
{'type': 'TOKEN', 'token_type': 'SYMBOL', 'text': 'fibonacci'}
Use the lexer on input.txt, producing "fast" array-based JSON tokens:
./lexer.py --fast input.txt | jq .
"fast" tokens are [<token type index>, <matched text>] pairs.
The same example tokens, but in 'fast' JSON format:
[0, '3.14159']
[1, 'fibonacci']
tokendefs.txt may also contain #pragma's: line-oriented, discard, eof, refine.
""")
def parse_tokendefs(lines):
"""Parses the token definitions file, stopping at the first 'refine' pragma."""
tokendefs = []
pragmas = {}
i = 0
while i < len(lines):
line = lines[i]
if len(line) == 0:
# skip blank lines
i += 1
continue
words = line.split()
if words[0] == '#pragma':
if len(words) == 1:
raise Exception("Can't parse pragma: %s" % line)
pragma_name = words[1]
if pragma_name in ['line-oriented', 'eof']:
pragmas[pragma_name] = True
i += 1
continue
elif pragma_name == 'discard':
discardable_token_types = words[2:]
if len(discardable_token_types) == 0:
raise Exception("Discard pragma with no token types listed")
pragmas[pragma_name] = discardable_token_types
i += 1
continue
elif pragma_name == 'refine':
break
else:
raise Exception("Unknown pragma '%s'" % pragma_name)
if line[0] == '#':
# this is just a comment.
i += 1
continue
tokentype = line
i += 1
if i >= len(lines):
raise Exception(
"Line %d: Token type '%s' has no corresponding regex." \
% (i, tokentype)
)
regex = lines[i]
if len(regex) == 0:
raise Exception("Line %d: Zero-length regex." % i+1)
i += 1
pair = (tokentype, regex)
tokendefs.append(pair)
continue
remaining_lines = lines[i:]
return (pragmas, tokendefs, remaining_lines)
def parse_refine_section(lines):
"""Parses a 'refine' pragma."""
line1 = lines[0]
if len(lines) == 1:
raise Exception("Empty refine section: '%s'" % line1)
refined_token_type = line1.split()[2]
refine_defs = []
i = 1
while i < len(lines):
line = lines[i]
if len(line) == 0:
# skip blank lines
i += 1
continue
words = line.split()
if words[0] == '#pragma':
if len(words) == 1:
raise Exception("Can't parse pragma: %s" % line)
pragma_name = words[1]
if pragma_name == 'refine':
break
else:
raise Exception("Pragma not allowed in 'refine' section: '%s'" % pragma_name)
if line[0] == '#':
# this is just a comment.
i += 1
continue
tokentype = line
i += 1
if i >= len(lines):
raise Exception(
"Line %d: Token type '%s' has no corresponding regex." \
% (i+1, tokentype)
)
regex = lines[i]
if len(tokentype) == 0:
raise Exception("Line %d: Zero-length regex." % i+1)
i += 1
pair = (tokentype, regex)
refine_defs.append(pair)
continue
refine_struct = [refined_token_type, refine_defs]
remaining_lines = lines[i:]
return (refine_struct, remaining_lines)
def codegen_pragmas(pragmas):
"""Generates the Python code for pragmas."""
fd = StringIO()
w = fd.write
is_line_oriented = 'line-oriented' in pragmas.keys()
w("pragma_line_oriented = %s\n" % is_line_oriented)
has_eof_pragma = 'eof' in pragmas.keys()
w("pragma_eof = %s\n" % has_eof_pragma)
if 'discard' in pragmas.keys():
toktypes_string = '[%s]' % ','.join(
[("'%s'" % token_type) for token_type in pragmas['discard']]
)
w("pragma_discard = %s\n" % toktypes_string)
else:
w("pragma_discard = []\n")
w('\n')
code = fd.getvalue()
fd.close()
return code
def codegen_regex(regex_text):
"""Generates the Python code of a regex."""
# do everything we can to avoid the backslash plague.
if "'" not in regex_text:
return "r'%s'" % regex_text
elif '"' not in regex_text:
return 'r"%s"' % regex_text
elif "'''" not in regex_text and not regex_text.startswith("'") and not regex_text.endswith("'"):
return "r'''%s'''" % regex_text
elif '"""' not in regex_text and not regex_text.startswith('"') and not regex_text.endswith('"'):
return 'r"""%s"""' % regex_text
else:
# oh well, at least we tried :shrug:
return regex_text.__repr__()
def codegen_tokendefs(tokendefs):
"""Generates the Python code of the tokendefs table."""
fd = StringIO()
w = fd.write
w("tokendefs = [\n")
for token_type, regex in tokendefs:
w(" ['%s', %s],\n" % (token_type, codegen_regex(regex)))
w("]\n")
code = fd.getvalue()
fd.close()
return code
def codegen_refinements(refines):
"""Generates the Python code of the refinements table."""
fd = StringIO()
w = fd.write
w("refinements = [\n")
for refined_token_type, tokendefs in refines:
w(" ['%s', [\n" % refined_token_type)
for token_type, regex in tokendefs:
w(" ['%s', %s],\n" % (token_type, codegen_regex(regex)))
w(" ]],\n")
w("]\n")
code = fd.getvalue()
fd.close()
return code
def codegen_toktypes(pragmas, tokendefs, refines):
toktypes = []
for tokendef in tokendefs:
toktype = tokendef[0]
toktypes.append(toktype)
for refinement in refines:
for tokdef in refinement[1]:
toktype = tokdef[0]
toktypes.append(toktype)
if 'eof' in pragmas.keys():
toktypes.append('EOF')
return "toktypes = %s\n" % toktypes
def codegen(pragmas, tokendefs, refines):
"""Generates the Python code of the lexer."""
fd = StringIO()
w = fd.write
w("""#!/usr/bin/env python
# DO NOT EDIT: this lexer was generated by mklexer.py.
import sys
import re
import json
""")
pragmas_code = codegen_pragmas(pragmas)
w(pragmas_code)
tokendefs_code = codegen_tokendefs(tokendefs)
w(tokendefs_code + '\n')
refinements_code = codegen_refinements(refines)
w(refinements_code + '\n')
toktypes_code = codegen_toktypes(pragmas, tokendefs, refines)
w(toktypes_code)
w("""
def compile_regexes():
\"\"\"Compile the regexes.\"\"\"
for pair in tokendefs:
pair[1] = re.compile(pair[1])
for refinement in refinements:
for pair in refinement[1]:
pair[1] = re.compile(pair[1] + '$')
compile_regexes()
def get_linenum_charnum(text, offset):
\"\"\"Returns the line number and character number of the offset.\"\"\"
linenum = 1
charnum = 1
i = 0
while i < offset:
if text[i] == '\\n':
linenum += 1
charnum = 1
i += 1
continue
else:
charnum += 1
i += 1
continue
return (linenum, charnum)
def consume_next_token(text, offset, use_fast_format):
\"\"\"Consumes next token from the given text input.
Returns a (token, offset) pair.
Throws if no tokens match.\"\"\"
for i, pair in enumerate(tokendefs):
(token_type, regex) = pair
m = regex.match(text, offset)
if m is None:
continue
matched_text = m.group()
if use_fast_format:
token = [i, matched_text]
else:
token = {
'type': 'token',
'token_type': token_type,
'text': matched_text,
}
new_offset = offset + len(matched_text)
return (token, new_offset)
# none of the token types matched
(linenum, charnum) = get_linenum_charnum(text, offset)
raise Exception(
"Can't lex starting at line %d, character %d, context: '%s'" \\
% (linenum, charnum, text[offset:offset+32])
)
def discard_tokens(tokens, use_fast_format):
\"\"\"Discards any tokens specified by the 'discard' pragma.\"\"\"
def make_discard_set():
if use_fast_format:
discard_set = set()
for i, pair in enumerate(tokendefs):
(token_type, _) = pair
if token_type in pragma_discard:
discard_set.add(i)
continue
else:
discard_set = set(pragma_discard)
return discard_set
discard_set = make_discard_set()
kept_tokens = []
for token in tokens:
if use_fast_format:
toktype = token[0]
else:
toktype = token['token_type']
if toktype not in discard_set:
kept_tokens.append(token)
continue
return kept_tokens
def make_lines(tokens, use_fast_format):
\"\"\"Return a line-oriented array-of-arrays from the given tokens.\"\"\"
lines = []
line = []
for token in tokens:
if use_fast_format:
text = token[1]
else:
text = token['text']
if text == '\\n':
lines.append(line)
line = []
continue
else:
line.append(token)
continue
if len(line) > 0:
lines.append(line)
return lines
def refine(tokens, use_fast_format):
\"\"\"Further refine the lexed tokens.\"\"\"
for refinement in refinements:
refineable_token_type = refinement[0]
pairs = refinement[1]
for token in tokens:
replacement_token = None
if use_fast_format:
token_type_index = token[0]
token_type = toktypes[token_type_index]
if token_type != refineable_token_type:
continue
for refined_token_type, regex in pairs:
token_text = token[1]
m = regex.match(token_text)
if m:
token[0] = toktypes.index(refined_token_type)
continue
continue
else:
if token['token_type'] != refineable_token_type:
continue
for refined_token_type, regex in pairs:
m = regex.match(token['text'])
if m:
token['token_type'] = refined_token_type
continue
continue
continue
return
def lex(text, use_fast_format):
\"\"\"Returns a list of tokens for the given text input.\"\"\"
tokens = []
offset = 0
while offset < len(text):
(token, offset) = consume_next_token(text, offset, use_fast_format)
tokens.append(token)
continue
refine(tokens, use_fast_format)
tokens = discard_tokens(tokens, use_fast_format)
if pragma_line_oriented:
tokens = make_lines(tokens, use_fast_format)
if pragma_eof:
if use_fast_format:
eof_token = [len(toktypes)-1, ""]
else:
eof_token = {
"type": "token",
"token_type": "EOF",
"text": ""
}
if pragma_line_oriented:
tokens.append([eof_token])
else:
tokens.append(eof_token)
format_dict = {'type': 'format'}
if use_fast_format:
if pragma_line_oriented:
format_dict['format'] = 'fast-lines'
else:
format_dict['format'] = 'fast'
format_dict['token_types'] = toktypes
else:
if pragma_line_oriented:
format_dict['format'] = 'tokens-lines'
else:
format_dict['format'] = 'tokens'
json_obj = [format_dict, tokens]
return json_obj
if __name__ == '__main__':
infile = [arg for arg in sys.argv[1:] if not arg.startswith('-')][-1]
use_fast_format = False
if '--fast' in sys.argv[1:]:
use_fast_format = True
fd = open(infile, 'r')
text = fd.read()
fd.close()
json_obj = lex(text, use_fast_format)
output = json.dumps(json_obj)
if not output.endswith('\\n'):
output += '\\n'
sys.stdout.write(output)
""")
code = fd.getvalue()
fd.close()
return code
if __name__ == "__main__":
if len(sys.argv) < 2:
usage(sys.stderr)
sys.exit(1)
if '-h' in sys.argv or '--help' in sys.argv:
usage(sys.stdout)
sys.exit(0)
# the last non-option arg is the tokendefs file.
tokendefs_fpath = None
non_option_args = [arg for arg in sys.argv[1:] if not arg.startswith('-')]
if len(non_option_args) != 1:
usage(sys.stderr)
sys.exit(1)
tokendefs_fpath = non_option_args[0]
fd = open(tokendefs_fpath, 'r')
tokendefs_lines = fd.read().splitlines()
fd.close()
(pragmas, tokendefs, remaining_lines) = parse_tokendefs(tokendefs_lines)
refines = []
while len(remaining_lines) > 0:
(refine_struct, remaining_lines) = parse_refine_section(remaining_lines)
refines.append(refine_struct)
code = codegen(pragmas, tokendefs, refines)
sys.stdout.write(code)
#!/bin/bash
set -e
set -o pipefail
shopt -s expand_aliases
alias canonicaljson="python -c 'import json, sys; sys.stdout.write(json.dumps(json.load(sys.stdin), sort_keys=True))'"
if ! test -d tests
then
rm -f tests.tar
python b64dec.py tests.tar.base64
cat tests.tar | tar x
rm -f tests.tar
fi
for d in $( ls tests )
do
echo "Test $d"
cd tests/$d
../../mklexer.py grammar.txt > /tmp/lexer.py
echo " Python 2"
cat answer.txt | canonicaljson > /tmp/1
python2 /tmp/lexer.py input.txt | canonicaljson > /tmp/2
diff -q /tmp/1 /tmp/2
echo " Python 3"
python3 /tmp/lexer.py input.txt | canonicaljson > /tmp/2
diff -q /tmp/1 /tmp/2
echo " Python 2, --fast format"
cat answer-fast.txt | canonicaljson > /tmp/1
python2 /tmp/lexer.py --fast input.txt | canonicaljson > /tmp/2
diff -q /tmp/1 /tmp/2
echo " Python 3, --fast format"
python3 /tmp/lexer.py --fast input.txt | canonicaljson > /tmp/2
diff -q /tmp/1 /tmp/2
rm -f /tmp/lexer.py /tmp/1 /tmp/2
cd ../..
done
tests/                                                                                              0000755 0601750 0601001 00000000000 13671773544 010642  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/001/                                                                                          0000755 0601750 0601001 00000000000 13671324467 011136  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/001/answer-fast.txt                                                                           0000644 0601750 0601001 00000000261 13671324467 014130  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast", "token_types": ["SYMBOL", "WSPACE"]},
 [
  [0, "foo"],
  [1, " "],
  [0, "bar"],
  [1, "   "],
  [0, "baz"],
  [1, "\n"]
 ]
]
                                                                                                                                                                                                                                                                                                                                               tests/001/answer.txt                                                                                0000644 0601750 0601001 00000000642 13671324467 013200  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens"},
 [
  {"type": "token", "token_type": "SYMBOL", "text": "foo"},
  {"type": "token", "token_type": "WSPACE", "text": " "},
  {"type": "token", "token_type": "SYMBOL", "text": "bar"},
  {"type": "token", "token_type": "WSPACE", "text": "   "},
  {"type": "token", "token_type": "SYMBOL", "text": "baz"},
  {"type": "token", "token_type": "WSPACE", "text": "\n"}
 ]
]
                                                                                              tests/001/grammar.txt                                                                               0000644 0601750 0601001 00000000031 13671233102 013300  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   SYMBOL
[a-z]+
WSPACE
\s+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       tests/001/input.txt                                                                                 0000644 0601750 0601001 00000000016 13671233142 013020  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo bar   baz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tests/002/                                                                                          0000755 0601750 0601001 00000000000 13671324467 011137  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/002/answer-fast.txt                                                                           0000644 0601750 0601001 00000000320 13671324467 014125  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast-lines", "token_types": ["SYMBOL", "WSPACE"]},
 [
  [
   [0, "foo"],
   [1, " "],
   [0, "bar"]
  ],
  [
   [0, "bin"],
   [1, " "],
   [0, "baz"]
  ]
 ]
]
                                                                                                                                                                                                                                                                                                                tests/002/answer.txt                                                                                0000644 0601750 0601001 00000000701 13671324467 013175  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens-lines"},
 [
  [
   {"type": "token", "token_type": "SYMBOL", "text": "foo"},
   {"type": "token", "token_type": "WSPACE", "text": " "},
   {"type": "token", "token_type": "SYMBOL", "text": "bar"}
  ],
  [
   {"type": "token", "token_type": "SYMBOL", "text": "bin"},
   {"type": "token", "token_type": "WSPACE", "text": " "},
   {"type": "token", "token_type": "SYMBOL", "text": "baz"}
  ]
 ]
]
                                                               tests/002/grammar.txt                                                                               0000644 0601750 0601001 00000000057 13671324467 013330  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   #pragma line-oriented
SYMBOL
[a-z]+
WSPACE
\s+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 tests/002/input.txt                                                                                 0000644 0601750 0601001 00000000020 13671324467 013027  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo bar
bin baz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tests/003/                                                                                          0000755 0601750 0601001 00000000000 13671324467 011140  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/003/answer-fast.txt                                                                           0000644 0601750 0601001 00000000202 13671324467 014125  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast", "token_types": ["SYMBOL", "NUMBER", "WSPACE"]},
 [
  [0, "foo"],
  [0, "bar"]
 ]
]
                                                                                                                                                                                                                                                                                                                                                                                              tests/003/answer.txt                                                                                0000644 0601750 0601001 00000000261 13671324467 013177  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens"},
 [
  {"type": "token", "token_type": "SYMBOL", "text": "foo"},
  {"type": "token", "token_type": "SYMBOL", "text": "bar"}
 ]
]
                                                                                                                                                                                                                                                                                                                                               tests/003/grammar.txt                                                                               0000644 0601750 0601001 00000000105 13671324467 013323  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   #pragma discard WSPACE NUMBER
SYMBOL
[a-z]+
NUMBER
[0-9]+
WSPACE
\s+
                                                                                                                                                                                                                                                                                                                                                                                                                                                           tests/003/input.txt                                                                                 0000644 0601750 0601001 00000000014 13671324467 013033  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo 123 bar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tests/004/                                                                                          0000755 0601750 0601001 00000000000 13671324467 011141  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/004/answer-fast.txt                                                                           0000644 0601750 0601001 00000000304 13671324467 014131  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast", "token_types": ["SYMBOL", "WSPACE", "EOF"]},
 [
  [0, "foo"],
  [1, " "],
  [0, "bar"],
  [1, "   "],
  [0, "baz"],
  [1, "\n"],
  [2, ""]
 ]
]
                                                                                                                                                                                                                                                                                                                            tests/004/answer.txt                                                                                0000644 0601750 0601001 00000000731 13671324467 013202  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens"},
 [
  {"type": "token", "token_type": "SYMBOL", "text": "foo"},
  {"type": "token", "token_type": "WSPACE", "text": " "},
  {"type": "token", "token_type": "SYMBOL", "text": "bar"},
  {"type": "token", "token_type": "WSPACE", "text": "   "},
  {"type": "token", "token_type": "SYMBOL", "text": "baz"},
  {"type": "token", "token_type": "WSPACE", "text": "\n"},
  {"type": "token", "token_type": "EOF", "text": ""}
 ]
]
                                       tests/004/grammar.txt                                                                               0000644 0601750 0601001 00000000045 13671324467 013327  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   #pragma eof
SYMBOL
[a-z]+
WSPACE
\s+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           tests/004/input.txt                                                                                 0000644 0601750 0601001 00000000016 13671324467 013036  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo bar   baz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tests/005/                                                                                          0000755 0601750 0601001 00000000000 13671324467 011142  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/005/answer-fast.txt                                                                           0000644 0601750 0601001 00000000320 13671324467 014130  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast-lines", "token_types": ["SYMBOL", "WSPACE", "EOF"]},
 [
  [
   [0, "foo"],
   [1, " "],
   [0, "bar"]
  ],
  [
   [0, "baz"]
  ],
  [
   [2, ""]
  ]
 ]
]
                                                                                                                                                                                                                                                                                                                tests/005/answer.txt                                                                                0000644 0601750 0601001 00000000611 13671324467 013200  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens-lines"},
 [
  [
   {"type": "token", "token_type": "SYMBOL", "text": "foo"},
   {"type": "token", "token_type": "WSPACE", "text": " "},
   {"type": "token", "token_type": "SYMBOL", "text": "bar"}
  ],
  [
   {"type": "token", "token_type": "SYMBOL", "text": "baz"}
  ],
  [
   {"type": "token", "token_type": "EOF", "text": ""}
  ]
 ]
]
                                                                                                                       tests/005/grammar.txt                                                                               0000644 0601750 0601001 00000000073 13671324467 013331  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   #pragma line-oriented
#pragma eof
SYMBOL
[a-z]+
WSPACE
\s+
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     tests/005/input.txt                                                                                 0000644 0601750 0601001 00000000014 13671324467 013035  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo bar
baz
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tests/006/                                                                                          0000755 0601750 0601001 00000000000 13671773744 011151  5                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   tests/006/answer-fast.txt                                                                           0000644 0601750 0601001 00000000337 13671773544 014145  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "fast", "token_types": [
     "SYMBOL", "WSPACE", "BREAK", "CONTINUE", "NEWLINE"
 ]},
 [
  [0, "foo"],
  [1, " "],
  [0, "bar"],
  [4, "\n"],
  [3, "continue"],
  [4, "\n"]
 ]
]
                                                                                                                                                                                                                                                                                                 tests/006/answer.txt                                                                                0000644 0601750 0601001 00000000652 13671773544 013212  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   [
 {"type": "format", "format": "tokens"},
 [
  {"type": "token", "token_type": "SYMBOL", "text": "foo"},
  {"type": "token", "token_type": "WSPACE", "text": " "},
  {"type": "token", "token_type": "SYMBOL", "text": "bar"},
  {"type": "token", "token_type": "NEWLINE", "text": "\n"},
  {"type": "token", "token_type": "CONTINUE", "text": "continue"},
  {"type": "token", "token_type": "NEWLINE", "text": "\n"}
 ]
]
                                                                                      tests/006/grammar.txt                                                                               0000644 0601750 0601001 00000000160 13671773544 013333  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   SYMBOL
[a-z]+
WSPACE
\s+

#pragma refine SYMBOL
BREAK
break
CONTINUE
continue

#pragma refine WSPACE
NEWLINE
\n
                                                                                                                                                                                                                                                                                                                                                                                                                tests/006/input.txt                                                                                 0000644 0601750 0601001 00000000021 13671773544 013040  0                                                                                                    ustar   cell                            None                                                                                                                                                                                                                   foo bar
continue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.