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

Fix bug in selective cloning.

Browse source
This commit is contained in:
Zeke Medley 2019-07-16 15:15:05 -07:00
commit 1692be4c2d
83 changed files with 1461 additions and 1328 deletions
Download patch file Download diff file Expand all files Collapse all files

59
CHANGES
View file

@ -1,4 +1,63 @@
2.6-624 | 2019-07-16 16:07:59 +0000
* Redo README. We now have separate plain text and Markdown versions.
(Zeke Medley, Corelight)
2.6-616 | 2019-07-16 15:21:37 +0000
* Fix referecne counting bug in EnumType copy constructor. (Jon
Siwek, Corelight)
* Remove unused BroObj::in_ser_cache member. (Jon Siwek, Corelight)
2.6-612 | 2019-07-15 19:46:04 -0700
* Fix a potential usage of List::remove_nth(-1) (Jon Siwek, Corelight)
* Change List::remote(const T&) to return a bool (Jon Siwek, Corelight)
It now indicates whether the removal took place or not, depending
on whether a matching element was found in the list.
* Fix debug build due to old int_list usage within assert (Jon Siwek, Corelight)
* Convert uses of loop_over_list to ranged-for loops (Tim Wojtulewicz, Corelight)
* Remove loop_over_queue (as an example for later removing loop_over_list) (Tim Wojtulewicz, Corelight)
* Change int_list in CCL.h to be a vector, fix uses of int_list to match (Tim Wojtulewicz, Corelight)
* Remove List<> usage from strings.bif (Tim Wojtulewicz, Corelight)
* Replace uses of the old Queue/PQueue generation code with new template versions (Tim Wojtulewicz, Corelight)
* Convert BaseQueue/Queue/PQueue into templates, including iterator support (Tim Wojtulewicz, Corelight)
* Replace uses of the old Dict generation code with new template versions (Tim Wojtulewicz, Corelight)
* Convert PDict into template (Tim Wojtulewicz, Corelight)
* Replace uses of the old List generation code with new template versions (Tim Wojtulewicz, Corelight)
* Convert BaseList/List/PList into templates, including iterator support (Tim Wojtulewicz, Corelight)
2.6-598 | 2019-07-12 18:20:12 -0700
* Fix canonification of timestamps with a decisecond multiple (Jon Siwek, Corelight)
2.6-597 | 2019-07-12 15:01:56 -0700
* Fix a couple of resource leaks from JSON changes (Tim Wojtulewicz, Corelight)
2.6-595 | 2019-07-12 13:34:08 -0700
* GH-157: Mark some attributes as not allowed for global variables (Tim Wojtulewicz, Corelight)
This disallows &default for global values that are not tables, and &optional for all globals.
* Fix uncaught exceptions from Val cloning failures (Jon Siwek, Corelight)
2.6-591 | 2019-07-11 13:29:28 -0700
* Fix potential thread safety issue with zeekenv util function

21
NEWS
View file

@ -357,6 +357,27 @@ Changed Functionality
are small changes to the output; most visibly double numbers are now rounded slightly
differently. The way in which port values are rendered does _not_ change for JSON logs.
- The C++-layer List, Queue, and Dict types have changed from using macros to
templates as well as some other API changes.
- Range-based for-loops are now supported
- The loop_over_queue macro is now removed
- PList is now a template instead of a macro, so any "PList(T)" usages in
external code should now use "PList<T>"
- PDict is now a template instead of a macro, so any "PDict(T)" usages in
external code should now use "PDict<T>"
- Generally some methods used to assume containers were only using integer
or pointer types, so semantics may now be slightly different to
either avoid copying or unsafely returning arbitrary T types by value.
E.g. List::remove_nth and List::get can no longer return a "null" value
when the provided index is out of range, so they assert instead, and
Queue::pop methods do not return a value at all (one must check for
a non-empty container before removing an element).
Removed Functionality
---------------------

107
README
View file

@ -1,36 +1,93 @@
=============================
Zeek Network Security Monitor
=============================
=================================
The Zeek Network Security Monitor
=================================
Zeek is a powerful framework for network analysis and security
monitoring.
Zeek is a powerful framework for network traffic analysis and security
monitoring. Follow us on Twitter at @zeekurity.
(Zeek is the new name for the long-established Bro system. Note that
parts of the system retain the "Bro" name, and it also often appears in
the documentation and distributions.)
Key Features
============
Please see the INSTALL file for installation instructions and pointers
for getting started. NEWS contains release notes for the current
version, and CHANGES has the complete history of changes. Please see
COPYING for licensing information.
* **In-depth Analysis**
Zeek ships with analyzers for many protocols, enabling
high-level semantic analysis at the application layer.
You can download source and binary releases on:
* **Adaptable & Flexible**
Zeek's domain specific scripting language enables site-specific
monitoring policies and means that it is not restricted to any
particular detection approach.
https://www.zeek.org/download
* **Efficient**
Zeek targets high-performance networks and is used operationally
at a variety of large sites.
To get the current development version, clone our master git
repository:
* **Highly Stateful**
Zeek keeps extensive application-layer state about the network
it monitors and provides a high-level archive of a network's
activity.
git clone --recursive https://github.com/zeek/zeek
Getting Started
===============
For more documentation, research publications, and community contact
information, please see the home page:
The best place to find information about getting started with Zeek is
our web site https://www.zeek.org, specifically the documentation
section there [1]. One the web site you can also get downloads for
stable releases, tutorials on getting Zeek set up, and many other
useful resources.
https://www.zeek.org
You can find release notes in NEWS, and a complete record of all
changes in CHANGES.
On behalf of the Zeek Development Team,
To work with the most recent code from the development branch of Zeek,
clone the master git repository:
> git clone --recursive https://github.com/zeek/zeek
With all dependencies [2] in place, build and install:
> ./configure && make && sudo make install
Write your first Zeek script:
# File "hello.zeek"
event zeek_init
{
print "Hello, World!";
}
And run it:
> zeek hello.zeek
For learning more about the Zeek scripting language,
https://try.zeek.org is a great resource.
Development
===========
Zeek is developed on GitHub by its community. We welcome
contributions. Working on an open source project like Zeek can be an
incredibly rewarding experience and, packet by packet, makes the
Internet a little safer. Today, as a result of countless
contributions, Zeek is used operationally around the world by major
companies and educational and scientific institutions alike for
securing their cyber infrastructure.
If you're interested in getting involved, we collect feature requests
and issues on GitHub. More information on Zeek's development can be
found here [2], and information about its community and mailing lists
(which are fairly active) can be found here [3].
License
-------
Zeek comes with a BSD license, allowing for free use with virtually no
restrictions. You can find it in COPYING.
[1] https://www.zeek.org/documentation/index.html
[2] https://docs.zeek.org/en/stable/install/install.html
[3] https://www.zeek.org/development/index.html
[4] https://www.zeek.org/community/index.html
Vern Paxson & Robin Sommer,
International Computer Science Institute &
Lawrence Berkeley National Laboratory
vern@icir.org / robin@icir.org

108
README.md Normal file
View file

@ -0,0 +1,108 @@
<h1 align="center">
[![Zeek Logo](https://www.zeek.org/images/bro-eyes.png)](https:://www.zeek.org)
The Zeek Network Security Monitor
</h1><h4 align="center">
A [powerful](https://www.zeek.org/why_choose_zeek.pdf) framework for network
traffic analysis and security monitoring.
[_Key Features_](#key-features) —
[_Documentation_](https://docs.zeek.org/en/stable/index.html) —
[_Getting Started_](#getting-started) —
[_Development_](#development) —
[_License_](#license)
Follow us on Twitter at [@zeekurity](https://twitter.com/zeekurity).
</h4>
Key Features
--------------
* __In-depth Analysis__
Zeek ships with analyzers for many protocols, enabling high-level semantic
analysis at the application layer.
* __Adaptable and Flexible__
Zeek's domain-specific scripting language enables site-specific monitoring
policies and means that it is not restricted to any particular detection
approach.
* __Efficient__
Zeek targets high-performance networks and is used operationally at a variety
of large sites.
* __Highly Stateful__
Zeek keeps extensive application-layer state about the network it monitors
and provides a high-level archive of a network's activity.
Getting Started
---------------
The best place to find information about getting started with Zeek is
our web site [www.zeek.org](https://www.zeek.org), specifically the
[documentation](https://www.zeek.org/documentation/index.html) section
there. On the web site you can also find downloads for stable
releases, tutorials on getting Zeek set up, and many other useful
resources.
You can find release notes in [NEWS](https://github.com/zeek/zeek/blob/master/NEWS),
and a complete record of all changes in [CHANGES](https://github.com/zeek/zeek/blob/master/CHANGES).
To work with the most recent code from the development branch of Zeek,
clone the master git repository:
`git clone --recursive https://github.com/zeek/zeek`
With all [dependencies](https://docs.zeek.org/en/stable/install/install.html#prerequisites)
in place, build and install:
`./configure && make && sudo make install`
Write your first Zeek script:
```zeek
# File "hello.zeek"
event zeek_init
{
print "Hello World!";
}
```
And run it:
`zeek hello.zeek`
For learning more about the Zeek scripting
language, [try.zeek.org](http://try.zeek.org) is a great resource.
Development
-----------
Zeek is developed on GitHub by its community. We welcome
contributions. Working on an open source project like Zeek can be an
incredibly rewarding experience and, packet by packet, makes the
Internet a little safer. Today, as a result of countless
contributions, Zeek is used operationally around the world by major
companies and educational and scientific institutions alike for
securing their cyber infrastructure.
If you're interested in getting involved, we collect feature requests
and issues on GitHub [here](https://github.com/zeek/zeek/issues) and
you might find
[these](https://github.com/zeek/zeek/issues?q=is%3Aissue+is%3Aopen+label%3A%22Difficulty%3A+Easy%22)
to be a good place to get started. More information on Zeek's
development can be found
[here](https://www.zeek.org/development/index.html), and information
about its community and mailing lists (which are fairly active) can be
found [here](https://www.zeek.org/community/index.html).
License
-------
Zeek comes with a BSD license, allowing for free use with virtually no
restrictions. You can find it [here](https://github.com/zeek/zeek/blob/master/COPYING).

1
README.rst
View file

@ -1 +0,0 @@
README

2
VERSION
View file

@ -1 +1 @@
2.6-591
2.6-624

2
cmake

@ -1 +1 @@
Subproject commit 8fb99b7aa9851caae2d938675324661571f8758e
Subproject commit 58e4eebe3aebd0cf608e51046805a9ab1ffa6c1b

44
src/Attr.cc
View file

@ -130,11 +130,12 @@ void Attr::AddTag(ODesc* d) const
d->Add(attr_name(Tag()));
}
Attributes::Attributes(attr_list* a, BroType* t, bool arg_in_record)
Attributes::Attributes(attr_list* a, BroType* t, bool arg_in_record, bool is_global)
{
attrs = new attr_list(a->length());
type = t->Ref();
in_record = arg_in_record;
global_var = is_global;
SetLocationInfo(&start_location, &end_location);
@ -142,16 +143,16 @@ Attributes::Attributes(attr_list* a, BroType* t, bool arg_in_record)
// rather than just taking over 'a' for ourselves, so that
// the necessary checking gets done.
loop_over_list(*a, i)
AddAttr((*a)[i]);
for ( const auto& attr : *a )
AddAttr(attr);
delete a;
}
Attributes::~Attributes()
{
loop_over_list(*attrs, i)
Unref((*attrs)[i]);
for ( const auto& attr : *attrs )
Unref(attr);
delete attrs;
@ -188,8 +189,8 @@ void Attributes::AddAttr(Attr* attr)
void Attributes::AddAttrs(Attributes* a)
{
attr_list* as = a->Attrs();
loop_over_list(*as, i)
AddAttr((*as)[i]);
for ( const auto& attr : *as )
AddAttr(attr);
Unref(a);
}
@ -199,9 +200,8 @@ Attr* Attributes::FindAttr(attr_tag t) const
if ( ! attrs )
return 0;
loop_over_list(*attrs, i)
for ( const auto& a : *attrs )
{
Attr* a = (*attrs)[i];
if ( a->Tag() == t )
return a;
}
@ -250,10 +250,14 @@ void Attributes::CheckAttr(Attr* a)
{
switch ( a->Tag() ) {
case ATTR_DEPRECATED:
case ATTR_OPTIONAL:
case ATTR_REDEF:
break;
case ATTR_OPTIONAL:
if ( global_var )
Error("&optional is not valid for global variables");
break;
case ATTR_ADD_FUNC:
case ATTR_DEL_FUNC:
{
@ -283,6 +287,14 @@ void Attributes::CheckAttr(Attr* a)
case ATTR_DEFAULT:
{
// &default is allowed for global tables, since it's used in initialization
// of table fields. it's not allowed otherwise.
if ( global_var && ! type->IsSet() && type->Tag() != TYPE_TABLE )
{
Error("&default is not valid for global variables");
break;
}
BroType* atype = a->AttrExpr()->Type();
if ( type->Tag() != TYPE_TABLE || (type->IsSet() && ! in_record) )
@ -391,9 +403,8 @@ void Attributes::CheckAttr(Attr* a)
int num_expires = 0;
if ( attrs )
{
loop_over_list(*attrs, i)
for ( const auto& a : *attrs )
{
Attr* a = (*attrs)[i];
if ( a->Tag() == ATTR_EXPIRE_READ ||
a->Tag() == ATTR_EXPIRE_WRITE ||
a->Tag() == ATTR_EXPIRE_CREATE )
@ -410,9 +421,10 @@ void Attributes::CheckAttr(Attr* a)
#if 0
//### not easy to test this w/o knowing the ID.
if ( ! IsGlobal() )
if ( ! global_var )
Error("expiration not supported for local variables");
#endif
break;
case ATTR_EXPIRE_FUNC:
@ -505,9 +517,8 @@ bool Attributes::operator==(const Attributes& other) const
if ( ! other.attrs )
return false;
loop_over_list(*attrs, i)
for ( const auto& a : *attrs )
{
Attr* a = (*attrs)[i];
Attr* o = other.FindAttr(a->Tag());
if ( ! o )
@ -517,9 +528,8 @@ bool Attributes::operator==(const Attributes& other) const
return false;
}
loop_over_list(*other.attrs, j)
for ( const auto& o : *other.attrs )
{
Attr* o = (*other.attrs)[j];
Attr* a = FindAttr(o->Tag());
if ( ! a )

3
src/Attr.h
View file

@ -77,7 +77,7 @@ protected:
// Manages a collection of attributes.
class Attributes : public BroObj {
public:
Attributes(attr_list* a, BroType* t, bool in_record);
Attributes(attr_list* a, BroType* t, bool in_record, bool is_global);
~Attributes() override;
void AddAttr(Attr* a);
@ -101,6 +101,7 @@ protected:
BroType* type;
attr_list* attrs;
bool in_record;
bool global_var;
};
#endif

21
src/BroList.h
View file

@ -6,31 +6,24 @@
#include "List.h"
class Expr;
declare(PList,Expr);
typedef PList(Expr) expr_list;
typedef PList<Expr> expr_list;
class ID;
declare(PList,ID);
typedef PList(ID) id_list;
typedef PList<ID> id_list;
class Val;
declare(PList,Val);
typedef PList(Val) val_list;
typedef PList<Val> val_list;
class Stmt;
declare(PList,Stmt);
typedef PList(Stmt) stmt_list;
typedef PList<Stmt> stmt_list;
class BroType;
declare(PList,BroType);
typedef PList(BroType) type_list;
typedef PList<BroType> type_list;
class Attr;
declare(PList,Attr);
typedef PList(Attr) attr_list;
typedef PList<Attr> attr_list;
class Timer;
declare(PList,Timer);
typedef PList(Timer) timer_list;
typedef PList<Timer> timer_list;
#endif

10
src/CCL.cc
View file

@ -2,6 +2,8 @@
#include "zeek-config.h"
#include <algorithm>
#include "CCL.h"
#include "RE.h"
#include "DFA.h"
@ -30,14 +32,14 @@ void CCL::Add(int sym)
ptr_compat_int sym_p = ptr_compat_int(sym);
// Check to see if the character is already in the ccl.
for ( int i = 0; i < syms->length(); ++i )
if ( (*syms)[i] == sym_p )
for ( auto sym : *syms )
if ( sym == sym_p )
return;
syms->append(sym_p);
syms->push_back(sym_p);
}
void CCL::Sort()
{
syms->sort(int_list_cmp);
std::sort(syms->begin(), syms->end());
}

6
src/CCL.h
View file

@ -3,10 +3,10 @@
#ifndef ccl_h
#define ccl_h
#include <vector>
#include "List.h"
declare(List,ptr_compat_int);
typedef List(ptr_compat_int) int_list;
typedef std::vector<ptr_compat_int> int_list;
class CCL {
public:
@ -26,7 +26,7 @@ public:
{ delete syms; syms = new_syms; }
unsigned int MemoryAllocation() const
{ return padded_sizeof(*this) + syms->MemoryAllocation(); }
{ return padded_sizeof(*this) + padded_sizeof(*syms) + pad_size(syms->size() * sizeof(int_list::value_type)); }
protected:
int_list* syms;

2
src/CMakeLists.txt
View file

@ -261,7 +261,6 @@ set(MAIN_SRCS
IntSet.cc
IP.cc
IPAddr.cc
List.cc
Reporter.cc
NFA.cc
Net.cc
@ -273,7 +272,6 @@ set(MAIN_SRCS
PolicyFile.cc
PrefixTable.cc
PriorityQueue.cc
Queue.cc
RandTest.cc
RE.cc
Reassem.cc

4
src/CompHash.cc
View file

@ -675,10 +675,10 @@ ListVal* CompositeHash::RecoverVals(const HashKey* k) const
const char* kp = (const char*) k->Key();
const char* const k_end = kp + k->Size();
loop_over_list(*tl, i)
for ( const auto& type : *tl )
{
Val* v = nullptr;
kp = RecoverOneVal(k, kp, k_end, (*tl)[i], v, false);
kp = RecoverOneVal(k, kp, k_end, type, v, false);
ASSERT(v);
l->Append(v);
}

11
src/Conn.cc
View file

@ -481,8 +481,8 @@ void Connection::ConnectionEvent(EventHandlerPtr f, analyzer::Analyzer* a, val_l
{
// This may actually happen if there is no local handler
// and a previously existing remote handler went away.
loop_over_list(vl, i)
Unref(vl[i]);
for ( const auto& v : vl)
Unref(v);
return;
}
@ -540,11 +540,10 @@ void Connection::CancelTimers()
// traversing. Thus, we first make a copy of the list which we then
// iterate through.
timer_list tmp(timers.length());
loop_over_list(timers, j)
tmp.append(timers[j]);
std::copy(timers.begin(), timers.end(), std::back_inserter(tmp));
loop_over_list(tmp, i)
GetTimerMgr()->Cancel(tmp[i]);
for ( const auto& timer : tmp )
GetTimerMgr()->Cancel(timer);
timers_canceled = 1;
timers.clear();

3
src/Continuation.h
View file

@ -50,8 +50,7 @@ private:
int current_level;
int suspend_level;
declare(PList, void);
typedef PList(void) voidp_list;
typedef PList<void> voidp_list;
voidp_list states;
};

18
src/DFA.cc
View file

@ -108,11 +108,11 @@ DFA_State* DFA_State::ComputeXtion(int sym, DFA_Machine* machine)
void DFA_State::AppendIfNew(int sym, int_list* sym_list)
{
for ( int i = 0; i < sym_list->length(); ++i )
if ( (*sym_list)[i] == sym )
for ( auto value : *sym_list )
if ( value == sym )
return;
sym_list->append(sym);
sym_list->push_back(sym);
}
NFA_state_list* DFA_State::SymFollowSet(int ec_sym, const EquivClass* ec)
@ -132,8 +132,8 @@ NFA_state_list* DFA_State::SymFollowSet(int ec_sym, const EquivClass* ec)
if ( ccl->IsNegated() )
{
int j;
for ( j = 0; j < syms->length(); ++j )
size_t j;
for ( j = 0; j < syms->size(); ++j )
{
// Loop through (sorted) negated
// character class, which has
@ -143,19 +143,19 @@ NFA_state_list* DFA_State::SymFollowSet(int ec_sym, const EquivClass* ec)
break;
}
if ( j >= syms->length() || (*syms)[j] > ec_sym )
if ( j >= syms->size() || (*syms)[j] > ec_sym )
// Didn't find ec_sym in ccl.
n->AddXtionsTo(ns);
continue;
}
for ( int j = 0; j < syms->length(); ++j )
for ( auto sym : *syms )
{
if ( (*syms)[j] > ec_sym )
if ( sym > ec_sym )
break;
if ( (*syms)[j] == ec_sym )
if ( sym == ec_sym )
{
n->AddXtionsTo(ns);
break;

4
src/DFA.h
View file

@ -105,10 +105,8 @@ private:
int hits; // Statistics
int misses;
declare(PDict,CacheEntry);
// Hash indexed by NFA states (MD5s of them, actually).
PDict(CacheEntry) states;
PDict<CacheEntry> states;
};
class DFA_Machine : public BroObj {

7
src/DNS_Mgr.h
View file

@ -23,14 +23,11 @@ class EventHandler;
class RecordType;
class DNS_Mgr_Request;
declare(PList,DNS_Mgr_Request);
typedef PList(DNS_Mgr_Request) DNS_mgr_request_list;
typedef PList<DNS_Mgr_Request> DNS_mgr_request_list;
struct nb_dns_info;
struct nb_dns_result;
declare(PDict,ListVal);
class DNS_Mapping;
enum DNS_MgrMode {
@ -144,7 +141,7 @@ protected:
DNS_MgrMode mode;
PDict(ListVal) services;
PDict<ListVal> services;
HostMap host_mappings;
AddrMap addr_mappings;

9
src/Debug.cc
View file

@ -27,7 +27,7 @@ using namespace std;
bool g_policy_debug = false;
DebuggerState g_debugger_state;
TraceState g_trace_state;
PDict(Filemap) g_dbgfilemaps;
PDict<Filemap> g_dbgfilemaps;
// These variables are used only to decide whether or not to print the
// current context; you don't want to do it after a step or next
@ -378,10 +378,9 @@ vector<ParseLocationRec> parse_location_string(const string& s)
}
StmtLocMapping* hit = 0;
loop_over_queue(*map, i)
for ( const auto entry : *map )
{
StmtLocMapping* entry = (*map)[i];
plr.filename = (*map)[i]->Loc().filename;
plr.filename = entry->Loc().filename;
if ( entry->Loc().first_line > plr.line )
break;
@ -389,7 +388,7 @@ vector<ParseLocationRec> parse_location_string(const string& s)
if ( plr.line >= entry->Loc().first_line &&
plr.line <= entry->Loc().last_line )
{
hit = (*map)[i];
hit = entry;
break;
}
}

6
src/Debug.h
View file

@ -29,9 +29,7 @@ struct ParseLocationRec {
#include "DbgBreakpoint.h"
class StmtLocMapping;
declare(PQueue,StmtLocMapping);
typedef PQueue(StmtLocMapping) Filemap; // mapping for a single file
declare(PDict,Filemap);
typedef PQueue<StmtLocMapping> Filemap; // mapping for a single file
class DbgBreakpoint;
class DbgWatch;
@ -178,7 +176,7 @@ string get_context_description(const Stmt* stmt, const Frame* frame);
extern Frame* g_dbg_locals; // variables created within debugger context
extern PDict(Filemap) g_dbgfilemaps; // filename => filemap
extern PDict<Filemap> g_dbgfilemaps; // filename => filemap
// Perhaps add a code/priority argument to do selective output.
int debug_msg(const char* fmt, ...) __attribute__ ((format (printf, 1, 2)));

4
src/DebugCmds.cc
View file

@ -51,7 +51,7 @@ void lookup_global_symbols_regex(const string& orig_regex, vector<ID*>& matches,
}
Scope* global = global_scope();
PDict(ID)* syms = global->Vars();
PDict<ID>* syms = global->Vars();
ID* nextid;
IterCookie* cookie = syms->InitForIteration();
@ -114,7 +114,7 @@ void choose_global_symbols_regex(const string& regex, vector<ID*>& choices,
// DebugCmdInfo implementation
//
PQueue(DebugCmdInfo) g_DebugCmdInfos;
PQueue<DebugCmdInfo> g_DebugCmdInfos;
DebugCmdInfo::DebugCmdInfo(const DebugCmdInfo& info)
: cmd(info.cmd), helpstring(0)

5
src/DebugCmds.h
View file

@ -12,9 +12,6 @@ using namespace std;
#include "Queue.h"
#include "DebugCmdConstants.h"
class DebugCmdInfo;
declare(PQueue,DebugCmdInfo);
class DebugCmdInfo {
public:
DebugCmdInfo(const DebugCmdInfo& info);
@ -47,7 +44,7 @@ protected:
bool repeatable;
};
extern PQueue(DebugCmdInfo) g_DebugCmdInfos;
extern PQueue<DebugCmdInfo> g_DebugCmdInfos;
void init_global_dbg_constants ();

63
src/Dict.cc
View file

@ -50,9 +50,9 @@ public:
}
int bucket, offset;
PList(DictEntry)** ttbl;
PList<DictEntry>** ttbl;
const int* num_buckets_p;
PList(DictEntry) inserted; // inserted while iterating
PList<DictEntry> inserted; // inserted while iterating
};
Dictionary::Dictionary(dict_order ordering, int initial_size)
@ -61,7 +61,7 @@ Dictionary::Dictionary(dict_order ordering, int initial_size)
tbl2 = 0;
if ( ordering == ORDERED )
order = new PList(DictEntry);
order = new PList<DictEntry>;
else
order = 0;
@ -99,10 +99,9 @@ void Dictionary::DeInit()
for ( int i = 0; i < num_buckets; ++i )
if ( tbl[i] )
{
PList(DictEntry)* chain = tbl[i];
loop_over_list(*chain, j)
PList<DictEntry>* chain = tbl[i];
for ( const auto& e : *chain )
{
DictEntry* e = (*chain)[j];
if ( delete_func )
delete_func(e->value);
delete e;
@ -119,10 +118,9 @@ void Dictionary::DeInit()
for ( int i = 0; i < num_buckets2; ++i )
if ( tbl2[i] )
{
PList(DictEntry)* chain = tbl2[i];
loop_over_list(*chain, j)
PList<DictEntry>* chain = tbl2[i];
for ( const auto& e : *chain )
{
DictEntry* e = (*chain)[j];
if ( delete_func )
delete_func(e->value);
delete e;
@ -141,7 +139,7 @@ void* Dictionary::Lookup(const void* key, int key_size, hash_t hash) const
return 0;
hash_t h;
PList(DictEntry)* chain;
PList<DictEntry>* chain;
// Figure out which hash table to look in.
h = hash % num_buckets;
@ -199,7 +197,7 @@ void* Dictionary::Remove(const void* key, int key_size, hash_t hash,
return 0;
hash_t h;
PList(DictEntry)* chain;
PList<DictEntry>* chain;
int* num_entries_ptr;
// Figure out which hash table to look in
@ -240,7 +238,7 @@ void* Dictionary::Remove(const void* key, int key_size, hash_t hash,
}
void* Dictionary::DoRemove(DictEntry* entry, hash_t h,
PList(DictEntry)* chain, int chain_offset)
PList<DictEntry>* chain, int chain_offset)
{
void* entry_value = entry->value;
@ -249,10 +247,8 @@ void* Dictionary::DoRemove(DictEntry* entry, hash_t h,
order->remove(entry);
// Adjust existing cookies.
loop_over_list(cookies, i)
for ( const auto& c : cookies )
{
IterCookie* c = cookies[i];
// Is the affected bucket the current one?
if ( (unsigned int) c->bucket == h )
{
@ -301,7 +297,7 @@ void* Dictionary::NextEntry(HashKey*& h, IterCookie*& cookie, int return_hash) c
{
if ( ! tbl && ! tbl2 )
{
const_cast<PList(IterCookie)*>(&cookies)->remove(cookie);
const_cast<PList<IterCookie>*>(&cookies)->remove(cookie);
delete cookie;
cookie = 0;
return 0;
@ -326,7 +322,7 @@ void* Dictionary::NextEntry(HashKey*& h, IterCookie*& cookie, int return_hash) c
int b = cookie->bucket;
int o = cookie->offset;
PList(DictEntry)** ttbl;
PList<DictEntry>** ttbl;
const int* num_buckets_p;
if ( ! cookie->ttbl )
@ -368,7 +364,7 @@ void* Dictionary::NextEntry(HashKey*& h, IterCookie*& cookie, int return_hash) c
// FIXME: I don't like removing the const here. But is there
// a better way?
const_cast<PList(IterCookie)*>(&cookies)->remove(cookie);
const_cast<PList<IterCookie>*>(&cookies)->remove(cookie);
delete cookie;
cookie = 0;
return 0;
@ -387,7 +383,7 @@ void* Dictionary::NextEntry(HashKey*& h, IterCookie*& cookie, int return_hash) c
void Dictionary::Init(int size)
{
num_buckets = NextPrime(size);
tbl = new PList(DictEntry)*[num_buckets];
tbl = new PList<DictEntry>*[num_buckets];
for ( int i = 0; i < num_buckets; ++i )
tbl[i] = 0;
@ -399,7 +395,7 @@ void Dictionary::Init(int size)
void Dictionary::Init2(int size)
{
num_buckets2 = NextPrime(size);
tbl2 = new PList(DictEntry)*[num_buckets2];
tbl2 = new PList<DictEntry>*[num_buckets2];
for ( int i = 0; i < num_buckets2; ++i )
tbl2[i] = 0;
@ -413,7 +409,7 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
if ( ! tbl )
Init(DEFAULT_DICT_SIZE);
PList(DictEntry)** ttbl;
PList<DictEntry>** ttbl;
int* num_entries_ptr;
int* max_num_entries_ptr;
hash_t h = new_entry->hash % num_buckets;
@ -438,7 +434,7 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
max_num_entries_ptr = &max_num_entries2;
}
PList(DictEntry)* chain = ttbl[h];
PList<DictEntry>* chain = ttbl[h];
int n = new_entry->len;
@ -460,7 +456,7 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
}
else
// Create new chain.
chain = ttbl[h] = new PList(DictEntry);
chain = ttbl[h] = new PList<DictEntry>;
// If we got this far, then we couldn't use an existing copy
// of the key, so make a new one if necessary.
@ -482,9 +478,8 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
// For ongoing iterations: If we already passed the bucket where this
// entry was put, add it to the cookie's list of inserted entries.
loop_over_list(cookies, i)
for ( const auto& c : cookies )
{
IterCookie* c = cookies[i];
if ( h < (unsigned int) c->bucket )
c->inserted.append(new_entry);
}
@ -545,7 +540,7 @@ void Dictionary::MoveChains()
do
{
PList(DictEntry)* chain = tbl[tbl_next_ind++];
PList<DictEntry>* chain = tbl[tbl_next_ind++];
if ( ! chain )
continue;
@ -605,13 +600,13 @@ unsigned int Dictionary::MemoryAllocation() const
for ( int i = 0; i < num_buckets; ++i )
if ( tbl[i] )
{
PList(DictEntry)* chain = tbl[i];
loop_over_list(*chain, j)
size += padded_sizeof(DictEntry) + pad_size((*chain)[j]->len);
PList<DictEntry>* chain = tbl[i];
for ( const auto& c : *chain )
size += padded_sizeof(DictEntry) + pad_size(c->len);
size += chain->MemoryAllocation();
}
size += pad_size(num_buckets * sizeof(PList(DictEntry)*));
size += pad_size(num_buckets * sizeof(PList<DictEntry>*));
if ( order )
size += order->MemoryAllocation();
@ -621,13 +616,13 @@ unsigned int Dictionary::MemoryAllocation() const
for ( int i = 0; i < num_buckets2; ++i )
if ( tbl2[i] )
{
PList(DictEntry)* chain = tbl2[i];
loop_over_list(*chain, j)
size += padded_sizeof(DictEntry) + pad_size((*chain)[j]->len);
PList<DictEntry>* chain = tbl2[i];
for ( const auto& c : *chain )
size += padded_sizeof(DictEntry) + pad_size(c->len);
size += chain->MemoryAllocation();
}
size += pad_size(num_buckets2 * sizeof(PList(DictEntry)*));
size += pad_size(num_buckets2 * sizeof(PList<DictEntry>*));
}
return size;

88
src/Dict.h
View file

@ -10,9 +10,6 @@ class Dictionary;
class DictEntry;
class IterCookie;
declare(PList,DictEntry);
declare(PList,IterCookie);
// Type indicating whether the dictionary should keep track of the order
// of insertions.
typedef enum { ORDERED, UNORDERED } dict_order;
@ -132,7 +129,7 @@ private:
void* Insert(DictEntry* entry, int copy_key);
void* DoRemove(DictEntry* entry, hash_t h,
PList(DictEntry)* chain, int chain_offset);
PList<DictEntry>* chain, int chain_offset);
int NextPrime(int n) const;
int IsPrime(int n) const;
@ -162,7 +159,7 @@ private:
// When we're resizing, we'll have tbl (old) and tbl2 (new)
// tbl_next_ind keeps track of how much we've moved to tbl2
// (it's the next index we're going to move).
PList(DictEntry)** tbl;
PList<DictEntry>** tbl;
int num_buckets;
int num_entries;
int max_num_entries;
@ -171,7 +168,7 @@ private:
int thresh_entries;
// Resizing table (replicates tbl above).
PList(DictEntry)** tbl2;
PList<DictEntry>** tbl2;
int num_buckets2;
int num_entries2;
int max_num_entries2;
@ -180,52 +177,47 @@ private:
hash_t tbl_next_ind;
PList(DictEntry)* order;
PList<DictEntry>* order;
dict_delete_func delete_func;
PList(IterCookie) cookies;
PList<IterCookie> cookies;
};
#define PDict(type) type ## PDict
#define PDictdeclare(type) \
class PDict(type) : public Dictionary { \
public: \
explicit PDict(type)(dict_order ordering = UNORDERED, \
int initial_size = 0) : \
Dictionary(ordering, initial_size) {} \
type* Lookup(const char* key) const \
{ \
HashKey h(key); \
return (type*) Dictionary::Lookup(&h); \
} \
type* Lookup(const HashKey* key) const \
{ return (type*) Dictionary::Lookup(key); } \
type* Insert(const char* key, type* val) \
{ \
HashKey h(key); \
return (type*) Dictionary::Insert(&h, (void*) val); \
} \
type* Insert(HashKey* key, type* val) \
{ return (type*) Dictionary::Insert(key, (void*) val); }\
type* NthEntry(int n) const \
{ return (type*) Dictionary::NthEntry(n); } \
type* NthEntry(int n, const char*& key) const \
{ \
int key_len; \
return (type*) Dictionary::NthEntry(n, (const void*&) key,\
key_len); \
} \
type* NextEntry(IterCookie*& cookie) const \
{ \
HashKey* h; \
return (type*) Dictionary::NextEntry(h, cookie, 0); \
} \
type* NextEntry(HashKey*& h, IterCookie*& cookie) const \
{ return (type*) Dictionary::NextEntry(h, cookie, 1); } \
type* RemoveEntry(const HashKey* key) \
{ return (type*) Remove(key->Key(), key->Size(), \
key->Hash()); } \
template<typename T>
class PDict : public Dictionary {
public:
explicit PDict(dict_order ordering = UNORDERED, int initial_size = 0) :
Dictionary(ordering, initial_size) {}
T* Lookup(const char* key) const
{
HashKey h(key);
return (T*) Dictionary::Lookup(&h);
}
T* Lookup(const HashKey* key) const
{ return (T*) Dictionary::Lookup(key); }
T* Insert(const char* key, T* val)
{
HashKey h(key);
return (T*) Dictionary::Insert(&h, (void*) val);
}
T* Insert(HashKey* key, T* val)
{ return (T*) Dictionary::Insert(key, (void*) val); }
T* NthEntry(int n) const
{ return (T*) Dictionary::NthEntry(n); }
T* NthEntry(int n, const char*& key) const
{
int key_len;
return (T*) Dictionary::NthEntry(n, (const void*&) key, key_len);
}
T* NextEntry(IterCookie*& cookie) const
{
HashKey* h;
return (T*) Dictionary::NextEntry(h, cookie, 0);
}
T* NextEntry(HashKey*& h, IterCookie*& cookie) const
{ return (T*) Dictionary::NextEntry(h, cookie, 1); }
T* RemoveEntry(const HashKey* key)
{ return (T*) Remove(key->Key(), key->Size(), key->Hash()); }
};
#endif

15
src/EquivClass.cc
View file

@ -52,11 +52,10 @@ void EquivClass::ConvertCCL(CCL* ccl)
int_list* c_syms = ccl->Syms();
int_list* new_syms = new int_list;
for ( int i = 0; i < c_syms->length(); ++i )
for ( auto sym : *c_syms )
{
int sym = (*c_syms)[i];
if ( IsRep(sym) )
new_syms->append(SymEquivClass(sym));
new_syms->push_back(SymEquivClass(sym));
}
ccl->ReplaceSyms(new_syms);
@ -95,18 +94,18 @@ void EquivClass::CCL_Use(CCL* ccl)
}
int_list* csyms = ccl->Syms();
for ( int i = 0; i < csyms->length(); /* no increment */ )
for ( size_t i = 0; i < csyms->size(); /* no increment */ )
{
int sym = (*csyms)[i];
int old_ec = bck[sym];
int new_ec = sym;
int j = i + 1;
size_t j = i + 1;
for ( int k = fwd[sym]; k && k < size; k = fwd[k] )
{ // look for the symbol in the character class
for ( ; j < csyms->length(); ++j )
for ( ; j < csyms->size(); ++j )
{
if ( (*csyms)[j] > k )
// Since the character class is sorted,
@ -131,7 +130,7 @@ void EquivClass::CCL_Use(CCL* ccl)
}
}
if ( j < csyms->length() && (*csyms)[j] == k )
if ( j < csyms->size() && (*csyms)[j] == k )
// We broke out of the above loop by finding
// an old companion - go to the next symbol.
continue;
@ -154,7 +153,7 @@ void EquivClass::CCL_Use(CCL* ccl)
fwd[new_ec] = ec_nil;
// Find next ccl member to process.
for ( ++i; i < csyms->length() && ccl_flags[i]; ++i )
for ( ++i; i < csyms->size() && ccl_flags[i]; ++i )
// Reset "doesn't need processing" flag.
ccl_flags[i] = 0;
}

4
src/Event.h
View file

@ -86,8 +86,8 @@ public:
QueueEvent(new Event(h, std::move(vl), src, aid, mgr, obj));
else
{
loop_over_list(vl, i)
Unref(vl[i]);
for ( const auto& v : vl )
Unref(v);
}
}

4
src/EventHandler.cc
View file

@ -117,8 +117,8 @@ void EventHandler::Call(val_list* vl, bool no_remote)
Unref(local->Call(vl));
else
{
loop_over_list(*vl, i)
Unref((*vl)[i]);
for ( auto v : *vl )
Unref(v);
}
}

6
src/EventRegistry.h
View file

@ -22,8 +22,7 @@ public:
// Returns a list of all local handlers that match the given pattern.
// Passes ownership of list.
typedef const char constchar; // PList doesn't like "const char"
declare(PList, constchar);
typedef PList(constchar) string_list;
typedef PList<constchar> string_list;
string_list* Match(RE_Matcher* pattern);
// Marks a handler as handling errors. Error handler will not be called
@ -38,8 +37,7 @@ public:
void PrintDebug();
private:
declare(PDict, EventHandler);
typedef PDict(EventHandler) handler_map;
typedef PDict<EventHandler> handler_map;
handler_map handlers;
};

116
src/Expr.cc
View file

@ -2113,8 +2113,7 @@ bool AssignExpr::TypeCheck(attr_list* attrs)
if ( attrs )
{
attr_copy = new attr_list(attrs->length());
loop_over_list(*attrs, i)
attr_copy->append((*attrs)[i]);
std::copy(attrs->begin(), attrs->end(), std::back_inserter(*attr_copy));
}
bool empty_list_assignment = (op2->AsListExpr()->Exprs().length() == 0);
@ -2194,8 +2193,7 @@ bool AssignExpr::TypeCheck(attr_list* attrs)
{
attr_list* a = sce->Attrs()->Attrs();
attrs = new attr_list(a->length());
loop_over_list(*a, i)
attrs->append((*a)[i]);
std::copy(a->begin(), a->end(), std::back_inserter(*attrs));
}
int errors_before = reporter->Errors();
@ -3029,10 +3027,8 @@ RecordConstructorExpr::RecordConstructorExpr(ListExpr* constructor_list)
const expr_list& exprs = constructor_list->Exprs();
type_decl_list* record_types = new type_decl_list(exprs.length());
loop_over_list(exprs, i)
for ( const auto& e : exprs )
{
Expr* e = exprs[i];
if ( e->Tag() != EXPR_FIELD_ASSIGN )
{
Error("bad type in record constructor", e);
@ -3133,18 +3129,18 @@ TableConstructorExpr::TableConstructorExpr(ListExpr* constructor_list,
}
}
attrs = arg_attrs ? new Attributes(arg_attrs, type, false) : 0;
attrs = arg_attrs ? new Attributes(arg_attrs, type, false, false) : 0;
type_list* indices = type->AsTableType()->Indices()->Types();
const expr_list& cle = constructor_list->Exprs();
// check and promote all index expressions in ctor list
loop_over_list(cle, i)
for ( const auto& expr : cle )
{
if ( cle[i]->Tag() != EXPR_ASSIGN )
if ( expr->Tag() != EXPR_ASSIGN )
continue;
Expr* idx_expr = cle[i]->AsAssignExpr()->Op1();
Expr* idx_expr = expr->AsAssignExpr()->Op1();
if ( idx_expr->Tag() != EXPR_LIST )
continue;
@ -3178,8 +3174,8 @@ Val* TableConstructorExpr::Eval(Frame* f) const
Val* aggr = new TableVal(Type()->AsTableType(), attrs);
const expr_list& exprs = op->AsListExpr()->Exprs();
loop_over_list(exprs, i)
exprs[i]->EvalIntoAggregate(type, aggr, f);
for ( const auto& expr : exprs )
expr->EvalIntoAggregate(type, aggr, f);
aggr->AsTableVal()->InitDefaultFunc(f);
@ -3195,8 +3191,8 @@ Val* TableConstructorExpr::InitVal(const BroType* t, Val* aggr) const
TableVal* tval = aggr ? aggr->AsTableVal() : new TableVal(tt, attrs);
const expr_list& exprs = op->AsListExpr()->Exprs();
loop_over_list(exprs, i)
exprs[i]->EvalIntoAggregate(t, tval, 0);
for ( const auto& expr : exprs )
expr->EvalIntoAggregate(t, tval, 0);
return tval;
}
@ -3242,7 +3238,7 @@ SetConstructorExpr::SetConstructorExpr(ListExpr* constructor_list,
else if ( type->Tag() != TYPE_TABLE || ! type->AsTableType()->IsSet() )
SetError("values in set(...) constructor do not specify a set");
attrs = arg_attrs ? new Attributes(arg_attrs, type, false) : 0;
attrs = arg_attrs ? new Attributes(arg_attrs, type, false, false) : 0;
type_list* indices = type->AsTableType()->Indices()->Types();
expr_list& cle = constructor_list->Exprs();
@ -3284,9 +3280,9 @@ Val* SetConstructorExpr::Eval(Frame* f) const
TableVal* aggr = new TableVal(type->AsTableType(), attrs);
const expr_list& exprs = op->AsListExpr()->Exprs();
loop_over_list(exprs, i)
for ( const auto& expr : exprs )
{
Val* element = exprs[i]->Eval(f);
Val* element = expr->Eval(f);
aggr->Assign(element, 0);
Unref(element);
}
@ -3304,9 +3300,8 @@ Val* SetConstructorExpr::InitVal(const BroType* t, Val* aggr) const
TableVal* tval = aggr ? aggr->AsTableVal() : new TableVal(tt, attrs);
const expr_list& exprs = op->AsListExpr()->Exprs();
loop_over_list(exprs, i)
for ( const auto& e : exprs )
{
Expr* e = exprs[i];
Val* element = check_and_promote(e->Eval(0), index_type, 1);
if ( ! element || ! tval->Assign(element, 0) )
@ -4500,8 +4495,8 @@ ListExpr::ListExpr(Expr* e) : Expr(EXPR_LIST)
ListExpr::~ListExpr()
{
loop_over_list(exprs, i)
Unref(exprs[i]);
for ( const auto& expr: exprs )
Unref(expr);
}
void ListExpr::Append(Expr* e)
@ -4512,8 +4507,8 @@ void ListExpr::Append(Expr* e)
int ListExpr::IsPure() const
{
loop_over_list(exprs, i)
if ( ! exprs[i]->IsPure() )
for ( const auto& expr : exprs )
if ( ! expr->IsPure() )
return 0;
return 1;
@ -4521,8 +4516,8 @@ int ListExpr::IsPure() const
int ListExpr::AllConst() const
{
loop_over_list(exprs, i)
if ( ! exprs[i]->IsConst() )
for ( const auto& expr : exprs )
if ( ! expr->IsConst() )
return 0;
return 1;
@ -4532,9 +4527,9 @@ Val* ListExpr::Eval(Frame* f) const
{
ListVal* v = new ListVal(TYPE_ANY);
loop_over_list(exprs, i)
for ( const auto& expr : exprs )
{
Val* ev = exprs[i]->Eval(f);
Val* ev = expr->Eval(f);
if ( ! ev )
{
RuntimeError("uninitialized list value");
@ -4559,12 +4554,12 @@ BroType* ListExpr::InitType() const
if ( exprs[0]->IsRecordElement(0) )
{
type_decl_list* types = new type_decl_list(exprs.length());
loop_over_list(exprs, i)
for ( const auto& expr : exprs )
{
TypeDecl* td = new TypeDecl(0, 0);
if ( ! exprs[i]->IsRecordElement(td) )
if ( ! expr->IsRecordElement(td) )
{
exprs[i]->Error("record element expected");
expr->Error("record element expected");
delete td;
delete types;
return 0;
@ -4580,9 +4575,8 @@ BroType* ListExpr::InitType() const
else
{
TypeList* tl = new TypeList();
loop_over_list(exprs, i)
for ( const auto& e : exprs )
{
Expr* e = exprs[i];
BroType* ti = e->Type();
// Collapse any embedded sets or lists.
@ -4716,10 +4710,8 @@ Val* ListExpr::InitVal(const BroType* t, Val* aggr) const
// know how to add themselves to a table or record. Another
// possibility is an expression that evaluates itself to a
// table, which we can then add to the aggregate.
loop_over_list(exprs, i)
for ( const auto& e : exprs )
{
Expr* e = exprs[i];
if ( e->Tag() == EXPR_ASSIGN || e->Tag() == EXPR_FIELD_ASSIGN )
{
if ( ! e->InitVal(t, aggr) )
@ -4757,17 +4749,17 @@ Val* ListExpr::AddSetInit(const BroType* t, Val* aggr) const
const TableType* tt = tv->Type()->AsTableType();
const TypeList* it = tt->Indices();
loop_over_list(exprs, i)
for ( const auto& expr : exprs )
{
Val* element;
if ( exprs[i]->Type()->IsSet() )
if ( expr->Type()->IsSet() )
// A set to flatten.
element = exprs[i]->Eval(0);
else if ( exprs[i]->Type()->Tag() == TYPE_LIST )
element = exprs[i]->InitVal(it, 0);
element = expr->Eval(0);
else if ( expr->Type()->Tag() == TYPE_LIST )
element = expr->InitVal(it, 0);
else
element = exprs[i]->InitVal((*it->Types())[0], 0);
element = expr->InitVal((*it->Types())[0], 0);
if ( ! element )
return 0;
@ -4786,7 +4778,7 @@ Val* ListExpr::AddSetInit(const BroType* t, Val* aggr) const
continue;
}
if ( exprs[i]->Type()->Tag() == TYPE_LIST )
if ( expr->Type()->Tag() == TYPE_LIST )
element = check_and_promote(element, it, 1);
else
element = check_and_promote(element, (*it->Types())[0], 1);
@ -4822,8 +4814,8 @@ void ListExpr::ExprDescribe(ODesc* d) const
Expr* ListExpr::MakeLvalue()
{
loop_over_list(exprs, i)
if ( exprs[i]->Tag() != EXPR_NAME )
for ( const auto & expr : exprs )
if ( expr->Tag() != EXPR_NAME )
ExprError("can only assign to list of identifiers");
return new RefExpr(this);
@ -4847,9 +4839,9 @@ TraversalCode ListExpr::Traverse(TraversalCallback* cb) const
TraversalCode tc = cb->PreExpr(this);
HANDLE_TC_EXPR_PRE(tc);
loop_over_list(exprs, i)
for ( const auto& expr : exprs )
{
tc = exprs[i]->Traverse(cb);
tc = expr->Traverse(cb);
HANDLE_TC_EXPR_PRE(tc);
}
@ -4868,11 +4860,11 @@ RecordAssignExpr::RecordAssignExpr(Expr* record, Expr* init_list, int is_init)
// 2) a string indicating the field name, then (as the next element)
// the value to use for that field.
for ( int i = 0; i < inits.length(); ++i )
for ( const auto& init : inits )
{
if ( inits[i]->Type()->Tag() == TYPE_RECORD )
if ( init->Type()->Tag() == TYPE_RECORD )
{
RecordType* t = inits[i]->Type()->AsRecordType();
RecordType* t = init->Type()->AsRecordType();
for ( int j = 0; j < t->NumFields(); ++j )
{
@ -4883,15 +4875,15 @@ RecordAssignExpr::RecordAssignExpr(Expr* record, Expr* init_list, int is_init)
same_type(lhs->FieldType(field), t->FieldType(j)) )
{
FieldExpr* fe_lhs = new FieldExpr(record, field_name);
FieldExpr* fe_rhs = new FieldExpr(inits[i], field_name);
FieldExpr* fe_rhs = new FieldExpr(init, field_name);
Append(get_assign_expr(fe_lhs->Ref(), fe_rhs->Ref(), is_init));
}
}
}
else if ( inits[i]->Tag() == EXPR_FIELD_ASSIGN )
else if ( init->Tag() == EXPR_FIELD_ASSIGN )
{
FieldAssignExpr* rf = (FieldAssignExpr*) inits[i];
FieldAssignExpr* rf = (FieldAssignExpr*) init;
rf->Ref();
const char* field_name = ""; // rf->FieldName();
@ -5155,8 +5147,8 @@ int check_and_promote_args(ListExpr*& args, RecordType* types)
def_elements.insert(def_attr->AttrExpr());
}
loop_over_list(def_elements, i)
el.append(def_elements[i]->Ref());
for ( const auto& elem : def_elements )
el.append(elem->Ref());
}
TypeList* tl = new TypeList();
@ -5198,18 +5190,22 @@ val_list* eval_list(Frame* f, const ListExpr* l)
const expr_list& e = l->Exprs();
val_list* v = new val_list(e.length());
loop_over_list(e, i)
bool success = true;
for ( const auto& expr : e )
{
Val* ev = e[i]->Eval(f);
Val* ev = expr->Eval(f);
if ( ! ev )
{
success = false;
break;
}
v->append(ev);
}
if ( i < e.length() )
if ( ! success )
{ // Failure.
loop_over_list(*v, j)
Unref((*v)[j]);
for ( const auto& val : *v )
Unref(val);
delete v;
return 0;
}

7
src/Frame.cc
View file

@ -159,6 +159,7 @@ Frame* Frame::Clone()
if ( trigger )
Ref(trigger);
f->trigger = trigger;
f->call = call;
return f;
@ -171,7 +172,8 @@ Frame* Frame::SelectiveClone(id_list* selection)
loop_over_list(*selection, i)
{
ID* current = (*selection)[i];
other->frame[current->Offset()] = this->frame[current->Offset()];
Val* v = this->frame[current->Offset()];
other->frame[current->Offset()] = v ? v->Clone() : 0;
}
return other;
@ -396,9 +398,8 @@ Frame* ClosureFrame::SelectiveClone(id_list* choose)
// and
id_list them;
loop_over_list(*choose, i)
for (const auto& we : *choose)
{
ID* we = (*choose)[i];
if ( CaptureContains(we) )
us.append(we);
else

49
src/Func.cc
View file

@ -74,11 +74,11 @@ std::string render_call_stack()
if ( ci.args )
{
loop_over_list(*ci.args, i)
for ( const auto& arg : *ci.args )
{
ODesc d;
d.SetShort();
(*ci.args)[i]->Describe(&d);
arg->Describe(&d);
if ( ! arg_desc.empty() )
arg_desc += ", ";
@ -130,8 +130,8 @@ void Func::AddBody(Stmt* /* new_body */, id_list* /* new_inits */,
Func* Func::DoClone()
{
// By default, ok just to return a reference. Func does not have any "state".
// That is different across instances.
// By default, ok just to return a reference. Func does not have any state
// that is different across instances.
return this;
}
@ -200,8 +200,8 @@ TraversalCode Func::Traverse(TraversalCallback* cb) const
void Func::CopyStateInto(Func* other) const
{
std::for_each(bodies.begin(), bodies.end(), [](const Body& b) { Ref(b.stmts); });
other->bodies = bodies;
other->bodies = bodies;
other->scope = scope;
other->kind = kind;
@ -260,8 +260,8 @@ std::pair<bool, Val*> Func::HandlePluginResult(std::pair<bool, Val*> plugin_resu
}
}
loop_over_list(*args, i)
Unref((*args)[i]);
for ( const auto& arg : *args )
Unref(arg);
return plugin_result;
}
@ -284,7 +284,8 @@ BroFunc::BroFunc(ID* arg_id, Stmt* arg_body, id_list* aggr_inits,
BroFunc::~BroFunc()
{
std::for_each(bodies.begin(), bodies.end(), [](Body& b) { Unref(b.stmts); });
std::for_each(bodies.begin(), bodies.end(),
[](Body& b) { Unref(b.stmts); });
Unref(closure);
}
@ -319,8 +320,8 @@ Val* BroFunc::Call(val_list* args, Frame* parent) const
{
// Can only happen for events and hooks.
assert(Flavor() == FUNC_FLAVOR_EVENT || Flavor() == FUNC_FLAVOR_HOOK);
loop_over_list(*args, i)
Unref((*args)[i]);
for ( const auto& arg : *args )
Unref(arg);
return Flavor() == FUNC_FLAVOR_HOOK ? val_mgr->GetTrue() : 0;
}
@ -354,10 +355,11 @@ Val* BroFunc::Call(val_list* args, Frame* parent) const
stmt_flow_type flow = FLOW_NEXT;
Val* result = 0;
for ( size_t i = 0; i < bodies.size(); ++i )
for ( const auto& body : bodies )
{
if ( sample_logger )
sample_logger->LocationSeen(bodies[i].stmts->GetLocationInfo());
sample_logger->LocationSeen(
body.stmts->GetLocationInfo());
Unref(result);
@ -378,7 +380,7 @@ Val* BroFunc::Call(val_list* args, Frame* parent) const
try
{
result = bodies[i].stmts->Exec(f, flow);
result = body.stmts->Exec(f, flow);
}
catch ( InterpreterException& e )
@ -423,8 +425,8 @@ Val* BroFunc::Call(val_list* args, Frame* parent) const
// We have an extra Ref for each argument (so that they don't get
// deleted between bodies), release that.
loop_over_list(*args, k)
Unref((*args)[k]);
for ( const auto& arg : *args )
Unref(arg);
if ( Flavor() == FUNC_FLAVOR_HOOK )
{
@ -468,8 +470,8 @@ void BroFunc::AddBody(Stmt* new_body, id_list* new_inits, int new_frame_size,
{
// For functions, we replace the old body with the new one.
assert(bodies.size() <= 1);
for ( unsigned int i = 0; i < bodies.size(); ++i )
Unref(bodies[i].stmts);
for ( const auto& body : bodies )
Unref(body.stmts);
bodies.clear();
}
@ -516,24 +518,17 @@ Func* BroFunc::DoClone()
{
// A BroFunc could hold a closure. In this case a clone of it must
// store a copy of this closure.
if ( ! this->closure )
{
return Func::DoClone();
}
else
{
BroFunc* other = new BroFunc();
CopyStateInto(other);
other->frame_size = frame_size;
other->closure = closure->Clone();
other->closure = closure ? closure->Clone() : nullptr;
other->outer_ids = outer_ids;
return other;
}
}
broker::expected<broker::data> BroFunc::SerializeClosure() const
{
@ -636,8 +631,8 @@ Val* BuiltinFunc::Call(val_list* args, Frame* parent) const
Val* result = func(parent, args);
call_stack.pop_back();
loop_over_list(*args, i)
Unref((*args)[i]);
for ( const auto& arg : *args )
Unref(arg);
// Don't Unref() args, that's the caller's responsibility.
if ( result && g_trace_state.DoTrace() )

6
src/ID.cc
View file

@ -181,7 +181,7 @@ void ID::UpdateValAttrs()
TypeDecl* fd = rt->FieldDecl(i);
if ( ! fd->attrs )
fd->attrs = new Attributes(new attr_list, rt->FieldType(i), true);
fd->attrs = new Attributes(new attr_list, rt->FieldType(i), true, IsGlobal());
fd->attrs->AddAttr(new Attr(ATTR_LOG));
}
@ -195,7 +195,7 @@ void ID::MakeDeprecated(Expr* deprecation)
return;
attr_list* attr = new attr_list{new Attr(ATTR_DEPRECATED, deprecation)};
AddAttrs(new Attributes(attr, Type(), false));
AddAttrs(new Attributes(attr, Type(), false, IsGlobal()));
}
string ID::GetDeprecationWarning() const
@ -245,7 +245,7 @@ void ID::SetOption()
if ( ! IsRedefinable() )
{
attr_list* attr = new attr_list{new Attr(ATTR_REDEF)};
AddAttrs(new Attributes(attr, Type(), false));
AddAttrs(new Attributes(attr, Type(), false, IsGlobal()));
}
}

246
src/List.cc
View file

@ -1,246 +0,0 @@
#include "zeek-config.h"
#include <stdio.h>
#include <stdlib.h>
#include "List.h"
#include "util.h"
#define DEFAULT_LIST_SIZE 10
#define GROWTH_FACTOR 2
BaseList::BaseList(int size)
{
num_entries = 0;
if ( size <= 0 )
{
max_entries = 0;
entry = 0;
return;
}
max_entries = size;
entry = (ent *) safe_malloc(max_entries * sizeof(ent));
}
BaseList::BaseList(const BaseList& b)
{
max_entries = b.max_entries;
num_entries = b.num_entries;
if ( max_entries )
entry = (ent *) safe_malloc(max_entries * sizeof(ent));
else
entry = 0;
for ( int i = 0; i < num_entries; ++i )
entry[i] = b.entry[i];
}
BaseList::BaseList(BaseList&& b)
{
entry = b.entry;
num_entries = b.num_entries;
max_entries = b.max_entries;
b.entry = 0;
b.num_entries = b.max_entries = 0;
}
BaseList::BaseList(const ent* arr, int n)
{
num_entries = max_entries = n;
entry = (ent*) safe_malloc(max_entries * sizeof(ent));
memcpy(entry, arr, n * sizeof(ent));
}
void BaseList::sort(list_cmp_func cmp_func)
{
qsort(entry, num_entries, sizeof(ent), cmp_func);
}
BaseList& BaseList::operator=(const BaseList& b)
{
if ( this == &b )
return *this;
free(entry);
max_entries = b.max_entries;
num_entries = b.num_entries;
if ( max_entries )
entry = (ent *) safe_malloc(max_entries * sizeof(ent));
else
entry = 0;
for ( int i = 0; i < num_entries; ++i )
entry[i] = b.entry[i];
return *this;
}
BaseList& BaseList::operator=(BaseList&& b)
{
if ( this == &b )
return *this;
free(entry);
entry = b.entry;
num_entries = b.num_entries;
max_entries = b.max_entries;
b.entry = 0;
b.num_entries = b.max_entries = 0;
return *this;
}
void BaseList::insert(ent a)
{
if ( num_entries == max_entries )
resize(max_entries ? max_entries * GROWTH_FACTOR : DEFAULT_LIST_SIZE);
for ( int i = num_entries; i > 0; --i )
entry[i] = entry[i-1]; // move all pointers up one
++num_entries;
entry[0] = a;
}
#include <stdio.h>
void BaseList::sortedinsert(ent a, list_cmp_func cmp_func)
{
// We optimize for the case that the new element is
// larger than most of the current entries.
// First append element.
if ( num_entries == max_entries )
resize(max_entries ? max_entries * GROWTH_FACTOR : DEFAULT_LIST_SIZE);
entry[num_entries++] = a;
// Then move it to the correct place.
ent tmp;
for ( int i = num_entries - 1; i > 0; --i )
{
if ( cmp_func(entry[i],entry[i-1]) <= 0 )
break;
tmp = entry[i];
entry[i] = entry[i-1];
entry[i-1] = tmp;
}
}
ent BaseList::remove(ent a)
{
int i;
for ( i = 0; i < num_entries && a != entry[i]; ++i )
;
return remove_nth(i);
}
ent BaseList::remove_nth(int n)
{
if ( n < 0 || n >= num_entries )
return 0;
ent old_ent = entry[n];
--num_entries;
for ( ; n < num_entries; ++n )
entry[n] = entry[n+1];
entry[n] = 0; // for debugging
return old_ent;
}
void BaseList::append(ent a)
{
if ( num_entries == max_entries )
resize(max_entries ? max_entries * GROWTH_FACTOR : DEFAULT_LIST_SIZE);
entry[num_entries++] = a;
}
// Get and remove from the end of the list.
ent BaseList::get()
{
if ( num_entries == 0 )
return 0;
return entry[--num_entries];
}
void BaseList::clear()
{
free(entry);
entry = 0;
num_entries = max_entries = 0;
}
ent BaseList::replace(int ent_index, ent new_ent)
{
if ( ent_index < 0 )
return 0;
ent old_ent;
if ( ent_index > num_entries - 1 )
{ // replacement beyond the end of the list
resize(ent_index + 1);
for ( int i = num_entries; i < max_entries; ++i )
entry[i] = 0;
num_entries = max_entries;
old_ent = 0;
}
else
old_ent = entry[ent_index];
entry[ent_index] = new_ent;
return old_ent;
}
int BaseList::resize(int new_size)
{
if ( new_size < num_entries )
new_size = num_entries; // do not lose any entries
if ( new_size != max_entries )
{
entry = (ent*) safe_realloc((void*) entry, sizeof(ent) * new_size);
if ( entry )
max_entries = new_size;
else
max_entries = 0;
}
return max_entries;
}
ent BaseList::is_member(ent e) const
{
int i;
for ( i = 0; i < length() && e != entry[i]; ++i )
;
return (i == length()) ? 0 : e;
}
int BaseList::member_pos(ent e) const
{
int i;
for ( i = 0; i < length() && e != entry[i]; ++i )
;
return (i == length()) ? -1 : i;
}

487
src/List.h
View file

@ -20,67 +20,362 @@
// Entries must be either a pointer to the data or nonzero data with
// sizeof(data) <= sizeof(void*).
#include <initializer_list>
#include <utility>
#include <stdarg.h>
#include <initializer_list>
#include <iterator>
#include <utility>
#include <cassert>
#include "util.h"
typedef void* ent;
typedef int (*list_cmp_func)(const void* v1, const void* v2);
class BaseList {
template<typename T>
class ListIterator
{
public:
void clear(); // remove all entries
int length() const { return num_entries; }
int max() const { return max_entries; }
int resize(int = 0); // 0 => size to fit current number of entries
ListIterator(T* entries, int offset, int num_entries) :
entries(entries), offset(offset), num_entries(num_entries), endptr() {}
bool operator==(const ListIterator& rhs) { return entries == rhs.entries && offset == rhs.offset; }
bool operator!=(const ListIterator& rhs) { return entries != rhs.entries || offset != rhs.offset; }
ListIterator & operator++() { offset++; return *this; }
ListIterator operator++(int) { auto t = *this; offset++; return t; }
ListIterator & operator--() { offset--; return *this; }
ListIterator operator--(int) { auto t = *this; offset--; return t; }
std::ptrdiff_t operator-(ListIterator const& sibling) const { return offset - sibling.offset; }
ListIterator & operator+=(int amount) { offset += amount; return *this; }
ListIterator & operator-=(int amount) { offset -= amount; return *this; }
bool operator<(ListIterator const&sibling) const { return offset < sibling.offset;}
bool operator<=(ListIterator const&sibling) const { return offset <= sibling.offset; }
bool operator>(ListIterator const&sibling) const { return offset > sibling.offset; }
bool operator>=(ListIterator const&sibling) const { return offset >= sibling.offset; }
T& operator[](int index)
{
if (index < num_entries)
return entries[index];
else
return endptr;
}
T& operator*()
{
if ( offset < num_entries )
return entries[offset];
else
return endptr;
}
void sort(list_cmp_func cmp_func);
private:
T* const entries;
int offset;
int num_entries;
T endptr; // let this get set to some random value on purpose. It's only used
// for the operator[] and operator* cases where you pass something
// off the end of the collection, which is undefined behavior anyways.
};
int MemoryAllocation() const
{ return padded_sizeof(*this) + pad_size(max_entries * sizeof(ent)); }
protected:
~BaseList() { free(entry); }
explicit BaseList(int = 0);
BaseList(const BaseList&);
BaseList(BaseList&&);
BaseList(const ent* arr, int n);
namespace std {
template<typename T>
class iterator_traits<ListIterator<T> >
{
public:
using difference_type = std::ptrdiff_t;
using size_type = std::size_t;
using value_type = T;
using pointer = T*;
using reference = T&;
using iterator_category = std::random_access_iterator_tag;
};
}
BaseList& operator=(const BaseList&);
BaseList& operator=(BaseList&&);
void insert(ent); // add at head of list
template<typename T>
class List {
public:
// Assumes that the list is sorted and inserts at correct position.
void sortedinsert(ent, list_cmp_func cmp_func);
const int DEFAULT_LIST_SIZE = 10;
const int LIST_GROWTH_FACTOR = 2;
void append(ent); // add to end of list
ent remove(ent); // delete entry from list
ent remove_nth(int); // delete nth entry from list
ent get(); // return and remove ent at end of list
ent last() // return at end of list
{ return entry[num_entries-1]; }
~List() { free(entries); }
explicit List(int size = 0)
{
num_entries = 0;
// Return 0 if ent is not in the list, ent otherwise.
ent is_member(ent) const;
if ( size <= 0 )
{
max_entries = 0;
entries = nullptr;
return;
}
// Returns -1 if ent is not in the list, otherwise its position.
int member_pos(ent) const;
max_entries = size;
ent replace(int, ent); // replace entry #i with a new value
entries = (T*) safe_malloc(max_entries * sizeof(T));
}
List(const List& b)
{
max_entries = b.max_entries;
num_entries = b.num_entries;
if ( max_entries )
entries = (T*) safe_malloc(max_entries * sizeof(T));
else
entries = nullptr;
for ( int i = 0; i < num_entries; ++i )
entries[i] = b.entries[i];
}
List(List&& b)
{
entries = b.entries;
num_entries = b.num_entries;
max_entries = b.max_entries;
b.entries = nullptr;
b.num_entries = b.max_entries = 0;
}
List(const T* arr, int n)
{
num_entries = max_entries = n;
entries = (T*) safe_malloc(max_entries * sizeof(T));
memcpy(entries, arr, n * sizeof(T));
}
List(std::initializer_list<T> il) : List(il.begin(), il.size()) {}
List& operator=(const List& b)
{
if ( this == &b )
return *this;
free(entries);
max_entries = b.max_entries;
num_entries = b.num_entries;
if ( max_entries )
entries = (T *) safe_malloc(max_entries * sizeof(T));
else
entries = nullptr;
for ( int i = 0; i < num_entries; ++i )
entries[i] = b.entries[i];
return *this;
}
List& operator=(List&& b)
{
if ( this == &b )
return *this;
free(entries);
entries = b.entries;
num_entries = b.num_entries;
max_entries = b.max_entries;
b.entries = nullptr;
b.num_entries = b.max_entries = 0;
return *this;
}
// Return nth ent of list (do not remove).
ent operator[](int i) const
T& operator[](int i) const
{
#ifdef SAFE_LISTS
if ( i < 0 || i > num_entries-1 )
return 0;
else
#endif
return entry[i];
return entries[i];
}
void clear() // remove all entries
{
free(entries);
entries = nullptr;
num_entries = max_entries = 0;
}
int length() const { return num_entries; }
int max() const { return max_entries; }
int resize(int new_size = 0) // 0 => size to fit current number of entries
{
if ( new_size < num_entries )
new_size = num_entries; // do not lose any entries
if ( new_size != max_entries )
{
entries = (T*) safe_realloc((void*) entries, sizeof(T) * new_size);
if ( entries )
max_entries = new_size;
else
max_entries = 0;
}
return max_entries;
}
void sort(list_cmp_func cmp_func)
{
qsort(entries, num_entries, sizeof(T), cmp_func);
}
int MemoryAllocation() const
{ return padded_sizeof(*this) + pad_size(max_entries * sizeof(T)); }
void insert(const T& a) // add at head of list
{
if ( num_entries == max_entries )
resize(max_entries ? max_entries * LIST_GROWTH_FACTOR : DEFAULT_LIST_SIZE);
for ( int i = num_entries; i > 0; --i )
entries[i] = entries[i-1]; // move all pointers up one
++num_entries;
entries[0] = a;
}
// Assumes that the list is sorted and inserts at correct position.
void sortedinsert(const T& a, list_cmp_func cmp_func)
{
// We optimize for the case that the new element is
// larger than most of the current entries.
// First append element.
if ( num_entries == max_entries )
resize(max_entries ? max_entries * LIST_GROWTH_FACTOR : DEFAULT_LIST_SIZE);
entries[num_entries++] = a;
// Then move it to the correct place.
T tmp;
for ( int i = num_entries - 1; i > 0; --i )
{
if ( cmp_func(entries[i],entries[i-1]) <= 0 )
break;
tmp = entries[i];
entries[i] = entries[i-1];
entries[i-1] = tmp;
}
}
void push_back(const T& a) { append(a); }
void push_front(const T& a) { insert(a); }
void pop_front() { remove_nth(0); }
void pop_back() { remove_nth(num_entries-1); }
T& front() { return entries[0]; }
T& back() { return entries[num_entries-1]; }
void append(const T& a) // add to end of list
{
if ( num_entries == max_entries )
resize(max_entries ? max_entries * LIST_GROWTH_FACTOR : DEFAULT_LIST_SIZE);
entries[num_entries++] = a;
}
bool remove(const T& a) // delete entry from list
{
for ( int i = 0; i < num_entries; ++i )
{
if ( a == entries[i] )
{
remove_nth(i);
return true;
}
}
return false;
}
T remove_nth(int n) // delete nth entry from list
{
assert(n >=0 && n < num_entries);
T old_ent = entries[n];
--num_entries;
for ( ; n < num_entries; ++n )
entries[n] = entries[n+1];
return old_ent;
}
ZEEK_DEPRECATED("Remove in v3.1: Use back()/pop_back() instead")
T get() // return and remove ent at end of list
{
assert(num_entries > 0);
return entries[--num_entries];
}
ZEEK_DEPRECATED("Remove in v3.1: Use back() instead")
T& last() { return back(); }
// Return 0 if ent is not in the list, ent otherwise.
bool is_member(const T& a) const
{
int pos = member_pos(a);
return pos != -1;
}
// Returns -1 if ent is not in the list, otherwise its position.
int member_pos(const T& e) const
{
int i;
for ( i = 0; i < length() && e != entries[i]; ++i )
;
return (i == length()) ? -1 : i;
}
T replace(int ent_index, const T& new_ent) // replace entry #i with a new value
{
if ( ent_index < 0 )
return 0;
T old_ent = nullptr;
if ( ent_index > num_entries - 1 )
{ // replacement beyond the end of the list
resize(ent_index + 1);
for ( int i = num_entries; i < max_entries; ++i )
entries[i] = nullptr;
num_entries = max_entries;
}
else
old_ent = entries[ent_index];
entries[ent_index] = new_ent;
return old_ent;
}
// Type traits needed for some of the std algorithms to work
using value_type = T;
// Iterator support
using iterator = ListIterator<T>;
using const_iterator = ListIterator<const T>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
iterator begin() { return { entries, 0, num_entries }; }
iterator end() { return { entries, num_entries, num_entries }; }
const_iterator begin() const { return { entries, 0, num_entries }; }
const_iterator end() const { return { entries, num_entries, num_entries }; }
const_iterator cbegin() const { return { entries, 0, num_entries }; }
const_iterator cend() const { return { entries, num_entries, num_entries }; }
reverse_iterator rbegin() { return reverse_iterator{end()}; }
reverse_iterator rend() { return reverse_iterator{begin()}; }
const_reverse_iterator rbegin() const { return const_reverse_iterator{end()}; }
const_reverse_iterator rend() const { return const_reverse_iterator{begin()}; }
const_reverse_iterator crbegin() const { return rbegin(); }
const_reverse_iterator crend() const { return rend(); }
protected:
// This could essentially be an std::vector if we wanted. Some
// reasons to maybe not refactor to use std::vector ?
//
@ -105,120 +400,18 @@ protected:
// advantage of realloc's ability to contract in-place, it would
// allocate-and-copy.
ent* entry;
T* entries;
int max_entries;
int num_entries;
};
// List.h -- interface for class List
// Use: to get a list of pointers to class foo you should:
// 1) typedef foo* Pfoo; (the macros don't like explicit pointers)
// 2) declare(List,Pfoo); (declare an interest in lists of Pfoo's)
// 3) variables are declared like:
// List(Pfoo) bar; (bar is of type list of Pfoo's)
// For lists of "type".
#define List(type) type ## List
// For lists of pointers to "type"
#define PList(type) type ## PList
#define Listdeclare(type) \
struct List(type) : BaseList \
{ \
explicit List(type)(type ...); \
List(type)() : BaseList(0) {} \
explicit List(type)(int sz) : BaseList(sz) {} \
List(type)(const List(type)& l) : BaseList(l) {} \
List(type)(List(type)&& l) : BaseList(std::move(l)) {} \
\
List(type)& operator=(const List(type)& l) \
{ return (List(type)&) BaseList::operator=(l); } \
List(type)& operator=(List(type)&& l) \
{ return (List(type)&) BaseList::operator=(std::move(l)); } \
void insert(type a) { BaseList::insert(ent(a)); } \
void sortedinsert(type a, list_cmp_func cmp_func) \
{ BaseList::sortedinsert(ent(a), cmp_func); } \
void append(type a) { BaseList::append(ent(a)); } \
type remove(type a) \
{ return type(BaseList::remove(ent(a))); } \
type remove_nth(int n) { return type(BaseList::remove_nth(n)); }\
type get() { return type(BaseList::get()); } \
type last() { return type(BaseList::last()); } \
type replace(int i, type new_type) \
{ return type(BaseList::replace(i,ent(new_type))); } \
type is_member(type e) const \
{ return type(BaseList::is_member(ent(e))); } \
int member_pos(type e) const \
{ return BaseList::member_pos(ent(e)); } \
\
type operator[](int i) const \
{ return type(BaseList::operator[](i)); } \
}; \
#define Listimplement(type) \
List(type)::List(type)(type e1 ...) : BaseList() \
{ \
append(e1); \
va_list ap; \
va_start(ap,e1); \
for ( type e = va_arg(ap,type); e != 0; e = va_arg(ap,type) ) \
append(e); \
resize(); \
}
#define PListdeclare(type) \
struct PList(type) : BaseList \
{ \
explicit PList(type)(type* ...); \
PList(type)() : BaseList(0) {} \
explicit PList(type)(int sz) : BaseList(sz) {} \
PList(type)(const PList(type)& l) : BaseList(l) {} \
PList(type)(PList(type)&& l) : BaseList(std::move(l)) {} \
PList(type)(std::initializer_list<type*> il) : BaseList((const ent*)il.begin(), il.size()) {} \
\
PList(type)& operator=(const PList(type)& l) \
{ return (PList(type)&) BaseList::operator=(l); } \
PList(type)& operator=(PList(type)&& l) \
{ return (PList(type)&) BaseList::operator=(std::move(l)); } \
void insert(type* a) { BaseList::insert(ent(a)); } \
void sortedinsert(type* a, list_cmp_func cmp_func) \
{ BaseList::sortedinsert(ent(a), cmp_func); } \
void append(type* a) { BaseList::append(ent(a)); } \
type* remove(type* a) \
{ return (type*)BaseList::remove(ent(a)); } \
type* remove_nth(int n) { return (type*)(BaseList::remove_nth(n)); }\
type* get() { return (type*)BaseList::get(); } \
type* operator[](int i) const \
{ return (type*)(BaseList::operator[](i)); } \
type* replace(int i, type* new_type) \
{ return (type*)BaseList::replace(i,ent(new_type)); } \
type* is_member(type* e) \
{ return (type*)BaseList::is_member(ent(e)); } \
int member_pos(type* e) \
{ return BaseList::member_pos(ent(e)); } \
}; \
#define PListimplement(type) \
PList(type)::PList(type)(type* ep1 ...) : BaseList() \
{ \
append(ep1); \
va_list ap; \
va_start(ap,ep1); \
for ( type* ep = va_arg(ap,type*); ep != 0; \
ep = va_arg(ap,type*) ) \
append(ep); \
resize(); \
}
#define declare(metatype,type) metatype ## declare (type)
// Specialization of the List class to store pointers of a type.
template<typename T>
using PList = List<T*>;
// Popular type of list: list of strings.
declare(PList,char);
typedef PList(char) name_list;
typedef PList<char> name_list;
// Macro to visit each list element in turn.
#define loop_over_list(list, iterator) \

3
src/NFA.h
View file

@ -9,8 +9,7 @@
class NFA_State;
class EquivClass;
declare(PList,NFA_State);
typedef PList(NFA_State) NFA_state_list;
typedef PList<NFA_State> NFA_state_list;
#define NO_ACCEPT 0

3
src/Obj.h
View file

@ -82,7 +82,6 @@ public:
BroObj()
{
ref_cnt = 1;
in_ser_cache = false;
notify_plugins = false;
// A bit of a hack. We'd like to associate location
@ -156,8 +155,6 @@ public:
~SuppressErrors() { --BroObj::suppress_errors; }
};
bool in_ser_cache;
protected:
Location* location; // all that matters in real estate

9
src/OpaqueVal.cc
View file

@ -233,9 +233,8 @@ void MD5Val::digest(val_list& vlist, u_char result[MD5_DIGEST_LENGTH])
{
EVP_MD_CTX* h = hash_init(Hash_MD5);
loop_over_list(vlist, i)
for ( const auto& v : vlist )
{
Val* v = vlist[i];
if ( v->Type()->Tag() == TYPE_STRING )
{
const BroString* str = v->AsString();
@ -385,9 +384,8 @@ void SHA1Val::digest(val_list& vlist, u_char result[SHA_DIGEST_LENGTH])
{
EVP_MD_CTX* h = hash_init(Hash_SHA1);
loop_over_list(vlist, i)
for ( const auto& v : vlist )
{
Val* v = vlist[i];
if ( v->Type()->Tag() == TYPE_STRING )
{
const BroString* str = v->AsString();
@ -529,9 +527,8 @@ void SHA256Val::digest(val_list& vlist, u_char result[SHA256_DIGEST_LENGTH])
{
EVP_MD_CTX* h = hash_init(Hash_SHA256);
loop_over_list(vlist, i)
for ( const auto& v : vlist )
{
Val* v = vlist[i];
if ( v->Type()->Tag() == TYPE_STRING )
{
const BroString* str = v->AsString();

137
src/Queue.cc
View file

@ -1,137 +0,0 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include "zeek-config.h"
#include <string.h>
#include "Queue.h"
BaseQueue::BaseQueue(int size)
{
const int DEFAULT_CHUNK_SIZE = 10;
chunk_size = DEFAULT_CHUNK_SIZE;
head = tail = num_entries = 0;
if ( size < 0 )
{
entry = new ent[1];
max_entries = 0;
}
else
{
if ( (entry = new ent[chunk_size+1]) )
max_entries = chunk_size;
else
{
entry = new ent[1];
max_entries = 0;
}
}
}
void BaseQueue::push_front(ent a)
{
if ( num_entries == max_entries )
{
resize(max_entries+chunk_size); // make more room
chunk_size *= 2;
}
++num_entries;
if ( head )
entry[--head] = a;
else
{
head = max_entries;
entry[head] = a;
}
}
void BaseQueue::push_back(ent a)
{
if ( num_entries == max_entries )
{
resize(max_entries+chunk_size); // make more room
chunk_size *= 2;
}
++num_entries;
if ( tail < max_entries )
entry[tail++] = a;
else
{
entry[tail] = a;
tail = 0;
}
}
ent BaseQueue::pop_front()
{
if ( ! num_entries )
return 0;
--num_entries;
if ( head < max_entries )
return entry[head++];
else
{
head = 0;
return entry[max_entries];
}
}
ent BaseQueue::pop_back()
{
if ( ! num_entries )
return 0;
--num_entries;
if ( tail )
return entry[--tail];
else
{
tail = max_entries;
return entry[tail];
}
}
int BaseQueue::resize(int new_size)
{
if ( new_size < num_entries )
new_size = num_entries; // do not lose any entries
if ( new_size != max_entries )
{
// Note, allocate extra space, so that we can always
// use the [max_entries] element.
// ### Yin, why not use realloc()?
ent* new_entry = new ent[new_size+1];
if ( new_entry )
{
if ( head <= tail )
memcpy( new_entry, entry + head,
sizeof(ent) * num_entries );
else
{
int len = num_entries - tail;
memcpy( new_entry, entry + head,
sizeof(ent) * len );
memcpy( new_entry + len, entry,
sizeof(ent) * tail );
}
delete [] entry;
entry = new_entry;
max_entries = new_size;
head = 0;
tail = num_entries;
}
else
{ // out of memory
}
}
return max_entries;
}

265
src/Queue.h
View file

@ -3,8 +3,8 @@
#ifndef queue_h
#define queue_h
// BaseQueue.h --
// Interface for class BaseQueue, current implementation is as an
// Queue.h --
// Interface for class Queue, current implementation is as an
// array of ent's. This implementation was chosen to optimize
// getting to the ent's rather than inserting and deleting.
// Also push's and pop's from the front or the end of the queue
@ -21,35 +21,214 @@
// Entries must be either a pointer to the data or nonzero data with
// sizeof(data) <= sizeof(void*).
#include "List.h"
class BaseQueue {
template<typename T>
class QueueIterator
{
T* const entries;
int offset;
int num_entries;
public:
~BaseQueue() { delete[] entry; }
QueueIterator(T* entries, int offset, int num_entries) :
entries(entries), offset(offset), num_entries(num_entries) {}
bool operator==(const QueueIterator& rhs) { return entries == rhs.entries && offset == rhs.offset; }
bool operator!=(const QueueIterator& rhs) { return entries != rhs.entries || offset != rhs.offset; }
QueueIterator & operator++() { offset++; return *this; }
QueueIterator operator++(int) { auto t = *this; offset++; return t; }
QueueIterator & operator--() { offset--; return *this; }
QueueIterator operator--(int) { auto t = *this; offset--; return t; }
std::ptrdiff_t operator-(QueueIterator const& sibling) const { return offset - sibling.offset; }
QueueIterator & operator+=(int amount) { offset += amount; return *this; }
QueueIterator & operator-=(int amount) { offset -= amount; return *this; }
bool operator<(QueueIterator const&sibling) const { return offset < sibling.offset;}
bool operator<=(QueueIterator const&sibling) const { return offset <= sibling.offset; }
bool operator>(QueueIterator const&sibling) const { return offset > sibling.offset; }
bool operator>=(QueueIterator const&sibling) const { return offset >= sibling.offset; }
T& operator[](int index)
{
return entries[index];
}
T& operator*()
{
return entries[offset];
}
};
namespace std {
template<typename T>
class iterator_traits<QueueIterator<T> >
{
public:
using difference_type = std::ptrdiff_t;
using size_type = std::size_t;
using value_type = T;
using pointer = T*;
using reference = T&;
using iterator_category = std::random_access_iterator_tag;
};
}
template<typename T>
class Queue {
public:
explicit Queue(int size = 0)
{
const int DEFAULT_CHUNK_SIZE = 10;
chunk_size = DEFAULT_CHUNK_SIZE;
head = tail = num_entries = 0;
if ( size < 0 )
{
entries = new T[1];
max_entries = 0;
}
else
{
if ( (entries = new T[chunk_size+1]) )
max_entries = chunk_size;
else
{
entries = new T[1];
max_entries = 0;
}
}
}
~Queue() { delete[] entries; }
int length() const { return num_entries; }
int resize(int = 0); // 0 => size to fit current number of entries
int resize(int new_size = 0) // 0 => size to fit current number of entries
{
if ( new_size < num_entries )
new_size = num_entries; // do not lose any entries
if ( new_size != max_entries )
{
// Note, allocate extra space, so that we can always
// use the [max_entries] element.
// ### Yin, why not use realloc()?
T* new_entries = new T[new_size+1];
if ( new_entries )
{
if ( head <= tail )
memcpy( new_entries, entries + head,
sizeof(T) * num_entries );
else
{
int len = num_entries - tail;
memcpy( new_entries, entries + head,
sizeof(T) * len );
memcpy( new_entries + len, entries,
sizeof(T) * tail );
}
delete [] entries;
entries = new_entries;
max_entries = new_size;
head = 0;
tail = num_entries;
}
else
{ // out of memory
}
}
return max_entries;
}
// remove all entries without delete[] entry
void clear() { head = tail = num_entries = 0; }
// helper functions for iterating over queue
int front() const { return head; }
int back() const { return tail; }
void incr(int& index) { index < max_entries ? ++index : index = 0; }
T& front() { return entries[head]; }
T& back() { return entries[tail]; }
const T& front() const { return entries[head]; }
const T& back() const { return entries[tail]; }
protected:
explicit BaseQueue(int = 0);
void push_front(const T& a) // add in front of queue
{
if ( num_entries == max_entries )
{
resize(max_entries+chunk_size); // make more room
chunk_size *= 2;
}
void push_front(ent); // add in front of queue
void push_back(ent); // add at end of queue
ent pop_front(); // return and remove the front of queue
ent pop_back(); // return and remove the end of queue
++num_entries;
if ( head )
entries[--head] = a;
else
{
head = max_entries;
entries[head] = a;
}
}
void push_back(const T& a) // add at end of queue
{
if ( num_entries == max_entries )
{
resize(max_entries+chunk_size); // make more room
chunk_size *= 2;
}
++num_entries;
if ( tail < max_entries )
entries[tail++] = a;
else
{
entries[tail] = a;
tail = 0;
}
}
void pop_front()
{
--num_entries;
if ( head < max_entries )
head++;
else
head = 0;
}
void pop_back()
{
--num_entries;
if ( tail )
--tail;
else
tail = max_entries;
}
// return nth *PHYSICAL* entry of queue (do not remove)
ent operator[](int i) const { return entry[i]; }
T& operator[](int i) const { return entries[i]; }
ent* entry;
// Type traits needed for some of the std algorithms to work
using value_type = T;
// Iterator support
using iterator = QueueIterator<T>;
using const_iterator = QueueIterator<const T>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
iterator begin() { return { entries, 0, num_entries }; }
iterator end() { return { entries, num_entries, num_entries }; }
const_iterator begin() const { return { entries, 0, num_entries }; }
const_iterator end() const { return { entries, num_entries, num_entries }; }
const_iterator cbegin() const { return { entries, 0, num_entries }; }
const_iterator cend() const { return { entries, num_entries, num_entries }; }
reverse_iterator rbegin() { return reverse_iterator{end()}; }
reverse_iterator rend() { return reverse_iterator{begin()}; }
const_reverse_iterator rbegin() const { return const_reverse_iterator{end()}; }
const_reverse_iterator rend() const { return const_reverse_iterator{begin()}; }
const_reverse_iterator crbegin() const { return rbegin(); }
const_reverse_iterator crend() const { return rend(); }
protected:
T* entries;
int chunk_size; // increase size by this amount when necessary
int max_entries; // entry's index range: 0 .. max_entries
int num_entries;
@ -57,54 +236,8 @@ protected:
int tail; // just beyond the end of the queue in the ring
};
// Queue.h -- interface for class Queue
// Use: to get a list of pointers to class foo you should:
// 1) declare(PQueue,foo); (declare interest in lists of foo*'s)
// 2) variables are declared like:
// PQueue(foo) bar; (bar is of type list of foo*'s)
// For queues of "type"
#define Queue(type) type ## Queue
// For queues of pointers to "type"
#define PQueue(type) type ## PQueue
#define Queuedeclare(type) \
struct Queue(type) : BaseQueue \
{ \
Queue(type)() : BaseQueue(0) {} \
explicit Queue(type)(int sz) : BaseQueue(sz) {} \
\
void push_front(type a) { BaseQueue::push_front(ent(a)); } \
void push_back(type a) { BaseQueue::push_back(ent(a)); } \
type pop_front() { return type(BaseQueue::pop_front()); }\
type pop_back() { return type(BaseQueue::pop_back()); } \
\
type operator[](int i) const \
{ return type(BaseQueue::operator[](i)); } \
}; \
#define PQueuedeclare(type) \
struct PQueue(type) : BaseQueue \
{ \
PQueue(type)() : BaseQueue(0) {} \
explicit PQueue(type)(int sz) : BaseQueue(sz) {} \
\
void push_front(type* a){ BaseQueue::push_front(ent(a)); } \
void push_back(type* a) { BaseQueue::push_back(ent(a)); } \
type* pop_front() \
{ return (type*)BaseQueue::pop_front(); } \
type* pop_back() \
{ return (type*)BaseQueue::pop_back(); } \
\
type* operator[](int i) const \
{ return (type*)BaseQueue::operator[](i); } \
}; \
// Macro to visit each queue element in turn.
#define loop_over_queue(queue, iterator) \
int iterator; \
for ( iterator = (queue).front(); iterator != (queue).back(); \
(queue).incr(iterator) ) \
template<typename T>
using PQueue = Queue<T*>;
#endif /* queue_h */

2
src/RE.cc
View file

@ -149,7 +149,7 @@ int Specific_RE_Matcher::Compile(int lazy)
int Specific_RE_Matcher::CompileSet(const string_list& set, const int_list& idx)
{
if ( set.length() != idx.length() )
if ( (size_t)set.length() != idx.size() )
reporter->InternalError("compileset: lengths of sets differ");
rem = this;

10
src/RE.h
View file

@ -22,10 +22,6 @@ class Specific_RE_Matcher;
class RE_Matcher;
class DFA_State;
declare(PDict,char);
declare(PDict,CCL);
declare(PList,CCL);
extern int case_insensitive;
extern CCL* curr_ccl;
extern NFA_Machine* nfa;
@ -123,9 +119,9 @@ protected:
int multiline;
char* pattern_text;
PDict(char) defs;
PDict(CCL) ccl_dict;
PList(CCL) ccl_list;
PDict<char> defs;
PDict<CCL> ccl_dict;
PList<CCL> ccl_list;
EquivClass equiv_class;
int* ecs;
DFA_Machine* dfa;

9
src/Reporter.cc
View file

@ -502,10 +502,7 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out,
vl.append(conn->BuildConnVal());
if ( addl )
{
loop_over_list(*addl, i)
vl.append((*addl)[i]);
}
std::copy(addl->begin(), addl->end(), std::back_inserter(vl));
if ( conn )
conn->ConnectionEventFast(event, 0, std::move(vl));
@ -516,8 +513,8 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out,
{
if ( addl )
{
loop_over_list(*addl, i)
Unref((*addl)[i]);
for ( const auto& av : *addl )
Unref(av);
}
}

41
src/Rule.cc
View file

@ -13,25 +13,25 @@ Rule::~Rule()
{
delete [] id;
loop_over_list(patterns, i)
for ( const auto& p : patterns )
{
delete [] patterns[i]->pattern;
delete patterns[i];
delete [] p->pattern;
delete p;
}
loop_over_list(hdr_tests, j)
delete hdr_tests[j];
for ( const auto& test : hdr_tests )
delete test;
loop_over_list(conditions, k)
delete conditions[k];
for ( const auto& cond : conditions )
delete cond;
loop_over_list(actions, l)
delete actions[l];
for ( const auto& action : actions )
delete action;
loop_over_list(preconds, m)
for ( const auto& prec : preconds )
{
delete [] preconds[m]->id;
delete preconds[m];
delete [] prec->id;
delete prec;
}
}
@ -49,21 +49,20 @@ void Rule::PrintDebug()
{
fprintf(stderr, "Rule %s (%d) %s\n", id, idx, active ? "[active]" : "[disabled]");
loop_over_list(patterns, i)
for ( const auto& p : patterns )
{
fprintf(stderr, " %-8s |%s| (%d) \n",
TypeToString(patterns[i]->type), patterns[i]->pattern,
patterns[i]->id);
TypeToString(p->type), p->pattern, p->id);
}
loop_over_list(hdr_tests, j)
hdr_tests[j]->PrintDebug();
for ( const auto& h : hdr_tests )
h->PrintDebug();
loop_over_list(conditions, k)
conditions[k]->PrintDebug();
for ( const auto& c : conditions )
c->PrintDebug();
loop_over_list(actions, l)
actions[l]->PrintDebug();
for ( const auto& a : actions )
a->PrintDebug();
fputs("\n", stderr);
}

24
src/Rule.h
View file

@ -14,11 +14,8 @@ class RuleHdrTest;
class Rule;
declare(PList, Rule);
typedef PList(Rule) rule_list;
declare(PDict, Rule);
typedef PDict(Rule) rule_dict;
typedef PList<Rule> rule_list;
typedef PDict<Rule> rule_dict;
class Rule {
public:
@ -61,14 +58,9 @@ private:
void SortHdrTests();
declare(PList, RuleAction);
typedef PList(RuleAction) rule_action_list;
declare(PList, RuleCondition);
typedef PList(RuleCondition) rule_condition_list;
declare(PList, RuleHdrTest);
typedef PList(RuleHdrTest) rule_hdr_test_list;
typedef PList<RuleAction> rule_action_list;
typedef PList<RuleCondition> rule_condition_list;
typedef PList<RuleHdrTest> rule_hdr_test_list;
rule_hdr_test_list hdr_tests;
rule_condition_list conditions;
@ -82,8 +74,7 @@ private:
bool negate; // negate test
};
declare(PList, Precond);
typedef PList(Precond) precond_list;
typedef PList<Precond> precond_list;
precond_list preconds;
rule_list dependents; // rules w/ us as a precondition
@ -101,8 +92,7 @@ private:
uint32 depth;
};
declare(PList, Pattern);
typedef PList(Pattern) pattern_list;
typedef PList<Pattern> pattern_list;
pattern_list patterns;
Rule* next; // Linkage within RuleHdrTest tree:

183
src/RuleMatcher.cc
View file

@ -25,6 +25,11 @@
uint32 RuleHdrTest::idcounter = 0;
static bool is_member_of(const int_list& l, int_list::value_type v)
{
return std::find(l.begin(), l.end(), v) != l.end();
}
RuleHdrTest::RuleHdrTest(Prot arg_prot, uint32 arg_offset, uint32 arg_size,
Comp arg_comp, maskedvalue_list* arg_vals)
{
@ -78,21 +83,20 @@ RuleHdrTest::RuleHdrTest(RuleHdrTest& h)
comp = h.comp;
vals = new maskedvalue_list;
loop_over_list(*h.vals, i)
vals->append(new MaskedValue(*(*h.vals)[i]));
for ( const auto& val : *h.vals )
vals->append(new MaskedValue(*val));
prefix_vals = h.prefix_vals;
for ( int j = 0; j < Rule::TYPES; ++j )
{
loop_over_list(h.psets[j], k)
for ( PatternSet* orig_set : h.psets[j] )
{
PatternSet* orig_set = h.psets[j][k];
PatternSet* copied_set = new PatternSet;
copied_set->re = 0;
copied_set->ids = orig_set->ids;
loop_over_list(orig_set->patterns, l)
copied_set->patterns.append(copy_string(orig_set->patterns[l]));
for ( const auto& pattern : orig_set->patterns )
copied_set->patterns.append(copy_string(pattern));
delete copied_set;
// TODO: Why do we create copied_set only to then
// never use it?
@ -110,14 +114,14 @@ RuleHdrTest::RuleHdrTest(RuleHdrTest& h)
RuleHdrTest::~RuleHdrTest()
{
loop_over_list(*vals, i)
delete (*vals)[i];
for ( auto val : *vals )
delete val;
delete vals;
for ( int i = 0; i < Rule::TYPES; ++i )
{
loop_over_list(psets[i], j)
delete psets[i][j]->re;
for ( auto pset : psets[i] )
delete pset->re;
}
delete ruleset;
@ -149,12 +153,12 @@ void RuleHdrTest::PrintDebug()
fprintf(stderr, " RuleHdrTest %s[%d:%d] %s",
str_prot[prot], offset, size, str_comp[comp]);
loop_over_list(*vals, i)
for ( const auto& val : *vals )
fprintf(stderr, " 0x%08x/0x%08x",
(*vals)[i]->val, (*vals)[i]->mask);
val->val, val->mask);
for ( size_t i = 0; i < prefix_vals.size(); ++i )
fprintf(stderr, " %s", prefix_vals[i].AsString().c_str());
for ( const auto& prefix : prefix_vals )
fprintf(stderr, " %s", prefix.AsString().c_str());
fprintf(stderr, "\n");
}
@ -176,22 +180,22 @@ RuleEndpointState::RuleEndpointState(analyzer::Analyzer* arg_analyzer, bool arg_
RuleEndpointState::~RuleEndpointState()
{
loop_over_list(matchers, i)
for ( auto matcher : matchers )
{
delete matchers[i]->state;
delete matchers[i];
delete matcher->state;
delete matcher;
}
loop_over_list(matched_text, j)
delete matched_text[j];
for ( auto text : matched_text )
delete text;
}
RuleFileMagicState::~RuleFileMagicState()
{
loop_over_list(matchers, i)
for ( auto matcher : matchers )
{
delete matchers[i]->state;
delete matchers[i];
delete matcher->state;
delete matcher;
}
}
@ -209,8 +213,8 @@ RuleMatcher::~RuleMatcher()
#endif
Delete(root);
loop_over_list(rules, i)
delete rules[i];
for ( auto rule : rules )
delete rule;
}
void RuleMatcher::Delete(RuleHdrTest* node)
@ -275,13 +279,13 @@ void RuleMatcher::AddRule(Rule* rule)
void RuleMatcher::BuildRulesTree()
{
loop_over_list(rules, r)
for ( const auto& rule : rules )
{
if ( ! rules[r]->Active() )
if ( ! rule->Active() )
continue;
rules[r]->SortHdrTests();
InsertRuleIntoTree(rules[r], 0, root, 0);
rule->SortHdrTests();
InsertRuleIntoTree(rule, 0, root, 0);
}
}
@ -289,10 +293,8 @@ void RuleMatcher::InsertRuleIntoTree(Rule* r, int testnr,
RuleHdrTest* dest, int level)
{
// Initiliaze the preconditions
loop_over_list(r->preconds, i)
for ( const auto& pc : r->preconds )
{
Rule::Precond* pc = r->preconds[i];
Rule* pc_rule = rules_by_id.Lookup(pc->id);
if ( ! pc_rule )
{
@ -345,11 +347,10 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs,
// For each type, get all patterns on this node.
for ( Rule* r = hdr_test->pattern_rules; r; r = r->next )
{
loop_over_list(r->patterns, j)
for ( const auto& p : r->patterns )
{
Rule::Pattern* p = r->patterns[j];
exprs[p->type].append(p->pattern);
ids[p->type].append(p->id);
ids[p->type].push_back(p->id);
}
}
@ -374,7 +375,7 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs,
loop_over_list(child_exprs[i], j)
{
exprs[i].append(child_exprs[i][j]);
ids[i].append(child_ids[i][j]);
ids[i].push_back(child_ids[i][j]);
}
}
}
@ -394,7 +395,7 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs,
void RuleMatcher::BuildPatternSets(RuleHdrTest::pattern_set_list* dst,
const string_list& exprs, const int_list& ids)
{
assert(exprs.length() == ids.length());
assert(static_cast<size_t>(exprs.length()) == ids.size());
// We build groups of at most sig_max_group_size regexps.
@ -406,7 +407,7 @@ void RuleMatcher::BuildPatternSets(RuleHdrTest::pattern_set_list* dst,
if ( i < exprs.length() )
{
group_exprs.append(exprs[i]);
group_ids.append(ids[i]);
group_ids.push_back(ids[i]);
}
if ( group_exprs.length() > sig_max_group_size ||
@ -452,9 +453,10 @@ static inline uint32 getval(const u_char* data, int size)
template <typename FuncT>
static inline bool match_or(const maskedvalue_list& mvals, uint32 v, FuncT comp)
{
loop_over_list(mvals, i)
// TODO: this could be a find_if
for ( const auto& val : mvals )
{
if ( comp(v & mvals[i]->mask, mvals[i]->val) )
if ( comp(v & val->mask, val->val) )
return true;
}
return false;
@ -480,9 +482,10 @@ template <typename FuncT>
static inline bool match_not_and(const maskedvalue_list& mvals, uint32 v,
FuncT comp)
{
loop_over_list(mvals, i)
// TODO: this could be a find_if
for ( const auto& val : mvals )
{
if ( comp(v & mvals[i]->mask, mvals[i]->val) )
if ( comp(v & val->mask, val->val) )
return false;
}
return true;
@ -577,9 +580,8 @@ RuleFileMagicState* RuleMatcher::InitFileMagic() const
{
RuleFileMagicState* state = new RuleFileMagicState();
loop_over_list(root->psets[Rule::FILE_MAGIC], i)
for ( const auto& set : root->psets[Rule::FILE_MAGIC] )
{
RuleHdrTest::PatternSet* set = root->psets[Rule::FILE_MAGIC][i];
assert(set->re);
RuleFileMagicState::Matcher* m = new RuleFileMagicState::Matcher;
m->state = new RE_Match_State(set->re);
@ -597,13 +599,13 @@ bool RuleMatcher::AllRulePatternsMatched(const Rule* r, MatchPos matchpos,
DBG_LOG(DBG_RULES, "Checking rule: %s", r->id);
// Check whether all patterns of the rule have matched.
loop_over_list(r->patterns, j)
for ( const auto& pattern : r->patterns )
{
if ( ams.find(r->patterns[j]->id) == ams.end() )
if ( ams.find(pattern->id) == ams.end() )
return false;
// See if depth is satisfied.
if ( matchpos > r->patterns[j]->offset + r->patterns[j]->depth )
if ( matchpos > pattern->offset + pattern->depth )
return false;
// FIXME: How to check for offset ??? ###
@ -640,10 +642,8 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state,
bool newmatch = false;
loop_over_list(state->matchers, x)
for ( const auto& m : state->matchers )
{
RuleFileMagicState::Matcher* m = state->matchers[x];
if ( m->state->Match(data, len, true, false, true) )
newmatch = true;
}
@ -655,9 +655,8 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state,
AcceptingMatchSet accepted_matches;
loop_over_list(state->matchers, y)
for ( const auto& m : state->matchers )
{
RuleFileMagicState::Matcher* m = state->matchers[y];
const AcceptingMatchSet& ams = m->state->AcceptedMatches();
accepted_matches.insert(ams.begin(), ams.end());
}
@ -682,10 +681,10 @@ RuleMatcher::MIME_Matches* RuleMatcher::Match(RuleFileMagicState* state,
{
Rule* r = *it;
loop_over_list(r->actions, rai)
for ( const auto& action : r->actions )
{
const RuleActionMIME* ram =
dynamic_cast<const RuleActionMIME*>(r->actions[rai]);
dynamic_cast<const RuleActionMIME*>(action);
if ( ! ram )
continue;
@ -734,11 +733,8 @@ RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer,
{
for ( int i = 0; i < Rule::TYPES; ++i )
{
loop_over_list(hdr_test->psets[i], j)
for ( const auto& set : hdr_test->psets[i] )
{
RuleHdrTest::PatternSet* set =
hdr_test->psets[i][j];
assert(set->re);
RuleEndpointState::Matcher* m =
@ -855,9 +851,8 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
}
// Feed data into all relevant matchers.
loop_over_list(state->matchers, x)
for ( const auto& m : state->matchers )
{
RuleEndpointState::Matcher* m = state->matchers[x];
if ( m->type == type &&
m->state->Match((const u_char*) data, data_len,
bol, eol, clear) )
@ -872,9 +867,8 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
AcceptingMatchSet accepted_matches;
loop_over_list(state->matchers, y )
for ( const auto& m : state->matchers )
{
RuleEndpointState::Matcher* m = state->matchers[y];
const AcceptingMatchSet& ams = m->state->AcceptedMatches();
accepted_matches.insert(ams.begin(), ams.end());
}
@ -907,10 +901,8 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
DBG_LOG(DBG_RULES, "Accepted rule: %s", r->id);
loop_over_list(state->hdr_tests, k)
for ( const auto& h : state->hdr_tests )
{
RuleHdrTest* h = state->hdr_tests[k];
DBG_LOG(DBG_RULES, "Checking for accepted rule on HdrTest %d", h->id);
// Skip if rule does not belong to this node.
@ -920,7 +912,7 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
DBG_LOG(DBG_RULES, "On current node");
// Skip if rule already fired for this connection.
if ( state->matched_rules.is_member(r->Index()) )
if ( is_member_of(state->matched_rules, r->Index()) )
continue;
// Remember that all patterns have matched.
@ -960,9 +952,8 @@ void RuleMatcher::FinishEndpoint(RuleEndpointState* state)
void RuleMatcher::ExecPureRules(RuleEndpointState* state, bool eos)
{
loop_over_list(state->hdr_tests, i)
for ( const auto& hdr_test : state->hdr_tests )
{
RuleHdrTest* hdr_test = state->hdr_tests[i];
for ( Rule* r = hdr_test->pure_rules; r; r = r->next )
ExecRulePurely(r, 0, state, eos);
}
@ -971,7 +962,7 @@ void RuleMatcher::ExecPureRules(RuleEndpointState* state, bool eos)
bool RuleMatcher::ExecRulePurely(Rule* r, BroString* s,
RuleEndpointState* state, bool eos)
{
if ( state->matched_rules.is_member(r->Index()) )
if ( is_member_of(state->matched_rules, r->Index()) )
return false;
DBG_LOG(DBG_RULES, "Checking rule %s purely", r->ID());
@ -997,10 +988,8 @@ bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state,
DBG_LOG(DBG_RULES, "Evaluating conditions for rule %s", r->ID());
// Check for other rules which have to match first.
loop_over_list(r->preconds, i)
for ( const auto& pc : r->preconds )
{
Rule::Precond* pc = r->preconds[i];
RuleEndpointState* pc_state = state;
if ( pc->opposite_dir )
@ -1014,7 +1003,7 @@ bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state,
if ( ! pc->negate )
{
if ( ! pc_state->matched_rules.is_member(pc->rule->Index()) )
if ( ! is_member_of(pc_state->matched_rules, pc->rule->Index()) )
// Precond rule has not matched yet.
return false;
}
@ -1024,13 +1013,13 @@ bool RuleMatcher::EvalRuleConditions(Rule* r, RuleEndpointState* state,
if ( ! eos )
return false;
if ( pc_state->matched_rules.is_member(pc->rule->Index()) )
if ( is_member_of(pc_state->matched_rules, pc->rule->Index()) )
return false;
}
}
loop_over_list(r->conditions, l)
if ( ! r->conditions[l]->DoMatch(r, state, data, len) )
for ( const auto& cond : r->conditions )
if ( ! cond->DoMatch(r, state, data, len) )
return false;
DBG_LOG(DBG_RULES, "Conditions met: MATCH! %s", r->ID());
@ -1041,19 +1030,18 @@ void RuleMatcher::ExecRuleActions(Rule* r, RuleEndpointState* state,
const u_char* data, int len, bool eos)
{
if ( state->opposite &&
state->opposite->matched_rules.is_member(r->Index()) )
is_member_of(state->opposite->matched_rules, r->Index()) )
// We have already executed the actions.
return;
state->matched_rules.append(r->Index());
state->matched_rules.push_back(r->Index());
loop_over_list(r->actions, i)
r->actions[i]->DoAction(r, state, data, len);
for ( const auto& action : r->actions )
action->DoAction(r, state, data, len);
// This rule may trigger some other rules; check them.
loop_over_list(r->dependents, j)
for ( const auto& dep : r->dependents )
{
Rule* dep = (r->dependents)[j];
ExecRule(dep, state, eos);
if ( state->opposite )
ExecRule(dep, state->opposite, eos);
@ -1063,13 +1051,11 @@ void RuleMatcher::ExecRuleActions(Rule* r, RuleEndpointState* state,
void RuleMatcher::ExecRule(Rule* rule, RuleEndpointState* state, bool eos)
{
// Nothing to do if it has already matched.
if ( state->matched_rules.is_member(rule->Index()) )
if ( is_member_of(state->matched_rules, rule->Index()) )
return;
loop_over_list(state->hdr_tests, i)
for ( const auto& h : state->hdr_tests )
{
RuleHdrTest* h = state->hdr_tests[i];
// Is it on this HdrTest at all?
if ( ! h->ruleset->Contains(rule->Index()) )
continue;
@ -1099,20 +1085,20 @@ void RuleMatcher::ClearEndpointState(RuleEndpointState* state)
state->payload_size = -1;
loop_over_list(state->matchers, j)
state->matchers[j]->state->Clear();
for ( const auto& matcher : state->matchers )
matcher->state->Clear();
}
void RuleMatcher::ClearFileMagicState(RuleFileMagicState* state) const
{
loop_over_list(state->matchers, j)
state->matchers[j]->state->Clear();
for ( const auto& matcher : state->matchers )
matcher->state->Clear();
}
void RuleMatcher::PrintDebug()
{
loop_over_list(rules, i)
rules[i]->PrintDebug();
for ( const auto& rule : rules )
rule->PrintDebug();
fprintf(stderr, "\n---------------\n");
@ -1135,10 +1121,10 @@ void RuleMatcher::PrintTreeDebug(RuleHdrTest* node)
RuleHdrTest::PatternSet* set = node->psets[i][j];
fprintf(stderr,
"[%d patterns in %s group %d from %d rules]\n",
"[%d patterns in %s group %d from %zu rules]\n",
set->patterns.length(),
Rule::TypeToString((Rule::PatternType) i), j,
set->ids.length());
set->ids.size());
}
}
@ -1182,9 +1168,8 @@ void RuleMatcher::GetStats(Stats* stats, RuleHdrTest* hdr_test)
for ( int i = 0; i < Rule::TYPES; ++i )
{
loop_over_list(hdr_test->psets[i], j)
for ( const auto& set : hdr_test->psets[i] )
{
RuleHdrTest::PatternSet* set = hdr_test->psets[i][j];
assert(set->re);
++stats->matchers;
@ -1234,9 +1219,9 @@ void RuleMatcher::DumpStateStats(BroFile* f, RuleHdrTest* hdr_test)
set->re->DFA()->NumStates(),
Rule::TypeToString((Rule::PatternType)i), j));
loop_over_list(set->ids, k)
for ( const auto& id : set->ids )
{
Rule* r = Rule::rule_table[set->ids[k] - 1];
Rule* r = Rule::rule_table[id - 1];
f->Write(fmt("%s ", r->ID()));
}
@ -1345,8 +1330,8 @@ void id_to_maskedvallist(const char* id, maskedvalue_list* append_to,
{
ListVal* lv = v->AsTableVal()->ConvertToPureList();
val_list* vals = lv->Vals();
loop_over_list(*vals, i )
if ( ! val_to_maskedval((*vals)[i], append_to, prefix_vector) )
for ( const auto& val : *vals )
if ( ! val_to_maskedval(val, append_to, prefix_vector) )
{
Unref(lv);
return;

22
src/RuleMatcher.h
View file

@ -56,13 +56,9 @@ struct MaskedValue {
uint32 mask;
};
declare(PList, MaskedValue);
typedef PList(MaskedValue) maskedvalue_list;
typedef PList(char) string_list;
declare(PList, BroString);
typedef PList(BroString) bstr_list;
typedef PList<MaskedValue> maskedvalue_list;
typedef PList<char> string_list;
typedef PList<BroString> bstr_list;
// Get values from Bro's script-level variables.
extern void id_to_maskedvallist(const char* id, maskedvalue_list* append_to,
@ -119,8 +115,7 @@ private:
int_list ids; // (only needed for debugging)
};
declare(PList, PatternSet);
typedef PList(PatternSet) pattern_set_list;
typedef PList<PatternSet> pattern_set_list;
pattern_set_list psets[Rule::TYPES];
// List of rules belonging to this node.
@ -136,8 +131,7 @@ private:
int level; // level within the tree
};
declare(PList, RuleHdrTest);
typedef PList(RuleHdrTest) rule_hdr_test_list;
typedef PList<RuleHdrTest> rule_hdr_test_list;
// RuleEndpointState keeps the per-stream matching state of one
// connection endpoint.
@ -172,8 +166,7 @@ private:
Rule::PatternType type;
};
declare(PList, Matcher);
typedef PList(Matcher) matcher_list;
typedef PList<Matcher> matcher_list;
bool is_orig;
analyzer::Analyzer* analyzer;
@ -212,8 +205,7 @@ private:
RE_Match_State* state;
};
declare(PList, Matcher);
typedef PList(Matcher) matcher_list;
typedef PList<Matcher> matcher_list;
matcher_list matchers;
};

11
src/Scope.cc
View file

@ -7,8 +7,7 @@
#include "Scope.h"
#include "Reporter.h"
declare(PList,Scope);
typedef PList(Scope) scope_list;
typedef PList<Scope> scope_list;
static scope_list scopes;
static Scope* top_scope;
@ -20,7 +19,7 @@ Scope::Scope(ID* id, attr_list* al)
attrs = al;
return_type = 0;
local = new PDict(ID)(ORDERED);
local = new PDict<ID>(ORDERED);
inits = new id_list;
if ( id )
@ -48,8 +47,8 @@ Scope::~Scope()
if ( attrs )
{
loop_over_list(*attrs, i)
Unref((*attrs)[i]);
for ( const auto& attr : *attrs )
Unref(attr);
delete attrs;
}
@ -109,7 +108,7 @@ void Scope::Describe(ODesc* d) const
TraversalCode Scope::Traverse(TraversalCallback* cb) const
{
PDict(ID)* ids = GetIDs();
PDict<ID>* ids = GetIDs();
IterCookie* iter = ids->InitForIteration();
HashKey* key;

8
src/Scope.h
View file

@ -15,8 +15,6 @@ class ID;
class BroType;
class ListVal;
declare(PDict,ID);
class Scope : public BroObj {
public:
explicit Scope(ID* id, attr_list* al);
@ -35,11 +33,11 @@ public:
BroType* ReturnType() const { return return_type; }
int Length() const { return local->Length(); }
PDict(ID)* Vars() const { return local; }
PDict<ID>* Vars() const { return local; }
ID* GenerateTemporary(const char* name);
PDict(ID)* GetIDs() const { return local; }
PDict<ID>* GetIDs() const { return local; }
// Returns the list of variables needing initialization, and
// removes it from this Scope.
@ -56,7 +54,7 @@ protected:
ID* scope_id;
attr_list* attrs;
BroType* return_type;
PDict(ID)* local;
PDict<ID>* local;
id_list* inits;
};

11
src/Sessions.h
View file

@ -20,9 +20,6 @@ class Connection;
class ConnCompressor;
struct ConnID;
declare(PDict,Connection);
declare(PDict,FragReassembler);
class Discarder;
class PacketFilter;
@ -216,10 +213,10 @@ protected:
const Packet *pkt, const EncapsulationStack* encap);
CompositeHash* ch;
PDict(Connection) tcp_conns;
PDict(Connection) udp_conns;
PDict(Connection) icmp_conns;
PDict(FragReassembler) fragments;
PDict<Connection> tcp_conns;
PDict<Connection> udp_conns;
PDict<Connection> icmp_conns;
PDict<FragReassembler> fragments;
typedef pair<IPAddr, IPAddr> IPPair;
typedef pair<EncapsulatingConn, double> TunnelActivity;

2
src/Stats.cc
View file

@ -239,7 +239,7 @@ void ProfileLogger::Log()
// Script-level state.
unsigned int size, mem = 0;
PDict(ID)* globals = global_scope()->Vars();
PDict<ID>* globals = global_scope()->Vars();
if ( expensive )
{

96
src/Stmt.cc
View file

@ -123,9 +123,9 @@ ExprListStmt::ExprListStmt(BroStmtTag t, ListExpr* arg_l)
l = arg_l;
const expr_list& e = l->Exprs();
loop_over_list(e, i)
for ( const auto& expr : e )
{
const BroType* t = e[i]->Type();
const BroType* t = expr->Type();
if ( ! t || t->Tag() == TYPE_VOID )
Error("value of type void illegal");
}
@ -172,9 +172,9 @@ TraversalCode ExprListStmt::Traverse(TraversalCallback* cb) const
HANDLE_TC_STMT_PRE(tc);
const expr_list& e = l->Exprs();
loop_over_list(e, i)
for ( const auto& expr : e )
{
tc = e[i]->Traverse(cb);
tc = expr->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}
@ -430,8 +430,8 @@ Case::~Case()
Unref(expr_cases);
Unref(s);
loop_over_list((*type_cases), i)
Unref((*type_cases)[i]);
for ( const auto& id : *type_cases )
Unref(id);
delete type_cases;
}
@ -631,9 +631,9 @@ SwitchStmt::SwitchStmt(Expr* index, case_list* arg_cases) :
{
have_types = true;
loop_over_list((*tl), j)
for ( const auto& t : *tl )
{
BroType* ct = (*tl)[j]->Type();
BroType* ct = t->Type();
if ( ! can_cast_value_to_type(e->Type(), ct) )
{
@ -641,7 +641,7 @@ SwitchStmt::SwitchStmt(Expr* index, case_list* arg_cases) :
continue;
}
if ( ! AddCaseLabelTypeMapping((*tl)[j], i) )
if ( ! AddCaseLabelTypeMapping(t, i) )
{
c->Error("duplicate case label");
continue;
@ -665,8 +665,8 @@ SwitchStmt::SwitchStmt(Expr* index, case_list* arg_cases) :
SwitchStmt::~SwitchStmt()
{
loop_over_list(*cases, i)
Unref((*cases)[i]);
for ( const auto& c : *cases )
Unref(c);
delete cases;
delete comp_hash;
@ -793,9 +793,8 @@ int SwitchStmt::IsPure() const
if ( ! e->IsPure() )
return 0;
loop_over_list(*cases, i)
for ( const auto& c : *cases )
{
Case* c = (*cases)[i];
if ( ! c->ExprCases()->IsPure() || ! c->Body()->IsPure() )
return 0;
}
@ -812,8 +811,8 @@ void SwitchStmt::Describe(ODesc* d) const
d->PushIndent();
d->AddCount(cases->length());
loop_over_list(*cases, i)
(*cases)[i]->Describe(d);
for ( const auto& c : *cases )
c->Describe(d);
d->PopIndent();
if ( ! d->IsBinary() )
@ -830,9 +829,9 @@ TraversalCode SwitchStmt::Traverse(TraversalCallback* cb) const
tc = e->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
loop_over_list(*cases, i)
for ( const auto& c : *cases )
{
tc = (*cases)[i]->Traverse(cb);
tc = c->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}
@ -1132,8 +1131,8 @@ ForStmt::ForStmt(id_list* arg_loop_vars, Expr* loop_expr, ID* val_var)
ForStmt::~ForStmt()
{
loop_over_list(*loop_vars, i)
Unref((*loop_vars)[i]);
for ( const auto& var : *loop_vars )
Unref(var);
delete loop_vars;
Unref(value_var);
@ -1147,7 +1146,7 @@ Val* ForStmt::DoExec(Frame* f, Val* v, stmt_flow_type& flow) const
if ( v->Type()->Tag() == TYPE_TABLE )
{
TableVal* tv = v->AsTableVal();
const PDict(TableEntryVal)* loop_vals = tv->AsTable();
const PDict<TableEntryVal>* loop_vals = tv->AsTable();
if ( ! loop_vals->Length() )
return 0;
@ -1275,9 +1274,9 @@ TraversalCode ForStmt::Traverse(TraversalCallback* cb) const
TraversalCode tc = cb->PreStmt(this);
HANDLE_TC_STMT_PRE(tc);
loop_over_list(*loop_vars, i)
for ( const auto& var : *loop_vars )
{
tc = (*loop_vars)[i]->Traverse(cb);
tc = var->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}
@ -1445,8 +1444,8 @@ StmtList::StmtList() : Stmt(STMT_LIST)
StmtList::~StmtList()
{
loop_over_list(stmts, i)
Unref(stmts[i]);
for ( const auto& stmt : stmts )
Unref(stmt);
}
Val* StmtList::Exec(Frame* f, stmt_flow_type& flow) const
@ -1454,17 +1453,17 @@ Val* StmtList::Exec(Frame* f, stmt_flow_type& flow) const
RegisterAccess();
flow = FLOW_NEXT;
loop_over_list(stmts, i)
for ( const auto& stmt : stmts )
{
f->SetNextStmt(stmts[i]);
f->SetNextStmt(stmt);
if ( ! pre_execute_stmt(stmts[i], f) )
if ( ! pre_execute_stmt(stmt, f) )
{ // ### Abort or something
}
Val* result = stmts[i]->Exec(f, flow);
Val* result = stmt->Exec(f, flow);
if ( ! post_execute_stmt(stmts[i], f, result, &flow) )
if ( ! post_execute_stmt(stmt, f, result, &flow) )
{ // ### Abort or something
}
@ -1477,8 +1476,8 @@ Val* StmtList::Exec(Frame* f, stmt_flow_type& flow) const
int StmtList::IsPure() const
{
loop_over_list(stmts, i)
if ( ! stmts[i]->IsPure() )
for ( const auto& stmt : stmts )
if ( ! stmt->IsPure() )
return 0;
return 1;
}
@ -1502,9 +1501,9 @@ void StmtList::Describe(ODesc* d) const
d->NL();
}
loop_over_list(stmts, i)
for ( const auto& stmt : stmts )
{
stmts[i]->Describe(d);
stmt->Describe(d);
d->NL();
}
@ -1518,9 +1517,9 @@ TraversalCode StmtList::Traverse(TraversalCallback* cb) const
TraversalCode tc = cb->PreStmt(this);
HANDLE_TC_STMT_PRE(tc);
loop_over_list(stmts, i)
for ( const auto& stmt : stmts )
{
tc = stmts[i]->Traverse(cb);
tc = stmt->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}
@ -1533,21 +1532,21 @@ Val* EventBodyList::Exec(Frame* f, stmt_flow_type& flow) const
RegisterAccess();
flow = FLOW_NEXT;
loop_over_list(stmts, i)
for ( const auto& stmt : stmts )
{
f->SetNextStmt(stmts[i]);
f->SetNextStmt(stmt);
// Ignore the return value, since there shouldn't be
// any; and ignore the flow, since we still execute
// all of the event bodies even if one of them does
// a FLOW_RETURN.
if ( ! pre_execute_stmt(stmts[i], f) )
if ( ! pre_execute_stmt(stmt, f) )
{ // ### Abort or something
}
Val* result = stmts[i]->Exec(f, flow);
Val* result = stmt->Exec(f, flow);
if ( ! post_execute_stmt(stmts[i], f, result, &flow) )
if ( ! post_execute_stmt(stmt, f, result, &flow) )
{ // ### Abort or something
}
}
@ -1563,16 +1562,16 @@ void EventBodyList::Describe(ODesc* d) const
{
if ( d->IsReadable() && stmts.length() > 0 )
{
loop_over_list(stmts, i)
for ( const auto& stmt : stmts )
{
if ( ! d->IsBinary() )
{
d->Add("{");
d->PushIndent();
stmts[i]->AccessStats(d);
stmt->AccessStats(d);
}
stmts[i]->Describe(d);
stmt->Describe(d);
if ( ! d->IsBinary() )
{
@ -1588,8 +1587,8 @@ void EventBodyList::Describe(ODesc* d) const
InitStmt::~InitStmt()
{
loop_over_list(*inits, i)
Unref((*inits)[i]);
for ( const auto& init : *inits )
Unref(init);
delete inits;
}
@ -1599,9 +1598,8 @@ Val* InitStmt::Exec(Frame* f, stmt_flow_type& flow) const
RegisterAccess();
flow = FLOW_NEXT;
loop_over_list(*inits, i)
for ( const auto& aggr : *inits )
{
ID* aggr = (*inits)[i];
BroType* t = aggr->Type();
Val* v = 0;
@ -1649,9 +1647,9 @@ TraversalCode InitStmt::Traverse(TraversalCallback* cb) const
TraversalCode tc = cb->PreStmt(this);
HANDLE_TC_STMT_PRE(tc);
loop_over_list(*inits, i)
for ( const auto& init : *inits )
{
tc = (*inits)[i]->Traverse(cb);
tc = init->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}

7
src/Stmt.h
View file

@ -17,8 +17,6 @@
class StmtList;
class ForStmt;
declare(PDict, int);
class Stmt : public BroObj {
public:
BroStmtTag Tag() const { return tag; }
@ -195,8 +193,7 @@ protected:
Stmt* s;
};
declare(PList,Case);
typedef PList(Case) case_list;
typedef PList<Case> case_list;
class SwitchStmt : public ExprStmt {
public:
@ -238,7 +235,7 @@ protected:
case_list* cases;
int default_case_idx;
CompositeHash* comp_hash;
PDict(int) case_label_value_map;
PDict<int> case_label_value_map;
std::vector<std::pair<ID*, int>> case_label_type_list;
};

40
src/Type.cc
View file

@ -207,16 +207,16 @@ unsigned int BroType::MemoryAllocation() const
TypeList::~TypeList()
{
loop_over_list(types, i)
Unref(types[i]);
for ( const auto& type : types )
Unref(type);
Unref(pure_type);
}
int TypeList::AllMatch(const BroType* t, int is_init) const
{
loop_over_list(types, i)
if ( ! same_type(types[i], t, is_init) )
for ( const auto& type : types )
if ( ! same_type(type, t, is_init) )
return 0;
return 1;
}
@ -381,9 +381,8 @@ TableType::TableType(TypeList* ind, BroType* yield)
type_list* tl = indices->Types();
loop_over_list(*tl, i)
for ( const auto& tli : *tl )
{
BroType* tli = (*tl)[i];
InternalTypeTag t = tli->InternalType();
if ( t == TYPE_INTERNAL_ERROR )
@ -650,7 +649,7 @@ void FuncType::DescribeReST(ODesc* d, bool roles_only) const
TypeDecl::TypeDecl(BroType* t, const char* i, attr_list* arg_attrs, bool in_record)
{
type = t;
attrs = arg_attrs ? new Attributes(arg_attrs, t, in_record) : 0;
attrs = arg_attrs ? new Attributes(arg_attrs, t, in_record, false) : 0;
id = i;
}
@ -704,8 +703,8 @@ RecordType::RecordType(type_decl_list* arg_types) : BroType(TYPE_RECORD)
RecordType* RecordType::ShallowClone()
{
auto pass = new type_decl_list();
loop_over_list(*types, i)
pass->append(new TypeDecl(*(*types)[i]));
for ( const auto& type : *types )
pass->append(new TypeDecl(*type));
return new RecordType(pass);
}
@ -713,8 +712,8 @@ RecordType::~RecordType()
{
if ( types )
{
loop_over_list(*types, i)
delete (*types)[i];
for ( auto type : *types )
delete type;
delete types;
}
@ -823,17 +822,15 @@ const char* RecordType::AddFields(type_decl_list* others, attr_list* attr)
if ( attr )
{
loop_over_list(*attr, j)
for ( const auto& at : *attr )
{
if ( (*attr)[j]->Tag() == ATTR_LOG )
if ( at->Tag() == ATTR_LOG )
log = true;
}
}
loop_over_list(*others, i)
for ( const auto& td : *others )
{
TypeDecl* td = (*others)[i];
if ( ! td->FindAttr(ATTR_DEFAULT) &&
! td->FindAttr(ATTR_OPTIONAL) )
return "extension field must be &optional or have &default";
@ -841,7 +838,7 @@ const char* RecordType::AddFields(type_decl_list* others, attr_list* attr)
if ( log )
{
if ( ! td->attrs )
td->attrs = new Attributes(new attr_list, td->type, true);
td->attrs = new Attributes(new attr_list, td->type, true, false);
td->attrs->AddAttr(new Attr(ATTR_LOG));
}
@ -883,11 +880,11 @@ void RecordType::DescribeFields(ODesc* d) const
{
d->AddCount(0);
d->AddCount(types->length());
loop_over_list(*types, i)
for ( const auto& type : *types )
{
(*types)[i]->type->Describe(d);
type->type->Describe(d);
d->SP();
d->Add((*types)[i]->id);
d->Add(type->id);
d->SP();
}
}
@ -1091,6 +1088,9 @@ EnumType::EnumType(const EnumType* e)
names[it->first] = it->second;
vals = e->vals;
for ( auto& kv : vals )
::Ref(kv.second);
}
EnumType* EnumType::ShallowClone()

3
src/Type.h
View file

@ -455,8 +455,7 @@ public:
const char* id;
};
declare(PList,TypeDecl);
typedef PList(TypeDecl) type_decl_list;
typedef PList<TypeDecl> type_decl_list;
class RecordType : public BroType {
public:

92
src/Val.cc
View file

@ -597,7 +597,8 @@ static ZeekJson BuildJSON(Val* val, bool only_loggable=false, RE_Matcher* re=new
string key_string;
if ( re->MatchAnywhere(key_val->AsString()) != 0 )
{
key_val = key_val->Substitute(re, new StringVal(""), 0)->AsStringVal();
StringVal blank("");
key_val = key_val->Substitute(re, &blank, 0)->AsStringVal();
key_string = key_val->ToStdString();
delete key_val;
}
@ -611,6 +612,7 @@ static ZeekJson BuildJSON(Val* val, bool only_loggable=false, RE_Matcher* re=new
}
delete fields;
delete field_indexes;
break;
}
@ -1031,7 +1033,7 @@ Val* StringVal::Substitute(RE_Matcher* re, StringVal* repl, bool do_all)
// cut_points is a set of pairs of indices in str that should
// be removed/replaced. A pair <x,y> means "delete starting
// at offset x, up to but not including offset y".
List(ptr_compat_int) cut_points; // where RE matches pieces of str
vector<std::pair<int, int>> cut_points;
int size = 0; // size of result
@ -1054,8 +1056,7 @@ Val* StringVal::Substitute(RE_Matcher* re, StringVal* repl, bool do_all)
break;
// s[offset .. offset+end_of_match-1] matches re.
cut_points.append(offset);
cut_points.append(offset + end_of_match);
cut_points.push_back({offset, offset + end_of_match});
offset += end_of_match;
n -= end_of_match;
@ -1071,8 +1072,7 @@ Val* StringVal::Substitute(RE_Matcher* re, StringVal* repl, bool do_all)
// size now reflects amount of space copied. Factor in amount
// of space for replacement text.
int num_cut_points = cut_points.length() / 2;
size += num_cut_points * repl->Len();
size += cut_points.size() * repl->Len();
// And a final NUL for good health.
++size;
@ -1082,13 +1082,13 @@ Val* StringVal::Substitute(RE_Matcher* re, StringVal* repl, bool do_all)
// Copy it all over.
int start_offset = 0;
for ( int i = 0; i < cut_points.length(); i += 2 /* loop over pairs */ )
for ( const auto& point : cut_points )
{
int num_to_copy = cut_points[i] - start_offset;
int num_to_copy = point.first - start_offset;
memcpy(r, s + start_offset, num_to_copy);
r += num_to_copy;
start_offset = cut_points[i+1];
start_offset = point.second;
// Now add in replacement text.
memcpy(r, repl->Bytes(), repl->Len());
@ -1185,8 +1185,8 @@ ListVal::ListVal(TypeTag t)
ListVal::~ListVal()
{
loop_over_list(vals, i)
Unref(vals[i]);
for ( const auto& val : vals )
Unref(val);
Unref(type);
}
@ -1196,9 +1196,9 @@ RE_Matcher* ListVal::BuildRE() const
Internal("non-string list in ListVal::IncludedInString");
RE_Matcher* re = new RE_Matcher();
loop_over_list(vals, i)
for ( const auto& val : vals )
{
const char* vs = (const char*) (vals[i]->AsString()->Bytes());
const char* vs = (const char*) (val->AsString()->Bytes());
re->AddPat(vs);
}
@ -1227,8 +1227,8 @@ TableVal* ListVal::ConvertToSet() const
SetType* s = new SetType(set_index, 0);
TableVal* t = new TableVal(s);
loop_over_list(vals, i)
t->Assign(vals[i], 0);
for ( const auto& val : vals )
t->Assign(val, 0);
Unref(s);
return t;
@ -1265,8 +1265,8 @@ Val* ListVal::DoClone(CloneState* state)
lv->vals.resize(vals.length());
state->NewClone(this, lv);
loop_over_list(vals, i)
lv->Append(vals[i]->Clone(state));
for ( const auto& val : vals )
lv->Append(val->Clone(state));
return lv;
}
@ -1274,8 +1274,8 @@ Val* ListVal::DoClone(CloneState* state)
unsigned int ListVal::MemoryAllocation() const
{
unsigned int size = 0;
loop_over_list(vals, i)
size += vals[i]->MemoryAllocation();
for ( const auto& val : vals )
size += val->MemoryAllocation();
return size + padded_sizeof(*this) + vals.MemoryAllocation() - padded_sizeof(vals)
+ type->MemoryAllocation();
@ -1330,7 +1330,7 @@ void TableVal::Init(TableType* t)
subnets = 0;
table_hash = new CompositeHash(table_type->Indices());
val.table_val = new PDict(TableEntryVal);
val.table_val = new PDict<TableEntryVal>;
val.table_val->SetDeleteFunc(table_entry_val_delete_func);
}
@ -1353,7 +1353,7 @@ void TableVal::RemoveAll()
{
// Here we take the brute force approach.
delete AsTable();
val.table_val = new PDict(TableEntryVal);
val.table_val = new PDict<TableEntryVal>;
val.table_val->SetDeleteFunc(table_entry_val_delete_func);
}
@ -1366,7 +1366,7 @@ int TableVal::RecursiveSize() const
!= TYPE_TABLE )
return n;
PDict(TableEntryVal)* v = val.table_val;
PDict<TableEntryVal>* v = val.table_val;
IterCookie* c = v->InitForIteration();
TableEntryVal* tv;
@ -1504,7 +1504,7 @@ int TableVal::AddTo(Val* val, int is_first_init, bool propagate_ops) const
return 0;
}
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
IterCookie* c = tbl->InitForIteration();
HashKey* k;
@ -1552,7 +1552,7 @@ int TableVal::RemoveFrom(Val* val) const
return 0;
}
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
IterCookie* c = tbl->InitForIteration();
HashKey* k;
@ -1574,14 +1574,14 @@ TableVal* TableVal::Intersect(const TableVal* tv) const
{
TableVal* result = new TableVal(table_type);
const PDict(TableEntryVal)* t0 = AsTable();
const PDict(TableEntryVal)* t1 = tv->AsTable();
PDict(TableEntryVal)* t2 = result->AsNonConstTable();
const PDict<TableEntryVal>* t0 = AsTable();
const PDict<TableEntryVal>* t1 = tv->AsTable();
PDict<TableEntryVal>* t2 = result->AsNonConstTable();
// Figure out which is smaller; assign it to t1.
if ( t1->Length() > t0->Length() )
{ // Swap.
const PDict(TableEntryVal)* tmp = t1;
const PDict<TableEntryVal>* tmp = t1;
t1 = t0;
t0 = tmp;
}
@ -1603,8 +1603,8 @@ TableVal* TableVal::Intersect(const TableVal* tv) const
bool TableVal::EqualTo(const TableVal* tv) const
{
const PDict(TableEntryVal)* t0 = AsTable();
const PDict(TableEntryVal)* t1 = tv->AsTable();
const PDict<TableEntryVal>* t0 = AsTable();
const PDict<TableEntryVal>* t1 = tv->AsTable();
if ( t0->Length() != t1->Length() )
return false;
@ -1630,8 +1630,8 @@ bool TableVal::EqualTo(const TableVal* tv) const
bool TableVal::IsSubsetOf(const TableVal* tv) const
{
const PDict(TableEntryVal)* t0 = AsTable();
const PDict(TableEntryVal)* t1 = tv->AsTable();
const PDict<TableEntryVal>* t0 = AsTable();
const PDict<TableEntryVal>* t1 = tv->AsTable();
if ( t0->Length() > t1->Length() )
return false;
@ -1767,8 +1767,8 @@ Val* TableVal::Default(Val* index)
{
const val_list* vl0 = index->AsListVal()->Vals();
vl = val_list(vl0->length());
loop_over_list(*vl0, i)
vl.append((*vl0)[i]->Ref());
for ( const auto& v : *vl0 )
vl.append(v->Ref());
}
else
{
@ -1824,7 +1824,7 @@ Val* TableVal::Lookup(Val* index, bool use_default_val)
return def;
}
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
if ( tbl->Length() > 0 )
{
@ -1969,7 +1969,7 @@ ListVal* TableVal::ConvertToList(TypeTag t) const
{
ListVal* l = new ListVal(t);
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
IterCookie* c = tbl->InitForIteration();
HashKey* k;
@ -2010,7 +2010,7 @@ ListVal* TableVal::ConvertToPureList() const
void TableVal::Describe(ODesc* d) const
{
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
int n = tbl->Length();
if ( d->IsBinary() || d->IsPortable() )
@ -2176,7 +2176,7 @@ void TableVal::DoExpire(double t)
if ( ! type )
return; // FIX ME ###
PDict(TableEntryVal)* tbl = AsNonConstTable();
PDict<TableEntryVal>* tbl = AsNonConstTable();
double timeout = GetExpireTime();
@ -2361,7 +2361,7 @@ Val* TableVal::DoClone(CloneState* state)
auto tv = new TableVal(table_type);
state->NewClone(this, tv);
const PDict(TableEntryVal)* tbl = AsTable();
const PDict<TableEntryVal>* tbl = AsTable();
IterCookie* cookie = tbl->InitForIteration();
HashKey* key;
@ -2410,7 +2410,7 @@ unsigned int TableVal::MemoryAllocation() const
{
unsigned int size = 0;
PDict(TableEntryVal)* v = val.table_val;
PDict<TableEntryVal>* v = val.table_val;
IterCookie* c = v->InitForIteration();
TableEntryVal* tv;
@ -2693,9 +2693,9 @@ Val* RecordVal::DoClone(CloneState* state)
rv->origin = nullptr;
state->NewClone(this, rv);
loop_over_list(*val.val_list_val, i)
for ( const auto& vlv : *val.val_list_val )
{
Val* v = (*val.val_list_val)[i] ? (*val.val_list_val)[i]->Clone(state) : nullptr;
Val* v = vlv ? vlv->Clone(state) : nullptr;
rv->val.val_list_val->append(v);
}
@ -2705,12 +2705,10 @@ Val* RecordVal::DoClone(CloneState* state)
unsigned int RecordVal::MemoryAllocation() const
{
unsigned int size = 0;
const val_list* vl = AsRecord();
loop_over_list(*vl, i)
for ( const auto& v : *vl )
{
Val* v = (*vl)[i];
if ( v )
size += v->MemoryAllocation();
}
@ -3088,8 +3086,8 @@ void delete_vals(val_list* vals)
{
if ( vals )
{
loop_over_list(*vals, i)
Unref((*vals)[i]);
for ( const auto& val : *vals )
Unref(val);
delete vals;
}
}

7
src/Val.h
View file

@ -56,7 +56,6 @@ class StateAccess;
class VectorVal;
class TableEntryVal;
declare(PDict,TableEntryVal);
typedef union {
// Used for bool, int, enum.
@ -78,7 +77,7 @@ typedef union {
Func* func_val;
BroFile* file_val;
RE_Matcher* re_val;
PDict(TableEntryVal)* table_val;
PDict<TableEntryVal>* table_val;
val_list* val_list_val;
vector<Val*>* vector_val;
@ -229,7 +228,7 @@ public:
CONST_ACCESSOR2(TYPE_ENUM, int, int_val, AsEnum)
CONST_ACCESSOR(TYPE_STRING, BroString*, string_val, AsString)
CONST_ACCESSOR(TYPE_FUNC, Func*, func_val, AsFunc)
CONST_ACCESSOR(TYPE_TABLE, PDict(TableEntryVal)*, table_val, AsTable)
CONST_ACCESSOR(TYPE_TABLE, PDict<TableEntryVal>*, table_val, AsTable)
CONST_ACCESSOR(TYPE_RECORD, val_list*, val_list_val, AsRecord)
CONST_ACCESSOR(TYPE_FILE, BroFile*, file_val, AsFile)
CONST_ACCESSOR(TYPE_PATTERN, RE_Matcher*, re_val, AsPattern)
@ -401,7 +400,7 @@ protected:
#endif
}
ACCESSOR(TYPE_TABLE, PDict(TableEntryVal)*, table_val, AsNonConstTable)
ACCESSOR(TYPE_TABLE, PDict<TableEntryVal>*, table_val, AsNonConstTable)
ACCESSOR(TYPE_RECORD, val_list*, val_list_val, AsNonConstRecord)
// For internal use by the Val::Clone() methods.

10
src/Var.cc
View file

@ -108,7 +108,7 @@ static void make_var(ID* id, BroType* t, init_class c, Expr* init,
id->SetType(t);
if ( attr )
id->AddAttrs(new Attributes(attr, t, false));
id->AddAttrs(new Attributes(attr, t, false, id->IsGlobal()));
if ( init )
{
@ -286,7 +286,7 @@ void add_type(ID* id, BroType* t, attr_list* attr)
id->MakeType();
if ( attr )
id->SetAttrs(new Attributes(attr, tnew, false));
id->SetAttrs(new Attributes(attr, tnew, false, false));
}
static void transfer_arg_defaults(RecordType* args, RecordType* recv)
@ -304,7 +304,7 @@ static void transfer_arg_defaults(RecordType* args, RecordType* recv)
if ( ! recv_i->attrs )
{
attr_list* a = new attr_list{def};
recv_i->attrs = new Attributes(a, recv_i->type, true);
recv_i->attrs = new Attributes(a, recv_i->type, true, false);
}
else if ( ! recv_i->attrs->FindAttr(ATTR_DEFAULT) )
@ -443,10 +443,8 @@ int get_func_priotity(attr_list* attrs)
int priority = 0;
if ( attrs )
{
loop_over_list(*attrs, i)
for ( const auto& a : *attrs )
{
Attr* a = (*attrs)[i];
if ( a->Tag() == ATTR_DEPRECATED )
continue;

8
src/analyzer/Analyzer.cc
View file

@ -728,11 +728,11 @@ void Analyzer::CancelTimers()
// traversing. Thus, we first make a copy of the list which we then
// iterate through.
timer_list tmp(timers.length());
loop_over_list(timers, j)
tmp.append(timers[j]);
std::copy(timers.begin(), timers.end(), back_inserter(tmp));
loop_over_list(tmp, i)
Conn()->GetTimerMgr()->Cancel(tmp[i]);
// TODO: could be a for_each
for ( auto timer : tmp )
Conn()->GetTimerMgr()->Cancel(timer);
timers_canceled = 1;
timers.clear();

1
src/analyzer/protocol/mime/MIME.h
View file

@ -84,7 +84,6 @@ protected:
};
// declare(PList, MIME_Header);
typedef vector<MIME_Header*> MIME_HeaderList;
class MIME_Entity {

4
src/analyzer/protocol/rpc/RPC.h
View file

@ -99,8 +99,6 @@ protected:
Val* v; // single (perhaps compound) value corresponding to call
};
declare(PDict,RPC_CallInfo);
class RPC_Interpreter {
public:
explicit RPC_Interpreter(analyzer::Analyzer* analyzer);
@ -125,7 +123,7 @@ protected:
void Weird(const char* name, const char* addl = "");
PDict(RPC_CallInfo) calls;
PDict<RPC_CallInfo> calls;
analyzer::Analyzer* analyzer;
};

8
src/analyzer/protocol/stepping-stone/SteppingStone.cc
View file

@ -77,11 +77,10 @@ int SteppingStoneEndpoint::DataSent(double t, uint64 seq, int len, int caplen,
while ( stp_manager->OrderedEndpoints().length() > 0 )
{
int f = stp_manager->OrderedEndpoints().front();
auto e = stp_manager->OrderedEndpoints().front();
if ( stp_manager->OrderedEndpoints()[f]->stp_resume_time < tmin )
if ( e->stp_resume_time < tmin )
{
SteppingStoneEndpoint* e =
stp_manager->OrderedEndpoints().pop_front();
e->Done();
Unref(e);
@ -109,9 +108,8 @@ int SteppingStoneEndpoint::DataSent(double t, uint64 seq, int len, int caplen,
stp_last_time = stp_resume_time = t;
Event(stp_resume_endp, stp_id);
loop_over_queue(stp_manager->OrderedEndpoints(), i)
for ( auto ep : stp_manager->OrderedEndpoints() )
{
SteppingStoneEndpoint* ep = stp_manager->OrderedEndpoints()[i];
if ( ep->endp->TCP() != endp->TCP() )
{
Ref(ep);

11
src/analyzer/protocol/stepping-stone/SteppingStone.h
View file

@ -13,9 +13,6 @@ namespace analyzer { namespace stepping_stone {
class SteppingStoneEndpoint;
class SteppingStoneManager;
declare(PQueue,SteppingStoneEndpoint);
declare(PDict,SteppingStoneEndpoint);
class SteppingStoneEndpoint : public BroObj {
public:
SteppingStoneEndpoint(tcp::TCP_Endpoint* e, SteppingStoneManager* m);
@ -41,8 +38,8 @@ protected:
// no LOOP in Bro language.
int stp_id;
HashKey* stp_key;
PDict(SteppingStoneEndpoint) stp_inbound_endps;
PDict(SteppingStoneEndpoint) stp_outbound_endps;
PDict<SteppingStoneEndpoint> stp_inbound_endps;
PDict<SteppingStoneEndpoint> stp_outbound_endps;
};
class SteppingStone_Analyzer : public tcp::TCP_ApplicationAnalyzer {
@ -76,14 +73,14 @@ class SteppingStoneManager {
public:
SteppingStoneManager() { endp_cnt = 0; }
PQueue(SteppingStoneEndpoint)& OrderedEndpoints()
PQueue<SteppingStoneEndpoint>& OrderedEndpoints()
{ return ordered_endps; }
// Use postfix ++, since the first ID needs to be even.
int NextID() { return endp_cnt++; }
protected:
PQueue(SteppingStoneEndpoint) ordered_endps;
PQueue<SteppingStoneEndpoint> ordered_endps;
int endp_cnt;
};

4
src/broker/Manager.cc
View file

@ -1064,8 +1064,8 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev)
mgr.QueueEventFast(handler, std::move(vl), SOURCE_BROKER);
else
{
loop_over_list(vl, i)
Unref(vl[i]);
for ( const auto& v : vl )
Unref(v);
}
}

2
src/broker/messaging.bif
View file

@ -28,7 +28,7 @@ std::set<std::string> val_to_topic_set(Val* val)
rval.emplace(val->AsString()->CheckString());
else
{
const PDict(TableEntryVal)* tbl = val->AsTable();
const PDict<TableEntryVal>* tbl = val->AsTable();
if ( tbl->Length() == 0 )
return rval;

3
src/file_analysis/AnalyzerSet.h
View file

@ -14,7 +14,6 @@
namespace file_analysis {
class File;
declare(PDict,Analyzer);
/**
* A set of file analysis analyzers indexed by an \c AnalyzerArgs (script-layer
@ -139,7 +138,7 @@ private:
File* file; /**< File which owns the set */
CompositeHash* analyzer_hash; /**< AnalyzerArgs hashes. */
PDict(file_analysis::Analyzer) analyzer_map; /**< Indexed by AnalyzerArgs. */
PDict<file_analysis::Analyzer> analyzer_map; /**< Indexed by AnalyzerArgs. */
/**
* Abstract base class for analyzer set modifications.

11
src/file_analysis/Manager.h
View file

@ -26,9 +26,6 @@
namespace file_analysis {
declare(PDict,bool);
declare(PDict,File);
/**
* Main entry point for interacting with file analysis.
*/
@ -339,8 +336,8 @@ public:
protected:
friend class FileTimer;
typedef PDict(bool) IDSet;
typedef PDict(File) IDMap;
typedef PDict<bool> IDSet;
typedef PDict<File> IDMap;
/**
* Create a new file to be analyzed or retrieve an existing one.
@ -410,8 +407,8 @@ private:
TagSet* LookupMIMEType(const string& mtype, bool add_if_not_found);
PDict(File) id_map; /**< Map file ID to file_analysis::File records. */
PDict(bool) ignored; /**< Ignored files. Will be finally removed on EOF. */
PDict<File> id_map; /**< Map file ID to file_analysis::File records. */
PDict<bool> ignored; /**< Ignored files. Will be finally removed on EOF. */
string current_file_id; /**< Hash of what get_file_handle event sets. */
RuleFileMagicState* magic_state; /**< File magic signature match state. */
MIMEMap mime_types;/**< Mapping of MIME types to analyzers. */

16
src/input/Manager.cc
View file

@ -52,8 +52,6 @@ static void input_hash_delete_func(void* val)
delete h;
}
declare(PDict, InputHash);
/**
* Base stuff that every stream can do.
*/
@ -109,8 +107,8 @@ public:
RecordType* rtype;
RecordType* itype;
PDict(InputHash)* currDict;
PDict(InputHash)* lastDict;
PDict<InputHash>* currDict;
PDict<InputHash>* lastDict;
Func* pred;
@ -703,9 +701,9 @@ bool Manager::CreateTableStream(RecordVal* fval)
stream->itype = idx->AsRecordType();
stream->event = event ? event_registry->Lookup(event->Name()) : 0;
stream->error_event = error_event ? event_registry->Lookup(error_event->Name()) : nullptr;
stream->currDict = new PDict(InputHash);
stream->currDict = new PDict<InputHash>;
stream->currDict->SetDeleteFunc(input_hash_delete_func);
stream->lastDict = new PDict(InputHash);
stream->lastDict = new PDict<InputHash>;
stream->lastDict->SetDeleteFunc(input_hash_delete_func);
stream->want_record = ( want_record->InternalInt() == 1 );
@ -1425,7 +1423,7 @@ void Manager::EndCurrentSend(ReaderFrontend* reader)
delete(stream->lastDict);
stream->lastDict = stream->currDict;
stream->currDict = new PDict(InputHash);
stream->currDict = new PDict<InputHash>;
stream->currDict->SetDeleteFunc(input_hash_delete_func);
#ifdef DEBUG
@ -1895,8 +1893,8 @@ bool Manager::SendEvent(ReaderFrontend* reader, const string& name, const int nu
if ( convert_error )
{
loop_over_list(vl, i)
Unref(vl[i]);
for ( const auto& v : vl )
Unref(v);
return false;
}

2
src/iosource/PktSrc.h
View file

@ -10,8 +10,6 @@
#include "Dict.h"
#include "Packet.h"
declare(PDict,BPF_Program);
namespace iosource {
/**

8
src/parse.y
View file

@ -164,11 +164,8 @@ static type_decl_list* copy_type_decl_list(type_decl_list* tdl)
type_decl_list* rval = new type_decl_list();
loop_over_list(*tdl, i)
{
TypeDecl* td = (*tdl)[i];
for ( const auto& td : *tdl )
rval->append(new TypeDecl(*td));
}
return rval;
}
@ -180,9 +177,8 @@ static attr_list* copy_attr_list(attr_list* al)
attr_list* rval = new attr_list();
loop_over_list(*al, i)
for ( const auto& a : *al )
{
Attr* a = (*al)[i];
::Ref(a);
rval->append(a);
}

4
src/probabilistic/Topk.cc
View file

@ -40,7 +40,7 @@ HashKey* TopkVal::GetHash(Val* v) const
TopkVal::TopkVal(uint64 arg_size) : OpaqueVal(topk_type)
{
elementDict = new PDict(Element);
elementDict = new PDict<Element>;
elementDict->SetDeleteFunc(topk_element_hash_delete_func);
size = arg_size;
type = 0;
@ -51,7 +51,7 @@ TopkVal::TopkVal(uint64 arg_size) : OpaqueVal(topk_type)
TopkVal::TopkVal() : OpaqueVal(topk_type)
{
elementDict = new PDict(Element);
elementDict = new PDict<Element>;
elementDict->SetDeleteFunc(topk_element_hash_delete_func);
size = 0;
type = 0;

4
src/probabilistic/Topk.h
View file

@ -33,8 +33,6 @@ struct Element {
~Element();
};
declare(PDict, Element);
class TopkVal : public OpaqueVal {
public:
@ -168,7 +166,7 @@ private:
BroType* type;
CompositeHash* hash;
std::list<Bucket*> buckets;
PDict(Element)* elementDict;
PDict<Element>* elementDict;
uint64 size; // how many elements are we tracking?
uint64 numElements; // how many elements do we have at the moment
bool pruned; // was this data structure pruned?

20
src/scan.l
View file

@ -126,8 +126,7 @@ public:
// A stack of input buffers we're scanning. file_stack[len-1] is the
// top of the stack.
declare(PList,FileInfo);
static PList(FileInfo) file_stack;
static PList<FileInfo> file_stack;
#define RET_CONST(v) \
{ \
@ -757,7 +756,7 @@ void do_atif(Expr* expr)
if ( ! val->AsBool() )
{
if_stack.append(current_depth);
if_stack.push_back(current_depth);
BEGIN(IGNORE);
}
}
@ -770,7 +769,7 @@ void do_atifdef(const char* id)
if ( ! (i = lookup_ID(id, current_module.c_str())) )
{
if_stack.append(current_depth);
if_stack.push_back(current_depth);
BEGIN(IGNORE);
}
@ -785,7 +784,7 @@ void do_atifndef(const char *id)
if ( (i = lookup_ID(id, current_module.c_str())) )
{
if_stack.append(current_depth);
if_stack.push_back(current_depth);
BEGIN(IGNORE);
}
@ -797,17 +796,17 @@ void do_atelse()
if ( current_depth == 0 )
reporter->Error("@else without @if...");
if ( if_stack.length() && current_depth > if_stack.last() )
if ( ! if_stack.empty() && current_depth > if_stack.back() )
return;
if ( YY_START == INITIAL )
{
if_stack.append(current_depth);
if_stack.push_back(current_depth);
BEGIN(IGNORE);
}
else
{
if_stack.get();
if_stack.pop_back();
BEGIN(INITIAL);
}
}
@ -817,10 +816,10 @@ void do_atendif()
if ( current_depth == 0 )
reporter->Error("unbalanced @if... @endif");
if ( current_depth == if_stack.last() )
if ( current_depth == if_stack.back() )
{
BEGIN(INITIAL);
if_stack.get();
if_stack.pop_back();
}
--current_depth;
@ -901,6 +900,7 @@ int yywrap()
yy_delete_buffer(YY_CURRENT_BUFFER);
if ( file_stack.length() > 0 )
delete file_stack.remove_nth(file_stack.length() - 1);
if ( YY_CURRENT_BUFFER )

9
src/strings.bif
View file

@ -61,15 +61,15 @@ function levenshtein_distance%(s1: string, s2: string%): count
function string_cat%(...%): string
%{
int n = 0;
loop_over_list(@ARG@, i)
n += @ARG@[i]->AsString()->Len();
for ( const auto& a : @ARG@ )
n += a->AsString()->Len();
u_char* b = new u_char[n+1];
BroString* s = new BroString(1, b, n);
loop_over_list(@ARG@, j)
for ( const auto& a : @ARG@ )
{
const BroString* s = @ARG@[j]->AsString();
const BroString* s = a->AsString();
memcpy(b, s->Bytes(), s->Len());
b += s->Len();
}
@ -350,7 +350,6 @@ Val* do_split(StringVal* str_val, RE_Matcher* re, int incl_sep, int max_num_sep)
return a;
}
%%}
## Splits a string into an array of strings according to a pattern.

11
src/util.cc
View file

@ -1001,11 +1001,12 @@ string bro_prefixes()
{
string rval;
loop_over_list(prefixes, j)
if ( j == 0 )
rval.append(prefixes[j]);
else
rval.append(":").append(prefixes[j]);
for ( const auto& prefix : prefixes )
{
if ( ! rval.empty() )
rval.append(":");
rval.append(prefix);
}
return rval;
}

8
src/zeek.bif
View file

@ -1566,8 +1566,8 @@ function cat%(...%): string
ODesc d;
d.SetStyle(RAW_STYLE);
loop_over_list(@ARG@, i)
@ARG@[i]->Describe(&d);
for ( const auto& a : @ARG@ )
a->Describe(&d);
BroString* s = new BroString(1, d.TakeBytes(), d.Len());
s->SetUseFreeToDelete(true);
@ -1898,7 +1898,7 @@ function reading_traces%(%): bool
function global_sizes%(%): var_sizes
%{
TableVal* sizes = new TableVal(var_sizes);
PDict(ID)* globals = global_scope()->Vars();
PDict<ID>* globals = global_scope()->Vars();
IterCookie* c = globals->InitForIteration();
ID* id;
@ -1925,7 +1925,7 @@ function global_sizes%(%): var_sizes
function global_ids%(%): id_table
%{
TableVal* ids = new TableVal(id_table);
PDict(ID)* globals = global_scope()->Vars();
PDict<ID>* globals = global_scope()->Vars();
IterCookie* c = globals->InitForIteration();
ID* id;

7
testing/btest/Baseline/language.attr-default-global-set-error/out
View file

@ -1,2 +1,5 @@
error in /home/jon/pro/zeek/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 4: arithmetic mixed with non-arithmetic (set[string] and 0)
error in /home/jon/pro/zeek/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 4: &default value has inconsistent type (0 and set[string])
error in /Users/tim/Desktop/projects/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 4: arithmetic mixed with non-arithmetic (set[string] and 0)
error in /Users/tim/Desktop/projects/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 4: &default value has inconsistent type (0 and set[string])
error in /Users/tim/Desktop/projects/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 9: &default is not valid for global variables (&default=10)
error in /Users/tim/Desktop/projects/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 9: &default is not valid for global variables (&optional, &default=9)
error in /Users/tim/Desktop/projects/zeek/testing/btest/.tmp/language.attr-default-global-set-error/attr-default-global-set-error.zeek, line 9: &optional is not valid for global variables (&optional, &default=9, &optional)

1
testing/btest/Baseline/language.enum-multiple-decls/out Normal file
View file

@ -0,0 +1 @@
ONE

9
testing/btest/Baseline/language.function-closures/out
View file

@ -44,3 +44,12 @@ expect: client
client
expect: unknown-33. outside-5
unknown-33. outside-5
classes!
bark i am thunder
eat i weigh 13
eat i weigh 14
I have a new name
bark i am twig
bark i am thunder

5
testing/btest/language/attr-default-global-set-error.zeek
View file

@ -2,3 +2,8 @@
# @TEST-EXEC: TEST_DIFF_CANONIFIER=$SCRIPTS/diff-remove-abspath btest-diff out
global ss: set[string] &default=0;
global d: count &default = 10
&default = 9
&optional
&log
&add_func = function(): count { return 3; };

10
testing/btest/language/enum-multiple-decls.zeek Normal file
View file

@ -0,0 +1,10 @@
# @TEST-EXEC: zeek -b %INPUT >out
# @TEST-EXEC: btest-diff out
# At the moment, it's legal to allow a double definitions. Internally, the
# reason/comment is: "so that we can define an enum both in a *.bif and *.zeek
# for avoiding cyclic dependencies."
type myenum: enum { ONE = 0x01 };
type myenum: enum { ONE = 0x01 };
print ONE;

40
testing/btest/language/function-closures.zeek
View file

@ -9,6 +9,31 @@ function make_count_upper (start : count) : function(step : count) : count
{ return (start += (step + numberone)); };
}
function dog_maker(name: string, weight: count) : function (action: string)
{
local eat = function (lbs: count) { print fmt("eat i weigh %s", lbs); };
local bark = function (who: string) { print fmt("bark i am %s", who); };
local dog = function (action: string)
{
switch action
{
case "bark":
bark(name);
break;
case "eat":
++weight;
eat(weight);
break;
default:
print "I have a new name";
name = action;
break;
}
};
return dog;
}
event zeek_init()
{
# basic
@ -129,6 +154,19 @@ event zeek_init()
print "expect: unknown-33. outside-5";
print dogs_also[33];
print "";
print "classes!";
print "";
} # event zeek_init
local dog = dog_maker("thunder", 12);
dog("bark");
dog("eat");
dog("eat");
local other_dog = copy(dog);
other_dog("twig");
other_dog("bark");
dog("bark");
} # zeek_init

2
testing/scripts/diff-remove-timestamps
View file

@ -9,5 +9,5 @@ else
sed="sed -E"
fi
$sed 's/(0\.000000)|([0-9]{9,10}\.[0-9]{2,8})/XXXXXXXXXX.XXXXXX/g' | \
$sed 's/(0\.000000)|([0-9]{9,10}\.[0-9]{1,8})/XXXXXXXXXX.XXXXXX/g' | \
$sed 's/^ *#(open|close).(19|20)..-..-..-..-..-..$/#\1 XXXX-XX-XX-XX-XX-XX/g'