kite

A package that helps to build C extensions for Blade as well as other C/C++ applications from a Blade script/project. Kite does not replace a build system, but rather sets up a build system for you and leverage them accordingly.

Package Information

• Name: git
• Version: 1.0.0
• Homepage: https://github.com/blade-lang/kite
• Tags: build, gcc, cmake, compiler, build-system, extension, c, package, library.
• Author: Richard Ore eqliqandfriends@gmail.com
• License: ISC

Installation

Kite can be installed via Nyssa using the following command:

nyssa install -g kite

It is recommended to install kite globally! This way you get the kite CLI too that allows you to easily develop C extensions/applications

During kite installation, it will attempt to locate build tools installed on the current machine and attempt to download/install any missing required build tool. If a package does exists, kite will continue to use the existing tool with the exception of cmake.

Kite requires the following build tools (it will download/install any missing):

• Make
• CMake
• C/C++ Compiler toolchain

Kite will always download its own copy of cmake and will not use an existing copy. This is to allow for a consistent cmake version across same versions of kite installation.

Usage

The simplest way to use kite is to use it as an auto builder. To do this you must first,

1. Create a kite.json file at the root of the project you want to build
2. Add your kite configuration to the file.

After the above steps, you have two ways of building the project. Firstly, via the CLI if you've installed Kite globally as recommended.

Simply run the command kite from the root of the application.

If you have installed kite locally, you can build your project by running the following from a script of the Blade REPL.

import kite

var artefact = kite.build('/path/to/my/project/')
echo 'Artefact: ${artefact}'

Kite Configuration

The kite.json file can contain the following configuration:

Only the name of a project is required configuration. All others are optional. Here is an example of a valid kite.json file.

{
  "name": "bpdf",
  "root": "./c-sources",
  "standard": 99,
  "files": [
    "some/random/file.c"
  ],
  "flags": [
    "-Wno-error"
  ],
  "include_dirs": [
    "./my_subdirectory"
  ]
}

API Documentation

Kite can be used as a CLI as well as a library from other applications. Kite exports the following functions for use from other modules that imports it.

• build(path):

  Automatically build a kite project based on the given configuration file in the path.

  • @params string path: The path to the kite project directory
  • @returns string: Path to the output file.

• build_lib(name [, configuration]):

  Builds a shared library with the given name and kite configuration and returns the path to the generated artefact.

  • @params string name: The name of the executable
  • @params dictionary configuration: A dictionary passing build configuration to the compiler (Optional)
  • @returns string: Path to the executable file.

• build_static_lib(name, configuration):

  Same as build_lib(), but builds a static library instead.

  • @params string name: The name of the executable.
  • @params dictionary configuration: A dictionary passing build configuration to the compiler (Optional)
  • @returns string: Path to the executable file.

• build_exe(name [, configuration]):

  Same as build_lib(), but builds an executable instead.

  • @params string name: The name of the executable.
  • @params dictionary configuration: A dictionary passing build configuration to the compiler (Optional)
  • @returns string: Path to the executable file.

• tools():

  Returns a dictionary that contains information about the build tools used by kite.

  • @returns dictionary

Limitations

Because kite leverages CMake as its build tool, Kite is currently limited to only what can be acheived through CMake and is subject to any bugs that may exist or not in CMake.