kopia lustrzana https://github.com/micropython/micropython
306 wiersze
20 KiB
C
306 wiersze
20 KiB
C
// rules for writing rules:
|
|
// - zero_or_more is implemented using opt_rule around a one_or_more rule
|
|
// - don't put opt_rule in arguments of or rule; instead, wrap the call to this or rule in opt_rule
|
|
|
|
// # Start symbols for the grammar:
|
|
// # single_input is a single interactive statement;
|
|
// # file_input is a module or sequence of commands read from an input file;
|
|
// # eval_input is the input for the eval() functions.
|
|
// # NB: compound_stmt in single_input is followed by extra NEWLINE! --> not in Micro Python
|
|
// single_input: NEWLINE | simple_stmt | compound_stmt
|
|
// file_input: (NEWLINE | stmt)* ENDMARKER
|
|
// eval_input: testlist NEWLINE* ENDMARKER
|
|
|
|
DEF_RULE(single_input, nc, or(3), tok(NEWLINE), rule(simple_stmt), rule(compound_stmt))
|
|
DEF_RULE(file_input, nc, and(1), opt_rule(file_input_2))
|
|
DEF_RULE(file_input_2, c(generic_all_nodes), one_or_more, rule(file_input_3))
|
|
DEF_RULE(file_input_3, nc, or(2), tok(NEWLINE), rule(stmt))
|
|
DEF_RULE(eval_input, nc, and(2), rule(testlist), opt_rule(eval_input_2))
|
|
DEF_RULE(eval_input_2, nc, and(1), tok(NEWLINE))
|
|
|
|
// decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
|
|
// decorators: decorator+
|
|
// decorated: decorators (classdef | funcdef)
|
|
// funcdef: 'def' NAME parameters ['->' test] ':' suite
|
|
// parameters: '(' [typedargslist] ')'
|
|
// typedargslist: tfpdef ['=' test] (',' tfpdef ['=' test])* [',' ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]] | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef
|
|
// tfpdef: NAME [':' test]
|
|
// varargslist: vfpdef ['=' test] (',' vfpdef ['=' test])* [',' ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef
|
|
// vfpdef: NAME
|
|
|
|
DEF_RULE(decorator, nc, and(4), tok(DEL_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
|
|
//DEF_RULE(decorator_2, nc, and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
|
|
DEF_RULE(decorators, nc, one_or_more, rule(decorator))
|
|
DEF_RULE(decorated, c(decorated), and(2), rule(decorators), rule(decorated_body))
|
|
DEF_RULE(decorated_body, nc, or(2), rule(classdef), rule(funcdef))
|
|
DEF_RULE(funcdef, c(funcdef), and(8), tok(KW_DEF), tok(NAME), tok(DEL_PAREN_OPEN), opt_rule(typedargslist), tok(DEL_PAREN_CLOSE), opt_rule(funcdef_2), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(funcdef_2, nc, and(2), tok(DEL_MINUS_MORE), rule(test))
|
|
// TODO typedargslist lets through more than is allowed
|
|
DEF_RULE(typedargslist, nc, list_with_end, rule(typedargslist_item), tok(DEL_COMMA))
|
|
DEF_RULE(typedargslist_item, nc, or(3), rule(typedargslist_name), rule(typedargslist_star), rule(typedargslist_dbl_star))
|
|
DEF_RULE(typedargslist_name, nc, and(3), tok(NAME), opt_rule(typedargslist_colon), opt_rule(typedargslist_equal))
|
|
DEF_RULE(typedargslist_star, nc, and(2), tok(OP_STAR), opt_rule(tfpdef))
|
|
DEF_RULE(typedargslist_dbl_star, nc, and(3), tok(OP_DBL_STAR), tok(NAME), opt_rule(typedargslist_colon))
|
|
DEF_RULE(typedargslist_colon, nc, and(2), tok(DEL_COLON), rule(test))
|
|
DEF_RULE(typedargslist_equal, nc, and(2), tok(DEL_EQUAL), rule(test))
|
|
DEF_RULE(tfpdef, nc, and(2), tok(NAME), opt_rule(typedargslist_colon))
|
|
// TODO varargslist lets through more than is allowed
|
|
DEF_RULE(varargslist, nc, list_with_end, rule(varargslist_item), tok(DEL_COMMA))
|
|
DEF_RULE(varargslist_item, nc, or(3), rule(varargslist_name), rule(varargslist_star), rule(varargslist_dbl_star))
|
|
DEF_RULE(varargslist_name, nc, and(2), tok(NAME), opt_rule(varargslist_equal))
|
|
DEF_RULE(varargslist_star, nc, and(2), tok(OP_STAR), opt_rule(vfpdef))
|
|
DEF_RULE(varargslist_dbl_star, nc, and(2), tok(OP_DBL_STAR), tok(NAME))
|
|
DEF_RULE(varargslist_equal, nc, and(2), tok(DEL_EQUAL), rule(test))
|
|
DEF_RULE(vfpdef, nc, and(1), tok(NAME))
|
|
|
|
// stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | simple_stmt
|
|
|
|
DEF_RULE(stmt, nc, or(9), rule(if_stmt), rule(while_stmt), rule(for_stmt), rule(try_stmt), rule(with_stmt), rule(funcdef), rule(classdef), rule(decorated), rule(simple_stmt))
|
|
|
|
// simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
|
|
|
|
DEF_RULE(simple_stmt, nc, and(2), rule(simple_stmt_2), tok(NEWLINE))
|
|
DEF_RULE(simple_stmt_2, c(generic_all_nodes), list_with_end, rule(small_stmt), tok(DEL_SEMICOLON))
|
|
|
|
// small_stmt: expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt
|
|
// expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))*)
|
|
// testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
|
|
// augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
|
|
// # For normal assignments, additional restrictions enforced by the interpreter
|
|
|
|
DEF_RULE(small_stmt, nc, or(8), rule(del_stmt), rule(pass_stmt), rule(flow_stmt), rule(import_stmt), rule(global_stmt), rule(nonlocal_stmt), rule(assert_stmt), rule(expr_stmt))
|
|
DEF_RULE(expr_stmt, c(expr_stmt), and(2), rule(testlist_star_expr), opt_rule(expr_stmt_2))
|
|
DEF_RULE(expr_stmt_2, nc, or(2), rule(expr_stmt_augassign), rule(expr_stmt_assign_list))
|
|
DEF_RULE(expr_stmt_augassign, nc, and(2), rule(augassign), rule(expr_stmt_6))
|
|
DEF_RULE(expr_stmt_assign_list, nc, one_or_more, rule(expr_stmt_assign))
|
|
DEF_RULE(expr_stmt_assign, nc, and(2), tok(DEL_EQUAL), rule(expr_stmt_6))
|
|
DEF_RULE(expr_stmt_6, nc, or(2), rule(yield_expr), rule(testlist_star_expr))
|
|
DEF_RULE(testlist_star_expr, c(generic_tuple), list_with_end, rule(testlist_star_expr_2), tok(DEL_COMMA))
|
|
DEF_RULE(testlist_star_expr_2, nc, or(2), rule(star_expr), rule(test))
|
|
DEF_RULE(augassign, nc, or(12), tok(DEL_PLUS_EQUAL), tok(DEL_MINUS_EQUAL), tok(DEL_STAR_EQUAL), tok(DEL_SLASH_EQUAL), tok(DEL_PERCENT_EQUAL), tok(DEL_AMPERSAND_EQUAL), tok(DEL_PIPE_EQUAL), tok(DEL_CARET_EQUAL), tok(DEL_DBL_LESS_EQUAL), tok(DEL_DBL_MORE_EQUAL), tok(DEL_DBL_STAR_EQUAL), tok(DEL_DBL_SLASH_EQUAL))
|
|
|
|
// del_stmt: 'del' exprlist
|
|
// pass_stmt: 'pass'
|
|
// flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt
|
|
// break_stmt: 'break'
|
|
// continue_stmt: 'continue'
|
|
// return_stmt: 'return' [testlist]
|
|
// yield_stmt: yield_expr
|
|
// raise_stmt: 'raise' [test ['from' test]]
|
|
|
|
DEF_RULE(del_stmt, c(del_stmt), and(2), tok(KW_DEL), rule(exprlist))
|
|
DEF_RULE(pass_stmt, c(generic_all_nodes), and(1), tok(KW_PASS))
|
|
DEF_RULE(flow_stmt, nc, or(5), rule(break_stmt), rule(continue_stmt), rule(return_stmt), rule(raise_stmt), rule(yield_stmt))
|
|
DEF_RULE(break_stmt, c(break_stmt), and(1), tok(KW_BREAK))
|
|
DEF_RULE(continue_stmt, c(continue_stmt), and(1), tok(KW_CONTINUE))
|
|
DEF_RULE(return_stmt, c(return_stmt), and(2), tok(KW_RETURN), opt_rule(testlist))
|
|
DEF_RULE(yield_stmt, c(yield_stmt), and(1), rule(yield_expr))
|
|
DEF_RULE(raise_stmt, c(raise_stmt), and(2), tok(KW_RAISE), opt_rule(raise_stmt_arg))
|
|
DEF_RULE(raise_stmt_arg, nc, and(2), rule(test), opt_rule(raise_stmt_from))
|
|
DEF_RULE(raise_stmt_from, nc, and(2), tok(KW_FROM), rule(test))
|
|
|
|
// import_stmt: import_name | import_from
|
|
// import_name: 'import' dotted_as_names
|
|
// import_from: 'from' (('.' | '...')* dotted_name | ('.' | '...')+) 'import' ('*' | '(' import_as_names ')' | import_as_names)
|
|
// import_as_name: NAME ['as' NAME]
|
|
// dotted_as_name: dotted_name ['as' NAME]
|
|
// import_as_names: import_as_name (',' import_as_name)* [',']
|
|
// dotted_as_names: dotted_as_name (',' dotted_as_name)*
|
|
// dotted_name: NAME ('.' NAME)*
|
|
// global_stmt: 'global' NAME (',' NAME)*
|
|
// nonlocal_stmt: 'nonlocal' NAME (',' NAME)*
|
|
// assert_stmt: 'assert' test [',' test]
|
|
|
|
DEF_RULE(import_stmt, nc, or(2), rule(import_name), rule(import_from))
|
|
DEF_RULE(import_name, c(import_name), and(2), tok(KW_IMPORT), rule(dotted_as_names))
|
|
DEF_RULE(import_from, c(import_from), and(4), tok(KW_FROM), rule(import_from_2), tok(KW_IMPORT), rule(import_from_3))
|
|
DEF_RULE(import_from_2, nc, or(2), rule(dotted_name), rule(import_from_2b))
|
|
DEF_RULE(import_from_2b, nc, and(2), rule(one_or_more_period_or_ellipsis), opt_rule(dotted_name))
|
|
DEF_RULE(import_from_3, nc, or(3), tok(OP_STAR), rule(import_as_names_paren), rule(import_as_names))
|
|
DEF_RULE(import_as_names_paren, nc, and(3), tok(DEL_PAREN_OPEN), rule(import_as_names), tok(DEL_PAREN_CLOSE))
|
|
DEF_RULE(one_or_more_period_or_ellipsis, nc, one_or_more, rule(period_or_ellipsis))
|
|
DEF_RULE(period_or_ellipsis, nc, or(2), tok(DEL_PERIOD), tok(ELLIPSIS))
|
|
DEF_RULE(import_as_name, nc, and(2), tok(NAME), opt_rule(as_name))
|
|
DEF_RULE(dotted_as_name, nc, and(2), rule(dotted_name), opt_rule(as_name))
|
|
DEF_RULE(as_name, nc, and(2), tok(KW_AS), tok(NAME))
|
|
DEF_RULE(import_as_names, nc, list_with_end, rule(import_as_name), tok(DEL_COMMA))
|
|
DEF_RULE(dotted_as_names, nc, list, rule(dotted_as_name), tok(DEL_COMMA))
|
|
DEF_RULE(dotted_name, nc, list, tok(NAME), tok(DEL_PERIOD))
|
|
DEF_RULE(global_stmt, c(global_stmt), and(2), tok(KW_GLOBAL), rule(name_list))
|
|
DEF_RULE(nonlocal_stmt, c(nonlocal_stmt), and(2), tok(KW_NONLOCAL), rule(name_list))
|
|
DEF_RULE(name_list, nc, list, tok(NAME), tok(DEL_COMMA))
|
|
DEF_RULE(assert_stmt, c(assert_stmt), and(3), tok(KW_ASSERT), rule(test), opt_rule(assert_stmt_extra))
|
|
DEF_RULE(assert_stmt_extra, nc, and(2), tok(DEL_COMMA), rule(test))
|
|
|
|
// compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated
|
|
// if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
|
|
// while_stmt: 'while' test ':' suite ['else' ':' suite]
|
|
// for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
|
|
// try_stmt: 'try' ':' suite ((except_clause ':' suite)+ ['else' ':' suite] ['finally' ':' suite] | 'finally' ':' suite)
|
|
// # NB compile.c makes sure that the default except clause is last
|
|
// except_clause: 'except' [test ['as' NAME]]
|
|
// with_stmt: 'with' with_item (',' with_item)* ':' suite
|
|
// with_item: test ['as' expr]
|
|
// suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
|
|
|
|
DEF_RULE(compound_stmt, nc, or(8), rule(if_stmt), rule(while_stmt), rule(for_stmt), rule(try_stmt), rule(with_stmt), rule(funcdef), rule(classdef), rule(decorated))
|
|
DEF_RULE(if_stmt, c(if_stmt), and(6), tok(KW_IF), rule(test), tok(DEL_COLON), rule(suite), opt_rule(if_stmt_elif_list), opt_rule(else_stmt))
|
|
DEF_RULE(if_stmt_elif_list, nc, one_or_more, rule(if_stmt_elif))
|
|
DEF_RULE(if_stmt_elif, nc, and(4), tok(KW_ELIF), rule(test), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(while_stmt, c(while_stmt), and(5), tok(KW_WHILE), rule(test), tok(DEL_COLON), rule(suite), opt_rule(else_stmt))
|
|
DEF_RULE(for_stmt, c(for_stmt), and(7), tok(KW_FOR), rule(exprlist), tok(KW_IN), rule(testlist), tok(DEL_COLON), rule(suite), opt_rule(else_stmt))
|
|
DEF_RULE(try_stmt, c(try_stmt), and(4), tok(KW_TRY), tok(DEL_COLON), rule(suite), rule(try_stmt_2))
|
|
DEF_RULE(try_stmt_2, nc, or(2), rule(try_stmt_except_and_more), rule(try_stmt_finally))
|
|
DEF_RULE(try_stmt_except_and_more, nc, and(3), rule(try_stmt_except_list), opt_rule(else_stmt), opt_rule(try_stmt_finally))
|
|
DEF_RULE(try_stmt_except, nc, and(4), tok(KW_EXCEPT), opt_rule(try_stmt_as_name), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(try_stmt_as_name, nc, and(2), rule(test), opt_rule(as_name))
|
|
DEF_RULE(try_stmt_except_list, nc, one_or_more, rule(try_stmt_except))
|
|
DEF_RULE(try_stmt_finally, nc, and(3), tok(KW_FINALLY), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(else_stmt, nc, and(3), tok(KW_ELSE), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(with_stmt, c(with_stmt), and(4), tok(KW_WITH), rule(with_stmt_list), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(with_stmt_list, nc, list, rule(with_item), tok(DEL_COMMA))
|
|
DEF_RULE(with_item, nc, and(2), rule(test), opt_rule(with_item_as))
|
|
DEF_RULE(with_item_as, nc, and(2), tok(KW_AS), rule(expr))
|
|
DEF_RULE(suite, nc, or(2), rule(suite_block), rule(simple_stmt))
|
|
DEF_RULE(suite_block, nc, and(4), tok(NEWLINE), tok(INDENT), rule(suite_block_stmts), tok(DEDENT))
|
|
DEF_RULE(suite_block_stmts, c(generic_all_nodes), one_or_more, rule(stmt))
|
|
|
|
// test: or_test ['if' or_test 'else' test] | lambdef
|
|
// test_nocond: or_test | lambdef_nocond
|
|
// lambdef: 'lambda' [varargslist] ':' test
|
|
// lambdef_nocond: 'lambda' [varargslist] ':' test_nocond
|
|
|
|
DEF_RULE(test, nc, or(2), rule(lambdef), rule(test_if_expr))
|
|
DEF_RULE(test_if_expr, c(test_if_expr), and(2), rule(or_test), opt_rule(test_if_else))
|
|
DEF_RULE(test_if_else, nc, and(4), tok(KW_IF), rule(or_test), tok(KW_ELSE), rule(test))
|
|
DEF_RULE(test_nocond, nc, or(2), rule(lambdef_nocond), rule(or_test))
|
|
DEF_RULE(lambdef, c(lambdef), and(4), tok(KW_LAMBDA), opt_rule(varargslist), tok(DEL_COLON), rule(test))
|
|
DEF_RULE(lambdef_nocond, c(lambdef), and(4), tok(KW_LAMBDA), opt_rule(varargslist), tok(DEL_COLON), rule(test_nocond))
|
|
|
|
// or_test: and_test ('or' and_test)*
|
|
// and_test: not_test ('and' not_test)*
|
|
// not_test: 'not' not_test | comparison
|
|
// comparison: expr (comp_op expr)*
|
|
// comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'in'|'not' 'in'|'is'|'is' 'not'
|
|
// star_expr: '*' expr
|
|
// expr: xor_expr ('|' xor_expr)*
|
|
// xor_expr: and_expr ('^' and_expr)*
|
|
// and_expr: shift_expr ('&' shift_expr)*
|
|
// shift_expr: arith_expr (('<<'|'>>') arith_expr)*
|
|
// arith_expr: term (('+'|'-') term)*
|
|
// term: factor (('*'|'/'|'%'|'//') factor)*
|
|
// factor: ('+'|'-'|'~') factor | power
|
|
// power: atom trailer* ['**' factor]
|
|
|
|
DEF_RULE(or_test, c(or_test), list, rule(and_test), tok(KW_OR))
|
|
DEF_RULE(and_test, c(and_test), list, rule(not_test), tok(KW_AND))
|
|
DEF_RULE(not_test, nc, or(2), rule(not_test_2), rule(comparison))
|
|
DEF_RULE(not_test_2, c(not_test_2), and(2), tok(KW_NOT), rule(not_test))
|
|
DEF_RULE(comparison, c(comparison), list, rule(expr), rule(comp_op))
|
|
DEF_RULE(comp_op, nc, or(9), tok(OP_LESS), tok(OP_MORE), tok(OP_DBL_EQUAL), tok(OP_LESS_EQUAL), tok(OP_MORE_EQUAL), tok(OP_NOT_EQUAL), tok(KW_IN), rule(comp_op_not_in), rule(comp_op_is))
|
|
DEF_RULE(comp_op_not_in, nc, and(2), tok(KW_NOT), tok(KW_IN))
|
|
DEF_RULE(comp_op_is, nc, and(2), tok(KW_IS), opt_rule(comp_op_is_not))
|
|
DEF_RULE(comp_op_is_not, nc, and(1), tok(KW_NOT))
|
|
DEF_RULE(star_expr, c(star_expr), and(2), tok(OP_STAR), rule(expr))
|
|
DEF_RULE(expr, c(expr), list, rule(xor_expr), tok(OP_PIPE))
|
|
DEF_RULE(xor_expr, c(xor_expr), list, rule(and_expr), tok(OP_CARET))
|
|
DEF_RULE(and_expr, c(and_expr), list, rule(shift_expr), tok(OP_AMPERSAND))
|
|
DEF_RULE(shift_expr, c(shift_expr), list, rule(arith_expr), rule(shift_op))
|
|
DEF_RULE(shift_op, nc, or(2), tok(OP_DBL_LESS), tok(OP_DBL_MORE))
|
|
DEF_RULE(arith_expr, c(arith_expr), list, rule(term), rule(arith_op))
|
|
DEF_RULE(arith_op, nc, or(2), tok(OP_PLUS), tok(OP_MINUS))
|
|
DEF_RULE(term, c(term), list, rule(factor), rule(term_op))
|
|
DEF_RULE(term_op, nc, or(4), tok(OP_STAR), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
|
|
DEF_RULE(factor, nc, or(2), rule(factor_2), rule(power))
|
|
DEF_RULE(factor_2, c(factor_2), and(2), rule(factor_op), rule(factor))
|
|
DEF_RULE(factor_op, nc, or(3), tok(OP_PLUS), tok(OP_MINUS), tok(OP_TILDE))
|
|
DEF_RULE(power, c(power), and(3), rule(atom), opt_rule(power_trailers), opt_rule(power_dbl_star))
|
|
DEF_RULE(power_trailers, c(power_trailers), one_or_more, rule(trailer))
|
|
DEF_RULE(power_dbl_star, c(power_dbl_star), and(2), tok(OP_DBL_STAR), rule(factor))
|
|
|
|
// atom: '(' [yield_expr|testlist_comp] ')' | '[' [testlist_comp] ']' | '{' [dictorsetmaker] '}' | NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False'
|
|
// testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] )
|
|
// trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
|
|
|
|
DEF_RULE(atom, nc, or(10), tok(NAME), tok(NUMBER), rule(atom_string), tok(ELLIPSIS), tok(KW_NONE), tok(KW_TRUE), tok(KW_FALSE), rule(atom_paren), rule(atom_bracket), rule(atom_brace))
|
|
DEF_RULE(atom_string, c(atom_string), one_or_more, rule(string_or_bytes))
|
|
DEF_RULE(string_or_bytes, nc, or(2), tok(STRING), tok(BYTES))
|
|
DEF_RULE(atom_paren, c(atom_paren), and(3), tok(DEL_PAREN_OPEN), opt_rule(atom_2b), tok(DEL_PAREN_CLOSE))
|
|
DEF_RULE(atom_2b, nc, or(2), rule(yield_expr), rule(testlist_comp))
|
|
DEF_RULE(atom_bracket, c(atom_bracket), and(3), tok(DEL_BRACKET_OPEN), opt_rule(testlist_comp), tok(DEL_BRACKET_CLOSE))
|
|
DEF_RULE(atom_brace, c(atom_brace), and(3), tok(DEL_BRACE_OPEN), opt_rule(dictorsetmaker), tok(DEL_BRACE_CLOSE))
|
|
DEF_RULE(testlist_comp, nc, and(2), rule(testlist_comp_2), opt_rule(testlist_comp_3))
|
|
DEF_RULE(testlist_comp_2, nc, or(2), rule(star_expr), rule(test))
|
|
DEF_RULE(testlist_comp_3, nc, or(2), rule(comp_for), rule(testlist_comp_3b))
|
|
DEF_RULE(testlist_comp_3b, nc, and(2), tok(DEL_COMMA), opt_rule(testlist_comp_3c))
|
|
DEF_RULE(testlist_comp_3c, nc, list_with_end, rule(testlist_comp_2), tok(DEL_COMMA))
|
|
DEF_RULE(trailer, nc, or(3), rule(trailer_paren), rule(trailer_bracket), rule(trailer_period))
|
|
DEF_RULE(trailer_paren, c(trailer_paren), and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
|
|
DEF_RULE(trailer_bracket, c(trailer_bracket), and(3), tok(DEL_BRACKET_OPEN), rule(subscriptlist), tok(DEL_BRACKET_CLOSE))
|
|
DEF_RULE(trailer_period, c(trailer_period), and(2), tok(DEL_PERIOD), tok(NAME))
|
|
|
|
// subscriptlist: subscript (',' subscript)* [',']
|
|
// subscript: test | [test] ':' [test] [sliceop]
|
|
// sliceop: ':' [test]
|
|
|
|
DEF_RULE(subscriptlist, c(generic_tuple), list_with_end, rule(subscript), tok(DEL_COMMA))
|
|
DEF_RULE(subscript, nc, or(2), rule(subscript_3), rule(subscript_2))
|
|
DEF_RULE(subscript_2, c(subscript_2), and(2), rule(test), opt_rule(subscript_3))
|
|
DEF_RULE(subscript_3, c(subscript_3), and(2), tok(DEL_COLON), opt_rule(subscript_3b))
|
|
DEF_RULE(subscript_3b, nc, or(2), rule(subscript_3c), rule(subscript_3d))
|
|
DEF_RULE(subscript_3c, nc, and(2), tok(DEL_COLON), opt_rule(test))
|
|
DEF_RULE(subscript_3d, nc, and(2), rule(test), opt_rule(sliceop))
|
|
DEF_RULE(sliceop, nc, and(2), tok(DEL_COLON), opt_rule(test))
|
|
|
|
// exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']
|
|
// testlist: test (',' test)* [',']
|
|
// dictorsetmaker: (test ':' test (comp_for | (',' test ':' test)* [','])) | (test (comp_for | (',' test)* [',']))
|
|
|
|
DEF_RULE(exprlist, nc, list_with_end, rule(exprlist_2), tok(DEL_COMMA))
|
|
DEF_RULE(exprlist_2, nc, or(2), rule(star_expr), rule(expr))
|
|
DEF_RULE(testlist, c(generic_tuple), list_with_end, rule(test), tok(DEL_COMMA))
|
|
// TODO dictorsetmaker lets through more than is allowed
|
|
DEF_RULE(dictorsetmaker, nc, and(2), rule(dictorsetmaker_item), opt_rule(dictorsetmaker_tail))
|
|
DEF_RULE(dictorsetmaker_item, c(dictorsetmaker_item), and(2), rule(test), opt_rule(dictorsetmaker_colon))
|
|
DEF_RULE(dictorsetmaker_colon, nc, and(2), tok(DEL_COLON), rule(test))
|
|
DEF_RULE(dictorsetmaker_tail, nc, or(2), rule(comp_for), rule(dictorsetmaker_list))
|
|
DEF_RULE(dictorsetmaker_list, nc, and(2), tok(DEL_COMMA), opt_rule(dictorsetmaker_list2))
|
|
DEF_RULE(dictorsetmaker_list2, nc, list_with_end, rule(dictorsetmaker_item), tok(DEL_COMMA))
|
|
|
|
// classdef: 'class' NAME ['(' [arglist] ')'] ':' suite
|
|
|
|
DEF_RULE(classdef, c(classdef), and(5), tok(KW_CLASS), tok(NAME), opt_rule(classdef_2), tok(DEL_COLON), rule(suite))
|
|
DEF_RULE(classdef_2, nc, and(3), tok(DEL_PAREN_OPEN), opt_rule(arglist), tok(DEL_PAREN_CLOSE))
|
|
|
|
// arglist: (argument ',')* (argument [','] | '*' test (',' argument)* [',' '**' test] | '**' test)
|
|
|
|
// TODO arglist lets through more than is allowed, compiler needs to do further verification
|
|
DEF_RULE(arglist, c(generic_all_nodes), list_with_end, rule(arglist_2), tok(DEL_COMMA))
|
|
DEF_RULE(arglist_2, nc, or(3), rule(arglist_star), rule(arglist_dbl_star), rule(argument))
|
|
DEF_RULE(arglist_star, c(arglist_star), and(2), tok(OP_STAR), rule(test))
|
|
DEF_RULE(arglist_dbl_star, c(arglist_dbl_star), and(2), tok(OP_DBL_STAR), rule(test))
|
|
|
|
// # The reason that keywords are test nodes instead of NAME is that using NAME
|
|
// # results in an ambiguity. ast.c makes sure it's a NAME.
|
|
// argument: test [comp_for] | test '=' test # Really [keyword '='] test
|
|
// comp_iter: comp_for | comp_if
|
|
// comp_for: 'for' exprlist 'in' or_test [comp_iter]
|
|
// comp_if: 'if' test_nocond [comp_iter]
|
|
|
|
DEF_RULE(argument, c(argument), and(2), rule(test), opt_rule(argument_2))
|
|
DEF_RULE(argument_2, nc, or(2), rule(comp_for), rule(argument_3))
|
|
DEF_RULE(argument_3, nc, and(2), tok(DEL_EQUAL), rule(test))
|
|
DEF_RULE(comp_iter, nc, or(2), rule(comp_for), rule(comp_if))
|
|
DEF_RULE(comp_for, nc, and(5), tok(KW_FOR), rule(exprlist), tok(KW_IN), rule(or_test), opt_rule(comp_iter))
|
|
DEF_RULE(comp_if, nc, and(3), tok(KW_IF), rule(test_nocond), opt_rule(comp_iter))
|
|
|
|
// # not used in grammar, but may appear in "node" passed from Parser to Compiler
|
|
// encoding_decl: NAME
|
|
|
|
// yield_expr: 'yield' [yield_arg]
|
|
// yield_arg: 'from' test | testlist
|
|
|
|
DEF_RULE(yield_expr, c(yield_expr), and(2), tok(KW_YIELD), opt_rule(yield_arg))
|
|
DEF_RULE(yield_arg, nc, or(2), rule(yield_arg_from), rule(testlist))
|
|
DEF_RULE(yield_arg_from, nc, and(2), tok(KW_FROM), rule(test))
|