JPM

(archive-c opts target & objects)

Link object files together to make a static library.

(compile-c compiler opts src dest &opt static?)

Compile a C file into an object file.

(create-buffer-c source dest name)

Inline raw byte file as a c file.

(create-buffer-c-impl bytes dest name)

(create-executable opts source dest no-core)

Links an image with libjanet.a (or .lib) to produce an executable. Also will try to link native modules into the final executable as well.

(embed-name path)

Rename a janet symbol for embedding.

(entry-name name)

Name of symbol that enters static compilation of a module.

(entry-replace name)

Escape special characters in the entry-name

(link-c has-cpp opts target & objects)

Link C or C++ object files together to make a native module.

(make-bin-source declarations lookup-into-invocations no-core)

(make-define define value)

Generate strings for adding custom defines to the compiler.

(make-defines defines)

Generate many defines. Takes a dictionary of defines. If a value is true, generates -DNAME (/DNAME on windows), otherwise -DNAME=value.

(modpath-to-meta path)

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

(modpath-to-static path)

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

(out-path path from-ext to-ext)

Take a source file path and convert it to an output path.

(add-loader)

Adds the custom template loader to Janet's module/loaders and update module/paths.

(ir & body)

Macro that automatically quotes the body provided and calls (print-ir ...) on the body.

(mangle token)

Convert any sequence of bytes to a valid C identifier in a way that is unlikely to collide. `print-ir` will not mangle symbols for you.

(print-ir ir)

Compile the CGEN IR to C and print it to (dyn :out).

(build)

(clean)

(configure &opt path)

Setup an out-of-tree build with certain configuration options.

(deps)

(enable-local-mode)

Modify the config to enable local development. Creates a local tree if one does not exist in ./jpm_tree/

(help)

(install & repo)

(jpm-debug-repl)

(list-installed)

(list-pkgs &opt search)

(list-rules &opt ctx)

(list-tasks &opt ctx)

(new-c-project name)

Create a new C project

(new-exe-project name)

Create a new executable project

(new-project name)

Create a new project

(quickbin input output)

(set-tree tree)

Set the module tree for installing dependencies. This just sets the modpath binpath and manpath. Also creates the tree if it doesn't exist. However, still uses the system libraries and headers for janet.

(show-config)

(show-paths)

(show-rule-tree &opt root depth)

(test)

(update-pkgs)

Table of all built-in options, as opposed to project deifned options.

A table of all of the dynamic config bindings to checkers (validators).

Table of all of the help text for each config option.

A table of possible options for enum option types.

A table of all of the dynamic config bindings to parsers.

Listing of all config dyns.

(defconf kw &opt parser docs options)

Define a function that wraps (dyn :keyword). This will allow use of dynamic bindings with static runtime checks.

(dyn:ar &opt dflt)

(dyn:auto-shebang &opt dflt)

(dyn:binpath &opt dflt)

(dyn:build-type &opt dflt)

(dyn:buildpath &opt dflt)

(dyn:c++ &opt dflt)

(dyn:c++-link &opt dflt)

(dyn:cc &opt dflt)

(dyn:cc-link &opt dflt)

(dyn:cflags &opt dflt)

(dyn:cflags-verbose &opt dflt)

(dyn:config-file &opt dflt)

(dyn:cppflags &opt dflt)

(dyn:curlpath &opt dflt)

(dyn:dest-dir &opt dflt)

(dyn:dynamic-cflags &opt dflt)

(dyn:dynamic-lflags &opt dflt)

(dyn:gitpath &opt dflt)

(dyn:headerpath &opt dflt)

(dyn:is-msvc &opt dflt)

(dyn:janet &opt dflt)

(dyn:janet-cflags &opt dflt)

(dyn:janet-importlib &opt dflt)

(dyn:janet-lflags &opt dflt)

(dyn:ldflags &opt dflt)

(dyn:lflags &opt dflt)

(dyn:libpath &opt dflt)

(dyn:local &opt dflt)

(dyn:manpath &opt dflt)

(dyn:modext &opt dflt)

(dyn:modpath &opt dflt)

(dyn:nocolor &opt dflt)

(dyn:offline &opt dflt)

(dyn:optimize &opt dflt)

(dyn:pkglist &opt dflt)

(dyn:silent &opt dflt)

(dyn:statext &opt dflt)

(dyn:tarpath &opt dflt)

(dyn:test &opt dflt)

(dyn:tree &opt dflt)

(dyn:update-pkgs &opt dflt)

(dyn:use-batch-shell &opt dflt)

(dyn:verbose &opt dflt)

(dyn:workers &opt dflt)

(load-config settings &opt override)

Load a configuration from a table or struct.

(load-config-file path &opt override)

Load a configuration from a file. If override is set, will override already set values. Otherwise will prefer the current value over the settings from the config file.

(load-default &opt override)

Load the default configuration.

(load-options &opt path)

Load a file that contains config options that can be set. If no such file exists, then do nothing.

(opt opts key &opt dflt)

Get an option, allowing overrides via dynamic bindings AND some default value dflt if no dynamic binding is set.

(read-env-variables)

Read environment variables that correspond to config variables into dyns.

(save-config path)

Write the current configuration information to a file.

Map some single characters to long options.

(pdag f dag &opt n-workers)

Executes a dag by calling f on every node in the graph. Can set the number of workers for parallel execution. The graph is represented as a table mapping nodes to arrays of child nodes. Each node will only be evaluated after all children have been evaluated. Returns a table mapping each node to the result of `(f node)`.

(pmap f data)

Function form of `ev/gather`. If any of the sibling fibers error, all other siblings will be canceled. Returns the gathered results in an array.

(auto)

Get an autodetected config.

(generate-config &opt destdir silent as-data)

Make a pretty good configuration file for the current target. Returns a buffer with config source contents. If `destdir` is given, will generate the folders needed to create a jpm tree.

(bundle-install bundle &opt no-deps force-update)

Install a bundle from a git repository.

(curl & args)

Make a call to curl

(do-rule target)

Evaluate a given rule in a one-off manner.

(download-bundle url bundle-type &opt tag shallow)

Download the package source (using git) to the local cache. Return the path to the downloaded or cached soure code.

(download-git-bundle bundle-dir url tag shallow)

Download a git bundle from a remote respository

(download-tar-bundle bundle-dir url &opt force-gz)

Download a dependency from a tape archive. The archive should have exactly one top level directory that contains the contents of the project.

(git & args)

Make a call to git.

(import-rules path &opt base-env)

Import another file that defines more rules. This ruleset is merged into the current ruleset.

(is-bundle-installed bundle)

Determines if a bundle has been installed or not

(load-lockfile &opt filename)

Load packages from a lockfile.

(load-project-meta &opt path)

Load the metadata from a project.janet file without doing a full evaluation of the project.janet file. Returns a struct with the project metadata. Raises an error if no metadata found.

(make-jpm-env &opt base-env)

Create an environment that is preloaded with jpm symbols.

(make-lockfile &opt filename)

(out-of-tree-config path &opt options)

Create an out of tree build configuration. This lets a user have a debug or release build, as well as other configuration on a one time basis. This works by creating a new directory with a project.janet that loads in the original project.janet file with some settings changed.

(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.

(require-jpm path &opt base-env)

Require a jpm file project file. This is different from a normal require in that code is loaded in the jpm environment.

(resolve-bundle bundle)

Convert any bundle string/table to the normalized table form.

(tar & args)

Make a call to tar.

(update-git-bundle bundle-dir tag shallow)

Fetch latest tag version from remote repository

(update-installed)

Update all previously installed packages to their latest versions.

(add-body target & body)

Add recipe code to an existing rule. This makes existing rules do more but does not modify the dependency graph.

(add-dep target dep)

Alias for `add-input`

(add-input target input)

Add a dependency to an existing rule. Useful for extending phony rules or extending the dependency graph of existing rules.

(add-output target output)

Add an output file to an existing rule. Rules can contain multiple outputs, but are still referred to by a main target name.

(add-thunk target thunk)

Append a thunk to a target's recipe.

(build-rules rules targets &opt n-workers)

Given a graph of all rules, extract a work graph that will build out-of-date files.

(getrules)

(phony target deps & body)

Alias for `task`.

(rule target deps & body)

Add a rule to the rule graph.

(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).

(scaffold-project name &opt options)

Generate a standardized project scaffold.

(abspath path)

Create an absolute path. Does not resolve . and .. (useful for generating entries in install manifest file).

(basename path)

Get the filename of a path without any leading directory components.

(clear-cache)

Clear the global git cache.

(clear-manifest)

Clear the global installation manifest.

(clexe-shell & args)

(color input-color text)

Color text with ascii escape sequences if (os/isatty)

(copy src dest)

Copy a file or directory recursively from one location to another.

(copyfile src dest)

Copy a file one location to another.

(create-dirs dest)

Create all directories needed for a file (mkdir -p).

(devnull)

(dirname path)

Get the directory of a file without the filename.

(do-monkeypatch build-dir)

Modify the existing environment to have the same paths as the test environment.

(drop1-shell std args)

Variant of `shell` to play nice with cl.exe, which outputs some junk to terminal that can't be turned off.

(exec-slurp & args)

Read stdout of subprocess and return it trimmed in a string.

(filepath-replace repo)

Remove special characters from a string or path to make it into a path segment.

(find-build-dir)

Gets the build directory to output files to.

(find-cache)

Return the path to the global cache.

(find-manifest name)

Get the full path of a manifest file given a package name.

(find-manifest-dir)

Get the path to the directory containing manifests for installed packages.

(is-mingw)

Check if built with mingw

(is-win)

Check if we should assume a DOS-like shell or default to posix shell.

(is-win-or-mingw)

Check if built with mingw

split paths on / and \.

(rimraf path)

Hard delete directory tree

(rm path)

Remove a directory and all sub directories.

(run-patched & extra-args)

Run a subprocess Janet repl that has the same environment as the test environment.

(run-repl)

Run a repl in the monkey patched test environment

(run-script path)

Run a local script in the monkey patched environment.

(shell & args)

Do a shell command

(undo-monkeypatch old-builddir)