Introduction à Tcl
Qu’est-ce que Tcl ?
Tcl (actuellement en version 8.4.1) veut dire ”tool command language” (Langage de commandes outils) et se prononce ”tickle”. Le site ftp de l’auteur du code source de Tcl se trouve sur ftp://ftp.scriptics.com/pub/tcl/.
Tcl consiste en deux choses : un langage et une librairie. D’abord, Tcl est un langage textuel simple, dont le but est principalement de transmettre des commandes à des programmes interactifs tels que des éditeurs de texte, des débuggeurs, des illustrateurs et des shells. Il a une syntaxe simple et est aussi programmable, ainsi les utilisateurs de Tcl peuvent écrire des procédures constituées de commandes pour mettre à disposition des commandes plus puissantes que celles présentes dans le jeu intégré.
Ensuite, Tcl est un package de librairies qui peut être embarqués dans des programmes applicatifs. La librairie Tcl consiste en un analyseur de langage Tcl, en des routines pour implémenter les commandes intégrées à Tcl, et en des procédures qui permettent à chaque application d’étendre Tcl avec des commandes supplémentaires spécifiques à cette application. L’application génère des commandes Tcl et les passe à l’analyseur Tcl pour exécution. Les commandes peuvent être générées à partir de caractères provenant d’une source externe, ou en associant des chaînes de caractères représentant des commandes à des éléments de l’interface utilisateur de l’application, tels que des commandes de menu, des boutons ou des raccourcis clavier. Quand la librairie Tcl reçoit des commandes elle les analyse sous forme de champs composants et exécute les comandes intégrées directement. Pour les commandes implémentées par l’application, Tcl rappelle l’application pour exécution des commandes. Dans la plupart des cas, les commandes invoqueront des appels récursifs à l’interpréteur Tcl en lui passant des chaînes de caractères supplémentaires à exécuter program generates (les procédures, les commandes de boucle et les commandes conditionnelles fonctionnent toute de cette manière).
Une application a beaucoup d’intérêt à utiliser Tcl en tant que son langage de commande. D’abord, Tcl apporte une syntaxe standard : une fois que les utilisateurs connaissent Tcl, ils seront aptes à facilement saisir des commandes dans une application basée sur Tcl. Ensuite, Tcl apporte la programmabilité. Tout ce qu’une application a besoin de faire est d’implémenter quelques commandes de bas niveau spécifiques à l’application. Tcl apporte beaucoup de commandes utilitaires plus une interface générique de programmation pour construire des procédures de commandes complexes. En utilisant Tcl, les applications n’ont pas à implémenter de nouveau ces fonctions. Enfin, des extensions de Tcl, telles que le toolkit Tcl, apportent des mécanismes de communication entre applications reposant sur l’envoi et la réception de commandes Tcl. Le framework commun du langage Tcl facilite la communication des applications entre elles.
Notez que Tcl a été conçu avec la plilosophie suivante : toute personne peut utiliser deux langages ou plus lors de la conception de systèmes logiciels importants. Un pour manipuler des structures complexes de données internes, ou quand la performance est cruciale, et un autre, tel que Tcl, pour écrire des petits scripts qui assemble les autres pièces, en apportant des points de connexion pour permettre des extensions utilisateur. Pour le rédacteur de script Tcl, la facilité d’apprentissage, la facilité de programmation et la facilité d’adhésion sont plus importantes que la performance ou que les aptitudes à gérer des structures de données et des algorithmes complexes. Tcl a été conçu pour faciliter le passage à un langage de bas niveau lorsque vous en arrivez à des tâches ayant plus de sens à un tel niveau. De cette manière, les fonctionnalités basiques du coeur du système peuvent rester réduites et l’on aura qu’à y ajouter les pièces que l’on souhaitera ou dont on aura besoin.
Tk (actuellement en version 8.4.1) est une extension de Tcl qui apporte au programmeur une interface au système de fenêtre X11. Notez que Tk a été compilé avec succès sous X11 R4, X11 R5, X11 R6, tout autant que sous les environnements NeWS/X11 de SUN.
Le site FTP de l’auteur pour obtenir les sources de Tk est à l’adresse : ftp://ftp.scriptics.com/pub/tcl/.
Notez que beaucoup d’utilisateurs rencontreront Tk via la commande “wish“. Wish est un shell simple de fenêtrage qui permet à l’utilisateur d’écrire des applications Tcl dans un environnement de prototypage. Lisez http://www.scriptics.com/people/john.ousterhout/ et http://www.scriptics.com/ (Nouveau Site d’hébergement) pour plus de détails.
Vous pouvez resté au courant des futures évolutions de Tcl en allant sur http://www.scriptics.com/research/tcl/team.html tout comme sur http://www.scriptics.com/.
Tcl est un langage de programmation très simple. Si vous n’avez jamais programmé auparavant, vous pouvez en apprendre assez sur Tcl en quelques heures pour écrire des programmes Tcl intéressants. Cette page apporte un survol rapide des principales fonctions de Tcl. Après avoir lu ceci, vous serez capable de commencer à écrire des scripts Tcl simples par vous-même ; cependant, nous vous recommandons de consulter un des nombreux ouvrages disponibles sur Tcl pour une formation complète.
Syntaxe de Base
Les scripts Tcl sont constitués de commandes séparées par des sauts de ligne ou des point-virgules. Les commandes ont toute la même forme de base illustrée par l’exemple suivant :
expr 20 + 10
Cette commande calcule la somme de 20 et 10 et retourne le résultat, 30. Vous pouvez essayer cet exemple et tous ceux de cette page en les tapant dans une application Tcl telle que tclsh ; quand une commande est exécutée, tclsh affiche son résultat.
Chaque commande Tcl consiste en un ou plusieurs mots séparés par des espaces. Dans cet exemple, il y a quatre mots : expr, 20, + et 10. Le premier mot est le nom de la commande et les autres mots sont les arguments de cette commande. Toutes les commandes Tcl consistent en des mots, mais toutes les commandes ne traitent pas leurs arguments de la même manière. La commande expr traite tous ses arguments ensemble sous forme d’expression arithmétique, calcule le résultat de cette expression et retourne le résultat sous forme de chaîne de caractères. Dans la commande expr la division en mots n’est pas significative : vous auriez pu facilement évoquer la même commande avec :
expr 20+10
Cependant, pour la plupart des commandes, la structure sémantique est importante, avec un objectif donné à chaque mot.
Toute commande Tcl renvoie un résultat. Si une commande n’a pas de résultat significatif alors elle renvoie une chaîne de caractère vide en guise de résultat.
Variables
Tcl vous autorise à stocker des valeurs dans des variables et à utiliser ces valeurs dans plus tard dans des commandes. La commande set est utilisée pour écrire et lire des variables. Par exemple, la commande suivante modifie la variable x et lui attribue la valeur 32 :
set x 32
La commande renvoie la nouvelle valeur de la variable. Vous pouvez lire la valeur de la variable en invoquant set avec un seul argument :
set x
Vous n’avez pas à déclarer les variables en Tcl : une variable est automatiquement créée à sa première attribution de valeur. Les variables Tcl ne sont pas typées : toute variable peut contenir toute forme de valeur.
Pour utiliser la valeur d’une variable dans une commande, utilisez une substitution de variable comme dans l’exemple suivant :
expr $x*3
Quand un $ apparaît dans une commande, Tcl traite les lettres et les chiffres qui le suivent comme constituant le nom de la variable et substitue la valeur de la variable à son nom. Dans cet exemple, l’argument actuel reçu par la commande expr sera 32*3 (en supposant que la variable x a été positionnée comme dans l’exemple précédent). Vous pouvez utiliser la substitution de variable dans tout mot de toute commande, ou même plusieurs fois dans une commande :
set cmd expr
set x 11 $cmd $x*$xSubstitution de commande
Vous pouvez aussi utiliser le résultat d’une commande comme argument d’une autre commande. Cela s’appelle la substitution de commande :
set a 44 set b [expr $a*4]
Quand un [ apparaît dans une commande, Tcl traite ce qui se trouve après et jusqu'au ] correspondant comme étant une commande imbriquée. Tcl évalue la commande imbriquée et substitue son résultat à la commande située entre les crochets. Dans l’exemple ci-dessus le second argument de la deuxiième commande set sera 176.
Guillemets et Accolades
Les guillemets vous permettent de spécifier des mots qui contiennent des espaces. Par exemple, considérez le script suivant :
set x 24 set y 18
set z "$x + $y égale [expr $x + $y]"
Après que ces trois commandes aient été évaluées, la variable z aura la valeur 24 + 18 égale 42. Tout ce qui est placé entre les guillemets est passé à la commande set en tant que mot unique. Notez que (a) des substitutions de commandes et de variables sont effectuées sur le texte situé entre les guillemets, et que (b) les guillemets elles-mêmes ne sont pas passées à la commande. Si les guillemets n’avaient pas été présentes, la commande set auraient reçu 6 arguments, ce qui aurait provoqué une erreur.
Les accolades apportent une autre manière de rassembler des informations en mots. Elles sont différentes des guillemets de part le fait qu’aucune substitution n’est effectuée sur le texte placé à l’intérieure :
set z {$x + $y égale [expr $x + $y]}Cette commande positionne la variable z à la valeur “$x + $y égale [expr $x + $y]“.
Structures de Contrôle
Tcl apporte un ensemble complet de structures de contrôle comprenant des commandes d’exécution conditionnelle, de boucle et procédurales. Les structures de contrôle de Tcl ne sont que des commandes qui prennent des scripts Tcl en tant qu’arguments. L’exemple ci-dessous crée une procédure Tcl appelée power, qui élève une base au rang de nombre entier :
proc power {base p} {
set result 1
while {$p > 0} {
set result [expr $result * $base]
set p [expr $p - 1]
}
return $result
}Ce script consiste en une seule commande, proc. La commande proc prend trois arguments : le nom de la procédure, une liste de noms d’arguments et le corps de la procédure, qui est un script Tcl. Notez que tout ce qui est placé entre l’accolade de la fin de la première ligne et celle de la dernière ligne est passé mot pour mot à proc en tant que simple argument. La commande proc crée une nouvelle commande Tcl nommée power qui prend deux arguments. Vous pouvez alors invoquer power par le biais de commandes telles que :
power 2 6 power 1.15 5
Quand power est appelée, le corps de la procédure est évalué. Tandis que le corps est exécuté il peut accéder à ses arguments sous forme de variables : base va contenir le premier argument et p le second.
Le corps de la procédure power contient trois commandes Tcl : set, while, et return. La commande while fait le plus gros de la procédure. Elle prend deux arguments, une expression ($p > 0) et un corps, qui est un autre script Tcl. La commande while évalue son argument expression en utilisant les mêmes règles du langage C et si le résultat est vrai (différent de zéro) alors elle évalue le corps en tant que script Tcl. Elle répète cette boucle jusqu’à ce que l’expression devienne éventuellement fausse (zéro). Dans ce cas, le corps de la commande while multiplie la valeur résultante par base puis décrémente p. Lorsque p atteind zéro, le résultat contient la puissance désirée de base. La commande return impose à la procédure de s’arrêter avec la valeur de la variable result en guise de résultat de la procédure.
D’où viennent les commandes ?
Comme vous l’avez vu, toutes les fonctionnalités intéressantes de Tcl sont représentées par des commandes. Les instructions sont des commandes, les expressions sont évaluées par l’exécution des commandes, les structures de contrôle sont des commandes et les procédures sont des commandes.
Les commandes Tcl sont créées de trois manières. Un premier groupe de commandes est fourni par l’interprêteur Tcl lui-même. Ces commandes sont appelées commandes internes. Elles comprennent toutes les commandes que vous avez vues jusqu’ici et plein d’autres (voir plus bas). Les commandes internes sont présentes dans toute application Tcl.
Le second groupe de commandes est créé en utilisant le mécanisme d’extension de Tcl. Tcl apporte des API qui vous permettent de créer une nouvelle commande en écrivant une procédure de commandes en C ou en C++ qui implemente la commande. Vous enregistrer alors la procédure avec l’interprêteur Tcl en indiquant à Tcl le nom de la commande que la procédure implémente. Par la suite, lorsque ce nom particulier est utilisé en guise de commande Tcl, Tcl appélera votre procédure afin d’exécuter la commande. Les commandes internes sont aussi implémentées en utilisant ce même mécanisme d’extension ; leurs procédures font simplement partie de la librairie Tcl.
Quand Tcl est utilisé au sein d’une application, l’application incorpore ses fonctions clés dans Tcl en utilisant le mécanisme d’extension. Ainsi le panel de commandes disponibles varie d’une application à une autre. Il y a aussi de nombreux packages d’extension qui peuvent être incorporés dans une application Tcl. Une des extensions les plus connues est Tk, qui apporte des moyens puissants de construire des interfaces graphiques utilisateurs. D’autres extensions apportent la programmabilité orientée objet, l’accès aux bases de données, plus de possibilités graphiques et une variété d’autres fonctions. Un des plus grands avantages de Tcl dans la construction d’applications vouées à l’intégration tient dans la facilité avec laquelle il peut être étendu de façon à incorporer de nouvelles fonctions ou à communiquer avec d’autres ressources.
Le troisième groupe de commandes consiste en des procédures créées avec la commande proc, telle que la commande power créée précédemment. Généralement, les extensions sont utilisées pour des fonctions de bas niveau où la programmation en C est plus adaptée, et les procédures sont utilisées pour des fonctions de haut niveau où il est plus facile d’écrire en Tcl.
Autres fonctions
Tcl contient beaucoup d’autres commandes que celles utilisées dans les exemples précédents. Voici un extrait de quelques-unes des fonctions fournies par les commandes internes de Tcl :
- Plus de structures de contrôle, telles que
if,for,foreachetswitch. - Manipulation de chaînes de caractères, comprenant un mécanisme puissant de comparaison d’expressions régulières. Des chaînes de caractères à longueur arbitraires peuvent être manipulées aussi facilement que des nombres.
- I/O, comprenant fichiers sur disque, sockets réseau, et périphériques tels que les ports série. Tcl offre des facilités particulièrement simples pour la communication par socket sur Internet.
- Gestion de fichier : Tcl fournit plusieurs commandes de manipulation de noms de fichiers, de lecture et d’écriture des attributs de fichier, de copie, de suppression de fichiers, de création de répertoires, et ainsi de suite.
- Appel de sous-programmes : vous pouvez lancer d’autres applications avec la commande
execet communiquer avec ceux-ci pendant leur exécution. - Listes : Tcl facilite la création de suite de valeurs (listes) et leur manipulation de diverses manières.
- Tableaux : vous pouvez créer des valeurs structurées consistant en des paires nom-valeur avec des valeurs de chaînes arbitraires pour les noms et les valeurs.
- Manipulation de l’heure et de la date.
- Evénements : Tcl permet à des scripts d’attendre qu’un certain événement apparaisse, tel qu’une durée ou la disponibilité d’une donnée sur un dispositif réseau.
Textes originaux en anglais sur www.tcl.tk : Introduction to Tcl
Chargement
Commentaires récents