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

low-level tidying/nits - no semantic changes

Browse source
This commit is contained in:
Vern Paxson 2021-08-16 10:15:10 -07:00
parent 0746ef7ecc
commit b4a44ed663
5 changed files with 26 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/CMakeLists.txt
View file

@ -200,7 +200,7 @@ install(FILES ${PRELOAD_SCRIPT} DESTINATION ${ZEEK_SCRIPT_INSTALL_PATH}/builtin-
install(FILES ${LOAD_SCRIPT} DESTINATION ${ZEEK_SCRIPT_INSTALL_PATH}/builtin-plugins/) install(FILES ${LOAD_SCRIPT} DESTINATION ${ZEEK_SCRIPT_INSTALL_PATH}/builtin-plugins/)
######################################################################## ########################################################################
## bro target ## zeek target
find_package (Threads) find_package (Threads)
@ -234,7 +234,7 @@ endmacro(COLLECT_HEADERS _var)
cmake_policy(POP) cmake_policy(POP)
# define a command that's used to run the make_dbg_constants.py script # define a command that's used to run the make_dbg_constants.py script
# building the bro binary depends on the outputs of this script # building the zeek binary depends on the outputs of this script
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdConstants.h add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdConstants.h
${CMAKE_CURRENT_BINARY_DIR}/DebugCmdInfoConstants.cc ${CMAKE_CURRENT_BINARY_DIR}/DebugCmdInfoConstants.cc
COMMAND ${PYTHON_EXECUTABLE} COMMAND ${PYTHON_EXECUTABLE}

34
src/Expr.cc
View file

@ -83,103 +83,103 @@ Expr::Expr(BroExprTag arg_tag) : tag(arg_tag), paren(false), type(nullptr)
const ListExpr* Expr::AsListExpr() const const ListExpr* Expr::AsListExpr() const
{ {
CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name) CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
return (const ListExpr*) this; return (const ListExpr*) this;
} }
ListExpr* Expr::AsListExpr() ListExpr* Expr::AsListExpr()
{ {
CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name) CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
return (ListExpr*) this; return (ListExpr*) this;
} }
ListExprPtr Expr::AsListExprPtr() ListExprPtr Expr::AsListExprPtr()
{ {
CHECK_TAG(tag, EXPR_LIST, "ExprVal::AsListExpr", expr_name) CHECK_TAG(tag, EXPR_LIST, "Expr::AsListExpr", expr_name)
return {NewRef{}, (ListExpr*) this}; return {NewRef{}, (ListExpr*) this};
} }
const NameExpr* Expr::AsNameExpr() const const NameExpr* Expr::AsNameExpr() const
{ {
CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name) CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
return (const NameExpr*) this; return (const NameExpr*) this;
} }
NameExpr* Expr::AsNameExpr() NameExpr* Expr::AsNameExpr()
{ {
CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name) CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
return (NameExpr*) this; return (NameExpr*) this;
} }
NameExprPtr Expr::AsNameExprPtr() NameExprPtr Expr::AsNameExprPtr()
{ {
CHECK_TAG(tag, EXPR_NAME, "ExprVal::AsNameExpr", expr_name) CHECK_TAG(tag, EXPR_NAME, "Expr::AsNameExpr", expr_name)
return {NewRef{}, (NameExpr*) this}; return {NewRef{}, (NameExpr*) this};
} }
const ConstExpr* Expr::AsConstExpr() const const ConstExpr* Expr::AsConstExpr() const
{ {
CHECK_TAG(tag, EXPR_CONST, "ExprVal::AsConstExpr", expr_name) CHECK_TAG(tag, EXPR_CONST, "Expr::AsConstExpr", expr_name)
return (const ConstExpr*) this; return (const ConstExpr*) this;
} }
ConstExprPtr Expr::AsConstExprPtr() ConstExprPtr Expr::AsConstExprPtr()
{ {
CHECK_TAG(tag, EXPR_CONST, "ExprVal::AsConstExpr", expr_name) CHECK_TAG(tag, EXPR_CONST, "Expr::AsConstExpr", expr_name)
return {NewRef{}, (ConstExpr*) this}; return {NewRef{}, (ConstExpr*) this};
} }
const CallExpr* Expr::AsCallExpr() const const CallExpr* Expr::AsCallExpr() const
{ {
CHECK_TAG(tag, EXPR_CALL, "ExprVal::AsCallExpr", expr_name) CHECK_TAG(tag, EXPR_CALL, "Expr::AsCallExpr", expr_name)
return (const CallExpr*) this; return (const CallExpr*) this;
} }
const AssignExpr* Expr::AsAssignExpr() const const AssignExpr* Expr::AsAssignExpr() const
{ {
CHECK_TAG(tag, EXPR_ASSIGN, "ExprVal::AsAssignExpr", expr_name) CHECK_TAG(tag, EXPR_ASSIGN, "Expr::AsAssignExpr", expr_name)
return (const AssignExpr*) this; return (const AssignExpr*) this;
} }
AssignExpr* Expr::AsAssignExpr() AssignExpr* Expr::AsAssignExpr()
{ {
CHECK_TAG(tag, EXPR_ASSIGN, "ExprVal::AsAssignExpr", expr_name) CHECK_TAG(tag, EXPR_ASSIGN, "Expr::AsAssignExpr", expr_name)
return (AssignExpr*) this; return (AssignExpr*) this;
} }
const IndexExpr* Expr::AsIndexExpr() const const IndexExpr* Expr::AsIndexExpr() const
{ {
CHECK_TAG(tag, EXPR_INDEX, "ExprVal::AsIndexExpr", expr_name) CHECK_TAG(tag, EXPR_INDEX, "Expr::AsIndexExpr", expr_name)
return (const IndexExpr*) this; return (const IndexExpr*) this;
} }
IndexExpr* Expr::AsIndexExpr() IndexExpr* Expr::AsIndexExpr()
{ {
CHECK_TAG(tag, EXPR_INDEX, "ExprVal::AsIndexExpr", expr_name) CHECK_TAG(tag, EXPR_INDEX, "Expr::AsIndexExpr", expr_name)
return (IndexExpr*) this; return (IndexExpr*) this;
} }
const EventExpr* Expr::AsEventExpr() const const EventExpr* Expr::AsEventExpr() const
{ {
CHECK_TAG(tag, EXPR_EVENT, "ExprVal::AsEventExpr", expr_name) CHECK_TAG(tag, EXPR_EVENT, "Expr::AsEventExpr", expr_name)
return (const EventExpr*) this; return (const EventExpr*) this;
} }
EventExprPtr Expr::AsEventExprPtr() EventExprPtr Expr::AsEventExprPtr()
{ {
CHECK_TAG(tag, EXPR_EVENT, "ExprVal::AsEventExpr", expr_name) CHECK_TAG(tag, EXPR_EVENT, "Expr::AsEventExpr", expr_name)
return {NewRef{}, (EventExpr*) this}; return {NewRef{}, (EventExpr*) this};
} }
const RefExpr* Expr::AsRefExpr() const const RefExpr* Expr::AsRefExpr() const
{ {
CHECK_TAG(tag, EXPR_REF, "ExprVal::AsRefExpr", expr_name) CHECK_TAG(tag, EXPR_REF, "Expr::AsRefExpr", expr_name)
return (const RefExpr*) this; return (const RefExpr*) this;
} }
RefExprPtr Expr::AsRefExprPtr() RefExprPtr Expr::AsRefExprPtr()
{ {
CHECK_TAG(tag, EXPR_REF, "ExprVal::AsRefExpr", expr_name) CHECK_TAG(tag, EXPR_REF, "Expr::AsRefExpr", expr_name)
return {NewRef{}, (RefExpr*) this}; return {NewRef{}, (RefExpr*) this};
} }

8
src/ZVal.h
View file

@ -70,9 +70,9 @@ union ZVal {
ZVal(OpaqueVal* v) { opaque_val = v; } ZVal(OpaqueVal* v) { opaque_val = v; }
ZVal(PatternVal* v) { re_val = v; } ZVal(PatternVal* v) { re_val = v; }
ZVal(TableVal* v) { table_val = v; } ZVal(TableVal* v) { table_val = v; }
ZVal(TypeVal* v) { type_val = v; }
ZVal(RecordVal* v) { record_val = v; } ZVal(RecordVal* v) { record_val = v; }
ZVal(VectorVal* v) { vector_val = v; } ZVal(VectorVal* v) { vector_val = v; }
ZVal(TypeVal* v) { type_val = v; }
ZVal(Val* v) { any_val = v; } ZVal(Val* v) { any_val = v; }
ZVal(StringValPtr v) { string_val = v.release(); } ZVal(StringValPtr v) { string_val = v.release(); }
@ -82,9 +82,9 @@ union ZVal {
ZVal(OpaqueValPtr v) { opaque_val = v.release(); } ZVal(OpaqueValPtr v) { opaque_val = v.release(); }
ZVal(PatternValPtr v) { re_val = v.release(); } ZVal(PatternValPtr v) { re_val = v.release(); }
ZVal(TableValPtr v) { table_val = v.release(); } ZVal(TableValPtr v) { table_val = v.release(); }
ZVal(TypeValPtr v) { type_val = v.release(); }
ZVal(RecordValPtr v) { record_val = v.release(); } ZVal(RecordValPtr v) { record_val = v.release(); }
ZVal(VectorValPtr v) { vector_val = v.release(); } ZVal(VectorValPtr v) { vector_val = v.release(); }
ZVal(TypeValPtr v) { type_val = v.release(); }
// Convert to a higher-level script value. The caller needs to // Convert to a higher-level script value. The caller needs to
// ensure that they're providing the correct type. // ensure that they're providing the correct type.
@ -170,8 +170,8 @@ private:
// Used for double, time, interval. // Used for double, time, interval.
double double_val; double double_val;
// The types are all variants of Val, Type, or more fundamentally // The types are all variants of Val, or more fundamentally Obj.
// Obj. They are raw pointers rather than IntrusivePtr's because // They are raw pointers rather than IntrusivePtr's because
// unions can't contain the latter. For memory management, we use // unions can't contain the latter. For memory management, we use
// Ref/Unref. // Ref/Unref.
StringVal* string_val; StringVal* string_val;

4
src/script_opt/CPP/README.md
View file

@ -78,8 +78,8 @@ a file `CPP-hashes.dat`, for use by an advanced feature, and an
empty `CPP-gen-addl.h` file (same). empty `CPP-gen-addl.h` file (same).
2. `ninja` or `make` to recompile Zeek 2. `ninja` or `make` to recompile Zeek
3. `./src/zeek -O use-C++ target.zeek` 3. `./src/zeek -O use-C++ target.zeek`
Executes with each function/hook/ Executes with each function/hook/event
event handler pulled in by `target.zeek` replaced with its compiled version. handler pulled in by `target.zeek` replaced with its compiled version.
Instead of the last line above, you can use the following variants: Instead of the last line above, you can use the following variants:

2
src/script_opt/GenRDs.cc
View file

@ -634,7 +634,7 @@ bool RD_Decorate::CheckLHS(const Expr* lhs, const Expr* e)
for ( const auto& expr : l->Exprs() ) for ( const auto& expr : l->Exprs() )
{ {
if ( expr->Tag() != EXPR_NAME ) if ( expr->Tag() != EXPR_NAME )
// This will happen for table initialiers, // This will happen for table initializers,
// for example. // for example.
return false; return false;