###################
#
# C'est ici qu'on habille le fichier sgml ou html
#
# C'est a l'interieur de cette fonction bien longue, je l'accorde,
# Que la presque totalite du travail est effectue.
# 
# Il ne faut surtout pas chercher a comprendre le pourquoi du comment,
# Chacun ayant sa propre technique bien particuliere de programmation.
# Bonne chance tout de meme pour ceux qui veulent tout comprendre.
#
###################

sub transfert
{
    local ($name,*habillage_brut,*Objet_html,*Les_Liens_Of_Info,*Les_Langues_Suf,*Les_Langues_H,$Le_Modele,$option,*Mes_Liens) = @_;
    
    local ($La_tete,$Le_mdp_options,$Le_mdp,$Le_corps);
    local ($langue,$menu,$base);
    local ($Le_lien_up,$Le_lien_next,$Le_lien_back);
    
# print "-->$name\n";
    
    if($name =~ /^$Rep_courant\/(.*?)\/(.*)$/)
    {
	local ($Dir) = $1;
	local ($Reste_Dir) = $2;
	if($Reste_Dir ne "")
	{
	    reper($name,{%habillage_brut},{%Objet_html},[@Les_Langues_Suf],{%Les_Langues_H},$Le_Modele,$option);
	    return;
	}
    }
    
    local ($Le_Modele_individuel) = '';
    
    local ($path_file,$name_file) = ($name =~ /(.*)\/(.*)$/);
    local ($true_name) = $name_file;
    local ($i) = 0; 
    
    lstat($name);
    
#
# On filtre les fichiers sgml et html
#
    
    local($i_par) = 0;
    $parallele_ok = 0;
    while($Parallele_oui[$i_par])
    {
	if($name =~ /(.*?)$Source$Parallele_oui[$i_par].*/)
	{
	    $parallele_ok = 1;
	}
	$i_par++;
    }
    $i_par = 0;
    while($Parallele_non[$i_par])
    {
	if($name =~ /(.*?)$Source$Parallele_non[$i_par].*/)
	{
	    $parallele_ok = 0;
	}
	$i_par++;
    }
    
    if (((! -l _) && (-f _)) && ($name =~ /.*\.sgml?$/ || $name =~ /.*\.html?$/ || $name =~ /.*\.js2?$/) && ($Filtre_fichier eq "" || $name =~ /.*$Filtre_fichier$/) && ($Parallele eq "" || ($Parallele ne "" && $parallele_ok))) #on a trouve un fichier a traiter
    {
	
	affiche("$name\n");
	
#
# Ici, je vais tricher
# Mon script ne gerant que du .sgml,
# Plutot que chercher partout le modifications a faire,
# Je remplace le .html en .sgml a l'entree.
# Je gagne ainsi en vitesse.
#
# $name_file etant le nom du fichier a traiter
#
	
	$name_file =~ s/\.html$/\.sgml/;
	
#Creation du ou des repertoire(s) destination(s)
	
	$file_dest = $name;
	$file_dest =~ s/sgml$/html/;
	$file_dest =~ s/$Source/$Dest/;
	
#On lit le fichier source
	open(FILE,$name);
	$info_ok = 0;
	
	undef $/;
	$info = <FILE>;
	
	# Netoyage de possibles 

	
	$info =~ s/
/\n/gs;
	$/ = $sauve;
	
	($path_solo,$file_solo,$langue,$file_suf) = decoupage_info($name);
	$sans_suf = $path_solo.$file_solo;
	$sans_suf_dest = $sans_suf;
	$sans_suf_dest =~ s/$Source/$Dest/;
	$path_solo_dest = $path_solo;
	$path_solo_dest =~ s/$Source/$Dest/;
	
#   print "La dest = $path_solo_dest\n";
#   if(!-e "$path_solo_dest")
	{&creation_repertoires($name)}
	
# print "$langue <- $sans_suf <- $file_suf <- $file_solo <- $path_solo\n";
	
#print "$info\n";
	
#
#
# Je crois que le debut du super while devrai se trouver ici
#
# ||
# \/
	
# La ligne suivante me permet de connaitre la langue du document original tout au long
# Des copies qu'on peut etre ammenes a faire
	$true_langue = $langue;
	
#  local($i_i) = 0;
#	  while($Les_Langues_Suf[$i_i])
#	   {
#	    print "$Les_Langues_Suf[$i_i++] \n";
	#      }
	
	
	if($langue eq "MONO")
	{#print "MONO\n";
	    super_habillage($info);
	}
	else
	{#print "NEW\n";
	    local @info_traite = super_habillage($info);
	    local($i_super_while) = 0;
	    while($Les_Langues_Suf[$i_super_while])
	    {
#
# Le Test qui suit, permet de creer des pages manquantes selon
# Une bdd de langues, dans l'ordre indique dans le fichier
# D'objets
#
		
		local($i_test_l) = 0;
		while($Les_Langues_Suf[$i_test_l])
		{
#	    print "$Les_Langues_Suf[$i_test_l] $i_test_l\n";
		    if(-e "$sans_suf.$Les_Langues_Suf[$i_test_l].html")
		    {last}
		    $i_test_l++;
		}
#      print "+=+> $Les_Langues_Suf[$i_test_l] $i_test_l\n";
		
#print "$i_test_l et $Les_Langues_H{$true_langue} $true_langue\n";
		if(($i_test_l + 1 == $Les_Langues_H{$true_langue}) && !(-e "$sans_suf.$Les_Langues_Suf[$i_super_while].html"))
		{
		    $langue = $Les_Langues_Suf[$i_super_while];
		    affiche( "Version $langue\n");       
		    $file_dest = "$path_solo$file_solo.$langue.html";
		    $file_dest =~ s/$Source/$Dest/;
#		print "-+-+-+->$langue\n";
#	    super_habillage($info);
		    &ecriture_destination($info_traite[0],$file_dest,$info_traite[2],$langue,$info_traite[4],$info_traite[5],$info_traite[6]);
		}
		$i_super_while++;
	    }
	}
	
# /\
# ||
# Je pense que la fin du super while devrai se trouver ici
# 
#
	
	if($Les_Liens_Of_Info{$true_name})
	{
	    &gestion_mdp($Les_Liens_Of_Info{$true_name},$name,$file_solo)
	    }
	elsif($Les_Liens_Of_Info{"$file_solo.+"})
	{
	    &gestion_mdp($Les_Liens_Of_Info{"$file_solo.+"},$name,$file_solo)
	    }
	elsif($Le_mdp)
	{&gestion_mdp($Le_mdp,$name,$file_solo)}
	
	$Le_mdp_options = '';
	
	close(FILE);       
	
	if ($name =~ /.*\.zipcruft_e/)
	{
	    unlink ($name);
#     print "$name\n";
	    $NB_ZIP++;
	}
	
	$NB_FILES++;
    }
    lstat($name);
    if (((! -l _) && (-d _)) && ($option =~ /.*r.*/ || ($option =~ /.*d.*/ && $NB_REP < 1))) #on traite un repertoire
    {
	$NB_REP++;
#   reper($name,{%habillage_brut},{%Objet_html},$Le_Modele,$option,copy_hash_of_hash[%Mes_Liens]);
	reper($name,{%habillage_brut},{%Objet_html},[@Les_Langues_Suf],{%Les_Langues_H},$Le_Modele,$option);
    }
    return;
    
}

############################
#
#
# C'est ici que tout les choses ont lieu
#
#
############################
sub super_habillage
{
    local ($info) = @_;
    
#
# Il faut restructurer la partie qui suit, pour pouvoir
# Gerer l'habillage unitaire,
# Il faut donc chercher a lire un fichier d'habillage unitaire
# Avant de creer un clone, comme c'etait le cas pour l'instant.
#
# 1 - Decouper le nom du fichier en corps, langue, suffixe
# 2 - Recuperer (s'il existe) les fichier corps.$Original et corps.$Habillage_file
# 3 - Se debrouiller pour que cet habillage soit vraiment unitaire
#
    
    local ($Le_Modele_Individuel) = '';
    
    if(-e "$sans_suf$Original")
    {
#   print "Habillage particulier pour $sans_suf\n";
	open (IND, "$sans_suf$Original");
	$sauve = $/;
	undef $/;
	$Le_Modele_Individuel = <IND>;
	$/ = $sauve;
	close (IND);
#   print "$Le_Modele_Individuel\n";
    }
    
    &aff_debug("J'ai lu le fichier") if ($debug);
    
    
    local (%habillage_brut_particulier) = ();
    local (%Objet_html_particulier) = ();
# On gere l'habillage particulier a un seul fichier
    if(-e "$sans_suf$Habillage_file")
    {
	local(@rien_a);
	local(%rien_b);
	affiche("Objets particuliers pour $sans_suf\n");
	# On traite le fichier d'habillage
	%habillage_brut_particulier = %habillage_brut;
#   print "($habillage_brut_particulier{'MP.COLOR_TEXT'})\n";
	(*habillage_brut_particulier,*rien_a,*rien_b) = &lecture_habillage("$sans_suf$Habillage_file",{%habillage_brut});
#   print "($habillage_brut_particulier{'MP.MENU.UP'})\n";
	# On genere l'habillage recursif
	*Objet_html_particulier = &dispersion_habillage({%habillage_brut_particulier});
#   print "\n($habillage_brut_particulier{'MP.MENU.UP'}) , ($Objet_html_particulier{'MP.MENU.UP'})\n";
#   print "($habillage_brut{'MP.MENU.UP'}) , ($Objet_html{'MP.MENU.UP'})\n";
#   print "($habillage_brut_particulier{'MP.BODY.OPTION'})\n";
#   print "($Objet_html_particulier{'MP.BODY.OPTION'})\n";
	# Maintenant, une fois qu'on a lu le fichier d'objets particuliers,
	# On gere les objets particuliers contenants des objets moins egoistes
	&aff_debug("J'ai lu le .obj particulier") if ($debug);
	
    }
    
    
# Decoupage de la page sgml en trois parties
# 1: La partie HEAD
# 2: La partie MDP
# 3: La partie BODY
    
#On filtre l'ancien format
    if($info =~ /<HTML>(.*?)<HEAD>(.*?)<\/HEAD>(.*?)<MDP (.*?)>(.*?)<\/MDP>(.*?)<BODY(.*?)>(.*?)<\/BODY>(.*?)<\/HTML>/is)
    {
	$La_tete = $2;
	$Le_mdp_options = $4;
	$Le_mdp = $5;
	$Le_body_option = $7;
	$Le_corps = $8;
	$Le_mdp_options =~ s/FR_PLUS/BI/is;
	$Le_mdp_options =~ s/EN_PLUS/BI/is;
    }
#On filtre le format HTML pur
    elsif($info =~ /<HTML>(.*?)<HEAD>(.*?)<\/HEAD>(.*?)<BODY(.*?)>(.*?)<\/BODY>(.*?)<\/HTML>/is)
    {
	$La_tete = $2;
	$Le_body_option = $4;
	$Le_corps = $5;
    }
    else
    {
	affiche( "le fichier $name est syntaxiquement incorrect\n");
#	 print "$info\n";
	return; 
    }   
    aff_debug("J'ai reconnu le fichier") if ($debug);
# Creation du Clonage
    
    if($Le_Modele_Individuel)
    {
	$info = $Le_Modele_Individuel;
    }
    else
    {
	$info = $Le_Modele;
    }
    $info =~ s/<PM\.HEAD>/$La_tete/;
    $info =~ s/<PM\.BODY>/$Le_corps/;
    $info =~ s/<PM\.BODY\.ATTRIBUT>/$Le_body_option/;
    
    if($file_suf ne "js" && $file_suf ne "js2")
    {
	$info = $Doc_Type.$info;
    }
    if($info =~ s/<MP.CREATION\s* VALUE\s*=\s*"(.*?)">//si)
    {
	$Create_value = $1;
	$Meta_Info_f = "<META Name=\"Author\" Content=\"$Create_value\">\n".$Meta_Info;
    }
    else
    {
	$Meta_Info_f = $Meta_Info;
    }
    $info =~ s/<HEAD(.*?)>/<HEAD$1>\n$Meta_Info_f/i;
    
    &aff_debug("J'ai cree un clone") if ($debug);
    
    
#
# Il faut verifier la langue de la page dans le cas ou elle est pas BI pour l'ancien format SGML
#
    local ($mdp_ok) = 0;
    if($Le_mdp_options)
    {
	if($Le_mdp_options =~ /.*\s*LANG=\s*(.*?)( |>).*/)
	{$langue = $1 }
	if($Le_mdp_options =~ /.*\s*MENU=\s*(.*?)( |>).*/)
	{$menu = $1 }
	if($Le_mdp_options =~ /.*\s*BASE=\s*(.*?)( |>).*/)
	{$base = $1 }
#     ($langue,$menu,$base) = ($Le_mdp_options =~ /\s*LANG=\s*(.*?)\s*MENU=\s*(.*?)\s*BASE=\s*(.*?)\s*$/);
	$mdp_ok = 1;
	if($name =~ /(.*)\.(.*)$/){$sans_suf = $1;$file_suf = $2;}
	if($langue =~ /FR/i)
	{
	    $info =~ s/<\s*(MDP)?(\.|_)?FR\s*>//gis;
	    $info =~ s/<\s*\/(MDP)?(\.|_)?FR\s*>//gis;
	}
	if($langue =~ /EN/i)
	{
	    $info =~ s/<\s*(MDP)?(\.|_)?EN\s*>//gis;
	    $info =~ s/<\s*\/(MDP)?(\.|_)?EN\s*>//gis;
	}
    }
    &aff_debug("J'ai traite un possible MDP") if ($debug);
    
# On commence a trafiquer le contenu du fichier source
    
# Je modifie l'aspect du fichier source pour creer un clone
# Du fichier Original
    
#
# On remplace l'ancien format MDP_ en MP.
#
    $info =~ s/<\s*(MDP(?:_|\.))(.*?)\s*>/<MP\.$2>/isg;
    
    &aff_debug("J'ai remplace les tags MDP") if ($debug);
#
# Differenciation des objet langue (ex: MP.FR) des autres objets
#
    local ($i_lan_obj) = 0;
    while($Les_Langues_Suf[$i_lan_obj])
    {
	$info =~ s/<\s*(MP\.)?$Les_Langues_Suf[$i_lan_obj]\s*>/<SAPI.$Les_Langues_Suf[$i_lan_obj]>/isg;
	$info =~ s/<\s*\/(MD?P(\.|_))?$Les_Langues_Suf[$i_lan_obj]\s*>/<\/SAPI.$Les_Langues_Suf[$i_lan_obj]>/isg;
	$i_lan_obj++;
    }
    &aff_debug("J'ai reconnu les tags langue") if ($debug);
    
#
# On recherche les objets dans les pages clones
#
    
#
# Je realise une boucle while pour remplacer recursivement les differents 
# Objets qu'on peut rencontrer dans la page traitee
# Ceci est fait, car un objet peut en contenir un autre
#
    
 #   print "coucou";
    $info = go_for_mp($info);
  #  print "coucou2";
    
    &aff_debug("J'ai fini le traitement des objets") if ($debug);
    
#
# C'est ici qu'on rajoutera le traitement dynamique des certains objets
# Dont on connait pas forcement le contenu jusqu'au traitement du fichier
# Sgml lui meme, comme par exemple les liens,
# Ou encore les langues
#
    
#
# Si on travaille avec un fichier au format MDP (ancien format)
# On lira les liens contenus dans la partie MDP que si le fichier $Liens
# N'existe pas, ou que l'option -m a ete demande.
#
    
    
#print "$name_file=>$name\n";
    ($Le_lien_up,$Le_lien_next,$Le_lien_back) = ('','','');
#print "$Le_lien_up,$Le_lien_next,$Le_lien_back\n";
    
#
# Pour l'instant, si je rencontre le tag <MDP>,
# Il sera traite ssi $Liens n'existe pas
#
    
    $Le_lien_up = $Mes_Liens{$true_name}{"Up"};
    $Le_lien_next = $Mes_Liens{$true_name}{"Next"};
    $Le_lien_back = $Mes_Liens{$true_name}{"Back"};
    $Le_lien_up = $Mes_Liens{"$file_solo.+"}{"Up"} if (!$Le_lien_up);
    $Le_lien_next = $Mes_Liens{"$file_solo.+"}{"Next"} if (!$Le_lien_next);
    $Le_lien_back = $Mes_Liens{"$file_solo.+"}{"Back"} if (!$Le_lien_back);
    
    if(((!$Le_lien_up && !$Le_lien_next && !$Le_lien_back)
	|| $option =~ /.*m.*/is) && $Le_mdp)
    {
	if($Le_mdp =~ /.*<UP>(.*?)<\/UP>/){$Le_lien_up = $1};
	if($Le_mdp =~ /.*<NEXT>(.*?)<\/NEXT>/){$Le_lien_next = $1};
	if($Le_mdp =~ /.*<BACK>(.*?)<\/BACK>/){$Le_lien_back = $1};
    }
    
#
# Gestion de faux freres avec le tag <sep>, qui permet de casser
# Une chaine dans le fichier $Liens
#
    if($Le_lien_up =~ /.*<\s*sep\s*>.*/is){$Le_lien_up = ''}
    if($Le_lien_next =~ /.*<\s*sep\s*>.*/is){$Le_lien_next = ''}
    if($Le_lien_back =~ /.*<\s*sep\s*>.*/is){$Le_lien_back = ''}
    
#     print "$Le_lien_up,$Le_lien_next,$Le_lien_back\n";
    
#
# Gestion des liens virtuels
# ex: .+ -> .fr.html et .en.html
#     .fr.html -> .fr.html et .en.html
#
    
    if($Le_lien_up)
    {
	$Le_lien_up =~ s/\.sgml/\.\+/;
# Je decoupe le nom du fichier en: 
# - Prefixe
# - Langue (si elle existe)
# - Suffixe
	$Le_lien_up =~ m#(.+?)(\.([^/.]+))?\.(html|\+)$#;
	local($Le_lien_up_remplace) = $Le_lien_up;
	$Up_name = $1;$Up_suf = $3;$Up_type = $4;
	if($Up_suf && $Les_Langues_H{lc($Up_suf)}){$Up_type = "+"}
	else{if($Up_suf){$Up_name .= ".$Up_suf"}}
	if($Up_type eq "+")
	{
	    $Le_lien_up_remplace = $Up_name;
	    local ($i_bandera) = 0;
	    while($Les_Langues_Suf[$i_bandera])
	    {
		$info =~ s/<$Mon_Pref.UP.$Les_Langues_Suf[$i_bandera]>(.*?)<(?:PM\.)?KEYWD\.UP>(.*?)<\/$Mon_Pref.UP.$Les_Langues_Suf[$i_bandera]>/<$Mon_Pref.$Les_Langues_Suf[$i_bandera]>$1$Le_lien_up_remplace.$Les_Langues_Suf[$i_bandera].html$2<\/$Mon_Pref.$Les_Langues_Suf[$i_bandera]>/isg;
		$i_bandera++;
	    }
	}
	else #Monolingue
	{$info =~ s/<(?:PM\.)?KEYWD\.UP>/$Le_lien_up_remplace/isg}
    }
    else
    {$info =~ s/<$Mon_Pref.UP.(.*?)>(.*?)<\/$Mon_Pref.UP.(.*?)>//isg}
    
    if($Le_lien_next)
    {
	$Le_lien_next =~ s/\.sgml/\.\+/;
	$Le_lien_next =~ m#(.+?)(\.([^/.]+))?\.(html|\+)$#;
	local ($Le_lien_next_remplace) = $Le_lien_next;
	$Next_name = $1;$Next_suf = $3;$Next_type = $4;
#		print "($1) ($3) ($4)\n";
	if($Next_suf && $Les_Langues_H{lc($Next_suf)}){$Next_type = "+"}
	else{if($Next_suf){$Next_name .= ".$Next_suf"}}
	if($Next_type eq "+")
	{
	    $Le_lien_next_remplace = $Next_name;
	    local ($i_bandera) = 0;
	    while($Les_Langues_Suf[$i_bandera])
	    {
		$info =~ s/<$Mon_Pref.NEXT.$Les_Langues_Suf[$i_bandera]>(.*?)<(?:PM\.)?KEYWD\.NEXT>(.*?)<\/$Mon_Pref.NEXT.$Les_Langues_Suf[$i_bandera]>/<$Mon_Pref.$Les_Langues_Suf[$i_bandera]>$1$Le_lien_next_remplace.$Les_Langues_Suf[$i_bandera].html$2<\/SAPI.$Les_Langues_Suf[$i_bandera]>/isg;
		$i_bandera++;
	    }
	}
	else #Monolingue
	{$info =~ s/<(?:PM\.)?KEYWD\.NEXT>/$Le_lien_next_remplace/isg}
    }
    else
    {$info =~ s/<$Mon_Pref.NEXT.(.*?)>(.*?)<\/$Mon_Pref.NEXT.(.*?)>//isg}
    
    if($Le_lien_back)
    {
	$Le_lien_back =~ s/\.sgml/\.\+/;
	$Le_lien_back =~ m#(.+?)(\.([^/.]+))?\.(html|\+)$#;
	local ($Le_lien_back_remplace) = $Le_lien_back;
	$Back_name = $1;$Back_suf = $3;$Back_type = $4;
	if($Back_suf && $Les_Langues_H{lc($Back_suf)}){$Back_type = "+"}
	else{if($Back_suf){$Back_name .= ".$Back_suf"}}
	if($Back_type eq "+")
	{
	    $Le_lien_back_remplace = $Back_name;
	    local ($i_bandera) = 0;
	    while($Les_Langues_Suf[$i_bandera])
	    {
		$info =~ s/<$Mon_Pref.BACK.$Les_Langues_Suf[$i_bandera]>(.*?)<(?:PM\.)?KEYWD\.BACK>(.*?)<\/$Mon_Pref.BACK.$Les_Langues_Suf[$i_bandera]>/<$Mon_Pref.$Les_Langues_Suf[$i_bandera]>$1$Le_lien_back_remplace.$Les_Langues_Suf[$i_bandera].html$2<\/SAPI.$Les_Langues_Suf[$i_bandera]>/isg;
		$i_bandera++;
	    }
	}
	else #Monolingue
	{$info =~ s/<(?:PM\.)?KEYWD\.BACK>/$Le_lien_back_remplace/isg}
    }
    else
    {$info =~ s/<$Mon_Pref.BACK.(.*?)>(.*?)<\/$Mon_Pref.BACK.(.*?)>//isg}
    
    $info =~ s/<PM.KEYWD.UP>/$Le_lien_up/gs;
    $info =~ s/<PM.KEYWD.BACK>/$Le_lien_back/gs;
    $info =~ s/<PM.KEYWD.NEXT>/$Le_lien_next/gs;
    
    &aff_debug("J'ai fini le traitement de la navigation interne") if ($debug);
    
#     print "$Le_lien_up,$Le_lien_next,$Le_lien_back\n";
#
# Fin traitement de liens
#
    
    
    
#
# Gestion de la langue
#
# Pour l'instant, je ne gere que MONO, BI, FR et EN
#
    
#
# On remplace <(?:PM\.)?KEYWD\.FILENAME> par le nom du fichier courant 
#
    $info =~ s/<(?:PM\.)?KEYWD\.FILENAME>/$file_solo/igs;
    
    
    &aff_debug("($Le_lien_back) ($Le_lien_next) ($Le_lien_up)") if ($debug);
    
#
# Fichier html
#
    if($langue eq "MONO")
    {
	$info =~ s/<$Mon_Pref\.WARNING\.(.*?)>(.*?)<\/$Mon_Pref\.WARNING\.(.*?)>//sg;    
	$info =~ s/<$Mon_Pref\.LANG\.(.*?)>(.*?)<\/$Mon_Pref\.LANG\.(.*?)>//sg;    
    }
#
# Ancien format SGML
#
    elsif($mdp_ok == 1)
    {
	$name_fr = $name_en = $name_file;
	$name_fr =~ s/\.sgml$/\.fr\.html/;
	$name_en =~ s/\.sgml$/\.en\.html/;
	if($langue eq "BI")
	{$info =~ s/<$Mon_Pref\.WARNING\.EN>(.*?)<\/$Mon_Pref\.WARNING\.EN>//sg;    
	 $info =~ s/<$Mon_Pref\.WARNING\.FR>(.*?)<\/$Mon_Pref\.WARNING\.FR>//sg;
     }
	elsif($langue eq "FR")
	{
	    $info =~ s/<$Mon_Pref\.WARNING\.FR>(.*?)<\/$Mon_Pref\.WARNING\.FR>//sg;    
	}
	elsif($langue eq "EN")
	{
	    $info =~ s/<$Mon_Pref\.WARNING\.EN>(.*?)<\/$Mon_Pref\.WARNING\.EN>//sg;    
	}
	$langue = "BI"; 
    }
#
# Nouveau format SGML
#
    else
    {
	local ($i_new_sgml) = 0;
	$info =~ s/<$Mon_Pref\.WARNING\.$langue>(.*?)<\/$Mon_Pref\.WARNING\.$langue>//isg if ($langue eq $true_langue);    
    }
    &aff_debug("J'ai fini la gestion de la langue") if ($debug);
    
#
# Fin Gestion de la langue
#
    
#
# On sauvegarde les information
#
    
#print "== == > $file_dest et $langue\n";
#
# Si l'option -a fut employee, on relativise les liens
#
    if($option =~ /.*a.*/)
    {
	local ($i_tags) = 0;
	while($TAGS[$i_tags])
	{
	    $info = &make_relatif($info,$file_dest,$TAGS[$i_tags]);
	    $i_tags++;
	}
	&aff_debug("J'ai fini la relativisation des liens") if ($debug);
    }
    
#
# Si l'option -t fut employee, on copie les fichiers images, ...
#
    if(($option =~ /.*t.*/is) && ($name =~ /.*$true_name$/is))
    {
	&transfert_autre($info,$file_dest);
	&aff_debug("J'ai fini la copie des fichiers images, ...") if ($debug);
    }
    
    if(!($option =~ /.*s.*/is) && ($name =~ /.*$true_name$/is))
    {
	$info = &image_size($info,$file_dest);
	&aff_debug("J'ai fini la gestion de la taille des images") if ($debug);
    }
    
    &ecriture_destination($name,$file_dest,$info,$langue,$Le_mdp,$mdp_ok,$option);
    &aff_debug("J'ai fini l'ecriture du fichier destination") if ($debug);
    
    return ($name,$file_dest,$info,$langue,$Le_mdp,$mdp_ok,$option);
    
#
# Gestion des images du fichier traite (<LIEN>...</LIEN>)
#
    
}

sub go_for_mp
{
    local($info) = @_;
    
#    print "Go for MP \n";
    
    while($info =~ /^.*?(<mP(.*?)>).*$/s)
    {
	$le_tout = $1;
	$le_reste = $2;
	$info =~ s/$le_tout/<MP$le_reste>/g;
    }
    while($info =~ /^.*?(<mp(.*?)>).*$/s)
    {
	$le_tout = $1;
	$le_reste = $2;
	$info =~ s/$le_tout/<MP$le_reste>/g;
    }
    while($info =~ /^.*?(<Mp(.*?)>).*$/s)
    {
	$le_tout = $1;
	$le_reste = $2;
	$info =~ s/$le_tout/<MP$le_reste>/g;
    }
#   $info = do_subst_mp($info);
#   return $info;
    
    local $rest1 =  substr($info, 0, (length($info)/2));
    local $rest2 =  substr($info, (length($info)/2), length($info));
    
    if($rest2 =~ /^([^<]*)<(.*)$/s)
    {
	local ($test1, $test2) = ($1, $2);
	if($test2 =~ /.*>.*/s)
	{
	    $rest2 = "<$test2";
	    $rest1 .= $test1;
	}
    }
#    print "Go for MP \n";
    
    ($info, $rest2) = do_subst_mp($info, $rest1, $rest2);
    ($info, $rest2) = do_subst_mp($info, $rest2, "");
#    print "Go for MP \n";
    return $info;
    
}

sub do_subst_mp
{
    local($info,$Rest1, $Rest2) = @_;
    local $info_val = $Rest1;
    
    while($info_val =~ /^(.*?)<(MP)(.*?)( (.*?))?>(.*)$/s)
    {
	if(!$info_ok)
        {#print "$name\n";
	    $NB_FILES_OK++;
	    $info_ok = 1;
	}
	$Expr = uc("$2$3");
#       print "$Expr<--\n";
	$Option = $5;
	if(!$Option){$Option = ""};      
#
# On traduit les differents objets contenus dans le fichier .obj
#
	
	if($Objet_html{$Expr} || $Objet_html_particulier{$Expr}) 
        {
	    if($Objet_html_particulier{$Expr})
	    {$Expr_e = $Objet_html_particulier{$Expr}}
	    else
	    {$Expr_e = $Objet_html{$Expr}}
	    local ($Op_temp) = $Option;
	    while($Op_temp =~ /(?:(.*)\s+|)(.*)\s*=\s*"(.*?)"\s*/is)
	    {
		$Op_temp = $1;
		$Attr = $2;
		$Val_attr = $3;
#		   print "$Attr = $Val_attr\n";
		if(!($Expr_e =~ s/PM\.ATTRIBUT\.$Attr(<SAPI.DEF>(.*?)<\/SAPI.DEF>)?/$Val_attr/i))
		{
		    affiche ("L'attribut $Attr n'existe pas dans l'objet $Expr\n");
		}
	    }
	    while($Expr_e =~ /$.*(PM\.ATTRIBUT\..*?<SAPI.DEF>(.*?)<\/SAPI.DEF>)/)
	    {
		local ($default) = $2;
		$Expr_e =~ s/$1/$default/;
	    }
	    $Expr_e =~ s/([^ ]*)\s*=\s*PM\.ATTRIBUT\.[^ ]*?( |>)/$2/gi;
	    $Expr_e =~ s/\s*>/>/g;
	    $info =~ s/<$Expr( ?$Option)>/$Expr_e/sg;
	    $Rest2 =~ s/<$Expr( ?$Option)>/$Expr_e/sg;
	    $info_val =~ s/<$Expr( ?$Option)>/$Expr_e/sg;
# print "\n\n$Expr => $Expr_e\n";
        }
	else
	{
	    $info_val =~ s/<$Expr( ?$Option)>//isg;
	    $info =~ s/<$Expr( ?$Option)>//isg;
	    affiche("===>l'objet $Expr n'existe pas ($Option)\n");
	}
    }
    
    return $info,$Rest2;  
 }

return 1;