Pseudo

Pseudo est un interpréteur utilisable dans le cadre d'introduction à l'algorithmique. L'idée est d'introduire une syntaxe proche de celle du pseudo-code (!) introduite par Prof'Expert Mathématiques discrètes.

Commandes du menu

Execution/Compiler	"compile" l'éditeur actif.
Execution/Exécuter	la première fois que cette commande est utilisée elle ouvre un éditeur dans lequel on tapera la commande à exécuter (c'est-à-dire le nom d'une procédure). Sinon, la commande Execution s'applique à la procédure dont le nom est sélectionné dans l'éditeur.

Syntaxe

Quelques symboles sont introduits pour éviter des ambiguités. Notamment une suite d'instructions ou de paramètres est notée entre crochets []. Voir les exemples pour plus de précision.

Définition d'une procédure

Il y a trois entêtes possibles:

POUR <nom procédure> corps de la procédure FIN

POUR <nom procédure> AVEC par corps de la procédure FIN

POUR <nom procédure> AVEC [ par1 par2 ...] corps de la procédure FIN

Un paramètre est soit un identificateur, soit un identificateur précédé de ' pour indiquer un paramètre représentant une fonction.

Exemples:

POUR calculer_aire_rectangle 
  LIRE "longueur et largeur" [longueur largeur]
  aire := longueur * largeur 
  ECRIRE aire 
FIN

POUR calculer_aire_rectangle AVEC [longueur largeur] 
  aire := longueur * largeur 
  RETOURNER aire 
FIN

POUR calculer_aire_rectangle2 
  LIRE "longueur et largeur" [long larg] 
  aire := calculer_aire_rectangle AVEC [long larg] 
  ECRIRE aire 
FIN

Le corps de la procédure est une suite de commandes parmi:

Conditions	SI cond ALORS com SINON com : voir la suite de Syracuse	SI cond ALORS com : voir la multiplication égyptienne
Boucles	TANTQUE cond FAIRE com : voir la suite de Syracuse	POUR id DE int A int FAIRE
	REPETER int com
Contrôle divers	RETOURNER exp : voir dessin de carreaux	RETOURNER [ lexp ]
	ARRET	SORTIR
	NIVEAUSUP
Lecture/écriture	LIRE str exp LIRE str [ lexp]	ECRIRE exp exp exp ECRIRE int int [lexp] ECRIRE exp
Graphisme	AXES	POINT exp exp LINE exp exp exp exp
Instantiation	id := exp id := `<nom fonction>`	id := `<nom fonction>` AVEC par id := `<nom fonction>` AVEC [par1 par2 ..]
Appel de procédures	`<nom procédure>`	`<nom procédure>` AVEC par `<nom procédure>` AVEC [par1 par2 ...]
Conditions	exp = exp exp <> exp exp < exp	exp <= exp exp >= exp non <cond>
Expressions arithmétiques	+ - * / ^ div mod

Suite de Syracuse

POUR syracuse AVEC n 
  SI (n mod 2) = 0 ALORS RETOURNER n div 2 SINON RETOURNER 3*n+1 
FIN

POUR suite_syracuse 
  LIRE "nombre de départ" n 
  pos := 0 
  TANTQUE n <> 1 FAIRE 
    [     ecrire AVEC [pos n] 
          n := syracuse AVEC n 
          pos := pos+1 
    ] 
  ECRIRE n 
FIN

POUR ecrire AVEC [pos n] 
  y := pos div 8 
  x := pos mod 8 
  ECRIRE 50*x-199 85 - 20*y n 
FIN

Dessin de "carreau"

POUR f1 AVEC x
  RETOURNER x+20
FIN

POUR f2 AVEC x
  RETOURNER -x+20
FIN

POUR f3 AVEC x
  RETOURNER x - 20
FIN

POUR f4 AVEC x
  RETOURNER -x - 20
FIN

POUR segment AVEC ['f x1 x2]
  pas := 1
  x := x1
  TANTQUE x <= x2 FAIRE
    [    y := f AVEC x
         POINT x y
         x := x + pas
    ]
FIN

POUR carreau
  AXES
  segment AVEC [f1 (-20) 0]
  segment AVEC [f2 0 20]
  segment AVEC [f3 0 20]
  segment AVEC [f4 (-20) 0]
FIN

POUR calcul_moyenne
  n := 0
  s := 0
  LIRE  "premier nombre" x
  TANTQUE x <> -1 FAIRE
    [       s := s+x
            n := n+1
            LIRE "nombre suivant (-1 pour terminer)" x
    ]
  ECRIRE s/n
FIN

PGDC

POUR pgdc AVEC [n m]
  TANTQUE m <> 0 FAIRE
    [       r := n mod m
            n := m
            m := r
    ]
  RETOURNER n
FIN

Multiplication égyptienne

POUR multiplier
  LIRE "donnez deux nombres entiers positifs" [n m]
  result := 0
  TANTQUE n <> 0 FAIRE
    [       SI (n mod 2) = 1 ALORS result := result + m
            n := n div 2
            m := m * 2
    ]
    ECRIRE result
FIN

POUR base_deux
  LIRE "nombre" n
  pos := 0
  SI n = 0 ALORS [ ECRIRE 0 ARRET ]
  TANTQUE n <> 0 FAIRE
    [       digit:= n mod 2
            n := n div 2
            ecrire AVEC [pos digit]
            pos := pos + 1 
    ]
FIN

POUR ecrire AVEC [pos digit]
  x := 190 - 10*pos
  ECRIRE x 0 digit
FIN