Expressions

Temporary address¶

Expressions work like in C, with one exception: it is possible to take the address of a temporary. This uses the operator && rather than &.

Consequently, this is valid:

fn void test(int* x) { ... }

test(&&1);

// In C:
// int x = 1;
// test(&x);

A pointer created with && is only valid until the end of the current function. In other words, you should never return the pointer created by && from a function as it will never be safe to use.

Well-defined evaluation order¶

Expressions have a well-defined evaluation order:

1. Binary expressions are evaluated from left to right.
2. Assignment occurs right to left, so a = a++ would result in a being unchanged.
3. Call arguments are evaluated in parameter order.

Compound literals¶

C3 has C's compound literals:

struct Foo
{
    int a;
    double b;
}

fn void test1(Foo x) { ... }

...

test1((Foo){ 1, 2.0 });

Arrays follow the same syntax:

fn void test2(int[3] x) { ... }

...

test2((int[3]){ 1, 2, 3 });

Note that when it's possible, inferring the type is allowed and preferred, so we have for the above examples:

test1({ 1, 2.0 });
test2({ 1, 2, 3 });

Passing a slice

fn void test(int[] y) { ... }

// Using &&
test(&&(int[3]){ 1, 2, 3 });

// Explicitly slicing:
test(((int[3]){ 1, 2, 3 })[..]);

// Using a slice directly as a temporary:
test((int[]){ 1, 2, 3 });

// Same as above but with inferred type:
test({ 1, 2, 3 });

Passing the pointer to an array

fn void test1(int[3]* z) { ... }
fn void test2(int* z) { ... }

test1(&&(int[3]){ 1, 2, 3 });
test2(&&(int[3]){ 1, 2, 3 });

Constant expressions¶

In C3 all constant expressions are guaranteed to be calculated at compile time. The following are considered constant expressions:

1. The null literal.
2. Boolean, floating point and integer literals.
3. The result of arithmetics on constant expressions.
4. Compile time variables (prefixed with $)
5. Global constant variables with initializers that are constant expressions.
6. The result of macros that do not generate code and only use constant expressions.
7. The result of a cast if the value is cast to a boolean, floating point or integer type and the value that is converted is a constant expression.
8. String literals.
9. Initializer lists containing constant values.

Some things that are not constant expressions:

1. Any pointer that isn't the null literal, even if it's derived from a constant expression.
2. The result of a cast except for casts of constant expressions to a numeric type.
3. Compound literals - even when values are constant expressions.

Including binary data¶

The $embed(...) function includes the contents of a file into the compilation as a constant array of bytes:

char[*] my_image = $embed("my_image.png");

The result of an embed works similar to a string literal and may implicitly convert to a char*, void*, char[], char[*] or String.

Limiting length¶

It's possible to limit the length of what is included using the optional second parameter.

char[4] my_data = $embed("foo.txt", 4);

Failure to load at compile time and defaults¶

Usually it's a compile time error if the file can't be included, but sometimes it's useful to only optionally include it. If this is desired, declare the left hand side an Optional:

char[]? my_image = $embed("my_image.png");

my_image will be an optional io::FILE_NOT_FOUND~ if the image is missing.

This also allows us to pass a default value using ??:

char[] my_image = $embed("my_image.png") ?? DEFAULT_IMAGE_DATA;