1 files changed, 97 insertions, 65 deletions

diff --git a/indra/llxuixml/llinitparam.cpp b/indra/llxuixml/llinitparam.cpp
index 2c92539387..db72aa19b9 100644
--- a/indra/llxuixml/llinitparam.cpp
+++ b/indra/llxuixml/llinitparam.cpp
@@ -40,7 +40,46 @@ namespace LLInitParam
 	{
 		const U8* my_addr = reinterpret_cast<const U8*>(this);
 		const U8* block_addr = reinterpret_cast<const U8*>(enclosing_block);
-		mEnclosingBlockOffset = (U16)(my_addr - block_addr);
+		mEnclosingBlockOffset = 0x7FFFffff & (U32)(my_addr - block_addr);
+	}
+
+	//
+	// ParamDescriptor
+	//
+	ParamDescriptor::ParamDescriptor(param_handle_t p, 
+									merge_func_t merge_func, 
+									deserialize_func_t deserialize_func, 
+									serialize_func_t serialize_func,
+									validation_func_t validation_func,
+									inspect_func_t inspect_func,
+									S32 min_count,
+									S32 max_count)
+	:	mParamHandle(p),
+		mMergeFunc(merge_func),
+		mDeserializeFunc(deserialize_func),
+		mSerializeFunc(serialize_func),
+		mValidationFunc(validation_func),
+		mInspectFunc(inspect_func),
+		mMinCount(min_count),
+		mMaxCount(max_count),
+		mUserData(NULL)
+	{}
+
+	ParamDescriptor::ParamDescriptor()
+	:	mParamHandle(0),
+		mMergeFunc(NULL),
+		mDeserializeFunc(NULL),
+		mSerializeFunc(NULL),
+		mValidationFunc(NULL),
+		mInspectFunc(NULL),
+		mMinCount(0),
+		mMaxCount(0),
+		mUserData(NULL)
+	{}
+
+	ParamDescriptor::~ParamDescriptor()
+	{
+		delete mUserData;
 	}
 
 	//
@@ -73,14 +112,10 @@ namespace LLInitParam
 		std::copy(src_block_data.mAllParams.begin(), src_block_data.mAllParams.end(), std::back_inserter(mAllParams));
 	}
 
-	//
-	// BaseBlock
-	//
-	BaseBlock::BaseBlock()
-	:	mChangeVersion(0)
-	{}
-
-	BaseBlock::~BaseBlock()
+	BlockDescriptor::BlockDescriptor()
+	:	mMaxParamOffset(0),
+		mInitializationState(UNINITIALIZED),
+		mCurrentBlockPtr(NULL)
 	{}
 
 	// called by each derived class in least to most derived order
@@ -113,9 +148,9 @@ namespace LLInitParam
 		return (param_address - baseblock_address);
 	}
 
-	bool BaseBlock::submitValue(const Parser::name_stack_t& name_stack, Parser& p, bool silent)
+	bool BaseBlock::submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent)
 	{
-		if (!deserializeBlock(p, std::make_pair(name_stack.begin(), name_stack.end())))
+		if (!deserializeBlock(p, std::make_pair(name_stack.begin(), name_stack.end()), true))
 		{
 			if (!silent)
 			{
@@ -145,7 +180,7 @@ namespace LLInitParam
 		return true;
 	}
 
-	bool BaseBlock::serializeBlock(Parser& parser, Parser::name_stack_t name_stack, const LLInitParam::BaseBlock* diff_block) const
+	void BaseBlock::serializeBlock(Parser& parser, Parser::name_stack_t& name_stack, const LLInitParam::BaseBlock* diff_block) const
 	{
 		// named param is one like LLView::Params::follows
 		// unnamed param is like LLView::Params::rect - implicit
@@ -164,8 +199,7 @@ namespace LLInitParam
 				// each param descriptor remembers its serial number
 				// so we can inspect the same param under different names
 				// and see that it has the same number
-				(*it)->mGeneration = parser.newParseGeneration();
-				name_stack.push_back(std::make_pair("", (*it)->mGeneration));
+				name_stack.push_back(std::make_pair("", true));
 				serialize_func(*param, parser, name_stack, diff_param);
 				name_stack.pop_back();
 			}
@@ -201,22 +235,15 @@ namespace LLInitParam
 					continue;
 				}
 
-				if (!duplicate)
-				{
-					it->second->mGeneration = parser.newParseGeneration();
-				}
-
-				name_stack.push_back(std::make_pair(it->first, it->second->mGeneration));
+				name_stack.push_back(std::make_pair(it->first, !duplicate));
 				const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL;
 				serialize_func(*param, parser, name_stack, diff_param);
 				name_stack.pop_back();
 			}
 		}
-
-		return true;
 	}
 
-	bool BaseBlock::inspectBlock(Parser& parser, Parser::name_stack_t name_stack) const
+	bool BaseBlock::inspectBlock(Parser& parser, Parser::name_stack_t name_stack, S32 min_count, S32 max_count) const
 	{
 		// named param is one like LLView::Params::follows
 		// unnamed param is like LLView::Params::rect - implicit
@@ -231,8 +258,7 @@ namespace LLInitParam
 			ParamDescriptor::inspect_func_t inspect_func = (*it)->mInspectFunc;
 			if (inspect_func)
 			{
-				(*it)->mGeneration = parser.newParseGeneration();
-				name_stack.push_back(std::make_pair("", (*it)->mGeneration));
+				name_stack.push_back(std::make_pair("", true));
 				inspect_func(*param, parser, name_stack, (*it)->mMinCount, (*it)->mMaxCount);
 				name_stack.pop_back();
 			}
@@ -260,11 +286,7 @@ namespace LLInitParam
 					}
 				}
 
-				if (!duplicate)
-				{
-					it->second->mGeneration = parser.newParseGeneration();
-				}
-				name_stack.push_back(std::make_pair(it->first, it->second->mGeneration));
+				name_stack.push_back(std::make_pair(it->first, !duplicate));
 				inspect_func(*param, parser, name_stack, it->second->mMinCount, it->second->mMaxCount);
 				name_stack.pop_back();
 			}
@@ -273,14 +295,18 @@ namespace LLInitParam
 		return true;
 	}
 
-	bool BaseBlock::deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack)
+	bool BaseBlock::deserializeBlock(Parser& p, Parser::name_stack_range_t name_stack_range, bool ignored)
 	{
 		BlockDescriptor& block_data = mostDerivedBlockDescriptor();
-		bool names_left = name_stack.first != name_stack.second;
+		bool names_left = name_stack_range.first != name_stack_range.second;
+
+		bool new_name = names_left
+						? name_stack_range.first->second
+						: true;
 
 		if (names_left)
 		{
-			const std::string& top_name = name_stack.first->first;
+			const std::string& top_name = name_stack_range.first->first;
 
 			ParamDescriptor::deserialize_func_t deserialize_func = NULL;
 			Param* paramp = NULL;
@@ -292,9 +318,18 @@ namespace LLInitParam
 				paramp = getParamFromHandle(found_it->second->mParamHandle);
 				deserialize_func = found_it->second->mDeserializeFunc;
 					
-				Parser::name_stack_range_t new_name_stack(name_stack.first, name_stack.second);
+				Parser::name_stack_range_t new_name_stack(name_stack_range.first, name_stack_range.second);
 				++new_name_stack.first;
-				return deserialize_func(*paramp, p, new_name_stack, name_stack.first == name_stack.second ? -1 : name_stack.first->second);
+				if (deserialize_func(*paramp, p, new_name_stack, new_name))
+				{
+					// value is no longer new, we know about it now
+					name_stack_range.first->second = false;
+					return true;
+				}
+				else
+				{
+					return false;
+				}
 			}
 		}
 
@@ -306,42 +341,50 @@ namespace LLInitParam
 			Param* paramp = getParamFromHandle((*it)->mParamHandle);
 			ParamDescriptor::deserialize_func_t deserialize_func = (*it)->mDeserializeFunc;
 
-			if (deserialize_func && deserialize_func(*paramp, p, name_stack, name_stack.first == name_stack.second ? -1 : name_stack.first->second))
+			if (deserialize_func && deserialize_func(*paramp, p, name_stack_range, new_name))
 			{
 				return true;
 			}
 		}
 
+		// if no match, and no names left on stack, this is just an existence assertion of this block
+		// verify by calling readValue with NoParamValue type, an inherently unparseable type
+		if (!names_left)
+		{
+			Flag no_value;
+			return p.readValue(no_value);
+		}
+
 		return false;
 	}
 
 	//static 
-	void BaseBlock::addParam(BlockDescriptor& block_data, const ParamDescriptor& in_param, const char* char_name)
+	void BaseBlock::addParam(BlockDescriptor& block_data, const ParamDescriptorPtr in_param, const char* char_name)
 	{
-		// create a copy of the paramdescriptor in allparams
+		// create a copy of the param descriptor in mAllParams
 		// so other data structures can store a pointer to it
 		block_data.mAllParams.push_back(in_param);
-		ParamDescriptor& param(block_data.mAllParams.back());
+		ParamDescriptorPtr param(block_data.mAllParams.back());
 
 		std::string name(char_name);
-		if ((size_t)param.mParamHandle > block_data.mMaxParamOffset)
+		if ((size_t)param->mParamHandle > block_data.mMaxParamOffset)
 		{
 			llerrs << "Attempted to register param with block defined for parent class, make sure to derive from LLInitParam::Block<YOUR_CLASS, PARAM_BLOCK_BASE_CLASS>" << llendl;
 		}
 
 		if (name.empty())
 		{
-			block_data.mUnnamedParams.push_back(&param);
+			block_data.mUnnamedParams.push_back(param);
 		}
 		else
 		{
 			// don't use insert, since we want to overwrite existing entries
-			block_data.mNamedParams[name] = &param;
+			block_data.mNamedParams[name] = param;
 		}
 
-		if (param.mValidationFunc)
+		if (param->mValidationFunc)
 		{
-			block_data.mValidationList.push_back(std::make_pair(param.mParamHandle, param.mValidationFunc));
+			block_data.mValidationList.push_back(std::make_pair(param->mParamHandle, param->mValidationFunc));
 		}
 	}
 
@@ -359,7 +402,7 @@ namespace LLInitParam
 				llerrs << "Attempted to register param with block defined for parent class, make sure to derive from LLInitParam::Block<YOUR_CLASS, PARAM_BLOCK_BASE_CLASS>" << llendl;
 			}
 
-			ParamDescriptor* param_descriptor = findParamDescriptor(handle);
+			ParamDescriptorPtr param_descriptor = findParamDescriptor(param);
 			if (param_descriptor)
 			{
 				if (synonym.empty())
@@ -374,14 +417,6 @@ namespace LLInitParam
 		}
 	}
 
-	void BaseBlock::setLastChangedParam(const Param& last_param, bool user_provided)
-	{ 
-		if (user_provided)
-		{
-			mChangeVersion++;
-		}
-	}
-
 	const std::string& BaseBlock::getParamName(const BlockDescriptor& block_data, const Param* paramp) const
 	{
 		param_handle_t handle = getHandleFromParam(paramp);
@@ -396,22 +431,23 @@ namespace LLInitParam
 		return LLStringUtil::null;
 	}
 
-	ParamDescriptor* BaseBlock::findParamDescriptor(param_handle_t handle)
+	ParamDescriptorPtr BaseBlock::findParamDescriptor(const Param& param)
 	{
+		param_handle_t handle = getHandleFromParam(&param);
 		BlockDescriptor& descriptor = mostDerivedBlockDescriptor();
 		BlockDescriptor::all_params_list_t::iterator end_it = descriptor.mAllParams.end();
 		for (BlockDescriptor::all_params_list_t::iterator it = descriptor.mAllParams.begin();
 			it != end_it;
 			++it)
 		{
-			if (it->mParamHandle == handle) return &(*it);
+			if ((*it)->mParamHandle == handle) return *it;
 		}
-		return NULL;
+		return ParamDescriptorPtr();
 	}
 
 	// take all provided params from other and apply to self
 	// NOTE: this requires that "other" is of the same derived type as this
-	bool BaseBlock::merge(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
+	bool BaseBlock::mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite)
 	{
 		bool some_param_changed = false;
 		BlockDescriptor::all_params_list_t::const_iterator end_it = block_data.mAllParams.end();
@@ -419,19 +455,15 @@ namespace LLInitParam
 			it != end_it;
 			++it)
 		{
-			const Param* other_paramp = other.getParamFromHandle(it->mParamHandle);
-			ParamDescriptor::merge_func_t merge_func = it->mMergeFunc;
+			const Param* other_paramp = other.getParamFromHandle((*it)->mParamHandle);
+			ParamDescriptor::merge_func_t merge_func = (*it)->mMergeFunc;
 			if (merge_func)
 			{
-				Param* paramp = getParamFromHandle(it->mParamHandle);
+				Param* paramp = getParamFromHandle((*it)->mParamHandle);
+				llassert(paramp->mEnclosingBlockOffset == (*it)->mParamHandle);
 				some_param_changed |= merge_func(*paramp, *other_paramp, overwrite);
 			}
 		}
 		return some_param_changed;
 	}
-
-	bool ParamCompare<LLSD, false>::equals(const LLSD &a, const LLSD &b)
-	{
-		return false;
-	}
 }