Programmation Tcl
Et c'est reparti pour de la prog !! Ouais !! 
Tcl est un langage de programmation dont vous
avez sûrement déjà entendu parler. Mais pas tout seul
: on entend parler plus souvent de Tcl/Tk ou de Tcl/Expect etc.
Il faut l'avouer Tcl est loin d'être un langage évolué,
il peut être très intéressant pour débuter en programmation
mais ses capacités sont très limitées. Tcl est la langage
utilisé pour coder les eggdrops (j'entre pas plus dans ce sujet que
je ne maîtrise pas).
Cet article est une suite de trois articles : maintenant nous allons étudier
le langage Tcl, ensuite nous utiliserons Expect qui peut être vu comme
une "extension" de Tcl et pour finir, l'objectif final : nous essayerons
de coder un vers avec ces langages.
Pourquoi choisir Tcl pour faire un worm plutôt que le C ? Premièrement
parce que l'objectif était avant tout de faire un article pas forcément
technique sur les worms. Il s'agissait plutôt de comprendre la façon
dont ils fonctionnent, les différentes étapes etc. Ensuite c'est
mon premier worm donc faut pas s'attendre à une version en C#31337
(c'est une nouvelle version du C LoL).
C parti : les variables
Je le répète : vous n'avez pas besoin d'avoir déjà
programmé pour faire du Tcl. C'est un langage très intuitif
(les instructions sont parlantes). A part ça Tcl est surtout un langage
interprété, tout comme le Perl, le Bash, le PHP. Bref pas de
compilation comme en C, C++... On appelle un programme en Tcl un script.
Pour faire du Tcl vous avez besoin d'un interpréteur Tcl. Celui-ci
se nomme Tclsh. Il peut être utilisé comme un shell, ce qui explique
le 'sh' à la fin de Tclsh.
Tcl est à priori dispo pour Windows, il suffit de le télécharger.
Pour les utilisateurs de Linux, il est déjà installé
(faites un 'whereis tclsh' pour savoir ou se trouve l'interpréteur).
Tcl signifie Tool Command Language. C'est donc un programme qui ne fait qu'appeler
des commandes, tout comme le fait un programme bash ou batch.
Tcl ne manipule que des chaînes de caractères. Bien sûr
on peut générer des nombres, les additionner... mais Tcl les
conserve en mémoire comme étant des chaînes de caractères.
La syntaxe du langage est très simple
;-) :
commande arg arg arg ...
Bref c comme si vous tappiez une commande sous Unix.
Il n'est pas nécessaire de déclarer les variables en Tcl (comme
pour le PHP). Les variables commencent par le caractère dollar ($).
Lorsque l'on fait référence à une variable, Tcl la remplace
par sa valeur et exécute la commande demandée. L'affectation
d'une valeur à une variable ne demande pas la présence du $.
Exemple :
set nom
"Alice"
puts "Mon nom est $nom"
Donnera l'affichage : Mon
nom est Alice
A la première ligne, la variable 'nom' est crée et la valeur
'Alice' lui est attribuée. A la seconde ligne, Tcl remplace '$nom'
par 'Alice' (substitution) et lance la commande
puts qui permet l'affichage de texte à l'écran.
Deuxième exemple :
set jour 23
set mois 11
set annee 2003
set date "$jour:$mois:$annee"
puts $date
Provoque l'affichage : 23:11:2003
Les commandes
Maintenant que nous avons vu la substitution des variables, pourquoi ne pas
étudier la substitution des commandes. Cette méthode, très
utilisée en Tcl, fonctionne de la même façon que pour
les variables : Tcl commence par faire les calculs demandés par la
ou les commandes. Le résultat est une chaîne de caractère
qui vient remplacer les commandes qui l'ont générées.
Tcl effectue ensuite la commande principale. Cela passera mieux avec un exemple
;-)
set ope "puts
HelloWorld"
eval $ope
On obtient : HelloWorld.
La commande eval permet comme son nom l'indique d'évaluer une commande.
Ici on déclare une variable 'ope' qui contient la commande 'puts
HelloWorld'.
La deuxième étape est l'évaluation de cette commande.
Tcl voit qu'il doit évaluer la variable 'ope'. Comme c'est une variable,
il la substitue par sa valeur : 'puts HelloWorld'
puis il lance la commande obtenue.
Une autre façon de faire des substitutions de commandes est d'utiliser
des crochets. Dans l'exemple suivant nous appelons la commande expr qui permet
d'effectuer des opérations mathématiques.
set euros 15
set francs [expr $euros*6.55957]
puts $francs
donne 98.39355.
Les crochets remplacent donc une commande par son résultat.
Quelques précisions à apporter sur la syntaxe de Tcl : tous
les arguments doivent être des chaînes de caractères. Les
arguments doivent être séparés par un espace ou une tabulation.
Les commandes sont soit séparées par un point virgule ou un
retour à la ligne.
Les caractères spéciaux
Il suffit de mettre un backslash devant un caractère pour lui enlever
ou lui rajouter un sens spécial.
set phrase "J'ai
20\$ dans\nmon portefeuille"
puts $phrase
donnera :
J'ai 20$ dans
mon portefeuille
Vous trouverez les caractères spéciaux dans cette annexe.
La commande expr permet d'effectuer beaucoup
d'expressions arithmétiques.
expr 1 == 0 donnera
0 (opération booléenne) expr
5+4 renverra 9.
Les opérateurs arithmétiques et fonctions mathématiques
disponibles sont listées ici.
Une méthode utilisée pour empécher la substitution des caractères spéciaux et donc des variables etc. est l'utilisation des accolades. Les accolades empèchent la substitution. Tout ce qui se trouve entre accolades est pris tel quel, même les passages à la lignes. Reprenons la phrase suivante :
set phrase {J'ai
20$ dans
mon portefeuille}
donne le même résultat que tout à l'heure.
Les commentaires
Ils commencent par le cacarctère dièse (#). Si ils se trouvent
après une instruction cette instruction doit se terminer par un point-virgule.
#Ce script affiche la longueur de la chaine "Hello"
additionné à la valeur 7
set len [expr [string length Hello]
+ 7] ; #deux évaluations de commande
puts $len ;# Affiche 12
Ne vous inquietez pas pour les commandes, elles sont toutes dans l'annexe.
D'autres commandes
unset permet la destruction d'une variable : unset
phrase (on ne met pas le dollar)
append permet de concaténer des variables
set phrase "LOTFREE"
append phrase " n°6"
puts $phrase
donne LOTFREE n°6
La commande format permet de choisir un format
d'affichage de la même façon que les commandes printf en C
set a 24.236784; set b secondes
puts [format "a = %5.3f %s"
$a $b]
donne a = 24.237 secondes
Il existe bien d'autres commandes ce serait trop long de toutes les passer en revue.
Les listes
Les listes constituent une des capacités intéressantes de Tcl.
Les commandes dédiées aux listes commencent généralement
par la lettre 'l'.
Une liste n'est rien de plus qu'un ensemble de chaînes de caractères
séparées par des blancs.
set a 5;# a=5
set liste1 {un deux trois}
;# liste1="un deux trois"
set liste2 "4 $a 6"
;# liste2="4 5 6"
set liste3 [list $liste1 $liste2]
puts liste3 ;# Donne
{un deux trois} {4 5 6}
Les listes permettent d'ajouter des éléments
de façons dynamique et d'y accèder simplement etc.
Malheureusement ça permet pas de tuer ce con de Pikachu !! 
Les tableaux
set montableau(0) "Zéro"
set montableau(1) "Un"
set montableau(2) "Deux"
for {set i 0}{i < 3}{incr i 1}{
puts $montableau($i)
}
donne :
Zéro
Un
Deux
Comme pour le PHP un tableau peut avoir des indices non numériques : set montableau(animal) "Kangourou" ;-)
Les variables d'environnement sont accessibles à travers le tableau prédéfinis 'env'. Ex : puts $env(DISPLAY)
Les tests
Comme dans tout langage de programmation il est possible de faire des branchements
conditionnels.
Les structures possibles sont les suivantes :
if {test} {
instructions_à_effectuer_si_la_condition_est_vérifiée
}
Il est possible d'exécuter des instructions
si la condition n'est pas vrai :
if {test}{
instructions_à_effectuer_si_la_condition_est_vérifiée
} else {
instructions_à_effectuer_si_la_condition_n'est_pas_vérifiée
}
Enfin avec plusieurs tests à la suite
:
if {test_1}{
instructions_à_réaliser_si_la_condition_test_1_est_vrai
} elseif {test_2}{
instructions_à_réaliser_si_la_condition_test_1_n'est_pas_réalisé_mais_que_la_condition_test_2_est_bonne
} else {
instructions_à_effectuer_si_aucune_des_conditions_ne_s'est_réalisée
}
Attention !! On ne peut insérer de sauts de ligne qu'à l'intérieur des accolades alors utilisez-les toujours de la façon que l'on vient de voir.
Pour ce qui est des conditions, ce doit être
des variables dites 'booléennes' (qui prennent comme valeur, soit vrai,
soit faux).
Pour obtenir une valeur booléenne on peut par exemple comparer deux
chiffres.
Inférieur : $a < $b
Supérieur : $a > $b
Egal : $a == $b
Différent : $a != $b
Supérieur ou égal : $a >= $b
Inférieur ou égal : $a <= $b
Vous n'êtes pas obligé de comparer
des variables (ouf !!), vous pouvez comparer une variable avec une valeur
ou deux variables ensembles etc.
if {$nom == "sirius"
} {
...
} elseif { $val < 5}{ ...
Les boucles
La façon dont les boucles sont formées n'est
pas si éloignées des structures conditionnelles. Commençont
par la boucle for :
for {initialisations} {test_de_fin_de_boucle}
{incrémentations}{
corps_de_la_boucle
}
Exemple :
for {set i 0} {$i < 6} {incr
i}{
puts -nonewline $i
}
donnera comme résultat : 012345
L'option nonewline permet simplement de ne pas passer à la ligne à
chaque affichage.
La boucle while, permet de répéter
une instruction (ou une suite d'instructions) tant que la condition générale
est vérifiée.
set i 10
while {$i > 0}{
puts $i
incr i -1
}
feras passer la variable $i de 10 à 0.
Une commande dérivée de la boucle
for est la boucle foreach qui permet de traiter tous les élèments
d'une liste.
foreach variable {liste_de_variables_à_prendre}{
corps_de_boucle
}
exemple :
puts "Les distribs
Linux sont :"
foreach nom {Mandrake RedHat Debian Knoppix Slackware
Suse Caldera}{
puts $nom
}
Affichera les différentes distrib Linux. Cette commande est très
intéressante avec les variables de type liste.
Comme on a pu le constater, à chaque passage dans la boucle la variable
après le mot clé foreach prend pour valeur l'élément
suivant de la liste. L'affectation peut se faire avec deux valeurs :
foreach {style artiste} "Punk
Rancid Ska Ska-p Rap Svinkels" {
puts "$artiste joue du
$style"
}
Les branchements à choix multiples
Ils permettent de comparer une variable à un grand nombre de valeurs.
La syntaxe est : switch chaîne valeur_1 bloc_1 valeur_2 bloc_2 ... valeur_n
bloc_n default bloc_default
Un bloc est le mot pour désigner une suite d'instructions. Voici un
exemple type :
switch $val {
0 {puts "Zéro"}
1 {puts "Un"}
2 {puts "Deux"}
default {puts "Désolé
je ne sais pas traduire ce nombre"}
}
La principale différence avec les autres langages de programmation
c'est qu'il n'y a pas besoin de mettre un "break" à la fin
de chaque bloc.
Toutefois les commandes 'break' et 'continue' existent. 'break' permet de
quitter une boucle for, while ou foreach et 'continue' permet de passer au
prochain tour de boucle sans terminer la boucle en cours.
Les procédures
Pour ce qui connaissent pas le mot 'procédure', et bien
en fait ce sont des fonctions qui renvoient un résultat. Du moins dans
le langage Tcl c'est comme ça puisque les fonctions n'existent pas
chez lui.
proc nom_de_la_procédure {arguments}{
corps_de_la_procédure
}
Bien que les arguments soient entre accolades, il ne s'agit pas forcément
de listes. Cela peut être tout type de variable. Voici une procédure
qui prend un nombre en arguments et renvoie sa valeur au carré :
proc carre {valeur}{
set resultat [expr pow($valeur,2)]
return $resultat
}
Pour appeler cette fonction on peut par exemple faire :
set x 2
puts [carre $x];#La substitution de commandes,
vous vous rappelez j'espère ;-)
et on obtient : 4.0
On aurait obtenu le même résultat
si on n'avait pas mis la commande return. Pourquoi ? Parce que en l'absence
de valeur de retour, Tcl renvoie le résultat de la dernière
commande.
Une procédure qui calcule une moyenne à partir des chiffres
d'une liste :
proc moyenne {liste}{
set longueur [llength $liste]; #On
récupère le nombre de chiffres dans la liste
if {$longueur > 0}{
set somme 0
for {set i 0} {$i <=
[expr $longueur-1]} {incr i}{
incr somme [lindex
$liste $i]; #On fait la somme de tous les chiffres de
la liste
}
append longueur .0 ;#Un
'truc' pour obtenir un réel au final
return [expr $somme/$longueur]
;#Moyenne = somme_des_chiffres / nombre_de_chiffres
}
}
Bon là on a fait une bonne partie. Passons
aux Flux.
Déjà on connait la commande d'écriture sur un flux :
puts
La commande de lecture est gets
Ok on sait lire et écrire mais avant tout il faut ouvrir le flux, pour
cela on utilise la commande open. Quand
on a fini les traitements on appelle la commande close
pour fermer ce flux. Voici un exemple pour illustrer tout cela :
set f [open "l33t.txt"
"w"]
puts $f "It\'s a l33t text"
puts $f "Enjoy it"
close $f
Commençons par la commande 'open'
: le premier argument est le fichier à ouvrir et le second est le mode
d'ouverture. Voici les différents modes d'ouverture d'un fichier :
* r : ouvre le fichier en lecture seulement, le fichier doit déjà
exister.
* r+ : ouvre le fichier en lecture et écriture, le fichier doit déjà
exister.
* w : ouvre le fichier en écriture seulement, il le remet à
0 si il existe déjà sinon il crée un nouveau fichier
* w+ : ouvre le fichier en lecture et écriture, il le remet à
0 si il existe déjà sinon il crée un nouveau fichier
* a : ouvre le fichier en écriture seulement, crée un nouveau
fichier vide s'il n'existe pas, se positionne à la fin du fichier.
* a+ : ouvre le fichier en lecture et écriture, crée un nouveau
fichier vide s'il n'existe pas, se positionne à la fin du fichier.
La commande open
renvoie un 'canal', c'est lui qui représente le flux sur lequel on
va écrire. Bref c'est un 'file descriptor'. La suite du programme est
simple : on écrit deux lignes et on ferme le fichier.
Un exemple de lecture dans un fichier :
set f [open "l33t.txt"
"r"]
set ligne1 [gets $f]
set long_ligne2 [gets $f ligne2]
close $f
puts "ligne
1 : $ligne1"
puts "ligne 2 : $ligne2"
puts "Longueur de la ligne 2 : $long_ligne2"
On obtient :
ligne 1 : It's a l33t text
ligne 2 : Enjoy it
Longueur de la ligne 2 : 8
Et une lecture au clavier :
puts -nonewline "Entrez
votre nom :"
gets sdtin nom
L'utilisation des sockets est presque similaire.
Il suffit d'utiliser la commande socket à la place de open.
Utilisez les nouvelles sections des manpages pour avoir plus d'infos sur les
commandes Tcl. Par exemple faites un "man n socket" sous Linux.
Bon on va pouvoir passer à expect maintenant :-)