/** * @file llinitparam.cpp * @brief parameter block abstraction for creating complex objects and * parsing construction parameters from xml and LLSD * * $LicenseInfo:firstyear=2008&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "linden_common.h" #include "llinitparam.h" #include "llformat.h" namespace LLInitParam { predicate_rule_t default_parse_rules() { return ll_make_predicate(PROVIDED) && !ll_make_predicate(EMPTY); } // // Param // Param::Param(BaseBlock* enclosing_block) : mIsProvided(false) { const U8* my_addr = reinterpret_cast<const U8*>(this); const U8* block_addr = reinterpret_cast<const U8*>(enclosing_block); U32 enclosing_block_offset = 0x7FFFffff & (U32)(my_addr - block_addr); mEnclosingBlockOffsetLow = enclosing_block_offset & 0x0000ffff; mEnclosingBlockOffsetHigh = (enclosing_block_offset & 0x007f0000) >> 16; } // // 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; } // // Parser // Parser::~Parser() {} void Parser::parserWarning(const std::string& message) { if (mParseSilently) return; LL_WARNS() << message << LL_ENDL; } void Parser::parserError(const std::string& message) { if (mParseSilently) return; LL_ERRS() << message << LL_ENDL; } // // BlockDescriptor // void BlockDescriptor::aggregateBlockData(BlockDescriptor& src_block_data) { mNamedParams.insert(src_block_data.mNamedParams.begin(), src_block_data.mNamedParams.end()); std::copy(src_block_data.mUnnamedParams.begin(), src_block_data.mUnnamedParams.end(), std::back_inserter(mUnnamedParams)); std::copy(src_block_data.mValidationList.begin(), src_block_data.mValidationList.end(), std::back_inserter(mValidationList)); std::copy(src_block_data.mAllParams.begin(), src_block_data.mAllParams.end(), std::back_inserter(mAllParams)); } void BlockDescriptor::addParam(const ParamDescriptorPtr in_param, const char* char_name) { // create a copy of the param descriptor in mAllParams // so other data structures can store a pointer to it mAllParams.push_back(in_param); ParamDescriptorPtr param(mAllParams.back()); std::string name(char_name); if ((size_t)param->mParamHandle > mMaxParamOffset) { LL_ERRS() << "Attempted to register param with block defined for parent class, make sure to derive from LLInitParam::Block<YOUR_CLASS, PARAM_BLOCK_BASE_CLASS>" << LL_ENDL; } if (name.empty()) { mUnnamedParams.push_back(param); } else { // don't use insert, since we want to overwrite existing entries mNamedParams[name] = param; } if (param->mValidationFunc) { mValidationList.push_back(std::make_pair(param->mParamHandle, param->mValidationFunc)); } } BlockDescriptor::BlockDescriptor() : mMaxParamOffset(0), mInitializationState(UNINITIALIZED), mCurrentBlockPtr(NULL) {} // called by each derived class in least to most derived order void BaseBlock::init(BlockDescriptor& descriptor, BlockDescriptor& base_descriptor, size_t block_size) { descriptor.mCurrentBlockPtr = this; descriptor.mMaxParamOffset = block_size; switch(descriptor.mInitializationState) { case BlockDescriptor::UNINITIALIZED: // copy params from base class here descriptor.aggregateBlockData(base_descriptor); descriptor.mInitializationState = BlockDescriptor::INITIALIZING; break; case BlockDescriptor::INITIALIZING: descriptor.mInitializationState = BlockDescriptor::INITIALIZED; break; case BlockDescriptor::INITIALIZED: // nothing to do break; } } param_handle_t BaseBlock::getHandleFromParam(const Param* param) const { const U8* param_address = reinterpret_cast<const U8*>(param); const U8* baseblock_address = reinterpret_cast<const U8*>(this); return (param_address - baseblock_address); } bool BaseBlock::submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent) { Parser::name_stack_range_t range = std::make_pair(name_stack.begin(), name_stack.end()); if (!deserializeBlock(p, range, true)) { if (!silent) { p.parserWarning(llformat("Failed to parse parameter \"%s\"", p.getCurrentElementName().c_str())); } return false; } return true; } bool BaseBlock::validateBlock(bool emit_errors) const { // only validate block when it hasn't already passed validation with current data if (!mValidated) { const BlockDescriptor& block_data = mostDerivedBlockDescriptor(); for (const BlockDescriptor::param_validation_list_t::value_type& pair : block_data.mValidationList) { const Param* param = getParamFromHandle(pair.first); if (!pair.second(param)) { if (emit_errors) { LL_WARNS() << "Invalid param \"" << getParamName(block_data, param) << "\"" << LL_ENDL; } return false; } } mValidated = true; } return mValidated; } bool BaseBlock::serializeBlock(Parser& parser, Parser::name_stack_t& name_stack, const predicate_rule_t predicate_rule, const LLInitParam::BaseBlock* diff_block) const { bool serialized = false; if (!predicate_rule.check(ll_make_predicate(PROVIDED, isProvided()))) { return false; } // named param is one like LLView::Params::follows // unnamed param is like LLView::Params::rect - implicit const BlockDescriptor& block_data = mostDerivedBlockDescriptor(); for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams) { param_handle_t param_handle = ptr->mParamHandle; const Param* param = getParamFromHandle(param_handle); ParamDescriptor::serialize_func_t serialize_func = ptr->mSerializeFunc; if (serialize_func && predicate_rule.check(ll_make_predicate(PROVIDED, param->anyProvided()))) { const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL; serialized |= serialize_func(*param, parser, name_stack, predicate_rule, diff_param); } } for (const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams) { param_handle_t param_handle = pair.second->mParamHandle; const Param* param = getParamFromHandle(param_handle); ParamDescriptor::serialize_func_t serialize_func = pair.second->mSerializeFunc; if (serialize_func && predicate_rule.check(ll_make_predicate(PROVIDED, param->anyProvided()))) { // Ensure this param has not already been serialized // Prevents <rect> from being serialized as its own tag. bool duplicate = false; for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams) { if (param_handle == ptr->mParamHandle) { duplicate = true; break; } } //FIXME: for now, don't attempt to serialize values under synonyms, as current parsers // don't know how to detect them if (duplicate) { continue; } name_stack.push_back(std::make_pair(pair.first, !duplicate)); const Param* diff_param = diff_block ? diff_block->getParamFromHandle(param_handle) : NULL; serialized |= serialize_func(*param, parser, name_stack, predicate_rule, diff_param); name_stack.pop_back(); } } if (!serialized && predicate_rule.check(ll_make_predicate(EMPTY))) { serialized |= parser.writeValue(Flag(), name_stack); } // was anything serialized in this block? return serialized; } 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 const BlockDescriptor& block_data = mostDerivedBlockDescriptor(); for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams) { param_handle_t param_handle = ptr->mParamHandle; const Param* param = getParamFromHandle(param_handle); ParamDescriptor::inspect_func_t inspect_func = ptr->mInspectFunc; if (inspect_func) { name_stack.push_back(std::make_pair("", true)); inspect_func(*param, parser, name_stack, ptr->mMinCount, ptr->mMaxCount); name_stack.pop_back(); } } for(const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams) { param_handle_t param_handle = pair.second->mParamHandle; const Param* param = getParamFromHandle(param_handle); ParamDescriptor::inspect_func_t inspect_func = pair.second->mInspectFunc; if (inspect_func) { // Ensure this param has not already been inspected bool duplicate = false; for (const ParamDescriptorPtr &ptr : block_data.mUnnamedParams) { if (param_handle == ptr->mParamHandle) { duplicate = true; break; } } name_stack.push_back(std::make_pair(pair.first, !duplicate)); inspect_func(*param, parser, name_stack, pair.second->mMinCount, pair.second->mMaxCount); name_stack.pop_back(); } } return true; } bool BaseBlock::deserializeBlock(Parser& p, Parser::name_stack_range_t& name_stack_range, bool ignored) { BlockDescriptor& block_data = mostDerivedBlockDescriptor(); 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_range.first->first; BlockDescriptor::param_map_t::iterator found_it = block_data.mNamedParams.find(top_name); if (found_it != block_data.mNamedParams.end()) { // find pointer to member parameter from offset table Param* paramp = getParamFromHandle(found_it->second->mParamHandle); ParamDescriptor::deserialize_func_t deserialize_func = found_it->second->mDeserializeFunc; Parser::name_stack_range_t new_name_stack(name_stack_range.first, name_stack_range.second); ++new_name_stack.first; 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; } } } // try to parse unnamed parameters, in declaration order for (ParamDescriptorPtr& ptr : block_data.mUnnamedParams) { Param* paramp = getParamFromHandle(ptr->mParamHandle); ParamDescriptor::deserialize_func_t deserialize_func = ptr->mDeserializeFunc; 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; } void BaseBlock::addSynonym(Param& param, const std::string& synonym) { BlockDescriptor& block_data = mostDerivedBlockDescriptor(); if (block_data.mInitializationState == BlockDescriptor::INITIALIZING) { param_handle_t handle = getHandleFromParam(¶m); // check for invalid derivation from a paramblock (i.e. without using // Block<T, Base_Class> if ((size_t)handle > block_data.mMaxParamOffset) { LL_ERRS() << "Attempted to register param with block defined for parent class, make sure to derive from LLInitParam::Block<YOUR_CLASS, PARAM_BLOCK_BASE_CLASS>" << LL_ENDL; } ParamDescriptorPtr param_descriptor = findParamDescriptor(param); if (param_descriptor) { if (synonym.empty()) { block_data.mUnnamedParams.push_back(param_descriptor); } else { block_data.mNamedParams[synonym] = param_descriptor; } } } } const std::string& BaseBlock::getParamName(const BlockDescriptor& block_data, const Param* paramp) const { param_handle_t handle = getHandleFromParam(paramp); for (BlockDescriptor::param_map_t::const_iterator it = block_data.mNamedParams.begin(); it != block_data.mNamedParams.end(); ++it) { if (it->second->mParamHandle == handle) { return it->first; } } return LLStringUtil::null; } ParamDescriptorPtr BaseBlock::findParamDescriptor(const Param& param) { param_handle_t handle = getHandleFromParam(¶m); BlockDescriptor& descriptor = mostDerivedBlockDescriptor(); for (ParamDescriptorPtr& ptr : descriptor.mAllParams) { if (ptr->mParamHandle == handle) return ptr; } 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::mergeBlock(BlockDescriptor& block_data, const BaseBlock& other, bool overwrite) { bool some_param_changed = false; for (const ParamDescriptorPtr& ptr : block_data.mAllParams) { const Param* other_paramp = other.getParamFromHandle(ptr->mParamHandle); ParamDescriptor::merge_func_t merge_func = ptr->mMergeFunc; if (merge_func) { Param* paramp = getParamFromHandle(ptr->mParamHandle); llassert(paramp->getEnclosingBlockOffset() == ptr->mParamHandle); some_param_changed |= merge_func(*paramp, *other_paramp, overwrite); } } return some_param_changed; } }