Merge branch 'master' of github.com:zeek/zeek

CHANGES

@@ -1,4 +1,24 @@
 
+2.6-647 | 2019-07-22 12:46:04 -0700
+
+  * Ignore abs-path in test. (Zeke Medley, Corelight)
+
+  * Report argument # type check failed on. (Zeke Medley, Corelight)
+
+  * Update test baseline. (Zeke Medley, Corelight)
+
+  * Improve func arg type checking. (Zeke Medley, Corelight)
+
+  * &expire_func(table, arg1, arg2, ...) + type checking. (Zeke Medley, Corelight)
+
+2.6-640 | 2019-07-22 12:22:08 -0700
+
+  * Mark List::insert deprecated in favor of push_front (Tim Wojtulewicz, Corelight)
+
+  * Mark List::sort as deprecated, remove List::sortedinsert (Tim Wojtulewicz, Corelight)
+
+  * Simplify container iterators to just use pointers directly (Tim Wojtulewicz, Corelight)
+
 2.6-635 | 2019-07-22 10:58:56 -0700
 
   * Add DPD::max_violations option

NEWS

@@ -576,6 +576,8 @@ Removed Functionality
 
 - Removed the BackDoor analyzer.
 
+- Removed ``List::sortedinsert`` from the C++ API.
+
 Deprecated Functionality
 ------------------------
 
@@ -593,6 +595,9 @@ Deprecated Functionality
 - The ``bro_is_terminating`` and ``bro_version`` function are deprecated and
   replaced by functions named ``zeek_is_terminating`` and ``zeek_version``.
 
+- The ``List::insert`` method from the C++ API is deprecated, use
+  ``List::push_front`` instead.
+
 Bro 2.6
 =======
 

VERSION

@@ -1 +1 @@
-2.6-635
+2.6-647

src/Attr.cc

@@ -168,7 +168,7 @@ void Attributes::AddAttr(Attr* attr)
 		// We overwrite old attributes by deleting them first.
 		RemoveAttr(attr->Tag());
 
-	attrs->append(attr);
+	attrs->push_back(attr);
 	Ref(attr);
 
 	// We only check the attribute after we've added it, to facilitate
@@ -179,11 +179,11 @@ void Attributes::AddAttr(Attr* attr)
 	// those attributes only have meaning for a redefinable value.
 	if ( (attr->Tag() == ATTR_ADD_FUNC || attr->Tag() == ATTR_DEL_FUNC) &&
 	     ! FindAttr(ATTR_REDEF) )
-		attrs->append(new Attr(ATTR_REDEF));
+		attrs->push_back(new Attr(ATTR_REDEF));
 
 	// For DEFAULT, add an implicit OPTIONAL.
 	if ( attr->Tag() == ATTR_DEFAULT && ! FindAttr(ATTR_OPTIONAL) )
-		attrs->append(new Attr(ATTR_OPTIONAL));
+		attrs->push_back(new Attr(ATTR_OPTIONAL));
 	}
 
 void Attributes::AddAttrs(Attributes* a)

src/Conn.cc

@@ -525,7 +525,7 @@ void Connection::AddTimer(timer_func timer, double t, int do_expire,
 
 	Timer* conn_timer = new ConnectionTimer(this, timer, t, do_expire, type);
 	GetTimerMgr()->Add(conn_timer);
-	timers.append(conn_timer);
+	timers.push_back(conn_timer);
 	}
 
 void Connection::RemoveTimer(Timer* t)

src/DFA.cc

@@ -402,7 +402,7 @@ DFA_Machine::DFA_Machine(NFA_Machine* n, EquivClass* arg_ec)
 	dfa_state_cache = new DFA_State_Cache();
 
 	NFA_state_list* ns = new NFA_state_list;
-	ns->append(n->FirstState());
+	ns->push_back(n->FirstState());
 
 	if ( ns->length() > 0 )
 		{

src/DNS_Mgr.cc

@@ -536,8 +536,8 @@ TableVal* DNS_Mgr::LookupHost(const char* name)
 	// Not found, or priming.
 	switch ( mode ) {
 	case DNS_PRIME:
-		requests.append(new DNS_Mgr_Request(name, AF_INET, false));
+		requests.push_back(new DNS_Mgr_Request(name, AF_INET, false));
-		requests.append(new DNS_Mgr_Request(name, AF_INET6, false));
+		requests.push_back(new DNS_Mgr_Request(name, AF_INET6, false));
 		return empty_addr_set();
 
 	case DNS_FORCE:
@@ -545,8 +545,8 @@ TableVal* DNS_Mgr::LookupHost(const char* name)
 		return 0;
 
 	case DNS_DEFAULT:
-		requests.append(new DNS_Mgr_Request(name, AF_INET, false));
+		requests.push_back(new DNS_Mgr_Request(name, AF_INET, false));
-		requests.append(new DNS_Mgr_Request(name, AF_INET6, false));
+		requests.push_back(new DNS_Mgr_Request(name, AF_INET6, false));
 		Resolve();
 		return LookupHost(name);
 
@@ -581,7 +581,7 @@ Val* DNS_Mgr::LookupAddr(const IPAddr& addr)
 	// Not found, or priming.
 	switch ( mode ) {
 	case DNS_PRIME:
-		requests.append(new DNS_Mgr_Request(addr));
+		requests.push_back(new DNS_Mgr_Request(addr));
 		return new StringVal("<none>");
 
 	case DNS_FORCE:
@@ -590,7 +590,7 @@ Val* DNS_Mgr::LookupAddr(const IPAddr& addr)
 		return 0;
 
 	case DNS_DEFAULT:
-		requests.append(new DNS_Mgr_Request(addr));
+		requests.push_back(new DNS_Mgr_Request(addr));
 		Resolve();
 		return LookupAddr(addr);
 

src/Dict.cc

@@ -179,7 +179,7 @@ void* Dictionary::Insert(void* key, int key_size, hash_t hash, void* val,
 		delete new_entry;
 		}
 	else if ( order )
-		order->append(new_entry);
+		order->push_back(new_entry);
 
 	// Resize logic.
 	if ( tbl2 )
@@ -470,7 +470,7 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
 
 	// We happen to know (:-() that appending is more efficient
 	// on lists than prepending.
-	chain->append(new_entry);
+	chain->push_back(new_entry);
 
 	++cumulative_entries;
 	if ( *max_num_entries_ptr < ++*num_entries_ptr )
@@ -481,7 +481,7 @@ void* Dictionary::Insert(DictEntry* new_entry, int copy_key)
 	for ( const auto& c : cookies )
 		{
 		if ( h < (unsigned int) c->bucket )
-			c->inserted.append(new_entry);
+			c->inserted.push_back(new_entry);
 		}
 
 	return 0;

src/Dict.h

@@ -113,7 +113,7 @@ public:
 	// removed. (We don't get this for free, so only use it if
 	// necessary.)
 	void MakeRobustCookie(IterCookie* cookie)
-		{ cookies.append(cookie); }
+		{ cookies.push_back(cookie); }
 
 	// Remove all entries.
 	void Clear();

src/EventRegistry.cc

@@ -25,7 +25,7 @@ EventRegistry::string_list* EventRegistry::Match(RE_Matcher* pattern)
 	while ( (v = handlers.NextEntry(k, c)) )
 		{
 		if ( v->LocalHandler() && pattern->MatchExactly(v->Name()) )
-			names->append(v->Name());
+			names->push_back(v->Name());
 
 		delete k;
 		}
@@ -44,7 +44,7 @@ EventRegistry::string_list* EventRegistry::UnusedHandlers()
 	while ( (v = handlers.NextEntry(k, c)) )
 		{
 		if ( v->LocalHandler() && ! v->Used() )
-			names->append(v->Name());
+			names->push_back(v->Name());
 
 		delete k;
 		}
@@ -63,7 +63,7 @@ EventRegistry::string_list* EventRegistry::UsedHandlers()
 	while ( (v = handlers.NextEntry(k, c)) )
 		{
 		if ( v->LocalHandler() && v->Used() )
-			names->append(v->Name());
+			names->push_back(v->Name());
 
 		delete k;
 		}
@@ -81,7 +81,7 @@ EventRegistry::string_list* EventRegistry::AllHandlers()
 	EventHandler* v;
 	while ( (v = handlers.NextEntry(k, c)) )
 		{
-		names->append(v->Name());
+		names->push_back(v->Name());
 		delete k;
 		}
 

src/Expr.cc

@@ -3039,7 +3039,7 @@ RecordConstructorExpr::RecordConstructorExpr(ListExpr* constructor_list)
 		FieldAssignExpr* field = (FieldAssignExpr*) e;
 		BroType* field_type = field->Type()->Ref();
 		char* field_name = copy_string(field->FieldName());
-		record_types->append(new TypeDecl(field_type, field_name));
+		record_types->push_back(new TypeDecl(field_type, field_name));
 		}
 
 	SetType(new RecordType(record_types));
@@ -4418,7 +4418,7 @@ ListExpr::~ListExpr()
 
 void ListExpr::Append(Expr* e)
 	{
-	exprs.append(e);
+	exprs.push_back(e);
 	((TypeList*) type)->Append(e->Type()->Ref());
 	}
 
@@ -4482,7 +4482,7 @@ BroType* ListExpr::InitType() const
 				return 0;
 				}
 
-			types->append(td);
+			types->push_back(td);
 			}
 
 
@@ -5061,11 +5061,11 @@ int check_and_promote_args(ListExpr*& args, RecordType* types)
 				return 0;
 				}
 
-			def_elements.insert(def_attr->AttrExpr());
+			def_elements.push_front(def_attr->AttrExpr());
 			}
 
 		for ( const auto& elem : def_elements )
-			el.append(elem->Ref());
+			el.push_back(elem->Ref());
 		}
 
 	TypeList* tl = new TypeList();
@@ -5116,7 +5116,7 @@ val_list* eval_list(Frame* f, const ListExpr* l)
 			success = false;
 			break;
 			}
-		v->append(ev);
+		v->push_back(ev);
 		}
 
 	if ( ! success )

src/Func.cc

@@ -473,8 +473,8 @@ Stmt* BroFunc::AddInits(Stmt* body, id_list* inits)
 		return body;
 
 	StmtList* stmt_series = new StmtList;
-	stmt_series->Stmts().append(new InitStmt(inits));
+	stmt_series->Stmts().push_back(new InitStmt(inits));
-	stmt_series->Stmts().append(body);
+	stmt_series->Stmts().push_back(body);
 
 	return stmt_series;
 	}

src/List.h

@@ -27,67 +27,9 @@
 #include <cassert>
 #include "util.h"
 
+// TODO: this can be removed in v3.1 when List::sort() is removed
 typedef int (*list_cmp_func)(const void* v1, const void* v2);
 
-template<typename T>
-class ListIterator
-	{
-public:
-	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;
-		}
-
-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.
-	};
-
-
-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;
-	};
-}
-
-
 template<typename T>
 class List {
 public:
@@ -213,6 +155,7 @@ public:
 		return max_entries;
 		}
 
+	ZEEK_DEPRECATED("Remove in v3.1: Use std::sort instead")
 	void sort(list_cmp_func cmp_func)
 		{
 		qsort(entries, num_entries, sizeof(T), cmp_func);
@@ -221,7 +164,7 @@ public:
 	int MemoryAllocation() const
 		{ return padded_sizeof(*this) + pad_size(max_entries * sizeof(T)); }
 
-	void insert(const T& a)	// add at head of list
+	void push_front(const T& a)
 		{
 		if ( num_entries == max_entries )
 			resize(max_entries ? max_entries * LIST_GROWTH_FACTOR : DEFAULT_LIST_SIZE);
@@ -233,45 +176,31 @@ public:
 		entries[0] = a;
 		}
 	
-	// Assumes that the list is sorted and inserts at correct position.
+	void push_back(const T& a)
-	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]; }
 
+	ZEEK_DEPRECATED("Remove in v3.1: Use push_front instead")
+	void insert(const T& a)	// add at head of list
+		{
+		push_front(a);
+		}
+
+	// The append method is maintained for historical/compatibility reasons.
+	// (It's commonly used in the event generation API)
 	void append(const T& a)	// add to end of list
 		{
-		if ( num_entries == max_entries )
+		push_back(a);
-			resize(max_entries ? max_entries * LIST_GROWTH_FACTOR : DEFAULT_LIST_SIZE);
-
-		entries[num_entries++] = a;
 		}
 
 	bool remove(const T& a)	// delete entry from list
@@ -353,19 +282,21 @@ public:
 
 	// Type traits needed for some of the std algorithms to work
 	using value_type = T;
+	using pointer = T*;
+	using const_pointer = const T*;
 
 	// Iterator support
-	using iterator = ListIterator<T>;
+	using iterator = pointer;
-	using const_iterator = ListIterator<const T>;
+	using const_iterator = const_pointer;
 	using reverse_iterator = std::reverse_iterator<iterator>;
 	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-	iterator begin() { return { entries, 0, num_entries }; }
+	iterator begin() { return entries; }
-	iterator end() { return { entries, num_entries, num_entries }; }
+	iterator end() { return entries + num_entries; }
-	const_iterator begin() const { return { entries, 0, num_entries }; }
+	const_iterator begin() const { return entries; }
-	const_iterator end() const { return { entries, num_entries, num_entries }; }
+	const_iterator end() const { return entries + num_entries; }
-	const_iterator cbegin() const { return { entries, 0, num_entries }; }
+	const_iterator cbegin() const { return entries; }
-	const_iterator cend() const { return { entries, num_entries, num_entries }; }
+	const_iterator cend() const { return entries + num_entries; }
 
 	reverse_iterator rbegin() { return reverse_iterator{end()}; }
 	reverse_iterator rend() { return reverse_iterator{begin()}; }

src/NFA.cc

@@ -2,6 +2,8 @@
 
 #include "zeek-config.h"
 
+#include <algorithm>
+
 #include "NFA.h"
 #include "EquivClass.h"
 
@@ -52,7 +54,7 @@ NFA_State::~NFA_State()
 void NFA_State::AddXtionsTo(NFA_state_list* ns)
 	{
 	for ( int i = 0; i < xtions.length(); ++i )
-		ns->append(xtions[i]);
+		ns->push_back(xtions[i]);
 	}
 
 NFA_State* NFA_State::DeepCopy()
@@ -90,7 +92,7 @@ NFA_state_list* NFA_State::EpsilonClosure()
 	epsclosure = new NFA_state_list;
 
 	NFA_state_list states;
-	states.append(this);
+	states.push_back(this);
 	SetMark(this);
 
 	int i;
@@ -105,18 +107,18 @@ NFA_state_list* NFA_State::EpsilonClosure()
 				NFA_State* nxt = (*x)[j];
 				if ( ! nxt->Mark() )
 					{
-					states.append(nxt);
+					states.push_back(nxt);
 					nxt->SetMark(nxt);
 					}
 				}
 
 			if ( ns->Accept() != NO_ACCEPT )
-				epsclosure->append(ns);
+				epsclosure->push_back(ns);
 			}
 
 		else
 			// Non-epsilon transition - keep it.
-			epsclosure->append(ns);
+			epsclosure->push_back(ns);
 		}
 
 	// Clear out markers.
@@ -342,11 +344,14 @@ NFA_state_list* epsilon_closure(NFA_state_list* states)
 			if ( ! closuremap.Contains(ns->ID()) )
 				{
 				closuremap.Insert(ns->ID());
-				closure->sortedinsert(ns, NFA_state_cmp_neg);
+				closure->push_back(ns);
 				}
 			}
 		}
 
+	// Sort all of the closures in the list by ID
+	std::sort(closure->begin(), closure->end(), NFA_state_cmp_neg);
+
 	// Make it fit.
 	closure->resize(0);
 
@@ -355,15 +360,10 @@ NFA_state_list* epsilon_closure(NFA_state_list* states)
 	return closure;
 	}
 
-int NFA_state_cmp_neg(const void* v1, const void* v2)
+bool NFA_state_cmp_neg(const NFA_State* v1, const NFA_State* v2)
 	{
-	const NFA_State* n1 = (const NFA_State*) v1;
+	if ( v1->ID() < v2->ID() )
-	const NFA_State* n2 = (const NFA_State*) v2;
+		return true;
-
-	if ( n1->ID() < n2->ID() )
-		return -1;
-	else if ( n1->ID() == n2->ID() )
-		return 0;
 	else
-		return 1;
+		return false;
 	}

src/NFA.h

@@ -29,7 +29,7 @@ public:
 	explicit NFA_State(CCL* ccl);
 	~NFA_State() override;
 
-	void AddXtion(NFA_State* next_state)	{ xtions.append(next_state); }
+	void AddXtion(NFA_State* next_state)	{ xtions.push_back(next_state); }
 	NFA_state_list* Transitions()		{ return &xtions; }
 	void AddXtionsTo(NFA_state_list* ns);
 
@@ -132,6 +132,6 @@ extern NFA_Machine* make_alternate(NFA_Machine* m1, NFA_Machine* m2);
 extern NFA_state_list* epsilon_closure(NFA_state_list* states);
 
 // For sorting NFA states based on their ID fields (decreasing)
-extern int NFA_state_cmp_neg(const void* v1, const void* v2);
+extern bool NFA_state_cmp_neg(const NFA_State* v1, const NFA_State* v2);
 
 #endif

src/Queue.h

@@ -21,52 +21,6 @@
 //	Entries must be either a pointer to the data or nonzero data with
 //	sizeof(data) <= sizeof(void*).
 
-template<typename T>
-class QueueIterator
-	{
-	T* const entries;
-	int offset;
-	int num_entries;
-public:
-	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 {
@@ -205,19 +159,21 @@ public:
 
 	// Type traits needed for some of the std algorithms to work
 	using value_type = T;
+	using pointer = T*;
+	using const_pointer = const T*;
 
 	// Iterator support
-	using iterator = QueueIterator<T>;
+	using iterator = pointer;
-	using const_iterator = QueueIterator<const T>;
+	using const_iterator = const_pointer;
 	using reverse_iterator = std::reverse_iterator<iterator>;
 	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-	iterator begin() { return { entries, 0, num_entries }; }
+	iterator begin() { return entries; }
-	iterator end() { return { entries, num_entries, num_entries }; }
+	iterator end() { return entries + num_entries; }
-	const_iterator begin() const { return { entries, 0, num_entries }; }
+	const_iterator begin() const { return entries; }
-	const_iterator end() const { return { entries, num_entries, num_entries }; }
+	const_iterator end() const { return entries + num_entries; }
-	const_iterator cbegin() const { return { entries, 0, num_entries }; }
+	const_iterator cbegin() const { return entries; }
-	const_iterator cend() const { return { entries, num_entries, num_entries }; }
+	const_iterator cend() const { return entries + num_entries; }
 
 	reverse_iterator rbegin() { return reverse_iterator{end()}; }
 	reverse_iterator rend() { return reverse_iterator{begin()}; }

src/RE.h

@@ -64,7 +64,7 @@ public:
 	void InsertCCL(const char* txt, CCL* ccl) { ccl_dict.Insert(txt, ccl); }
 	int InsertCCL(CCL* ccl)
 		{
-		ccl_list.append(ccl);
+		ccl_list.push_back(ccl);
 		return ccl_list.length() - 1;
 		}
 	CCL* LookupCCL(const char* txt)	{ return ccl_dict.Lookup(txt); }

src/Reporter.cc

@@ -221,12 +221,12 @@ void Reporter::WeirdHelper(EventHandlerPtr event, Val* conn_val, file_analysis::
 	val_list vl(2);
 
 	if ( conn_val )
-		vl.append(conn_val);
+		vl.push_back(conn_val);
 	else if ( f )
-		vl.append(f->GetVal()->Ref());
+		vl.push_back(f->GetVal()->Ref());
 
 	if ( addl )
-		vl.append(new StringVal(addl));
+		vl.push_back(new StringVal(addl));
 
 	va_list ap;
 	va_start(ap, fmt_name);
@@ -491,15 +491,15 @@ void Reporter::DoLog(const char* prefix, EventHandlerPtr event, FILE* out,
 		val_list vl(vl_size);
 
 		if ( time )
-			vl.append(new Val(network_time ? network_time : current_time(), TYPE_TIME));
+			vl.push_back(new Val(network_time ? network_time : current_time(), TYPE_TIME));
 
-		vl.append(new StringVal(buffer));
+		vl.push_back(new StringVal(buffer));
 
 		if ( location )
-			vl.append(new StringVal(loc_str.c_str()));
+			vl.push_back(new StringVal(loc_str.c_str()));
 
 		if ( conn )
-			vl.append(conn->BuildConnVal());
+			vl.push_back(conn->BuildConnVal());
 
 		if ( addl )
 			std::copy(addl->begin(), addl->end(), std::back_inserter(vl));

src/Rule.cc

@@ -76,9 +76,9 @@ void Rule::AddPattern(const char* str, Rule::PatternType type,
 	p->id = ++pattern_counter;
 	p->offset = offset;
 	p->depth = depth;
-	patterns.append(p);
+	patterns.push_back(p);
 
-	rule_table.append(this);
+	rule_table.push_back(this);
 	}
 
 void Rule::AddRequires(const char* id, bool opposite_direction, bool negate)
@@ -89,7 +89,7 @@ void Rule::AddRequires(const char* id, bool opposite_direction, bool negate)
 	p->opposite_dir = opposite_direction;
 	p->negate = negate;
 
-	preconds.append(p);
+	preconds.push_back(p);
 	}
 
 void Rule::SortHdrTests()

src/Rule.h

@@ -40,9 +40,9 @@ public:
 
 	bool Active()	{ return active; }
 	void SetActiveStatus(bool new_status)	{ active = new_status; }
-	void AddAction(RuleAction* act)		{ actions.append(act); }
+	void AddAction(RuleAction* act)		{ actions.push_back(act); }
-	void AddCondition(RuleCondition* cond)	{ conditions.append(cond); }
+	void AddCondition(RuleCondition* cond)	{ conditions.push_back(cond); }
-	void AddHdrTest(RuleHdrTest* hdr_test)	{ hdr_tests.append(hdr_test);	}
+	void AddHdrTest(RuleHdrTest* hdr_test)	{ hdr_tests.push_back(hdr_test);	}
 	void AddPattern(const char* str, Rule::PatternType type,
 			uint32 offset = 0, uint32 depth = INT_MAX);
 	void AddRequires(const char* id, bool opposite_direction, bool negate);

src/RuleCondition.cc

@@ -163,12 +163,12 @@ bool RuleConditionEval::DoMatch(Rule* rule, RuleEndpointState* state,
 
 	// Call function with a signature_state value as argument.
 	val_list args(2);
-	args.append(rule_matcher->BuildRuleStateValue(rule, state));
+	args.push_back(rule_matcher->BuildRuleStateValue(rule, state));
 
 	if ( data )
-		args.append(new StringVal(len, (const char*) data));
+		args.push_back(new StringVal(len, (const char*) data));
 	else
-		args.append(val_mgr->GetEmptyString());
+		args.push_back(val_mgr->GetEmptyString());
 
 	bool result = 0;
 

src/RuleMatcher.cc

@@ -84,7 +84,7 @@ RuleHdrTest::RuleHdrTest(RuleHdrTest& h)
 
 	vals = new maskedvalue_list;
 	for ( const auto& val : *h.vals )
-		vals->append(new MaskedValue(*val));
+		vals->push_back(new MaskedValue(*val));
 
 	prefix_vals = h.prefix_vals;
 
@@ -96,7 +96,7 @@ RuleHdrTest::RuleHdrTest(RuleHdrTest& h)
 			copied_set->re = 0;
 			copied_set->ids = orig_set->ids;
 			for ( const auto& pattern : orig_set->patterns )
-				copied_set->patterns.append(copy_string(pattern));
+				copied_set->patterns.push_back(copy_string(pattern));
 			delete copied_set;
 			// TODO: Why do we create copied_set only to then
 			// never use it?
@@ -273,7 +273,7 @@ void RuleMatcher::AddRule(Rule* rule)
 		return;
 		}
 
-	rules.append(rule);
+	rules.push_back(rule);
 	rules_by_id.Insert(rule->ID(), rule);
 	}
 
@@ -303,7 +303,7 @@ void RuleMatcher::InsertRuleIntoTree(Rule* r, int testnr,
 			}
 
 		pc->rule = pc_rule;
-		pc_rule->dependents.append(r);
+		pc_rule->dependents.push_back(r);
 		}
 
 	// All tests in tree already?
@@ -349,7 +349,7 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs,
 		{
 		for ( const auto& p : r->patterns )
 			{
-			exprs[p->type].append(p->pattern);
+			exprs[p->type].push_back(p->pattern);
 			ids[p->type].push_back(p->id);
 			}
 		}
@@ -374,7 +374,7 @@ void RuleMatcher::BuildRegEx(RuleHdrTest* hdr_test, string_list* exprs,
 			{
 			loop_over_list(child_exprs[i], j)
 				{
-				exprs[i].append(child_exprs[i][j]);
+				exprs[i].push_back(child_exprs[i][j]);
 				ids[i].push_back(child_ids[i][j]);
 				}
 			}
@@ -406,7 +406,7 @@ void RuleMatcher::BuildPatternSets(RuleHdrTest::pattern_set_list* dst,
 		{
 		if ( i < exprs.length() )
 			{
-			group_exprs.append(exprs[i]);
+			group_exprs.push_back(exprs[i]);
 			group_ids.push_back(ids[i]);
 			}
 
@@ -419,7 +419,7 @@ void RuleMatcher::BuildPatternSets(RuleHdrTest::pattern_set_list* dst,
 			set->re->CompileSet(group_exprs, group_ids);
 			set->patterns = group_exprs;
 			set->ids = group_ids;
-			dst->append(set);
+			dst->push_back(set);
 
 			group_exprs.clear();
 			group_ids.clear();
@@ -585,7 +585,7 @@ RuleFileMagicState* RuleMatcher::InitFileMagic() const
 		assert(set->re);
 		RuleFileMagicState::Matcher* m = new RuleFileMagicState::Matcher;
 		m->state = new RE_Match_State(set->re);
-		state->matchers.append(m);
+		state->matchers.push_back(m);
 		}
 
 	// Save some memory.
@@ -706,7 +706,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer,
 		new RuleEndpointState(analyzer, from_orig, opposite, pia);
 
 	rule_hdr_test_list tests;
-	tests.append(root);
+	tests.push_back(root);
 
 	loop_over_list(tests, h)
 		{
@@ -719,7 +719,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer,
 		// Current HdrTest node matches the packet, so remember it
 		// if we have any rules on it.
 		if ( hdr_test->pattern_rules || hdr_test->pure_rules )
-			state->hdr_tests.append(hdr_test);
+			state->hdr_tests.push_back(hdr_test);
 
 		// Evaluate all rules on this node which don't contain
 		// any patterns.
@@ -741,7 +741,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer,
 						new RuleEndpointState::Matcher;
 					m->state = new RE_Match_State(set->re);
 					m->type = (Rule::PatternType) i;
-					state->matchers.append(m);
+					state->matchers.push_back(m);
 					}
 				}
 			}
@@ -795,7 +795,7 @@ RuleEndpointState* RuleMatcher::InitEndpoint(analyzer::Analyzer* analyzer,
 				}
 
 				if ( match )
-					tests.append(h);
+					tests.push_back(h);
 				}
 			}
 		}
@@ -918,9 +918,9 @@ void RuleMatcher::Match(RuleEndpointState* state, Rule::PatternType type,
 			// Remember that all patterns have matched.
 			if ( ! state->matched_by_patterns.is_member(r) )
 				{
-				state->matched_by_patterns.append(r);
+				state->matched_by_patterns.push_back(r);
 				BroString* s = new BroString(data, data_len, 0);
-				state->matched_text.append(s);
+				state->matched_text.push_back(s);
 				}
 
 			DBG_LOG(DBG_RULES, "And has not already fired");
@@ -1314,7 +1314,7 @@ static bool val_to_maskedval(Val* v, maskedvalue_list* append_to,
 			return false;
 	}
 
-	append_to->append(mval);
+	append_to->push_back(mval);
 
 	return true;
 	}

src/Scope.cc

@@ -194,13 +194,13 @@ ID* install_ID(const char* name, const char* module_name,
 
 void push_existing_scope(Scope* scope)
 	{
-	scopes.append(scope);
+	scopes.push_back(scope);
 	}
 
 void push_scope(ID* id, attr_list* attrs)
 	{
 	top_scope = new Scope(id, attrs);
-	scopes.append(top_scope);
+	scopes.push_back(top_scope);
 	}
 
 Scope* pop_scope()

src/Scope.h

@@ -44,7 +44,7 @@ public:
 	id_list* GetInits();
 
 	// Adds a variable to the list.
-	void AddInit(ID* id)		{ inits->append(id); }
+	void AddInit(ID* id)		{ inits->push_back(id); }
 
 	void Describe(ODesc* d) const override;
 

src/Type.cc

@@ -226,7 +226,7 @@ void TypeList::Append(BroType* t)
 	if ( pure_type && ! same_type(t, pure_type) )
 		reporter->InternalError("pure type-list violation");
 
-	types.append(t);
+	types.push_back(t);
 	}
 
 void TypeList::AppendEvenIfNotPure(BroType* t)
@@ -237,7 +237,7 @@ void TypeList::AppendEvenIfNotPure(BroType* t)
 		pure_type = 0;
 		}
 
-	types.append(t);
+	types.push_back(t);
 	}
 
 void TypeList::Describe(ODesc* d) const
@@ -714,7 +714,7 @@ RecordType* RecordType::ShallowClone()
 	{
 	auto pass = new type_decl_list();
 	for ( const auto& type : *types )
-		pass->append(new TypeDecl(*type));
+		pass->push_back(new TypeDecl(*type));
 	return new RecordType(pass);
 	}
 
@@ -853,7 +853,7 @@ const char* RecordType::AddFields(type_decl_list* others, attr_list* attr)
 			td->attrs->AddAttr(new Attr(ATTR_LOG));
 			}
 
-		types->append(td);
+		types->push_back(td);
 		}
 
 	delete others;
@@ -1883,7 +1883,7 @@ BroType* merge_types(const BroType* t1, const BroType* t2)
 				return 0;
 				}
 
-			tdl3->append(new TypeDecl(tdl3_i, copy_string(td1->id)));
+			tdl3->push_back(new TypeDecl(tdl3_i, copy_string(td1->id)));
 			}
 
 		return new RecordType(tdl3);

src/Val.cc

@@ -1215,7 +1215,7 @@ void ListVal::Append(Val* v)
 			Internal("heterogeneous list in ListVal::Append");
 		}
 
-	vals.append(v);
+	vals.push_back(v);
 	type->AsTypeList()->Append(v->Type()->Ref());
 	}
 
@@ -1770,7 +1770,7 @@ Val* TableVal::Default(Val* index)
 		const val_list* vl0 = index->AsListVal()->Vals();
 		vl = val_list(vl0->length());
 		for ( const auto& v : *vl0 )
-			vl.append(v->Ref());
+			vl.push_back(v->Ref());
 		}
 	else
 		{
@@ -2478,7 +2478,7 @@ RecordVal::RecordVal(RecordType* t, bool init_fields) : Val(t)
 				def = new VectorVal(type->AsVectorType());
 			}
 
-		vl->append(def ? def->Ref() : 0);
+		vl->push_back(def ? def->Ref() : 0);
 
 		Unref(def);
 		}
@@ -2697,7 +2697,7 @@ Val* RecordVal::DoClone(CloneState* state)
 	for ( const auto& vlv : *val.val_list_val )
 		{
 		Val* v = vlv ? vlv->Clone(state) : nullptr;
-  		rv->val.val_list_val->append(v);
+  		rv->val.val_list_val->push_back(v);
 		}
 
 	return rv;

src/analyzer/Analyzer.cc

@@ -713,7 +713,7 @@ void Analyzer::AddTimer(analyzer_timer_func timer, double t,
 		AnalyzerTimer(this, timer, t, do_expire, type);
 
 	Conn()->GetTimerMgr()->Add(analyzer_timer);
-	timers.append(analyzer_timer);
+	timers.push_back(analyzer_timer);
 	}
 
 void Analyzer::RemoveTimer(Timer* t)

src/analyzer/protocol/irc/IRC.cc

@@ -395,11 +395,11 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 				}
 
 			val_list vl(6);
-			vl.append(BuildConnVal());
+			vl.push_back(BuildConnVal());
-			vl.append(val_mgr->GetBool(orig));
+			vl.push_back(val_mgr->GetBool(orig));
-			vl.append(new StringVal(parts[0].c_str()));
+			vl.push_back(new StringVal(parts[0].c_str()));
-			vl.append(new StringVal(parts[1].c_str()));
+			vl.push_back(new StringVal(parts[1].c_str()));
-			vl.append(new StringVal(parts[2].c_str()));
+			vl.push_back(new StringVal(parts[2].c_str()));
 
 			parts.erase(parts.begin(), parts.begin() + 4);
 
@@ -410,7 +410,7 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 			if ( real_name[0] == ':' )
 				real_name = real_name.substr(1);
 
-			vl.append(new StringVal(real_name.c_str()));
+			vl.push_back(new StringVal(real_name.c_str()));
 
 			ConnectionEventFast(irc_whois_user_line, std::move(vl));
 			}
@@ -740,20 +740,20 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 		// extract username and real name
 		vector<string> parts = SplitWords(params, ' ');
 		val_list vl(6);
-		vl.append(BuildConnVal());
+		vl.push_back(BuildConnVal());
-		vl.append(val_mgr->GetBool(orig));
+		vl.push_back(val_mgr->GetBool(orig));
 
 		if ( parts.size() > 0 )
-			vl.append(new StringVal(parts[0].c_str()));
+			vl.push_back(new StringVal(parts[0].c_str()));
-		else vl.append(val_mgr->GetEmptyString());
+		else vl.push_back(val_mgr->GetEmptyString());
 
 		if ( parts.size() > 1 )
-			vl.append(new StringVal(parts[1].c_str()));
+			vl.push_back(new StringVal(parts[1].c_str()));
-		else vl.append(val_mgr->GetEmptyString());
+		else vl.push_back(val_mgr->GetEmptyString());
 
 		if ( parts.size() > 2 )
-			vl.append(new StringVal(parts[2].c_str()));
+			vl.push_back(new StringVal(parts[2].c_str()));
-		else vl.append(val_mgr->GetEmptyString());
+		else vl.push_back(val_mgr->GetEmptyString());
 
 		string realname;
 		for ( unsigned int i = 3; i < parts.size(); i++ )
@@ -764,7 +764,7 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 			}
 
 		const char* name = realname.c_str();
-		vl.append(new StringVal(*name == ':' ? name + 1 : name));
+		vl.push_back(new StringVal(*name == ':' ? name + 1 : name));
 
 		ConnectionEventFast(irc_user_message, std::move(vl));
 		}
@@ -798,11 +798,11 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 			}
 
 		val_list vl(6);
-		vl.append(BuildConnVal());
+		vl.push_back(BuildConnVal());
-		vl.append(val_mgr->GetBool(orig));
+		vl.push_back(val_mgr->GetBool(orig));
-		vl.append(new StringVal(prefix.c_str()));
+		vl.push_back(new StringVal(prefix.c_str()));
-		vl.append(new StringVal(parts[0].c_str()));
+		vl.push_back(new StringVal(parts[0].c_str()));
-		vl.append(new StringVal(parts[1].c_str()));
+		vl.push_back(new StringVal(parts[1].c_str()));
 		if ( parts.size() > 2 )
 			{
 			string comment = parts[2];
@@ -812,10 +812,10 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 			if ( comment[0] == ':' )
 				comment = comment.substr(1);
 
-			vl.append(new StringVal(comment.c_str()));
+			vl.push_back(new StringVal(comment.c_str()));
 			}
 		else
-			vl.append(val_mgr->GetEmptyString());
+			vl.push_back(val_mgr->GetEmptyString());
 
 		ConnectionEventFast(irc_kick_message, std::move(vl));
 		}

src/analyzer/protocol/login/RSH.cc

@@ -170,18 +170,18 @@ void Rsh_Analyzer::DeliverStream(int len, const u_char* data, bool orig)
 	val_list vl(4 + orig);
 	const char* line = (const char*) data;
 	line = skip_whitespace(line);
-	vl.append(BuildConnVal());
+	vl.push_back(BuildConnVal());
-	vl.append(client_name ? client_name->Ref() : new StringVal("<none>"));
+	vl.push_back(client_name ? client_name->Ref() : new StringVal("<none>"));
-	vl.append(username ? username->Ref() : new StringVal("<none>"));
+	vl.push_back(username ? username->Ref() : new StringVal("<none>"));
-	vl.append(new StringVal(line));
+	vl.push_back(new StringVal(line));
 
 	if ( orig )
 		{
 		if ( contents_orig->RshSaveState() == RSH_SERVER_USER_NAME )
 			// First input
-			vl.append(val_mgr->GetTrue());
+			vl.push_back(val_mgr->GetTrue());
 		else
-			vl.append(val_mgr->GetFalse());
+			vl.push_back(val_mgr->GetFalse());
 
 		ConnectionEventFast(rsh_request, std::move(vl));
 		}

src/analyzer/protocol/pop3/POP3.cc

@@ -926,12 +926,12 @@ void POP3_Analyzer::POP3Event(EventHandlerPtr event, bool is_orig,
 
 	val_list vl(2 + (bool)arg1 + (bool)arg2);
 
-	vl.append(BuildConnVal());
+	vl.push_back(BuildConnVal());
-	vl.append(val_mgr->GetBool(is_orig));
+	vl.push_back(val_mgr->GetBool(is_orig));
 	if ( arg1 )
-		vl.append(new StringVal(arg1));
+		vl.push_back(new StringVal(arg1));
 	if ( arg2 )
-		vl.append(new StringVal(arg2));
+		vl.push_back(new StringVal(arg2));
 
 	ConnectionEventFast(event, std::move(vl));
 	}

src/analyzer/protocol/rpc/MOUNT.cc

@@ -168,10 +168,10 @@ int MOUNT_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_status
 					start_time, last_time, reply_len, (bool)request + (bool)reply);
 
 		if ( request )
-			vl.append(request);
+			vl.push_back(request);
 
 		if ( reply )
-			vl.append(reply);
+			vl.push_back(reply);
 
 		analyzer->ConnectionEventFast(event, std::move(vl));
 		}
@@ -189,7 +189,7 @@ val_list MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
 	// Returns a new val_list that already has a conn_val, and mount3_info.
 	// These are the first parameters for each mount_* event ...
 	val_list vl(2 + extra_elements);
-	vl.append(analyzer->BuildConnVal());
+	vl.push_back(analyzer->BuildConnVal());
 	VectorVal* auxgids = new VectorVal(internal_type("index_vec")->AsVectorType());
 
 	for (size_t i = 0; i < c->AuxGIDs().size(); ++i)
@@ -212,7 +212,7 @@ val_list MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
 	info->Assign(11, new StringVal(c->MachineName()));
 	info->Assign(12, auxgids);
 
-	vl.append(info);
+	vl.push_back(info);
 	return vl;
 	}
 

src/analyzer/protocol/rpc/NFS.cc

@@ -280,10 +280,10 @@ int NFS_Interp::RPC_BuildReply(RPC_CallInfo* c, BifEnum::rpc_status rpc_status,
 					start_time, last_time, reply_len, (bool)request + (bool)reply);
 
 		if ( request )
-			vl.append(request);
+			vl.push_back(request);
 
 		if ( reply )
-			vl.append(reply);
+			vl.push_back(reply);
 
 		analyzer->ConnectionEventFast(event, std::move(vl));
 		}
@@ -325,7 +325,7 @@ val_list NFS_Interp::event_common_vl(RPC_CallInfo *c, BifEnum::rpc_status rpc_st
 	// Returns a new val_list that already has a conn_val, and nfs3_info.
 	// These are the first parameters for each nfs_* event ...
 	val_list vl(2 + extra_elements);
-	vl.append(analyzer->BuildConnVal());
+	vl.push_back(analyzer->BuildConnVal());
 	VectorVal* auxgids = new VectorVal(internal_type("index_vec")->AsVectorType());
 
 	for ( size_t i = 0; i < c->AuxGIDs().size(); ++i )
@@ -346,7 +346,7 @@ val_list NFS_Interp::event_common_vl(RPC_CallInfo *c, BifEnum::rpc_status rpc_st
 	info->Assign(11, new StringVal(c->MachineName()));
 	info->Assign(12, auxgids);
 
-	vl.append(info);
+	vl.push_back(info);
 	return vl;
 	}
 

src/analyzer/protocol/rpc/Portmap.cc

@@ -284,20 +284,20 @@ void PortmapperInterp::Event(EventHandlerPtr f, Val* request, BifEnum::rpc_statu
 
 	val_list vl;
 
-	vl.append(analyzer->BuildConnVal());
+	vl.push_back(analyzer->BuildConnVal());
 
 	if ( status == BifEnum::RPC_SUCCESS )
 		{
 		if ( request )
-			vl.append(request);
+			vl.push_back(request);
 		if ( reply )
-			vl.append(reply);
+			vl.push_back(reply);
 		}
 	else
 		{
-		vl.append(BifType::Enum::rpc_status->GetVal(status));
+		vl.push_back(BifType::Enum::rpc_status->GetVal(status));
 		if ( request )
-			vl.append(request);
+			vl.push_back(request);
 		}
 
 	analyzer->ConnectionEventFast(f, std::move(vl));

src/broker/Manager.cc

@@ -1039,7 +1039,7 @@ void Manager::ProcessEvent(const broker::topic& topic, broker::zeek::Event ev)
 		auto val = data_to_val(std::move(args[i]), expected_type);
 
 		if ( val )
-			vl.append(val);
+			vl.push_back(val);
 		else
 			{
 			reporter->Warning("failed to convert remote event '%s' arg #%d,"

src/broker/messaging.bif

@@ -103,7 +103,7 @@ function Broker::publish%(topic: string, ...%): bool
 	val_list args(bif_args->length() - 1);
 
 	for ( auto i = 1; i < bif_args->length(); ++i )
-		args.append((*bif_args)[i]);
+		args.push_back((*bif_args)[i]);
 
 	auto rval = publish_event_args(args, topic->AsString(), frame);
 	return val_mgr->GetBool(rval);
@@ -196,7 +196,7 @@ function Cluster::publish_rr%(pool: Pool, key: string, ...%): bool
 	val_list args(bif_args->length() - 2);
 
 	for ( auto i = 2; i < bif_args->length(); ++i )
-		args.append((*bif_args)[i]);
+		args.push_back((*bif_args)[i]);
 
 	auto rval = publish_event_args(args, topic->AsString(), frame);
 	Unref(topic);
@@ -237,7 +237,7 @@ function Cluster::publish_hrw%(pool: Pool, key: any, ...%): bool
 	val_list args(bif_args->length() - 2);
 
 	for ( auto i = 2; i < bif_args->length(); ++i )
-		args.append((*bif_args)[i]);
+		args.push_back((*bif_args)[i]);
 
 	auto rval = publish_event_args(args, topic->AsString(), frame);
 	Unref(topic);

src/file_analysis/analyzer/x509/OCSP.cc

@@ -87,10 +87,10 @@ bool ocsp_add_cert_id(const OCSP_CERTID* cert_id, val_list* vl, BIO* bio)
 	if ( ! res )
 		{
 		reporter->Weird("OpenSSL failed to get OCSP_CERTID info");
-		vl->append(val_mgr->GetEmptyString());
+		vl->push_back(val_mgr->GetEmptyString());
-		vl->append(val_mgr->GetEmptyString());
+		vl->push_back(val_mgr->GetEmptyString());
-		vl->append(val_mgr->GetEmptyString());
+		vl->push_back(val_mgr->GetEmptyString());
-		vl->append(val_mgr->GetEmptyString());
+		vl->push_back(val_mgr->GetEmptyString());
 		return false;
 		}
 
@@ -99,22 +99,22 @@ bool ocsp_add_cert_id(const OCSP_CERTID* cert_id, val_list* vl, BIO* bio)
 
 	i2a_ASN1_OBJECT(bio, hash_alg);
 	int len = BIO_read(bio, buf, sizeof(buf));
-	vl->append(new StringVal(len, buf));
+	vl->push_back(new StringVal(len, buf));
 	BIO_reset(bio);
 
 	i2a_ASN1_STRING(bio, issuer_name_hash, V_ASN1_OCTET_STRING);
 	len = BIO_read(bio, buf, sizeof(buf));
-	vl->append(new StringVal(len, buf));
+	vl->push_back(new StringVal(len, buf));
 	BIO_reset(bio);
 
 	i2a_ASN1_STRING(bio, issuer_key_hash, V_ASN1_OCTET_STRING);
 	len = BIO_read(bio, buf, sizeof(buf));
-	vl->append(new StringVal(len, buf));
+	vl->push_back(new StringVal(len, buf));
 	BIO_reset(bio);
 
 	i2a_ASN1_INTEGER(bio, serial_number);
 	len = BIO_read(bio, buf, sizeof(buf));
-	vl->append(new StringVal(len, buf));
+	vl->push_back(new StringVal(len, buf));
 	BIO_reset(bio);
 
 	return true;
@@ -436,7 +436,7 @@ void file_analysis::OCSP::ParseRequest(OCSP_REQUEST* req)
 	for ( int i=0; i<req_count; i++ )
 		{
 		val_list rvl(5);
-		rvl.append(GetFile()->GetVal()->Ref());
+		rvl.push_back(GetFile()->GetVal()->Ref());
 
 		OCSP_ONEREQ *one_req = OCSP_request_onereq_get0(req, i);
 		OCSP_CERTID *cert_id = OCSP_onereq_get0_id(one_req);
@@ -503,26 +503,26 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 		}
 #endif
 
-	vl.append(GetFile()->GetVal()->Ref());
+	vl.push_back(GetFile()->GetVal()->Ref());
-	vl.append(status_val);
+	vl.push_back(status_val);
 
 #if ( OPENSSL_VERSION_NUMBER < 0x10100000L ) || defined(LIBRESSL_VERSION_NUMBER)
-	vl.append(val_mgr->GetCount((uint64)ASN1_INTEGER_get(resp_data->version)));
+	vl.push_back(val_mgr->GetCount((uint64)ASN1_INTEGER_get(resp_data->version)));
 #else
-	vl.append(parse_basic_resp_data_version(basic_resp));
+	vl.push_back(parse_basic_resp_data_version(basic_resp));
 #endif
 
 	// responderID
 	if ( OCSP_RESPID_bio(basic_resp, bio) )
 		{
 		len = BIO_read(bio, buf, sizeof(buf));
-		vl.append(new StringVal(len, buf));
+		vl.push_back(new StringVal(len, buf));
 		BIO_reset(bio);
 		}
 	else
 		{
 		reporter->Weird("OpenSSL failed to get OCSP responder id");
-		vl.append(val_mgr->GetEmptyString());
+		vl.push_back(val_mgr->GetEmptyString());
 		}
 
 	// producedAt
@@ -532,7 +532,7 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 	produced_at = OCSP_resp_get0_produced_at(basic_resp);
 #endif
 
-	vl.append(new Val(GetTimeFromAsn1(produced_at, GetFile(), reporter), TYPE_TIME));
+	vl.push_back(new Val(GetTimeFromAsn1(produced_at, GetFile(), reporter), TYPE_TIME));
 
 	// responses
 
@@ -546,7 +546,7 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 			continue;
 
 		val_list rvl(10);
-		rvl.append(GetFile()->GetVal()->Ref());
+		rvl.push_back(GetFile()->GetVal()->Ref());
 
 		// cert id
 		const OCSP_CERTID* cert_id = nullptr;
@@ -574,36 +574,36 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 			reporter->Weird("OpenSSL failed to find status of OCSP response");
 
 		const char* cert_status_str = OCSP_cert_status_str(status);
-		rvl.append(new StringVal(strlen(cert_status_str), cert_status_str));
+		rvl.push_back(new StringVal(strlen(cert_status_str), cert_status_str));
 
 		// revocation time and reason if revoked
 		if ( status == V_OCSP_CERTSTATUS_REVOKED )
 			{
-			rvl.append(new Val(GetTimeFromAsn1(revoke_time, GetFile(), reporter), TYPE_TIME));
+			rvl.push_back(new Val(GetTimeFromAsn1(revoke_time, GetFile(), reporter), TYPE_TIME));
 
 			if ( reason != OCSP_REVOKED_STATUS_NOSTATUS )
 				{
 				const char* revoke_reason = OCSP_crl_reason_str(reason);
-				rvl.append(new StringVal(strlen(revoke_reason), revoke_reason));
+				rvl.push_back(new StringVal(strlen(revoke_reason), revoke_reason));
 				}
 			else
-				rvl.append(new StringVal(0, ""));
+				rvl.push_back(new StringVal(0, ""));
 			}
 		else
 			{
-			rvl.append(new Val(0.0, TYPE_TIME));
+			rvl.push_back(new Val(0.0, TYPE_TIME));
-			rvl.append(new StringVal(0, ""));
+			rvl.push_back(new StringVal(0, ""));
 			}
 
 		if ( this_update )
-			rvl.append(new Val(GetTimeFromAsn1(this_update, GetFile(), reporter), TYPE_TIME));
+			rvl.push_back(new Val(GetTimeFromAsn1(this_update, GetFile(), reporter), TYPE_TIME));
 		else
-			rvl.append(new Val(0.0, TYPE_TIME));
+			rvl.push_back(new Val(0.0, TYPE_TIME));
 
 		if ( next_update )
-			rvl.append(new Val(GetTimeFromAsn1(next_update, GetFile(), reporter), TYPE_TIME));
+			rvl.push_back(new Val(GetTimeFromAsn1(next_update, GetFile(), reporter), TYPE_TIME));
 		else
-			rvl.append(new Val(0.0, TYPE_TIME));
+			rvl.push_back(new Val(0.0, TYPE_TIME));
 
 		mgr.QueueEvent(ocsp_response_certificate, std::move(rvl));
 
@@ -621,10 +621,10 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 #if ( OPENSSL_VERSION_NUMBER < 0x10100000L ) || defined(LIBRESSL_VERSION_NUMBER)
 	i2a_ASN1_OBJECT(bio, basic_resp->signatureAlgorithm->algorithm);
 	len = BIO_read(bio, buf, sizeof(buf));
-	vl.append(new StringVal(len, buf));
+	vl.push_back(new StringVal(len, buf));
 	BIO_reset(bio);
 #else
-	vl.append(parse_basic_resp_sig_alg(basic_resp, bio, buf, sizeof(buf)));
+	vl.push_back(parse_basic_resp_sig_alg(basic_resp, bio, buf, sizeof(buf)));
 #endif
 
 	//i2a_ASN1_OBJECT(bio, basic_resp->signature);
@@ -633,7 +633,7 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 	//BIO_reset(bio);
 
 	certs_vector = new VectorVal(internal_type("x509_opaque_vector")->AsVectorType());
-	vl.append(certs_vector);
+	vl.push_back(certs_vector);
 
 #if ( OPENSSL_VERSION_NUMBER < 0x10100000L ) || defined(LIBRESSL_VERSION_NUMBER)
 	certs = basic_resp->certs;

src/input/Manager.cc

@@ -1825,7 +1825,7 @@ bool Manager::CallPred(Func* pred_func, const int numvals, ...) const
 	va_list lP;
 	va_start(lP, numvals);
 	for ( int i = 0; i < numvals; i++ )
-		vl.append( va_arg(lP, Val*) );
+		vl.push_back( va_arg(lP, Val*) );
 
 	va_end(lP);
 
@@ -1881,7 +1881,7 @@ bool Manager::SendEvent(ReaderFrontend* reader, const string& name, const int nu
 	for ( int j = 0; j < num_vals; j++)
 		{
 		Val* v = ValueToVal(i, vals[j], convert_error);
-		vl.append(v);
+		vl.push_back(v);
 		if ( v && ! convert_error && ! same_type(type->FieldType(j), v->Type()) )
 			{
 			convert_error = true;
@@ -1916,7 +1916,7 @@ void Manager::SendEvent(EventHandlerPtr ev, const int numvals, ...) const
 	va_list lP;
 	va_start(lP, numvals);
 	for ( int i = 0; i < numvals; i++ )
-		vl.append( va_arg(lP, Val*) );
+		vl.push_back( va_arg(lP, Val*) );
 
 	va_end(lP);
 
@@ -1933,7 +1933,7 @@ void Manager::SendEvent(EventHandlerPtr ev, list<Val*> events) const
 #endif
 
 	for ( list<Val*>::iterator i = events.begin(); i != events.end(); i++ )
-		vl.append( *i );
+		vl.push_back( *i );
 
 	mgr.QueueEvent(ev, std::move(vl), SOURCE_LOCAL);
 	}

src/main.cc

@@ -481,7 +481,7 @@ int main(int argc, char** argv)
 
 	prog = argv[0];
 
-	prefixes.append(strdup(""));	// "" = "no prefix"
+	prefixes.push_back(strdup(""));	// "" = "no prefix"
 
 	char* p = zeekenv("ZEEK_PREFIXES");
 
@@ -537,19 +537,19 @@ int main(int argc, char** argv)
 			break;
 
 		case 'i':
-			interfaces.append(optarg);
+			interfaces.push_back(optarg);
 			break;
 
 		case 'p':
-			prefixes.append(optarg);
+			prefixes.push_back(optarg);
 			break;
 
 		case 'r':
-			read_files.append(optarg);
+			read_files.push_back(optarg);
 			break;
 
 		case 's':
-			rule_files.append(optarg);
+			rule_files.push_back(optarg);
 			break;
 
 		case 't':
@@ -877,11 +877,11 @@ int main(int argc, char** argv)
 	char* s;
 	while ( (s = strsep(&tmp, " \t")) )
 		if ( *s )
-			rule_files.append(s);
+			rule_files.push_back(s);
 
 	// Append signature files defined in @load-sigs
 	for ( size_t i = 0; i < sig_files.size(); ++i )
-		rule_files.append(copy_string(sig_files[i].c_str()));
+		rule_files.push_back(copy_string(sig_files[i].c_str()));
 
 	if ( rule_files.length() > 0 )
 		{

src/option.bif

@@ -17,11 +17,11 @@ static bool call_option_handlers_and_set_value(StringVal* name, ID* i, Val* val,
 			{
 			bool add_loc = handler_function->FType()->AsFuncType()->ArgTypes()->Types()->length() == 3;
 			val_list vl(2 + add_loc);
-			vl.append(name->Ref());
+			vl.push_back(name->Ref());
-			vl.append(val);
+			vl.push_back(val);
 
 			if ( add_loc )
-				vl.append(location->Ref());
+				vl.push_back(location->Ref());
 
 			val = handler_function->Call(&vl); // consumed by next call.
 			if ( ! val )

src/parse.y

@@ -165,7 +165,7 @@ static type_decl_list* copy_type_decl_list(type_decl_list* tdl)
 	type_decl_list* rval = new type_decl_list();
 
 	for ( const auto& td : *tdl )
-		rval->append(new TypeDecl(*td));
+		rval->push_back(new TypeDecl(*td));
 
 	return rval;
 	}
@@ -180,7 +180,7 @@ static attr_list* copy_attr_list(attr_list* al)
 	for ( const auto& a : *al )
 		{
 		::Ref(a);
-		rval->append(a);
+		rval->push_back(a);
 		}
 
 	return rval;
@@ -264,7 +264,7 @@ bro:
 		decl_list stmt_list
 			{
 			if ( stmts )
-				stmts->AsStmtList()->Stmts().append($2);
+				stmts->AsStmtList()->Stmts().push_back($2);
 			else
 				stmts = $2;
 
@@ -1016,7 +1016,7 @@ type_list:
 type_decl_list:
 		type_decl_list type_decl
 			{
-			$1->append($2);
+			$1->push_back($2);
 			}
 	|
 			{
@@ -1046,11 +1046,11 @@ formal_args:
 
 formal_args_decl_list:
 		formal_args_decl_list ';' formal_args_decl
-			{ $1->append($3); }
+			{ $1->push_back($3); }
 	|	formal_args_decl_list ',' formal_args_decl
-			{ $1->append($3); }
+			{ $1->push_back($3); }
 	|	formal_args_decl
-			{ $$ = new type_decl_list(); $$->append($1); }
+			{ $$ = new type_decl_list(); $$->push_back($1); }
 	;
 
 formal_args_decl:
@@ -1284,11 +1284,11 @@ opt_attr:
 
 attr_list:
 		attr_list attr
-			{ $1->append($2); }
+			{ $1->push_back($2); }
 	|	attr
 			{
 			$$ = new attr_list;
-			$$->append($1);
+			$$->push_back($1);
 			}
 	;
 
@@ -1523,7 +1523,7 @@ stmt_list:
 		stmt_list stmt
 			{
 			set_location(@1, @2);
-			$1->AsStmtList()->Stmts().append($2);
+			$1->AsStmtList()->Stmts().push_back($2);
 			$1->UpdateLocationEndInfo(@2);
 			}
 	|
@@ -1553,7 +1553,7 @@ event:
 
 case_list:
 		case_list case
-			{ $1->append($2); }
+			{ $1->push_back($2); }
 	|
 			{ $$ = new case_list; }
 	;
@@ -1571,12 +1571,12 @@ case:
 
 case_type_list:
 		case_type_list ',' case_type
-			{ $1->append($3); }
+			{ $1->push_back($3); }
 	|
 		case_type
 			{
 			$$ = new id_list;
-			$$->append($1);
+			$$->push_back($1);
 			}
 	;
 
@@ -1624,7 +1624,7 @@ for_head:
 						      false, false);
 
 			id_list* loop_vars = new id_list;
-			loop_vars->append(loop_var);
+			loop_vars->push_back(loop_var);
 
 			$$ = new ForStmt(loop_vars, $5);
 			}
@@ -1662,7 +1662,7 @@ for_head:
 				val_var = install_ID($5, module, false, false);
 
 			id_list* loop_vars = new id_list;
-			loop_vars->append(key_var);
+			loop_vars->push_back(key_var);
 
 			$$ = new ForStmt(loop_vars, $7, val_var);
 			}
@@ -1689,11 +1689,11 @@ for_head:
 
 local_id_list:
 		local_id_list ',' local_id
-			{ $1->append($3); }
+			{ $1->push_back($3); }
 	|	local_id
 			{
 			$$ = new id_list;
-			$$->append($1);
+			$$->push_back($1);
 			}
 	;
 

src/rule-parse.y

@@ -166,7 +166,7 @@ rule_attr:
 
 				val->val = proto;
 				val->mask = 0xffffffff;
-				vallist->append(val);
+				vallist->push_back(val);
 
 				// offset & size params are dummies, actual next proto value in
 				// header is retrieved dynamically via IP_Hdr::NextProto()
@@ -259,7 +259,7 @@ hdr_expr:
 
 			val->val = $8.val;
 			val->mask = $6;
-			vallist->append(val);
+			vallist->push_back(val);
 
 			$$ = new RuleHdrTest($1, $3.offset, $3.len,
 					(RuleHdrTest::Comp) $7, vallist);
@@ -274,14 +274,14 @@ hdr_expr:
 
 value_list:
 		value_list ',' value
-			{ $1->append(new MaskedValue($3)); $$ = $1; }
+			{ $1->push_back(new MaskedValue($3)); $$ = $1; }
 	|	value_list ',' ranged_value
 			{
 			int numVals = $3->length();
 			for ( int idx = 0; idx < numVals; idx++ )
 				{
 				MaskedValue* val = (*$3)[idx];
-				$1->append(val);
+				$1->push_back(val);
 				}
 			$$ = $1;
 			}
@@ -290,7 +290,7 @@ value_list:
 	|	value
 			{
 			$$ = new maskedvalue_list();
-			$$->append(new MaskedValue($1));
+			$$->push_back(new MaskedValue($1));
 			}
 	|	ranged_value
 			{
@@ -344,7 +344,7 @@ ranged_value:
 				MaskedValue* masked = new MaskedValue();
 				masked->val = val;
 				masked->mask = 0xffffffff;
-				$$->append(masked);
+				$$->push_back(masked);
 				}
 			}
 		;

src/scan.l

@@ -682,11 +682,11 @@ static int load_files(const char* orig_file)
 	// was done when we're finished processing it.
 	if ( ! did_module_restore )
 		{
-		file_stack.append(new FileInfo(current_module));
+		file_stack.push_back(new FileInfo(current_module));
 		did_module_restore = true;
 		}
 	else
-		file_stack.append(new FileInfo);
+		file_stack.push_back(new FileInfo);
 
 	zeekygen_mgr->Script(file_path);
 
@@ -839,7 +839,7 @@ void add_essential_input_file(const char* file)
 	if ( ! filename )
 		(void) load_files(file);
 	else
-		essential_input_files.append(copy_string(file));
+		essential_input_files.push_back(copy_string(file));
 	}
 
 void add_input_file(const char* file)
@@ -850,7 +850,7 @@ void add_input_file(const char* file)
 	if ( ! filename )
 		(void) load_files(file);
 	else
-		input_files.append(copy_string(file));
+		input_files.push_back(copy_string(file));
 	}
 
 void add_input_file_at_front(const char* file)
@@ -861,7 +861,7 @@ void add_input_file_at_front(const char* file)
 	if ( ! filename )
 		(void) load_files(file);
 	else
-		input_files.insert(copy_string(file));
+		input_files.push_front(copy_string(file));
 	}
 
 void add_to_name_list(char* s, char delim, name_list& nl)
@@ -872,7 +872,7 @@ void add_to_name_list(char* s, char delim, name_list& nl)
 		if ( s_delim )
 			*s_delim = 0;
 
-		nl.append(copy_string(s));
+		nl.push_back(copy_string(s));
 
 		if ( s_delim )
 			s = s_delim + 1;

src/zeek.bif

@@ -1335,8 +1335,8 @@ bool sort_function(Val* a, Val* b)
 		return 1;
 
 	val_list sort_func_args;
-	sort_func_args.append(a->Ref());
+	sort_func_args.push_back(a->Ref());
-	sort_func_args.append(b->Ref());
+	sort_func_args.push_back(b->Ref());
 
 	Val* result = sort_function_comp->Call(&sort_func_args);
 	int int_result = result->CoerceToInt();