Le désoeuvrement, origine de tous les vices, m'a poussé à chercher ce qu'on aurait pu inventer comme langage de programmation au dessus de l'assembleur, mais en dessous de FORTRAN. Plus basique que BASIC.



Donc j'ai conservé la traduction des formules, et supprimé tout ce qui est structures de contrôle. Hop, plus de boucle DO. Juste une instruction de saut, éventuellement conditionnelle.



Pour commence, voila un exemple simple : somme des carrés de 1 à N

 
 #
 # somme des carrés des entiers de 1 à 5
 #
   print "--- exemple : somme des carres des entiers de 1 à 5"
   declare somme, n, i
debut
   somme = 0
   n = 5
   i = 1
boucle
   jump fin if i > n
   somme = somme + i * i
   print i, somme
   i = i + 1
   jump boucle
fin
     print "somme = ",somme
     stop

Une instruction/déclaration par ligne. Les étiquettes commencent en colonne 1. La déclaration des variables est obligatoire (mais il n'y a qu'un type entier). Tableaux multidimensionnels indicés à partir de 1. Le saut conditionnel utilise une comparaison (pas de conditions composées). Un jour, peut être, il y aura print/println, et input pour des lectures. Bon, ça y est vous savez programmer.



Et pour faire bon poids, le problème des 8 reines

#
# pb des 8 reines
# m billaud, 27 dec 2012
#
     declare n, t(8), q, nb

     n  = 8    # nombre de reines
     nb = 0    # nombre de solutions trouvées
     q  = 0    # nombre de reines positionnées

success                     # les reines t1..q sont compatibles
     jump display if q == n
     q = q + 1              # on essaie d'en placer une autre
     t(q) = 1
test                        #  tq compatible avec t1..q-1 ?
     declare i
     i = 1
testi
     jump success if i == q     # oui. alors on passe à la suivante
     jump next    if t(i) == t(q)
     jump next    if t(i)-t(q) == i-q
     jump next    if t(i)-t(q) == q-i	
     i = i + 1
     jump testi
                            # non, on essaie autre chose
# --
next
     t(q) = t(q)+1          # autre possibilité pour la même reine ?
     jump test if t(q) <= n   
	
	
fail                        # non, retour à la reine précédente
     q = q - 1
     jump next if q > 0
                            # plus de possibilités   
     print "On a trouvé", nb,"solutions."     # y en a 92, je vous assure.
     stop
#
# affichage d'une solution
#
    
display
    declare r
    r = 0
    i = n
    nb = nb + 1
displayloop
    r = 10*r + t(i)
    i = i - 1
    jump displayloop if i > 0
    print "solution ", nb,"=", r
    jump fail            # inutile d'essayer de changer t(n)

Ah, et les tours de Hanoi (hello, HCM !)

#
# tours de Hanoi
#
    declare from(10), to(10), nb(10)
    declare top
    declare f, t, b, n
    top = 1
    from(top) = 1
    to(top) = 2
    nb(top) = 3
    print "*** tours de hanoi avec n=", nb(top)
loop
    f= from(top) 
    t = to(top)
    b = 6 - (f+t)
    n = nb(top)
#   print "boucle", f, t, b
    top = top -1
    jump general if n > 1
    print f,"->",t
    jump next
general
    from(top+3) = f
    to  (top+3) = b 
    nb  (top+3) = n-1
    
    from(top+2) = f
    to  (top+2) = t 
    nb  (top+2) = 1
    
    from(top+1) = b
    to  (top+1) = t 
    nb  (top+1) = n-1

    top = top+3
next
    jump loop if top > 0    
    stop

L'interprète est écrit en Python, environ 600 lignes. Analyse par descente récursive, traduction sous forme de code intermédiaire : tableau d'objets "instruction" contenant des "Expression" arborescentes, évaluées récursivement.