Tdom

Pour parser du XML, j'utilise tDOM qui provient de http://www.tdom.org

Références sur le Wiki anglophone : http://wiki.tcl.tk/2?tDOM

Par rapport à TclDOM, référencé dans Utiliser XML et XSLT,

tDOM est assurément très rapide (pas fait de comparaison de vitesse mais ça pulse),
il est écrit en C et comporte donc une extension binaire, ce qui est une contrainte de déploiement
tDOM est différent... pas de portabilité directe de TclDOM vers tDOM ni vice-versa

Rudiments d'utilisation pour explorer du XML, qui contiendrait des balises <categorie> et <maproc>.

Dans cet exemple, j'encapsule du code Tcl à l'intérieur d'une section CDATA.

  # exploration (parse) de code XML avec tDOM
  # exemple employant des balises simples et une section CDATA

  # procédure récursive d'exploration
  proc xml_explore { node {lvl 0} {hierlist {}} } {
     set type [$node nodeType]
     set name [$node nodeName]
     set value [$node nodeValue]

     if {$type != "ELEMENT_NODE" } then {
       return
     }
     switch $name {
         "categorie" {
             xml_parsecategorie $node
         }
         "maproc" {
             xml_parsemaproc $node
         }
     }
     # conserver la hiérarchie des noeuds (utile pour faire proc de debug contextuel)
     set nodehierlist [concat $name $hierlist]
     foreach child [$node childNodes] {
         xml_explore $child [expr {$lvl+1}] $nodehierlist
     }
  }

  # procédure pour parser categorie qui aurait un attribut id et un attribut param
  proc xml_parsecategorie { node } {
     set monid [$node getAttribute id]
     set monparam [$node getAttribute param]
	 puts "voici une balise categorie avec id = $monid et param = $monparam"
  }

  # procédure pour parser maproc qui contiendrait un attribut clause
  # et encapsulerait un élément CDATA (texte à prendre tel que, sans
  # analyse)
  proc xml_parsemaproc { node } {
	set clause [$node getAttribute clause]
	if { $clause == "tcltext" } {
		set tcltext [[$node firstChild] nodeValue]
		puts "voici du code tcl, affichons le..."
		puts stdout "tcltext: $tcltext"

		puts stdout "évaluons le ..."
	        eval $tcltext
	}
  }

  package require tdom

  set schematext {<?xml version="1.0" encoding="ISO-8859-1"?>
	<categorie id="premiere" param="grand">
		<maproc clause="tcltext">
			<![CDATA[
			   for { set i 1 } { $i < 100 } { incr i } {
			   		puts stdout "i: $i"
			   }
			   puts stdout "et voilà le travail"
			]]>
		</maproc>
	</categorie>
  }

  set xmldoc [dom parse $schematext]
  set xmlroot [$xmldoc documentElement]

  xml_explore $xmlroot
  $xmldoc delete

VWa

Dans la série "vite fait bien fait", je colle une intervention de RS sur c.l.t.:

 [/tmp]669:cat > test.xml
 <names><name>Peter</name><name>Paul</name><name>Mary</name></names>
 [/tmp]670:tclsh
 % package req tdom
 0.8.0
 % xml::parser p -characterdatacommand chardata
 p
 % proc chardata string {puts $string}
 % p parsefile test.xml
 Peter
 Paul
 Mary
 %

Miko

Voir également Transformation basique de XML en liste Tcl avec tdom.