This fixes a long standing problem that viper code generation gave
terrible error messages, and actually no errors on pyboard where
assertions are disabled.

Now all compile-time errors are raised as proper Python exceptions, and
are of type ViperTypeError.

Addresses issue #940.

This patch gets full function argument passing working with native
emitter.  Includes named args, keyword args, default args, var args
and var keyword args.  Fully Python compliant.

It reuses the bytecode mp_setup_code_state function to do all the hard
work.  This function is slightly adjusted to accommodate native calls,
and the native emitter is forced a bit to emit similar prelude and
code-info as bytecode.

Currently supports only x64 and Thumb2 archs.

This implementation is smaller (in code size) than #1024.

This is a temporary fix.

Saves around 230 bytes on Thumb2 and 750 bytes on x86.

Saves 116 bytes for stmhal and 56 bytes for cc3200 port.

Previous to this patch, a big-int, float or imag constant was interned
(made into a qstr) and then parsed at runtime to create an object each
time it was needed.  This is wasteful in RAM and not efficient.  Now,
these constants are parsed straight away in the parser and turned into
objects.  This allows constants with large numbers of digits (so
addresses issue #1103) and takes us a step closer to #722.

This makes the code (more) compatible with the C99 standard.

This allows an exception to propagate correctly through a finally
handler.

See issue #699.

Saves 24 bytes in bare-arm.

Native code has GC-heap pointers in it so it must be scanned.  But on
unix port memory for native functions is mmap'd, and so it must have
explicit code to scan it for root pointers.

This allows to directly load a Python object to the Python stack.  See
issue #722 for background.

Addresses issue #1022.

This patch makes the MICROPY_PY_BUILTINS_SLICE compile-time option
fully disable the builtin slice operation (when set to 0).  This
includes removing the slice sytanx from the grammar.  Now, enabling
slice costs 4228 bytes on unix x64, and 1816 bytes on stmhal.

This patch makes MICROPY_PY_BUILTINS_SET compile-time option fully
disable the builtin set object (when set to 0).  This includes removing
set constructor/comprehension from the grammar, the compiler and the
emitters.  Now, enabling set costs 8168 bytes on unix x64, and 3576
bytes on stmhal.

Viper can now do: ptr8(buf)[0], which loads a byte from a buffer using
machine instructions.

This should pretty much resolve issue #50.

Viper can now do the following:

def store(p:ptr8, c:int):
    p[0] = c

This does a store of c to the memory pointed to by p using a machine
instructions inline in the code.

This included a bit of restructuring of the assembler backends.  Note
that the ARM backend is missing a few functions and won't compile.

Allows things like: if 1: ...