**************************************************************************
******************   Macro MORTRAN de base (MTN mac)  ********************
**************************************************************************
***********   Utlilisable dans ZINIT, dans les processeurs   *************
***********        et dans le noyau de ZOOM (ZOOM KER)       *************
**************************************************************************
remise a jour mai 93


 Block MORTRAN
===============
  MORTRAN possede la notion de block : c'est une séquence d'instructions
delimité par des "bracket" : < (ouverure de block) et > (fermeture). Les blocks
MORTRAN peuvent etre emboités.

 Etiquettes
============
 Plutot que de mettre des numeros d'étiquette, on peut utiliser un nom symbolique
entoure de :
Exemple :
:Label1: ......;
         if ..... go to :Label1: ;
write (6,:Format2:) i;
:Format2: format (1x,I4);

 Instructions Conditionelles
=============================

IF Logical_exp < block >

IF Logical_exp < block > ELSE < block >

IF Logical_exp < block > ELSEIF Logical_exp_2 < block > ELSE < block >

avec Logical_exp : expression logique (validité du FTN)
...   Upgrade du 6/8/93(Al1):  ...........................

     expression logique valide :
   IF xxx.eq.Op1,Op2,etc < ... qui est équivalent a:
                IF (xxx.eq.Op1).or.(xxx.eq.Op2) etc
     ainsi que
 IF xxx.eq.Op1,Op2,etc .and.(ou.or.)yyy.eq.Op3,Op4,etc< ...
    qui est équivalent a:
                IF ((xxx.eq.Op1).or.(xxx.eq.Op2) etc)
                    .and.(ou .or.)
                         ((yyy.eq.Op3).or.(yyy.eq.Op4)etc<
..........................................................

On peut mettre autant de ElseIf que l'on veut.
L'instruction Else n'est jamais obligatoire

 Opérations d'itérations
==========================

DO Loop_Exp < block >  ou autre écriture : <Loop_Exp; block >
---------------------                      ------------------
avec Loop_Exp : expression standard FORTRAN de boucle : Indice = min,max {,step}
Si la valeur de l'indice est modifie par l'utilisateur a l'interieur de la
boucle (chose autorisée par FORTRAN), un WARNING sera généré par MORTRAN:
** MTN WARNING DO LOOP INDEX (nn) should not be altered.

Equivalent a ce qui existe dans beaucoup de compilateur : DO .....     END DO
exemple : do i=1,5 <....>   ou  <i=1,5; ....>

Boucles DO a multiples indices:
-------------------------------
DO ((...(I=1,12,3),J=J1,J2)...) <block>;
   Un seul <> bloc pour plusieurs boucles imbriquees. Equivalent a:
   DO ...
   <   ...
      <  DO J=J1,J2
         < DO I=1,12,3
           ...
         >
      >
   ...
   >;
   c.a.d comme la regle d' indices de PRINT(((A(i,j),i=..)j=..)

WHILE Logical_exp < block >
---------------------------
avec Logical_exp : expression logique
  L'expression logique est d'abord tester. Si elle est vrai, on execute les
instructions du block, puis on refait le test. Quand le test est faux, on execute
l'instruction suivant le block.

UNTIL Logical_exp < block >
---------------------------
avec Logical_exp : expression logique
  Inverse logique de WHILE :  Si l'expression logique est fausse, on execute les
instructions du block, puis on refait le test. Quand le test est vrai, on execute
l'instruction suivant le block.

Les instructions peuvent également etre située a la fin du block.
UNTIL Logical_exp < block > UNTIL Logical_exp_2
UNTIL Logical_exp < block > WHILE Logical_exp_2
WHILE Logical_exp < block > UNTIL Logical_exp_2
WHILE Logical_exp < block > WHILE Logical_exp_2

S'il n'y a pas de test en début, on peut faire précéder le block par LOOP
LOOP < block > UNTIL Logical_exp
LOOP < block > WHILE Logical_exp

 Controle et rupture d'iteration
----------------------------------
  * itération suivante : on peut interompre l'executions des instructions contenues
dans le block et passer directement a l'itération suivante par l'instrucion NEXT; .
  * Sortie du processus d'itération : ou peut sortir du processus d'itération par
l'instruction EXIT; . On execute alors l'instruction suivant le block.
  * Si plusieurs itérations sont emboitées, les instructions NEXT et EXIT font
référence au block a l'interieur duquel elles se situent.
  * Si plusieurs itérations sont emboitées, il est possible d'appliquer les
instructions NEXT et EXIT a n'importe quel block, si on les etiquette. Par exemple,
avec
:Label: WHILE Logical_exp < block >
on peut, quelques soi le niveau d'emboitement, faire EXIT:Label: et NEXT:Label: