Skip to content

Instantly share code, notes, and snippets.

@olasd olasd/output
Last active Dec 15, 2015

Embed
What would you like to do?
Parsley is fun.
⏚ [nicolasd:~/code/parsley] [parsley] $ python test_parsley.py
('root',
[(1, 0), (346, 0)],
('parens',
[(3, 0), (3, 36)],
('token', [(3, 1), (3, 12)], 'import-from'),
('token',
[(3, 13), (3, 28)],
'tests.resources'),
('token', [(3, 29), (3, 35)], 'kwtest')),
('parens',
[(4, 0), (4, 41)],
('token', [(4, 1), (4, 12)], 'import-from'),
('token', [(4, 13), (4, 20)], 'os.path'),
('token', [(4, 21), (4, 27)], 'exists'),
('token', [(4, 28), (4, 33)], 'isdir'),
('token', [(4, 34), (4, 40)], 'isfile')),
('parens',
[(5, 0), (5, 12)],
('token', [(5, 1), (5, 7)], 'import'),
('token', [(5, 8), (5, 11)], 'sys')),
('parens',
[(6, 0), (6, 23)],
('token', [(6, 1), (6, 10)], 'import-as'),
('token', [(6, 11), (6, 14)], 'sys'),
('token', [(6, 15), (6, 22)], 'systest')),
('parens',
[(9, 0), (14, 38)],
('token', [(9, 1), (9, 5)], 'defn'),
('token', [(9, 6), (9, 19)], 'test-sys-argv'),
('list', [(9, 20), (9, 22)]),
('string',
[(10, 2), (10, 25)],
'NATIVE: test sys.argv'),
('parens',
[(14, 2), (14, 37)],
('token', [(14, 3), (14, 9)], 'assert'),
('parens',
[(14, 10), (14, 36)],
('token',
[(14, 11), (14, 21)],
'isinstance'),
('token',
[(14, 22), (14, 30)],
'sys.argv'),
('token', [(14, 31), (14, 35)], 'list')))),
('parens',
[(17, 0), (19, 41)],
('token', [(17, 1), (17, 5)], 'defn'),
('token', [(17, 6), (17, 16)], 'test-lists'),
('list', [(17, 17), (17, 19)]),
('string',
[(18, 2), (18, 33)],
'NATIVE: test lists work right'),
('parens',
[(19, 2), (19, 40)],
('token', [(19, 3), (19, 9)], 'assert'),
('parens',
[(19, 10), (19, 39)],
('token', [(19, 11), (19, 12)], '='),
('list',
[(19, 13), (19, 22)],
('number', [(19, 14), (19, 15)], '1'),
('number', [(19, 16), (19, 17)], '2'),
('number', [(19, 18), (19, 19)], '3'),
('number', [(19, 20), (19, 21)], '4')),
('parens',
[(19, 23), (19, 38)],
('token', [(19, 24), (19, 25)], '+'),
('list',
[(19, 26), (19, 31)],
('number', [(19, 27), (19, 28)], '1'),
('number', [(19, 29), (19, 30)], '2')),
('list',
[(19, 32), (19, 37)],
('number', [(19, 33), (19, 34)], '3'),
('number', [(19, 35), (19, 36)], '4')))))),
('parens',
[(22, 0), (32, 25)],
('token', [(22, 1), (22, 5)], 'defn'),
('token',
[(22, 6), (22, 19)],
'test-for-loop'),
('list', [(22, 20), (22, 22)]),
('string',
[(23, 2), (23, 27)],
'NATIVE: test for loops?'),
('parens',
[(24, 2), (24, 16)],
('token', [(24, 3), (24, 7)], 'setv'),
('token', [(24, 8), (24, 13)], 'count'),
('number', [(24, 14), (24, 15)], '0')),
('parens',
[(25, 2), (26, 29)],
('token', [(25, 3), (25, 6)], 'for'),
('list',
[(25, 7), (25, 22)],
('token', [(25, 8), (25, 9)], 'x'),
('list',
[(25, 10), (25, 21)],
('number', [(25, 11), (25, 12)], '1'),
('number', [(25, 13), (25, 14)], '2'),
('number', [(25, 15), (25, 16)], '3'),
('number', [(25, 17), (25, 18)], '4'),
('number', [(25, 19), (25, 20)], '5'))),
('parens',
[(26, 4), (26, 28)],
('token', [(26, 5), (26, 9)], 'setv'),
('token', [(26, 10), (26, 15)], 'count'),
('parens',
[(26, 16), (26, 27)],
('token', [(26, 17), (26, 18)], '+'),
('token',
[(26, 19), (26, 24)],
'count'),
('token', [(26, 25), (26, 26)], 'x')))),
('parens',
[(27, 2), (27, 23)],
('token', [(27, 3), (27, 9)], 'assert'),
('parens',
[(27, 10), (27, 22)],
('token', [(27, 11), (27, 12)], '='),
('token', [(27, 13), (27, 18)], 'count'),
('number', [(27, 19), (27, 21)], '15'))),
('parens',
[(28, 2), (28, 16)],
('token', [(28, 3), (28, 7)], 'setv'),
('token', [(28, 8), (28, 13)], 'count'),
('number', [(28, 14), (28, 15)], '0')),
('parens',
[(29, 2), (31, 31)],
('token', [(29, 3), (29, 6)], 'for'),
('list',
[(29, 7), (30, 22)],
('token', [(29, 8), (29, 9)], 'x'),
('list',
[(29, 10), (29, 21)],
('number', [(29, 11), (29, 12)], '1'),
('number', [(29, 13), (29, 14)], '2'),
('number', [(29, 15), (29, 16)], '3'),
('number', [(29, 17), (29, 18)], '4'),
('number', [(29, 19), (29, 20)], '5')),
('token', [(30, 8), (30, 9)], 'y'),
('list',
[(30, 10), (30, 21)],
('number', [(30, 11), (30, 12)], '1'),
('number', [(30, 13), (30, 14)], '2'),
('number', [(30, 15), (30, 16)], '3'),
('number', [(30, 17), (30, 18)], '4'),
('number', [(30, 19), (30, 20)], '5'))),
('parens',
[(31, 4), (31, 30)],
('token', [(31, 5), (31, 9)], 'setv'),
('token', [(31, 10), (31, 15)], 'count'),
('parens',
[(31, 16), (31, 29)],
('token', [(31, 17), (31, 18)], '+'),
('token',
[(31, 19), (31, 24)],
'count'),
('token', [(31, 25), (31, 26)], 'x'),
('token', [(31, 27), (31, 28)], 'y')))),
('parens',
[(32, 2), (32, 24)],
('token', [(32, 3), (32, 9)], 'assert'),
('parens',
[(32, 10), (32, 23)],
('token', [(32, 11), (32, 12)], '='),
('token', [(32, 13), (32, 18)], 'count'),
('number', [(32, 19), (32, 22)], '150')))),
('parens',
[(35, 0), (43, 24)],
('token', [(35, 1), (35, 5)], 'defn'),
('token',
[(35, 6), (35, 21)],
'test-while-loop'),
('list', [(35, 22), (35, 24)]),
('string',
[(36, 2), (36, 29)],
'NATIVE: test while loops?'),
('parens',
[(37, 2), (37, 16)],
('token', [(37, 3), (37, 7)], 'setv'),
('token', [(37, 8), (37, 13)], 'count'),
('number', [(37, 14), (37, 15)], '5')),
('parens',
[(38, 2), (38, 15)],
('token', [(38, 3), (38, 7)], 'setv'),
('token', [(38, 8), (38, 12)], 'fact'),
('number', [(38, 13), (38, 14)], '1')),
('parens',
[(39, 2), (41, 29)],
('token', [(39, 3), (39, 8)], 'while'),
('parens',
[(39, 9), (39, 20)],
('token', [(39, 10), (39, 11)], '>'),
('token', [(39, 12), (39, 17)], 'count'),
('number', [(39, 18), (39, 19)], '0')),
('parens',
[(40, 4), (40, 30)],
('token', [(40, 5), (40, 9)], 'setv'),
('token', [(40, 10), (40, 14)], 'fact'),
('parens',
[(40, 15), (40, 29)],
('token', [(40, 16), (40, 17)], '*'),
('token', [(40, 18), (40, 22)], 'fact'),
('token',
[(40, 23), (40, 28)],
'count'))),
('parens',
[(41, 4), (41, 28)],
('token', [(41, 5), (41, 9)], 'setv'),
('token', [(41, 10), (41, 15)], 'count'),
('parens',
[(41, 16), (41, 27)],
('token', [(41, 17), (41, 18)], '-'),
('token',
[(41, 19), (41, 24)],
'count'),
('number', [(41, 25), (41, 26)], '1')))),
('parens',
[(42, 2), (42, 22)],
('token', [(42, 3), (42, 9)], 'assert'),
('parens',
[(42, 10), (42, 21)],
('token', [(42, 11), (42, 12)], '='),
('token', [(42, 13), (42, 18)], 'count'),
('number', [(42, 19), (42, 20)], '0'))),
('parens',
[(43, 2), (43, 23)],
('token', [(43, 3), (43, 9)], 'assert'),
('parens',
[(43, 10), (43, 22)],
('token', [(43, 11), (43, 12)], '='),
('token', [(43, 13), (43, 17)], 'fact'),
('number', [(43, 18), (43, 21)], '120')))),
('parens',
[(46, 0), (50, 31)],
('token', [(46, 1), (46, 5)], 'defn'),
('token', [(46, 6), (46, 14)], 'test-not'),
('list', [(46, 15), (46, 17)]),
('string',
[(47, 2), (47, 20)],
'NATIVE: test not'),
('parens',
[(48, 2), (48, 24)],
('token', [(48, 3), (48, 9)], 'assert'),
('parens',
[(48, 10), (48, 23)],
('token', [(48, 11), (48, 14)], 'not'),
('parens',
[(48, 15), (48, 22)],
('token', [(48, 16), (48, 17)], '='),
('number', [(48, 18), (48, 19)], '1'),
('number', [(48, 20), (48, 21)], '2')))),
('parens',
[(49, 2), (49, 31)],
('token', [(49, 3), (49, 9)], 'assert'),
('parens',
[(49, 10), (49, 30)],
('token', [(49, 11), (49, 12)], '='),
('token', [(49, 13), (49, 17)], 'true'),
('parens',
[(49, 18), (49, 29)],
('token', [(49, 19), (49, 22)], 'not'),
('token',
[(49, 23), (49, 28)],
'false')))),
('parens',
[(50, 2), (50, 29)],
('token', [(50, 3), (50, 9)], 'assert'),
('parens',
[(50, 10), (50, 28)],
('token', [(50, 11), (50, 12)], '='),
('token', [(50, 13), (50, 18)], 'false'),
('parens',
[(50, 19), (50, 27)],
('token', [(50, 20), (50, 23)], 'not'),
('number', [(50, 24), (50, 26)], '42'))))),
('parens',
[(53, 0), (56, 24)],
('token', [(53, 1), (53, 5)], 'defn'),
('token', [(53, 6), (53, 14)], 'test-inv'),
('list', [(53, 15), (53, 17)]),
('string',
[(54, 2), (54, 20)],
'NATIVE: test inv'),
('parens',
[(55, 2), (55, 23)],
('token', [(55, 3), (55, 9)], 'assert'),
('parens',
[(55, 10), (55, 22)],
('token', [(55, 11), (55, 12)], '='),
('parens',
[(55, 13), (55, 18)],
('token', [(55, 14), (55, 15)], '~'),
('number', [(55, 16), (55, 17)], '1')),
('token', [(55, 19), (55, 21)], '-2'))),
('parens',
[(56, 2), (56, 23)],
('token', [(56, 3), (56, 9)], 'assert'),
('parens',
[(56, 10), (56, 22)],
('token', [(56, 11), (56, 12)], '='),
('parens',
[(56, 13), (56, 19)],
('token', [(56, 14), (56, 15)], '~'),
('token', [(56, 16), (56, 18)], '-2')),
('number', [(56, 20), (56, 21)], '1')))),
('parens',
[(59, 0), (62, 42)],
('token', [(59, 1), (59, 5)], 'defn'),
('token', [(59, 6), (59, 13)], 'test-in'),
('list', [(59, 14), (59, 16)]),
('string',
[(60, 2), (60, 19)],
'NATIVE: test in'),
('parens',
[(61, 2), (61, 37)],
('token', [(61, 3), (61, 9)], 'assert'),
('parens',
[(61, 10), (61, 36)],
('token', [(61, 11), (61, 13)], 'in'),
('string', [(61, 14), (61, 17)], 'a'),
('list',
[(61, 18), (61, 35)],
('string', [(61, 19), (61, 22)], 'a'),
('string', [(61, 23), (61, 26)], 'b'),
('string', [(61, 27), (61, 30)], 'c'),
('string', [(61, 31), (61, 34)], 'd')))),
('parens',
[(62, 2), (62, 41)],
('token', [(62, 3), (62, 9)], 'assert'),
('parens',
[(62, 10), (62, 40)],
('token', [(62, 11), (62, 17)], 'not-in'),
('string', [(62, 18), (62, 21)], 'f'),
('list',
[(62, 22), (62, 39)],
('string', [(62, 23), (62, 26)], 'a'),
('string', [(62, 27), (62, 30)], 'b'),
('string', [(62, 31), (62, 34)], 'c'),
('string', [(62, 35), (62, 38)], 'd'))))),
('parens',
[(65, 0), (67, 20)],
('token', [(65, 1), (65, 5)], 'defn'),
('token', [(65, 6), (65, 16)], 'test-noteq'),
('list', [(65, 17), (65, 19)]),
('string',
[(66, 2), (66, 18)],
'NATIVE: not eq'),
('parens',
[(67, 2), (67, 19)],
('token', [(67, 3), (67, 9)], 'assert'),
('parens',
[(67, 10), (67, 18)],
('token', [(67, 11), (67, 13)], '!='),
('number', [(67, 14), (67, 15)], '2'),
('number', [(67, 16), (67, 17)], '3')))),
('parens',
[(70, 0), (75, 25)],
('token', [(70, 1), (70, 5)], 'defn'),
('token', [(70, 6), (70, 17)], 'test-numops'),
('list', [(70, 18), (70, 20)]),
('string',
[(71, 2), (71, 23)],
'NATIVE: test numpos'),
('parens',
[(72, 2), (72, 24)],
('token', [(72, 3), (72, 9)], 'assert'),
('parens',
[(72, 10), (72, 23)],
('token', [(72, 11), (72, 12)], '>'),
('number', [(72, 13), (72, 14)], '5'),
('number', [(72, 15), (72, 16)], '4'),
('number', [(72, 17), (72, 18)], '3'),
('number', [(72, 19), (72, 20)], '2'),
('number', [(72, 21), (72, 22)], '1'))),
('parens',
[(73, 2), (73, 24)],
('token', [(73, 3), (73, 9)], 'assert'),
('parens',
[(73, 10), (73, 23)],
('token', [(73, 11), (73, 12)], '<'),
('number', [(73, 13), (73, 14)], '1'),
('number', [(73, 15), (73, 16)], '2'),
('number', [(73, 17), (73, 18)], '3'),
('number', [(73, 19), (73, 20)], '4'),
('number', [(73, 21), (73, 22)], '5'))),
('parens',
[(74, 2), (74, 24)],
('token', [(74, 3), (74, 9)], 'assert'),
('parens',
[(74, 10), (74, 23)],
('token', [(74, 11), (74, 13)], '<='),
('number', [(74, 14), (74, 15)], '5'),
('number', [(74, 16), (74, 17)], '5'),
('number', [(74, 18), (74, 19)], '5'),
('number', [(74, 20), (74, 21)], '5'))),
('parens',
[(75, 2), (75, 24)],
('token', [(75, 3), (75, 9)], 'assert'),
('parens',
[(75, 10), (75, 23)],
('token', [(75, 11), (75, 13)], '>='),
('number', [(75, 14), (75, 15)], '5'),
('number', [(75, 16), (75, 17)], '5'),
('number', [(75, 18), (75, 19)], '5'),
('number', [(75, 20), (75, 21)], '5')))),
('parens',
[(78, 0), (82, 26)],
('token', [(78, 1), (78, 5)], 'defn'),
('token', [(78, 6), (78, 13)], 'test-is'),
('list', [(78, 14), (78, 16)]),
('string',
[(79, 2), (79, 38)],
'NATIVE: test is can deal with None'),
('parens',
[(80, 2), (80, 15)],
('token', [(80, 3), (80, 7)], 'setv'),
('token', [(80, 8), (80, 9)], 'a'),
('token', [(80, 10), (80, 14)], 'null')),
('parens',
[(81, 2), (81, 22)],
('token', [(81, 3), (81, 9)], 'assert'),
('parens',
[(81, 10), (81, 21)],
('token', [(81, 11), (81, 13)], 'is'),
('token', [(81, 14), (81, 15)], 'a'),
('token', [(81, 16), (81, 20)], 'null'))),
('parens',
[(82, 2), (82, 25)],
('token', [(82, 3), (82, 9)], 'assert'),
('parens',
[(82, 10), (82, 24)],
('token', [(82, 11), (82, 17)], 'is-not'),
('token', [(82, 18), (82, 19)], 'a'),
('string', [(82, 20), (82, 23)], 'b')))),
('parens',
[(85, 0), (89, 22)],
('token', [(85, 1), (85, 5)], 'defn'),
('token',
[(85, 6), (85, 20)],
'test-branching'),
('list', [(85, 21), (85, 23)]),
('string',
[(86, 2), (86, 29)],
'NATIVE: test if branching'),
('parens',
[(87, 2), (89, 21)],
('token', [(87, 3), (87, 5)], 'if'),
('token', [(87, 6), (87, 10)], 'true'),
('parens',
[(88, 4), (88, 20)],
('token', [(88, 5), (88, 11)], 'assert'),
('parens',
[(88, 12), (88, 19)],
('token', [(88, 13), (88, 14)], '='),
('number', [(88, 15), (88, 16)], '1'),
('number', [(88, 17), (88, 18)], '1'))),
('parens',
[(89, 4), (89, 20)],
('token', [(89, 5), (89, 11)], 'assert'),
('parens',
[(89, 12), (89, 19)],
('token', [(89, 13), (89, 14)], '='),
('number', [(89, 15), (89, 16)], '2'),
('number', [(89, 17), (89, 18)], '1'))))),
('parens',
[(92, 0), (99, 25)],
('token', [(92, 1), (92, 5)], 'defn'),
('token',
[(92, 6), (92, 28)],
'test-branching-with-do'),
('list', [(92, 29), (92, 31)]),
('string',
[(93, 2), (93, 41)],
'NATIVE: test if branching (multiline)'),
('parens',
[(94, 2), (99, 24)],
('token', [(94, 3), (94, 5)], 'if'),
('token', [(94, 6), (94, 11)], 'false'),
('parens',
[(95, 4), (95, 20)],
('token', [(95, 5), (95, 11)], 'assert'),
('parens',
[(95, 12), (95, 19)],
('token', [(95, 13), (95, 14)], '='),
('number', [(95, 15), (95, 16)], '2'),
('number', [(95, 17), (95, 18)], '1'))),
('parens',
[(96, 4), (99, 23)],
('token', [(96, 5), (96, 7)], 'do'),
('parens',
[(97, 6), (97, 22)],
('token',
[(97, 7), (97, 13)],
'assert'),
('parens',
[(97, 14), (97, 21)],
('token', [(97, 15), (97, 16)], '='),
('number', [(97, 17), (97, 18)], '1'),
('number', [(97, 19), (97, 20)], '1'))),
('parens',
[(98, 6), (98, 22)],
('token',
[(98, 7), (98, 13)],
'assert'),
('parens',
[(98, 14), (98, 21)],
('token', [(98, 15), (98, 16)], '='),
('number', [(98, 17), (98, 18)], '1'),
('number', [(98, 19), (98, 20)], '1'))),
('parens',
[(99, 6), (99, 22)],
('token',
[(99, 7), (99, 13)],
'assert'),
('parens',
[(99, 14), (99, 21)],
('token', [(99, 15), (99, 16)], '='),
('number', [(99, 17), (99, 18)], '1'),
('number', [(99, 19), (99, 20)], '1')))))),
('parens',
[(101, 0), (110, 25)],
('token', [(101, 1), (101, 5)], 'defn'),
('token',
[(101, 6), (101, 39)],
'test-branching-expr-count-with-do'),
('list', [(101, 40), (101, 42)]),
('string',
[(102, 2), (102, 78)],
'NATIVE: make sure we execute the right number of expressions in the branch'),
('parens',
[(103, 2), (103, 18)],
('token', [(103, 3), (103, 7)], 'setv'),
('token', [(103, 8), (103, 15)], 'counter'),
('number', [(103, 16), (103, 17)], '0')),
('parens',
[(104, 2), (109, 36)],
('token', [(104, 3), (104, 5)], 'if'),
('token', [(104, 6), (104, 11)], 'false'),
('parens',
[(105, 4), (105, 20)],
('token',
[(105, 5), (105, 11)],
'assert'),
('parens',
[(105, 12), (105, 19)],
('token', [(105, 13), (105, 14)], '='),
('number', [(105, 15), (105, 16)], '2'),
('number', [(105, 17), (105, 18)], '1'))),
('parens',
[(106, 4), (109, 35)],
('token', [(106, 5), (106, 7)], 'do'),
('parens',
[(107, 6), (107, 34)],
('token',
[(107, 7), (107, 11)],
'setv'),
('token',
[(107, 12), (107, 19)],
'counter'),
('parens',
[(107, 20), (107, 33)],
('token',
[(107, 21), (107, 22)],
'+'),
('token',
[(107, 23), (107, 30)],
'counter'),
('number',
[(107, 31), (107, 32)],
'1'))),
('parens',
[(108, 6), (108, 34)],
('token',
[(108, 7), (108, 11)],
'setv'),
('token',
[(108, 12), (108, 19)],
'counter'),
('parens',
[(108, 20), (108, 33)],
('token',
[(108, 21), (108, 22)],
'+'),
('token',
[(108, 23), (108, 30)],
'counter'),
('number',
[(108, 31), (108, 32)],
'1'))),
('parens',
[(109, 6), (109, 34)],
('token',
[(109, 7), (109, 11)],
'setv'),
('token',
[(109, 12), (109, 19)],
'counter'),
('parens',
[(109, 20), (109, 33)],
('token',
[(109, 21), (109, 22)],
'+'),
('token',
[(109, 23), (109, 30)],
'counter'),
('number',
[(109, 31), (109, 32)],
'1'))))),
('parens',
[(110, 2), (110, 24)],
('token', [(110, 3), (110, 9)], 'assert'),
('parens',
[(110, 10), (110, 23)],
('token', [(110, 11), (110, 12)], '='),
('token',
[(110, 13), (110, 20)],
'counter'),
('number', [(110, 21), (110, 22)], '3')))),
('parens',
[(113, 0), (117, 46)],
('token', [(113, 1), (113, 5)], 'defn'),
('token', [(113, 6), (113, 15)], 'test-cond'),
('list', [(113, 16), (113, 18)]),
('string',
[(114, 2), (114, 37)],
'NATIVE: test if cond sorta works.'),
('parens',
[(115, 2), (117, 45)],
('token', [(115, 3), (115, 7)], 'cond'),
('parens',
[(116, 4), (116, 38)],
('parens',
[(116, 5), (116, 12)],
('token', [(116, 6), (116, 7)], '='),
('number', [(116, 8), (116, 9)], '1'),
('number', [(116, 10), (116, 11)], '2')),
('parens',
[(116, 13), (116, 37)],
('token',
[(116, 14), (116, 20)],
'assert'),
('parens',
[(116, 21), (116, 36)],
('token',
[(116, 22), (116, 24)],
'is'),
('token',
[(116, 25), (116, 29)],
'true'),
('token',
[(116, 30), (116, 35)],
'false')))),
('parens',
[(117, 4), (117, 44)],
('parens',
[(117, 5), (117, 19)],
('token', [(117, 6), (117, 8)], 'is'),
('token',
[(117, 9), (117, 13)],
'null'),
('token',
[(117, 14), (117, 18)],
'null')),
('parens',
[(117, 20), (117, 43)],
('token',
[(117, 21), (117, 27)],
'assert'),
('parens',
[(117, 28), (117, 42)],
('token',
[(117, 29), (117, 31)],
'is'),
('token',
[(117, 32), (117, 36)],
'true'),
('token',
[(117, 37), (117, 41)],
'true')))))),
('parens',
[(120, 0), (123, 37)],
('token', [(120, 1), (120, 5)], 'defn'),
('token',
[(120, 6), (120, 16)],
'test-index'),
('list', [(120, 17), (120, 19)]),
('string',
[(121, 2), (121, 39)],
'NATIVE: Test that dict access works'),
('parens',
[(122, 2), (122, 42)],
('token', [(122, 3), (122, 9)], 'assert'),
('parens',
[(122, 10), (122, 35)],
('token', [(122, 11), (122, 14)], 'get'),
('dict',
[(122, 15), (122, 28)],
('string',
[(122, 16), (122, 21)],
'one'),
('string',
[(122, 22), (122, 27)],
'two')),
('string', [(122, 29), (122, 34)], 'one')),
('string', [(122, 36), (122, 41)], 'two')),
('parens',
[(123, 2), (123, 36)],
('token', [(123, 3), (123, 9)], 'assert'),
('parens',
[(123, 10), (123, 35)],
('token', [(123, 11), (123, 12)], '='),
('parens',
[(123, 13), (123, 32)],
('token',
[(123, 14), (123, 17)],
'get'),
('list',
[(123, 18), (123, 29)],
('number',
[(123, 19), (123, 20)],
'1'),
('number',
[(123, 21), (123, 22)],
'2'),
('number',
[(123, 23), (123, 24)],
'3'),
('number',
[(123, 25), (123, 26)],
'4'),
('number',
[(123, 27), (123, 28)],
'5')),
('number', [(123, 30), (123, 31)], '1')),
('number', [(123, 33), (123, 34)], '2')))),
('parens',
[(126, 0), (129, 28)],
('token', [(126, 1), (126, 5)], 'defn'),
('token',
[(126, 6), (126, 17)],
'test-lambda'),
('list', [(126, 18), (126, 20)]),
('string',
[(127, 2), (127, 32)],
'NATIVE: test lambda operator'),
('parens',
[(128, 2), (128, 36)],
('token', [(128, 3), (128, 7)], 'setv'),
('token', [(128, 8), (128, 14)], 'square'),
('parens',
[(128, 15), (128, 35)],
('token',
[(128, 16), (128, 22)],
'lambda'),
('list',
[(128, 23), (128, 26)],
('token', [(128, 24), (128, 25)], 'x')),
('parens',
[(128, 27), (128, 34)],
('token', [(128, 28), (128, 29)], '*'),
('token', [(128, 30), (128, 31)], 'x'),
('token', [(128, 32), (128, 33)], 'x')))),
('parens',
[(129, 2), (129, 27)],
('token', [(129, 3), (129, 9)], 'assert'),
('parens',
[(129, 10), (129, 26)],
('token', [(129, 11), (129, 12)], '='),
('number', [(129, 13), (129, 14)], '4'),
('parens',
[(129, 15), (129, 25)],
('token',
[(129, 16), (129, 22)],
'square'),
('number', [(129, 23), (129, 24)], '2'))))),
('parens',
[(132, 0), (136, 35)],
('token', [(132, 1), (132, 5)], 'defn'),
('token',
[(132, 6), (132, 24)],
'test-imported-bits'),
('list', [(132, 25), (132, 27)]),
('string',
[(133, 2), (133, 33)],
'NATIVE: test the imports work'),
('parens',
[(134, 2), (134, 33)],
('token', [(134, 3), (134, 9)], 'assert'),
('parens',
[(134, 10), (134, 32)],
('token', [(134, 11), (134, 13)], 'is'),
('parens',
[(134, 14), (134, 26)],
('token',
[(134, 15), (134, 21)],
'exists'),
('string', [(134, 22), (134, 25)], '.')),
('token', [(134, 27), (134, 31)], 'true'))),
('parens',
[(135, 2), (135, 32)],
('token', [(135, 3), (135, 9)], 'assert'),
('parens',
[(135, 10), (135, 31)],
('token', [(135, 11), (135, 13)], 'is'),
('parens',
[(135, 14), (135, 25)],
('token',
[(135, 15), (135, 20)],
'isdir'),
('string', [(135, 21), (135, 24)], '.')),
('token', [(135, 26), (135, 30)], 'true'))),
('parens',
[(136, 2), (136, 34)],
('token', [(136, 3), (136, 9)], 'assert'),
('parens',
[(136, 10), (136, 33)],
('token', [(136, 11), (136, 13)], 'is'),
('parens',
[(136, 14), (136, 26)],
('token',
[(136, 15), (136, 21)],
'isfile'),
('string', [(136, 22), (136, 25)], '.')),
('token',
[(136, 27), (136, 32)],
'false')))),
('parens',
[(139, 0), (140, 22)],
('token', [(139, 1), (139, 5)], 'defn'),
('token', [(139, 6), (139, 12)], 'foodec'),
('list',
[(139, 13), (139, 19)],
('token', [(139, 14), (139, 18)], 'func')),
('parens',
[(140, 2), (140, 21)],
('token', [(140, 3), (140, 9)], 'lambda'),
('list', [(140, 10), (140, 12)]),
('parens',
[(140, 13), (140, 20)],
('token', [(140, 14), (140, 15)], '+'),
('number', [(140, 16), (140, 17)], '1'),
('number', [(140, 18), (140, 19)], '1')))),
('parens',
[(143, 0), (145, 13)],
('token',
[(143, 1), (143, 14)],
'decorate-with'),
('token', [(143, 15), (143, 21)], 'foodec'),
('parens',
[(144, 2), (145, 12)],
('token', [(144, 3), (144, 7)], 'defn'),
('token',
[(144, 8), (144, 17)],
'tfunction'),
('list', [(144, 18), (144, 20)]),
('parens',
[(145, 4), (145, 11)],
('token', [(145, 5), (145, 6)], '*'),
('number', [(145, 7), (145, 8)], '2'),
('number', [(145, 9), (145, 10)], '2')))),
('parens',
[(148, 0), (150, 29)],
('token', [(148, 1), (148, 5)], 'defn'),
('token',
[(148, 6), (148, 21)],
'test-decorators'),
('list', [(148, 22), (148, 24)]),
('string',
[(149, 2), (149, 28)],
'NATIVE: test decorators.'),
('parens',
[(150, 2), (150, 28)],
('token', [(150, 3), (150, 9)], 'assert'),
('parens',
[(150, 10), (150, 27)],
('token', [(150, 11), (150, 12)], '='),
('parens',
[(150, 13), (150, 24)],
('token',
[(150, 14), (150, 23)],
'tfunction')),
('number', [(150, 25), (150, 26)], '2')))),
('parens',
[(153, 0), (155, 62)],
('token', [(153, 1), (153, 5)], 'defn'),
('token',
[(153, 6), (153, 17)],
'test-kwargs'),
('list', [(153, 18), (153, 20)]),
('string',
[(154, 2), (154, 31)],
'NATIVE: test kwargs things.'),
('parens',
[(155, 2), (155, 61)],
('token', [(155, 3), (155, 9)], 'assert'),
('parens',
[(155, 10), (155, 60)],
('token', [(155, 11), (155, 12)], '='),
('parens',
[(155, 13), (155, 45)],
('token',
[(155, 14), (155, 21)],
'kwapply'),
('parens',
[(155, 22), (155, 30)],
('token',
[(155, 23), (155, 29)],
'kwtest')),
('dict',
[(155, 31), (155, 44)],
('string',
[(155, 32), (155, 37)],
'one'),
('string',
[(155, 38), (155, 43)],
'two'))),
('dict',
[(155, 46), (155, 59)],
('string',
[(155, 47), (155, 52)],
'one'),
('string',
[(155, 53), (155, 58)],
'two'))))),
('parens',
[(158, 0), (160, 51)],
('token', [(158, 1), (158, 5)], 'defn'),
('token',
[(158, 6), (158, 17)],
'test-dotted'),
('list', [(158, 18), (158, 20)]),
('string',
[(159, 2), (159, 34)],
'NATIVE: test dotted invocation'),
('parens',
[(160, 2), (160, 50)],
('token', [(160, 3), (160, 9)], 'assert'),
('parens',
[(160, 10), (160, 49)],
('token', [(160, 11), (160, 12)], '='),
('parens',
[(160, 13), (160, 38)],
('token',
[(160, 14), (160, 19)],
'.join'),
('string', [(160, 20), (160, 23)], ' '),
('list',
[(160, 24), (160, 37)],
('string',
[(160, 25), (160, 30)],
'one'),
('string',
[(160, 31), (160, 36)],
'two'))),
('string',
[(160, 39), (160, 48)],
'one two')))),
('parens',
[(163, 0), (168, 47)],
('token', [(163, 1), (163, 5)], 'defn'),
('token',
[(163, 6), (163, 21)],
'test-exceptions'),
('list', [(163, 22), (163, 24)]),
('string',
[(164, 2), (164, 27)],
'NATIVE: test Exceptions'),
('parens',
[(165, 2), (168, 46)],
('token', [(165, 3), (165, 6)], 'try'),
('parens',
[(166, 4), (166, 22)],
('token', [(166, 5), (166, 10)], 'throw'),
('parens',
[(166, 11), (166, 21)],
('token',
[(166, 12), (166, 20)],
'KeyError'))),
('parens',
[(167, 2), (167, 37)],
('token', [(167, 3), (167, 8)], 'catch'),
('token',
[(167, 9), (167, 16)],
'IOError'),
('token', [(167, 18), (167, 19)], 'e'),
('parens',
[(167, 20), (167, 36)],
('token',
[(167, 21), (167, 27)],
'assert'),
('parens',
[(167, 28), (167, 35)],
('token',
[(167, 29), (167, 30)],
'='),
('number',
[(167, 31), (167, 32)],
'2'),
('number',
[(167, 33), (167, 34)],
'1')))),
('parens',
[(168, 2), (168, 45)],
('token', [(168, 3), (168, 8)], 'catch'),
('token',
[(168, 9), (168, 17)],
'KeyError'),
('token', [(168, 18), (168, 19)], 'e'),
('parens',
[(168, 20), (168, 27)],
('token', [(168, 21), (168, 22)], '+'),
('number', [(168, 23), (168, 24)], '1'),
('number', [(168, 25), (168, 26)], '1')),
('parens',
[(168, 28), (168, 44)],
('token',
[(168, 29), (168, 35)],
'assert'),
('parens',
[(168, 36), (168, 43)],
('token',
[(168, 37), (168, 38)],
'='),
('number',
[(168, 39), (168, 40)],
'1'),
('number',
[(168, 41), (168, 42)],
'1')))))),
('parens',
[(170, 0), (175, 26)],
('token', [(170, 1), (170, 5)], 'defn'),
('token',
[(170, 6), (170, 19)],
'test-earmuffs'),
('list', [(170, 20), (170, 22)]),
('string',
[(171, 2), (171, 25)],
'NATIVE: Test earmuffs'),
('parens',
[(172, 2), (172, 18)],
('token', [(172, 3), (172, 7)], 'setv'),
('starred_token',
[(172, 8), (172, 13)],
[(172, 9), (172, 12)]),
('string', [(172, 14), (172, 17)], '2')),
('parens',
[(173, 2), (173, 16)],
('token', [(173, 3), (173, 7)], 'setv'),
('token', [(173, 8), (173, 11)], 'foo'),
('string', [(173, 12), (173, 15)], '3')),
('parens',
[(174, 2), (174, 24)],
('token', [(174, 3), (174, 9)], 'assert'),
('parens',
[(174, 10), (174, 23)],
('token', [(174, 11), (174, 12)], '='),
('starred_token',
[(174, 13), (174, 18)],
[(174, 14), (174, 17)]),
('token', [(174, 19), (174, 22)], 'FOO'))),
('parens',
[(175, 2), (175, 25)],
('token', [(175, 3), (175, 9)], 'assert'),
('parens',
[(175, 10), (175, 24)],
('token', [(175, 11), (175, 13)], '!='),
('starred_token',
[(175, 14), (175, 19)],
[(175, 15), (175, 18)]),
('token', [(175, 20), (175, 23)], 'foo')))),
('parens',
[(178, 0), (181, 33)],
('token', [(178, 1), (178, 5)], 'defn'),
('token',
[(178, 6), (178, 20)],
'test-threading'),
('list', [(178, 21), (178, 23)]),
('string',
[(179, 2), (179, 32)],
'NATIVE: test threading macro'),
('parens',
[(180, 2), (181, 32)],
('token', [(180, 3), (180, 9)], 'assert'),
('parens',
[(180, 10), (181, 31)],
('token', [(180, 11), (180, 12)], '='),
('parens',
[(180, 13), (180, 64)],
('token', [(180, 14), (180, 16)], '->'),
('parens',
[(180, 17), (180, 35)],
('token',
[(180, 18), (180, 24)],
'.upper'),
('string',
[(180, 25), (180, 34)],
'a b c d')),
('parens',
[(180, 36), (180, 54)],
('token',
[(180, 37), (180, 45)],
'.replace'),
('string',
[(180, 46), (180, 49)],
'A'),
('string',
[(180, 50), (180, 53)],
'X')),
('parens',
[(180, 55), (180, 63)],
('token',
[(180, 56), (180, 62)],
'.split'))),
('list',
[(181, 13), (181, 30)],
('string', [(181, 14), (181, 17)], 'X'),
('string', [(181, 18), (181, 21)], 'B'),
('string', [(181, 22), (181, 25)], 'C'),
('string', [(181, 26), (181, 29)], 'D'))))),
('parens',
[(184, 0), (187, 33)],
('token', [(184, 1), (184, 5)], 'defn'),
('token',
[(184, 6), (184, 24)],
'test-threading-two'),
('list', [(184, 25), (184, 27)]),
('string',
[(185, 2), (185, 32)],
'NATIVE: test threading macro'),
('parens',
[(186, 2), (187, 32)],
('token', [(186, 3), (186, 9)], 'assert'),
('parens',
[(186, 10), (187, 31)],
('token', [(186, 11), (186, 12)], '='),
('parens',
[(186, 13), (186, 60)],
('token', [(186, 14), (186, 16)], '->'),
('string',
[(186, 17), (186, 26)],
'a b c d'),
('token',
[(186, 27), (186, 33)],
'.upper'),
('parens',
[(186, 34), (186, 52)],
('token',
[(186, 35), (186, 43)],
'.replace'),
('string',
[(186, 44), (186, 47)],
'A'),
('string',
[(186, 48), (186, 51)],
'X')),
('token',
[(186, 53), (186, 59)],
'.split')),
('list',
[(187, 13), (187, 30)],
('string', [(187, 14), (187, 17)], 'X'),
('string', [(187, 18), (187, 21)], 'B'),
('string', [(187, 22), (187, 25)], 'C'),
('string', [(187, 26), (187, 29)], 'D'))))),
('parens',
[(190, 0), (194, 40)],
('token', [(190, 1), (190, 5)], 'defn'),
('token',
[(190, 6), (190, 16)],
'test-assoc'),
('list', [(190, 17), (190, 19)]),
('string',
[(191, 2), (191, 22)],
'NATIVE: test assoc'),
('parens',
[(192, 2), (192, 27)],
('token', [(192, 3), (192, 7)], 'setv'),
('token', [(192, 8), (192, 12)], 'vals'),
('dict',
[(192, 13), (192, 26)],
('string', [(192, 14), (192, 19)], 'one'),
('string', [(192, 20), (192, 25)], 'two'))),
('parens',
[(193, 2), (193, 28)],
('token', [(193, 3), (193, 8)], 'assoc'),
('token', [(193, 9), (193, 13)], 'vals'),
('string', [(193, 14), (193, 19)], 'two'),
('string', [(193, 20), (193, 27)], 'three')),
('parens',
[(194, 2), (194, 39)],
('token', [(194, 3), (194, 9)], 'assert'),
('parens',
[(194, 10), (194, 38)],
('token', [(194, 11), (194, 12)], '='),
('parens',
[(194, 13), (194, 29)],
('token',
[(194, 14), (194, 17)],
'get'),
('token',
[(194, 18), (194, 22)],
'vals'),
('string',
[(194, 23), (194, 28)],
'two')),
('string',
[(194, 30), (194, 37)],
'three')))),
('parens',
[(197, 0), (200, 19)],
('token', [(197, 1), (197, 5)], 'defn'),
('token', [(197, 6), (197, 15)], 'test-pass'),
('list', [(197, 16), (197, 18)]),
('string',
[(198, 2), (198, 30)],
'NATIVE: Test pass worksish'),
('parens',
[(199, 2), (199, 25)],
('token', [(199, 3), (199, 5)], 'if'),
('token', [(199, 6), (199, 10)], 'true'),
('parens',
[(199, 11), (199, 17)],
('token', [(199, 12), (199, 16)], 'pass')),
('parens',
[(199, 18), (199, 24)],
('token', [(199, 19), (199, 23)], 'pass'))),
('parens',
[(200, 2), (200, 18)],
('token', [(200, 3), (200, 9)], 'assert'),
('parens',
[(200, 10), (200, 17)],
('token', [(200, 11), (200, 12)], '='),
('number', [(200, 13), (200, 14)], '1'),
('number', [(200, 15), (200, 16)], '1')))),
('parens',
[(203, 0), (208, 22)],
('token', [(203, 1), (203, 5)], 'defn'),
('token',
[(203, 6), (203, 16)],
'test-yield'),
('list', [(203, 17), (203, 19)]),
('string',
[(204, 2), (204, 25)],
'NATIVE: test yielding'),
('parens',
[(205, 2), (205, 45)],
('token', [(205, 3), (205, 7)], 'defn'),
('token', [(205, 8), (205, 11)], 'gen'),
('list', [(205, 12), (205, 14)]),
('parens',
[(205, 15), (205, 44)],
('token', [(205, 16), (205, 19)], 'for'),
('list',
[(205, 20), (205, 33)],
('token', [(205, 21), (205, 22)], 'x'),
('list',
[(205, 23), (205, 32)],
('number',
[(205, 24), (205, 25)],
'1'),
('number',
[(205, 26), (205, 27)],
'2'),
('number',
[(205, 28), (205, 29)],
'3'),
('number',
[(205, 30), (205, 31)],
'4'))),
('parens',
[(205, 34), (205, 43)],
('token',
[(205, 35), (205, 40)],
'yield'),
('token', [(205, 41), (205, 42)], 'x')))),
('parens',
[(206, 2), (206, 14)],
('token', [(206, 3), (206, 7)], 'setv'),
('token', [(206, 8), (206, 11)], 'ret'),
('number', [(206, 12), (206, 13)], '0')),
('parens',
[(207, 2), (207, 38)],
('token', [(207, 3), (207, 6)], 'for'),
('list',
[(207, 7), (207, 16)],
('token', [(207, 8), (207, 9)], 'y'),
('parens',
[(207, 10), (207, 15)],
('token',
[(207, 11), (207, 14)],
'gen'))),
('parens',
[(207, 17), (207, 37)],
('token', [(207, 18), (207, 22)], 'setv'),
('token', [(207, 23), (207, 26)], 'ret'),
('parens',
[(207, 27), (207, 36)],
('token', [(207, 28), (207, 29)], '+'),
('token',
[(207, 30), (207, 33)],
'ret'),
('token', [(207, 34), (207, 35)], 'y')))),
('parens',
[(208, 2), (208, 21)],
('token', [(208, 3), (208, 9)], 'assert'),
('parens',
[(208, 10), (208, 20)],
('token', [(208, 11), (208, 12)], '='),
('token', [(208, 13), (208, 16)], 'ret'),
('number', [(208, 17), (208, 19)], '10')))),
('parens',
[(211, 0), (214, 35)],
('token', [(211, 1), (211, 5)], 'defn'),
('token',
[(211, 6), (211, 16)],
'test-first'),
('list', [(211, 17), (211, 19)]),
('string',
[(212, 2), (212, 30)],
'NATIVE: test firsty things'),
('parens',
[(213, 2), (213, 36)],
('token', [(213, 3), (213, 9)], 'assert'),
('parens',
[(213, 10), (213, 35)],
('token', [(213, 11), (213, 12)], '='),
('parens',
[(213, 13), (213, 32)],
('token',
[(213, 14), (213, 19)],
'first'),
('list',
[(213, 20), (213, 31)],
('number',
[(213, 21), (213, 22)],
'1'),
('number',
[(213, 23), (213, 24)],
'2'),
('number',
[(213, 25), (213, 26)],
'3'),
('number',
[(213, 27), (213, 28)],
'4'),
('number',
[(213, 29), (213, 30)],
'5'))),
('number', [(213, 33), (213, 34)], '1'))),
('parens',
[(214, 2), (214, 34)],
('token', [(214, 3), (214, 9)], 'assert'),
('parens',
[(214, 10), (214, 33)],
('token', [(214, 11), (214, 12)], '='),
('parens',
[(214, 13), (214, 30)],
('token',
[(214, 14), (214, 17)],
'car'),
('list',
[(214, 18), (214, 29)],
('number',
[(214, 19), (214, 20)],
'1'),
('number',
[(214, 21), (214, 22)],
'2'),
('number',
[(214, 23), (214, 24)],
'3'),
('number',
[(214, 25), (214, 26)],
'4'),
('number',
[(214, 27), (214, 28)],
'5'))),
('number', [(214, 31), (214, 32)], '1')))),
('parens',
[(217, 0), (221, 47)],
('token', [(217, 1), (217, 5)], 'defn'),
('token',
[(217, 6), (217, 16)],
'test-slice'),
('list', [(217, 17), (217, 19)]),
('string',
[(218, 2), (218, 22)],
'NATIVE: test slice'),
('parens',
[(219, 2), (219, 46)],
('token', [(219, 3), (219, 9)], 'assert'),
('parens',
[(219, 10), (219, 45)],
('token', [(219, 11), (219, 12)], '='),
('parens',
[(219, 13), (219, 34)],
('token',
[(219, 14), (219, 19)],
'slice'),
('list',
[(219, 20), (219, 31)],
('number',
[(219, 21), (219, 22)],
'1'),
('number',
[(219, 23), (219, 24)],
'2'),
('number',
[(219, 25), (219, 26)],
'3'),
('number',
[(219, 27), (219, 28)],
'4'),
('number',
[(219, 29), (219, 30)],
'5')),
('number', [(219, 32), (219, 33)], '1')),
('list',
[(219, 35), (219, 44)],
('number', [(219, 36), (219, 37)], '2'),
('number', [(219, 38), (219, 39)], '3'),
('number', [(219, 40), (219, 41)], '4'),
('number', [(219, 42), (219, 43)], '5')))),
('parens',
[(220, 2), (220, 44)],
('token', [(220, 3), (220, 9)], 'assert'),
('parens',
[(220, 10), (220, 43)],
('token', [(220, 11), (220, 12)], '='),
('parens',
[(220, 13), (220, 36)],
('token',
[(220, 14), (220, 19)],
'slice'),
('list',
[(220, 20), (220, 31)],
('number',
[(220, 21), (220, 22)],
'1'),
('number',
[(220, 23), (220, 24)],
'2'),
('number',
[(220, 25), (220, 26)],
'3'),
('number',
[(220, 27), (220, 28)],
'4'),
('number',
[(220, 29), (220, 30)],
'5')),
('number', [(220, 32), (220, 33)], '1'),
('number', [(220, 34), (220, 35)], '3')),
('list',
[(220, 37), (220, 42)],
('number', [(220, 38), (220, 39)], '2'),
('number', [(220, 40), (220, 41)], '3')))),
('parens',
[(221, 2), (221, 46)],
('token', [(221, 3), (221, 9)], 'assert'),
('parens',
[(221, 10), (221, 45)],
('token', [(221, 11), (221, 12)], '='),
('parens',
[(221, 13), (221, 32)],
('token',
[(221, 14), (221, 19)],
'slice'),
('list',
[(221, 20), (221, 31)],
('number',
[(221, 21), (221, 22)],
'1'),
('number',
[(221, 23), (221, 24)],
'2'),
('number',
[(221, 25), (221, 26)],
'3'),
('number',
[(221, 27), (221, 28)],
'4'),
('number',
[(221, 29), (221, 30)],
'5'))),
('list',
[(221, 33), (221, 44)],
('number', [(221, 34), (221, 35)], '1'),
('number', [(221, 36), (221, 37)], '2'),
('number', [(221, 38), (221, 39)], '3'),
('number', [(221, 40), (221, 41)], '4'),
('number', [(221, 42), (221, 43)], '5'))))),
('parens',
[(224, 0), (226, 44)],
('token', [(224, 1), (224, 5)], 'defn'),
('token', [(224, 6), (224, 15)], 'test-rest'),
('list', [(224, 16), (224, 18)]),
('string',
[(225, 2), (225, 21)],
'NATIVE: test rest'),
('parens',
[(226, 2), (226, 43)],
('token', [(226, 3), (226, 9)], 'assert'),
('parens',
[(226, 10), (226, 42)],
('token', [(226, 11), (226, 12)], '='),
('parens',
[(226, 13), (226, 31)],
('token',
[(226, 14), (226, 18)],
'rest'),
('list',
[(226, 19), (226, 30)],
('number',
[(226, 20), (226, 21)],
'1'),
('number',
[(226, 22), (226, 23)],
'2'),
('number',
[(226, 24), (226, 25)],
'3'),
('number',
[(226, 26), (226, 27)],
'4'),
('number',
[(226, 28), (226, 29)],
'5'))),
('list',
[(226, 32), (226, 41)],
('number', [(226, 33), (226, 34)], '2'),
('number', [(226, 35), (226, 36)], '3'),
('number', [(226, 37), (226, 38)], '4'),
('number', [(226, 39), (226, 40)], '5'))))),
('parens',
[(229, 0), (231, 37)],
('token', [(229, 1), (229, 5)], 'defn'),
('token',
[(229, 6), (229, 19)],
'test-importas'),
('list', [(229, 20), (229, 22)]),
('string',
[(230, 2), (230, 26)],
'NATIVE: test import as'),
('parens',
[(231, 2), (231, 36)],
('token', [(231, 3), (231, 9)], 'assert'),
('parens',
[(231, 10), (231, 35)],
('token', [(231, 11), (231, 13)], '!='),
('parens',
[(231, 14), (231, 32)],
('token',
[(231, 15), (231, 18)],
'len'),
('token',
[(231, 19), (231, 31)],
'systest.path')),
('number', [(231, 33), (231, 34)], '0')))),
('parens',
[(234, 0), (237, 19)],
('token', [(234, 1), (234, 5)], 'defn'),
('token',
[(234, 6), (234, 18)],
'test-context'),
('list', [(234, 19), (234, 21)]),
('string',
[(235, 2), (235, 21)],
'NATIVE: test with'),
('parens',
[(236, 2), (237, 18)],
('token', [(236, 3), (236, 10)], 'with-as'),
('parens',
[(236, 11), (236, 33)],
('token', [(236, 12), (236, 16)], 'open'),
('string',
[(236, 17), (236, 28)],
'README.md'),
('string', [(236, 29), (236, 32)], 'r')),
('token', [(236, 34), (236, 36)], 'fd'),
('parens',
[(237, 11), (237, 17)],
('token', [(237, 12), (237, 16)], 'pass')))),
('parens',
[(240, 0), (247, 21)],
('token', [(240, 1), (240, 5)], 'defn'),
('token',
[(240, 6), (240, 21)],
'test-for-doodle'),
('list', [(240, 22), (240, 24)]),
('string',
[(241, 2), (241, 23)],
'NATIVE: test for-do'),
('parens',
[(242, 2), (242, 69)],
('token', [(242, 3), (242, 5)], 'do'),
('parens',
[(242, 6), (242, 68)],
('token', [(242, 7), (242, 9)], 'do'),
('parens',
[(242, 10), (242, 67)],
('token', [(242, 11), (242, 13)], 'do'),
('parens',
[(242, 14), (242, 66)],
('token',
[(242, 15), (242, 17)],
'do'),
('parens',
[(242, 18), (242, 65)],
('token',
[(242, 19), (242, 21)],
'do'),
('parens',
[(242, 22), (242, 64)],
('token',
[(242, 23), (242, 25)],
'do'),
('parens',
[(242, 26), (242, 63)],
('token',
[(242, 27), (242, 29)],
'do'),
('parens',
[(242, 30), (242, 62)],
('token',
[(242, 31), (242, 33)],
'do'),
('parens',
[(242, 34), (242, 61)],
('token',
[(242, 35), (242, 37)],
'do'),
('parens',
[(242, 38), (242, 60)],
('token',
[(242, 39), (242, 43)],
'setf'),
('parens',
[(242, 44), (242, 51)],
('token',
[(242, 45),
(242, 46)],
','),
('token',
[(242, 47),
(242, 48)],
'x'),
('token',
[(242, 49),
(242, 50)],
'y')),
('parens',
[(242, 52), (242, 59)],
('token',
[(242, 53),
(242, 54)],
','),
('number',
[(242, 55),
(242, 56)],
'0'),
('number',
[(242, 57),
(242, 58)],
'0')))))))))))),
('parens',
[(243, 2), (246, 31)],
('token', [(243, 3), (243, 10)], 'foreach'),
('list',
[(243, 11), (243, 20)],
('token', [(243, 12), (243, 13)], '-'),
('list',
[(243, 14), (243, 19)],
('number', [(243, 15), (243, 16)], '1'),
('number', [(243, 17), (243, 18)], '2'))),
('parens',
[(244, 11), (246, 30)],
('token', [(244, 12), (244, 14)], 'do'),
('parens',
[(245, 13), (245, 29)],
('token',
[(245, 14), (245, 18)],
'setf'),
('token', [(245, 19), (245, 20)], 'x'),
('parens',
[(245, 21), (245, 28)],
('token',
[(245, 22), (245, 23)],
'+'),
('token',
[(245, 24), (245, 25)],
'x'),
('number',
[(245, 26), (245, 27)],
'1'))),
('parens',
[(246, 13), (246, 29)],
('token',
[(246, 14), (246, 18)],
'setf'),
('token', [(246, 19), (246, 20)], 'y'),
('parens',
[(246, 21), (246, 28)],
('token',
[(246, 22), (246, 23)],
'+'),
('token',
[(246, 24), (246, 25)],
'y'),
('number',
[(246, 26), (246, 27)],
'1'))))),
('parens',
[(247, 2), (247, 20)],
('token', [(247, 3), (247, 9)], 'assert'),
('parens',
[(247, 10), (247, 19)],
('token', [(247, 11), (247, 12)], '='),
('token', [(247, 13), (247, 14)], 'y'),
('token', [(247, 15), (247, 16)], 'x'),
('number', [(247, 17), (247, 18)], '2')))),
('parens',
[(250, 0), (257, 49)],
('token', [(250, 1), (250, 5)], 'defn'),
('token',
[(250, 6), (250, 25)],
'test-comprehensions'),
('list', [(250, 26), (250, 28)]),
('string',
[(251, 2), (251, 36)],
'NATIVE: test list comprehensions'),
('parens',
[(252, 2), (252, 54)],
('token', [(252, 3), (252, 9)], 'assert'),
('parens',
[(252, 10), (252, 53)],
('token', [(252, 11), (252, 12)], '='),
('parens',
[(252, 13), (252, 46)],
('token',
[(252, 14), (252, 23)],
'list-comp'),
('parens',
[(252, 24), (252, 31)],
('token',
[(252, 25), (252, 26)],
'*'),
('token',
[(252, 27), (252, 28)],
'x'),
('number',
[(252, 29), (252, 30)],
'2')),
('parens',
[(252, 32), (252, 45)],
('token',
[(252, 33), (252, 34)],
'x'),
('parens',
[(252, 35), (252, 44)],
('token',
[(252, 36), (252, 41)],
'range'),
('number',
[(252, 42), (252, 43)],
'2')))),
('list',
[(252, 47), (252, 52)],
('number', [(252, 48), (252, 49)], '0'),
('number', [(252, 50), (252, 51)], '2')))),
('parens',
[(253, 2), (253, 62)],
('token', [(253, 3), (253, 9)], 'assert'),
('parens',
[(253, 10), (253, 61)],
('token', [(253, 11), (253, 12)], '='),
('parens',
[(253, 13), (253, 54)],
('token',
[(253, 14), (253, 23)],
'list-comp'),
('parens',
[(253, 24), (253, 31)],
('token',
[(253, 25), (253, 26)],
'*'),
('token',
[(253, 27), (253, 28)],
'x'),
('number',
[(253, 29), (253, 30)],
'2')),
('parens',
[(253, 32), (253, 45)],
('token',
[(253, 33), (253, 34)],
'x'),
('parens',
[(253, 35), (253, 44)],
('token',
[(253, 36), (253, 41)],
'range'),
('number',
[(253, 42), (253, 43)],
'4'))),
('parens',
[(253, 46), (253, 53)],
('token',
[(253, 47), (253, 48)],
'%'),
('token',
[(253, 49), (253, 50)],
'x'),
('number',
[(253, 51), (253, 52)],
'2'))),
('list',
[(253, 55), (253, 60)],
('number', [(253, 56), (253, 57)], '2'),
('number', [(253, 58), (253, 59)], '6')))),
('parens',
[(254, 2), (255, 20)],
('token', [(254, 3), (254, 9)], 'assert'),
('parens',
[(254, 10), (255, 19)],
('token', [(254, 11), (254, 12)], '='),
('parens',
[(254, 13), (254, 74)],
('token',
[(254, 14), (254, 20)],
'sorted'),
('parens',
[(254, 21), (254, 73)],
('token',
[(254, 22), (254, 31)],
'list-comp'),
('parens',
[(254, 32), (254, 39)],
('token',
[(254, 33), (254, 34)],
'*'),
('token',
[(254, 35), (254, 36)],
'y'),
('number',
[(254, 37), (254, 38)],
'2')),
('parens',
[(254, 40), (254, 72)],
('parens',
[(254, 41), (254, 48)],
('token',
[(254, 42), (254, 43)],
','),
('token',
[(254, 44), (254, 45)],
'x'),
('token',
[(254, 46), (254, 47)],
'y')),
('parens',
[(254, 49), (254, 71)],
('token',
[(254, 50), (254, 56)],
'.items'),
('dict',
[(254, 57), (254, 70)],
('string',
[(254, 58), (254, 61)],
'1'),
('number',
[(254, 62), (254, 63)],
'1'),
('string',
[(254, 64), (254, 67)],
'2'),
('number',
[(254, 68), (254, 69)],
'2')))))),
('list',
[(255, 13), (255, 18)],
('number', [(255, 14), (255, 15)], '2'),
('number', [(255, 16), (255, 17)], '4')))),
('parens',
[(256, 2), (257, 48)],
('token', [(256, 3), (256, 9)], 'assert'),
('parens',
[(256, 10), (257, 47)],
('token', [(256, 11), (256, 12)], '='),
('parens',
[(256, 13), (256, 58)],
('token',
[(256, 14), (256, 23)],
'list-comp'),
('parens',
[(256, 24), (256, 31)],
('token',
[(256, 25), (256, 26)],
','),
('token',
[(256, 27), (256, 28)],
'x'),
('token',
[(256, 29), (256, 30)],
'y')),
('parens',
[(256, 32), (256, 57)],
('token',
[(256, 33), (256, 34)],
'x'),
('parens',
[(256, 35), (256, 44)],
('token',
[(256, 36), (256, 41)],
'range'),
('number',
[(256, 42), (256, 43)],
'2')),
('token',
[(256, 45), (256, 46)],
'y'),
('parens',
[(256, 47), (256, 56)],
('token',
[(256, 48), (256, 53)],
'range'),
('number',
[(256, 54), (256, 55)],
'2')))),
('list',
[(257, 13), (257, 46)],
('parens',
[(257, 14), (257, 21)],
('token',
[(257, 15), (257, 16)],
','),
('number',
[(257, 17), (257, 18)],
'0'),
('number',
[(257, 19), (257, 20)],
'0')),
('parens',
[(257, 22), (257, 29)],
('token',
[(257, 23), (257, 24)],
','),
('number',
[(257, 25), (257, 26)],
'0'),
('number',
[(257, 27), (257, 28)],
'1')),
('parens',
[(257, 30), (257, 37)],
('token',
[(257, 31), (257, 32)],
','),
('number',
[(257, 33), (257, 34)],
'1'),
('number',
[(257, 35), (257, 36)],
'0')),
('parens',
[(257, 38), (257, 45)],
('token',
[(257, 39), (257, 40)],
','),
('number',
[(257, 41), (257, 42)],
'1'),
('number',
[(257, 43), (257, 44)],
'1')))))),
('parens',
[(260, 0), (268, 39)],
('token', [(260, 1), (260, 5)], 'defn'),
('token',
[(260, 6), (260, 21)],
'test-defn-order'),
('list', [(260, 22), (260, 24)]),
('string',
[(261, 2), (261, 38)],
'NATIVE: test defn evaluation order'),
('parens',
[(262, 2), (262, 15)],
('token', [(262, 3), (262, 7)], 'setv'),
('token', [(262, 8), (262, 11)], 'acc'),
('list', [(262, 12), (262, 14)])),
('parens',
[(263, 2), (266, 24)],
('token', [(263, 3), (263, 7)], 'defn'),
('token', [(263, 8), (263, 14)], 'my-fun'),
('list', [(263, 15), (263, 17)]),
('parens',
[(264, 4), (264, 23)],
('token',
[(264, 5), (264, 12)],
'.append'),
('token', [(264, 13), (264, 16)], 'acc'),
('string', [(264, 17), (264, 22)], 'Foo')),
('parens',
[(265, 4), (265, 23)],
('token',
[(265, 5), (265, 12)],
'.append'),
('token', [(265, 13), (265, 16)], 'acc'),
('string', [(265, 17), (265, 22)], 'Bar')),
('parens',
[(266, 4), (266, 23)],
('token',
[(266, 5), (266, 12)],
'.append'),
('token', [(266, 13), (266, 16)], 'acc'),
('string', [(266, 17), (266, 22)], 'Baz'))),
('parens',
[(267, 2), (267, 10)],
('token', [(267, 3), (267, 9)], 'my-fun')),
('parens',
[(268, 2), (268, 38)],
('token', [(268, 3), (268, 9)], 'assert'),
('parens',
[(268, 10), (268, 37)],
('token', [(268, 11), (268, 12)], '='),
('token', [(268, 13), (268, 16)], 'acc'),
('list',
[(268, 17), (268, 36)],
('string',
[(268, 18), (268, 23)],
'Foo'),
('string',
[(268, 24), (268, 29)],
'Bar'),
('string',
[(268, 30), (268, 35)],
'Baz'))))),
('parens',
[(271, 0), (275, 30)],
('token', [(271, 1), (271, 5)], 'defn'),
('token',
[(271, 6), (271, 22)],
'test-defn-return'),
('list', [(271, 23), (271, 25)]),
('string',
[(272, 2), (272, 28)],
'NATIVE: test defn return'),
('parens',
[(273, 2), (274, 12)],
('token', [(273, 3), (273, 7)], 'defn'),
('token', [(273, 8), (273, 14)], 'my-fun'),
('list',
[(273, 15), (273, 18)],
('token', [(273, 16), (273, 17)], 'x')),
('parens',
[(274, 4), (274, 11)],
('token', [(274, 5), (274, 6)], '+'),
('token', [(274, 7), (274, 8)], 'x'),
('number', [(274, 9), (274, 10)], '1'))),
('parens',
[(275, 2), (275, 29)],
('token', [(275, 3), (275, 9)], 'assert'),
('parens',
[(275, 10), (275, 28)],
('token', [(275, 11), (275, 12)], '='),
('number', [(275, 13), (275, 15)], '43'),
('parens',
[(275, 16), (275, 27)],
('token',
[(275, 17), (275, 23)],
'my-fun'),
('number',
[(275, 24), (275, 26)],
'42'))))),
('parens',
[(278, 0), (287, 39)],
('token', [(278, 1), (278, 5)], 'defn'),
('token',
[(278, 6), (278, 18)],
'test-defn-do'),
('list', [(278, 19), (278, 21)]),
('string',
[(279, 2), (279, 46)],
'NATIVE: test defn evaluation order with do'),
('parens',
[(280, 2), (280, 15)],
('token', [(280, 3), (280, 7)], 'setv'),
('token', [(280, 8), (280, 11)], 'acc'),
('list', [(280, 12), (280, 14)])),
('parens',
[(281, 2), (285, 27)],
('token', [(281, 3), (281, 7)], 'defn'),
('token', [(281, 8), (281, 14)], 'my-fun'),
('list', [(281, 15), (281, 17)]),
('parens',
[(282, 4), (285, 26)],
('token', [(282, 5), (282, 7)], 'do'),
('parens',
[(283, 6), (283, 25)],
('token',
[(283, 7), (283, 14)],
'.append'),
('token',
[(283, 15), (283, 18)],
'acc'),
('string',
[(283, 19), (283, 24)],
'Foo')),
('parens',
[(284, 6), (284, 25)],
('token',
[(284, 7), (284, 14)],
'.append'),
('token',
[(284, 15), (284, 18)],
'acc'),
('string',
[(284, 19), (284, 24)],
'Bar')),
('parens',
[(285, 6), (285, 25)],
('token',
[(285, 7), (285, 14)],
'.append'),
('token',
[(285, 15), (285, 18)],
'acc'),
('string',
[(285, 19), (285, 24)],
'Baz')))),
('parens',
[(286, 2), (286, 10)],
('token', [(286, 3), (286, 9)], 'my-fun')),
('parens',
[(287, 2), (287, 38)],
('token', [(287, 3), (287, 9)], 'assert'),
('parens',
[(287, 10), (287, 37)],
('token', [(287, 11), (287, 12)], '='),
('token', [(287, 13), (287, 16)], 'acc'),
('list',
[(287, 17), (287, 36)],
('string',
[(287, 18), (287, 23)],
'Foo'),
('string',
[(287, 24), (287, 29)],
'Bar'),
('string',
[(287, 30), (287, 35)],
'Baz'))))),
('parens',
[(290, 0), (296, 30)],
('token', [(290, 1), (290, 5)], 'defn'),
('token',
[(290, 6), (290, 25)],
'test-defn-do-return'),
('list', [(290, 26), (290, 28)]),
('string',
[(291, 2), (291, 36)],
'NATIVE: test defn return with do'),
('parens',
[(292, 2), (295, 15)],
('token', [(292, 3), (292, 7)], 'defn'),
('token', [(292, 8), (292, 14)], 'my-fun'),
('list',
[(292, 15), (292, 18)],
('token', [(292, 16), (292, 17)], 'x')),
('parens',
[(293, 4), (295, 14)],
('token', [(293, 5), (293, 7)], 'do'),
('parens',
[(294, 6), (294, 14)],
('token', [(294, 7), (294, 8)], '+'),
('token', [(294, 9), (294, 10)], 'x'),
('number',
[(294, 11), (294, 13)],
'42')),
('parens',
[(295, 6), (295, 13)],
('token', [(295, 7), (295, 8)], '+'),
('token', [(295, 9), (295, 10)], 'x'),
('number', [(295, 11), (295, 12)], '1')))),
('parens',
[(296, 2), (296, 29)],
('token', [(296, 3), (296, 9)], 'assert'),
('parens',
[(296, 10), (296, 28)],
('token', [(296, 11), (296, 12)], '='),
('number', [(296, 13), (296, 15)], '43'),
('parens',
[(296, 16), (296, 27)],
('token',
[(296, 17), (296, 23)],
'my-fun'),
('number',
[(296, 24), (296, 26)],
'42'))))),
('parens',
[(299, 0), (301, 35)],
('token', [(299, 1), (299, 5)], 'defn'),
('token',
[(299, 6), (299, 18)],
'test-mangles'),
('list', [(299, 19), (299, 21)]),
('string',
[(300, 2), (300, 24)],
'NATIVE: test mangles'),
('parens',
[(301, 2), (301, 34)],
('token', [(301, 3), (301, 9)], 'assert'),
('parens',
[(301, 10), (301, 33)],
('token', [(301, 11), (301, 12)], '='),
('number', [(301, 13), (301, 14)], '2'),
('parens',
[(301, 15), (301, 32)],
('parens',
[(301, 16), (301, 31)],
('token',
[(301, 17), (301, 19)],
'fn'),
('list', [(301, 20), (301, 22)]),
('parens',
[(301, 23), (301, 30)],
('token',
[(301, 24), (301, 25)],
'+'),
('number',
[(301, 26), (301, 27)],
'1'),
('number',
[(301, 28), (301, 29)],
'1'))))))),
('parens',
[(304, 0), (307, 27)],
('token', [(304, 1), (304, 5)], 'defn'),
('token',
[(304, 6), (304, 20)],
'test-fn-return'),
('list', [(304, 21), (304, 23)]),
('string',
[(305, 2), (305, 32)],
'NATIVE: test function return'),
('parens',
[(306, 2), (306, 42)],
('token', [(306, 3), (306, 7)], 'setv'),
('token', [(306, 8), (306, 15)], 'fn-test'),
('parens',
[(306, 16), (306, 41)],
('parens',
[(306, 17), (306, 40)],
('token', [(306, 18), (306, 20)], 'fn'),
('list', [(306, 21), (306, 23)]),
('parens',
[(306, 24), (306, 39)],
('token',
[(306, 25), (306, 27)],
'fn'),
('list', [(306, 28), (306, 30)]),
('parens',
[(306, 31), (306, 38)],
('token',
[(306, 32), (306, 33)],
'+'),
('number',
[(306, 34), (306, 35)],
'1'),
('number',
[(306, 36), (306, 37)],
'1')))))),
('parens',
[(307, 2), (307, 26)],
('token', [(307, 3), (307, 9)], 'assert'),
('parens',
[(307, 10), (307, 25)],
('token', [(307, 11), (307, 12)], '='),
('parens',
[(307, 13), (307, 22)],
('token',
[(307, 14), (307, 21)],
'fn-test')),
('number', [(307, 23), (307, 24)], '2')))),
('parens',
[(310, 0), (312, 53)],
('token', [(310, 1), (310, 5)], 'defn'),
('token', [(310, 6), (310, 14)], 'test-let'),
('list', [(310, 15), (310, 17)]),
('string',
[(311, 2), (311, 35)],
'NATIVE: test let works rightish'),
('parens',
[(312, 2), (312, 52)],
('token', [(312, 3), (312, 9)], 'assert'),
('parens',
[(312, 10), (312, 51)],
('token', [(312, 11), (312, 12)], '='),
('parens',
[(312, 13), (312, 48)],
('token',
[(312, 14), (312, 17)],
'let'),
('list',
[(312, 18), (312, 37)],
('list',
[(312, 19), (312, 24)],
('token',
[(312, 20), (312, 21)],
'x'),
('number',
[(312, 22), (312, 23)],
'1')),
('list',
[(312, 25), (312, 30)],
('token',
[(312, 26), (312, 27)],
'y'),
('number',
[(312, 28), (312, 29)],
'2')),
('list',
[(312, 31), (312, 36)],
('token',
[(312, 32), (312, 33)],
'z'),
('number',
[(312, 34), (312, 35)],
'3'))),
('parens',
[(312, 38), (312, 47)],
('token',
[(312, 39), (312, 40)],
'+'),
('token',
[(312, 41), (312, 42)],
'x'),
('token',
[(312, 43), (312, 44)],
'y'),
('token',
[(312, 45), (312, 46)],
'z'))),
('number', [(312, 49), (312, 50)], '6')))),
('parens',
[(315, 0), (317, 40)],
('token', [(315, 1), (315, 5)], 'defn'),
('token',
[(315, 6), (315, 21)],
'test-if-mangler'),
('list', [(315, 22), (315, 24)]),
('string',
[(316, 2), (316, 35)],
'NATIVE: test that we return ifs'),
('parens',
[(317, 2), (317, 39)],
('token', [(317, 3), (317, 9)], 'assert'),
('parens',
[(317, 10), (317, 38)],
('token', [(317, 11), (317, 12)], '='),
('token', [(317, 13), (317, 17)], 'true'),
('parens',
[(317, 18), (317, 37)],
('token', [(317, 19), (317, 21)], 'if'),
('token',
[(317, 22), (317, 26)],
'true'),
('token',
[(317, 27), (317, 31)],
'true'),
('token',
[(317, 32), (317, 36)],
'true'))))),
('parens',
[(320, 0), (331, 21)],
('token', [(320, 1), (320, 5)], 'defn'),
('token',
[(320, 6), (320, 20)],
'test-let-scope'),
('list', [(320, 21), (320, 23)]),
('string',
[(321, 2), (321, 35)],
'NATIVE: test let works rightish'),
('parens',
[(322, 2), (322, 14)],
('token', [(322, 3), (322, 7)], 'setv'),
('token', [(322, 8), (322, 9)], 'y'),
('number', [(322, 10), (322, 13)], '123')),
('parens',
[(323, 2), (327, 16)],
('token', [(323, 3), (323, 9)], 'assert'),
('parens',
[(323, 10), (327, 15)],
('token', [(323, 11), (323, 12)], '='),
('parens',
[(323, 13), (326, 25)],
('token',
[(323, 14), (323, 17)],
'let'),
('list',
[(323, 18), (325, 25)],
('list',
[(323, 19), (323, 24)],
('token',
[(323, 20), (323, 21)],
'x'),
('number',
[(323, 22), (323, 23)],
'1')),
('list',
[(324, 19), (324, 24)],
('token',
[(324, 20), (324, 21)],
'y'),
('number',
[(324, 22), (324, 23)],
'2')),
('list',
[(325, 19), (325, 24)],
('token',
[(325, 20), (325, 21)],
'z'),
('number',
[(325, 22), (325, 23)],
'3'))),
('parens',
[(326, 15), (326, 24)],
('token',
[(326, 16), (326, 17)],
'+'),
('token',
[(326, 18), (326, 19)],
'x'),
('token',
[(326, 20), (326, 21)],
'y'),
('token',
[(326, 22), (326, 23)],
'z'))),
('number', [(327, 13), (327, 14)], '6'))),
('parens',
[(328, 2), (330, 35)],
('token', [(328, 3), (328, 6)], 'try'),
('parens',
[(329, 4), (329, 21)],
('token',
[(329, 5), (329, 11)],
'assert'),
('parens',
[(329, 12), (329, 20)],
('token', [(329, 13), (329, 14)], '='),
('token', [(329, 15), (329, 16)], 'x'),
('number',
[(329, 17), (329, 19)],
'42'))),
('parens',
[(330, 4), (330, 34)],
('token', [(330, 5), (330, 10)], 'catch'),
('token',
[(330, 11), (330, 20)],
'NameError'),
('token', [(330, 21), (330, 22)], 'e'),
('parens',
[(330, 23), (330, 33)],
('token',
[(330, 24), (330, 30)],
'assert'),
('token', [(330, 31), (330, 32)], 'e')))),
('parens',
[(331, 2), (331, 20)],
('token', [(331, 3), (331, 9)], 'assert'),
('parens',
[(331, 10), (331, 19)],
('token', [(331, 11), (331, 12)], '='),
('token', [(331, 13), (331, 14)], 'y'),
('number', [(331, 15), (331, 18)], '123')))))
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import parsley
import pprint
grammar = r"""
# Hy Grammar
# Whitespace and comments
hspace = ' ' | '\t' | comment
vspace = '\r\n' | '\r' | '\n'
comment = ';' (~vspace anything)*
ws = (hspace | vspace | comment)+
# The root node is composed of zero or more parenthesized expressions separated by whitespace
root = (ws? (parens:first (ws parens)*:rest) ws? end -> ('root', self.get_boundaries(), first, ) + tuple(rest)) | ws? -> ('root', self.get_boundaries(), )
parens = '(' list_contents:contents ws? ')' -> ('parens', self.get_boundaries(), ) + contents
# A listey thing contains a (possibly empty) suite of whitespace-separated terms
list_contents = (ws? (term:first (ws term)*:rest) -> (first, ) + tuple(rest)) | -> ()
# A term can be several kinds of things
# please keep the "token" at the end, it eats lots of stuff.
term = string | quoted | unquoted | list | dict | parens | number | token
# A quoted term
quoted = '\'' term:term -> ('quoted', self.get_boundaries(), term)
# An unquoted term
unquoted = ',' term:term -> ('unquoted', self.get_boundaries(), term)
# A list
list = '[' list_contents:contents ws? ']' -> ('list', self.get_boundaries(), ) + contents
# A dict
dict = '{' list_contents:contents ws? '}' -> ('dict', self.get_boundaries(), ) + contents
# A string
string = '\"' <(escapedChar | ~'"' anything)*>:st '\"' -> ('string', self.get_boundaries(), st)
escapedChar = '\\' (
('"' -> '"') |
('/' -> '/') |
('b' -> '\b') |
('f' -> '\f') |
('n' -> '\n') |
('r' -> '\r') |
('t' -> '\t') |
('\\' -> '\\')
)
# A number
number = <digit+>:number -> ('number', self.get_boundaries(), number)
# Or a token
token = starred_token | litteral_token | ('*' -> ('token', self.get_boundaries(), '*'))
litteral_token = <(letterOrDigit | :x ?(x in "+-:=?<>,.!%~"))+>:t -> ('token', self.get_boundaries(), t)
starred_token = '*' litteral_token:t '*' -> ('starred_token', self.get_boundaries(), t[1])
"""
from ometa.runtime import OMetaBase
class HyGrammarBase(OMetaBase):
def __init__(self, *args, **kwargs):
super(HyGrammarBase, self).__init__(*args, **kwargs)
linecounts = []
counter = 0
for line in str(self.input.data).split('\n'):
counter += len(line) + 1
linecounts.append(counter)
self.__linecounts = linecounts
self.curpos = []
@property
def pos(self):
pos = self.input.position
prevcount = 0
for lineNo, count in enumerate(self.__linecounts):
if pos < count:
break
prevcount = count
return (lineNo + 1, pos - prevcount)
def get_boundaries(self, trace=False):
if trace:
import pdb; pdb.set_trace()
return self.curpos[-1:] + [self.pos]
def _apply(self, rule, ruleName, args):
try:
self.curpos.append(self.pos)
ret = super(HyGrammarBase, self)._apply(rule, ruleName, args)
finally:
self.curpos.pop()
return ret
g = parsley.makeGrammar(grammar, {}, extends=HyGrammarBase)
pprint.pprint(g(file('/home/nicolasd/code/hy/hy/tests/native_tests/language.hy').read()).root(), width=50)
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.