path: root/doc/language.tex

\part{Language}

An Elna program consists of one or more source files, called \textbf{modules}.

Each module can declare \textbf{types}, \textbf{global variables} and
\textbf{procedures}, used by this module or exported to be used by other
modules.

Each procedure can get some input and produce an output as a result of
executing a \textbf{statement block}, a list, where each \textbf{statement}
is executed in the order it appears in the block.

\chapter{Vocabulary}

A language is an infinite set of sentences, namely the sentences well formed
according to its syntax. In Elna, these sentences are called compilation units.
Each unit is a finite sequence of \textit{tokens} from a finite vocabulary.
The vocabulary of Elna consists of identifiers, reserved words, numbers, characters,
strings, operators, delimiters, and comments. They are called \textit{tokens}
and are composed of sequences of characters.

The following lexical rules must be observed when composing tokens. Blanks and
line breaks must not occur within tokens (except in comments and strings). They
are ignored unless they are essential to separate two consecutive tokens.
Capital and lower-case letters are considered as being distinct.

\section{Identifiers}

\textit{Identifiers} are sequences of letters, digits and underscores. The first
character must be a letter or an underscore.

\begin{grammar}
<identifier> = <letter> \{<letter> | <decimal-digit>\}.
\end{grammar}

Examples:

\begin{itemize}
		\item \verb|x|
		\item \verb|TypeName|
		\item \verb|procedure_name|
\end{itemize}

\section{Numbers}

Numbers are signed or unsigned integers, or real numbers. Integers may be
preceded by a prefix and followed by a suffix. The prefixes \verb|0x| and
\verb|0X| indicate hexadecimal representation, \verb|0b| and \verb|0B|
indicate binary representation. Unsigned integers have the suffix \verb|u|,
signed integers have no suffix.

A \textit{real number} always contains a decimal point. Optionally it may
also contain a decimal scale factor. The letters \verb|e| or \verb|E| is
pronounced as `times ten to the power of'.

\begin{grammar}
<integer-literal> = `0' | <counting-digit> \{<decimal-digit>\}.

<word-literal> = <integer-literal> `u'
	\alt{} `0' (`X' | `x') <hex-digit> \{<hex-digit>\}
	\alt{} `0' (`B' | `b') <binary-digit> \{<binary-digit>\}.

<real-literal> = <integer-literal> `.\@' <decimal-digit> \{<decimal-digit>\}
	\alt{} <integer-literal>\} `e' [`+' | `-'] <decimal-digit> \{<decimal-digit>\}.
\end{grammar}

Examples:

\begin{itemize}
		\item 2016
		\item 1987u
		\item 0xff
		\item 0b101
		\item 0.5
		\item 4.567e8
\end{itemize}

\section{Strings and characters}

Single \textit{characters} are enclosed in single quotation marks
(\textquotesingle).\@ \textit{Strings} are sequences of characters enclosed in
double quotation marks (\textquotedbl). The number of characters in a string is
called the \textit{the length} of the string.

\begin{grammar}
<escaped-character> = `\\' \\
	(`n' | `t' | `f' | `r' | `v' | `\\' | `\textquotesingle' | `\textquotedbl' | `0').

<hex-character> = `\\x' <hex-digit> \{<hex-digit>\}.

<character> = <printable-character> | <escaped-character> | <hex-character>.

<character-literal> = `\textquotesingle' <character> `\textquotesingle'.

<string-literal> = `\textquotedbl' \{<character>\} `\textquotedbl'.
\end{grammar}

Alternatively, a single character may be represented by a
\textit{escape sequence} (see~\ref{table:escape}), a character combination
beginning with a backslash (\textbackslash).

\begin{table}[ht]
\centering
\begin{tabular}{r l}
	\textbf{Sequence} & \textbf{Meaning} \\
	\toprule
	\verb|\n| & Newline \\
	\midrule
	\verb|\t| & Horizontal tab \\
	\midrule
	\verb|\f| & Form feed \\
	\midrule
	\verb|\r| & Carriage return \\
	\midrule
	\verb|\v| & Vertical tab \\
	\midrule
	\verb|\\| & Backslash \\
	\midrule
	\verb|\'| & Single quote \\
	\midrule
	\verb|\"| & Double quote \\
	\midrule
	\verb|\0| & Null character \\
	\midrule
	\verb|\xh…| & Arbitrary hexadecimal value, where \verb|n| is a hexadecimal digit \\
	\bottomrule
\end{tabular}
\caption{Escape sequences}\label{table:escape}
\end{table}

Examples:

\begin{itemize}
		\item \verb|"String"|
		\item \verb|'c'|
		\item \verb|'\''|
		\item \verb|"\"multi\nline\nquoted\nstring\""|
\end{itemize}

\section{Operators and delimiters}

\textit{Operators} and \textit{delimiters} are the special characters, character
pairs, or reserved words listed below. These reserved words consist exclusively
of letters and cannot be used in the role of identifiers.

\begin{itemize}
	\item{}:=
	\item $@\quad\hat{}\quad\sim$
	\item $.\quad,\quad;\quad:\quad|$
	\item $<\quad>\quad>=\quad<=\quad<>\quad=$
	\item $+\quad-\quad*\quad/$
	\item $or\quad{}xor\quad\&$
	\item (\ and\ )
	\item \lbrack{} and \rbrack{}
	\item \{ and \}
	\item Pointer
	\item module
	\item import
	\item type
	\item const
	\item var
	\item begin
	\item end
	\item proc
	\item record
	\item while
	\item do
	\item case
	\item of
	\item if
	\item then
	\item elsif
	\item else
	\item cast
	\item return
	\item true
	\item false
	\item nil
\end{itemize}

\section{Comments}

\textit{Comments} may be inserted between any two tokens in a program. They
are arbitrary character sequences opened by the bracket \verb|(*| and closed
by \verb|*)|. Comments do not affect the meaning of a program.

\chapter{Expressions}

Expressions are constructs denoting rules of computation whereby constants and current values of
variables are combined to derive other values by the application of operators and function
procedures. Expressions consist of operands and operators. Parentheses may be used to express
specific associations of operators and operands.

\section{Literal constants}

\begin{grammar}
<literal> = <integer-literal> | <word-literal> | <real-literal>
	\alt{} <string-literal> | <character-literal>
	\alt{} `true' | `false' | `nil'.
\end{grammar}

Literal constants are

\begin{itemize}
	\item signed and unsigned integers,
	\item real numbers,
	\item booleans,
	\item characters,
	\item strings,
	\item and enumerations.
\end{itemize}

\section{Call expressions}

\subsection*{Procedure call}

\begin{grammar}
<procedure-call> = <designator> `(' [<expressions>] `)'.
\end{grammar}

If the designator object is a procedure followed by a (possibly empty) parameter list,
the designator implies an activation of the procedure and stands for the value resulting
from its execution. The (types of the) actual parameters must correspond to the formal
parameters as specified in the procedure's declaration.

\subsection*{Type cast}

\begin{grammar}
<cast> = `cast' `(' <expression> `:\@' <type> `)'.
\end{grammar}

The type of an object can be reinterpreted with a cast expression: \\
\verb|cast(object: Type)|.

\subsection*{Traits}

\begin{grammar}
<trait-identifier> = `#' <identifier>.

<trait> = <trait-identifier> `(' [<types>] `)'.
\end{grammar}

Traits allow to query some information about the types, like their size or
field offset or alignment. Calling a trait looks like a procedure call but
trait names start with a \verb|#| and their arguments are type expressions and
not value expressions.

Supported compiler traits:

\begin{itemize}
	\item \verb|#size(T)| queries type size.
	\item \verb|#align(T)| queries type alignment.
	\item \verb|#offset(T, F)| queries the offset of the field \verb|F| in the record \verb|T|.
\end{itemize}

\section{Object designators}

\begin{grammar}
<selector> = `[' <expression> `]' | `.\@' <identifier> | `^'.

<designator> = <reference> <selector> | <identifier>.

<reference> = <literal>
	\alt{} <designator>
	\alt{} <trait>
	\alt{} <cast>
	\alt{} <procedure-call>
	\alt{} `(' <expression> `)'.
\end{grammar}

With the exception of literal constants and call expressions, operands are denoted by
\textit{designators}. A designator consists of an identifier referring to the constant,
variable, or procedure to be designated. This identifier or any other expression may be
followed by selectors, if the designated object is an element of a structure.

Designators are addressable, meaning that it is possible to get the address of the
designated object or assign a value to it (if the designated object is mutable).

\subsection*{Subscript selector}

If \verb|A| designates an array or a string, then \verb|A[E]| denotes that element of
\verb|A| whose index is the current value of the expression \verb|E|. The type of
\verb|E| must be of type \verb|Word| or \verb|Int|. The first element has index 1,
the second 2 and so on.

\subsection*{Dereference selector}

If \verb|P| designates a pointer, \verb|P^| denotes the object which is
referenced by \verb|P|.

\subsection*{Field selector}

If \verb|R| designates a record, then \verb|R.f| denotes the field \verb|f| of
\verb|R|.

\subsection*{Variable designator}

If the designated object is a variable, then the designator refers to the
variable's current value.

If the designated object is a procedure, a designator without parameter list
refers to the address of the procedure. Procedure designators designate
immutable objects.

\subsection*{Selector evaluation order}

Selectors are evaluated from left to right.

For example the expression \verb|r^.field| includes 3 designators:

\begin{enumerate}
	\item Variable designator \verb|r|.
	\item \verb|r^| dereferences the pointer \verb|r| and refers
		to the object at the address in \verb|r|.
	\item \verb|r^.field| accesses the field \verb|field| in that object.
\end{enumerate}

\section{Unary expressions}

\begin{grammar}
<unary-operator> = `@' | `~' | `-'.

<factor> = <unary-operator> <factor> | <reference>.
\end{grammar}

Unary expressions are expressions with a prefix operator followed by one
operand. Unary operators in table~\ref{table:unary} associate from right
to left.

$@$ takes the address of its operand. The operand expression should be
addressable.

$\sim$ applied on a boolean acts as logical not. Applied on an integer --- as
bitwise not.

\begin{table}[ht]
\centering
\begin{tabularx}{0.7\textwidth}{%
	r
	l
	>{\centering\arraybackslash}X
}
	\textbf{Symbol} & \textbf{Symbol name} & \textbf{Description} \\
	\toprule
	$@$ & \textit{at sign} & Address \\
	\midrule
	$-$ & \textit{minus} & Sign inversion \\
	\midrule
	$+$ & \textit{plus} & Identity operation \\
	\midrule
	$\sim$ & \textit{tilde} & Negation \\
	\bottomrule
\end{tabularx}
\caption{Unary operators}\label{table:unary}
\end{table}

\section{Binary expressions}

\begin{grammar}
<term> = <factor> \{<multiplication-operator> <factor>\}.

<simple-expression> = <term> \{<addition-operator> <term>\}.

<comparand> = <simple-expression> \{<shift-operator> <simple-expression>\}.

<relation> = <comparand> \{<relation-operator> <comparand>\}.

<operand> = <relation> \{`&' <relation>\}.

<expression> = <operand> \{(`or' | `xor') <operand>\}.
\end{grammar}

The syntax of expressions distinguishes between several classes of
operators with different precedences (binding strengths). Operators of
the same precedence associate from left to right. For example, $x - y - z$
stands for $(x - y) - z$.

The available operators are listed in the table~\ref{table:binary}.
In some instances, several different operations are designated by
the same operator symbol. In these cases, the actual operation is
identified by the type of the operands.

\begin{table}[ht]
\centering
\begin{tabularx}{\textwidth}{%
	c
	>{\centering\arraybackslash}X
	>{\raggedright\arraybackslash}X
}
	\textbf{Precedence} & \textbf{Operator} & \textbf{Description} \\
	\toprule
	1 & $* \quad / \quad \%$ & Multiplication, division and remainder. \\
	\midrule
	2 & $+ \quad -$ & Addition and subtraction. \\
	\midrule
	3 & $<< \quad >>$ & Left and right shifts. \\
	\midrule
	4 & $= \quad <> \quad > \quad < \quad <= \quad >=$ & Relational operators. \\
	\midrule
	5 & $\&$ & Logical conjuction. \\
	\midrule
	6 & $or \quad xor \quad$ & Logical disjunction operators. \\
	\bottomrule
\end{tabularx}
\caption{Operator precedence}\label{table:binary}
\end{table}

\subsection*{Logical and bitwise operators}

Meaning of the operators in table~\ref{table:logical} depends on the
operand type:

Applied on booleans they act as logical operators.

Applied on integers they perform the corresponding logical operation
bitwise, on each pair of bits of their operands.

$or$ and $\&$ are short-circuiting, if the evaluation of the left
side of the operation is enough to determine the final result,
the right side should not be evaluated.

\begin{table}[ht]
\centering
\begin{tabularx}{\textwidth}{%
	r
	l
	>{\centering\arraybackslash}X
	>{\centering\arraybackslash}X
}
	\textbf{Symbol} & \textbf{Description} &
		\textbf{$p \cdot q$ with $\cdot$ as logical operator stands for} &
		\textbf{As bitwise operator} \\
	\toprule
	$or$ & Inclusive disjunction & If $p$ then $true$, else $q$ & Bitwise or \\
	\midrule
	$xor$ & Exclusive disjunction & If $p$ then not $q$, else $q$ & Bitwise xor \\
	\midrule
	$\&$ & Conjuction & If $p$ then $q$, else $false$ & Bitwise and \\
	\bottomrule
\end{tabularx}
\caption{Logical operators}\label{table:logical}
\end{table}

\subsection*{Arithmetic operators}

Operators in table~\ref{table:arithmetic} apply to operands of numeric
types. Both operands must be of the same type, which is also the type of
the result.

Let $q = x / y$, and $r = x \% y$. Then quotient $q$ and remainder $r$ are
defined by the equation

\[
x = q * y + r \mid 0 \leq r < y
\]

Division on integer operands performs integer division.

\begin{table}[ht]
\centering
\begin{tabular}{r l}
	\textbf{Symbol} & \textbf{Result} \\
	\toprule
	$+$ & Sum \\
	\midrule
	$-$ & Difference \\
	\midrule
	$*$ & Product \\
	\midrule
	$/$ & Quotient \\
	\midrule
	$\%$ & Modulus \\
	\bottomrule
\end{tabular}
\caption{Arithmetic operators}\label{table:arithmetic}
\end{table}

\subsection*{Relations}

Relations in table~\ref{table:relation} are boolean. The ordering
relations $<$, $<=$, $>$, $>=$ apply to the numeric types. The
relations $=$ and $<>$ apply to all types.

\begin{table}[ht]
\centering
\begin{tabular}{r l}
	\textbf{Symbol} & \textbf{Result} \\
	\toprule
	$=$ & Equal \\
	\midrule
	$<>$ & Unequal \\
	\midrule
	$<$ & Less \\
	\midrule
	$<=$ & Less or equal \\
	\midrule
	$>$ & Greater \\
	\midrule
	$>=$ & Greater or equal \\
	\bottomrule
\end{tabular}
\caption{Relational operators}\label{table:relation}
\end{table}

\chapter{Statements}

\begin{grammar}
<statement> = <assignment> | <procedure-call> | <defer-statement>
    | <label-declaration> | <goto-statement> |
    | <while-statement> | <if-statement> | <case-statement>.
\end{grammar}

Statements denote actions. There are elementary and structured statements.
Elementary statements are not composed of any parts that are themselves
statements. They are the assignment and the procedure call. Structured
statements are composed of parts that are themselves statements. They
are used to express sequencing and conditional, selective, and
repetitive execution. A statement may also be empty, in which case it
denotes no action. The empty statement is included in order to relax
punctuation rules in statement sequences.

\section{Elementary statements}
\section{Conditional statements}
\section{Loop statements}