JPM

Link object files together to make a static library.

Compile a C file into an object file.

Inline raw byte file as a c file.

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.

Rename a janet symbol for embedding.

Name of symbol that enters static compilation of a module.

Escape special characters in the entry-name

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

Generate strings for adding custom defines to the compiler.

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

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

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

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

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

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

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.

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

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

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

Create a new C project

Create a new project

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.

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.

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

Load a configuration from a table or struct.

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 the default configuration.

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

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

Read environment variables that correspond to config variables into dyns.

Write the current configuration information to a file.

Map some single characters to long options.

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

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.

Get an autodetected config.

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.

Install a bundle from a git repository.

Make a call to curl

Evaluate a given rule in a one-off manner.

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

Download a git bundle from a remote respository

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

Make a call to git.

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

Load packages from a lockfile.

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.

Create an environment that is preloaded with jpm symbols.

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.

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 a jpm file project file. This is different from a normal require in that code is loaded in the jpm environment.

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

Make a call to tar.

Fetch latest tag version from remote repository

Update all previously installed packages to their latest versions.

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

Alias for `add-input`

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

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

Append a thunk to a target's recipe.

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

Alias for `task`.

Add a rule to the rule graph.

Alias for `sh-task`.

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

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

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

Generate a standardized project scaffold.

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

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

Clear the global git cache.

Clear the global installation manifest.

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

Copy a file one location to another.

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

Get the directory of a file without the filename.

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

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

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

Gets the build directory to output files to.

Return the path to the global cache.

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

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

Check if built with mingw

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

Check if built with mingw

split paths on / and \.

Hard delete directory tree

Remove a directory and all sub directories.

Do a shell command