el = ND_out(n);
for (i = 0; i < el.size; i++) {
e = el.list[i];
- fprintf (stderr, "%s(%x) -> %s(%x) : %d\n", e->tail->name,e->tail, e->head->name, e->head,
+ fprintf (stderr, "%s(%x) -> %s(%x) : %d\n", agtail(e)->name,agtail(e), aghead(e)->name, aghead(e),
ED_minlen(e));
}
n = ND_next(n);
tp = rp->v[i];
if (ND_save_out(tp).list) {
for (j = 0; (e = ND_save_out(tp).list[j]); j++) {
- if ((ND_rank(e->head) > r) || (ND_rank(e->tail) > r)) {
+ if ((ND_rank(aghead(e)) > r) || (ND_rank(agtail(e)) > r)) {
found = TRUE;
break;
}
}
if (ND_save_in(tp).list) {
for (j = 0; (e = ND_save_in(tp).list[j]); j++) {
- if ((ND_rank(e->tail) > r) || (ND_rank(e->head) > r)) {
+ if ((ND_rank(agtail(e)) > r) || (ND_rank(aghead(e)) > r)) {
found = TRUE;
break;
}
if (u == v)
return TRUE;
for (i = 0; (e = ND_out(u).list[i]); i++) {
- if (go(e->head, v))
+ if (go(aghead(e), v))
return TRUE;
}
return FALSE;
edge_t *e;
e = NEW(edge_t);
- e->tail = u;
- e->head = v;
+ agtail(e) = u;
+ aghead(e) = v;
if (len > USHRT_MAX)
largeMinlen (len);
ED_minlen(e) = ROUND(len);
*/
sw = 0;
for (k = 0; (e = ND_other(u).list[k]); k++) {
- if (e->tail == e->head) {
+ if (agtail(e) == aghead(e)) {
sw += selfRightSpace (e);
}
}
if ((e = (edge_t*)ND_alg(u))) {
e0 = ND_save_out(u).list[0];
e1 = ND_save_out(u).list[1];
- if (ND_order(e0->head) > ND_order(e1->head)) {
+ if (ND_order(aghead(e0)) > ND_order(aghead(e1))) {
ff = e0;
e0 = e1;
e1 = ff;
}
m0 = (ED_minlen(e) * GD_nodesep(g)) / 2;
- m1 = m0 + ND_rw(e0->head) + ND_lw(e0->tail);
+ m1 = m0 + ND_rw(aghead(e0)) + ND_lw(agtail(e0));
/* these guards are needed because the flat edges
* work very poorly with cluster layout */
- if (canreach(e0->tail, e0->head) == FALSE)
- make_aux_edge(e0->head, e0->tail, m1,
+ if (canreach(agtail(e0), aghead(e0)) == FALSE)
+ make_aux_edge(aghead(e0), agtail(e0), m1,
ED_weight(e));
- m1 = m0 + ND_rw(e1->tail) + ND_lw(e1->head);
- if (canreach(e1->head, e1->tail) == FALSE)
- make_aux_edge(e1->tail, e1->head, m1,
+ m1 = m0 + ND_rw(agtail(e1)) + ND_lw(aghead(e1));
+ if (canreach(aghead(e1), agtail(e1)) == FALSE)
+ make_aux_edge(agtail(e1), aghead(e1), m1,
ED_weight(e));
}
/* position flat edge endpoints */
for (k = 0; k < ND_flat_out(u).size; k++) {
e = ND_flat_out(u).list[k];
- if (ND_order(e->tail) < ND_order(e->head)) {
- t0 = e->tail;
- h0 = e->head;
+ if (ND_order(agtail(e)) < ND_order(aghead(e))) {
+ t0 = agtail(e);
+ h0 = aghead(e);
} else {
- t0 = e->head;
- h0 = e->tail;
+ t0 = aghead(e);
+ h0 = agtail(e);
}
width = ND_rw(t0) + ND_lw(h0);
m0 = width / 2 - 1;
}
#endif
- make_aux_edge(sn, e->tail, m0 + 1, ED_weight(e));
- make_aux_edge(sn, e->head, m1 + 1, ED_weight(e));
+ make_aux_edge(sn, agtail(e), m0 + 1, ED_weight(e));
+ make_aux_edge(sn, aghead(e), m1 + 1, ED_weight(e));
ND_rank(sn) =
- MIN(ND_rank(e->tail) - m0 - 1,
- ND_rank(e->head) - m1 - 1);
+ MIN(ND_rank(agtail(e)) - m0 - 1,
+ ND_rank(aghead(e)) - m1 - 1);
}
}
}
int c;
edge_t *e;
- if (g != g->root) {
+ if (g != agroot(g)) {
contain_nodes(g);
if ((e = find_fast_edge(GD_ln(g),GD_rn(g)))) /* maybe from lrvn()?*/
ED_weight(e) += 128;
if (ND_node_type(v) != VIRTUAL)
return FALSE;
for (e = ND_save_out(v).list[0]; ED_to_orig(e); e = ED_to_orig(e));
- if (agcontains(g, e->tail))
+ if (agcontains(g, agtail(e)))
return FALSE;
- if (agcontains(g, e->head))
+ if (agcontains(g, aghead(e)))
return FALSE;
return TRUE;
}
if (v == NULL)
continue;
for (i = ND_order(v) - 1; i >= 0; i--) {
- u = GD_rank(g->root)[r].v[i];
+ u = GD_rank(agroot(g))[r].v[i];
/* can't use "is_a_vnode_of" because elists are swapped */
if ((ND_node_type(u) == NORMAL) || vnode_not_related_to(g, u)) {
make_aux_edge(u, GD_ln(g), CL_OFFSET + ND_rw(u), 0);
break;
}
}
- for (i = ND_order(v) + GD_rank(g)[r].n; i < GD_rank(g->root)[r].n;
+ for (i = ND_order(v) + GD_rank(g)[r].n; i < GD_rank(agroot(g))[r].n;
i++) {
- u = ND_rank(g->root)[r].v[i];
+ u = GD_rank(agroot(g))[r].v[i];
if ((ND_node_type(u) == NORMAL) || vnode_not_related_to(g, u)) {
make_aux_edge(GD_rn(g), u, CL_OFFSET + ND_lw(u), 0);
break;
} else
nprev = n;
}
- GD_nlist(g)->u.prev = NULL;
+ ND_prev(GD_nlist(g)) = NULL;
}
/* set_xcoords:
static void adjustEqual(graph_t * g, int delta)
{
int r, avail, half, deltop, delbottom;
- graph_t *root = g->root;
+ graph_t *root = agroot(g);
rank_t *rank = GD_rank(root);
int maxr = GD_maxrank(g);
int minr = GD_minrank(g);
int y = yoff;
for (r = GD_maxrank(root) - 1; r >= GD_minrank(root); r--) {
if (rank[r].n > 0)
- rank[r].v[0]->u.coord.y += y;
+ ND_coord(rank[r].v[0]).y += y;
y += yoff;
}
GD_ht2(g) += yoff;
static void adjustSimple(graph_t * g, int delta)
{
int r, bottom, deltop, delbottom;
- graph_t *root = g->root;
+ graph_t *root = agroot(g);
rank_t *rank = GD_rank(root);
int maxr = GD_maxrank(g);
int minr = GD_minrank(g);
if (delbottom > 0) {
for (r = maxr; r >= minr; r--) {
if (rank[r].n > 0)
- rank[r].v[0]->u.coord.y += delbottom;
+ ND_coord(rank[r].v[0]).y += delbottom;
}
deltop = GD_ht2(g) + (delta-bottom) + delbottom - rank[minr].ht2;
}
if (deltop > 0) {
for (r = minr-1; r >= GD_minrank(root); r--) {
if (rank[r].n > 0)
- rank[r].v[0]->u.coord.y += deltop;
+ ND_coord(rank[r].v[0]).y += deltop;
}
}
GD_ht2(g) += (delta - bottom);
int rht; /* height between top and bottom ranks */
int delta, maxr, minr;
int c, ht1, ht2;
- rank_t *rank = GD_rank(g->root);
+ rank_t *rank = GD_rank(agroot(g));
ht1 = GD_ht1(g);
ht2 = GD_ht2(g);
GD_ht1(g) = ht1;
GD_ht2(g) = ht2;
- if ((g != g->root) && GD_label(g)) {
+ if ((g != agroot(g)) && GD_label(g)) {
lht = MAX(GD_border(g)[LEFT_IX].y, GD_border(g)[RIGHT_IX].y);
maxr = GD_maxrank(g);
minr = GD_minrank(g);
}
/* update the global ranks */
- if (g != g->root) {
+ if (g != agroot(g)) {
rank[GD_minrank(g)].ht2 = MAX(rank[GD_minrank(g)].ht2, GD_ht2(g));
rank[GD_maxrank(g)].ht1 = MAX(rank[GD_maxrank(g)].ht1, GD_ht1(g));
}
{
int c, ht1, ht2;
graph_t *subg;
- rank_t *rank = GD_rank(g->root);
+ rank_t *rank = GD_rank(agroot(g));
int haveClustLabel = 0;
ht1 = GD_ht1(g);
/* account for a possible cluster label in clusters */
/* room for root graph label is handled in dotneato_postprocess */
- if ((g != g->root) && GD_label(g)) {
+ if ((g != agroot(g)) && GD_label(g)) {
haveClustLabel = 1;
- if (!GD_flip(g->root)) {
+ if (!GD_flip(agroot(g))) {
ht1 += GD_border(g)[BOTTOM_IX].y;
ht2 += GD_border(g)[TOP_IX].y;
}
GD_ht2(g) = ht2;
/* update the global ranks */
- if (g != g->root) {
+ if (g != agroot(g)) {
rank[GD_minrank(g)].ht2 = MAX(rank[GD_minrank(g)].ht2, ht2);
rank[GD_maxrank(g)].ht1 = MAX(rank[GD_maxrank(g)].ht1, ht1);
}
/* have to look for high self-edge labels, too */
if (ND_other(n).list)
for (j = 0; (e = ND_other(n).list[j]); j++) {
- if (e->tail == e->head) {
+ if (agtail(e) == aghead(e)) {
if (ED_label(e))
ht2 = MAX(ht2, ED_label(e)->dimen.y / 2);
}
/* make the initial assignment of ycoords to leftmost nodes by ranks */
maxht = 0;
r = GD_maxrank(g);
- rank[r].v[0]->u.coord.y = rank[r].ht1;
+ (ND_coord(rank[r].v[0])).y = rank[r].ht1;
while (--r >= GD_minrank(g)) {
d0 = rank[r + 1].pht2 + rank[r].pht1 + GD_ranksep(g); /* prim node sep */
d1 = rank[r + 1].ht2 + rank[r].ht1 + CL_OFFSET; /* cluster sep */
delta = MAX(d0, d1);
if (rank[r].n > 0) /* this may reflect some problem */
- rank[r].v[0]->u.coord.y = rank[r + 1].v[0]->u.coord.y + delta;
+ (ND_coord(rank[r].v[0])).y = (ND_coord(rank[r + 1].v[0])).y + delta;
#ifdef DEBUG
else
fprintf(stderr, "dot set_ycoords: rank %d is empty\n",
if (GD_exact_ranksep(g)) {
for (r = GD_maxrank(g) - 1; r >= GD_minrank(g); r--)
if (rank[r].n > 0) /* this may reflect the same problem :-() */
- rank[r].v[0]->u.coord.y =
- rank[r + 1].v[0]->u.coord.y + maxht;
+ (ND_coord(rank[r].v[0])).y=
+ (ND_coord(rank[r + 1].v[0])).y + maxht;
}
if (lbl && GD_flip(g))
/* copy ycoord assignment from leftmost nodes to others */
for (n = GD_nlist(g); n; n = ND_next(n))
- ND_coord(n).y = rank[ND_rank(n)].v[0]->u.coord.y;
+ ND_coord(n).y = (ND_coord(rank[ND_rank(n)].v[0])).y;
}
/* dot_compute_bb:
node_t *v;
pointf LL, UR;
- if (g == g->root) {
+ if (g == agroot(g)) {
LL.x = (double)(INT_MAX);
UR.x = (double)(-INT_MAX);
for (r = GD_minrank(g); r <= GD_maxrank(g); r++) {
}
offset = CL_OFFSET;
for (c = 1; c <= GD_n_cluster(g); c++) {
- x = (double)(GD_clust(g)[c]->u.bb.LL.x - offset);
+ x = (double)(GD_bb(GD_clust(g)[c]).LL.x - offset);
LL.x = MIN(LL.x, x);
- x = (double)(GD_clust(g)[c]->u.bb.UR.x + offset);
+ x = (double)(GD_bb(GD_clust(g)[c]).UR.x + offset);
UR.x = MAX(UR.x, x);
}
} else {
LL.x = (double)(ND_rank(GD_ln(g)));
UR.x = (double)(ND_rank(GD_rn(g)));
}
- LL.y = (double)(ND_rank(root)[GD_maxrank(g)].v[0]->u.coord.y - GD_ht1(g));
- UR.y = (double)(ND_rank(root)[GD_minrank(g)].v[0]->u.coord.y + GD_ht2(g));
+ LL.y = (double)(ND_coord(ND_rank(root)[GD_maxrank(g)].v[0]).y - GD_ht1(g));
+ UR.y = (double)(ND_coord(ND_rank(root)[GD_minrank(g)].v[0]).y + GD_ht2(g));
GD_bb(g).LL = LL;
GD_bb(g).UR = UR;
}
static point resize_leaf(node_t * leaf, point lbound)
{
- dot_nodesize(leaf, GD_flip(leaf->graph));
+ dot_nodesize(leaf, GD_flip(agraphof(leaf)));
ND_coord(leaf).y = lbound.y;
ND_coord(leaf).x = lbound.x + ND_lw(leaf);
- lbound.x = lbound.x + ND_lw(leaf) + ND_rw(leaf) + GD_nodesep(leaf->graph);
+ lbound.x = lbound.x + ND_lw(leaf) + ND_rw(leaf) + GD_nodesep(agraphof(leaf));
return lbound;
}
static point place_leaf(node_t * leaf, point lbound, int order)
{
node_t *leader;
- graph_t *g = leaf->graph;
+ graph_t *g = agraphof(leaf);
leader = UF_find(leaf);
if (leaf != leader)
lbound.y = ND_coord(leader).y;
lbound = resize_leaf(leader, lbound);
if (ND_out(leader).size > 0) { /* in-edge leaves */
- n = ND_out(leader).list[0]->head;
+ n = aghead(ND_out(leader).list[0]);
j = ND_order(leader) + 1;
for (e = agfstin(g, n); e; e = agnxtin(g, e)) {
- if ((e->tail != leader) && (UF_find(e->tail) == leader)) {
- lbound = place_leaf(e->tail, lbound, j++);
+ if ((agtail(e) != leader) && (UF_find(agtail(e)) == leader)) {
+ lbound = place_leaf(agtail(e), lbound, j++);
unmerge_oneway(e);
- elist_append(e, ND_in(e->head));
+ elist_append(e, ND_in(aghead(e)));
}
}
} else { /* out edge leaves */
- n = ND_in(leader).list[0]->tail;
+ n = agtail(ND_in(leader).list[0]);
j = ND_order(leader) + 1;
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
- if ((e->head != leader) && (UF_find(e->head) == leader)) {
- lbound = place_leaf(e->head, lbound, j++);
+ if ((aghead(e) != leader) && (UF_find(aghead(e)) == leader)) {
+ lbound = place_leaf(aghead(e), lbound, j++);
unmerge_oneway(e);
- elist_append(e, ND_out(e->tail));
+ elist_append(e, ND_out(agtail(e)));
}
}
}
do_leaves(g, ND_outleaf(n));
if (ND_other(n).list)
for (i = 0; (e = ND_other(n).list[i]); i++) {
- if ((d = ND_rank(e->head) - ND_rank(e->head)) == 0)
+ if ((d = ND_rank(aghead(e)) - ND_rank(aghead(e))) == 0)
continue;
f = ED_to_orig(e);
if (ports_eq(e, f) == FALSE) {
if (GD_ln(g))
return;
- ln = virtual_node(g->root);
+ ln = virtual_node(agroot(g));
ND_node_type(ln) = SLACKNODE;
- rn = virtual_node(g->root);
+ rn = virtual_node(agroot(g));
ND_node_type(rn) = SLACKNODE;
- if (GD_label(g) && (g != g->root) && !GD_flip(g->root)) {
+ if (GD_label(g) && (g != agroot(g)) && !GD_flip(agroot(g))) {
int w = MAX(GD_border(g)[BOTTOM_IX].x, GD_border(g)[TOP_IX].x);
make_aux_edge(ln, rn, w, 0);
}
v = GD_rank(g)[r].v[0];
if (v == NULL) {
agerr(AGERR, "contain_nodes clust %s rank %d missing node\n",
- g->name, r);
+ agnameof(g), r);
continue;
}
make_aux_edge(ln, v,
}
switch (kind) {
case SOURCERANK:
- GD_minset(g)->u.ranktype = kind;
+ ND_ranktype(GD_minset(g)) = kind;
break;
case SINKRANK:
- GD_maxset(g)->u.ranktype = kind;
+ ND_ranktype(GD_maxset(g)) = kind;
break;
}
}
}
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
- for (e = agfstout(g->root, n); e; e = agnxtout(g->root, e)) {
- if (agcontains(g, e->head))
+ for (e = agfstout(agroot(g), n); e; e = agnxtout(agroot(g), e)) {
+ if (agcontains(g, aghead(e)))
+#ifndef WITH_CGRAPH
aginsert(g, e);
+#else /* WITH_CGRAPH */
+ agsubedge(g,e,1);
+#endif /* WITH_CGRAPH */
}
}
}
collapse_sets(graph_t *rg, graph_t *g)
{
int c;
- graph_t *mg, *subg;
- node_t *mn, *n;
- edge_t *me;
+ graph_t *subg;
+ node_t *n;
+#ifndef WITH_CGRAPH
+ graph_t *mg;
+ node_t *mn;
+ edge_t *me;
mg = g->meta_node->graph;
for (me = agfstout(mg, g->meta_node); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
-
+#else /* WITH_CGRAPH */
+ for (subg = agfstsubg(g); subg; subg = agnxtsubg(subg)) {
+#endif /* WITH_CGRAPH */
c = rank_set_class(subg);
if (c) {
if ((c == CLUSTER) && CL_type == LOCAL)
else
collapse_rankset(rg, subg, c);
}
- else collapse_sets(rg,subg);
+ else collapse_sets(rg, subg);
/* mark nodes with ordered edges so their leaves are not collapsed */
if (agget(subg, "ordering"))
static void
find_clusters(graph_t * g)
{
- graph_t *mg, *subg;
+ graph_t *subg;
+#ifndef WITH_CGRAPH
+ graph_t *mg;
node_t *mn;
edge_t *me;
for (me = agfstout(mg, g->meta_node); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
-
+#else /* WITH_CGRAPH */
+ for (subg = agfstsubg(subg); subg; subg = agnxtsubg(subg)) {
+#endif /* WITH_CGRAPH */
if (GD_set_type(subg) == CLUSTER)
collapse_cluster(g, subg);
}
{
int c;
- GD_minrank(g) += GD_leader(g)->u.rank;
- GD_maxrank(g) += GD_leader(g)->u.rank;
+ GD_minrank(g) += ND_rank(GD_leader(g));
+ GD_maxrank(g) += ND_rank(GD_leader(g));
for (c = 1; c <= GD_n_cluster(g); c++)
set_minmax(GD_clust(g)[c]);
}
GD_maxset(g) = UF_find(GD_maxset(g));
if ((n = GD_maxset(g))) {
- slen.y = (GD_maxset(g)->u.ranktype == SINKRANK);
+ slen.y = (ND_ranktype(GD_maxset(g)) == SINKRANK);
while ((e = ND_out(n).list[0])) {
- assert(e->head == UF_find(e->head));
+ assert(aghead(e) == UF_find(aghead(e)));
reverse_edge(e);
}
}
if ((n = GD_minset(g))) {
- slen.x = (GD_minset(g)->u.ranktype == SOURCERANK);
+ slen.x = (ND_ranktype(GD_minset(g)) == SOURCERANK);
while ((e = ND_in(n).list[0])) {
- assert(e->tail == UF_find(e->tail));
+ assert(agtail(e) == UF_find(agtail(e)));
reverse_edge(e);
}
}
UF_singleton(n);
n = agnxtnode(g, n);
}
- if (g == g->root) {
+ if (g == agroot(g)) {
if (CL_type == LOCAL) {
for (c = 1; c <= GD_n_cluster(g); c++)
set_minmax(GD_clust(g)[c]);
int is_cluster(graph_t * g)
{
- return (strncmp(g->name, "cluster", 7) == 0);
+ return (strncmp(agnameof(g), "cluster", 7) == 0);
}
#ifdef OBSOLETE
if ((ED_tail_port(e).p.x) || (ED_head_port(e).p.x))
return;
- if ((ED_minlen(e) != 1) || (ND_order(e->tail) > 0))
+ if ((ED_minlen(e) != 1) || (ND_order(agtail(e)) > 0))
return;
- par = ((leaf != e->head) ? e->head : e->tail);
+ par = ((leaf != aghead(e)) ? aghead(e) : agtail(e));
ND_ranktype(leaf) = LEAFSET;
- if (par == e->tail)
+ if (par == agtail(e))
GD_outleaf(par) = merge_leaves(g, GD_outleaf(par), leaf);
else
GD_inleaf(par) = merge_leaves(g, GD_inleaf(par), leaf);
same_t same[MAXSAME];
int i;
+#ifndef WITH_CGRAPH
E_samehead = agfindattr(g->proto->e, "samehead");
E_sametail = agfindattr(g->proto->e, "sametail");
+#else /* WITH_CGRAPH */
+ E_samehead = agattr(g, AGEDGE, "samehead",(char*)0);
+ E_sametail = agattr(g, AGEDGE, "sametail",(char*)0);
+#endif /* WITH_CGRAPH */
if (!(E_samehead || E_sametail))
return;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
n_same = 0;
for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
- if (e->head == n && E_samehead &&
+ if (aghead(e) == n && E_samehead &&
+#ifndef WITH_CGRAPH
(id = agxget(e, E_samehead->index))[0])
+#else /* WITH_CGRAPH */
+ (id = agxget(e, E_sametail->index))[0])
+#endif /* WITH_CGRAPH */
sameedge(same, n, e, id);
- else if (e->tail == n && E_sametail &&
- (id = agxget(e, E_sametail->index))[0])
+ else if (agtail(e) == n && E_sametail &&
+#ifndef WITH_CGRAPH
+ (id = agxget(e, E_sametail->index))[0])
+#else /* WITH_CGRAPH */
+ (id = agxget(e, E_sametail))[0])
+#endif /* WITH_CGRAPH */
sameedge(same, n, e, id);
}
for (i = 0; i < n_same; i++) {
}
if (++n_same > MAXSAME) {
agerr(AGERR, "too many same{head,tail} groups for node %s\n",
- n->name);
+ agnameof(n));
return;
}
alloc_elist(1, same[i].l);
same[i].arr_len = 0;
set_arrow:
arrow_flags(e, &sflag, &eflag);
- if ((flag = e->head == n ? eflag : sflag))
+ if ((flag = aghead(e) == n ? eflag : sflag))
same[i].arr_len =
/* only consider arrows if there's exactly one arrow */
(++same[i].n_arr == 1) ? arrow_length(e, flag) : 0;
bring the angles within PI of each other. av(a,b)!=av(a,b+2*PI) */
for (i = 0; i < l->size; i++) {
e = l->list[i];
- if (e->head == u)
- v = e->tail;
+ if (aghead(e) == u)
+ v = agtail(e);
else
- v = e->head;
+ v = aghead(e);
x1 = ND_coord(v).x - ND_coord(u).x;
y1 = ND_coord(v).y - ND_coord(u).y;
r = hypot(x1, y1);
/* (x1,y1),(x2,y2) is a segment that must cross the node boundary */
x1 = ND_coord(u).x;
y1 = ND_coord(u).y; /* center of node */
- r = MAX(ND_lw(u) + ND_rw(u), ND_ht(u) + GD_ranksep(u->graph)); /* far away */
+ r = MAX(ND_lw(u) + ND_rw(u), ND_ht(u) + GD_ranksep(agraphof(u))); /* far away */
x2 = x * r + ND_coord(u).x;
y2 = y * r + ND_coord(u).y;
{ /* now move (x1,y1) to the node boundary */
for (; e; e = ED_to_virt(e)) { /* assign to all virt edges of e */
for (f = e; f;
f = ED_edge_type(f) == VIRTUAL &&
- ND_node_type(f->head) == VIRTUAL &&
- ND_out(f->head).size == 1 ?
- ND_out(f->head).list[0] : NULL) {
- if (f->head == u)
+ ND_node_type(aghead(f)) == VIRTUAL &&
+ ND_out(aghead(f)).size == 1 ?
+ ND_out(aghead(f)).list[0] : NULL) {
+ if (aghead(f) == u)
ED_head_port(f) = prt;
- if (f->tail == u)
+ if (agtail(f) == u)
ED_tail_port(f) = prt;
}
for (f = e; f;
f = ED_edge_type(f) == VIRTUAL &&
- ND_node_type(f->tail) == VIRTUAL &&
- ND_in(f->tail).size == 1 ?
- ND_in(f->tail).list[0] : NULL) {
- if (f->head == u)
+ ND_node_type(agtail(f)) == VIRTUAL &&
+ ND_in(agtail(f)).size == 1 ?
+ ND_in(agtail(f)).list[0] : NULL) {
+ if (aghead(f) == u)
ED_head_port(f) = prt;
- if (f->tail == u)
+ if (agtail(f) == u)
ED_tail_port(f) = prt;
}
}
#else
for (; e; e = ED_to_virt(e)) { /* assign to all virt edges of e */
- if (e->head == u)
+ if (aghead(e) == u)
ED_head_port(e) =
arr_port.defined && !eflag ? arr_prt : prt;
- if (e->tail == u)
+ if (agtail(e) == u)
ED_tail_port(e) =
arr_port.defined && !sflag ? arr_prt : prt;
}
projects / graphviz / commitdiff