\documentclass[twocolumn,a4paper]{article}
\usepackage{french,tp}
\advance\topmargin -1cm
\advance\textheight 1cm
\advance\textheight -8mm

\begin{document}
\begin{header}
{\Huge Rappels de syntaxe}
\bigskip
\end{header}
\small

\subsubsection*{Blocs d'instruction}
Un paire {\tt BEGIN} {\tt END} délimite
un bloc d'instructions.
Les instructions à l'intérieur du bloc
sont séparées par des {\tt ;}.
Elles sont exécutées séquentiellement
\footnote{c'est-à-dire les une après les autres,
dans l'ordre où elles sont écrites}.

Attention ! à chaque {\tt BEGIN} correspond un
unique {\tt END}. Pour plus de lisibilité, on
demande que la présentation du programme
fasse clairement apparaître cette correspondance.

\subsubsection*{Instructions simples}
Ce sont l'affectation et l'appel d'une procédure.
L'affectation se fait par {\tt :=} à la gauche duquel
il y a un identificateur de variable et à la droite duquel
il y a une expression de même type.

L'appel de procédure se fait par écriture de l'identificateur
de la procédure, ses arguments étant entre parenthèses.

\subsubsection*{Instructions composées}
Les instructions de sélection (ou branchement) sont :
\begin{itemize}
\item {\tt IF {\em expression booléenne}
\\THEN {\em instruction ou bloc d'instructions}
\\ELSE {\em instruction ou bloc d'instructions}}
\\qui exécute une instruction ou l'autre.
\item {\tt IF {\em expression booléenne}
\\THEN {\em instruction ou bloc d'instructions}}
\\qui n'exécute rien si l'expression est fausse.
%\item {\tt CASE {\em expression scalaire} OF
%\\{\em val} : {\em séquence d'instructions}
%\\...
%\\ELSE {\em séquence d'instructions}
%\\END}
%\\et sa version sans {\tt ELSE}.
\end{itemize}

Les instructions de boucle (ou d'itération) sont :
\begin{itemize}
\item {\tt FOR {\em variable} := {\em début} TO {\em fin}
\\DO {\em instruction ou bloc d'instructions}}
\\qui incrémente la variable à chaque étape et s'arrête
lorsqu'elle égale {\tt\em fin}.
\item {\tt FOR {\em variable} := {\em début} DOWNTO {\em fin}
\\DO {\em instruction ou bloc d'instructions}}
\\en décrémentant la variable.
\item {\tt REPEAT
\\{\em séquence d'instructions}
\\UNTIL {\em expression booléenne}}
\\qui exécute la séquence d'instruction, puis teste
la valeur de l'expression booléenne, et recommence
si c'était {\tt False}.
\item {\tt WHILE {\em expression booléenne}
\\DO {\em instruction ou bloc d'instructions}}
\\le test est fait avant l'exécution des instructions.
\end{itemize}

Il faut faire attention à la position des {\tt ;}
qui servent à séparer les instructions d'une
séquence d'instructions
\footnote{Pas de {\tt ;} avant un {\tt ELSE}.}.

\subsubsection*{Un programme}
Un programme Pascal se décompose en trois zones :
\begin{enumerate}
\item la déclaration du programme, à l'aide
du mot clé {\tt PROGRAM}, suivie par un {\tt ;}
\item une zone de déclaration des identificateurs
globaux, chaque déclaration étant suivie par {\tt ;}
\item le bloc d'instructions du programme, suivi par {\tt .}
\end{enumerate}

\subsubsection*{Les déclarations}
Chaque déclaration permet, dans la suite,
d'utiliser un nouvel identificateur.
Celui-ci peut désigner :
\begin{itemize}
\item une variable : avec le mot clé {\tt VAR} et le séparateur {\tt :}
on déclare une ou plusieurs variables d'un certain type.
Le programme réserve donc une place dans la mémoire pour y stocker
la valeur de la variable.
\item une constante : avec le mot clé {\tt CONST} et le séparateur {\tt =}
on donne un nom à une valeur.
\item un type : avec le mot clé {\tt TYPE} et le séparateur {\tt =}
on donne un nom à un type de données.
\item une procédure ou une fonction : avec les mots clés {\tt PROCEDURE}
et {\tt FUNCTION}. Voir ci-dessous.
\end{itemize}

\subsubsection*{Procédures et fonctions}
La déclaration de chaque procédure ou fonction
se décompose en trois zones :
\begin{enumerate}
\tolerance=10000
\item la déclaration du prototype de la procédure ou fonction, à l'aide
du mot clé {\tt PROCEDURE} ou {\tt FUNCTION}, suivie par un {\tt ;}
\item une zone de déclaration des identificateurs
locaux, chaque déclaration étant suivie par {\tt ;}
\item le bloc d'instructions de la procédure ou fonction, suivi par {\tt ;}
\end{enumerate}

La déclaration d'un prototype doit préciser quels
sont les paramètres, et s'ils sont passés par valeur
ou par référence (avec le mot clé {\tt VAR};
on dit aussi par adresse ou par variable).

Pour une fonction, le prototype donne le type du résultat,
qui doit être un type simple.
La valeur du résultat est décidée à l'intérieur du bloc
d'instructions, par une affectation à l'identificateur
de la fonction, qui est alors formellement considéré
comme un identificateur de variable.

\subsubsection*{Types simples}
On connait les types scalaires (booléens : {\tt BOOLEAN},
caractères : {\tt CHAR} ou entiers : {\tt INTEGER} et {\tt LONGINT})
et les types flottants {\tt REAL}.
Il y a aussi les chaînes de caractères {\tt STRING}.

\subsubsection*{Types composés}
Un tableau {\tt ARRAY}
est une collection de variables de même type, numérotées.
On accède aux éléments d'un tableau avec {\tt {\em variable}[{\em position}]}.

Les cases d'un tableau peuvent être numérotées selon plusieurs
coordonnées. Le type des cases est quelconque.
La déclaration d'un type tableau est de la forme :
\\{\tt ARRAY[{\em inter\-valle1},...] OF {\em type des cases}}.

Un enregistrement (ou article, structure, {\tt RECORD})
est une collection de variables de types variés,
nommées par des identificateurs.
On accède aux éléments d'un enregistrement avec {\tt {\em variable}.{\em nom}}.
Chacun s'appelle un {\em champ}.

La déclaration d'un enregistrement est de la forme :
\\{\tt RECORD {\em nom1} : {\em type1}; ... END}\hspace{5mm}
et l'ordre dans lequel sont déclarés les champs de l'enregistrement
n'importe pas.
\end{document}
