Survol de Tcl


Base sur "Practical Programming in Tcl and Tk", Brent Welch, janvier 1995 (DRAFT)

F. Balmas, Decembre 2000

execution
tclsh
pour lancer l'interpreteur Tcl seul
wish
pour lancer l'interpreteur Tcl et Tk
source
pour inclure un fichier source Tcl
au prompt comme dans un fichier 
 source ./file.tcl
exit
pour sortir
#!/usr/local/bin/wish
en tete d'un fichier pour qu'il soit interprete par Tcl/Tk
variables
definition : 
	set foo 5
utilisation : 
	puts $foo
expressions mathematiques
expr
commande a utiliser pour faire tout calcul mathematique 
expr 4 + 5
expr 1 / 3.0
expr 2 * asin(1.0)
operateurs et fonctions
operations de base, operateurs bit a bit, comparateurs et connecteurs logiques
fonctions trigonometriques, log et exponentiations, conversions de formats
substitution de commandes
ou comment recuperer le resultat d'une commande pour en faire autre chose 
set foo [ expr 3 + 7 ]
set pi [ expr 2 * asin(1.0) ]
structures de controle
de maniere generale, avec les structures de controles, il faut respecter la mise en page des blocs
if-then-else 
if { $x == 0 } {
	puts "Error zero division"
} else {
	set z [ expr $y / $x ]
}
while 
set i 0; while { $i<10 } incr i

set i 0
while { $i<10 } {
	puts $i
	incr i
}
for 
for { set i 0 } { $i < 10 } { incr i 3 } {
	puts $i
	}
foreach 
set i 1
foreach value { 2 3 4 5} {
	set i [expr $i * $value] }
switch 
switch -exact $value {
	foo { puts "foo $value" }
	bar { puts "$value bar" }
	default { puts $value }
}
-exact pour comparaison de chaines
-glob pour matching "a la UNIX"
-regexp pour matching d'expressions regulieres
break, continue, return
classiquement comme partout ailleurs, pour controler l'execution d'une boucle et/ou pour quitter une procedure
exit
pour quitter l'interprete
procedures
proc
definition 
proc foo { a b } {
	puts "$a $b" }
proc bar { a b {c 5} } {
	puts "$a $b $c" }
proc fooN { a b args } {	( args  est un mot-cle)
	puts "$a $b"
	puts $args
}
execution 
foo 2 3
	--> 2 3
foo 1
	ERREUR ; no value given for parameter "b" to "foo"
bar 1 2 3
	--> 1 2 3
bar 1 2
	--> 1 2 5
fooN 1 2 3 4 5
	--> 1 2
	    3 4 5
fooN 1 2 3
	--> 1 2
	    3
fooN 1 2  
	--> 1 2
global
pour utiliser une variable globale dans une procedure, il faut la declarer comme telle en tete de la procedure 
set foo 5
proc printfoo { } {
global foo
	puts $foo
}
structures de donnees
chaines
notees avec ou sans guillements
operations sur les chaines avec string ainsi que append 
string length "abc"
	--> 3
string range abcdefg 1 4
	--> bcde
set foo "abc"
append $foo d e f
	--> abcdef
pattern matching de type UNIX 
string match a* "alpha"
	--> 1
string match {[ab]*} abricot
	--> 1
string match {[ab]*} hello
	--> 0
matching d'expressions regulieres 
regexp a+ baaacaa
	--> 1
regexp a+ bbbbbbb
	--> 0
listes
entrees avec des accolades, affichees sans
operations sur les listes (commandes specialisees) 
set foo { 1 2 3 }
 	--> 1 2 3 
set x 4 ; set y 7
list $x $y
	--> 4 7
lindex $foo 1
	--> 2
concat $foo { a b }
	--> 1 2 3 a b
array
index: string, pas seulement nb
operations sur les tableaux avec array 
set TAB(chien) dog
puts $TAB(chien)
set TAB(chat) cat ; set TAB(oiseau) bird
array size TAB
	--> 3
array names TAB
	--> chat oiseau chien
entrees/sorties
puts, gets
afficher et lire 
puts "abc"
puts stdout "abc"       (affiche a l'ecran)
puts $id "abc"		(affiche sur un canal de sortie, cf. plus bas)
gets stdin		(lecture au clavier, ramene le nb de caracteres lus)
gets stdin toto		(lit au clavier et met le resultat dans toto)
gets $id toto		(la meme chose avec un canal d'entree)
open, close 
set id [ open "foo.tcl" r  ]
puts [gets $id]				(lit une ligne)
close $id
read 
set id [ open "foo.tcl" r  ]
set content [ read $id ]		(lit tout le contenu)
puts $content
close $id

while {[gets $id line] >= 0 ] {
	process $line
}
foreach line [split [read $id]] {
	process $line
}
format, scan
analogues a printf, scanf du C
file
looking at the file system
exec
pour executer une commande shell ou tout autre programme 
set d [exec date]
set n [exec sort <file | uniq | wc -l ]
exec my_shell_program $x $y
gestion des erreurs
catch
pour intercepter une erreur et la traiter : catch command var
var contient resultat de la commande ou le message d'erreur
catch vaut 0 (pas d'erreur) sinon 1 
if [catch { open ./exo.tcl r} id] {
	puts "Erreur : $id"
} else {
	set content [ read $id ]
	close $id
}
error
pour provoque intentionnellement une erreur 
proc savediv { a b } {
if { $b == 0 } {
	error "division par zero impossible"
} else {
	return [ expr $a / $b ]
} }
if  [catch { savediv 5 0 } x]  {
	puts "Attention : pas de division par zero"
} else {
	puts $x
}