CallGraph - create, navigate, and dump the call graph for a program

NAME

CallGraph - create, navigate, and dump the call graph for a program

SYNOPSIS

    # note: you need a subclass for the language you are using
    use CallGraph::Lang::Fortran;
    my $graph = CallGraph::Lang::Fortran->new(files => [glob('*.f')]);
    print $graph->dump;

    # navigate the call graph...
    my $root = $graph->root;     # returns a CallGraph::Node object
    my (@calls) = $root->calls;


    # if you want to create your own language subclass:
    package CallGraph::Lang::MyLanguage;
    use base 'CallGraph';
    # must define the parse method
    sub parse {
        my ($self, $fh) = @_;
        while (<$fh>) {
            # add subroutines and calls by using
            # $self->new_sub and $self->add_call
        }
    }

DESCRIPTION

This module creates a ``call graph'' for a program. Please note that you need another module to actually parse your program and add the calls by using the CallGraph methods. The current distribution includes a module for parsing Fortran 77, the CallGraph::Lang::Fortran manpage.

METHODS

CallGraph->new(option => value, ...)

Create a new CallGraph object. The following options are available:

files => $file1
files => [$file1, $file2...]: Reads and parses the given files. $file1, etc. can be either filenames or filehandles.
lines => \@lines: Parses the array reference, which is expected to be an array of program lines. You can use this if you have already slurped your program into an array.
dump_options => {option => value, ...}: Pass the options to the CallGraph::Dumper manpage when dumping the call graph.

$graph->add_files($file1, $file2, ...)

Reads and parses the given files. $file1, etc. can be either filenames or filehandles.

$graph->add_lines(\@lines)

Parses the array reference, which is expected to be an array of program lines. You can use this if you have already slurped your program into an array.

$graph->add_call($from, $to)

Add a call (a link) to the graph. $from and $to must be subroutine names. The nodes are created automatically (by calling new_sub) if needed, with type 'external' (meaning that they haven't been defined explicitly yet).

my $sub = $graph->get_sub($sub_name)

Returns the the CallGraph::Node manpage object for the subroutine named $sub_name. Note that there can be only one subroutine with a given name in a call graph.

my @subs = $graph->subs

Returns the list of all the subroutines contained in the graph, as the CallGraph::Node manpage objects.

my $root = $graph->root;

$graph->root($new_root);

Get or set the root of the call graph. $root is a CallGraph::Node object; $new_root can be either an object or a subroutine name.

my $sub = $graph->new_sub(name => $sub_name, [type => $type])

Create and add a new subroutine (a the CallGraph::Node manpage object) to the graph. There can only be one subroutine with a given name; if new_sub is called with a name that has been used before, it returnes the previously existing object (note that the type of an existing object can be changed by this call).

If the type is not specified when a subroutine is first created, it defaults to 'external'.

my $dump = $graph->dump(option => value, ...)

Dump the call graph into a string representation. The options are passed to the CallGraph::Dumper manpage. The root of the graph must be defined for dump to work.

VERSION

0.55

AUTHOR

Ivan Tubert <itub@cpan.org>

COPYRIGHT

CallGraph - create, navigate, and dump the call graph for a program