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

Rename BroType to Type

Browse source
This commit is contained in:
Tim Wojtulewicz 2020-06-10 14:27:36 -07:00
parent c04d9cae45
commit 137e416a03
34 changed files with 367 additions and 359 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/Attr.cc
View file

@ -146,7 +146,7 @@ void Attr::AddTag(ODesc* d) const
d->Add(attr_name(Tag())); d->Add(attr_name(Tag()));
} }
Attributes::Attributes(attr_list* a, IntrusivePtr<BroType> t, bool arg_in_record, bool is_global) Attributes::Attributes(attr_list* a, IntrusivePtr<Type> t, bool arg_in_record, bool is_global)
{ {
attrs.reserve(a->length()); attrs.reserve(a->length());
in_record = arg_in_record; in_record = arg_in_record;
@ -164,14 +164,14 @@ Attributes::Attributes(attr_list* a, IntrusivePtr<BroType> t, bool arg_in_record
delete a; delete a;
} }
Attributes::Attributes(IntrusivePtr<BroType> t, Attributes::Attributes(IntrusivePtr<Type> t,
bool arg_in_record, bool is_global) bool arg_in_record, bool is_global)
: Attributes(std::vector<IntrusivePtr<Attr>>{}, std::move(t), : Attributes(std::vector<IntrusivePtr<Attr>>{}, std::move(t),
arg_in_record, is_global) arg_in_record, is_global)
{} {}
Attributes::Attributes(std::vector<IntrusivePtr<Attr>> a, Attributes::Attributes(std::vector<IntrusivePtr<Attr>> a,
IntrusivePtr<BroType> t, IntrusivePtr<Type> t,
bool arg_in_record, bool is_global) bool arg_in_record, bool is_global)
: type(std::move(t)) : type(std::move(t))
{ {

8
src/Attr.h
View file

@ -112,11 +112,11 @@ protected:
class Attributes final : public BroObj { class Attributes final : public BroObj {
public: public:
[[deprecated("Remove in v4.1. Construct using IntrusivePtrs instead.")]] [[deprecated("Remove in v4.1. Construct using IntrusivePtrs instead.")]]
Attributes(attr_list* a, IntrusivePtr<BroType> t, bool in_record, bool is_global); Attributes(attr_list* a, IntrusivePtr<Type> t, bool in_record, bool is_global);
Attributes(std::vector<IntrusivePtr<Attr>> a, IntrusivePtr<BroType> t, Attributes(std::vector<IntrusivePtr<Attr>> a, IntrusivePtr<Type> t,
bool in_record, bool is_global); bool in_record, bool is_global);
Attributes(IntrusivePtr<BroType> t, bool in_record, bool is_global); Attributes(IntrusivePtr<Type> t, bool in_record, bool is_global);
void AddAttr(IntrusivePtr<Attr> a); void AddAttr(IntrusivePtr<Attr> a);
@ -147,7 +147,7 @@ public:
protected: protected:
void CheckAttr(Attr* attr); void CheckAttr(Attr* attr);
IntrusivePtr<BroType> type; IntrusivePtr<Type> type;
std::vector<IntrusivePtr<Attr>> attrs; std::vector<IntrusivePtr<Attr>> attrs;
bool in_record; bool in_record;
bool global_var; bool global_var;

5
src/BroList.h
View file

@ -16,8 +16,9 @@ using id_list = PList<zeek::detail::ID>;
FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail); FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
using stmt_list = PList<zeek::detail::Stmt>; using stmt_list = PList<zeek::detail::Stmt>;
FORWARD_DECLARE_NAMESPACED(BroType, zeek); namespace zeek { class Type; }
using type_list = PList<zeek::BroType>; using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
using type_list = PList<zeek::Type>;
FORWARD_DECLARE_NAMESPACED(Attr, zeek::detail); FORWARD_DECLARE_NAMESPACED(Attr, zeek::detail);
using attr_list = PList<zeek::detail::Attr>; using attr_list = PList<zeek::detail::Attr>;

8
src/CompHash.cc
View file

@ -71,7 +71,7 @@ CompositeHash::~CompositeHash()
// Computes the piece of the hash for Val*, returning the new kp. // Computes the piece of the hash for Val*, returning the new kp.
char* CompositeHash::SingleValHash(bool type_check, char* kp0, char* CompositeHash::SingleValHash(bool type_check, char* kp0,
zeek::BroType* bt, Val* v, bool optional) const zeek::Type* bt, Val* v, bool optional) const
{ {
char* kp1 = nullptr; char* kp1 = nullptr;
zeek::InternalTypeTag t = bt->InternalType(); zeek::InternalTypeTag t = bt->InternalType();
@ -449,7 +449,7 @@ std::unique_ptr<HashKey> CompositeHash::ComputeSingletonHash(const Val* v, bool
} }
} }
int CompositeHash::SingleTypeKeySize(zeek::BroType* bt, const Val* v, int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const Val* v,
bool type_check, int sz, bool optional, bool type_check, int sz, bool optional,
bool calc_static_size) const bool calc_static_size) const
{ {
@ -730,7 +730,7 @@ IntrusivePtr<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, zeek::BroType* t, const char* const k_end, zeek::Type* t,
IntrusivePtr<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.
@ -1010,7 +1010,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
for ( int i = 0; i < n; ++i ) for ( int i = 0; i < n; ++i )
{ {
IntrusivePtr<Val> v; IntrusivePtr<Val> v;
zeek::BroType* it = tl->Types()[i].get(); zeek::Type* it = tl->Types()[i].get();
kp1 = RecoverOneVal(k, kp1, k_end, it, &v, false); kp1 = RecoverOneVal(k, kp1, k_end, it, &v, false);
lv->Append(std::move(v)); lv->Append(std::move(v));
} }

6
src/CompHash.h
View file

@ -37,7 +37,7 @@ protected:
// Computes the piece of the hash for Val*, returning the new kp. // Computes the piece of the hash for Val*, returning the new kp.
// Used as a helper for ComputeHash in the non-singleton case. // Used as a helper for ComputeHash in the non-singleton case.
char* SingleValHash(bool type_check, char* kp, zeek::BroType* bt, Val* v, char* SingleValHash(bool type_check, char* kp, zeek::Type* bt, Val* v,
bool optional) const; bool optional) const;
// Recovers just one Val of possibly many; called from RecoverVals. // Recovers just one Val of possibly many; called from RecoverVals.
@ -46,7 +46,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,
zeek::BroType* t, IntrusivePtr<Val>* pval, bool optional) const; zeek::Type* 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.
@ -85,7 +85,7 @@ protected:
int ComputeKeySize(const Val* v, bool type_check, int ComputeKeySize(const Val* v, bool type_check,
bool calc_static_size) const; bool calc_static_size) const;
int SingleTypeKeySize(zeek::BroType*, const Val*, int SingleTypeKeySize(zeek::Type*, const Val*,
bool type_check, int sz, bool optional, bool type_check, int sz, bool optional,
bool calc_static_size) const; bool calc_static_size) const;

6
src/Desc.cc
View file

@ -403,19 +403,19 @@ void ODesc::Clear()
} }
} }
bool ODesc::PushType(const zeek::BroType* type) bool ODesc::PushType(const zeek::Type* type)
{ {
auto res = encountered_types.insert(type); auto res = encountered_types.insert(type);
return std::get<1>(res); return std::get<1>(res);
} }
bool ODesc::PopType(const zeek::BroType* type) bool ODesc::PopType(const zeek::Type* type)
{ {
size_t res = encountered_types.erase(type); size_t res = encountered_types.erase(type);
return (res == 1); return (res == 1);
} }
bool ODesc::FindType(const zeek::BroType* type) bool ODesc::FindType(const zeek::Type* type)
{ {
auto res = encountered_types.find(type); auto res = encountered_types.find(type);

12
src/Desc.h
View file

@ -25,7 +25,9 @@ typedef enum {
class BroFile; class BroFile;
class IPAddr; class IPAddr;
class IPPrefix; class IPPrefix;
FORWARD_DECLARE_NAMESPACED(BroType, zeek);
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
class ODesc { class ODesc {
public: public:
@ -146,9 +148,9 @@ public:
// Used to determine recursive types. Records push their types on here; // Used to determine recursive types. Records push their types on here;
// if the same type (by address) is re-encountered, processing aborts. // if the same type (by address) is re-encountered, processing aborts.
bool PushType(const zeek::BroType* type); bool PushType(const zeek::Type* type);
bool PopType(const zeek::BroType* type); bool PopType(const zeek::Type* type);
bool FindType(const zeek::BroType* type); bool FindType(const zeek::Type* type);
protected: protected:
void Indent(); void Indent();
@ -204,5 +206,5 @@ protected:
bool do_flush; bool do_flush;
bool include_stats; bool include_stats;
std::set<const zeek::BroType*> encountered_types; std::set<const zeek::Type*> encountered_types;
}; };

62
src/Expr.cc
View file

@ -90,7 +90,7 @@ IntrusivePtr<Expr> Expr::MakeLvalue()
return {NewRef{}, this}; return {NewRef{}, this};
} }
void Expr::EvalIntoAggregate(const BroType* /* t */, Val* /* aggr */, void Expr::EvalIntoAggregate(const zeek::Type* /* t */, Val* /* aggr */,
Frame* /* f */) const Frame* /* f */) const
{ {
Internal("Expr::EvalIntoAggregate called"); Internal("Expr::EvalIntoAggregate called");
@ -101,7 +101,7 @@ void Expr::Assign(Frame* /* f */, IntrusivePtr<Val> /* v */)
Internal("Expr::Assign called"); Internal("Expr::Assign called");
} }
IntrusivePtr<BroType> Expr::InitType() const IntrusivePtr<zeek::Type> Expr::InitType() const
{ {
return type; return type;
} }
@ -116,7 +116,7 @@ bool Expr::IsPure() const
return true; return true;
} }
IntrusivePtr<Val> Expr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> Expr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( aggr ) if ( aggr )
{ {
@ -182,7 +182,7 @@ void Expr::Canonicize()
{ {
} }
void Expr::SetType(IntrusivePtr<BroType> t) void Expr::SetType(IntrusivePtr<zeek::Type> t)
{ {
if ( ! type || type->Tag() != zeek::TYPE_ERROR ) if ( ! type || type->Tag() != zeek::TYPE_ERROR )
type = std::move(t); type = std::move(t);
@ -1047,7 +1047,7 @@ PosExpr::PosExpr(IntrusivePtr<Expr> arg_op)
const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType(); const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType();
TypeTag bt = t->Tag(); TypeTag bt = t->Tag();
IntrusivePtr<BroType> base_result_type; IntrusivePtr<zeek::Type> base_result_type;
if ( IsIntegral(bt) ) if ( IsIntegral(bt) )
// Promote count and counter to int. // Promote count and counter to int.
@ -1082,7 +1082,7 @@ NegExpr::NegExpr(IntrusivePtr<Expr> arg_op)
const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType(); const auto& t = IsVector(op->GetType()->Tag()) ? op->GetType()->Yield() : op->GetType();
TypeTag bt = t->Tag(); TypeTag bt = t->Tag();
IntrusivePtr<BroType> base_result_type; IntrusivePtr<zeek::Type> base_result_type;
if ( IsIntegral(bt) ) if ( IsIntegral(bt) )
// Promote count and counter to int. // Promote count and counter to int.
@ -1151,7 +1151,7 @@ AddExpr::AddExpr(IntrusivePtr<Expr> arg_op1, IntrusivePtr<Expr> arg_op2)
if ( IsVector(bt2) ) if ( IsVector(bt2) )
bt2 = op2->GetType()->AsVectorType()->Yield()->Tag(); bt2 = op2->GetType()->AsVectorType()->Yield()->Tag();
IntrusivePtr<BroType> base_result_type; IntrusivePtr<zeek::Type> base_result_type;
if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) ) if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) )
base_result_type = base_type(bt1); base_result_type = base_type(bt1);
@ -1276,7 +1276,7 @@ SubExpr::SubExpr(IntrusivePtr<Expr> arg_op1, IntrusivePtr<Expr> arg_op2)
if ( IsVector(bt2) ) if ( IsVector(bt2) )
bt2 = t2->AsVectorType()->Yield()->Tag(); bt2 = t2->AsVectorType()->Yield()->Tag();
IntrusivePtr<BroType> base_result_type; IntrusivePtr<zeek::Type> base_result_type;
if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) ) if ( bt2 == zeek::TYPE_INTERVAL && ( bt1 == zeek::TYPE_TIME || bt1 == zeek::TYPE_INTERVAL ) )
base_result_type = base_type(bt1); base_result_type = base_type(bt1);
@ -2262,7 +2262,7 @@ IntrusivePtr<Val> AssignExpr::Eval(Frame* f) const
return nullptr; return nullptr;
} }
IntrusivePtr<BroType> AssignExpr::InitType() const IntrusivePtr<zeek::Type> AssignExpr::InitType() const
{ {
if ( op1->Tag() != EXPR_LIST ) if ( op1->Tag() != EXPR_LIST )
{ {
@ -2278,7 +2278,7 @@ IntrusivePtr<BroType> AssignExpr::InitType() const
op2->GetType()); op2->GetType());
} }
void AssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const void AssignExpr::EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const
{ {
if ( IsError() ) if ( IsError() )
return; return;
@ -2327,7 +2327,7 @@ void AssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const
RuntimeError("type clash in table assignment"); RuntimeError("type clash in table assignment");
} }
IntrusivePtr<Val> AssignExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> AssignExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( ! aggr ) if ( ! aggr )
{ {
@ -3004,14 +3004,14 @@ RecordConstructorExpr::~RecordConstructorExpr()
{ {
} }
IntrusivePtr<Val> RecordConstructorExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> RecordConstructorExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
auto v = Eval(nullptr); auto v = Eval(nullptr);
if ( v ) if ( v )
{ {
RecordVal* rv = v->AsRecordVal(); RecordVal* rv = v->AsRecordVal();
auto bt = const_cast<BroType*>(t); auto bt = const_cast<zeek::Type*>(t);
IntrusivePtr<RecordType> rt{NewRef{}, bt->AsRecordType()}; IntrusivePtr<RecordType> rt{NewRef{}, bt->AsRecordType()};
auto aggr_rec = cast_intrusive<RecordVal>(std::move(aggr)); auto aggr_rec = cast_intrusive<RecordVal>(std::move(aggr));
auto ar = rv->CoerceTo(std::move(rt), std::move(aggr_rec)); auto ar = rv->CoerceTo(std::move(rt), std::move(aggr_rec));
@ -3049,7 +3049,7 @@ void RecordConstructorExpr::ExprDescribe(ODesc* d) const
TableConstructorExpr::TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list, TableConstructorExpr::TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> arg_attrs, std::unique_ptr<std::vector<IntrusivePtr<Attr>>> arg_attrs,
IntrusivePtr<BroType> arg_type) IntrusivePtr<zeek::Type> arg_type)
: UnaryExpr(EXPR_TABLE_CONSTRUCTOR, std::move(constructor_list)) : UnaryExpr(EXPR_TABLE_CONSTRUCTOR, std::move(constructor_list))
{ {
if ( IsError() ) if ( IsError() )
@ -3143,7 +3143,7 @@ IntrusivePtr<Val> TableConstructorExpr::Eval(Frame* f) const
return aggr; return aggr;
} }
IntrusivePtr<Val> TableConstructorExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> TableConstructorExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( IsError() ) if ( IsError() )
return nullptr; return nullptr;
@ -3170,7 +3170,7 @@ void TableConstructorExpr::ExprDescribe(ODesc* d) const
SetConstructorExpr::SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list, SetConstructorExpr::SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> arg_attrs, std::unique_ptr<std::vector<IntrusivePtr<Attr>>> arg_attrs,
IntrusivePtr<BroType> arg_type) IntrusivePtr<zeek::Type> arg_type)
: UnaryExpr(EXPR_SET_CONSTRUCTOR, std::move(constructor_list)) : UnaryExpr(EXPR_SET_CONSTRUCTOR, std::move(constructor_list))
{ {
if ( IsError() ) if ( IsError() )
@ -3254,7 +3254,7 @@ IntrusivePtr<Val> SetConstructorExpr::Eval(Frame* f) const
return aggr; return aggr;
} }
IntrusivePtr<Val> SetConstructorExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> SetConstructorExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( IsError() ) if ( IsError() )
return nullptr; return nullptr;
@ -3288,7 +3288,7 @@ void SetConstructorExpr::ExprDescribe(ODesc* d) const
} }
VectorConstructorExpr::VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list, VectorConstructorExpr::VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
IntrusivePtr<BroType> arg_type) IntrusivePtr<zeek::Type> arg_type)
: UnaryExpr(EXPR_VECTOR_CONSTRUCTOR, std::move(constructor_list)) : UnaryExpr(EXPR_VECTOR_CONSTRUCTOR, std::move(constructor_list))
{ {
if ( IsError() ) if ( IsError() )
@ -3352,7 +3352,7 @@ IntrusivePtr<Val> VectorConstructorExpr::Eval(Frame* f) const
return vec; return vec;
} }
IntrusivePtr<Val> VectorConstructorExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> VectorConstructorExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( IsError() ) if ( IsError() )
return nullptr; return nullptr;
@ -3392,7 +3392,7 @@ FieldAssignExpr::FieldAssignExpr(const char* arg_field_name,
SetType(op->GetType()); SetType(op->GetType());
} }
void FieldAssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) void FieldAssignExpr::EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f)
const const
{ {
if ( IsError() ) if ( IsError() )
@ -3553,7 +3553,7 @@ RecordCoerceExpr::RecordCoerceExpr(IntrusivePtr<Expr> arg_op,
if ( ! same_type(sup_t_i, sub_t_i) ) if ( ! same_type(sup_t_i, sub_t_i) )
{ {
auto is_arithmetic_promotable = [](BroType* sup, BroType* sub) -> bool auto is_arithmetic_promotable = [](zeek::Type* sup, zeek::Type* sub) -> bool
{ {
auto sup_tag = sup->Tag(); auto sup_tag = sup->Tag();
auto sub_tag = sub->Tag(); auto sub_tag = sub->Tag();
@ -3570,7 +3570,7 @@ RecordCoerceExpr::RecordCoerceExpr(IntrusivePtr<Expr> arg_op,
return true; return true;
}; };
auto is_record_promotable = [](BroType* sup, BroType* sub) -> bool auto is_record_promotable = [](zeek::Type* sup, zeek::Type* sub) -> bool
{ {
if ( sup->Tag() != zeek::TYPE_RECORD ) if ( sup->Tag() != zeek::TYPE_RECORD )
return false; return false;
@ -3623,12 +3623,12 @@ RecordCoerceExpr::~RecordCoerceExpr()
delete [] map; delete [] map;
} }
IntrusivePtr<Val> RecordCoerceExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> RecordCoerceExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( auto v = Eval(nullptr) ) if ( auto v = Eval(nullptr) )
{ {
RecordVal* rv = v->AsRecordVal(); RecordVal* rv = v->AsRecordVal();
auto bt = const_cast<BroType*>(t); auto bt = const_cast<zeek::Type*>(t);
IntrusivePtr<RecordType> rt{NewRef{}, bt->AsRecordType()}; IntrusivePtr<RecordType> rt{NewRef{}, bt->AsRecordType()};
auto aggr_rec = cast_intrusive<RecordVal>(std::move(aggr)); auto aggr_rec = cast_intrusive<RecordVal>(std::move(aggr));
@ -4399,7 +4399,7 @@ IntrusivePtr<Val> ListExpr::Eval(Frame* f) const
return v; return v;
} }
IntrusivePtr<BroType> ListExpr::InitType() const IntrusivePtr<zeek::Type> ListExpr::InitType() const
{ {
if ( exprs.empty() ) if ( exprs.empty() )
{ {
@ -4457,7 +4457,7 @@ IntrusivePtr<BroType> ListExpr::InitType() const
} }
} }
IntrusivePtr<Val> ListExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> ListExpr::InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
// While fairly similar to the EvalIntoAggregate() code, // While fairly similar to the EvalIntoAggregate() code,
// we keep this separate since it also deals with initialization // we keep this separate since it also deals with initialization
@ -4601,7 +4601,7 @@ IntrusivePtr<Val> ListExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) co
return aggr; return aggr;
} }
IntrusivePtr<Val> ListExpr::AddSetInit(const BroType* t, IntrusivePtr<Val> aggr) const IntrusivePtr<Val> ListExpr::AddSetInit(const zeek::Type* t, IntrusivePtr<Val> aggr) const
{ {
if ( aggr->GetType()->Tag() != zeek::TYPE_TABLE ) if ( aggr->GetType()->Tag() != zeek::TYPE_TABLE )
Internal("bad aggregate in ListExpr::InitVal"); Internal("bad aggregate in ListExpr::InitVal");
@ -4764,7 +4764,7 @@ RecordAssignExpr::RecordAssignExpr(const IntrusivePtr<Expr>& record,
} }
} }
CastExpr::CastExpr(IntrusivePtr<Expr> arg_op, IntrusivePtr<BroType> t) CastExpr::CastExpr(IntrusivePtr<Expr> arg_op, IntrusivePtr<zeek::Type> t)
: UnaryExpr(EXPR_CAST, std::move(arg_op)) : UnaryExpr(EXPR_CAST, std::move(arg_op))
{ {
auto stype = Op()->GetType(); auto stype = Op()->GetType();
@ -4812,7 +4812,7 @@ void CastExpr::ExprDescribe(ODesc* d) const
GetType()->Describe(d); GetType()->Describe(d);
} }
IsExpr::IsExpr(IntrusivePtr<Expr> arg_op, IntrusivePtr<BroType> arg_t) IsExpr::IsExpr(IntrusivePtr<Expr> arg_op, IntrusivePtr<zeek::Type> arg_t)
: UnaryExpr(EXPR_IS, std::move(arg_op)), t(std::move(arg_t)) : UnaryExpr(EXPR_IS, std::move(arg_op)), t(std::move(arg_t))
{ {
SetType(zeek::base_type(zeek::TYPE_BOOL)); SetType(zeek::base_type(zeek::TYPE_BOOL));
@ -4850,7 +4850,7 @@ IntrusivePtr<Expr> get_assign_expr(IntrusivePtr<Expr> op1,
is_init); is_init);
} }
IntrusivePtr<Expr> check_and_promote_expr(Expr* const e, BroType* t) IntrusivePtr<Expr> check_and_promote_expr(Expr* const e, zeek::Type* t)
{ {
const auto& et = e->GetType(); const auto& et = e->GetType();
TypeTag e_tag = et->Tag(); TypeTag e_tag = et->Tag();
@ -5006,7 +5006,7 @@ bool check_and_promote_args(ListExpr* const args, RecordType* types)
return rval; return rval;
} }
bool check_and_promote_exprs_to_type(ListExpr* const elements, BroType* type) bool check_and_promote_exprs_to_type(ListExpr* const elements, zeek::Type* type)
{ {
expr_list& el = elements->Exprs(); expr_list& el = elements->Exprs();

54
src/Expr.h
View file

@ -76,9 +76,9 @@ class Stmt;
class Expr : public BroObj { class Expr : public BroObj {
public: public:
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
BroType* Type() const { return type.get(); } zeek::Type* Type() const { return type.get(); }
const IntrusivePtr<BroType>& GetType() const const IntrusivePtr<zeek::Type>& GetType() const
{ return type; } { return type; }
template <class T> template <class T>
@ -97,7 +97,7 @@ public:
// into the given aggregate of the given type. Note that // into the given aggregate of the given type. Note that
// return type is void since it's updating an existing // return type is void since it's updating an existing
// value, rather than creating a new one. // value, rather than creating a new one.
virtual void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f)
const; const;
// Assign to the given value, if appropriate. // Assign to the given value, if appropriate.
@ -105,7 +105,7 @@ public:
// Returns the type corresponding to this expression interpreted // Returns the type corresponding to this expression interpreted
// as an initialization. Returns nil if the initialization is illegal. // as an initialization. Returns nil if the initialization is illegal.
virtual IntrusivePtr<BroType> InitType() const; virtual IntrusivePtr<zeek::Type> InitType() const;
// Returns true if this expression, interpreted as an initialization, // Returns true if this expression, interpreted as an initialization,
// constitutes a record element, false otherwise. If the TypeDecl* // constitutes a record element, false otherwise. If the TypeDecl*
@ -118,7 +118,7 @@ public:
// with the given type. If "aggr" is non-nil, then this expression // with the given type. If "aggr" is non-nil, then this expression
// is an element of the given aggregate, and it is added to it // is an element of the given aggregate, and it is added to it
// accordingly. // accordingly.
virtual IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const; virtual IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
// True if the expression has no side effects, false otherwise. // True if the expression has no side effects, false otherwise.
virtual bool IsPure() const; virtual bool IsPure() const;
@ -223,7 +223,7 @@ protected:
// Puts the expression in canonical form. // Puts the expression in canonical form.
virtual void Canonicize(); virtual void Canonicize();
void SetType(IntrusivePtr<BroType> t); void SetType(IntrusivePtr<zeek::Type> t);
// Reports the given error and sets the expression's type to // Reports the given error and sets the expression's type to
// TYPE_ERROR. // TYPE_ERROR.
@ -235,7 +235,7 @@ protected:
[[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const; [[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const;
BroExprTag tag; BroExprTag tag;
IntrusivePtr<BroType> type; IntrusivePtr<zeek::Type> type;
bool paren; bool paren;
}; };
@ -524,10 +524,10 @@ public:
const IntrusivePtr<Attributes>& attrs = nullptr); const IntrusivePtr<Attributes>& attrs = nullptr);
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const override; void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
IntrusivePtr<BroType> InitType() const override; IntrusivePtr<zeek::Type> InitType() const override;
bool IsRecordElement(TypeDecl* td) const override; bool IsRecordElement(TypeDecl* td) const override;
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
bool IsPure() const override; bool IsPure() const override;
protected: protected:
@ -624,7 +624,7 @@ public:
~RecordConstructorExpr() override; ~RecordConstructorExpr() override;
protected: protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> Fold(Val* v) const override; IntrusivePtr<Val> Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
@ -634,7 +634,7 @@ class TableConstructorExpr final : public UnaryExpr {
public: public:
TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list, TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs, std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
IntrusivePtr<BroType> arg_type = nullptr); IntrusivePtr<zeek::Type> arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]] [[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); } Attributes* Attrs() { return attrs.get(); }
@ -645,7 +645,7 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
protected: protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
@ -656,7 +656,7 @@ class SetConstructorExpr final : public UnaryExpr {
public: public:
SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list, SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs, std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
IntrusivePtr<BroType> arg_type = nullptr); IntrusivePtr<zeek::Type> arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]] [[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); } Attributes* Attrs() { return attrs.get(); }
@ -667,7 +667,7 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
protected: protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
@ -677,12 +677,12 @@ protected:
class VectorConstructorExpr final : public UnaryExpr { class VectorConstructorExpr final : public UnaryExpr {
public: public:
explicit VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list, explicit VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
IntrusivePtr<BroType> arg_type = nullptr); IntrusivePtr<zeek::Type> arg_type = nullptr);
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
protected: protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
}; };
@ -693,7 +693,7 @@ public:
const char* FieldName() const { return field_name.c_str(); } const char* FieldName() const { return field_name.c_str(); }
void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const override; void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
bool IsRecordElement(TypeDecl* td) const override; bool IsRecordElement(TypeDecl* td) const override;
protected: protected:
@ -717,7 +717,7 @@ public:
~RecordCoerceExpr() override; ~RecordCoerceExpr() override;
protected: protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> Fold(Val* v) const override; IntrusivePtr<Val> Fold(Val* v) const override;
// For each super-record slot, gives subrecord slot with which to // For each super-record slot, gives subrecord slot with which to
@ -868,15 +868,15 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
IntrusivePtr<BroType> InitType() const override; IntrusivePtr<zeek::Type> InitType() const override;
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override; IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Expr> MakeLvalue() override; IntrusivePtr<Expr> MakeLvalue() override;
void Assign(Frame* f, IntrusivePtr<Val> v) override; void Assign(Frame* f, IntrusivePtr<Val> v) override;
TraversalCode Traverse(TraversalCallback* cb) const override; TraversalCode Traverse(TraversalCallback* cb) const override;
protected: protected:
IntrusivePtr<Val> AddSetInit(const BroType* t, IntrusivePtr<Val> aggr) const; IntrusivePtr<Val> AddSetInit(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
@ -891,7 +891,7 @@ public:
class CastExpr final : public UnaryExpr { class CastExpr final : public UnaryExpr {
public: public:
CastExpr(IntrusivePtr<Expr> op, IntrusivePtr<BroType> t); CastExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
protected: protected:
IntrusivePtr<Val> Eval(Frame* f) const override; IntrusivePtr<Val> Eval(Frame* f) const override;
@ -900,14 +900,14 @@ protected:
class IsExpr final : public UnaryExpr { class IsExpr final : public UnaryExpr {
public: public:
IsExpr(IntrusivePtr<Expr> op, IntrusivePtr<BroType> t); IsExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
protected: protected:
IntrusivePtr<Val> Fold(Val* v) const override; IntrusivePtr<Val> Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override; void ExprDescribe(ODesc* d) const override;
private: private:
IntrusivePtr<BroType> t; IntrusivePtr<zeek::Type> t;
}; };
inline Val* Expr::ExprVal() const inline Val* Expr::ExprVal() const
@ -936,11 +936,11 @@ IntrusivePtr<Expr> get_assign_expr(IntrusivePtr<Expr> op1,
* Returns nullptr if the expression cannot match or a promoted * Returns nullptr if the expression cannot match or a promoted
* expression. * expression.
*/ */
extern IntrusivePtr<Expr> check_and_promote_expr(Expr* e, BroType* t); extern IntrusivePtr<Expr> check_and_promote_expr(Expr* e, Type* t);
extern bool check_and_promote_exprs(ListExpr* elements, TypeList* types); extern bool check_and_promote_exprs(ListExpr* elements, TypeList* types);
extern bool check_and_promote_args(ListExpr* args, RecordType* types); extern bool check_and_promote_args(ListExpr* args, RecordType* types);
extern bool check_and_promote_exprs_to_type(ListExpr* elements, BroType* type); extern bool check_and_promote_exprs_to_type(ListExpr* elements, Type* type);
// Returns a ListExpr simplified down to a list a values, or nil // Returns a ListExpr simplified down to a list a values, or nil
// if they couldn't all be reduced. // if they couldn't all be reduced.

10
src/File.h
View file

@ -18,7 +18,9 @@
class RecordVal; class RecordVal;
FORWARD_DECLARE_NAMESPACED(BroType, zeek); namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
FORWARD_DECLARE_NAMESPACED(PrintStmt, zeek::detail); FORWARD_DECLARE_NAMESPACED(PrintStmt, zeek::detail);
FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail); FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail);
@ -41,9 +43,9 @@ public:
void SetBuf(bool buffered); // false=line buffered, true=fully buffered void SetBuf(bool buffered); // false=line buffered, true=fully buffered
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
zeek::BroType* FType() const { return t.get(); } zeek::Type* FType() const { return t.get(); }
const IntrusivePtr<zeek::BroType>& GetType() const const IntrusivePtr<zeek::Type>& GetType() const
{ return t; } { return t; }
// Whether the file is open in a general sense; it might // Whether the file is open in a general sense; it might
@ -104,7 +106,7 @@ protected:
void RaiseOpenEvent(); void RaiseOpenEvent();
FILE* f; FILE* f;
IntrusivePtr<zeek::BroType> t; IntrusivePtr<zeek::Type> t;
char* name; char* name;
char* access; char* access;
zeek::detail::Attributes* attrs; zeek::detail::Attributes* attrs;

2
src/Frame.cc
View file

@ -460,7 +460,7 @@ std::pair<bool, IntrusivePtr<Frame>> Frame::Unserialize(const broker::vector& da
return std::make_pair(false, nullptr); return std::make_pair(false, nullptr);
broker::integer g = *has_type; broker::integer g = *has_type;
zeek::BroType t( static_cast<zeek::TypeTag>(g) ); zeek::Type t( static_cast<zeek::TypeTag>(g) );
auto val = bro_broker::data_to_val(std::move(val_tuple[0]), &t); auto val = bro_broker::data_to_val(std::move(val_tuple[0]), &t);
if ( ! val ) if ( ! val )

4
src/ID.cc
View file

@ -36,7 +36,7 @@ const IntrusivePtr<zeek::detail::ID>& zeek::id::find(std::string_view name)
return global_scope()->Find(name); return global_scope()->Find(name);
} }
const IntrusivePtr<zeek::BroType>& zeek::id::find_type(std::string_view name) const IntrusivePtr<zeek::Type>& zeek::id::find_type(std::string_view name)
{ {
auto id = global_scope()->Find(name); auto id = global_scope()->Find(name);
@ -133,7 +133,7 @@ std::string ID::ModuleName() const
return extract_module_name(name); return extract_module_name(name);
} }
void ID::SetType(IntrusivePtr<zeek::BroType> t) void ID::SetType(IntrusivePtr<zeek::Type> t)
{ {
type = std::move(t); type = std::move(t);
} }

20
src/ID.h
View file

@ -16,7 +16,9 @@
class Val; class Val;
class Func; class Func;
FORWARD_DECLARE_NAMESPACED(BroType, zeek); namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
FORWARD_DECLARE_NAMESPACED(RecordType, zeek); FORWARD_DECLARE_NAMESPACED(RecordType, zeek);
FORWARD_DECLARE_NAMESPACED(TableType, zeek); FORWARD_DECLARE_NAMESPACED(TableType, zeek);
FORWARD_DECLARE_NAMESPACED(VectorType, zeek); FORWARD_DECLARE_NAMESPACED(VectorType, zeek);
@ -54,14 +56,14 @@ public:
std::string ModuleName() const; std::string ModuleName() const;
void SetType(IntrusivePtr<BroType> t); void SetType(IntrusivePtr<Type> t);
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
BroType* Type() { return type.get(); } zeek::Type* Type() { return type.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
const BroType* Type() const { return type.get(); } const zeek::Type* Type() const { return type.get(); }
const IntrusivePtr<BroType>& GetType() const const IntrusivePtr<zeek::Type>& GetType() const
{ return type; } { return type; }
template <class T> template <class T>
@ -69,9 +71,9 @@ public:
{ return cast_intrusive<T>(type); } { return cast_intrusive<T>(type); }
[[deprecated("Remove in v4.1. Use IsType() and GetType().")]] [[deprecated("Remove in v4.1. Use IsType() and GetType().")]]
BroType* AsType() { return is_type ? GetType().get() : nullptr; } zeek::Type* AsType() { return is_type ? GetType().get() : nullptr; }
[[deprecated("Remove in v4.1. Use IsType() and GetType().")]] [[deprecated("Remove in v4.1. Use IsType() and GetType().")]]
const BroType* AsType() const { return is_type ? GetType().get() : nullptr; } const zeek::Type* AsType() const { return is_type ? GetType().get() : nullptr; }
bool IsType() const bool IsType() const
{ return is_type; } { return is_type; }
@ -172,7 +174,7 @@ protected:
IDScope scope; IDScope scope;
bool is_export; bool is_export;
bool infer_return_type; bool infer_return_type;
IntrusivePtr<BroType> type; IntrusivePtr<zeek::Type> type;
bool is_const, is_enum_const, is_type, is_option; bool is_const, is_enum_const, is_type, is_option;
int offset; int offset;
IntrusivePtr<Val> val; IntrusivePtr<Val> val;
@ -202,7 +204,7 @@ const IntrusivePtr<zeek::detail::ID>& find(std::string_view name);
* @param name The identifier name to lookup * @param name The identifier name to lookup
* @return The type of the identifier. * @return The type of the identifier.
*/ */
const IntrusivePtr<zeek::BroType>& find_type(std::string_view name); const IntrusivePtr<zeek::Type>& find_type(std::string_view name);
/** /**
* Lookup an ID by its name and return its type (as cast to @c T). * Lookup an ID by its name and return its type (as cast to @c T).

8
src/OpaqueVal.cc
View file

@ -96,7 +96,7 @@ IntrusivePtr<OpaqueVal> OpaqueVal::Unserialize(const broker::data& data)
return val; return val;
} }
broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<zeek::BroType>& t) broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<zeek::Type>& t)
{ {
if ( t->InternalType() == zeek::TYPE_INTERNAL_ERROR ) if ( t->InternalType() == zeek::TYPE_INTERNAL_ERROR )
return broker::ec::invalid_data; return broker::ec::invalid_data;
@ -112,7 +112,7 @@ broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<zeek:
return {broker::vector{false, static_cast<uint64_t>(t->Tag())}}; return {broker::vector{false, static_cast<uint64_t>(t->Tag())}};
} }
IntrusivePtr<zeek::BroType> OpaqueVal::UnserializeType(const broker::data& data) IntrusivePtr<zeek::Type> OpaqueVal::UnserializeType(const broker::data& data)
{ {
auto v = caf::get_if<broker::vector>(&data); auto v = caf::get_if<broker::vector>(&data);
if ( ! (v && v->size() == 2) ) if ( ! (v && v->size() == 2) )
@ -723,7 +723,7 @@ IntrusivePtr<Val> BloomFilterVal::DoClone(CloneState* state)
return state->NewClone(this, make_intrusive<BloomFilterVal>()); return state->NewClone(this, make_intrusive<BloomFilterVal>());
} }
bool BloomFilterVal::Typify(IntrusivePtr<zeek::BroType> arg_type) bool BloomFilterVal::Typify(IntrusivePtr<zeek::Type> arg_type)
{ {
if ( type ) if ( type )
return false; return false;
@ -882,7 +882,7 @@ IntrusivePtr<Val> CardinalityVal::DoClone(CloneState* state)
make_intrusive<CardinalityVal>(new probabilistic::CardinalityCounter(*c))); make_intrusive<CardinalityVal>(new probabilistic::CardinalityCounter(*c)));
} }
bool CardinalityVal::Typify(IntrusivePtr<zeek::BroType> arg_type) bool CardinalityVal::Typify(IntrusivePtr<zeek::Type> arg_type)
{ {
if ( type ) if ( type )
return false; return false;

16
src/OpaqueVal.h
View file

@ -148,13 +148,13 @@ protected:
* Helper function for derived class that need to record a type * Helper function for derived class that need to record a type
* during serialization. * during serialization.
*/ */
static broker::expected<broker::data> SerializeType(const IntrusivePtr<zeek::BroType>& t); static broker::expected<broker::data> SerializeType(const IntrusivePtr<zeek::Type>& t);
/** /**
* Helper function for derived class that need to restore a type * Helper function for derived class that need to restore a type
* during unserialization. Returns the type at reference count +1. * during unserialization. Returns the type at reference count +1.
*/ */
static IntrusivePtr<zeek::BroType> UnserializeType(const broker::data& data); static IntrusivePtr<zeek::Type> UnserializeType(const broker::data& data);
}; };
namespace probabilistic { namespace probabilistic {
@ -304,10 +304,10 @@ public:
IntrusivePtr<Val> DoClone(CloneState* state) override; IntrusivePtr<Val> DoClone(CloneState* state) override;
const IntrusivePtr<zeek::BroType>& Type() const const IntrusivePtr<zeek::Type>& Type() const
{ return type; } { return type; }
bool Typify(IntrusivePtr<zeek::BroType> type); bool Typify(IntrusivePtr<zeek::Type> type);
void Add(const Val* val); void Add(const Val* val);
size_t Count(const Val* val) const; size_t Count(const Val* val) const;
@ -328,7 +328,7 @@ private:
BloomFilterVal(const BloomFilterVal&); BloomFilterVal(const BloomFilterVal&);
BloomFilterVal& operator=(const BloomFilterVal&); BloomFilterVal& operator=(const BloomFilterVal&);
IntrusivePtr<zeek::BroType> type; IntrusivePtr<zeek::Type> type;
CompositeHash* hash; CompositeHash* hash;
probabilistic::BloomFilter* bloom_filter; probabilistic::BloomFilter* bloom_filter;
}; };
@ -343,10 +343,10 @@ public:
void Add(const Val* val); void Add(const Val* val);
const IntrusivePtr<zeek::BroType>& Type() const const IntrusivePtr<zeek::Type>& Type() const
{ return type; } { return type; }
bool Typify(IntrusivePtr<zeek::BroType> type); bool Typify(IntrusivePtr<zeek::Type> type);
probabilistic::CardinalityCounter* Get() { return c; }; probabilistic::CardinalityCounter* Get() { return c; };
@ -355,7 +355,7 @@ protected:
DECLARE_OPAQUE_VALUE(CardinalityVal) DECLARE_OPAQUE_VALUE(CardinalityVal)
private: private:
IntrusivePtr<zeek::BroType> type; IntrusivePtr<zeek::Type> type;
CompositeHash* hash; CompositeHash* hash;
probabilistic::CardinalityCounter* c; probabilistic::CardinalityCounter* c;
}; };

9
src/Scope.h
View file

@ -15,7 +15,8 @@
template <class T> class IntrusivePtr; template <class T> class IntrusivePtr;
class ListVal; class ListVal;
FORWARD_DECLARE_NAMESPACED(BroType, zeek); namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
FORWARD_DECLARE_NAMESPACED(ID, zeek::detail); FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
class Scope : public BroObj { class Scope : public BroObj {
@ -45,9 +46,9 @@ public:
{ return attrs; } { return attrs; }
[[deprecated("Remove in v4.1. Use GetReturnTrype().")]] [[deprecated("Remove in v4.1. Use GetReturnTrype().")]]
zeek::BroType* ReturnType() const { return return_type.get(); } zeek::Type* ReturnType() const { return return_type.get(); }
const IntrusivePtr<zeek::BroType>& GetReturnType() const const IntrusivePtr<zeek::Type>& GetReturnType() const
{ return return_type; } { return return_type; }
size_t Length() const { return local.size(); } size_t Length() const { return local.size(); }
@ -70,7 +71,7 @@ public:
protected: protected:
IntrusivePtr<zeek::detail::ID> scope_id; IntrusivePtr<zeek::detail::ID> scope_id;
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs; std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs;
IntrusivePtr<zeek::BroType> return_type; IntrusivePtr<zeek::Type> return_type;
std::map<std::string, IntrusivePtr<zeek::detail::ID>, std::less<>> local; std::map<std::string, IntrusivePtr<zeek::detail::ID>, std::less<>> local;
std::vector<IntrusivePtr<zeek::detail::ID>> inits; std::vector<IntrusivePtr<zeek::detail::ID>> inits;
}; };

124
src/Type.cc
View file

@ -24,7 +24,7 @@ using namespace std;
namespace zeek { namespace zeek {
BroType::TypeAliasMap BroType::type_aliases; Type::TypeAliasMap Type::type_aliases;
// Note: This function must be thread-safe. // Note: This function must be thread-safe.
const char* type_name(zeek::TypeTag t) const char* type_name(zeek::TypeTag t)
@ -64,14 +64,14 @@ const char* type_name(zeek::TypeTag t)
return type_names[int(t)]; return type_names[int(t)];
} }
BroType::BroType(zeek::TypeTag t, bool arg_base_type) Type::Type(zeek::TypeTag t, bool arg_base_type)
: tag(t), internal_tag(to_internal_type_tag(tag)), : tag(t), internal_tag(to_internal_type_tag(tag)),
is_network_order(zeek::is_network_order(t)), is_network_order(zeek::is_network_order(t)),
base_type(arg_base_type) base_type(arg_base_type)
{ {
} }
IntrusivePtr<BroType> BroType::ShallowClone() IntrusivePtr<Type> Type::ShallowClone()
{ {
switch ( tag ) { switch ( tag ) {
case TYPE_VOID: case TYPE_VOID:
@ -89,15 +89,15 @@ IntrusivePtr<BroType> BroType::ShallowClone()
case TYPE_ADDR: case TYPE_ADDR:
case TYPE_SUBNET: case TYPE_SUBNET:
case TYPE_ANY: case TYPE_ANY:
return make_intrusive<BroType>(tag, base_type); return make_intrusive<Type>(tag, base_type);
default: default:
reporter->InternalError("cloning illegal base BroType"); reporter->InternalError("cloning illegal base Type");
} }
return nullptr; return nullptr;
} }
int BroType::MatchesIndex(zeek::detail::ListExpr* const index) const int Type::MatchesIndex(zeek::detail::ListExpr* const index) const
{ {
if ( Tag() == TYPE_STRING ) if ( Tag() == TYPE_STRING )
{ {
@ -111,22 +111,22 @@ int BroType::MatchesIndex(zeek::detail::ListExpr* const index) const
return DOES_NOT_MATCH_INDEX; return DOES_NOT_MATCH_INDEX;
} }
const IntrusivePtr<BroType>& BroType::Yield() const const IntrusivePtr<Type>& Type::Yield() const
{ {
return BroType::nil; return Type::nil;
} }
bool BroType::HasField(const char* /* field */) const bool Type::HasField(const char* /* field */) const
{ {
return false; return false;
} }
BroType* BroType::FieldType(const char* /* field */) const Type* Type::FieldType(const char* /* field */) const
{ {
return nullptr; return nullptr;
} }
void BroType::Describe(ODesc* d) const void Type::Describe(ODesc* d) const
{ {
if ( d->IsBinary() ) if ( d->IsBinary() )
d->Add(int(Tag())); d->Add(int(Tag()));
@ -140,22 +140,22 @@ void BroType::Describe(ODesc* d) const
} }
} }
void BroType::DescribeReST(ODesc* d, bool roles_only) const void Type::DescribeReST(ODesc* d, bool roles_only) const
{ {
d->Add(fmt(":zeek:type:`%s`", type_name(Tag()))); d->Add(fmt(":zeek:type:`%s`", type_name(Tag())));
} }
void BroType::SetError() void Type::SetError()
{ {
tag = TYPE_ERROR; tag = TYPE_ERROR;
} }
unsigned int BroType::MemoryAllocation() const unsigned int Type::MemoryAllocation() const
{ {
return padded_sizeof(*this); return padded_sizeof(*this);
} }
bool TypeList::AllMatch(const BroType* t, bool is_init) const bool TypeList::AllMatch(const Type* t, bool is_init) const
{ {
for ( const auto& type : types ) for ( const auto& type : types )
if ( ! same_type(type, t, is_init) ) if ( ! same_type(type, t, is_init) )
@ -163,7 +163,7 @@ bool TypeList::AllMatch(const BroType* t, bool is_init) const
return true; return true;
} }
void TypeList::Append(IntrusivePtr<BroType> t) void TypeList::Append(IntrusivePtr<Type> t)
{ {
if ( pure_type && ! same_type(t, pure_type) ) if ( pure_type && ! same_type(t, pure_type) )
reporter->InternalError("pure type-list violation"); reporter->InternalError("pure type-list violation");
@ -171,7 +171,7 @@ void TypeList::Append(IntrusivePtr<BroType> t)
types.emplace_back(std::move(t)); types.emplace_back(std::move(t));
} }
void TypeList::AppendEvenIfNotPure(IntrusivePtr<BroType> t) void TypeList::AppendEvenIfNotPure(IntrusivePtr<Type> t)
{ {
if ( pure_type && ! same_type(t, pure_type) ) if ( pure_type && ! same_type(t, pure_type) )
pure_type = nullptr; pure_type = nullptr;
@ -215,8 +215,8 @@ unsigned int TypeList::MemoryAllocation() const
size += pad_size(types.capacity() * sizeof(decltype(types)::value_type)); size += pad_size(types.capacity() * sizeof(decltype(types)::value_type));
return BroType::MemoryAllocation() return Type::MemoryAllocation()
+ padded_sizeof(*this) - padded_sizeof(BroType) + padded_sizeof(*this) - padded_sizeof(Type)
+ size; + size;
} }
@ -238,7 +238,7 @@ int IndexType::MatchesIndex(zeek::detail::ListExpr* const index) const
void IndexType::Describe(ODesc* d) const void IndexType::Describe(ODesc* d) const
{ {
BroType::Describe(d); Type::Describe(d);
if ( ! d->IsBinary() ) if ( ! d->IsBinary() )
d->Add("["); d->Add("[");
@ -317,7 +317,7 @@ bool IndexType::IsSubNetIndex() const
return false; return false;
} }
TableType::TableType(IntrusivePtr<TypeList> ind, IntrusivePtr<BroType> yield) TableType::TableType(IntrusivePtr<TypeList> ind, IntrusivePtr<Type> yield)
: IndexType(TYPE_TABLE, std::move(ind), std::move(yield)) : IndexType(TYPE_TABLE, std::move(ind), std::move(yield))
{ {
if ( ! indices ) if ( ! indices )
@ -344,7 +344,7 @@ TableType::TableType(IntrusivePtr<TypeList> ind, IntrusivePtr<BroType> yield)
} }
} }
IntrusivePtr<BroType> TableType::ShallowClone() IntrusivePtr<Type> TableType::ShallowClone()
{ {
return make_intrusive<TableType>(indices, yield_type); return make_intrusive<TableType>(indices, yield_type);
} }
@ -378,7 +378,7 @@ SetType::SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr
else if ( tl.size() == 1 ) else if ( tl.size() == 1 )
{ {
IntrusivePtr<BroType> ft{NewRef{}, flatten_type(tl[0].get())}; IntrusivePtr<Type> ft{NewRef{}, flatten_type(tl[0].get())};
indices = make_intrusive<TypeList>(ft); indices = make_intrusive<TypeList>(ft);
indices->Append(std::move(ft)); indices->Append(std::move(ft));
} }
@ -403,7 +403,7 @@ SetType::SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr
} }
} }
IntrusivePtr<BroType> SetType::ShallowClone() IntrusivePtr<Type> SetType::ShallowClone()
{ {
return make_intrusive<SetType>(indices, elements); return make_intrusive<SetType>(indices, elements);
} }
@ -411,8 +411,8 @@ IntrusivePtr<BroType> SetType::ShallowClone()
SetType::~SetType() = default; SetType::~SetType() = default;
FuncType::FuncType(IntrusivePtr<RecordType> arg_args, FuncType::FuncType(IntrusivePtr<RecordType> arg_args,
IntrusivePtr<BroType> arg_yield, FunctionFlavor arg_flavor) IntrusivePtr<Type> arg_yield, FunctionFlavor arg_flavor)
: BroType(TYPE_FUNC), args(std::move(arg_args)), : Type(TYPE_FUNC), args(std::move(arg_args)),
arg_types(make_intrusive<TypeList>()), yield(std::move(arg_yield)) arg_types(make_intrusive<TypeList>()), yield(std::move(arg_yield))
{ {
flavor = arg_flavor; flavor = arg_flavor;
@ -441,7 +441,7 @@ FuncType::FuncType(IntrusivePtr<RecordType> arg_args,
prototypes.emplace_back(Prototype{false, args, std::move(offsets)}); prototypes.emplace_back(Prototype{false, args, std::move(offsets)});
} }
IntrusivePtr<BroType> FuncType::ShallowClone() IntrusivePtr<Type> FuncType::ShallowClone()
{ {
auto f = make_intrusive<FuncType>(); auto f = make_intrusive<FuncType>();
f->args = args; f->args = args;
@ -481,7 +481,7 @@ int FuncType::MatchesIndex(zeek::detail::ListExpr* const index) const
bool FuncType::CheckArgs(const type_list* args, bool is_init) const bool FuncType::CheckArgs(const type_list* args, bool is_init) const
{ {
std::vector<IntrusivePtr<BroType>> as; std::vector<IntrusivePtr<Type>> as;
as.reserve(args->length()); as.reserve(args->length());
for ( auto a : *args ) for ( auto a : *args )
@ -490,7 +490,7 @@ bool FuncType::CheckArgs(const type_list* args, bool is_init) const
return CheckArgs(as, is_init); return CheckArgs(as, is_init);
} }
bool FuncType::CheckArgs(const std::vector<IntrusivePtr<BroType>>& args, bool FuncType::CheckArgs(const std::vector<IntrusivePtr<Type>>& args,
bool is_init) const bool is_init) const
{ {
const auto& my_args = arg_types->Types(); const auto& my_args = arg_types->Types();
@ -609,7 +609,7 @@ std::optional<FuncType::Prototype> FuncType::FindPrototype(const RecordType& arg
return {}; return {};
} }
TypeDecl::TypeDecl(const char* i, IntrusivePtr<BroType> t, TypeDecl::TypeDecl(const char* i, IntrusivePtr<Type> t,
IntrusivePtr<zeek::detail::Attributes> arg_attrs) IntrusivePtr<zeek::detail::Attributes> arg_attrs)
: type(std::move(t)), : type(std::move(t)),
attrs(std::move(arg_attrs)), attrs(std::move(arg_attrs)),
@ -650,7 +650,7 @@ void TypeDecl::DescribeReST(ODesc* d, bool roles_only) const
} }
} }
RecordType::RecordType(type_decl_list* arg_types) : BroType(TYPE_RECORD) RecordType::RecordType(type_decl_list* arg_types) : Type(TYPE_RECORD)
{ {
types = arg_types; types = arg_types;
num_fields = types ? types->length() : 0; num_fields = types ? types->length() : 0;
@ -658,7 +658,7 @@ RecordType::RecordType(type_decl_list* arg_types) : BroType(TYPE_RECORD)
// in this case the clone is actually not so shallow, since // in this case the clone is actually not so shallow, since
// it gets modified by everyone. // it gets modified by everyone.
IntrusivePtr<BroType> RecordType::ShallowClone() IntrusivePtr<Type> RecordType::ShallowClone()
{ {
auto pass = new type_decl_list(); auto pass = new type_decl_list();
for ( const auto& type : *types ) for ( const auto& type : *types )
@ -760,7 +760,7 @@ void RecordType::DescribeReST(ODesc* d, bool roles_only) const
d->PopType(this); d->PopType(this);
} }
static string container_type_name(const BroType* ft) static string container_type_name(const Type* ft)
{ {
string s; string s;
if ( ft->Tag() == TYPE_RECORD ) if ( ft->Tag() == TYPE_RECORD )
@ -1016,7 +1016,7 @@ string RecordType::GetFieldDeprecationWarning(int field, bool has_check) const
return ""; return "";
} }
SubNetType::SubNetType() : BroType(TYPE_SUBNET) SubNetType::SubNetType() : Type(TYPE_SUBNET)
{ {
} }
@ -1028,8 +1028,8 @@ void SubNetType::Describe(ODesc* d) const
d->Add(int(Tag())); d->Add(int(Tag()));
} }
FileType::FileType(IntrusivePtr<BroType> yield_type) FileType::FileType(IntrusivePtr<Type> yield_type)
: BroType(TYPE_FILE), yield(std::move(yield_type)) : Type(TYPE_FILE), yield(std::move(yield_type))
{ {
} }
@ -1049,7 +1049,7 @@ void FileType::Describe(ODesc* d) const
} }
} }
OpaqueType::OpaqueType(const string& arg_name) : BroType(TYPE_OPAQUE) OpaqueType::OpaqueType(const string& arg_name) : Type(TYPE_OPAQUE)
{ {
name = arg_name; name = arg_name;
} }
@ -1070,20 +1070,20 @@ void OpaqueType::DescribeReST(ODesc* d, bool roles_only) const
} }
EnumType::EnumType(const string& name) EnumType::EnumType(const string& name)
: BroType(TYPE_ENUM) : Type(TYPE_ENUM)
{ {
counter = 0; counter = 0;
SetName(name); SetName(name);
} }
EnumType::EnumType(const EnumType* e) EnumType::EnumType(const EnumType* e)
: BroType(TYPE_ENUM), names(e->names), vals(e->vals) : Type(TYPE_ENUM), names(e->names), vals(e->vals)
{ {
counter = e->counter; counter = e->counter;
SetName(e->GetName()); SetName(e->GetName());
} }
IntrusivePtr<BroType> EnumType::ShallowClone() IntrusivePtr<Type> EnumType::ShallowClone()
{ {
if ( counter == 0 ) if ( counter == 0 )
return make_intrusive<EnumType>(GetName()); return make_intrusive<EnumType>(GetName());
@ -1166,8 +1166,8 @@ void EnumType::CheckAndAddName(const string& module_name, const char* name,
if ( vals.find(val) == vals.end() ) if ( vals.find(val) == vals.end() )
vals[val] = make_intrusive<EnumVal>(IntrusivePtr{NewRef{}, this}, val); vals[val] = make_intrusive<EnumVal>(IntrusivePtr{NewRef{}, this}, val);
set<BroType*> types = BroType::GetAliases(GetName()); set<Type*> types = Type::GetAliases(GetName());
set<BroType*>::const_iterator it; set<Type*>::const_iterator it;
for ( it = types.begin(); it != types.end(); ++it ) for ( it = types.begin(); it != types.end(); ++it )
if ( *it != this ) if ( *it != this )
@ -1303,19 +1303,19 @@ void EnumType::DescribeReST(ODesc* d, bool roles_only) const
} }
} }
VectorType::VectorType(IntrusivePtr<BroType> element_type) VectorType::VectorType(IntrusivePtr<Type> element_type)
: BroType(TYPE_VECTOR), yield_type(std::move(element_type)) : Type(TYPE_VECTOR), yield_type(std::move(element_type))
{ {
} }
IntrusivePtr<BroType> VectorType::ShallowClone() IntrusivePtr<Type> VectorType::ShallowClone()
{ {
return make_intrusive<VectorType>(yield_type); return make_intrusive<VectorType>(yield_type);
} }
VectorType::~VectorType() = default; VectorType::~VectorType() = default;
const IntrusivePtr<BroType>& VectorType::Yield() const const IntrusivePtr<Type>& VectorType::Yield() const
{ {
// Work around the fact that we use void internally to mark a vector // Work around the fact that we use void internally to mark a vector
// as being unspecified. When looking at its yield type, we need to // as being unspecified. When looking at its yield type, we need to
@ -1376,7 +1376,7 @@ void VectorType::DescribeReST(ODesc* d, bool roles_only) const
// false otherwise. Assumes that t1's tag is different from t2's. Note // false otherwise. Assumes that t1's tag is different from t2's. Note
// that the test is in only one direction - we don't check whether t2 is // that the test is in only one direction - we don't check whether t2 is
// initialization-compatible with t1. // initialization-compatible with t1.
static bool is_init_compat(const BroType& t1, const BroType& t2) static bool is_init_compat(const Type& t1, const Type& t2)
{ {
if ( t1.Tag() == TYPE_LIST ) if ( t1.Tag() == TYPE_LIST )
{ {
@ -1392,7 +1392,7 @@ static bool is_init_compat(const BroType& t1, const BroType& t2)
return false; return false;
} }
bool same_type(const BroType& arg_t1, const BroType& arg_t2, bool same_type(const Type& arg_t1, const Type& arg_t2,
bool is_init, bool match_record_field_names) bool is_init, bool match_record_field_names)
{ {
if ( &arg_t1 == &arg_t2 || if ( &arg_t1 == &arg_t2 ||
@ -1587,7 +1587,7 @@ bool record_promotion_compatible(const RecordType* super_rec,
return true; return true;
} }
const BroType* flatten_type(const BroType* t) const Type* flatten_type(const Type* t)
{ {
if ( t->Tag() != TYPE_LIST ) if ( t->Tag() != TYPE_LIST )
return t; return t;
@ -1610,9 +1610,9 @@ const BroType* flatten_type(const BroType* t)
return t; return t;
} }
BroType* flatten_type(BroType* t) Type* flatten_type(Type* t)
{ {
return (BroType*) flatten_type((const BroType*) t); return (Type*) flatten_type((const Type*) t);
} }
bool is_assignable(TypeTag t) bool is_assignable(TypeTag t)
@ -1684,8 +1684,8 @@ TypeTag max_type(TypeTag t1, TypeTag t2)
} }
} }
IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& arg_t1, IntrusivePtr<Type> merge_types(const IntrusivePtr<Type>& arg_t1,
const IntrusivePtr<BroType>& arg_t2) const IntrusivePtr<Type>& arg_t2)
{ {
auto t1 = arg_t1.get(); auto t1 = arg_t1.get();
auto t2 = arg_t2.get(); auto t2 = arg_t2.get();
@ -1779,7 +1779,7 @@ IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& arg_t1,
const auto& y1 = t1->Yield(); const auto& y1 = t1->Yield();
const auto& y2 = t2->Yield(); const auto& y2 = t2->Yield();
IntrusivePtr<BroType> y3; IntrusivePtr<Type> y3;
if ( y1 || y2 ) if ( y1 || y2 )
{ {
@ -1924,7 +1924,7 @@ IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& arg_t1,
} }
} }
IntrusivePtr<BroType> merge_type_list(zeek::detail::ListExpr* elements) IntrusivePtr<Type> merge_type_list(zeek::detail::ListExpr* elements)
{ {
TypeList* tl_type = elements->GetType()->AsTypeList(); TypeList* tl_type = elements->GetType()->AsTypeList();
const auto& tl = tl_type->Types(); const auto& tl = tl_type->Types();
@ -1950,7 +1950,7 @@ IntrusivePtr<BroType> merge_type_list(zeek::detail::ListExpr* elements)
} }
// Reduces an aggregate type. // Reduces an aggregate type.
static BroType* reduce_type(BroType* t) static Type* reduce_type(Type* t)
{ {
if ( t->Tag() == TYPE_LIST ) if ( t->Tag() == TYPE_LIST )
return flatten_type(t); return flatten_type(t);
@ -1969,7 +1969,7 @@ static BroType* reduce_type(BroType* t)
return t; return t;
} }
IntrusivePtr<BroType> init_type(zeek::detail::Expr* init) IntrusivePtr<Type> init_type(zeek::detail::Expr* init)
{ {
if ( init->Tag() != zeek::detail::EXPR_LIST ) if ( init->Tag() != zeek::detail::EXPR_LIST )
{ {
@ -2016,7 +2016,7 @@ IntrusivePtr<BroType> init_type(zeek::detail::Expr* init)
for ( int i = 1; t && i < el.length(); ++i ) for ( int i = 1; t && i < el.length(); ++i )
{ {
auto el_t = el[i]->InitType(); auto el_t = el[i]->InitType();
IntrusivePtr<BroType> ti; IntrusivePtr<Type> ti;
if ( el_t ) if ( el_t )
ti = {NewRef{}, reduce_type(el_t.get())}; ti = {NewRef{}, reduce_type(el_t.get())};
@ -2053,7 +2053,7 @@ IntrusivePtr<BroType> init_type(zeek::detail::Expr* init)
nullptr); nullptr);
} }
bool is_atomic_type(const BroType& t) bool is_atomic_type(const Type& t)
{ {
switch ( t.InternalType() ) { switch ( t.InternalType() ) {
case TYPE_INTERNAL_INT: case TYPE_INTERNAL_INT:
@ -2068,14 +2068,14 @@ bool is_atomic_type(const BroType& t)
} }
} }
const IntrusivePtr<BroType>& base_type(zeek::TypeTag tag) const IntrusivePtr<Type>& base_type(zeek::TypeTag tag)
{ {
static IntrusivePtr<BroType> base_types[NUM_TYPES]; static IntrusivePtr<Type> base_types[NUM_TYPES];
// We could check here that "tag" actually corresponds to a basic type. // We could check here that "tag" actually corresponds to a basic type.
if ( ! base_types[tag] ) if ( ! base_types[tag] )
{ {
base_types[tag] = make_intrusive<BroType>(tag, true); base_types[tag] = make_intrusive<Type>(tag, true);
// Give the base types a pseudo-location for easier identification. // Give the base types a pseudo-location for easier identification.
Location l(type_name(tag), 0, 0, 0, 0); Location l(type_name(tag), 0, 0, 0, 0);
base_types[tag]->SetLocationInfo(&l); base_types[tag]->SetLocationInfo(&l);

236
src/Type.h
View file

@ -185,14 +185,14 @@ constexpr int DOES_NOT_MATCH_INDEX = 0;
constexpr int MATCHES_INDEX_SCALAR = 1; constexpr int MATCHES_INDEX_SCALAR = 1;
constexpr int MATCHES_INDEX_VECTOR = 2; constexpr int MATCHES_INDEX_VECTOR = 2;
class BroType : public BroObj { class Type : public BroObj {
public: public:
static inline const IntrusivePtr<BroType> nil; static inline const IntrusivePtr<Type> nil;
explicit BroType(zeek::TypeTag tag, bool base_type = false); explicit Type(zeek::TypeTag tag, bool base_type = false);
[[deprecated("Remove in v4.1. Use the version that takes zeek::TypeTag instead.")]] [[deprecated("Remove in v4.1. Use the version that takes zeek::TypeTag instead.")]]
explicit BroType(::TypeTag tag, bool base_type = false) explicit Type(::TypeTag tag, bool base_type = false)
: BroType(static_cast<zeek::TypeTag>(tag), base_type) : Type(static_cast<zeek::TypeTag>(tag), base_type)
{} {}
// Performs a shallow clone operation of the Bro type. // Performs a shallow clone operation of the Bro type.
@ -203,7 +203,7 @@ public:
// Clone operations will mostly be implemented in the derived classes; // Clone operations will mostly be implemented in the derived classes;
// in addition cloning will be limited to classes that can be reached by // in addition cloning will be limited to classes that can be reached by
// the script-level. // the script-level.
virtual IntrusivePtr<BroType> ShallowClone(); virtual IntrusivePtr<Type> ShallowClone();
TypeTag Tag() const { return tag; } TypeTag Tag() const { return tag; }
InternalTypeTag InternalType() const { return internal_tag; } InternalTypeTag InternalType() const { return internal_tag; }
@ -223,13 +223,13 @@ public:
// Returns the type yielded by this type. For example, if // Returns the type yielded by this type. For example, if
// this type is a table[string] of port, then returns the "port" // this type is a table[string] of port, then returns the "port"
// type. Returns nil if this is not an index type. // type. Returns nil if this is not an index type.
virtual const IntrusivePtr<BroType>& Yield() const; virtual const IntrusivePtr<Type>& Yield() const;
[[deprecated("Remove in v4.1. Use Yield() instead.")]] [[deprecated("Remove in v4.1. Use Yield() instead.")]]
virtual BroType* YieldType() virtual Type* YieldType()
{ return Yield().get(); } { return Yield().get(); }
[[deprecated("Remove in v4.1. Use Yield() instead.")]] [[deprecated("Remove in v4.1. Use Yield() instead.")]]
virtual const BroType* YieldType() const virtual const Type* YieldType() const
{ return Yield().get(); } { return Yield().get(); }
// Returns true if this type is a record and contains the // Returns true if this type is a record and contains the
@ -239,126 +239,126 @@ public:
// Returns the type of the given field, or nil if no such field. // Returns the type of the given field, or nil if no such field.
[[deprecated("Remove in v4.1. Use RecordType::GetFieldType() directly.")]] [[deprecated("Remove in v4.1. Use RecordType::GetFieldType() directly.")]]
virtual BroType* FieldType(const char* field) const; virtual Type* FieldType(const char* field) const;
#define CHECK_TYPE_TAG(tag_type, func_name) \ #define CHECK_TYPE_TAG(tag_type, func_name) \
CHECK_TAG(tag, tag_type, func_name, type_name) CHECK_TAG(tag, tag_type, func_name, type_name)
const TypeList* AsTypeList() const const TypeList* AsTypeList() const
{ {
CHECK_TYPE_TAG(TYPE_LIST, "BroType::AsTypeList"); CHECK_TYPE_TAG(TYPE_LIST, "Type::AsTypeList");
return (const TypeList*) this; return (const TypeList*) this;
} }
TypeList* AsTypeList() TypeList* AsTypeList()
{ {
CHECK_TYPE_TAG(TYPE_LIST, "BroType::AsTypeList"); CHECK_TYPE_TAG(TYPE_LIST, "Type::AsTypeList");
return (TypeList*) this; return (TypeList*) this;
} }
const TableType* AsTableType() const const TableType* AsTableType() const
{ {
CHECK_TYPE_TAG(TYPE_TABLE, "BroType::AsTableType"); CHECK_TYPE_TAG(TYPE_TABLE, "Type::AsTableType");
return (const TableType*) this; return (const TableType*) this;
} }
TableType* AsTableType() TableType* AsTableType()
{ {
CHECK_TYPE_TAG(TYPE_TABLE, "BroType::AsTableType"); CHECK_TYPE_TAG(TYPE_TABLE, "Type::AsTableType");
return (TableType*) this; return (TableType*) this;
} }
SetType* AsSetType() SetType* AsSetType()
{ {
if ( ! IsSet() ) if ( ! IsSet() )
BadTag("BroType::AsSetType", type_name(tag)); BadTag("Type::AsSetType", type_name(tag));
return (SetType*) this; return (SetType*) this;
} }
const SetType* AsSetType() const const SetType* AsSetType() const
{ {
if ( ! IsSet() ) if ( ! IsSet() )
BadTag("BroType::AsSetType", type_name(tag)); BadTag("Type::AsSetType", type_name(tag));
return (const SetType*) this; return (const SetType*) this;
} }
const RecordType* AsRecordType() const const RecordType* AsRecordType() const
{ {
CHECK_TYPE_TAG(TYPE_RECORD, "BroType::AsRecordType"); CHECK_TYPE_TAG(TYPE_RECORD, "Type::AsRecordType");
return (const RecordType*) this; return (const RecordType*) this;
} }
RecordType* AsRecordType() RecordType* AsRecordType()
{ {
CHECK_TYPE_TAG(TYPE_RECORD, "BroType::AsRecordType"); CHECK_TYPE_TAG(TYPE_RECORD, "Type::AsRecordType");
return (RecordType*) this; return (RecordType*) this;
} }
const SubNetType* AsSubNetType() const const SubNetType* AsSubNetType() const
{ {
CHECK_TYPE_TAG(TYPE_SUBNET, "BroType::AsSubNetType"); CHECK_TYPE_TAG(TYPE_SUBNET, "Type::AsSubNetType");
return (const SubNetType*) this; return (const SubNetType*) this;
} }
SubNetType* AsSubNetType() SubNetType* AsSubNetType()
{ {
CHECK_TYPE_TAG(TYPE_SUBNET, "BroType::AsSubNetType"); CHECK_TYPE_TAG(TYPE_SUBNET, "Type::AsSubNetType");
return (SubNetType*) this; return (SubNetType*) this;
} }
const FuncType* AsFuncType() const const FuncType* AsFuncType() const
{ {
CHECK_TYPE_TAG(TYPE_FUNC, "BroType::AsFuncType"); CHECK_TYPE_TAG(TYPE_FUNC, "Type::AsFuncType");
return (const FuncType*) this; return (const FuncType*) this;
} }
FuncType* AsFuncType() FuncType* AsFuncType()
{ {
CHECK_TYPE_TAG(TYPE_FUNC, "BroType::AsFuncType"); CHECK_TYPE_TAG(TYPE_FUNC, "Type::AsFuncType");
return (FuncType*) this; return (FuncType*) this;
} }
const EnumType* AsEnumType() const const EnumType* AsEnumType() const
{ {
CHECK_TYPE_TAG(TYPE_ENUM, "BroType::AsEnumType"); CHECK_TYPE_TAG(TYPE_ENUM, "Type::AsEnumType");
return (EnumType*) this; return (EnumType*) this;
} }
EnumType* AsEnumType() EnumType* AsEnumType()
{ {
CHECK_TYPE_TAG(TYPE_ENUM, "BroType::AsEnumType"); CHECK_TYPE_TAG(TYPE_ENUM, "Type::AsEnumType");
return (EnumType*) this; return (EnumType*) this;
} }
const VectorType* AsVectorType() const const VectorType* AsVectorType() const
{ {
CHECK_TYPE_TAG(TYPE_VECTOR, "BroType::AsVectorType"); CHECK_TYPE_TAG(TYPE_VECTOR, "Type::AsVectorType");
return (VectorType*) this; return (VectorType*) this;
} }
OpaqueType* AsOpaqueType() OpaqueType* AsOpaqueType()
{ {
CHECK_TYPE_TAG(TYPE_OPAQUE, "BroType::AsOpaqueType"); CHECK_TYPE_TAG(TYPE_OPAQUE, "Type::AsOpaqueType");
return (OpaqueType*) this; return (OpaqueType*) this;
} }
const OpaqueType* AsOpaqueType() const const OpaqueType* AsOpaqueType() const
{ {
CHECK_TYPE_TAG(TYPE_OPAQUE, "BroType::AsOpaqueType"); CHECK_TYPE_TAG(TYPE_OPAQUE, "Type::AsOpaqueType");
return (OpaqueType*) this; return (OpaqueType*) this;
} }
VectorType* AsVectorType() VectorType* AsVectorType()
{ {
CHECK_TYPE_TAG(TYPE_VECTOR, "BroType::AsVectorType"); CHECK_TYPE_TAG(TYPE_VECTOR, "Type::AsVectorType");
return (VectorType*) this; return (VectorType*) this;
} }
const TypeType* AsTypeType() const const TypeType* AsTypeType() const
{ {
CHECK_TYPE_TAG(TYPE_TYPE, "BroType::AsTypeType"); CHECK_TYPE_TAG(TYPE_TYPE, "Type::AsTypeType");
return (TypeType*) this; return (TypeType*) this;
} }
TypeType* AsTypeType() TypeType* AsTypeType()
{ {
CHECK_TYPE_TAG(TYPE_TYPE, "BroType::AsTypeType"); CHECK_TYPE_TAG(TYPE_TYPE, "Type::AsTypeType");
return (TypeType*) this; return (TypeType*) this;
} }
@ -372,7 +372,7 @@ public:
return tag == TYPE_TABLE && Yield(); return tag == TYPE_TABLE && Yield();
} }
BroType* Ref() { ::Ref(this); return this; } Type* Ref() { ::Ref(this); return this; }
void Describe(ODesc* d) const override; void Describe(ODesc* d) const override;
virtual void DescribeReST(ODesc* d, bool roles_only = false) const; virtual void DescribeReST(ODesc* d, bool roles_only = false) const;
@ -382,16 +382,16 @@ public:
void SetName(const std::string& arg_name) { name = arg_name; } void SetName(const std::string& arg_name) { name = arg_name; }
const std::string& GetName() const { return name; } const std::string& GetName() const { return name; }
typedef std::map<std::string, std::set<BroType*> > TypeAliasMap; typedef std::map<std::string, std::set<Type*> > TypeAliasMap;
static std::set<BroType*> GetAliases(const std::string& type_name) static std::set<Type*> GetAliases(const std::string& type_name)
{ return BroType::type_aliases[type_name]; } { return Type::type_aliases[type_name]; }
static void AddAlias(const std::string &type_name, BroType* type) static void AddAlias(const std::string &type_name, Type* type)
{ BroType::type_aliases[type_name].insert(type); } { Type::type_aliases[type_name].insert(type); }
protected: protected:
BroType() { } Type() = default;
void SetError(); void SetError();
@ -405,48 +405,48 @@ private:
static TypeAliasMap type_aliases; static TypeAliasMap type_aliases;
}; };
class TypeList final : public BroType { class TypeList final : public Type {
public: public:
explicit TypeList(IntrusivePtr<BroType> arg_pure_type = nullptr) explicit TypeList(IntrusivePtr<Type> arg_pure_type = nullptr)
: BroType(TYPE_LIST), pure_type(std::move(arg_pure_type)) : Type(TYPE_LIST), pure_type(std::move(arg_pure_type))
{ {
} }
const std::vector<IntrusivePtr<BroType>>& Types() const const std::vector<IntrusivePtr<Type>>& Types() const
{ return types; } { return types; }
bool IsPure() const { return pure_type != nullptr; } bool IsPure() const { return pure_type != nullptr; }
// Returns the underlying pure type, or nil if the list // Returns the underlying pure type, or nil if the list
// is not pure or is empty. // is not pure or is empty.
const IntrusivePtr<BroType>& GetPureType() const const IntrusivePtr<Type>& GetPureType() const
{ return pure_type; } { return pure_type; }
[[deprecated("Remove in v4.1. Use GetPureType() instead.")]] [[deprecated("Remove in v4.1. Use GetPureType() instead.")]]
BroType* PureType() { return pure_type.get(); } Type* PureType() { return pure_type.get(); }
[[deprecated("Remove in v4.1. Use GetPureType() instead.")]] [[deprecated("Remove in v4.1. Use GetPureType() instead.")]]
const BroType* PureType() const { return pure_type.get(); } const Type* PureType() const { return pure_type.get(); }
// True if all of the types match t, false otherwise. If // True if all of the types match t, false otherwise. If
// is_init is true, then the matching is done in the context // is_init is true, then the matching is done in the context
// of an initialization. // of an initialization.
bool AllMatch(const BroType* t, bool is_init) const; bool AllMatch(const Type* t, bool is_init) const;
bool AllMatch(const IntrusivePtr<BroType>& t, bool is_init) const bool AllMatch(const IntrusivePtr<Type>& t, bool is_init) const
{ return AllMatch(t.get(), is_init); } { return AllMatch(t.get(), is_init); }
void Append(IntrusivePtr<BroType> t); void Append(IntrusivePtr<Type> t);
void AppendEvenIfNotPure(IntrusivePtr<BroType> t); void AppendEvenIfNotPure(IntrusivePtr<Type> t);
void Describe(ODesc* d) const override; void Describe(ODesc* d) const override;
unsigned int MemoryAllocation() const override; unsigned int MemoryAllocation() const override;
protected: protected:
IntrusivePtr<BroType> pure_type; IntrusivePtr<Type> pure_type;
std::vector<IntrusivePtr<BroType>> types; std::vector<IntrusivePtr<Type>> types;
}; };
class IndexType : public BroType { class IndexType : public Type {
public: public:
int MatchesIndex(zeek::detail::ListExpr* index) const override; int MatchesIndex(zeek::detail::ListExpr* index) const override;
@ -456,10 +456,10 @@ public:
[[deprecated("Remove in v4.1. Use GetIndices().")]] [[deprecated("Remove in v4.1. Use GetIndices().")]]
TypeList* Indices() const { return indices.get(); } TypeList* Indices() const { return indices.get(); }
const std::vector<IntrusivePtr<BroType>>& IndexTypes() const const std::vector<IntrusivePtr<Type>>& IndexTypes() const
{ return indices->Types(); } { return indices->Types(); }
const IntrusivePtr<BroType>& Yield() const override const IntrusivePtr<Type>& Yield() const override
{ return yield_type; } { return yield_type; }
void Describe(ODesc* d) const override; void Describe(ODesc* d) const override;
@ -470,8 +470,8 @@ public:
protected: protected:
IndexType(TypeTag t, IntrusivePtr<TypeList> arg_indices, IndexType(TypeTag t, IntrusivePtr<TypeList> arg_indices,
IntrusivePtr<BroType> arg_yield_type) IntrusivePtr<Type> arg_yield_type)
: BroType(t), indices(std::move(arg_indices)), : Type(t), indices(std::move(arg_indices)),
yield_type(std::move(arg_yield_type)) yield_type(std::move(arg_yield_type))
{ {
} }
@ -479,14 +479,14 @@ protected:
~IndexType() override; ~IndexType() override;
IntrusivePtr<TypeList> indices; IntrusivePtr<TypeList> indices;
IntrusivePtr<BroType> yield_type; IntrusivePtr<Type> yield_type;
}; };
class TableType : public IndexType { class TableType : public IndexType {
public: public:
TableType(IntrusivePtr<TypeList> ind, IntrusivePtr<BroType> yield); TableType(IntrusivePtr<TypeList> ind, IntrusivePtr<Type> yield);
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
// Returns true if this table type is "unspecified", which is // Returns true if this table type is "unspecified", which is
// what one gets using an empty "set()" or "table()" constructor. // what one gets using an empty "set()" or "table()" constructor.
@ -498,7 +498,7 @@ public:
SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr> arg_elements); SetType(IntrusivePtr<TypeList> ind, IntrusivePtr<zeek::detail::ListExpr> arg_elements);
~SetType() override; ~SetType() override;
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
[[deprecated("Remove in v4.1. Use Elements() isntead.")]] [[deprecated("Remove in v4.1. Use Elements() isntead.")]]
zeek::detail::ListExpr* SetElements() const { return elements.get(); } zeek::detail::ListExpr* SetElements() const { return elements.get(); }
@ -510,7 +510,7 @@ protected:
IntrusivePtr<zeek::detail::ListExpr> elements; IntrusivePtr<zeek::detail::ListExpr> elements;
}; };
class FuncType final : public BroType { class FuncType final : public Type {
public: public:
static inline const IntrusivePtr<FuncType> nil; static inline const IntrusivePtr<FuncType> nil;
@ -525,15 +525,15 @@ public:
std::map<int, int> offsets; std::map<int, int> offsets;
}; };
FuncType(IntrusivePtr<RecordType> args, IntrusivePtr<BroType> yield, FuncType(IntrusivePtr<RecordType> args, IntrusivePtr<Type> yield,
FunctionFlavor f); FunctionFlavor f);
[[deprecated("Remove in v4.1. Use the version that takes zeek::FunctionFlavor instead.")]] [[deprecated("Remove in v4.1. Use the version that takes zeek::FunctionFlavor instead.")]]
FuncType(IntrusivePtr<RecordType> args, IntrusivePtr<BroType> yield, ::function_flavor f) FuncType(IntrusivePtr<RecordType> args, IntrusivePtr<Type> yield, ::function_flavor f)
: FuncType(args, yield, static_cast<FunctionFlavor>(f)) : FuncType(args, yield, static_cast<FunctionFlavor>(f))
{} {}
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
~FuncType() override; ~FuncType() override;
@ -543,10 +543,10 @@ public:
const IntrusivePtr<RecordType>& Params() const const IntrusivePtr<RecordType>& Params() const
{ return args; } { return args; }
const IntrusivePtr<BroType>& Yield() const override const IntrusivePtr<Type>& Yield() const override
{ return yield; } { return yield; }
void SetYieldType(IntrusivePtr<BroType> arg_yield) { yield = std::move(arg_yield); } void SetYieldType(IntrusivePtr<Type> arg_yield) { yield = std::move(arg_yield); }
FunctionFlavor Flavor() const { return flavor; } FunctionFlavor Flavor() const { return flavor; }
std::string FlavorString() const; std::string FlavorString() const;
@ -560,7 +560,7 @@ public:
int MatchesIndex(zeek::detail::ListExpr* index) const override; int MatchesIndex(zeek::detail::ListExpr* index) const override;
bool CheckArgs(const type_list* args, bool is_init = false) const; bool CheckArgs(const type_list* args, bool is_init = false) const;
bool CheckArgs(const std::vector<IntrusivePtr<BroType>>& args, bool CheckArgs(const std::vector<IntrusivePtr<Type>>& args,
bool is_init = false) const; bool is_init = false) const;
[[deprecated("Remove in v4.1. Use ParamList().")]] [[deprecated("Remove in v4.1. Use ParamList().")]]
@ -591,20 +591,20 @@ public:
protected: protected:
friend IntrusivePtr<FuncType> make_intrusive<FuncType>(); friend IntrusivePtr<FuncType> make_intrusive<FuncType>();
FuncType() : BroType(TYPE_FUNC) { flavor = FUNC_FLAVOR_FUNCTION; } FuncType() : Type(TYPE_FUNC) { flavor = FUNC_FLAVOR_FUNCTION; }
IntrusivePtr<RecordType> args; IntrusivePtr<RecordType> args;
IntrusivePtr<TypeList> arg_types; IntrusivePtr<TypeList> arg_types;
IntrusivePtr<BroType> yield; IntrusivePtr<Type> yield;
FunctionFlavor flavor; FunctionFlavor flavor;
std::vector<Prototype> prototypes; std::vector<Prototype> prototypes;
}; };
class TypeType final : public BroType { class TypeType final : public Type {
public: public:
explicit TypeType(IntrusivePtr<BroType> t) : BroType(TYPE_TYPE), type(std::move(t)) {} explicit TypeType(IntrusivePtr<Type> t) : zeek::Type(TYPE_TYPE), type(std::move(t)) {}
IntrusivePtr<BroType> ShallowClone() override { return make_intrusive<TypeType>(type); } IntrusivePtr<Type> ShallowClone() override { return make_intrusive<TypeType>(type); }
const IntrusivePtr<BroType>& GetType() const const IntrusivePtr<Type>& GetType() const
{ return type; } { return type; }
template <class T> template <class T>
@ -612,18 +612,18 @@ public:
{ return cast_intrusive<T>(type); } { return cast_intrusive<T>(type); }
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
BroType* Type() { return type.get(); } zeek::Type* Type() { return type.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
const BroType* Type() const { return type.get(); } const zeek::Type* Type() const { return type.get(); }
protected: protected:
IntrusivePtr<BroType> type; IntrusivePtr<zeek::Type> type;
}; };
class TypeDecl final { class TypeDecl final {
public: public:
TypeDecl() = default; TypeDecl() = default;
TypeDecl(const char* i, IntrusivePtr<BroType> t, TypeDecl(const char* i, IntrusivePtr<Type> t,
IntrusivePtr<zeek::detail::Attributes> attrs = nullptr); IntrusivePtr<zeek::detail::Attributes> attrs = nullptr);
TypeDecl(const TypeDecl& other); TypeDecl(const TypeDecl& other);
~TypeDecl(); ~TypeDecl();
@ -637,38 +637,38 @@ public:
void DescribeReST(ODesc* d, bool roles_only = false) const; void DescribeReST(ODesc* d, bool roles_only = false) const;
IntrusivePtr<BroType> type; IntrusivePtr<Type> type;
IntrusivePtr<zeek::detail::Attributes> attrs; IntrusivePtr<zeek::detail::Attributes> attrs;
const char* id = nullptr; const char* id = nullptr;
}; };
using type_decl_list = PList<TypeDecl>; using type_decl_list = PList<TypeDecl>;
class RecordType final : public BroType { class RecordType final : public Type {
public: public:
explicit RecordType(type_decl_list* types); explicit RecordType(type_decl_list* types);
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
~RecordType() override; ~RecordType() override;
bool HasField(const char* field) const override; bool HasField(const char* field) const override;
[[deprecated("Remove in v4.1. Use GetFieldType() instead (note it doesn't check for invalid names).")]] [[deprecated("Remove in v4.1. Use GetFieldType() instead (note it doesn't check for invalid names).")]]
BroType* FieldType(const char* field) const override Type* FieldType(const char* field) const override
{ {
auto offset = FieldOffset(field); auto offset = FieldOffset(field);
return offset >= 0 ? GetFieldType(offset).get() : nullptr; return offset >= 0 ? GetFieldType(offset).get() : nullptr;
} }
[[deprecated("Remove in v4.1. Use GetFieldType() instead.")]] [[deprecated("Remove in v4.1. Use GetFieldType() instead.")]]
BroType* FieldType(int field) const Type* FieldType(int field) const
{ return GetFieldType(field).get(); } { return GetFieldType(field).get(); }
/** /**
* Looks up a field by name and returns its type. No check for invalid * Looks up a field by name and returns its type. No check for invalid
* field name is performed. * field name is performed.
*/ */
const IntrusivePtr<BroType>& GetFieldType(const char* field_name) const const IntrusivePtr<Type>& GetFieldType(const char* field_name) const
{ return GetFieldType(FieldOffset(field_name)); } { return GetFieldType(FieldOffset(field_name)); }
/** /**
@ -683,7 +683,7 @@ public:
* Looks up a field by its index and returns its type. No check for * Looks up a field by its index and returns its type. No check for
* invalid field offset is performed. * invalid field offset is performed.
*/ */
const IntrusivePtr<BroType>& GetFieldType(int field_index) const const IntrusivePtr<Type>& GetFieldType(int field_index) const
{ return (*types)[field_index]->type; } { return (*types)[field_index]->type; }
/** /**
@ -753,31 +753,31 @@ protected:
type_decl_list* types; type_decl_list* types;
}; };
class SubNetType final : public BroType { class SubNetType final : public Type {
public: public:
SubNetType(); SubNetType();
void Describe(ODesc* d) const override; void Describe(ODesc* d) const override;
}; };
class FileType final : public BroType { class FileType final : public Type {
public: public:
explicit FileType(IntrusivePtr<BroType> yield_type); explicit FileType(IntrusivePtr<Type> yield_type);
IntrusivePtr<BroType> ShallowClone() override { return make_intrusive<FileType>(yield); } IntrusivePtr<Type> ShallowClone() override { return make_intrusive<FileType>(yield); }
~FileType() override; ~FileType() override;
const IntrusivePtr<BroType>& Yield() const override const IntrusivePtr<Type>& Yield() const override
{ return yield; } { return yield; }
void Describe(ODesc* d) const override; void Describe(ODesc* d) const override;
protected: protected:
IntrusivePtr<BroType> yield; IntrusivePtr<Type> yield;
}; };
class OpaqueType final : public BroType { class OpaqueType final : public Type {
public: public:
explicit OpaqueType(const std::string& name); explicit OpaqueType(const std::string& name);
IntrusivePtr<BroType> ShallowClone() override { return make_intrusive<OpaqueType>(name); } IntrusivePtr<Type> ShallowClone() override { return make_intrusive<OpaqueType>(name); }
~OpaqueType() override { }; ~OpaqueType() override { };
const std::string& Name() const { return name; } const std::string& Name() const { return name; }
@ -791,13 +791,13 @@ protected:
std::string name; std::string name;
}; };
class EnumType final : public BroType { class EnumType final : public Type {
public: public:
typedef std::list<std::pair<std::string, bro_int_t> > enum_name_list; typedef std::list<std::pair<std::string, bro_int_t> > enum_name_list;
explicit EnumType(const EnumType* e); explicit EnumType(const EnumType* e);
explicit EnumType(const std::string& arg_name); explicit EnumType(const std::string& arg_name);
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
~EnumType() override; ~EnumType() override;
// The value of this name is next internal counter value, starting // The value of this name is next internal counter value, starting
@ -844,13 +844,13 @@ protected:
bro_int_t counter; bro_int_t counter;
}; };
class VectorType final : public BroType { class VectorType final : public Type {
public: public:
explicit VectorType(IntrusivePtr<BroType> t); explicit VectorType(IntrusivePtr<Type> t);
IntrusivePtr<BroType> ShallowClone() override; IntrusivePtr<Type> ShallowClone() override;
~VectorType() override; ~VectorType() override;
const IntrusivePtr<BroType>& Yield() const override; const IntrusivePtr<Type>& Yield() const override;
int MatchesIndex(zeek::detail::ListExpr* index) const override; int MatchesIndex(zeek::detail::ListExpr* index) const override;
@ -862,24 +862,24 @@ public:
void DescribeReST(ODesc* d, bool roles_only = false) const override; void DescribeReST(ODesc* d, bool roles_only = false) const override;
protected: protected:
IntrusivePtr<BroType> yield_type; IntrusivePtr<Type> yield_type;
}; };
// True if the two types are equivalent. If is_init is true then the test is // True if the two types are equivalent. If is_init is true then the test is
// done in the context of an initialization. If match_record_field_names is // done in the context of an initialization. If match_record_field_names is
// true then for record types the field names have to match, too. // true then for record types the field names have to match, too.
extern bool same_type(const BroType& t1, const BroType& t2, extern bool same_type(const Type& t1, const Type& t2,
bool is_init=false, bool match_record_field_names=true); bool is_init=false, bool match_record_field_names=true);
inline bool same_type(const IntrusivePtr<BroType>& t1, const IntrusivePtr<BroType>& t2, inline bool same_type(const IntrusivePtr<Type>& t1, const IntrusivePtr<Type>& t2,
bool is_init=false, bool match_record_field_names=true) bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); } { return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const BroType* t1, const BroType* t2, inline bool same_type(const Type* t1, const Type* t2,
bool is_init=false, bool match_record_field_names=true) bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); } { return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const IntrusivePtr<BroType>& t1, const BroType* t2, inline bool same_type(const IntrusivePtr<Type>& t1, const Type* t2,
bool is_init=false, bool match_record_field_names=true) bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); } { return same_type(*t1, *t2, is_init, match_record_field_names); }
inline bool same_type(const BroType* t1, const IntrusivePtr<BroType>& t2, inline bool same_type(const Type* t1, const IntrusivePtr<Type>& t2,
bool is_init=false, bool match_record_field_names=true) bool is_init=false, bool match_record_field_names=true)
{ return same_type(*t1, *t2, is_init, match_record_field_names); } { return same_type(*t1, *t2, is_init, match_record_field_names); }
@ -891,10 +891,10 @@ extern bool same_attrs(const zeek::detail::Attributes* a1, const zeek::detail::A
extern bool record_promotion_compatible(const RecordType* super_rec, extern bool record_promotion_compatible(const RecordType* super_rec,
const RecordType* sub_rec); const RecordType* sub_rec);
// If the given BroType is a TypeList with just one element, returns // If the given Type is a TypeList with just one element, returns
// that element, otherwise returns the type. // that element, otherwise returns the type.
extern const BroType* flatten_type(const BroType* t); extern const Type* flatten_type(const Type* t);
extern BroType* flatten_type(BroType* t); extern Type* flatten_type(Type* t);
// Returns the "maximum" of two type tags, in a type-promotion sense. // Returns the "maximum" of two type tags, in a type-promotion sense.
extern TypeTag max_type(TypeTag t1, TypeTag t2); extern TypeTag max_type(TypeTag t1, TypeTag t2);
@ -902,27 +902,27 @@ extern TypeTag max_type(TypeTag t1, TypeTag t2);
// Given two types, returns the "merge", in which promotable types // Given two types, returns the "merge", in which promotable types
// are promoted to the maximum of the two. Returns nil (and generates // are promoted to the maximum of the two. Returns nil (and generates
// an error message) if the types are incompatible. // an error message) if the types are incompatible.
IntrusivePtr<BroType> merge_types(const IntrusivePtr<BroType>& t1, IntrusivePtr<Type> merge_types(const IntrusivePtr<Type>& t1,
const IntrusivePtr<BroType>& t2); const IntrusivePtr<Type>& t2);
// Given a list of expressions, returns a (ref'd) type reflecting // Given a list of expressions, returns a (ref'd) type reflecting
// a merged type consistent across all of them, or nil if this // a merged type consistent across all of them, or nil if this
// cannot be done. // cannot be done.
IntrusivePtr<BroType> merge_type_list(zeek::detail::ListExpr* elements); IntrusivePtr<Type> merge_type_list(zeek::detail::ListExpr* elements);
// Given an expression, infer its type when used for an initialization. // Given an expression, infer its type when used for an initialization.
IntrusivePtr<BroType> init_type(zeek::detail::Expr* init); IntrusivePtr<Type> init_type(zeek::detail::Expr* init);
// Returns true if argument is an atomic type. // Returns true if argument is an atomic type.
bool is_atomic_type(const BroType& t); bool is_atomic_type(const Type& t);
inline bool is_atomic_type(const BroType* t) inline bool is_atomic_type(const Type* t)
{ return is_atomic_type(*t); } { return is_atomic_type(*t); }
inline bool is_atomic_type(const IntrusivePtr<BroType>& t) inline bool is_atomic_type(const IntrusivePtr<Type>& t)
{ return is_atomic_type(*t); } { return is_atomic_type(*t); }
// True if the given type tag corresponds to type that can be assigned to. // True if the given type tag corresponds to type that can be assigned to.
extern bool is_assignable(TypeTag t); extern bool is_assignable(TypeTag t);
inline bool is_assignable(BroType* t) inline bool is_assignable(Type* t)
{ return zeek::is_assignable(t->Tag()); } { return zeek::is_assignable(t->Tag()); }
// True if the given type tag corresponds to an integral type. // True if the given type tag corresponds to an integral type.
@ -974,17 +974,17 @@ inline bool BothString(TypeTag t1, TypeTag t2) { return (IsString(t1) && IsStrin
inline bool EitherError(TypeTag t1, TypeTag t2) { return (IsErrorType(t1) || IsErrorType(t2)); } inline bool EitherError(TypeTag t1, TypeTag t2) { return (IsErrorType(t1) || IsErrorType(t2)); }
// Returns the basic (non-parameterized) type with the given type. // Returns the basic (non-parameterized) type with the given type.
const IntrusivePtr<zeek::BroType>& base_type(zeek::TypeTag tag); const IntrusivePtr<zeek::Type>& base_type(zeek::TypeTag tag);
// Returns the basic error type. // Returns the basic error type.
inline const IntrusivePtr<zeek::BroType>& error_type() { return base_type(TYPE_ERROR); } inline const IntrusivePtr<zeek::Type>& error_type() { return base_type(TYPE_ERROR); }
} // namespace zeek } // namespace zeek
// Returns the basic (non-parameterized) type with the given type. // Returns the basic (non-parameterized) type with the given type.
// The reference count of the type is not increased. // The reference count of the type is not increased.
[[deprecated("Remove in v4.1. Use zeek::base_type() instead")]] [[deprecated("Remove in v4.1. Use zeek::base_type() instead")]]
inline zeek::BroType* base_type_no_ref(TypeTag tag) inline zeek::Type* base_type_no_ref(TypeTag tag)
{ return zeek::base_type(static_cast<zeek::TypeTag>(tag)).get(); } { return zeek::base_type(static_cast<zeek::TypeTag>(tag)).get(); }
extern IntrusivePtr<zeek::OpaqueType> md5_type; extern IntrusivePtr<zeek::OpaqueType> md5_type;
@ -998,7 +998,7 @@ extern IntrusivePtr<zeek::OpaqueType> x509_opaque_type;
extern IntrusivePtr<zeek::OpaqueType> ocsp_resp_opaque_type; extern IntrusivePtr<zeek::OpaqueType> ocsp_resp_opaque_type;
extern IntrusivePtr<zeek::OpaqueType> paraglob_type; extern IntrusivePtr<zeek::OpaqueType> paraglob_type;
using BroType [[deprecated("Remove in v4.1. Use zeek::BroType instead.")]] = zeek::BroType; using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
using TypeList [[deprecated("Remove in v4.1. Use zeek::TypeList instead.")]] = zeek::TypeList; using TypeList [[deprecated("Remove in v4.1. Use zeek::TypeList instead.")]] = zeek::TypeList;
using IndexType [[deprecated("Remove in v4.1. Use zeek::IndexType instead.")]] = zeek::IndexType; using IndexType [[deprecated("Remove in v4.1. Use zeek::IndexType instead.")]] = zeek::IndexType;
using TableType [[deprecated("Remove in v4.1. Use zeek::TableType instead.")]] = zeek::TableType; using TableType [[deprecated("Remove in v4.1. Use zeek::TableType instead.")]] = zeek::TableType;

14
src/Val.cc
View file

@ -391,7 +391,7 @@ void Val::SetID(zeek::detail::ID* id)
} }
#endif #endif
bool Val::WouldOverflow(const zeek::BroType* from_type, const zeek::BroType* to_type, const Val* val) bool Val::WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val)
{ {
if ( !to_type || !from_type ) if ( !to_type || !from_type )
return true; return true;
@ -1337,7 +1337,7 @@ static void table_entry_val_delete_func(void* val)
delete tv; delete tv;
} }
static void find_nested_record_types(const IntrusivePtr<zeek::BroType>& t, std::set<zeek::RecordType*>* found) static void find_nested_record_types(const IntrusivePtr<zeek::Type>& t, std::set<zeek::RecordType*>* found)
{ {
if ( ! t ) if ( ! t )
return; return;
@ -3188,14 +3188,14 @@ void VectorVal::ValDescribe(ODesc* d) const
d->Add("]"); d->Add("]");
} }
IntrusivePtr<Val> check_and_promote(IntrusivePtr<Val> v, const zeek::BroType* t, IntrusivePtr<Val> check_and_promote(IntrusivePtr<Val> v, const zeek::Type* t,
bool is_init, bool is_init,
const Location* expr_location) const Location* expr_location)
{ {
if ( ! v ) if ( ! v )
return nullptr; return nullptr;
zeek::BroType* vt = flatten_type(v->GetType().get()); zeek::Type* vt = flatten_type(v->GetType().get());
t = flatten_type(t); t = flatten_type(t);
zeek::TypeTag t_tag = t->Tag(); zeek::TypeTag t_tag = t->Tag();
@ -3392,7 +3392,7 @@ void delete_vals(val_list* vals)
} }
} }
IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::BroType* t) IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::Type* t)
{ {
// Note: when changing this function, adapt all three of // Note: when changing this function, adapt all three of
// cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type(). // cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type().
@ -3418,7 +3418,7 @@ IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::BroType* t)
return nullptr; return nullptr;
} }
bool can_cast_value_to_type(const Val* v, zeek::BroType* t) bool can_cast_value_to_type(const Val* v, zeek::Type* t)
{ {
// Note: when changing this function, adapt all three of // Note: when changing this function, adapt all three of
// cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type(). // cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type().
@ -3444,7 +3444,7 @@ bool can_cast_value_to_type(const Val* v, zeek::BroType* t)
return false; return false;
} }
bool can_cast_value_to_type(const zeek::BroType* s, zeek::BroType* t) bool can_cast_value_to_type(const zeek::Type* s, zeek::Type* t)
{ {
// Note: when changing this function, adapt all three of // Note: when changing this function, adapt all three of
// cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type(). // cast_value_to_type()/can_cast_value_to_type()/can_cast_value_to_type().

28
src/Val.h
View file

@ -140,12 +140,12 @@ public:
explicit Val(IntrusivePtr<BroFile> f); explicit Val(IntrusivePtr<BroFile> f);
// Extra arg to differentiate from protected version. // Extra arg to differentiate from protected version.
Val(IntrusivePtr<zeek::BroType> t, bool type_type) Val(IntrusivePtr<zeek::Type> t, bool type_type)
: type(make_intrusive<zeek::TypeType>(std::move(t))) : type(make_intrusive<zeek::TypeType>(std::move(t)))
{} {}
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]] [[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
Val(zeek::BroType* t, bool type_type) : Val({NewRef{}, t}, type_type) Val(zeek::Type* t, bool type_type) : Val({NewRef{}, t}, type_type)
{} {}
Val() Val()
@ -185,11 +185,11 @@ public:
virtual bool RemoveFrom(Val* v) const; virtual bool RemoveFrom(Val* v) const;
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
zeek::BroType* Type() { return type.get(); } zeek::Type* Type() { return type.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]] [[deprecated("Remove in v4.1. Use GetType().")]]
const zeek::BroType* Type() const { return type.get(); } const zeek::Type* Type() const { return type.get(); }
const IntrusivePtr<zeek::BroType>& GetType() const const IntrusivePtr<zeek::Type>& GetType() const
{ return type; } { return type; }
template <class T> template <class T>
@ -233,7 +233,7 @@ public:
return *val.subnet_val; return *val.subnet_val;
} }
zeek::BroType* AsType() const zeek::Type* AsType() const
{ {
CHECK_TAG(type->Tag(), zeek::TYPE_TYPE, "Val::Type", zeek::type_name) CHECK_TAG(type->Tag(), zeek::TYPE_TYPE, "Val::Type", zeek::type_name)
return type.get(); return type.get();
@ -333,7 +333,7 @@ public:
void SetID(zeek::detail::ID* id); void SetID(zeek::detail::ID* id);
#endif #endif
static bool WouldOverflow(const zeek::BroType* from_type, const zeek::BroType* to_type, const Val* val); static bool WouldOverflow(const zeek::Type* from_type, const zeek::Type* to_type, const Val* val);
IntrusivePtr<TableVal> GetRecordFields(); IntrusivePtr<TableVal> GetRecordFields();
@ -361,11 +361,11 @@ protected:
{} {}
template<typename V> template<typename V>
Val(V&& v, IntrusivePtr<zeek::BroType> t) noexcept Val(V&& v, IntrusivePtr<zeek::Type> t) noexcept
: val(std::forward<V>(v)), type(std::move(t)) : val(std::forward<V>(v)), type(std::move(t))
{} {}
explicit Val(IntrusivePtr<zeek::BroType> t) noexcept explicit Val(IntrusivePtr<zeek::Type> t) noexcept
: type(std::move(t)) : type(std::move(t))
{} {}
@ -386,7 +386,7 @@ protected:
virtual IntrusivePtr<Val> DoClone(CloneState* state); virtual IntrusivePtr<Val> DoClone(CloneState* state);
BroValUnion val; BroValUnion val;
IntrusivePtr<zeek::BroType> type; IntrusivePtr<zeek::Type> type;
#ifdef DEBUG #ifdef DEBUG
// For debugging, we keep the name of the ID to which a Val is bound. // For debugging, we keep the name of the ID to which a Val is bound.
@ -1372,7 +1372,7 @@ protected:
// If not a match, generates an error message and return nil. If is_init is // If not a match, generates an error message and return nil. If is_init is
// true, then the checking is done in the context of an initialization. // true, then the checking is done in the context of an initialization.
extern IntrusivePtr<Val> check_and_promote(IntrusivePtr<Val> v, extern IntrusivePtr<Val> check_and_promote(IntrusivePtr<Val> v,
const zeek::BroType* t, bool is_init, const zeek::Type* t, bool is_init,
const Location* expr_location = nullptr); const Location* expr_location = nullptr);
extern bool same_val(const Val* v1, const Val* v2); extern bool same_val(const Val* v1, const Val* v2);
@ -1390,16 +1390,16 @@ inline bool is_vector(const IntrusivePtr<Val>& v) { return is_vector(v.get()); }
// Returns v casted to type T if the type supports that. Returns null if not. // Returns v casted to type T if the type supports that. Returns null if not.
// //
// Note: This implements the script-level cast operator. // Note: This implements the script-level cast operator.
extern IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::BroType* t); extern IntrusivePtr<Val> cast_value_to_type(Val* v, zeek::Type* t);
// Returns true if v can be casted to type T. If so, check_and_cast() will // Returns true if v can be casted to type T. If so, check_and_cast() will
// succeed as well. // succeed as well.
// //
// Note: This implements the script-level type comparision operator. // Note: This implements the script-level type comparision operator.
extern bool can_cast_value_to_type(const Val* v, zeek::BroType* t); extern bool can_cast_value_to_type(const Val* v, zeek::Type* t);
// Returns true if values of type s may support casting to type t. This is // Returns true if values of type s may support casting to type t. This is
// purely static check to weed out cases early on that will never succeed. // purely static check to weed out cases early on that will never succeed.
// However, even this function returns true, casting may still fail for a // However, even this function returns true, casting may still fail for a
// specific instance later. // specific instance later.
extern bool can_cast_value_to_type(const zeek::BroType* s, zeek::BroType* t); extern bool can_cast_value_to_type(const zeek::Type* s, zeek::Type* t);

20
src/Var.cc
View file

@ -19,7 +19,7 @@
using namespace zeek::detail; using namespace zeek::detail;
static IntrusivePtr<Val> init_val(zeek::detail::Expr* init, const zeek::BroType* t, static IntrusivePtr<Val> init_val(zeek::detail::Expr* init, const zeek::Type* t,
IntrusivePtr<Val> aggr) IntrusivePtr<Val> aggr)
{ {
try try
@ -32,7 +32,7 @@ static IntrusivePtr<Val> init_val(zeek::detail::Expr* init, const zeek::BroType*
} }
} }
static bool add_prototype(const IntrusivePtr<zeek::detail::ID>& id, zeek::BroType* t, static bool add_prototype(const IntrusivePtr<zeek::detail::ID>& id, zeek::Type* t,
std::vector<IntrusivePtr<zeek::detail::Attr>>* attrs, std::vector<IntrusivePtr<zeek::detail::Attr>>* attrs,
const IntrusivePtr<zeek::detail::Expr>& init) const IntrusivePtr<zeek::detail::Expr>& init)
{ {
@ -110,7 +110,7 @@ static bool add_prototype(const IntrusivePtr<zeek::detail::ID>& id, zeek::BroTyp
return true; return true;
} }
static void make_var(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::BroType> t, static void make_var(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::Type> t,
zeek::detail::init_class c, zeek::detail::init_class c,
IntrusivePtr<zeek::detail::Expr> init, IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr, std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr,
@ -310,7 +310,7 @@ static void make_var(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek
} }
} }
void add_global(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::BroType> t, void add_global(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::Type> t,
zeek::detail::init_class c, IntrusivePtr<zeek::detail::Expr> init, zeek::detail::init_class c, IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr, std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr,
decl_type dt) decl_type dt)
@ -318,7 +318,7 @@ void add_global(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::Bro
make_var(id, std::move(t), c, std::move(init), std::move(attr), dt, true); make_var(id, std::move(t), c, std::move(init), std::move(attr), dt, true);
} }
IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<zeek::detail::ID> id, IntrusivePtr<zeek::BroType> t, IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<zeek::detail::ID> id, IntrusivePtr<zeek::Type> t,
zeek::detail::init_class c, IntrusivePtr<zeek::detail::Expr> init, zeek::detail::init_class c, IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr, std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr,
decl_type dt) decl_type dt)
@ -360,12 +360,12 @@ extern IntrusivePtr<zeek::detail::Expr> add_and_assign_local(IntrusivePtr<zeek::
false, std::move(val)); false, std::move(val));
} }
void add_type(zeek::detail::ID* id, IntrusivePtr<zeek::BroType> t, void add_type(zeek::detail::ID* id, IntrusivePtr<zeek::Type> t,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr) std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr)
{ {
std::string new_type_name = id->Name(); std::string new_type_name = id->Name();
std::string old_type_name = t->GetName(); std::string old_type_name = t->GetName();
IntrusivePtr<zeek::BroType> tnew; IntrusivePtr<zeek::Type> tnew;
if ( (t->Tag() == zeek::TYPE_RECORD || t->Tag() == zeek::TYPE_ENUM) && if ( (t->Tag() == zeek::TYPE_RECORD || t->Tag() == zeek::TYPE_ENUM) &&
old_type_name.empty() ) old_type_name.empty() )
@ -375,10 +375,10 @@ void add_type(zeek::detail::ID* id, IntrusivePtr<zeek::BroType> t,
// Clone the type to preserve type name aliasing. // Clone the type to preserve type name aliasing.
tnew = t->ShallowClone(); tnew = t->ShallowClone();
zeek::BroType::AddAlias(new_type_name, tnew.get()); zeek::Type::AddAlias(new_type_name, tnew.get());
if ( new_type_name != old_type_name && ! old_type_name.empty() ) if ( new_type_name != old_type_name && ! old_type_name.empty() )
zeek::BroType::AddAlias(old_type_name, tnew.get()); zeek::Type::AddAlias(old_type_name, tnew.get());
tnew->SetName(id->Name()); tnew->SetName(id->Name());
@ -769,7 +769,7 @@ ListVal* internal_list_val(const char* name)
return nullptr; return nullptr;
} }
zeek::BroType* internal_type(const char* name) zeek::Type* internal_type(const char* name)
{ {
return zeek::id::find_type(name).get(); return zeek::id::find_type(name).get();
} }

8
src/Var.h
View file

@ -19,14 +19,14 @@ FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
typedef enum { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, } decl_type; typedef enum { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, } decl_type;
extern void add_global(const IntrusivePtr<zeek::detail::ID>& id, extern void add_global(const IntrusivePtr<zeek::detail::ID>& id,
IntrusivePtr<zeek::BroType> t, IntrusivePtr<zeek::Type> t,
zeek::detail::init_class c, zeek::detail::init_class c,
IntrusivePtr<zeek::detail::Expr> init, IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr, std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr,
decl_type dt); decl_type dt);
extern IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<zeek::detail::ID> id, extern IntrusivePtr<zeek::detail::Stmt> add_local(IntrusivePtr<zeek::detail::ID> id,
IntrusivePtr<zeek::BroType> t, IntrusivePtr<zeek::Type> t,
zeek::detail::init_class c, zeek::detail::init_class c,
IntrusivePtr<zeek::detail::Expr> init, IntrusivePtr<zeek::detail::Expr> init,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr, std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr,
@ -36,7 +36,7 @@ extern IntrusivePtr<zeek::detail::Expr> add_and_assign_local(IntrusivePtr<zeek::
IntrusivePtr<zeek::detail::Expr> init, IntrusivePtr<zeek::detail::Expr> init,
IntrusivePtr<Val> val = nullptr); IntrusivePtr<Val> val = nullptr);
extern void add_type(zeek::detail::ID* id, IntrusivePtr<zeek::BroType> t, extern void add_type(zeek::detail::ID* id, IntrusivePtr<zeek::Type> t,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr); std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attr);
extern void begin_func(IntrusivePtr<zeek::detail::ID> id, const char* module_name, extern void begin_func(IntrusivePtr<zeek::detail::ID> id, const char* module_name,
@ -77,7 +77,7 @@ extern TableVal* opt_internal_table(const char* name); // nil if not defined
extern ListVal* internal_list_val(const char* name); extern ListVal* internal_list_val(const char* name);
[[deprecated("Remove in v4.1. Use zeek::id::find_type().")]] [[deprecated("Remove in v4.1. Use zeek::id::find_type().")]]
extern zeek::BroType* internal_type(const char* name); extern zeek::Type* internal_type(const char* name);
[[deprecated("Remove in v4.1. Use zeek::id::find_func().")]] [[deprecated("Remove in v4.1. Use zeek::id::find_func().")]]
extern Func* internal_func(const char* name); extern Func* internal_func(const char* name);

16
src/broker/Data.cc
View file

@ -20,7 +20,7 @@ IntrusivePtr<zeek::OpaqueType> bro_broker::opaque_of_table_iterator;
IntrusivePtr<zeek::OpaqueType> bro_broker::opaque_of_vector_iterator; IntrusivePtr<zeek::OpaqueType> bro_broker::opaque_of_vector_iterator;
IntrusivePtr<zeek::OpaqueType> bro_broker::opaque_of_record_iterator; IntrusivePtr<zeek::OpaqueType> bro_broker::opaque_of_record_iterator;
static bool data_type_check(const broker::data& d, zeek::BroType* t); static bool data_type_check(const broker::data& d, zeek::Type* t);
static broker::port::protocol to_broker_port_proto(TransportProto tp) static broker::port::protocol to_broker_port_proto(TransportProto tp)
{ {
@ -75,7 +75,7 @@ TEST_CASE("converting Broker to Zeek protocol constants")
struct val_converter { struct val_converter {
using result_type = IntrusivePtr<Val>; using result_type = IntrusivePtr<Val>;
zeek::BroType* type; zeek::Type* type;
result_type operator()(broker::none) result_type operator()(broker::none)
{ {
@ -445,7 +445,7 @@ struct val_converter {
struct type_checker { struct type_checker {
using result_type = bool; using result_type = bool;
zeek::BroType* type; zeek::Type* type;
result_type operator()(broker::none) result_type operator()(broker::none)
{ {
@ -771,7 +771,7 @@ struct type_checker {
} }
}; };
static bool data_type_check(const broker::data& d, zeek::BroType* t) static bool data_type_check(const broker::data& d, zeek::Type* t)
{ {
if ( t->Tag() == zeek::TYPE_ANY ) if ( t->Tag() == zeek::TYPE_ANY )
return true; return true;
@ -779,7 +779,7 @@ static bool data_type_check(const broker::data& d, zeek::BroType* t)
return caf::visit(type_checker{t}, d); return caf::visit(type_checker{t}, d);
} }
IntrusivePtr<Val> bro_broker::data_to_val(broker::data d, zeek::BroType* type) IntrusivePtr<Val> bro_broker::data_to_val(broker::data d, zeek::Type* type)
{ {
if ( type->Tag() == zeek::TYPE_ANY ) if ( type->Tag() == zeek::TYPE_ANY )
return bro_broker::make_data_val(move(d)); return bro_broker::make_data_val(move(d));
@ -1137,17 +1137,17 @@ void bro_broker::DataVal::ValDescribe(ODesc* d) const
d->Add("}"); d->Add("}");
} }
bool bro_broker::DataVal::canCastTo(zeek::BroType* t) const bool bro_broker::DataVal::canCastTo(zeek::Type* t) const
{ {
return data_type_check(data, t); return data_type_check(data, t);
} }
IntrusivePtr<Val> bro_broker::DataVal::castTo(zeek::BroType* t) IntrusivePtr<Val> bro_broker::DataVal::castTo(zeek::Type* t)
{ {
return data_to_val(data, t); return data_to_val(data, t);
} }
const IntrusivePtr<zeek::BroType>& bro_broker::DataVal::ScriptDataType() const IntrusivePtr<zeek::Type>& bro_broker::DataVal::ScriptDataType()
{ {
static auto script_data_type = zeek::id::find_type("Broker::Data"); static auto script_data_type = zeek::id::find_type("Broker::Data");
return script_data_type; return script_data_type;

8
src/broker/Data.h
View file

@ -65,7 +65,7 @@ broker::expected<broker::data> val_to_data(const Val* v);
* @return a pointer to a new Bro value or a nullptr if the conversion was not * @return a pointer to a new Bro value or a nullptr if the conversion was not
* possible. * possible.
*/ */
IntrusivePtr<Val> data_to_val(broker::data d, zeek::BroType* type); IntrusivePtr<Val> data_to_val(broker::data d, zeek::Type* type);
/** /**
* Convert a Bro threading::Value to a Broker data value. * Convert a Bro threading::Value to a Broker data value.
@ -109,13 +109,13 @@ public:
void ValDescribe(ODesc* d) const override; void ValDescribe(ODesc* d) const override;
IntrusivePtr<Val> castTo(zeek::BroType* t); IntrusivePtr<Val> castTo(zeek::Type* t);
bool canCastTo(zeek::BroType* t) const; bool canCastTo(zeek::Type* t) const;
// Returns the Bro type that scripts use to represent a Broker data // Returns the Bro type that scripts use to represent a Broker data
// instance. This may be wrapping the opaque value inside another // instance. This may be wrapping the opaque value inside another
// type. // type.
static const IntrusivePtr<zeek::BroType>& ScriptDataType(); static const IntrusivePtr<zeek::Type>& ScriptDataType();
broker::data data; broker::data data;

2
src/broker/messaging.bif
View file

@ -7,7 +7,7 @@
#include <set> #include <set>
#include <string> #include <string>
static bool is_string_set(const zeek::BroType* type) static bool is_string_set(const zeek::Type* type)
{ {
if ( ! type->IsSet() ) if ( ! type->IsSet() )
return false; return false;

4
src/input/Manager.cc
View file

@ -774,7 +774,7 @@ bool Manager::CreateAnalysisStream(RecordVal* fval)
return true; return true;
} }
bool Manager::IsCompatibleType(zeek::BroType* t, bool atomic_only) bool Manager::IsCompatibleType(zeek::Type* t, bool atomic_only)
{ {
if ( ! t ) if ( ! t )
return false; return false;
@ -2159,7 +2159,7 @@ HashKey* Manager::HashValues(const int num_elements, const Value* const *vals) c
// have_error is a reference to a boolean which is set to true as soon as an error occurs. // have_error is a reference to a boolean which is set to true as soon as an error occurs.
// When have_error is set to true at the beginning of the function, it is assumed that // When have_error is set to true at the beginning of the function, it is assumed that
// an error already occurred in the past and processing is aborted. // an error already occurred in the past and processing is aborted.
Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::BroType* request_type, bool& have_error) const Val* Manager::ValueToVal(const Stream* i, const Value* val, zeek::Type* request_type, bool& have_error) const
{ {
if ( have_error ) if ( have_error )
return nullptr; return nullptr;

4
src/input/Manager.h
View file

@ -111,7 +111,7 @@ public:
* *
* @return True if the type is compatible with the input framework. * @return True if the type is compatible with the input framework.
*/ */
static bool IsCompatibleType(zeek::BroType* t, bool atomic_only=false); static bool IsCompatibleType(zeek::Type* t, bool atomic_only=false);
protected: protected:
friend class ReaderFrontend; friend class ReaderFrontend;
@ -222,7 +222,7 @@ private:
int CopyValue(char *data, const int startpos, const threading::Value* val) const; int CopyValue(char *data, const int startpos, const threading::Value* val) const;
// Convert Threading::Value to an internal Bro Type (works with Records). // Convert Threading::Value to an internal Bro Type (works with Records).
Val* ValueToVal(const Stream* i, const threading::Value* val, zeek::BroType* request_type, bool& have_error) const; Val* ValueToVal(const Stream* i, const threading::Value* val, zeek::Type* request_type, bool& have_error) const;
// Convert Threading::Value to an internal Bro list type. // Convert Threading::Value to an internal Bro list type.
Val* ValueToIndexVal(const Stream* i, int num_fields, const zeek::RecordType* type, const threading::Value* const *vals, bool& have_error) const; Val* ValueToIndexVal(const Stream* i, int num_fields, const zeek::RecordType* type, const threading::Value* const *vals, bool& have_error) const;

2
src/logging/Manager.cc
View file

@ -913,7 +913,7 @@ bool Manager::Write(EnumVal* id, RecordVal* columns_arg)
return true; return true;
} }
threading::Value* Manager::ValToLogVal(Val* val, zeek::BroType* ty) threading::Value* Manager::ValToLogVal(Val* val, zeek::Type* ty)
{ {
if ( ! ty ) if ( ! ty )
ty = val->GetType().get(); ty = val->GetType().get();

2
src/logging/Manager.h
View file

@ -261,7 +261,7 @@ private:
threading::Value** RecordToFilterVals(Stream* stream, Filter* filter, threading::Value** RecordToFilterVals(Stream* stream, Filter* filter,
RecordVal* columns); RecordVal* columns);
threading::Value* ValToLogVal(Val* val, zeek::BroType* ty = nullptr); threading::Value* ValToLogVal(Val* val, zeek::Type* ty = nullptr);
Stream* FindStream(EnumVal* id); Stream* FindStream(EnumVal* id);
void RemoveDisabledWriters(Stream* stream); void RemoveDisabledWriters(Stream* stream);
void InstallRotationTimer(WriterInfo* winfo); void InstallRotationTimer(WriterInfo* winfo);

8
src/parse.y
View file

@ -169,7 +169,7 @@ static void parser_redef_enum (zeek::detail::ID *id)
static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_list> fields, static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_list> fields,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs) std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs)
{ {
std::set<zeek::BroType*> types = zeek::BroType::GetAliases(id->Name()); std::set<zeek::Type*> types = zeek::Type::GetAliases(id->Name());
if ( types.empty() ) if ( types.empty() )
{ {
@ -201,7 +201,7 @@ static void extend_record(zeek::detail::ID* id, std::unique_ptr<zeek::type_decl_
static IntrusivePtr<zeek::detail::Attributes> static IntrusivePtr<zeek::detail::Attributes>
make_attributes(std::vector<IntrusivePtr<zeek::detail::Attr>>* attrs, make_attributes(std::vector<IntrusivePtr<zeek::detail::Attr>>* attrs,
IntrusivePtr<zeek::BroType> t, bool in_record, bool is_global) IntrusivePtr<zeek::Type> t, bool in_record, bool is_global)
{ {
if ( ! attrs ) if ( ! attrs )
return nullptr; return nullptr;
@ -241,7 +241,7 @@ static bool expr_is_table_type_name(const zeek::detail::Expr* expr)
zeek::detail::EventExpr* event_expr; zeek::detail::EventExpr* event_expr;
zeek::detail::Stmt* stmt; zeek::detail::Stmt* stmt;
zeek::detail::ListExpr* list; zeek::detail::ListExpr* list;
zeek::BroType* type; zeek::Type* type;
zeek::RecordType* record; zeek::RecordType* record;
zeek::FuncType* func_type; zeek::FuncType* func_type;
zeek::TypeList* type_l; zeek::TypeList* type_l;
@ -1667,7 +1667,7 @@ case_type:
| TOK_TYPE type TOK_AS TOK_ID | TOK_TYPE type TOK_AS TOK_ID
{ {
const char* name = $4; const char* name = $4;
IntrusivePtr<zeek::BroType> type{AdoptRef{}, $2}; IntrusivePtr<zeek::Type> type{AdoptRef{}, $2};
auto case_var = lookup_ID(name, current_module.c_str()); auto case_var = lookup_ID(name, current_module.c_str());
if ( case_var && case_var->IsGlobal() ) if ( case_var && case_var->IsGlobal() )

2
src/probabilistic/Topk.cc
View file

@ -18,7 +18,7 @@ static void topk_element_hash_delete_func(void* val)
delete e; delete e;
} }
void TopkVal::Typify(IntrusivePtr<zeek::BroType> t) void TopkVal::Typify(IntrusivePtr<zeek::Type> t)
{ {
assert(!hash && !type); assert(!hash && !type);
type = std::move(t); type = std::move(t);

4
src/probabilistic/Topk.h
View file

@ -161,9 +161,9 @@ private:
* *
* @param t type that is tracked * @param t type that is tracked
*/ */
void Typify(IntrusivePtr<zeek::BroType> t); void Typify(IntrusivePtr<zeek::Type> t);
IntrusivePtr<zeek::BroType> type; IntrusivePtr<zeek::Type> type;
CompositeHash* hash; CompositeHash* hash;
std::list<Bucket*> buckets; std::list<Bucket*> buckets;
PDict<Element>* elementDict; PDict<Element>* elementDict;

6
src/threading/SerialTypes.cc
View file

@ -122,7 +122,7 @@ Value::~Value()
} }
} }
bool Value::IsCompatibleType(zeek::BroType* t, bool atomic_only) bool Value::IsCompatibleType(zeek::Type* t, bool atomic_only)
{ {
if ( ! t ) if ( ! t )
return false; return false;
@ -535,7 +535,7 @@ Val* Value::ValueToVal(const std::string& source, const Value* val, bool& have_e
if ( stag == zeek::TYPE_VOID ) if ( stag == zeek::TYPE_VOID )
stag = val->val.set_val.vals[0]->type; stag = val->val.set_val.vals[0]->type;
IntrusivePtr<zeek::BroType> index_type; IntrusivePtr<zeek::Type> index_type;
if ( stag == zeek::TYPE_ENUM ) if ( stag == zeek::TYPE_ENUM )
{ {
@ -575,7 +575,7 @@ Val* Value::ValueToVal(const std::string& source, const Value* val, bool& have_e
case zeek::TYPE_VECTOR: case zeek::TYPE_VECTOR:
{ {
IntrusivePtr<zeek::BroType> type; IntrusivePtr<zeek::Type> type;
if ( val->val.vector_val.size == 0 && val->subtype == zeek::TYPE_VOID ) if ( val->val.vector_val.size == 0 && val->subtype == zeek::TYPE_VOID )
// don't know type - unspecified table. // don't know type - unspecified table.

2
src/threading/SerialTypes.h
View file

@ -202,7 +202,7 @@ struct Value {
* Returns true if the type can be represented by a Value. If * Returns true if the type can be represented by a Value. If
* `atomic_only` is true, will not permit composite types. This * `atomic_only` is true, will not permit composite types. This
* method is thread-safe. */ * method is thread-safe. */
static bool IsCompatibleType(zeek::BroType* t, bool atomic_only=false); static bool IsCompatibleType(zeek::Type* t, bool atomic_only=false);
/** /**
* Convenience function to delete an array of value pointers. * Convenience function to delete an array of value pointers.