declare-cc

Root build directory that will contain all built artifacts

Bound to the bundle manifest during a bundle/install.

Force a given toolchain. If unset, will auto-detect.

(create-buffer-c bytes dest name)

Inline raw byte file as a c file. The header file will contain two exported symbols, `(string name "_emded")`, a
 pointer of an array of unsigned char, and `(string name "_embed_size")`, a size_t of the number bytes.

(declare-archive &named entry name deps)

Build a janet archive. This is a file that bundles together many janet scripts into a janet image. This file can the be moved to any machine with a janet vm and the required dependencies and run there.

(declare-bin &named main)

Declare a generic file to be installed as an executable.

(declare-binscript &named main hardcode-syspath is-janet)

Declare a janet file to be installed as an executable script. Creates
a shim on windows. If hardcode is true, will insert code into the script
such that it will run correctly even when JANET_PATH is changed. if auto-shebang
is truthy, will also automatically insert a correct shebang line.

(declare-documentation &named source prefix)

Mark a file as general documentation to be installed. Documentation will be installed to $SYSYPATH/man/`prefix`/`(basename source)`

(declare-executable &named name entry install headers no-compile no-core defines pkg-config-flags target-os deps static pkg-config-libs smart-libs c-std c++-std msvc-libs ldflags cflags c++flags lflags libs static-libs dynamic-libs use-rpath use-rdynamic)

Declare a janet file to be the entry of a standalone executable program. The entry file is evaluated and a main function is looked for in the entry file. This function is marshalled into bytecode which is then embedded in a final executable for distribution.

(declare-headers &named headers prefix)

Declare headers for a library installation. Installed headers can be used by other native libraries.

(declare-manpage page)

Mark a manpage for installation. Manpages will be installed to $SYSPATH/man/man1/`(basename page)`

(declare-native &named name source embedded lflags libs cflags c++flags defines nostatic static-libs deps headers use-rpath use-rdynamic pkg-config-flags dynamic-libs msvc-libs ldflags pkg-config-libs smart-libs c-std c++-std target-os)

Declare a native module. This is a shared library that can be loaded dynamically by a janet runtime. This also builds a static libary that can be used to bundle janet code and native into a single executable.

(declare-project &named name description url version repo tag dependencies author license)

Define your project metadata. This should
be the first declaration in a project.janet file.
Sets up the JPM-style build rule system as well as
creates a number of default bundle hooks including:
- build
- clean
- check
- install
- list-rules
- rule-tree

(declare-source &named source prefix)

Create Janet modules. This does not actually build the module(s), but registers them for packaging and installation. :source should be an array of files and directores to copy into JANET_MODPATH or JANET_PATH. :prefix can optionally be given to modify the destination path to be (string JANET_PATH prefix source).

(install-file-rule src dest &opt chmod-mode thunk is-exe)

Add install and uninstall rule for moving file from src into destdir.

(jpm-shim-env &opt e)

Create an environment table that can evaluate project.janet files

(modpath-to-meta toolchain path)

Get the meta file path (.meta.janet) corresponding to a native module path (.so).

(modpath-to-static toolchain path)

Get the static library (.a) path corresponding to a native module path (.so).

(phony target deps & body)

Alias for `task`.

(post-deps & body)

Run code at the top level if jpm dependencies are installed. Build code that imports dependencies should be wrapped with this macro, as project.janet needs to be able to run successfully even without dependencies installed.

(quickbin entry output)

Create an executable file from a script with a main function.

(rule target deps & body)

Add a rule to the rule graph.

(run-tests &opt root-directory)

Run tests on a project in the current directory. The tests will be run in the environment dictated by (dyn :modpath).

(sh-phony target deps & body)

Alias for `sh-task`.

(sh-rule target deps & body)

Add a rule that invokes a shell command, and fails if the command returns non-zero.

(sh-task target deps & body)

Add a task that invokes a shell command, and fails if the command returns non-zero.

(task target deps & body)

Add a task rule to the rule graph. A task rule will always run if invoked (it is always considered out of date).