A present le programme marche a moiti=E9, c=B4est a dire le fichier xml
qui est gener=E9 par le programme n=B4est pas lu jusqu=B4a la fin.
J=B4arrive pas a determiner le pourquoi.Donc le parcoursdu fichier
n=B4est pas effectu=E9 jusqu=B4a la fin par l=B4algorithme de parcours del
a structure de donn=E9es....
Quelqu=B4un pourrait il avoir une id=E9e?
Merci
Ci-dessous le code:
use strict;
use warnings;
use XML::Writer;
my $xml_var;
my $xml_write =3D new XML::Writer(OUTPUT =3D> \$xml_var,
DATA_MODE =3D> 1, DATA_INDENT =3D> 2);
A present le programme marche a moitié, c´est a dire le fichier xml qui est generé par le programme n´est pas lu jusqu´a la fin. J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier n´est pas effectué jusqu´a la fin par l´algorithme de parcours del a structure de données....
Quelqu´un pourrait il avoir une idée? Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) { for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) { for my $u_ptr ( @{ $i_ptr->{'bal'} } ) { for my $a_ptr (@{ $u_ptr->{'bal'} }) { for my $b_ptr (@{ $a_ptr->{'bal'} }) {
- le programme fonctionne sur une structure "$xml_mem" ("Hash-of-Array-of-Hash-of..." généré par XML::Simple). - avec chaque boucle "for" on descend un niveau dans la structure. - l'élément {'bal'} correspond à une balise <bal> dans le XML. - l'algorithme descend jusqu'à une certain profondeur dans la structure, la profondeur est limité par le nombre de boucles "for" dans l'algorithme.
Dans ma réponse du 17 Août 2006 ("analyse tres complexe de fichier perl") sur ce forum fr.comp.lang.perl j'ai donné (parmi autres) 3 liens de documentation qui sont indispensable pour la compréhension du programme:
Je propose que vous donnez plus de détails des règles de composition de ce fichier. Avec des détails supplémentaires, on pourrait peut-être proposer une autre solution, même, si nécessaire, une autre stratégie.
En ce qui concerne la stratégie: je reviens sur ma réponse du 17 Août 2006:
Avec ma demarche en utilisant XML::Simple, il est probable que l'analyse sera géné par d'autres données, mais je voudrais signaler que XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/ modules XML.
[ snip ]
Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers { mx0_0_asx { interfaces {
[ snip de 600 lignes ]
Merci de réduire la taille du fichier DATA, tel qu'il est, il est définitivement trop gros.
lepetitjoe@caramail.com wrote:
Bonjour,
J´ai eu à poster un message sur ce forum concernant l´analyse d´un
fichier en Perl, le lien est celui ci
A present le programme marche a moitié, c´est a dire le fichier xml
qui est generé par le programme n´est pas lu jusqu´a la fin.
J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier
n´est pas effectué jusqu´a la fin par l´algorithme de parcours del
a structure de données....
Quelqu´un pourrait il avoir une idée?
Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) {
for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) {
for my $u_ptr ( @{ $i_ptr->{'bal'} } ) {
for my $a_ptr (@{ $u_ptr->{'bal'} }) {
for my $b_ptr (@{ $a_ptr->{'bal'} }) {
- le programme fonctionne sur une structure "$xml_mem"
("Hash-of-Array-of-Hash-of..." généré par XML::Simple).
- avec chaque boucle "for" on descend un niveau dans la structure.
- l'élément {'bal'} correspond à une balise <bal> dans le XML.
- l'algorithme descend jusqu'à une certain profondeur dans la
structure, la profondeur est limité par le nombre de boucles "for"
dans l'algorithme.
Dans ma réponse du 17 Août 2006 ("analyse tres complexe de fichier
perl") sur ce forum fr.comp.lang.perl j'ai donné (parmi autres) 3
liens de documentation qui sont indispensable pour la compréhension du
programme:
Je propose que vous donnez plus de détails des règles de composition
de ce fichier. Avec des détails supplémentaires, on pourrait
peut-être proposer une autre solution, même, si nécessaire, une
autre stratégie.
En ce qui concerne la stratégie: je reviens sur ma réponse du 17
Août 2006:
Avec ma demarche en utilisant XML::Simple, il est probable
que l'analyse sera géné par d'autres données, mais je
voudrais signaler que XML::Simple n'est qu'une première
stratégie/module parmi des centaines des stratégies/
modules XML.
[ snip ]
Il est probable qu'il existe autres stratégies/modules
XML qui sont beaucoup mieux adapté au problème
(peut-être XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers {
mx0_0_asx {
interfaces {
[ snip de 600 lignes ]
Merci de réduire la taille du fichier DATA, tel qu'il est, il est
définitivement trop gros.
A present le programme marche a moitié, c´est a dire le fichier xml qui est generé par le programme n´est pas lu jusqu´a la fin. J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier n´est pas effectué jusqu´a la fin par l´algorithme de parcours del a structure de données....
Quelqu´un pourrait il avoir une idée? Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) { for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) { for my $u_ptr ( @{ $i_ptr->{'bal'} } ) { for my $a_ptr (@{ $u_ptr->{'bal'} }) { for my $b_ptr (@{ $a_ptr->{'bal'} }) {
- le programme fonctionne sur une structure "$xml_mem" ("Hash-of-Array-of-Hash-of..." généré par XML::Simple). - avec chaque boucle "for" on descend un niveau dans la structure. - l'élément {'bal'} correspond à une balise <bal> dans le XML. - l'algorithme descend jusqu'à une certain profondeur dans la structure, la profondeur est limité par le nombre de boucles "for" dans l'algorithme.
Dans ma réponse du 17 Août 2006 ("analyse tres complexe de fichier perl") sur ce forum fr.comp.lang.perl j'ai donné (parmi autres) 3 liens de documentation qui sont indispensable pour la compréhension du programme:
Je propose que vous donnez plus de détails des règles de composition de ce fichier. Avec des détails supplémentaires, on pourrait peut-être proposer une autre solution, même, si nécessaire, une autre stratégie.
En ce qui concerne la stratégie: je reviens sur ma réponse du 17 Août 2006:
Avec ma demarche en utilisant XML::Simple, il est probable que l'analyse sera géné par d'autres données, mais je voudrais signaler que XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/ modules XML.
[ snip ]
Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers { mx0_0_asx { interfaces {
[ snip de 600 lignes ]
Merci de réduire la taille du fichier DATA, tel qu'il est, il est définitivement trop gros.
Klaus
wrote:
Bonjour,
J´ai eu à poster un message sur ce forum concernant l´analyse d´un fichier en Perl, le lien est celui ci
A present le programme marche a moitié, c´est a dire le fichier xml qui est generé par le programme n´est pas lu jusqu´a la fin. J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier n´est pas effectué jusqu´a la fin par l´algorithme de parcours del a structure de données....
Quelqu´un pourrait il avoir une idée? Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) { [ ... ] for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) { [ ... ] for my $u_ptr ( @{ $i_ptr->{'bal'} } ) { [ ... ] for my $a_ptr (@{ $u_ptr->{'bal'} }) { [ ... ] for my $b_ptr (@{ $a_ptr->{'bal'} }) { [ ... ]
- L'algorithme travaille sur une structure $xml_mem (du genre "Hash-of-Array-of-Hash-of...") qui est générée par XML::Simple - L'élément {'bal'} correspond à une balise <bal> dans le fichier XML - Avec chaque boucle "for" dans l'algorithme, on descend un niveau dans la structure, la profondeur maximale est limité par le nombre des boucles "for".
Pour comprendre le fonctionnement du programme, il est indispensable de comprendre d'abord les 3 documents suivants: http://perl.enstimac.fr/DocFr/perllol.html http://search.cpan.org/~josephw/XML-Writer-0.600/Writer.pm http://search.cpan.org/~grantm/XML-Simple-2.14/lib/XML/Simple.pm
Comme déjà signalé dans ma réponse du 17 Août 2006 ("analyse tres complexe de fichier perl") dans ce forum fr.comp.lang.perl:
Avec ma demarche en utilisant XML::Simple, il est probable que l'analyse sera géné par d'autres données, mais je voudrais signaler que XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/modules XML. [...] Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers { mx0_0_asx { interfaces {
[ snip de 600 lignes ]
Le fichier DATA est trop gros. Il faut réduire la taille du fichier et donner plutôt les règles de composition du fichier.
lepetitjoe@caramail.com wrote:
Bonjour,
J´ai eu à poster un message sur ce forum concernant l´analyse d´un
fichier en Perl, le lien est celui ci
A present le programme marche a moitié, c´est a dire le fichier xml
qui est generé par le programme n´est pas lu jusqu´a la fin.
J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier
n´est pas effectué jusqu´a la fin par l´algorithme de parcours del
a structure de données....
Quelqu´un pourrait il avoir une idée?
Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) {
[ ... ]
for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) {
[ ... ]
for my $u_ptr ( @{ $i_ptr->{'bal'} } ) {
[ ... ]
for my $a_ptr (@{ $u_ptr->{'bal'} }) {
[ ... ]
for my $b_ptr (@{ $a_ptr->{'bal'} }) {
[ ... ]
- L'algorithme travaille sur une structure $xml_mem (du genre
"Hash-of-Array-of-Hash-of...") qui est générée par XML::Simple
- L'élément {'bal'} correspond à une balise <bal> dans le fichier
XML
- Avec chaque boucle "for" dans l'algorithme, on descend un niveau dans
la structure, la profondeur maximale est limité par le nombre des
boucles "for".
Pour comprendre le fonctionnement du programme, il est indispensable de
comprendre d'abord les 3 documents suivants:
http://perl.enstimac.fr/DocFr/perllol.html
http://search.cpan.org/~josephw/XML-Writer-0.600/Writer.pm
http://search.cpan.org/~grantm/XML-Simple-2.14/lib/XML/Simple.pm
Comme déjà signalé dans ma réponse du 17 Août 2006 ("analyse tres
complexe de fichier perl") dans ce forum fr.comp.lang.perl:
Avec ma demarche en utilisant XML::Simple, il est
probable que l'analyse sera géné par d'autres données,
mais je voudrais signaler que XML::Simple n'est qu'une
première stratégie/module parmi des centaines des
stratégies/modules XML.
[...]
Il est probable qu'il existe autres stratégies/modules XML
qui sont beaucoup mieux adapté au problème (peut-être
XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers {
mx0_0_asx {
interfaces {
[ snip de 600 lignes ]
Le fichier DATA est trop gros. Il faut réduire la taille du fichier et
donner plutôt les règles de composition du fichier.
A present le programme marche a moitié, c´est a dire le fichier xml qui est generé par le programme n´est pas lu jusqu´a la fin. J´arrive pas a determiner le pourquoi.Donc le parcoursdu fichier n´est pas effectué jusqu´a la fin par l´algorithme de parcours del a structure de données....
Quelqu´un pourrait il avoir une idée? Merci
Ci-dessous le code:
for my $r_ptr ( @{ $xml_mem->{'bal'}->[0]->{'bal'} } ) { [ ... ] for my $i_ptr ( @{ $r_ptr->{'bal'}->[0]->{'bal'} } ) { [ ... ] for my $u_ptr ( @{ $i_ptr->{'bal'} } ) { [ ... ] for my $a_ptr (@{ $u_ptr->{'bal'} }) { [ ... ] for my $b_ptr (@{ $a_ptr->{'bal'} }) { [ ... ]
- L'algorithme travaille sur une structure $xml_mem (du genre "Hash-of-Array-of-Hash-of...") qui est générée par XML::Simple - L'élément {'bal'} correspond à une balise <bal> dans le fichier XML - Avec chaque boucle "for" dans l'algorithme, on descend un niveau dans la structure, la profondeur maximale est limité par le nombre des boucles "for".
Pour comprendre le fonctionnement du programme, il est indispensable de comprendre d'abord les 3 documents suivants: http://perl.enstimac.fr/DocFr/perllol.html http://search.cpan.org/~josephw/XML-Writer-0.600/Writer.pm http://search.cpan.org/~grantm/XML-Simple-2.14/lib/XML/Simple.pm
Comme déjà signalé dans ma réponse du 17 Août 2006 ("analyse tres complexe de fichier perl") dans ce forum fr.comp.lang.perl:
Avec ma demarche en utilisant XML::Simple, il est probable que l'analyse sera géné par d'autres données, mais je voudrais signaler que XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/modules XML. [...] Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
__DATA__
logical-routers { mx0_0_asx { interfaces {
[ snip de 600 lignes ]
Le fichier DATA est trop gros. Il faut réduire la taille du fichier et donner plutôt les règles de composition du fichier.
lepetitjoe
En fait , regle de composition du fichier il n´y en a pas en tant que tel, ce fichier est generé automatiquement par un serveur et moi utilisateur je n´ai aucune influence sur la composition du fichier. Donc je ne peux pas exactement vous dire sur quelles bases le fichier est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la lecture de la structure XML . Merci bien
En fait , regle de composition du fichier il n´y en a pas en tant que
tel, ce fichier est generé automatiquement par un serveur et moi
utilisateur je n´ai aucune influence sur la composition du fichier.
Donc je ne peux pas exactement vous dire sur quelles bases le fichier
est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la
lecture de la structure XML .
Merci bien
En fait , regle de composition du fichier il n´y en a pas en tant que tel, ce fichier est generé automatiquement par un serveur et moi utilisateur je n´ai aucune influence sur la composition du fichier. Donc je ne peux pas exactement vous dire sur quelles bases le fichier est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la lecture de la structure XML . Merci bien
Klaus
wrote:
En fait , regle de composition du fichier il n´y en a pas en tant que tel, ce fichier est generé automatiquement par un serveur et moi utilisateur je n´ai aucune influence sur la composition du fichier. Donc je ne peux pas exactement vous dire sur quelles bases le fichier est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la lecture de la structure XML .
Comme déjà dit, pour comprendre le fonctionnement de mon programme, il est indispensable de comprendre d'abord les 3 documents suivants:
Mais pour analyser un fichier log avec Perl et XML, vous n'êtes pas obligé d'utiliser la méthode XML::Simple dans mon programme.
La méthode XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/modules XML sous Perl. Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
lepetitjoe@caramail.com wrote:
En fait , regle de composition du fichier il n´y en a pas en tant que
tel, ce fichier est generé automatiquement par un serveur et moi
utilisateur je n´ai aucune influence sur la composition du fichier.
Donc je ne peux pas exactement vous dire sur quelles bases le fichier
est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la
lecture de la structure XML .
Comme déjà dit, pour comprendre le fonctionnement de mon programme,
il est indispensable de comprendre d'abord les 3 documents suivants:
Mais pour analyser un fichier log avec Perl et XML, vous n'êtes pas
obligé d'utiliser la méthode XML::Simple dans mon programme.
La méthode XML::Simple n'est qu'une première stratégie/module parmi
des centaines des stratégies/modules XML sous Perl. Il est probable
qu'il existe autres stratégies/modules XML qui sont beaucoup mieux
adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)
En fait , regle de composition du fichier il n´y en a pas en tant que tel, ce fichier est generé automatiquement par un serveur et moi utilisateur je n´ai aucune influence sur la composition du fichier. Donc je ne peux pas exactement vous dire sur quelles bases le fichier est composé.
Mon probleme est de detecter exactement ce qui bloque la suite de la lecture de la structure XML .
Comme déjà dit, pour comprendre le fonctionnement de mon programme, il est indispensable de comprendre d'abord les 3 documents suivants:
Mais pour analyser un fichier log avec Perl et XML, vous n'êtes pas obligé d'utiliser la méthode XML::Simple dans mon programme.
La méthode XML::Simple n'est qu'une première stratégie/module parmi des centaines des stratégies/modules XML sous Perl. Il est probable qu'il existe autres stratégies/modules XML qui sont beaucoup mieux adapté au problème (peut-être XML::Twig ? -- ou XML::TokeParser ?)