Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 22:58:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Deprecate RecordType::FieldType(), replace with GetFieldType()

Browse source
This commit is contained in:
Jon Siwek 2020-05-07 15:05:43 -07:00
parent 455fc29b1a
commit 103fed9f01
13 changed files with 105 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

2
NEWS
View file

@ -146,6 +146,8 @@ Deprecated Functionality
- The ``utf16_bytestring_to_utf8_val()`` function is deprecated, use - The ``utf16_bytestring_to_utf8_val()`` function is deprecated, use
``utf16_to_utf8_val()`` instead. ``utf16_to_utf8_val()`` instead.
- ``RecordType::FieldType()`` is deprecated, use ``RecordType::GetFieldType()``
Zeek 3.1.0 Zeek 3.1.0
========== ==========

6
src/CompHash.cc
View file

@ -189,7 +189,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
return nullptr; return nullptr;
if ( ! (kp = SingleValHash(type_check, kp, if ( ! (kp = SingleValHash(type_check, kp,
rt->FieldType(i), rt->GetFieldType(i).get(),
rv_i, optional)) ) rv_i, optional)) )
return nullptr; return nullptr;
} }
@ -517,7 +517,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
Attributes* a = rt->FieldDecl(i)->attrs.get(); Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->FindAttr(ATTR_OPTIONAL)); bool optional = (a && a->FindAttr(ATTR_OPTIONAL));
sz = SingleTypeKeySize(rt->FieldType(i), sz = SingleTypeKeySize(rt->GetFieldType(i).get(),
rv ? rv->Lookup(i) : nullptr, rv ? rv->Lookup(i) : nullptr,
type_check, sz, optional, type_check, sz, optional,
calc_static_size); calc_static_size);
@ -910,7 +910,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
bool optional = (a && a->FindAttr(ATTR_OPTIONAL)); bool optional = (a && a->FindAttr(ATTR_OPTIONAL));
kp = RecoverOneVal(k, kp, k_end, kp = RecoverOneVal(k, kp, k_end,
rt->FieldType(i), &v, optional); rt->GetFieldType(i).get(), &v, optional);
// An earlier call to reporter->InternalError would have called abort() and broken the // An earlier call to reporter->InternalError would have called abort() and broken the
// call tree that clang-tidy is relying on to get the error described. // call tree that clang-tidy is relying on to get the error described.

2
src/EventHandler.cc
View file

@ -132,7 +132,7 @@ void EventHandler::NewEvent(const zeek::Args& vl)
for ( int i = 0; i < args->NumFields(); i++ ) for ( int i = 0; i < args->NumFields(); i++ )
{ {
const char* fname = args->FieldName(i); const char* fname = args->FieldName(i);
BroType* ftype = args->FieldType(i); const auto& ftype = args->GetFieldType(i);
auto fdefault = args->FieldDefault(i); auto fdefault = args->FieldDefault(i);
auto rec = make_intrusive<RecordVal>(call_argument); auto rec = make_intrusive<RecordVal>(call_argument);

20
src/Expr.cc
View file

@ -2373,7 +2373,7 @@ IntrusivePtr<Val> AssignExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr)
RecordVal* aggr_r = aggr->AsRecordVal(); RecordVal* aggr_r = aggr->AsRecordVal();
auto v = op2->InitVal(rt->FieldType(td.id), nullptr); auto v = op2->InitVal(rt->GetFieldType(td.id).get(), nullptr);
if ( ! v ) if ( ! v )
return nullptr; return nullptr;
@ -2867,7 +2867,7 @@ FieldExpr::FieldExpr(IntrusivePtr<Expr> arg_op, const char* arg_field_name)
ExprError("no such field in record"); ExprError("no such field in record");
else else
{ {
SetType({NewRef{}, rt->FieldType(field)}); SetType(rt->GetFieldType(field));
td = rt->FieldDecl(field); td = rt->FieldDecl(field);
if ( rt->IsFieldDeprecated(field) ) if ( rt->IsFieldDeprecated(field) )
@ -3565,8 +3565,8 @@ RecordCoerceExpr::RecordCoerceExpr(IntrusivePtr<Expr> arg_op,
break; break;
} }
BroType* sub_t_i = sub_r->FieldType(i); BroType* sub_t_i = sub_r->GetFieldType(i).get();
BroType* sup_t_i = t_r->FieldType(t_i); BroType* sup_t_i = t_r->GetFieldType(t_i).get();
if ( ! same_type(sup_t_i, sub_t_i) ) if ( ! same_type(sup_t_i, sub_t_i) )
{ {
@ -3685,7 +3685,7 @@ IntrusivePtr<Val> RecordCoerceExpr::Fold(Val* v) const
} }
BroType* rhs_type = rhs->Type(); BroType* rhs_type = rhs->Type();
BroType* field_type = val_type->FieldType(i); BroType* field_type = val_type->GetFieldType(i).get();
if ( rhs_type->Tag() == TYPE_RECORD && if ( rhs_type->Tag() == TYPE_RECORD &&
field_type->Tag() == TYPE_RECORD && field_type->Tag() == TYPE_RECORD &&
@ -3711,11 +3711,11 @@ IntrusivePtr<Val> RecordCoerceExpr::Fold(Val* v) const
{ {
auto def_val = def->AttrExpr()->Eval(nullptr); auto def_val = def->AttrExpr()->Eval(nullptr);
BroType* def_type = def_val->Type(); BroType* def_type = def_val->Type();
BroType* field_type = Type()->AsRecordType()->FieldType(i); const auto& field_type = Type()->AsRecordType()->GetFieldType(i);
if ( def_type->Tag() == TYPE_RECORD && if ( def_type->Tag() == TYPE_RECORD &&
field_type->Tag() == TYPE_RECORD && field_type->Tag() == TYPE_RECORD &&
! same_type(def_type, field_type) ) ! same_type(def_type, field_type.get()) )
{ {
auto tmp = def_val->AsRecordVal()->CoerceTo( auto tmp = def_val->AsRecordVal()->CoerceTo(
field_type->AsRecordType()); field_type->AsRecordType());
@ -3814,7 +3814,7 @@ FlattenExpr::FlattenExpr(IntrusivePtr<Expr> arg_op)
auto tl = make_intrusive<TypeList>(); auto tl = make_intrusive<TypeList>();
for ( int i = 0; i < num_fields; ++i ) for ( int i = 0; i < num_fields; ++i )
tl->Append({NewRef{}, rt->FieldType(i)}); tl->Append(rt->GetFieldType(i));
Unref(rt); Unref(rt);
SetType(std::move(tl)); SetType(std::move(tl));
@ -4809,7 +4809,7 @@ RecordAssignExpr::RecordAssignExpr(const IntrusivePtr<Expr>& record,
int field = lhs->FieldOffset(field_name); int field = lhs->FieldOffset(field_name);
if ( field >= 0 && if ( field >= 0 &&
same_type(lhs->FieldType(field), t->FieldType(j)) ) same_type(lhs->GetFieldType(field).get(), t->GetFieldType(j).get()) )
{ {
auto fe_lhs = make_intrusive<FieldExpr>(record, field_name); auto fe_lhs = make_intrusive<FieldExpr>(record, field_name);
auto fe_rhs = make_intrusive<FieldExpr>(IntrusivePtr{NewRef{}, init}, field_name); auto fe_rhs = make_intrusive<FieldExpr>(IntrusivePtr{NewRef{}, init}, field_name);
@ -5081,7 +5081,7 @@ bool check_and_promote_args(ListExpr* const args, RecordType* types)
TypeList* tl = new TypeList(); TypeList* tl = new TypeList();
for ( int i = 0; i < types->NumFields(); ++i ) for ( int i = 0; i < types->NumFields(); ++i )
tl->Append({NewRef{}, types->FieldType(i)}); tl->Append(types->GetFieldType(i));
int rval = check_and_promote_exprs(args, tl); int rval = check_and_promote_exprs(args, tl);
Unref(tl); Unref(tl);

2
src/ID.cc
View file

@ -187,7 +187,7 @@ void ID::UpdateValAttrs()
TypeDecl* fd = rt->FieldDecl(i); TypeDecl* fd = rt->FieldDecl(i);
if ( ! fd->attrs ) if ( ! fd->attrs )
fd->attrs = make_intrusive<Attributes>(new attr_list, IntrusivePtr{NewRef{}, rt->FieldType(i)}, true, IsGlobal()); fd->attrs = make_intrusive<Attributes>(new attr_list, rt->GetFieldType(i), true, IsGlobal());
fd->attrs->AddAttr(make_intrusive<Attr>(ATTR_LOG)); fd->attrs->AddAttr(make_intrusive<Attr>(ATTR_LOG));
} }

29
src/Type.cc
View file

@ -442,7 +442,7 @@ FuncType::FuncType(IntrusivePtr<RecordType> arg_args,
args->Error(err_str); args->Error(err_str);
} }
arg_types->Append({NewRef{}, args->FieldType(i)}); arg_types->Append(args->GetFieldType(i));
offsets[i] = i; offsets[i] = i;
} }
@ -609,10 +609,10 @@ std::optional<FuncType::Prototype> FuncType::FindPrototype(const RecordType& arg
for ( auto i = 0; i < args.NumFields(); ++i ) for ( auto i = 0; i < args.NumFields(); ++i )
{ {
auto ptype = p.args->FieldType(i); const auto& ptype = p.args->GetFieldType(i);
auto desired_type = args.FieldType(i); const auto& desired_type = args.GetFieldType(i);
if ( ! same_type(ptype, desired_type) || if ( ! same_type(ptype.get(), desired_type.get()) ||
! streq(args.FieldName(i), p.args->FieldName(i)) ) ! streq(args.FieldName(i), p.args->FieldName(i)) )
{ {
matched = false; matched = false;
@ -700,17 +700,6 @@ bool RecordType::HasField(const char* field) const
return FieldOffset(field) >= 0; return FieldOffset(field) >= 0;
} }
BroType* RecordType::FieldType(const char* field) const
{
int offset = FieldOffset(field);
return offset >= 0 ? FieldType(offset) : nullptr;
}
BroType* RecordType::FieldType(int field) const
{
return (*types)[field]->type.get();
}
IntrusivePtr<Val> RecordType::FieldDefault(int field) const IntrusivePtr<Val> RecordType::FieldDefault(int field) const
{ {
const TypeDecl* td = FieldDecl(field); const TypeDecl* td = FieldDecl(field);
@ -830,7 +819,7 @@ IntrusivePtr<TableVal> RecordType::GetRecordFieldsVal(const RecordVal* rv) const
for ( int i = 0; i < NumFields(); ++i ) for ( int i = 0; i < NumFields(); ++i )
{ {
const BroType* ft = FieldType(i); const auto& ft = GetFieldType(i);
const TypeDecl* fd = FieldDecl(i); const TypeDecl* fd = FieldDecl(i);
Val* fv = nullptr; Val* fv = nullptr;
@ -844,7 +833,7 @@ IntrusivePtr<TableVal> RecordType::GetRecordFieldsVal(const RecordVal* rv) const
auto nr = make_intrusive<RecordVal>(internal_type("record_field")->AsRecordType()); auto nr = make_intrusive<RecordVal>(internal_type("record_field")->AsRecordType());
string s = container_type_name(ft); string s = container_type_name(ft.get());
nr->Assign(0, make_intrusive<StringVal>(s)); nr->Assign(0, make_intrusive<StringVal>(s));
nr->Assign(1, val_mgr->Bool(logged)); nr->Assign(1, val_mgr->Bool(logged));
nr->Assign(2, fv); nr->Assign(2, fv);
@ -1656,10 +1645,10 @@ bool record_promotion_compatible(const RecordType* super_rec,
// Orphaned field. // Orphaned field.
continue; continue;
BroType* sub_field_type = sub_rec->FieldType(i); const auto& sub_field_type = sub_rec->GetFieldType(i);
BroType* super_field_type = super_rec->FieldType(o); const auto& super_field_type = super_rec->GetFieldType(o);
if ( same_type(sub_field_type, super_field_type) ) if ( same_type(sub_field_type.get(), super_field_type.get()) )
continue; continue;
if ( sub_field_type->Tag() != TYPE_RECORD ) if ( sub_field_type->Tag() != TYPE_RECORD )

28
src/Type.h
View file

@ -552,8 +552,32 @@ public:
~RecordType() override; ~RecordType() override;
bool HasField(const char* field) const override; bool HasField(const char* field) const override;
BroType* FieldType(const char* field) const override;
BroType* FieldType(int field) const; [[deprecated("Remove in v4.1. Use GetFieldType() instead (note it doesn't check for invalid names).")]]
BroType* FieldType(const char* field) const override
{
auto offset = FieldOffset(field);
return offset >= 0 ? GetFieldType(offset).get() : nullptr;
}
[[deprecated("Remove in v4.1. Use GetFieldType() instead.")]]
BroType* FieldType(int field) const
{ return GetFieldType(field).get(); }
/**
* Looks up a field by name and returns its type. No check for invalid
* field name is performed.
*/
const IntrusivePtr<BroType>& GetFieldType(const char* field_name) const
{ return GetFieldType(FieldOffset(field_name)); }
/**
* Looks up a field by its index and returns its type. No check for
* invalid field offset is performed.
*/
const IntrusivePtr<BroType>& GetFieldType(int field_index) const
{ return (*types)[field_index]->type; }
IntrusivePtr<Val> FieldDefault(int field) const; IntrusivePtr<Val> FieldDefault(int field) const;
// A field's offset is its position in the type_decl_list, // A field's offset is its position in the type_decl_list,

7
src/Val.cc
View file

@ -2817,12 +2817,13 @@ IntrusivePtr<RecordVal> RecordVal::CoerceTo(const RecordType* t, Val* aggr, bool
// Check for allowable optional fields is outside the loop, below. // Check for allowable optional fields is outside the loop, below.
continue; continue;
if ( ar_t->FieldType(t_i)->Tag() == TYPE_RECORD && const auto& ft = ar_t->GetFieldType(t_i);
! same_type(ar_t->FieldType(t_i), v->Type()) )
if ( ft->Tag() == TYPE_RECORD && ! same_type(ft.get(), v->Type()) )
{ {
auto rhs = make_intrusive<ConstExpr>(IntrusivePtr{NewRef{}, v}); auto rhs = make_intrusive<ConstExpr>(IntrusivePtr{NewRef{}, v});
auto e = make_intrusive<RecordCoerceExpr>(std::move(rhs), auto e = make_intrusive<RecordCoerceExpr>(std::move(rhs),
IntrusivePtr{NewRef{}, ar_t->FieldType(t_i)->AsRecordType()}); cast_intrusive<RecordType>(ft));
ar->Assign(t_i, e->Eval(nullptr)); ar->Assign(t_i, e->Eval(nullptr));
continue; continue;
} }

2
src/Var.cc
View file

@ -448,7 +448,7 @@ static bool canonical_arg_types_match(const FuncType* decl, const FuncType* impl
return false; return false;
for ( auto i = 0; i < canon_args->NumFields(); ++i ) for ( auto i = 0; i < canon_args->NumFields(); ++i )
if ( ! same_type(canon_args->FieldType(i), impl_args->FieldType(i)) ) if ( ! same_type(canon_args->GetFieldType(i).get(), impl_args->GetFieldType(i).get()) )
return false; return false;
return true; return true;

4
src/broker/Data.cc
View file

@ -403,7 +403,7 @@ struct val_converter {
} }
auto item_val = bro_broker::data_to_val(move(a[idx]), auto item_val = bro_broker::data_to_val(move(a[idx]),
rt->FieldType(i)); rt->GetFieldType(i).get());
if ( ! item_val ) if ( ! item_val )
return nullptr; return nullptr;
@ -730,7 +730,7 @@ struct type_checker {
continue; continue;
} }
if ( ! data_type_check(a[idx], rt->FieldType(i)) ) if ( ! data_type_check(a[idx], rt->GetFieldType(i).get()) )
return false; return false;
++idx; ++idx;

78
src/input/Manager.cc
View file

@ -366,16 +366,16 @@ bool Manager::CreateEventStream(RecordVal* fval)
for ( int i = 0; i < fields->NumFields(); i++ ) for ( int i = 0; i < fields->NumFields(); i++ )
{ {
if ( ! same_type(args[i + 2].get(), fields->FieldType(i) ) ) if ( ! same_type(args[i + 2].get(), fields->GetFieldType(i).get() ) )
{ {
ODesc desc1; ODesc desc1;
ODesc desc2; ODesc desc2;
args[i + 2]->Describe(&desc1); args[i + 2]->Describe(&desc1);
fields->FieldType(i)->Describe(&desc2); fields->GetFieldType(i)->Describe(&desc2);
reporter->Error("Input stream %s: Incompatible type for event in field %d. Need type '%s':%s, got '%s':%s", reporter->Error("Input stream %s: Incompatible type for event in field %d. Need type '%s':%s, got '%s':%s",
stream_name.c_str(), i + 3, stream_name.c_str(), i + 3,
type_name(fields->FieldType(i)->Tag()), desc2.Description(), type_name(fields->GetFieldType(i)->Tag()), desc2.Description(),
type_name(args[i + 2]->Tag()), desc1.Description()); type_name(args[i + 2]->Tag()), desc1.Description());
return false; return false;
@ -497,15 +497,15 @@ bool Manager::CreateTableStream(RecordVal* fval)
return false; return false;
} }
if ( ! same_type(idx->FieldType(j), tl[j].get()) ) if ( ! same_type(idx->GetFieldType(j).get(), tl[j].get()) )
{ {
ODesc desc1; ODesc desc1;
ODesc desc2; ODesc desc2;
idx->FieldType(j)->Describe(&desc1); idx->GetFieldType(j)->Describe(&desc1);
tl[j]->Describe(&desc2); tl[j]->Describe(&desc2);
reporter->Error("Input stream %s: Table type does not match index type. Need type '%s':%s, got '%s':%s", stream_name.c_str(), reporter->Error("Input stream %s: Table type does not match index type. Need type '%s':%s, got '%s':%s", stream_name.c_str(),
type_name(idx->FieldType(j)->Tag()), desc1.Description(), type_name(idx->GetFieldType(j)->Tag()), desc1.Description(),
type_name(tl[j]->Tag()), desc2.Description()); type_name(tl[j]->Tag()), desc2.Description());
return false; return false;
@ -526,7 +526,7 @@ bool Manager::CreateTableStream(RecordVal* fval)
const BroType* compare_type = val.get(); const BroType* compare_type = val.get();
if ( want_record->InternalInt() == 0 ) if ( want_record->InternalInt() == 0 )
compare_type = val->FieldType(0); compare_type = val->GetFieldType(0).get();
if ( ! same_type(table_yield, compare_type) ) if ( ! same_type(table_yield, compare_type) )
{ {
@ -606,11 +606,11 @@ bool Manager::CreateTableStream(RecordVal* fval)
return false; return false;
} }
else if ( want_record->InternalInt() == 0 else if ( want_record->InternalInt() == 0
&& val && !same_type(args[3].get(), val->FieldType(0) ) ) && val && !same_type(args[3].get(), val->GetFieldType(0).get() ) )
{ {
ODesc desc1; ODesc desc1;
ODesc desc2; ODesc desc2;
val->FieldType(0)->Describe(&desc1); val->GetFieldType(0)->Describe(&desc1);
args[3]->Describe(&desc2); args[3]->Describe(&desc2);
reporter->Error("Input stream %s: Table event's value attribute does not match. Need '%s', got '%s'", stream_name.c_str(), reporter->Error("Input stream %s: Table event's value attribute does not match. Need '%s', got '%s'", stream_name.c_str(),
desc1.Description(), desc2.Description()); desc1.Description(), desc2.Description());
@ -892,7 +892,7 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
for ( int i = 0; i < rec->NumFields(); i++ ) for ( int i = 0; i < rec->NumFields(); i++ )
{ {
if ( ! IsCompatibleType(rec->FieldType(i)) ) if ( ! IsCompatibleType(rec->GetFieldType(i).get()) )
{ {
string name = nameprepend + rec->FieldName(i); string name = nameprepend + rec->FieldName(i);
// If the field is a file, function, or opaque // If the field is a file, function, or opaque
@ -901,21 +901,21 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
// stuff that we actually cannot read :) // stuff that we actually cannot read :)
if ( allow_file_func ) if ( allow_file_func )
{ {
if ( ( rec->FieldType(i)->Tag() == TYPE_FILE || if ( ( rec->GetFieldType(i)->Tag() == TYPE_FILE ||
rec->FieldType(i)->Tag() == TYPE_FUNC || rec->GetFieldType(i)->Tag() == TYPE_FUNC ||
rec->FieldType(i)->Tag() == TYPE_OPAQUE ) && rec->GetFieldType(i)->Tag() == TYPE_OPAQUE ) &&
rec->FieldDecl(i)->FindAttr(ATTR_OPTIONAL) ) rec->FieldDecl(i)->FindAttr(ATTR_OPTIONAL) )
{ {
reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", type_name(rec->FieldType(i)->Tag()), name.c_str()); reporter->Info("Encountered incompatible type \"%s\" in type definition for field \"%s\" in ReaderFrontend. Ignoring optional field.", type_name(rec->GetFieldType(i)->Tag()), name.c_str());
continue; continue;
} }
} }
reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", type_name(rec->FieldType(i)->Tag()), name.c_str()); reporter->Error("Incompatible type \"%s\" in type definition for for field \"%s\" in ReaderFrontend", type_name(rec->GetFieldType(i)->Tag()), name.c_str());
return false; return false;
} }
if ( rec->FieldType(i)->Tag() == TYPE_RECORD ) if ( rec->GetFieldType(i)->Tag() == TYPE_RECORD )
{ {
string prep = nameprepend + rec->FieldName(i) + "."; string prep = nameprepend + rec->FieldName(i) + ".";
@ -925,7 +925,7 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
return false; return false;
} }
if ( !UnrollRecordType(fields, rec->FieldType(i)->AsRecordType(), prep, allow_file_func) ) if ( !UnrollRecordType(fields, rec->GetFieldType(i)->AsRecordType(), prep, allow_file_func) )
{ {
return false; return false;
} }
@ -937,15 +937,15 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
string name = nameprepend + rec->FieldName(i); string name = nameprepend + rec->FieldName(i);
const char* secondary = nullptr; const char* secondary = nullptr;
IntrusivePtr<Val> c; IntrusivePtr<Val> c;
TypeTag ty = rec->FieldType(i)->Tag(); TypeTag ty = rec->GetFieldType(i)->Tag();
TypeTag st = TYPE_VOID; TypeTag st = TYPE_VOID;
bool optional = false; bool optional = false;
if ( ty == TYPE_TABLE ) if ( ty == TYPE_TABLE )
st = rec->FieldType(i)->AsSetType()->Indices()->GetPureType()->Tag(); st = rec->GetFieldType(i)->AsSetType()->Indices()->GetPureType()->Tag();
else if ( ty == TYPE_VECTOR ) else if ( ty == TYPE_VECTOR )
st = rec->FieldType(i)->AsVectorType()->YieldType()->Tag(); st = rec->GetFieldType(i)->AsVectorType()->YieldType()->Tag();
else if ( ty == TYPE_PORT && else if ( ty == TYPE_PORT &&
rec->FieldDecl(i)->FindAttr(ATTR_TYPE_COLUMN) ) rec->FieldDecl(i)->FindAttr(ATTR_TYPE_COLUMN) )
@ -1027,9 +1027,9 @@ Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType
int position = 0; int position = 0;
if ( num_fields == 1 && type->FieldType(0)->Tag() != TYPE_RECORD ) if ( num_fields == 1 && type->GetFieldType(0)->Tag() != TYPE_RECORD )
{ {
idxval = ValueToVal(i, vals[0], type->FieldType(0), have_error); idxval = ValueToVal(i, vals[0], type->GetFieldType(0).get(), have_error);
position = 1; position = 1;
} }
else else
@ -1037,12 +1037,12 @@ Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType
ListVal *l = new ListVal(TYPE_ANY); ListVal *l = new ListVal(TYPE_ANY);
for ( int j = 0 ; j < type->NumFields(); j++ ) for ( int j = 0 ; j < type->NumFields(); j++ )
{ {
if ( type->FieldType(j)->Tag() == TYPE_RECORD ) if ( type->GetFieldType(j)->Tag() == TYPE_RECORD )
l->Append({AdoptRef{}, ValueToRecordVal(i, vals, l->Append({AdoptRef{}, ValueToRecordVal(i, vals,
type->FieldType(j)->AsRecordType(), &position, have_error)}); type->GetFieldType(j)->AsRecordType(), &position, have_error)});
else else
{ {
l->Append({AdoptRef{}, ValueToVal(i, vals[position], type->FieldType(j), have_error)}); l->Append({AdoptRef{}, ValueToVal(i, vals[position], type->GetFieldType(j).get(), have_error)});
position++; position++;
} }
} }
@ -1158,7 +1158,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals)
valval = nullptr; valval = nullptr;
else if ( stream->num_val_fields == 1 && !stream->want_record ) else if ( stream->num_val_fields == 1 && !stream->want_record )
valval = ValueToVal(i, vals[position], stream->rtype->FieldType(0), convert_error); valval = ValueToVal(i, vals[position], stream->rtype->GetFieldType(0).get(), convert_error);
else else
valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error); valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error);
@ -1502,14 +1502,14 @@ int Manager::SendEventStreamEvent(Stream* i, EnumVal* type, const Value* const *
{ {
Val* val = nullptr; Val* val = nullptr;
if ( stream->fields->FieldType(j)->Tag() == TYPE_RECORD ) if ( stream->fields->GetFieldType(j)->Tag() == TYPE_RECORD )
val = ValueToRecordVal(i, vals, val = ValueToRecordVal(i, vals,
stream->fields->FieldType(j)->AsRecordType(), stream->fields->GetFieldType(j)->AsRecordType(),
&position, convert_error); &position, convert_error);
else else
{ {
val = ValueToVal(i, vals[position], stream->fields->FieldType(j), convert_error); val = ValueToVal(i, vals[position], stream->fields->GetFieldType(j).get(), convert_error);
position++; position++;
} }
@ -1547,7 +1547,7 @@ int Manager::PutTable(Stream* i, const Value* const *vals)
valval = nullptr; valval = nullptr;
else if ( stream->num_val_fields == 1 && stream->want_record == 0 ) else if ( stream->num_val_fields == 1 && stream->want_record == 0 )
valval = ValueToVal(i, vals[position], stream->rtype->FieldType(0), convert_error); valval = ValueToVal(i, vals[position], stream->rtype->GetFieldType(0).get(), convert_error);
else else
valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error); valval = ValueToRecordVal(i, vals, stream->rtype, &position, convert_error);
@ -1845,10 +1845,10 @@ bool Manager::SendEvent(ReaderFrontend* reader, const string& name, const int nu
Val* v = ValueToVal(i, vals[j], convert_error); Val* v = ValueToVal(i, vals[j], convert_error);
vl.emplace_back(AdoptRef{}, v); vl.emplace_back(AdoptRef{}, v);
if ( v && ! convert_error && ! same_type(type->FieldType(j), v->Type()) ) if ( v && ! convert_error && ! same_type(type->GetFieldType(j).get(), v->Type()) )
{ {
convert_error = true; convert_error = true;
type->FieldType(j)->Error("SendEvent types do not match", v->Type()); type->GetFieldType(j)->Error("SendEvent types do not match", v->Type());
} }
} }
@ -1916,8 +1916,8 @@ RecordVal* Manager::ListValToRecordVal(ListVal* list, RecordType *request_type,
assert ( (*position) <= maxpos ); assert ( (*position) <= maxpos );
Val* fieldVal = nullptr; Val* fieldVal = nullptr;
if ( request_type->FieldType(i)->Tag() == TYPE_RECORD ) if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ListValToRecordVal(list, request_type->FieldType(i)->AsRecordType(), position); fieldVal = ListValToRecordVal(list, request_type->GetFieldType(i)->AsRecordType(), position);
else else
{ {
fieldVal = list->Idx(*position).get(); fieldVal = list->Idx(*position).get();
@ -1940,10 +1940,10 @@ RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *v
for ( int i = 0; i < request_type->NumFields(); i++ ) for ( int i = 0; i < request_type->NumFields(); i++ )
{ {
Val* fieldVal = nullptr; Val* fieldVal = nullptr;
if ( request_type->FieldType(i)->Tag() == TYPE_RECORD ) if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ValueToRecordVal(stream, vals, request_type->FieldType(i)->AsRecordType(), position, have_error); fieldVal = ValueToRecordVal(stream, vals, request_type->GetFieldType(i)->AsRecordType(), position, have_error);
else if ( request_type->FieldType(i)->Tag() == TYPE_FILE || else if ( request_type->GetFieldType(i)->Tag() == TYPE_FILE ||
request_type->FieldType(i)->Tag() == TYPE_FUNC ) request_type->GetFieldType(i)->Tag() == TYPE_FUNC )
{ {
// If those two unsupported types are encountered here, they have // If those two unsupported types are encountered here, they have
// been let through by the type checking. // been let through by the type checking.
@ -1956,7 +1956,7 @@ RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *v
} }
else else
{ {
fieldVal = ValueToVal(stream, vals[*position], request_type->FieldType(i), have_error); fieldVal = ValueToVal(stream, vals[*position], request_type->GetFieldType(i).get(), have_error);
(*position)++; (*position)++;
} }

6
src/logging/Manager.cc
View file

@ -247,7 +247,7 @@ bool Manager::CreateStream(EnumVal* id, RecordVal* sval)
if ( ! (columns->FieldDecl(i)->FindAttr(ATTR_LOG)) ) if ( ! (columns->FieldDecl(i)->FindAttr(ATTR_LOG)) )
continue; continue;
if ( ! threading::Value::IsCompatibleType(columns->FieldType(i)) ) if ( ! threading::Value::IsCompatibleType(columns->GetFieldType(i).get()) )
{ {
reporter->Error("type of field '%s' is not support for logging output", reporter->Error("type of field '%s' is not support for logging output",
columns->FieldName(i)); columns->FieldName(i));
@ -409,7 +409,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, RecordType* rt,
rtype = rt; rtype = rt;
} }
BroType* t = rtype->FieldType(i); const auto& t = rtype->GetFieldType(i);
// Ignore if &log not specified. // Ignore if &log not specified.
if ( ! rtype->FieldDecl(i)->FindAttr(ATTR_LOG) ) if ( ! rtype->FieldDecl(i)->FindAttr(ATTR_LOG) )
@ -744,7 +744,7 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg)
path_arg = val_mgr->EmptyString(); path_arg = val_mgr->EmptyString();
IntrusivePtr<Val> rec_arg; IntrusivePtr<Val> rec_arg;
BroType* rt = filter->path_func->FType()->Args()->FieldType("rec"); const auto& rt = filter->path_func->FType()->Args()->GetFieldType("rec");
if ( rt->Tag() == TYPE_RECORD ) if ( rt->Tag() == TYPE_RECORD )
rec_arg = columns->CoerceTo(rt->AsRecordType(), true); rec_arg = columns->CoerceTo(rt->AsRecordType(), true);

8
src/supervisor/Supervisor.cc
View file

@ -1123,14 +1123,14 @@ IntrusivePtr<RecordVal> Supervisor::NodeConfig::ToRecord() const
if ( cpu_affinity ) if ( cpu_affinity )
rval->Assign(rt->FieldOffset("cpu_affinity"), val_mgr->Int(*cpu_affinity)); rval->Assign(rt->FieldOffset("cpu_affinity"), val_mgr->Int(*cpu_affinity));
auto st = BifType::Record::Supervisor::NodeConfig->FieldType("scripts"); const auto& st = rt->GetFieldType("scripts");
auto scripts_val = new VectorVal(st->AsVectorType()); auto scripts_val = new VectorVal(st->AsVectorType());
rval->Assign(rt->FieldOffset("scripts"), scripts_val); rval->Assign(rt->FieldOffset("scripts"), scripts_val);
for ( const auto& s : scripts ) for ( const auto& s : scripts )
scripts_val->Assign(scripts_val->Size(), make_intrusive<StringVal>(s)); scripts_val->Assign(scripts_val->Size(), make_intrusive<StringVal>(s));
auto tt = BifType::Record::Supervisor::NodeConfig->FieldType("cluster"); const auto& tt = rt->GetFieldType("cluster");
auto cluster_val = new TableVal({NewRef{}, tt->AsTableType()}); auto cluster_val = new TableVal({NewRef{}, tt->AsTableType()});
rval->Assign(rt->FieldOffset("cluster"), cluster_val); rval->Assign(rt->FieldOffset("cluster"), cluster_val);
@ -1314,8 +1314,8 @@ void Supervisor::SupervisedNode::Init(zeek::Options* options) const
IntrusivePtr<RecordVal> Supervisor::Status(std::string_view node_name) IntrusivePtr<RecordVal> Supervisor::Status(std::string_view node_name)
{ {
auto rval = make_intrusive<RecordVal>(BifType::Record::Supervisor::Status); auto rval = make_intrusive<RecordVal>(BifType::Record::Supervisor::Status);
auto tt = BifType::Record::Supervisor::Status->FieldType("nodes"); const auto& tt = BifType::Record::Supervisor::Status->GetFieldType("nodes");
auto node_table_val = new TableVal({NewRef{}, tt->AsTableType()}); auto node_table_val = new TableVal(cast_intrusive<TableType>(tt));
rval->Assign(0, node_table_val); rval->Assign(0, node_table_val);
if ( node_name.empty() ) if ( node_name.empty() )