GVPR(1)

📦
version 16.1.0 · 4 versions
, in arch rolling, fedora 43, fedora 44, nixpkgs unstable, ubuntu resolute, ubuntu stonking

💖 GVPR(1) 💖

okay bestie, this is the manual for gvpr — graph pattern scanning and processing language. It's giving graph stream editor, awk-inspired, and we're about to read the whole thing together. 💅

✨ NAME ✨

gvpr — graph pattern scanning and processing language

🌸 SYNOPSIS 🌸

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

🦋 DESCRIPTION 🦋

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.

💅 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 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 — Enable verbose 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:

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:

{ [ 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 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

💖 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 🌸

okay bestie, these are the graph-level functions that make graphs, subgraphs, and tell you stuff about them. slay.

  • graph(s : string, t : string) : graph_t — creates a graph whose name is s and whose type is specified 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 subgraph already exists, it is returned. no cap.
  • 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. periodt.
  • 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 🦋

nodes are the main characters, fr fr. here’s how to make them and vibe-check them.

  • node(g : 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 sg. Returns the node.
  • 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.
  • rename(n : node_t, newname : string) : int — changes the name of n to newname and returns 0 on success or -1 if there is an existing node with that name.

🌈 Edges 🌈

edges connect the girlies. here’s the whole edge situation.

  • 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_sg(sg : graph_t, t : node_t, h : node_t, s : string) : edge_t — 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 between head and tail nodes is unimportant. If such an edge exists, it is returned. Otherwise, NULL is returned.
  • isEdge_sg(sg : graph_t, t : node_t, h : node_t, s : string) : edge_t — 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 unimportant. If such an edge exists, it is returned. Otherwise, NULL is returned.
  • isSubedge(sg : 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, n : node_t) : edge_t — returns the next edge after e in the root graph.
  • nxtedge_sg(sg : graph_t, e : edge_t, n : node_t) : edge_t — returns the next edge after e in the graph sg.
  • opp(e : edge_t, n : node_t) : node_t — returns the node on the edge e not equal to n. Returns NULL if n is not a node of e. This can be useful when using fstedge and nxtedge to enumerate the neighbors of n. 💅

💾 Graph I/O 💾

reading and writing graphs, the moment we’ve all been waiting for.

  • 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 🎀

the catch-all drawer of graph stuff. it’s giving very useful, ngl.

  • delete(g : graph_t, x : obj_t) : void — 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 : 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 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.
  • 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", respectively. 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 function will initialize it with a default value of "". To avoid this, one should use the hasAttr or isAttr function 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 function will initialize it with a default value of "". To avoid this, one should use the isAttr function to check that the attribute exists.
  • setDflt(g : graph_t, kind : string, name : string, value : string) : int — sets the default value of attribute name to value in 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 argument 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 — hands you back the connected component of graph g that contains node n, as a subgraph of g. Heads up bestie: this subgraph is nodes only, no edges. You gotta run induce if you want the edges back in. If n isn't even in g, it fails and returns NULL. And "connected" here means connected in the underlying undirected graph of g. 🦋
  • kindOf(obj : obj_t) : string — tells you what kind of thing obj is. For nodes it's "N", for edges "E", for graphs "G". Cute lil single-letter vibes. ✨
  • lock(g : graph_t, v : int) : int — graph locking, but only on root graphs. If v is positive, the graph gets locked so future delete calls don't take effect immediately. If v is zero, it's unlocked. And if somebody called delete on the graph while it was locked? The graph gets closed. If v is negative, literally nothing happens. Either way, you get the previous lock value back. 💅

🌸 Strings 🌸

  • sprintf(fmt : string, ...) : string — returns the string you get from formatting everything after fmt according to the printf(3) format fmt. Classic glow-up for your values. ✨
  • gsub(str : string, pat : string) : string
  • gsub(str : string, pat : string, repl : string) : string — gives you str with all the substrings matching pat deleted, or replaced by repl. Global search and destroy, no cap. 🔥
  • sub(str : string, pat : string) : string
  • sub(str : string, pat : string, repl : string) : string — same energy but only the leftmost substring matching pat gets deleted or replaced by repl. You can also use '^' and '$' at the beginning and end of pat to anchor the pattern to the start or end of str, respectively. 🎀
  • substr(str : string, idx : int) : string
  • substr(str : string, idx : int, len : int) : string — the substring of str from position idx to the end, or of length len. Indexing starts at 0 btw, we're not barbarians. If idx is negative or idx is greater than the length of str, it's a fatal error. Same deal in the second form: if len is negative or idx + len is greater than the length of str, fatal error. Be careful bestie. 😭
  • strcmp(s1 : string, s2 : string) : int — it's the standard C strcmp(3), doing exactly what you expect. 🫶
  • length(s : string) : int — the length of string s. Periodt. 💅
  • index(s : string, t : string) : int
  • rindex(s : string, t : string) : int — gives you the index in s where the leftmost (or rightmost) copy of t lives, or -1 if t isn't a substring of s. Finder of strings, iconic. 🦋
  • match(s : string, p : string) : int — the index in s where the leftmost match of pattern p starts, or -1 if no substring of s matches p. Regex bestie behavior. ✨
  • toupper(s : string) : string — a version of s with the alphabetic characters screamed into UPPER-CASE. 📣
  • tolower(s : string) : string — a version of s with the alphabetic characters softened into lower-case. 🌸
  • canon(s : string) : string — a version of s that's fit to be used as an identifier in a dot file. Cleaned up and ready to serve. 💅
  • html(g : graph_t, s : string) : string — returns a "magic" version of s as an HTML string. You'd typically use this to attach an HTML-like label to a graph object. Important tea though: the returned string lives in g. So it gets freed when g is closed, and to actually act as an HTML string it has to be used with an object of g. Also the angle bracket quotes should not be part of s — those get added if g is written in concrete DOT format. 🎀
  • ishtml(s : string) : int — returns non-zero if and only if s is an HTML string. Simple vibe check. ✨
  • 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. Matching set bestie. 🍓
  • 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, pulling out values according to the sscanf(3) format fmt. The values get stored in the addresses following fmt, and those addresses have the form &v, where v is some declared variable of the correct type. Returns how many items it 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 — okay so split breaks the string s into fields, while tokens breaks it into tokens. A field is all the non-separator characters between two separator characters (or the beginning/end of the string) — which means a field can totally be the empty string, no judgment. A token is a maximal, non-empty substring that doesn't contain a separator character. The separator characters are whatever you put in seps. If you don't provide seps, the default is " \t\n". The functions return the number of fields or tokens. 🌈

The fields and tokens get stored in the argument arr. That array must be string-valued and have int as its index type. Entries are indexed by consecutive integers starting at 0. Anything already sitting in the array will either be 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 newline. Say it with your chest. 📣
  • printf(fmt : string, ...) : int
  • printf(fd : int, fmt : string, ...) : int — prints the string you get from formatting the values after fmt according to the printf(3) format fmt. Returns 0 on success. By default it prints on stdout. If you pass the optional integer fd, output is written on the open stream associated with fd. Serving formatted text fr fr. 💅
  • scanf(fmt : string, ...) : int
  • scanf(fd : int, fmt : string, ...) : int — scans values from an input stream according to the scanf(3) format fmt. Values get stored in the addresses following fmt, addresses of the form &v, where v is a declared variable of the correct type. By default it reads from stdin. If the optional integer fd is given, input is read from the open stream associated with fd. Returns the number of items successfully scanned. 🫶
  • openF(s : string, t : string) : int — opens the file s as an I/O stream. The string argument t says how the file gets opened. The arguments are the same as for the C function fopen(3). 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. But since gvpr may use stdin to read the input graphs, the user should avoid using this stream. You've been warned bestie. 😭

  • 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. Returns the empty string "" on end of file. Note that the newline character is left in the returned string, so don't be surprised by it. 🌸

➗ 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. Hashtag it, count it, slay. 💅
  • idx in arr : int — returns 1 if a value has been set for index idx in the array arr. Returns 0 otherwise. Vibe check on that index. ✨
  • unset(v : array, idx) : int — removes the item indexed by idx. Returns 1 if the item existed, 0 otherwise. 🧚
  • unset(v : array) : void — re-initializes the array. Full reset, fresh start. 🌸

✨ Miscellaneous ✨

  • exit(v : int) : void — causes gvpr to exit with the exit code v. Bye bestie, on your terms. 👋
  • system(cmd : string) : int — provides the standard C function system(3). It executes cmd in the user's shell environment, and returns the exit status of the shell. Main character energy, running the whole show. 🔥
  • 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 you leave it out, the current time is used. Returns the previous seed value. srand should be called before any calls to rand — that's the rule, don't skip it. 💖
  • 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 recognized string representations. The fmt value should be one of "RGB", "RGBA", "HSV", or "HSVA". Returns an empty string on error. The glow-up pipeline for your color palette. 🌈

✨ BUILT‐IN VARIABLES ✨

okay bestie so gvpr comes with a whole lil squad of special variables that are basically the main characters 🫶 — it sets their values for you automatically depending on the context. And unless it says otherwise, you cannot change them. iykyk.

  • $ : obj_t — this is the current object, whether that's a node, an edge, or a graph, depending on the context. Heads up though: it is not available in BEGIN or END clauses. 🙈
  • $F : string — the name of the current input file, periodt.
  • $G : graph_t — the current graph being processed. Again, not available in BEGIN or END clauses. 💅
  • $NG : graph_t — the next graph to be processed. If $NG is NULL, then the current graph $G is the last graph. Lowkey important caveat: 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 — the output graph. Before graph traversal it gets 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. And yes — the output graph may be set by the user. 👑
  • $T : graph_t — the current target graph. It's a subgraph of $G, and it's available only in N, E and END_G clauses.
  • $tgtname : string — the name of the target graph. By default it's 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 — 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 — 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 — tells you 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 — the number of arguments specified by the -a args command-line argument.
  • ARGV : string array — the array of arguments specified by the -a args command-line argument. The *i*th argument is given by ARGV[i]. ✨

🌈 BUILT‐IN CONSTANTS 🌈

There are several symbolic constants defined by gvpr. The whole collection, no cap:

  • 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. 🧚

🎀 EXAMPLES 🎀

okay these are literally so good, watch this:

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. iconic transformation fr fr.

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. 🌸

🌿 ENVIRONMENT 🌿

  • GVPRPATH — a 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. 🪟

💀 BUGS AND WARNINGS 💀

ok so before you go absolutely feral with this language, bestie, read this part. it's giving caution tape for a reason. 🎀

🚨 the traversal one (this one is real)

If your script is out here deleting nodes while you're inside an N{} or E{} block — and you're using BFS or DFS traversals — be careful, okay? 😭 Those traversals rely on stacks and queues of nodes, so the vibes get messy if you're mutating the graph mid-walk. Deleting nodes during BFS/DFS traversal is literally the "not me accidentally destabilizing my own iterator" moment. Be careful. 🫶

🐚 the shell-quoting one

When the program is given as a command line argument, the usual shell interpretation takes place, and that can absolutely mess with some of the special names in gvpr. ✨

To avoid this, it is best to wrap the program in single quotes. no cap.

🪤 the backslash trap

If your string constants contain pattern metacharacters and you want to escape them so you don't trigger pattern matching — you will probably need two backslashes, because a single backslash gets lost when the string is originally scanned. 💀

Usually it's simpler to just use strcmp and avoid pattern matching altogether. iykyk.

🦋 the graph library glow-up (24 April 2008)

As of 24 April 2008, gvpr switched to using a new, underlying graph library. The new model is simpler: there is only one copy of a node, not one copy for each subgraph logically containing it. slay, honestly.

But — and this is the important part — it means 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. periodt.

🌸 the scope situation

There is a single global scope, except for formal function parameters — and even those 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. But for now?

It is advisable to use distinct names for all variables. 💅

🔥 the type-checking jumpscare

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. iconic behavior, just do it.

🧚 the (char*)0 thing

The expr library does not support string values of (char*)0. Which 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. So:

((int)"2")

evaluates to 1. 💀 yes really.

👑 the classic C lore

The language inherits the usual C problems, such as dangling references and the confusion between '=' and '=='. some things never change, bestie. 💜

👑 AUTHOR 👑

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

🌈 SEE ALSO 🌈

and that's the whole page, bestie!! 🎀 this was GVPR(1), source/version GVPR(1), dated 29 August 2013 — go forth and write the most unhinged graph-processing scripts of your life, you absolute main character. 🦋✨💖

📦 where this page comes from