From fe055aa1ae36ee8058a2da7eabc63da913123a69 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Fri, 13 Feb 2026 22:54:22 +0100 Subject: [PATCH] Document expressions --- doc/appendix.tex | 3 +- doc/language.tex | 353 ++++++++++++++++++++++++++++++++++++++------ doc/type-system.tex | 32 ---- 3 files changed, 311 insertions(+), 77 deletions(-) diff --git a/doc/appendix.tex b/doc/appendix.tex index 9d92d53..0777d55 100644 --- a/doc/appendix.tex +++ b/doc/appendix.tex @@ -1,6 +1,7 @@ \part{Appendix} +\appendix -\addchap{Syntax} +\chapter{Syntax} \begin{grammar} = `A' | `B' | … | `Z' | `a' | `b' | … | `z' | `\_'. diff --git a/doc/language.tex b/doc/language.tex index a18dac8..9112127 100644 --- a/doc/language.tex +++ b/doc/language.tex @@ -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} + = | | + \alt{} | + \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} + = `(' [] `)'. +\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' `(' `:\@' `)'. +\end{grammar} + +The type of an object can be reinterpreted with a cast expression: \\ +\verb|cast(object: Type)|. + +\subsection*{Traits} + +\begin{grammar} + = `#' . + + = `(' [] `)'. +\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} + = `[' `]' | `.\@' | `^'. + + = | . + + = + \alt{} + \alt{} + \alt{} + \alt{} + \alt{} `(' `)'. +\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} + = `@' | `~' | `-'. -\verb|@| (\textit{at sign}) takes the address of its operand. The operand expression should be + = | . +\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} + = \{ \}. + + = \{ \}. + + = \{ \}. + + = \{ \}. + + = \{`&' \}. + + = \{(`or' | `xor') \}. +\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} diff --git a/doc/type-system.tex b/doc/type-system.tex index 4ac36e4..3ae8a30 100644 --- a/doc/type-system.tex +++ b/doc/type-system.tex @@ -124,35 +124,3 @@ begin e := E.one end. \end{lstlisting} - -\chapter{Type operations} - -\chapter{Cast} - -\begin{grammar} - = `cast' `(' `:\@' `)'. -\end{grammar} - -The type of an object can be reinterpreted with a cast expression: \\ -\verb|cast(object: Type)|. - -\chapter{Traits} - -\begin{grammar} - = `#' . - - = `(' [] `)'. -\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}