Locations & Expressions¶
Céu specifies locations and expressions as follows:
Exp ::= NUM  STR  null  true  false
 `(´ Exp `)´
 Exp <binop> Exp
 <unop> Exp
 Exp is Type
 Exp as Type
 Exp as `/´(noholdplainpure)
 `&´ (Nat_Call  Loc)
 `&&´ Loc
 Loc [`?´]
 sizeof `(´ (TypeExp) `)´
 Nat_Call  Code_Call
Loc ::= [`*´`$´] Loc
 Loc { `[´Exp`]´  (`:´`.´) (ID_intID_nat)  `!´ }
 `(´ Loc [as (Type  `/´(noholdplainpure)) `)´
 ID_int
 ID_nat
 outer
 `{´ <code in C> `}´
/* Operator Precedence */
/* lowest priority */
// locations
* $
: . !
as
// expressions
is as // binops
or
and
!= == <= >= < >

^
&
<< >>
+ 
* / %
not +  ~ $$ // unops
/* highest priority */
Primary¶
TODO
Arithmetic¶
Céu supports the arithmetic expressions addition, subtraction, modulo (remainder), multiplication, division, unaryplus, and unaryminus through the operators that follow:
+  % * / + 
Bitwise¶
Céu supports the bitwise expressions not, and, or, xor, leftshift, and rightshift through the operators that follow:
~ &  ^ << >>
Relational¶
Céu supports the relational expressions equalto, notequalto, greaterthan, lessthan, greaterthanorequalto, and lessthanorequalto 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:
 The expression type is a data type:
 The new type is
int
: Evaluates to the type enumeration for the expression type.  The new type is a subtype of the expression static type:
 The expression runtime type is a subtype of the new type: Evaluates to the new type.
 Evaluates to error.
 The new type is a supertype of the expression static type: Always succeeds and evaluates to the new type. See also Dynamic Dispatching.
 Evaluates to error.
 The new type is
 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 `/´(noholdplainpure)
Modifiers may suppress the requirement for resource finalization.
References¶
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 `(´ (TypeExp) `)´
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 outofbounds 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
Constructor¶
Vector constructors are only valid in assignments:
Vec_Cons ::= (Exp  `[´ [LIST(Exp)] `]´) { `..´ (Exp  Lua_Stmts  `[´ [LIST(Exp)] `]´) }
Examples:
vector[3] int v; // declare an empty vector of length 3 (v = [])
v = v .. [8]; // append value '8' to the empty vector (v = [8])
v = v .. [1] .. [5]; // append values '1' and '5' to the vector (v = [8, 1, 5])
Fields¶
The operators .´ and
:´ specify fields of
data abstractions and
native structs:
Dot ::= Loc `.´ (ID_intID_nat)
Colon ::= Loc `:´ (ID_intID_nat)
The expression e:f
is a sugar for (*e).f
.
TODO: ID_nat to avoid clashing with Céu keywords.