static void pre(Agraph_t * g)
{
len_sym = agattr(g, AGEDGE, "len", NULL);
aginit(g, AGNODE, "dijkstra", sizeof(nodedata_t), 1);
#if 0
aginit(g, AGEDGE, "dijkstra", sizeof(edgedata_t), 1);
#endif
}
static void write_graph(Agraph_t * g, GVJ_t * job, int top, state_t* sp)
{
Agnode_t* np;
Agedge_t* ep;
int ncnt = 0;
int ecnt = 0;
int sgcnt = 0;
int has_subgs;
Dt_t* map;
if (top) {
map = dtopen (&intDisc, Dtoset);
aginit(g, AGNODE, ID, sizeof(gvid_t), FALSE);
aginit(g, AGEDGE, ID, sizeof(gvid_t), FALSE);
aginit(g, AGRAPH, ID, -((int)sizeof(gvid_t)), FALSE);
sgcnt = label_subgs(g, sgcnt, map);
for (np = agfstnode(g); np; np = agnxtnode(g,np)) {
if (IS_CLUSTER(np)) {
ND_gid(np) = lookup(map, agnameof(np));
}
else {
ND_gid(np) = sgcnt + ncnt++;
}
for (ep = agfstout(g, np); ep; ep = agnxtout(g,ep)) {
ED_gid(ep) = ecnt++;
}
}
dtclose(map);
}
indent(job, sp->Level++);
gvputs(job, "{\n");
write_hdr(g, job, top, sp);
write_attrs((Agobj_t*)g, job, sp);
if (top) {
gvputs(job, ",\n");
indent(job, sp->Level);
gvprintf(job, "\"_subgraph_cnt\": %d", sgcnt);
} else {
gvputs(job, ",\n");
indent(job, sp->Level);
gvprintf(job, "\"_gvid\": %d", GD_gid(g));
}
has_subgs = write_subgs(g, job, top, sp);
write_nodes (g, job, top, has_subgs, sp);
write_edges (g, job, top, sp);
gvputs(job, "\n");
sp->Level--;
indent(job, sp->Level);
if (top)
gvputs(job, "}\n");
else
gvputs(job, "}");
}
static int process(Agraph_t * g, int gcnt)
{
Agnode_t *n;
bcstate state;
Agraph_t *blk;
Agraph_t *tree;
int bcnt;
aginit(g, AGNODE, "info", sizeof(Agnodeinfo_t), TRUE);
aginit(g, AGEDGE, "info", sizeof(Agedgeinfo_t), TRUE);
aginit(g, AGRAPH, "info", sizeof(Agraphinfo_t), TRUE);
state.count = 0;
state.nComp = 0;
state.stk = 0;
state.blks = 0;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (N(n) == 0)
dfs(g, n, &state, 0);
}
for (blk = state.blks; blk; blk = NEXTBLK(blk)) {
nodeInduce(blk, g);
}
if (external) {
bcnt = 0;
for (blk = state.blks; blk; blk = NEXTBLK(blk)) {
gwrite(blk, gcnt, bcnt++);
}
} else
gwrite(g, gcnt, 0);
if (doTree) {
tree = agopen("blkcut_tree", Agstrictundirected, 0);
for (blk = state.blks; blk; blk = NEXTBLK(blk))
addCutPts(tree, blk);
gwrite(tree, gcnt, -1);
agclose(tree);
}
if (verbose) {
int cuts = 0;
bcnt = 0;
for (blk = state.blks; blk; blk = NEXTBLK(blk))
bcnt++;
for (n = agfstnode(g); n; n = agnxtnode(g, n))
if (Cut(n))
cuts++;
fprintf(stderr, "%s: %d blocks %d cutpoints\n", agnameof(g), bcnt,
cuts);
}
if (state.blks && NEXTBLK(state.blks))
return 1; /* >= 2 blocks */
else
return 0;
}
int main(int argc, char *argv[])
{
Agraph_t *g;
Agnode_t *n;
int rv = 0;
init(argc, argv);
if ((g = agread(inFile, (Agdisc_t *) 0)) != 0) {
if (agisdirected (g)) {
aginit(g, AGNODE, "info", sizeof(Agnodeinfo_t), TRUE);
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (ND_mark(n) == 0)
rv |= dfs(g, n, 0);
}
if (doWrite) {
agwrite(g, outFile);
fflush(outFile);
}
if (Verbose) {
if (rv)
fprintf(stderr, "Graph \"%s\" has cycles; %d reversed edges\n", graphName(g), num_rev);
else
fprintf(stderr, "Graph \"%s\" is acyclic\n", graphName(g));
}
} else {
rv = -1;
if (Verbose)
fprintf(stderr, "Graph \"%s\" is undirected\n", graphName(g));
}
exit(rv);
} else
exit(-1);
}
static void
init (int argc, char* argv[])
{
int c;
aginit();
while ((c = getopt(argc, argv, ":?necCaDUrsv")) != -1) {
switch (c) {
case 'e':
flags |= EDGES;
break;
case 'n':
flags |= NODES;
break;
case 'c':
flags |= CC;
break;
case 'C':
flags |= CL;
tot_cl = 0;
break;
case 'a':
flags = NODES | EDGES | CC | CL;
break;
case 'r':
recurse = 1;
break;
case 's':
silent = 1;
break;
case 'v':
verbose = 1;
break;
case 'D':
gtype = DIRECTED;
break;
case 'U':
gtype = UNDIRECTED;
break;
case '?':
if (optopt == '?') usage(0);
else fprintf(stderr,"gc: option -%c unrecognized - ignored\n", optopt);
break;
}
}
argv += optind;
argc -= optind;
if (argc) Files = argv;
if (flags == 0) flags = NODES | EDGES;
if (gtype == 0) gtype = DIRECTED | UNDIRECTED;
outfile = stdout;
}
/* init:
*/
static void init(int argc, char *argv[])
{
int c;
aginit();
while ((c = getopt(argc, argv, ":ngvum:o:G:?")) != -1) {
switch (c) {
case 'n':
packMode = l_node;
break;
case 'g':
packMode = l_graph;
break;
case 'm':
setInt(&margin, optarg);
break;
case 'o':
outfp = openFile(optarg, "w");
break;
case 'u':
packMode = l_undef;
break;
case 'G':
if (*optarg)
setNameValue(optarg);
else
fprintf(stderr,
"gvpack: option -G missing argument - ignored\n");
break;
case 'v':
verbose = 1;
Verbose = 1;
break;
case '?':
if (optopt == '?')
usage(0);
else
fprintf(stderr,
"gvpack: option -%c unrecognized - ignored\n", optopt);
break;
}
}
argv += optind;
argc -= optind;
if (argc) {
myFiles = argv;
nGraphs = argc; /* guess one graph per file */
} else
nGraphs = 10; /* initial guess as to no. of graphs */
if (!outfp)
outfp = stdout; /* stdout the default */
}
void dotneato_initialize(int argc, char** argv, char *str)
{
char *rest,c;
int i,nfiles;
aginit();
nfiles = 0;
for (i = 1; i < argc; i++)
if (argv[i][0] != '-') nfiles++;
Files = N_NEW(nfiles + 1, char *);
Files[nfiles++] = str;
nfiles = 0;
CmdName = argv[0];
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
rest = &(argv[i][2]);
switch (c = argv[i][1]) {
case 'G': global_def(rest,agraphattr); break;
case 'N': global_def(rest,agnodeattr); break;
case 'E': global_def(rest,agedgeattr); break;
case 'T': Output_lang = lang_select(rest); break;
case 'V':
fprintf(stderr,"%s version %s (%s)\n",
Info[0], Info[1], Info[2]);
exit (0);
break;
case 'l':
use_library(rest[0]?rest:(*argv[i+1]!='-'?argv[++i]:NULL));
break;
case 'n':
Nop = TRUE;
if (isdigit(*rest)) Nop = atoi (rest);
break;
case 'o':
Output_file = file_select(rest[0]?rest:argv[++i]);
break;
case 's':
PSinputscale = (rest[0]?atof(rest):POINTS_PER_INCH);
break;
case 'v': Verbose = TRUE; break;
case 'x': Reduce = TRUE; break;
default:
fprintf(stderr,"%s: option -%c unrecognized\n",CmdName,c);
}
}
else
Files[nfiles++] = argv[i];
}
if (Output_file == NULL) Output_file = stdout;
/* set persistent attributes here */
agnodeattr(NULL,"label",NODENAME_ESC);
}
GVC_t *gvContextPlugins(const lt_symlist_t *builtins, int demand_loading)
{
GVC_t *gvc;
#ifndef WITH_CGRAPH
aginit();
agnodeattr(NULL, "label", NODENAME_ESC);
#else
agattr(NULL, AGNODE, "label", NODENAME_ESC);
#endif
gvc = gvNEWcontext(builtins, demand_loading);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
static void
process(Agraph_t* G)
{
Agnode_t* n;
Agraph_t* map;
int nc = 0;
float nontree_frac;
int Maxdegree;
Stack stack;
sccstate state;
aginit(G,AGRAPH,"scc_graph",sizeof(Agraphinfo_t),TRUE);
aginit(G,AGNODE,"scc_node",sizeof(Agnodeinfo_t),TRUE);
state.Comp = state.ID = 0;
state.N_nodes_in_nontriv_SCC = 0;
if (Verbose)
nc = countComponents(G,&Maxdegree,&nontree_frac);
initStack(&stack, agnnodes(G) + 1);
map = agopen("scc_map",Agdirected,(Agdisc_t *)0);
for (n = agfstnode(G); n; n = agnxtnode(n))
if (getval(n) == 0) visit(n,map,&stack,&state);
freeStack(&stack);
if (!Silent) agwrite(map,stdout);
agclose(map);
if (Verbose)
fprintf(stderr,"%d %d %d %d %.4f %d %.4f\n",
agnnodes(G), agnedges(G), nc, state.Comp,
state.N_nodes_in_nontriv_SCC / (double) agnnodes(G), Maxdegree,
nontree_frac);
else
fprintf(stderr,"%d nodes, %d edges, %d strong components\n",
agnnodes(G), agnedges(G), state.Comp);
}
/*----------------------------------------------------------------------------
* initialize the internal graphviz structure.
*/
static void
cls_inherit_graph_init (AnjutaClassInheritance *plugin, gchar* graph_label)
{
Agsym_t *sym;
gchar dpi_text[16];
snprintf (dpi_text, 16, "%d", INCH_TO_PIXELS_CONVERSION_FACTOR);
aginit ();
plugin->graph = agopen (graph_label, AGDIGRAPH);
plugin->gvc = gvContext();
if (!(sym = agfindattr(plugin->graph->proto->n, "dpi")))
sym = agraphattr(plugin->graph, "dpi", dpi_text);
agxset(plugin->graph, sym->index, dpi_text);
}
GVC_t *gvContext(void)
{
GVC_t *gvc;
#ifndef WITH_CGRAPH
aginit();
agnodeattr(NULL, "label", NODENAME_ESC);
#else
agattr(NULL, AGNODE, "label", NODENAME_ESC);
#endif
/* default to no builtins, demand loading enabled */
gvc = gvNEWcontext(NULL, TRUE);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
int gvToolTred(Agraph_t * g)
{
Agnode_t *n;
int warn = 0;
if (agisdirected(g)) {
aginit(g, AGNODE, "info", sizeof(Agmarknodeinfo_t), TRUE);
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
warn = dfs(n, NULL, warn);
}
agclean(g, AGNODE, "info");
} else {
fprintf(stderr, "warning: %s is not a directed graph, not attempting tred\n",
agnameof(g));
}
return 0; // FIXME - return proper errors
}
int main(int argc, char **argv)
{
Agraph_t *g;
ingraph_state ig;
init(argc, argv);
newIngraph(&ig, Files, agread);
aginit();
while ((g = nextGraph(&ig)) != 0) {
color(g);
agwrite(g, stdout);
fflush(stdout);
agclose(g);
}
exit(0);
}
int main(int argc, char **argv)
{
Agraph_t *g;
Agnode_t *n, *m;
Agedge_t *e;
Agsym_t *a;
#ifdef NO_LAYOUT_OR_RENDERING
aginit();
#else
/* set up a graphviz context - but only once even for multiple graphs */
static GVC_t *gvc;
if (!gvc)
gvc = gvContext();
#endif
/* Create a simple digraph */
g = agopen("g", AGDIGRAPH);
n = agnode(g, "n");
m = agnode(g, "m");
e = agedge(g, n, m);
/* Set an attribute - in this case one that affects the visible rendering */
agsafeset(n, "color", "red", "");
#ifdef NO_LAYOUT_OR_RENDERING
/* Just write the graph without layout */
agwrite(g, stdout);
#else
/* Use the directed graph layout engine */
gvLayout(gvc, g, "dot");
/* Output in .dot format */
gvRender(gvc, g, "dot", stdout);
gvFreeLayout(gvc, g);
#endif
agclose(g);
return 0;
}
static void init(int argc, char *argv[])
{
int c;
cmd = argv[0];
aginit();
while ((c = getopt(argc, argv, ":vno:")) != -1)
switch (c) {
case 'o':
outFile = openFile(optarg, "w");
break;
case 'n':
doWrite = 0;
break;
case 'v':
Verbose = 1;
break;
case '?':
if (optopt == '?')
usage(0);
else {
fprintf(stderr, "%s: option -%c unrecognized\n", cmd,
optopt);
usage(-1);
}
break;
case ':':
fprintf(stderr, "%s: missing argument for option -%c\n",
cmd, optopt);
usage(-1);
break;
}
if (optind < argc) {
inFile = openFile(argv[optind], "r");
} else
inFile = stdin;
if (!outFile)
outFile = stdout;
}
static void init(int argc, char *argv[])
{
int c;
aginit();
while ((c = getopt(argc, argv, ":escvm:?")) != -1) {
switch (c) {
case 'e':
doEdges = 0;
break;
case 'c':
doComps = 1;
break;
case 'm':
margin = atoi(optarg);
break;
case 's':
single = 1;
break;
case 'v':
verbose = 1;
Verbose = 1;
break;
case '?':
if (optopt == '?')
usage(0);
else
fprintf(stderr,
"ptest: option -%c unrecognized - ignored\n", c);
break;
}
}
argv += optind;
argc -= optind;
if (argc) {
Files = argv;
nFiles = argc;
}
}
void aginit_wrapper() {
aginit();
}
int main(int argc, char **argv)
{
int c;
char *progname;
ingraph_state ig;
Agraph_t *graph;
Agnode_t *node;
Agedge_t *edge;
Agedge_t *nexte;
Agsym_t *attr;
char **files;
generic_list_t *attr_list;
generic_list_t *node_list;
unsigned long i, j;
opterr = 0;
progname = strrchr(argv[0], '/');
if (progname == NULL) {
progname = argv[0];
} else {
progname++; /* character after last '/' */
}
attr_list = new_generic_list(16);
node_list = new_generic_list(16);
while ((c = getopt(argc, argv, "hvn:N:")) != -1) {
switch (c) {
case 'N':
{
attr_list = addattr(attr_list, optarg);
break;
}
case 'n':
{
node_list = addnode(node_list, optarg);
break;
}
case 'h':
{
help_message(progname);
exit(EXIT_SUCCESS);
break;
}
case 'v':
{
verbose = 1;
break;
}
case '?':
if (isprint(optopt)) {
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
} else {
fprintf(stderr, "Unknown option character `\\x%X'.\n",
optopt);
}
exit(EXIT_FAILURE);
break;
default:
help_message(progname);
exit(EXIT_FAILURE);
break;
}
}
/* Any arguments left? */
if (optind < argc) {
files = &argv[optind];
} else {
files = NULL;
}
newIngraph(&ig, files, gread);
while ((graph = nextGraph(&ig)) != NULL) {
if (agisdirected(graph) == 0) {
fprintf(stderr,
"*** Error: Graph is undirected! Pruning works only with directed graphs!\n");
exit(EXIT_FAILURE);
}
/* attach node data for marking to all nodes */
aginit(graph, AGNODE, NDNAME, sizeof(ndata), 1);
/* prune all nodes specified on the commandline */
for (i = 0; i < node_list->used; i++) {
if (verbose == 1)
fprintf(stderr, "Pruning node %s\n",
(char *) node_list->data[i]);
/* check whether a node of that name exists at all */
node = agnode(graph, (char *) node_list->data[i], 0);
if (node == NULL) {
fprintf(stderr,
"*** Warning: No such node: %s -- gracefully skipping this one\n",
(char *) node_list->data[i]);
} else {
MARK(node); /* Avoid cycles */
/* Iterate over all outgoing edges */
for (edge = agfstout(node); edge; edge = nexte) {
nexte = agnxtout(edge);
if (aghead(edge) != node) { /* non-loop edges */
if (verbose == 1)
fprintf(stderr, "Processing descendant: %s\n",
agnameof(aghead(edge)));
remove_child(graph, aghead(edge));
agdelete(graph, edge);
}
}
UNMARK(node); /* Unmark so that it can be removed in later passes */
/* Change attribute (e.g. border style) to show that node has been pruneed */
for (j = 0; j < attr_list->used; j++) {
/* create attribute if it doesn't exist and set it */
attr =
agattr(graph, AGNODE,
((strattr_t *) attr_list->data[j])->n, "");
if (attr == NULL) {
fprintf(stderr, "Couldn't create attribute: %s\n",
((strattr_t *) attr_list->data[j])->n);
exit(EXIT_FAILURE);
}
agxset(node, attr,
((strattr_t *) attr_list->data[j])->v);
}
}
}
agwrite(graph, stdout);
agclose(graph);
}
free(attr_list);
free(node_list);
exit(EXIT_SUCCESS);
}
void dotneato_initialize(GVC_t *gvc, int argc, char** argv)
{
char *rest,c, *val;
int i,v,nfiles;
/* establish if we are running in a CGI environment */
HTTPServerEnVar=getenv("SERVER_NAME");
/* establish Gvfilepath, if any */
Gvfilepath = getenv("GV_FILE_PATH");
aginit();
nfiles = 0;
for (i = 1; i < argc; i++)
if (argv[i][0] != '-') nfiles++;
Files = N_NEW(nfiles + 1, char *);
nfiles = 0;
if (!CmdName) setCmdName (argv[0]);
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
rest = &(argv[i][2]);
switch (c = argv[i][1]) {
case 'G':
if (*rest) global_def(rest,agraphattr);
else {
fprintf(stderr,"Missing argument for -G flag\n");
dotneato_usage (1);
}
break;
case 'N':
if (*rest) global_def(rest,agnodeattr);
else {
fprintf(stderr,"Missing argument for -N flag\n");
dotneato_usage (1);
}
break;
case 'E':
if (*rest) global_def(rest,agedgeattr);
else {
fprintf(stderr,"Missing argument for -E flag\n");
dotneato_usage (1);
}
break;
case 'T':
val = getFlagOpt (argc, argv, &i);
if (!val) {
fprintf(stderr,"Missing argument for -T flag\n");
dotneato_usage (1);
}
gvrender_output_langname_job(gvc, val);
break;
case 'V':
fprintf(stderr,"%s version %s (%s)\n",
gvc->info[0], gvc->info[1], gvc->info[2]);
exit (0);
break;
case 'l':
val = getFlagOpt (argc, argv, &i);
if (!val) {
fprintf(stderr,"Missing argument for -l flag\n");
dotneato_usage (1);
}
use_library(val);
break;
case 'o':
val = getFlagOpt (argc, argv, &i);
gvrender_output_filename_job(gvc, val);
break;
case 'q':
if (*rest) {
v = atoi(rest);
if (v <= 0) {
fprintf (stderr, "Invalid parameter \"%s\" for -q flag - ignored\n", rest);
}
else if (v == 1) agseterr (AGERR);
else agseterr (AGMAX);
}
else agseterr (AGERR);
break;
case 's':
if (*rest) {
PSinputscale = atof(rest);
if (PSinputscale <= 0) {
fprintf (stderr, "Invalid parameter \"%s\" for -s flag\n", rest);
dotneato_usage (1);
}
}
else PSinputscale = POINTS_PER_INCH;
break;
case 'v':
Verbose = TRUE;
if (isdigit(*rest)) Verbose = atoi (rest);
break;
case 'y': y_invert = TRUE; break;
case '?': dotneato_usage (0); break;
default:
fprintf(stderr, "%s: option -%c unrecognized\n\n",
CmdName,c);
dotneato_usage (1);
}
}
else
Files[nfiles++] = argv[i];
}
/* if no -Txxx, then set default format */
if (!gvc->jobs || !gvc->jobs->output_langname) {
gvrender_output_langname_job(gvc, "dot");
}
/* need to set Output_lang now based on the first -Txxx,
* so that CodeGen->textsize picks up an appropriate routine
* otherwise node sizing can be wrong for any or all of the products.
*/
/* FIXME */
Output_lang = lang_select(gvc, gvc->jobs->output_langname, 0);
/* set persistent attributes here (if not already set from command line options) */
if (! (agfindattr(agprotograph()->proto->n, "label")))
agnodeattr(NULL,"label",NODENAME_ESC);
}
static int visit(Agnode_t * n, Agraph_t * map, Stack * sp, sccstate * st)
{
unsigned int m, min;
Agnode_t *t;
Agraph_t *subg;
Agedge_t *e;
min = ++(st->ID);
setval(n, min);
push(sp, n);
#ifdef USE_CGRAPH
for (e = agfstout(n->root, n); e; e = agnxtout(n->root, e)) {
#else
for (e = agfstout(n); e; e = agnxtout(e)) {
#endif
t = aghead(e);
if (getval(t) == 0)
m = visit(t, map, sp, st);
else
m = getval(t);
if (m < min)
min = m;
}
if (getval(n) == min) {
if (!wantDegenerateComp && (top(sp) == n)) {
setval(n, INF);
pop(sp);
} else {
char name[32];
Agraph_t *G = agraphof(n);;
sprintf(name, "cluster_%d", (st->Comp)++);
subg = agsubg(G, name, TRUE);
agbindrec(subg, "scc_graph", sizeof(Agraphinfo_t), TRUE);
setrep(subg, agnode(map, name, TRUE));
do {
t = pop(sp);
agsubnode(subg, t, TRUE);
setval(t, INF);
setscc(t, subg);
st->N_nodes_in_nontriv_SCC++;
} while (t != n);
#ifdef USE_CGRAPH
nodeInduce(subg, map);
#else
nodeInduce(subg);
#endif
if (!Silent)
agwrite(subg, stdout);
}
}
return min;
}
static int label(Agnode_t * n, int nodecnt, int *edgecnt)
{
Agedge_t *e;
setval(n, 1);
nodecnt++;
#ifdef USE_CGRAPH
for (e = agfstedge(n->root, n); e; e = agnxtedge(n->root, e, n)) {
#else
for (e = agfstedge(n); e; e = agnxtedge(e, n)) {
#endif
(*edgecnt) += 1;
if (e->node == n)
e = agopp(e);
if (!getval(e->node))
nodecnt = label(e->node, nodecnt, edgecnt);
}
return nodecnt;
}
static int
countComponents(Agraph_t * g, int *max_degree, float *nontree_frac)
{
int nc = 0;
int sum_edges = 0;
int sum_nontree = 0;
int deg;
int n_edges;
int n_nodes;
Agnode_t *n;
#ifdef USE_CGRAPH
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
#else
for (n = agfstnode(g); n; n = agnxtnode(n)) {
#endif
if (!getval(n)) {
nc++;
n_edges = 0;
n_nodes = label(n, 0, &n_edges);
sum_edges += n_edges;
sum_nontree += (n_edges - n_nodes + 1);
}
}
if (max_degree) {
int maxd = 0;
#ifdef USE_CGRAPH
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
deg = agdegree(g, n, TRUE, TRUE);
#else
for (n = agfstnode(g); n; n = agnxtnode(n)) {
deg = agdegree(n, TRUE, TRUE);
#endif
if (maxd < deg)
maxd = deg;
setval(n, 0);
}
*max_degree = maxd;
}
if (nontree_frac) {
if (sum_edges > 0)
*nontree_frac = (float) sum_nontree / (float) sum_edges;
else
*nontree_frac = 0.0;
}
return nc;
}
static void process(Agraph_t * G)
{
Agnode_t *n;
Agraph_t *map;
int nc = 0;
float nontree_frac = 0;
int Maxdegree = 0;
Stack stack;
sccstate state;
aginit(G, AGRAPH, "scc_graph", sizeof(Agraphinfo_t), TRUE);
aginit(G, AGNODE, "scc_node", sizeof(Agnodeinfo_t), TRUE);
state.Comp = state.ID = 0;
state.N_nodes_in_nontriv_SCC = 0;
if (Verbose)
nc = countComponents(G, &Maxdegree, &nontree_frac);
initStack(&stack, agnnodes(G) + 1);
map = agopen("scc_map", Agdirected, (Agdisc_t *) 0);
#ifdef USE_CGRAPH
for (n = agfstnode(G); n; n = agnxtnode(G, n))
#else
for (n = agfstnode(G); n; n = agnxtnode(n))
#endif
if (getval(n) == 0)
visit(n, map, &stack, &state);
freeStack(&stack);
if (!Silent)
agwrite(map, stdout);
agclose(map);
if (Verbose)
fprintf(stderr, "%d %d %d %d %.4f %d %.4f\n",
agnnodes(G), agnedges(G), nc, state.Comp,
state.N_nodes_in_nontriv_SCC / (double) agnnodes(G),
Maxdegree, nontree_frac);
else
fprintf(stderr, "%d nodes, %d edges, %d strong components\n",
agnnodes(G), agnedges(G), state.Comp);
}
static char *useString = "Usage: %s [-sdv?] <files>\n\
-s - silent\n\
-d - allow degenerate components\n\
-v - verbose\n\
-? - print usage\n\
If no files are specified, stdin is used\n";
static void usage(int v)
{
printf(useString, CmdName);
exit(v);
}
/**
* \brief Initialization
*
*/
void graph__init(void)
{
aginit();
}
void dotneato_args_initialize(GVC_t * gvc, int argc, char **argv)
{
char c, *rest, *layout;
const char *val;
int i, v, nfiles;
unsigned char buf[SMALLBUF];
agxbuf xb;
int Kflag = 0;
/* establish if we are running in a CGI environment */
HTTPServerEnVar = getenv("SERVER_NAME");
/* establish Gvfilepath, if any */
Gvfilepath = getenv("GV_FILE_PATH");
gvc->common.cmdname = dotneato_basename(argv[0]);
if (gvc->common.verbose) {
fprintf(stderr, "%s - %s version %s (%s)\n",
gvc->common.cmdname, gvc->common.info[0],
gvc->common.info[1], gvc->common.info[2]);
}
/* configure for available plugins */
/* needs to know if "dot -c" is set (gvc->common.config) */
/* must happen before trying to select any plugins */
gvconfig(gvc, gvc->common.config);
if (gvc->common.config)
exit (0);
/* feed the globals */
Verbose = gvc->common.verbose;
CmdName = gvc->common.cmdname;
#ifndef WITH_CGRAPH
aginit();
#endif
nfiles = 0;
for (i = 1; i < argc; i++)
if (argv[i] && argv[i][0] != '-')
nfiles++;
gvc->input_filenames = N_NEW(nfiles + 1, char *);
nfiles = 0;
agxbinit(&xb, SMALLBUF, buf);
for (i = 1; i < argc; i++) {
if (argv[i] && argv[i][0] == '-') {
rest = &(argv[i][2]);
switch (c = argv[i][1]) {
case 'G':
if (*rest)
#ifdef WITH_CGRAPH
global_def(&xb, rest, AGRAPH, agattr);
#else
global_def(&xb, rest, agraphattr);
#endif
else {
fprintf(stderr, "Missing argument for -G flag\n");
dotneato_usage(1);
}
break;
case 'N':
if (*rest)
#ifdef WITH_CGRAPH
global_def(&xb, rest, AGNODE,agattr);
#else
global_def(&xb, rest, agnodeattr);
#endif
else {
fprintf(stderr, "Missing argument for -N flag\n");
dotneato_usage(1);
}
break;
case 'E':
if (*rest)
#ifdef WITH_CGRAPH
global_def(&xb, rest, AGEDGE,agattr);
#else
global_def(&xb, rest, agedgeattr);
#endif
else {
static void color(Agraph_t * g)
{
int nn, i, j, cnt;
Agnode_t *n, *v, **nlist;
Agedge_t *e;
char *p;
double x, y, maxrank = 0.0;
double sum[NC], d, lowsat, highsat;
if (agattr(g, AGNODE, "pos", 0) == NULL) {
fprintf(stderr,
"graph must be run through 'dot' before 'gvcolor'\n");
exit(1);
}
aginit(g, AGNODE, "nodeinfo", sizeof(Agnodeinfo_t), TRUE);
if (agattr(g, AGNODE, "style", 0) == NULL)
agattr(g, AGNODE, "style", "filled");
if ((p = agget(g, "Defcolor")))
setcolor(p, Defcolor);
if ((p = agget(g, "rankdir")) && (p[0] == 'L'))
LR = 1;
if ((p = agget(g, "flow")) && (p[0] == 'b'))
Forward = 0;
if ((p = agget(g, "saturation"))) {
if (sscanf(p, "%lf,%lf", &lowsat, &highsat) == 2) {
MinRankSaturation = lowsat;
MaxRankSaturation = highsat;
AdjustSaturation = 1;
}
}
/* assemble the sorted list of nodes and store the initial colors */
nn = agnnodes(g);
nlist = (Agnode_t **) malloc(nn * sizeof(Agnode_t *));
i = 0;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
nlist[i++] = n;
if ((p = agget(n, "color")))
setcolor(p, ND_x(n));
p = agget(n, "pos");
sscanf(p, "%lf,%lf", &x, &y);
ND_relrank(n) = (LR ? x : y);
if (maxrank < ND_relrank(n))
maxrank = ND_relrank(n);
}
if (LR != Forward)
for (i = 0; i < nn; i++) {
n = nlist[i];
ND_relrank(n) = maxrank - ND_relrank(n);
}
qsort((void *) nlist, (size_t) nn, sizeof(Agnode_t *),
(int (*)(const void *, const void *)) cmpf);
/* this is the pass that pushes the colors through the edges */
for (i = 0; i < nn; i++) {
n = nlist[i];
/* skip nodes that were manually colored */
cnt = 0;
for (j = 0; j < NC; j++)
if (ND_x(n)[j] != 0.0)
cnt++;
if (cnt > 0)
continue;
for (j = 0; j < NC; j++)
sum[j] = 0.0;
cnt = 0;
for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
v = aghead(e);
if (v == n)
v = agtail(e);
d = ND_relrank(v) - ND_relrank(n) - 0.01;
if (d < 0) {
double t = 0.0;
for (j = 0; j < NC; j++) {
t += ND_x(v)[j];
sum[j] += ND_x(v)[j];
}
if (t > 0.0)
cnt++;
}
}
if (cnt)
for (j = 0; j < NC; j++)
ND_x(n)[j] = sum[j] / cnt;
}
/* apply saturation adjustment and convert color to string */
for (i = 0; i < nn; i++) {
double h, s, b, t;
char buf[64];
n = nlist[i];
t = 0.0;
for (j = 0; j < NC; j++)
t += ND_x(n)[j];
if (t > 0.0) {
h = ND_x(n)[0];
if (AdjustSaturation) {
s = ND_relrank(n) / maxrank;
if (!Forward)
s = 1.0 - s;
s = MinRankSaturation
+ s * (MaxRankSaturation - MinRankSaturation);
} else
s = 1.0;
s = s * ND_x(n)[1];
b = ND_x(n)[2];
} else {
h = Defcolor[0];
s = Defcolor[1];
b = Defcolor[2];
}
sprintf(buf, "%f %f %f", h, s, b);
agset(n, "color", buf);
}
}
void dotneato_args_initialize(GVC_t * gvc, int argc, char **argv)
{
char *rest, c, *val;
int i, v, nfiles;
/* establish if we are running in a CGI environment */
HTTPServerEnVar = getenv("SERVER_NAME");
/* establish Gvfilepath, if any */
Gvfilepath = getenv("GV_FILE_PATH");
/* configure for available plugins and codegens */
gvconfig(gvc, gvc->common.config);
if (gvc->common.config)
exit (0);
gvc->common.cmdname = dotneato_basename(argv[0]);
i = gvlayout_select(gvc, gvc->common.cmdname);
if (i == NO_SUPPORT)
gvlayout_select(gvc, "dot");
/* feed the globals */
Verbose = gvc->common.verbose;
CmdName = gvc->common.cmdname;
aginit();
nfiles = 0;
for (i = 1; i < argc; i++)
if (argv[i] && argv[i][0] != '-')
nfiles++;
gvc->input_filenames = N_NEW(nfiles + 1, char *);
nfiles = 0;
for (i = 1; i < argc; i++) {
if (argv[i] && argv[i][0] == '-') {
rest = &(argv[i][2]);
switch (c = argv[i][1]) {
case 'G':
if (*rest)
global_def(rest, agraphattr);
else {
fprintf(stderr, "Missing argument for -G flag\n");
dotneato_usage(1);
}
break;
case 'N':
if (*rest)
global_def(rest, agnodeattr);
else {
fprintf(stderr, "Missing argument for -N flag\n");
dotneato_usage(1);
}
break;
case 'E':
if (*rest)
global_def(rest, agedgeattr);
else {
fprintf(stderr, "Missing argument for -E flag\n");
dotneato_usage(1);
}
break;
case 'T':
val = getFlagOpt(argc, argv, &i);
if (!val) {
fprintf(stderr, "Missing argument for -T flag\n");
dotneato_usage(1);
exit(1);
}
v = gvjobs_output_langname(gvc, val);
if (!v) {
fprintf(stderr, "Format: \"%s\" not recognized. Use one of:%s\n",
val, gvplugin_list(gvc, API_device, val));
exit(1);
}
break;
case 'K':
val = getFlagOpt(argc, argv, &i);
if (!val) {
fprintf(stderr, "Missing argument for -K flag\n");
dotneato_usage(1);
exit(1);
}
v = gvlayout_select(gvc, val);
if (v == NO_SUPPORT) {
fprintf(stderr, "Layout type: \"%s\" not recognized. Use one of:%s\n",
val, gvplugin_list(gvc, API_layout, val));
exit(1);
}
break;
case 'V':
fprintf(stderr, "%s - %s version %s (%s)\n",
gvc->common.cmdname, gvc->common.info[0],
gvc->common.info[1], gvc->common.info[2]);
exit(0);
break;
case 'l':
val = getFlagOpt(argc, argv, &i);
if (!val) {
fprintf(stderr, "Missing argument for -l flag\n");
dotneato_usage(1);
}
use_library(gvc, val);
break;
case 'o':
val = getFlagOpt(argc, argv, &i);
if (! gvc->common.auto_outfile_names)
gvjobs_output_filename(gvc, val);
break;
case 'q':
if (*rest) {
v = atoi(rest);
if (v <= 0) {
fprintf(stderr,
"Invalid parameter \"%s\" for -q flag - ignored\n",
rest);
} else if (v == 1)
agseterr(AGERR);
else
agseterr(AGMAX);
} else
agseterr(AGERR);
break;
case 's':
if (*rest) {
PSinputscale = atof(rest);
if (PSinputscale <= 0) {
fprintf(stderr,
"Invalid parameter \"%s\" for -s flag\n",
rest);
dotneato_usage(1);
}
} else
PSinputscale = POINTS_PER_INCH;
break;
case 'x':
Reduce = TRUE;
break;
case 'y':
Y_invert = TRUE;
break;
case '?':
dotneato_usage(0);
break;
default:
fprintf(stderr, "%s: option -%c unrecognized\n\n", gvc->common.cmdname,
c);
dotneato_usage(1);
}
} else if (argv[i])
gvc->input_filenames[nfiles++] = argv[i];
}
/* if no -Txxx, then set default format */
if (!gvc->jobs || !gvc->jobs->output_langname) {
v = gvjobs_output_langname(gvc, "dot");
assert(v); /* "dot" should always be available as an output format */
}
/* set persistent attributes here (if not already set from command line options) */
if (!(agfindattr(agprotograph()->proto->n, "label")))
agnodeattr(NULL, "label", NODENAME_ESC);
}
