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

Reformat Zeek in Spicy style

Browse source 
This largely copies over Spicy's `.clang-format` configuration file. The
one place where we deviate is header include order since Zeek depends on
headers being included in a certain order.
This commit is contained in:
Benjamin Bannier 2023-10-10 21:13:34 +02:00
parent 7b8e7ed72c
commit f5a76c1aed
786 changed files with 131714 additions and 153609 deletions
Download patch file Download diff file Expand all files Collapse all files

607
src/script_opt/CPP/RuntimeVec.cc
View file

@ -5,20 +5,18 @@
#include "zeek/Overflow.h"
#include "zeek/ZeekString.h"
namespace zeek::detail
{
namespace zeek::detail {
using namespace std;
// Helper function for ensuring that two vectors have matching sizes.
static bool check_vec_sizes__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
if ( v1->Size() == v2->Size() )
return true;
static bool check_vec_sizes__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
if ( v1->Size() == v2->Size() )
return true;
reporter->CPPRuntimeError("vector operands are of different sizes");
return false;
}
reporter->CPPRuntimeError("vector operands are of different sizes");
return false;
}
// Helper function that returns a VectorTypePtr apt for use with the
// the given yield type. We don't just use the yield type directly
@ -28,35 +26,28 @@ static bool check_vec_sizes__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
// convert the vector to the high-level representation if needed.
//
// One exception: for booleans ("is_bool" is true), we use those directly.
static VectorTypePtr base_vector_type__CPP(const VectorTypePtr& vt, bool is_bool = false)
{
switch ( vt->Yield()->InternalType() )
{
case TYPE_INTERNAL_INT:
{
auto base_tag = is_bool ? TYPE_BOOL : TYPE_INT;
return make_intrusive<VectorType>(base_type(base_tag));
}
static VectorTypePtr base_vector_type__CPP(const VectorTypePtr& vt, bool is_bool = false) {
switch ( vt->Yield()->InternalType() ) {
case TYPE_INTERNAL_INT: {
auto base_tag = is_bool ? TYPE_BOOL : TYPE_INT;
return make_intrusive<VectorType>(base_type(base_tag));
}
case TYPE_INTERNAL_UNSIGNED:
return make_intrusive<VectorType>(base_type(TYPE_COUNT));
case TYPE_INTERNAL_UNSIGNED: return make_intrusive<VectorType>(base_type(TYPE_COUNT));
case TYPE_INTERNAL_DOUBLE:
return make_intrusive<VectorType>(base_type(TYPE_DOUBLE));
case TYPE_INTERNAL_DOUBLE: return make_intrusive<VectorType>(base_type(TYPE_DOUBLE));
default:
return nullptr;
}
}
default: return nullptr;
}
}
// The kernel used for unary vector operations.
#define VEC_OP1_KERNEL(accessor, type, op) \
for ( unsigned int i = 0; i < v->Size(); ++i ) \
{ \
auto v_i = v->ValAt(i); \
if ( v_i ) \
v_result->Assign(i, make_intrusive<type>(op v_i->accessor())); \
}
#define VEC_OP1_KERNEL(accessor, type, op) \
for ( unsigned int i = 0; i < v->Size(); ++i ) { \
auto v_i = v->ValAt(i); \
if ( v_i ) \
v_result->Assign(i, make_intrusive<type>(op v_i->accessor())); \
}
// A macro (since it's beyond my templating skillz to deal with the
// "op" operator) for unary vector operations, invoking the kernel
@ -64,42 +55,38 @@ static VectorTypePtr base_vector_type__CPP(const VectorTypePtr& vt, bool is_bool
// is an optional kernel to use for vectors whose underlying type
// is "double". It needs to be optional because C++ will (rightfully)
// complain about applying certain C++ unary operations to doubles.
#define VEC_OP1(name, op, double_kernel) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v, const TypePtr& t) \
{ \
auto vt = base_vector_type__CPP(cast_intrusive<VectorType>(t)); \
auto v_result = make_intrusive<VectorVal>(vt); \
\
switch ( vt->Yield()->InternalType() ) \
{ \
case TYPE_INTERNAL_INT: \
{ \
VEC_OP1_KERNEL(AsInt, IntVal, op) \
break; \
} \
\
case TYPE_INTERNAL_UNSIGNED: \
{ \
VEC_OP1_KERNEL(AsCount, CountVal, op) \
break; \
} \
\
double_kernel \
\
default : break; \
} \
\
return v_result; \
}
#define VEC_OP1(name, op, double_kernel) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v, const TypePtr& t) { \
auto vt = base_vector_type__CPP(cast_intrusive<VectorType>(t)); \
auto v_result = make_intrusive<VectorVal>(vt); \
\
switch ( vt->Yield()->InternalType() ) { \
case TYPE_INTERNAL_INT: { \
VEC_OP1_KERNEL(AsInt, IntVal, op) \
break; \
} \
\
case TYPE_INTERNAL_UNSIGNED: { \
VEC_OP1_KERNEL(AsCount, CountVal, op) \
break; \
} \
\
double_kernel \
\
default : break; \
} \
\
return v_result; \
}
// Instantiates a double_kernel for a given operation.
#define VEC_OP1_WITH_DOUBLE(name, op) \
VEC_OP1( \
name, op, case TYPE_INTERNAL_DOUBLE \
: { \
VEC_OP1_KERNEL(AsDouble, DoubleVal, op) \
break; \
})
#define VEC_OP1_WITH_DOUBLE(name, op) \
VEC_OP1( \
name, op, case TYPE_INTERNAL_DOUBLE \
: { \
VEC_OP1_KERNEL(AsDouble, DoubleVal, op) \
break; \
})
// The unary operations supported for vectors.
VEC_OP1_WITH_DOUBLE(pos, +)
@ -109,52 +96,47 @@ VEC_OP1(comp, ~, )
// A kernel for applying a binary operation element-by-element to two
// vectors of a given low-level type.
#define VEC_OP2_KERNEL(accessor, type, op, zero_check) \
for ( unsigned int i = 0; i < v1->Size(); ++i ) \
{ \
auto v1_i = v1->ValAt(i); \
auto v2_i = v2->ValAt(i); \
if ( v1_i && v2_i ) \
{ \
if ( zero_check && v2_i->IsZero() ) \
reporter->CPPRuntimeError("division/modulo by zero"); \
else \
v_result->Assign(i, make_intrusive<type>(v1_i->accessor() op v2_i->accessor())); \
} \
}
#define VEC_OP2_KERNEL(accessor, type, op, zero_check) \
for ( unsigned int i = 0; i < v1->Size(); ++i ) { \
auto v1_i = v1->ValAt(i); \
auto v2_i = v2->ValAt(i); \
if ( v1_i && v2_i ) { \
if ( zero_check && v2_i->IsZero() ) \
reporter->CPPRuntimeError("division/modulo by zero"); \
else \
v_result->Assign(i, make_intrusive<type>(v1_i->accessor() op v2_i->accessor())); \
} \
}
// Analogous to VEC_OP1, instantiates a function for a given binary operation,
// with customimzable kernels for "int" and "double" operations.
// This version is for operations whose result type is the same as the
// operand type.
#define VEC_OP2(name, op, int_kernel, double_kernel, zero_check, is_bool) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v1, const VectorValPtr& v2) \
{ \
if ( ! check_vec_sizes__CPP(v1, v2) ) \
return nullptr; \
\
auto vt = base_vector_type__CPP(v1->GetType<VectorType>(), is_bool); \
auto v_result = make_intrusive<VectorVal>(vt); \
\
switch ( vt->Yield()->InternalType() ) \
{ \
case TYPE_INTERNAL_UNSIGNED: \
{ \
VEC_OP2_KERNEL(AsCount, CountVal, op, zero_check) \
break; \
} \
\
int_kernel double_kernel \
\
default : break; \
} \
\
return v_result; \
}
#define VEC_OP2(name, op, int_kernel, double_kernel, zero_check, is_bool) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v1, const VectorValPtr& v2) { \
if ( ! check_vec_sizes__CPP(v1, v2) ) \
return nullptr; \
\
auto vt = base_vector_type__CPP(v1->GetType<VectorType>(), is_bool); \
auto v_result = make_intrusive<VectorVal>(vt); \
\
switch ( vt->Yield()->InternalType() ) { \
case TYPE_INTERNAL_UNSIGNED: { \
VEC_OP2_KERNEL(AsCount, CountVal, op, zero_check) \
break; \
} \
\
int_kernel double_kernel \
\
default : break; \
} \
\
return v_result; \
}
// Instantiates a regular int_kernel for a binary operation.
#define VEC_OP2_WITH_INT(name, op, double_kernel, zero_check) \
VEC_OP2( \
#define VEC_OP2_WITH_INT(name, op, double_kernel, zero_check) \
VEC_OP2( \
name, op, case TYPE_INTERNAL_INT \
: { \
VEC_OP2_KERNEL(AsInt, IntVal, op, zero_check) \
@ -163,8 +145,8 @@ VEC_OP1(comp, ~, )
double_kernel, zero_check, false)
// Instantiates an int_kernel for boolean operations.
#define VEC_OP2_WITH_BOOL(name, op, zero_check) \
VEC_OP2( \
#define VEC_OP2_WITH_BOOL(name, op, zero_check) \
VEC_OP2( \
name, op, case TYPE_INTERNAL_INT \
: { \
VEC_OP2_KERNEL(AsBool, BoolVal, op, zero_check) \
@ -173,8 +155,8 @@ VEC_OP1(comp, ~, )
, zero_check, true)
// Instantiates a double_kernel for a binary operation.
#define VEC_OP2_WITH_DOUBLE(name, op, zero_check) \
VEC_OP2_WITH_INT( \
#define VEC_OP2_WITH_DOUBLE(name, op, zero_check) \
VEC_OP2_WITH_INT( \
name, op, case TYPE_INTERNAL_DOUBLE \
: { \
VEC_OP2_KERNEL(AsDouble, DoubleVal, op, zero_check) \
@ -198,42 +180,36 @@ VEC_OP2_WITH_INT(rshift, >>, , 0)
// A version of VEC_OP2 that instead supports relational operations, so
// the result type is always vector-of-bool.
#define VEC_REL_OP(name, op) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v1, const VectorValPtr& v2) \
{ \
if ( ! check_vec_sizes__CPP(v1, v2) ) \
return nullptr; \
\
auto vt = v1->GetType<VectorType>(); \
auto res_type = make_intrusive<VectorType>(base_type(TYPE_BOOL)); \
auto v_result = make_intrusive<VectorVal>(res_type); \
\
switch ( vt->Yield()->InternalType() ) \
{ \
case TYPE_INTERNAL_INT: \
{ \
VEC_OP2_KERNEL(AsInt, BoolVal, op, 0) \
break; \
} \
\
case TYPE_INTERNAL_UNSIGNED: \
{ \
VEC_OP2_KERNEL(AsCount, BoolVal, op, 0) \
break; \
} \
\
case TYPE_INTERNAL_DOUBLE: \
{ \
VEC_OP2_KERNEL(AsDouble, BoolVal, op, 0) \
break; \
} \
\
default: \
break; \
} \
\
return v_result; \
}
#define VEC_REL_OP(name, op) \
VectorValPtr vec_op_##name##__CPP(const VectorValPtr& v1, const VectorValPtr& v2) { \
if ( ! check_vec_sizes__CPP(v1, v2) ) \
return nullptr; \
\
auto vt = v1->GetType<VectorType>(); \
auto res_type = make_intrusive<VectorType>(base_type(TYPE_BOOL)); \
auto v_result = make_intrusive<VectorVal>(res_type); \
\
switch ( vt->Yield()->InternalType() ) { \
case TYPE_INTERNAL_INT: { \
VEC_OP2_KERNEL(AsInt, BoolVal, op, 0) \
break; \
} \
\
case TYPE_INTERNAL_UNSIGNED: { \
VEC_OP2_KERNEL(AsCount, BoolVal, op, 0) \
break; \
} \
\
case TYPE_INTERNAL_DOUBLE: { \
VEC_OP2_KERNEL(AsDouble, BoolVal, op, 0) \
break; \
} \
\
default: break; \
} \
\
return v_result; \
}
// The relational operations supported for vectors.
VEC_REL_OP(lt, <)
@ -243,244 +219,203 @@ VEC_REL_OP(ne, !=)
VEC_REL_OP(le, <=)
VEC_REL_OP(ge, >=)
VectorValPtr vec_op_add__CPP(VectorValPtr v, int incr)
{
const auto& yt = v->GetType()->Yield();
auto is_signed = yt->InternalType() == TYPE_INTERNAL_INT;
auto n = v->Size();
VectorValPtr vec_op_add__CPP(VectorValPtr v, int incr) {
const auto& yt = v->GetType()->Yield();
auto is_signed = yt->InternalType() == TYPE_INTERNAL_INT;
auto n = v->Size();
for ( unsigned int i = 0; i < n; ++i )
{
auto v_i = v->ValAt(i);
ValPtr new_v_i;
for ( unsigned int i = 0; i < n; ++i ) {
auto v_i = v->ValAt(i);
ValPtr new_v_i;
if ( is_signed )
new_v_i = val_mgr->Int(v_i->AsInt() + incr);
else
new_v_i = val_mgr->Count(v_i->AsCount() + incr);
if ( is_signed )
new_v_i = val_mgr->Int(v_i->AsInt() + incr);
else
new_v_i = val_mgr->Count(v_i->AsCount() + incr);
v->Assign(i, new_v_i);
}
v->Assign(i, new_v_i);
}
return v;
}
return v;
}
VectorValPtr vec_op_sub__CPP(VectorValPtr v, int i)
{
return vec_op_add__CPP(std::move(v), -i);
}
VectorValPtr vec_op_sub__CPP(VectorValPtr v, int i) { return vec_op_add__CPP(std::move(v), -i); }
// This function provides the core functionality. The arguments
// are applied as though they appeared left-to-right in a statement
// "s1 + v2 + v3 + s4". For any invocation, v2 will always be
// non-nil, and one-and-only-one of s1, v3, or s4 will be non-nil.
static VectorValPtr str_vec_op_str_vec_add__CPP(const StringValPtr& s1, const VectorValPtr& v2,
const VectorValPtr& v3, const StringValPtr& s4)
{
auto vt = v2->GetType<VectorType>();
auto v_result = make_intrusive<VectorVal>(vt);
auto n = v2->Size();
static VectorValPtr str_vec_op_str_vec_add__CPP(const StringValPtr& s1, const VectorValPtr& v2, const VectorValPtr& v3,
const StringValPtr& s4) {
auto vt = v2->GetType<VectorType>();
auto v_result = make_intrusive<VectorVal>(vt);
auto n = v2->Size();
for ( unsigned int i = 0; i < n; ++i )
{
vector<const String*> strings;
for ( unsigned int i = 0; i < n; ++i ) {
vector<const String*> strings;
auto v2_i = v2->ValAt(i);
if ( ! v2_i )
continue;
auto v2_i = v2->ValAt(i);
if ( ! v2_i )
continue;
auto s2 = v2_i->AsString();
const String* s3 = nullptr;
auto s2 = v2_i->AsString();
const String* s3 = nullptr;
if ( v3 )
{
auto v3_i = v3->ValAt(i);
if ( ! v3_i )
continue;
s3 = v3_i->AsString();
}
if ( v3 ) {
auto v3_i = v3->ValAt(i);
if ( ! v3_i )
continue;
s3 = v3_i->AsString();
}
if ( s1 )
strings.push_back(s1->AsString());
strings.push_back(s2);
if ( s3 )
strings.push_back(s3);
if ( s4 )
strings.push_back(s4->AsString());
if ( s1 )
strings.push_back(s1->AsString());
strings.push_back(s2);
if ( s3 )
strings.push_back(s3);
if ( s4 )
strings.push_back(s4->AsString());
auto res = make_intrusive<StringVal>(concatenate(strings));
v_result->Assign(i, res);
}
auto res = make_intrusive<StringVal>(concatenate(strings));
v_result->Assign(i, res);
}
return v_result;
}
return v_result;
}
VectorValPtr str_vec_op_add__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_str_vec_add__CPP(nullptr, v1, v2, nullptr);
}
VectorValPtr str_vec_op_add__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_str_vec_add__CPP(nullptr, v1, v2, nullptr);
}
VectorValPtr str_vec_op_add__CPP(const VectorValPtr& v1, const StringValPtr& s2)
{
return str_vec_op_str_vec_add__CPP(nullptr, v1, nullptr, s2);
}
VectorValPtr str_vec_op_add__CPP(const VectorValPtr& v1, const StringValPtr& s2) {
return str_vec_op_str_vec_add__CPP(nullptr, v1, nullptr, s2);
}
VectorValPtr str_vec_op_add__CPP(const StringValPtr& s1, const VectorValPtr& v2)
{
return str_vec_op_str_vec_add__CPP(s1, v2, nullptr, nullptr);
}
VectorValPtr str_vec_op_add__CPP(const StringValPtr& s1, const VectorValPtr& v2) {
return str_vec_op_str_vec_add__CPP(s1, v2, nullptr, nullptr);
}
// Kernel for element-by-element string relationals. "rel1" and "rel2"
// codify which relational (</<=/==/!=/>=/>) we're aiming to support,
// in terms of how a Bstr_cmp() comparison should be assessed.
static VectorValPtr str_vec_op_kernel__CPP(const VectorValPtr& v1, const VectorValPtr& v2, int rel1,
int rel2)
{
auto res_type = make_intrusive<VectorType>(base_type(TYPE_BOOL));
auto v_result = make_intrusive<VectorVal>(res_type);
auto n = v1->Size();
static VectorValPtr str_vec_op_kernel__CPP(const VectorValPtr& v1, const VectorValPtr& v2, int rel1, int rel2) {
auto res_type = make_intrusive<VectorType>(base_type(TYPE_BOOL));
auto v_result = make_intrusive<VectorVal>(res_type);
auto n = v1->Size();
for ( unsigned int i = 0; i < n; ++i )
{
auto v1_i = v1->ValAt(i);
auto v2_i = v2->ValAt(i);
if ( ! v1_i || ! v2_i )
continue;
for ( unsigned int i = 0; i < n; ++i ) {
auto v1_i = v1->ValAt(i);
auto v2_i = v2->ValAt(i);
if ( ! v1_i || ! v2_i )
continue;
auto s1 = v1_i->AsString();
auto s2 = v2_i->AsString();
auto s1 = v1_i->AsString();
auto s2 = v2_i->AsString();
auto cmp = Bstr_cmp(s1, s2);
auto rel = (cmp == rel1) || (cmp == rel2);
auto cmp = Bstr_cmp(s1, s2);
auto rel = (cmp == rel1) || (cmp == rel2);
v_result->Assign(i, val_mgr->Bool(rel));
}
v_result->Assign(i, val_mgr->Bool(rel));
}
return v_result;
}
return v_result;
}
VectorValPtr str_vec_op_lt__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, -1, -1);
}
VectorValPtr str_vec_op_le__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, -1, 0);
}
VectorValPtr str_vec_op_eq__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, 0, 0);
}
VectorValPtr str_vec_op_ne__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, -1, 1);
}
VectorValPtr str_vec_op_gt__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, 1, 1);
}
VectorValPtr str_vec_op_ge__CPP(const VectorValPtr& v1, const VectorValPtr& v2)
{
return str_vec_op_kernel__CPP(v1, v2, 0, 1);
}
VectorValPtr str_vec_op_lt__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, -1, -1);
}
VectorValPtr str_vec_op_le__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, -1, 0);
}
VectorValPtr str_vec_op_eq__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, 0, 0);
}
VectorValPtr str_vec_op_ne__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, -1, 1);
}
VectorValPtr str_vec_op_gt__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, 1, 1);
}
VectorValPtr str_vec_op_ge__CPP(const VectorValPtr& v1, const VectorValPtr& v2) {
return str_vec_op_kernel__CPP(v1, v2, 0, 1);
}
VectorValPtr vector_select__CPP(const VectorValPtr& v1, VectorValPtr v2, VectorValPtr v3)
{
auto vt = v2->GetType<VectorType>();
auto v_result = make_intrusive<VectorVal>(vt);
VectorValPtr vector_select__CPP(const VectorValPtr& v1, VectorValPtr v2, VectorValPtr v3) {
auto vt = v2->GetType<VectorType>();
auto v_result = make_intrusive<VectorVal>(vt);
if ( ! check_vec_sizes__CPP(v1, v2) || ! check_vec_sizes__CPP(v1, v3) )
return nullptr;
if ( ! check_vec_sizes__CPP(v1, v2) || ! check_vec_sizes__CPP(v1, v3) )
return nullptr;
auto n = v1->Size();
auto n = v1->Size();
for ( unsigned int i = 0; i < n; ++i )
{
auto vr_i = v1->BoolAt(i) ? v2->ValAt(i) : v3->ValAt(i);
v_result->Assign(i, std::move(vr_i));
}
for ( unsigned int i = 0; i < n; ++i ) {
auto vr_i = v1->BoolAt(i) ? v2->ValAt(i) : v3->ValAt(i);
v_result->Assign(i, std::move(vr_i));
}
return v_result;
}
return v_result;
}
VectorValPtr vector_coerce_to__CPP(const VectorValPtr& v, const TypePtr& targ)
{
auto res_t = cast_intrusive<VectorType>(targ);
auto v_result = make_intrusive<VectorVal>(std::move(res_t));
auto n = v->Size();
auto yt = targ->Yield();
auto ytag = yt->Tag();
VectorValPtr vector_coerce_to__CPP(const VectorValPtr& v, const TypePtr& targ) {
auto res_t = cast_intrusive<VectorType>(targ);
auto v_result = make_intrusive<VectorVal>(std::move(res_t));
auto n = v->Size();
auto yt = targ->Yield();
auto ytag = yt->Tag();
for ( unsigned int i = 0; i < n; ++i )
{
ValPtr v_i = v->ValAt(i);
if ( ! v_i )
continue;
for ( unsigned int i = 0; i < n; ++i ) {
ValPtr v_i = v->ValAt(i);
if ( ! v_i )
continue;
// We compute these for each element to cover the case where
// the coerced vector is of type "any".
auto& t_i = v_i->GetType();
auto it = t_i->InternalType();
// We compute these for each element to cover the case where
// the coerced vector is of type "any".
auto& t_i = v_i->GetType();
auto it = t_i->InternalType();
ValPtr r_i;
switch ( ytag )
{
case TYPE_BOOL:
r_i = val_mgr->Bool(v_i->CoerceToInt() != 0);
break;
ValPtr r_i;
switch ( ytag ) {
case TYPE_BOOL: r_i = val_mgr->Bool(v_i->CoerceToInt() != 0); break;
case TYPE_INT:
if ( (it == TYPE_INTERNAL_UNSIGNED || it == TYPE_INTERNAL_DOUBLE) &&
would_overflow(t_i.get(), yt.get(), v_i.get()) )
reporter->CPPRuntimeError(
"overflow promoting from unsigned/double to signed arithmetic value");
else
r_i = val_mgr->Int(v_i->CoerceToInt());
break;
case TYPE_INT:
if ( (it == TYPE_INTERNAL_UNSIGNED || it == TYPE_INTERNAL_DOUBLE) &&
would_overflow(t_i.get(), yt.get(), v_i.get()) )
reporter->CPPRuntimeError("overflow promoting from unsigned/double to signed arithmetic value");
else
r_i = val_mgr->Int(v_i->CoerceToInt());
break;
case TYPE_COUNT:
if ( (it == TYPE_INTERNAL_INT || it == TYPE_INTERNAL_DOUBLE) &&
would_overflow(t_i.get(), yt.get(), v_i.get()) )
reporter->CPPRuntimeError(
"overflow promoting from signed/double to signed arithmetic value");
else
r_i = val_mgr->Count(v_i->CoerceToUnsigned());
break;
case TYPE_COUNT:
if ( (it == TYPE_INTERNAL_INT || it == TYPE_INTERNAL_DOUBLE) &&
would_overflow(t_i.get(), yt.get(), v_i.get()) )
reporter->CPPRuntimeError("overflow promoting from signed/double to signed arithmetic value");
else
r_i = val_mgr->Count(v_i->CoerceToUnsigned());
break;
case TYPE_ENUM:
r_i = yt->AsEnumType()->GetEnumVal(v_i->CoerceToInt());
break;
case TYPE_ENUM: r_i = yt->AsEnumType()->GetEnumVal(v_i->CoerceToInt()); break;
case TYPE_PORT:
r_i = make_intrusive<PortVal>(v_i->CoerceToUnsigned());
break;
case TYPE_PORT: r_i = make_intrusive<PortVal>(v_i->CoerceToUnsigned()); break;
case TYPE_DOUBLE:
r_i = make_intrusive<DoubleVal>(v_i->CoerceToDouble());
break;
case TYPE_DOUBLE: r_i = make_intrusive<DoubleVal>(v_i->CoerceToDouble()); break;
case TYPE_INTERVAL:
r_i = make_intrusive<IntervalVal>(v_i->CoerceToDouble());
break;
case TYPE_INTERVAL: r_i = make_intrusive<IntervalVal>(v_i->CoerceToDouble()); break;
case TYPE_TIME:
r_i = make_intrusive<TimeVal>(v_i->CoerceToDouble());
break;
case TYPE_TIME: r_i = make_intrusive<TimeVal>(v_i->CoerceToDouble()); break;
default:
reporter->InternalError("bad vector type in vector_coerce_to__CPP");
}
default: reporter->InternalError("bad vector type in vector_coerce_to__CPP");
}
v_result->Assign(i, std::move(r_i));
}
v_result->Assign(i, std::move(r_i));
}
return v_result;
}
return v_result;
}
VectorValPtr vec_scalar_mixed_with_vector()
{
reporter->CPPRuntimeError("vector-mixed-with-scalar operations not supported");
return nullptr;
}
VectorValPtr vec_scalar_mixed_with_vector() {
reporter->CPPRuntimeError("vector-mixed-with-scalar operations not supported");
return nullptr;
}
} // namespace zeek::detail
} // namespace zeek::detail