Comment puis-je créer un graphe d'appel d'analyse statique pour Perl?

Question

Je travaille sur un programme Perl modérément complexe. Dans le cadre de son développement, il doit subir des modifications et des tests. En raison de certaines contraintes d'environnement, l'exécution fréquente de ce programme n'est pas une option facile à exercer.

Ce que je veux, c'est un générateur de graphe d'appel statique pour Perl. Il n'a pas à couvrir tous les cas de bords (par exemple, redéfinir les variables pour les fonctions ou vice versa dans une évaluation).

(Oui, je sais qu'il ya une centrale d'appel graphique d'exécution avec Devel :: dprofpp, mais la gestion du temps n'est pas garanti d'appeler toutes les fonctions. Je besoin pouvoir regarder chaque fonction

Answer 1

Je ne pense pas qu'il existe un générateur de graphe d'appel "statique" pour Perl. La prochaine chose la plus proche serait Devel::NYTProf.

L'objectif principal est le profilage, mais sa sortie peut vous dire combien de fois un sous-programme a été appelé, et d'où.

Si vous devez vous assurer que tous les sous-programmes sont appelés, vous pouvez également utiliser Devel::Cover, qui vérifie que votre suite de tests couvre chaque sous-routine.

Answer 2

ne peut se faire dans le cas général:

my $obj = Obj->new; 
my $method = some_external_source(); 

$obj->$method(); 

Cependant, il devrait être assez facile d'obtenir un grand nombre de cas (exécuter ce programme contre lui-même):

#!/usr/bin/perl 

use strict; 
use warnings; 

sub foo { 
    bar(); 
    baz(quux()); 
} 

sub bar { 
    baz(); 
} 

sub baz { 
    print "foo\n"; 
} 

sub quux { 
    return 5; 
} 

my %calls; 

while (<>) { 
    next unless my ($name) = /^sub (\S+)/; 
    while (<>) { 
     last if /^}/; 
     next unless my @funcs = /(\w+)\(/g; 
     push @{$calls{$name}}, @funcs; 
    } 
} 

use Data::Dumper; 
print Dumper \%calls; 

Notez ce manque

• appels à des fonctions qui n'utilisent pas entre parenthèses (par exemple print "foo\n";)
• appels à des fonctions qui sont déréférencées (par ex. $coderef->())
• appels à des méthodes qui sont des chaînes (par exemple $obj->$method())
• appelle le putt la parenthèse ouverte sur une autre ligne
• autres choses que je ne l'ai pas pensé

Il capture de façon incorrecte

• fonctions (par exemple #foo() a commenté)
• certaines chaînes (par exemple "foo()")
• autres choses que je ne l'ai pas pensé

Si vous voulez une meilleure solution que bidouille sans valeur, il est temps de commencer à chercher dans PPI, mais même cela aura des problèmes avec des choses comme $obj->$method().

Juste parce que je m'ennuyais, voici une version qui utilise PPI. Il ne trouve que les appels de fonction (pas les appels de méthode). Il ne fait également aucune tentative pour conserver les noms des sous-programmes uniques (c.-à-d.si vous appelez le même sous-programme plus d'une fois, il apparaîtra plus d'une fois).

#!/usr/bin/perl 

use strict; 
use warnings; 

use PPI; 
use Data::Dumper; 
use Scalar::Util qw/blessed/; 

sub is { 
    my ($obj, $class) = @_; 
    return blessed $obj and $obj->isa($class); 
} 

my $program = PPI::Document->new(shift); 

my $subs = $program->find(
    sub { $_[1]->isa('PPI::Statement::Sub') and $_[1]->name } 
); 

die "no subroutines declared?" unless $subs; 

for my $sub (@$subs) { 
    print $sub->name, "\n"; 
    next unless my $function_calls = $sub->find(
     sub { 
      $_[1]->isa('PPI::Statement')    and 
      $_[1]->child(0)->isa("PPI::Token::Word") and 
      not (
       $_[1]->isa("PPI::Statement::Scheduled") or 
       $_[1]->isa("PPI::Statement::Package") or 
       $_[1]->isa("PPI::Statement::Include") or 
       $_[1]->isa("PPI::Statement::Sub")  or 
       $_[1]->isa("PPI::Statement::Variable") or 
       $_[1]->isa("PPI::Statement::Compound") or 
       $_[1]->isa("PPI::Statement::Break")  or 
       $_[1]->isa("PPI::Statement::Given")  or 
       $_[1]->isa("PPI::Statement::When") 
      ) 
     } 
    ); 
    print map { "\t" . $_->child(0)->content . "\n" } @$function_calls; 
} 

Answer 3

Je ne suis pas sûr qu'il est 100% possible (puisque le code Perl ne peut pas être analysé de façon statique en théorie, en raison de BEGIN blocs et tels - voir very recent SO discussion). En outre, les références de sous-programmes peuvent rendre très difficile à faire même dans des endroits où blocs n'entrent pas en jeu.

Cependant, someone apparently made the attempt - Je le sais seulement mais ne l'ai jamais employé ainsi l'acheteur méfiez-vous.

Answer 4

J'ai récemment trébuché sur un script en essayant de trouver une réponse à la même question. Le script (lié à ci-dessous) utilise GraphViz pour créer un graphique d'appel d'un programme ou module Perl. La sortie peut être dans un certain nombre de formats d'image.

http://www.teragridforum.org/mediawiki/index.php?title=Perl_Static_Source_Code_Analysis