#/usr/bin/perl

<<DOC;
Nom : Olga Semenova
JANVIER 2005
 Le programme prend en entrée le nom du répertoire contenant les fichiers à traiter, intègre le traitement par
 le programme Tree-tagger et construit en sortie un fichier structuré contenant  sur chaque ligne le nom du fichier et
 le résultat d'étiquetage :
 <file><name>du fichier</name><element><data type="type">""</data><data type="lemma">""</data>
 <data type="string">""</data></element></file>
DOC

#-----------------------------------------------------------
#le nom du répertoire passe en argument au programme
my $rep="$ARGV[0]";

#on s'assure que le nom du répertoire ne se termine pas par un "/"
$rep=~ s/[\/]$//;

#on initialise une variable contenant le flux de sortie
my $DUMPFULL1="";

#----------------------------------------
# on ouvre le fichier de sortie
my $output1="RESULTAT-TreeTagger.xml";
if (!open (FILEOUT,">$output1")) { die "Pb a l'ouverture du fichier $output1"};

#----------------------------------------
#on lance le parcours récursif de l’arbre des fils
&parcoursarborescencefichiers($rep);        #recurse!

#----------------------------------------
# on formate la sortie : fichier XML avec entete
# on intègre le contenu de la variable contenant le filtrage
print FILEOUT "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n";
print FILEOUT "<PARCOURS>\n";
print FILEOUT "<NOM>Votre nom</NOM>\n";
print FILEOUT "<ETIQUETAGE>\n";
print FILEOUT "$DUMPFULL1\n";
print FILEOUT "</ETIQUETAGE>\n";
print FILEOUT "</PARCOURS>\n";
close(FILEOUT);
exit;

#----------------------------------------------
##Procedure de parcours
sub parcoursarborescencefichiers {
    my $path = shift(@_);

    #On ouvre le répertoire
    opendir(DIR, $path) or die "can't open $path: $!\n";

    #On « récupère » le  contenu du répertoire
    my @files = readdir(DIR);
    closedir(DIR);

    #Pour chacun des « éléments » contenu dans le répertoire,
    #on va vérifier son statut (répertoire -d ou fichier -f)
    foreach my $file (@files) {
        next if $file =~ /^\.\.?$/;

        #On commence par écrire  le chemin complet de l’ « élément »
        $file = $path."/".$file;

        #Si l’ « élément » est un répertoire (-d = directory) : on relance le parcours
        if (-d $file) {
            &parcoursarborescencefichiers($file);        #recurse!
        }

        #Si l’ « élément » est un fichier (-f = file)  : on lance le traitement de filtrage
        #dont le résultat est attribué à la variable $DUMPFULL1;

        #on verifie si "élément" est un fichier
        if (-f $file) {

                #si oui, on l'ouvre
                #et on l'associe à un pointeur FIC et à une variable $file;
                open(FIC, $file);

                #on commence à formater la sortie XML:
                #pour que la variable $DUMPFULL1 imprime chaque fois le résultat du traitement, on ajoute ".", l'opérateur de concaténation;
                $DUMPFULL1 .= "<file>\n<name>$file</name>\n";

                #Parcours du fichier associé au pointeur FIC;
                #Chaque ligne est stockée dans la variable $ligne;
                while ($ligne=<FIC>)

                {       #On vérifie si la ligne contient le motif ci-dessous;
                        #l'opérateur conditionnel =~ signifie "ressemble à";
                        #g = general, c'est à dire on cherche tout le texte;
                        #.* = on cherche n'importe quel caractère qui apparait
                        if ($ligne=~/<description>(.*)<\/description>/g) {

                        #vu que $1 est une variable par défaut (elle désigne le contenu entre parenthèses)
                        #on préfère la remplacer par une variable locale;
                        my $var=$1;

                        #si la ligne contient le motif indiquée ci-dessus, on procède au remplacement des caractères "mal affichés";

                        $var=~ s/&#38;#39;/'/g;
                        $var=~ s/&#38;#34;/"/g;
                        $var=~ s/&#234;/ê/g;
                        $var=~ s/é/é/g;
                        $var=~ s/ç/ç/g;
                        $var=~ s/è/è/g;
                        $var=~ s/Ã/à/g;
                        $var=~ s/à´/ô/g;
                        $var=~ s/&#233;/é/g;

                        if (!open (FILEOUTTEMP,">temp.txt")) { die "Pb a l'ouverture du fichier temp.txt"};

                        #on formate le texte mot par ligne
                        $var=~ s/([^A-Za-zéèàëêâùïçôîÉÈÀÊÔÂÎÏËÙÇ'])/\n$1\n/g;
                        $var=~ s/\'/\'\n/g;
                        print FILEOUTTEMP $var;
                        close(FILEOUTTEMP);

#-----------------------------------------------------------
##Traitement par Tree-tagger:

                 #fichier d'entree ($input2): le fichier contenant le résultat des remplacements éffectués ci-dessus;
                 #fichier de sortie ($output2): le fichier contenant le résultat du traitement par Tree-tagger;
                        $input2 = "temp.txt";
                        $output2 = "sortie_tt.txt";

                        #on lance le Tree-tagger en indiquant les options, fichier paramètre, fichier d'entrée et
 fichier de sortie
                        system("tree-tagger.exe -token -lemma -no-unknown french.par $input2 $output2");


#-----------------------------------------------------------
##Formatage de sortie XML
                         #on ouvre le fichier temporaire étiqueté et lemmatisé par Tree tagger
                        open (FILEINTEMP, $output2);

                        while ($ligne1= <FILEINTEMP>)
                        {
                                #l'opérateur !~ (ne ressemble pas à)
                                if ($ligne1!~/\ô\¯\:\.\ô\¯\:\.\./) {
            # Remplacement des guillemets par <![CDATA["]]> (évite erreur d'interprétation XML)
            $ligne1=~s/\"/<![CDATA[\"]]>/g;

# . = un caractère quelconque sauf fin de ligne;
#\t = tabulation
#[^\t] = tout sauf tabulation
# * = 0 ou n fois
            $ligne1=~s/([^\t]*)\t([^\t]*)\t(.*)/<element>\n<data type=\"type\">$2<\/data>\n
<data type=\"lemma\">$3<\/data>\n<data type=\"string\">$1<\/data>\n<\/element>/;

                        $DUMPFULL1 .= $ligne1;
                                }

                        }


                        }
                }
                #on ferme la balise <file> qui boucle le traitement de chaque fichier;
                $DUMPFULL1 .= "</file>\n";
                close(FILEINTEMP, $output2);

            print $i++,"\n";
        }
    }
}
#----------------------------------------------