GitLab

Note: made two places in api implementation as unimplemented as
the instruction/type chnaged.

Added supports for all types.

Support Const NULL

Support conversions, the TAILCALL and NEW instructions

Also fixed a bug in FuncVer building.

Still panics. need to debug

Now it can handle both local vars and constants.

Currently only BinOp is implemented. More instructions will be built
later.

Ensure that "structs" have names, so that structs can be referred
symbolically. In the future, functions and basic blocks also need to be
ensured to have names. Such names are generated from their IDs if not
provided by the client.

The IR builder can create named or unnamed MuEntityHeader based on
whether it has client-provided name or not.

Can build constants now (currently only Constant::Int).

Also resolves dependency

Implemented dependency resolution.

Creaation and destruction of MuVM, MuCtx and MuIRBuilder. Now the
`mvm->new_context`, `ctx->new_ir_builder`, `ctx->close_context` and
`b->abort` works. MuVM can also be created via a top-level "C"-style
exported function `mu_fastimpl_new()` so that in theory, it can be used
in C programs.

Now it is the time to actually implement the public API. This commit
only contains scaffolds so that it compiles, and I can fill in actual
implementations later. Most of them should forward to the actual VM.*
methods (with some adaptations).

Found a way to implement handle allocation and dealllocation, and a way
to access MuVM from MuCtx using pointers.

Re-wrote the muapi2rustapi.py script.

Use *const for CStrings and CMuValue.

Set linker flags properly according to the OS.

Tested trap handler callback. It looks like it is easy enough for Rust
to interact with C.

Added linker flags so it will work in Linux.

Test whether the generated stubs are reasonable.

Added the "localtest" directory for testing the API without touching
other modules. (TODO: It could be moved somewhere else, but should not
use src as an extern crate, or it will depend on the entire crate.)

Use CStr for incoming strings from C. CString is for C-style strings
**owned by Rust**.

Added comments at the beginning of api_c.rs and api_bridge.rs to
indicate some parts of the files are generated.