gvpr
(1)
Name
gvpr - graph pattern scanning and processing language
( previously known as gpr )
Synopsis
gvpr [-icqV?] [ -o outfile ] [ -a args ] [ 'prog' | -f
progfile ] [ files ]
Description
User Commands GVPR(1)
NAME
gvpr - graph pattern scanning and processing language
( previously known as gpr )
SYNOPSIS
gvpr [-icqV?] [ -o outfile ] [ -a args ] [ 'prog' | -f
progfile ] [ files ]
DESCRIPTION
gvpr 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 predi-
cate-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 tar-
get graph. The output graph can be set in the program or,
in a limited sense, on the command line.
OPTIONS
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 out-
put graph in the context of its root graph.
-o outfile
Causes the output stream to be written to the specified
SunOS 5.11 Last change: 3 July 2009 1
User Commands GVPR(1)
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 speci-
fied in the environment variable GPRPATH 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.
-V Causes the program to print version information and
exit.
-? Causes the program to print usage information and exit.
OPERANDS
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.
PROGRAMS
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:
SunOS 5.11 Last change: 3 July 2009 2
User Commands GVPR(1)
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 per-
formed on every node or edge, as appropriate. If there is
no action and the predicate evaluates to true, the associ-
ated 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 the 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 differ-
ence 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. How-
ever, 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 super-
type 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.
SunOS 5.11 Last change: 3 July 2009 3
User Commands GVPR(1)
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:
{ [ statement ... ] }
expression // commonly var = expression
if( expression ) statement [ else statement ]
for( expression ; expression ; expression ) statement
for( array [ var ]) statement
forr( array [ var ]) statement
while( expression ) statement
switch( expression ) case statements
break [ expression ]
continue [ expression ]
return [ expression ]
Items in brackets are optional.
In the second form of the for statement and the forr state-
ment, 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 compar-
isons using == and != treat the right hand operand as a pat-
tern for the purpose of regular expression matching. Pat-
terns 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 possi-
ble.
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
SunOS 5.11 Last change: 3 July 2009 4
User Commands GVPR(1)
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 identi-
fiers denote attributes of the current node or edge, respec-
tively, 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.
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
SunOS 5.11 Last change: 3 July 2009 5
User Commands GVPR(1)
strict : int
true (non-zero) if the graph is strict
BUILT-IN FUNCTIONS
The following functions are built into gvpr. Those functions
returning references to graph objects return NULL in case of
failure.
Graphs and subgraph
graph(s : string, t : string) : graph_t
creates a graph whose name is s and whose type is spec-
ified by the string t. Ignoring case, the 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 : graph_t, s : string) : graph_t
creates a subgraph in graph g with name s. If the sub-
graph already exists, it is returned.
isSubg(g : graph_t, s : string) : graph_t
returns the subgraph in graph g with name s, if it
exists, or NULL otherwise.
fstsubg(g : graph_t) : graph_t
returns the first subgraph in graph g, or NULL if none
exists.
nxtsubg(sg : graph_t) : graph_t
returns the next subgraph after sg, or NULL.
isDirect(g : graph_t) : int
returns true if and only if g is directed.
isStrict(g : graph_t) : int
returns true if and only if g is strict.
nNodes(g : graph_t) : int
returns the number of nodes in g.
nEdges(g : graph_t) : int
returns the number of edges in g.
Nodes
node(sg : graph_t, s : string) : node_t
creates a node in graph g of name s. If such a node
already exists, it is returned.
subnode(sg : graph_t, n : node_t) : node_t
inserts the node n into the subgraph g. Returns the
node.
SunOS 5.11 Last change: 3 July 2009 6
User Commands GVPR(1)
fstnode(g : graph_t) : node_t
returns the first node in graph g, or NULL if none
exists.
nxtnode(n : node_t) : node_t
returns the next node after n in the root graph, or
NULL.
nxtnode_sg(sg : graph_t, n : node_t) : node_t
returns the next node after n in sg, or NULL.
isNode(sg : graph_t, s : string) : node_t
looks for a node in (sub)graph sg of name s. If such a
node exists, it is returned. Otherwise, NULL is
returned.
isSubnode(sg : graph_t, n : node_t) : int
returns non-zero if node n is in (sub)graph sg, or zero
otherwise.
indegreeOf(sg : graph_t, n : node_t) : int
returns the indegree of node n in (sub)graph sg.
outdegreeOf(sg : graph_t, n : node_t) : int
returns the outdegree of node n in (sub)graph sg.
degreeOf(sg : graph_t, n : node_t) : int
returns the degree of node n in (sub)graph sg.
Edges
edge(t : node_t, h : node_t, s : string) : edge_t
creates an edge with tail node t, head node h and name
s in the root graph. If the graph is undirected, the
distinction between head and tail nodes is unimportant.
If such an edge already exists, it is returned.
edge_t
edge_sg(sg : graph_t, t : node_t, h : node_t, s :
string) :
creates an edge with tail node t, head node h and name
s in (sub)graph sg (and all parent graphs). 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 : graph_t, e : edge_t) : edge_t
inserts the edge e into the subgraph g. Returns the
edge.
isEdge(t : node_t, h : node_t, s : string) : edge_t
looks for an edge with tail node t, head node h and
name s. If the graph is undirected, the distinction
SunOS 5.11 Last change: 3 July 2009 7
User Commands GVPR(1)
between head and tail nodes is unimportant. If such an
edge exists, it is returned. Otherwise, NULL is
returned.
edge_t
isEdge_sg(sg : graph_t, t : node_t, h : node_t, s :
string) :
looks for an edge with tail node t, head node h and
name s in (sub)graph sg. If the graph is undirected,
the distinction between head and tail nodes is unimpor-
tant. If such an edge exists, it is returned. Other-
wise, NULL is returned.
isSubedge(g : graph_t, e : edge_t) : int
returns non-zero if edge e is in (sub)graph sg, or zero
otherwise.
fstout(n : node_t) : edge_t
returns the first outedge of node n in the root graph.
fstout_sg(sg : graph_t, n : node_t) : edge_t
returns the first outedge of node n in (sub)graph sg.
nxtout(e : edge_t) : edge_t
returns the next outedge after e in the root graph.
nxtout_sg(sg : graph_t, e : edge_t) : edge_t
returns the next outedge after e in graph sg.
fstin(n : node_t) : edge_t
returns the first inedge of node n in the root graph.
fstin_sg(sg : graph_t, n : node_t) : edge_t
returns the first inedge of node n in graph sg.
nxtin(e : edge_t) : edge_t
returns the next inedge after e in the root graph.
nxtin_sg(sg : graph_t, e : edge_t) : edge_t
returns the next inedge after e in graph sg.
fstedge(n : node_t) : edge_t
returns the first edge of node n in the root graph.
fstedge_sg(sg : graph_t, n : node_t) : edge_t
returns the first edge of node n in graph sg.
nxtedge(e : edge_t, node_t) : edge_t
returns the next edge after e in the root graph.
nxtedge_sg(sg : graph_t, e : edge_t, node_t) : edge_t
returns the next edge after e in the graph sg.
SunOS 5.11 Last change: 3 July 2009 8
User Commands GVPR(1)
Graph I/O
write(g : graph_t) : void
prints g in dot format onto the output stream.
writeG(g : graph_t, fname : string) : void
prints g in dot format into the file fname.
fwriteG(g : graph_t, fd : int) : void
prints g in dot format onto the open stream denoted by
the integer fd.
readG(fname : string) : graph_t
returns a graph read from the file fname. The graph
should be in dot format. If no graph can be read, NULL
is returned.
freadG(fd : int) : graph_t
returns the next graph read from the open stream fd.
Returns NULL at end of file.
Graph miscellany
delete(g : graph_t, x : obj_t) : void
deletes object x from graph g. If g is NULL, the func-
tion uses the root graph of x. If x is a graph or sub-
graph, it is closed unless x is locked.
isIn(g : graph_t, x : obj_t) : int
returns true if x is in subgraph g.
cloneG(g : graph_t, s : string) : graph_t
creates a clone of graph g with name of s. If s is "",
the created graph has the same name as g.
clone(g : graph_t, x : obj_t) : obj_t
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. In this case, the call is equivalent to
cloneG(x,"").
copy(g : graph_t, x : obj_t) : obj_t
creates a copy of object x in graph g, where the new
object has the same name/value attributes as the origi-
nal 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
SunOS 5.11 Last change: 3 July 2009 9
User Commands GVPR(1)
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.
copyA(src : obj_t, tgt : obj_t) : int
copies the attributes of object src to object tgt,
overwriting any attribute values tgt may initially
have.
induce(g : graph_t) : void
extends g to its node-induced subgraph extension in its
root graph.
hasAttr(src : obj_t, name : string) : int
returns non-zero if object src has an attribute whose
name is name. It returns 0 otherwise.
isAttr(g : graph_t, kind : string, name : string) : int
returns non-zero if an attribute name has been defined
in g for objects of the given kind. For nodes, edges,
and graphs, kind should be "N", "E", and "G", respec-
tively. It returns 0 otherwise.
aget(src : obj_t, name : string) : string
returns the value of attribute name in object src. This
is useful for those cases when name conflicts with one
of the keywords such as "head" or "root". If the
attribute has not been declared in the graph, the func-
tion will initialize it with a default value of "". To
avoid this, one should use the hasAttr or isAttr func-
tion to check that the attribute exists.
aset(src : obj_t, name : string, value : string) : int
sets the value of attribute name in object src to
value. Returns 0 on success, non-zero on failure. See
aget above.
getDflt(g : graph_t, kind : string, name : string) : string
returns the default value of attribute name in objects
in g of the given kind. For nodes, edges, and graphs,
kind should be "N", "E", and "G", respectively. If the
attribute has not been declared in the graph, the func-
tion will initialize it with a default value of "". To
avoid this, one should use the isAttr function to check
that the attribute exists.
string) : int
setDflt(g : graph_t, kind : string, name : string,
value :
sets the default value of attribute name to value in
SunOS 5.11 Last change: 3 July 2009 10
User Commands GVPR(1)
objects in g of the given kind. For nodes, edges, and
graphs, kind should be "N", "E", and "G", respectively.
Returns 0 on success, non-zero on failure. See getDflt
above.
fstAttr(g : graph_t, kind : string) : string
returns the name of the first attribute of objects in g
of the given kind. For nodes, edges, and graphs, kind
should be "N", "E", and "G", respectively. If there
are no attributes, the string "" is returned.
nxtAttr(g : graph_t, kind : string, name : string) : string
returns the name of the next attribute of objects in g
of the given kind after the attribute name. The argu-
ment name must be the name of an existing attribute; it
will typically be the return value of an previous call
to fstAttr or nxtAttr. For nodes, edges, and graphs,
kind should be "N", "E", and "G", respectively. If
there are no attributes left, the string "" is
returned.
compOf(g : graph_t, n : node_t) : graph_t
returns the connected component of the graph g contain-
ing node n, as a subgraph of g. The subgraph only con-
tains the nodes. One can use induce to add the edges.
The function fails and returns NULL if n is not in g.
Connectivity is based on the underlying undirected
graph of g.
kindOf(obj : obj_t) : string
returns an indication of what kind of graph object is
the argument. For nodes, edges, and graphs, it returns
should be "N", "E", and "G", respectively.
lock(g : graph_t, v : int) : int
implements graph locking on root graphs. 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
the graph while it was locked, the graph is closed. If
v is negative, nothing is done. In all cases, the pre-
vious lock value is returned.
Strings
sprintf(fmt : string, ...) : string
returns the string resulting from formatting the values
of the expressions occurring after fmt according to the
printf(3) format fmt
gsub(str : string, pat : string) : string
gsub(str : string, pat : string, repl : string) : string
SunOS 5.11 Last change: 3 July 2009 11
User Commands GVPR(1)
returns str with all substrings matching pat deleted or
replaced by repl, respectively.
sub(str : string, pat : string) : string
sub(str : string, pat : string, repl : string) : string
returns str with the leftmost substring matching pat
deleted or replaced by repl, respectively. The charac-
ters '^' 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 : string, idx : int) : string
substr(str : string, idx : int, len : int) : string
returns the substring of str starting at position idx
to the end of the string or of length len, respec-
tively. Indexing starts at 0. If idx is negative or
idx is greater than the length of str, a fatal error
occurs. Similarly, in the second case, if len is nega-
tive or idx + len is greater than the length of str, a
fatal error occurs.
strcmp(s1 : string, s2 : string) : int
provides the standard C function strcmp(3).
index(s : string, t : string) : int
rindex(s : string, t : string) : int
returns the index of the character in string s where
the leftmost (rightmost) copy of string t can be found,
or -1 if t is not a substring of s.
match(s : string, p : string) : int
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.
toupper(s : string) : string
returns a version of s with the alphabetic characters
converted to upper-case.
tolower(s : string) : string
returns a version of s with the alphabetic characters
converted to lower-case.
canon(s : string) : string
returns a version of s appropriate to be used as an
identifier in a dot file.
html(g : graph_t, s : string) : string
returns a ``magic'' version of s as an HTML string.
SunOS 5.11 Last change: 3 July 2009 12
User Commands GVPR(1)
This will typically be used to attach an HTML-like
label to a graph object. Note that the returned string
lives in g. In particular, it will be freed when g is
closed, and to act as an HTML string, it has to be used
with an object of g. In addition, note that the angle
bracket quotes should not be part of s. These will be
added if g is written in concrete DOT format.
xOf(s : string) : string
returns the string "x" if s has the form "x,y", where
both x and y are numeric.
yOf(s : string) : string
returns the string "y" if s has the form "x,y", where
both x and y are numeric.
llOf(s : string) : string
returns the string "llx,lly" if s has the form
"llx,lly,urx,ury", where all of llx, lly, urx, and ury
are numeric.
urOf(s)
urOf(s : string) : string returns the string "urx,ury"
if s has the form "llx,lly,urx,ury", where all of llx,
lly, urx, and ury are numeric.
sscanf(s : string, fmt : string, ...) : int
scans the string s, extracting values according to the
sscanf(3) format fmt. The values are stored in the
addresses following fmt, addresses having the form &v,
where v is some declared variable of the correct type.
Returns the number of items successfully scanned.
split(s : string, arr : array, seps : string) : int
split(s : string, arr : array) : int
tokens(s : string, arr : array, seps : string) : int
tokens(s : string, arr : array) : int
The split function breaks the string s into fields,
while the tokens function breaks the string into
tokens. A field consists of all non-separator charac-
ters between two separator characters or the beginning
or end of the string. Thus, a field may be the empty
string. A token is a maximal, non-empty substring not
containing a separator character. The separator char-
acters are those given in the seps argument. If seps
is not provided, the default value is " \t\n". The
functions return the number of fields or tokens.
The fields and tokens are stored in the argument array.
SunOS 5.11 Last change: 3 July 2009 13
User Commands GVPR(1)
The array must be string-valued and, if an index type
is specified, it must be int. The entries are indexed
by consecutive integers, starting at 0. Any values
already stored in the array will be either overwritten,
or still be present after the function returns.
I/O
print(...) : void
print( expr, ... ) prints a string representation of
each argument in turn onto stdout, followed by a new-
line.
printf(fmt : string, ...) : int
printf(fd : int, fmt : string, ...) : int
prints the string resulting from formatting the values
of the expressions following fmt according to the
printf(3) format fmt. Returns 0 on success. By
default, it prints on stdout. If the optional integer
fd is given, output is written on the open stream asso-
ciated with fd.
scanf(fmt : string, ...) : int
scanf(fd : int, fmt : string, ...) : int
scans in values from an input stream according to the
scanf(3) format fmt. The values are stored in the
addresses following fmt, addresses having the form &v,
where v is some declared variable of the correct type.
By default, it reads from stdin. If the optional inte-
ger fd is given, input is read from the open stream
associated with fd. Returns the number of items suc-
cessfully scanned.
openF(s : string, t : string) : int
opens the file s as an I/O stream. The string argument
t specifies how the file is opened. The arguments are
the same as for the C function fopen(3). It returns an
integer denoting the stream, or -1 on error.
As usual, streams 0, 1 and 2 are already open as stdin,
stdout, and stderr, respectively. Since gvpr may use
stdin to read the input graphs, the user should avoid
using this stream.
closeF(fd : int) : int
closes the open stream denoted by the integer fd.
Streams 0, 1 and 2 cannot be closed. Returns 0 on
success.
readL(fd : int) : string
returns the next line read from the input stream fd. It
SunOS 5.11 Last change: 3 July 2009 14
User Commands GVPR(1)
returns the empty string "" on end of file. Note that
the newline character is left in the returned string.
Math
exp(d : double) : double
returns e to the dth power.
log(d : double) : double
returns the natural log of d.
sqrt(d : double) : double
returns the square root of the double d.
pow(d : double, x : double) : double
returns d raised to the xth power.
cos(d : double) : double
returns the cosine of d.
sin(d : double) : double
returns the sine of d.
atan2(y : double, x : double) : double
returns the arctangent of y/x in the range -pi to pi.
MIN(y : double, x : double) : double
returns the minimum of y and x.
MAX(y : double, x : double) : double
returns the maximum of y and x.
Associative Arrays
# arr : int
returns the number of elements in the array arr.
idx in arr : int
returns 1 if a value has been set for index idx in the
array arr. It returns 0 otherwise.
unset(v : array, idx) : int
removes the item indexed by idx. It returns 1 if the
item existed, 0 otherwise.
unset(v : array) : void
re-initializes the array.
Miscellaneous
exit(v : int) : void
causes gvpr to exit with the exit code v.
system(cmd : string) : int
provides the standard C function system(3). It
SunOS 5.11 Last change: 3 July 2009 15
User Commands GVPR(1)
executes cmd in the user's shell environment, and
returns the exit status of the shell.
rand() : double
returns a pseudo-random double between 0 and 1.
srand() : int
srand(v : int) : int
sets a seed for the random number generator. The
optional argument gives the seed; if it is omitted, the
current time is used. The previous seed value is
returned. srand should be called before any calls to
rand.
colorx(color : string, fmt : string) : string
translates a color from one format to another. The
color argument should be a color in one of the recog-
nized string representations. The fmt value should be
one of "RGB", "RGBA", "HSV", or "HSVA". An empty
string is returned on error.
BUILT-IN VARIABLES
gvpr provides certain special, built-in variables, whose
values are set automatically by gvpr depending on the con-
text. Except as noted, the user cannot modify their values.
$ : obj_t
denotes the current object (node, edge, graph) depend-
ing 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.
$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
SunOS 5.11 Last change: 3 July 2009 16
User Commands GVPR(1)
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 undi-
rected) depth-first traversal of the graph (cf. $tvtype
below). 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 previx "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].
BUILT-IN CONSTANTS
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
SunOS 5.11 Last change: 3 July 2009 17
User Commands GVPR(1)
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 sim-
ply look for some unvisited node and traverse its con-
nected component. On the other hand, if $tvroot has
changed, its connected component will be toured, assum-
ing 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 infi-
nite 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 speci-
fied 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 speci-
fied 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 bread-first search on
the graph ignoring edge directions. See the item on
TV_dfs above for the role of $tvroot.
SunOS 5.11 Last change: 3 July 2009 18
User Commands GVPR(1)
EXAMPLES
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 %s0, n, e, $G.name);
tot_n += n;
tot_e += e;
}
END { printf ("%d nodes %d edges total0, tot_n, tot_e) }
Version of the program gc.
gvpr -c ""
Equivalent to nop.
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] = %d0, n.name, deg[n]);
}
}
Computes the degrees of nodes with edges.
BEGIN {
int i, indent;
int seen[string];
SunOS 5.11 Last change: 3 July 2009 19
User Commands GVPR(1)
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.
ENVIRONMENT
GPRPATH
Colon-separated list of directories to be searched to
find the file specified by the -f option.
BUGS AND WARNINGS
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, underly-
ing 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
InxtnodeP cannot traverse a subgraph using just a node argu-
ment. For this reason, subgraph traversal requires new func-
tions ending in "_sg", which also take a subgraph argument.
The versions without that suffix will always traverse the
root graph.
SunOS 5.11 Last change: 3 July 2009 20
User Commands GVPR(1)
There is a single global scope, except for formal function
parameters, and even these can interfere with the type sys-
tem. 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 nec-
essary 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 '=='.
AUTHOR
Emden R. Gansner <erg@research.att.com>
ATTRIBUTES
See attributes(5) for descriptions of the following
attributes:
+---------------+------------------+
|ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+---------------+------------------+
|Availability | image/graphviz |
+---------------+------------------+
|Stability | Volatile |
+---------------+------------------+
SEE ALSO
awk(1), gc(1), dot(1), nop(1), expr(3), cgraph(3)
NOTES
This software was built from source available at
https://java.net/projects/solaris-userland. The original
community source was downloaded from
http://www.graphviz.org/pub/graphviz/sta-
SunOS 5.11 Last change: 3 July 2009 21
User Commands GVPR(1)
ble/SOURCES/graphviz-2.28.0.tar.gz
Further information about this software can be found on the
open source community website at http://www.graphviz.org/.
SunOS 5.11 Last change: 3 July 2009 22