suspect-devices/circuitpython/py/parse.c, branch 6.2.0-beta.1

Add license to some obvious files.

2020-07-06T18:16:25+00:00

f-strings: Make optional, defaulting to !CIRCUITPY_MINIMAL_BUILD

2020-03-09T14:03:25+00:00

This should reclaim *most* code space added to handle f-strings. However, there may be some small code growth as parse_string_literal takes a new parameter (which will always be 0, so hopefully the optimizer eliminates it)

Address dpgeorge feedback - largely simplifications

2020-03-09T13:16:07+00:00

py: Implement partial PEP-498 (f-string) support

2020-03-09T13:16:07+00:00

This implements (most of) the PEP-498 spec for f-strings, with two exceptions: - raw f-strings (`fr` or `rf` prefixes) raise `NotImplementedError` - one special corner case does not function as specified in the PEP (more on that in a moment) This is implemented in the core as a syntax translation, brute-forcing all f-strings to run through `String.format`. For example, the statement `x='world'; print(f'hello {x}')` gets translated *at a syntax level* (injected into the lexer) to `x='world'; print('hello {}'.format(x))`. While this may lead to weird column results in tracebacks, it seemed like the fastest, most efficient, and *likely* most RAM-friendly option, despite being implemented under the hood with a completely separate `vstr_t`. Since [string concatenation of adjacent literals is implemented in the lexer](https://github.com/micropython/micropython/commit/534b7c368dc2af7720f3aaed0c936ef46d773957), two side effects emerge: - All strings with at least one f-string portion are concatenated into a single literal which *must* be run through `String.format()` wholesale, and: - Concatenation of a raw string with interpolation characters with an f-string will cause `IndexError`/`KeyError`, which is both different from CPython *and* different from the corner case mentioned in the PEP (which gave an example of the following:) ```python x = 10 y = 'hi' assert ('a' 'b' f'{x}' '{c}' f'str<{y:^4}>' 'd' 'e') == 'ab10{c}str< hi >de' ``` The above-linked commit detailed a pretty solid case for leaving string concatenation in the lexer rather than putting it in the parser, and undoing that decision would likely be disproportionately costly on resources for the sake of a probably-low-impact corner case. An alternative to become complaint with this corner case of the PEP would be to revert to string concatenation in the parser *only when an f-string is part of concatenation*, though I've done no investigation on the difficulty or costs of doing this. A decent set of tests is included. I've manually tested this on the `unix` port on Linux and on a Feather M4 Express (`atmel-samd`) and things seem sane.

parse: push_result_token: throw an exception on too-long names

2020-03-01T15:38:34+00:00

Before this, such names would instead cause an assertion error inside qstr_from_strn. A simple reproducer is a python source file containing the letter "a" repeated 256 times

Two fixes and translate more strings.

2018-08-09T20:29:30+00:00

* Fix finding translations with escaped characters. * Add back \r to translations since its needed by screen.

continued WIP: almost compiling

2018-07-12T18:13:51+00:00

WIP: after merge; before testing

2018-07-11T20:45:30+00:00

Make parsing more memory flexible.

2018-01-25T02:22:20+00:00

The parser attempts to allocate two large (~512 byte) chunks up front. If it couldn't, then it would error out. This change will cause it to try allocating half the previous attempt until its down to two copies. This is ok upfront because later code checks bounds and tries to extend the allocation if needed.

py/parse: Fix macro evaluation by avoiding empty __VA_ARGS__.

2017-12-29T02:44:26+00:00

Empty __VA_ARGS__ are not allowed in the C preprocessor so adjust the rule arg offset calculation to not use them. Also, some compilers (eg MSVC) require an extra layer of macro expansion.