An Easy and Modern Build System For C/C++ With Readable Syntax.
Yogurt 48fa6ebe8d WORK AKREADY | 2 gadi atpakaļ | |
---|---|---|
.vscode | 2 gadi atpakaļ | |
cate | 2 gadi atpakaļ | |
examples | 2 gadi atpakaļ | |
externals | 2 gadi atpakaļ | |
include | 2 gadi atpakaļ | |
src | 2 gadi atpakaļ | |
.catel | 2 gadi atpakaļ | |
.gitignore | 2 gadi atpakaļ | |
LICENSE.txt | 2 gadi atpakaļ | |
build.sh | 2 gadi atpakaļ | |
build_release.sh | 2 gadi atpakaļ | |
cate_carbon_example | 2 gadi atpakaļ | |
cate_example.png | 2 gadi atpakaļ | |
flex_setup.md | 2 gadi atpakaļ | |
makefile | 2 gadi atpakaļ | |
readme.md | 2 gadi atpakaļ |
Cate is a simple and fast build system for C/C++, its syntax is much simpler than the other build systems. While Cate is slower than Make, it's is much easier to set up and create projects and libraries with.
Cate does not have a Windows release as of yet because of our laziness
Unlike CMake and other build systems, Cate does not require Make and is not Turing complete. Cate is more like a wrapper state-machine for GCC/clang than an object oriented build system (unlike CMake), or a build system programming language (also unlike CMake).
Cate is not written in Rust and never will be; Cate has 0 memory leaks thanks to a practice known as "knowing how memory works".
Do note:
\"
characters in string literals, nor string splitting.If you're still here; that means you suffered enough CMake to reconsider your life choices, Thank you for choosing Cate!
Run the following commands:
wget https://github.com/TheMilkies/Cate/releases/download/v2.2/cate_2.2-0_amd64.deb
sudo dpkg -i cate_2.2-0_amd64.deb
rm cate_2.2-0_amd64.deb
Run the following commands:
mkdir catering
cd catering
wget https://github.com/TheMilkies/Cate/releases/download/v2.2/linux_cate_v2.2.0.zip
unzip linux_cate_v2.2.0.zip
sudo ./install.sh
cd ..
rm -rf catering
Make sure you have these installed:
g++
or clang++
)Run ./build.sh
, It'll ask you if you'd like to install at the end.
Run cate
, Unlike Make; It'll automatically detect the thread count.
Use sudo cate install
to install
Run make -jN
where N is your thread count, you don't want it to build single-threaded.
Use sudo make install
to install
Cate's CLI is intuitive, but doesn't offer much. You can not set cflags
with a command (unlike Autotools), but you get the minimum required to work with Cate.
-tN
: Set thread count to N. Cate automatically detects thread count so this isn't required.-l
: Lists Catefiles in Catefiles directory (set by Catel).-D
: Disable all user-defined system()
calls in script.-f
: Forcefully rebuild project, by deleting its object files-v
: Shows the installed Cate version.-h
: Shows help and Cate version.Create the following structure
cate/
|_ build.cate
include/
src/
|_ main.c
Or use the following commands
mkdir cate include src
touch cate/build.cate src/main.c
(We are working on a tool called "cater" which will do this and more automatically)
You've come this far! Good Job!
Cate breaks most known build system conventions by forcing you to use multiple files for different targets and having a file extension (unlike CMake, Make, Autotools, and many more). For a debug build; you'll have a debug.cate
. For a cross-platform build; you'll have a platformname.cate
.
Cate uses C-like syntax with the exception of it being a "state-machine" rather than a language. It does not support int literals (0123456789) as of yet (and hopefully forever).
Cate does not support a.property = b.property;
syntax
There are only two class types, Project
and Library
.
Example project
Project project;
project.files = {"src/main.c"};
project.includes = {"include"};
project.libs = {/*add libraries here*/};
project.flags = "-O2";
project.out = "project";
project.build();
Libraries require a parameter called LibraryType
which can be either static
or dynamic
Example library (not in example project)
Library library(static)
library.files = {"src/main.c"};
library.includes = {"include"};
library.libs = {/*add libraries here*/};
library.flags = "-O2";
library.out = "out/liblibrary.a";
library.build();
Both classes have these properties, even if they don't make sense for the class
Array<String> files
: Files of the project/library. No default.Array<String> incs|includes|include_paths
: Include paths of the project/library. No default.
String out
: The output file name. Defaults to identifier.
String compiler
: The compiler to use. Default is cc
.
String obj_dir|object_dir|build_dir|build_directory
: The folder it'd store object files in.
String flags
: The cflags of the project/library, All object files are compiled with them. Default is empty.
String final_flags
: The cflags ran at the end (linking step) of the project/library's compilation. Default is empty.
bool link
: Whether to run the linking step or not. Default is true
.
bool threading
: Whether to add -pthread
to build command. Default is false
.
bool smol|smolize
: Whether to attempt to reduce output-file's size with minimal to no performance loss. Default is false
.
LibraryType type
: Type of library, static
or dynamic
. Gets from library "constructor".
void build()
: Builds project/library.void clean()
: Deletes project/library's build directory.Array<String> recursive(String path)
: Get all files in path ending with an extension. Example: project.files = recursive("src/*.c");
void system(String command)
: Run command. Would be skipped if user runs Cate with the -D
flag.A Catel file (.catel
) is a dumb file made to point cate at the right directory, and use a default file.
Here's an example Catel file:
def smol.cate
dir cate