From a907732e25a62de23699de66f4b86aefd843c2c6 Mon Sep 17 00:00:00 2001 From: Dev Bali Date: Mon, 4 Nov 2019 16:52:56 -0800 Subject: [PATCH 1/2] Added support to create a Hashkey for PatternVals using their Pattern Texts --- src/CompHash.cc | 15 +++++++++++++++ src/Type.cc | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/CompHash.cc b/src/CompHash.cc index 327778c5c5..6fbe765e08 100644 --- a/src/CompHash.cc +++ b/src/CompHash.cc @@ -401,6 +401,21 @@ HashKey* CompositeHash::ComputeSingletonHash(const Val* v, int type_check) const if ( v->Type()->Tag() == TYPE_FUNC ) return new HashKey(v->AsFunc()->GetUniqueFuncID()); + if (v->Type()->Tag() == TYPE_PATTERN) { + char* texts[2] = { + v->AsPattern()->PatternText(), + v->AsPattern()->AnywherePatternText() + }; + + char key [ sizeof(size_t) * 2 + strlen(texts[0]) + strlen(texts[1]) ]; + std::memcpy(key, strlen(texts[0]), sizeof(size_t)); + std::memcpy(*(key + sizeof(size_t)), strlen(texts[1]), sizeof(size_t)); + std::memcpy(key + 2 * sizeof(size_t), texts[0], strlen(texts[0])); + std::memcpy(key + 2 * sizeof(size_t) + strlen(texts[0]), texts[1], strlen(texts[1])); + + return new HashKey(key); + } + reporter->InternalError("bad index type in CompositeHash::ComputeSingletonHash"); return 0; diff --git a/src/Type.cc b/src/Type.cc index c3e12f5a29..975cf9eb88 100644 --- a/src/Type.cc +++ b/src/Type.cc @@ -391,7 +391,7 @@ TableType::TableType(TypeList* ind, BroType* yield) // Allow functions, since they can be compared // for Func* pointer equality. if ( t == TYPE_INTERNAL_OTHER && tli->Tag() != TYPE_FUNC && - tli->Tag() != TYPE_RECORD ) + tli->Tag() != TYPE_RECORD && tli->Tag() != TYPE_PATTERN) { tli->Error("bad index type"); SetError(); From 4002a1124e2b179049a4c171ed5f697958001773 Mon Sep 17 00:00:00 2001 From: Dev Bali Date: Thu, 19 Dec 2019 18:31:32 -0800 Subject: [PATCH 2/2] Enable Patterns as Table index in non singleton cases --- src/CompHash.cc | 78 ++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 67 insertions(+), 11 deletions(-) diff --git a/src/CompHash.cc b/src/CompHash.cc index 6fbe765e08..a68319f528 100644 --- a/src/CompHash.cc +++ b/src/CompHash.cc @@ -146,6 +146,30 @@ char* CompositeHash::SingleValHash(int type_check, char* kp0, break; } + case TYPE_PATTERN: + { + const char* texts[2] = { + v->AsPattern()->PatternText(), + v->AsPattern()->AnywherePatternText() + }; + + size_t* kp; + for (int i = 0; i < 2; i++) + { + kp = AlignAndPadType(kp0+i); + *kp = strlen(texts[i]) + 1; + } + + kp1 = reinterpret_cast(kp+1); + for (int i = 0; i < 2; i++) + { + memcpy(kp1, texts[i], strlen(texts[i]) + 1); + kp1 += strlen(texts[i]) + 1; + } + + break; + } + case TYPE_RECORD: { char* kp = kp0; @@ -401,20 +425,19 @@ HashKey* CompositeHash::ComputeSingletonHash(const Val* v, int type_check) const if ( v->Type()->Tag() == TYPE_FUNC ) return new HashKey(v->AsFunc()->GetUniqueFuncID()); - if (v->Type()->Tag() == TYPE_PATTERN) { - char* texts[2] = { + if (v->Type()->Tag() == TYPE_PATTERN) + { + const char* texts[2] = { v->AsPattern()->PatternText(), v->AsPattern()->AnywherePatternText() }; - - char key [ sizeof(size_t) * 2 + strlen(texts[0]) + strlen(texts[1]) ]; - std::memcpy(key, strlen(texts[0]), sizeof(size_t)); - std::memcpy(*(key + sizeof(size_t)), strlen(texts[1]), sizeof(size_t)); - std::memcpy(key + 2 * sizeof(size_t), texts[0], strlen(texts[0])); - std::memcpy(key + 2 * sizeof(size_t) + strlen(texts[0]), texts[1], strlen(texts[1])); - - return new HashKey(key); - } + int n = strlen(texts[0]) + strlen(texts[1]) + 2; // 2 for null + char* key = new char[n]; + std::memcpy(key, texts[0], strlen(texts[0]) + 1); + std::memcpy(key + strlen(texts[0]) + 1, texts[1], strlen(texts[1]) + 1); + //std::cout << "Singleton key of " << v->AsPattern()->PatternText() << "; " << key << std::endl; + return new HashKey(reinterpret_cast(key), n); + } reporter->InternalError("bad index type in CompositeHash::ComputeSingletonHash"); return 0; @@ -477,6 +500,17 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v, break; } + case TYPE_PATTERN: + { + if ( ! v ) + return (optional && ! calc_static_size) ? sz : 0; + + sz = SizeAlign(sz, 2 * sizeof(size_t)); + sz += strlen(v->AsPattern()->PatternText()) + + strlen(v->AsPattern()->AnywherePatternText()) + 2; // 2 for null terminators + break; + } + case TYPE_RECORD: { const RecordVal* rv = v ? v->AsRecordVal() : 0; @@ -846,6 +880,28 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0, } break; + case TYPE_PATTERN: + { + RE_Matcher* re = nullptr; + if ( is_singleton ) + { + kp1 = kp0; + int divider = strlen(kp0) + 1; + re = new RE_Matcher(kp1, kp1 + divider); + kp1 += k->Size(); + } + else + { + const size_t* const len = AlignType(kp0); + + kp1 = reinterpret_cast(len+2); + re = new RE_Matcher(kp1, kp1 + len[0]); + kp1 += len[0] + len[1]; + } + pval = new PatternVal(re); + } + break; + case TYPE_RECORD: { const char* kp = kp0;