index<--

EVE Syntax

Bookmarks

In this article you will learn about:

• elements
• punctuation
• comments
• identifiers
• globals
• expressions
• statements
• keywords
• delimiters
• operators

Hello World

#hello world
driver hello:
import 
    con := $lib.console;
process
    con.print ("Hello World!");
return;

Syntax Elements

# Progra example written in EVE
+-----------------------------------------
| a driver can receive parameters        |
+----------------------------------------+
driver syntax_elements(Integer p1, p2):

** start declaration region
globals
    Integer @v1, @v2;

** use a system library
import
    con := $lib.console;
   
** define two driver functions
functions
    Integer add(Integer p1, p2) => (p1+p2);
    Integer sub(Integer p1, p2) => (p1-p2);
    
** define executable region    
process
    con.print ("param1:#p1, #p2");
    @v1 := add(p1, p2);
    @v2 := sub(p1, p2);
    con.print ("result: @v1");
    con.print ("result: @v2");
return;

Punctuation:

Comments

• Hash sign "#" is used for single-line header comment,
• Single line comment is using two stars: "**";
• End of line comments are using two spashes : "//"
• Expression comments are using C notation: "/* ... */"
• Block comments are using Bee like notation: "+- ... -+"

Examples:

# comments in EVE language
+-------------------------------
|  New style boxed comments    |
+------------------------------+
driver comment_demo:

global Integer a = 0;

*******************************
** old style boxed comments  **
*******************************
process
    ** Next we use expression comments:    
    a := a + 1 /* *(a - 1) */ -1;
    
    /* expression comments are similar to C++
       comments. we use expression comments
       for commenting out code for debug */
       
return; // end of line comment

Notes:

• Outline comments /*...*/ are supported inside expressions;
• A statement can continue after end of line comment;
• After module. you can add comments on many lines;

Identifiers

The name of identifiers in EVE can have a length of 30 characters. A name starts with lowercase letters (a..z) or capital letters (A..Z) followed by one or more characters or numbers. No special characters or spaces are permitted in the name except underscore ("_"). An identifier can contain underscore and can start with underscore but it can not end with underscore and can not use two consecutive underscores.

These are valid identifiers

x, y, z
a1,a2,a3
thisIsOK
this_is_ok
_this_is_valid

These are invalid identifiers

1st
not_valid_
_not_valid_

Identifier Sigil

A sigil is a special character prefix that is used to define an identifier. We use sigil to improve code readability but also to add extra functionality to specific identifiers that are not regular. EVE is using following sigils to define special kind of variables or identifiers:

Default variables

Notes:

• Prefix is reducing collision between local and global name scope;
• In other languages this kind of prefix is called sigil;
• A system constant is usually represented by a basic type not objects;
• A system variables can be an object with attributes or a base type.

Globals

In EVE you can define global variables. These are primitive values or references to objects. A global variable is represented by an identifier, and is pair-up with a data type that must pe specified before the identifier name, like in Java.

Global variables can have an initial value that is establish using initial value operator "=" and then can be modified during the program execution using modifiers like: { :=, ::, +=, -= ... } in assignment statements.

Patterns:

A syntax pattern is a pseudo-code example, not a valid EVE program. We use EVE patterns in this document to explain the syntax, but then we also create one or more examples.

# design pattern

** define a type using definition symbol ":"
type Type_name: super_type {parameters};

** establish several variables
globals
    ** use type to define a variable without initialization
    Type_name @var_name;
    
    ** declare variable with specific value and type
    Type_name @var_name = value;

    ** define multiple variables with same initial value 
    Type_name @var_name1 = @var_name2 ...= value;
    
    ** multiple variables with diverse initial values
    Type_name @var_name1 =value1, @var_name2 = value2;

Examples:

Usually the exemples are complette programs but sometimes just a fragment. Most of the examples that can be executed are stored also in GitHub document. However it is possible the one in GitHub to be a bit different then the one in documentation.

** define global variables
globals
    ** two integer variables
    Integer @a = 0;
    Integer @b = 0;
    
    ** one double variable
    Double @d = 0.5;
    
    ** multiple Double numbers
    Double @x, @y, @z; 

Initial Value

The initial value can be establish using the initializer that is "=". This symbol can use only literals and no expressions. It is not able to execute the right operator. That is the initial value can be a constant literal. When used in this way the right side literal value must match the type of the declaration.

Zero Value

When a variable is specified, and the initializer "=" is missing the variable takes default zero value. This value is different for each data type. For example zero value for Integers = 0 for Double = 0.0 and for String = "" (empty string). Compozite data types are initialized to "empty", that is a reserved value equivalent to "∅" used in set theory.

Cascade Initialization

Operator "=" is used to create an expression. That means you can initialize multiple variables using a single declaration. This is different than assignment ":=" or clone "::" that create a statement and not an expression.

# define global variables
globals
    ** two integer numbers
    Integer a = b = 0;
    Double  x = y = z = 0.5;

Expressions

An expression is a syntax element that can be evaluated using mathematical rules and principles. Expressions are created using identifiers, operators, functions and constant literals.

• can be combined to create more complex expressions;
• have a type that is calculated using type inference;
• can be assigned to variables using ":=" or "?" operators;
• can be printed to console using "print" or "write" methods;
• can use round parenthesis () to establish order of operations;

Examples

** simple expressions in print statement
driver expression_demo:

import console.(*)

process:
    print 10;
    write "this is a test";
    ** complex expressions can use ()
    print (10 + 10 + 15); // numeric expression
    print (10 > 5) or (2 < 3); // logical expression
    ** list of expressions are enclosed in ()
    print (1, 2, 3); // expect: 1 2 3
    print (10, 11, 12); // expect: 10 11 12
    ** using write to: avoid new line and print
    write (1,2);
    write (3,4);
    ** now create a new line and output the text
    print; // 1234
return;    

Notes:

• print statement can receive multiple arguments in parenthesis ()
• print statement will add new line by default,
• print statement will separate different values using one space
• write statement will output to console and do not add new line
• write statement also separate values by using one space

Assign Expression

To assign result of an expression to a variable you can use assign operator: ":=". This operator has a strange behavior that you must understand to avoid unintended side-effects. When a single variable is used as an expression, the operator transfer a value "by sharing" a reference, so it does not "copy" the value but the reference to that value.

by reference:

#pseudo-code fragment
identifier := variable_name; // share a reference to global
identifier := function_name; // share a reference to function
identifier := literal; // mutate value / initialize
identifier := expression; // mutate value / initialize
identifier := function_name(); // mutate value / reset value

by value:

To make a clone/copy of an object value you must use clone operator that is (::) instead of (:=). This will transfer a value not a reference. After clonning, we can modify one value without affecting the other.

Syntax:

// making a clone 
variable_name :: reference_name; 

Ternary expression

A ternary operator is the "if" keyword. This keyword has actually two roles in EVE. It can be used to create a conditional statement or an expression. It can be used to return a value or other depending on one or several logical expressions.

Syntax:

variable_name := (value1 if condition else value2); 
variable_name := (value1 if condition1 else value 2 if condition2 else value3); 

Example:

global test = True;
...
expect(True if test else False); // will pass
...

Statements

One statement can be declarative or imperative.

• A statement is usually a single line of code
• A statement can extend on several lines and finalize with ";"
• A group of several statements is called a code block,
• A block is finalized with "end" + starting keyword then ";"

Single line statement

The most simple statements are definitly the declaration statements:

driver assign_demo:
locals
    ** initialization statements
    Integer a = 2;
    Double  b:= a + 0.5;
process   
    ** verification statements   
    expect a == 2;
    expect b == 2.5;
return;    

Multi-line statements

One expression can span multiple lines.

• The expression may be enclosed in parenthesis or quotation marks;
• Arithmetic expressions can use an operator to continue on next line;

Example:

# multiple line demo
driver multi_line:

locals
    Integer x;
    Hash    a;
    
process
    ** multi-row expression
    x := 1 + 
         2 +
        (3 + 4)
       + 5;
       
    ** multi-row literal
    a := {
        (1:2),
        (3:4),
        (5:6)
    };
return;

Reserved keywords

Computer was invented in England during WW2 so, we prefer English words even though a computer language could be created using keywords from other spoken languages. EVE is using about 50 English reserved words. You can not use these words as identifiers.

Definition regions

Semantic keywords

Blocks of code/sections

Operator keywords

Interruption statements

Delimiters

Operators

EVE us ASCII symbols for operators. One operator can be single character or two characters with no space between tem. Sometimes we use the same character twice for example "==" or ">>". This technique is known in many other computer languages.

Single symbol:

# , : . ; = ~ ? % ^ * - + / < > ~ & | ^ ! @ $

Two symbols:

** // == != =+ <> << >> => >= <= <: .. .! !. !! 

Modifiers:

++ -- :: := += -= *= /= %= ^= &= |= <+ +>

Delimiters:

"_" '_' `_` (...) [...] {...} #(...)

Single symbols

EVE use al single simbols usually found on your keyboward.

Double symbols

Eve use two symbols to create supplementary operators.

String concatenation

Numeric operators

Relation Operators

EVE use two symbols to create a additional operators.

Modifiers

Each modifier is created with pattern "x=" where x is a single symbol:

Collection operators

In following table: A, B, C are collections and x is a member:

Logical operators

These operators are expected logical values T = True, F = False

Table of truth for logical operators:

Unary operator: not

• not False = True
• not True = False

Bitwise operators

These operators are working for natural numbers ≥ 0

Binary operators

Unary operators

Quick Format

For printing output using a format we use operator as that is the "quick format" operator. We can use system constant templlated that are available for making different formats for different data types. This operator is a bit smarter than the "?" operator that we can use for "string templates".

Date Format

Time Format

Numeric Format

Read next: Structure