Примеры

{   v_import("level-00/voidc_target.void");
    v_import("level-00/voidc_types.void");

    v_import("llvm-c/Core.void");

    v_import("printf.void");
}

{   llvm_ctx = v_target_get_voidc_llvm_ctx();
    module = LLVMModuleCreateWithNameInContext("hello_mod", llvm_ctx);

    builder = v_target_get_voidc_builder();

    hello_ft  = v_function_type(void, 0, 0, false);
    hello_ft_ = v_type_get_llvm_type(hello_ft);
    hello_f   = LLVMAddFunction(module, "hello", hello_ft_);

    entry = LLVMAppendBasicBlockInContext(llvm_ctx, hello_f, "entry");

    LLVMPositionBuilderAtEnd(builder, entry);


    typ_ = v_alloca(LLVMTypeRef);

    char_     = v_type_get_llvm_type(char);
    char_ptr_ = LLVMPointerType(char_, 0);

    v_store(char_ptr_, typ_);

    int_ = v_type_get_llvm_type(int);

    printf_ft_ = LLVMFunctionType(int_, typ_, 1, true);
    printf_f   = LLVMAddFunction(module, "printf", printf_ft_);

    str = LLVMBuildGlobalStringPtr(builder, "Hello world!\n", "str");

    arg = v_alloca(LLVMValueRef);

    v_store(str, arg);

    LLVMBuildCall2(builder, printf_ft_, printf_f, arg, 1, "");


    LLVMBuildRetVoid(builder);

    LLVMClearInsertionPosition(builder);

    //-----------------------------------------------------------------
    voidc_prepare_module_for_jit(module);

    //-----------------------------------------------------------------
    msg = LLVMPrintModuleToString(module);

    printf("\n%s\n", msg);

    LLVMDisposeMessage(msg);

    //-----------------------------------------------------------------
    voidc_add_module_to_jit(module);

//  LLVMDisposeModule(module);


    //-----------------------------------------------------------------
    v_add_symbol("hello", hello_ft, 0);
}

{   hello();
}

{ v_import("mainline.void"); }
{ v_enable_mainline(); }
{
    v_import("llvm-c/Core.void");

    v_import("cstdio.void");
}

//---------------------------------------------------------------------
#define iterate: (stmt, n)
{'stmt_list'

    #define doit: (l, r)
    {'stmt'

        #if (l < r-1)

            #define some: (m)
            {'stmt_list'

                doit(l, m);
                doit(m, r);

            'stmt_list'}

            some((l+r)/2);

        #else

            stmt(l);

        #endif

    'stmt'}

    #assert (0 < n)

    doit(0, n);

'stmt_list'}


//---------------------------------------------------------------------
//{   #define stmt: (i)  =  printf("%d\n", i);
//
//    iterate(stmt, 99);
//}


//---------------------------------------------------------------------
print_value_intrinsic: (*void, vis: *voidc_visitor_t, self: *v_ast_base_t) ~> void
{
    args = v_ast_expr_call_get_arg_list((self: *v_ast_expr_t));
    arg0 = v_list_get_item(args, 0);

    v_push_result();

    v_ast_accept_visitor(arg0, vis);

    val = v_get_result_value();

    str = LLVMPrintValueToString(val);
    defer LLVMDisposeMessage(str);

    expr: &v_ast_expr_t := {};

    v_ast_make_expr_string(&expr, str);

    v_pop_result();

    v_ast_accept_visitor(&expr, vis);
}

{   v_add_intrinsic("print_value", print_value_intrinsic, 0);
}


//---------------------------------------------------------------------
{   w = 2;

    v: uint(w)[2] = { 1, 0 };         //- Sic!

    #define stmt: (i)
    {'stmt_list'

        printf("i: %d; v: %s\n", i, print_value(v[1]));

        vv = v[0] + v[1];

        #if ((vv: int(w)) < 0)

            w = w + 1;

        #endif

        v: uint(w)[2] = { v[1], vv };

    'stmt_list'}

    n = 999;

    iterate(stmt, n);

    printf("n: %d; v: %s\n", n, print_value(v[1]));
}