XVM is a virtual machine with its own interpreted language for the XELIS network developed in Rust. It supports constants, functions, while/foreach loops, arrays and structures. The syntax is strongly inspired by Rust and Golang.
All the verifications are mainly made at the level of the Parser to check the conformity of the code to be interpreted.
The different primitive types are:
u8
(unsigned 8 bits)u16
(unsigned 16 bits)u32
(unsigned 32 bits)u64
(unsigned 64 bits)u128
(unsigned 128 bits)bool
string
struct
optional<T>
where T is another type (it allow the value to be nullable)File extension is .xel
the semicolon is optional, thus can be added if desired without any difference in the code.
Recursive functions are allowed, but limited to a configurable depth.
A environment system is completely customizable to set your own native functions. This helps to manage exactly what a program can interact with. Custom structs are also available.
An error will be returned by the interpreter if an overflow is detected without causing a panic.
Rules
0
._
(underscore) for a better readability.u64
will be the default.Examples
let my_byte: u8 = 10
let my_u16: u16 = 70
let my_u32: u32 = 999
let my_int: u64 = 25655
let my_u128: u128 = 100_000_000L
for constant variable, it must be declared outside a function, with const
keyword.
Rules
let
or const
keyword.null
is set by default.Examples
const hello: string = "hello"
...
let world: string = "world"
Values of built-in types can be casted into other built-in types easily using the keyword as
.
Rules
Examples
let id: u128 = 1337
let b: u8 = id as u8
let id_str: string = id as string
Instead of having one file with all your code, you can have multiple files that will be compiled into one final program.
Rules
.xel
if its a local importExamples
math
namespace
import "math.xel" as math;
...
math.sum(a, b)
no namespace:
sum(a, b)
entry
function is a "public callable" function and must return a u64
value.
Rules
func
or entry
keyword.Examples
entry foo() { ... }
func foo() { ... }
func foo(): u64 { ... }
func foo(a: u64, b: u64) { ... }
func (f Foo) bar() { ... }
A structure can contain other structures.
Rules
Examples
struct MyStruct {
message: string,
value: u64
}
Rules
bool
condition is required.Examples
let score: u64 = is_winner() ? 20 : 0
Rules
bool
condition is required after it.Examples
let negative: bool = !condition
Rules
Examples
let array: u64[] = [10, 20, 30, 40]
...
let dim: u64[][] = [[34, 17], [8, 14], [0, 69]]
Rules
bool
condition.Examples
if condition {
...
}
if (i > 20 && i != 25) || i == 0 {
...
}
Rules
if
condition.Examples
else {
...
}
Rules
if
or an else if
condition.Examples
else if condition {
...
}
else if my_struct != null {
...
}
Rules
Examples
while condition {
...
}
Rules
Examples
foreach val in values {
...
}
Rules
Examples
for i: u64 = 0; i < 10; i += 1 {
...
}
Rules
foreach
, for
, while
).Examples
while condition {
if i % 10 == 0 {
break;
}
...
}
Rules
foreach
, for
, while
).Examples
while condition {
if i % 10 == 0 {
continue;
}
...
}
Rules
Examples
func foo(): string {
return "Hello World!"
}
func bar() {
if condition {
return
}
foo()
}
Allows you to isolate a part of the code / variables created.
Rules
Examples
{
...
}