OSS/elna
1
0
Fork 0
Code Issues Releases Activity

Document expressions

Browse Source
This commit is contained in:
Eugen Wissner
2026-02-13 22:54:22 +01:00
parent d7c27f1c63
commit fe055aa1ae
3 changed files with 311 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
doc/appendix.tex
View File

@@ -1,6 +1,7 @@
\part{Appendix}
\appendix
\addchap{Syntax}
\chapter{Syntax}
\begin{grammar}
<letter> = `A' | `B' | … | `Z' | `a' | `b' | … | `z' | `\_'.

353
doc/language.tex
View File

@@ -15,60 +15,325 @@ where a statement has control over the evaluation of its components.
Statements can also modify the state of the procedure or the program by
mutating variables.
Most simple expressions are identifiers referencing program's symbols and
literals. These atomic expressions can be combined to more complex expressions
by applying various operations to one or more expressions.
\chapter{Expressions}
The expression \verb|@r.field| includes 3 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 expression \verb|r|.
\item Field access \verb|(r).field|.
\item Address taking \verb|@(r.field)|.
\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}
The expression is evaluated in the above order. The postfix expressions
like field access have higher precedence than prefix operators.
\section{Binary expressions}
\begin{table}
\centering
\begin{tabularx}{0.8\textwidth}{%
l
>{\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 & $or \quad xor \quad \&$ & Logical operators.\\
\bottomrule
\end{tabularx}
\caption{Operator precedence}
\end{table}
\section{Unary expressions}
Unary expressions are expressions with a prefix operator followed by one
operand.
\begin{grammar}
<unary-operator> = `@' | `~' | `-'.
\verb|@| (\textit{at sign}) takes the address of its operand. The operand expression should be
<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.
\verb|-| (\textit{minus}) negates a numeric value.
\verb|~| (\textit{tilde}) applied on a boolean acts as logical not. Applied on a numeric – as
$\sim$ applied on a boolean acts as logical not. Applied on an integer --- as
bitwise not.
\chapter{Conditional statements}
\chapter{Loop statements}
\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}
\section{Conditional statements}
\section{Loop statements}

32
doc/type-system.tex
View File

@@ -124,35 +124,3 @@ begin
e := E.one
end.
\end{lstlisting}
\chapter{Type operations}
\chapter{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)|.
\chapter{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
traits 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}