py: Add support for matmul operator @ as per PEP 465.
To make progress towards MicroPython supporting Python 3.5, adding the matmul operator is important because it's a really "low level" part of the language, being a new token and modifications to the grammar. It doesn't make sense to make it configurable because 1) it would make the grammar and lexer complicated/messy; 2) no other operators are configurable; 3) it's not a feature that can be "dynamically plugged in" via an import. And matmul can be useful as a general purpose user-defined operator, it doesn't have to be just for numpy use. Based on work done by Jim Mussared.pull/1/head
parent
14e203282a
commit
2069c563f9
10
py/grammar.h
10
py/grammar.h
|
@ -55,7 +55,7 @@ DEF_RULE_NC(eval_input_2, and(1), tok(NEWLINE))
|
||||||
// varargslist: vfpdef ['=' test] (',' vfpdef ['=' test])* [',' ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef
|
// varargslist: vfpdef ['=' test] (',' vfpdef ['=' test])* [',' ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef
|
||||||
// vfpdef: NAME
|
// vfpdef: NAME
|
||||||
|
|
||||||
DEF_RULE_NC(decorator, and(4), tok(DEL_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
|
DEF_RULE_NC(decorator, and(4), tok(OP_AT), rule(dotted_name), opt_rule(trailer_paren), tok(NEWLINE))
|
||||||
DEF_RULE_NC(decorators, one_or_more, rule(decorator))
|
DEF_RULE_NC(decorators, one_or_more, rule(decorator))
|
||||||
DEF_RULE(decorated, c(decorated), and_ident(2), rule(decorators), rule(decorated_body))
|
DEF_RULE(decorated, c(decorated), and_ident(2), rule(decorators), rule(decorated_body))
|
||||||
#if MICROPY_PY_ASYNC_AWAIT
|
#if MICROPY_PY_ASYNC_AWAIT
|
||||||
|
@ -96,7 +96,7 @@ DEF_RULE(simple_stmt_2, c(generic_all_nodes), list_with_end, rule(small_stmt), t
|
||||||
// small_stmt: expr_stmt | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | nonlocal_stmt | assert_stmt
|
// 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))*)
|
// expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))*)
|
||||||
// testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
|
// testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
|
||||||
// augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
|
// augassign: '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
|
||||||
// # For normal assignments, additional restrictions enforced by the interpreter
|
// # For normal assignments, additional restrictions enforced by the interpreter
|
||||||
|
|
||||||
DEF_RULE_NC(small_stmt, 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_NC(small_stmt, 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))
|
||||||
|
@ -108,7 +108,7 @@ DEF_RULE_NC(expr_stmt_assign, and_ident(2), tok(DEL_EQUAL), rule(expr_stmt_6))
|
||||||
DEF_RULE_NC(expr_stmt_6, or(2), rule(yield_expr), rule(testlist_star_expr))
|
DEF_RULE_NC(expr_stmt_6, 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, c(generic_tuple), list_with_end, rule(testlist_star_expr_2), tok(DEL_COMMA))
|
||||||
DEF_RULE_NC(testlist_star_expr_2, or(2), rule(star_expr), rule(test))
|
DEF_RULE_NC(testlist_star_expr_2, or(2), rule(star_expr), rule(test))
|
||||||
DEF_RULE_NC(augassign, 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))
|
DEF_RULE_NC(augassign, or(13), tok(DEL_PLUS_EQUAL), tok(DEL_MINUS_EQUAL), tok(DEL_STAR_EQUAL), tok(DEL_AT_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
|
// del_stmt: 'del' exprlist
|
||||||
// pass_stmt: 'pass'
|
// pass_stmt: 'pass'
|
||||||
|
@ -226,7 +226,7 @@ DEF_RULE(lambdef_nocond, c(lambdef), and_blank(4), tok(KW_LAMBDA), opt_rule(vara
|
||||||
// and_expr: shift_expr ('&' shift_expr)*
|
// and_expr: shift_expr ('&' shift_expr)*
|
||||||
// shift_expr: arith_expr (('<<'|'>>') arith_expr)*
|
// shift_expr: arith_expr (('<<'|'>>') arith_expr)*
|
||||||
// arith_expr: term (('+'|'-') term)*
|
// arith_expr: term (('+'|'-') term)*
|
||||||
// term: factor (('*'|'/'|'%'|'//') factor)*
|
// term: factor (('*'|'@'|'/'|'%'|'//') factor)*
|
||||||
// factor: ('+'|'-'|'~') factor | power
|
// factor: ('+'|'-'|'~') factor | power
|
||||||
// power: atom_expr ['**' factor]
|
// power: atom_expr ['**' factor]
|
||||||
// atom_expr: 'await' atom trailer* | atom trailer*
|
// atom_expr: 'await' atom trailer* | atom trailer*
|
||||||
|
@ -249,7 +249,7 @@ DEF_RULE_NC(shift_op, or(2), tok(OP_DBL_LESS), tok(OP_DBL_MORE))
|
||||||
DEF_RULE(arith_expr, c(term), list, rule(term), rule(arith_op))
|
DEF_RULE(arith_expr, c(term), list, rule(term), rule(arith_op))
|
||||||
DEF_RULE_NC(arith_op, or(2), tok(OP_PLUS), tok(OP_MINUS))
|
DEF_RULE_NC(arith_op, or(2), tok(OP_PLUS), tok(OP_MINUS))
|
||||||
DEF_RULE(term, c(term), list, rule(factor), rule(term_op))
|
DEF_RULE(term, c(term), list, rule(factor), rule(term_op))
|
||||||
DEF_RULE_NC(term_op, or(4), tok(OP_STAR), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
|
DEF_RULE_NC(term_op, or(5), tok(OP_STAR), tok(OP_AT), tok(OP_SLASH), tok(OP_PERCENT), tok(OP_DBL_SLASH))
|
||||||
DEF_RULE_NC(factor, or(2), rule(factor_2), rule(power))
|
DEF_RULE_NC(factor, or(2), rule(factor_2), rule(power))
|
||||||
DEF_RULE(factor_2, c(factor_2), and_ident(2), rule(factor_op), rule(factor))
|
DEF_RULE(factor_2, c(factor_2), and_ident(2), rule(factor_op), rule(factor))
|
||||||
DEF_RULE_NC(factor_op, or(3), tok(OP_PLUS), tok(OP_MINUS), tok(OP_TILDE))
|
DEF_RULE_NC(factor_op, or(3), tok(OP_PLUS), tok(OP_MINUS), tok(OP_TILDE))
|
||||||
|
|
|
@ -174,7 +174,7 @@ STATIC void indent_pop(mp_lexer_t *lex) {
|
||||||
// this means if the start of two ops are the same then they are equal til the last char
|
// this means if the start of two ops are the same then they are equal til the last char
|
||||||
|
|
||||||
STATIC const char *const tok_enc =
|
STATIC const char *const tok_enc =
|
||||||
"()[]{},:;@~" // singles
|
"()[]{},:;~" // singles
|
||||||
"<e=c<e=" // < <= << <<=
|
"<e=c<e=" // < <= << <<=
|
||||||
">e=c>e=" // > >= >> >>=
|
">e=c>e=" // > >= >> >>=
|
||||||
"*e=c*e=" // * *= ** **=
|
"*e=c*e=" // * *= ** **=
|
||||||
|
@ -185,6 +185,7 @@ STATIC const char *const tok_enc =
|
||||||
"/e=c/e=" // / /= // //=
|
"/e=c/e=" // / /= // //=
|
||||||
"%e=" // % %=
|
"%e=" // % %=
|
||||||
"^e=" // ^ ^=
|
"^e=" // ^ ^=
|
||||||
|
"@e=" // @ @=
|
||||||
"=e=" // = ==
|
"=e=" // = ==
|
||||||
"!."; // start of special cases: != . ...
|
"!."; // start of special cases: != . ...
|
||||||
|
|
||||||
|
@ -193,7 +194,7 @@ STATIC const uint8_t tok_enc_kind[] = {
|
||||||
MP_TOKEN_DEL_PAREN_OPEN, MP_TOKEN_DEL_PAREN_CLOSE,
|
MP_TOKEN_DEL_PAREN_OPEN, MP_TOKEN_DEL_PAREN_CLOSE,
|
||||||
MP_TOKEN_DEL_BRACKET_OPEN, MP_TOKEN_DEL_BRACKET_CLOSE,
|
MP_TOKEN_DEL_BRACKET_OPEN, MP_TOKEN_DEL_BRACKET_CLOSE,
|
||||||
MP_TOKEN_DEL_BRACE_OPEN, MP_TOKEN_DEL_BRACE_CLOSE,
|
MP_TOKEN_DEL_BRACE_OPEN, MP_TOKEN_DEL_BRACE_CLOSE,
|
||||||
MP_TOKEN_DEL_COMMA, MP_TOKEN_DEL_COLON, MP_TOKEN_DEL_SEMICOLON, MP_TOKEN_DEL_AT, MP_TOKEN_OP_TILDE,
|
MP_TOKEN_DEL_COMMA, MP_TOKEN_DEL_COLON, MP_TOKEN_DEL_SEMICOLON, MP_TOKEN_OP_TILDE,
|
||||||
|
|
||||||
MP_TOKEN_OP_LESS, MP_TOKEN_OP_LESS_EQUAL, MP_TOKEN_OP_DBL_LESS, MP_TOKEN_DEL_DBL_LESS_EQUAL,
|
MP_TOKEN_OP_LESS, MP_TOKEN_OP_LESS_EQUAL, MP_TOKEN_OP_DBL_LESS, MP_TOKEN_DEL_DBL_LESS_EQUAL,
|
||||||
MP_TOKEN_OP_MORE, MP_TOKEN_OP_MORE_EQUAL, MP_TOKEN_OP_DBL_MORE, MP_TOKEN_DEL_DBL_MORE_EQUAL,
|
MP_TOKEN_OP_MORE, MP_TOKEN_OP_MORE_EQUAL, MP_TOKEN_OP_DBL_MORE, MP_TOKEN_DEL_DBL_MORE_EQUAL,
|
||||||
|
@ -205,6 +206,7 @@ STATIC const uint8_t tok_enc_kind[] = {
|
||||||
MP_TOKEN_OP_SLASH, MP_TOKEN_DEL_SLASH_EQUAL, MP_TOKEN_OP_DBL_SLASH, MP_TOKEN_DEL_DBL_SLASH_EQUAL,
|
MP_TOKEN_OP_SLASH, MP_TOKEN_DEL_SLASH_EQUAL, MP_TOKEN_OP_DBL_SLASH, MP_TOKEN_DEL_DBL_SLASH_EQUAL,
|
||||||
MP_TOKEN_OP_PERCENT, MP_TOKEN_DEL_PERCENT_EQUAL,
|
MP_TOKEN_OP_PERCENT, MP_TOKEN_DEL_PERCENT_EQUAL,
|
||||||
MP_TOKEN_OP_CARET, MP_TOKEN_DEL_CARET_EQUAL,
|
MP_TOKEN_OP_CARET, MP_TOKEN_DEL_CARET_EQUAL,
|
||||||
|
MP_TOKEN_OP_AT, MP_TOKEN_DEL_AT_EQUAL,
|
||||||
MP_TOKEN_DEL_EQUAL, MP_TOKEN_OP_DBL_EQUAL,
|
MP_TOKEN_DEL_EQUAL, MP_TOKEN_OP_DBL_EQUAL,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -106,7 +106,7 @@ typedef enum _mp_token_kind_t {
|
||||||
MP_TOKEN_OP_MORE_EQUAL,
|
MP_TOKEN_OP_MORE_EQUAL,
|
||||||
MP_TOKEN_OP_NOT_EQUAL,
|
MP_TOKEN_OP_NOT_EQUAL,
|
||||||
|
|
||||||
// Order of these 12 matches corresponding mp_binary_op_t operator
|
// Order of these 13 matches corresponding mp_binary_op_t operator
|
||||||
MP_TOKEN_OP_PIPE,
|
MP_TOKEN_OP_PIPE,
|
||||||
MP_TOKEN_OP_CARET,
|
MP_TOKEN_OP_CARET,
|
||||||
MP_TOKEN_OP_AMPERSAND,
|
MP_TOKEN_OP_AMPERSAND,
|
||||||
|
@ -115,12 +115,13 @@ typedef enum _mp_token_kind_t {
|
||||||
MP_TOKEN_OP_PLUS,
|
MP_TOKEN_OP_PLUS,
|
||||||
MP_TOKEN_OP_MINUS,
|
MP_TOKEN_OP_MINUS,
|
||||||
MP_TOKEN_OP_STAR,
|
MP_TOKEN_OP_STAR,
|
||||||
|
MP_TOKEN_OP_AT,
|
||||||
MP_TOKEN_OP_DBL_SLASH,
|
MP_TOKEN_OP_DBL_SLASH,
|
||||||
MP_TOKEN_OP_SLASH,
|
MP_TOKEN_OP_SLASH,
|
||||||
MP_TOKEN_OP_PERCENT,
|
MP_TOKEN_OP_PERCENT,
|
||||||
MP_TOKEN_OP_DBL_STAR,
|
MP_TOKEN_OP_DBL_STAR,
|
||||||
|
|
||||||
// Order of these 12 matches corresponding mp_binary_op_t operator
|
// Order of these 13 matches corresponding mp_binary_op_t operator
|
||||||
MP_TOKEN_DEL_PIPE_EQUAL,
|
MP_TOKEN_DEL_PIPE_EQUAL,
|
||||||
MP_TOKEN_DEL_CARET_EQUAL,
|
MP_TOKEN_DEL_CARET_EQUAL,
|
||||||
MP_TOKEN_DEL_AMPERSAND_EQUAL,
|
MP_TOKEN_DEL_AMPERSAND_EQUAL,
|
||||||
|
@ -129,6 +130,7 @@ typedef enum _mp_token_kind_t {
|
||||||
MP_TOKEN_DEL_PLUS_EQUAL,
|
MP_TOKEN_DEL_PLUS_EQUAL,
|
||||||
MP_TOKEN_DEL_MINUS_EQUAL,
|
MP_TOKEN_DEL_MINUS_EQUAL,
|
||||||
MP_TOKEN_DEL_STAR_EQUAL,
|
MP_TOKEN_DEL_STAR_EQUAL,
|
||||||
|
MP_TOKEN_DEL_AT_EQUAL,
|
||||||
MP_TOKEN_DEL_DBL_SLASH_EQUAL,
|
MP_TOKEN_DEL_DBL_SLASH_EQUAL,
|
||||||
MP_TOKEN_DEL_SLASH_EQUAL,
|
MP_TOKEN_DEL_SLASH_EQUAL,
|
||||||
MP_TOKEN_DEL_PERCENT_EQUAL,
|
MP_TOKEN_DEL_PERCENT_EQUAL,
|
||||||
|
@ -144,7 +146,6 @@ typedef enum _mp_token_kind_t {
|
||||||
MP_TOKEN_DEL_COLON,
|
MP_TOKEN_DEL_COLON,
|
||||||
MP_TOKEN_DEL_PERIOD,
|
MP_TOKEN_DEL_PERIOD,
|
||||||
MP_TOKEN_DEL_SEMICOLON,
|
MP_TOKEN_DEL_SEMICOLON,
|
||||||
MP_TOKEN_DEL_AT,
|
|
||||||
MP_TOKEN_DEL_EQUAL,
|
MP_TOKEN_DEL_EQUAL,
|
||||||
MP_TOKEN_DEL_MINUS_MORE,
|
MP_TOKEN_DEL_MINUS_MORE,
|
||||||
} mp_token_kind_t;
|
} mp_token_kind_t;
|
||||||
|
|
|
@ -478,6 +478,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
|
||||||
[MP_BINARY_OP_INPLACE_SUBTRACT] = MP_QSTR___isub__,
|
[MP_BINARY_OP_INPLACE_SUBTRACT] = MP_QSTR___isub__,
|
||||||
#if MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS
|
#if MICROPY_PY_ALL_INPLACE_SPECIAL_METHODS
|
||||||
[MP_BINARY_OP_INPLACE_MULTIPLY] = MP_QSTR___imul__,
|
[MP_BINARY_OP_INPLACE_MULTIPLY] = MP_QSTR___imul__,
|
||||||
|
[MP_BINARY_OP_INPLACE_MAT_MULTIPLY] = MP_QSTR___imatmul__,
|
||||||
[MP_BINARY_OP_INPLACE_FLOOR_DIVIDE] = MP_QSTR___ifloordiv__,
|
[MP_BINARY_OP_INPLACE_FLOOR_DIVIDE] = MP_QSTR___ifloordiv__,
|
||||||
[MP_BINARY_OP_INPLACE_TRUE_DIVIDE] = MP_QSTR___itruediv__,
|
[MP_BINARY_OP_INPLACE_TRUE_DIVIDE] = MP_QSTR___itruediv__,
|
||||||
[MP_BINARY_OP_INPLACE_MODULO] = MP_QSTR___imod__,
|
[MP_BINARY_OP_INPLACE_MODULO] = MP_QSTR___imod__,
|
||||||
|
@ -493,6 +494,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
|
||||||
[MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
|
[MP_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
|
||||||
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
||||||
[MP_BINARY_OP_MULTIPLY] = MP_QSTR___mul__,
|
[MP_BINARY_OP_MULTIPLY] = MP_QSTR___mul__,
|
||||||
|
[MP_BINARY_OP_MAT_MULTIPLY] = MP_QSTR___matmul__,
|
||||||
[MP_BINARY_OP_FLOOR_DIVIDE] = MP_QSTR___floordiv__,
|
[MP_BINARY_OP_FLOOR_DIVIDE] = MP_QSTR___floordiv__,
|
||||||
[MP_BINARY_OP_TRUE_DIVIDE] = MP_QSTR___truediv__,
|
[MP_BINARY_OP_TRUE_DIVIDE] = MP_QSTR___truediv__,
|
||||||
[MP_BINARY_OP_MODULO] = MP_QSTR___mod__,
|
[MP_BINARY_OP_MODULO] = MP_QSTR___mod__,
|
||||||
|
@ -510,6 +512,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
|
||||||
[MP_BINARY_OP_REVERSE_SUBTRACT] = MP_QSTR___rsub__,
|
[MP_BINARY_OP_REVERSE_SUBTRACT] = MP_QSTR___rsub__,
|
||||||
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
#if MICROPY_PY_ALL_SPECIAL_METHODS
|
||||||
[MP_BINARY_OP_REVERSE_MULTIPLY] = MP_QSTR___rmul__,
|
[MP_BINARY_OP_REVERSE_MULTIPLY] = MP_QSTR___rmul__,
|
||||||
|
[MP_BINARY_OP_REVERSE_MAT_MULTIPLY] = MP_QSTR___rmatmul__,
|
||||||
[MP_BINARY_OP_REVERSE_FLOOR_DIVIDE] = MP_QSTR___rfloordiv__,
|
[MP_BINARY_OP_REVERSE_FLOOR_DIVIDE] = MP_QSTR___rfloordiv__,
|
||||||
[MP_BINARY_OP_REVERSE_TRUE_DIVIDE] = MP_QSTR___rtruediv__,
|
[MP_BINARY_OP_REVERSE_TRUE_DIVIDE] = MP_QSTR___rtruediv__,
|
||||||
[MP_BINARY_OP_REVERSE_MODULO] = MP_QSTR___rmod__,
|
[MP_BINARY_OP_REVERSE_MODULO] = MP_QSTR___rmod__,
|
||||||
|
|
14
py/parse.c
14
py/parse.c
|
@ -135,8 +135,8 @@ STATIC const uint16_t rule_arg_combined_table[] = {
|
||||||
#define RULE_EXPAND(x) x
|
#define RULE_EXPAND(x) x
|
||||||
#define RULE_PADDING(rule, ...) RULE_PADDING2(rule, __VA_ARGS__, RULE_PADDING_IDS(rule))
|
#define RULE_PADDING(rule, ...) RULE_PADDING2(rule, __VA_ARGS__, RULE_PADDING_IDS(rule))
|
||||||
#define RULE_PADDING2(rule, ...) RULE_EXPAND(RULE_PADDING3(rule, __VA_ARGS__))
|
#define RULE_PADDING2(rule, ...) RULE_EXPAND(RULE_PADDING3(rule, __VA_ARGS__))
|
||||||
#define RULE_PADDING3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) __VA_ARGS__
|
#define RULE_PADDING3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) __VA_ARGS__
|
||||||
#define RULE_PADDING_IDS(r) PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r,
|
#define RULE_PADDING_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r,
|
||||||
|
|
||||||
// Use an enum to create constants specifying how much room a rule takes in rule_arg_combined_table
|
// Use an enum to create constants specifying how much room a rule takes in rule_arg_combined_table
|
||||||
enum {
|
enum {
|
||||||
|
@ -155,8 +155,8 @@ enum {
|
||||||
// Macro to compute the start of a rule in rule_arg_combined_table
|
// Macro to compute the start of a rule in rule_arg_combined_table
|
||||||
#define RULE_ARG_OFFSET(rule, ...) RULE_ARG_OFFSET2(rule, __VA_ARGS__, RULE_ARG_OFFSET_IDS(rule))
|
#define RULE_ARG_OFFSET(rule, ...) RULE_ARG_OFFSET2(rule, __VA_ARGS__, RULE_ARG_OFFSET_IDS(rule))
|
||||||
#define RULE_ARG_OFFSET2(rule, ...) RULE_EXPAND(RULE_ARG_OFFSET3(rule, __VA_ARGS__))
|
#define RULE_ARG_OFFSET2(rule, ...) RULE_EXPAND(RULE_ARG_OFFSET3(rule, __VA_ARGS__))
|
||||||
#define RULE_ARG_OFFSET3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _13
|
#define RULE_ARG_OFFSET3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _14
|
||||||
#define RULE_ARG_OFFSET_IDS(r) PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r, PAD0_##r,
|
#define RULE_ARG_OFFSET_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r, PAD0_##r,
|
||||||
|
|
||||||
// Use the above enum values to create a table of offsets for each rule's arg
|
// Use the above enum values to create a table of offsets for each rule's arg
|
||||||
// data, which indexes rule_arg_combined_table. The offsets require 9 bits of
|
// data, which indexes rule_arg_combined_table. The offsets require 9 bits of
|
||||||
|
@ -632,7 +632,7 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
|
||||||
} else if (rule_id == RULE_shift_expr
|
} else if (rule_id == RULE_shift_expr
|
||||||
|| rule_id == RULE_arith_expr
|
|| rule_id == RULE_arith_expr
|
||||||
|| rule_id == RULE_term) {
|
|| rule_id == RULE_term) {
|
||||||
// folding for binary ops: << >> + - * / % //
|
// folding for binary ops: << >> + - * @ / % //
|
||||||
mp_parse_node_t pn = peek_result(parser, num_args - 1);
|
mp_parse_node_t pn = peek_result(parser, num_args - 1);
|
||||||
if (!mp_parse_node_get_int_maybe(pn, &arg0)) {
|
if (!mp_parse_node_get_int_maybe(pn, &arg0)) {
|
||||||
return false;
|
return false;
|
||||||
|
@ -644,8 +644,8 @@ STATIC bool fold_constants(parser_t *parser, uint8_t rule_id, size_t num_args) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, i));
|
mp_token_kind_t tok = MP_PARSE_NODE_LEAF_ARG(peek_result(parser, i));
|
||||||
if (tok == MP_TOKEN_OP_SLASH || tok == MP_TOKEN_OP_DBL_STAR) {
|
if (tok == MP_TOKEN_OP_AT || tok == MP_TOKEN_OP_SLASH || tok == MP_TOKEN_OP_DBL_STAR) {
|
||||||
// Can't fold / or **
|
// Can't fold @ or / or **
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
|
mp_binary_op_t op = MP_BINARY_OP_LSHIFT + (tok - MP_TOKEN_OP_DBL_LESS);
|
||||||
|
|
|
@ -81,7 +81,7 @@ typedef enum {
|
||||||
MP_BINARY_OP_IS,
|
MP_BINARY_OP_IS,
|
||||||
MP_BINARY_OP_EXCEPTION_MATCH,
|
MP_BINARY_OP_EXCEPTION_MATCH,
|
||||||
|
|
||||||
// 12 inplace arithmetic operations; order matches corresponding mp_token_kind_t
|
// 13 inplace arithmetic operations; order matches corresponding mp_token_kind_t
|
||||||
MP_BINARY_OP_INPLACE_OR,
|
MP_BINARY_OP_INPLACE_OR,
|
||||||
MP_BINARY_OP_INPLACE_XOR,
|
MP_BINARY_OP_INPLACE_XOR,
|
||||||
MP_BINARY_OP_INPLACE_AND,
|
MP_BINARY_OP_INPLACE_AND,
|
||||||
|
@ -90,12 +90,13 @@ typedef enum {
|
||||||
MP_BINARY_OP_INPLACE_ADD,
|
MP_BINARY_OP_INPLACE_ADD,
|
||||||
MP_BINARY_OP_INPLACE_SUBTRACT,
|
MP_BINARY_OP_INPLACE_SUBTRACT,
|
||||||
MP_BINARY_OP_INPLACE_MULTIPLY,
|
MP_BINARY_OP_INPLACE_MULTIPLY,
|
||||||
|
MP_BINARY_OP_INPLACE_MAT_MULTIPLY,
|
||||||
MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
|
MP_BINARY_OP_INPLACE_FLOOR_DIVIDE,
|
||||||
MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
|
MP_BINARY_OP_INPLACE_TRUE_DIVIDE,
|
||||||
MP_BINARY_OP_INPLACE_MODULO,
|
MP_BINARY_OP_INPLACE_MODULO,
|
||||||
MP_BINARY_OP_INPLACE_POWER,
|
MP_BINARY_OP_INPLACE_POWER,
|
||||||
|
|
||||||
// 12 normal arithmetic operations; order matches corresponding mp_token_kind_t
|
// 13 normal arithmetic operations; order matches corresponding mp_token_kind_t
|
||||||
MP_BINARY_OP_OR,
|
MP_BINARY_OP_OR,
|
||||||
MP_BINARY_OP_XOR,
|
MP_BINARY_OP_XOR,
|
||||||
MP_BINARY_OP_AND,
|
MP_BINARY_OP_AND,
|
||||||
|
@ -104,6 +105,7 @@ typedef enum {
|
||||||
MP_BINARY_OP_ADD,
|
MP_BINARY_OP_ADD,
|
||||||
MP_BINARY_OP_SUBTRACT,
|
MP_BINARY_OP_SUBTRACT,
|
||||||
MP_BINARY_OP_MULTIPLY,
|
MP_BINARY_OP_MULTIPLY,
|
||||||
|
MP_BINARY_OP_MAT_MULTIPLY,
|
||||||
MP_BINARY_OP_FLOOR_DIVIDE,
|
MP_BINARY_OP_FLOOR_DIVIDE,
|
||||||
MP_BINARY_OP_TRUE_DIVIDE,
|
MP_BINARY_OP_TRUE_DIVIDE,
|
||||||
MP_BINARY_OP_MODULO,
|
MP_BINARY_OP_MODULO,
|
||||||
|
@ -123,6 +125,7 @@ typedef enum {
|
||||||
MP_BINARY_OP_REVERSE_ADD,
|
MP_BINARY_OP_REVERSE_ADD,
|
||||||
MP_BINARY_OP_REVERSE_SUBTRACT,
|
MP_BINARY_OP_REVERSE_SUBTRACT,
|
||||||
MP_BINARY_OP_REVERSE_MULTIPLY,
|
MP_BINARY_OP_REVERSE_MULTIPLY,
|
||||||
|
MP_BINARY_OP_REVERSE_MAT_MULTIPLY,
|
||||||
MP_BINARY_OP_REVERSE_FLOOR_DIVIDE,
|
MP_BINARY_OP_REVERSE_FLOOR_DIVIDE,
|
||||||
MP_BINARY_OP_REVERSE_TRUE_DIVIDE,
|
MP_BINARY_OP_REVERSE_TRUE_DIVIDE,
|
||||||
MP_BINARY_OP_REVERSE_MODULO,
|
MP_BINARY_OP_REVERSE_MODULO,
|
||||||
|
|
|
@ -43,9 +43,9 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
|
||||||
bc=\\d\+ line=126
|
bc=\\d\+ line=126
|
||||||
00 LOAD_CONST_NONE
|
00 LOAD_CONST_NONE
|
||||||
01 LOAD_CONST_FALSE
|
01 LOAD_CONST_FALSE
|
||||||
02 BINARY_OP 26 __add__
|
02 BINARY_OP 27 __add__
|
||||||
03 LOAD_CONST_TRUE
|
03 LOAD_CONST_TRUE
|
||||||
04 BINARY_OP 26 __add__
|
04 BINARY_OP 27 __add__
|
||||||
05 STORE_FAST 0
|
05 STORE_FAST 0
|
||||||
06 LOAD_CONST_SMALL_INT 0
|
06 LOAD_CONST_SMALL_INT 0
|
||||||
07 STORE_FAST 0
|
07 STORE_FAST 0
|
||||||
|
@ -84,7 +84,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
|
||||||
\\d\+ STORE_FAST 7
|
\\d\+ STORE_FAST 7
|
||||||
\\d\+ LOAD_FAST 0
|
\\d\+ LOAD_FAST 0
|
||||||
\\d\+ LOAD_DEREF 14
|
\\d\+ LOAD_DEREF 14
|
||||||
\\d\+ BINARY_OP 26 __add__
|
58 BINARY_OP 27 __add__
|
||||||
\\d\+ STORE_FAST 8
|
\\d\+ STORE_FAST 8
|
||||||
\\d\+ LOAD_FAST 0
|
\\d\+ LOAD_FAST 0
|
||||||
\\d\+ UNARY_OP 1
|
\\d\+ UNARY_OP 1
|
||||||
|
@ -363,7 +363,7 @@ Raw bytecode (code_info_size=\\d\+, bytecode_size=\\d\+):
|
||||||
42 STORE_FAST_N 19
|
42 STORE_FAST_N 19
|
||||||
44 LOAD_FAST 9
|
44 LOAD_FAST 9
|
||||||
45 LOAD_FAST_N 19
|
45 LOAD_FAST_N 19
|
||||||
47 BINARY_OP 26 __add__
|
47 BINARY_OP 27 __add__
|
||||||
48 POP_TOP
|
48 POP_TOP
|
||||||
49 LOAD_CONST_NONE
|
49 LOAD_CONST_NONE
|
||||||
50 RETURN_VALUE
|
50 RETURN_VALUE
|
||||||
|
@ -520,7 +520,7 @@ arg names: *
|
||||||
bc=\\d\+ line=113
|
bc=\\d\+ line=113
|
||||||
00 LOAD_DEREF 0
|
00 LOAD_DEREF 0
|
||||||
02 LOAD_CONST_SMALL_INT 1
|
02 LOAD_CONST_SMALL_INT 1
|
||||||
03 BINARY_OP 26 __add__
|
03 BINARY_OP 27 __add__
|
||||||
04 STORE_FAST 1
|
04 STORE_FAST 1
|
||||||
05 LOAD_CONST_SMALL_INT 1
|
05 LOAD_CONST_SMALL_INT 1
|
||||||
06 STORE_DEREF 0
|
06 STORE_DEREF 0
|
||||||
|
@ -539,7 +539,7 @@ arg names: * b
|
||||||
bc=\\d\+ line=139
|
bc=\\d\+ line=139
|
||||||
00 LOAD_FAST 1
|
00 LOAD_FAST 1
|
||||||
01 LOAD_DEREF 0
|
01 LOAD_DEREF 0
|
||||||
03 BINARY_OP 26 __add__
|
03 BINARY_OP 27 __add__
|
||||||
04 RETURN_VALUE
|
04 RETURN_VALUE
|
||||||
mem: total=\\d\+, current=\\d\+, peak=\\d\+
|
mem: total=\\d\+, current=\\d\+, peak=\\d\+
|
||||||
stack: \\d\+ out of \\d\+
|
stack: \\d\+ out of \\d\+
|
||||||
|
|
Loading…
Reference in New Issue