Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 14:48:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

CompHash: return IntrusivePtr

Browse source
This commit is contained in:
Max Kellermann 2020-03-02 19:27:17 +01:00
parent ba35ebec4c
commit 7924e948b9
3 changed files with 46 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

70
src/CompHash.cc
View file

@ -720,19 +720,19 @@ int CompositeHash::SizeAlign(int offset, unsigned int size) const
return offset; return offset;
} }
ListVal* CompositeHash::RecoverVals(const HashKey* k) const IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey* k) const
{ {
ListVal* l = new ListVal(TYPE_ANY); auto l = make_intrusive<ListVal>(TYPE_ANY);
const type_list* tl = type->Types(); const type_list* tl = type->Types();
const char* kp = (const char*) k->Key(); const char* kp = (const char*) k->Key();
const char* const k_end = kp + k->Size(); const char* const k_end = kp + k->Size();
for ( const auto& type : *tl ) for ( const auto& type : *tl )
{ {
Val* v = nullptr; IntrusivePtr<Val> v;
kp = RecoverOneVal(k, kp, k_end, type, v, false); kp = RecoverOneVal(k, kp, k_end, type, v, false);
ASSERT(v); ASSERT(v);
l->Append(v); l->Append(v.release());
} }
if ( kp != k_end ) if ( kp != k_end )
@ -743,7 +743,7 @@ ListVal* CompositeHash::RecoverVals(const HashKey* k) const
const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0, const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
const char* const k_end, BroType* t, const char* const k_end, BroType* t,
Val*& pval, bool optional) const IntrusivePtr<Val>& pval, bool optional) const
{ {
// k->Size() == 0 for a single empty string. // k->Size() == 0 for a single empty string.
if ( kp0 >= k_end && k->Size() > 0 ) if ( kp0 >= k_end && k->Size() > 0 )
@ -772,11 +772,11 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
if ( tag == TYPE_ENUM ) if ( tag == TYPE_ENUM )
pval = t->AsEnumType()->GetVal(*kp).release(); pval = t->AsEnumType()->GetVal(*kp);
else if ( tag == TYPE_BOOL ) else if ( tag == TYPE_BOOL )
pval = val_mgr->GetBool(*kp); pval = {AdoptRef{}, val_mgr->GetBool(*kp)};
else if ( tag == TYPE_INT ) else if ( tag == TYPE_INT )
pval = val_mgr->GetInt(*kp); pval = {AdoptRef{}, val_mgr->GetInt(*kp)};
else else
{ {
reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()"); reporter->InternalError("bad internal unsigned int in CompositeHash::RecoverOneVal()");
@ -793,11 +793,11 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
switch ( tag ) { switch ( tag ) {
case TYPE_COUNT: case TYPE_COUNT:
case TYPE_COUNTER: case TYPE_COUNTER:
pval = val_mgr->GetCount(*kp); pval = {AdoptRef{}, val_mgr->GetCount(*kp)};
break; break;
case TYPE_PORT: case TYPE_PORT:
pval = val_mgr->GetPort(*kp); pval = {AdoptRef{}, val_mgr->GetPort(*kp)};
break; break;
default: default:
@ -814,9 +814,9 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
if ( tag == TYPE_INTERVAL ) if ( tag == TYPE_INTERVAL )
pval = new IntervalVal(*kp, 1.0); pval = make_intrusive<IntervalVal>(*kp, 1.0);
else else
pval = new Val(*kp, tag); pval = make_intrusive<Val>(*kp, tag);
} }
break; break;
@ -829,7 +829,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
switch ( tag ) { switch ( tag ) {
case TYPE_ADDR: case TYPE_ADDR:
pval = new AddrVal(addr); pval = make_intrusive<AddrVal>(addr);
break; break;
default: default:
@ -844,7 +844,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
{ {
const uint32_t* const kp = AlignType<uint32_t>(kp0); const uint32_t* const kp = AlignType<uint32_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+5); kp1 = reinterpret_cast<const char*>(kp+5);
pval = new SubNetVal(kp, kp[4]); pval = make_intrusive<SubNetVal>(kp, kp[4]);
} }
break; break;
@ -862,7 +862,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
if ( ! f ) if ( ! f )
reporter->InternalError("failed to look up unique function id %" PRIu32 " in CompositeHash::RecoverOneVal()", *kp); reporter->InternalError("failed to look up unique function id %" PRIu32 " in CompositeHash::RecoverOneVal()", *kp);
pval = new Val(f); pval = make_intrusive<Val>(f);
if ( ! pval->Type() ) if ( ! pval->Type() )
reporter->InternalError("bad aggregate Val in CompositeHash::RecoverOneVal()"); reporter->InternalError("bad aggregate Val in CompositeHash::RecoverOneVal()");
@ -898,7 +898,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
re = new RE_Matcher(kp1, kp1 + len[0]); re = new RE_Matcher(kp1, kp1 + len[0]);
kp1 += len[0] + len[1]; kp1 += len[0] + len[1];
} }
pval = new PatternVal(re); pval = make_intrusive<PatternVal>(re);
} }
break; break;
@ -912,7 +912,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
int i; int i;
for ( i = 0; i < num_fields; ++i ) for ( i = 0; i < num_fields; ++i )
{ {
Val* v; IntrusivePtr<Val> v;
Attributes* a = rt->FieldDecl(i)->attrs; Attributes* a = rt->FieldDecl(i)->attrs;
bool optional = (a && a->FindAttr(ATTR_OPTIONAL)); bool optional = (a && a->FindAttr(ATTR_OPTIONAL));
@ -930,17 +930,17 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
break; break;
} }
values.push_back(v); values.push_back(v.release());
} }
ASSERT(int(values.size()) == num_fields); ASSERT(int(values.size()) == num_fields);
RecordVal* rv = new RecordVal(rt); auto rv = make_intrusive<RecordVal>(rt);
for ( int i = 0; i < num_fields; ++i ) for ( int i = 0; i < num_fields; ++i )
rv->Assign(i, values[i]); rv->Assign(i, values[i]);
pval = rv; pval = std::move(rv);
kp1 = kp; kp1 = kp;
} }
break; break;
@ -952,19 +952,19 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
n = *kp; n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
TableType* tt = t->AsTableType(); TableType* tt = t->AsTableType();
TableVal* tv = new TableVal(tt); auto tv = make_intrusive<TableVal>(tt);
vector<Val*> keys, values; vector<Val*> keys, values;
for ( int i = 0; i < n; ++i ) for ( int i = 0; i < n; ++i )
{ {
Val* key; IntrusivePtr<Val> key;
kp1 = RecoverOneVal(k, kp1, k_end, tt->Indices(), key, false); kp1 = RecoverOneVal(k, kp1, k_end, tt->Indices(), key, false);
keys.push_back(key); keys.push_back(key.release());
if ( ! t->IsSet() ) if ( ! t->IsSet() )
{ {
Val* value; IntrusivePtr<Val> value;
kp1 = RecoverOneVal(k, kp1, k_end, tt->YieldType(), value, kp1 = RecoverOneVal(k, kp1, k_end, tt->YieldType(), value,
false); false);
values.push_back(value); values.push_back(value.release());
} }
} }
@ -974,7 +974,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
Unref(keys[i]); Unref(keys[i]);
} }
pval = tv; pval = std::move(tv);
} }
break; break;
@ -985,7 +985,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
n = *kp; n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
VectorType* vt = t->AsVectorType(); VectorType* vt = t->AsVectorType();
VectorVal* vv = new VectorVal(vt); auto vv = make_intrusive<VectorVal>(vt);
for ( unsigned int i = 0; i < n; ++i ) for ( unsigned int i = 0; i < n; ++i )
{ {
kp = AlignType<unsigned int>(kp1); kp = AlignType<unsigned int>(kp1);
@ -994,14 +994,14 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
kp = AlignType<unsigned int>(kp1); kp = AlignType<unsigned int>(kp1);
unsigned int have_val = *kp; unsigned int have_val = *kp;
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
Val* value = 0; IntrusivePtr<Val> value;
if ( have_val ) if ( have_val )
kp1 = RecoverOneVal(k, kp1, k_end, vt->YieldType(), value, kp1 = RecoverOneVal(k, kp1, k_end, vt->YieldType(), value,
false); false);
vv->Assign(index, value); vv->Assign(index, std::move(value));
} }
pval = vv; pval = std::move(vv);
} }
break; break;
@ -1012,16 +1012,16 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
n = *kp; n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
TypeList* tl = t->AsTypeList(); TypeList* tl = t->AsTypeList();
ListVal* lv = new ListVal(TYPE_ANY); auto lv = make_intrusive<ListVal>(TYPE_ANY);
for ( int i = 0; i < n; ++i ) for ( int i = 0; i < n; ++i )
{ {
Val* v; IntrusivePtr<Val> v;
BroType* it = (*tl->Types())[i]; BroType* it = (*tl->Types())[i];
kp1 = RecoverOneVal(k, kp1, k_end, it, v, false); kp1 = RecoverOneVal(k, kp1, k_end, it, v, false);
lv->Append(v); lv->Append(v.release());
} }
pval = lv; pval = std::move(lv);
} }
break; break;
@ -1051,7 +1051,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
kp1 = reinterpret_cast<const char*>(kp+1); kp1 = reinterpret_cast<const char*>(kp+1);
} }
pval = new StringVal(new BroString((const byte_vec) kp1, n, 1)); pval = make_intrusive<StringVal>(new BroString((const byte_vec) kp1, n, 1));
kp1 += n; kp1 += n;
} }
break; break;

4
src/CompHash.h
View file

@ -18,7 +18,7 @@ public:
HashKey* ComputeHash(const Val* v, int type_check) const; HashKey* ComputeHash(const Val* v, int type_check) const;
// Given a hash key, recover the values used to create it. // Given a hash key, recover the values used to create it.
ListVal* RecoverVals(const HashKey* k) const; IntrusivePtr<ListVal> RecoverVals(const HashKey* k) const;
unsigned int MemoryAllocation() const { return padded_sizeof(*this) + pad_size(size); } unsigned int MemoryAllocation() const { return padded_sizeof(*this) + pad_size(size); }
@ -36,7 +36,7 @@ protected:
// upon errors, so there is no return value for invalid input. // upon errors, so there is no return value for invalid input.
const char* RecoverOneVal(const HashKey* k, const char* RecoverOneVal(const HashKey* k,
const char* kp, const char* const k_end, const char* kp, const char* const k_end,
BroType* t, Val*& pval, bool optional) const; BroType* t, IntrusivePtr<Val>& pval, bool optional) const;
// Rounds the given pointer up to the nearest multiple of the // Rounds the given pointer up to the nearest multiple of the
// given size, if not already a multiple. // given size, if not already a multiple.

24
src/Val.cc
View file

@ -1568,10 +1568,9 @@ int TableVal::AddTo(Val* val, int is_first_init, bool propagate_ops) const
{ {
if ( is_first_init && t->AsTable()->Lookup(k) ) if ( is_first_init && t->AsTable()->Lookup(k) )
{ {
Val* key = table_hash->RecoverVals(k); auto key = table_hash->RecoverVals(k);
// ### Shouldn't complain if their values are equal. // ### Shouldn't complain if their values are equal.
key->Warn("multiple initializations for index"); key->Warn("multiple initializations for index");
Unref(key);
continue; continue;
} }
@ -1959,7 +1958,7 @@ bool TableVal::UpdateTimestamp(Val* index)
ListVal* TableVal::RecoverIndex(const HashKey* k) const ListVal* TableVal::RecoverIndex(const HashKey* k) const
{ {
return table_hash->RecoverVals(k); return table_hash->RecoverVals(k).release();
} }
void TableVal::CallChangeFunc(const Val* index, Val* old_value, OnChangeType tpe) void TableVal::CallChangeFunc(const Val* index, Val* old_value, OnChangeType tpe)
@ -2047,10 +2046,9 @@ Val* TableVal::Delete(const HashKey* k)
if ( subnets ) if ( subnets )
{ {
Val* index = table_hash->RecoverVals(k); auto index = table_hash->RecoverVals(k);
if ( ! subnets->Remove(index) ) if ( ! subnets->Remove(index.get()) )
reporter->InternalWarning("index not in prefix table"); reporter->InternalWarning("index not in prefix table");
Unref(index);
} }
delete v; delete v;
@ -2060,8 +2058,7 @@ Val* TableVal::Delete(const HashKey* k)
if ( change_func && va ) if ( change_func && va )
{ {
auto index = table_hash->RecoverVals(k); auto index = table_hash->RecoverVals(k);
CallChangeFunc(index, va->Ref(), ELEMENT_REMOVED); CallChangeFunc(index.get(), va->Ref(), ELEMENT_REMOVED);
Unref(index);
} }
return va; return va;
@ -2077,19 +2074,17 @@ ListVal* TableVal::ConvertToList(TypeTag t) const
HashKey* k; HashKey* k;
while ( tbl->NextEntry(k, c) ) while ( tbl->NextEntry(k, c) )
{ {
ListVal* index = table_hash->RecoverVals(k); auto index = table_hash->RecoverVals(k);
if ( t == TYPE_ANY ) if ( t == TYPE_ANY )
l->Append(index); l->Append(index.release());
else else
{ {
// We're expecting a pure list, flatten the // We're expecting a pure list, flatten the
// ListVal. // ListVal.
if ( index->Length() != 1 ) if ( index->Length() != 1 )
InternalWarning("bad index in TableVal::ConvertToList"); InternalWarning("bad index in TableVal::ConvertToList");
Val* flat_v = index->Index(0)->Ref(); l->Append(index->Index(0)->Ref());
Unref(index);
l->Append(flat_v);
} }
delete k; delete k;
@ -2144,7 +2139,7 @@ void TableVal::Describe(ODesc* d) const
if ( ! v ) if ( ! v )
reporter->InternalError("hash table underflow in TableVal::Describe"); reporter->InternalError("hash table underflow in TableVal::Describe");
ListVal* vl = table_hash->RecoverVals(k); auto vl = table_hash->RecoverVals(k);
int dim = vl->Length(); int dim = vl->Length();
if ( i > 0 ) if ( i > 0 )
@ -2169,7 +2164,6 @@ void TableVal::Describe(ODesc* d) const
vl->Describe(d); vl->Describe(d);
delete k; delete k;
Unref(vl);
if ( table_type->IsSet() ) if ( table_type->IsSet() )
{ // We're a set, not a table. { // We're a set, not a table.