assert(contains(src_slots, slot_id));
shared_ptr<GoughSSAVarMin> vmin = make_shared<GoughSSAVarMin>();
+ if (!vmin) {
+ assert(0);
+ throw std::bad_alloc();
+ }
cfg[e].vars.emplace_back(vmin);
final_var = vmin.get();
DEBUG_PRINTF("bypassing min on join %u\n", slot_id);
} else {
shared_ptr<GoughSSAVarMin> vmin = make_shared<GoughSSAVarMin>();
+ if (!vmin) {
+ assert(0);
+ throw std::bad_alloc();
+ }
cfg[e].vars.emplace_back(vmin);
final_var = vmin.get();
const depth &repeatMax, u32 minPeriod)
: stateSize(0), packedCtrlSize(0), horizon(0), patchCount(0),
patchSize(0), encodingSize(0), patchesOffset(0) {
+ if (type == REPEAT_SPARSE_OPTIMAL_P && minPeriod == 0) {
+ assert(0);
+ throw std::domain_error("SPARSE_OPTIMAL_P must have non-zero minPeriod.");
+ }
assert(repeatMin <= repeatMax);
assert(repeatMax.is_reachable());
assert(minPeriod || type != REPEAT_SPARSE_OPTIMAL_P);
bool doLitHaigSom(NG &ng, NGHolder &g, som_type som) {
ue2_literal lit;
shared_ptr<NGHolder> rhs = make_shared<NGHolder>();
+ if (!rhs) {
+ assert(0);
+ throw std::bad_alloc();
+ }
if (!ng.cc.grey.allowLitHaig) {
return false;
}
ue2_literal lit;
shared_ptr<NGHolder> rhs = make_shared<NGHolder>();
shared_ptr<NGHolder> lhs = make_shared<NGHolder>();
+ if (!rhs || !lhs) {
+ assert(0);
+ throw std::bad_alloc();
+ }
+
if (!splitOffBestLiteral(g, regions, &lit, &*lhs, &*rhs, ng.cc)) {
return false;
}
shared_ptr<NGHolder> lhs = make_shared<NGHolder>();
shared_ptr<NGHolder> rhs = make_shared<NGHolder>();
+ if (!lhs || !rhs) {
+ assert(0);
+ throw std::bad_alloc();
+ }
+
unordered_map<NFAVertex, NFAVertex> lhs_map;
unordered_map<NFAVertex, NFAVertex> rhs_map;
DEBUG_PRINTF("splitting on pivot %zu\n", h[pivot].index);
unordered_map<NFAVertex, NFAVertex> temp_map;
shared_ptr<NGHolder> new_lhs = make_shared<NGHolder>();
+ if (!new_lhs) {
+ assert(0);
+ throw std::bad_alloc();
+ }
splitLHS(h, pivot, new_lhs.get(), &temp_map);
/* want to cut off paths to pivot from things other than the pivot -
if (!contains(done_rhs, adj)) {
unordered_map<NFAVertex, NFAVertex> temp_map;
shared_ptr<NGHolder> new_rhs = make_shared<NGHolder>();
+ if (!new_rhs) {
+ assert(0);
+ throw std::bad_alloc();
+ }
splitRHS(h, adj, new_rhs.get(), &temp_map);
remove_edge(new_rhs->start, new_rhs->accept, *new_rhs);
remove_edge(new_rhs->start, new_rhs->acceptEod, *new_rhs);
assert(!splitters.empty());
shared_ptr<NGHolder> lhs = make_shared<NGHolder>();
+ if (!lhs) {
+ assert(0);
+ throw bad_alloc();
+ }
unordered_map<NFAVertex, NFAVertex> v_map;
cloneHolder(*lhs, base_graph, &v_map);
lhs->kind = NFA_INFIX;
}
hs_compile_error_t *compile_err = NULL;
hs_expr_info_t *info = NULL;
- hs_error_t err = hs_expression_info(expressions[i], flags[i], &info,
+ hs_error_t err = hs_expression_info(expressions[i],
+ flags ? flags[i] : 0, &info,
&compile_err);
if (err != HS_SUCCESS) {
hs_free_compile_error(compile_err);
DEBUG_PRINTF("woot?\n");
shared_ptr<NGHolder> h_new = make_shared<NGHolder>();
+ if (!h_new) {
+ assert(0);
+ throw std::bad_alloc();
+ }
unordered_map<NFAVertex, NFAVertex> rhs_map;
vector<NFAVertex> exits_vec;
insert(&exits_vec, exits_vec.end(), exits);
struct LitTrieVertexProps {
LitTrieVertexProps() = default;
explicit LitTrieVertexProps(u8 c_in) : c(c_in) {}
- size_t index; // managed by ue2_graph
+ size_t index = 0; // managed by ue2_graph
u8 c = 0; //!< character reached on this vertex
flat_set<ReportID> reports; //!< managed reports fired on this vertex
};
using base_vertex_type = typename base_graph_traits::vertex_descriptor;
base_edge_type underlying_edge;
- const base_graph_type *g;
- bool reverse; // if true, reverse vertices in source() and target()
+ const base_graph_type *g = nullptr;
+ bool reverse = false; // if true, reverse vertices in source() and target()
inline std::pair<base_vertex_type, base_vertex_type>
canonical_edge() const {
: lit(&lit_in), idx(idx_in) {}
const ue2_literal *lit = nullptr;
- size_t idx;
+ size_t idx = 0;
};
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
}
auto internal_stream_index = stream_indices[stream_id];
- assert(blob || bytes > 0);
+ if (!(blob && bytes > 0)) {
+ assert(0);
+ throw std::domain_error("Invalid blob or bytes from sqlite3.");
+ }
blocks.emplace_back(id, stream_id, internal_stream_index,
string(blob, blob + bytes));
}
total += block.payload.size();
}
+ if (total == 0) {
+ assert(0);
+ throw std::invalid_argument("Empty corpus.");
+ }
+
return total;
}
std::lock_guard<std::mutex> lock(mutex);
if (failed) {
// We have previously failed to compile this database.
- return nullptr;
+ throw CompileFailed("Unable to compile db previously.");
}
if (db) {
return db;
pl.logicalKeyRenumber();
const auto &m_lkey = pl.getLkeyMap();
assert(!m_lkey.empty());
- u32 a_subid; // arbitrary sub id
+ u32 a_subid = 0; // arbitrary sub id
unordered_map<u32, vector<Corpus>> m_data;
for (const auto &it : m_lkey) {
a_subid = it.first;
}
-Thread::Thread(size_t num) : thread_id(num) {}
+Thread::Thread(size_t num) : thread_id(num), thread() {}
Thread::~Thread() {}
: matchness(100), unmatchness(0), randomness(0), prefixRange(0, 0),
suffixRange(0, 0), cycleMin(1), cycleMax(1),
corpusLimit(DEFAULT_CORPUS_GENERATOR_LIMIT), editDistance(0),
- alphabetSize(~0) {
+ alphabetSize(~0), rngSeed(0) {
// empty
}