Subversion Repositories wimsdev

#!/usr/bin/perl

use strict "vars";

use strict "subs";

use locale;

use warnings;

use Text::Balanced qw (extract_bracketed extract_tagged);

$/ = undef; # slurp

#

###############################################################################

#

#    This file is part of latex2wims

#

#    latex2wims is free software; you can redistribute it and/or modify

#    it under the terms of the GNU General Public License as published by

#    the Free Software Foundation; either version 2 of the License, or

#    (at your option) any later version.

#

#    latex2wims is distributed in the hope that it will be useful,

#    but WITHOUT ANY WARRANTY; without even the implied warranty of

#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#    GNU General Public License for more details.

#

#    You should have received a copy of the GNU General Public License

#    along with latex2wims; if not, write to the Free Software

#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#

###############################################################################

#

my ($FILE, $MACRO, $EMBED, $NUMERO, $doc_DIR, $DIR, $author, $email, $worksheet, $SHEET,$ABOUT, $SUBDIR) ;

my $verbose = 0;

my $depth = 2 ;

my $INDEX = 0 ;

my $TOOLTIP = 0 ;

my $STYLE = '' ;

my $OPTION = '' ;

my $tooltip_prompt = '<img src="gifs/picto.gif" alt="picto" />' ;

$tooltip_prompt='';

my $linkout='' ;

$worksheet= '';

$SHEET = '' ;

$DIR = '';

$doc_DIR = '';

$SUBDIR='1';

my @SECTIONS = qw(document part chapter section subsection subsubsection);

#my @SECTIONS = ( document part entete frame subsection subsubsection );

#TODO biblio dans un fichier séparé si on a rencontré \begin{thebibliography} Non,

# on n'a qu'a mettre cet environnement de type link

#$doc_DIR=$ENV{'w_docdir'};

#$DIR=$ENV{'w_dir'};

#$DIR =~ s/ +//;

push (@ARGV,split(' ', $ENV{'wims_exec_parm'})) if ($ENV{'wims_exec_parm'}) ;

while ($_ = shift (@ARGV))

{

  last if (!/^--/);

     if (/^--style=(.*)$/) { $STYLE   = $1; }

  elsif (/^--macro=(.*)$/) { $MACRO   = $1; }

  elsif (/^--docdir=(.*)$/){ $doc_DIR = $1; }

  elsif (/^--dir=(.*)$/)   { $DIR     = $1; }

  elsif (/^--subdir=(.*)$/){ $SUBDIR  = $1; }

  elsif (/^--embed=(.*)$/) { $EMBED   = $1; }

  elsif (/^--verbose$/)    { $verbose = 1; }

  elsif (/^--author=(.*)$/){ $author  = $1; }

  elsif (/^--email=(.*)$/) { $email   = $1; }

  elsif (/^--worksheet=(.*)$/) { $worksheet   = $1; }

  elsif (/^--tooltip_prompt=(.*)$/) { $tooltip_prompt = $1; }

  elsif (/^--linkout=(.*)$/) { $linkout = $1; }

  elsif (/^--cut=(.*)$/) { @SECTIONS = split(',',$1) ;}

  elsif (/^--help$/) {

   usage(); # includes --help !

    exit 1;

  }

} ;

$FILE = $_;

$DIR = $DIR . '/' if ($DIR) ;

$doc_DIR = $doc_DIR . '/' if ($doc_DIR) ;

my $BASE = $doc_DIR . "doc/$SUBDIR/src";

my $BASE0= $doc_DIR . "doc/$SUBDIR";

my $LOAD = '\reload{<img src="gifs/doc/etoile.gif" alt="rechargez" style="width:20px;height:20px;" />}';

my $FLECHE = '→';

$linkout = "\\doc{module=$linkout}" . $FLECHE if ($linkout) ;

##################################

##Initialisation

#si je rajoute les listes : type=fold : signifierait que les item sont en fold [demande

#d'avoir des titres, ca serait du type description en latex

#pas de titre ? deb fin <ul ... >  </ul>

#type =

#hash contenant les caractéristiques des environnements latex, voir \environmentwims

my %hash_environ = (

  titre  => {},

  style  => {},

  type   => {},

  deb    => {},

  fin    => {},

  parm   => {},

  origin => {},

  list   => {},

  tabular => {},

);

#hash contenant les commandes venant de \defwims, \def & co ou par defaut

my %hash_command = (

  cnt_arg    => {},

  definition => {},

  origin     => {},

);

my @liste_env_list = ('itemize', 'description', 'enumerate', 'trivlist') ;

  $hash_environ{type}{'description_item'} = 'fold' ;

  $hash_environ{titre}{'description_item'} = ' ' ;

my @liste_env_tabular = ('tabular') ;

my @liste_env_spec = ('equation', 'multline', 'latexonly',

  'pmatrix','smallmatrix', 'eqnarray', 'array', 'algorithmic', 'algorithm', 'align',

  'thebibliography', 'pspicture', 'picture', 'cases', 'gather',

  'displaymath', 'math', 'center', 'minipage', 'lstlisting', 'columns', 'column', 'figure');

my @liste_com_spec = ('paragraph', 'href', 'url', 'exercise', 'doc') ; #je ne m'en sers pas encore

#commandes par défaut : sont écrasés par un \def ou un \defwims

#$hash_command{cnt_arg}{text} = 1 ;

#$hash_command{definition}{text} = '\) #1 \(' ;

#$hash_command{origin}{text} = 'defaut' ;

$hash_command{cnt_arg}{paragraph} = 1 ;

$hash_command{definition}{paragraph} = '<p class="paragraph"> #1 </p>' ;

$hash_command{origin}{paragraph} = 'defaut' ;

$hash_command{cnt_arg}{href} = 2 ;

$hash_command{definition}{href} = '<a href="http:#1" target="wims_external">#2</a>';

$hash_command{origin}{href} = 'defaut' ;

$hash_command{cnt_arg}{url} = 1 ;

$hash_command{definition}{url} = '<a href="http:#1" target="wims_external">#1</a>';

$hash_command{origin}{url} = 'defaut' ;

$hash_command{cnt_arg}{exercise} = 2 ;

$hash_command{definition}{exercise} = "\\exercise\{\#1\}\{\#2\}";

$hash_command{origin}{exercise} = 'defwims' ;

$hash_command{cnt_arg}{doc} = 2 ;

$hash_command{definition}{doc} = '\doc{#1&cmd=new}{#2}';

$hash_command{origin}{doc} = 'defwims' ;

#a un label est associé son bloc [nom de fichier]

my %hash_bloc = (

  fichier  => {},

  titre    => {},

);

my %hash_index = (

  page    => {},

);

#type sert à repérer les fichiers embed ou fold.

my %hash = (

  text   => {},

  prev   => {},

  next   => {},

  upbl   => {},

  titb   => {},

  tittoc => {},

  keyw   => {},

  datm   => {},

  label  => {},

  toc    => {},

  chemin => {},

  niveau => {},

  type   => {},

  author => {},

  title => {},

  email => {},

  toctip => {},

);

my %hash_toc = ();

my %prefixe = ( fold => 'F_' , link => 'L_' );

my %hash_secinv;

for (my $i = 0; $i <= $#SECTIONS; $i++) { $hash_secinv{$SECTIONS[$i]} = $i; }

my (%errmsg); # empèche le ré-affichage d'un même warning.

$SIG{__WARN__} = sub { my ($x) = @_;

  return if $errmsg{$x};

  $errmsg{$x} = 1;

  print STDERR "### $x";

};

system("mkdir -p $BASE0") if (!$ENV{'wims_exec_parm'});

system("mkdir -p $BASE") if (!$ENV{'wims_exec_parm'});

$hash{niveau}{'main'} = 0;

#pour algorithmic

#TODO récupérer les informations dans le fichier de l'utilisateur

my %hash_algo = (

  titre => {},

  apres => {},

  avant => {},

  suite => {}

) ;

my $algo_noend = 0 ;

my $voca = %{$hash_algo{titre}} ;

my @liste_voca = ('FOR', 'IF','WHILE','REPEAT','ELSE','ELSIF','ENDIF','DO',

 'ENDWHILE', 'REQUIRE','ENSURE','ENDFOR','STATE','UNTIL','THEN', 'RETURN') ;

$hash_command{definition}{algorithmicrequire}='<b>Require</b>';

$hash_command{origin}{algorithmicrequire}='defaut';

$hash_command{cnt_arg}{algorithmicrequire}= 0 ;

$hash_command{definition}{algorithmicensure}='<b>Ensure</b>';

$hash_command{definition}{algorithmicend}='<b>end</b>';

$hash_command{definition}{algorithmicif}='<b>if</b>';

$hash_command{definition}{algorithmicthen}='<b>then</b>';

$hash_command{definition}{algorithmicelse}='<b>else</b>';

$hash_command{definition}{algorithmicelsif}="<b>$hash_command{definition}{algorithmicelse} $hash_command{definition}{algorithmicif}</b>";

$hash_command{definition}{algorithmicendif}="<b>$hash_command{definition}{algorithmicend} $hash_command{definition}{algorithmicif}</b>";

$hash_command{definition}{algorithmicfor}='<b>for</b>';

$hash_command{definition}{algorithmicforall}='<b>for all</b>';

$hash_command{definition}{algorithmicdo}='<b>do</b>';

$hash_command{definition}{algorithmicendfor}="<b>$hash_command{definition}{algorithmicend} $hash_command{definition}{algorithmicfor}</b>";

$hash_command{definition}{algorithmicwhile}='<b>while</b>';

$hash_command{definition}{algorithmicendwhile}="<b>$hash_command{definition}{algorithmicend} $hash_command{definition}{algorithmicwhile}</b>";

$hash_command{definition}{algorithmicloop}='<b>loop</b>';

$hash_command{definition}{algorithmicendloop}="<b>$hash_command{definition}{algorithmicend} $hash_command{definition}{algorithmicloop}</b";

$hash_command{definition}{algorithmicrepeat}='<b>repeat</b>';

$hash_command{definition}{algorithmicuntil}='<b>until</b>';

$hash_command{definition}{algorithmicprint}='<b>print</b>';

$hash_command{definition}{algorithmicreturn}='<b>return</b>';

for my $cmd (@liste_voca) { $hash_command{origin}{"algorithmic\L$cmd\E"} = 'defaut' }

for my $cmd ('FOR','IF','WHILE','REPEAT','ELSE','ELSIF') {

          $hash_algo{apres}{$cmd} = 1 ;

} ;

for my $cmd ('IF') { $hash_algo{suite}{$cmd} = 'THEN' ;} ;

for my $cmd ('FOR','WHILE') { $hash_algo{suite}{$cmd} = 'DO' ;} ;

for my $cmd ('ENDFOR','ENDIF', 'ENDWHILE','UNTIL','ELSE','ELSIF') {

          $hash_algo{avant}{$cmd} = -1 ;

} ;

for my $cmd ('FOR','IF','WHILE','REQUIRE','ENSURE', 'STATE','UNTIL') {

          $hash_algo{avant}{$cmd} = 0 ;

} ;

for my $cmd ('ENDFOR','ENDIF','ENDWHILE','REQUIRE','ENSURE', 'STATE','UNTIL') {

          $hash_algo{apres}{$cmd} = 0 ;

}

# lit les fichiers wims.sty  puis les fichers .tex. pour éviter : un seul fichier tex, le premier ?

my $TEXT = Init($FILE, \%hash_environ, \%hash_command, \%hash, \%hash_algo);

out1 ('sheet', $SHEET) ;

$ABOUT = $hash{about}{main} ;

out1 ('about.phtml', (($ABOUT)? $ABOUT :'') . '

<p>

Ce document a été créé par Latex2wims.</p>

!changeto docu/about.phtml') ;

if (!($hash{author}{main})) {

  warn " ATTENTION : Vous devez mettre un nom d'auteur \\author{xxx}" ;

  $hash{author}{main}=$author } ;

if (!($hash{title}{main})) {

  warn " ATTENTION : Vous devez mettre un titre : \\title{xx} " ;

  $hash{title}{main} = '??' } ;

if (!($hash{email}{main})) {

  warn " ATTENTION : Vous devez mettre un email \\email{xxx}" ;

  $hash{email}{main}=$email } ;

# PASSE 2: ferme les \section & co

my $SEC_MIN_GLOBAL = 10; # = \infty

#$SEC_MIN_GLOBAL = 3 ;

my @cnt = (0) x ($#SECTIONS + 1);

my ($secpattern) = join('|', @SECTIONS);

$TEXT =~ s/\\begin\s*{($secpattern)\s*}/cnt_section($1,\@cnt)/eg;

$TEXT =~ s/\[fragile\]//g;

$TEXT =~ s/\\end\s*{\s*($secpattern)\s*}/<\/$1>/g;

$TEXT =~ s/\\wimsentre{($secpattern)}/\\wimsentre$1/g;

$TEXT =~ s/\\(wimsentre)?($secpattern)\b\*?/open_close($2,\@cnt,$1)/eg;

$TEXT =~ s|</document>.*||s;

$TEXT =~ s|.*<document>||s;

if($SEC_MIN_GLOBAL == 10) {$SEC_MIN_GLOBAL = 0} ;

my ($NIVEAU, $NIVEAU_max) = ($SEC_MIN_GLOBAL, $SEC_MIN_GLOBAL + $depth - 1);

# PASSE 3: crée les blocs venant des sections et co

#  et renvoie une partie de la table des matières

my $toc = analyse_texte ($TEXT, \%hash, 'main', $NIVEAU, $NIVEAU_max, '');

# PASSE 4: création de tous les blocs ( environnements de type fold ou link)

{

  my ($ref, $ref_env)  = (\%hash, \%hash_environ);

  while (my ($Id, $TEXT) = each (%{$hash{text}})) {

    $TEXT = TraiteText ($TEXT, $ref, $ref_env, $Id);

#TODO non testé l'utilisation de prev etc

    $ref->{text}{$Id} = $TEXT;

  }

}

#récupération de tous les labels et rajout du titre en haut de la table dans la toc du tag

#On les traite pour que le label soit associé au nom du fichier créé automatiquement.

#$hash{toc}{$tag} contient les fichiers des sections en dessous de $tag

# PASSE 5

for my $tag (keys %{$hash{text}}) {

  my $T = $hash{text}{$tag};

  $T =~ s/\\label\s*\{([^}]+)\}/store_label($1, $tag, \%hash_bloc)/eg;

  $T =~ s/\\index\s*\{([^}]+)\}/store_index($1, $tag, \%hash_index)/eg;

  $hash{text}{$tag} = $T;

  my $tagupbl = $hash{upbl}{$tag};

  #plus utilisé, mais j'hésite !

#  $hash_toc{$tag} = "\\link{$tagupbl}\n\n" . $hash{toc}{$tagupbl};

}

# PASSE 6: sort l'index mis à jour des ref à l'aide des labels créés auparavant  et rajoute

#TODO rajouter eqref mais ca dépend vraiment de la phrase !

for my $tag (keys %{$hash{text}}) {

  my $macro = '\\\\ref|\\\\cite|\\\\eqref';

  my $T = $hash{text}{$tag};

  my $cle = 'prev|next|upbl|titb|keyw|datm';

  $T =~ s/($macro)\{([^}]+)\}\{([^}]+)\}/store_ref($2, $3, $2, \%hash_bloc)/eg;

# repere toto~\cite{}

  $T =~ s/([^\s]+)\~($macro)\s*([.*])?\s*\{([^}]+)\}/store_ref($4, $1 .

    ($3||''), $4, \%hash_bloc)/eg;

  $T =~ s/($macro)\s*([.*])?\{([^}]+)\}/store_ref($3, ($2 ? "$3: $2" : $3), $3, \%hash_bloc)/eg;

  $T =~ s/\\($cle)\s*\{(\w*)\}/store_tag($1, $2, $tag, \%hash, \%hash_bloc)/eg;

  $hash{text}{$tag} = $T;

}

my @ListIndex = sort {$a cmp $b} (keys %{$hash_index{page}}) ;

out('index', selection('<div class="index">' . makeindex (\%hash_index, 0, @ListIndex) . '</div>'

                         ,'left-selection','index')) if ((@ListIndex) && $INDEX == 1 && makeindex (\%hash_index));

#crée les blocs [entourés de la table des matières]

#crée les deux sortes de fichiers demandés par wims .def (fichier de définition général) +

# nom.hd  qui gère les règles de navigation  pour chaque bloc

#attention : dans le cas où il y a un \\embed{toto}, il faut créer le fichier toto.hd ...

#TODO : \embed{toto} : je suppose ici que le contenu de toto est du wims à ne pas

#interpréter

#pour l'instant je m'en suis servi pour stocker des programmes qui interviennent plusieurs fois.

#Crée le vrai fichier qui est mis dans le dossier src

#On ne met pas de table de matières si le bloc est de type fold

#TODO option = chemin tout seul, toc à gauche + chemin, toc à gauche et à droite + chemin,

#style selection droite, selection gauche

for my $tag (keys %{$hash{text}}) {

  complete ($tag, \%hash);

  out ("$tag.hd", hd($tag,\%hash));

  my $txt = traitement_final($hash{text}{$tag});

  my $tagupbl = $hash{upbl}{$tag};

  my $type = $hash{type}{$tag} ;

  my $style = $hash{style}{$tag};

 #si type est non vide il est égal à embed ou fold

  my $dotoc_left = ($OPTION =~ /toc_left/ && !$type);

  my $dotoc_right = ($OPTION =~ /toc_right/ && !$type);

  my $dotoc_up = ($OPTION =~ /toc_up/ && !$type);

  my $dotoc_down = ($OPTION =~ /toc_down/ && !$type);

  my $CHEMIN = chemin($tag, \%hash);

  #J'ai enlevé $LOAD

  $CHEMIN = ($dotoc_up || $dotoc_down)  && ($CHEMIN =~ $FLECHE) ? $CHEMIN : '';

  my $CHEMIN_up=($dotoc_up) ? "<div id=\"up_toc\">$CHEMIN</div>": '' ;

  my $CHEMIN_down=($dotoc_down) ? "<div id=\"down_toc\">$CHEMIN</div>" : '' ;

  my @Chemin = split(',', $hash{chemin}{$tag});

  my $TOCg = $dotoc_left ? selection($hash{toc}{main}, 'left_selection', @Chemin) : '';

  my $TOCd = ($dotoc_right && $tag ne 'main' && (!($dotoc_left) || $tagupbl ne 'main' )) ? selection($hash{toc}{$tagupbl}, 'right_selection', @Chemin) : '';

  my $tit_index = ($hash{titb}{index})? $hash{titb}{index} : 'Index' ;

  my $index = ($INDEX == 1 && (@ListIndex)) ? "<li>\\link{index}{$tit_index}</li>" : '';

  my $tooltip = "";

  ##$txt="<div class=\"fold\"> ".$txt ."<\/div>" if ($type=~/fold/) ;

  my $pat= '<br\s+class="spacer"\s*/>';

  $txt = $tooltip . toc_HTML ($txt, clean($TOCg,\%hash), clean($TOCd,\%hash), $CHEMIN_up, $CHEMIN_down, $index);

  $txt =~ s/$pat\s*$pat/<br class="spacer" \>/g;

  out ($tag, $txt );

}

if ($INDEX == 1) { out ('index.hd', hd('index',\%hash) )};

my @style = sortuniq(split(',',$STYLE)) if ($STYLE) ;

out_def ('.def', def (\%hash, @style ));

##############

sub analyse_texte { my ($TEXT, $ref, $Id, $niveau, $niveau_max, $Toc) = @_;

  my $link = ($niveau <= $niveau_max);

  return $Toc if $niveau > $#SECTIONS ;

  my $section = $SECTIONS[$niveau];

  my $sectiontag = "<$section>";

  my @decoup = split (/$sectiontag/, $TEXT);

  my $text = $decoup[0];

  my $toc_titre ;

  my ($cnt, $id) = (1, "");

  #On parcourt un texte $Id : $text  et on enlève tous les niveaux inférieurs

 # (boucle while)

  while ( $decoup[$cnt]) {

  #tient compte des titres courts pour la toc

    my @u = extract_tagged ($decoup[$cnt],'\[','\]');

    $toc_titre = ($u[4]) ? $u[4] : '' ;

    @u = extract_tagged ($u[1],'{','}');

    if (!$u[4]) { $NUMERO = 1 ; warn " ATTENTION : section dans $Id sans titre ; l'option numerotation a été rajoutée"};

    my @extract = extract_tagged ($sectiontag . $u[1], $sectiontag);

    my $idold =  $id;

    $id = $Id . ($link? 'S': "$prefixe{fold}S") . $cnt;

    $cnt++;

    my $titre = $u[4];

    $toc_titre = $titre if (!$toc_titre) ;

    $titre =~ s/\n/ /g;

    $titre = Numero($id) . "  $titre" if ($NUMERO);

    $toc_titre = Numero($id) . "  $toc_titre" if ($NUMERO);

    $text .=  $link ?"<p>\\link{$id}</p>"

                    :"<p>\\fold{$id}{<span class=\"$section\">$titre</span>}</p>";

    if ($link) {

      $Toc .=  "<p><XXXX=\"$id\">\\link{$id}{$toc_titre}<YYYY=\"$id\"></p>";

    }

    $text .= $extract[1];

    $ref->{titb}{$id} = $titre;

    $ref->{tittoc}{$id} = $toc_titre;

    $ref->{text}{$id} = $extract[4];

    $ref->{type}{$id} = 'fold' if !$link ;

    $Toc = analyse_texte ($ref->{text}{$id}, $ref, $id, $niveau + 1, $niveau_max, $Toc) ;

    $ref->{upbl}{$id} = $Id;

    $ref->{prev}{$id} = $idold;

    $ref->{next}{$idold} = $id;

   #modifier avec selection

    my $tp = '' ;

    if ($TOOLTIP==1) {

    if (!$ref->{toctip}{$Id}) {$ref->{toctip}{$Id}=($ref->{tittoc}{$id}) ?

      "<li>\\link{$id}{$ref->{tittoc}{$id}}</li>": '' ; }

    else {

      $ref->{toctip}{$Id} .= ($ref->{tittoc}{$id}) ?  "<li>\\link{$id}{$ref->{tittoc}{$id}}</li>": '' ;

    }

    #$ref->{toctip}{$Id} .= $ref->{tittoc}{$id} ;

    $tp = "ZZZZZ$id" ; }

    $ref->{toc}{$Id} .= "\n<XXXX=\"$id\">\\link{$id}{$ref->{tittoc}{$id}

    }$tp <YYYY=\"$id\">";

  }

 #maintenant, ce qui reste dans $text est exactement ce qu'on doit mettre dans le hash->{text}{$Id}

  $ref->{text}{$Id} = $text;

  $ref->{titb}{main} = $ref->{title}{main};

  $ref->{tittoc}{main} = $ref->{title}{main} if (!$ref->{tittoc}{main});

  $Toc;

}

sub store_tag { my ($cle, $label, $tag, $ref, $ref_bloc) = @_;

  $ref->{$cle}{$tag} = $ref_bloc->{fichier}{$label} ;

  '';

}

sub store_label { my ($label, $Id, $ref) = @_;

   $ref->{fichier}{$label} = $Id;

   "<a id=\"$label\"></a>";

}

sub dbg { print STDERR "$_[0]\n" if ($verbose); }

sub store_index { my ($label, $Id, $ref_index) = @_;

   dbg("... index: \"$label\"");

   my $L = $ref_index->{page}{$label};

   $ref_index->{page}{$label} =  !$L ? $Id : "$L,$Id";

   "<a id=\"$label\"></a>";

}

sub class_index { my ($index,$level) = @_ ;

     my @a = split('!', $index) ;

     ($a[$level])? $a[$level] : $index ;

 }

 #!(keys %{$ref_index->{page}}

 #sort keys %{$ref_index->{page}} ;

sub makeindex { my ($ref_index, $level, @L ) = @_;

   return '' if (!$#L) ;

   my $dejavu = '' ;

   my $TEXT = "\n<ul class=\"index\">";

   for my $index (@L) {

      next if ($dejavu =~ /\b$index\b/) ;

      my @list = sort {$a cmp $b} grep {class_index($_, $level) eq class_index($index, $level)} @L ;

      my @l = split('!', $index) ;

      if ($l[$level]) {

          $TEXT .= "<li> " ;

          for my $ind (split(',',$ref_index->{page}{$index})) {

             if ($ind && !($dejavu =~ /\b$ind\b/)) {

                 $TEXT .= "\\link{$ind}{".  $l[$level] . " }{$ind}" ;

             }

          }

          $dejavu .= ' ' . join (' , ', @list) ;

          $TEXT .= makeindex ($ref_index, $level + 1, @list) . "</li>" ;

      };

   }

   "$TEXT </ul>";

}

sub TraiteText {my ($TEXT, $ref, $ref_env, $Id) = @_;

  $TEXT =~ s/\s*$//; # strip trailing whitespace

 #0 ul et li sans rien

 #1 avec style

 $TEXT =~ s/\\(begin|end)\s*{wimsonly}//g;

 for my $rubrique (keys %{$ref_env->{list}}) {

     $TEXT = traite_list ($TEXT, $ref, $ref_env, $Id, $rubrique,1);

 }

 for my $rubrique (@liste_env_list) {

     $TEXT = traite_list ($TEXT, $ref, $ref_env, $Id, $rubrique,0);

 }

for my $rubrique (keys %{$ref_env->{tabular}}) {

     if ($TEXT =~ /\\begin{$rubrique}/) {

       $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique,0);

     }

 }

for my $rubrique (@liste_env_tabular) {

   if ($TEXT =~ /\\begin{$rubrique}/) {

     $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique,0);

   }

}

 for my $rubrique (@liste_env_spec) {

    if ($TEXT =~ /\\begin{$rubrique(\*)?}/) {

      $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique, 1);

    }

  }

#le 1 et 0 servent à initialiser le compteur dans le cas ou on doit créer de nouveaux blocs dans la même page

  for my  $rubrique (keys %{$ref_env->{titre}}) {

    if ($TEXT =~ /\\begin{$rubrique}/) {

      $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique,1);

    }

  }

  for my $rubrique (keys %{$ref_env->{list}}) {

     $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique,0);

     $TEXT = traite_environ ($TEXT, $ref, $ref_env, $Id, $rubrique . '_item',0);

  }

  if ($TEXT =~ /\\begin\{\s*(\w*)\s*\}/g) {

     warn " ATTENTION : environnement non répertorié : $1" if $1 ne 'matrix' && $1 ne 'split';

  }

  $TEXT =~ s,<li>\n+</li>,<li></li>,g;

  $TEXT =~ s,</div>\s+</div>,</div></div>,g;

  $TEXT =~ s,</div>\s+<,</div>\n<,g;

  $TEXT =~ s,<div ([^>]+)>\s+<,<div $1><,g;

  $TEXT =~ s/\n{2,5}/<br class=\"spacer\" \/>/g;

  $TEXT;

}

#on pourrait faire une boucle  while ; on pourrait avoir deux fois le meme environnement imbrique ?

#begin{proof} \begin{proof} \end{proof}\end{proof} Je crois que c'est pour cela que je fais ce truc

#tordu. En fait  split me sert uniquement à trouver le premier <$environ>

#$cnt sert à numéroter semi-globalement (création de blocs correspondant à un même environnement dans une meme page

#exemple mainS4S3F_proof1,mainS4S3F_proof2,mainS4S3F_proof3,mainS4S3F_proof4,mainS4S3F_proof5

sub traite_list {my ($TEXT, $ref, $ref_env, $Id, $environ, $option) = @_;

 my ($e_item, $b_item , $b_class, $e_class) = (' ',' ', ' ', ' ');

  if ( $option == 1 ) {

         $e_item = "\\end{$environ\_item}" ;

         $b_item = "\\begin{$environ\_item}" ;

      my $style = $ref_env->{style}{$environ} ;

      $style = ($style) ? $style : $environ;

      $b_class= "ul class=\"$style\"" ;

      $e_class= "\/ul" ;

      }

      {

        if    ($environ eq 'enumerate'){ $b_class = "ol class=\"enumerate\"" ; $e_class= "\/ol" ; }

        elsif ($environ eq 'itemize'){ $b_class = "ul class=\"itemize\"" ;  $e_class= "\/ul" ;}

        elsif ($environ eq 'description'){

              $b_class = "ul style=\"list-style:none;\"" ;

              $e_class= "\/ul" ;

              $e_item = "\\end{$environ\_item}" ;