From 8f259f866d7ca05cf4aaeb507ed3891cb742f776 Mon Sep 17 00:00:00 2001
From: Bernhard Amann <bernhard@icsi.berkeley.edu>
Date: Wed, 6 Mar 2013 14:08:06 -0800
Subject: [PATCH] change vector assignment operator and remove unnecessary
 argument (expr)

---
 src/BroString.cc          |  2 +-
 src/CompHash.cc           |  2 +-
 src/Expr.cc               | 43 ++++++++++++++++++---------------------
 src/ICMP.cc               |  2 +-
 src/IP.cc                 |  4 ++--
 src/NFS.cc                |  2 +-
 src/SmithWaterman.cc      |  4 ++--
 src/StateAccess.cc        |  4 ++--
 src/TunnelEncapsulation.h |  2 +-
 src/Val.cc                |  9 ++++----
 src/Val.h                 | 10 ++++-----
 src/bro.bif               |  8 ++++----
 src/input/Manager.cc      |  2 +-
 src/modbus-analyzer.pac   | 36 ++++++++++++++++----------------
 src/strings.bif           |  2 +-
 15 files changed, 63 insertions(+), 69 deletions(-)

diff --git a/src/BroString.cc b/src/BroString.cc
index e05995b156..19f7a16566 100644
--- a/src/BroString.cc
+++ b/src/BroString.cc
@@ -369,7 +369,7 @@ VectorVal* BroString:: VecToPolicy(Vec* vec)
 		BroString* string = (*vec)[i];
 		StringVal* val = new StringVal(string->Len(),
 						(const char*) string->Bytes());
-		result->Assign(i+1, val, 0);
+		result->Assign(i+1, val);
 		}
 
 	return result;
diff --git a/src/CompHash.cc b/src/CompHash.cc
index 306b3ea83e..05d3e515d2 100644
--- a/src/CompHash.cc
+++ b/src/CompHash.cc
@@ -856,7 +856,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey* k, const char* kp0,
 				if ( have_val )
 					kp1 = RecoverOneVal(k, kp1, k_end, vt->YieldType(), value,
 					                    false);
-				vv->Assign(index, value, 0);
+				vv->Assign(index, value);
 				}
 
 			pval = vv;
diff --git a/src/Expr.cc b/src/Expr.cc
index 3df4d781a0..19295e92d5 100644
--- a/src/Expr.cc
+++ b/src/Expr.cc
@@ -485,7 +485,7 @@ Val* UnaryExpr::Eval(Frame* f) const
 		for ( unsigned int i = 0; i < v_op->Size(); ++i )
 			{
 			Val* v_i = v_op->Lookup(i);
-			result->Assign(i, v_i ? Fold(v_i) : 0, this);
+			result->Assign(i, v_i ? Fold(v_i) : 0);
 			}
 
 		Unref(v);
@@ -625,10 +625,9 @@ Val* BinaryExpr::Eval(Frame* f) const
 			if ( v_op1->Lookup(i) && v_op2->Lookup(i) )
 				v_result->Assign(i,
 						 Fold(v_op1->Lookup(i),
-						      v_op2->Lookup(i)),
-						 this);
+						      v_op2->Lookup(i)));
 			else
-				v_result->Assign(i, 0, this);
+				v_result->Assign(i, 0);
 			// SetError("undefined element in vector operation");
 			}
 
@@ -648,10 +647,9 @@ Val* BinaryExpr::Eval(Frame* f) const
 			if ( vv_i )
 				v_result->Assign(i,
 					 is_vec1 ?
-						 Fold(vv_i, v2) : Fold(v1, vv_i),
-					 this);
+						 Fold(vv_i, v2) : Fold(v1, vv_i));
 			else
-				v_result->Assign(i, 0, this);
+				v_result->Assign(i, 0);
 
 			// SetError("Undefined element in vector operation");
 			}
@@ -1049,10 +1047,10 @@ Val* IncrExpr::Eval(Frame* f) const
 			if ( elt )
 				{
 				Val* new_elt = DoSingleEval(f, elt);
-				v_vec->Assign(i, new_elt, this, OP_INCR);
+				v_vec->Assign(i, new_elt, OP_INCR);
 				}
 			else
-				v_vec->Assign(i, 0, this, OP_INCR);
+				v_vec->Assign(i, 0, OP_INCR);
 			}
 		op->Assign(f, v_vec, OP_INCR);
 		}
@@ -1919,7 +1917,7 @@ Val* BoolExpr::Eval(Frame* f) const
 			result = new VectorVal(Type()->AsVectorType());
 			result->Resize(vector_v->Size());
 			result->AssignRepeat(0, result->Size(),
-						scalar_v, this);
+						scalar_v);
 			}
 		else
 			result = vector_v->Ref()->AsVectorVal();
@@ -1957,10 +1955,10 @@ Val* BoolExpr::Eval(Frame* f) const
 				(! op1->IsZero() && ! op2->IsZero()) :
 				(! op1->IsZero() || ! op2->IsZero());
 
-			result->Assign(i, new Val(local_result, TYPE_BOOL), this);
+			result->Assign(i, new Val(local_result, TYPE_BOOL));
 			}
 		else
-			result->Assign(i, 0, this);
+			result->Assign(i, 0);
 		}
 
 	Unref(v1);
@@ -2334,10 +2332,9 @@ Val* CondExpr::Eval(Frame* f) const
 		if ( local_cond )
 			result->Assign(i,
 				       local_cond->IsZero() ?
-					       b->Lookup(i) : a->Lookup(i),
-				       this);
+					       b->Lookup(i) : a->Lookup(i));
 		else
-			result->Assign(i, 0, this);
+			result->Assign(i, 0);
 		}
 
 	return result;
@@ -2961,7 +2958,7 @@ Val* IndexExpr::Eval(Frame* f) const
 			for ( unsigned int i = 0; i < v_v2->Size(); ++i )
 				{
 				if ( v_v2->Lookup(i)->AsBool() )
-					v_result->Assign(v_result->Size() + 1, v_v1->Lookup(i), this);
+					v_result->Assign(v_result->Size() + 1, v_v1->Lookup(i));
 				}
 			}
 		else
@@ -2971,7 +2968,7 @@ Val* IndexExpr::Eval(Frame* f) const
 			// Probably only do this if *all* are negative.
 			v_result->Resize(v_v2->Size());
 			for ( unsigned int i = 0; i < v_v2->Size(); ++i )
-				v_result->Assign(i, v_v1->Lookup(v_v2->Lookup(i)->CoerceToInt()), this);
+				v_result->Assign(i, v_v1->Lookup(v_v2->Lookup(i)->CoerceToInt()));
 			}
 		}
 	else
@@ -3048,7 +3045,7 @@ void IndexExpr::Assign(Frame* f, Val* v, Opcode op)
 
 	switch ( v1->Type()->Tag() ) {
 	case TYPE_VECTOR:
-		if ( ! v1->AsVectorVal()->Assign(v2, v, this, op) )
+		if ( ! v1->AsVectorVal()->Assign(v2, v, op) )
 			Internal("assignment failed");
 		break;
 
@@ -3620,7 +3617,7 @@ Val* VectorConstructorExpr::Eval(Frame* f) const
 		{
 		Expr* e = exprs[i];
 		Val* v = e->Eval(f);
-		if ( ! vec->Assign(i, v, e) )
+		if ( ! vec->Assign(i, v) )
 			{
 			Error(fmt("type mismatch at index %d", i), e);
 			return 0;
@@ -3644,7 +3641,7 @@ Val* VectorConstructorExpr::InitVal(const BroType* t, Val* aggr) const
 		Expr* e = exprs[i];
 		Val* v = check_and_promote(e->Eval(0), t->YieldType(), 1);
 
-		if ( ! v || ! vec->Assign(i, v, e) )
+		if ( ! v || ! vec->Assign(i, v) )
 			{
 			Error(fmt("initialization type mismatch at index %d", i), e);
 			return 0;
@@ -3865,9 +3862,9 @@ Val* ArithCoerceExpr::Fold(Val* v) const
 		{
 		Val* elt = vv->Lookup(i);
 		if ( elt )
-			result->Assign(i, FoldSingleVal(elt, t), this);
+			result->Assign(i, FoldSingleVal(elt, t));
 		else
-			result->Assign(i, 0, this);
+			result->Assign(i, 0);
 		}
 
 	return result;
@@ -5042,7 +5039,7 @@ Val* ListExpr::InitVal(const BroType* t, Val* aggr) const
 			Expr* e = exprs[i];
 			check_and_promote_expr(e, vec->Type()->AsVectorType()->YieldType());
 			Val* v = e->Eval(0);
-			if ( ! vec->Assign(i, v, e) )
+			if ( ! vec->Assign(i, v) )
 				{
 				e->Error(fmt("type mismatch at index %d", i));
 				return 0;
diff --git a/src/ICMP.cc b/src/ICMP.cc
index b9b4e89404..5634e3885f 100644
--- a/src/ICMP.cc
+++ b/src/ICMP.cc
@@ -829,7 +829,7 @@ VectorVal* ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
 		data += length;
 		caplen -= length;
 
-		vv->Assign(vv->Size(), rv, 0);
+		vv->Assign(vv->Size(), rv);
 		}
 
 	return vv;
diff --git a/src/IP.cc b/src/IP.cc
index 16424e26f2..78311cc2d2 100644
--- a/src/IP.cc
+++ b/src/IP.cc
@@ -63,7 +63,7 @@ static VectorVal* BuildOptionsVal(const u_char* data, int len)
 			len -= opt->ip6o_len + off;
 			}
 
-		vv->Assign(vv->Size(), rv, 0);
+		vv->Assign(vv->Size(), rv);
 		}
 
 	return vv;
@@ -626,7 +626,7 @@ VectorVal* IPv6_Hdr_Chain::BuildVal() const
 			reporter->InternalError("IPv6_Hdr_Chain bad header %d", type);
 			break;
 		}
-		rval->Assign(rval->Size(), ext_hdr, 0);
+		rval->Assign(rval->Size(), ext_hdr);
 		}
 
 	return rval;
diff --git a/src/NFS.cc b/src/NFS.cc
index 2911ee7f59..d64f7755a3 100644
--- a/src/NFS.cc
+++ b/src/NFS.cc
@@ -599,7 +599,7 @@ RecordVal* NFS_Interp::nfs3_readdir_reply(bool isplus, const u_char*& buf,
 				entry->Assign(4, nfs3_post_op_fh(buf,n));
 				}
 
-			entries->Assign(pos, entry, 0);
+			entries->Assign(pos, entry);
 			pos++;
 			}
 
diff --git a/src/SmithWaterman.cc b/src/SmithWaterman.cc
index ef329e49a5..e051032756 100644
--- a/src/SmithWaterman.cc
+++ b/src/SmithWaterman.cc
@@ -96,12 +96,12 @@ VectorVal* BroSubstring::VecToPolicy(Vec* vec)
 				align_val->Assign(0, new StringVal(new BroString(*align.string)));
 				align_val->Assign(1, new Val(align.index, TYPE_COUNT));
 
-				aligns->Assign(j+1, align_val, 0);
+				aligns->Assign(j+1, align_val);
 				}
 
 			st_val->Assign(1, aligns);
 			st_val->Assign(2, new Val(bst->IsNewAlignment(), TYPE_BOOL));
-			result->Assign(i+1, st_val, 0);
+			result->Assign(i+1, st_val);
 			}
 		}
 
diff --git a/src/StateAccess.cc b/src/StateAccess.cc
index 2d0a8dfc5a..c027624526 100644
--- a/src/StateAccess.cc
+++ b/src/StateAccess.cc
@@ -371,7 +371,7 @@ void StateAccess::Replay()
 
 			CheckOld("index assign", target.id, op1.val, op3,
 					v->AsVectorVal()->Lookup(index));
-			v->AsVectorVal()->Assign(index, op2 ? op2->Ref() : 0, 0);
+			v->AsVectorVal()->Assign(index, op2 ? op2->Ref() : 0);
 			}
 
 		else
@@ -421,7 +421,7 @@ void StateAccess::Replay()
 			Val* lookup_op1 = v->AsVectorVal()->Lookup(index);
 			int delta = lookup_op1->CoerceToInt() + amount;
 			Val* new_val = new Val(delta, t);
-			v->AsVectorVal()->Assign(index, new_val, 0);
+			v->AsVectorVal()->Assign(index, new_val);
 			}
 
 		else
diff --git a/src/TunnelEncapsulation.h b/src/TunnelEncapsulation.h
index e8ca7a48b6..a43f7c0b57 100644
--- a/src/TunnelEncapsulation.h
+++ b/src/TunnelEncapsulation.h
@@ -186,7 +186,7 @@ public:
 		if ( conns )
 			{
 			for ( size_t i = 0; i < conns->size(); ++i )
-				vv->Assign(i, (*conns)[i].GetRecordVal(), 0);
+				vv->Assign(i, (*conns)[i].GetRecordVal());
 			}
 
 		return vv;
diff --git a/src/Val.cc b/src/Val.cc
index 20051aff5f..5133550236 100644
--- a/src/Val.cc
+++ b/src/Val.cc
@@ -2921,8 +2921,7 @@ VectorVal::~VectorVal()
 	delete val.vector_val;
 	}
 
-bool VectorVal::Assign(unsigned int index, Val* element, const Expr* assigner,
-			Opcode op)
+bool VectorVal::Assign(unsigned int index, Val* element, Opcode op)
 	{
 	if ( element &&
 	     ! same_type(element->Type(), vector_type->YieldType(), 0) )
@@ -2983,12 +2982,12 @@ bool VectorVal::Assign(unsigned int index, Val* element, const Expr* assigner,
 	}
 
 bool VectorVal::AssignRepeat(unsigned int index, unsigned int how_many,
-				Val* element, const Expr* assigner)
+				Val* element)
 	{
 	ResizeAtLeast(index + how_many);
 
 	for ( unsigned int i = index; i < index + how_many; ++i )
-		if ( ! Assign(i, element, assigner) )
+		if ( ! Assign(i, element ) )
 			return false;
 
 	return true;
@@ -3089,7 +3088,7 @@ bool VectorVal::DoUnserialize(UnserialInfo* info)
 		{
 		Val* v;
 		UNSERIALIZE_OPTIONAL(v, Val::Unserialize(info, TYPE_ANY));
-		Assign(i, v, 0);
+		Assign(i, v);
 		}
 
 	return true;
diff --git a/src/Val.h b/src/Val.h
index 8ebfb2de0e..4b2705c5b4 100644
--- a/src/Val.h
+++ b/src/Val.h
@@ -968,18 +968,16 @@ public:
 	// Note: does NOT Ref() the element! Remember to do so unless
 	//       the element was just created and thus has refcount 1.
 	//
-	bool Assign(unsigned int index, Val* element, const Expr* assigner,
-			Opcode op = OP_ASSIGN);
-	bool Assign(Val* index, Val* element, const Expr* assigner,
-			Opcode op = OP_ASSIGN)
+	bool Assign(unsigned int index, Val* element, Opcode op = OP_ASSIGN);
+	bool Assign(Val* index, Val* element, Opcode op = OP_ASSIGN)
 		{
 		return Assign(index->AsListVal()->Index(0)->CoerceToUnsigned(),
-				element, assigner, op);
+				element, op);
 		}
 
 	// Assigns the value to how_many locations starting at index.
 	bool AssignRepeat(unsigned int index, unsigned int how_many,
-			  Val* element, const Expr* assigner);
+			  Val* element);
 
 	// Returns nil if no element was at that value.
 	// Lookup does NOT grow the vector to this size.
diff --git a/src/bro.bif b/src/bro.bif
index 8cea9d9123..79161ac47a 100644
--- a/src/bro.bif
+++ b/src/bro.bif
@@ -1349,7 +1349,7 @@ function order%(v: any, ...%) : index_vec
 	for ( i = 0; i < n; ++i )
 		{
 		int ind = ind_vv[i];
-		result_v->Assign(i, new Val(ind, TYPE_COUNT), 0);
+		result_v->Assign(i, new Val(ind, TYPE_COUNT));
 		}
 
 	return result_v;
@@ -1633,7 +1633,7 @@ function record_type_to_vector%(rt: string%): string_vec
 		for ( int i = 0; i < type->NumFields(); ++i )
 			{
 			StringVal* val = new StringVal(type->FieldName(i));
-			result->Assign(i+1, val, 0);
+			result->Assign(i+1, val);
 			}
 		}
 
@@ -2139,7 +2139,7 @@ function routing0_data_to_addrs%(s: string%): addr_vec
 	while ( len > 0 )
 		{
 		IPAddr a(IPv6, (const uint32*) bytes, IPAddr::Network);
-		rval->Assign(rval->Size(), new AddrVal(a), 0);
+		rval->Assign(rval->Size(), new AddrVal(a));
 		bytes += 16;
 		len -= 16;
 		}
@@ -2162,7 +2162,7 @@ function addr_to_counts%(a: addr%): index_vec
 	int len = a->AsAddr().GetBytes(&bytes);
 
 	for ( int i = 0; i < len; ++i )
-		rval->Assign(i, new Val(ntohl(bytes[i]), TYPE_COUNT), 0);
+		rval->Assign(i, new Val(ntohl(bytes[i]), TYPE_COUNT));
 
 	return rval;
 	%}
diff --git a/src/input/Manager.cc b/src/input/Manager.cc
index d9006d66a2..a6df9533e7 100644
--- a/src/input/Manager.cc
+++ b/src/input/Manager.cc
@@ -2107,7 +2107,7 @@ Val* Manager::ValueToVal(const Value* val, BroType* request_type)
 		VectorType* vt = new VectorType(type->Ref());
 		VectorVal* v = new VectorVal(vt);
 		for (  int i = 0; i < val->val.vector_val.size; i++ )
-			v->Assign(i, ValueToVal( val->val.set_val.vals[i], type ), 0);
+			v->Assign(i, ValueToVal( val->val.set_val.vals[i], type ));
 
 		Unref(vt);
 		return v;
diff --git a/src/modbus-analyzer.pac b/src/modbus-analyzer.pac
index b03df9d188..a9c773b9e9 100644
--- a/src/modbus-analyzer.pac
+++ b/src/modbus-analyzer.pac
@@ -149,7 +149,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i=0; i < ${message.registers}->size(); ++i )
 				{
 				Val* r = new Val(${message.registers[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 			BifEvent::generate_modbus_read_holding_registers_response(connection()->bro_analyzer(),
@@ -192,7 +192,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i=0; i < (${message.registers})->size(); ++i )
 				{
 				Val* r = new Val(${message.registers[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 			BifEvent::generate_modbus_read_input_registers_response(connection()->bro_analyzer(),
@@ -335,7 +335,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i = 0; i < (${message.registers}->size()); ++i )
 				{
 				Val* r = new Val(${message.registers[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 				BifEvent::generate_modbus_write_multiple_registers_request(connection()->bro_analyzer(),
@@ -371,13 +371,13 @@ refine flow ModbusTCP_Flow += {
 			//for ( unsigned int i = 0; i < (${message.references}->size()); ++i )
 			//	{
 			//	Val* r = new Val((${message.references[i].ref_type}), TYPE_COUNT);
-			//	t->Assign(i, r, 0, OP_ASSIGN);
+			//	t->Assign(i, r);
 			//
 			//	Val* k = new Val((${message.references[i].file_num}), TYPE_COUNT);
-			//	t->Assign(i, k, 0, OP_ASSIGN);
+			//	t->Assign(i, k);
 			//
 			//	Val* l = new Val((${message.references[i].record_num}), TYPE_COUNT);
-			//	t->Assign(i, l, 0, OP_ASSIGN);
+			//	t->Assign(i, l);
 			//	}
 
 			BifEvent::generate_modbus_read_file_record_request(connection()->bro_analyzer(),
@@ -398,7 +398,7 @@ refine flow ModbusTCP_Flow += {
 			//	{
 			//	//TODO: work the reference type in here somewhere
 			//	Val* r = new Val(${message.references[i].record_data}), TYPE_COUNT);
-			//	t->Assign(i, r, 0, OP_ASSIGN);
+			//	t->Assign(i, r);
 			//	}
 
 			BifEvent::generate_modbus_read_file_record_response(connection()->bro_analyzer(),
@@ -418,18 +418,18 @@ refine flow ModbusTCP_Flow += {
 			//for ( unsigned int i = 0; i < (${message.references}->size()); ++i )
 			//	{
 			//	Val* r = new Val((${message.references[i].ref_type}), TYPE_COUNT);
-			//	t->Assign(i, r, 0, OP_ASSIGN);
+			//	t->Assign(i, r);
 			//
 			//	Val* k = new Val((${message.references[i].file_num}), TYPE_COUNT);
-			//	t->Assign(i, k, 0, OP_ASSIGN);
+			//	t->Assign(i, k);
 			//
 			//	Val* n = new Val((${message.references[i].record_num}), TYPE_COUNT);
-			//	t->Assign(i, n, 0, OP_ASSIGN);
+			//	t->Assign(i, n);
 			//
 			//	for ( unsigned int j = 0; j < (${message.references[i].register_value}->size()); ++j )
 			//		{
 			//		k = new Val((${message.references[i].register_value[j]}), TYPE_COUNT);
-			//		t->Assign(i, k, 0, OP_ASSIGN);
+			//		t->Assign(i, k);
 			//		}
 			//	}
 
@@ -451,18 +451,18 @@ refine flow ModbusTCP_Flow += {
 			//for ( unsigned int i = 0; i < (${messages.references}->size()); ++i )
 			//	{
 			//	Val* r = new Val((${message.references[i].ref_type}), TYPE_COUNT);
-			//	t->Assign(i, r, 0, OP_ASSIGN);
+			//	t->Assign(i, r);
 			//
 			//	Val* f = new Val((${message.references[i].file_num}), TYPE_COUNT);
-			//	t->Assign(i, f, 0, OP_ASSIGN);
+			//	t->Assign(i, f);
 			//
 			//	Val* rn = new Val((${message.references[i].record_num}), TYPE_COUNT);
-			//	t->Assign(i, rn, 0, OP_ASSIGN);
+			//	t->Assign(i, rn);
 			//
 			//	for ( unsigned int j = 0; j<(${message.references[i].register_value}->size()); ++j )
 			//		{
 			//		Val* k = new Val((${message.references[i].register_value[j]}), TYPE_COUNT);
-			//		t->Assign(i, k, 0, OP_ASSIGN);
+			//		t->Assign(i, k);
 			//		}
 
 			BifEvent::generate_modbus_write_file_record_response(connection()->bro_analyzer(),
@@ -519,7 +519,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i = 0; i < ${message.write_register_values}->size(); ++i )
 				{
 				Val* r = new Val(${message.write_register_values[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 			BifEvent::generate_modbus_read_write_multiple_registers_request(connection()->bro_analyzer(),
@@ -550,7 +550,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i = 0; i < ${message.registers}->size(); ++i )
 				{
 				Val* r = new Val(${message.registers[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 			BifEvent::generate_modbus_read_write_multiple_registers_response(connection()->bro_analyzer(),
@@ -593,7 +593,7 @@ refine flow ModbusTCP_Flow += {
 			for ( unsigned int i = 0; i < (${message.register_data})->size(); ++i )
 				{
 				Val* r = new Val(${message.register_data[i]}, TYPE_COUNT);
-				t->Assign(i, r, 0, OP_ASSIGN);
+				t->Assign(i, r);
 				}
 
 			BifEvent::generate_modbus_read_fifo_queue_response(connection()->bro_analyzer(),
diff --git a/src/strings.bif b/src/strings.bif
index dc5e064dc6..55e2e79c7f 100644
--- a/src/strings.bif
+++ b/src/strings.bif
@@ -866,7 +866,7 @@ function str_split%(s: string, idx: index_vec%): string_vec
 
 		for ( BroString::VecIt it = result->begin();
 		      it != result->end(); ++it, ++i )
-			result_v->Assign(i, new StringVal(*it), 0);
+			result_v->Assign(i, new StringVal(*it));
 			// StringVal now possesses string.
 
 		delete result;