suspect-devices/circuitpython/py/parse.c, branch v1.9.3

all: Remove inclusion of internal py header files.

2017-10-04T01:37:50+00:00

Header files that are considered internal to the py core and should not normally be included directly are: py/nlr.h - internal nlr configuration and declarations py/bc0.h - contains bytecode macro definitions py/runtime0.h - contains basic runtime enums Instead, the top-level header files to include are one of: py/obj.h - includes runtime0.h and defines everything to use the mp_obj_t type py/runtime.h - includes mpstate.h and hence nlr.h, obj.h, runtime0.h, and defines everything to use the general runtime support functions Additional, specific headers (eg py/objlist.h) can be included if needed.

all: Use the name MicroPython consistently in comments

2017-07-31T08:35:40+00:00

There were several different spellings of MicroPython present in comments, when there should be only one.

py/parse: Simplify handling of errors by raising them directly.

2017-02-24T03:56:37+00:00

The parser was originally written to work without raising any exceptions and instead return an error value to the caller. But it's now required that a call to the parser be wrapped in an nlr handler, so we may as well make use of that fact and simplify the parser so that it doesn't need to keep track of any memory errors that it had. The parser anyway explicitly raises an exception at the end if there was an error. This patch simplifies the parser by letting the underlying memory allocation functions raise an exception if they fail to allocate any memory. And if there is an error parsing the " = const()" pattern then that also raises an exception right away instead of trying to recover gracefully and then raise.

py: Create str/bytes objects in the parser, not the compiler.

2017-02-24T02:43:43+00:00

Previous to this patch any non-interned str/bytes objects would create a special parse node that held a copy of the str/bytes data. Then in the compiler this data would be turned into a str/bytes object. This actually lead to 2 copies of the data, one in the parse node and one in the object. The parse node's copy of the data would be freed at the end of the compile stage but nevertheless it meant that the peak memory usage of the parse/compile stage was higher than it needed to be (by an amount equal to the number of bytes in all the non-interned str/bytes objects). This patch changes the behaviour so that str/bytes objects are created directly in the parser and the object stored in a const-object parse node (which already exists for bignum, float and complex const objects). This reduces peak RAM usage of the parse/compile stage, simplifies the parser and compiler, and reduces code size by about 170 bytes on Thumb2 archs, and by about 300 bytes on Xtensa archs.

py/parse: Allow parser/compiler consts to be bignums.

2017-02-24T02:03:44+00:00

This patch allows uPy consts to be bignums, eg: X = const(1 << 100) The infrastructure for consts to be a bignum (rather than restricted to small integers) has been in place for a while, ever since constant folding was upgraded to allow bignums. It just required a small change (in this patch) to enable it.

py/grammar: Group no-compile grammar rules together to shrink tables.

2017-02-16T08:45:06+00:00

Grammar rules have 2 variants: ones that are attached to a specific compile function which is called to compile that grammar node, and ones that don't have a compile function and are instead just inspected to see what form they take. In the compiler there is a table of all grammar rules, with each entry having a pointer to the associated compile function. Those rules with no compile function have a null pointer. There are 120 such rules, so that's 120 words of essentially wasted code space. By grouping together the compile vs no-compile rules we can put all the no-compile rules at the end of the list of rules, and then we don't need to store the null pointers. We just have a truncated table and it's guaranteed that when indexing this table we only index the first half, the half with populated pointers. This patch implements such a grouping by having a specific macro for the compile vs no-compile grammar rules (DEF_RULE vs DEF_RULE_NC). It saves around 460 bytes of code on 32-bit archs.

py/parse: Refactor code to remove assert(0)'s.

2017-01-17T06:00:55+00:00

This helps to improve code coverage. Note that most of the changes in this patch are just de-denting the cases of the switch statements.

py/parse: Add code to fold logical constants in or/and/not operations.

2016-11-15T05:48:49+00:00

Adds about 200 bytes to the code size when constant folding is enabled.

py/parse: Make mp_parse_node_new_leaf an inline function.

2016-11-15T05:48:48+00:00

It is split into 2 functions, one to make small ints and the other to make a non-small-int leaf node. This reduces code size by 32 bytes on bare-arm, 64 bytes on unix (x64-64) and 144 bytes on stmhal.

py/parse: Move function to check for const parse node to parse.[ch].

2016-11-15T05:48:48+00:00