bases • 00_console_et_generalites

TUTORIEL 0 - La console Scol et généralités

Objectif : Ouvrir la console et des généralités sur la programmation Scol

STATUT : INCOMPLET (deux ou trois paragraphes restent à écrire)

Ok pour toute version de Scol Windows, MacOS et Linux.

TUTORIEL 0

La console Scol et généralités

Version : 1.1
Date : août 2007 (1.0), mai 2009 (1.1)
Licence du tutoriel : GNU FDL v1.3 (gnu_fdl)
Licence du code source : GNU/GPL v3 (GPL)
Téléchargement : tutoriel 0
Décompressez l'archive et copiez le dossier "0" dans "%scol%/tutoriels/codes/" où %scol% est le dossier répertoire utilisateur de Scol. Ok pour toute version de Scol supérieure à la 4.

Objectif :

  • Ouvrir la console
  • Généralités sur la programmation Scol

Moyens :

  • Présentation succinte de Scol
  • Arborescence, partitions et l'installation Scol
  • Un script de lancement Scol
  • Fonctions _foo
  • Fichier de log
  • Chargement et compilation
  • Types Scol


Scol est un langage interprété de haut niveau. Il est écrit en C/C++. Il est openSource (licence de type 'BSD-like'. Développer en Scol revient à écrire des programmes en langage Scol et à les exécuter sur une machine virtuelle Scol ou plusieurs machines virtuelles Scol qui communiquent entre elles. Les principales caractéristiques de la VM (Machine Virtuelle) Scol sont les suivantes (cf Tutoriel de référence) :

  • la gestion automatiqée de la mémoire,
  • le langage de cette machine est Scol,
  • les liaisons réseaux sont transparentes pour l'utilisateur comme pour le développeur,
  • des librairies sont ajoutées pour créer toutes sortes d'interactions avec l'environnement extérieur de la machine (2d, 3d, multimedia, bdd, réseau, ...).
Les versions pour systèmes MACOS et UNIX doivent être mises à jour. La version pour Windows est ok. Pour davantage de détails, voyez cet article sur le Scolring.

INSTALLER SCOL


Que l'on soit simple utilisateur ou développeur chevronné, c'est le même téléchargement et la même installation :)

  • Sous Windows :
    • Téléchargez l'exécutable de la dernière version stable disponible. Vous pouvez choisir une version beta voire alpha si vous savez ce que vous faites)
    • Double-cliquez sur le fichier téléchargé
    • Suivez les instructions qui s'affichent à l'écran
  • Sous Linux :
    • Téléchargez l'archive de la dernière version disponible
    • Décompressez-la et copiez la dans un répertoire de votre répertoire personnel
    • Lancez le script (à rendre exécutable s'il ne l'est pas déjà) situé à la racine "scol".
    • Ou, autre méthode, téléchargez le script automatisé d'installation téléchargeable sur iriZone.
    • Si rien ne se passe, éditez le fichier 'scol' situé au même niveau et remplacez "$HOME/scol/usm..." par "/home/votre_login/scol/usm..." et relancez.
  • Sous MacOS :
    • A rédiger ...
    • Version obsolète


EXÉCUTER SCOL

Une seule instance de Scol peut être lancée simultanément sur une même machine : ce sera la machine virtuelle Scol primaire. Ensuite, elle pourra elle-même gérer simultanément autant de VM Scol que nécessaire.
Si, pour une raison ou une autre, vous désirez lancer une nouvelle session, fermez d'abord la première VM primaire.

  • Sous Windows :
    • Double-cliquez sur le fichier 'scol.exe' ('usmwin.exe' pour les anciennes versions) à la racine du dossier d'installation de Scol ou lancez-le depuis le menu Démarrer.

  • Sous Linux :
    • Dans un terminal, rendez-vous dans le répertoire Scol (typiquement 'cd scol') puis exécutez la commande :
      $ ./scol &
    • Pour lancer une application Scol ou un site depuis la console (une fois la VM primaire ci-dessus lancée ) :
      $ ./scol ./partition/rep_application/application.scol &
    • Autre méthode : en utilisant ma petite application graphique Python / Tk 'scollinux' disponible sur mon site.

  • Sous MacOS :
    • A rédiger ...
    • Version obsolète


FERMER SCOL

Lorsque la VM primaire est détruite, toutes les autres VM encore ouvertes seront détruites aussi.

  • Sous Windows :
    • Cliquez droit sur l'icône Scol situé dans la barre des taches, près de l'horloge et sélectionnez "Quitter le Voyager".
    • Ou tuer le processus 'scol.exe' via le gestionnaire des taches de Windows si celui-ci ne répond plus.
  • Sous Linux :
    • Cliquez droit sur l'icône Scol et sélectionnez "Quitter le Voyager".
    • Ou terminer le processus 'usm...' si celui-ci ne répond plus.
    • Ou encore, si vous utilisez 'scollinux', cliquez sur le bouton "Tuer Scol".
  • Sous MacOS :
    • A rédiger ...
    • Version obsolète


L'ARBORESCENCE SCOL

Consultez cet article qui différencie les branches 4.x de Scol des branches 5.x et supérieures.

Vos propres codes sources devraient être placés dans la partition utilisateur de Scol, à l'emplacement de votre choix.
Depuis les versions 5.x, cette partition est définie dans le fichier "usm.ini" lui-même situé à la racine du répertoire d'installation de Scol. C'est la valeur correspondant à la clé "disku".
Pour les versions antérieures, il s'agit de la valeur de la clé "partition" du même fichier "usm.ini".

Lorsqu'une application Scol est exécutée, elle n'a accès qu'aux fichiers se trouvant dans la même partition active (elle n'a pas accès au Cache et inversement). Seul le DHDMS peut contourner sous condition cette restriction. Il est possible de modifier ces partitions, voire de les restreindre à des sous-dossiers, etc mais uniquement en local, vous ne pourrez rien modifier de tel à distance.


FICHIER DE LOG

Lorsqu'on programme, il est toujours intéressant de débugguer. La console est des plus spartiates et n'est pas vraiment conviviale ! Fort heureusement, il existe des fichiers de log (et d'autres méthodes mais qui relèvent plutôt d'habitudes de programmeur; elles seront vues au tutoriel 5).
Dans ces fichiers sont inscrits un certain nombre de messages venant de la VM mais on peut aussi y insérer ses propres messages.
Dans le même répertoire que ce fichier, il y a un "launch.scol-2007-08-14_21-58-10.log".

Pour générer un fichier de log, il faut d'abord activer les fonctions adéquates de la VM. C'est relativement simple : éditez le fichier "usm.ini" qui se trouve à la racine de Scol et remplacez "log no" par "log yes" et "echo 0" par "echo ffff". Enregistrez et fermez. Pour les désactiver, c'est la même manip en sens inverse.

Le nom du fichier de log généré comporte déjà un certain nombre d'informations :
- le nom du script lanceur : ici 'launch.scol'
- la date à laquelle il a été lancé : ici le 14 août 2007
- l'heure à laquelle il a été lancé : ici à 21 heures, 58 minutes et 10 secondes
On peut ainsi fort heureusement faire un historique de ces logs.

Si on ouvre ce fichier de log avec un éditeur de texte, on remarque :
- la version utilisée de Scol, ici la 4.6c
- le nom de la machine, ici PortDev
- les IPs accessible, ici que la boucle locale (127.0.0.1)
- le masque d'affichage, ici ffff. Il existe en effet d'autres masques entre 0 et ffff mais les différences sont mineures et non pertinentes dans l'immense majorité des cas. Le masque ffff correspond au degré maximal.
- les partitions Scol
- les initialisations de différentes librairies
Jusque là, c'est commun à tous les logs, à quelques nuances près selon la version Scol ou les librairies utilisées.
On a ensuite :
- la création d'un canal spécifique à la (future) application (celle qui va s'afficher une fois les packages nécessaires chargés et compilés). Ici, un canal 'local' (terme impropre mais je suppose plus compréhensible au commun des mortels) : c'est le sens du mot "unplugged" dans unplugged channel -16384
- le chargement d'un package (_load "locked/slv.pkg") qui fera le lien entre la VM primaire et la VM de notre application.
- ce fichier est chargé et compilé : on y voit des choses très intéressantes : les types que le compilateur a déterminé pour les variables et fonctions présentes dans ce package. C'est intéressant pour débugguer mais aussi pour apprendre. Ce sera le cas pour tous les packages que la VM chargera et compilera.
- une fois compilé, la fonction 'main' est recherché avec, pour paramètre, l'adresse IP qui se limite ici à un numéro de port, sous-entendant par là l'emploi de la boucle locale, et le nom du fichier de script. C'est ce que veut dire main ":1200" "launch.scol"
- le canal est ouvert et on y est connecté (ouverture d'un canal CONNECT (100007f):4b0)
- enfin, les différentes fonctions du script sont exécutées.

Pour écrire un message dans un fichier de log, il faut, outre l'activation vue plus haut, utiliser une ou plusieurs des fonctions suivantes :
- _fooS : pour écrire une chaîne
_fooS "Scol, c'est bien !"
_fooS strcat "La valeur de MaVariable est " MaVariable
- _fooI : pour écrire un hexadécimal
_fooI AA3D8
- _fooId : pour écrire un entier
- _fooIList : pour écrire une liste d'hexadécimaux
- _fooSList : pour écrire une liste de chaînes
...


SCRIPT DE LANCEMENT

Ouvrez votre éditeur de texte favori et copiez-y les lignes suivantes. Enregistrez-le dans un sous-répertoire de votre partition utilisateur (par exemple sous le nom "launch0.scol") 

_showconsole
_fooS "Ceci est le premier tutoriel de la serie"
_fooS "Cette fenetre est la 'console'"
_fooS "Elle est utile pour debugger"
_fooS ""
_fooS "Pour fermer ce tutoriel et detruire"
_fooS "la machine virtuelle (VM) associee"
_fooS "fermez simplement la console (X)"
_fooS "et lisez 'tutoriel0.txt' dans ce meme repertoire."
_fooS "Bonne journee"

Lancez ce script. En exécutant ce script, le système sollicite la VM primaire (ou la lance au préalable si cela n'était pas déjà fait) et lui fournit, en argument, le chemin et le nom du script. La VM primaire crée alors une nouvelle VM ("secondaire"), y charge l'API Scol et lit, ligne après ligne, le contenu du script.

La première ligne demande à la VM d'afficher la console. La console est une interface des plus rudimentaires Les lignes suivantes demandent, via la fonction '_fooS' vue plus haut, d'afficher un texte.

La VM est tuée dès que la console est fermée. La VM primaire, elle, peut continuer de tourner en fond.

Cet exemple très simple est juste là pour montrer comment est lancé une VM Scol. Il n'est pas du tout recommandé d'écrire un programme dans un tel script. Sa vocation est d'appeler au chargement et à la compilation de packages. Par ailleurs, ce genre de script peut être limité en taille par le système lui-même (Windows par exemple) et l'API Scol disponible y est très limitée.


CHARGEMENT ET COMPILATION DE PACKAGES

Un package est un fichier contenant du code Scol destiné à être exécuté. C'est un fichier texte dont l'extension est, par convention, ".pkg". Même si rien n'interdit d'utiliser une autre extension, mieux vaut, pour garder la cohérence du système, garder cette extension ".pkg".
Donc, vous l'aurez compris, la programmation Scol consiste à écrire des packages en langage Scol puis de les faire charger et compiler par une VM via un script.

Pour charger et compiler un script, on utilise la fonction scol '_load' ou '_loadS'. On utilise cette fonction dans les scripts mais on peut aussi l'utiliser dans un package pour en ajouter d'autres après coup. Dans les deux cas, la syntaxe est la même :

_load "repertoire1/repertoire2/fichier.pkg"
_load "repertoire1/repertoire2/fichier2.pkg"
_load "repertoire1/repertoire3/fichier.pkg"
fonction_a_appeler argument

Ici, on charge 3 packages et une fois compilés, on appele la fonction 'fonction_a_appeler' avec un argument 'argument'. Cette fonction (les fonctions seront présentées dans un prochain tutoriel) doit obligatoirement être définie dans un des packages précédemment chargés.

Notez que la compilation se fait à la volée : chaque package est compilé dans l'ordre du script puis le script est exécuté. Il n'y a pas de compilation préalable pour une exécution future. Compilation et exécution sont de fait indissociables.
L'ordre des packages a son importance. En effet, toutes fonctions et variables doivent être déclarées avant d'être utilisées.


LES TYPES

Le compilateur détermine lui-même le typage des fonctions. Ensuite, lors de l'exécution du programme Scol, ce typage n'est plus utilisé.
Il existe quelques cas où il est nécessaire de typer explicitement une fonction : lorsqu'il y a ambiguïté ou lorsqu'une fonction doit être utilisée avant d'être définie. Nous verrons ça dans le tutoriel 4. Il en va de même pour les variables locales dont les types sont directement définis par le compilateur. Au final, ce sont essentiellement des variables globales dont les types devront être définis, et encore ça dépend lesquelles.

Malgré tout, outre les erreurs de syntaxe, la plupart des erreurs de compilation proviennent d'une erreur de typage. En effet, cette "facilité" est à double tranchant : elle permet de développer sans trop se préoccuper des types des objets qu'on manipule et du coup on a tendance à les oublier. Pensez à noter zn commentaire les types des fonctions, c'est un excellent moyen d'éviter ces pièges.

Si le compilateur ne peut définir le type d'une variable ou d'une fonction ou qu'il y a ambiguïté entre plusieurs types possibles, le compilateur s'arrêtera et générera une erreur.

Les principaux types rencontrés sont :

  • I, les entiers
  • F, les nombres flottants
  • S, les chaînes de caractères
  • Chn, les canaux
  • Env, les environnements
  • Comm, les communications
  • INET, les requêtes HTTP
  • Srv, les serveurs Scol
  • etc
puis d'autres venant des librairies Scol comme :
  • H3d, les objets 3d
  • S3d, les sessions 3d
  • ObjWin, les fenêtres 2d
  • SqlDB, les connexions à une base de données
  • AsSnd, les sons système
  • etc
et encore les combinaisons sous forme de tuples :
  • [S I Chn], un objet chaîne, un objet entier, un objet canal
  • [S r1], une liste de chaine de récurrence 1
  • [[S3d ObjSurface H3d H3d] r1], une liste dont chaque élément est composé d'une session 3d, d'un buffer de rendu et de deux objets 3d
  • etc

enfin, les types que vous définirez vous-même grâce au structures et au constructeurs de types. Tout cela sera vu prochainement :)


NIL

'nil' est une constante Scol qui possède tous les types à la fois, du plus simple au plus complexe. 'nil' est notamment la valeur d'une variable déclarée mais non initialisée.


LES ENTIERS

Les entiers peuvent être codés dans les 4 bases suivantes :

  • en binaire : 0b1000111110
  • en octal : 0o1076
  • en décimal : 574
  • en hexadécimal : 0x23E


LES FLOTTANTS

Les flottants forment un type spécifique : F
10.25.


LES CHAINES

Les chaines (de type S) sont exposées au tutoriel 9.