uDraw(Graph)

While the above features make this a tremendously useful tool, there are a few small hitches:

• It is quite memory hungry, such that, after a longish meditation, it may crash without having displayed anything -- a clear sign that you must reduce the number of nodes and/or edges further.
• It strongly separates graph attributes and display options. This means that you can't put into a generated graph the fact that it is to be oriented sideways (which is generally necessary here because, even when renamed to something short, filenames are much wider than tall). As a workaround, if you don't want to make it your default, or choose orientation from the menu every time, they propose a little starter script:

      export UDG_HOME=/where/ever/uDrawGraph-3.1
      TMP=`mktemp -t udg.XXXXXX` || exit 1
      trap "rm -f $TMP" EXIT
      echo "[menu(file(open_graph(\"${1-log.udg}\"))),menu(layout(orientation(left_right)))]" >$TMP
      $UDG_HOME/bin/uDrawGraph -init $TMP
      

• It doesn't yet support node border colors. Due to this "--because" displays double borders when they should be red.
• When merging several files into one node leads to self edges both with "--dependencies" and "--includes", only one of these will be displayed, randomly dotted or drawn through and with a label of "2*".

Graphviz

dotty

Its own display tool, dotty, has the advantage over uDraw(Graph) that you can freely drag the nodes, without being restricted to the level assigned by the layout. When your screen is full of edges, dragging one node gives you a nice impression of where the edges of that node lead to. But it also loses information when you modify it. Apart from that it is an antiquated Xlib tool. It also displays an annoying little circle on the middle of each edge, and no option seems to get rid of it.

ZGRViewer

ZGRViewer <http://zvtm.sourceforge.net/zgrviewer.html> is a separately downloadable Java viewer which has comfortable zooming and panning. The graph is only viewable, no moving of nodes. There are five buttons in the view area, which offer additional fancy semi-3D zoom variations, but, unlike the basic functionality, they can be extremely slow depending on your Java setup. For my Sun Linux Java, the following gave a tremendous boost:

    export J2D_PIXMAPS=shared USE_DGA_PIXMAPS=1
    

Grappa

Grappa is a separately downloadable Java 1.2 viewer. There is no wrapper shell script, the jar contains no manifest, none of the sources contain a main function, and with the appletviewer it produced two tall windows which hang with a "starting applet" message, so I don't know how to test this. It can be tried on a demo web site as an applet.

Selecting an edge makes it bold red, so you can manually scroll its other end into view without loosing it out of sight. Other than that and zooming and deleting nodes it seems to have no useful features. It ignores valid hexadecimal color specifications.

SVG

SVG, one of the file types the backends can export to, is already quite old. But some browsers still have problems with it. When embedding it with an object tag only Opera scales it, others clip it, which is useless for a thumbnail. When viewed as a document of it's own, only Opera and Konqueror allow scaling it, while Firefox scales only the labels. Even though the labels are text, no browser can search for them. IE6 doesn't have a clue, unless you install a plugin. A dedicated application, like Inkscape, can serve you better.

HTML

Textual Graph

    (define-derived-mode textgraph-mode outline-mode "Graph"
      (view-mode)
      (set (make-local-variable 'outline-regexp) " *.")
      (set (make-local-variable 'outline-level)
           (lambda () (/ (- (match-end 0) (match-beginning 0) -1) 2)))
      (set (make-local-variable 'outline-font-lock-keywords)
           '(("^ *\\(?:{[a-z,]+} \\)?\\([^{\n]+\\)" (1 (outline-font-lock-face) nil t))))
      (setq imenu-generic-expression
            '((nil "^ *\\(?:{[a-z,]+} \\)?\\(.+?\\)\\(?:{[a-z,]+}\\)?$" 1))))

The lines can have comma separated annotations between braces, unless you also give the "-p, --plain" option. When these come before the target they pertain to the relationship with the parent, i.e. the previous line indented less. When they come after the target, they pertain to the target itself. They are as follows:

because

When this comes before a target, the parent was built because of this one. When it comes after, the target had some inherent reason for being rebuilt.

bidirectional

This dependency or inclusion goes in both directions.

include

The parent includes this file. This annotation is only given when also showing dependencies.

phony

This is a phony target.

repeated

The information about this target and its children was already given earlier on.

Renaming

For one thing, you can rewrite names to "undef" or the empty string. This will eliminate the node from the graph. Note that eliminating a node in this first stage will break a chain of dependency if this node was in the middle.

You can also rewrite various names to the same string, coercing them all into the same node, which accumulates the combined dependencies and dependents.

On the other hand you can just rename names to (usually) shorter names, so as to reduce the width of nodes, which can be far to wide with absolute filenames. There are a few predefined functions in package "Mpp::Rewrite", in which your code also runs, you can use for this. These return true if they did something so you can combine them as in:

    --rename='cwd( 1 ) || &home || &usr'

&cwd

cwd number

cwd number, name[, separator]

Removes the current working directory from the beginning of path. With a number, also replaces parent directories that many levels up with the right number of ../ directories, where applicable. In this case you can give an alternate name, like a piled up ':' instead of '..' and additionally an alternate separator like '' instead of '/'. In the first case you might get :/:/a/b, in the second an even shorter ::a/b instead of ../../a/b. Passing a number is useful if you draw in stuff from neighbouring trees. Or you have a src directory, where most of the action is, so you call makeppgraph there, but want to see the relation to your other directories too.

If you give no "--rename" option, &cwd is the default. Should you want no renaming, you can give some perlcode like "--rename=1" that does nothing.

&dir

This one is a great reducer of graph complexity. It reduces every file to its directory. That amounts to the question: "Files from which directory depend on files from which other directory?" Note that while the dependency graph is always acyclic (else makepp wouldn't know where to start building), that is not true of this reduced view. E.g. if dir1/a depends on dir2/b and dir2/a on dir1/b that will display as a mutual dependency between dir1 and dir2. Since a cyclic graph has no obvious starting point, the layout may be odd.

Unlike the other functions in this section, this is not exclusive with the others. So you may not want to logically combine it:

    --rename='&dir; &cwd || &home'
    

&home

Replaces your home directory with ~/.

&makepp

Replaces the makepp installation directory with |m|.

&suf

suf number

This one is also a great reducer of graph complexity. It reduces every file that has a suffix to an asterisk and that suffix. So you can see which kinds of files depend on which other kinds. With an argument of 0 it leaves the first character of the directory, provided it is one of "/", "~" or "|" (as put in by &home or &usr if you called those first). With a positive argument, it leaves that many directory levels at the beginning. With a negative argument, it removes that many directory levels at the end. So for /a/b/c/d/e/x.y you get:

    &suf        *.y
    suf 0       /*.y
    suf 1       /a/*.y
    suf 2       /a/b/*.y
    suf -1      /a/b/c/d/*.y
    suf -2      /a/b/c/*.y
    

For a relative a/b/c/d/e/x.y you get:

    &suf        *.y
    suf 0       *.y
    suf 1       a/*.y
    suf -1      a/b/c/d/*.y
    

&usr

Under /, /usr, /usr/local, /usr/X11, /u sr/X11R6, /usr/X11R7 or /opt, for any of the directories bin, etc, include, lib or share, the initials of these words are concatenated between bars.

E.g. /usr/local/ b in/foobar becomes |ulb|foobar or /usr/include/net/if.h becomes |ui|net/if.h. Note that `l' stands for `local' when between two letters and for `lib' as the last letter.

Merging

c2o

For any C/C++ source and the resulting .o file, merge them into one node, by adding to the source path a suffix of ">o" like some/where/foo.cc>o, even if the .o file is in another directory.

exe

For any .o file and the resulting executable of the same notdir basename without a suffix or with .exe, merge them into one node, by adding an asterisk to the .o file. This will not currently work together with c2o.

x2

For any pair of files with the same name, usually a header or library published to a central directory, merge them into one node, by adding *2 to the dependency.