Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
figus wrote:Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new
SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd",
false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK
non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
entites rencontrees lors de la lecture du xml.
Il y a des implementations apache d'entity resolver par exemple
(xml-commons, implementation des catalogues oasis) et tu peux configurer
tes lecteurs de xml pour qu'ils les utilisent (en SAX, DOM).
Je ne sais pas si JDOM peut utiliser des entity resolver mais comme ils
utilise de maniere sous jacente les autres APIs tu dois pouvoir utiliser
un entity resolver avec.
Fais une recherche sur google a propos d'entity resolver et des
catlogues oasis si tu veux en savoir plus.
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
figus wrote:
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new
SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd",
false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK
non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
entites rencontrees lors de la lecture du xml.
Il y a des implementations apache d'entity resolver par exemple
(xml-commons, implementation des catalogues oasis) et tu peux configurer
tes lecteurs de xml pour qu'ils les utilisent (en SAX, DOM).
Je ne sais pas si JDOM peut utiliser des entity resolver mais comme ils
utilise de maniere sous jacente les autres APIs tu dois pouvoir utiliser
un entity resolver avec.
Fais une recherche sur google a propos d'entity resolver et des
catlogues oasis si tu veux en savoir plus.
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
figus wrote:Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Mon problème est lié à $CHEMIN.
Quand je crée mon DOM, j'ai une erreur de chargement de la DTD.
J'ai partiellement résolu mon problème en forçant le non-chargement de
la DTD externe :
SAXBuilder parser = new
SAXBuilder("org.apache.xerces.parsers.SAXParser");
parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd",
false);
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pourrais ensuite facilement changer le DocType en instantiant
$CHEMIN et valider.
Mais, je n'ai pas l'impression que ce soit possible. J'ai bien lu la doc
de JDOM et il est bien dit que JDOM ne permet pas de garantir un DOM
valide par rapport à une DTD. Et je n'ai rien vu dans les API du JDK
non plus.
Auriez-vous déjà rencontré ce problème ?
Comment l'avez-vous résolu ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Merci d'avance à tous.
En general on utilise un EntityResolver qui est appele pour resoudre les
entites rencontrees lors de la lecture du xml.
Il y a des implementations apache d'entity resolver par exemple
(xml-commons, implementation des catalogues oasis) et tu peux configurer
tes lecteurs de xml pour qu'ils les utilisent (en SAX, DOM).
Je ne sais pas si JDOM peut utiliser des entity resolver mais comme ils
utilise de maniere sous jacente les autres APIs tu dois pouvoir utiliser
un entity resolver avec.
Fais une recherche sur google a propos d'entity resolver et des
catlogues oasis si tu veux en savoir plus.
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Bonjour à tous
Je bosse avec le JDK 1.4.2 et JDOM 1.0.
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
ludo06 wrote:
[je coupe la proposition d'utilisation d'un Entity Resolver]
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
faire et donc ma reponse doit etre a cote de la plaque...
ludo06 wrote:
[je coupe la proposition d'utilisation d'un Entity Resolver]
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
faire et donc ma reponse doit etre a cote de la plaque...
ludo06 wrote:
[je coupe la proposition d'utilisation d'un Entity Resolver]
A la reflexion je ne suis pas sur d'avoir bien saisi ce que tu veux
faire et donc ma reponse doit etre a cote de la plaque...
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Je ne suis pas sûr à 100%, mais il semble que le problème est que ce
document est tout simplement mal formé. Un identifieur ne peut pas
contenir une variable d'environnement comme "$CHEMIN" : ce n'est pas
une uri valide.
Partant de là, la meilleure solution serait, si c'est possible, d'avoir
des documents bien formés...
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Cette solution consiste finalement à générer un document XML bien formé
; pourquoi ne pas faire cette modification avec n'importe quel langage
de script ou en java (inutile de faire l'analyse syntaxique du XML -
que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Je ne suis pas sûr à 100%, mais il semble que le problème est que ce
document est tout simplement mal formé. Un identifieur ne peut pas
contenir une variable d'environnement comme "$CHEMIN" : ce n'est pas
une uri valide.
Partant de là, la meilleure solution serait, si c'est possible, d'avoir
des documents bien formés...
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Cette solution consiste finalement à générer un document XML bien formé
; pourquoi ne pas faire cette modification avec n'importe quel langage
de script ou en java (inutile de faire l'analyse syntaxique du XML -
que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Je souhaite charger et valider des fichiers XML ayant un DOCTYPE du genre
: <!DOCTYPE plugin SYSTEM "$CHEMIN/dtd/plugin.dtd">
Je ne suis pas sûr à 100%, mais il semble que le problème est que ce
document est tout simplement mal formé. Un identifieur ne peut pas
contenir une variable d'environnement comme "$CHEMIN" : ce n'est pas
une uri valide.
Partant de là, la meilleure solution serait, si c'est possible, d'avoir
des documents bien formés...
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir lieu.
Cette solution consiste finalement à générer un document XML bien formé
; pourquoi ne pas faire cette modification avec n'importe quel langage
de script ou en java (inutile de faire l'analyse syntaxique du XML -
que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
Je ne me suis pas intéressé du tout à avoir une URI correcte ou pas en
fait.
<!DOCTYPE plugin PUBLIC "http://monsite.com/mesdtd/plugin.dtd">
et ceci
<!DOCTYPE plugin SYSTEM "dtd/plugin.dtd">
seraient corrects ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution
serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir
lieu.
Cette solution consiste finalement à générer un document XML bien
formé ; pourquoi ne pas faire cette modification avec n'importe quel
langage de script ou en java (inutile de faire l'analyse syntaxique du
XML - que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
Je ne me suis pas intéressé du tout à avoir une URI correcte ou pas en
fait.
<!DOCTYPE plugin PUBLIC "http://monsite.com/mesdtd/plugin.dtd">
et ceci
<!DOCTYPE plugin SYSTEM "dtd/plugin.dtd">
seraient corrects ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution
serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir
lieu.
Cette solution consiste finalement à générer un document XML bien
formé ; pourquoi ne pas faire cette modification avec n'importe quel
langage de script ou en java (inutile de faire l'analyse syntaxique du
XML - que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Ca me permet de voir si le XML est bien formé, mais pas s'il valide la
DTD bien sur.
Je pense (sans être sûr) que Le document n'est *pas* bien formé, s'il
contient une uri incorrecte après le mot clef "SYSTEM".
Je ne me suis pas intéressé du tout à avoir une URI correcte ou pas en
fait.
<!DOCTYPE plugin PUBLIC "http://monsite.com/mesdtd/plugin.dtd">
et ceci
<!DOCTYPE plugin SYSTEM "dtd/plugin.dtd">
seraient corrects ?
J'ai bien une idée, mais si y'a mieux je suis preneur. Ma solution
serait
de générer un fichier temporaire (avec le doctype instantié et
accessible) et de le recharger en DOM. La validation pouvant avoir
lieu.
Cette solution consiste finalement à générer un document XML bien
formé ; pourquoi ne pas faire cette modification avec n'importe quel
langage de script ou en java (inutile de faire l'analyse syntaxique du
XML - que ce document n'est d'ailleurs pas), pour ensuite le parser
normalement ?
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Dans tous les cas le plus sain, à mon avis, reste toujours de ne générer
que des documents bien formé... S'il faut utiliser un niveau
d'indirection, pourquoi ne pas utiliser des mots clefs "PUBLIC" :
<!DOCTYPE plugin PUBLIC "-// my dtd">
et mapper ces identifiants publics avec des uri dans un catalog,
éventuellement géré, depuis EntityResolver, par com.arbortext.Catalog de
Norman Walsh (http://www.arbortext.com/catalog.html). Ca serait XMLment
orthodoxe, sans hackage d'uri.
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Dans tous les cas le plus sain, à mon avis, reste toujours de ne générer
que des documents bien formé... S'il faut utiliser un niveau
d'indirection, pourquoi ne pas utiliser des mots clefs "PUBLIC" :
<!DOCTYPE plugin PUBLIC "-// my dtd">
et mapper ces identifiants publics avec des uri dans un catalog,
éventuellement géré, depuis EntityResolver, par com.arbortext.Catalog de
Norman Walsh (http://www.arbortext.com/catalog.html). Ca serait XMLment
orthodoxe, sans hackage d'uri.
Je suis sur la piste de mon propre Entity Resolver (comme suggéré par
ludo06) qui substituerait un DocType accessible. Comme ça prend place
avant le build du DOM, c'est tout à fait adéquat.
Dans tous les cas le plus sain, à mon avis, reste toujours de ne générer
que des documents bien formé... S'il faut utiliser un niveau
d'indirection, pourquoi ne pas utiliser des mots clefs "PUBLIC" :
<!DOCTYPE plugin PUBLIC "-// my dtd">
et mapper ces identifiants publics avec des uri dans un catalog,
éventuellement géré, depuis EntityResolver, par com.arbortext.Catalog de
Norman Walsh (http://www.arbortext.com/catalog.html). Ca serait XMLment
orthodoxe, sans hackage d'uri.
