root/trunk/jps2ps/jpshash.pl

#!/usr/bin/perl -w

#### le repertoire d'installation de BBgraf 
#$BBGRAF_DIR = "/var/www/syracuse/bbgraf/";

### le repertoire d'installation de jps2ps
##$JPS2PS_DIR = $BBGRAF_DIR . "jps2ps/";
$JPS2PS_DIR = "/opt/syracuse/app/jps2ps/";

### le repertoire d'installation des pps
$PPS_DIR = $JPS2PS_DIR . "pps/";

### le repertoire d'installation des package
$PACKAGE_DIR = $JPS2PS_DIR . "package/";

### les programmes utilises
$lit_cles = $JPS2PS_DIR . "lit_cles.pl";
$lit_appels = $JPS2PS_DIR . "lit_appels.pl";

## affichage d'un tableau
sub affiche_tableau {
    my ($reftableau) = @_ ;
    foreach $mot (@$reftableau) {
        print ("           " . $mot . "\n");
    };
}

## affichage d'un tableau
sub affiche_tableau_terminal {
    my ($reftableau) = @_ ;
    foreach $mot (@$reftableau) {
        print ("\"$mot\", ");
    };
}

## affichage de la table de hachage %keytofile passee en argument
sub affiche_hachage {
    my (%keytofile) = @_;
    foreach $cle (keys %keytofile) {
        print ("cle      : $cle\n");
        print ("fichiers : \n");
        &affiche_tableau ($keytofile {$cle});
    };
}

## affichage de la table de hachage %keytofile passee en argument
sub affiche_hachage_terminal {
    my (%keytofile) = @_;
    foreach $cle (keys %keytofile) {
        print ("     \"$cle\" => [");
        &affiche_tableau_terminal ($keytofile {$cle});
        print ("],\n");
    };
}


##### creation du fichier listpps
sub cree_listpps_file {
$listpps_file = "/tmp/listpps.pl";

open (FILE, ">$listpps_file") or die "impossible d'ouvrir $listpps_file";
select (FILE);
print<<Fin_Code;
#!/usr/bin/perl 

\$PPS_DIR = \$JPS2PS_DIR . "pps/";
\$PACKAGE_DIR = \$JPS2PS_DIR . "package/";

##### ##### ##### ##### ##### ##### ##### ##### 
#####
##### les fichiers .pps 
#####
##### ##### ##### ##### ##### ##### ##### ##### 
Fin_Code


## on recup les noms des fichiers pps
@les_fichiers = `cd $PPS_DIR \; find ./ -name "*.pps"`;
foreach (@les_fichiers) {
    $_ =~ s/\.\///;
};

foreach $element (@les_fichiers) {
    $element =~ s/\n//;
    $pps_name = $element;
    $pps_name =~ s/\.pps//;
    print ("\$" . $pps_name . " = \$PPS_DIR \. \"" . $element . "\";\n");
};

## idem pour les packages

## on recup les noms des fichiers pps
@les_package = `cd $PACKAGE_DIR \; find ./ -name "*.pps"`;
foreach (@les_package) {
    $_ =~ s/\.\///;
};

foreach $element (@les_package) {
    $element =~ s/\n//;
    $pkg_name = $element;
    $pkg_name =~ s/\.pps//;
    print ("\$" . $pkg_name . " = \$PACKAGE_DIR \. \"" . $element . "\";\n");
};

print ("1;\n");
close (FILE);
};


##### ##### ##### ##### ##### ##### ##### ##### 
#####
##### creation du fichier priorite
#####
##### ##### ##### ##### ##### ##### ##### ##### 
sub cree_priorite_file {
$priorite_file = "/tmp/priorite.pl";

open (FILE, ">$priorite_file") or die "impossible d'ouvrir $priorite_file";
select (FILE);
print<<Fin_Code;
#!/usr/bin/perl 

##### ##### ##### ##### ##### ##### ##### ##### 
##### 
##### On definit le tableau des ordres de priorite
##### pour les _fichiers_ a inserer. Autrement dit,
##### on ne trouve ici que des noms de fichier
##### (definis dans listpps.pl) 
##### 
##### ##### ##### ##### ##### ##### ##### ##### 

\@cles = (
Fin_Code

@les_fichiers = `cd $PPS_DIR \; find ./ -name "*.pps"`;
foreach (@les_fichiers) {
    $_ =~ s/\.\///;
};
foreach $element (@les_fichiers) {
    $element =~ s/\n//;
    $pps_name = $element;
    $pps_name =~ s/\.pps//;
    print ("\"" . $pps_name . "\",\n");
};

@les_package = `cd $PACKAGE_DIR \; find ./ -name "*.pps"`;
foreach (@les_package) {
    $_ =~ s/\.\///;
};
foreach $element (@les_package) {
    $element =~ s/\n//;
    $pkg_name = $element;
    $pkg_name =~ s/\.pps//;
    print ("\"" . $pkg_name . "\",\n");
};
print ("\);\n1;\n");
close (FILE);
};

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

&cree_listpps_file;
&cree_priorite_file;

%keytofile = ();
%filetoappels = ();
#$refhash = \%keytofile;

## on lit les cles defs dans un fichier pps, et affecte 
## ce fichier en dependance pour chaque cle
foreach $pps (@les_fichiers) {
    @cles = `cd $PPS_DIR \; $lit_cles $pps`;
    $pps_name = $pps;
    $pps_name =~ s/\.pps//;
    $pps_name =~ s/\n//;
    foreach $cle (@cles) {
        $cle =~ s/\n//;
        $keytofile {$cle} = ["$pps_name"];
    };
};

foreach $pkg (@les_package) {
    $pkg_name = $pkg;
    $pkg_name =~ s/\.pps//;
    $cle = "use" . "$pkg_name";
    $keytofile {$cle} = ["$pkg_name"];
};
## 

## maintenant on lit les appels ds chaque fichier
foreach $pps (@les_fichiers) {
    @appels = `cd $PPS_DIR \; $lit_appels $pps`;
    $pps_name = $pps;
    $pps_name =~ s/\.pps//;
    $pps_name =~ s/\n//;
    foreach (@appels) {
        $_ =~ s/\n//;
    };
    $filetoappels {$pps_name} = [ @appels ];
};

foreach $pkg (@les_package) {
    @appels = `cd $PACKAGE_DIR \; $lit_appels $pkg`;
    $pkg_name = $pkg;
    $pkg_name =~ s/\.pps//;
    $pkg_name =~ s/\n//;
    foreach (@appels) {
        $_ =~ s/\n//;
    };
    $filetoappels {$pkg_name} = [ @appels ];
};

#select (STDOUT);
#&affiche_hachage (%filetoappels);
#&affiche_hachage (%keytofile);

sub fait_une_passe {
    $modif = 0;
foreach $word (keys %keytofile) {
#    print ("clé étudiée : $word\n");

    ## fichier pps ou est stocke la def de arcnp
    $pps_name = $keytofile {"$word"} [0];
#    print ("fichier de stockage : $pps_name\n");
    
    ## table des appels ds le fichier pps
    $reftab = $filetoappels {"$pps_name"};
    @tab = @$reftab;
#    &affiche_tableau ([ @$reftab ]);

    $i = 0;
    $n = 1 + $#tab;
    while ($i < $n) {
        ## appel no $i
        $nom = @$reftab [$i];
        if (exists ($keytofile{$nom})) {
        @appel = ();
        @appel = @{ $keytofile {"$word"} };
        $taille1 = $#appel;
        push (@{ $keytofile {"$word"}} , @{ $keytofile {"$nom"}});

        ## ## maintenant on supprime les doublons ds un tableau du hachage
        %deja_vu = ();
        @uniques = ();
        @appel = ();
        @appel = @{ $keytofile {"$word"} };
        foreach $objet (@appel) {
            unless ($deja_vu{$objet}) {
                $deja_vu{$objet} = 1;
                push (@uniques, $objet);
            }
        }
        $taille2 = $#uniques;

        $keytofile {"$word"} = [ @uniques ];
        if ($taille2 > $taille1) {
            $modif = 1;
        };

#           print ("$nom : $taille1 : $taille2\n");
#            $reftableau_dep = $keytofile {"$nom"};
#            @tableau_dep = @$reftableau_dep;
#            &affiche_tableau ([ @$reftableau_dep ]);
        };
        $i++;
    }
## le nombre de ces appels
#print ("$n\n");
};
};

## le traitement des dependances
$modif = 1;
while ($modif =~ 1) {
    &fait_une_passe ();
};



sub cree_dephash_file {
##### creation du fichier dephash
$dephash_file = "/tmp/dephash.pl";

open (FILE, ">$dephash_file") or die "impossible d'ouvrir $dephash_file";
select (FILE);
print<<Fin_Code;
#!/usr/bin/perl 

##### ##### ##### ##### ##### ##### ##### ##### 
#####
##### on definit le hachage des dependances
#####
##### ##### ##### ##### ##### ##### ##### ##### 

%dependances = (
Fin_Code

&affiche_hachage_terminal (%keytofile);

print ("                \);\n 1;");
close (FILE);
};

## select (STDOUT);
## &affiche_hachage_terminal (%keytofile);

## foreach (@cles) {
##     print ($_ . ".\n");
## };

&cree_dephash_file ();

`mv $dephash_file $JPS2PS_DIR`;
`mv $listpps_file $JPS2PS_DIR`;
`mv $priorite_file $JPS2PS_DIR`;

1;