* required so that ^ doesn't match trailing \n */
for (const auto &e : out_edges_range(v, g)) {
if (target(e, g) == g.accept) {
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
/* assert has been resolved; clear flag */
u32 cnt = last_id - first_id;
// long literals first for included literals checking
for (u32 k = 0; k < cnt; k++) {
- litIds.push_back(last_id - k - 1);
+ litIds.emplace_back(last_id - k - 1);
}
i = j;
- buckets.push_back(litIds);
+ buckets.emplace_back(litIds);
}
// reverse bucket id, longer literals come first
LitInfo & li = tmpLitInfo[i];
u32 hash = CONF_HASH_CALL(li.v, andmsk, mult, nBits);
DEBUG_PRINTF("%016llx --> %u\n", li.v, hash);
- res2lits[hash].push_back(i);
+ res2lits[hash].emplace_back(i);
gm |= li.groups;
}
if (contains(bucketToLits, b)) {
vector<hwlmLiteral> vl;
for (const LiteralIndex &lit_idx : bucketToLits.at(b)) {
- vl.push_back(lits[lit_idx]);
+ vl.emplace_back(lits[lit_idx]);
}
DEBUG_PRINTF("b %d sz %zu\n", b, vl.size());
nibbleSets[i * 2] = nibbleSets[i * 2 + 1] = 0xffff;
}
}
- litIds.push_back(lit_id);
+ litIds.emplace_back(lit_id);
sort_and_unique(litIds);
}
u8 *rtable_base, const u32 num_tables) {
vector<u8 *> tables;
for (u32 i = 0; i < num_tables; i++) {
- tables.push_back(rtable_base + i * RTABLE_SIZE);
+ tables.emplace_back(rtable_base + i * RTABLE_SIZE);
}
for (auto t : tables) {
path append(const path &orig, const CharReach &cr, u32 new_dest) {
path p(new_dest);
p.reach = orig.reach;
- p.reach.push_back(cr);
+ p.reach.emplace_back(cr);
return p;
}
const dstate &s = rdfa.states[p.dest];
if (!p.reach.empty() && p.reach.back().none()) {
- out.push_back(p);
+ out.emplace_back(p);
return;
}
if (!s.reports.empty()) {
if (generates_callbacks(rdfa.kind)) {
- out.push_back(p);
+ out.emplace_back(p);
return;
} else {
path pp = append(p, CharReach(), p.dest);
- all[p.dest].push_back(pp);
- out.push_back(move(pp));
+ all[p.dest].emplace_back(pp);
+ out.emplace_back(move(pp));
}
}
if (!s.reports_eod.empty()) {
path pp = append(p, CharReach(), p.dest);
- all[p.dest].push_back(pp);
- out.push_back(move(pp));
+ all[p.dest].emplace_back(pp);
+ out.emplace_back(move(pp));
}
flat_map<u32, CharReach> dest;
DEBUG_PRINTF("----good: [%s] -> %u\n",
describeClasses(pp.reach).c_str(), pp.dest);
- all[e.first].push_back(pp);
- out.push_back(move(pp));
+ all[e.first].emplace_back(pp);
+ out.emplace_back(move(pp));
}
}
const vector<CharReach> rev_map = reverse_alpha_remapping(rdfa);
vector<path> paths{path(base)};
unordered_map<u32, vector<path>> all;
- all[base].push_back(path(base));
+ all[base].emplace_back(path(base));
for (u32 i = 0; i < len && paths.size() < PATHS_LIMIT; i++) {
vector<path> next_gen;
for (const auto &p : paths) {
vector<vector<CharReach>> rv;
rv.reserve(paths.size());
for (auto &p : paths) {
- rv.push_back(vector<CharReach>(std::make_move_iterator(p.reach.begin()),
+ rv.emplace_back(vector<CharReach>(std::make_move_iterator(p.reach.begin()),
std::make_move_iterator(p.reach.end())));
}
return rv;
DEBUG_PRINTF(" %hu is in region\n", t);
region.insert(t);
- pending.push_back(t);
+ pending.emplace_back(t);
}
}
// find neighbors for cv
for (const auto &v : adjacent_vertices_range(cv, g)) {
if (g[v].stateId != id && contains(group, g[v].stateId)) {
- neighbor.push_back(g[v].stateId);
+ neighbor.emplace_back(g[v].stateId);
DEBUG_PRINTF("Neighbor:%u\n", g[v].stateId);
}
}
vector<u32> init;
for (const auto &v : vertices_range(cg)) {
vertexMap[cg[v].stateId] = v;
- init.push_back(cg[v].stateId);
+ init.emplace_back(cg[v].stateId);
}
gStack.push(init);
// Choose a vertex from the graph
u32 id = g[0];
const CliqueVertex &n = vertexMap.at(id);
- clique.push_back(id);
+ clique.emplace_back(id);
// Corresponding vertex in the original graph
vector<u32> neighbor;
set<u32> subgraphId(g.begin(), g.end());
vector<CliqueVertex> dead;
for (const auto &v : vertices_range(cg)) {
if (find(c.begin(), c.end(), cg[v].stateId) != c.end()) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
for (const auto &v : dead) {
}
vector<u32> clique;
findCliqueGroup(cg, clique);
- cliquesVec.push_back(clique);
+ cliquesVec.emplace_back(clique);
}
// get the independent set with max size
// get min reset distance for each repeat
for (size_t i = lower; i < upper; i++) {
CliqueVertex v = add_vertex(CliqueVertexProps(i), *cg);
- vertices.push_back(v);
+ vertices.emplace_back(v);
const vector<size_t> &tmp_dist =
minResetDistToEnd(triggers[i], cr);
- min_reset_dist.push_back(tmp_dist);
+ min_reset_dist.emplace_back(tmp_dist);
}
// find exclusive pair for each repeat
auto clique = removeClique(*cg);
size_t cliqueSize = clique.size();
if (cliqueSize > 1) {
- groups.push_back(clique);
+ groups.emplace_back(clique);
exclusive = EXCLUSIVE;
total += cliqueSize;
}
}
if (pr.bounds.max.is_finite()) {
- may_stale.push_back(i);
+ may_stale.emplace_back(i);
}
info.type = verify_u8(rtype);
if (rtype == REPEAT_SPARSE_OPTIMAL_P) {
for (u32 j = 0; j < rsi.patchSize; j++) {
- tables.push_back(rsi.table[j]);
+ tables.emplace_back(rsi.table[j]);
}
sparseRepeats++;
patchSize[i] = rsi.patchSize;
is_reset = true;
}
- repeatInfoPair.push_back(make_pair(min_period, is_reset));
+ repeatInfoPair.emplace_back(make_pair(min_period, is_reset));
- candidateTriggers.push_back(triggers.at(top));
- candidateRepeats.push_back(i);
+ candidateTriggers.emplace_back(triggers.at(top));
+ candidateRepeats.emplace_back(i);
}
// Case 1: exclusive repeats
for (size_t i = 0; i < states.size(); i++) { // i is the previous state
for (size_t sym = 0; sym < alpha_size; sym++) {
dstate_id_t present_state = rdfa.states[i].next[sym];
- states[present_state].prev[sym].push_back(i);
+ states[present_state].prev[sym].emplace_back(i);
}
}
}
new_states.reserve(num_partitions);
for (const auto &m : ordering) {
- new_states.push_back(rdfa.states[m.first]);
+ new_states.emplace_back(rdfa.states[m.first]);
}
rdfa.states = std::move(new_states);
}
} else {
var = joins_at_s.at(sr.slot);
}
- reports_out->push_back(make_pair(sr.report, var));
+ reports_out->emplace_back(make_pair(sr.report, var));
}
}
shared_ptr<GoughSSAVarNew> vnew;
if (slot_id == trigger_slot) {
vnew = make_shared<GoughSSAVarNew>(0U);
- cfg[e].vars.push_back(vnew);
+ cfg[e].vars.emplace_back(vnew);
} else {
assert(contains(src_slots, slot_id));
}
assert(contains(src_slots, slot_id));
shared_ptr<GoughSSAVarMin> vmin = make_shared<GoughSSAVarMin>();
- cfg[e].vars.push_back(vmin);
+ cfg[e].vars.emplace_back(vmin);
final_var = vmin.get();
DEBUG_PRINTF("slot %u gets a new value\n", slot_id);
vnew = vnew_by_adj[adjust];
} else {
vnew = make_shared<GoughSSAVarNew>(adjust);
- cfg[e].vars.push_back(vnew);
+ cfg[e].vars.emplace_back(vnew);
vnew_by_adj[adjust] = vnew;
}
assert(vnew);
DEBUG_PRINTF("bypassing min on join %u\n", slot_id);
} else {
shared_ptr<GoughSSAVarMin> vmin = make_shared<GoughSSAVarMin>();
- cfg[e].vars.push_back(vmin);
+ cfg[e].vars.emplace_back(vmin);
final_var = vmin.get();
if (vnew) {
u32 min_state = !is_triggered(raw.kind);
if (min_state) {
- vertices.push_back(GoughGraph::null_vertex()); /* skip dead state */
+ vertices.emplace_back(GoughGraph::null_vertex()); /* skip dead state */
}
vector<flat_map<u32, GoughSSAVarJoin *> > joins(raw.states.size());
for (u32 i = min_state; i < raw.states.size(); ++i) {
GoughVertex v = add_vertex(GoughVertexProps(i), *cfg);
- vertices.push_back(v);
+ vertices.emplace_back(v);
/* create JOIN variables */
for (som_tran_info::const_iterator it = raw.state_som[i].preds.begin();
u32 slot_id = it->first;
if (!contains(raw.new_som_nfa_states, slot_id)
|| raw.new_som_nfa_states.at(slot_id)) {
- (*cfg)[v].vars.push_back(make_shared<GoughSSAVarJoin>());
+ (*cfg)[v].vars.emplace_back(make_shared<GoughSSAVarJoin>());
joins[get(vertex_index, *cfg, v)][slot_id]
= (*cfg)[v].vars.back().get();
DEBUG_PRINTF("dfa %u:: slot %u\n", i, slot_id);
continue;
}
var->seen = true;
- queue->push_back(var);
+ queue->emplace_back(var);
}
}
continue;
}
var->seen = true;
- queue.push_back(var);
+ queue.emplace_back(var);
}
}
void GoughSSAVarNew::generate(vector<gough_ins> *out) const {
assert(slot != INVALID_SLOT);
- out->push_back(make_gough_ins(GOUGH_INS_NEW, slot, adjust));
+ out->emplace_back(make_gough_ins(GOUGH_INS_NEW, slot, adjust));
}
#ifndef NDEBUG
/* if the destination is one of the sources, no need to move it */
first = false;
} else {
- input_slots.push_back(var->slot);
+ input_slots.emplace_back(var->slot);
}
}
for (const u32 &input_slot : input_slots) {
if (first) {
- out->push_back(make_gough_ins(GOUGH_INS_MOV, slot, input_slot));
+ out->emplace_back(make_gough_ins(GOUGH_INS_MOV, slot, input_slot));
first = false;
} else {
- out->push_back(make_gough_ins(GOUGH_INS_MIN, slot, input_slot));
+ out->emplace_back(make_gough_ins(GOUGH_INS_MIN, slot, input_slot));
}
}
}
/* value of destination slot is not used by any remaining joins;
* we can output this join immediately */
DEBUG_PRINTF("out %u<-%u\n", dest, src);
- out->push_back(make_gough_ins(GOUGH_INS_MOV, dest, src));
+ out->emplace_back(make_gough_ins(GOUGH_INS_MOV, dest, src));
eji.erase(src, dest);
/* stash the initial value of the split register in a temp register */
u32 temp = base_temp_slot++;
DEBUG_PRINTF("out %u<-%u\n", temp, split);
- out->push_back(make_gough_ins(GOUGH_INS_MOV, temp, split));
+ out->emplace_back(make_gough_ins(GOUGH_INS_MOV, temp, split));
eji.remap_src(split, temp); /* update maps */
/* split can now be safely written out to as all the uses of it as an
* input now refer to temp instead */
DEBUG_PRINTF("out %u<-%u\n", split, input_for_split);
- out->push_back(make_gough_ins(GOUGH_INS_MOV, split, input_for_split));
+ out->emplace_back(make_gough_ins(GOUGH_INS_MOV, split, input_for_split));
eji.erase(input_for_split, split);
/* handle any uncovered simple cases */
for (vector<gough_ins> &ins_list : *blocks | map_values) {
assert(!ins_list.empty());
- ins_list.push_back(make_gough_ins(GOUGH_INS_END));
+ ins_list.emplace_back(make_gough_ins(GOUGH_INS_END));
}
}
DEBUG_PRINTF("i = %zu [%zu]\n", reports.size(), gg[v].reports.size());
if (v == GoughGraph::null_vertex() || gg[v].reports.empty()) {
- reports.push_back(MO_INVALID_IDX);
+ reports.emplace_back(MO_INVALID_IDX);
continue;
}
raw_gough_report_list rrl(gg[v].reports, rm, remap_reports);
DEBUG_PRINTF("non empty r %zu\n", reports.size());
if (rev.find(rrl) != rev.end()) {
- reports.push_back(rev[rrl]);
+ reports.emplace_back(rev[rrl]);
} else {
DEBUG_PRINTF("adding to rl\n");
rev[rrl] = ri->size();
- reports.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
}
for (auto v : verts) {
if (v == GoughGraph::null_vertex() || gg[v].reports_eod.empty()) {
- reports_eod.push_back(MO_INVALID_IDX);
+ reports_eod.emplace_back(MO_INVALID_IDX);
continue;
}
DEBUG_PRINTF("non empty r eod\n");
raw_gough_report_list rrl(gg[v].reports_eod, rm, remap_reports);
if (rev.find(rrl) != rev.end()) {
- reports_eod.push_back(rev[rrl]);
+ reports_eod.emplace_back(rev[rrl]);
continue;
}
DEBUG_PRINTF("adding to rl eod %zu\n", gg[v].reports_eod.size());
rev[rrl] = ri->size();
- reports_eod.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports_eod.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
/* TODO: support single report in gough */
void raw_gough_report_info_impl::fillReportLists(NFA *n, size_t base_offset,
vector<u32> &ro) const {
for (const raw_gough_report_list &r : rl) {
- ro.push_back(base_offset);
+ ro.emplace_back(base_offset);
gough_report_list *p = (gough_report_list *)((char *)n + base_offset);
u32 i = 0;
fprintf(f, "\tuses:");
vector<u32> used_id;
for (const GoughSSAVar *var : used) {
- used_id.push_back(var->slot);
+ used_id.emplace_back(var->slot);
}
for (const u32 &id : used_id) {
fprintf(f, " %u", id);
fprintf(f, "\tuses:");
vector<u32> used_id;
for (const GoughSSAVar *var : used) {
- used_id.push_back(var->slot);
+ used_id.emplace_back(var->slot);
}
for (const u32 &id : used_id) {
fprintf(f, " %u", id);
const GoughSSAVar *vp = g[v].vars[i].get();
stringstream ss;
ss << dump_name(g[v]) << "_" << i;
- vars->push_back(vp);
+ vars->emplace_back(vp);
names->insert(make_pair(vp, ss.str()));
src_label->insert(make_pair(vp, dump_name(g[v])));
}
const GoughSSAVar *vp = g[e].vars[i].get();
stringstream ss;
ss << dump_name(g, e) << "_" << i;
- vars->push_back(vp);
+ vars->emplace_back(vp);
names->insert(make_pair(vp, ss.str()));
src_label->insert(make_pair(vp, dump_name(g, e)));
}
namespace ue2 {
template<typename VarP, typename VarQ>
-void push_back_all_raw(vector<VarP> *out, const vector<VarQ> &in) {
+void emplace_back_all_raw(vector<VarP> *out, const vector<VarQ> &in) {
for (const auto &var : in) {
- out->push_back(var.get());
+ out->emplace_back(var.get());
}
}
static
void all_vars(const GoughGraph &g, vector<GoughSSAVar *> *out) {
for (auto v : vertices_range(g)) {
- push_back_all_raw(out, g[v].vars);
+ emplace_back_all_raw(out, g[v].vars);
}
for (const auto &e : edges_range(g)) {
- push_back_all_raw(out, g[e].vars);
+ emplace_back_all_raw(out, g[e].vars);
}
}
void add_to_dom_ordering(const vector<VarP> &vars,
vector<GoughSSAVar *> *out) {
for (const auto &var : vars) {
- out->push_back(var.get());
+ out->emplace_back(var.get());
}
}
public:
explicit FinishVisitor(vector<GoughVertex> *o) : out(o) {}
void finish_vertex(const GoughVertex v, const GoughGraph &) {
- out->push_back(v);
+ out->emplace_back(v);
}
vector<GoughVertex> *out;
};
verts.reserve(args.num_states);
for (auto v : vertices_range(h)) {
if (state_ids.at(v) != NO_STATE) {
- verts.push_back(v);
+ verts.emplace_back(v);
}
}
u8 num = 0;
for (auto mi = mapping.begin(), me = mapping.end(); mi != me; ++mi, ++num) {
// Reach entry.
- reach.push_back(mi->first);
+ reach.emplace_back(mi->first);
// Character mapping.
const CharReach &cr = mi->second;
DEBUG_PRINTF("state %u is accelerable\n", bi.state_ids.at(v));
AccelBuild a;
findStopLiterals(bi, v, a);
- accelStates.push_back(a);
+ accelStates.emplace_back(a);
}
// AccelStates should be sorted by state number, so that we build our accel
for (const auto &vv : tops | map_values) {
for (NFAVertex v : vv) {
if (!edge(g.start, v, g).second) {
- tempEdges.push_back(add_edge(g.start, v, g).first);
+ tempEdges.emplace_back(add_edge(g.start, v, g).first);
}
}
}
// Similarly, connect (start, startDs) if necessary.
if (!edge(g.start, g.startDs, g).second) {
NFAEdge e = add_edge(g.start, g.startDs, g);
- tempEdges.push_back(e); // Remove edge later.
+ tempEdges.emplace_back(e); // Remove edge later.
}
unordered_map<NFAVertex, AccelScheme> out;
vector<NFAVertex> astates;
for (const auto &m : accel_map) {
- astates.push_back(m.first);
+ astates.emplace_back(m.first);
}
NFAStateSet useful(num_states);
for (u32 j = 0, j_end = astates.size(); j < j_end; j++) {
if (i & (1U << j)) {
NFAVertex v = astates[j];
- states.push_back(v);
+ states.emplace_back(v);
state_set.set(state_ids.at(v));
}
}
// bits in accelStates.
vector<AccelBuild> accelOuts(accelCount);
vector<u32> effective_accel_set;
- effective_accel_set.push_back(0); /* empty is effectively empty */
+ effective_accel_set.emplace_back(0); /* empty is effectively empty */
for (u32 i = 1; i < accelCount; i++) {
u32 effective_i = getEffectiveAccelStates(args, dom_map, i,
accelStates);
- effective_accel_set.push_back(effective_i);
+ effective_accel_set.emplace_back(effective_i);
if (effective_i == IMPOSSIBLE_ACCEL_MASK) {
DEBUG_PRINTF("this combination of accel states is not possible\n");
// an index.
// Start with the NONE case.
- auxvec.push_back(AccelAux());
+ auxvec.emplace_back(AccelAux());
memset(&auxvec[0], 0, sizeof(AccelAux));
auxvec[0].accel_type = ACCEL_NONE; // no states on.
auto it = find_if(auxvec.begin(), auxvec.end(), AccelAuxCmp(aux));
if (it == auxvec.end()) {
accelTable[i] = verify_u8(auxvec.size());
- auxvec.push_back(aux);
+ auxvec.emplace_back(aux);
} else {
accelTable[i] = verify_u8(it - auxvec.begin());
}
return verify_u32(std::distance(squash.begin(), it));
}
u32 idx = verify_u32(squash.size());
- squash.push_back(sit->second);
+ squash.emplace_back(sit->second);
return idx;
}
assert(!r.empty());
vector<ReportID> my_reports(begin(r), end(r));
- my_reports.push_back(MO_INVALID_IDX); // sentinel
+ my_reports.emplace_back(MO_INVALID_IDX); // sentinel
auto cache_it = reports_cache.find(my_reports);
if (cache_it != end(reports_cache)) {
a.reports = addReports(h[v].reports, reports, reports_cache);
}
a.squash = addSquashMask(args, v, squash);
- accepts.push_back(move(a));
+ accepts.emplace_back(move(a));
}
}
if (edge(v, h.accept, h).second) {
acceptMask.set(state_id);
- verts_accept.push_back(v);
+ verts_accept.emplace_back(v);
} else {
assert(edge(v, h.acceptEod, h).second);
acceptEodMask.set(state_id);
- verts_accept_eod.push_back(v);
+ verts_accept_eod.emplace_back(v);
}
}
// of states.
assert(e.succ_states.size() == num_states);
assert(e.squash_states.size() == num_states);
- exceptionMap[e].push_back(i);
+ exceptionMap[e].emplace_back(i);
exceptionCount++;
}
}
unordered_set<NFAVertex> visited;
for (const auto &m : args.tops) {
for (NFAVertex v : m.second) {
- cur.push_back(v);
+ cur.emplace_back(v);
visited.insert(v);
}
}
continue;
}
if (!contains(visited, w)) {
- next.push_back(w);
+ next.emplace_back(w);
visited.insert(w);
}
}
void setupReach(const u8 *reachMap, const u8 *reachBase, u32 size,
u32 state_count, vector<CharReach> *perStateReach) {
for (u32 i = 0; i < state_count; i++) {
- perStateReach->push_back(CharReach());
+ perStateReach->emplace_back(CharReach());
for (u32 j = 0; j < N_CHARS; j++) {
u8 k = reachMap[j];
const u8 *r = reachBase + k * (size/8);
for (size_t i = 0; i < states.size(); i++) {
for (symbol_t sym = 0; sym < impl_alpha_size; sym++) {
dstate_id_t curr = rdfa.states[i].next[sym];
- states[curr].prev_vec[sym].push_back(i);
+ states[curr].prev_vec[sym].emplace_back(i);
}
if (!rdfa.states[i].reports.empty()
|| !rdfa.states[i].reports_eod.empty()) {
for (const dstate &s : rdfa.states) {
if (s.reports.empty()) {
- reports.push_back(MO_INVALID_IDX);
+ reports.emplace_back(MO_INVALID_IDX);
continue;
}
DEBUG_PRINTF("non empty r\n");
auto it = rev.find(rrl);
if (it != rev.end()) {
- reports.push_back(it->second);
+ reports.emplace_back(it->second);
} else {
DEBUG_PRINTF("adding to rl %zu\n", ri->size());
rev.emplace(rrl, ri->size());
- reports.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
}
for (const dstate &s : rdfa.states) {
if (s.reports_eod.empty()) {
- reports_eod.push_back(MO_INVALID_IDX);
+ reports_eod.emplace_back(MO_INVALID_IDX);
continue;
}
raw_report_list rrl(s.reports_eod, rm, remap_reports);
auto it = rev.find(rrl);
if (it != rev.end()) {
- reports_eod.push_back(it->second);
+ reports_eod.emplace_back(it->second);
continue;
}
DEBUG_PRINTF("adding to rl eod %zu\n", s.reports_eod.size());
rev.emplace(rrl, ri->size());
- reports_eod.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports_eod.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
assert(!ri->rl.empty()); /* all components should be able to generate
void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset,
vector<u32> &ro) const {
for (const auto &reps : rl) {
- ro.push_back(base_offset);
+ ro.emplace_back(base_offset);
report_list *p = (report_list *)((char *)n + base_offset);
for (u32 i = 1; i < info.size(); i++) {
if (info.is_widehead(i)) {
- wideHead.push_back(i);
+ wideHead.emplace_back(i);
} else if (info.is_widestate(i)) {
- wideState.push_back(i);
+ wideState.emplace_back(i);
} else if (info.is_sherman(i)) {
- sherm.push_back(i);
+ sherm.emplace_back(i);
} else {
- norm.push_back(i);
+ norm.emplace_back(i);
}
}
for (u32 i = 1; i < info.size(); i++) {
if (!info.states[i].reports.empty()) {
- accept.push_back(i);
+ accept.emplace_back(i);
} else if (contains(accel_escape_info, i)) {
- accel.push_back(i);
+ accel.emplace_back(i);
} else {
- norm.push_back(i);
+ norm.emplace_back(i);
}
}
const symbol_t curr_sym,
vector<dstate_id_t> &temp_chain) {
//Record current id first.
- temp_chain.push_back(curr_id);
+ temp_chain.emplace_back(curr_id);
const u16 size = info.impl_alpha_size;
DEBUG_PRINTF("This is a new chain!\n");
// Add this new chain and get it marked.
- candidate_chain.push_back(temp_chain);
+ candidate_chain.emplace_back(temp_chain);
for (auto &id : temp_chain) {
DEBUG_PRINTF("(Marking s%u ...)\n", id);
// The tail symbol comes from vector chain_tail;
if (j == width - 1) {
- symbol_chain.push_back(chain_tail[i]);
+ symbol_chain.emplace_back(chain_tail[i]);
} else {
for (symbol_t sym = 0; sym < info.impl_alpha_size; sym++) {
if (rdfa.states[curr_id].next[sym] == next_id) {
- symbol_chain.push_back(sym);
+ symbol_chain.emplace_back(sym);
break;
}
}
}
}
- info.wide_symbol_chain.push_back(symbol_chain);
+ info.wide_symbol_chain.emplace_back(symbol_chain);
}
}
}
reverse(temp_chain.begin(), temp_chain.end());
- temp_chain.push_back(curr_id);
+ temp_chain.emplace_back(curr_id);
assert(head > 0 && head == temp_chain.front());
if (store_chain_longest(info.wide_state_chain, temp_chain,
added, head_is_new)) {
- chain_tail.push_back(sym);
+ chain_tail.emplace_back(sym);
}
}
}
continue;
}
if (dist[t] == ~0U) {
- to_visit.push_back(t);
+ to_visit.emplace_back(t);
dist[t] = d + 1;
} else {
assert(dist[t] <= d + 1);
continue; /* sheng impl ids have already been allocated */
} if (info.is_sherman(i)) {
if (info.is_sheng_succ(i)) {
- sherm_sheng_succ.push_back(i);
+ sherm_sheng_succ.emplace_back(i);
} else {
- sherm.push_back(i);
+ sherm.emplace_back(i);
}
} else {
if (info.is_sheng_succ(i)) {
- norm_sheng_succ.push_back(i);
+ norm_sheng_succ.emplace_back(i);
} else {
- norm.push_back(i);
+ norm.emplace_back(i);
}
}
}
sheng_states.insert(v);
for (const auto &t : adjacent_vertices_range(v, g)) {
if (!contains(considered, g[t].index)) {
- to_consider.push_back(t);
+ to_consider.emplace_back(t);
}
if (t == base_cyclic) {
seen_back_edge = true;
if (info.is_sheng(i)) {
continue; /* already allocated */
} else if (!info.states[i].reports.empty()) {
- accept.push_back(i);
+ accept.emplace_back(i);
} else if (contains(accel_escape_info, i)) {
- accel.push_back(i);
+ accel.emplace_back(i);
} else {
- norm.push_back(i);
+ norm.emplace_back(i);
}
}
u32 e = MQE_TOP_FIRST;
for (const auto &puff : triggered_puffs) {
- puff_clusters[ClusterKey(e, puff)].push_back(puff);
+ puff_clusters[ClusterKey(e, puff)].emplace_back(puff);
e++;
}
for (const auto &puff : puffs_in) {
- puff_clusters[ClusterKey(puff)].push_back(puff);
+ puff_clusters[ClusterKey(puff)].emplace_back(puff);
}
assert(it->first.trigger_event
== MQE_TOP_FIRST + distance(kilopuffs.begin(), it));
- out->push_back(mpv_counter_info());
+ out->emplace_back(mpv_counter_info());
map<ClusterKey, vector<raw_puff>>::const_iterator it_o = it;
++it;
fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset,
++it;
}
if (it != trig_ite) {
- out->push_back(mpv_counter_info());
+ out->emplace_back(mpv_counter_info());
fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset,
kilopuffs, kilopuffs.begin(), it);
}
while (it != kilopuffs.end() && it->first.auto_restart) {
assert(it->first.trigger_event == MQE_INVALID);
- out->push_back(mpv_counter_info());
+ out->emplace_back(mpv_counter_info());
map<ClusterKey, vector<raw_puff>>::const_iterator it_o = it;
++it;
fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset,
vector<RdfaGraph::vertex_descriptor> verts;
verts.reserve(rdfa.states.size());
for (dstate_id_t i = 0; i < rdfa.states.size(); i++) {
- verts.push_back(add_vertex(g));
+ verts.emplace_back(add_vertex(g));
assert(g[verts.back()].index == i);
}
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
- esets.push_back(t);
+ esets.emplace_back(t);
}
}
}
const vector<StateSet> initial() {
vector<StateSet> rv = {as};
if (start_floating != DEAD_STATE && start_floating != start_anchored) {
- rv.push_back(fs);
+ rv.emplace_back(fs);
}
return rv;
}
// Put the larger of the two DFAs on the output list, retain the
// smaller one on the queue for further merge attempts.
if (d2->states.size() > d1->states.size()) {
- dfas.push_back(move(d2));
+ dfas.emplace_back(move(d2));
q.push(move(d1));
} else {
- dfas.push_back(move(d1));
+ dfas.emplace_back(move(d1));
q.push(move(d2));
}
}
}
while (!q.empty()) {
- dfas.push_back(move(q.front()));
+ dfas.emplace_back(move(q.front()));
q.pop();
}
u32 repeatTmp = info->patchCount > 2 ? 64 : (u32)repeatMax;
u32 repeat_index = repeatTmp < minPeriod ? repeatTmp : minPeriod;
for (u32 i = 0; i <= repeat_index; i++) {
- info->table.push_back(i + 1);
+ info->table.emplace_back(i + 1);
}
for (u32 i = minPeriod + 1; i <= repeatTmp; i++) {
- info->table.push_back(info->table[i - 1] + info->table[i - minPeriod]);
+ info->table.emplace_back(info->table[i - 1] + info->table[i - minPeriod]);
if (info->table[i] < info->table[i - 1]) {
return i - 1;
}
break;
}
}
- out.push_back(i);
+ out.emplace_back(i);
}
return out;
void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset,
vector<u32> &ro) const {
for (const auto &reps : rl) {
- ro.push_back(base_offset);
+ ro.emplace_back(base_offset);
report_list *p = (report_list *)((char *)n + base_offset);
for (const dstate &s : rdfa.states) {
if (s.reports.empty()) {
- reports.push_back(MO_INVALID_IDX);
+ reports.emplace_back(MO_INVALID_IDX);
continue;
}
raw_report_list rrl(s.reports, rm, remap_reports);
DEBUG_PRINTF("non empty r\n");
if (rev.find(rrl) != rev.end()) {
- reports.push_back(rev[rrl]);
+ reports.emplace_back(rev[rrl]);
} else {
DEBUG_PRINTF("adding to rl %zu\n", ri->size());
rev[rrl] = ri->size();
- reports.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
}
for (const dstate &s : rdfa.states) {
if (s.reports_eod.empty()) {
- reports_eod.push_back(MO_INVALID_IDX);
+ reports_eod.emplace_back(MO_INVALID_IDX);
continue;
}
DEBUG_PRINTF("non empty r eod\n");
raw_report_list rrl(s.reports_eod, rm, remap_reports);
if (rev.find(rrl) != rev.end()) {
- reports_eod.push_back(rev[rrl]);
+ reports_eod.emplace_back(rev[rrl]);
continue;
}
DEBUG_PRINTF("adding to rl eod %zu\n", s.reports_eod.size());
rev[rrl] = ri->size();
- reports_eod.push_back(ri->size());
- ri->rl.push_back(rrl);
+ reports_eod.emplace_back(ri->size());
+ ri->rl.emplace_back(rrl);
}
assert(!ri->rl.empty()); /* all components should be able to generate
}
nibble_masks.clear();
for (const auto &e : new_masks) {
- nibble_masks.push_back(e.second);
+ nibble_masks.emplace_back(e.second);
}
}
u32 cur = 0;
for (const auto &sub : tamaInfo.subengines) {
u32 base = cur;
- top_base.push_back(base + MQE_TOP_FIRST);
+ top_base.emplace_back(base + MQE_TOP_FIRST);
DEBUG_PRINTF("subengine:%u\n", i);
for (const auto &t : tamaInfo.tops[i++]) {
cur = base + t;
void TamaInfo::add(NFA *sub, const set<u32> &top) {
assert(subengines.size() < max_occupancy);
- subengines.push_back(sub);
- tops.push_back(top);
+ subengines.emplace_back(sub);
+ tops.emplace_back(top);
}
void TamaProto::add(const NFA *n, const u32 id, const u32 top,
vector<NFAEdge> out;
for (const auto &e : edges_range(g)) {
if (g[e].assert_flags) {
- out.push_back(e);
+ out.emplace_back(e);
}
}
return out;
(is_special(v, g) || contains(tail_shell, v))) {
DEBUG_PRINTF("edge (%zu,%zu) is a shell edge\n", g[u].index,
g[v].index);
- shell_edges.push_back(e);
+ shell_edges.emplace_back(e);
}
}
if (head_shell.size() + tail_shell.size() + N_SPECIALS >=
num_vertices(*g)) {
DEBUG_PRINTF("all in shell component\n");
- comps.push_back(std::move(g));
+ comps.emplace_back(std::move(g));
*shell_comp = true;
return;
}
// into the tail shell, we aren't going to find more than one component.
if (shell_edges.empty() && shellHasOnePath(*g, head_shell, tail_shell)) {
DEBUG_PRINTF("single component\n");
- comps.push_back(std::move(g));
+ comps.emplace_back(std::move(g));
return;
}
assert(num > 0);
if (num == 1 && shell_edges.empty()) {
DEBUG_PRINTF("single component\n");
- comps.push_back(std::move(g));
+ comps.emplace_back(std::move(g));
return;
}
for (const auto &m : split_components) {
NFAVertex v = m.first;
u32 c = m.second;
- verts[c].push_back(v);
+ verts[c].emplace_back(v);
DEBUG_PRINTF("vertex %zu is in comp %u\n", (*g)[v].index, c);
}
pruneUseless(*gc);
DEBUG_PRINTF("component %zu has %zu vertices\n", comps.size(),
num_vertices(*gc));
- comps.push_back(move(gc));
+ comps.emplace_back(move(gc));
}
// Another component to handle the direct shell-to-shell edges.
pruneUseless(*gc);
DEBUG_PRINTF("shell edge component %zu has %zu vertices\n",
comps.size(), num_vertices(*gc));
- comps.push_back(move(gc));
+ comps.emplace_back(move(gc));
*shell_comp = true;
}
// For trivial cases, we needn't bother running the full
// connected_components algorithm.
if (!grey.calcComponents || isAlternationOfClasses(*g)) {
- comps.push_back(std::move(g));
+ comps.emplace_back(std::move(g));
return comps;
}
}
if (isAlternationOfClasses(*gc)) {
- out.push_back(std::move(gc));
+ out.emplace_back(std::move(gc));
continue;
}
continue;
}
DEBUG_PRINTF("removing %zu->%zu\n", g[u].index, g[v].index);
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
for (const auto &e : in_edges_range(v, g)) {
if (!is_any_start(source(e, g), g)) {
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
}
// unique push
void push(unsigned id) {
if (ids.insert(id).second) {
- q.push_back(id);
+ q.emplace_back(id);
}
}
vertex_map.resize(num_verts);
for (auto v : vertices_range(g)) {
- infos.push_back(make_unique<VertexInfo>(v, g));
+ infos.emplace_back(make_unique<VertexInfo>(v, g));
vertex_map[g[v].index] = infos.back().get();
}
classes[cur_class].erase(vi);
new_class_vertices.insert(vi);
}
- classes.push_back(move(new_class_vertices));
+ classes.emplace_back(move(new_class_vertices));
if (contains(tmi->first, cur_class)) {
reval_queue.push(new_class);
g[new_v].reports.clear(); /* populated as we pull in succs */
// store this vertex in our global vertex list
- infos.push_back(make_unique<VertexInfo>(new_v, g));
+ infos.emplace_back(make_unique<VertexInfo>(new_v, g));
VertexInfo *new_vertex_info = infos.back().get();
NFAVertex new_v_eod = NGHolder::null_vertex();
if (require_separate_eod_vertex(cur_class_vertices, g)) {
new_v_eod = clone_vertex(g, old_v);
g[new_v_eod].reports.clear();
- infos.push_back(make_unique<VertexInfo>(new_v_eod, g));
+ infos.emplace_back(make_unique<VertexInfo>(new_v_eod, g));
new_vertex_info_eod = infos.back().get();
}
for (auto v : adjacent_vertices_range(root, g)) {
if (g[v].assert_flags & POS_FLAG_VIRTUAL_START) {
DEBUG_PRINTF("(?m)^ vertex or leading \\[bB] vertex\n");
- victims.push_back(v);
+ victims.emplace_back(v);
}
}
if (v == g.startDs) {
continue;
}
- initials.push_back(v);
+ initials.emplace_back(v);
}
if (initials.empty()) {
DEBUG_PRINTF("no initial vertices\n");
if (u == cyclic) {
continue;
}
- preds.push_back(u);
+ preds.emplace_back(u);
// We want to delete the out-edges of each predecessor, but need to
// make sure we don't delete the startDs self loop.
for (const auto &e : out_edges_range(u, g)) {
if (target(e, g) != g.startDs) {
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
}
add_edge(u, v, g);
}
preds.clear();
- preds.push_back(v);
+ preds.emplace_back(v);
}
assert(!preds.empty());
for (auto u : preds) {
for (const auto &e : edges_range(g)) {
if (isEdgePrunable(g, report, depths, e)) {
DEBUG_PRINTF("pruning\n");
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
// a min_offset.
if (u == g.start && is_any_accept(v, g) && has_min_offset(u)) {
DEBUG_PRINTF("vacuous edge in graph with min_offset!\n");
- dead.push_back(e);
+ dead.emplace_back(e);
continue;
}
// If a min_length is set, vacuous edges can be removed.
if (is_any_start(u, g) && is_any_accept(v, g) && has_min_length(u)) {
DEBUG_PRINTF("vacuous edge in graph with min_length!\n");
- dead.push_back(e);
+ dead.emplace_back(e);
continue;
}
}
if (d.max.is_finite() && d.max < report.minLength) {
DEBUG_PRINTF("prune, max match length %s < min_length=%llu\n",
d.max.str().c_str(), report.minLength);
- dead.push_back(e);
+ dead.emplace_back(e);
continue;
}
if (report.maxOffset != MAX_OFFSET && d.min > report.maxOffset) {
DEBUG_PRINTF("prune, min match length %s > max_offset=%llu\n",
d.min.str().c_str(), report.maxOffset);
- dead.push_back(e);
+ dead.emplace_back(e);
continue;
}
}
return true;
}
- mask->push_back(g[v].char_reach);
+ mask->emplace_back(g[v].char_reach);
if (out_degree(v, g) != 1) {
DEBUG_PRINTF("out_degree != 1\n");
const vector<StateSet> initial() {
vector<StateSet> rv = {init};
if (start_floating != DEAD_STATE && start_floating != start_anchored) {
- rv.push_back(initDS);
+ rv.emplace_back(initDS);
}
return rv;
}
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
- esets.push_back(t);
+ esets.emplace_back(t);
}
}
}
const vector<StateSet> initial() {
vector<StateSet> rv(1, as);
if (start_floating != DEAD_STATE && start_floating != start_anchored) {
- rv.push_back(fs);
+ rv.emplace_back(fs);
}
return rv;
}
DEBUG_PRINTF("d vertex %zu\n", g[v].index);
vector<u32> &out_map = preds[slot_id];
for (auto u : inv_adjacent_vertices_range(v, g)) {
- out_map.push_back(g[u].index);
+ out_map.emplace_back(g[u].index);
}
sort(out_map.begin(), out_map.end());
rdfa->state_som.reserve(rdfa->states.size());
for (u32 i = 0; i < rdfa->states.size(); i++) {
- rdfa->state_som.push_back(dstate_som());
+ rdfa->state_som.emplace_back(dstate_som());
const StateSet &source_states = nfa_state_map[i];
if (source_states.count() > HAIG_MAX_LIVE_SOM_SLOTS) {
DEBUG_PRINTF("too many live states\n");
for (vector<u32>::const_iterator jt = it->second.begin();
jt != it->second.end(); ++jt) {
if (*jt < N_SPECIALS || *jt == CREATE_NEW_SOM) {
- out.push_back(*jt);
+ out.emplace_back(*jt);
} else {
- out.push_back(*jt + adj);
+ out.emplace_back(*jt + adj);
}
}
}
vector<u32> per_dfa_adj;
u32 curr_adj = 0;
for (const auto &haig : dfas) {
- per_dfa_adj.push_back(curr_adj);
+ per_dfa_adj.emplace_back(curr_adj);
curr_adj += total_slots_used(*haig);
if (curr_adj < per_dfa_adj.back()) {
/* overflowed our som slot count */
rdfa->state_som.reserve(rdfa->states.size());
for (u32 i = 0; i < rdfa->states.size(); i++) {
- rdfa->state_som.push_back(dstate_som());
+ rdfa->state_som.emplace_back(dstate_som());
const vector<dstate_id_t> &source_nfa_states = nfa_state_map[i];
DEBUG_PRINTF("finishing state %u\n", i);
vector<NFAVertex> cand_starts;
for (NFAVertex u : unhandled_succ_tops | map_keys) {
if (hasSelfLoop(u, g)) {
- cand_starts.push_back(u);
+ cand_starts.emplace_back(u);
}
}
if (e.second == NO_STATE) {
continue;
}
- ordering.push_back(e.first);
+ ordering.emplace_back(e.first);
}
// Sort in reverse order by state ID.
if (v == g.accept || v == g.acceptEod) {
paths->push_back({});
if (!generates_callbacks(g) || v == g.acceptEod) {
- paths->back().push_back(CharReach()); /* red tape options */
+ paths->back().emplace_back(CharReach()); /* red tape options */
}
return;
}
} while (new_depth-- && curr.size() >= MAGIC_TOO_WIDE_NUMBER);
for (auto &c : curr) {
- c.push_back(cr);
- paths->push_back(std::move(c));
+ c.emplace_back(cr);
+ paths->emplace_back(std::move(c));
}
}
}
DEBUG_PRINTF("worse\n");
continue;
}
- priority_path.push_back(move(as));
+ priority_path.emplace_back(move(as));
}
sort(priority_path.begin(), priority_path.end());
DEBUG_PRINTF("worse\n");
continue;
}
- priority_path.push_back(move(as));
+ priority_path.emplace_back(move(as));
}
sort(priority_path.begin(), priority_path.end());
fout << "[label=\"SINK\"];";
} else {
ue2_literal s;
- s.push_back(lg[v].c);
+ s.emplace_back(lg[v].c);
fout << "[label=\"" << dumpString(s) << "\"];";
}
fout << endl;
if (ucolor != small_color::white && vcolor == small_color::white) {
assert(v != lg.sink);
- white_cut.push_back(e);
+ white_cut.emplace_back(e);
white_flow += lg[e].score;
}
if (ucolor == small_color::black && vcolor != small_color::black) {
assert(v != lg.sink);
- black_cut.push_back(e);
+ black_cut.emplace_back(e);
black_flow += lg[e].score;
}
}
continue;
dont_explode:
make_nocase(&s);
- replacements.push_back(s);
+ replacements.emplace_back(s);
}
insert(&lits, replacements);
assert(read_count[g[u].index]);
for (const auto &p : built[g[u].index]) {
- out.push_back(p);
- out.back().push_back(v);
+ out.emplace_back(p);
+ out.back().emplace_back(v);
if (out.size() > MAX_PATHS) {
// All these paths should eventually end up at a sink, so
if (is_special(v, g)) {
continue;
}
- mask.push_back(g[v].char_reach);
+ mask.emplace_back(g[v].char_reach);
}
// Reports are attached to the second-to-last vertex.
DEBUG_PRINTF("failed validation\n");
return false;
}
- masks.push_back(move(pm));
+ masks.emplace_back(move(pm));
}
for (const auto &pm : masks) {
CharReach t = cr & esets[i];
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
- esets.push_back(t);
+ esets.emplace_back(t);
}
}
}
const vector<StateSet> initial() {
vector<StateSet> rv = {init};
if (start_floating != DEAD_STATE && start_floating != start_anchored) {
- rv.push_back(initDS);
+ rv.emplace_back(initDS);
}
return rv;
}
}
}
DEBUG_PRINTF("vertex %zu is a candidate\n", g[v].index);
- cand->push_back(v);
+ cand->emplace_back(v);
next_cand:;
}
}
}
}
DEBUG_PRINTF("vertex %zu is a candidate\n", g[v].index);
- cand->push_back(v);
+ cand->emplace_back(v);
next_cand:;
}
}
add_edge_if_not_present(g.startDs, t, g);
// mark this edge for removal
- deadEdges.push_back(e);
+ deadEdges.emplace_back(e);
}
// if the number of edges to be removed equals out degree, vertex
// needs to be removed; else, only remove the edges
* existing in progress matches. */
continue;
}
- u_succs.push_back(v);
+ u_succs.emplace_back(v);
}
stable_sort(u_succs.begin(), u_succs.end(),
DEBUG_PRINTF("found white cut edge %zu->%zu cap %llu\n",
h[from].index, h[to].index, ec);
observed_white_flow += ec;
- picked_white.push_back(e);
+ picked_white.emplace_back(e);
}
if (fromColor == small_color::black && toColor != small_color::black) {
assert(ec <= INVALID_EDGE_CAP);
DEBUG_PRINTF("found black cut edge %zu->%zu cap %llu\n",
h[from].index, h[to].index, ec);
observed_black_flow += ec;
- picked_black.push_back(e);
+ picked_black.emplace_back(e);
}
}
}
u32 id = region_map.at(v);
RegionInfo &ri = regions.emplace(id, RegionInfo(id)).first->second;
- ri.vertices.push_back(v);
+ ri.vertices.emplace_back(v);
ri.reach |= h[v].char_reach;
}
if (i > 0) {
add_edge(verts.back(), v, g);
}
- verts.push_back(v);
+ verts.emplace_back(v);
}
if (maxWidth.is_infinite()) {
// accept->acceptEod), so all non-specials are unreachable.
for (auto v : vertices_range(g)) {
if (!is_special(v, g)) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
} else {
continue;
}
if (!contains(colours, v)) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
}
if (!is_special(v, g) && get(colors, v) == small_color::white) {
DEBUG_PRINTF("vertex %zu is unreachable from %zu\n",
g[v].index, g[s].index);
- dead.push_back(NFAVertex(v));
+ dead.emplace_back(NFAVertex(v));
}
}
const CharReach &cr = g[v].char_reach;
if (cr.none()) {
DEBUG_PRINTF("empty: %zu\n", g[v].index);
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
// We can prune any out-edges that aren't accepts
for (const auto &e : out_edges_range(u, g)) {
if (!is_any_accept(target(e, g), g)) {
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
}
for (const auto &report_id : g[v].reports) {
const Report &r = rm.getReport(report_id);
if (isSimpleExhaustible(r)) {
- reporters.push_back(v);
+ reporters.emplace_back(v);
break;
}
}
for (const auto &report_id : g[v].reports) {
const Report &r = rm.getReport(report_id);
if (isSimpleExhaustible(r)) {
- reporters.push_back(v);
+ reporters.emplace_back(v);
break;
}
}
unbounded = true;
}
- nodes.push_back(a);
+ nodes.emplace_back(a);
DEBUG_PRINTF("vertex %zu has in_degree %zu\n", g[a].index,
in_degree(a, g));
if (a != g.startDs && edge(g.startDs, a, g).second
&& proper_out_degree(a, g) == 1
&& g[a].char_reach == cr) {
- nodes.push_back(a);
+ nodes.emplace_back(a);
a = g.startDs;
}
// Break out if we've reduced our intersection to [v]
if (best->size() == 1) {
assert(*(best->begin()) == v);
- intersection.push_back(v);
+ intersection.emplace_back(v);
return;
}
}
// Break out if we've reduced our intersection to [v]
if (best->size() == 1) {
assert(*(best->begin()) == v);
- intersection.push_back(v);
+ intersection.emplace_back(v);
return;
}
}
if (!open.empty()) {
DEBUG_PRINTF("exit %zu\n", g[v].index);
- exits.push_back(move(v_exit));
+ exits.emplace_back(move(v_exit));
}
}
}
u32 region = region_map.at(v);
if (contains(deadRegions, region)) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
}
u32 comp_id = rit->second;
assert(comp_id < num);
- rs[comp_id].vertices.push_back(v);
+ rs[comp_id].vertices.emplace_back(v);
}
for (const auto &rsi : rs) {
continue;
}
- verts.push_back(v);
+ verts.emplace_back(v);
}
if (recalc) {
splitSubgraph(g, verts, minNumVertices, q);
} else {
DEBUG_PRINTF("subgraph is ok\n");
- rs_out.push_back(rsi);
+ rs_out.emplace_back(rsi);
}
q.pop();
}
DEBUG_PRINTF("all preds in subgraph, vertex %zu becomes tug\n",
g[v].index);
add_edge(cyclic, v, g);
- tugs.push_back(v);
+ tugs.emplace_back(v);
return;
}
DEBUG_PRINTF("there are other paths, cloned tug %zu from vertex %zu\n",
g[t].index, g[v].index);
- tugs.push_back(t);
+ tugs.emplace_back(t);
add_edge(cyclic, t, g);
// New vertex gets all of v's successors, including v itself if it's
}
succs->clear();
- succs->push_back(d);
+ succs->emplace_back(d);
rsi.repeatMax -= 1;
if (v == last) { /* ignore self loop */
continue;
}
- succs->push_back(v);
+ succs->emplace_back(v);
}
}
remove_vertices(rsi.vertices, g, false);
erase_all(&depths, rsi.vertices);
- repeats->push_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin,
+ repeats->emplace_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin,
rsi.repeatMax, rsi.minPeriod, cyclic,
pos_trigger, tugs));
}
remove_vertices(rsi.vertices, g, false);
erase_all(&depths, rsi.vertices);
- repeats->push_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin,
+ repeats->emplace_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin,
rsi.repeatMax, rsi.minPeriod, cyclic,
pos_trigger, tugs));
}
}
u32 comp_id = rit->second;
assert(comp_id < num);
- rs[comp_id].vertices.push_back(v);
+ rs[comp_id].vertices.emplace_back(v);
}
#ifdef DEBUG
goto next_edge;
}
- starts_by_top[top].push_back(v);
+ starts_by_top[top].emplace_back(v);
}
- dead.push_back(e);
+ dead.emplace_back(e);
next_edge:;
}
}
v = next;
- straw.push_back(v);
+ straw.emplace_back(v);
}
straw.clear();
if (contains(curr, g.start)) {
DEBUG_PRINTF("start in repeat's immediate preds\n");
- trigger.push_back(CharReach::dot()); // Trigger could be anything!
+ trigger.emplace_back(CharReach::dot()); // Trigger could be anything!
return trigger;
}
for (size_t num_steps = 0; num_steps < MAX_TRIGGER_STEPS; num_steps++) {
next.clear();
- trigger.push_back(CharReach());
+ trigger.emplace_back(CharReach());
CharReach &cr = trigger.back();
for (auto v_c : curr) {
triggers.push_back({}); // empty
return triggers;
}
- q.push_back(Path(1, u));
+ q.emplace_back(Path(1, u));
}
while (!q.empty()) {
if (path.size() >= max_len) {
max_len = min(max_len, path.size());
- done.push_back(path);
+ done.emplace_back(path);
goto next_path;
}
// Found an accept. There's no point expanding this path any
// further, we're done.
max_len = min(max_len, path.size());
- done.push_back(path);
+ done.emplace_back(path);
goto next_path;
}
if (path.size() + 1 >= max_len) {
- done.push_back(path);
- done.back().push_back(u);
+ done.emplace_back(path);
+ done.back().emplace_back(u);
} else {
- q.push_back(path); // copy
- q.back().push_back(u);
+ q.emplace_back(path); // copy
+ q.back().emplace_back(u);
}
}
if (q.size() + done.size() > UNIONED_FALLBACK_THRESHOLD) {
DEBUG_PRINTF("search too large, fall back to union trigger\n");
triggers.clear();
- triggers.push_back(getUnionedTrigger(g, sink));
+ triggers.emplace_back(getUnionedTrigger(g, sink));
return triggers;
}
}
for (const auto &path : done) {
vector<CharReach> reach_path;
for (auto jt = path.rbegin(), jte = path.rend(); jt != jte; ++jt) {
- reach_path.push_back(g[*jt].char_reach);
+ reach_path.emplace_back(g[*jt].char_reach);
}
unique_triggers.insert(reach_path);
}
if (!own_straw.empty()) {
add_edge(own_straw.back(), v2, g);
}
- own_straw.push_back(v2);
+ own_straw.emplace_back(v2);
}
// Wire our straw to start, not startDs.
repeatMax = depth::infinity(); /* will continue to pump out matches */
}
- repeats_out->push_back(GraphRepeatInfo());
+ repeats_out->emplace_back(GraphRepeatInfo());
GraphRepeatInfo &ri = repeats_out->back();
ri.vertices.swap(rsi.vertices);
ri.repeatMin = rsi.repeatMin;
assert(!isLeafNode(v, g));
const NFAEdge &e = add_edge(g.start, v, g);
- tempEdges.push_back(e);
+ tempEdges.emplace_back(e);
}
}
temp.erase(remove(temp.begin(), temp.end(), g.startDs));
temp.erase(remove(temp.begin(), temp.end(), g.start));
if (proper_out_degree(g.startDs, g)) {
- temp.push_back(g.startDs);
+ temp.emplace_back(g.startDs);
}
if (!startIsRedundant(g)) {
- temp.push_back(g.start);
+ temp.emplace_back(g.start);
}
// Walk ordering, remove vertices that shouldn't be participating in state
continue; // accepts don't need states
}
- ordering.push_back(v);
+ ordering.emplace_back(v);
}
// Output of topo order was in reverse.
continue;
}
if (edge(t, v, g).second && find(start, it, t) != ite) {
- candidates.push_back(make_pair(v, t));
+ candidates.emplace_back(make_pair(v, t));
}
}
}
}
if (isRegionEntry(g, v, regions)) {
- info[region].enters.push_back(v);
+ info[region].enters.emplace_back(v);
}
if (isRegionExit(g, v, regions)) {
- info[region].exits.push_back(v);
+ info[region].exits.emplace_back(v);
}
- info[region].full.push_back(v);
+ info[region].full.emplace_back(v);
}
for (auto &m : info) {
if (p_v == prefix.accept || regions.at(v) < dead_region) {
continue;
}
- to_clear.push_back(p_v);
+ to_clear.emplace_back(p_v);
}
for (auto v : to_clear) {
for (auto v : r.exits) {
if (edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second) {
DEBUG_PRINTF("add reporter %zu\n", g[v].index);
- reporters.push_back(v);
+ reporters.emplace_back(v);
}
}
}
DEBUG_PRINTF("adding v=%zu\n", g[v].index);
auto it = mapping.find(v);
assert(it != mapping.end());
- reporters.push_back(it->second);
+ reporters.emplace_back(it->second);
}
}
}
if (is_special(v, g) || regions.at(v) < split_region) {
continue;
}
- tail_vertices.push_back(v);
+ tail_vertices.emplace_back(v);
}
for (auto enter : enters) {
}, g);
}
- new_enters.push_back(orig_to_copy[enter]);
+ new_enters.emplace_back(orig_to_copy[enter]);
}
// Remove the original set of tail vertices.
continue;
}
add_edge_if_not_present(g.start, v, g[e], g);
- dead.push_back(e);
+ dead.emplace_back(e);
}
remove_edges(dead, g);
}
if (source(e, g) == g.accept) {
continue;
}
- dead.push_back(e);
+ dead.emplace_back(e);
}
if (dead.empty()) {
sds_succ.erase(g.startDs);
map<NFAVertex, vector<ue2_literal> > curr;
- curr[g.startDs].push_back(ue2_literal());
+ curr[g.startDs].emplace_back(ue2_literal());
map<NFAVertex, set<NFAVertex> > seen;
map<NFAVertex, vector<ue2_literal> > next;
goto exit;
}
did_expansion = true;
- out.push_back(lit);
+ out.emplace_back(lit);
out.back().push_back(c, nocase);
count++;
if (out.back().length() > MAX_MASK2_WIDTH
dumpHolder(*rhs, 91, "lithaig_rhs", ng.cc.grey);
vector<vector<CharReach> > triggers;
- triggers.push_back(as_cr_seq(lit));
+ triggers.emplace_back(as_cr_seq(lit));
assert(rhs->kind == NFA_SUFFIX);
shared_ptr<raw_som_dfa> haig
assert(rhs->kind == NFA_SUFFIX);
vector<vector<CharReach> > triggers;
- triggers.push_back(as_cr_seq(lit));
+ triggers.emplace_back(as_cr_seq(lit));
ue2_literal lit2;
if (getTrailingLiteral(g, &lit2)
}
assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit));
- triggers.push_back(as_cr_seq(lit));
+ triggers.emplace_back(as_cr_seq(lit));
}
bool unordered_som_triggers = true; /* TODO: check overlaps to ensure that
continue;
}
- cands.push_back(it);
+ cands.emplace_back(it);
}
while (!cands.empty()) {
vector<som_plan> plan;
retry:
// Note: no-one should ever pay attention to the root plan's parent.
- plan.push_back(som_plan(prefix, escapes, false, 0));
+ plan.emplace_back(som_plan(prefix, escapes, false, 0));
dumpHolder(*plan.back().prefix, 12, "som_prefix", cc.grey);
if (!prefix_by_rev) {
if (!doSomPlanning(g, stuck, regions, info, picked, plan, cc.grey)) {
for (const auto &e : in_edges_range(v, g)) {
const DepthMinMax &d = getDepth(source(e, g), g, depths);
assert(d.min == d.max);
- predGroups[d.min].push_back(e);
+ predGroups[d.min].emplace_back(e);
}
DEBUG_PRINTF("forking vertex with %zu pred groups\n", predGroups.size());
NFAVertex clone = add_vertex(g[v], g);
depth clone_depth = predDepth + 1;
g[clone].index = clone_idx;
- depths.push_back(DepthMinMax(clone_depth, clone_depth));
+ depths.emplace_back(DepthMinMax(clone_depth, clone_depth));
DEBUG_PRINTF("cloned vertex %u with depth %s\n", clone_idx,
clone_depth.str().c_str());
vector<NFAVertex> vstarts;
for (auto v : vertices_range(g)) {
if (is_virtual_start(v, g)) {
- vstarts.push_back(v);
+ vstarts.emplace_back(v);
}
}
- vstarts.push_back(g.startDs);
+ vstarts.emplace_back(g.startDs);
// wire the successors of every virtual start or startDs to g.start.
for (auto v : vstarts) {
smgb_cache &cache) {
deque<NFAVertex> remaining;
for (const auto &m : *squash) {
- remaining.push_back(m.first);
+ remaining.emplace_back(m.first);
}
while (!remaining.empty()) {
DEBUG_PRINTF("%zu is an upstream squasher of %zu\n", u_index,
g[v].index);
(*squash)[u] = u_squash;
- remaining.push_back(u);
+ remaining.emplace_back(u);
}
}
}
vector<NFAVertex> unreach;
for (auto v : vertices_range(revg)) {
if (!contains(colours, v)) {
- unreach.push_back(NFAVertex(v));
+ unreach.emplace_back(NFAVertex(v));
}
}
return unreach;
u32 add_to_tail(NFAVertex v) {
u32 rank = size();
to_rank[v] = rank;
- to_vertex.push_back(v);
+ to_vertex.emplace_back(v);
return rank;
}
}
DEBUG_PRINTF("%zu is a seed\n", h[v].index);
- seeds->push_back(v);
+ seeds->emplace_back(v);
already_seeds.insert(v);
}
}
vector<NFAVertex> tail;
assert(in_degree(h.acceptEod, h) == 1);
for (auto v : inv_adjacent_vertices_range(h.accept, h)) {
- tail.push_back(v);
+ tail.emplace_back(v);
}
assert(!tail.empty());
add_edge(u, v, h);
}
tail.clear();
- tail.push_back(v);
+ tail.emplace_back(v);
}
for (auto v : tail) {
lits->reserve(lit_info.size());
for (auto &m : lit_info) {
- lits->push_back(move(m.second));
+ lits->emplace_back(move(m.second));
}
DEBUG_PRINTF("%zu candidate literal sets\n", lits->size());
}
}
if (isRegionExit(g, v, regions)) {
- exits[region].push_back(v);
+ exits[region].emplace_back(v);
}
if (isRegionEntry(g, v, regions)) {
}
DEBUG_PRINTF("candidate is a candidate\n");
- lits->push_back(make_unique<VertLitInfo>(vv, s, anchored));
+ lits->emplace_back(make_unique<VertLitInfo>(vv, s, anchored));
}
}
assert(ait != accepts.end());
NFAVertex curr = *ait;
while (curr && !is_special(curr, g)) {
- dom_trace.push_back(curr);
+ dom_trace.emplace_back(curr);
curr = dominators[curr];
}
reverse(dom_trace.begin(), dom_trace.end());
curr = *ait;
vector<NFAVertex> dom_trace2;
while (curr && !is_special(curr, g)) {
- dom_trace2.push_back(curr);
+ dom_trace2.emplace_back(curr);
curr = dominators[curr];
}
reverse(dom_trace2.begin(), dom_trace2.end());
for (const RoseInEdge &e : ee) {
RoseInVertex src = source(e, vg);
RoseInVertex dest = target(e, vg);
- images[src].push_back(dest);
+ images[src].emplace_back(dest);
remove_edge(e, vg);
}
add_edge(v, dest, RoseInEdgeProps(rhs, 0U), vg);
}
}
- verts_by_image[image].push_back(v);
+ verts_by_image[image].emplace_back(v);
}
}
if (delay == lit.length() && edge(h->start, h->accept, *h).second
&& num_vertices(*h) == N_SPECIALS) {
- to_anchor.push_back(e);
+ to_anchor.emplace_back(e);
continue;
}
}
NGHolder *h = g[e].graph.get();
- infixes[h].push_back(e);
+ infixes[h].emplace_back(e);
}
for (const auto &m : infixes) {
assert(vg[target(e, vg)].type == RIV_LITERAL);
if (vg[e].graph) {
NGHolder *h = vg[e].graph.get();
- prefixes[h].push_back(e);
+ prefixes[h].emplace_back(e);
}
}
if (vg[ve].graph) {
NGHolder *h = vg[ve].graph.get();
- edges_by_graph[h].push_back(ve);
+ edges_by_graph[h].emplace_back(ve);
}
}
for (const RoseInEdge &ve : edges_range(vg)) {
NGHolder *h = vg[ve].graph.get();
if (contains(weak, h)) {
- weak_edges[h].push_back(ve);
+ weak_edges[h].emplace_back(ve);
}
}
VertLitInfo &vli = by_reports[make_pair(false, h[v].reports)];
insert(&vli.lit, ss);
- vli.vv.push_back(v);
+ vli.vv.emplace_back(v);
seen.insert(v);
}
VertLitInfo &vli = by_reports[make_pair(true, h[v].reports)];
insert(&vli.lit, ss);
- vli.vv.push_back(v);
+ vli.vv.emplace_back(v);
}
assert(!by_reports.empty());
assert(vg[e].graph); /* non suffix paths should be wired to other
accepts */
const NGHolder *h = vg[e].graph.get();
- suffixes[h].push_back(e);
+ suffixes[h].emplace_back(e);
}
/* look at suffixes and try to split */
for (const RoseInEdge &ve : edges_range(vg)) {
if (vg[ve].graph && vg[source(ve, vg)].type == RIV_LITERAL) {
const NGHolder *h = vg[ve].graph.get();
- right_edges[h].push_back(ve);
+ right_edges[h].emplace_back(ve);
}
}
for (const RoseInEdge &ve : edges_range(vg)) {
if (vg[ve].graph && vg[source(ve, vg)].type == RIV_LITERAL) {
const NGHolder *h = vg[ve].graph.get();
- right_edges[h].push_back(ve);
+ right_edges[h].emplace_back(ve);
}
}
for (const RoseInEdge &e : out_edges_range(v, vg)) {
if (vg[e].graph) {
NGHolder *h = vg[e].graph.get();
- rightfixes[h].push_back(e);
+ rightfixes[h].emplace_back(e);
}
}
}
continue;
}
- acc_edges.push_back(e);
+ acc_edges.emplace_back(e);
}
for (const RoseInEdge &e : acc_edges) {
for (const auto &e : edges) {
RoseInVertex s = source(e, vg);
if (vg[s].type == RIV_LITERAL) {
- triggers.push_back(as_cr_seq(vg[s].s));
+ triggers.emplace_back(as_cr_seq(vg[s].s));
}
ENSURE_AT_LEAST(&max_offset, vg[s].max_offset);
LIMIT_TO_AT_MOST(&min_offset, vg[s].min_offset);
for (const RoseInEdge &ve : edges_range(vg)) {
if (vg[ve].graph && !vg[ve].dfa) {
auto &h = vg[ve].graph;
- edges_by_graph[h].push_back(ve);
+ edges_by_graph[h].emplace_back(ve);
}
}
for (auto &m : edges_by_graph) {
: Component(other) {
for (const auto &c : other.children) {
assert(c);
- children.push_back(unique_ptr<Component>(c->clone()));
+ children.emplace_back(unique_ptr<Component>(c->clone()));
}
}
}
void ComponentAlternation::append(unique_ptr<Component> component) {
- children.push_back(move(component));
+ children.emplace_back(move(component));
}
vector<PositionInfo> ComponentAlternation::first() const {
{
PositionInfo epsilon(GlushkovBuildState::POS_EPSILON);
epsilon.flags = POS_FLAG_NOFLOAT;
- m_first.push_back(epsilon);
+ m_first.emplace_back(epsilon);
// We have the start vertex in firsts so that we can discourage
// the mid-pattern use of boundaries.
- m_first.push_back(startState);
+ m_first.emplace_back(startState);
break;
}
{
PositionInfo epsilon(GlushkovBuildState::POS_EPSILON);
epsilon.flags = POS_FLAG_NOFLOAT;
- m_first.push_back(epsilon);
+ m_first.emplace_back(epsilon);
// We have the start vertex in firsts so that we can discourage
// the mid-pattern use of boundaries.
- m_first.push_back(startState);
+ m_first.emplace_back(startState);
// Newline
m_newline = makeNewline(bs);
builder.setAssertFlag(m_newline, POS_FLAG_VIRTUAL_START);
PositionInfo nl(m_newline);
nl.flags = POS_FLAG_MUST_FLOAT | POS_FLAG_FIDDLE_ACCEPT;
- m_first.push_back(nl);
- m_last.push_back(nl);
+ m_first.emplace_back(nl);
+ m_last.emplace_back(nl);
recordPosBounds(m_newline, m_newline + 1);
break;
}
PositionInfo epsilon(GlushkovBuildState::POS_EPSILON);
epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_NO_NL_EOD |
POS_FLAG_NO_NL_ACCEPT | POS_FLAG_ONLY_ENDS;
- m_first.push_back(epsilon);
+ m_first.emplace_back(epsilon);
break;
}
case END_STRING_OPTIONAL_LF: // end of data with optional LF ('$')
PositionInfo epsilon(GlushkovBuildState::POS_EPSILON);
epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_WIRE_NL_EOD |
POS_FLAG_NO_NL_ACCEPT | POS_FLAG_ONLY_ENDS;
- m_first.push_back(epsilon);
+ m_first.emplace_back(epsilon);
break;
}
case END_LINE: // multiline anchor: end of data or a newline
PositionInfo epsilon(GlushkovBuildState::POS_EPSILON);
epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_WIRE_NL_EOD |
POS_FLAG_WIRE_NL_ACCEPT | POS_FLAG_ONLY_ENDS;
- m_first.push_back(epsilon);
+ m_first.emplace_back(epsilon);
break;
}
default:
// Each optional repeat has an epsilon at the end of its firsts list.
for (u32 i = m_min; i < m_firsts.size(); i++) {
- m_firsts[i].push_back(GlushkovBuildState::POS_EPSILON);
+ m_firsts[i].emplace_back(GlushkovBuildState::POS_EPSILON);
}
}
// Deep copy children.
for (const auto &c : other.children) {
assert(c);
- children.push_back(unique_ptr<Component>(c->clone()));
+ children.emplace_back(unique_ptr<Component>(c->clone()));
}
if (other.alternation) {
const ComponentAlternation &c = *other.alternation;
}
void ComponentSequence::addComponent(unique_ptr<Component> comp) {
- children.push_back(move(comp));
+ children.emplace_back(move(comp));
}
bool ComponentSequence::addRepeat(u32 min, u32 max,
if (alternation) {
addAlternation();
assert(children.empty());
- children.push_back(move(alternation));
+ children.emplace_back(move(alternation));
alternation = nullptr;
}
}
if (firsts.empty()) {
DEBUG_PRINTF("trivial empty sequence %zu\n", firsts.size());
assert(children.empty());
- firsts.push_back(GlushkovBuildState::POS_EPSILON);
+ firsts.emplace_back(GlushkovBuildState::POS_EPSILON);
}
DEBUG_PRINTF("%zu firsts\n", firsts.size());
continue;
}
- out.push_back(*it);
+ out.emplace_back(*it);
out.back().flags = flags;
seen_flags.insert(flags);
}
for (const auto &last : lasts) {
for (const auto &e : eps_visits) {
- out.push_back(last);
+ out.emplace_back(last);
out.back().flags |= e.flags;
}
}
vector<PositionInfo> ComponentWordBoundary::first() const {
vector<PositionInfo> firsts;
- firsts.push_back(position);
+ firsts.emplace_back(position);
return firsts;
}
vector<PositionInfo> UTF8ComponentClass::first(void) const {
vector<PositionInfo> rv;
if (single_pos != GlushkovBuildState::POS_UNINITIALIZED) {
- rv.push_back(single_pos);
+ rv.emplace_back(single_pos);
}
if (two_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) {
- rv.push_back(two_char_dot_head);
+ rv.emplace_back(two_char_dot_head);
}
if (three_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) {
- rv.push_back(three_char_dot_head);
+ rv.emplace_back(three_char_dot_head);
}
if (four_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) {
- rv.push_back(four_char_dot_head);
+ rv.emplace_back(four_char_dot_head);
}
for (auto it = heads.begin(); it != heads.end(); ++it) {
- rv.push_back(it->second);
+ rv.emplace_back(it->second);
}
return rv;
}
vector<PositionInfo> lasts, firsts;
// start->startDs and startDs self-loop.
- lasts.push_back(startState);
- lasts.push_back(startDotstarState);
- firsts.push_back(startDotstarState);
+ lasts.emplace_back(startState);
+ lasts.emplace_back(startDotstarState);
+ firsts.emplace_back(startDotstarState);
connectRegions(lasts, firsts);
// accept to acceptEod edges already wired
bool require_accept = !(flags & POS_FLAG_ONLY_ENDS);
if (require_eod) {
- tolist->push_back(bs.acceptEodState);
+ tolist->emplace_back(bs.acceptEodState);
}
if (require_nl_accept) {
bs.addSuccessor(newline, builder.getAccept());
bs.acceptNlState = newline;
}
- tolist->push_back(bs.acceptNlState);
+ tolist->emplace_back(bs.acceptNlState);
}
if (require_nl_eod) {
bs.addSuccessor(newline, builder.getAcceptEOD());
bs.acceptNlEodState = newline;
}
- tolist->push_back(bs.acceptNlEodState);
+ tolist->emplace_back(bs.acceptNlEodState);
}
if (require_accept) {
- tolist->push_back(bs.acceptState);
+ tolist->emplace_back(bs.acceptState);
}
}
for (const auto &p : a) {
if (seen.emplace(p.pos, p.flags).second) {
- out.push_back(p); // first encounter
+ out.emplace_back(p); // first encounter
}
}
lop.op = op;
lop.lo = left;
lop.ro = right;
- logicalTree.push_back(lop);
+ logicalTree.emplace_back(lop);
return lop.id;
}
ci.result = lkey_result;
ci.min_offset = min_offset;
ci.max_offset = max_offset;
- combInfoMap.push_back(ci);
+ combInfoMap.emplace_back(ci);
DEBUG_PRINTF("ckey %u (id %u) -> lkey %u..%u, ekey=0x%x\n", ckey, ci.id,
ci.start, ci.result, ci.ekey);
left = subid_stack.back();
subid_stack.pop_back();
}
- subid_stack.push_back(pl.logicalTreeAdd(op_stack.back().op, left, right));
+ subid_stack.emplace_back(pl.logicalTreeAdd(op_stack.back().op, left, right));
op_stack.pop_back();
}
}
} else {
if ((subid = fetchSubID(logical, digit, i)) != (u32)-1) {
- subid_stack.push_back(getLogicalKey(subid));
+ subid_stack.emplace_back(getLogicalKey(subid));
addRelateCKey(subid_stack.back(), ckey);
}
if (logical[i] == ' ') { // skip whitespace
lkey_start = subid_stack.back();
}
}
- op_stack.push_back(op);
+ op_stack.emplace_back(op);
} else {
throw LocatedParseError("Unknown character");
}
throw LocatedParseError("Not enough right parentheses");
}
if ((subid = fetchSubID(logical, digit, i)) != (u32)-1) {
- subid_stack.push_back(getLogicalKey(subid));
+ subid_stack.emplace_back(getLogicalKey(subid));
addRelateCKey(subid_stack.back(), ckey);
}
while (!op_stack.empty()) {
}
DEBUG_PRINTF(" adding new vertex index=%zu\n", tbi->g[w].index);
- vertex_map[iv].push_back(w);
+ vertex_map[iv].emplace_back(w);
} else {
w = created[key];
}
RoseVertex v = tryForAnchoredVertex(tbi, iv_info, ep);
if (v != RoseGraph::null_vertex()) {
DEBUG_PRINTF("add anchored literal vertex\n");
- vertex_map[iv].push_back(v);
+ vertex_map[iv].emplace_back(v);
return;
}
}
continue;
}
add_edge_if_not_present(u, g.accept, g);
- dead.push_back(e);
+ dead.emplace_back(e);
if (!contains(remap, g[u].reports)) {
remap[g[u].reports] = build.getNewNfaReport();
if (ig[iv].type == RIV_START) {
DEBUG_PRINTF("is root\n");
- vertex_map[iv].push_back(tbi->root);
+ vertex_map[iv].emplace_back(tbi->root);
continue;
} else if (ig[iv].type == RIV_ANCHORED_START) {
DEBUG_PRINTF("is anchored root\n");
- vertex_map[iv].push_back(tbi->anchored_root);
+ vertex_map[iv].emplace_back(tbi->anchored_root);
continue;
}
NGHolder *h = in[e].graph.get();
assert(isCorrectlyTopped(*h));
- graphs[h].push_back(e);
+ graphs[h].emplace_back(e);
}
vector<RoseInEdge> graph_edges;
continue;
}
- graphs.push_back(ig[e].graph.get());
+ graphs.emplace_back(ig[e].graph.get());
}
for (const auto &g : graphs) {
}
if (rdfa) {
- outfixes.push_back(OutfixInfo(move(rdfa)));
+ outfixes.emplace_back(OutfixInfo(move(rdfa)));
} else {
- outfixes.push_back(OutfixInfo(cloneHolder(h)));
+ outfixes.emplace_back(OutfixInfo(cloneHolder(h)));
}
populateOutfixInfo(outfixes.back(), h, *this);
bool RoseBuildImpl::addOutfix(const NGHolder &h, const raw_som_dfa &haig) {
DEBUG_PRINTF("haig with %zu states\n", haig.states.size());
- outfixes.push_back(OutfixInfo(ue2::make_unique<raw_som_dfa>(haig)));
+ outfixes.emplace_back(OutfixInfo(ue2::make_unique<raw_som_dfa>(haig)));
populateOutfixInfo(outfixes.back(), h, *this);
return true; /* failure is not yet an option */
auto *mpv = mpv_outfix->mpv();
assert(mpv);
- mpv->puffettes.push_back(rp);
+ mpv->puffettes.emplace_back(rp);
mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */
mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats));
auto *mpv = mpv_outfix->mpv();
assert(mpv);
- mpv->triggered_puffettes.push_back(rp);
+ mpv->triggered_puffettes.emplace_back(rp);
mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */
mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats));
return false;
}
- curr.push_back(lit);
+ curr.emplace_back(lit);
curr.back().push_back(c, nocase);
}
}
auto it = ite - min(size_t{HWLM_MASKLEN}, mask.size() - delay);
for (; it != ite; ++it) {
- msk.push_back(0);
- cmp.push_back(0);
+ msk.emplace_back(0);
+ cmp.emplace_back(0);
make_and_cmp_mask(*it, &msk.back(), &cmp.back());
}
for (auto &rdfa : dfas) {
u32 start_size = mcclellanStartReachSize(rdfa.get());
if (start_size <= MAX_SMALL_START_REACH) {
- small_starts.push_back(move(rdfa));
+ small_starts.emplace_back(move(rdfa));
} else {
- big_starts.push_back(move(rdfa));
+ big_starts.emplace_back(move(rdfa));
}
}
dfas.clear();
// Rehome our groups into one vector.
for (auto &rdfa : small_starts) {
- dfas.push_back(move(rdfa));
+ dfas.emplace_back(move(rdfa));
}
for (auto &rdfa : big_starts) {
- dfas.push_back(move(rdfa));
+ dfas.emplace_back(move(rdfa));
}
// Final test: if we've built two DFAs here that are small enough, we can
explicit Automaton_Holder(const NGHolder &g_in) : g(g_in) {
for (auto v : vertices_range(g)) {
vertexToIndex[v] = indexToVertex.size();
- indexToVertex.push_back(v);
+ indexToVertex.emplace_back(v);
}
assert(indexToVertex.size() <= ANCHORED_NFA_STATE_LIMIT);
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
- esets.push_back(t);
+ esets.emplace_back(t);
}
}
}
if (cr.count() > 1 && !cr.isCaselessChar()) {
break;
}
- lit_verts.push_back(v);
+ lit_verts.emplace_back(v);
}
if (lit_verts.empty()) {
if (check_dupe(*out_dfa, build.anchored_nfas[hash], remap)) {
return ANCHORED_REMAP;
}
- build.anchored_nfas[hash].push_back(move(out_dfa));
+ build.anchored_nfas[hash].emplace_back(move(out_dfa));
return ANCHORED_SUCCESS;
}
rdfa->start_floating = DEAD_STATE;
rdfa->alpha_size = autom.alphasize;
rdfa->alpha_remap = autom.alpha;
- anchored_dfas->push_back(move(rdfa));
+ anchored_dfas->emplace_back(move(rdfa));
}
}
// DFAs that already exist as raw_dfas.
for (auto &anch_dfas : build.anchored_nfas) {
for (auto &rdfa : anch_dfas.second) {
- dfas.push_back(move(rdfa));
+ dfas.emplace_back(move(rdfa));
}
}
build.anchored_nfas.clear();
for (auto &rdfa : anchored_dfas) {
u32 removed_dots = remove_leading_dots(rdfa);
- start_offset->push_back(removed_dots);
+ start_offset->emplace_back(removed_dots);
minimize_hopcroft(rdfa, cc.grey);
assert(nfa->length);
total_size += ROUNDUP_CL(sizeof(anchored_matcher_info) + nfa->length);
- nfas->push_back(move(nfa));
+ nfas->emplace_back(move(nfa));
}
// We no longer need to keep the raw_dfa structures around.
dfas.reserve(anch_dfas.size());
for (auto &rdfa : anch_dfas) {
assert(rdfa);
- dfas.push_back(move(*rdfa));
+ dfas.emplace_back(move(*rdfa));
}
return dfas;
}
vector<CharReach> as_cr_seq(const rose_literal_id &lit) {
vector<CharReach> rv = as_cr_seq(lit.s);
for (u32 i = 0; i < lit.delay; i++) {
- rv.push_back(CharReach::dot());
+ rv.emplace_back(CharReach::dot());
}
/* TODO: take into account cmp/msk */
for (u32 id : lit_ids) {
const rose_literal_id &lit = tbi.literals.at(id);
- (*trigger_lits)[top].push_back(as_cr_seq(lit));
+ (*trigger_lits)[top].emplace_back(as_cr_seq(lit));
}
}
}
map<flat_set<ReportID>, vector<NFAVertex> > reporters;
for (auto v : inv_adjacent_vertices_range(h.accept, h)) {
- reporters[h[v].reports].push_back(v);
+ reporters[h[v].reports].emplace_back(v);
}
for (const auto &e : reporters) {
ExclusiveSubengine engine;
engine.nfa = move(n);
engine.vertices = verts;
- info.subengines.push_back(move(engine));
+ info.subengines.emplace_back(move(engine));
}
info.queue = qif.get_queue();
- exclusive_info.push_back(move(info));
+ exclusive_info.emplace_back(move(info));
}
updateExclusiveInfixProperties(build, exclusive_info, bc.leftfix_info,
no_retrigger_queues);
// NFA already built.
u32 id = leftfixes[leftfix];
if (contains(vertex_map, id)) {
- vertex_map[id].push_back(v);
+ vertex_map[id].emplace_back(v);
}
DEBUG_PRINTF("sharing leftfix, id=%u\n", id);
continue;
if (leftfix.graph() || leftfix.castle()) {
leftfixes.emplace(leftfix, role_id);
- vertex_map[role_id].push_back(v);
+ vertex_map[role_id].emplace_back(v);
map<u32, vector<vector<CharReach>>> triggers;
findTriggerSequences(build, infixTriggers.at(leftfix), &triggers);
}
}
- succs[leftfix].push_back(v);
+ succs[leftfix].emplace_back(v);
}
rose_group initial_groups = tbi.getInitialGroups();
ExclusiveSubengine engine;
engine.nfa = move(n);
engine.vertices = verts;
- info.subengines.push_back(move(engine));
+ info.subengines.emplace_back(move(engine));
const auto &reports = all_reports(s);
info.reports.insert(reports.begin(), reports.end());
}
info.queue = qif.get_queue();
- exclusive_info.push_back(move(info));
+ exclusive_info.emplace_back(move(info));
}
updateExclusiveSuffixProperties(build, exclusive_info,
no_retrigger_queues);
if (contains(suffixes, s)) {
u32 id = suffixes[s];
if (!tbi.isInETable(v)) {
- vertex_map[id].push_back(v);
+ vertex_map[id].emplace_back(v);
}
continue;
}
DEBUG_PRINTF("assigning %p to id %u\n", s.graph(), role_id);
suffixes.emplace(s, role_id);
- vertex_map[role_id].push_back(v);
+ vertex_map[role_id].emplace_back(v);
const set<PredTopPair> &s_triggers = suffixTriggers.at(s);
map<u32, vector<vector<CharReach>>> triggers;
findTriggerSequences(tbi, s_triggers, &triggers);
// Eager EOD reporters won't have state indices.
auto it = bc.roleStateIndices.find(v);
if (it != end(bc.roleStateIndices)) {
- lb_roles.push_back(it->second);
+ lb_roles.emplace_back(it->second);
DEBUG_PRINTF("last byte %u\n", it->second);
}
}
u32 qi = e.first;
auto &ekeys = e.second;
assert(!ekeys.empty());
- ekeys.push_back(INVALID_EKEY); /* terminator */
+ ekeys.emplace_back(INVALID_EKEY); /* terminator */
out[qi] = bc.engine_blob.add_range(ekeys);
}
const auto &eng_info = bc.engine_info_by_queue.at(qi);
if (eng_info.accepts_eod) {
DEBUG_PRINTF("nfa qi=%u accepts eod\n", qi);
- keys.push_back(qi);
+ keys.emplace_back(qi);
}
}
u32 offset = bc.engine_blob.add(*nfa, nfa->length);
DEBUG_PRINTF("wrote SOM rev NFA %zu (len %u) to offset %u\n",
nfa_offsets.size(), nfa->length, offset);
- nfa_offsets.push_back(offset);
+ nfa_offsets.emplace_back(offset);
/* note: som rev nfas don't need a queue assigned as only run in block
* mode reverse */
}
for (size_t i = 0; i < leftInfoTable.size(); i++) {
if (!leftInfoTable[i].transient) {
DEBUG_PRINTF("leftfix %zu is active\n", i);
- keys.push_back(verify_u32(i));
+ keys.emplace_back(verify_u32(i));
}
}
for (const auto &lit_id : lit_ids) {
auto prog = makeLiteralProgram(build, bc, prog_build, lit_id,
lit_edge_map, false);
- blocks.push_back(move(prog));
+ blocks.emplace_back(move(prog));
}
return assembleProgramBlocks(move(blocks));
DEBUG_PRINTF("fragment candidate: lit_id=%u %s\n", lit_id,
dumpString(lit.s).c_str());
auto &fi = frag_info[getFragment(lit)];
- fi.lit_ids.push_back(lit_id);
+ fi.lit_ids.emplace_back(lit_id);
fi.groups |= groups;
}
u32 id = j;
if (contains(includedIdMap, id) ||
contains(includedDelayIdMap, id)) {
- candidates.push_back(j);
+ candidates.emplace_back(j);
DEBUG_PRINTF("find candidate\n");
}
}
delay_id, offset);
} else {
delay_id = verify_u32(programs.size());
- programs.push_back(offset);
+ programs.emplace_back(offset);
cache.emplace(offset, delay_id);
DEBUG_PRINTF("assigned new delay_id %u for offset %u\n",
delay_id, offset);
offset);
} else {
anch_id = verify_u32(programs.size());
- programs.push_back(offset);
+ programs.emplace_back(offset);
cache.emplace(offset, anch_id);
DEBUG_PRINTF("assigned new anch_id %u for offset %u\n", anch_id,
offset);
for (ReportID id : reports) {
auto program = makeReportProgram(build, bc.needs_mpv_catchup, id);
u32 offset = writeProgram(bc, move(program));
- programs.push_back(offset);
+ programs.emplace_back(offset);
build.rm.setProgramOffset(id, offset);
DEBUG_PRINTF("program for report %u @ %u (%zu instructions)\n", id,
programs.back(), program.size());
g[u].index);
continue;
}
- edge_list.push_back(e);
+ edge_list.emplace_back(e);
}
const bool multiple_preds = edge_list.size() > 1;
vector<RoseEdge> edge_list;
for (const auto &v : lit_info.vertices) {
for (const auto &e : in_edges_range(v, g)) {
- edge_list.push_back(e);
+ edge_list.emplace_back(e);
}
}
vector<u32> vec;
for (u32 q : eager) {
assert(q >= leftfixBeginQueue);
- vec.push_back(q - leftfixBeginQueue);
+ vec.emplace_back(q - leftfixBeginQueue);
}
auto iter = mmbBuildSparseIterator(vec, queue_count - leftfixBeginQueue);
vector<rose_literal_id> rv;
for (const u32 id : tbi.g[v].literals) {
- rv.push_back(tbi.literals.at(id));
+ rv.emplace_back(tbi.literals.at(id));
}
return rv;
if (g[v].left && !tbi.isRootSuccessor(v)) {
makeCastle(g[v].left, left_cache);
if (g[v].left.castle) {
- rev[g[v].left.castle.get()].push_back(v);
+ rev[g[v].left.castle.get()].emplace_back(v);
}
}
for (auto v : vertices_range(g)) {
const LeftEngInfo &left = g[v].left;
if (left.castle && left.castle->repeats.size() > 1) {
- left_castles[left].push_back(v);
+ left_castles[left].emplace_back(v);
}
const RoseSuffixInfo &suffix = g[v].suffix;
if (suffix.castle && suffix.castle->repeats.size() > 1) {
- suffix_castles[suffix].push_back(v);
+ suffix_castles[suffix].emplace_back(v);
}
}
RoseGraph &g = tbi.g;
for (auto v : vertices_range(g)) {
if (g[v].left.castle) {
- rose_castles[g[v].left.castle.get()].push_back(v);
+ rose_castles[g[v].left.castle.get()].emplace_back(v);
}
if (g[v].suffix.castle) {
- suffix_castles[g[v].suffix.castle.get()].push_back(v);
+ suffix_castles[g[v].suffix.castle.get()].emplace_back(v);
}
}
limited_explosion(lit.s) && literal_info[id].delayed_ids.empty()) {
DEBUG_PRINTF("need to explode existing string '%s'\n",
dumpString(lit.s).c_str());
- explode.push_back(id);
+ explode.emplace_back(id);
} else {
literal_info[id].requires_benefits = true;
}
if (lit.table == ROSE_EOD_ANCHORED) {
if (suitableForAnchored(tbi, lit, info)) {
- eodLiteralsForAnchored.push_back(i);
+ eodLiteralsForAnchored.emplace_back(i);
} else {
- eodLiteralsForFloating.push_back(i);
+ eodLiteralsForFloating.emplace_back(i);
}
} else if (lit.table == ROSE_FLOATING) {
numFloatingLiterals++;
for (auto v : vertices_range(build.g)) {
if (build.g[v].left) {
const LeftEngInfo &lei = build.g[v].left;
- leftfixes[lei].push_back(v);
+ leftfixes[lei].emplace_back(v);
}
}
return leftfixes;
h[e].tops = std::move(updated_tops);
if (h[e].tops.empty()) {
DEBUG_PRINTF("edge (start,%zu) has only unused tops\n", h[v].index);
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
if (!stateIsSEPLiteral(next, i, rdfa)) {
return false;
}
- lits[rdfa.states[next].reports].push_back(i);
+ lits[rdfa.states[next].reports].emplace_back(i);
}
// Map from symbols back to character reachability.
dumpString(sai.literal).c_str(), sai.min_bound);
}
- anchored_lits.push_back(make_pair(sai, lit_ids));
+ anchored_lits.emplace_back(make_pair(sai, lit_ids));
if (sai.literal.length() == 1) {
oneByteLiterals++;
}
map<ue2_literal, flat_set<ReportID>> sep_literals;
for (OutfixInfo &oi : tbi.outfixes) {
if (extractSEPLiterals(oi, tbi.rm, sep_literals)) {
- sep_outfixes.push_back(&oi);
+ sep_outfixes.emplace_back(&oi);
}
}
/* transfer mpv outfix to main queue */
if (mpv_outfix) {
- outfixes.push_back(move(*mpv_outfix));
+ outfixes.emplace_back(move(*mpv_outfix));
mpv_outfix = nullptr;
}
} else {
RoseEdge e_new = add_edge(ar, v, g);
setEdgeBounds(g, e_new, bound_min, bound_max);
- to_delete->push_back(e_old);
+ to_delete->emplace_back(e_old);
}
g[v].left.reset(); /* clear the prefix info */
} else {
RoseEdge e_new = add_edge(ar, v, g);
setEdgeBounds(g, e_new, ri.repeatMin + width, ri.repeatMax + width);
- to_delete->push_back(e_old);
+ to_delete->emplace_back(e_old);
}
} else {
vector<CharReach> makePath(const rose_literal_id &lit) {
vector<CharReach> path(begin(lit.s), end(lit.s));
for (u32 i = 0; i < lit.delay; i++) {
- path.push_back(CharReach::dot());
+ path.emplace_back(CharReach::dot());
}
return path;
}
u32 idx = 0;
u32 i = mmbit_sparse_iter_begin(b, num_bits, &idx, it, s);
while (i != MMB_INVALID) {
- keys.push_back(i);
+ keys.emplace_back(i);
i = mmbit_sparse_iter_next(b, num_bits, i, &idx, it, s);
}
vector<u32> programs;
for (const auto &frag : fragments) {
if (frag.lit_program_offset) {
- programs.push_back(frag.lit_program_offset);
+ programs.emplace_back(frag.lit_program_offset);
}
if (frag.delay_program_offset) {
- programs.push_back(frag.delay_program_offset);
+ programs.emplace_back(frag.delay_program_offset);
}
}
sort_and_unique(programs);
for (const auto &roleInfo : roleInfoSet) {
if (cnt == chunkSize) {
cnt -= chunkSize;
- chunks.push_back(roleChunk);
+ chunks.emplace_back(roleChunk);
roleChunk.roles.clear();
}
- roleChunk.roles.push_back(roleInfo);
+ roleChunk.roles.emplace_back(roleInfo);
cnt++;
}
if (cnt > 1) {
- chunks.push_back(roleChunk);
+ chunks.emplace_back(roleChunk);
}
return chunks;
NFAVertex u = add_vertex(h);
h[u].char_reach = c;
if (!i++) {
- heads.push_back(u);
+ heads.emplace_back(u);
last = u;
continue;
}
add_edge(last, u, h);
last = u;
}
- tails.push_back(last);
+ tails.emplace_back(last);
tailId.insert(h[last].index);
}
for (const auto &i : clique) {
DEBUG_PRINTF("cliq:%zu\n", i.size());
if (i.size() > 1) {
- exclusive_roles.push_back(i);
+ exclusive_roles.emplace_back(i);
}
}
DEBUG_PRINTF("Clique graph size:%zu\n", exclusive_roles.size());
for (const auto &c : lit) {
roleInfo.prefix_cr |= c;
}
- roleInfo.literals.push_back(lit);
+ roleInfo.literals.emplace_back(lit);
}
}
/* long literals will either be stuck in a mega group or spread around
* depending on availability */
if (superStrong(lit)) {
- long_lits.push_back(id);
+ long_lits.emplace_back(id);
continue;
}
return {it->second, false};
}
u32 id = verify_u32(lits.size());
- lits.push_back(lit);
+ lits.emplace_back(lit);
lits_index.emplace(lit, id);
return {id, true};
}
}
contractVertex(g, v, all_edges);
- dead.push_back(v);
+ dead.emplace_back(v);
}
remove_vertices(dead, g);
vector<s8> look_offsets;
vector<CharReach> reaches;
for (const auto &le : look) {
- look_offsets.push_back(le.offset);
- reaches.push_back(le.reach);
+ look_offsets.emplace_back(le.offset);
+ reaches.emplace_back(le.reach);
}
inst->look_index = blob.lookaround_cache.get_offset_of(look_offsets, blob);
inst->reach_index = blob.lookaround_cache.get_offset_of(reaches, blob);
vector<u32> keys;
vector<u32> jump_offsets;
for (const auto &jump : jump_table) {
- keys.push_back(jump.first);
+ keys.emplace_back(jump.first);
assert(contains(offset_map, jump.second));
- jump_offsets.push_back(offset_map.at(jump.second));
+ jump_offsets.emplace_back(offset_map.at(jump.second));
}
auto iter = mmbBuildSparseIterator(keys, num_keys);
bool done_offset = false;
for (const auto &le : vle) {
- reaches.back().push_back(le.reach);
+ reaches.back().emplace_back(le.reach);
/* empty reaches don't have valid offsets */
if (!done_offset && le.reach.any()) {
- look_offsets.push_back(le.offset);
+ look_offsets.emplace_back(le.offset);
done_offset = true;
}
}
DEBUG_PRINTF("lit: '%s', nocase=%d, groups=0x%llx\n",
escapeString(lit.s).c_str(), lit.nocase ? 1 : 0,
lit.groups);
- filtered_lits->push_back(&lit);
+ filtered_lits->emplace_back(&lit);
}
}
DEBUG_PRINTF("successor %zu has no leftfix\n", g[t].index);
return;
}
- rose_look.push_back(map<s32, CharReach>());
+ rose_look.emplace_back(map<s32, CharReach>());
getRoseForwardReach(g[t].left, g[e].rose_top, rose_look.back());
}
if (g[v].suffix) {
DEBUG_PRINTF("suffix engine\n");
- rose_look.push_back(map<s32, CharReach>());
+ rose_look.emplace_back(map<s32, CharReach>());
getSuffixForwardReach(g[v].suffix, g[v].suffix.top, rose_look.back());
}
vector<s32> dead;
for (const auto &m : look) {
if (m.second.all()) {
- dead.push_back(m.first);
+ dead.emplace_back(m.first);
}
}
erase_all(&look, dead);
vector<s32> dead;
for (const auto &m : look) {
if (m.second.all() && m.first != earliest) {
- dead.push_back(m.first);
+ dead.emplace_back(m.first);
}
}
erase_all(&look, dead);
s8 offset = verify_s8(m.first);
lookaround.emplace_back(offset, m.second);
}
- lookarounds.push_back(lookaround);
+ lookarounds.emplace_back(lookaround);
}
}
return true;
}
if (contains(g[v].reports, report)) {
- curr.push_back(v);
+ curr.emplace_back(v);
}
}
looks[idx][0 - i] = g[u].char_reach;
total_len++;
} else {
- curr.push_back(u);
- looks.push_back(looks[idx]);
+ curr.emplace_back(u);
+ looks.emplace_back(looks[idx]);
(looks.back())[0 - i] = g[u].char_reach;
total_len += looks.back().size();
}
continue;
}
- candidates.push_back(id);
+ candidates.emplace_back(id);
}
for (const u32 &id : candidates) {
}
}
- used_lit_ids.push_back(id);
+ used_lit_ids.emplace_back(id);
}
if (used_lit_ids.empty()) {
continue;
}
- roses[RoseGroup(tbi, v)].push_back(v);
+ roses[RoseGroup(tbi, v)].emplace_back(v);
}
DEBUG_PRINTF("collected %zu rose groups\n", roses.size());
set<RoseVertex> &verts = suffix_map[s];
if (verts.empty()) {
- part[make_pair(suffix_size_key(s), all_reports(s))].push_back(s);
+ part[make_pair(suffix_size_key(s), all_reports(s))].emplace_back(s);
}
verts.insert(v);
}
void insert(const EngineRef &h, RoseVertex v) {
typename BouquetMap::iterator f = bouquet.find(h);
if (f == bouquet.end()) {
- ordering.push_back(h);
- bouquet[h].push_back(v);
+ ordering.emplace_back(h);
+ bouquet[h].emplace_back(v);
} else {
- f->second.push_back(v);
+ f->second.emplace_back(v);
}
}
void insert(const EngineRef &h, const deque<RoseVertex> &verts) {
typename BouquetMap::iterator f = bouquet.find(h);
if (f == bouquet.end()) {
- ordering.push_back(h);
+ ordering.emplace_back(h);
bouquet.insert(make_pair(h, verts));
} else {
f->second.insert(f->second.end(), verts.begin(), verts.end());
deque<Bouquet<EngineRef>> &out,
const size_t chunk_size) {
if (in.size() <= chunk_size) {
- out.push_back(in);
+ out.emplace_back(in);
return;
}
- out.push_back(Bouquet<EngineRef>());
+ out.emplace_back(Bouquet<EngineRef>());
for (const auto &engine : in) {
if (out.back().size() >= chunk_size) {
- out.push_back(Bouquet<EngineRef>());
+ out.emplace_back(Bouquet<EngineRef>());
}
out.back().insert(engine, in.vertices(engine));
}
vector<const rose_literal_id *> pred_rose_lits;
pred_rose_lits.reserve(pred_lits.size());
for (const auto &p : pred_lits) {
- pred_rose_lits.push_back(&build.literals.at(p));
+ pred_rose_lits.emplace_back(&build.literals.at(p));
}
for (auto v : v2) {
static
void chunk(vector<T> in, vector<vector<T>> *out, size_t chunk_size) {
if (in.size() <= chunk_size) {
- out->push_back(std::move(in));
+ out->emplace_back(std::move(in));
return;
}
- out->push_back(vector<T>());
+ out->emplace_back(vector<T>());
out->back().reserve(chunk_size);
for (const auto &t : in) {
if (out->back().size() >= chunk_size) {
- out->push_back(vector<T>());
+ out->emplace_back(vector<T>());
out->back().reserve(chunk_size);
}
- out->back().push_back(std::move(t));
+ out->back().emplace_back(std::move(t));
}
}
continue;
}
assert(contains(all_reports(left), left.leftfix_report));
- eng_verts[left].push_back(v);
+ eng_verts[left].emplace_back(v);
}
return eng_verts;
assert(!parents.empty());
#ifndef _WIN32
- engine_groups[MergeKey(left, parents)].push_back(left);
+ engine_groups[MergeKey(left, parents)].emplace_back(left);
#else
// On windows, when passing MergeKey object into map 'engine_groups',
// it will not be copied, but will be freed along with
// will cause is_block_type_valid() assertion error in MergeKey
// destructor.
MergeKey *mk = new MergeKey(left, parents);
- engine_groups[*mk].push_back(left);
+ engine_groups[*mk].emplace_back(left);
#endif
}
continue;
}
}
- engine_groups[DedupeLeftKey(build, move(preds), left)].push_back(left);
+ engine_groups[DedupeLeftKey(build, move(preds), left)].emplace_back(left);
}
/* We don't bother chunking as we expect deduping to be successful if the
}
roses.insert(r1, verts2);
- merged.push_back(r2);
+ merged.emplace_back(r2);
if (num_vertices(*winner) >= small_merge_max_vertices(tbi.cc)) {
DEBUG_PRINTF("h1 now has %zu vertices, proceeding to next\n",
continue;
}
- eng_verts[g[v].left].push_back(v);
+ eng_verts[g[v].left].emplace_back(v);
}
map<CharReach, vector<left_id>> by_reach;
for (const auto &left : eng_verts | map_keys) {
- by_reach[left.castle()->reach()].push_back(left);
+ by_reach[left.castle()->reach()].emplace_back(left);
}
vector<vector<left_id>> chunks;
g[v].suffix.graph = winner;
}
suffixes.insert(s1, verts2);
- merged.push_back(s2);
+ merged.emplace_back(s2);
if (num_vertices(*s1.graph()) >= small_merge_max_vertices(tbi.cc)) {
DEBUG_PRINTF("h1 now has %zu vertices, proceeding to next\n",
vector<NGHolder *> batch;
for (auto it = begin(nfas), ite = end(nfas); it != ite; ++it) {
- batch.push_back(*it);
+ batch.emplace_back(*it);
assert((*it)->kind == NFA_OUTFIX);
if (batch.size() == MERGE_GROUP_SIZE_MAX || next(it) == ite) {
auto batch_merged = mergeNfaCluster(batch, &build.rm, build.cc);
vector<RawDfa *> out_dfas;
vector<RawDfa *> chunk;
for (auto it = begin(dfas), ite = end(dfas); it != ite; ++it) {
- chunk.push_back(*it);
+ chunk.emplace_back(*it);
if (chunk.size() >= DFA_CHUNK_SIZE_MAX || next(it) == ite) {
pairwiseDfaMerge(chunk, dfa_mapping, outfixes, merge_func);
out_dfas.insert(end(out_dfas), begin(chunk), end(chunk));
if (outfix.rdfa()) {
auto *rdfa = outfix.rdfa();
- dfas.push_back(rdfa);
+ dfas.emplace_back(rdfa);
dfa_mapping[rdfa] = it - tbi.outfixes.begin();
continue;
}
if (rdfa) {
// Transform this outfix into a DFA and add it to the merge set.
dfa_mapping[rdfa.get()] = it - tbi.outfixes.begin();
- dfas.push_back(rdfa.get());
+ dfas.emplace_back(rdfa.get());
outfix.proto = move(rdfa);
new_dfas++;
}
for (auto &outfix : tbi.outfixes) {
if (outfix.rdfa()) {
- dfas.push_back(outfix.rdfa());
+ dfas.emplace_back(outfix.rdfa());
} else if (outfix.holder()) {
- nfas.push_back(outfix.holder());
+ nfas.emplace_back(outfix.holder());
} else if (outfix.haig()) {
- som_dfas.push_back(outfix.haig());
+ som_dfas.emplace_back(outfix.haig());
}
}
}
if (!contains(eng_verts, c)) {
- by_reach[c->reach()].push_back(c);
+ by_reach[c->reach()].emplace_back(c);
}
- eng_verts[c].push_back(v);
+ eng_verts[c].emplace_back(v);
}
for (auto &chunk : by_reach | map_values) {
bool inserted = m.second;
if (inserted) {
- literal_info.push_back(rose_literal_info());
+ literal_info.emplace_back(rose_literal_info());
assert(literal_info.size() == id + 1);
if (delay) {
bool inserted = m.second;
if (inserted) {
- literal_info.push_back(rose_literal_info());
+ literal_info.emplace_back(rose_literal_info());
assert(literal_info.size() == id + 1);
if (delay) {
assert(m.second);
u32 id = m.first;
- literal_info.push_back(rose_literal_info());
+ literal_info.emplace_back(rose_literal_info());
assert(literal_info.size() == id + 1);
literal_info[id].undelayed_id = id;
}
RoseProgram::RoseProgram() {
- prog.push_back(make_unique<RoseInstrEnd>());
+ prog.emplace_back(make_unique<RoseInstrEnd>());
}
RoseProgram::~RoseProgram() = default;
}
for (const auto &it : lo2hi) {
u32 hi_lo = (it.second << 16) | it.first;
- buckets[hi_lo].push_back(entry.offset);
+ buckets[hi_lo].emplace_back(entry.offset);
}
}
}
continue;
}
- blocks.push_back(move(block));
+ blocks.emplace_back(move(block));
seen.emplace(blocks.back());
}
makePushDelayedInstructions(build.literals, prog_build,
build.literal_info.at(lit_id).delayed_ids,
prog);
- blocks.push_back(move(prog));
+ blocks.emplace_back(move(prog));
}
return assembleProgramBlocks(move(blocks));
vector<u32> keys;
for (const u32 &key : pred_blocks | map_keys) {
- keys.push_back(key);
+ keys.emplace_back(key);
}
const RoseInstruction *end_inst = sparse_program.end_instruction();
h[e].tops = std::move(pruned_tops);
if (h[e].tops.empty()) {
DEBUG_PRINTF("edge (start,%zu) has only unused tops\n", h[v].index);
- dead.push_back(e);
+ dead.emplace_back(e);
}
}
out.emplace_back();
}
auto out_bucket = p.first->second;
- out[out_bucket].push_back(v);
+ out[out_bucket].emplace_back(v);
}
}
for (RoseVertex v : adjacent_vertices_range(u, g)) {
auto it = inv.find(v);
if (it != end(inv)) {
- neighbours_by_bucket[it->second].push_back(v);
+ neighbours_by_bucket[it->second].emplace_back(v);
}
}
} else {
for (RoseVertex v : inv_adjacent_vertices_range(u, g)) {
auto it = inv.find(v);
if (it != end(inv)) {
- neighbours_by_bucket[it->second].push_back(v);
+ neighbours_by_bucket[it->second].emplace_back(v);
}
}
}
if (contains(picked, v)) {
inv[v] = new_key;
} else {
- leftovers.push_back(v);
+ leftovers.emplace_back(v);
}
}
assert(!leftovers.empty());
assert(e.second.size() + leftovers.size()
== buckets[old_key].size());
- extras.push_back(e.second);
+ extras.emplace_back(e.second);
buckets[old_key].swap(leftovers);
}
insert(&buckets, buckets.end(), extras);
}
mergeVerticesDiamond(a, b, build, rai);
- dead->push_back(a);
+ dead->emplace_back(a);
candidates.erase(a);
break; // next a
}
RoseVertex b = *jt;
if (attemptRoseMerge(build, true, a, b, false, rai)) {
mergeVerticesLeft(a, b, build, rai);
- dead->push_back(a);
+ dead->emplace_back(a);
candidates.erase(ait);
break; // consider next a
}
RoseVertex b = *jt;
if (attemptRoseMerge(build, false, a, b, !mergeRoses, rai)) {
mergeVerticesRight(a, b, build, rai);
- dead->push_back(a);
+ dead->emplace_back(a);
candidates.erase(a);
break; // consider next a
}
vector<RoseVertex> dead;
for (const auto &v : candidates) {
if (hasNoDiamondSiblings(g, v)) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
if (g[et].minBound <= g[e].minBound
&& g[et].maxBound >= g[e].maxBound) {
DEBUG_PRINTF("remove more constrained edge\n");
- deadEdges.push_back(e);
+ deadEdges.emplace_back(e);
}
} else {
DEBUG_PRINTF("rehome edge: add %zu->%zu\n", g[u].index,
g[t].index);
add_edge(u, t, g[e], g);
- deadEdges.push_back(e);
+ deadEdges.emplace_back(e);
}
}
for (auto &e : deadEdges) {
remove_edge(e, g);
}
- changed.push_back(v);
+ changed.emplace_back(v);
g[t].min_offset = min(g[t].min_offset, g[v].min_offset);
g[t].max_offset = max(g[t].max_offset, g[v].max_offset);
}
NGHolder *h = g[v].suffix.graph.get();
assert(!g[v].suffix.haig); /* should not be here if haig */
rev[h] = v;
- cluster.push_back(h);
+ cluster.emplace_back(h);
}
it = it2;
ENSURE_AT_LEAST(&g[winner].max_offset, g[victim].max_offset);
insert(&g[winner].reports, g[victim].reports);
- dead.push_back(victim);
+ dead.emplace_back(victim);
}
}
}
continue;
}
- suffix_vertices.push_back(v);
+ suffix_vertices.emplace_back(v);
}
}
vector<RoseVertex> &vec = clusters[key];
if (vec.empty()) {
- ordered.push_back(key);
+ ordered.emplace_back(key);
}
- vec.push_back(v);
+ vec.emplace_back(v);
}
DEBUG_PRINTF("find loop done\n");
for (auto v : vertices_range(g)) {
if (tbi.hasLiteralInTable(v, table)) {
- table_verts.push_back(v);
+ table_verts.emplace_back(v);
}
}
for (auto v : vertices_range(g)) {
if ((table == ROSE_FLOATING && tbi.isFloating(v))
|| (table == ROSE_ANCHORED && tbi.isAnchored(v))) {
- table_verts.push_back(v);
+ table_verts.emplace_back(v);
}
}
for (ReportID id : g[v].reports) {
const auto &report = rm.getReport(id);
if (report.minOffset > max_depth) {
- bad_reports.push_back(id);
+ bad_reports.emplace_back(id);
}
}
vector<const raw_dfa *> dfa_ptrs;
dfa_ptrs.reserve(dfas.size());
for (auto &d : dfas) {
- dfa_ptrs.push_back(d.get());
+ dfa_ptrs.emplace_back(d.get());
}
auto merged = mergeAllDfas(dfa_ptrs, DFA_MERGE_MAX_STATES, &rm, cc.grey);
DEBUG_PRINTF("merge succeeded, result has %zu states\n",
merged->states.size());
dfas.clear();
- dfas.push_back(std::move(merged));
+ dfas.emplace_back(std::move(merged));
return true;
}
minimize_hopcroft(*r, cc.grey);
}
- dfas.push_back(std::move(r));
+ dfas.emplace_back(std::move(r));
if (dfas.size() >= cc.grey.smallWriteMergeBatchSize) {
if (!mergeDfas(dfas, rm, cc)) {
auto v = target(e, trie);
DEBUG_PRINTF("bfs (%zu, %zu) on '%c'\n", trie[u].index, trie[v].index,
trie[v].c);
- ordering.push_back(v);
+ ordering.emplace_back(v);
auto f = find_failure_target(u, v, trie);
deque<LitTrieVertex> q;
for (auto v : vertices_range(trie)) {
if (!trie[v].reports.empty()) {
- q.push_back(v);
+ q.emplace_back(v);
dist[trie[v].index] = 0;
}
}
for (auto u : inv_adjacent_vertices_range(v, trie)) {
auto &u_dist = dist[trie[u].index];
if (u_dist == UINT32_MAX) {
- q.push_back(u);
+ q.emplace_back(u);
u_dist = d + 1;
}
}
DEBUG_PRINTF("pruning vertex %zu (min path len %u)\n",
trie[v].index, min_path_len);
clear_vertex(v, trie);
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
CharReach t = cr & esets[i];
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
- esets.push_back(t);
+ esets.emplace_back(t);
}
}
}
}
if (!is_empty(lit_trie)) {
- dfas.push_back(buildDfa(lit_trie, false));
+ dfas.emplace_back(buildDfa(lit_trie, false));
DEBUG_PRINTF("caseful literal dfa with %zu states\n",
dfas.back()->states.size());
}
if (!is_empty(lit_trie_nocase)) {
- dfas.push_back(buildDfa(lit_trie_nocase, true));
+ dfas.emplace_back(buildDfa(lit_trie_nocase, true));
DEBUG_PRINTF("nocase literal dfa with %zu states\n",
dfas.back()->states.size());
}
u32 SomSlotManager::addRevNfa(bytecode_ptr<NFA> nfa, u32 maxWidth) {
u32 rv = verify_u32(rev_nfas.size());
- rev_nfas.push_back(move(nfa));
+ rev_nfas.emplace_back(move(nfa));
// A rev nfa commits us to having enough history around to handle its
// max width.
// find neighbors for cv
for (const auto &v : adjacent_vertices_range(cv, g)) {
if (g[v].stateId != id && contains(group, g[v].stateId)){
- neighbor.push_back(g[v].stateId);
+ neighbor.emplace_back(g[v].stateId);
DEBUG_PRINTF("Neighbor:%u\n", g[v].stateId);
}
}
vector<u32> init;
for (const auto &v : vertices_range(cg)) {
vertexMap[cg[v].stateId] = v;
- init.push_back(cg[v].stateId);
+ init.emplace_back(cg[v].stateId);
}
gStack.push(init);
// Choose a vertex from the graph
u32 id = g[0];
CliqueVertex &n = vertexMap.at(id);
- clique.push_back(id);
+ clique.emplace_back(id);
// Corresponding vertex in the original graph
set<u32> subgraphId(g.begin(), g.end());
auto neighbor = getNeighborInfo(cg, n, subgraphId);
for (const auto &v : vertices_range(cg)) {
u32 id = cg[v].stateId;
if (find(c.begin(), c.end(), id) != c.end()) {
- dead.push_back(v);
+ dead.emplace_back(v);
}
}
for (const auto &v : dead) {
break;
}
auto clique = findCliqueGroup(cg);
- cliquesVec.push_back(clique);
+ cliquesVec.emplace_back(clique);
}
return cliquesVec;
dstates.reserve(state_limit);
dstate_ids.emplace(n.dead, DEAD_STATE);
- dstates.push_back(ds(alphabet_size));
+ dstates.emplace_back(ds(alphabet_size));
std::fill_n(dstates[0].next.begin(), alphabet_size, DEAD_STATE);
std::queue<std::pair<StateSet, dstate_id_t>> q;
q.emplace(init[i], dstates.size());
assert(!contains(dstate_ids, init[i]));
dstate_ids.emplace(init[i], dstates.size());
- dstates.push_back(ds(alphabet_size));
+ dstates.emplace_back(ds(alphabet_size));
}
std::vector<StateSet> succs(alphabet_size, n.dead);
} else {
succ_id = dstate_ids.size();
dstate_ids.emplace(succs[s], succ_id);
- dstates.push_back(ds(alphabet_size));
+ dstates.emplace_back(ds(alphabet_size));
dstates.back().daddy = n.unalpha[s] < N_CHARS ? curr_id : 0;
q.emplace(succs[s], succ_id);
}
std::map<size_t, std::vector<vertex_descriptor>> comps;
for (const auto &e : comp_map) {
- comps[e.second].push_back(e.first);
+ comps[e.second].emplace_back(e.first);
}
flat_set<vertex_descriptor> rv;
std::pair<iterator, bool> insert(const Key &key, const Element &element) {
const auto idx = data.size();
if (map.emplace(key, idx).second) {
- data.push_back(element);
+ data.emplace_back(element);
return {begin() + idx, true};
}
return {end(), false};
if (depth != t->depth) {
depth = t->depth;
- levels.push_back(out.size());
+ levels.emplace_back(out.size());
}
DEBUG_PRINTF("pop: mask=0x%08llx, depth=%u, children.size()=%zu\n",
t->mask, t->depth, t->children.size());
- out.push_back(mmbit_sparse_iter());
+ out.emplace_back(mmbit_sparse_iter());
memset(&out.back(), 0, sizeof(mmbit_sparse_iter));
mmbit_sparse_iter &record = out.back();
record.mask = t->mask;
}
if (*sp_it > member) {
- split_temp_diff.push_back(member);
+ split_temp_diff.emplace_back(member);
} else {
- split_temp_inter.push_back(member);
+ split_temp_inter.emplace_back(member);
}
}
/* smaller subset is placed in the new subset */
size_t new_index = subsets.size();
- subsets.push_back(subset());
+ subsets.emplace_back(subset());
insert(&subsets.back().members, subsets.back().members.end(), *small);
for (const auto &e : *small) {
for (size_t i = seen.find_first(); i != seen.npos;
i = seen.find_next(i)) {
- containing->push_back(i);
+ containing->emplace_back(i);
}
}
assert(sub < subsets.size());
member_to_subset[i] = sub;
- subsets[sub].members.push_back(i);
+ subsets[sub].members.emplace_back(i);
}
/* none of the subsets should be empty */
}
u32 size = reportIds.size();
- reportIds.push_back(ir);
+ reportIds.emplace_back(ir);
reportIdToInternalMap.emplace(ir, size);
DEBUG_PRINTF("new report %u\n", size);
return size;
projects / thirdparty / vectorscan.git / commitdiff
