gvpr - Man Page

gvpr [-icnqV?] [ -o outfile ] [ -a args ] [ 'prog' | -f progfile ] [ files ]

gvpr (previously known as gpr) is a graph stream editor inspired by awk. It copies input graphs to its output, possibly transforming their structure and attributes, creating new graphs, or printing arbitrary information. The graph model is that provided by libcgraph(3). In particular, gvpr reads and writes graphs using the dot language.

Basically, gvpr traverses each input graph, denoted by $G, visiting each node and edge, matching it with the predicate-action rules supplied in the input program. The rules are evaluated in order. For each predicate evaluating to true, the corresponding  action is performed.  During the traversal, the current node or edge being visited is denoted by $.

For each input graph, there is a target subgraph, denoted by $T, initially empty and used to accumulate chosen entities, and an output graph, $O, used for final processing and then written to output.  By default, the output graph is the target graph. The output graph can be set in the program or, in a limited sense, on the command line.

The following options are supported:

-a args

The string args is split into whitespace-separated tokens,  with the individual tokens available as strings in the gvpr program  as ARGV[0],...,ARGV[ARGC-1]. Whitespace characters within single or double quoted substrings, or preceded by a backslash, are ignored as separators.  In general, a backslash character turns off any special meaning of the following character. Note that the tokens derived from multiple -a flags are concatenated.

-c

Use the source graph as the output graph.

-i

Derive the node-induced subgraph extension of the output graph in the context  of its root graph.

-o outfile

Causes the output stream to be written to the specified file; by default, output is written to stdout.

-f progfile

Use the contents of the specified file as the program to execute on the input. If progfile contains a slash character, the name is taken as the pathname of the file. Otherwise, gvpr will use the directories specified in the environment variable GVPRPATH to look for the file. If -f is not given, gvpr will use the first non-option argument as the program.

-q

Turns off warning messages.

-n

Turns off graph read-ahead. By default, the variable $NG is set to the next graph to be processed. This requires a read of the next graph before processing the current graph, which may block if the next graph is only generated in response to some action pertaining to the processing of the current graph.

-V

Causes the program to print version information and exit.

-?

Causes the program to print usage information and exit.

The following operand is supported:

files

Names of files containing 1 or more graphs in the dot language. If no -f option is given, the first name is removed from the list and used  as the input program. If the list of files is empty, stdin will be used.

A gvpr program consists of a list of predicate-action clauses, having one of the forms:

BEGIN { action }

BEG_G { action }

N [ predicate ] { action }

E [ predicate ] { action }

END_G { action }

END { action }

A program can contain at most one of each of the BEGIN,  END_G and END clauses.  There can be any number of BEG_G, N and E statements, the first applied to graphs, the second to nodes, the third to edges. These are separated into blocks, a block consisting of an optional BEG_G statement and all N and E statements up to  the next BEG_G statement, if any. The top-level semantics of a gvpr program are:

Evaluate the BEGIN clause, if any.
For each input graph G {
    For each block {
        Set G as the current graph and current object.
        Evaluate the BEG_G clause, if any.
        For each node and edge in G {
            Set the node or edge as the current object.
            Evaluate the N or E clauses, as appropriate.
        } 
    } 
    Set G as the current object.
    Evaluate the END_G clause, if any.
} 
Evaluate the END clause, if any.

The actions of the BEGIN, BEG_G, END_G and END clauses are performed when the clauses are evaluated. For N or E clauses, either the predicate or action may be omitted.  If there is no predicate with an action, the action is  performed on every node or edge, as appropriate. If there is no action and the predicate evaluates to true, the associated node or edge is added to the target graph.

The blocks are evaluated in the order in which they occur. Within a block, the N clauses  (E clauses, respectively) are evaluated in the order in which they occur. Note, though, that within a block,  N or E clauses may be interlaced, depending on the traversal order.

Predicates and actions are sequences of statements in the C dialect  supported by the expr(3) library. The only difference between predicates and actions is that the former must have a type that may interpreted as either true or false. Here the usual C convention is followed, in which a non-zero value is considered true. This would include non-empty strings and non-empty references to nodes, edges, etc. However, if a string can be  converted to an integer, this value is used.

In addition to the usual C base types (void, int, char, float, long,  unsigned and double),  gvpr provides string as a synonym for char*, and  the graph-based types node_t, edge_t, graph_t and obj_t. The obj_t type can be viewed as a supertype of the other 3 concrete types; the correct base type is maintained dynamically. Besides these base types, the only other supported type expressions are (associative) arrays.

Constants follow C syntax, but strings may be quoted with either "..." or '...'. gvpr accepts C++ comments as well as cpp-type comments. For the latter, if a line begins with a '#' character, the rest of the line is ignored.

A statement can be a declaration of a function, a variable or an array, or an executable statement. For declarations, there is a single scope. Array declarations have the form:

 type array [ type0 ]

where type0 is optional. If it is supplied, the parser will  enforce that all array subscripts have the specified type. If it is not supplied, objects of all types can be used as subscripts. As in C, variables and arrays must be declared. In particular, an undeclared variable will be interpreted as the name of an attribute of a node, edge or graph, depending on the context.

Executable statements can be one of the following:

Items in brackets are optional.

In the second form of the for statement and the forr statement, the variable var is set to each value used as an index in the specified array and then the associated statement is evaluated. For numeric and string indices, the indices are  returned in increasing (decreasing) numeric or lexicographic order for  for (forr, respectively). This can be used for sorting.

Function definitions can only appear in the BEGIN clause.

Expressions include the usual C expressions.  String comparisons using == and != treat the right hand operand as a pattern for the purpose of regular expression matching. Patterns use ksh(1) file match pattern syntax. (For simple string equality, use the strcmp function.

gvpr will attempt to use an expression as a string or numeric value  as appropriate. Both C-like casts and function templates will cause conversions to be performed, if possible.

Expressions of graphical type (i.e., graph_t, node_t, edge_t, obj_t) may be followed by a field reference in the form of .name. The resulting value is the value of the attribute named name of the given object. In addition, in certain contexts an undeclared, unmodified identifier is taken to be an attribute name. Specifically, such identifiers denote attributes of the current node or edge, respectively, in N and E clauses, and the current graph in BEG_G and END_G clauses.

As usual in the libcgraph(3) model, attributes are string-valued. In addition, gvpr supports certain pseudo-attributes of graph objects, not necessarily string-valued. These reflect intrinsic properties of the graph objects and cannot be set by the user.

head : node_t

the head of an edge.

tail : node_t

the tail of an edge.

name : string

the name of an edge, node or graph. The name of an edge has the form "<tail-name><edge-op><head-name>[<key>]", where <edge-op> is "->" or "--" depending on whether the graph is directed or not. The bracket part [<key>] only appears if the edge has a non-trivial key.

indegree : int

the indegree of a node.

outdegree : int

the outdegree of a node.

degree : int

the degree of a node.

X : double

the X coordinate of a node. (Assumes the node has a pos attribute.)

Y : double

the Y coordinate of a node. (Assumes the node has a pos attribute.)

root : graph_t

the root graph of an object. The root of a root graph is itself.

parent : graph_t

the parent graph of a subgraph. The parent of a root graph is NULL

n_edges : int

the number of edges in the graph

n_nodes : int

the number of nodes in the graph

directed : int

true (non-zero) if the graph is directed

strict : int

true (non-zero) if the graph is strict

The following functions are built into gvpr. Those functions returning references to graph objects return NULL in case of failure.

gvpr provides certain special, built-in variables, whose values are set automatically by gvpr depending on the context. Except as noted, the user cannot modify their values.

$ : obj_t

denotes the current object (node, edge, graph) depending on the context.  It is not available in BEGIN or END clauses.

$F : string

is the name of the current input file.

$G : graph_t

denotes the current graph being processed. It is not available in BEGIN or END clauses.

$NG : graph_t

denotes the next graph to be processed. If $NG is NULL,  the current graph $G is the last graph. Note that if the input comes from stdin, the last graph cannot be determined until the input pipe is closed.  It is not available in BEGIN or END clauses, or if the  -n flag is used.

$O : graph_t

denotes the output graph. Before graph traversal, it is initialized to the target graph. After traversal and any END_G actions, if it refers to a non-empty graph, that graph is printed onto the output stream. It is only valid in N, E and END_G clauses. The output graph may be set by the user.

$T : graph_t

denotes the current target graph. It is a subgraph of $G and is available only in N, E and END_G clauses.

$tgtname : string

denotes the name of the target graph.  By default, it is set to "gvpr_result". If used multiple times during the execution of gvpr, the name will be appended with an integer.  This variable may be set by the user.

$tvroot : node_t

indicates the starting node for a (directed or undirected) depth-first or breadth-first traversal of the graph (cf. $tvtype below). The default value is NULL for each input graph. After the traversal at the given root, if the value of $tvroot has changed, a new traversal will begin with the new value of $tvroot. Also, see $tvnext below.

$tvnext : node_t

indicates the next starting node for a (directed or undirected) depth-first or breadth-first traversal of the graph (cf. $tvtype below). If a traversal finishes and the $tvroot has not been reset but the $tvnext has been set but not used, this node will be used as the next choice for $tvroot. The default value is NULL for each input graph.

$tvedge : edge_t

For BFS and DFS traversals, this is set to the edge used to arrive at the current node or edge. At the beginning of a traversal, or for other traversal types, the value is NULL.

$tvtype : tvtype_t

indicates how gvpr traverses a graph. It can only take one of the constant values with the prefix "TV_" described below. TV_flat is the default.

In the underlying graph library cgraph(3), edges in undirected graphs are given an arbitrary direction. This is used for traversals, such as TV_fwd, requiring directed edges.

ARGC : int

denotes the number of arguments specified by the  -a args command-line argument.

ARGV : string array

denotes the array of arguments specified by the  -a args command-line argument. The ith argument is given by ARGV[i].

There are several symbolic constants defined by gvpr.

NULL : obj_t

a null object reference, equivalent to 0.

TV_flat : tvtype_t

a simple, flat traversal, with graph objects visited in seemingly arbitrary order.

TV_ne : tvtype_t

a traversal which first visits all of the nodes, then all of the edges.

TV_en : tvtype_t

a traversal which first visits all of the edges, then all of the nodes.

TV_dfs : tvtype_t

TV_postdfs : tvtype_t

TV_prepostdfs : tvtype_t

a traversal of the graph using a depth-first search on the underlying undirected graph.  To do the traversal, gvpr will check the value of $tvroot. If this has the same value that it had previously (at the start, the previous value is initialized to NULL.), gvpr will simply look for some unvisited node and traverse its connected component. On the other hand, if $tvroot has changed, its connected component will be toured, assuming it has not been previously visited or, if $tvroot is NULL, the traversal will stop. Note that using TV_dfs and $tvroot, it is possible to create an infinite loop.

By default, the traversal is done in pre-order. That is, a node is visited before all of its unvisited edges. For TV_postdfs, all of a node's unvisited edges are visited before the node. For TV_prepostdfs, a node is visited twice, before and after all of its unvisited edges.

TV_fwd : tvtype_t

TV_postfwd : tvtype_t

TV_prepostfwd : tvtype_t

A traversal of the graph using a depth-first search on the graph following only forward arcs. The choice of roots for the traversal is the same as described for TV_dfs above. The different order of visitation specified by TV_fwd, TV_postfwd and TV_prepostfwd are the same as those specified by the analogous traversals TV_dfs, TV_postdfs and TV_prepostdfs.

TV_rev : tvtype_t

TV_postrev : tvtype_t

TV_prepostrev : tvtype_t

A traversal of the graph using a depth-first search on the graph following only reverse arcs. The choice of roots for the traversal is the same as described for TV_dfs above. The different order of visitation specified by TV_rev, TV_postrev and TV_prepostrev are the same as those specified by the analogous traversals TV_dfs, TV_postdfs and TV_prepostdfs.

TV_bfs : tvtype_t

A traversal of the graph using a breadth-first search on the graph ignoring edge directions. See the item on TV_dfs above for the role of $tvroot.

gvpr -i 'N[color=="blue"]' file.gv

Generate the node-induced subgraph of all nodes with color blue.

gvpr -c 'N[color=="blue"]{color = "red"}' file.gv

Make all blue nodes red.

BEGIN { int n, e; int tot_n = 0; int tot_e = 0; }
BEG_G {
  n = nNodes($G);
  e = nEdges($G);
  printf ("%d nodes %d edges %s\n", n, e, $G.name);
  tot_n += n;
  tot_e += e;
}
END { printf ("%d nodes %d edges total\n", tot_n, tot_e) }

Version of the program gc.

BEG_G { graph_t g = graph ("merge", "S"); }
E {
  node_t h = clone(g,$.head);
  node_t t = clone(g,$.tail);
  edge_t e = edge(t,h,"");
  e.weight = e.weight + 1;
}
END_G { $O = g; }

Produces a strict version of the input graph, where the weight attribute of an edge indicates how many edges from the input graph the edge represents.

BEGIN {node_t n; int deg[]}
E{deg[head]++; deg[tail]++; }
END_G {
  for (deg[n]) {
    printf ("deg[%s] = %d\n", n.name, deg[n]);
  }
}

Computes the degrees of nodes with edges.

BEGIN {
  int i, indent;
  int seen[string];
  void prInd (int cnt) {
    for (i = 0; i < cnt; i++) printf ("  ");
  }
}
BEG_G {

   $tvtype = TV_prepostfwd;
   $tvroot = node($,ARGV[0]);
}
N {
  if (seen[$.name]) indent--;
  else {
    prInd(indent);
      print ($.name);
    seen[$.name] = 1;
    indent++;
  }
}

Prints the depth-first traversal of the graph, starting with the node whose name is ARGV[0], as an indented list.

GVPRPATH

Colon-separated list of directories to be searched to find the file specified by the -f option. gvpr has a default list built in. If GVPRPATH is not defined, the default list is used. If GVPRPATH starts with colon, the list is formed by appending GVPRPATH to the default list. If GVPRPATH ends with colon, the list is formed by appending the default list to GVPRPATH. Otherwise, GVPRPATH is used for the list.

On Windows systems, replace “colon” with “semicolon” in the previous paragraph.

Scripts should be careful deleting nodes during N{} and E{} blocks using BFS and DFS traversals as these rely on stacks and queues of nodes.

When the program is given as a command line argument, the usual shell interpretation takes place, which may affect some of the special names in gvpr. To avoid this, it is best to wrap the program in single quotes.

If string constants contain pattern metacharacters that you want to escape to avoid pattern matching, two backslashes will probably be necessary, as a single backslash will be lost when the string is originally scanned. Usually, it is simpler to use strcmp to avoid pattern matching.

As of 24 April 2008, gvpr switched to using a new, underlying graph library, which uses the simpler model that there is only one copy of a node, not one copy for each subgraph logically containing it. This means that iterators such as nxtnode cannot traverse a subgraph using just a node argument. For this reason, subgraph traversal requires new functions ending in "_sg", which also take a subgraph argument. The versions without that suffix will always traverse the root graph.

There is a single global scope, except for formal function parameters, and even these can interfere with the type system. Also, the  extent of all variables is the entire life of the program.  It might be preferable for scope to reflect the natural nesting of the clauses, or for the program to at least reset locally declared variables. For now, it is advisable to use distinct names for all variables.

If a function ends with a complex statement, such as an IF statement, with each branch doing a return, type checking may fail.  Functions should use a return at the end.

The expr library does not support string values of (char*)0. This means we can't distinguish between "" and (char*)0 edge keys. For the purposes of looking up and creating edges, we translate ""  to be (char*)0, since this latter value is necessary in order to look up any edge with a matching head and tail.

Related to this, strings converted to integers act like char pointers, getting the value 0 or 1 depending on whether the string consists solely of zeroes or not. Thus, the ((int)"2") evaluates to 1.

The language inherits the usual C problems such as dangling references and the confusion between '=' and '=='.

Emden R. Gansner <erg@research.att.com>

awk(1), gc(1), dot(1), nop(1), expr(3), cgraph(3)

acyclic(1), bcomps(1), ccomps(1), dijkstra(1), gc(1), gvcolor(1), gvgen(1), gvmap(1), gvmap.sh(1), gvpack(1), gvpr(3), nop(1), prune(1), sccmap(1), smyrna(1), tred(1), unflatten(1).