Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-03 07:08:19 +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
``utf16_to_utf8_val()`` instead.
- ``RecordType::FieldType()`` is deprecated, use ``RecordType::GetFieldType()``
Zeek 3.1.0
==========

6
src/CompHash.cc
View file

@ -189,7 +189,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
return nullptr;
if ( ! (kp = SingleValHash(type_check, kp,
rt->FieldType(i),
rt->GetFieldType(i).get(),
rv_i, optional)) )
return nullptr;
}
@ -517,7 +517,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->FindAttr(ATTR_OPTIONAL));
sz = SingleTypeKeySize(rt->FieldType(i),
sz = SingleTypeKeySize(rt->GetFieldType(i).get(),
rv ? rv->Lookup(i) : nullptr,
type_check, sz, optional,
calc_static_size);
@ -910,7 +910,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
bool optional = (a && a->FindAttr(ATTR_OPTIONAL));
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
// 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++ )
{
const char* fname = args->FieldName(i);
BroType* ftype = args->FieldType(i);
const auto& ftype = args->GetFieldType(i);
auto fdefault = args->FieldDefault(i);
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();
auto v = op2->InitVal(rt->FieldType(td.id), nullptr);
auto v = op2->InitVal(rt->GetFieldType(td.id).get(), nullptr);
if ( ! v )
return nullptr;
@ -2867,7 +2867,7 @@ FieldExpr::FieldExpr(IntrusivePtr<Expr> arg_op, const char* arg_field_name)
ExprError("no such field in record");
else
{
SetType({NewRef{}, rt->FieldType(field)});
SetType(rt->GetFieldType(field));
td = rt->FieldDecl(field);
if ( rt->IsFieldDeprecated(field) )
@ -3565,8 +3565,8 @@ RecordCoerceExpr::RecordCoerceExpr(IntrusivePtr<Expr> arg_op,
break;
}
BroType* sub_t_i = sub_r->FieldType(i);
BroType* sup_t_i = t_r->FieldType(t_i);
BroType* sub_t_i = sub_r->GetFieldType(i).get();
BroType* sup_t_i = t_r->GetFieldType(t_i).get();
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* field_type = val_type->FieldType(i);
BroType* field_type = val_type->GetFieldType(i).get();
if ( rhs_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);
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 &&
field_type->Tag() == TYPE_RECORD &&
! same_type(def_type, field_type) )
! same_type(def_type, field_type.get()) )
{
auto tmp = def_val->AsRecordVal()->CoerceTo(
field_type->AsRecordType());
@ -3814,7 +3814,7 @@ FlattenExpr::FlattenExpr(IntrusivePtr<Expr> arg_op)
auto tl = make_intrusive<TypeList>();
for ( int i = 0; i < num_fields; ++i )
tl->Append({NewRef{}, rt->FieldType(i)});
tl->Append(rt->GetFieldType(i));
Unref(rt);
SetType(std::move(tl));
@ -4809,7 +4809,7 @@ RecordAssignExpr::RecordAssignExpr(const IntrusivePtr<Expr>& record,
int field = lhs->FieldOffset(field_name);
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_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();
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);
Unref(tl);

2
src/ID.cc
View file

@ -187,7 +187,7 @@ void ID::UpdateValAttrs()
TypeDecl* fd = rt->FieldDecl(i);
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));
}

29
src/Type.cc
View file

@ -442,7 +442,7 @@ FuncType::FuncType(IntrusivePtr<RecordType> arg_args,
args->Error(err_str);
}
arg_types->Append({NewRef{}, args->FieldType(i)});
arg_types->Append(args->GetFieldType(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 )
{
auto ptype = p.args->FieldType(i);
auto desired_type = args.FieldType(i);
const auto& ptype = p.args->GetFieldType(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)) )
{
matched = false;
@ -700,17 +700,6 @@ bool RecordType::HasField(const char* field) const
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
{
const TypeDecl* td = FieldDecl(field);
@ -830,7 +819,7 @@ IntrusivePtr<TableVal> RecordType::GetRecordFieldsVal(const RecordVal* rv) const
for ( int i = 0; i < NumFields(); ++i )
{
const BroType* ft = FieldType(i);
const auto& ft = GetFieldType(i);
const TypeDecl* fd = FieldDecl(i);
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());
string s = container_type_name(ft);
string s = container_type_name(ft.get());
nr->Assign(0, make_intrusive<StringVal>(s));
nr->Assign(1, val_mgr->Bool(logged));
nr->Assign(2, fv);
@ -1656,10 +1645,10 @@ bool record_promotion_compatible(const RecordType* super_rec,
// Orphaned field.
continue;
BroType* sub_field_type = sub_rec->FieldType(i);
BroType* super_field_type = super_rec->FieldType(o);
const auto& sub_field_type = sub_rec->GetFieldType(i);
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;
if ( sub_field_type->Tag() != TYPE_RECORD )

28
src/Type.h
View file

@ -552,8 +552,32 @@ public:
~RecordType() 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;
// 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.
continue;
if ( ar_t->FieldType(t_i)->Tag() == TYPE_RECORD &&
! same_type(ar_t->FieldType(t_i), v->Type()) )
const auto& ft = ar_t->GetFieldType(t_i);
if ( ft->Tag() == TYPE_RECORD && ! same_type(ft.get(), v->Type()) )
{
auto rhs = make_intrusive<ConstExpr>(IntrusivePtr{NewRef{}, v});
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));
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;
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 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]),
rt->FieldType(i));
rt->GetFieldType(i).get());
if ( ! item_val )
return nullptr;
@ -730,7 +730,7 @@ struct type_checker {
continue;
}
if ( ! data_type_check(a[idx], rt->FieldType(i)) )
if ( ! data_type_check(a[idx], rt->GetFieldType(i).get()) )
return false;
++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++ )
{
if ( ! same_type(args[i + 2].get(), fields->FieldType(i) ) )
if ( ! same_type(args[i + 2].get(), fields->GetFieldType(i).get() ) )
{
ODesc desc1;
ODesc desc2;
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",
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());
return false;
@ -497,15 +497,15 @@ bool Manager::CreateTableStream(RecordVal* fval)
return false;
}
if ( ! same_type(idx->FieldType(j), tl[j].get()) )
if ( ! same_type(idx->GetFieldType(j).get(), tl[j].get()) )
{
ODesc desc1;
ODesc desc2;
idx->FieldType(j)->Describe(&desc1);
idx->GetFieldType(j)->Describe(&desc1);
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(),
type_name(idx->FieldType(j)->Tag()), desc1.Description(),
type_name(idx->GetFieldType(j)->Tag()), desc1.Description(),
type_name(tl[j]->Tag()), desc2.Description());
return false;
@ -526,7 +526,7 @@ bool Manager::CreateTableStream(RecordVal* fval)
const BroType* compare_type = val.get();
if ( want_record->InternalInt() == 0 )
compare_type = val->FieldType(0);
compare_type = val->GetFieldType(0).get();
if ( ! same_type(table_yield, compare_type) )
{
@ -606,11 +606,11 @@ bool Manager::CreateTableStream(RecordVal* fval)
return false;
}
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 desc2;
val->FieldType(0)->Describe(&desc1);
val->GetFieldType(0)->Describe(&desc1);
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(),
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++ )
{
if ( ! IsCompatibleType(rec->FieldType(i)) )
if ( ! IsCompatibleType(rec->GetFieldType(i).get()) )
{
string name = nameprepend + rec->FieldName(i);
// 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 :)
if ( allow_file_func )
{
if ( ( rec->FieldType(i)->Tag() == TYPE_FILE ||
rec->FieldType(i)->Tag() == TYPE_FUNC ||
rec->FieldType(i)->Tag() == TYPE_OPAQUE ) &&
if ( ( rec->GetFieldType(i)->Tag() == TYPE_FILE ||
rec->GetFieldType(i)->Tag() == TYPE_FUNC ||
rec->GetFieldType(i)->Tag() == TYPE_OPAQUE ) &&
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;
}
}
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;
}
if ( rec->FieldType(i)->Tag() == TYPE_RECORD )
if ( rec->GetFieldType(i)->Tag() == TYPE_RECORD )
{
string prep = nameprepend + rec->FieldName(i) + ".";
@ -925,7 +925,7 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
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;
}
@ -937,15 +937,15 @@ bool Manager::UnrollRecordType(vector<Field*> *fields, const RecordType *rec,
string name = nameprepend + rec->FieldName(i);
const char* secondary = nullptr;
IntrusivePtr<Val> c;
TypeTag ty = rec->FieldType(i)->Tag();
TypeTag ty = rec->GetFieldType(i)->Tag();
TypeTag st = TYPE_VOID;
bool optional = false;
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 )
st = rec->FieldType(i)->AsVectorType()->YieldType()->Tag();
st = rec->GetFieldType(i)->AsVectorType()->YieldType()->Tag();
else if ( ty == TYPE_PORT &&
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;
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;
}
else
@ -1037,12 +1037,12 @@ Val* Manager::ValueToIndexVal(const Stream* i, int num_fields, const RecordType
ListVal *l = new ListVal(TYPE_ANY);
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,
type->FieldType(j)->AsRecordType(), &position, have_error)});
type->GetFieldType(j)->AsRecordType(), &position, have_error)});
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++;
}
}
@ -1158,7 +1158,7 @@ int Manager::SendEntryTable(Stream* i, const Value* const *vals)
valval = nullptr;
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
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;
if ( stream->fields->FieldType(j)->Tag() == TYPE_RECORD )
if ( stream->fields->GetFieldType(j)->Tag() == TYPE_RECORD )
val = ValueToRecordVal(i, vals,
stream->fields->FieldType(j)->AsRecordType(),
stream->fields->GetFieldType(j)->AsRecordType(),
&position, convert_error);
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++;
}
@ -1547,7 +1547,7 @@ int Manager::PutTable(Stream* i, const Value* const *vals)
valval = nullptr;
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
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);
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;
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 );
Val* fieldVal = nullptr;
if ( request_type->FieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ListValToRecordVal(list, request_type->FieldType(i)->AsRecordType(), position);
if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ListValToRecordVal(list, request_type->GetFieldType(i)->AsRecordType(), position);
else
{
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++ )
{
Val* fieldVal = nullptr;
if ( request_type->FieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ValueToRecordVal(stream, vals, request_type->FieldType(i)->AsRecordType(), position, have_error);
else if ( request_type->FieldType(i)->Tag() == TYPE_FILE ||
request_type->FieldType(i)->Tag() == TYPE_FUNC )
if ( request_type->GetFieldType(i)->Tag() == TYPE_RECORD )
fieldVal = ValueToRecordVal(stream, vals, request_type->GetFieldType(i)->AsRecordType(), position, have_error);
else if ( request_type->GetFieldType(i)->Tag() == TYPE_FILE ||
request_type->GetFieldType(i)->Tag() == TYPE_FUNC )
{
// If those two unsupported types are encountered here, they have
// been let through by the type checking.
@ -1956,7 +1956,7 @@ RecordVal* Manager::ValueToRecordVal(const Stream* stream, const Value* const *v
}
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)++;
}

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)) )
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",
columns->FieldName(i));
@ -409,7 +409,7 @@ bool Manager::TraverseRecord(Stream* stream, Filter* filter, RecordType* rt,
rtype = rt;
}
BroType* t = rtype->FieldType(i);
const auto& t = rtype->GetFieldType(i);
// Ignore if &log not specified.
if ( ! rtype->FieldDecl(i)->FindAttr(ATTR_LOG) )
@ -744,7 +744,7 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg)
path_arg = val_mgr->EmptyString();
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 )
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 )
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());
rval->Assign(rt->FieldOffset("scripts"), scripts_val);
for ( const auto& s : scripts )
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()});
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)
{
auto rval = make_intrusive<RecordVal>(BifType::Record::Supervisor::Status);
auto tt = BifType::Record::Supervisor::Status->FieldType("nodes");
auto node_table_val = new TableVal({NewRef{}, tt->AsTableType()});
const auto& tt = BifType::Record::Supervisor::Status->GetFieldType("nodes");
auto node_table_val = new TableVal(cast_intrusive<TableType>(tt));
rval->Assign(0, node_table_val);
if ( node_name.empty() )