# Locations & Expressions¶

Céu specifies locations and expressions as follows:

``````Exp ::= NUM | STR | null | true | false | on | off | yes | no
|  `(´ Exp `)´
|  Exp <binop> Exp
|  <unop> Exp
|  Exp (`:´|`.´) (ID_int|ID_nat)
|  Exp (`?´|`!´)
|  Exp `[´ Exp `]´
|  Exp `(´ [ LIST(Exp) ] `)´
|  Exp is Type
|  Exp as Type
|  Exp as `/´(nohold|plain|pure)
|  sizeof `(´ (Type|Exp) `)´
|  Nat_Call | Code_Call
|  ID_int
|  ID_nat
|  outer

/* Locations */

Loc ::= Loc [as (Type | `/´(nohold|plain|pure)) `)´
|  [`*´|`\$´] Loc
|  Loc { `[´Exp`]´ | (`:´|`.´) (ID_int|ID_nat) | `!´ }
|  ID_int
|  ID_nat
|  outer
|  `{´ <code in C> `}´
|  `(´ Loc `)´

/* Operator Precedence */

/* lowest priority */

// locations
*     \$
:     .     !     []
as

// expressions
is    as                                            // binops
or
and
!=    ==    <=    >=    <     >
|
^
&
<<    >>
+     -
*     /     %
not   +     -     ~     \$\$    \$     *     &&    &   // unops
:     .     !     ?     ()    []

/* highest priority */
``````

`TODO`

`TODO`

## Arithmetic¶

Céu supports the arithmetic expressions addition, subtraction, modulo (remainder), multiplication, division, unary-plus, and unary-minus through the operators that follow:

``````    +      -      %      *      /      +      -
``````

## Bitwise¶

Céu supports the bitwise expressions not, and, or, xor, left-shift, and right-shift through the operators that follow:

``````    ~      &      |      ^      <<      >>
``````

## Relational¶

Céu supports the relational expressions equal-to, not-equal-to, greater-than, less-than, greater-than-or-equal-to, and less-than-or-equal-to through the operators that follow:

``````    ==      !=      >      <      >=      <=
``````

Relational expressions evaluate to true or false.

## Logical¶

Céu supports the logical expressions not, and, and or through the operators that follow:

``````    not      and      or
``````

Logical expressions evaluate to true or false.

## Types¶

Céu supports type checks and casts:

``````Check ::= Exp is Type
Cast  ::= Exp as Type
``````

### Type Check¶

A type check evaluates to true or false depending on whether the runtime type of the expression is a subtype of the checked type or not.

The static type of the expression must be a supertype of the checked type.

Example:

``````data Aa;
data Aa.Bb;
var Aa a = <...>;       // "a" is of static type "Aa"
<...>
if a is Aa.Bb then      // is the runtime type of "a" a subtype of "Aa.Bb"?
<...>
end
``````

### Type Cast¶

A type cast converts the type of an expression into a new type as follows:

1. The expression type is a data type:
1. The new type is `int`: Evaluates to the type enumeration for the expression type.
2. The new type is a subtype of the expression static type:
1. The expression runtime type is a subtype of the new type: Evaluates to the new type.
2. Evaluates to error.
3. The new type is a supertype of the expression static type: Always succeeds and evaluates to the new type. See also Dynamic Dispatching.
4. Evaluates to error.
2. Evaluates to the new type (i.e., a weak typecast, as in C).

Examples:

``````var Direction dir = <...>;
_printf("dir = %d\n", dir as int);

var Aa a = <...>;
_printf("a.v = %d\n", (a as Aa.Bb).v);

var Media.Video vid = <...>;
await/dynamic Play(&m as Media);

var bool b = <...>;
_printf("b= %d\n", b as int);
``````

## Modifiers¶

Expressions that evaluate to native types can be modified as follows:

``````Mod ::= Exp as `/´(nohold|plain|pure)
``````

Modifiers may suppress the requirement for resource finalization.

Céu supports aliases and pointers as references.

### Aliases¶

An alias is acquired by prefixing a native call or a location with the operator `&`:

``````Alias ::= `&´ (Nat_Call | Loc)
``````

See also the unwrap operator `!` for option variable aliases.

### Pointers¶

The operator `&&` returns the address of a location, while the operator `*` dereferences a pointer:

``````Addr  ::= `&&´ Loc
Deref ::= `*´ Loc
``````

## Option¶

The operator `?` checks if the location of an option type is set, while the operator `!` unwraps the location, raising an error if it is unset:

``````Check  ::= Loc `?´
Unwrap ::= Loc `!´
``````

## Sizeof¶

A `sizeof` expression returns the size of a type or expression, in bytes:

``````Sizeof ::= sizeof `(´ (Type|Exp) `)´
``````

## Calls¶

See Native Call and Code Invocation.

## Vectors¶

### Index¶

Céu uses square brackets to index vectors:

``````Vec_Idx ::= Loc `[´ Exp `]´
``````

The index expression must be of type `usize`.

Vectors start at index zero. Céu generates an error for out-of-bounds vector accesses.

### Length¶

The operator `\$` returns the current length of a vector, while the operator `\$\$` returns the max length:

``````Vec_Len ::= `\$´  Loc
Vec_Max ::= `\$\$´ Loc
``````

`TODO: max`

The vector length can also be assigned:

``````var[] int vec = [ 1, 2, 3 ];
\$vec = 1;
``````

The new length must be smaller or equal to the current length, otherwise the assignment raises a runtime error. The space for dynamic vectors shrinks automatically.

### Constructor¶

Vector constructors are only valid in assignments:

``````Vec_Cons   ::= (Loc | Exp) Vec_Concat { Vec_Concat }
|  `[´ [LIST(Exp)] `]´ { Vec_Concat }
Vec_Concat ::= `..´ (Exp | Lua_Stmts | `[´ [LIST(Exp)] `]´)
``````

Examples:

``````var int v;        // declare an empty vector of length 3     (v = [])
v = v .. ;        // append value '8' to the empty vector    (v = )
v = v ..  .. ; // append values '1' and '5' to the vector (v = [8, 1, 5])
``````

## Fields¶

The operators `.` and `:` access public fields of data abstractions, code abstractions, and native structs:

``````Dot   ::= Loc `.´ (ID_int|ID_nat)
Colon ::= Loc `:´ (ID_int|ID_nat)
``````

The expression `e:f` is a sugar for `(*e).f`.

`TODO: ID_nat to avoid clashing with Céu keywords.`