Variables
Variable definitions in C2 look a lot like variable definitions in C (on purpose):
i32 counter = 0;
public bool hasBool = false;
Point* p = nil;
The public keyword may only be used with global variables.
Multiple variable declarations
Like in C, C2 allows multiple variables to be declared in one line:
i32 a, b, c;
However, to avoid the C pitfall of
int* a, b;
where b would be an 'int' and not an 'int*', defining multiple variables is not allowed for pointer and array types.
The static keyword
The static keyword has the same meaning as the static keyword in C when used on local (as in non-global) variables in C; their lifetime is bigger then that of the function. For example calling the function below 3 times:
fn void increment() {
static i32 counter = 0;
counter++;
printf("%d\n", counter);
}
will result in:
1
2
3
The static keyword may only be used on non-global variables. The 'static' variable is automatically zero-initialized (like global variables). If explicitly initialized, the init expression must be a compile-time constant/value.
The tlocal keyword
The tlocal keyword is usede to indicate a variable has thread local storage.
Initialization
C2 has some convenient variable initialization syntax:
type Data struct {
i32 a;
char* text;
f32 f;
}
Data[] mydata = {
{ 1, "first", 1.11 },
{ 2, "second", 2.22 },
{ 3, "third", 3.33 },
}
In C2, all global variables are automatically initialized with a default value if no explicit initialization is done.
The examples below show some C2 initialization options.
Array index designators
i32[] array = {
[10] = 0,
[11] = 3,
}
// mixing index designators with default (incremental) initialization
i32[4] array2 = {
0,
[3] = 3,
4, // error: access elements in array initializer
}
// using enum constant as index designator value
type E enum i8 {
FOO = 2,
BAR = 5,
}
i32[] array = {
[E.BAR] = 5,
0, // index 6
[E.FOO] = 2
3, // index 3
4,
5, // error: duplicate initialization of array index
}
// using non-compile-time constant as index value is not allowed
i32 a = 1;
const i32 b = 2;
i32 array2 = {
[a] = 1, // error: initializer element is not a compile-time constant
[b] = 2,
}
Field designators
Field designators initialize struct members by name.
// basic struct fields
type Point struct {
i32 x;
const u8* name;
}
Point[] array = {
{ 1, "one" }, // basic struct initialization
{ .x = 3, .name = "three" }, // using field designators
{ 4, .name = "four" }, // error: mixing field designator with non-field designators
}
Rules:
-
Array and Field designators may not be combined to initialize members of a single struct
-
Sub-structs may use different initializers from their parent struct
-
Union can only be initialized using Field-designators
Incrementally declared arrays
Incrementally declared arrays are a special feature in C2. These can be used to avoid messy macros when it is required to have some elements of the array present depending on some external condition (#ifdef'ed).
To incrementally declare array, use the [+] array subscript in the initial declaration. Entries can then be added from
different points in the code.
type Point struct {
i32 x;
i32 y;
}
Point[+] points;
points += { 10, 11 }
// ... other code
points += { 20, 22 }
// ... other code
points += { 30, 31 }
Note that incrementally defined arrays can only be used at the global level (not inside functions), as their length must be known at compile time.