• TL;DR
• The project idea
• Getting started
• Installing
• Testing and examples
• Contributing
• Questions & answers
• Notes on the project
• Ressources
• Version 2.0 Forecast
• License

A compiler frontend and backend library that allows the evaluation, analysis and compilation of programs, through an abstract stack-based virtual machine whose intermediate representation follows the concatenative paradigm; optimized for implicit data vectorization, big numbers and recursive passage styles.

The library provides compilation help features adapted to all types of languages and paradigms.

The Runtime Core Library, abbreviated RCL, is a high-level program compilation, evaluation and diagnostic library.

The library provides everything you need to adapt the compilation to your language constructs and also gives access to a wide range of prefabricated compilation help modules, including full support for imperative paradigm, functional paradigm, object paradigm, logical paradigm, and expression evaluation methods: strict, lazy, and perhaps optimistic (to plan).

The execution machine is based on an abstract and high-level stack-based IR language following the concatenative paradigm. The means of evaluation are interpretation, JIT and AOT compilation. Code generation (to compile into an executable / JIT) is fully optimized for recursion, parallelism (SMID), asynchronous execution, very large numbers computation, memory management, as well as the size of the resulting file.

The goal of the RCL is to provide a way to compile, evaluate and diagnose, all in one, high level, theoretical IR from an abstract VM.

The project is not sufficiently developed to be available from a package manager. In the meantime, you can build it from the makefile, which has been written in such a way as to accompany you as best as possible.

The dependencies of external dynamic libraries are:

• libffi (used for FFI with C)
• gmp (used for large number arithmetic)

The programs needed to build the project:

• Makefile
• GCC

At the moment, with make:

cd RCL/
make LIB & make DLL & make VM & make clean

Will build the VM as executable one, the library as dynamic linking one and as static linking one.

load 3
load 7
add
load 2
mul
load 10
div

.define
    // An optimized factorial function (with recursion)
    fac_acc =
        dup 1 swap lw quote
            [pop]
            [dup flip * swap -- fac_acc]
        ifte ;
    fac = 1 swap fac_acc ;

.main
    817 x\
    "The factorial of x = " puts
    x fac nvshow puts

#include <RCL\Library\rclib.h>

int main(int argc, char *argv[])
{
    // Calling the 'Hello, world!' function
    rcl_hello_world();
    return EXIT_SUCCESS;
}

#include <RCL\Library\rclib.h>
#include <RCL\Library\Primitive\Expression.h>

int main(int argc, char *argv[])
{
    rcl_expr_t cst_n1 = rcl_expr_cst_int(4);
    rcl_expr_t cst_n2 = rcl_expr_cst_int(8);
    rcl_expr_t my_exp = rcl_expr_add(cst_n1, cst_n2);

    printf("Input: 4 + 8\n");
    printf("RCL display: %s\n", rcl_show_ir_expr(my_exp));
    
    struct IResult res = rcl_evali_expr(my_exp);

    printf("Resulting: %d\n", res.main_returned);
    
    return EXIT_SUCCESS;
}

#include <RCL\Library\rclib.h>
#include <RCL\Library\Primitive\Expression.h>

int main(int argc, char *argv[])
{
    rcl_expr_t my_exp =
        rcl_expr__mul(
            rcl_expr__var("4"),
            rcl_expr__add(
                rcl_expr__cst_int(3),
                rcl_expr__div(
                    rcl_expr__var("6"),
                    rcl_expr__cst_int(2))));

    printf("Input: 4 * (3 + (6 / 2))\n");
    printf("RCL display: %s\n", rcl_show_ir_expr(my_exp));
    
    struct IResult res = rcl_evali_expr(my_exp);

    printf("Resulting: %d\n", res.main_returned);
    
    return EXIT_SUCCESS;
}

If you have constructive questions, suggestions for improvements or features to be added, bug or performance reports, then check if a report has not already been raised in issues, in which case it has probably already been processed or is being maintained, otherwise feel free to do so and/or actively participate in the project by forking it. Amendments will be made if they are relevant.

A list of anticipated questions that I think are legitimate, for those interested in the project...

Inventory of links to interesting resources on the subject of compilation, intermediate representations and optimizations.

The current version is a prototype under construction which aims to be really usable (I'd like in any case 😛). This version is therefore relatively rigid to extensions and customizations as well as limited in terms of code generation backend or optimizations.

The RCL 2.0 version should build on this prototype in order to extend its capabilities to allow you to broaden your quality and personality for compiling and evaluation.

Indeed, version 2.0 provides a very modular and customizable as well as very easily usable and exportable way to extend the RCL's functionalities. Here are the key features that this version will try to achieve:

• Customization of optimization runs ;
• Definition of compilation options ;
• Definition of new compilation and JIT backends ;
• Definition of customized optimizations on IR ;
• Definition of customized optimizations on the backend.

The configurations would be done through the analysis of a Json file.

This project is licensed under the Apache 2.0 License. See the license file.