• SAM76 Language

    From roche182@laposte.net@21:1/5 to All on Thu Dec 21 03:24:55 2017
    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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)