STATUT : INCOMPLET

Téléchargement du tutoriel complet : tutoriel 0
Décompressez l'archive et copiez le dossier "0" dans "%scol%/partition/tutoriels/codes/" où %scol% est le dossier d'installation de Scol.
Ok pour toute version de Scol Windows, MacOS et Linux.

TUTORIEL 0

La console Scol et généralités

Auteur : iri
Site web : http://www.irizone.net
Version : 1.0
Date : août 2007
License : GNU/GPL v3 (http://www.gnu.org)

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 Scol ou plusieurs machines 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.

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 disponible
    • 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 l'exécutable situé à la racine (son nom est variable suivant les versions mais il commence par 'usm...').
    • Ou, autre méthode, téléchargez le script automatisé d'installation téléchargeable sur mon site.
    • 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 tuer 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

Sans détailler, il y a :

  • La racine :
    Elle contient l'exécutable, divers fichiers dont deux qui seront détaillés plus loin : usm.ini et usmress.ini.
  • Le répertoire Plugin :
    Il contient les librairies ajoutant les interfaces 2D, 3D, SQL, Multimedia, ... à Scol
  • Le répertoire Log :
    Il contient les fichiers de trace (log) si ceux-ci sont activés (voir plus bas).
  • Le répertoire Partition :
    Il contient les fichiers nécessaires au Scol Voyager et aux différentes applications Scol installées notamment, des librairies graphiques éventuelles et contiendra également vos futurs développements.
  • Le répertoire Cache :
    Comme son nom l'indique, il sert de cache aux applications qui l'utilisent ou aux sites que vous visiterez.

Scol reconnaît, de base, deux partitions : le répertoire Partition et le répertoire Cache. Une partition Scol est un dossier (avec ses sous-dossiers) du disque dur utilisable par Scol. Autrement dit, Scol est incapable de travailler ou d'aller modifier un fichier qui se trouverait en dehors d'une partition. C'est un gage de sécurité.

Normalement, Scol travaille avec la partition Partition : tout le reste lui est donc inaccessible. C'est dans cette partition que vous écrirez vos programmes.
Lorsque vous visiterez des sites, la partition Cache sera alors activée. 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.


USM.INI et USMRESS.INI

  • usm.ini

    Il configure Scol.
    A rédiger
  • usmress.ini

    Il fournit des ressources accessibles à toutes les VM Scol (excepté le numéro de licence). On peut y ajouter des ressources personnelles mais celles-ci ne seront accessibles qu'au VM locales puisque les autres ordinateurs ne les connaissent pas.
    A compléter


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". C'est un fichier généré lorsque j'avais lancé le script "tutoriel0.scol".

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 dans 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

Double-cliquez sur "launch.scol" si vous êtes sous Windows, lancez le script si vous êtes sous Linux.

Le fichier 'launch.scol' contient :

_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"

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, continue 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 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 etn 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.

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.


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.
...
C'est pourquoi une fonction ne doit jamais retourner toujours 'nil' pour ne pas arrêter le compilateur.

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