Généralités

• Une ligne d’instruction commence toujours par une commande
• Chaque argument est séparé par un espace
• Une ligne peut se terminer par un point-virgule (facultatif sauf si on place un commentaire à la suite)
• Les commentaires commencent par le caractère #
• En Tcl, tout est chaîne de caractères
• Avant d’exécuter la commande, le langage substitue tout ce qui est possible dans la ligne
• L’anti-slash (\) est le caractère d’échappement
• L’anti-slash (\) en fin de ligne est un caractère de continuation de ligne (La ligne suivante est considérée comme écrite sur la même ligne)
• Les arguments passés lors de l’appel d’un script sont accessibles par les variables globales: argc: nombre d’arguments, argv0: nom du script et argv: liste des arguments.

Commandes de base

puts param

• affiche le paramètre à l’écran

set variable valeur*

• Affecter la valeur à la variable. Si valeur n’est pas spécifiée, la commande affiche le contenu de la ‘variable

unset variable

• Détruit la variable

expr* {expression}

• Evalue l’expression (généralement mathématique) passée en paramètre. Les accolades ne sont pas obligatoires mais fortement conseillées pour éviter l’injection de code

Conditions If/Then/Else

if {cond} {
  {cmd1}
} else/elseif {
  {cmd2}
}

Switch

switch var {
  case chaine {
    cmd1}
  default {
    cmd2}
  }

Boucle while

while cond
  cmd

Boucle For

for init cond step
  cmd

break

• Interrompt totalement l’exécution d’une boucle

continue

• Interrompt l’itération courante de la boucle et passe à l’itération suivante

incr var

• Incrémentation

Définition d’une fonction

proc nom arguments {
  code
  return }

• On peut déclarer plusieurs arguments si on les place entre accolades. Lors de l’exécution de la fonction les arguments sont définis en tant que variables locales. Le return est optionnel. Il définit la valeur de retour de la fonction. Si omis, c’est la valeur de retour de la dernière instruction qui est utilisée.

proc nom {arg1 {arg2 defVal}} {
  code
  return }

• La valeur par défaut defVal est assignée à l’argument 2 si la valeur n’est pas définie lors de l’appel de la fonction

proc nom {arg1 args} { 
  code
  return }

• La fonction accepte un nombre variable de paramètres. Les paramètres supplémentaires sont assignés à la variable args (sous forme de liste si plus de 1)

global var

• Crée une variable local var qui est un lien vers la variable globale du même nom

upvar level $param var

• Crée une variable locale var qui pointe vers la variable du niveau supérieur passée en paramètre. level est facultatif et vaut par défaut 1 (1 niveau au dessus). Si level vaut i, on remonte au i-ème niveau supérieur. Si level vaut #i, on va au i-ème niveau sous le niveau global

exec programme args ?&?

• Exécute programme. Les paramètres args sont passés au programme exécuté. Si le symbole & est ajouté à la fin, le programme est exécuté en arrière plan.

open programme

info sous-commande

• Renvoie des infos diverses sur l’environnement. Généralement, renvoie la liste des éléments existants. commands / exists varName / functions / globals / locals / procs / vars / cmdcount / level / patchlevel / script / tclversion / args procname / body procname / default procname arg varName

pid

• Renvoie le PID du script tcl

source fichier

• Charge et exécute le fichier. Utile pour structurer un programme en plusieurs fichiers/modules

cd dir

• change le répertoire courant

pwd

• Affiche le répertoire courant

time {commande} ?count?

• Exécute la commande et renvoie le temps d’exécution. Si count est spécifié, le script est exécuté count fois et time renvoie le temps d’exécution moyen

Substitutions

Tcl procède en 2 étapes:

1. Substitution des expressions (remplacement des variables par leur valeurs) - une seule passe
2. Evaluation des expressions

Double quotes “ “

• Le texte entre quotes est considéré comme un tout.
• Les quotes autorisent les substitutions à l’intérieur des quotes

Accolades { }

• Le texte entre accolades est considéré comme un tout.
• Les accolades désactivent les substitutions à l’intérieur des accolades (sauf dans les cas des expressions)
• Des accolades à l’intérieur d’un bloc quote sont considérées comme un simple caractère (i.e. elles ne désactivent pas la substitution)

Crochets [ ]

• Une commande placée entre crochets est d’abord évaluée avant d’exécuter la ligne complète
• Des crochets à l’intérieur d’un bloc accolades ne sont pas évalués
• Des crochets à l’intérieur d’un bloc quote sont évalués

Commandes liées

Opérateurs

Fonction mathématiques

• abs
• acos
• asin
• atan
• atan2
• bool
• ceil
• cos
• cosh
• double
• entier
• exp
• floor
• fmod
• hypot
• int
• isqrt
• log
• log10
• max
• min
• pow
• rand
• round
• sin
• sinh
• sqrt
• srand
• tan
• tanh
• wide

Transtypage

• double()
• int()
• wide()
• entier()

Listes

Arrays

• En Tcl, on utilise des tableaux associatifs.
• Pour accéder à un élément, on utilise la syntaxe tableau(clé). Exemple set id(prenom) Jérôme' ou puts $id(prenom)

Opérations sur les tableaux

Les fonctions liées aux tableaux sont des sous-commandes de la commande array.

Parcourir un tableau

foreach cle [array names tab] {     // On établit la liste des clés du tableau puis on parcourt chacun des éléments de cette liste
    puts $tab($cle)                // On accède à la valeur correspond à la clé en cours
}

foreach {cle valeur} [array get tab] {     // On crée une liste avec les clés et les valeurs et on parcourt cette liste en récupérant ces infos 2 par 2
    puts $cle          // on accède à la clé
    puts $valeur       // on accède à la valeur
}

Passage d’un tableau en paramètre

Pour passer un tableau en paramètres à une procédure, il faut:

• Passer le nom du tableau (ie sans le $)
• Effectuer un upvar dans la procédure

proc toto tab {
    upvar $tab t     // fonction upvar
    puts $t(cle)     // on accède au tableau
}

toto tableau     // Appel de la procédure avec le nom du tableau

Strings

La commande string nécessite des sous-commandes pour réaliser l’action désirée.

Exemple: string length $myString

Opérations sur les chaînes

Expressions régulières

• regexp expr chaine varMatch varGroup1 varGroup2 …
  • Recherche l’expression régulière expr dans la chaîne.
  • la portion de la chaîne qui correspond à la regexp est stockée dans la variable varMatch
  • Si des groupes sont présents dans la regexp (portions de regexp entre paranthèses), le résultat de chaque groupe est placé dans varGroupi
• regsub expr chaine remplac var
  • Recherche l’expression régulière expr dans la chaîne et remplace toutes les occurrences par la chaîne définie dans remplac
  • Le résultat est retourné dans var

Manipulation de fichiers

Lire/Ecrire dans des fichiers

Manipuler des fichiers/répertoires

• glob pattern: liste les fichier qui correspondent au pattern
• file: Nécessite une des sous-commandes suivantes:
  • Manipulation du nom d’un fichier
    • dirname
    • extension
    • join
    • nativename
    • rootname
    • split
    • tail
  • Information sur un fichier
    • atime
    • executable
    • exists
    • isdirectory
    • isfile
    • lstat
    • mtime
    • owned
    • readable
    • readlink
    • size
    • stat
    • type
    • writable
  • Action sur un fichier/répertoire
    • copy
    • delete
    • mkdir
    • rename

Namespaces & Packages

Namespaces

• Un namespace est un espace dans lequel les variables et procédures dont indépendantes des autres namespaces
• Pour accéder à une variable d’un namespace, on utilise la syntaxe: nomEspace::maVar (en relatif) ou ::nomEspace::maVar (en absolu depuis l’espace global)

Packages

Un package permet d’empaqueter un ensemble cohérent de fonctions, généralement à l’intérieur d’un namespace.

Pour créer et utiliser un package, 3 étapes:

1. Coder le package. Au début du package doit se trouver l’instruction package provide nomPack ?version? pour indiquer à Tcl qu’on fournit le package suivant.
2. Créer un index. L’index est créé avec la commande pkg_mkIndex repertoire ?pattern?. Cette étape a pour effet de créer un fichier pkgIndex.tcl pour permettre à tcl d’indexer le package.
3. Ajouter le répertoire contenant le fichier pkgIndex.tcl à l’une des variables globales auto_path ou tcl_pkgPath. Ces variables contiennent la liste des répertoires que va explorer Tcl pour indexer les packages.

Exemple type d’un package:

package provide monPaquet 1.0		// Annonce à Tcl qu'on fournit le monPaquet en version 1.0
package require autreDependance 2.5    // ce paquet requiert un autre paquet pour fonctionner
 
# Création du namespace
namespace eval ::paqNameSpace {
    namespace export proc1 proc2      // Rend les éléments listés accessible par l'extérieur du namespace
 
    variable maVar1 0                 // Crée une variable globale au namespace
    variable maVar2 "du texte"
}
 
 
# Définition des procédures
proc ::paqNameSpace::proc1 {param} {
    variable maVar1                   // Crée une variable locale qui est un alias vers la var globale du namespace du même nom
 
    // Code
}

Gestion des erreurs

• Une fonction retourne toujours un statut indiquant la présence d’une erreur ou non.
• le statut est retourné implicitement (uniquement en cas d’erreur) ou explicitement (avec les commandes return ou error)
• Tcl propose un mécanisme pour vérifier le statut d’une fonction