oracular (3) Analizo::Command::graph.3pm.gz

NAME

       analizo-graph - dependency graph generator

USAGE

         analizo graph [OPTIONS] <input> [<input> [<input> ...]]

DESCRIPTION

       analizo graph reads the dependency information from one or more source code directories passed as
       arguments, and produces as output the graph of dependencies between the modules of the software in the
       graphviz(1) format.

       analizo graph is part of the analizo suite.

REQUIRED ARGUMENTS

       <input>...
           The input directories (or files) with source code to be processed.

           Although you can pass individual files as input, this tool is more useful if you pass entire source
           directories. If you pass just a couple of files, their dependencies on modules that are not declared
           and/or implemented in those files will not be calculated.

OPTIONS

       --omit <functions>
           Omit the given functions from the call graph. Multiple function names may be given separated by
           commas.

       --cluster
           Cluster the functions into files, so you can see in which files are the calling and called functions.

       --modules
           Group the functions by modules (files or OO classes), and only represent calls between modules. This
           is useful to see the dependencies between the modules of the program, instead of focusing on specific
           functions. The arrows between the modules will be labelled with a number that represents the number
           of different places in which the calling module calls functions in the called module (i.e.  how many
           times module A calls module B).

           It doesn't make much sense to use --modules together with --cluster.

       --extractor <extractor>
           Define which extractor method use to parse the source code. Currently "Doxyparse" is the only
           extractor available.  Default is Doxyparse.

       --output <file>, -o <file>
           Use a file as output

VIEWING THE GRAPH

       To view the generated graph, pipe analizo's output to one of the Graphviz tools. You can use dotty(1) to
       display the graph in a X11 window:

         $ analizo graph src/ | dotty -

       You can also generate a file to print or include in a document by using the dot(1).

       To generate a PNG image called graph.png:

         $ analizo graph src/ | dot -Tpng -ograph.png -

       To generate a PostScript version of the dependency graph for printing, you can also use the dot. For
       example, to generate a dependency graph in the file graph.ps fitting everything on a US letter size page
       in landscape mode, try

         $ analizo graph src/ | dot -Grotate=90 -Gsize=11,8.5 -Tps -o graph.ps

       Sometimes, the graph will fit better if the dependencies arrows go from left to right instead of top to
       bottom.  The dot option -Grankdir=LR will do that:

         $ analizo graph src/ | dot -Gsize=8.5,11 -Grankdir=LR -Tps -o graph.ps

       For large software, the graph may end up too small to comfortably read.  If that happens, try N-up
       printing:

         $ analizo graph src/ | dot -Gpage=8.5,11 -Tps -o graph.ps

       You can also try playing with other dot options such as -Gratio, or for a different style of graph, try
       using neato instead of dot. See the Graphviz documentation for more information about the various options
       available for customizing the style of the graph.

READING THE GRAPH

       When generating a graph in the function level (i.g. without the --modules option), function calls are
       displayed as solid arrows.  A dotted arrow means that the function the arrow points from takes the
       address of the function the arrow points to; this typically indicates that the latter function is being
       used as a callback.

       When the --modules option is on, then there are only solid arrows. An arrow from A to B means that A
       depends on B.

SEE ALSO

       dotty(1), dot(1), neato(1), analizo(1)

COPYRIGHT AND AUTHORS

       See analizo(1).