SAIL (langage de programmation)

SAIL , le langage d'intelligence artificielle de Stanford , a été développé par Dan Swinehart et Bob Sproull du Stanford AI Lab . Il s'agissait à l'origine d'un grand langage de type ALGOL 60 pour les PDP-10 et DECSYSTEM-20 . Le langage combinait le compilateur GOGOL du langage PDP-6 /-10 antérieur, essentiellement une version d'ALGOL uniquement en nombres entiers , avec le magasin associatif du langage LEAP . La première version est sortie en novembre 1969 et a connu un développement continu dans les années 1980, avec notamment un dérivé commercial, MAINSAIL .

La principale caractéristique de SAIL est un système de données symboliques basé sur un magasin associatif basé sur LEAP de Jerry Feldman et Paul Rovner. Les éléments peuvent être stockés sous forme d'ensembles non ordonnés ou d'associations (triples). D'autres fonctionnalités incluent les processus, les variables de procédure, les événements et les interruptions, les contextes, le retour en arrière et la récupération de place des enregistrements . Il dispose également de macros structurées en blocs, d'une fonction de coroutining et de nouveaux types de données destinés à la construction d'arbres de recherche et de listes d'associations.

Le compilateur GOGOL a été écrit à l'origine par Bill McKeeman sur le PDP-1 . Il s'agissait essentiellement d'une version d' ALGOL-60 uniquement en nombres entiers avec un certain nombre d'ajouts pour fournir un accès direct à la mémoire et à d'autres matériels afin de lui permettre d'être utilisé comme langage de programmation système . Il réduisait les tableaux à une seule dimension, supprimait toute possibilité d'effectuer des allocations de mémoire dynamiques, mais ajoutait quelques fonctionnalités de chaîne supplémentaires. Une version grandement mise à jour par John Sauter, GOGOL II, a été écrite dans le cadre d'un portage du système d'exploitation sous-jacent d'ODIN vers THOR. Lorsque le Stanford AI Lab a reçu son PDP-6 , Sauter, Pettit et (surtout) Dan Swinehart ont écrit GOGOL III pour la nouvelle machine.

Swinehart, rejoint par Robert Sproull, a fusionné la syntaxe GOGOL avec des ajouts des versions contemporaines du langage LEAP pour produire la première version de SAIL en novembre 1969. La principale caractéristique de LEAP en tant que langage était son utilisation du stockage associatif, plus communément connu aujourd'hui sous le nom de Map ou Dictionary. Dans LEAP, on pouvait définir la valeur d'un champ dans un type en utilisant un triplet, la première entrée étant le nom de la variable, la deuxième le nom du champ et la troisième la valeur.

D'autres améliorations ont été apportées par Russell Taylor, Jim Low et Hana Samet, qui ont ajouté des processus, des variables de procédure, des interruptions, du contexte, des procédures de correspondance, un nouveau système de macros et d'autres fonctionnalités. Le développement a ensuite été confié à Taylor, John Reiser et Robert Smith, qui ont ajouté un débogueur, une instruction d'impression au niveau du système, des enregistrements et ont effectué la conversion du SUAI de Standord vers TENEX . Il a ensuite été porté également vers TOPS-10 de DEC , tandis que la version originale de TENEX fonctionnait sans modification sous TOPS-20 .

Comme de nombreux systèmes ALGOL, et plus tard Pascal , la structure de base de SAIL est basée sur le bloc , qui est désigné par le code entre les mots-clés BEGINet END. Dans un bloc, il y a une structure supplémentaire, avec les déclarations de variables locales en haut, le cas échéant, et le code, ou les instructions , qui suivent. Contrairement à la plupart des dialectes, SAIL permettait de placer une chaîne après le BEGIN, comme BEGIN "program", puis de terminer le bloc par END "program". Le compilateur les utiliserait, s'ils étaient saisis, pour vérifier que les crochets sont bien placés. SAIL n'incluait pas l'équivalent d'un PROGRAMbloc comme en Pascal, ni d'un maincomme en C, l'exécution commençant par la première ligne de code dans le bloc le plus externe.

Les instructions standard incluaient IF...THEN...ELSE, FOR...STEP...UNTIL...DO , WHILE...DO pour les boucles testées en haut, WHILE...UNTILpour celles testées en bas et GOTOqui utilisaient une étiquette. Le CASEétait similaire à switchen C, mais utilisait normalement une syntaxe quelque peu différente, comme CASE i OF ("Zero","One","Two");, qui renvoie la chaîne appropriée en fonction de la valeur de i. Si l'on voulait tester des valeurs explicites dans le CASE, les valeurs devaient être entre crochets :

CAS I DE DEBUT [ 0 ] 10 ; [ 4 ] 25 ; [ 6 ][ 7 ] 50 FIN ;

Ce code ignore les valeurs de 1 à 3 et ne renvoie qu'une valeur pour les valeurs répertoriées. Notez que le dernier élément ne peut pas être suivi d'un point-virgule.

DONEsorti d'un bloc, généralement utilisé dans les boucles, et CONTINUEretourné au début du bloc. Une boucle infinie était généralement implémentée avec WHILE TRUE DO....

Les procédures étaient implémentées de manière similaire au langage de programmation C , avec le type de retour, le cas échéant, devant le nom, par exemple, STRING PROCEDURE toUpper(STRING originalStr);BEGIN.... Notez l'utilisation peu courante du point-virgule ici, alors que Pascal suivrait immédiatement d'un bloc, généralement un BEGIN.

Afin d'améliorer les performances, SAIL a ajouté deux qualificateurs de procédure SIMPLEet RECURSIVEa RECURSIVEindiqué au compilateur que la procédure pouvait s'appeler elle-même et que ses variables locales devaient donc être écrites dans la pile, pas seulement les informations de retour de sous-routine. SIMPLEa fait le contraire, exigeant que la procédure n'ait aucune variable locale, ne permettant pas GOTOde sortir de la fonction et ne pouvant pas faire référence aux variables de la procédure englobante. Ces directives pouvaient éviter l'obligation de remplir un enregistrement d'activation complet , améliorant ainsi les performances. Cela avait également pour effet secondaire de signifier que les variables déclarées dans une procédure qui n'était pas marquée RECURSIVE ne seraient pas réinitialisées entre les appels, static agissant de manière similaire à C.

SAIL incluait également le FORWARDqualificateur, utilisé pour insérer des déclarations anticipées , généralement lorsque deux procédures s'appellent mutuellement. RETURN fonctionnait comme en C, en quittant la procédure et en revenant à l'appelant, ainsi qu'en renvoyant éventuellement une valeur si la procédure en utilise une. Les paramètres passés aux procédures pouvaient être par VALUEou REFERENCE, ce dernier permettant de renvoyer des valeurs.

Les types de variables de base dans SAIL sont les entiers , les réels (à virgule flottante), les booléens et les chaînes . Les conversions de type étaient automatiques, donc INTEGER i;i←SQRT(5);la valeur 5 était convertie en double, comme c'est ce que SQRT exige, puis le résultat était converti en entier. Chacun de ces types peut être transformé en tableau en ajoutant le ARRAYqualificateur et en plaçant les limites du tableau entre parenthèses, par exemple, REAL ARRAY weeks[1:52]);. SAIL prenait en charge les tableaux 1-d et 2-d.

Le langage utilisait la flèche gauche pour l'affectation, ←ou le trait de soulignement sur les plates-formes qui n'avaient pas Stanford ASCII . Il comprenait un certain nombre de fonctions standard comme la racine carrée , tous les opérateurs mathématiques courants et était par ailleurs similaire à la plupart des dérivés d'ALGOL pour la programmation normale.

Les chaînes étaient manipulées à l'aide du découpage de tableau , avec aStr[i TO j]le renvoi de la sous-chaîne avec des caractères de i à j, ou aStr[i FOR j]qui renvoyait la sous-chaîne commençant à i et fonctionnant pendant j caractères. Le INFmot-clé (inity) représentait la fin de la chaîne, donc on pouvait aStr[i TO INF]tout renvoyer à partir de i. Les fonctions et opérateurs de chaîne inclus EQUpour tester si deux chaînes étaient égales, l'esperluette pour la concaténation, LENGTH, et LOPqui supprime le premier caractère de la chaîne. Il n'y avait aucun moyen de comparer des chaînes autrement que EQU, les opérateurs comme <étaient définis uniquement pour les nombres.

Le concept d' enregistrements en tant que type de données n'a été introduit que récemment lors de l'écriture de SAIL. Cette fonctionnalité montre donc les signes d'être « boulonnée » à la syntaxe du langage. Par exemple, une structure d'enregistrement a été définie à l'aide de l' RECORD!CLASSinstruction : RECORD!CLASS person (STRING name, address; INTEGER accountnum; REAL balance). Cette instruction fonctionnait de manière similaire à l' RECORDinstruction de Pascal, définissant le modèle de l'enregistrement. Pour créer un enregistrement, on utilisait l' NEW!RECORDinstruction, qui renvoyait un RECORD!POINTER. Les pointeurs étaient typés et pouvaient être typés vers plusieurs types, par exemple, RECORD POINTER (person,university) rp;définit rp, un pointeur vers un enregistrement de personne ou d'université. Les pointeurs pouvaient également être déclarés pour pointer vers ANY!CLASS. L'accès aux données d'un enregistrement était également idiosyncratique ; pour imprimer le fichier de noms d'une personne, par exemple, la syntaxe était PRINT(person:name[rp]);.

En plus des fonctionnalités de base des chaînes, SAIL incluait un système d'analyse de chaînes dans le langage de base. SCANfonctionnait sur des variables de chaîne, tandis que le système, par ailleurs similaire, INPUTétait utilisé pour analyser les chaînes lues à partir d'un fichier. Les deux utilisaient un système connu sous le nom de « table de rupture » qui consistait en un ensemble de caractères représentant les endroits où arrêter la lecture, les exemples incluent les sauts de ligne, divers espaces et la ponctuation. Ces tables étaient stockées dans des structures spéciales, et le système n'en autorisait que 54, un nombre qui n'est pas expliqué dans la documentation.

Pour construire une nouvelle table, on appelait d'abord GETBREAKwhich qui renvoyait le prochain emplacement libre dans la table, ou "numéro de table". Ceci était suivi par un SETBREAK, qui prenait le numéro de table, une chaîne avec les caractères de rupture, une autre chaîne de "caractères d'omission" qui étaient simplement ignorés pendant la lecture (comme s'ils n'étaient pas dans la chaîne) et enfin les "modes", des indicateurs qui indiquaient comment le système devait fonctionner. Une fois définis, le programme pouvait alors appeler à plusieurs reprises SCANou INPUTet recevoir des chaînes complètes. Cela incluait un paramètre de référence, normalement brkchar, qui contenait le caractère qui a provoqué la rupture, permettant de tester, par exemple, les caractères de fin de fichier. Le système est conceptuellement similaire à strtokla fonctionnalité de C, qui fait partie de stdlib par opposition à une partie du langage lui-même comme dans SAIL.

Le système d'entrée/sortie de SAIL était basé sur l'idée de « canaux » numérotés d'une manière quelque peu similaire aux entrées du scanner. Pour ouvrir un fichier, on appelait d'abord GETCHANpour renvoyer une valeur d'un canal libre, puis OPENon l'éditait avec divers paramètres pour décrire le fichier et les modes de fonctionnement. RELEASEétait équivalent à fermer. Une fois ouvert, le fichier pouvait être lu, sous réserve des règles de numérisation mentionnées ci-dessus, en appelant INPUTet en recherchant la fin du fichier. Les fichiers n'avaient pas de noms dans le cadre de OPEN, à la place, LOOKUPils pouvaient être utilisés pour pointer un canal vers un fichier donné, ENTERcréer un nouveau fichier associé à un canal et RENAMEpermettre de modifier un nom de fichier existant. On peut ouvrir un fichier existant pour l'écriture en utilisant GETCHAN... OPEN... LOOKUP... ENTER.

Il y avait de nombreux gestionnaires et variables spéciaux qui étaient utilisés pendant les E/S. Par exemple, la INCHWLfonction était une INPUT câblée en dur sur le terminal utilisateur et toujours ouverte, et elle renvoyait son caractère d'interruption dans la variable système !SKIP!. La PRINTfonction sortait normalement vers le même canal de terminal, mais pouvait également être dirigée vers n'importe quel autre canal ouvert.

En tant que langage de programmation système, les performances étaient importantes et pour y parvenir, SAIL incluait un DEFINEqui utilisait le remplacement de chaîne de manière similaire aux #definemacros de C. Une différence était que les délimiteurs autour de la substitution devaient être définis, par exemple REQUIRE "[][]" DELIMITERS;DEFINE maxSize=[100];. Une utilisation courante de ces macros était de définir des constantes de caractères comme CRLF, car elles ne faisaient pas partie du langage de base. Une autre était de redéfinir l' COMMENTinstruction en la plus courte !.

Le système comprenait également un système de compilation conditionnelle utilisant des instructions, par opposition aux directives de préprocesseur que l'on trouve dans C. IFCRcompilait les blocs entre les THENCet ELSECou correspondants ENDC. La condition dans l'IFCR doit être connue au moment de la compilation, donc, comme en C, c'était normalement une DEFINEvaleur d.

La principale différence entre SAIL et les autres langages dérivés d'ALGOL était l'inclusion du magasin associatif du langage LEAP. Ce système permettait de placer les données dans des structures de type enregistrement, puis de les sauvegarder, de les récupérer et de les rechercher. À cet égard, il était similaire aux fonctionnalités de traitement des données de COBOL . La base du magasin était l' association ou triple , qui permettait d'associer une valeur de données à un emplacement nommé dans un enregistrement. Par exemple, on pourrait créer un enregistrement du type Family_Memberavec Name"Tom" et définir le Fatherchamp sur "Harry". Cela donne un triple de la forme (Père, Tom, Harry). Les bibliothèques associées pourraient alors trouver tous les Family_Members avec "Harry" comme Father, renvoyant peut-être "Tom" et "Alice".

Le code suivant, trouvé dans le didacticiel, convertit une chaîne d'entrée en majuscules.

PROCÉDURE DE CHAÎNE upper ( CHAÎNE rawstring ) ; BEGIN " upper " CHAÎNE tmp ; INTEGER char ; tmp ← NULL ; WHILE LENGTH ( rawstring ) DO BEGIN char ← LOP ( rawstring ) ; COMMENT LOP renvoie le premier caractère et déplace le pointeur au-delà tmp ← tmp & ( IF " a " LEQ char LEQ " z " THEN char - '40 ELSE char);  END;  RETURN(tmp);  END "upper";

Un certain nombre de systèmes logiciels intéressants ont été codés en SAIL, notamment certaines des premières versions de FTP et de TeX , un système de formatage de documents appelé PUB, et BRIGHT, un projet de base de données clinique parrainé par les National Institutes of Health .

En 1978, il existait une demi-douzaine de systèmes d'exploitation différents pour le PDP-10 : ITS (MIT), WAITS (Stanford), TOPS-10 (DEC), CMU TOPS-10 (Carnegie Mellon), TENEX ( BBN ), Tymcom-X (Tymshare) et TOPS-20 (DEC, basé sur TENEX).

SAIL a été porté de WAITS vers ITS afin que les chercheurs du MIT puissent utiliser le logiciel développé à l'Université de Stanford . Chaque portage nécessitait généralement la réécriture du code d'E/S dans chaque application.

Une version de SAIL indépendante de la machine appelée MAINSAIL a été développée à la fin des années 1970 et a été utilisée pour développer de nombreux outils de conception eCAD au cours des années 1980. MAINSAIL était facilement portable vers de nouveaux processeurs et systèmes d'exploitation, et était encore d'une utilisation limitée en 2005 .