SAM76 Language

26 views
Skip to first unread message

roch...@laposte.net

unread,
Dec 21, 2017, 6:24:56 AM12/21/17
to
SAM76MSX.WS4
------------

- "SAM76: Un langage venu d'ailleurs"
Thierry Dauthier
"MSX Magazine", Janvier-Février 1985, No.4, p.26

(Retapé par Emmanuel ROCHE.)

Des versions de SAM76 existent sous CP/M (TM Digital Research Inc) pour les
micro-ordinateurs suivants: APPLE II+, IIe, Epson QX-10 et Sony SMC-70G en
version graphique étendue, interfacées a un vidéodisque... De plus, une
version beaucoup plus importante a été développée sur les machines DECsystem-
10. Enfin, SAM76 est désormais disponible pour le standard MSX1 et MSX2, sous
MSX-DOS. Cette dernière version utilise également les possibilités graphiques
de ce standard.


Ce langage peu connu est apparu pour la première fois en 1976. Créé par le
groupe des R.E.S.I.S.T.O.R.S. du New Jersey (USA) sous la direction de Claude
A.R. Kagan, le langage SAM76 repose sur le concept du traitement de listes. A
la base de SAM76, on trouve deux processeurs de listes et un processeur
arithmétique, en précision infinie. L'un des processeurs de listes est inspiré
du "M6 Macro Processor" conçu par M.D. Mac Ilroy et R. Morris des Bell
Telephone Laboratories et l'autre est inspiré de la syntaxe du "GPM A General
Purpose Macro Generator" conçu par C. Strachey.

Dans la série des processeurs de listes, on connaissait déjà LISP, SMALLTALK,
LOGO. La liste s'agrandit avec SAM76.

Les points forts du SAM76 sont: la gestion des entrées/sorties, la gestion des
données, le calcul en précision infinie, le graphisme. Mais, à l'origine,
SAM76 a été conçu dans un souci de complète compatibilité entre les
différentes informations que l'utilisateur peut entrer dans la machine. Pour
cela, de nouveaux concepts ont été introduits.


Les concepts du SAM76
---------------------

Du texte rien que du texte, pourrait être la devise de ce langage. En effet,
toutes les informations (programmes, données, arguments, commandes) sont
appelées TEXTE. Ces informations sont considérées comme des séquences de
caractères et elles sont gardées en mémoire au format ASCII, c'est-à-dire
telles qu'elles ont été introduites au clavier. Cette technique fournit au
langage une compatibilité à 2 niveaux.


1 Une compatibilité complète de la structure des commandes
----------------------------------------------------------

Le résultat d'une commande peut devenir une autre commande ou un argument pour
une autre commande. Précisons que le langage n'a pas de message d'erreur
proprement dit. Si une commande est mal écrite, elle est ignorée. Si, dans une
commande complète, il y a des caractères inutiles, ceux-ci seront ignorés et
la commande sera exécutée. Mais il y a des messages, lorsque l'erreur provient
de l'interpréteur SAM76 ou de l'ordinateur lui-même.


2 Compatibilité des données
---------------------------

Les lettres, chiffres, symboles et autres caractères de contrôle, peuvent être
mélangés librement. Il est, par exemple, très facile d'additionner "chien"
avec la valeur "4" sans passer par une multitude de conversions numériques ou
alphanumériques, il suffit d'utiliser la fonction d'addition (AD):
%ad,chien,4/=

Résultat: chien4
De même : %ad,5,4/= 9

On voit donc la simplicité du traitement des séquences de caractères de
quelques types qu'elles soient.


Format des commandes
--------------------

La plupart des commandes acceptent 3 syntaxes différentes: Actif; la commande
sera tout de suite exécutée. Neutre; forme complémentaire de la syntaxe actif.
Protège; la commande ne sera pas évaluée lors de la première lecture. Ces
syntaxes prennent la forme:

Actif %fonction, argument, /
Neutre &fonction argument, /
Protège ! séquence protégée /

Le langage reconnaît une commande au caractère (%) ou (&). Il considère alors
que les 2 ou 3 caractères qui suivent représentent la fonction. La virgule est
l'élément séparateur du langage, puis viennent le ou les arguments. Le slash
(/) indique la fin de la fonction. Nous présenterons d'abord des exemples
utilisant les commandes arithmétiques, car elles sont très simples à
assimiler. Nous avons déjà vu la fonction d'addition, voici la soustraction,
la multiplication, la division. Les fonctions plus complexes peuvent
facilement se définir par la suite.

%mu,464,45412/=21071168 Multiplication de 464 par 45412
%di,100,10/=10 Division de 100 par 10
%su,4,3/=1 Soustraction de 3 à 4

Jusque-là, rien de surprenant, si ce n'est la syntaxe: on s'y fait assez vite.
Mais voilà, toutes les commandes de SAM76 s'imbriquent les unes dans les
autres (comme un jeu de Lego) pour devenir des procédures très puissantes.
Voici une combinaison de 3 commandes:

%ad,3,%mu,2,%di,4,3///=5

Le signe égal (=) est équivalent à la touche (RETURN) ou (ENTER), c'est
l'activateur. Dès que vous appuyez sur cette touche, la fonction est évaluée
et le résultat est affiché, ici "5" est le résultat.

Pour arriver à ce résultat, SAM76 utilise un algorithme particulier.


Le Scanner
----------

C'est l'oeil du SAM76. Tout ce qui doit être activé passe par lui; il lit la
séquence de caractères et l'évalue. Si c'est une fonction, il l'exécute et la
remplace par sa valeur. Puis, tout ce qui peut à nouveau être exécuté est
remplacé par sa valeur, pour aboutir au résultat final. Voici l'algorithme
suivi par le scanner:

- Lire de gauche à droite jusqu'au premier (/) trouvé.
- Exécuter et remplacer la fonction par sa valeur.
- Reprendre au début avec la nouvelle valeur de la fonction.
- Continuer à lire de gauche à droite jusqu'au prochain (/).
- Lorsque, à un pourcent (%) ou à un (&), ne correspond plus de (/)
alors afficher le résultat.

Prenons un exemple :

%ad,2,%mu,3,4//= premier slash trouvé

Exécute ce qui se trouve entre le dernier (%) et le premier (/) trouvé, puis
remplace le tout par sa valeur. Il reste "7" plus la première fonction qui n'a
pas encore été évaluée.

%ad,2,7/ lit jusqu'au prochain slash (/)

Exécuter et remplacer. 9 pas d'autre (/) alors afficher le résultat.

Remarque: les commandes deviennent les arguments d'autres commandes et il n'y
a pas de limites au nombre de commandes que l'on peut ainsi imbriquer.


Les procédures
--------------

En SAM76, il n'y a pas de numéro de ligne, de GOTO, GOSUB ou autres
instructions communes au BASIC, mais il y a des procédures. Une procédure
SAM76 est une séquence de caractères qui sera exécutée lorsque le nom de la
procédure sera appelé. Pour appeler une procédure, il y a plusieurs solutions:
soit directement au clavier, par son nom, comme on le ferait pour une commande
du langage, ou au sein d'une procédure. Voici comment se définit une procédure
appelée "procédure" en SAM76:

%dt, procédure, !%as,(,),Anne, Marie,Paul,Jean///=

La fonction "DT" définit la procédure, les caractères compris entre le (!) et
le second slash (/) sont protégés: ils seront conservés en mémoire sous le nom
"procédure": l'instruction "AS" effectue un tri alphabétique croissant. La
virgule entre les deux parenthèses sera le caractère qui séparera les éléments
"Jean, Anne, Marie, Paul" lorsqu'ils seront triés. Les deux parenthèses qui
entourent la virgule servent à protéger ce caractère, car la virgule est un
élément de la syntaxe du langage. Pour utiliser cette procédure, voici 2
façons:

%procédure/=Anne,Jean,Marie,Paul

Ce qui suit le "égal" est le résultat.

%os,%procédure/ine/=Anne,Jean,Marie,Pauline

La fonction "OS" (Output String) est la fonction d'affichage: elle est
équivalente au "PRINT" du BASIC. Vous remarquerez que Paul est devenu Pauline,
chose assez étrange direz-vous, hé bien non car, une fois le résultat de
"procédure" affiché, la fonction "OS" affiche à son tour la séquence de
caractères "ine". Dans le premier exemple plus haut, on n'a pas utilisé la
fonction "OS" pour afficher le résultat de "procédure", car toutes les
fonctions du langage qui doivent afficher un résultat passent automatiquement
par la fonction "OS".


Partitions et Registres
-----------------------

Ce sont les noms donnés aux différents types de déclaration de variables. En
BASIC, on trouve des variables numériques et alphanumériques. En SAM76, il n'y
a plus de distinction entre ces 2 types: le langage fait lui-même la
distinction, ce qui simplifie bien des choses.

La partition est le premier type de variable, elle pourrait être comparée à
une sorte de trou, dans lequel on pourrait mettre n'importe quels caractères
ou séquences de caractères. Le nombre de caractères que l'on peut y insérer
n'est pas limité. Ce qui nous amène à préciser qu'en SAM76, tout peut être
infini, la seule limite étant la capacité mémoire de l'ordinateur. Revenons à
la partition: on la rencontre exclusivement à l'intérieur de procédures.
Exemple: définissons la procédure "polit" qui sera chargée d'afficher
"bonjour".

%dt,polit,!bonjour//=

La fonction "PT" (Partition Texte), permet de crier une partition à un endroit
choisi dans une procédure choisie. Ici, nous allons cr2er une partition sur la
séquence "jour".

%pt,polit,jour/=

La commande "VT" (Voir Texte) permet de voir le contenu d'une procédure, qui
n'est, en fait, qu'un texte. Rappelez-vous: tout est du texte en SAM76. La
commande affichera le contenu de la procédure "polit".

bonj[1]

Le [1] représente la partition, les caractères "jour" ont disparu. Le 1
indique le numéro de la partition. S'il y avait eu plusieurs partitions,
celles-ci auraient eu, en suivant, le numéro 2 puis 3 puis 4, etc... Ainsi
numérotées, les partitions peuvent faire l'objet de traitement. Exemple, on
peut, avec l'exemple précédent, insérer la séquence "soir" dans la partition.
Pour cela, on doit préciser le nom de la procédure sur laquelle le traitement
doit porter, puis la séquence à y insérer.

%ft,polit,soir/=bonsoir

de même:

%ft,polit,soir bonjour/=bonsoir bonjour


Les Registres
-------------

Un registre est une case mémoire dans laquelle on peut conserver une séquence
de caractères numériques. Pour définir un registre, il faut lui donner un nom
comme "case, A, B3, 2, etc..." et un contenu numérique. Exemple:

%zs,trois,3/=

On met la valeur "3" dans le registre de nom "trois". Les registres servent
pour des opérations arithmétiques. On peut les incrémenter ou les décrémenter
automatiquement par les fonctions "ZI" et "ZD". Ils trouvent leur intérêt dans
les boucles. Comme compteurs, ils peuvent être la condition d'un test. Dans ce
dernier cas, il y aura branchement vers une procédure plutôt que vers une
autre si le test est vérifié.

%zi,A,1,3 !%vrai// !%faux///=

C'est-à-dire, dans cet exemple, lorsque le registre "A", qui est décrémenté de
1 à chaque passage par la procédure atteindra la valeur 3, alors il y aura
branchement vers la procédure "vrai". Si le test est faux, alors on exécute la
procédure "faux". C'est simple, non?


Les fonctions Booléennes
------------------------

Elles ne sont qu'au nombre de 2, mais les fonctions manquantes peuvent
facilement être créées par procédures à partir des 2 premières. Ce sont les
tests d'égalité: fonction "II" et de supériorité "IG". Ces fonctions acceptent
un nombre illimité de tests et, à chaque test, elles assurent le branchement
vers les procédures adéquates. Voici leur syntaxe:

%II,A,B,!%vrai//,!%faux//,B,C,!%oui//,!%non///=

Dans cet exemple, A,B,C,D sont des noms de procédures qui font l'objet de
test; "vrai,faux,oui,non" sont les procédures de branchement. Ce qui se lit:
si A=B alors exécute "vrai" sinon exécute "faux". Dans les deux cas, revient
au test suivant après exécution des procédures de branchement puis, si B=C
alors exécute "oui" sinon exécute "faux". Dans les deux cas, il n'y a pas de
test qui suit, donc on ne revient pas sur la procédure d'égalité. Avouez qu'il
est plus facile de l'écrire que de l'expliquer.


La gestion des Entrées/Sorties
------------------------------

La première chose à noter, c'est que SAM76 est entièrement interactif avec son
système d'exploitation SOSM (un compatible du CP/M de Digital Research). On
peut passer de l'un à l'autre comme on passe d'une pièce dans une autre, et
cela sans la moindre perte des données contenues en mémoire. Cette souplesse
est bien pratique à l'usage.

Les entrées/sorties sont gérées par 2 fonctions qui reçoivent des arguments
correspondant aux périphériques choisis. Ces fonctions sont:

%soc,argument/= (Select Output Channel)
%sic,argument/= (Select Input Channel)

Les arguments disponibles sont:

CON Console vidéo
LST Imprimante
PUN Lecture carte perforée, ou Cassette
USR Périphérique défini par l'utilisateur

Outre ces commandes, SAM76 possède des fonctions pour sauver, effacer, charger
des procédures, des images, des fichiers binaires dit Overlay et des fichiers
de type ASCII à partir d'un lecteur de disque. De même, une série de commandes
permet d'exploiter des fichiers de type séquentiel. D'autres commandes, plus
spéciales, peuvent lire et écrire une piste ou un secteur d'une disquette.


Choisissez votre base
---------------------

Le SAM76 possède 2 bases numériques. L'une dénommée BASE X car elle est
utilisée pour les opérations internes du langage; elle est en base 16
(hexadécimale). L'autre base, la BASE N, sert à toutes les opérations
arithmétiques commandées par l'utilisateur, et elle est en base 10 (décimale).
La fonction "CNB" permet de changer la BASE N. Ainsi, on peut choisir la base
dans laquelle on veut travailler.

Exemple: %cnb,16/=

Dès lors, toutes les opérations arithmétiques demanderont des arguments en
hexadécimal, et le résultat des opérations sera, lui aussi, en hexadécimal.

Exemple: %mu,2,6/=C

La multiplication de 2 par 6 donne bien "C" en base 16. Outre la base 16, vous
pouvez choisir la base qui vous plaît. Comme beaucoup de processeurs de
listes, SAM76 accepte la récursivité. On dit d'une procédure qu'elle est
récursive lorsqu'elle s'appelle elle-même dans son principe. Voici un exemple
avec le calcul de factorielle. Précisons que, là encore, le calcul de la
factorielle ne sera limité que par la capacité mémoire de la machine. Voici la
procédure:

%dt,fac,!%ii,*,] I !%mu,*,%fac,%u,*,I//////////////=

Dans cette procédure, on remarquera 2 choses. Premièrement, les (*): elles
représentent les caractères où il y aura une partition qui contiendra le
nombre de la factorielle à chercher et, par la suite, les résultats partiels
de la recherche, jusqu'à ce que celui-ci soit égal à 1: alors, on affichera le
résultat. Le second point, c'est qu'il y a plus de caractères (/) que
nécessaire. En effet, lorsque les procédures deviennent importantes, il est
fastidieux de compter le nombre exact de slashs qui termineront les fonctions.
Aussi, on en met beaucoup plus que nécessaire. Rappelez-vous que les
caractères inutiles sont automatiquement éliminés par le langage, alors
pourquoi s'en priver?

Pour utiliser notre procédure récursive "fac", il ne reste plus qu'a créer les
partitions à la place des (*).

%pt,fac,*/=

Le calcul de factorielle 5 s'écrira :

%fac,5/= 120

SAM76 possède plus de 150 fonctions, vous comprendrez donc que le but de cet
article n'était pas de les voir toutes, mais plutôt de donner un aperçu des
possibilités de ce langage, inconnu pour beaucoup. Aussi, en guise de
conclusion, nous terminerons sur les possibilités graphiques de ce langage.
Et, pour mieux en juger, voici ce que l'on peut faire (facilement) avec un
traitement de texte (SLED) écrit en SAM76.


EOF
Reply all
Reply to author
Forward
0 new messages