cjanet

Array of JanetAbstractTypes to register for marshalling in the current compilation unit

Array of C Constants defined in the current compilation unit

Array of C Functions defined in the current compilation unit

The default type used when declaring variables

current indent buffer

A context value for storing the current state of compilation, including buffers, flags, and tool paths.

(@ & args)

(abstract-type name & fields)

Macro version of emit-abstract-type that allows for top-level unquote

(begin-jit &keys options)

Begin C Janet JIT context. Optionally pass in options to configure compilation. The `options` argument
will be passed to the `spork/cc` module to compile generated C code. Generated intermediates will be created
in the _build/ directory.

(block & args)

(cdef name & more)

Define constant which will be registered in the module.
It takes care of the docstring.

(cfunction name & more)

Define a C Function in cjanet. This also takes care
of recording docstrings and such. Arity checking will be
generated for you (by insertion of a call to janet_arity
or janet_fixarity).

(declare & args)

(emit-abstract-type name & fields)

(emit-block-end &opt nl)

(emit-block-start)

(emit-blocks statements &opt no-indent)

Emit a number of statements in a bracketed block

(emit-cdef name & more)

Define constant which will be registered in the module.
It takes care of the docstring.

(emit-cfunction name & more)

Functional form of `cfunction` - takes the same arguments, but parameters must be manually quoted.

(emit-comment msg)

Emit a multi-line comment string for C

(emit-declare binding & form)

Emit a declaration of a variable or constant.

(emit-extern binding)

Emit a declaration of a variable or constant.

(emit-function name & form)

Emit a C function definition.

(emit-include path)

(emit-indent)

(emit-module-entry name)

Call this at the end of a cjanet module to add a module entry function.

(emit-preprocess & args)

Emit a line of source code for the pre-processor.
For example `(emit-preprocess "include" "<stdio.h>")`.

(emit-typedef name definition)

Emit a type declaration (C typedef).

(end-jit &named no-load cache)

End current compilation context, compile all buffered code, and then by default load it into the current process.
The `no-load` argument controls whether or not the compiled code is loaded. If `no-load` is truthy, then
this function will return the path to the compiled shared object and skip loading.
If `cache` is truthy, this function will use a previously compiled shared object or DLL if it exists and the source code matches.

(extern & args)

(function & args)

(include path)

(mangle token)

Convert any sequence of bytes to a valid C identifier in a way that is unlikely to collide. The period character
is left unchanged even though it is not a valid identifier to allow for easy access into structs. Will also remove
any grafted type info. E.g. abc:int -> abc
For generating lvalues and rvalues.

(mangle-name token)

Same as `mangle` but only emit proper C identifiers (no ., :, or -> allowed).
For C identifiers.

(mangle-type token)

Same as `mangle` but for valid C

(module-entry name)

Call this at the end of a cjanet module to add a module entry function.

(preprocess & args)

(register-binding-type alias ctype &opt wrapfn getfn optfn abstract)

Add a C type that can be used a parameter or return type to CFunctions.
`alias` is a short name that can be used as a type alias only in CFunctions, and can be
nil if no alias is desired. Any of `wrapfn`, `getfn`, and `optfn` can be nil.

* `ctype` is a CJanet type expression, such as `(* double)` or `(const MyCustonType)`.
* `wrapfn` is a function or C macro name that is used to convert values of `ctype` to a `Janet` value,
 such as `janet_wrap_pointer` or `wrap_my_custom_type`. This will be used for returning values from functions.
* `getfn` is the name of a function of two argumnets to extract this value from a parameter list, such as `janet_getnumber`.
 This function should have the signature `Janet getfn(const Janet *argv, int32_t n);`
* `optfn` is the name of a function similar to `getfn` but will be used in the case where the parameter is optional.
 This function should have the signature `Janet optfn(const Janet *argv, int32_t argc, int32_t n, <anytype> dflt);`
 Notably, the "default" value `dflt` does not need to be any particular type.

(type-split x &opt dflt-type)

Extract name and type from a variable. Allow typing variables as both (name type) or name:type as a shorthand. If no type is found, default to dflt-type. dflt-type itself defaults to (dyn *default-ctype* 'CJANET_DEFAULT_TYPE')

(typedef & args)