use NGHolder::foo in favour of NFAGraph::foo

src/nfa/limex_compile.cpp

@@ -345,7 +345,7 @@ void buildReachMapping(const build_info &args, vector<NFAStateSet> &reach,
 }
 
 struct AccelBuild {
-    AccelBuild() : v(NFAGraph::null_vertex()), state(0), offset(0), ma_len1(0),
+    AccelBuild() : v(NGHolder::null_vertex()), state(0), offset(0), ma_len1(0),
             ma_len2(0), ma_type(MultibyteAccelInfo::MAT_NONE) {}
     NFAVertex v;
     u32 state;

src/nfagraph/ng_anchored_dots.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -119,7 +119,7 @@ NFAVertex findReformable(const NGHolder &g, const set<NFAVertex> &starts,
     }
 
     if (dotq.empty()) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
 
     const DotInfo &dot = dotq.top();
@@ -165,10 +165,10 @@ void reformAnchoredRepeatsComponent(NGHolder &g,
         return;
     }
 
-    NFAVertex dotV = NFAGraph::null_vertex();
+    NFAVertex dotV = NGHolder::null_vertex();
     set<NFAVertex> otherV;
     dotV = findReformable(g, compAnchoredStarts, otherV);
-    if (dotV == NFAGraph::null_vertex()) {
+    if (dotV == NGHolder::null_vertex()) {
         DEBUG_PRINTF("no candidate reformable dot found.\n");
         return;
     }
@@ -268,10 +268,10 @@ void reformUnanchoredRepeatsComponent(NGHolder &g,
     }
 
     while (true) {
-        NFAVertex dotV = NFAGraph::null_vertex();
+        NFAVertex dotV = NGHolder::null_vertex();
         set<NFAVertex> otherV;
         dotV = findReformable(g, compUnanchoredStarts, otherV);
-        if (dotV == NFAGraph::null_vertex()) {
+        if (dotV == NGHolder::null_vertex()) {
             DEBUG_PRINTF("no candidate reformable dot found.\n");
             return;
         }
@@ -464,7 +464,7 @@ void collapseVariableDotRepeat(NGHolder &g, NFAVertex start,
     // The first of our optional dots must be connected to start. The jump edge
     // past it will be verified in gatherParticipants(). If start is
     // graph.start, it should not be connected to startDs.
-    NFAVertex initialDot = NFAGraph::null_vertex();
+    NFAVertex initialDot = NGHolder::null_vertex();
     for (auto v : adjacent_vertices_range(start, g)) {
         if (is_special(v, g)) {
             continue;

src/nfagraph/ng_builder.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -131,7 +131,7 @@ NFABuilderImpl::~NFABuilderImpl() {
 NFAVertex NFABuilderImpl::getVertex(Position pos) const {
     assert(id2vertex.size() >= pos);
     const NFAVertex v = id2vertex[pos];
-    assert(v != NFAGraph::null_vertex());
+    assert(v != NGHolder::null_vertex());
     assert(graph->g[v].index == pos);
     return v;
 }

src/nfagraph/ng_execute.cpp

@@ -58,7 +58,7 @@ namespace ue2 {
 
 struct StateInfo {
     StateInfo(NFAVertex v, const CharReach &cr) : vertex(v), reach(cr) {}
-    StateInfo() : vertex(NFAGraph::null_vertex()) {}
+    StateInfo() : vertex(NGHolder::null_vertex()) {}
     NFAVertex vertex;
     CharReach reach;
 };

src/nfagraph/ng_extparam.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -294,21 +294,21 @@ bool anchorPatternWithBoundedRepeat(NGWrapper &g, const depth &minWidth,
 
 static
 NFAVertex findSingleCyclic(const NGHolder &g) {
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
     for (const auto &e : edges_range(g)) {
         if (source(e, g) == target(e, g)) {
             if (source(e, g) == g.startDs) {
                 continue;
             }
-            if (v != NFAGraph::null_vertex()) {
+            if (v != NGHolder::null_vertex()) {
                 // More than one cyclic vertex.
-                return NFAGraph::null_vertex();
+                return NGHolder::null_vertex();
             }
             v = source(e, g);
         }
     }
 
-    if (v != NFAGraph::null_vertex()) {
+    if (v != NGHolder::null_vertex()) {
         DEBUG_PRINTF("cyclic is %u\n", g[v].index);
         assert(!is_special(v, g));
     }
@@ -359,11 +359,11 @@ bool transformMinLengthToRepeat(const ReportManager &rm, NGWrapper &g) {
     // The graph must contain a single cyclic vertex (other than startDs), and
     // that vertex can have one pred and one successor.
     NFAVertex cyclic = findSingleCyclic(g);
-    if (cyclic == NFAGraph::null_vertex()) {
+    if (cyclic == NGHolder::null_vertex()) {
         return false;
     }
 
-    NFAGraph::adjacency_iterator ai, ae;
+    NGHolder::adjacency_iterator ai, ae;
     tie(ai, ae) = adjacent_vertices(g.start, g);
     if (*ai == g.startDs) {
         ++ai;
@@ -411,7 +411,7 @@ bool transformMinLengthToRepeat(const ReportManager &rm, NGWrapper &g) {
 
     // Check the cyclic state is A-OK.
     v = getSoleDestVertex(g, cyclic);
-    if (v == NFAGraph::null_vertex()) {
+    if (v == NGHolder::null_vertex()) {
         DEBUG_PRINTF("cyclic has more than one successor\n");
         return false;
     }

src/nfagraph/ng_haig.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -89,11 +89,11 @@ void populateInit(const NGHolder &g, const flat_set<NFAVertex> &unused,
     }
 
     v_by_index->clear();
-    v_by_index->resize(num_vertices(g), NFAGraph::null_vertex());
+    v_by_index->resize(num_vertices(g), NGHolder::null_vertex());
 
     for (auto v : vertices_range(g)) {
         u32 v_index = g[v].index;
-        assert((*v_by_index)[v_index] == NFAGraph::null_vertex());
+        assert((*v_by_index)[v_index] == NGHolder::null_vertex());
         (*v_by_index)[v_index] = v;
     }
 }

src/nfagraph/ng_holder.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -154,7 +154,7 @@ void clear_out_edges(NFAVertex v, NGHolder &h) {
 }
 
 void clear_graph(NGHolder &h) {
-    NFAGraph::vertex_iterator vi, ve;
+    NGHolder::vertex_iterator vi, ve;
     for (tie(vi, ve) = vertices(h); vi != ve;) {
         NFAVertex v = *vi;
         ++vi;

src/nfagraph/ng_holder.h

@@ -171,7 +171,7 @@ bool is_special(const NFAVertex v, const GraphT &g) {
 }
 
 static really_inline
-std::pair<NFAGraph::adjacency_iterator, NFAGraph::adjacency_iterator>
+std::pair<NGHolder::adjacency_iterator, NGHolder::adjacency_iterator>
 adjacent_vertices(NFAVertex v, const NGHolder &h) {
     return adjacent_vertices(v, h.g);
 }
@@ -182,7 +182,7 @@ std::pair<NFAEdge, bool> edge(NFAVertex u, NFAVertex v, const NGHolder &h) {
 }
 
 static really_inline
-std::pair<NFAGraph::edge_iterator, NFAGraph::edge_iterator>
+std::pair<NGHolder::edge_iterator, NGHolder::edge_iterator>
 edges(const NGHolder &h) {
     return edges(h.g);
 }
@@ -193,13 +193,13 @@ size_t in_degree(NFAVertex v, const NGHolder &h) {
 }
 
 static really_inline
-std::pair<NFAGraph::in_edge_iterator, NFAGraph::in_edge_iterator>
+std::pair<NGHolder::in_edge_iterator, NGHolder::in_edge_iterator>
 in_edges(NFAVertex v, const NGHolder &h) {
     return in_edges(v, h.g);
 }
 
 static really_inline
-std::pair<NFAGraph::inv_adjacency_iterator, NFAGraph::inv_adjacency_iterator>
+std::pair<NGHolder::inv_adjacency_iterator, NGHolder::inv_adjacency_iterator>
 inv_adjacent_vertices(NFAVertex v, const NGHolder &h) {
     return inv_adjacent_vertices(v, h.g);
 }
@@ -210,7 +210,7 @@ size_t out_degree(NFAVertex v, const NGHolder &h) {
 }
 
 static really_inline
-std::pair<NFAGraph::out_edge_iterator, NFAGraph::out_edge_iterator>
+std::pair<NGHolder::out_edge_iterator, NGHolder::out_edge_iterator>
 out_edges(NFAVertex v, const NGHolder &h) {
     return out_edges(v, h.g);
 }
@@ -226,7 +226,7 @@ NFAVertex target(const NFAEdge &e, const NGHolder &h) {
 }
 
 static really_inline
-std::pair<NFAGraph::vertex_iterator, NFAGraph::vertex_iterator>
+std::pair<NGHolder::vertex_iterator, NGHolder::vertex_iterator>
 vertices(const NGHolder &h) {
     return vertices(h.g);
 }

src/nfagraph/ng_limex.cpp

@@ -164,7 +164,7 @@ void makeTopStates(NGHolder &g, map<u32, NFAVertex> &tops,
 
         assert(!contains(tops, t));
 
-        NFAVertex s = NFAGraph::null_vertex();
+        NFAVertex s = NGHolder::null_vertex();
         flat_set<NFAVertex> succs;
         insert(&succs, top.second);
 

src/nfagraph/ng_limex_accel.cpp

@@ -658,7 +658,7 @@ NFAVertex get_sds_or_proxy(const NGHolder &g) {
         return g.startDs;
     }
 
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
     for (auto w : adjacent_vertices_range(g.start, g)) {
         if (w != g.startDs) {
             if (!v) {
@@ -693,8 +693,8 @@ NFAVertex get_sds_or_proxy(const NGHolder &g) {
 
 static
 NFAVertex find_next(const NFAVertex v, const NGHolder &g) {
-    NFAVertex res = NFAGraph::null_vertex();
+    NFAVertex res = NGHolder::null_vertex();
-    for (NFAVertex u :  adjacent_vertices_range(v, g)) {
+    for (NFAVertex u : adjacent_vertices_range(v, g)) {
         if (u != v) {
             res = u;
             break;
@@ -736,7 +736,7 @@ MultibyteAccelInfo nfaCheckMultiAccel(const NGHolder &g,
 
     // find our start vertex
     NFAVertex cur = find_next(v, g);
-    if (cur == NFAGraph::null_vertex()) {
+    if (cur == NGHolder::null_vertex()) {
         DEBUG_PRINTF("invalid start vertex\n");
         return MultibyteAccelInfo();
     }

src/nfagraph/ng_mcclellan.cpp

@@ -173,11 +173,11 @@ void populateInit(const NGHolder &g, const flat_set<NFAVertex> &unused,
     }
 
     v_by_index->clear();
-    v_by_index->resize(num_vertices(g), NFAGraph::null_vertex());
+    v_by_index->resize(num_vertices(g), NGHolder::null_vertex());
 
     for (auto v : vertices_range(g)) {
         u32 vert_id = g[v].index;
-        assert((*v_by_index)[vert_id] == NFAGraph::null_vertex());
+        assert((*v_by_index)[vert_id] == NGHolder::null_vertex());
         (*v_by_index)[vert_id] = v;
     }
 

src/nfagraph/ng_prefilter.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -135,7 +135,7 @@ void findWidths(const NGHolder &g,
     // Wire our entries to start and our exits to accept.
     for (auto v : ri.vertices) {
         NFAVertex v_new = mapping[v];
-        assert(v_new != NFAGraph::null_vertex());
+        assert(v_new != NGHolder::null_vertex());
 
         if (isRegionEntry(g, v, region_map) &&
             !edge(rg.start, v_new, rg).second) {

src/nfagraph/ng_puff.cpp

@@ -472,7 +472,7 @@ bool doComponent(RoseBuild &rose, ReportManager &rm, NGHolder &g, NFAVertex a,
     }
 
     NFAVertex puffv = nodes.back();
-    assert(puffv != NFAGraph::null_vertex());
+    assert(puffv != NGHolder::null_vertex());
     u32 width = countChain(g, nodes.back());
 
     flat_set<ReportID> chain_reports;

src/nfagraph/ng_redundancy.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -158,7 +158,7 @@ void populateContainers(const NGHolder &g, VertexInfoMap &infoMap) {
 static
 void inplaceIntersection(vector<NFAVertex> &vset1,
                          const flat_set<NFAVertex> &vset2) {
-    const NFAVertex GONE = NFAGraph::null_vertex();
+    const NFAVertex GONE = NGHolder::null_vertex();
 
     vector<NFAVertex>::iterator it = vset1.begin(), ite = vset1.end();
     flat_set<NFAVertex>::const_iterator jt = vset2.begin(), jte = vset2.end();

src/nfagraph/ng_repeat.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -1202,7 +1202,7 @@ CharReach predReach(const NGHolder &g, NFAVertex v) {
 static
 void filterMap(const NGHolder &subg,
                ue2::unordered_map<NFAVertex, NFAVertex> &vmap) {
-    NFAGraph::vertex_iterator vi, ve;
+    NGHolder::vertex_iterator vi, ve;
     tie(vi, ve) = vertices(subg);
     const ue2::unordered_set<NFAVertex> remaining_verts(vi, ve);
 

src/nfagraph/ng_rose.cpp

@@ -780,7 +780,7 @@ bool literalIsWholeGraph(const NGHolder &g, const ue2_literal &lit) {
     NFAVertex v = g.accept;
 
     for (auto it = lit.rbegin(), ite = lit.rend(); it != ite; ++it) {
-        NFAGraph::inv_adjacency_iterator ai, ae;
+        NGHolder::inv_adjacency_iterator ai, ae;
         tie(ai, ae) = inv_adjacent_vertices(v, g);
         if (ai == ae) {
             assert(0); // no predecessors?

src/nfagraph/ng_som.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -384,7 +384,7 @@ makePrefix(const NGHolder &g, const ue2::unordered_map<NFAVertex, u32> &regions,
     add_edge(prefix.accept, prefix.acceptEod, prefix);
 
     assert(!next_enters.empty());
-    assert(next_enters.front() != NFAGraph::null_vertex());
+    assert(next_enters.front() != NGHolder::null_vertex());
     u32 dead_region = regions.at(next_enters.front());
     DEBUG_PRINTF("curr_region %u, dead_region %u\n",
                  regions.at(curr_exits.front()), dead_region);
@@ -2537,7 +2537,7 @@ bool doHaigLitHaigSom(NG &ng, NGHolder &g,
     RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig);
 
     bool lhs_all_vac = true;
-    NFAGraph::adjacency_iterator ai, ae;
+    NGHolder::adjacency_iterator ai, ae;
     for (tie(ai, ae) = adjacent_vertices(lhs->startDs, *lhs);
          ai != ae && lhs_all_vac; ++ai) {
         if (!is_special(*ai, *lhs)) {

src/nfagraph/ng_squash.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -369,7 +369,7 @@ map<NFAVertex, NFAStateSet> findSquashers(const NGHolder &g, som_type som) {
     buildPDomTree(g, pdom_tree);
 
     // Build list of vertices by state ID and a set of init states.
-    vector<NFAVertex> vByIndex(numStates, NFAGraph::null_vertex());
+    vector<NFAVertex> vByIndex(numStates, NGHolder::null_vertex());
     NFAStateSet initStates(numStates);
     smgb_cache cache(g);
 
@@ -394,7 +394,7 @@ map<NFAVertex, NFAStateSet> findSquashers(const NGHolder &g, som_type som) {
 
     for (u32 i = 0; i < numStates; i++) {
         NFAVertex v = vByIndex[i];
-        assert(v != NFAGraph::null_vertex());
+        assert(v != NGHolder::null_vertex());
         const CharReach &cr = g[v].char_reach;
 
         /* only non-init cyclics can be squashers */

src/nfagraph/ng_uncalc_components.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -184,7 +184,7 @@ u32 commonPrefixLength(const NGHolder &ga,
             size_t a_count = 0;
             size_t b_count = 0;
 
-            NFAGraph::out_edge_iterator ei, ee;
+            NGHolder::out_edge_iterator ei, ee;
             for (tie(ei, ee) = out_edges(a[i], ga); ok && ei != ee; ++ei) {
                 u32 sid = a_state_ids.at(target(*ei, ga));
                 if (sid == NO_STATE || sid >= max) {
@@ -213,7 +213,7 @@ u32 commonPrefixLength(const NGHolder &ga,
                 }
             }
 
-            NFAGraph::adjacency_iterator ai, ae;
+            NGHolder::adjacency_iterator ai, ae;
             for (tie(ai, ae) = adjacent_vertices(b[i], gb); ok && ai != ae;
                  ++ai) {
                 u32 sid = b_state_ids.at(*ai);

src/nfagraph/ng_util.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -78,26 +78,26 @@ depth maxDistFromStartOfData(const NFAVertexDepth &vd) {
 }
 
 NFAVertex getSoleDestVertex(const NGHolder &g, NFAVertex a) {
-    assert(a != NFAGraph::null_vertex());
+    assert(a != NGHolder::null_vertex());
 
-    NFAGraph::out_edge_iterator ii, iie;
+    NGHolder::out_edge_iterator ii, iie;
     tie(ii, iie) = out_edges(a, g);
     if (ii == iie) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
     NFAVertex b = target(*ii, g);
     if (a == b) {
         ++ii;
         if (ii == iie) {
-            return NFAGraph::null_vertex();
+            return NGHolder::null_vertex();
         }
 
         b = target(*ii, g);
         if (++ii != iie) {
-            return NFAGraph::null_vertex();
+            return NGHolder::null_vertex();
         }
     } else if (++ii != iie && (target(*ii, g) != a || ++ii != iie)) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
 
     assert(a != b);
@@ -105,23 +105,23 @@ NFAVertex getSoleDestVertex(const NGHolder &g, NFAVertex a) {
 }
 
 NFAVertex getSoleSourceVertex(const NGHolder &g, NFAVertex a) {
-    assert(a != NFAGraph::null_vertex());
+    assert(a != NGHolder::null_vertex());
 
     u32 idegree = in_degree(a, g);
     if (idegree != 1 && !(idegree == 2 && hasSelfLoop(a, g))) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
 
-    NFAGraph::in_edge_iterator ii, iie;
+    NGHolder::in_edge_iterator ii, iie;
     tie(ii, iie) = in_edges(a, g);
     if (ii == iie) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
     NFAVertex b = source(*ii, g);
     if (a == b) {
         ++ii;
         if (ii == iie) {
-            return NFAGraph::null_vertex();
+            return NGHolder::null_vertex();
         }
 
         b = source(*ii, g);
@@ -321,7 +321,7 @@ bool can_match_at_eod(const NGHolder &h) {
 }
 
 bool can_only_match_at_eod(const NGHolder &g) {
-    NFAGraph::in_edge_iterator ie, ee;
+    NGHolder::in_edge_iterator ie, ee;
     tie(ie, ee) = in_edges(g.accept, g);
 
     return ie == ee;

src/nfagraph/ng_util.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -65,7 +65,7 @@ bool is_dot(NFAVertex v, const GraphT &g) {
 template<class U>
 static really_inline
 void succ(const NGHolder &g, NFAVertex v, U *s) {
-    NFAGraph::adjacency_iterator ai, ae;
+    NGHolder::adjacency_iterator ai, ae;
     tie(ai, ae) = adjacent_vertices(v, g);
     s->insert(ai, ae);
 }
@@ -74,14 +74,14 @@ void succ(const NGHolder &g, NFAVertex v, U *s) {
 template<class U>
 static really_inline
 void pred(const NGHolder &g, NFAVertex v, U *p) {
-    NFAGraph::inv_adjacency_iterator it, ite;
+    NGHolder::inv_adjacency_iterator it, ite;
     tie(it, ite) = inv_adjacent_vertices(v, g);
     p->insert(it, ite);
 }
 
 /** returns a vertex with an out edge from v and is not v.
  * v must have exactly one out-edge excluding self-loops.
- * will return NFAGraph::null_vertex() if the preconditions don't hold.
+ * will return NGHolder::null_vertex() if the preconditions don't hold.
  */
 NFAVertex getSoleDestVertex(const NGHolder &g, NFAVertex v);
 

src/rose/rose_build_anchored.cpp

@@ -476,7 +476,7 @@ NFAVertex extractLiteral(const NGHolder &h, ue2_literal *lit) {
     }
 
     if (lit_verts.empty()) {
-        return NFAGraph::null_vertex();
+        return NGHolder::null_vertex();
     }
 
     bool nocase = false;
@@ -488,7 +488,7 @@ NFAVertex extractLiteral(const NGHolder &h, ue2_literal *lit) {
         if (cr.isAlpha()) {
             bool cr_nocase = cr.count() != 1;
             if (case_set && cr_nocase != nocase) {
-                return NFAGraph::null_vertex();
+                return NGHolder::null_vertex();
             }
 
             case_set = true;
@@ -511,7 +511,7 @@ bool isSimple(const NGHolder &h, u32 *min_bound, u32 *max_bound,
     DEBUG_PRINTF("looking for simple case\n");
     NFAVertex lit_head = extractLiteral(h, lit);
 
-    if (lit_head == NFAGraph::null_vertex()) {
+    if (lit_head == NGHolder::null_vertex()) {
         DEBUG_PRINTF("no literal found\n");
         return false;
     }

src/rose/rose_build_misc.cpp

@@ -538,11 +538,11 @@ static
 bool requiresDedupe(const NGHolder &h, const ue2::flat_set<ReportID> &reports,
                     const Grey &grey) {
     /* TODO: tighten */
-    NFAVertex seen_vert = NFAGraph::null_vertex();
+    NFAVertex seen_vert = NGHolder::null_vertex();
 
     for (auto v : inv_adjacent_vertices_range(h.accept, h)) {
         if (has_intersection(h[v].reports, reports)) {
-            if (seen_vert != NFAGraph::null_vertex()) {
+            if (seen_vert != NGHolder::null_vertex()) {
                 return true;
             }
             seen_vert = v;
@@ -551,7 +551,7 @@ bool requiresDedupe(const NGHolder &h, const ue2::flat_set<ReportID> &reports,
 
     for (auto v : inv_adjacent_vertices_range(h.acceptEod, h)) {
         if (has_intersection(h[v].reports, reports)) {
-            if (seen_vert != NFAGraph::null_vertex()) {
+            if (seen_vert != NGHolder::null_vertex()) {
                 return true;
             }
             seen_vert = v;

unit/internal/limex_nfa.cpp

@@ -314,10 +314,8 @@ protected:
         // Reverse the graph and add some reports on the accept vertices.
         NGHolder g_rev(NFA_REV_PREFIX);
         reverseHolder(*g, g_rev);
-        NFAGraph::inv_adjacency_iterator ai, ae;
+        for (NFAVertex v : inv_adjacent_vertices_range(g_rev.accept, g_rev)) {
-        for (tie(ai, ae) = inv_adjacent_vertices(g_rev.accept, g_rev); ai != ae;
+            g_rev[v].reports.insert(0);
-             ++ai) {
-            g_rev[*ai].reports.insert(0);
         }
 
         nfa = constructReversedNFA(g_rev, type, cc);

unit/internal/nfagraph_equivalence.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -27,7 +27,8 @@
  */
 
 /**
- * Unit tests for checking the removeGraphEquivalences code in nfagraph/ng_equivalence.cpp.
+ * Unit tests for checking the removeGraphEquivalences code in
+ * nfagraph/ng_equivalence.cpp.
  */
 
 #include "config.h"
@@ -71,10 +72,9 @@ TEST(NFAGraph, RemoveEquivalence1) {
     ASSERT_EQ(2U, in_degree(g.accept, g));
 
     // Find a vertex that goes right after startDs
-    NFAVertex a = NFAGraph::null_vertex();
+    NFAVertex a = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex v : adjacent_vertices_range(g.startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.startDs, g); ai != ae; ++ai) {
+        a = v;
-        a = *ai;
         if (a == g.startDs) {
             continue;
         }
@@ -87,8 +87,8 @@ TEST(NFAGraph, RemoveEquivalence1) {
     ASSERT_TRUE(a != nullptr);
 
     // There should be two edges from v to nodes with reachability 'b' and 'c'
-    NFAVertex b = NFAGraph::null_vertex();
+    NFAVertex b = NGHolder::null_vertex();
-    NFAVertex c = NFAGraph::null_vertex();
+    NFAVertex c = NGHolder::null_vertex();
     for (NFAVertex tmp : adjacent_vertices_range(a, g)) {
         const CharReach &tmpcr = g[tmp].char_reach;
         ASSERT_EQ(1U, tmpcr.count());
@@ -133,11 +133,9 @@ TEST(NFAGraph, RemoveEquivalence2) {
     ASSERT_EQ(1U, in_degree(g.accept, g));
 
     // Find a vertex leading to accept
-    NFAVertex a = NFAGraph::null_vertex();
+    NFAVertex a = NGHolder::null_vertex();
-    NFAGraph::inv_adjacency_iterator ai, ae;
+    for (NFAVertex v : inv_adjacent_vertices_range(g.accept, g)) {
-    for (tie(ai, ae) = inv_adjacent_vertices(g.accept, g); ai != ae;
+        a = v;
-         ++ai) {
-        a = *ai;
         if (a == g.accept) {
             continue;
         }
@@ -150,8 +148,8 @@ TEST(NFAGraph, RemoveEquivalence2) {
     ASSERT_TRUE(a != nullptr);
 
     // There should be two edges from v to nodes with reachability 'b' and 'c'
-    NFAVertex b = NFAGraph::null_vertex();
+    NFAVertex b = NGHolder::null_vertex();
-    NFAVertex c = NFAGraph::null_vertex();
+    NFAVertex c = NGHolder::null_vertex();
     for (NFAVertex tmp : inv_adjacent_vertices_range(a, g)) {
         const CharReach &tmpcr = g[tmp].char_reach;
         ASSERT_EQ(1U, tmpcr.count());
@@ -197,10 +195,9 @@ TEST(NFAGraph, RemoveEquivalence3) {
     ASSERT_EQ(2U, in_degree(g.accept, g));
 
     // Find a vertex 'a' that goes right after startDs
-    NFAVertex a = NFAGraph::null_vertex();
+    NFAVertex a = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex v : adjacent_vertices_range(g.startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.startDs, g); ai != ae; ++ai) {
+        a = v;
-        a = *ai;
         if (a == g.startDs) {
             continue;
         }
@@ -234,10 +231,9 @@ TEST(NFAGraph, RemoveEquivalence3) {
     ASSERT_TRUE(edge(dot2, dot1, g).second);
 
     // now, let's find X and Y nodes
-    NFAVertex X = NFAGraph::null_vertex();
+    NFAVertex X = NGHolder::null_vertex();
-    NFAVertex Y = NFAGraph::null_vertex();
+    NFAVertex Y = NGHolder::null_vertex();
-    for (tie(ai, ae) = adjacent_vertices(dot2, g); ai != ae; ++ai) {
+    for (NFAVertex tmp : adjacent_vertices_range(dot2, g)) {
-        NFAVertex tmp = *ai;
 
         // we already know about dot1, so skip it
         if (tmp == dot1) {
@@ -290,12 +286,9 @@ TEST(NFAGraph, RemoveEquivalence4) {
     ASSERT_EQ(1U, in_degree(g.accept, g));
 
     // Find X and Y nodes that are connected to startDs
-    NFAVertex X = NFAGraph::null_vertex();
+    NFAVertex X = NGHolder::null_vertex();
-    NFAVertex Y = NFAGraph::null_vertex();
+    NFAVertex Y = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex tmp : adjacent_vertices_range(g.startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.startDs, g); ai != ae; ++ai) {
-        NFAVertex tmp = *ai;
-
         // skip startDs
         if (tmp == g.startDs) {
             continue;
@@ -341,10 +334,8 @@ TEST(NFAGraph, RemoveEquivalence4) {
     ASSERT_TRUE(edge(dot2, dot1, g).second);
 
     // now find 'a'
-    NFAVertex a = NFAGraph::null_vertex();
+    NFAVertex a = NGHolder::null_vertex();
-    for (tie(ai, ae) = adjacent_vertices(dot2, g); ai != ae; ++ai) {
+    for (NFAVertex tmp : adjacent_vertices_range(dot2, g)) {
-        NFAVertex tmp = *ai;
-
         // skip dot1
         if (tmp == dot1) {
             continue;
@@ -392,10 +383,9 @@ TEST(NFAGraph, RemoveEquivalence5) {
     ASSERT_EQ(1U, in_degree(g.accept, g));
 
     // find first vertex and ensure it has a self loop
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex t : adjacent_vertices_range(g.startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.startDs, g); ai != ae; ++ai) {
+        v = t;
-        v = *ai;
         if (v == g.startDs) {
             continue;
         }
@@ -409,15 +399,13 @@ TEST(NFAGraph, RemoveEquivalence5) {
     ASSERT_TRUE(v != nullptr);
 
     // now, find the vertex leading to accept
-    NFAVertex v2 = NFAGraph::null_vertex();
+    NFAVertex v2 = NGHolder::null_vertex();
-    for (tie(ai, ae) = adjacent_vertices(v, g); ai != ae; ++ai) {
+    for (NFAVertex tmp : adjacent_vertices_range(v, g)) {
-        NFAVertex tmp = *ai;
-
         // skip self-loop
         if (tmp == v) {
             continue;
         }
-        v2 = *ai;
+        v2 = tmp;
         // get char reach
         const CharReach tmpcr = g[tmp].char_reach;
 
@@ -450,10 +438,9 @@ TEST(NFAGraph, RemoveEquivalence6) {
     ASSERT_EQ(1U, in_degree(g.accept, g));
 
     // find that vertex and ensure it has no self loops and an edge to accept
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex t : adjacent_vertices_range(g.startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.startDs, g); ai != ae; ++ai) {
+        v = t;
-        v = *ai;
         if (v == g.startDs) {
             continue;
         }
@@ -492,13 +479,12 @@ TEST(NFAGraph, RemoveEquivalence7) {
     ASSERT_EQ(1U, in_degree(g.accept, g));
 
     // find that vertex and ensure it's a dot self loop and has one outgoing edge
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex t : adjacent_vertices_range(g.start, g)) {
-    for (tie(ai, ae) = adjacent_vertices(g.start, g); ai != ae; ++ai) {
+        if (t == g.startDs) {
-        if (*ai == g.startDs) {
             continue;
         }
-        v = *ai;
+        v = t;
         // check if it has the right char reach
         const CharReach &tmpcr = g[v].char_reach;
         ASSERT_TRUE(tmpcr.all());
@@ -509,13 +495,13 @@ TEST(NFAGraph, RemoveEquivalence7) {
     ASSERT_TRUE(v != nullptr);
 
     // find the next vertex and ensure it has an edge to accept
-    NFAVertex v2 = NFAGraph::null_vertex();
+    NFAVertex v2 = NGHolder::null_vertex();
-    for (tie(ai, ae) = adjacent_vertices(v, g); ai != ae; ++ai) {
+    for (NFAVertex t : adjacent_vertices_range(v, g)) {
         // skip self loop
-        if (*ai == v) {
+        if (t == v) {
             continue;
         }
-        v2 = *ai;
+        v2 = t;
         // check if it has the right char reach
         const CharReach &tmpcr = g[v2].char_reach;
         ASSERT_EQ(1U, tmpcr.count());

unit/internal/nfagraph_redundancy.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -27,7 +27,8 @@
  */
 
 /**
- * Unit tests for checking the removeRedundancy code in nfagraph/ng_redundancy.cpp.
+ * Unit tests for checking the removeRedundancy code in
+ * nfagraph/ng_redundancy.cpp.
  */
 
 #include "config.h"
@@ -62,15 +63,17 @@ TEST(NFAGraph, RemoveRedundancy1) {
     // Our graph should only have two non-special nodes
     ASSERT_EQ((size_t)N_SPECIALS + 2, num_vertices(*graph));
 
-    // Dot-star start state should be connected to itself and a single other vertex
+    // Dot-star start state should be connected to itself and a single other
+    // vertex
     ASSERT_EQ(2U, out_degree(graph->startDs, g));
 
     // That single vertex should have reachability [ab]
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex t : adjacent_vertices_range(graph->startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(graph->startDs, g); ai != ae; ++ai) {
+        v = t;
-        v = *ai;
+        if (v != graph->startDs) {
-        if (v != graph->startDs) break;
+            break;
+        }
     }
     const CharReach &cr = g[v].char_reach;
     ASSERT_EQ(2U, cr.count());
@@ -103,35 +106,39 @@ TEST(NFAGraph, RemoveRedundancy2) {
     // Our graph should now have only 3 non-special vertices
     ASSERT_EQ((size_t)N_SPECIALS + 3, num_vertices(*graph));
 
-    // Dot-star start state should be connected to itself and a single other vertex
+    // Dot-star start state should be connected to itself and a single other
+    // vertex
     ASSERT_EQ(2U, out_degree(graph->startDs, g));
 
     // That single vertex should have reachability [a]
-    NFAVertex v = NFAGraph::null_vertex();
+    NFAVertex v = NGHolder::null_vertex();
-    NFAGraph::adjacency_iterator ai, ae;
+    for (NFAVertex t : adjacent_vertices_range(graph->startDs, g)) {
-    for (tie(ai, ae) = adjacent_vertices(graph->startDs, g); ai != ae; ++ai) {
+        v = t;
-        v = *ai;
+        if (v != graph->startDs) {
-        if (v != graph->startDs) break;
+            break;
+        }
     }
     const CharReach &cr = g[v].char_reach;
     ASSERT_EQ(1U, cr.count());
     ASSERT_TRUE(cr.test('a'));
 
-    // 'a' should have two out edges: one to a dot with a cycle (.*) and one to 'c'
+    // 'a' should have two out edges: one to a dot with a cycle (.*) and one to
+    // 'c'
     ASSERT_EQ(2U, out_degree(v, g));
-    NFAVertex dotstar = NFAGraph::null_vertex(), vc = NFAGraph::null_vertex();
+    NFAVertex dotstar = NGHolder::null_vertex();
-    for (tie(ai, ae) = adjacent_vertices(v, g); ai != ae; ++ai) {
+    NFAVertex vc = NGHolder::null_vertex();
-        const CharReach &cr2 = g[*ai].char_reach;
+    for (NFAVertex t : adjacent_vertices_range(v, g)) {
+        const CharReach &cr2 = g[t].char_reach;
         if (cr2.count() == 1 && cr2.test('c')) {
-            vc = *ai;
+            vc = t;
         } else if (cr2.all()) {
-            dotstar = *ai;
+            dotstar = t;
         } else {
             FAIL();
         }
     }
-    ASSERT_TRUE(vc != NFAGraph::null_vertex());
+    ASSERT_TRUE(vc != NGHolder::null_vertex());
-    ASSERT_TRUE(dotstar != NFAGraph::null_vertex());
+    ASSERT_TRUE(dotstar != NGHolder::null_vertex());
 
     // Dot-star node should have a self-loop and an edge to vertex 'c'
     ASSERT_EQ(2U, out_degree(dotstar, g));

unit/internal/nfagraph_util.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -85,24 +85,23 @@ TEST(NFAGraph, split1) {
     splitGraph(src, pivot, &lhs, &lhs_map, &rhs, &rhs_map);
 
     ASSERT_EQ(3U + N_SPECIALS, num_vertices(lhs));
-    NFAGraph::vertex_iterator vi, ve;
+    for (NFAVertex v : vertices_range(lhs)) {
-    for (tie(vi, ve) = vertices(lhs); vi != ve; ++vi) {
+        if (is_special(v, lhs)) {
-        if (is_special(*vi, lhs)) {
             continue;
         }
 
-        u32 cr = lhs[*vi].char_reach.find_first();
+        u32 cr = lhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE((cr >= 'a' && cr <= 'c'));
     }
 
     ASSERT_EQ(8U + N_SPECIALS, num_vertices(rhs) );
-    for (tie(vi, ve) = vertices(rhs); vi != ve; ++vi) {
+    for (NFAVertex v : vertices_range(rhs)) {
-        if (is_special(*vi, rhs)) {
+        if (is_special(v, rhs)) {
             continue;
         }
 
-        u32 cr = rhs[*vi].char_reach.find_first();
+        u32 cr = rhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE(cr >= 'b' && cr <= 'i');
     }
@@ -137,24 +136,23 @@ TEST(NFAGraph, split2) {
     splitGraph(src, pivot, &lhs, &lhs_map, &rhs, &rhs_map);
 
     ASSERT_EQ(3U + N_SPECIALS, num_vertices(lhs));
-    NFAGraph::vertex_iterator vi, ve;
+    for (NFAVertex v : vertices_range(lhs)) {
-    for (tie(vi, ve) = vertices(lhs); vi != ve; ++vi) {
+        if (is_special(v, lhs)) {
-        if (is_special(*vi, lhs)) {
             continue;
         }
 
-        u32 cr = lhs[*vi].char_reach.find_first();
+        u32 cr = lhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE(cr >= 'a' && cr <= 'c');
     }
 
     ASSERT_EQ(3U + N_SPECIALS, num_vertices(rhs) );
-    for (tie(vi, ve) = vertices(rhs); vi != ve; ++vi) {
+    for (NFAVertex v : vertices_range(rhs)) {
-        if (is_special(*vi, rhs)) {
+        if (is_special(v, rhs)) {
             continue;
         }
 
-        u32 cr = rhs[*vi].char_reach.find_first();
+        u32 cr = rhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE(cr >= 'b' && cr <= 'd');
     }
@@ -211,24 +209,23 @@ TEST(NFAGraph, split3) {
     splitGraph(src, pivots, &lhs, &lhs_map, &rhs, &rhs_map);
 
     ASSERT_EQ(7U + N_SPECIALS, num_vertices(lhs));
-    NFAGraph::vertex_iterator vi, ve;
+    for (NFAVertex v : vertices_range(lhs)) {
-    for (tie(vi, ve) = vertices(lhs); vi != ve; ++vi) {
+        if (is_special(v, lhs)) {
-        if (is_special(*vi, lhs)) {
             continue;
         }
 
-        u32 cr = lhs[*vi].char_reach.find_first();
+        u32 cr = lhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE((cr >= 'a' && cr <= 'g'));
     }
 
     ASSERT_EQ(2U + N_SPECIALS, num_vertices(rhs) );
-    for (tie(vi, ve) = vertices(rhs); vi != ve; ++vi) {
+    for (NFAVertex v : vertices_range(rhs)) {
-        if (is_special(*vi, rhs)) {
+        if (is_special(v, rhs)) {
             continue;
         }
 
-        u32 cr = rhs[*vi].char_reach.find_first();
+        u32 cr = rhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE(cr >= 'h' && cr <= 'i');
     }
@@ -289,13 +286,12 @@ TEST(NFAGraph, split4) {
     splitGraph(src, pivots, &lhs, &lhs_map, &rhs, &rhs_map);
 
     ASSERT_EQ(7U + N_SPECIALS, num_vertices(lhs));
-    NFAGraph::vertex_iterator vi, ve;
+    for (NFAVertex v : vertices_range(lhs)) {
-    for (tie(vi, ve) = vertices(lhs); vi != ve; ++vi) {
+        if (is_special(v, lhs)) {
-        if (is_special(*vi, lhs)) {
             continue;
         }
 
-        u32 cr = lhs[*vi].char_reach.find_first();
+        u32 cr = lhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE((cr >= 'a' && cr <= 'g'));
     }
@@ -304,12 +300,12 @@ TEST(NFAGraph, split4) {
     ASSERT_TRUE(edge(lhs_map[d], lhs_map[d], lhs).second);
 
     ASSERT_EQ(2U + N_SPECIALS, num_vertices(rhs) );
-    for (tie(vi, ve) = vertices(rhs); vi != ve; ++vi) {
+    for (NFAVertex v : vertices_range(rhs)) {
-        if (is_special(*vi, rhs)) {
+        if (is_special(v, rhs)) {
             continue;
         }
 
-        u32 cr = rhs[*vi].char_reach.find_first();
+        u32 cr = rhs[v].char_reach.find_first();
         SCOPED_TRACE(cr);
         ASSERT_TRUE(cr >= 'h' && cr <= 'i');
     }

util/ng_corpus_generator.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Intel Corporation
+ * Copyright (c) 2015-2016, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -158,7 +158,7 @@ void findPaths(const NGHolder &g, CorpusProperties &cProps,
         DEBUG_PRINTF("dequeuing path %s, back %u\n",
                      pathToString(g, *p).c_str(), g[u].index);
 
-        NFAGraph::adjacency_iterator ai, ae;
+        NGHolder::adjacency_iterator ai, ae;
         for (tie(ai, ae) = adjacent_vertices(u, g); ai != ae; ++ai) {
             NFAVertex v = *ai;
 

util/ng_find_matches.cpp

@@ -76,7 +76,7 @@ struct fmstate {
     fmstate(const NGHolder &g, bool som_in, bool utf8_in, bool aSD_in,
             const ReportManager &rm_in)
         : num_states(num_vertices(g)), states(num_states), next(num_states),
-          vertices(num_vertices(g), NFAGraph::null_vertex()), som(som_in),
+          vertices(num_vertices(g), NGHolder::null_vertex()), som(som_in),
           utf8(utf8_in), allowStartDs(aSD_in), rm(rm_in), accept(num_states),
           accept_with_eod(num_states) {
         // init states