C2Go extensions reference

These names are not one new class of C keyword. <c2go.h> exposes macros and declarations, while Clang supplies attributes, built-ins, pragmas, and predefined macros. The category matters when reading diagnostics or writing a reusable header.

Minimal pattern

Outside an active pragma region, the default world is unmanaged. Defined functions are internal C2Go code; a declaration-only function is a native import unless an explicit extension says otherwise.

#include <c2go.h>

#pragma c2go managed push
struct Node {
    struct Node *next;
    long value;
};
#pragma c2go pop

c2go_extern long node_value(const struct Node *node) {
    return node->value;
}

Bare managed enables the function, pointer, and record managed defaults and is appropriate for most managed regions. The declaration is exported to Go because the function is marked c2go_extern.

World, export, and link attributes

For task-oriented examples, see Export C to Go and Call Go from C.

A declaration-only function is a native import by default; importing an ordinary native function does not require unmanaged extern. Apply unmanaged explicitly when the declaration must be permanently import-only or when function-pointer parameters or returns need host-callback type rules.

Managed allocation and type information

Use c2go_typeinfo(struct Node) rather than constructing a descriptor manually:

struct Node *node = gc_malloc(
    c2go_typeinfo(struct Node),
    sizeof(struct Node)
);

Plain malloc, calloc, realloc, and free remain the unmanaged C allocator API. See GC-aware allocation for ownership rules.

Function-pointer crossings

These forms are not interchangeable with &fn. The raw native address and the callable C2Go wrapper have different calling contracts. See Callbacks.

Pragma regions

Supported forms are:

#pragma c2go managed push  /* Recommended: enable every managed default */
/* declarations */
#pragma c2go pop

#pragma c2go managed(C2GO_PTR | C2GO_RECORD) push  /* Use only for selective control */
/* declarations */
#pragma c2go pop

#pragma c2go unmanaged push
/* declarations */
#pragma c2go pop

Bare managed enables C2GO_FUNC | C2GO_PTR | C2GO_RECORD and is the default choice for ordinary use. Use managed(N) only when one of those behaviors must be disabled. It accepts integers or macros combined with parentheses and bitwise OR (|). Macros are expanded before the mask is evaluated, and the final value must be in the range 0..7. Other expression operators such as + and - are intentionally unsupported.

For example, managed(C2GO_PTR | C2GO_RECORD) leaves the function bit disabled, so declaration-only functions in that region remain native imports. unmanaged push is equivalent to a zero mask. Regions nest, and each pop unwinds one level.

Selector constants

Go boundary types

These are ABI representations, not an implementation of Go language operations in C. Dynamic interface dispatch is not available; bind a named Go wrapper. See Boundary data types.

Predefined mode macros

__C2GO__ and __clang_c2go__ are defined while compiling in C2Go mode. Use them only for small compatibility branches:

#if defined(__C2GO__)
#  include <c2go.h>
#endif

Do not infer target support from a mode macro. The release matrix and hard boundaries live in Platforms and current limitations.