parse.c 41.4 KB
Newer Older
1
2
3
4
5
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
6
 * Copyright (c) 2013-2015 Damien P. George
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

xbe's avatar
xbe committed
27
#include <stdbool.h>
Damien's avatar
Damien committed
28
29
30
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
31
#include <string.h>
Damien's avatar
Damien committed
32

33
#include "py/nlr.h"
34
35
36
37
#include "py/lexer.h"
#include "py/parse.h"
#include "py/parsenum.h"
#include "py/smallint.h"
38
39
#include "py/runtime.h"
#include "py/builtin.h"
Damien's avatar
Damien committed
40
41

#define RULE_ACT_ARG_MASK       (0x0f)
42
43
44
#define RULE_ACT_KIND_MASK      (0x30)
#define RULE_ACT_ALLOW_IDENT    (0x40)
#define RULE_ACT_ADD_BLANK      (0x80)
Damien's avatar
Damien committed
45
46
47
48
49
50
51
52
#define RULE_ACT_OR             (0x10)
#define RULE_ACT_AND            (0x20)
#define RULE_ACT_LIST           (0x30)

#define RULE_ARG_KIND_MASK      (0xf000)
#define RULE_ARG_ARG_MASK       (0x0fff)
#define RULE_ARG_TOK            (0x1000)
#define RULE_ARG_RULE           (0x2000)
53
#define RULE_ARG_OPT_RULE       (0x3000)
Damien's avatar
Damien committed
54

55
#define ADD_BLANK_NODE(rule) ((rule->act & RULE_ACT_ADD_BLANK) != 0)
56

Damien's avatar
Damien committed
57
58
59
60
61
62
63
64
65
66
67
68
69
// (un)comment to use rule names; for debugging
//#define USE_RULE_NAME (1)

typedef struct _rule_t {
    byte rule_id;
    byte act;
#ifdef USE_RULE_NAME
    const char *rule_name;
#endif
    uint16_t arg[];
} rule_t;

enum {
70
#define DEF_RULE(rule, comp, kind, ...) RULE_##rule,
71
#include "py/grammar.h"
Damien's avatar
Damien committed
72
73
#undef DEF_RULE
    RULE_maximum_number_of,
74
    RULE_string, // special node for non-interned string
75
    RULE_bytes, // special node for non-interned bytes
76
    RULE_const_object, // special node for a constant, generic Python object
Damien's avatar
Damien committed
77
78
};

79
80
#define ident                   (RULE_ACT_ALLOW_IDENT)
#define blank                   (RULE_ACT_ADD_BLANK)
Damien's avatar
Damien committed
81
82
83
84
85
#define or(n)                   (RULE_ACT_OR | n)
#define and(n)                  (RULE_ACT_AND | n)
#define one_or_more             (RULE_ACT_LIST | 2)
#define list                    (RULE_ACT_LIST | 1)
#define list_with_end           (RULE_ACT_LIST | 3)
86
#define tok(t)                  (RULE_ARG_TOK | MP_TOKEN_##t)
Damien's avatar
Damien committed
87
88
89
#define rule(r)                 (RULE_ARG_RULE | RULE_##r)
#define opt_rule(r)             (RULE_ARG_OPT_RULE | RULE_##r)
#ifdef USE_RULE_NAME
90
#define DEF_RULE(rule, comp, kind, ...) static const rule_t rule_##rule = { RULE_##rule, kind, #rule, { __VA_ARGS__ } };
Damien's avatar
Damien committed
91
#else
92
#define DEF_RULE(rule, comp, kind, ...) static const rule_t rule_##rule = { RULE_##rule, kind, { __VA_ARGS__ } };
Damien's avatar
Damien committed
93
#endif
94
#include "py/grammar.h"
Damien's avatar
Damien committed
95
96
97
98
99
100
101
102
103
104
#undef or
#undef and
#undef list
#undef list_with_end
#undef tok
#undef rule
#undef opt_rule
#undef one_or_more
#undef DEF_RULE

105
STATIC const rule_t *rules[] = {
106
#define DEF_RULE(rule, comp, kind, ...) &rule_##rule,
107
#include "py/grammar.h"
Damien's avatar
Damien committed
108
109
110
111
#undef DEF_RULE
};

typedef struct _rule_stack_t {
112
113
114
    mp_uint_t src_line : BITS_PER_WORD - 8; // maximum bits storing source line number
    mp_uint_t rule_id : 8; // this must be large enough to fit largest rule number
    mp_uint_t arg_i; // this dictates the maximum nodes in a "list" of things
Damien's avatar
Damien committed
115
116
} rule_stack_t;

117
118
119
120
121
122
123
124
125
typedef struct _mp_parse_chunk_t {
    mp_uint_t alloc;
    union {
        mp_uint_t used;
        struct _mp_parse_chunk_t *next;
    } union_;
    byte data[];
} mp_parse_chunk_t;

126
127
128
129
130
131
typedef enum {
    PARSE_ERROR_NONE = 0,
    PARSE_ERROR_MEMORY,
    PARSE_ERROR_CONST,
} parse_error_t;

Damien's avatar
Damien committed
132
typedef struct _parser_t {
133
    parse_error_t parse_error;
134

135
136
    mp_uint_t rule_stack_alloc;
    mp_uint_t rule_stack_top;
Damien's avatar
Damien committed
137
138
    rule_stack_t *rule_stack;

139
140
    mp_uint_t result_stack_alloc;
    mp_uint_t result_stack_top;
141
    mp_parse_node_t *result_stack;
142
143

    mp_lexer_t *lexer;
144
145
146

    mp_parse_tree_t tree;
    mp_parse_chunk_t *cur_chunk;
Damien's avatar
Damien committed
147

148
149
150
151
    #if MICROPY_COMP_CONST
    mp_map_t consts;
    #endif
} parser_t;
152

153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
STATIC void *parser_alloc(parser_t *parser, size_t num_bytes) {
    // use a custom memory allocator to store parse nodes sequentially in large chunks

    mp_parse_chunk_t *chunk = parser->cur_chunk;

    if (chunk != NULL && chunk->union_.used + num_bytes > chunk->alloc) {
        // not enough room at end of previously allocated chunk so try to grow
        mp_parse_chunk_t *new_data = (mp_parse_chunk_t*)m_renew_maybe(byte, chunk,
            sizeof(mp_parse_chunk_t) + chunk->alloc,
            sizeof(mp_parse_chunk_t) + chunk->alloc + num_bytes, false);
        if (new_data == NULL) {
            // could not grow existing memory; shrink it to fit previous
            (void)m_renew(byte, chunk, sizeof(mp_parse_chunk_t) + chunk->alloc,
                sizeof(mp_parse_chunk_t) + chunk->union_.used);
            chunk->alloc = chunk->union_.used;
            chunk->union_.next = parser->tree.chunk;
            parser->tree.chunk = chunk;
            chunk = NULL;
        } else {
            // could grow existing memory
            chunk->alloc += num_bytes;
        }
    }

    if (chunk == NULL) {
        // no previous chunk, allocate a new chunk
        size_t alloc = MICROPY_ALLOC_PARSE_CHUNK_INIT;
        if (alloc < num_bytes) {
            alloc = num_bytes;
        }
        chunk = (mp_parse_chunk_t*)m_new(byte, sizeof(mp_parse_chunk_t) + alloc);
        chunk->alloc = alloc;
        chunk->union_.used = 0;
        parser->cur_chunk = chunk;
    }

    byte *ret = chunk->data + chunk->union_.used;
    chunk->union_.used += num_bytes;
    return ret;
}

194
STATIC void push_rule(parser_t *parser, mp_uint_t src_line, const rule_t *rule, mp_uint_t arg_i) {
195
    if (parser->parse_error) {
196
197
        return;
    }
Damien's avatar
Damien committed
198
    if (parser->rule_stack_top >= parser->rule_stack_alloc) {
199
        rule_stack_t *rs = m_renew_maybe(rule_stack_t, parser->rule_stack, parser->rule_stack_alloc, parser->rule_stack_alloc + MICROPY_ALLOC_PARSE_RULE_INC, true);
200
        if (rs == NULL) {
201
            parser->parse_error = PARSE_ERROR_MEMORY;
202
203
204
            return;
        }
        parser->rule_stack = rs;
205
        parser->rule_stack_alloc += MICROPY_ALLOC_PARSE_RULE_INC;
Damien's avatar
Damien committed
206
    }
207
208
209
210
    rule_stack_t *rs = &parser->rule_stack[parser->rule_stack_top++];
    rs->src_line = src_line;
    rs->rule_id = rule->rule_id;
    rs->arg_i = arg_i;
Damien's avatar
Damien committed
211
212
}

213
STATIC void push_rule_from_arg(parser_t *parser, mp_uint_t arg) {
Damien's avatar
Damien committed
214
    assert((arg & RULE_ARG_KIND_MASK) == RULE_ARG_RULE || (arg & RULE_ARG_KIND_MASK) == RULE_ARG_OPT_RULE);
215
    mp_uint_t rule_id = arg & RULE_ARG_ARG_MASK;
Damien's avatar
Damien committed
216
    assert(rule_id < RULE_maximum_number_of);
217
    push_rule(parser, parser->lexer->tok_line, rules[rule_id], 0);
Damien's avatar
Damien committed
218
219
}

220
STATIC void pop_rule(parser_t *parser, const rule_t **rule, mp_uint_t *arg_i, mp_uint_t *src_line) {
221
    assert(!parser->parse_error);
Damien's avatar
Damien committed
222
223
224
    parser->rule_stack_top -= 1;
    *rule = rules[parser->rule_stack[parser->rule_stack_top].rule_id];
    *arg_i = parser->rule_stack[parser->rule_stack_top].arg_i;
225
    *src_line = parser->rule_stack[parser->rule_stack_top].src_line;
Damien's avatar
Damien committed
226
227
}

228
mp_parse_node_t mp_parse_node_new_leaf(mp_int_t kind, mp_int_t arg) {
229
230
231
    if (kind == MP_PARSE_NODE_SMALL_INT) {
        return (mp_parse_node_t)(kind | (arg << 1));
    }
232
    return (mp_parse_node_t)(kind | (arg << 4));
Damien's avatar
Damien committed
233
234
}

235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
int mp_parse_node_extract_list(mp_parse_node_t *pn, mp_uint_t pn_kind, mp_parse_node_t **nodes) {
    if (MP_PARSE_NODE_IS_NULL(*pn)) {
        *nodes = NULL;
        return 0;
    } else if (MP_PARSE_NODE_IS_LEAF(*pn)) {
        *nodes = pn;
        return 1;
    } else {
        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)(*pn);
        if (MP_PARSE_NODE_STRUCT_KIND(pns) != pn_kind) {
            *nodes = pn;
            return 1;
        } else {
            *nodes = pns->nodes;
            return MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
        }
    }
}

254
#if MICROPY_DEBUG_PRINTERS
255
void mp_parse_node_print(mp_parse_node_t pn, mp_uint_t indent) {
256
257
258
259
260
    if (MP_PARSE_NODE_IS_STRUCT(pn)) {
        printf("[% 4d] ", (int)((mp_parse_node_struct_t*)pn)->source_line);
    } else {
        printf("       ");
    }
261
    for (mp_uint_t i = 0; i < indent; i++) {
Damien's avatar
Damien committed
262
263
        printf(" ");
    }
264
    if (MP_PARSE_NODE_IS_NULL(pn)) {
Damien's avatar
Damien committed
265
        printf("NULL\n");
266
    } else if (MP_PARSE_NODE_IS_SMALL_INT(pn)) {
267
        mp_int_t arg = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
268
        printf("int(" INT_FMT ")\n", arg);
269
    } else if (MP_PARSE_NODE_IS_LEAF(pn)) {
270
        mp_uint_t arg = MP_PARSE_NODE_LEAF_ARG(pn);
271
272
273
274
        switch (MP_PARSE_NODE_LEAF_KIND(pn)) {
            case MP_PARSE_NODE_ID: printf("id(%s)\n", qstr_str(arg)); break;
            case MP_PARSE_NODE_STRING: printf("str(%s)\n", qstr_str(arg)); break;
            case MP_PARSE_NODE_BYTES: printf("bytes(%s)\n", qstr_str(arg)); break;
275
            case MP_PARSE_NODE_TOKEN: printf("tok(" INT_FMT ")\n", arg); break;
Damien's avatar
Damien committed
276
277
278
            default: assert(0);
        }
    } else {
279
        // node must be a mp_parse_node_struct_t
280
        mp_parse_node_struct_t *pns = (mp_parse_node_struct_t*)pn;
281
282
        if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_string) {
            printf("literal str(%.*s)\n", (int)pns->nodes[1], (char*)pns->nodes[0]);
283
284
        } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_bytes) {
            printf("literal bytes(%.*s)\n", (int)pns->nodes[1], (char*)pns->nodes[0]);
285
286
        } else if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_const_object) {
            printf("literal const(%p)\n", (mp_obj_t)pns->nodes[0]);
287
        } else {
288
            mp_uint_t n = MP_PARSE_NODE_STRUCT_NUM_NODES(pns);
Damien's avatar
Damien committed
289
#ifdef USE_RULE_NAME
290
            printf("%s(" UINT_FMT ") (n=" UINT_FMT ")\n", rules[MP_PARSE_NODE_STRUCT_KIND(pns)]->rule_name, (mp_uint_t)MP_PARSE_NODE_STRUCT_KIND(pns), n);
Damien's avatar
Damien committed
291
#else
292
            printf("rule(" UINT_FMT ") (n=" UINT_FMT ")\n", (mp_uint_t)MP_PARSE_NODE_STRUCT_KIND(pns), n);
Damien's avatar
Damien committed
293
#endif
294
            for (mp_uint_t i = 0; i < n; i++) {
295
296
                mp_parse_node_print(pns->nodes[i], indent + 2);
            }
Damien's avatar
Damien committed
297
298
299
        }
    }
}
300
#endif // MICROPY_DEBUG_PRINTERS
Damien's avatar
Damien committed
301
302

/*
303
STATIC void result_stack_show(parser_t *parser) {
Damien's avatar
Damien committed
304
    printf("result stack, most recent first\n");
305
    for (mp_int_t i = parser->result_stack_top - 1; i >= 0; i--) {
306
        mp_parse_node_print(parser->result_stack[i], 0);
Damien's avatar
Damien committed
307
308
309
310
    }
}
*/

311
STATIC mp_parse_node_t pop_result(parser_t *parser) {
312
    if (parser->parse_error) {
313
314
        return MP_PARSE_NODE_NULL;
    }
Damien's avatar
Damien committed
315
316
317
318
    assert(parser->result_stack_top > 0);
    return parser->result_stack[--parser->result_stack_top];
}

319
STATIC mp_parse_node_t peek_result(parser_t *parser, mp_uint_t pos) {
320
    if (parser->parse_error) {
321
322
        return MP_PARSE_NODE_NULL;
    }
Damien's avatar
Damien committed
323
324
325
326
    assert(parser->result_stack_top > pos);
    return parser->result_stack[parser->result_stack_top - 1 - pos];
}

327
STATIC void push_result_node(parser_t *parser, mp_parse_node_t pn) {
328
    if (parser->parse_error) {
329
330
        return;
    }
331
    if (parser->result_stack_top >= parser->result_stack_alloc) {
332
        mp_parse_node_t *stack = m_renew_maybe(mp_parse_node_t, parser->result_stack, parser->result_stack_alloc, parser->result_stack_alloc + MICROPY_ALLOC_PARSE_RESULT_INC, true);
333
        if (stack == NULL) {
334
            parser->parse_error = PARSE_ERROR_MEMORY;
335
336
            return;
        }
337
        parser->result_stack = stack;
338
        parser->result_stack_alloc += MICROPY_ALLOC_PARSE_RESULT_INC;
339
    }
Damien's avatar
Damien committed
340
341
342
    parser->result_stack[parser->result_stack_top++] = pn;
}

343
STATIC mp_parse_node_t make_node_string_bytes(parser_t *parser, mp_uint_t src_line, mp_uint_t rule_kind, const char *str, mp_uint_t len) {
344
    mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_parse_node_t) * 2);
345
    if (pn == NULL) {
346
        parser->parse_error = PARSE_ERROR_MEMORY;
347
        return MP_PARSE_NODE_NULL;
348
349
    }
    pn->source_line = src_line;
350
    pn->kind_num_nodes = rule_kind | (2 << 8);
351
352
    char *p = m_new(char, len);
    memcpy(p, str, len);
353
    pn->nodes[0] = (mp_int_t)p;
354
    pn->nodes[1] = len;
355
356
357
358
    return (mp_parse_node_t)pn;
}

STATIC mp_parse_node_t make_node_const_object(parser_t *parser, mp_uint_t src_line, mp_obj_t obj) {
359
    mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_parse_node_t));
360
    if (pn == NULL) {
361
        parser->parse_error = PARSE_ERROR_MEMORY;
362
363
364
365
366
367
        return MP_PARSE_NODE_NULL;
    }
    pn->source_line = src_line;
    pn->kind_num_nodes = RULE_const_object | (1 << 8);
    pn->nodes[0] = (mp_uint_t)obj;
    return (mp_parse_node_t)pn;
368
}
369

370
STATIC void push_result_token(parser_t *parser) {
371
    mp_parse_node_t pn;
372
373
    mp_lexer_t *lex = parser->lexer;
    if (lex->tok_kind == MP_TOKEN_NAME) {
374
375
376
377
378
379
380
381
382
383
384
        qstr id = qstr_from_strn(lex->vstr.buf, lex->vstr.len);
        #if MICROPY_COMP_CONST
        // lookup identifier in table of dynamic constants
        mp_map_elem_t *elem = mp_map_lookup(&parser->consts, MP_OBJ_NEW_QSTR(id), MP_MAP_LOOKUP);
        if (elem != NULL) {
            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, MP_OBJ_SMALL_INT_VALUE(elem->value));
        } else
        #endif
        {
            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_ID, id);
        }
385
386
387
388
    } else if (lex->tok_kind == MP_TOKEN_INTEGER) {
        mp_obj_t o = mp_parse_num_integer(lex->vstr.buf, lex->vstr.len, 0, lex);
        if (MP_OBJ_IS_SMALL_INT(o)) {
            pn = mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, MP_OBJ_SMALL_INT_VALUE(o));
Damien's avatar
Damien committed
389
        } else {
390
            pn = make_node_const_object(parser, lex->tok_line, o);
Damien's avatar
Damien committed
391
        }
392
393
394
    } else if (lex->tok_kind == MP_TOKEN_FLOAT_OR_IMAG) {
        mp_obj_t o = mp_parse_num_decimal(lex->vstr.buf, lex->vstr.len, true, false, lex);
        pn = make_node_const_object(parser, lex->tok_line, o);
395
396
    } else if (lex->tok_kind == MP_TOKEN_STRING || lex->tok_kind == MP_TOKEN_BYTES) {
        // Don't automatically intern all strings/bytes.  doc strings (which are usually large)
397
398
        // will be discarded by the compiler, and so we shouldn't intern them.
        qstr qst = MP_QSTR_NULL;
399
        if (lex->vstr.len <= MICROPY_ALLOC_PARSE_INTERN_STRING_LEN) {
400
            // intern short strings
401
            qst = qstr_from_strn(lex->vstr.buf, lex->vstr.len);
402
403
        } else {
            // check if this string is already interned
404
            qst = qstr_find_strn(lex->vstr.buf, lex->vstr.len);
405
406
407
        }
        if (qst != MP_QSTR_NULL) {
            // qstr exists, make a leaf node
408
            pn = mp_parse_node_new_leaf(lex->tok_kind == MP_TOKEN_STRING ? MP_PARSE_NODE_STRING : MP_PARSE_NODE_BYTES, qst);
409
        } else {
410
            // not interned, make a node holding a pointer to the string/bytes data
411
            pn = make_node_string_bytes(parser, lex->tok_line, lex->tok_kind == MP_TOKEN_STRING ? RULE_string : RULE_bytes, lex->vstr.buf, lex->vstr.len);
412
        }
Damien's avatar
Damien committed
413
    } else {
414
        pn = mp_parse_node_new_leaf(MP_PARSE_NODE_TOKEN, lex->tok_kind);
Damien's avatar
Damien committed
415
416
417
418
    }
    push_result_node(parser, pn);
}

419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
#if MICROPY_COMP_MODULE_CONST
STATIC const mp_map_elem_t mp_constants_table[] = {
    #if MICROPY_PY_UCTYPES
    { MP_OBJ_NEW_QSTR(MP_QSTR_uctypes), (mp_obj_t)&mp_module_uctypes },
    #endif
    // Extra constants as defined by a port
    MICROPY_PORT_CONSTANTS
};
STATIC MP_DEFINE_CONST_MAP(mp_constants_map, mp_constants_table);
#endif

#if MICROPY_COMP_CONST_FOLDING
STATIC bool fold_constants(parser_t *parser, const rule_t *rule, mp_uint_t num_args) {
    // this code does folding of arbitrary integer expressions, eg 1 + 2 * 3 + 4
    // it does not do partial folding, eg 1 + 2 + x -> 3 + x

    mp_int_t arg0;
    if (rule->rule_id == RULE_expr
        || rule->rule_id == RULE_xor_expr
        || rule->rule_id == RULE_and_expr) {
        // folding for binary ops: | ^ &
        mp_parse_node_t pn = peek_result(parser, num_args - 1);
        if (!MP_PARSE_NODE_IS_SMALL_INT(pn)) {
            return false;
        }
        arg0 = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
        for (mp_int_t i = num_args - 2; i >= 0; --i) {
            pn = peek_result(parser, i);
            if (!MP_PARSE_NODE_IS_SMALL_INT(pn)) {
                return false;
            }
            mp_int_t arg1 = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
            if (rule->rule_id == RULE_expr) {
                // int | int
                arg0 |= arg1;
            } else if (rule->rule_id == RULE_xor_expr) {
                // int ^ int
                arg0 ^= arg1;
            } else if (rule->rule_id == RULE_and_expr) {
                // int & int
                arg0 &= arg1;
            }
        }
    } else if (rule->rule_id == RULE_shift_expr
        || rule->rule_id == RULE_arith_expr
        || rule->rule_id == RULE_term) {
        // folding for binary ops: << >> + - * / % //
        mp_parse_node_t pn = peek_result(parser, num_args - 1);
        if (!MP_PARSE_NODE_IS_SMALL_INT(pn)) {
            return false;
        }
        arg0 = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
        for (mp_int_t i = num_args - 2; i >= 1; i -= 2) {
            pn = peek_result(parser, i - 1);
            if (!MP_PARSE_NODE_IS_SMALL_INT(pn)) {
                return false;
            }
            mp_int_t arg1 = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
            mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, i));
            if (tok == MP_TOKEN_OP_DBL_LESS) {
                // int << int
                if (arg1 >= (mp_int_t)BITS_PER_WORD
                    || arg0 > (MP_SMALL_INT_MAX >> arg1)
                    || arg0 < (MP_SMALL_INT_MIN >> arg1)) {
                    return false;
                }
                arg0 <<= arg1;
            } else if (tok == MP_TOKEN_OP_DBL_MORE) {
                // int >> int
                if (arg1 >= (mp_int_t)BITS_PER_WORD) {
                    // Shifting to big amounts is underfined behavior
                    // in C and is CPU-dependent; propagate sign bit.
                    arg1 = BITS_PER_WORD - 1;
                }
                arg0 >>= arg1;
            } else if (tok == MP_TOKEN_OP_PLUS) {
                // int + int
                arg0 += arg1;
            } else if (tok == MP_TOKEN_OP_MINUS) {
                // int - int
                arg0 -= arg1;
            } else if (tok == MP_TOKEN_OP_STAR) {
                // int * int
                if (mp_small_int_mul_overflow(arg0, arg1)) {
                    return false;
                }
                arg0 *= arg1;
            } else if (tok == MP_TOKEN_OP_SLASH) {
                // int / int
                return false;
            } else if (tok == MP_TOKEN_OP_PERCENT) {
                // int % int
                if (arg1 == 0) {
                    return false;
                }
                arg0 = mp_small_int_modulo(arg0, arg1);
            } else {
                assert(tok == MP_TOKEN_OP_DBL_SLASH); // should be
                // int // int
                if (arg1 == 0) {
                    return false;
                }
                arg0 = mp_small_int_floor_divide(arg0, arg1);
            }
            if (!MP_SMALL_INT_FITS(arg0)) {
                return false;
            }
        }
    } else if (rule->rule_id == RULE_factor_2) {
        // folding for unary ops: + - ~
        mp_parse_node_t pn = peek_result(parser, 0);
        if (!MP_PARSE_NODE_IS_SMALL_INT(pn)) {
            return false;
        }
        arg0 = MP_PARSE_NODE_LEAF_SMALL_INT(pn);
        mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, 1));
        if (tok == MP_TOKEN_OP_PLUS) {
            // +int
        } else if (tok == MP_TOKEN_OP_MINUS) {
            // -int
            arg0 = -arg0;
            if (!MP_SMALL_INT_FITS(arg0)) {
                return false;
            }
        } else {
            assert(tok == MP_TOKEN_OP_TILDE); // should be
            // ~int
            arg0 = ~arg0;
        }

    #if MICROPY_COMP_CONST
    } else if (rule->rule_id == RULE_expr_stmt) {
        mp_parse_node_t pn1 = peek_result(parser, 0);
        if (!MP_PARSE_NODE_IS_NULL(pn1)
            && !(MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_expr_stmt_augassign)
            || MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_expr_stmt_assign_list))) {
            // this node is of the form <x> = <y>
            mp_parse_node_t pn0 = peek_result(parser, 1);
            if (MP_PARSE_NODE_IS_ID(pn0)
                && MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_power)
                && MP_PARSE_NODE_IS_ID(((mp_parse_node_struct_t*)pn1)->nodes[0])
                && MP_PARSE_NODE_LEAF_ARG(((mp_parse_node_struct_t*)pn1)->nodes[0]) == MP_QSTR_const
                && MP_PARSE_NODE_IS_STRUCT_KIND(((mp_parse_node_struct_t*)pn1)->nodes[1], RULE_trailer_paren)
                && MP_PARSE_NODE_IS_NULL(((mp_parse_node_struct_t*)pn1)->nodes[2])
                ) {
                // code to assign dynamic constants: id = const(value)

                // get the id
                qstr id = MP_PARSE_NODE_LEAF_ARG(pn0);

                // get the value
                mp_parse_node_t pn_value = ((mp_parse_node_struct_t*)((mp_parse_node_struct_t*)pn1)->nodes[1])->nodes[0];
                if (!MP_PARSE_NODE_IS_SMALL_INT(pn_value)) {
                    parser->parse_error = PARSE_ERROR_CONST;
                    return false;
                }
                mp_int_t value = MP_PARSE_NODE_LEAF_SMALL_INT(pn_value);

                // store the value in the table of dynamic constants
                mp_map_elem_t *elem = mp_map_lookup(&parser->consts, MP_OBJ_NEW_QSTR(id), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
                assert(elem->value == MP_OBJ_NULL);
                elem->value = MP_OBJ_NEW_SMALL_INT(value);

                // replace const(value) with value
                pop_result(parser);
                push_result_node(parser, pn_value);

                // finished folding this assignment, but we still want it to be part of the tree
                return false;
            }
        }
        return false;
    #endif

    #if MICROPY_COMP_MODULE_CONST
    } else if (rule->rule_id == RULE_power) {
        mp_parse_node_t pn0 = peek_result(parser, 2);
        mp_parse_node_t pn1 = peek_result(parser, 1);
        mp_parse_node_t pn2 = peek_result(parser, 0);
        if (!(MP_PARSE_NODE_IS_ID(pn0)
            && MP_PARSE_NODE_IS_STRUCT_KIND(pn1, RULE_trailer_period)
            && MP_PARSE_NODE_IS_NULL(pn2))) {
            return false;
        }
        // id1.id2
        // look it up in constant table, see if it can be replaced with an integer
        mp_parse_node_struct_t *pns1 = (mp_parse_node_struct_t*)pn1;
        assert(MP_PARSE_NODE_IS_ID(pns1->nodes[0]));
        qstr q_base = MP_PARSE_NODE_LEAF_ARG(pn0);
        qstr q_attr = MP_PARSE_NODE_LEAF_ARG(pns1->nodes[0]);
        mp_map_elem_t *elem = mp_map_lookup((mp_map_t*)&mp_constants_map, MP_OBJ_NEW_QSTR(q_base), MP_MAP_LOOKUP);
        if (elem == NULL) {
            return false;
        }
        mp_obj_t dest[2];
        mp_load_method_maybe(elem->value, q_attr, dest);
        if (!(MP_OBJ_IS_SMALL_INT(dest[0]) && dest[1] == NULL)) {
            return false;
        }
        arg0 = MP_OBJ_SMALL_INT_VALUE(dest[0]);
    #endif

    } else {
        return false;
    }

    // success folding this rule

    for (mp_uint_t i = num_args; i > 0; i--) {
        pop_result(parser);
    }
    push_result_node(parser, mp_parse_node_new_leaf(MP_PARSE_NODE_SMALL_INT, arg0));

    return true;
}
#endif

636
STATIC void push_result_rule(parser_t *parser, mp_uint_t src_line, const rule_t *rule, mp_uint_t num_args) {
637
638
639
640
641
642
643
    #if MICROPY_COMP_CONST_FOLDING
    if (fold_constants(parser, rule, num_args)) {
        // we folded this rule so return straight away
        return;
    }
    #endif

644
    mp_parse_node_struct_t *pn = parser_alloc(parser, sizeof(mp_parse_node_struct_t) + sizeof(mp_parse_node_t) * num_args);
645
    if (pn == NULL) {
646
        parser->parse_error = PARSE_ERROR_MEMORY;
647
648
649
650
        return;
    }
    pn->source_line = src_line;
    pn->kind_num_nodes = (rule->rule_id & 0xff) | (num_args << 8);
651
    for (mp_uint_t i = num_args; i > 0; i--) {
Damien's avatar
Damien committed
652
653
        pn->nodes[i - 1] = pop_result(parser);
    }
654
    push_result_node(parser, (mp_parse_node_t)pn);
Damien's avatar
Damien committed
655
656
}

657
mp_parse_tree_t mp_parse(mp_lexer_t *lex, mp_parse_input_kind_t input_kind) {
658

659
    // initialise parser and allocate memory for its stacks
660

661
    parser_t parser;
662

663
    parser.parse_error = PARSE_ERROR_NONE;
664

665
    parser.rule_stack_alloc = MICROPY_ALLOC_PARSE_RULE_INIT;
666
667
    parser.rule_stack_top = 0;
    parser.rule_stack = m_new_maybe(rule_stack_t, parser.rule_stack_alloc);
Damien's avatar
Damien committed
668

669
    parser.result_stack_alloc = MICROPY_ALLOC_PARSE_RESULT_INIT;
670
671
    parser.result_stack_top = 0;
    parser.result_stack = m_new_maybe(mp_parse_node_t, parser.result_stack_alloc);
Damien's avatar
Damien committed
672

673
674
    parser.lexer = lex;

675
676
677
    parser.tree.chunk = NULL;
    parser.cur_chunk = NULL;

678
679
680
681
    #if MICROPY_COMP_CONST
    mp_map_init(&parser.consts, 0);
    #endif

682
683
684
685
    // check if we could allocate the stacks
    if (parser.rule_stack == NULL || parser.result_stack == NULL) {
        goto memory_error;
    }
686

687
    // work out the top-level rule to use, and push it on the stack
688
    mp_uint_t top_level_rule;
Damien's avatar
Damien committed
689
    switch (input_kind) {
690
        case MP_PARSE_SINGLE_INPUT: top_level_rule = RULE_single_input; break;
Damien George's avatar
Damien George committed
691
        case MP_PARSE_EVAL_INPUT: top_level_rule = RULE_eval_input; break;
Damien's avatar
Damien committed
692
693
        default: top_level_rule = RULE_file_input;
    }
694
    push_rule(&parser, lex->tok_line, rules[top_level_rule], 0);
Damien's avatar
Damien committed
695

696
697
    // parse!

698
699
    mp_uint_t n, i; // state for the current rule
    mp_uint_t rule_src_line; // source line for the first token matched by the current rule
Damien's avatar
Damien committed
700
    bool backtrack = false;
701
    const rule_t *rule = NULL;
Damien's avatar
Damien committed
702
703
704

    for (;;) {
        next_rule:
705
        if (parser.rule_stack_top == 0 || parser.parse_error) {
Damien's avatar
Damien committed
706
707
708
            break;
        }

709
        pop_rule(&parser, &rule, &i, &rule_src_line);
Damien's avatar
Damien committed
710
711
712
713
        n = rule->act & RULE_ACT_ARG_MASK;

        /*
        // debugging
714
715
        printf("depth=%d ", parser.rule_stack_top);
        for (int j = 0; j < parser.rule_stack_top; ++j) {
Damien's avatar
Damien committed
716
717
718
719
720
721
722
723
724
725
726
727
            printf(" ");
        }
        printf("%s n=%d i=%d bt=%d\n", rule->rule_name, n, i, backtrack);
        */

        switch (rule->act & RULE_ACT_KIND_MASK) {
            case RULE_ACT_OR:
                if (i > 0 && !backtrack) {
                    goto next_rule;
                } else {
                    backtrack = false;
                }
728
729
730
731
732
733
                for (; i < n; ++i) {
                    uint16_t kind = rule->arg[i] & RULE_ARG_KIND_MASK;
                    if (kind == RULE_ARG_TOK) {
                        if (lex->tok_kind == (rule->arg[i] & RULE_ARG_ARG_MASK)) {
                            push_result_token(&parser);
                            mp_lexer_to_next(lex);
Damien's avatar
Damien committed
734
                            goto next_rule;
735
                        }
Damien's avatar
Damien committed
736
                    } else {
737
738
739
740
741
                        assert(kind == RULE_ARG_RULE);
                        if (i + 1 < n) {
                            push_rule(&parser, rule_src_line, rule, i + 1); // save this or-rule
                        }
                        push_rule_from_arg(&parser, rule->arg[i]); // push child of or-rule
Damien's avatar
Damien committed
742
743
744
                        goto next_rule;
                    }
                }
745
                backtrack = true;
Damien's avatar
Damien committed
746
747
                break;

748
            case RULE_ACT_AND: {
Damien's avatar
Damien committed
749
750
751
752
753
754

                // failed, backtrack if we can, else syntax error
                if (backtrack) {
                    assert(i > 0);
                    if ((rule->arg[i - 1] & RULE_ARG_KIND_MASK) == RULE_ARG_OPT_RULE) {
                        // an optional rule that failed, so continue with next arg
755
                        push_result_node(&parser, MP_PARSE_NODE_NULL);
Damien's avatar
Damien committed
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
                        backtrack = false;
                    } else {
                        // a mandatory rule that failed, so propagate backtrack
                        if (i > 1) {
                            // already eaten tokens so can't backtrack
                            goto syntax_error;
                        } else {
                            goto next_rule;
                        }
                    }
                }

                // progress through the rule
                for (; i < n; ++i) {
                    switch (rule->arg[i] & RULE_ARG_KIND_MASK) {
771
                        case RULE_ARG_TOK: {
Damien's avatar
Damien committed
772
                            // need to match a token
773
                            mp_token_kind_t tok_kind = rule->arg[i] & RULE_ARG_ARG_MASK;
774
                            if (lex->tok_kind == tok_kind) {
Damien's avatar
Damien committed
775
                                // matched token
776
                                if (tok_kind == MP_TOKEN_NAME) {
777
                                    push_result_token(&parser);
Damien's avatar
Damien committed
778
                                }
779
                                mp_lexer_to_next(lex);
Damien's avatar
Damien committed
780
781
782
783
784
785
786
787
788
789
790
791
                            } else {
                                // failed to match token
                                if (i > 0) {
                                    // already eaten tokens so can't backtrack
                                    goto syntax_error;
                                } else {
                                    // this rule failed, so backtrack
                                    backtrack = true;
                                    goto next_rule;
                                }
                            }
                            break;
792
                        }
Damien's avatar
Damien committed
793
794
                        case RULE_ARG_RULE:
                        case RULE_ARG_OPT_RULE:
795
                        rule_and_no_other_choice:
796
797
                            push_rule(&parser, rule_src_line, rule, i + 1); // save this and-rule
                            push_rule_from_arg(&parser, rule->arg[i]); // push child of and-rule
Damien's avatar
Damien committed
798
799
800
                            goto next_rule;
                        default:
                            assert(0);
801
                            goto rule_and_no_other_choice; // to help flow control analysis
Damien's avatar
Damien committed
802
803
804
805
806
807
808
809
810
                    }
                }

                assert(i == n);

                // matched the rule, so now build the corresponding parse_node

                // count number of arguments for the parse_node
                i = 0;
811
                bool emit_rule = false;
812
                for (mp_uint_t x = 0; x < n; ++x) {
Damien's avatar
Damien committed
813
                    if ((rule->arg[x] & RULE_ARG_KIND_MASK) == RULE_ARG_TOK) {
814
                        mp_token_kind_t tok_kind = rule->arg[x] & RULE_ARG_ARG_MASK;
815
                        if (tok_kind >= MP_TOKEN_NAME) {
Damien's avatar
Damien committed
816
817
                            emit_rule = true;
                        }
818
                        if (tok_kind == MP_TOKEN_NAME) {
Damien's avatar
Damien committed
819
820
821
822
823
824
825
826
827
                            // only tokens which were names are pushed to stack
                            i += 1;
                        }
                    } else {
                        // rules are always pushed
                        i += 1;
                    }
                }

828
                #if !MICROPY_ENABLE_DOC_STRING
829
                // this code discards lonely statements, such as doc strings
830
831
                if (input_kind != MP_PARSE_SINGLE_INPUT && rule->rule_id == RULE_expr_stmt && peek_result(&parser, 0) == MP_PARSE_NODE_NULL) {
                    mp_parse_node_t p = peek_result(&parser, 1);
832
                    if ((MP_PARSE_NODE_IS_LEAF(p) && !MP_PARSE_NODE_IS_ID(p)) || MP_PARSE_NODE_IS_STRUCT_KIND(p, RULE_string)) {
833
                        pop_result(&parser); // MP_PARSE_NODE_NULL
834
835
836
837
838
839
840
                        mp_parse_node_t pn = pop_result(&parser); // possibly RULE_string
                        if (MP_PARSE_NODE_IS_STRUCT(pn)) {
                            mp_parse_node_struct_t *pns = (mp_parse_node_struct_t *)pn;
                            if (MP_PARSE_NODE_STRUCT_KIND(pns) == RULE_string) {
                                m_del(char, (char*)pns->nodes[0], (mp_uint_t)pns->nodes[1]);
                            }
                        }
841
                        push_result_rule(&parser, rule_src_line, rules[RULE_pass_stmt], 0);
842
843
844
                        break;
                    }
                }
845
                #endif
846

Damien's avatar
Damien committed
847
848
849
850
851
                // always emit these rules, even if they have only 1 argument
                if (rule->rule_id == RULE_expr_stmt || rule->rule_id == RULE_yield_stmt) {
                    emit_rule = true;
                }

852
853
854
855
856
                // if a rule has the RULE_ACT_ALLOW_IDENT bit set then this
                // rule should not be emitted if it has only 1 argument
                // NOTE: can't set this flag for atom_paren because we need it
                // to distinguish, for example, [a,b] from [(a,b)]
                if (rule->act & RULE_ACT_ALLOW_IDENT) {
Damien's avatar
Damien committed
857
858
859
860
                    emit_rule = false;
                }

                // always emit these rules, and add an extra blank node at the end (to be used by the compiler to store data)
861
                if (ADD_BLANK_NODE(rule)) {
Damien's avatar
Damien committed
862
                    emit_rule = true;
863
                    push_result_node(&parser, MP_PARSE_NODE_NULL);
Damien's avatar
Damien committed
864
865
866
                    i += 1;
                }

867
868
                mp_uint_t num_not_nil = 0;
                for (mp_uint_t x = 0; x < i; ++x) {
869
                    if (peek_result(&parser, x) != MP_PARSE_NODE_NULL) {
Damien's avatar
Damien committed
870
871
872
                        num_not_nil += 1;
                    }
                }
873
874
                if (emit_rule || num_not_nil != 1) {
                    // need to add rule when num_not_nil==0 for, eg, atom_paren, testlist_comp_3b
875
                    push_result_rule(&parser, rule_src_line, rule, i);
876
                } else {
Damien's avatar
Damien committed
877
                    // single result, leave it on stack
878
                    mp_parse_node_t pn = MP_PARSE_NODE_NULL;
879
                    for (mp_uint_t x = 0; x < i; ++x) {
880
                        mp_parse_node_t pn2 = pop_result(&parser);
881
                        if (pn2 != MP_PARSE_NODE_NULL) {
Damien's avatar
Damien committed
882
883
884
                            pn = pn2;
                        }
                    }
885
                    push_result_node(&parser, pn);
Damien's avatar
Damien committed
886
887
                }
                break;
888
            }
Damien's avatar
Damien committed
889

890
            case RULE_ACT_LIST: {
Damien's avatar
Damien committed
891
892
893
                // n=2 is: item item*
                // n=1 is: item (sep item)*
                // n=3 is: item (sep item)* [sep]
894
                bool had_trailing_sep;
Damien's avatar
Damien committed
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
                if (backtrack) {
                    list_backtrack:
                    had_trailing_sep = false;
                    if (n == 2) {
                        if (i == 1) {
                            // fail on item, first time round; propagate backtrack
                            goto next_rule;
                        } else {
                            // fail on item, in later rounds; finish with this rule
                            backtrack = false;
                        }
                    } else {
                        if (i == 1) {
                            // fail on item, first time round; propagate backtrack
                            goto next_rule;
                        } else if ((i & 1) == 1) {
                            // fail on item, in later rounds; have eaten tokens so can't backtrack
                            if (n == 3) {
                                // list allows trailing separator; finish parsing list
                                had_trailing_sep = true;
                                backtrack = false;
                            } else {
                                // list doesn't allowing trailing separator; fail
                                goto syntax_error;
                            }
                        } else {
                            // fail on separator; finish parsing list
                            backtrack = false;
                        }
                    }
                } else {
                    for (;;) {
927
                        mp_uint_t arg = rule->arg[i & 1 & n];
Damien's avatar
Damien committed
928
929
                        switch (arg & RULE_ARG_KIND_MASK) {
                            case RULE_ARG_TOK:
930
                                if (lex->tok_kind == (arg & RULE_ARG_ARG_MASK)) {
Damien's avatar
Damien committed
931
932
933
                                    if (i & 1 & n) {
                                        // separators which are tokens are not pushed to result stack
                                    } else {
934
                                        push_result_token(&parser);
Damien's avatar
Damien committed
935
                                    }
936
                                    mp_lexer_to_next(lex);
Damien's avatar
Damien committed
937
938
939
940
941
942
943
944
945
946
                                    // got element of list, so continue parsing list
                                    i += 1;
                                } else {
                                    // couldn't get element of list
                                    i += 1;
                                    backtrack = true;
                                    goto list_backtrack;
                                }
                                break;
                            case RULE_ARG_RULE:
947
                            rule_list_no_other_choice:
948
949
                                push_rule(&parser, rule_src_line, rule, i + 1); // save this list-rule
                                push_rule_from_arg(&parser, arg); // push child of list-rule
Damien's avatar
Damien committed
950
951
952
                                goto next_rule;
                            default:
                                assert(0);
953
                                goto rule_list_no_other_choice; // to help flow control analysis
Damien's avatar
Damien committed
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
                        }
                    }
                }
                assert(i >= 1);

                // compute number of elements in list, result in i
                i -= 1;
                if ((n & 1) && (rule->arg[1] & RULE_ARG_KIND_MASK) == RULE_ARG_TOK) {
                    // don't count separators when they are tokens
                    i = (i + 1) / 2;
                }

                if (i == 1) {
                    // list matched single item
                    if (had_trailing_sep) {
                        // if there was a trailing separator, make a list of a single item
970
                        push_result_rule(&parser, rule_src_line, rule, i);
Damien's avatar
Damien committed
971
972
973
974
                    } else {
                        // just leave single item on stack (ie don't wrap in a list)
                    }
                } else {
975
                    push_result_rule(&parser, rule_src_line, rule, i);
Damien's avatar
Damien committed
976
977
                }
                break;
978
            }
Damien's avatar
Damien committed
979
980
981
982
983

            default:
                assert(0);
        }
    }
984

985
986
987
988
    #if MICROPY_COMP_CONST
    mp_map_deinit(&parser.consts);
    #endif

989
990
991
992
993
994
995
996
997
998
    // truncate final chunk and link into chain of chunks
    if (parser.cur_chunk != NULL) {
        (void)m_renew(byte, parser.cur_chunk,
            sizeof(mp_parse_chunk_t) + parser.cur_chunk->alloc,
            sizeof(mp_parse_chunk_t) + parser.cur_chunk->union_.used);
        parser.cur_chunk->alloc = parser.cur_chunk->union_.used;
        parser.cur_chunk->union_.next = parser.tree.chunk;
        parser.tree.chunk = parser.cur_chunk;
    }

999
    mp_obj_t exc;
1000

For faster browsing, not all history is shown. View entire blame