Passing -v -v -v on the command line of the coverage build will now print
the parse tree (as well as other things at this verbosity level).

The lexer is very mature and this debug function is no longer used.  If
it's really needed one can uncomment it and recompile.

This check always fails (ie chr0 is never EOF) because the callers of this
function never call it past the end of the input stream.  And even if they
did it would be harmless because 1) reader.readbyte must continue to
return an EOF char if the stream is exhausted; 2) next_char would just
count the subsequent EOF's as characters worth 1 column.

    import utimeq, utime
    # Max queue size, the queue allocated statically on creation
    q = utimeq.utimeq(10)
    q.push(utime.ticks_ms(), data1, data2)
    res = [0, 0, 0]
    # Items in res are filled up with results
    q.pop(res)

And also simplify it to remove the check for small int.  This can be done
because this function is only ever called if the argument is not a small
int.

It's pretty rough way to detect yaota8266 being used, but otherwise allows
to have a filesystem in such config.

Native code can hold pointers to objects on the heap, eg constant objects
like big integers.

It needs an extra pass to compute the size of the constant table for the
l32r instructions.

Required for the testsuite.

This is required to avoid extra level of output "cooking" ("\r\r\n") and
make test infrastructure work. On the other hand, this breaks somewhat
Zephyr console abstraction.

Ultimately all ports that use lib/utils/interrupt_char would enable
MICROPY_KBD_EXCEPTION, so this is an interim solution.

Defining and initialising mp_kbd_exception is boiler-plate code and so the
core runtime can provide it, instead of each port needing to do it
themselves.

The exception object is placed in the VM state rather than on the heap.

There's no need to store a separate pointer to this object.

mp_kbd_exception is now considered the standard variable name to hold the
singleton KeyboardInterrupt exception.

This patch also moves the creation of this object from pyb_usb_init() to
main().

Previous to this patch pyboard.py would open a new serial connection to
the target for each script that was run, and for any command that was run.
Apart from being inefficient, this meant that the board was soft-reset
between scripts/commands, which precludes scripts from accessing variables
set in a previous one.

This patch changes the behaviour of pyboard.py so that the connection to
the target is created only once, and it's not reset between scripts or any
command that is sent with the -c option.