Petit guide de VB6 vers Tcl

  Version franaise du VB6 To Tcl mini-HOWTO

  Mark Hubbard

   Digital Connections Inc. [http://www.dcisite.com]

   <markh CHEZ dcisite POINT com>

   Conversion du format HTML au format DocBook v4.1.  : Pradeep Padala

   Adaptation franaise : Berhaut Denis

   +------------------------------------------------------------------------+
   | Historique des versions                                                |
   |------------------------------------------------------------------------|
   | Version v1.0.fr.1.0          | 02 juin 2004          | db              |
   |------------------------------------------------------------------------|
   | Premire traduction franaise                                          |
   |------------------------------------------------------------------------|
   | Version v1.0                 | 2003-04-30            | tab             |
   |------------------------------------------------------------------------|
   | Version initiale, rvise par LDP                                      |
   |------------------------------------------------------------------------|
   | Version 0.9                  | 2003-04-08            | ppadala         |
   |------------------------------------------------------------------------|
   | Conversion au format Docbook                                           |
   |------------------------------------------------------------------------|
   | Version 0.8                  | 2002-07-08            | mark            |
   |------------------------------------------------------------------------|
   | Document original                                                      |
   +------------------------------------------------------------------------+

   Rsum

   Un tour de Tcl en 15 minutes pour programmeurs Visual Basic et VBScript.

   --------------------------------------------------------------------------

   Table des matires

   1. Introduction

   2. Exemples

   3. Pour plus d'information

   4. Licence et droits d'auteur

1.  Introduction

   Programmeurs VB and VBScript : Je sais ce que vous ressentez. Vraiment. En
   tant que Microsoft Certified Professional en VB6, j'ai pratiqu ces
   langages pendant sept ans. Je les ai vraiment aims, jusqu' ce que je
   saute le pas pour Tcl et que je commence  remarquer les diffrences de
   flexibilit qui sont prsentes ici. Si Tcl vous parat compltement
   tranger, et que vous vous demandez comment une chose pareille peut
   exister, attendez d'avoir vu un morceau de code C ou un script de shell
   UNIX. Je pense que ce sont eux qui l'ont le plus influenc. Les scripts
   shell UNIX sont beaucoup plus avancs que les scripts shell MS Windows, y
   compris ceux de NT/2000. En fait, les scripts Unix ont une grande partie
   des fonctionnalits montres ici. Tcl et les scripts shell sont tous les
   deux largement bass sur des substitutions de chanes. J'ai choisi
   d'tudier Tcl plutt que les scripts shell parce que le code Tcl est
   beaucoup plus verbeux et semblable  l'anglais (et donc maintenable) que
   les scripts shell, qui ont tendance  tre obscurs. Certains noms
   d'instructions de script consistent uniquement en de la ponctuation!

   Tcl tourne aussi sur les 'quatre grandes' plate-formes pour PC (Linux,
   *nix, Windows, Mac) comme sur d'autres. Java(tm) le promet, mais Tcl l'a
   fait (sinon plus). Contrairement  Java et VB, Tcl n'est soumis  aucune
   influence commerciale (ce qui le rend vraiment libre,pas seulement
   'gratuit') ; au fil des annes son dveloppement a coll  vos besoins et
   vos dsirs, vous les dveloppeurs et dveloppeurs potentiels. Aucune
   socit n'a tir Tcl en dehors de ce chemin pour son intrt d'entreprise.
   Le contraste le plus important entre Tcl et VB est que mme les
   diffrences techniques expliques plus bas peuvent tre clipses par Tcl

2.  Exemples

   Tableau 1.  Diffrences

+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                VB6                                                                                                                 |                                                                                                                                         Tcl/Tk 8.3                                                                                                                                          |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Notes/diffrences                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim a as integer dim b as integer a=1 : b=0                                                                                                                                                                                         |set a 1; set b 0                                                                                                                                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Sparateur d'instructions multiples sur une ligne. Tcl utilise un point virgule. On considre gnralement que plusieurs instructions sur une ligne constituent du code mal form, mais on utilise aussi le point virgule pour mettre en commentaire une partie d'une ligne, comme illustr ici.                                                                                                                                                                                                                                  |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|' ceci est une ligne entire                                                                                                                                                                                                        |# ceci est une ligne entire                                                                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Commentaire sur une ligne entire. Ce langage n'a pas besoin non plus d'un espace aprs la marque de mise en commentaire.                                                                                                                                                                                                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim a as integer a=1 'ceci est un commentaire sur la mme ligne qu'une instruction.                                                                                                                                                 |set a 1 ;# ceci est un commentaire sur la mme ligne qu'une instruction.                                                                                                                                                                                                                     |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Commentaire partag avec une instruction sur une ligne. Remarquez le point virgule, utilis comme si le commentaire est une autre instruction sur cette ligne.                                                                                                                                                                                                                                                                                                                                                                    |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string s="/data/docs/vb6_to_tcl.htm"                                                                                                                                                                                       |set s {/data/docs/vb6_to_tcl.htm}                                                                                                                                                                                                                                                            |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une chane entre accolades. Les substitutions en Tcl ne s'effectuent gnralement pas dans une chane entre accolades. Si la chane contient des variables ou d'autres lments qui devraient tre substitus, ce sera diffr, mais on pourra les substituer plus tard. On peut souvent le faire avec des instructions qui mettent en uvre des structures de contrle, comme 'if' or 'while'. Une fois que vous tes familiariss avec les principes de Tcl,faites en sorte d'avoir une comprhension approfondie |
|de ce processus parce que c'est important pour progresser en Tcl.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set s "/data/docs/vb6_to_tcl.htm"                                                                                                                                                                                                                                                            |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une chane entre guillemets. On peut effectuer toutes les substitutions (variables, commandes,antislash)  l'intrieur d'une chane entre guillemets.                                                                                                                                                                                                                                                                                                                                                               |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set s /data/docs/vb6_to_tcl.htm                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une chane hors des guillemets. On peut effectuer toutes les substitutions (variables, commandes,antislash) sur une chane situe  l'extrieur de guillemets. L'interprteur prend simplement la chane comme tant le troisime terme de l'instruction set (deuxime argument de l'instruction set). Ceci marche s'il n'y a pas d'espace ou certains autres caractres dans la chane. A utiliser avec prcaution, en particulier si vous manipulez des donnes saisies par l'utilisateur.                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string s = vbCrLf &"Un logiciel libre n'est pas simplement" &vbCrLf _ &" et seulement'gratuit'" &vbCrLf _ &"mais offre aussi la libert de crer" &vbCrLf _ &"et d'utiliser les meilleurs outils." &vbCrLf                 |set s { Un logiciel libre n'est pas simplement 'gratuit' mais offre aussi la libert de crer et d'utiliser les meilleurs outils. }                                                                                                                                                          |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une chane multi-lignes. Remarquez la syntaxe plus encombre du VB, qui le rend plus difficile  lire que le code Tcl.                                                                                                                                                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string dim t as string s = trim(t)                                                                                                                                                                                         |set s [string trim $t]                                                                                                                                                                                                                                                                       |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une valeur de retour de fonction. Le troisime terme de cette instruction set est entre crochets. Cela signifie qu'il est lui-mme une instruction qui doit tre excute, le rsultat occupant la place du troisime terme de l'instruction set.                                                                                                                                                                                                                                                                   |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string dim t as string s = lcase(trim(t))                                                                                                                                                                                  |set s [string tolower [string trim $t]]                                                                                                                                                                                                                                                      |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation d'une fonction de fonction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim x as double dim y as double x = (y + 10) * 5                                                                                                                                                                                    |set x [expr {($y + 10) * 5}]                                                                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Assignation du rsultat d'une expression mathmatique. L'interprteur Tcl utilise l'instruction expr pour valuer les expressions mathmatiques ou logiques. Beaucoup d'autres instructions telles que 'if' or 'while' utilisent expr. Quand on y recourt explicitement, expr doit comporter un seul argument qui est une chane contenant l'expression (comme prsent ici). Cela peut sembler grossier dans les cas simples, quand vous voulez juste ajouter quelque chose  une variable. Dans ce cas, essayez d'utiliser      |
|l'instruction incr.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string s = s &"ajout de texte rajout"                                                                                                                                                                                     |append s {ajout de texte}                                                                                                                                                                                                                                                                    |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Ajouter une chane  une autre. En VB, c'est l'une des oprations les plus lentes, mais c'est particulirement rapide en Tcl. La vitesse est trs importante ici, parce qu'on effectue souvent cette opration dans des boucles ou des boucles imbriques.                                                                                                                                                                                                                                                                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string dim t as string dim u as string s = "Je demanderai  " & t & " de m'envoyer " & trim(u) & " ainsi que le tarif"                                                                                                     |set s "Ije demanderai  $t de m'envoyer [string trim $u] ainsi que le tarif"                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Construire une chane par substitution.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|print "bonjour"                                                                                                                                                                                                                     |Displays bonjour.                                                                                                                                                                                                                                                                            |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Afficher sur la console (en fait, VB affiche dans un formulaire ou dans la fentre de dbogage.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|sub ma_procedure (byval a as integer, byval b as string)                                                                                                                                                                            |proc ma_procedure {a b} {                                                                                                                                                                                                                                                                    |
| debug.print "Je demanderai  " & b                                                                                                                                                                                                 | debug.print "Je demanderai  " b                                                                                                                                                                                                                                                            |
|end sub                                                                                                                                                                                                                             |}                                                                                                                                                                                                                                                                                            |
|function ma_fonction (byval a as integer, _ optional byval b as string = "Mark") _ as string                                                                                                                                        |proc ma_fonction {a {b Mark}} {                                                                                                                                                                                                                                                              |
| ma_fonction = "Je demanderai  " & b                                                                                                                                                                                               | return "Je demanderai  $b"                                                                                                                                                                                                                                                                 |
|end function                                                                                                                                                                                                                        |}                                                                                                                                                                                                                                                                                            |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Dfinition de procdure. Remarquez qu'en VB, la syntaxe est diffrente pour les procdures et les fonctions. En Tcl,on utilise la commande proc pour dfinir les deux. proc est une instruction ordinaire Tcl qui s'excute comme n'importe quelle autre instruction. Son premier argument est une liste de paramtres Tcl pour la nouvelle procdure. Son deuxime argument est une grande chane qui contient le corps de la nouvelle procdure (le script Tcl en lui-mme). Important : Tcl est sensible  la classe pour      |
|pratiquement toutes les oprations : toutes les rfrences aux noms d'instructions et aux noms de variables, ainsi que par dfaut les comparaisons de chanes de caractres. Ainsi,un appel  Proc provoquera une erreur (P en majuscule),comme le ferait un appel  Ma_procedure , ou faire rfrence  la variable B dans ma_procedure (b tait en minuscule).                                                                                                                                                                  |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                                                                                    |if {$i < 0} {set i 0} {incr i -1}                                                                                                                                                                                                                                                            |
|dim i as integer if i < 0 then i = 0 else i = i - 1                                                                                                                                                                                 |# option possible if {$i < 0} then {set i 0} else {incr i -1}                                                                                                                                                                                                                                |
|                                                                                                                                                                                                                                    |# une autre option if {$i < 0} then { set i 0 } else { incr i -1 }                                                                                                                                                                                                                           |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Excution conditionnelle 'if'. S'ils sont prsents, l'instruction Tcl 'if' ignore les mots-cls facultatifs 'then' et 'else'. Dans la mesure o les deux blocs de codes sont juste des chanes,on peut les entourer d'accolades pour les formater correctement, comme on le voit. Afin d'viter les erreurs de syntaxe, entourez aussi par des accolades toutes les expressions de test non triviales. De cette manire, les substitutions (comme $i dans notre exemple) ne seront prises en compte que lorsque l'instruction 'if'|
|passera l'expression de test  l'analyseur d'expressions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim i as integer i = 1 while i < 2000 i = i * 2 wend                                                                                                                                                                                |set i 1 while {$i < 2000} { set i [expr {$i * 2}] }                                                                                                                                                                                                                                          |
|'option possible i = 1 do while i < 2000 i = i * 2 loop                                                                                                                                                                             |                                                                                                                                                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|'while' loop. Ceci est identique  l'instruction 'if' dans laquelle il prend une expression de test comme premier argument, suivie par une chane de code.                                                                                                                                                                                                                                                                                                                                                                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                                                                                                                                                                                    |for {set i 0} {$i < 9} {incr i} { # neuf rptitions 0-8 puts $i }                                                                                                                                                                                                                           |
|dim i as integer for i = 0 to 8 'neuf rptitions 0-8 debug.print i next                                                                                                                                                            |# option possible for {set i 0} {$i <= 8} {incr i} { # de nouveau, neuf rptitions 0-8 puts $i } # autre option possible for {set i 1} {$i <= 9} {incr i} { # neuf rptitions 1-9 puts $i }                                                                                                |
|                                                                                                                                                                                                                                    |# encore une autre possible - moins lisible set i 1 for {} {[incr i] <= 9} {} { # neuf rptitions 1-9 puts $i }                                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|'for' boucle avec compteur interne. En Tcl (comme dans tous les langages), ceci revient  une boucle 'while'. Dans certains langages comme VB, 'for' n'est pas aussi flexible que 'while'. Ce n'est pas le cas en Tcl. On peut utiliser n'importe quoi comme code d'initialisation, comme expression de test pour for, comme code d'incrmentation. Ces lments ne sont pas rservs  une utilisation particulire,comme vous pouvez le voir dans l'exemple final.                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim c as new collection dim o as object c.add "Mark" c.add "Roy" c.add "Brian" for each o in c debug.print o next                                                                                                                   |set c [list Mark Roy Brian] foreach o $c { puts $o }                                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Boucle  travers des lments d'une structure de donnes. En Tcl, on utilise une structure de donnes en liste. Il n'y a pas d'quivalent direct en VB, mais ce qu'il y a de plus proche est une collection d'objets. Remarquez bien que les collections VB sont, et de loin, plus lentes que les listes Tcl dans des oprations classiques,parce qu'appeler des objets dans des mthodes est plus consommateur de temps systme. Retenez aussi qu'il existe des utilisations bien plus puissantes et cratives de l'instruction  |
|foreach,qui ne sont pas montres ici. Elles n'ont pas d'quivalent direct en VB.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string select case s case "John" debug.print "Mellencamp" case "Steve" debug.print "Tyler" case else debug.print "Inconnu" end select                                                                                      |switch -exact $s { John {puts Mellencamp} Steve {puts Tyler} default {puts Inconnu} }                                                                                                                                                                                                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Excution d'un choix parmi plusieurs. Remarquez que la version Tcl est sensible  la casse. a n'est pas souvent le cas en VB, en fonction de l'option 'option compare' qui est active dans le module. L'option -exact prcise que la chane doit tre exactement concordante,contrairement  une concordance partielle ou  une concordance d'expression rationnelle (qui n'est pas sensible  la casse). Notez aussi qu'il y a de nombreuses d'utilisations puissantes et cratives de l'instruction switch, qui ne sont pas    |
|montres ici.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|on error goto capture debug.print a 'a n'a pas t dclar. ... capture: debug.print err.number, err.description                                                                                                                    |if [catch { puts $a ;# a n' pas t initialis } my_err] { puts "message d'erreur: $my_err" puts "stack trace: $errorInfo" # ces erreurs auraient t montres # de toute faon par la l'interception d'erreur par dfaut. } else { puts {Tout est correct.} # l'autre bloc est facultatif. }|
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Interception d'erreur. En VB, l'interception d'erreurs de faon concise peut poser des problmes, en particulier si des actions diffrentes, dpendant du code impliqu, doivent tre menes. L'instruction Tcl catch rsout clairement ces problmes. De plus,Tcl fournit automatiquement une trace de la pile de code en erreur. en VB, la trace de la pile doit tre explicitement construite dans le code,si l'on dsire en avoir une dans l'application de production (pas dans l'IDE). C'est un avantage pour Tcl quand on  |
|dbogue sur le terrain. Retenez que catch retourne un boolen 1 ou 0, que l'on utilise classiquement avec 'if', comme prsent ici.                                                                                                                                                                                                                                                                                                                                                                                               |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set i [expr $e]                                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Passe une expression mathmatique arbitraire  l'interprteur pour qu'il l'value. Ce peut tre une expression saisie par un utilisateur, ou gnre antrieurement par du code. C'est l'un des aspects les plus puissants de Tcl. En VB,on ne peut pas du tout en disposer.                                                                                                                                                                                                                                                      |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set s [eval $c]                                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Passe un code arbitraire  l'interprteur pour qu'il l'excute. Ce peut tre un script saisi par un utilisateur, ou gnr antrieurement par du code. C'est l'un des aspects les plus puissants de Tcl. En VB,on ne peut pas du tout en disposer.                                                                                                                                                                                                                                                                                |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |source my_script.tcl                                                                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Passe un nom de fichier arbitraire  l'interprteur pour qu'il excute ce fichier comme un script. C'est l'un des aspects les plus puissants de Tcl. En VB,on ne peut pas du tout en disposer.                                                                                                                                                                                                                                                                                                                                    |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set var_name marks_age incr $var_name                                                                                                                                                                                                                                                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Excute des oprations sur une variable choisie arbitrairement. Le code montr ici va modifier la variable age_de_marc . Son nom (la chane "age_de_marc") est stock dans la variable nom_de_variable . En fait, juste avant son excution, chaque lment de chaque instruction est soumis  une tentative de substitution par l'interprteur. Ainsi,n'importe quelle partie d'une instruction (et mme le nom de l'instruction elle-mme) peut tre modifie en fonction des donnes ou d'un autre critre. C'est l'un des     |
|aspects les plus puissants de Tcl. En VB,on ne peut pas du tout en disposer.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim s as string dim li as string dim f_num as integer s = "" f_num = fichierlibre open "mon_fichier.txt" for input as #f_num while not eof(f_num) line input #f_num, li s = s & li & vbCrLf wend close #f_num                       |set f [open mon_fichier.txt r] set s [read $f] close $f                                                                                                                                                                                                                                      |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Lit le fichier entier dans une variable. Ce code VB est trs lent, mme pour des fichiers moyennement gros. Et il n'y aucun moyen de prendre en compte les caractres de saut de ligne. Le code Tcl accepte et prserve les sauts de ligne dans les donnes. Il normalise aussi les diffrents caractres de sauts de ligne en un simple type de caractres de sauts de ligne standardis(par dfaut). Ce code s'applique de faon quivalente  des donnes brutes,  des listes Tcl,  des tableaux Tcl. L'option r dans        |
|l'instruction open indique qu'elle est en mode 'read' (lecture).                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim a(1 to 3) as string a(1) = "Mark" a(2) = "Brian" a(3) = "Roy" 'ae - il me faut plus d'lments redim preserve a(1 to 10) as string a(4) = "John"                                                                               |array set a [list 1 Mark 2 Brian 3 Roy] set a(4) John # maintenant diffrents types # de noms d'lments dans le mme tableau set a(Red) Hat set a(Linux,RedHat) 7.1                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Tableau contre Tableau. En VB, les tableaux sont limits  l'utilisation de nombres comme indices (En Tcl, on appelle 'element names' les indices, ou index). Et la taille d'un tableau doit tre dclare ; pour l'agrandir il faut utiliser l'opration (lente) 'ReDim Preserve'. Les tableaux Tcl s'agrandissent automatiquement, et disposent d'une table de hashage super efficace qui leur permet mme de prendre en charge des centaines de milliers d'lments  une vitesse suprieure. En Tcl, on utilise tous les types|
|de donnes comme nom d'lment, et diffrents types peuvent mme tre mlangs dans le mme tableau. Le nombre de dimensions de chaque lment n'est pas limit. Tcl fournit des moyens simples pour se dplacer dans les tableaux, ou dans certains lments du tableau (par filtrage). Vous pouvez aussi obtenir une liste entire ou partielle des noms d'lments, et faire d'autres oprations plus facilement qu'en VB. En VB, l'utilisation d'une partie de ses possibilits ncessite l'utilisation d'une collection ou   |
|d'un objet de dictionnaire. Chacun d'eux possde ses bizarreries et ses piges, tels qu'une charge plus importante qu'un tableau VB.                                                                                                                                                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |array set mon_tableau $ma_liste set ma_liste [array get mon_tableau]                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Liste vers tableau, et l'inverse. Le transfert facile et rapide entre deux structures de donnes primaires signifie que les outils appliqus  l'un peuvent l'tre  l'autre. Ils multiplient mutuellement leur utilit.                                                                                                                                                                                                                                                                                                          |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|dim a(1 to 100) as string dim i as integer dim f_num as integer f_num = fichierlibre open "mon_fichier.txt" for output as #f_num for i=1 to 100 print #f_num, a(i) next close #f_num                                                |set f [open mon_fichier.txt w] set $f [array get a] close $f                                                                                                                                                                                                                                 |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Ecrit le tableau entier. Dans ce code VB, et frquemment dans d'autres codes VB, les sauts de ligne et d'autres caractres prsents dans les donnes vont provoquer des erreurs  un stade ultrieur (phnomne de relecture). Cela devient un problme si votre code manipule des donnes saisies par un utilisateur. En Tcl, a n'en n'est pas un, les donnes sont conserves tout le temps "proprement". De plus, de nombreuses combinaisons de caractres de retour chariot (0x0 ou dcimal 13) et de saut de ligne (0x0A ou |
|dcimal 10)sont automatiquement normalises par dfaut. Remarquez bien que ces deux exemples ne produisent pas des fichiers identiques en sortie. L'exemple Tcl, comme le VB, crit un fichier texte. Mais le fichier Tcl sera lu (par Tcl) et aura automatiquement le mme nombre d'lments, les mmes noms d'lments, etc. En Tcl, la structure de donnes en liste est utilise pour cela. S'en servir garantit que les donnes sont formates selon une reprsentation concise, sans ambigut, textuelle. Les humains      |
|peuvent aussi le lire et y crire.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set f [open mon_fichier.txt w] puts $f [array get a blanc*] close $f                                                                                                                                                                                                                         |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Ecrit certains lments d'un tableau. En VB, il faudrait utiliser une collection ou un objet de dictionnaire pour faire a. Une boucle ferait une itration  travers tous les lments et slectionnerait ceux qui sont appropris. En Tcl, le nom du tableau est a et une chane blanc* (sensible  la casse) est utilise comme filtre pour slectionner les lments  grande vitesse.                                                                                                                                        |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set ma_liste [lsort $ma_liste]                                                                                                                                                                                                                                                               |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Trier une liste. Le tri peut tre invers, ou ordonn numriquement, etc... On peut aussi trier une liste de sous-listes en utilisant un lment d'index. Tcl contient une suite complte d'instructions pour manipuler les structures de donnes en liste. Voir aussi lappend , linsert , lreplace , lsearch , concat , split , join , etc. On peut aussi imbriquer arbitrairement les listes Tcl ; l'instruction foreach s'excutera sans problme.                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|' ncessite une rfrence aux ADO ' considre que nous avons une connexion nomme conn dim rs as new recordset rs.open "select id, nom, age from peuple", _ ma_connexion, adOpenStatic ' placer ici le code rs.close set rs=nothing |package require tclodbc # considre que nous avons une connexion nomme conn conn read a "select id, nom, age from peuple" # placer ici le code unset a ;# libration du tableau                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Renvoie un simple tableau de donnes d'une table de base de donnes. En VB, les donnes sont toujours retournes dans un objet 'recordset'. En Tcl,il peut tre renvoy dans un tableau et/ou dans une liste, en fonction de vos besoins et du paquetage de la base de donnes utilis.                                                                                                                                                                                                                                           |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |package require http set httpTrans [http::geturl $pageURL] upvar #0 $httpTrans state if {$state(status) == {ok}} { puts $state(body) }                                                                                                                                                       |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Retourne un document ou un fichier d'un serveur Web.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |regexp -all {src=['"](.+?)['"]} $body mes_images                                                                                                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Recherche et extraction de modles de chanes complexes. En Tcl,on utilise les expressions rationnelles pour cela. Expression rationnelle est une spcification de recherche de concordance de modles de chanes,dont le concept est similaire au modle des cartes magiques utilis avec l'oprateur 'like',  l'exception des strodes, de tous les strodes. Les expressions rationnelles sont plusieurs fois plus puissantes et plus flexibles que les modles 'like'. Pour une initiation informelle aux expressions      |
|rationnelles, voyez http://zez.org/article/articleprint/11 [http://zez.org/article/articleprint/11] . L'analyseur d'expressions rationnelles de Tcl est crit en code C optimis, et on peut l'utiliser au travers de diffrentes instructions Tcl (regexp , regsub , lsearch , etc. Vous pouvez aussi utiliser les versions plus simples, moins puissantes auxquelles vous tes habitus dans diffrentes instructions (glob , string match , lsearch , et d'autres encore). Cet exemple prendrait entre 15 et 50 lignes de code |
|VB, en fonction de la robustesse et de la tolrance  des situations diverses qu'il aurait besoin d'avoir. De plus, c'est l'un des codes les plus difficiles, les plus durs  dboguer, et les plus lents que l'on puisse crire en VB (c'est la voix de l'exprience qui parle). Ici, on obtient rapidement une liste des URLs de toutes les images d'une page HTML.                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set find {<tr>(.*?)<td>(.*?)</td><td>(.*?)</td><td>(.*?)</td>(.*?)</tr>} set replace {<tr>\1<td width=20%>\2</td><td width=40%>\3</td><td width=30%>\4</td>\5</tr>} regsub -all -nocase $exp $body $replace result puts $result                                                              |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Recherche et substitution de modles de chanes complexes. De nouveau, en Tcl,on utilise les expressions rationnelles. Cet exemple prendrait entre 40 lignes de code VB voire plus, en particulier s'il est logiquement organis avec suffisamment de commentaires pour qu'un programmeur charg de la maintenance puisse suivre. Et de plus, c'est l'un des codes les plus difficiles, les plus durs  dboguer, et les plus lents que l'on puisse crire en VB. Ici, le jeu de trois cellules dans chaque ligne du corps du HTML|
|est systmatiquement modifi, tout en laissant le contenu de chaque cellule inchang.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |set handle [socket markhpc.dcisite.com 2000] set bienvenue [read $handle] close $handle                                                                                                                                                                                                      |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Cre une connexion  une interface rseau (en tant que client) et retourne des donnes. Dans l'exemple, nous considrons qu'un serveur coute sur le port TCP 2000 de l'hte spcifi.                                                                                                                                                                                                                                                                                                                                            |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|(Pas d'quivalence)                                                                                                                                                                                                                 |proc bienvenue {handle client_ip client_port} { puts $handle {Bienvenue sur notre serveur d'accueil!} close $handle } socket -server bienvenue 2000                                                                                                                                          |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|Met en oeuvre un serveur rseau pour rpondre au client montr ci-dessus. Voici le script complet. si vous utilisez Wish (le shell fentr Tcl), il tournera toute la journe comme il est prsent. Si vous utilisez Wish (le shell fentr Tcl), ajoutez une instruction vwait  la fin, pour forcer le programme  attendre des vnements plutt que de se terminer  la fin du script. Cette diffrence entre les deux shells est ncessaire et intentionnelle, dans la mesure o Wish est pilot par dfaut par les         |
|vnementset que Tclsh ne l'est pas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

3.  Pour plus d'information

     * Programmation Tcl/Tk et initiation : Lisez l'incroyable livre de Brent
       Welch Practical Programming in Tcl and Tk . Grce  la gnrosit de
       Brent, vous pouvez mme lire et imprimer les vieilles ditions et des
       chapitres slectionns des ditions actuelles sur
       http://www.beedub.com/book [http://www.beedub.com/book] .

     * Tlchargements ncessaires pour dvelopper en Tcl : Voyez
       http://www.tcl.tk [http://www.tcl.tk] pour TclPro 1.4.1 pour tous les
       systmes d'exploitation et  peu prs tous les paquetages
       complmentaires dont vous pourriez avoir besoin. TclPro contient les
       deux interprteurs (Tclsh et Wish) version 8.3, plus un excellent
       dbogueur interactif ainsi qu'un ensemble d'outils et de bibliothques
       trs utiles. La version 1.4.1 est disponible au public. cependant, 
       la mi-2002,il semble que ActiveState [http://www.activestate.com] est
       en train de transformer TclPro en produit commercial. Rappelez-vous
       que vous pouvez toujours obtenir les interprteurs 'standard' pour
       tous les systmes d'exploitation du site http://tcl.sourceforge.net
       [http://tcl.sourceforge.net] tant donn que Tcl est un logiciel open
       source.

     * Editeurs avec coloration syntaxique, etc : Pour travailler sous MS
       Windows, j'apprcie le produit commercial bon march TextPad
       disponible  l'adresse http://www.textpad.com [http://www.textpad.com]
       . Actuellement, il cote 29$ US par licence, et vous pouvez l'essayer
       avant de l'acheter. Tlchargez la dfinition de syntaxe Tcl de leur
       site Web. TextPad est l'diteur pour MS Windows possdant le plus de
       caractristiques que j'ai jamais vues ; il a la capacit d'muler le
       comportement des diteurs de Microsoft. Vous pouvez l'utiliser comme
       IDE (outil de dveloppement) pour Tcl/Tk en l'interfaant avec les
       interprteurs et vos autres outils. Pour Unix/Linux, et peut-tre bien
       mme pour MS Windows, essayez Nedit  l'adresse http://www.nedit.org
       [http://www.nedit.org] . Il est libre, plac sous les termes de la GNU
       General Public License. C'est aussi un bon outil, qui permet aux
       utilisateurs de MS Windows d'tre immdiatement productifs.

     * Des outils auxquelles vous penserez probablement : La premire chose
       que veulent beaucoup de programmeurs VB est d'attaquer une base de
       donnes ODBC. Allez chercher le paquetage TclODBC de http://www.tcl.tk
       [http://www.tcl.tk] . C'est une DLL win32 qui vous permettra d'accder
        toutes les sources de donnes et pilotes ODBC. Il est fourni avec de
       la documentation, et il y a un mini-exemple ci-dessus. Remarquez qu'il
       peut tre comme ne pas tre portable vers d'autres systmes
       d'exploitation, donc vous devriez encapsuler tous les appels que vous
       lui ferez dans des procdures. De cette faon, vous pourrez porter
       votre code pour utiliser d'autres bibliothques plus tard. Les
       expressions rationnelles sont en elle-mme presqu'un langage de
       programmation puissant. De ce fait, il faut un certain temps pour les
       matriser. Le petit programme Tcl 'Visual RegExp' m'a normment aid
       en cela. Vous l'obtiendrez  l'adresse
       http://laurent.riesterer.free.fr/regexp
       [http://laurent.riesterer.free.fr/regexp] . Il y a aussi plusieurs
       paquetages qui relient Tcl au monde d'ActiveX ; ainsi vous pouvez
       automatiser des applications MS Office, etc...

     * Sujets d'aide principaux : Quand vous aurez obtenu TclPro et son
       fichier d'aide, allez  son index et regardez le sujet 'Tcl'. Il y a
       un sommaire des rgles syntaxiques du langage, et des substitutions
       qui le pilotent. Regardez sans faute les sujets suivants :
       're_syntax', 'tclvars', 'tclsh', and 'wish'. A premire vue, ils sont
       transcrits des pages de manuel (man pages)d'Unix/Linux, et constituent
       certains des meilleurs textes que j'ai jamais vu dans les aides de
       Windows ; si vous avez besoin de matriaux de rfrence , je ne vous
       recommande pas de lire ce fichier d'aide pour votre initiation, mais
       c'est une excellente rfrence de programmation.

     * 'Dmarrer' lments du menu : Aprs avoir install TclPro, vous
       devriez regarder le menu 'Dmarrer' de TclPro,et examiner le 'Incr
       Widgets Reference' et le 'Widget Tour'. Ils montrent les possibilits
       de l'interface graphique de Tk avec le code Tcl effectivement
       ncessaire pour les utiliser.

     * Argumentaire (comment convaincre votre direction d'utiliser Tcl/Tk) :
       On trouvera une profusion d'informations convaincantes  l'adresse
       suivante http://www.tcl.tk [http://www.tcl.tk] .

4.  Licence et droits d'auteur

   Copyright (c) 2003 Mark Hubbard.

   Permission est accorde de copier, distribuer et/ou de modifier ce
   document selon les termes de la GNU Free Documentation Licence, version
   1.2 ou ultrieure publie par la Free Software Foundation ; sans section
   modifie, sans texte de couverture de premire ou de dernire page. Une
   copie de la license est disponible  http://www.gnu.org/copyleft/fdl.html
   [http://www.gnu.org/copyleft/fdl.html] , dans la section intitule  GNU
   Free Documentation License  .

   "Visual Basic," "VBScript," et tous les termes relatifs sont la proprit
   de Microsoft http://www.microsoft.com [http://www.microsoft.com] .

   Tcl (Tool Command Language) est un logiciel open source, cr par John
   Ousterhout - http://www.tcl.tk [http://www.tcl.tk] ou
   http://tcl.sourceforge.net [http://tcl.sourceforge.net] .

