Basically, gpr 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.

-a args

The string args is split into whitespace-separated tokens, with the individual tokens available as strings in the gpr program as ARGV[0],...,ARGV[ARGC-1].

-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 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 -f is not given, gpr will use the first non-option argument as the program.

-v

Causes the program to print version information and exit.

-?

Causes the program to print usage information and exit.

files

Names of files containing 1 or more graphs in 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, the standard input will be used.

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, BEG_G, END_G and END clauses. There can be any number of N and E statements, the first applied to nodes, the second to edges. The top-level semantics of a gpr program are: Evaluate the BEGIN clause, if any. For each input graph G { 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.

Predicates and actions are sequences of statements in the C dialect supported by libexpr(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, string, float, long, unsigned and double), gpr provides 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 '...'. In certain contexts, string values are interpreted as patterns for the purpose of regular expression matching. Patterns use ksh(1) file match pattern syntax. gpr uses C++ comments.

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 [ var ]

where the var is optional. Executable statements can be one of the following:

{ [ statement ... ] }
expression               # commonly var = expression
if( expression ) statement [ else statement ]
for( expression ; expression ; expression ) statement
for( array [ var ]) statement
while( expression ) statement
switch( expression ) case statements
break [ expression ]
continue [ expression ]
return [ expression ]

In the second form of the for statement, the variable var is set to each value used as an index in the specified array and then the associated statement is evaluated. 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. gpr will attempt to use an expression as a string or numeric value as appropriate.

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 libagraph(3) model, attributes are string-valued. In addition, gpr supports certain pseudo-attributes of graph objects, not necessarily string-valued. These reflect intrinsic properties of the graph objects and cannot be assigned to.

head

the head of an edge.

tail

the tail of an edge.

name

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

the indegree of a node.

outdegree

the outdegree of a node.

degree

the degree of a node.

root

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

parent

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

n_edges

the number of edges in the graph

n_nodes

the number of nodes in the graph

directed

true if the graph is directed

strict

true if the graph is strict

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

graph(s, t)

creates a graph whose name is s and whose type is specified by the string t. Ignoring case, characters U, D, S, N have the interpretation undirected, directed, strict, and non-strict, respectively. If t is empty, a directed, non-strict graph is generated.

subg(g, s)

creates a subgraph in graph g with name s. If the subgraph already exists, it is returned.

isSubg(g, s)

returns the subgraph in graph g with name s, if it exists.

fstsubg(g)

returns the first subgraph in graph g.

nxtsubg(sg)

returns the next subgraph after sg.

isDirect(g)

returns true if and only if g is directed.

isStrict(g)

returns true if and only if g is strict.

nNodes(g)

returns the number of nodes in g.

nEdges(g)

returns the number of edges in g.

node(g, s)

creates a node in graph g of name s. If such a node already exists, it is returned.

subnode(g, n)

inserts the node n into the subgraph g. Returns the node.

fstnode(g)

returns the first node in graph g.

nxtnode(n)

returns the next node after n.

isNode(g, s)

looks for a node in graph g of name s. If such a node exists, it is returned.

edge(t, h, s)

creates an edge with tail node t, head node h and name s. If the graph is undirected, the distinction between head and tail nodes is unimportant. If such an edge already exists, it is returned.

subedge(g, e)

inserts the edge e into the subgraph g. Returns the edge.

isEdge(t, h, s)

looks for an edge with tail node t, head node h and name s. If the graph is undirected, the distinction between head and tail nodes is unimportant. If such an edge exists, it is returned.

fstout(n)

returns the first out edge of node n.

nxtout(e)

returns the next out edge after e.

fstin(n)

returns the first in edge of node n.

nxtin(e)

returns the next in edge after e.

fstedge(n)

returns the first edge of node n.

nxtedge(e)

returns the next edge after e.

write(g)

prints g in dot format on the output stream.

writeG(g, fname)

prints g in dot format into the file fname.

fwriteG(g, fd)

prints g in dot format onto the open stream denoted by the integer fd.

readG(fname)

returns a graph read from the file fname. The graph should be in dot format.

freadG(fd)

returns the next graph read from the open stream fd. Return NULL at end of file.

delete(g, x)

deletes object x from graph g. If g is NULL, the function uses the root graph of x. If x is a graph or subgraph, it is closed unless x is locked.

isIn(g, v)

returns true if v is in subgraph g. If v is a graph, this indicates that g is the parent graph of v.

clone(g, x)

creates a clone of object x in graph g. In particular, the new object has the same name/value attributes and structure as the original object. If an object with the same key as x already exists, its attributes are overlaid by those of x and the object is returned. If an edge is cloned, both endpoints are implicitly cloned. If a graph is cloned, all nodes, edges and subgraphs are implicitly cloned. If x is a graph, g may be null, in which case the cloned object will be a new root graph.

copy(g, x)

creates a copy of object x in graph g, where the new object has the same name/value attributes as the original object. If an object with the same key as x already exists, its attributes are overlaid by those of x and the object is returned. Note that this is a shallow copy. If x is a graph, none of its nodes, edges or subgraphs are copied into the new graph. If x is an edge, the endpoints are created if necessary, but they are not cloned. If x is a graph, g may be null, in which case the cloned object will be a new root graph.

induce(g)

extends g to its node-induced subgraph extension in its root graph.

compOf(g, x)

returns the connected component of the graph g containing node x, as a subgraph of g. The subgraph only contains the nodes. One can use induce to add the edges. The function fails if x is not in g.

lock(g, v)

implements graph locking. If the integer v is positive, the graph is set so that future calls to delete have no immediate effect. If v is zero, the graph is unlocked. If there has been a call to delete while the graph was locked, the graph is closed. If v is negative, nothing is done. In all cases, the previous lock value is returned.

sprintf(fmt, expr, ...)

returns the string resulting from formatting expr ... according to the (3) format fmt

gsub(str, pat)

gsub(str, pat, repl)

returns str with all substrings matching pat deleted or replaced by repl, respectively.

sub(str, pat)

sub(str, pat, repl)

returns str with the leftmost substring matching pat deleted or replaced by repl, respectively. The characters '^' and '$' may be used at the beginning and end, respectively, of pat to anchor the pattern to the beginning or end of str.

substr(str, idx)

substr(str, idx, len)

returns the substring of str starting at position idx to the end of the string or of length len, respectively.

length(s)

returns the length of the string s.

index(s, t)

returns the index of the character in string s where the leftmost copy of string t can be found, or -1 if t is not a substring of s.

match(s, p)

returns the index of the character in string s where the leftmost match of pattern p can be found, or -1 if no substring of s matches p.

canon(s)

returns a version of s appropriate to be used as an identifier in a dot file.

xOf(s)

returns the string "x" if s has the form "x,y".

yOf(s)

returns the string "y" if s has the form "x,y".

llOf(s)

returns the string "llx,lly" if s has the form "llx,lly,urx,ury".

urOf(s)

returns the string "urx,ury" if s has the form "llx,lly,urx,ury".