livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'main' into DRTVWR-580-maint-T 

# Conflicts:
#	doc/contributions.txt
#	indra/llcharacter/llkeyframemotion.cpp
#	indra/newview/llfilepicker.cpp
master
Andrey Lihatskiy 2023-05-17 17:47:45 +03:00
parent 42f16180a9 5a70639b79
commit 4dcab10bf8
700 changed files with 25364 additions and 61273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
.github/workflows/stale.yaml vendored Normal file
View File

@ -0,0 +1,24 @@
name: Stale PRs
on:
workflow_dispatch:
schedule:
- cron: 0 0 * * *
permissions:
issues: write
pull-requests: write
jobs:
stale:
runs-on: ubuntu-latest
steps:
- uses: actions/stale@v6
id: stale
with:
stale-pr-message: This pull request is stale because it has been open 60 days with no activity. Remove stale label or comment or it will be closed in 7 days
days-before-stale: 60
days-before-close: 7
exempt-pr-labels: blocked,must,should,keep
stale-pr-label: stale
- name: Print outputs
run: echo ${{ join(steps.stale.outputs.*, ',') }}

44
autobuild.xml
View File

@ -611,9 +611,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>8de71c518c248d77f70f87ab5e9de732</string>
<string>5a1d52ec3981292855a179be86988a02</string>
<key>url</key>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/105828/925920/fmodstudio-2.02.06.575716-darwin64-575716.tar.bz2</string>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/112152/972159/fmodstudio-2.02.13.578928-darwin64-578928.tar.bz2</string>
</map>
<key>name</key>
<string>darwin64</string>
@ -635,9 +635,9 @@
<key>archive</key>
<map>
<key>hash</key>
<string>2eea946ee7a572b748cec0c623ade3ef</string>
<string>8594ec180b73be42d37b6f93ac59ab4a</string>
<key>url</key>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/105830/925932/fmodstudio-2.02.06.575716-windows-575716.tar.bz2</string>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/112153/972171/fmodstudio-2.02.13.578928-windows-578928.tar.bz2</string>
</map>
<key>name</key>
<string>windows</string>
@ -647,16 +647,16 @@
<key>archive</key>
<map>
<key>hash</key>
<string>483d6fd5d057b0a681bffef9b8b9d927</string>
<string>46941a2610f83c353e551d300e536c54</string>
<key>url</key>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/105829/925931/fmodstudio-2.02.06.575716-windows64-575716.tar.bz2</string>
<string>https://s3-proxy.lindenlab.com/private-builds-secondlife-com/ct2/112154/972170/fmodstudio-2.02.13.578928-windows64-578928.tar.bz2</string>
</map>
<key>name</key>
<string>windows64</string>
</map>
</map>
<key>version</key>
<string>2.02.06.575716</string>
<string>2.02.13.578928</string>
</map>
<key>fontconfig</key>
<map>
@ -2845,6 +2845,36 @@ Copyright (c) 2012, 2014, 2015, 2016 nghttp2 contributors</string>
<key>version</key>
<string>0.54.1.555529</string>
</map>
<key>xxhash</key>
<map>
<key>copyright</key>
<string>Copyright 2012-2020 Yann Collet</string>
<key>description</key>
<string>xxHash Extremely fast hash algorithm</string>
<key>license</key>
<string>bsd</string>
<key>license_file</key>
<string>LICENSES/xxhash.txt</string>
<key>name</key>
<string>xxhash</string>
<key>platforms</key>
<map>
<key>common</key>
<map>
<key>archive</key>
<map>
<key>hash</key>
<string>e4f77ba0a9b8ec3cc3fabc51c4da81d2</string>
<key>url</key>
<string>https://automated-builds-secondlife-com.s3.amazonaws.com/ct2/110070/956941/xxhash-0.8.1.578006-windows-578006.tar.bz2</string>
</map>
<key>name</key>
<string>common</string>
</map>
</map>
<key>version</key>
<string>0.8.1</string>
</map>
<key>zlib-ng</key>
<map>
<key>canonical_repo</key>

9
doc/contributions.txt
View File

@ -237,6 +237,7 @@ Ansariel Hiller
SL-15227
SL-15398
SL-18432
SL-4126
Aralara Rajal
Arare Chantilly
CHUIBUG-191
@ -287,6 +288,7 @@ Beq Janus
SL-18592
SL-18637
SL-19317
SL-19660
Beth Walcher
Bezilon Kasei
Biancaluce Robbiani
@ -495,6 +497,8 @@ Evangelista Emerald
Faelon Swordthain
Farallon Greyskin
VWR-2036
Fawrsk
SL-18893
Feep Larsson
VWR-447
VWR-1314
@ -587,6 +591,8 @@ Henri Beauchamp
VWR-1320
VWR-1406
VWR-4157
SL-15175
SL-19110
herina Bode
Hikkoshi Sakai
VWR-429
@ -1178,6 +1184,9 @@ Orenj Marat
Orion Delphis
Oryx Tempel
PanteraPolnocy
SL-18891
SL-18904
SL-18937
SL-19681
Parvati Silverweb
Patric Mills

1
indra/cmake/LLCommon.cmake
View File

@ -4,6 +4,7 @@ include(APR)
include(Boost)
include(EXPAT)
include(Tracy)
include(xxHash)
include(ZLIBNG)
include(JsonCpp)

10
indra/cmake/Variables.cmake
View File

@ -63,7 +63,7 @@ if (EXISTS ${CMAKE_SOURCE_DIR}/Server.cmake)
set(INSTALL_PROPRIETARY ON CACHE BOOL "Install proprietary binaries")
endif (EXISTS ${CMAKE_SOURCE_DIR}/Server.cmake)
set(TEMPLATE_VERIFIER_OPTIONS "" CACHE STRING "Options for scripts/template_verifier.py")
set(TEMPLATE_VERIFIER_MASTER_URL "https://bitbucket.org/lindenlab/master-message-template-git/raw/master/message_template.msg" CACHE STRING "Location of the master message template")
set(TEMPLATE_VERIFIER_MASTER_URL "https://github.com/secondlife/master-message-template/raw/master/message_template.msg" CACHE STRING "Location of the master message template")
if (NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
@ -191,9 +191,15 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
# development must be done after the build as we do in viewer_manifest.py for
# released builds
# https://stackoverflow.com/a/54296008
# With Xcode 14.1, apparently you must take drastic steps to prevent
# implicit signing.
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED NO)
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED NO)
# "-" represents "Sign to Run Locally" and empty string represents "Do Not Sign"
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "")
set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS "")
set(CMAKE_XCODE_ATTRIBUTE_DISABLE_MANUAL_TARGET_ORDER_BUILD_WARNING YES)
set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION NO)
set(CMAKE_OSX_ARCHITECTURES "${ARCH}")
string(REPLACE "i686" "i386" CMAKE_OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}")
string(REPLACE "AMD64" "x86_64" CMAKE_OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}")

8
indra/cmake/xxHash.cmake Normal file
View File

@ -0,0 +1,8 @@
# -*- cmake -*-
if (XXHASH_CMAKE_INCLUDED)
return()
endif (XXHASH_CMAKE_INCLUDED)
set (XXHASH_CMAKE_INCLUDED TRUE)
include(Prebuilt)
use_prebuilt_binary(xxhash)

136
indra/llappearance/llavatarappearance.cpp
View File

@ -214,12 +214,10 @@ void LLAvatarAppearance::initInstance()
mRoot = createAvatarJoint();
mRoot->setName( "mRoot" );
for (LLAvatarAppearanceDictionary::MeshEntries::const_iterator iter = sAvatarDictionary->getMeshEntries().begin();
iter != sAvatarDictionary->getMeshEntries().end();
++iter)
for (const LLAvatarAppearanceDictionary::MeshEntries::value_type& mesh_pair : sAvatarDictionary->getMeshEntries())
{
const EMeshIndex mesh_index = iter->first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = iter->second;
const EMeshIndex mesh_index = mesh_pair.first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = mesh_pair.second;
LLAvatarJoint* joint = createAvatarJoint();
joint->setName(mesh_dict->mName);
joint->setMeshID(mesh_index);
@ -260,21 +258,16 @@ void LLAvatarAppearance::initInstance()
//-------------------------------------------------------------------------
// associate baked textures with meshes
//-------------------------------------------------------------------------
for (LLAvatarAppearanceDictionary::MeshEntries::const_iterator iter = sAvatarDictionary->getMeshEntries().begin();
iter != sAvatarDictionary->getMeshEntries().end();
++iter)
for (const LLAvatarAppearanceDictionary::MeshEntries::value_type& mesh_pair : sAvatarDictionary->getMeshEntries())
{
const EMeshIndex mesh_index = iter->first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = iter->second;
const EMeshIndex mesh_index = mesh_pair.first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = mesh_pair.second;
const EBakedTextureIndex baked_texture_index = mesh_dict->mBakedID;
// Skip it if there's no associated baked texture.
if (baked_texture_index == BAKED_NUM_INDICES) continue;
for (avatar_joint_mesh_list_t::iterator iter = mMeshLOD[mesh_index]->mMeshParts.begin();
iter != mMeshLOD[mesh_index]->mMeshParts.end();
++iter)
for (LLAvatarJointMesh* mesh : mMeshLOD[mesh_index]->mMeshParts)
{
LLAvatarJointMesh* mesh = (*iter);
mBakedTextureDatas[(S32)baked_texture_index].mJointMeshes.push_back(mesh);
}
}
@ -297,10 +290,8 @@ LLAvatarAppearance::~LLAvatarAppearance()
delete_and_clear(mBakedTextureDatas[i].mTexLayerSet);
mBakedTextureDatas[i].mJointMeshes.clear();
for (morph_list_t::iterator iter2 = mBakedTextureDatas[i].mMaskedMorphs.begin();
iter2 != mBakedTextureDatas[i].mMaskedMorphs.end(); iter2++)
for (LLMaskedMorph* masked_morph : mBakedTextureDatas[i].mMaskedMorphs)
{
LLMaskedMorph* masked_morph = (*iter2);
delete masked_morph;
}
}
@ -319,11 +310,8 @@ LLAvatarAppearance::~LLAvatarAppearance()
std::for_each(mPolyMeshes.begin(), mPolyMeshes.end(), DeletePairedPointer());
mPolyMeshes.clear();
for (avatar_joint_list_t::iterator jointIter = mMeshLOD.begin();
jointIter != mMeshLOD.end();
++jointIter)
for (LLAvatarJoint* joint : mMeshLOD)
{
LLAvatarJoint* joint = *jointIter;
std::for_each(joint->mMeshParts.begin(), joint->mMeshParts.end(), DeletePointer());
joint->mMeshParts.clear();
}
@ -477,10 +465,9 @@ void LLAvatarAppearance::compareJointStateMaps(joint_state_map_t& last_state,
if (!last_state.empty() && (last_state != curr_state))
{
S32 diff_count = 0;
joint_state_map_t::iterator it;
for (it=last_state.begin(); it != last_state.end(); ++it)
for (joint_state_map_t::value_type& pair : last_state)
{
const std::string& key = it->first;
const std::string& key = pair.first;
if (last_state[key] != curr_state[key])
{
LL_DEBUGS("AvatarBodySize") << "BodySize change " << key << " " << last_state[key] << "->" << curr_state[key] << LL_ENDL;
@ -690,10 +677,8 @@ BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent
// setup children
LLAvatarBoneInfo::bones_t::const_iterator iter;
for (iter = info->mChildren.begin(); iter != info->mChildren.end(); ++iter)
for (LLAvatarBoneInfo* child_info : info->mChildren)
{
LLAvatarBoneInfo *child_info = *iter;
if (!setupBone(child_info, joint, volume_num, joint_num))
{
return FALSE;
@ -745,10 +730,8 @@ BOOL LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
S32 current_joint_num = 0;
S32 current_volume_num = 0;
LLAvatarSkeletonInfo::bone_info_list_t::const_iterator iter;
for (iter = info->mBoneInfoList.begin(); iter != info->mBoneInfoList.end(); ++iter)
for (LLAvatarBoneInfo* bone_info : info->mBoneInfoList)
{
LLAvatarBoneInfo *bone_info = *iter;
if (!setupBone(bone_info, NULL, current_volume_num, current_joint_num))
{
LL_ERRS() << "Error parsing bone in skeleton file" << LL_ENDL;
@ -826,14 +809,10 @@ void LLAvatarAppearance::buildCharacter()
//-------------------------------------------------------------------------
// clear mesh data
//-------------------------------------------------------------------------
for (avatar_joint_list_t::iterator jointIter = mMeshLOD.begin();
jointIter != mMeshLOD.end(); ++jointIter)
for (LLAvatarJoint* joint : mMeshLOD)
{
LLAvatarJoint* joint = *jointIter;
for (avatar_joint_mesh_list_t::iterator meshIter = joint->mMeshParts.begin();
meshIter != joint->mMeshParts.end(); ++meshIter)
for (LLAvatarJointMesh* mesh : joint->mMeshParts)
{
LLAvatarJointMesh * mesh = *meshIter;
mesh->setMesh(NULL);
}
}
@ -1007,12 +986,8 @@ BOOL LLAvatarAppearance::loadAvatar()
}
// avatar_lad.xml : <morph_masks>
for (LLAvatarXmlInfo::morph_info_list_t::iterator iter = sAvatarXmlInfo->mMorphMaskInfoList.begin();
iter != sAvatarXmlInfo->mMorphMaskInfoList.end();
++iter)
for (LLAvatarXmlInfo::LLAvatarMorphInfo* info : sAvatarXmlInfo->mMorphMaskInfoList)
{
LLAvatarXmlInfo::LLAvatarMorphInfo *info = *iter;
EBakedTextureIndex baked = sAvatarDictionary->findBakedByRegionName(info->mRegion);
if (baked != BAKED_NUM_INDICES)
{
@ -1031,11 +1006,8 @@ BOOL LLAvatarAppearance::loadAvatar()
loadLayersets();
// avatar_lad.xml : <driver_parameters>
for (LLAvatarXmlInfo::driver_info_list_t::iterator iter = sAvatarXmlInfo->mDriverInfoList.begin();
iter != sAvatarXmlInfo->mDriverInfoList.end();
++iter)
for (LLDriverParamInfo* info : sAvatarXmlInfo->mDriverInfoList)
{
LLDriverParamInfo *info = *iter;
LLDriverParam* driver_param = new LLDriverParam( this );
if (driver_param->setInfo(info))
{
@ -1067,11 +1039,8 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
mRoot->addChild( mSkeleton[0] );
// make meshes children before calling parent version of the function
for (avatar_joint_list_t::iterator iter = mMeshLOD.begin();
iter != mMeshLOD.end();
++iter)
for (LLAvatarJoint* joint : mMeshLOD)
{
LLAvatarJoint *joint = *iter;
joint->mUpdateXform = FALSE;
joint->setMeshesToChildren();
}
@ -1103,12 +1072,9 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
// SKELETAL DISTORTIONS
{
LLAvatarXmlInfo::skeletal_distortion_info_list_t::iterator iter;
for (iter = sAvatarXmlInfo->mSkeletalDistortionInfoList.begin();
iter != sAvatarXmlInfo->mSkeletalDistortionInfoList.end();
++iter)
for (LLViewerVisualParamInfo* visual_param_info : sAvatarXmlInfo->mSkeletalDistortionInfoList)
{
LLPolySkeletalDistortionInfo *info = (LLPolySkeletalDistortionInfo*)*iter;
LLPolySkeletalDistortionInfo *info = (LLPolySkeletalDistortionInfo*)visual_param_info;
LLPolySkeletalDistortion *param = new LLPolySkeletalDistortion(this);
if (!param->setInfo(info))
{
@ -1132,11 +1098,8 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
//-----------------------------------------------------------------------------
BOOL LLAvatarAppearance::loadMeshNodes()
{
for (LLAvatarXmlInfo::mesh_info_list_t::const_iterator meshinfo_iter = sAvatarXmlInfo->mMeshInfoList.begin();
meshinfo_iter != sAvatarXmlInfo->mMeshInfoList.end();
++meshinfo_iter)
for (const LLAvatarXmlInfo::LLAvatarMeshInfo* info : sAvatarXmlInfo->mMeshInfoList)
{
const LLAvatarXmlInfo::LLAvatarMeshInfo *info = *meshinfo_iter;
const std::string &type = info->mType;
S32 lod = info->mLOD;
@ -1148,12 +1111,10 @@ BOOL LLAvatarAppearance::loadMeshNodes()
switch(lod)
case 0:
mesh = &mHairMesh0; */
for (LLAvatarAppearanceDictionary::MeshEntries::const_iterator mesh_iter = sAvatarDictionary->getMeshEntries().begin();
mesh_iter != sAvatarDictionary->getMeshEntries().end();
++mesh_iter)
for (const LLAvatarAppearanceDictionary::MeshEntries::value_type& mesh_pair : sAvatarDictionary->getMeshEntries())
{
const EMeshIndex mesh_index = mesh_iter->first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = mesh_iter->second;
const EMeshIndex mesh_index = mesh_pair.first;
const LLAvatarAppearanceDictionary::MeshEntry *mesh_dict = mesh_pair.second;
if (type.compare(mesh_dict->mName) == 0)
{
mesh_id = mesh_index;
@ -1221,20 +1182,17 @@ BOOL LLAvatarAppearance::loadMeshNodes()
mesh->setMesh( poly_mesh );
mesh->setLOD( info->mMinPixelArea );
for (LLAvatarXmlInfo::LLAvatarMeshInfo::morph_info_list_t::const_iterator xmlinfo_iter = info->mPolyMorphTargetInfoList.begin();
xmlinfo_iter != info->mPolyMorphTargetInfoList.end();
++xmlinfo_iter)
for (const LLAvatarXmlInfo::LLAvatarMeshInfo::morph_info_pair_t& info_pair : info->mPolyMorphTargetInfoList)
{
const LLAvatarXmlInfo::LLAvatarMeshInfo::morph_info_pair_t *info_pair = &(*xmlinfo_iter);
LLPolyMorphTarget *param = new LLPolyMorphTarget(mesh->getMesh());
if (!param->setInfo((LLPolyMorphTargetInfo*)info_pair->first))
if (!param->setInfo((LLPolyMorphTargetInfo*)info_pair.first))
{
delete param;
return FALSE;
}
else
{
if (info_pair->second)
if (info_pair.second)
{
addSharedVisualParam(param);
param->setParamLocation(isSelf() ? LOC_AV_SELF : LOC_AV_OTHER);
@ -1257,11 +1215,8 @@ BOOL LLAvatarAppearance::loadMeshNodes()
BOOL LLAvatarAppearance::loadLayersets()
{
BOOL success = TRUE;
for (LLAvatarXmlInfo::layer_info_list_t::const_iterator layerset_iter = sAvatarXmlInfo->mLayerInfoList.begin();
layerset_iter != sAvatarXmlInfo->mLayerInfoList.end();
++layerset_iter)
for (LLTexLayerSetInfo* layerset_info : sAvatarXmlInfo->mLayerInfoList)
{
LLTexLayerSetInfo *layerset_info = *layerset_iter;
if (isSelf())
{
// Construct a layerset for each one specified in avatar_lad.xml and initialize it as such.
@ -1277,14 +1232,12 @@ BOOL LLAvatarAppearance::loadLayersets()
// scan baked textures and associate the layerset with the appropriate one
EBakedTextureIndex baked_index = BAKED_NUM_INDICES;
for (LLAvatarAppearanceDictionary::BakedTextures::const_iterator baked_iter = sAvatarDictionary->getBakedTextures().begin();
baked_iter != sAvatarDictionary->getBakedTextures().end();
++baked_iter)
for (const LLAvatarAppearanceDictionary::BakedTextures::value_type& baked_pair : sAvatarDictionary->getBakedTextures())
{
const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = baked_iter->second;
const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = baked_pair.second;
if (layer_set->isBodyRegion(baked_dict->mName))
{
baked_index = baked_iter->first;
baked_index = baked_pair.first;
// ensure both structures are aware of each other
mBakedTextureDatas[baked_index].mTexLayerSet = layer_set;
layer_set->setBakedTexIndex(baked_index);
@ -1300,11 +1253,8 @@ BOOL LLAvatarAppearance::loadLayersets()
}
// scan morph masks and let any affected layers know they have an associated morph
for (LLAvatarAppearance::morph_list_t::const_iterator morph_iter = mBakedTextureDatas[baked_index].mMaskedMorphs.begin();
morph_iter != mBakedTextureDatas[baked_index].mMaskedMorphs.end();
++morph_iter)
for (LLMaskedMorph* morph : mBakedTextureDatas[baked_index].mMaskedMorphs)
{
LLMaskedMorph *morph = *morph_iter;
LLTexLayerInterface* layer = layer_set->findLayerByName(morph->mLayer);
if (layer)
{
@ -1320,7 +1270,6 @@ BOOL LLAvatarAppearance::loadLayersets()
else // !isSelf()
{
// Construct a layerset for each one specified in avatar_lad.xml and initialize it as such.
LLTexLayerSetInfo *layerset_info = *layerset_iter;
layerset_info->createVisualParams(this);
}
}
@ -1747,13 +1696,13 @@ void LLAvatarAppearance::makeJointAliases(LLAvatarBoneInfo *bone_info)
boost::char_separator<char> sep(" ");
boost::tokenizer<boost::char_separator<char> > tok(aliases, sep);
for(boost::tokenizer<boost::char_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i)
for(const std::string& i : tok)
{
if ( mJointAliasMap.find(*i) != mJointAliasMap.end() )
if ( mJointAliasMap.find(i) != mJointAliasMap.end() )
{
LL_WARNS() << "avatar skeleton: Joint alias \"" << *i << "\" remapped from " << mJointAliasMap[*i] << " to " << bone_name << LL_ENDL;
LL_WARNS() << "avatar skeleton: Joint alias \"" << i << "\" remapped from " << mJointAliasMap[i] << " to " << bone_name << LL_ENDL;
}
mJointAliasMap[*i] = bone_name;
mJointAliasMap[i] = bone_name;
}
for (LLAvatarBoneInfo* bone : bone_info->mChildren)
@ -1768,21 +1717,14 @@ const LLAvatarAppearance::joint_alias_map_t& LLAvatarAppearance::getJointAliases
if (mJointAliasMap.empty())
{
LLAvatarSkeletonInfo::bone_info_list_t::const_iterator iter;
for (iter = sAvatarSkeletonInfo->mBoneInfoList.begin();
iter != sAvatarSkeletonInfo->mBoneInfoList.end();
++iter)
for (LLAvatarBoneInfo* bone_info : sAvatarSkeletonInfo->mBoneInfoList)
{
//LLAvatarBoneInfo *bone_info = *iter;
makeJointAliases( *iter );
makeJointAliases(bone_info);
}
LLAvatarXmlInfo::attachment_info_list_t::iterator attach_iter;
for (attach_iter = sAvatarXmlInfo->mAttachmentInfoList.begin();
attach_iter != sAvatarXmlInfo->mAttachmentInfoList.end();
++attach_iter)
for (LLAvatarXmlInfo::LLAvatarAttachmentInfo* info : sAvatarXmlInfo->mAttachmentInfoList)
{
LLAvatarXmlInfo::LLAvatarAttachmentInfo *info = *attach_iter;
std::string bone_name = info->mName;
// Also accept the name with spaces substituted with

5
indra/llappearance/llavatarappearance.h
View File

@ -387,10 +387,9 @@ protected:
LLAvatarMeshInfo() : mLOD(0), mMinPixelArea(.1f) {}
~LLAvatarMeshInfo()
{
morph_info_list_t::iterator iter;
for (iter = mPolyMorphTargetInfoList.begin(); iter != mPolyMorphTargetInfoList.end(); iter++)
for (morph_info_list_t::value_type& pair : mPolyMorphTargetInfoList)
{
delete iter->first;
delete pair.first;
}
mPolyMorphTargetInfoList.clear();
}

11
indra/llappearance/llavatarappearancedefines.cpp
View File

@ -183,18 +183,15 @@ LLAvatarAppearanceDictionary::~LLAvatarAppearanceDictionary()
// map it to the baked texture.
void LLAvatarAppearanceDictionary::createAssociations()
{
for (BakedTextures::const_iterator iter = mBakedTextures.begin(); iter != mBakedTextures.end(); iter++)
for (BakedTextures::value_type& baked_pair : mBakedTextures)
{
const EBakedTextureIndex baked_index = (iter->first);
const BakedEntry *dict = (iter->second);
const EBakedTextureIndex baked_index = baked_pair.first;
const BakedEntry *dict = baked_pair.second;
// For each texture that this baked texture index affects, associate those textures
// with this baked texture index.
for (texture_vec_t::const_iterator local_texture_iter = dict->mLocalTextures.begin();
local_texture_iter != dict->mLocalTextures.end();
local_texture_iter++)
for (const ETextureIndex local_texture_index : dict->mLocalTextures)
{
const ETextureIndex local_texture_index = (ETextureIndex) *local_texture_iter;
mTextures[local_texture_index]->mIsUsedByBakedTexture = true;
mTextures[local_texture_index]->mBakedTextureIndex = baked_index;
}

45
indra/llappearance/llavatarjoint.cpp
View File

@ -100,10 +100,9 @@ void LLAvatarJoint::setValid( BOOL valid, BOOL recursive )
//----------------------------------------------------------------
if (recursive)
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->setValid(valid, TRUE);
}
}
@ -118,10 +117,9 @@ void LLAvatarJoint::setSkeletonComponents( U32 comp, BOOL recursive )
mComponents = comp;
if (recursive)
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (auto child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->setSkeletonComponents(comp, recursive);
}
}
@ -133,10 +131,9 @@ void LLAvatarJoint::setVisible(BOOL visible, BOOL recursive)
if (recursive)
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->setVisible(visible, recursive);
}
}
@ -144,30 +141,27 @@ void LLAvatarJoint::setVisible(BOOL visible, BOOL recursive)
void LLAvatarJoint::updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pixel_area)
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->updateFaceSizes(num_vertices, num_indices, pixel_area);
}
}
void LLAvatarJoint::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind, bool terse_update)
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->updateFaceData(face, pixel_area, damp_wind, terse_update);
}
}
void LLAvatarJoint::updateJointGeometry()
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->updateJointGeometry();
}
}
@ -178,10 +172,9 @@ BOOL LLAvatarJoint::updateLOD(F32 pixel_area, BOOL activate)
BOOL lod_changed = FALSE;
BOOL found_lod = FALSE;
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
F32 jointLOD = joint->getLOD();
if (found_lod || jointLOD == DEFAULT_AVATAR_JOINT_LOD)
@ -207,10 +200,9 @@ BOOL LLAvatarJoint::updateLOD(F32 pixel_area, BOOL activate)
void LLAvatarJoint::dump()
{
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* child : mChildren)
{
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(*iter);
LLAvatarJoint* joint = static_cast<LLAvatarJoint*>(child);
joint->dump();
}
}
@ -219,10 +211,9 @@ void LLAvatarJoint::dump()
void LLAvatarJoint::setMeshesToChildren()
{
removeAllChildren();
for (avatar_joint_mesh_list_t::iterator iter = mMeshParts.begin();
iter != mMeshParts.end(); iter++)
for (LLAvatarJointMesh* mesh : mMeshParts)
{
addChild((*iter));
addChild(mesh);
}
}
//-----------------------------------------------------------------------------

5
indra/llappearance/llavatarjointmesh.cpp
View File

@ -379,10 +379,9 @@ void LLAvatarJointMesh::setupJoint(LLAvatarJoint* current_joint)
}
// depth-first traversal
for (LLJoint::joints_t::iterator iter = current_joint->mChildren.begin();
iter != current_joint->mChildren.end(); ++iter)
for (LLJoint* joint : current_joint->mChildren)
{
LLAvatarJoint* child_joint = (LLAvatarJoint*)(*iter);
LLAvatarJoint* child_joint = (LLAvatarJoint*)joint;
setupJoint(child_joint);
}
}

85
indra/llappearance/lldriverparam.cpp
View File

@ -102,9 +102,8 @@ void LLDriverParamInfo::toStream(std::ostream &out)
LLViewerVisualParamInfo::toStream(out);
out << "driver" << "\t";
out << mDrivenInfoList.size() << "\t";
for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++)
for (LLDrivenEntryInfo& driven : mDrivenInfoList)
{
LLDrivenEntryInfo driven = *iter;
out << driven.mDrivenID << "\t";
}
@ -121,9 +120,8 @@ void LLDriverParamInfo::toStream(std::ostream &out)
if(mDriverParam && mDriverParam->getAvatarAppearance()->isSelf() &&
mDriverParam->getAvatarAppearance()->isValid())
{
for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++)
for (LLDrivenEntryInfo& driven : mDrivenInfoList)
{
LLDrivenEntryInfo driven = *iter;
LLViewerVisualParam *param =
(LLViewerVisualParam*)mDriverParam->getAvatarAppearance()->getVisualParam(driven.mDrivenID);
if (param)
@ -232,19 +230,19 @@ void LLDriverParam::setWeight(F32 weight)
//-------|----|-------|----|-------> driver
// | min1 max1 max2 min2
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
LLDrivenEntryInfo* info = driven->mInfo;
LLDrivenEntry* drivenp = &driven;
LLDrivenEntryInfo* info = drivenp->mInfo;
F32 driven_weight = 0.f;
F32 driven_min = driven->mParam->getMinWeight();
F32 driven_max = driven->mParam->getMaxWeight();
F32 driven_min = drivenp->mParam->getMinWeight();
F32 driven_max = drivenp->mParam->getMaxWeight();
if (mIsAnimating)
{
// driven param doesn't interpolate (textures, for example)
if (!driven->mParam->getAnimating())
if (!drivenp->mParam->getAnimating())
{
continue;
}
@ -268,7 +266,7 @@ void LLDriverParam::setWeight(F32 weight)
driven_weight = driven_min;
}
setDrivenWeight(driven,driven_weight);
setDrivenWeight(drivenp,driven_weight);
continue;
}
else
@ -292,23 +290,22 @@ void LLDriverParam::setWeight(F32 weight)
driven_weight = driven_min;
}
setDrivenWeight(driven,driven_weight);
setDrivenWeight(drivenp,driven_weight);
continue;
}
}
driven_weight = getDrivenWeight(driven, mCurWeight);
setDrivenWeight(driven,driven_weight);
driven_weight = getDrivenWeight(drivenp, mCurWeight);
setDrivenWeight(drivenp,driven_weight);
}
}
F32 LLDriverParam::getTotalDistortion()
{
F32 sum = 0.f;
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
sum += driven->mParam->getTotalDistortion();
sum += driven.mParam->getTotalDistortion();
}
return sum;
@ -320,10 +317,9 @@ const LLVector4a &LLDriverParam::getAvgDistortion()
LLVector4a sum;
sum.clear();
S32 count = 0;
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
sum.add(driven->mParam->getAvgDistortion());
sum.add(driven.mParam->getAvgDistortion());
count++;
}
sum.mul( 1.f/(F32)count);
@ -335,10 +331,9 @@ const LLVector4a &LLDriverParam::getAvgDistortion()
F32 LLDriverParam::getMaxDistortion()
{
F32 max = 0.f;
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
F32 param_max = driven->mParam->getMaxDistortion();
F32 param_max = driven.mParam->getMaxDistortion();
if( param_max > max )
{
max = param_max;
@ -353,10 +348,9 @@ LLVector4a LLDriverParam::getVertexDistortion(S32 index, LLPolyMesh *poly_mesh)
{
LLVector4a sum;
sum.clear();
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
sum.add(driven->mParam->getVertexDistortion( index, poly_mesh ));
sum.add(driven.mParam->getVertexDistortion(index, poly_mesh));
}
return sum;
}
@ -365,13 +359,12 @@ const LLVector4a* LLDriverParam::getFirstDistortion(U32 *index, LLPolyMesh **pol
{
mCurrentDistortionParam = NULL;
const LLVector4a* v = NULL;
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
v = driven->mParam->getFirstDistortion( index, poly_mesh );
v = driven.mParam->getFirstDistortion(index, poly_mesh);
if( v )
{
mCurrentDistortionParam = driven->mParam;
mCurrentDistortionParam = driven.mParam;
break;
}
}
@ -415,7 +408,7 @@ const LLVector4a* LLDriverParam::getNextDistortion(U32 *index, LLPolyMesh **poly
for( iter++; iter != mDriven.end(); iter++ )
{
driven = &(*iter);
v = driven->mParam->getFirstDistortion( index, poly_mesh );
v = driven->mParam->getFirstDistortion(index, poly_mesh);
if( v )
{
mCurrentDistortionParam = driven->mParam;
@ -448,14 +441,14 @@ void LLDriverParam::setAnimationTarget( F32 target_value)
{
LLVisualParam::setAnimationTarget(target_value);
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
F32 driven_weight = getDrivenWeight(driven, mTargetWeight);
LLDrivenEntry* drivenp = &driven;
F32 driven_weight = getDrivenWeight(drivenp, mTargetWeight);
// this isn't normally necessary, as driver params handle interpolation of their driven params
// but texture params need to know to assume their final value at beginning of interpolation
driven->mParam->setAnimationTarget(driven_weight);
drivenp->mParam->setAnimationTarget(driven_weight);
}
}
@ -466,10 +459,9 @@ void LLDriverParam::stopAnimating()
{
LLVisualParam::stopAnimating();
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
driven->mParam->setAnimating(FALSE);
driven.mParam->setAnimating(FALSE);
}
}
@ -477,17 +469,15 @@ void LLDriverParam::stopAnimating()
BOOL LLDriverParam::linkDrivenParams(visual_param_mapper mapper, BOOL only_cross_params)
{
BOOL success = TRUE;
LLDriverParamInfo::entry_info_list_t::iterator iter;
for (iter = getInfo()->mDrivenInfoList.begin(); iter != getInfo()->mDrivenInfoList.end(); ++iter)
for (LLDrivenEntryInfo& driven_info : getInfo()->mDrivenInfoList)
{
LLDrivenEntryInfo *driven_info = &(*iter);
S32 driven_id = driven_info->mDrivenID;
S32 driven_id = driven_info.mDrivenID;
// check for already existing links. Do not overwrite.
BOOL found = FALSE;
for (entry_list_t::iterator driven_iter = mDriven.begin(); driven_iter != mDriven.end() && !found; ++driven_iter)
for (auto& driven : mDriven)
{
if (driven_iter->mInfo->mDrivenID == driven_id)
if (driven.mInfo->mDrivenID == driven_id)
{
found = TRUE;
}
@ -500,7 +490,7 @@ BOOL LLDriverParam::linkDrivenParams(visual_param_mapper mapper, BOOL only_cross
bool push = param && (!only_cross_params || param->getCrossWearable());
if (push)
{
mDriven.push_back(LLDrivenEntry( param, driven_info ));
mDriven.push_back(LLDrivenEntry( param, &driven_info ));
}
else
{
@ -523,10 +513,9 @@ void LLDriverParam::updateCrossDrivenParams(LLWearableType::EType driven_type)
bool needs_update = (getWearableType()==driven_type);
// if the driver has a driven entry for the passed-in wearable type, we need to refresh the value
for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
for(LLDrivenEntry& driven : mDriven)
{
LLDrivenEntry* driven = &(*iter);
if (driven && driven->mParam && driven->mParam->getCrossWearable() && driven->mParam->getWearableType() == driven_type)
if (driven.mParam && driven.mParam->getCrossWearable() && driven.mParam->getWearableType() == driven_type)
{
needs_update = true;
}

3
indra/llappearance/lllocaltextureobject.cpp
View File

@ -96,9 +96,8 @@ LLTexLayer* LLLocalTextureObject::getTexLayer(U32 index) const
LLTexLayer* LLLocalTextureObject::getTexLayer(const std::string &name)
{
for( tex_layer_vec_t::iterator iter = mTexLayers.begin(); iter != mTexLayers.end(); iter++)
for(LLTexLayer* layer : mTexLayers)
{
LLTexLayer *layer = *iter;
if (layer->getName().compare(name) == 0)
{
return layer;

19
indra/llappearance/llpolymesh.cpp
View File

@ -890,11 +890,10 @@ void LLPolyMesh::dumpDiagInfo()
LL_INFOS() << "-----------------------------------------------------" << LL_ENDL;
// print each loaded mesh, and it's memory usage
for(LLPolyMeshSharedDataTable::iterator iter = sGlobalSharedMeshList.begin();
iter != sGlobalSharedMeshList.end(); ++iter)
for(const LLPolyMeshSharedDataTable::value_type& mesh_pair : sGlobalSharedMeshList)
{
const std::string& mesh_name = iter->first;
LLPolyMeshSharedData* mesh = iter->second;
const std::string& mesh_name = mesh_pair.first;
LLPolyMeshSharedData* mesh = mesh_pair.second;
S32 num_verts = mesh->mNumVertices;
S32 num_faces = mesh->mNumFaces;
@ -997,14 +996,12 @@ LLPolyMorphData* LLPolyMesh::getMorphData(const std::string& morph_name)
{
if (!mSharedData)
return NULL;
for (LLPolyMeshSharedData::morphdata_list_t::iterator iter = mSharedData->mMorphData.begin();
iter != mSharedData->mMorphData.end(); ++iter)
for (LLPolyMorphData* morph_data : mSharedData->mMorphData)
{
LLPolyMorphData *morph_data = *iter;
if (morph_data->getName() == morph_name)
{
return morph_data;
}
if (morph_data->getName() == morph_name)
{
return morph_data;
}
}
return NULL;
}

32
indra/llappearance/llpolymorph.cpp
View File

@ -363,18 +363,16 @@ BOOL LLPolyMorphTarget::setInfo(LLPolyMorphTargetInfo* info)
setWeight(getDefaultWeight());
LLAvatarAppearance* avatarp = mMesh->getAvatar();
LLPolyMorphTargetInfo::volume_info_list_t::iterator iter;
for (iter = getInfo()->mVolumeInfoList.begin(); iter != getInfo()->mVolumeInfoList.end(); iter++)
for (LLPolyVolumeMorphInfo& volume_info : getInfo()->mVolumeInfoList)
{
LLPolyVolumeMorphInfo *volume_info = &(*iter);
for (S32 i = 0; i < avatarp->mNumCollisionVolumes; i++)
{
if (avatarp->mCollisionVolumes[i].getName() == volume_info->mName)
if (avatarp->mCollisionVolumes[i].getName() == volume_info.mName)
{
mVolumeMorphs.push_back(
LLPolyVolumeMorph(&avatarp->mCollisionVolumes[i],
volume_info->mScale,
volume_info->mPos));
volume_info.mScale,
volume_info.mPos));
break;
}
}
@ -641,15 +639,14 @@ void LLPolyMorphTarget::apply( ESex avatar_sex )
}
// now apply volume changes
for( volume_list_t::iterator iter = mVolumeMorphs.begin(); iter != mVolumeMorphs.end(); iter++ )
for(LLPolyVolumeMorph& volume_morph : mVolumeMorphs)
{
LLPolyVolumeMorph* volume_morph = &(*iter);
LLVector3 scale_delta = volume_morph->mScale * delta_weight;
LLVector3 pos_delta = volume_morph->mPos * delta_weight;
LLVector3 scale_delta = volume_morph.mScale * delta_weight;
LLVector3 pos_delta = volume_morph.mPos * delta_weight;
volume_morph->mVolume->setScale(volume_morph->mVolume->getScale() + scale_delta);
volume_morph.mVolume->setScale(volume_morph.mVolume->getScale() + scale_delta);
// SL-315
volume_morph->mVolume->setPosition(volume_morph->mVolume->getPosition() + pos_delta);
volume_morph.mVolume->setPosition(volume_morph.mVolume->getPosition() + pos_delta);
}
}
@ -735,15 +732,14 @@ void LLPolyMorphTarget::applyMask(U8 *maskTextureData, S32 width, S32 height, S3
void LLPolyMorphTarget::applyVolumeChanges(F32 delta_weight)
{
// now apply volume changes
for( volume_list_t::iterator iter = mVolumeMorphs.begin(); iter != mVolumeMorphs.end(); iter++ )
for(LLPolyVolumeMorph& volume_morph : mVolumeMorphs)
{
LLPolyVolumeMorph* volume_morph = &(*iter);
LLVector3 scale_delta = volume_morph->mScale * delta_weight;
LLVector3 pos_delta = volume_morph->mPos * delta_weight;
LLVector3 scale_delta = volume_morph.mScale * delta_weight;
LLVector3 pos_delta = volume_morph.mPos * delta_weight;
volume_morph->mVolume->setScale(volume_morph->mVolume->getScale() + scale_delta);
volume_morph.mVolume->setScale(volume_morph.mVolume->getScale() + scale_delta);
// SL-315
volume_morph->mVolume->setPosition(volume_morph->mVolume->getPosition() + pos_delta);
volume_morph.mVolume->setPosition(volume_morph.mVolume->getPosition() + pos_delta);
}
}

38
indra/llappearance/llpolyskeletaldistortion.cpp
View File

@ -143,38 +143,35 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
mID = info->mID;
setWeight(getDefaultWeight());
LLPolySkeletalDistortionInfo::bone_info_list_t::iterator iter;
for (iter = getInfo()->mBoneInfoList.begin(); iter != getInfo()->mBoneInfoList.end(); iter++)
for (LLPolySkeletalBoneInfo& bone_info : getInfo()->mBoneInfoList)
{
LLPolySkeletalBoneInfo *bone_info = &(*iter);
LLJoint* joint = mAvatar->getJoint(bone_info->mBoneName);
LLJoint* joint = mAvatar->getJoint(bone_info.mBoneName);
if (!joint)
{
// There's no point continuing after this error - means
// that either the skeleton or lad file is broken.
LL_WARNS() << "Joint " << bone_info->mBoneName << " not found." << LL_ENDL;
LL_WARNS() << "Joint " << bone_info.mBoneName << " not found." << LL_ENDL;
return FALSE;
}
// store it
mJointScales[joint] = bone_info->mScaleDeformation;
mJointScales[joint] = bone_info.mScaleDeformation;
// apply to children that need to inherit it
for (LLJoint::joints_t::iterator iter = joint->mChildren.begin();
iter != joint->mChildren.end(); ++iter)
for (LLJoint* joint : joint->mChildren)
{
LLAvatarJoint* child_joint = (LLAvatarJoint*)(*iter);
LLAvatarJoint* child_joint = (LLAvatarJoint*)joint;
if (child_joint->inheritScale())
{
LLVector3 childDeformation = LLVector3(child_joint->getScale());
childDeformation.scaleVec(bone_info->mScaleDeformation);
childDeformation.scaleVec(bone_info.mScaleDeformation);
mJointScales[child_joint] = childDeformation;
}
}
if (bone_info->mHasPositionDeformation)
if (bone_info.mHasPositionDeformation)
{
mJointOffsets[joint] = bone_info->mPositionDeformation;
mJointOffsets[joint] = bone_info.mPositionDeformation;
}
}
return TRUE;
@ -195,15 +192,12 @@ void LLPolySkeletalDistortion::apply( ESex avatar_sex )
F32 effective_weight = ( getSex() & avatar_sex ) ? mCurWeight : getDefaultWeight();
LLJoint* joint;
joint_vec_map_t::iterator iter;
for (iter = mJointScales.begin();
iter != mJointScales.end();
iter++)
for (joint_vec_map_t::value_type& scale_pair : mJointScales)
{
joint = iter->first;
joint = scale_pair.first;
LLVector3 newScale = joint->getScale();
LLVector3 scaleDelta = iter->second;
LLVector3 scaleDelta = scale_pair.second;
LLVector3 offset = (effective_weight - mLastWeight) * scaleDelta;
newScale = newScale + offset;
//An aspect of attached mesh objects (which contain joint offsets) that need to be cleaned up when detached
@ -218,13 +212,11 @@ void LLPolySkeletalDistortion::apply( ESex avatar_sex )
joint->setScale(newScale, true);
}
for (iter = mJointOffsets.begin();
iter != mJointOffsets.end();
iter++)
for (joint_vec_map_t::value_type& offset_pair : mJointOffsets)
{
joint = iter->first;
joint = offset_pair.first;
LLVector3 newPosition = joint->getPosition();
LLVector3 positionDelta = iter->second;
LLVector3 positionDelta = offset_pair.second;
newPosition = newPosition + (effective_weight * positionDelta) - (mLastWeight * positionDelta);
// SL-315
bool allow_attachment_pos_overrides = true;

6
indra/llappearance/lltexglobalcolor.cpp
View File

@ -55,12 +55,10 @@ BOOL LLTexGlobalColor::setInfo(LLTexGlobalColorInfo *info)
//mID = info->mID; // No ID
mParamGlobalColorList.reserve(mInfo->mParamColorInfoList.size());
for (param_color_info_list_t::iterator iter = mInfo->mParamColorInfoList.begin();
iter != mInfo->mParamColorInfoList.end();
iter++)
for (LLTexLayerParamColorInfo* color_info : mInfo->mParamColorInfoList)
{
LLTexParamGlobalColor* param_color = new LLTexParamGlobalColor(this);
if (!param_color->setInfo(*iter, TRUE))
if (!param_color->setInfo(color_info, TRUE))
{
mInfo = NULL;
return FALSE;

139
indra/llappearance/lltexlayer.cpp
View File

@ -241,11 +241,8 @@ BOOL LLTexLayerSetInfo::parseXml(LLXmlTreeNode* node)
void LLTexLayerSetInfo::createVisualParams(LLAvatarAppearance *appearance)
{
//layer_info_list_t mLayerInfoList;
for (layer_info_list_t::iterator layer_iter = mLayerInfoList.begin();
layer_iter != mLayerInfoList.end();
layer_iter++)
for (LLTexLayerInfo* layer_info : mLayerInfoList)
{
LLTexLayerInfo *layer_info = *layer_iter;
layer_info->createVisualParams(appearance);
}
}
@ -287,12 +284,10 @@ BOOL LLTexLayerSet::setInfo(const LLTexLayerSetInfo *info)
//mID = info->mID; // No ID
mLayerList.reserve(info->mLayerInfoList.size());
for (LLTexLayerSetInfo::layer_info_list_t::const_iterator iter = info->mLayerInfoList.begin();
iter != info->mLayerInfoList.end();
iter++)
for (LLTexLayerInfo* layer_info : info->mLayerInfoList)
{
LLTexLayerInterface *layer = NULL;
if ( (*iter)->isUserSettable() )
if (layer_info->isUserSettable())
{
layer = new LLTexLayerTemplate( this, getAvatarAppearance() );
}
@ -301,7 +296,7 @@ BOOL LLTexLayerSet::setInfo(const LLTexLayerSetInfo *info)
layer = new LLTexLayer(this);
}
// this is the first time this layer (of either type) is being created - make sure you add the parameters to the avatar appearance
if (!layer->setInfo(*iter, NULL))
if (!layer->setInfo(layer_info, NULL))
{
mInfo = NULL;
return FALSE;
@ -348,14 +343,12 @@ BOOL LLTexLayerSet::parseData(LLXmlTreeNode* node)
void LLTexLayerSet::deleteCaches()
{
for( layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerInterface* layer = *iter;
layer->deleteCaches();
}
for (layer_list_t::iterator iter = mMaskLayerList.begin(); iter != mMaskLayerList.end(); iter++)
for (LLTexLayerInterface* layer : mMaskLayerList)
{
LLTexLayerInterface* layer = *iter;
layer->deleteCaches();
}
}
@ -368,9 +361,8 @@ BOOL LLTexLayerSet::render( S32 x, S32 y, S32 width, S32 height, LLRenderTarget*
if (mMaskLayerList.size() > 0)
{
for (layer_list_t::iterator iter = mMaskLayerList.begin(); iter != mMaskLayerList.end(); iter++)
for (LLTexLayerInterface* layer : mMaskLayerList)
{
LLTexLayerInterface* layer = *iter;
if (layer->isInvisibleAlphaMask())
{
mIsVisible = FALSE;
@ -399,9 +391,8 @@ BOOL LLTexLayerSet::render( S32 x, S32 y, S32 width, S32 height, LLRenderTarget*
if (mIsVisible)
{
// composite color layers
for( layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerInterface* layer = *iter;
if (layer->getRenderPass() == LLTexLayer::RP_COLOR)
{
gGL.flush();
@ -473,9 +464,8 @@ void LLTexLayerSet::gatherMorphMaskAlpha(U8 *data, S32 origin_x, S32 origin_y, S
LL_PROFILE_ZONE_SCOPED;
memset(data, 255, width * height);
for( layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerInterface* layer = *iter;
layer->gatherAlphaMasks(data, origin_x, origin_y, width, height, bound_target);
}
@ -526,9 +516,8 @@ void LLTexLayerSet::renderAlphaMaskTextures(S32 x, S32 y, S32 width, S32 height,
if (mMaskLayerList.size() > 0)
{
gGL.setSceneBlendType(LLRender::BT_MULT_ALPHA);
for (layer_list_t::iterator iter = mMaskLayerList.begin(); iter != mMaskLayerList.end(); iter++)
for (LLTexLayerInterface* layer : mMaskLayerList)
{
LLTexLayerInterface* layer = *iter;
gGL.flush();
layer->blendAlphaTexture(x,y,width, height);
gGL.flush();
@ -549,9 +538,8 @@ void LLTexLayerSet::applyMorphMask(U8* tex_data, S32 width, S32 height, S32 num_
BOOL LLTexLayerSet::isMorphValid() const
{
for(layer_list_t::const_iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(const LLTexLayerInterface* layer : mLayerList)
{
const LLTexLayerInterface* layer = *iter;
if (layer && !layer->isMorphValid())
{
return FALSE;
@ -562,9 +550,8 @@ BOOL LLTexLayerSet::isMorphValid() const
void LLTexLayerSet::invalidateMorphMasks()
{
for( layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerInterface* layer = *iter;
if (layer)
{
layer->invalidateMorphMasks();
@ -661,14 +648,12 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
/* if ("upper_shirt" == local_texture_name)
mLocalTexture = TEX_UPPER_SHIRT; */
mLocalTexture = TEX_NUM_INDICES;
for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearance::getDictionary()->getTextures().begin();
iter != LLAvatarAppearance::getDictionary()->getTextures().end();
iter++)
for (const LLAvatarAppearanceDictionary::Textures::value_type& dict_pair : LLAvatarAppearance::getDictionary()->getTextures())
{
const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second;
const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = dict_pair.second;
if (local_texture_name == texture_dict->mName)
{
mLocalTexture = iter->first;
mLocalTexture = dict_pair.first;
break;
}
}
@ -735,11 +720,8 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
BOOL LLTexLayerInfo::createVisualParams(LLAvatarAppearance *appearance)
{
BOOL success = TRUE;
for (param_color_info_list_t::iterator color_info_iter = mParamColorInfoList.begin();
color_info_iter != mParamColorInfoList.end();
color_info_iter++)
for (LLTexLayerParamColorInfo* color_info : mParamColorInfoList)
{
LLTexLayerParamColorInfo * color_info = *color_info_iter;
LLTexLayerParamColor* param_color = new LLTexLayerParamColor(appearance);
if (!param_color->setInfo(color_info, TRUE))
{
@ -749,11 +731,8 @@ BOOL LLTexLayerInfo::createVisualParams(LLAvatarAppearance *appearance)
}
}
for (param_alpha_info_list_t::iterator alpha_info_iter = mParamAlphaInfoList.begin();
alpha_info_iter != mParamAlphaInfoList.end();
alpha_info_iter++)
for (LLTexLayerParamAlphaInfo* alpha_info : mParamAlphaInfoList)
{
LLTexLayerParamAlphaInfo * alpha_info = *alpha_info_iter;
LLTexLayerParamAlpha* param_alpha = new LLTexLayerParamAlpha(appearance);
if (!param_alpha->setInfo(alpha_info, TRUE))
{
@ -796,15 +775,13 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
//mID = info->mID; // No ID
mParamColorList.reserve(mInfo->mParamColorInfoList.size());
for (param_color_info_list_t::const_iterator iter = mInfo->mParamColorInfoList.begin();
iter != mInfo->mParamColorInfoList.end();
iter++)
for (LLTexLayerParamColorInfo* color_info : mInfo->mParamColorInfoList)
{
LLTexLayerParamColor* param_color;
if (!wearable)
{
param_color = new LLTexLayerParamColor(this);
if (!param_color->setInfo(*iter, TRUE))
if (!param_color->setInfo(color_info, TRUE))
{
mInfo = NULL;
return FALSE;
@ -812,7 +789,7 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
}
else
{
param_color = (LLTexLayerParamColor*)wearable->getVisualParam((*iter)->getID());
param_color = (LLTexLayerParamColor*)wearable->getVisualParam(color_info->getID());
if (!param_color)
{
mInfo = NULL;
@ -823,15 +800,13 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
}
mParamAlphaList.reserve(mInfo->mParamAlphaInfoList.size());
for (param_alpha_info_list_t::const_iterator iter = mInfo->mParamAlphaInfoList.begin();
iter != mInfo->mParamAlphaInfoList.end();
iter++)
for (LLTexLayerParamAlphaInfo* alpha_info : mInfo->mParamAlphaInfoList)
{
LLTexLayerParamAlpha* param_alpha;
if (!wearable)
{
param_alpha = new LLTexLayerParamAlpha( this );
if (!param_alpha->setInfo(*iter, TRUE))
if (!param_alpha->setInfo(alpha_info, TRUE))
{
mInfo = NULL;
return FALSE;
@ -839,7 +814,7 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
}
else
{
param_alpha = (LLTexLayerParamAlpha*) wearable->getVisualParam((*iter)->getID());
param_alpha = (LLTexLayerParamAlpha*) wearable->getVisualParam(alpha_info->getID());
if (!param_alpha)
{
mInfo = NULL;
@ -873,12 +848,9 @@ LLWearableType::EType LLTexLayerInterface::getWearableType() const
if (TEX_INVALID == te)
{
LLWearableType::EType type = LLWearableType::WT_INVALID;
param_color_list_t::const_iterator color_iter = mParamColorList.begin();
param_alpha_list_t::const_iterator alpha_iter = mParamAlphaList.begin();
for (; color_iter != mParamColorList.end(); color_iter++)
for (LLTexLayerParamColor* param : mParamColorList)
{
LLTexLayerParamColor* param = *color_iter;
if (param)
{
LLWearableType::EType new_type = (LLWearableType::EType)param->getWearableType();
@ -893,9 +865,8 @@ LLWearableType::EType LLTexLayerInterface::getWearableType() const
}
}
for (; alpha_iter != mParamAlphaList.end(); alpha_iter++)
for (LLTexLayerParamAlpha* param : mParamAlphaList)
{
LLTexLayerParamAlpha* param = *alpha_iter;
if (param)
{
LLWearableType::EType new_type = (LLWearableType::EType)param->getWearableType();
@ -938,18 +909,18 @@ void LLTexLayerInterface::invalidateMorphMasks()
LLViewerVisualParam* LLTexLayerInterface::getVisualParamPtr(S32 index) const
{
LLViewerVisualParam *result = NULL;
for (param_color_list_t::const_iterator color_iter = mParamColorList.begin(); color_iter != mParamColorList.end() && !result; ++color_iter)
for (LLTexLayerParamColor* param : mParamColorList)
{
if ((*color_iter)->getID() == index)
if (param->getID() == index)
{
result = *color_iter;
result = param;
}
}
for (param_alpha_list_t::const_iterator alpha_iter = mParamAlphaList.begin(); alpha_iter != mParamAlphaList.end() && !result; ++alpha_iter)
for (LLTexLayerParamAlpha* param : mParamAlphaList)
{
if ((*alpha_iter)->getID() == index)
if (param->getID() == index)
{
result = *alpha_iter;
result = param;
}
}
@ -994,10 +965,9 @@ LLTexLayer::~LLTexLayer()
//std::for_each(mParamAlphaList.begin(), mParamAlphaList.end(), DeletePointer());
//std::for_each(mParamColorList.begin(), mParamColorList.end(), DeletePointer());
for( alpha_cache_t::iterator iter = mAlphaCache.begin();
iter != mAlphaCache.end(); iter++ )
for (alpha_cache_t::value_type& alpha_pair : mAlphaCache)
{
U8* alpha_data = iter->second;
U8* alpha_data = alpha_pair.second;
ll_aligned_free_32(alpha_data);
}
@ -1021,10 +991,8 @@ BOOL LLTexLayer::setInfo(const LLTexLayerInfo* info, LLWearable* wearable )
//static
void LLTexLayer::calculateTexLayerColor(const param_color_list_t &param_list, LLColor4 &net_color)
{
for (param_color_list_t::const_iterator iter = param_list.begin();
iter != param_list.end(); iter++)
for (const LLTexLayerParamColor* param : param_list)
{
const LLTexLayerParamColor* param = *iter;
LLColor4 param_net = param->getNetColor();
const LLTexLayerParamColorInfo *info = (LLTexLayerParamColorInfo *)param->getInfo();
switch(info->getOperation())
@ -1049,10 +1017,8 @@ void LLTexLayer::calculateTexLayerColor(const param_color_list_t &param_list, LL
/*virtual*/ void LLTexLayer::deleteCaches()
{
// Only need to delete caches for alpha params. Color params don't hold extra memory
for (param_alpha_list_t::iterator iter = mParamAlphaList.begin();
iter != mParamAlphaList.end(); iter++ )
for (LLTexLayerParamAlpha* param : mParamAlphaList)
{
LLTexLayerParamAlpha* param = *iter;
param->deleteCaches();
}
}
@ -1226,9 +1192,8 @@ const U8* LLTexLayer::getAlphaData() const
const LLUUID& uuid = getUUID();
alpha_mask_crc.update((U8*)(&uuid.mData), UUID_BYTES);
for (param_alpha_list_t::const_iterator iter = mParamAlphaList.begin(); iter != mParamAlphaList.end(); iter++)
for (const LLTexLayerParamAlpha* param : mParamAlphaList)
{
const LLTexLayerParamAlpha* param = *iter;
// MULTI-WEARABLE: verify visual parameters used here
F32 param_weight = param->getWeight();
alpha_mask_crc.update((U8*)&param_weight, sizeof(F32));
@ -1365,9 +1330,8 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
// Accumulate alphas
LLGLSNoAlphaTest gls_no_alpha_test;
gGL.color4f( 1.f, 1.f, 1.f, 1.f );
for (param_alpha_list_t::iterator iter = mParamAlphaList.begin(); iter != mParamAlphaList.end(); iter++)
for (LLTexLayerParamAlpha* param : mParamAlphaList)
{
LLTexLayerParamAlpha* param = *iter;
success &= param->render( x, y, width, height );
if (!success && !force_render)
{
@ -1441,9 +1405,8 @@ void LLTexLayer::renderMorphMasks(S32 x, S32 y, S32 width, S32 height, const LLC
const LLUUID& uuid = getUUID();
alpha_mask_crc.update((U8*)(&uuid.mData), UUID_BYTES);
for (param_alpha_list_t::const_iterator iter = mParamAlphaList.begin(); iter != mParamAlphaList.end(); iter++)
for (const LLTexLayerParamAlpha* param : mParamAlphaList)
{
const LLTexLayerParamAlpha* param = *iter;
F32 param_weight = param->getWeight();
alpha_mask_crc.update((U8*)&param_weight, sizeof(F32));
}
@ -1683,12 +1646,10 @@ LLTexLayer* LLTexLayerTemplate::getLayer(U32 i) const
BOOL success = TRUE;
updateWearableCache();
for (wearable_cache_t::const_iterator iter = mWearableCache.begin(); iter!= mWearableCache.end(); iter++)
for (LLWearable* wearable : mWearableCache)
{
LLWearable* wearable = NULL;
LLLocalTextureObject *lto = NULL;
LLTexLayer *layer = NULL;
wearable = *iter;
if (wearable)
{
lto = wearable->getLocalTextureObject(mInfo->mLocalTexture);
@ -1785,17 +1746,15 @@ LLTexLayer* LLTexLayerTemplate::getLayer(U32 i) const
//-----------------------------------------------------------------------------
LLTexLayerInterface* LLTexLayerSet::findLayerByName(const std::string& name)
{
for (layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for (LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerInterface* layer = *iter;
if (layer->getName() == name)
{
return layer;
}
}
for (layer_list_t::iterator iter = mMaskLayerList.begin(); iter != mMaskLayerList.end(); iter++ )
for (LLTexLayerInterface* layer : mMaskLayerList)
{
LLTexLayerInterface* layer = *iter;
if (layer->getName() == name)
{
return layer;
@ -1807,20 +1766,20 @@ LLTexLayerInterface* LLTexLayerSet::findLayerByName(const std::string& name)
void LLTexLayerSet::cloneTemplates(LLLocalTextureObject *lto, LLAvatarAppearanceDefines::ETextureIndex tex_index, LLWearable *wearable)
{
// initialize all texlayers with this texture type for this LTO
for( LLTexLayerSet::layer_list_t::iterator iter = mLayerList.begin(); iter != mLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mLayerList)
{
LLTexLayerTemplate* layer = (LLTexLayerTemplate*)*iter;
if (layer->getInfo()->getLocalTexture() == (S32) tex_index)
LLTexLayerTemplate* layer_template = (LLTexLayerTemplate*)layer;
if (layer_template->getInfo()->getLocalTexture() == (S32)tex_index)
{
lto->addTexLayer(layer, wearable);
lto->addTexLayer(layer_template, wearable);
}
}
for( LLTexLayerSet::layer_list_t::iterator iter = mMaskLayerList.begin(); iter != mMaskLayerList.end(); iter++ )
for(LLTexLayerInterface* layer : mMaskLayerList)
{
LLTexLayerTemplate* layer = (LLTexLayerTemplate*)*iter;
if (layer->getInfo()->getLocalTexture() == (S32) tex_index)
LLTexLayerTemplate* layer_template = (LLTexLayerTemplate*)layer;
if (layer_template->getInfo()->getLocalTexture() == (S32)tex_index)
{
lto->addTexLayer(layer, wearable);
lto->addTexLayer(layer_template, wearable);
}
}
}

4
indra/llappearance/lltexlayerparams.cpp
View File

@ -103,10 +103,8 @@ void LLTexLayerParamAlpha::getCacheByteCount(S32* gl_bytes)
{
*gl_bytes = 0;
for (param_alpha_ptr_list_t::iterator iter = sInstances.begin();
iter != sInstances.end(); iter++)
for (LLTexLayerParamAlpha* instance : sInstances)
{
LLTexLayerParamAlpha* instance = *iter;
LLGLTexture* tex = instance->mCachedProcessedTexture;
if (tex)
{

84
indra/llappearance/llwearable.cpp
View File

@ -60,12 +60,12 @@ LLWearable::LLWearable()
// virtual
LLWearable::~LLWearable()
{
for (visual_param_index_map_t::iterator vpIter = mVisualParamIndexMap.begin(); vpIter != mVisualParamIndexMap.end(); ++vpIter)
for (visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
{
LLVisualParam* vp = vpIter->second;
LLVisualParam* vp = vp_pair.second;
vp->clearNextParam();
delete vp;
vpIter->second = NULL;
vp_pair.second = NULL;
}
destroyTextures();
@ -122,12 +122,10 @@ BOOL LLWearable::exportStream( std::ostream& output_stream ) const
// parameters
output_stream << "parameters " << mVisualParamIndexMap.size() << "\n";
for (visual_param_index_map_t::const_iterator iter = mVisualParamIndexMap.begin();
iter != mVisualParamIndexMap.end();
++iter)
for (const visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
{
S32 param_id = iter->first;
const LLVisualParam* param = iter->second;
S32 param_id = vp_pair.first;
const LLVisualParam* param = vp_pair.second;
F32 param_weight = param->getWeight();
output_stream << param_id << " " << terse_F32_to_string( param_weight ) << "\n";
}
@ -135,11 +133,11 @@ BOOL LLWearable::exportStream( std::ostream& output_stream ) const
// texture entries
output_stream << "textures " << mTEMap.size() << "\n";
for (te_map_t::const_iterator iter = mTEMap.begin(); iter != mTEMap.end(); ++iter)
for (const te_map_t::value_type& te_pair : mTEMap)
{
S32 te = iter->first;
const LLUUID& image_id = iter->second->getID();
output_stream << te << " " << image_id << "\n";
S32 te = te_pair.first;
const LLUUID& image_id = te_pair.second->getID();
output_stream << te << " " << image_id << "\n";
}
return TRUE;
}
@ -160,11 +158,9 @@ void LLWearable::createVisualParams(LLAvatarAppearance *avatarp)
}
// resync driver parameters to point to the newly cloned driven parameters
for (visual_param_index_map_t::iterator param_iter = mVisualParamIndexMap.begin();
param_iter != mVisualParamIndexMap.end();
++param_iter)
for (visual_param_index_map_t::value_type& param_pair : mVisualParamIndexMap)
{
LLVisualParam* param = param_iter->second;
LLVisualParam* param = param_pair.second;
LLVisualParam*(LLWearable::*wearable_function)(S32)const = &LLWearable::getVisualParam;
// need this line to disambiguate between versions of LLCharacter::getVisualParam()
LLVisualParam*(LLAvatarAppearance::*param_function)(S32)const = &LLAvatarAppearance::getVisualParam;
@ -523,10 +519,9 @@ std::vector<LLLocalTextureObject*> LLWearable::getLocalTextureListSeq()
{
std::vector<LLLocalTextureObject*> result;
for(te_map_t::const_iterator iter = mTEMap.begin();
iter != mTEMap.end(); iter++)
for(te_map_t::value_type& te_pair : mTEMap)
{
LLLocalTextureObject* lto = iter->second;
LLLocalTextureObject* lto = te_pair.second;
result.push_back(lto);
}
@ -547,37 +542,15 @@ void LLWearable::revertValues()
// FIXME DRANO - this triggers changes to driven params on avatar, potentially clobbering baked appearance.
//update saved settings so wearable is no longer dirty
// non-driver params first
for (param_map_t::const_iterator iter = mSavedVisualParamMap.begin(); iter != mSavedVisualParamMap.end(); iter++)
// One loop should be necessary here
for (param_map_t::value_type& vp_pair : mSavedVisualParamMap)
{
S32 id = iter->first;
F32 value = iter->second;
S32 id = vp_pair.first;
LLVisualParam *param = getVisualParam(id);
if(param && !dynamic_cast<LLDriverParam*>(param) )
if(param)
{
F32 value = vp_pair.second;
setVisualParamWeight(id, value);
}
}
//then driver params
for (param_map_t::const_iterator iter = mSavedVisualParamMap.begin(); iter != mSavedVisualParamMap.end(); iter++)
{
S32 id = iter->first;
F32 value = iter->second;
LLVisualParam *param = getVisualParam(id);
if(param && dynamic_cast<LLDriverParam*>(param) )
{
setVisualParamWeight(id, value);
}
}
// make sure that saved values are sane
for (param_map_t::const_iterator iter = mSavedVisualParamMap.begin(); iter != mSavedVisualParamMap.end(); iter++)
{
S32 id = iter->first;
LLVisualParam *param = getVisualParam(id);
if( param )
{
mSavedVisualParamMap[id] = param->getWeight();
}
}
@ -589,10 +562,10 @@ void LLWearable::saveValues()
{
//update saved settings so wearable is no longer dirty
mSavedVisualParamMap.clear();
for (visual_param_index_map_t::const_iterator iter = mVisualParamIndexMap.begin(); iter != mVisualParamIndexMap.end(); ++iter)
for (const visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
{
S32 id = iter->first;
LLVisualParam *wearable_param = iter->second;
S32 id = vp_pair.first;
LLVisualParam *wearable_param = vp_pair.second;
F32 value = wearable_param->getWeight();
mSavedVisualParamMap[id] = value;
}
@ -706,23 +679,18 @@ LLVisualParam* LLWearable::getVisualParam(S32 index) const
void LLWearable::getVisualParams(visual_param_vec_t &list)
{
visual_param_index_map_t::iterator iter = mVisualParamIndexMap.begin();
visual_param_index_map_t::iterator end = mVisualParamIndexMap.end();
// add all visual params to the passed-in vector
for( ; iter != end; ++iter )
for(visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
{
list.push_back(iter->second);
list.push_back(vp_pair.second);
}
}
void LLWearable::animateParams(F32 delta)
{
for(visual_param_index_map_t::iterator iter = mVisualParamIndexMap.begin();
iter != mVisualParamIndexMap.end();
++iter)
for(visual_param_index_map_t::value_type& vp_pair : mVisualParamIndexMap)
{
LLVisualParam *param = (LLVisualParam*) iter->second;
LLVisualParam *param = (LLVisualParam*)vp_pair.second;
param->animate(delta);
}
}

39
indra/llaudio/llaudioengine.cpp
View File

@ -123,18 +123,16 @@ void LLAudioEngine::shutdown()
cleanupWind();
// Clean up audio sources
source_map::iterator iter_src;
for (iter_src = mAllSources.begin(); iter_src != mAllSources.end(); iter_src++)
for (source_map::value_type& src_pair : mAllSources)
{
delete iter_src->second;
delete src_pair.second;
}
// Clean up audio data
data_map::iterator iter_data;
for (iter_data = mAllData.begin(); iter_data != mAllData.end(); iter_data++)
for (data_map::value_type& data_pair : mAllData)
{
delete iter_data->second;
delete data_pair.second;
}
@ -310,12 +308,12 @@ void LLAudioEngine::idle()
updateChannels();
// Update queued sounds (switch to next queued data if the current has finished playing)
for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
for (source_map::value_type& src_pair : mAllSources)
{
// This is lame, instead of this I could actually iterate through all the sources
// attached to each channel, since only those with active channels
// can have anything interesting happen with their queue? (Maybe not true)
LLAudioSource *sourcep = iter->second;
LLAudioSource *sourcep = src_pair.second;
if (!sourcep->mQueuedDatap || sourcep->isMuted())
{
// Muted, or nothing queued, so we don't care.
@ -395,9 +393,9 @@ void LLAudioEngine::idle()
LLAudioSource *sync_masterp = NULL;
LLAudioChannel *master_channelp = NULL;
F32 max_sm_priority = -1.f;
for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
for (source_map::value_type& src_pair : mAllSources)
{
LLAudioSource *sourcep = iter->second;
LLAudioSource *sourcep = src_pair.second;
if (sourcep->isMuted())
{
continue;
@ -417,9 +415,9 @@ void LLAudioEngine::idle()
{
// Synchronize loop slaves with their masters
// Update queued sounds (switch to next queued data if the current has finished playing)
for (iter = mAllSources.begin(); iter != mAllSources.end(); ++iter)
for (source_map::value_type& src_pair : mAllSources)
{
LLAudioSource *sourcep = iter->second;
LLAudioSource *sourcep = src_pair.second;
if (!sourcep->isSyncSlave())
{
@ -1115,9 +1113,9 @@ void LLAudioEngine::startNextTransfer()
}
for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
for (data_map::value_type& preload_pair : asp->mPreloadMap)
{
LLAudioData *adp = data_iter->second;
LLAudioData *adp = preload_pair.second;
if (!adp)
{
continue;
@ -1137,9 +1135,9 @@ void LLAudioEngine::startNextTransfer()
{
max_pri = -1.f;
source_map::iterator source_iter;
for (source_iter = mAllSources.begin(); source_iter != mAllSources.end(); source_iter++)
for (source_map::value_type& source_pair : mAllSources)
{
asp = source_iter->second;
asp = source_pair.second;
if (!asp)
{
continue;
@ -1166,9 +1164,9 @@ void LLAudioEngine::startNextTransfer()
continue;
}
for (data_iter = asp->mPreloadMap.begin(); data_iter != asp->mPreloadMap.end(); data_iter++)
for (data_map::value_type& preload_pair : asp->mPreloadMap)
{
LLAudioData *adp = data_iter->second;
LLAudioData *adp = preload_pair.second;
if (!adp)
{
continue;
@ -1603,10 +1601,9 @@ void LLAudioSource::addAudioData(LLAudioData *adp, const bool set_current)
bool LLAudioSource::hasPendingPreloads() const
{
// Check to see if we've got any preloads on deck for this source
data_map::const_iterator iter;
for (iter = mPreloadMap.begin(); iter != mPreloadMap.end(); iter++)
for (const data_map::value_type& preload_pair : mPreloadMap)
{
LLAudioData *adp = iter->second;
LLAudioData *adp = preload_pair.second;
// note: a bad UUID will forever be !hasDecodedData()
// but also hasDecodeFailed(), hence the check for hasDecodeFailed()
if (!adp)

7
indra/llcharacter/llanimationstates.cpp
View File

@ -379,12 +379,11 @@ LLUUID LLAnimationLibrary::stringToAnimState( const std::string& name, BOOL allo
if (true_name)
{
for (anim_map_t::iterator iter = mAnimMap.begin();
iter != mAnimMap.end(); iter++)
for (anim_map_t::value_type& anim_pair : mAnimMap)
{
if (iter->second == true_name)
if (anim_pair.second == true_name)
{
id = iter->first;
id = anim_pair.first;
break;
}
}

77
indra/llcharacter/llbvhloader.cpp
View File

@ -156,10 +156,9 @@ LLBVHLoader::LLBVHLoader(const char* buffer, ELoadStatus &loadStatus, S32 &error
}
// Recognize all names we've been told are legal.
std::map<std::string, std::string>::iterator iter;
for (iter = joint_alias_map.begin(); iter != joint_alias_map.end(); iter++)
for (std::map<std::string, std::string>::value_type& alias_pair : joint_alias_map)
{
makeTranslation( iter->first , iter->second );
makeTranslation( alias_pair.first , alias_pair.second );
}
char error_text[128]; /* Flawfinder: ignore */
@ -950,10 +949,8 @@ ELoadStatus LLBVHLoader::loadBVHFile(const char *buffer, char* error_text, S32 &
//------------------------------------------------------------------------
void LLBVHLoader::applyTranslations()
{
JointVector::iterator ji;
for (ji = mJoints.begin(); ji != mJoints.end(); ++ji )
for (Joint* joint : mJoints)
{
Joint *joint = *ji;
//----------------------------------------------------------------
// Look for a translation for this joint.
// If none, skip to next joint
@ -1066,10 +1063,8 @@ void LLBVHLoader::optimize()
mEaseOut *= factor;
}
JointVector::iterator ji;
for (ji = mJoints.begin(); ji != mJoints.end(); ++ji)
for (Joint* joint : mJoints)
{
Joint *joint = *ji;
BOOL pos_changed = FALSE;
BOOL rot_changed = FALSE;
@ -1294,15 +1289,12 @@ U32 LLBVHLoader::getOutputSize()
// writes contents to datapacker
BOOL LLBVHLoader::serialize(LLDataPacker& dp)
{
JointVector::iterator ji;
KeyVector::iterator ki;
F32 time;
// count number of non-ignored joints
S32 numJoints = 0;
for (ji=mJoints.begin(); ji!=mJoints.end(); ++ji)
for (Joint* joint : mJoints)
{
Joint *joint = *ji;
if ( ! joint->mIgnore )
numJoints++;
}
@ -1321,11 +1313,8 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
dp.packU32(mHand, "hand_pose");
dp.packU32(numJoints, "num_joints");
for ( ji = mJoints.begin();
ji != mJoints.end();
++ji )
for (Joint* joint : mJoints)
{
Joint *joint = *ji;
// if ignored, skip it
if ( joint->mIgnore )
continue;
@ -1348,17 +1337,15 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
Joint *mergeParent = NULL;
Joint *mergeChild = NULL;
JointVector::iterator mji;
for (mji=mJoints.begin(); mji!=mJoints.end(); ++mji)
for (Joint* mjoint : mJoints)
{
Joint *mjoint = *mji;
if ( !joint->mMergeParentName.empty() && (mjoint->mName == joint->mMergeParentName) )
{
mergeParent = *mji;
mergeParent = mjoint;
}
if ( !joint->mMergeChildName.empty() && (mjoint->mName == joint->mMergeChildName) )
{
mergeChild = *mji;
mergeChild = mjoint;
}
}
@ -1367,19 +1354,17 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
LLQuaternion::Order order = bvhStringToOrder( joint->mOrder );
S32 outcount = 0;
S32 frame = 0;
for ( ki = joint->mKeys.begin();
ki != joint->mKeys.end();
++ki )
for (Key& key : joint->mKeys)
{
if ((frame == 0) && joint->mRelativeRotationKey)
{
first_frame_rot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
first_frame_rot = mayaQ( key.mRot[0], key.mRot[1], key.mRot[2], order);
fixup_rot.shortestArc(LLVector3::z_axis * first_frame_rot * frameRot, LLVector3::z_axis);
}
if (ki->mIgnoreRot)
if (key.mIgnoreRot)
{
frame++;
continue;
@ -1418,7 +1403,7 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
mergeChildRot.loadIdentity();
}
LLQuaternion inRot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
LLQuaternion inRot = mayaQ( key.mRot[0], key.mRot[1], key.mRot[2], order);
LLQuaternion outRot = frameRotInv* mergeChildRot * inRot * mergeParentRot * ~first_frame_rot * frameRot * offsetRot;
@ -1446,16 +1431,14 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
LLVector3 relKey;
frame = 0;
for ( ki = joint->mKeys.begin();
ki != joint->mKeys.end();
++ki )
for (Key& key : joint->mKeys)
{
if ((frame == 0) && joint->mRelativePositionKey)
{
relKey.setVec(ki->mPos);
relKey.setVec(key.mPos);
}
if (ki->mIgnorePos)
if (key.mIgnorePos)
{
frame++;
continue;
@ -1463,7 +1446,7 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
time = llmax((F32)(frame - NUMBER_OF_IGNORED_FRAMES_AT_START), 0.0f) * mFrameTime; // Time elapsed before this frame starts.
LLVector3 inPos = (LLVector3(ki->mPos) - relKey) * ~first_frame_rot;// * fixup_rot;
LLVector3 inPos = (LLVector3(key.mPos) - relKey) * ~first_frame_rot;// * fixup_rot;
LLVector3 outPos = inPos * frameRot * offsetRot;
outPos *= INCHES_TO_METERS;
@ -1496,24 +1479,22 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
S32 num_constraints = (S32)mConstraints.size();
dp.packS32(num_constraints, "num_constraints");
for (ConstraintVector::iterator constraint_it = mConstraints.begin();
constraint_it != mConstraints.end();
constraint_it++)
for (Constraint& constraint : mConstraints)
{
U8 byte = constraint_it->mChainLength;
U8 byte = constraint.mChainLength;
dp.packU8(byte, "chain_length");
byte = constraint_it->mConstraintType;
byte = constraint.mConstraintType;
dp.packU8(byte, "constraint_type");
dp.packBinaryDataFixed((U8*)constraint_it->mSourceJointName, 16, "source_volume");
dp.packVector3(constraint_it->mSourceOffset, "source_offset");
dp.packBinaryDataFixed((U8*)constraint_it->mTargetJointName, 16, "target_volume");
dp.packVector3(constraint_it->mTargetOffset, "target_offset");
dp.packVector3(constraint_it->mTargetDir, "target_dir");
dp.packF32(constraint_it->mEaseInStart, "ease_in_start");
dp.packF32(constraint_it->mEaseInStop, "ease_in_stop");
dp.packF32(constraint_it->mEaseOutStart, "ease_out_start");
dp.packF32(constraint_it->mEaseOutStop, "ease_out_stop");
dp.packBinaryDataFixed((U8*)constraint.mSourceJointName, 16, "source_volume");
dp.packVector3(constraint.mSourceOffset, "source_offset");
dp.packBinaryDataFixed((U8*)constraint.mTargetJointName, 16, "target_volume");
dp.packVector3(constraint.mTargetOffset, "target_offset");
dp.packVector3(constraint.mTargetDir, "target_dir");
dp.packF32(constraint.mEaseInStart, "ease_in_start");
dp.packF32(constraint.mEaseInStop, "ease_in_stop");
dp.packF32(constraint.mEaseOutStart, "ease_out_start");
dp.packF32(constraint.mEaseOutStop, "ease_out_stop");
}

4
indra/llcharacter/llcharacter.cpp
View File

@ -246,10 +246,8 @@ void LLCharacter::dumpCharacter( LLJoint* joint )
LL_INFOS() << "DEBUG: " << joint->getName() << " (" << (joint->getParent()?joint->getParent()->getName():std::string("ROOT")) << ")" << LL_ENDL;
// recurse
for (LLJoint::joints_t::iterator iter = joint->mChildren.begin();
iter != joint->mChildren.end(); ++iter)
for (LLJoint* child_joint : joint->mChildren)
{
LLJoint* child_joint = *iter;
dumpCharacter(child_joint);
}
}

13
indra/llcharacter/llcharacter.h
View File

@ -218,11 +218,9 @@ public:
S32 getVisualParamCountInGroup(const EVisualParamGroup group) const
{
S32 rtn = 0;
for (visual_param_index_map_t::const_iterator iter = mVisualParamIndexMap.begin();
iter != mVisualParamIndexMap.end();
/**/ )
for (const visual_param_index_map_t::value_type& index_pair : mVisualParamIndexMap)
{
if ((iter++)->second->getGroup() == group)
if (index_pair.second->getGroup() == group)
{
++rtn;
}
@ -237,11 +235,10 @@ public:
}
S32 getVisualParamID(LLVisualParam *id)
{
visual_param_index_map_t::iterator iter;
for (iter = mVisualParamIndexMap.begin(); iter != mVisualParamIndexMap.end(); iter++)
for (visual_param_index_map_t::value_type& index_pair : mVisualParamIndexMap)
{
if (iter->second == id)
return iter->first;
if (index_pair.second == id)
return index_pair.first;
}
return 0;
}

9
indra/llcharacter/llgesture.cpp
View File

@ -199,15 +199,14 @@ BOOL LLGestureList::triggerAndReviseString(const std::string &string, std::strin
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(" ");
tokenizer tokens(string, sep);
tokenizer::iterator token_iter;
for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
for(const std::string& cur_token : tokens)
{
LLGesture* gesture = NULL;
if( !found_gestures ) // Only pay attention to the first gesture in the string.
{
std::string cur_token_lower = *token_iter;
std::string cur_token_lower = cur_token;
LLStringUtil::toLower(cur_token_lower);
for (U32 i = 0; i < mList.size(); i++)
@ -228,7 +227,7 @@ BOOL LLGestureList::triggerAndReviseString(const std::string &string, std::strin
LLStringUtil::toLower(output_lower);
if( cur_token_lower == output_lower )
{
revised_string->append(*token_iter);
revised_string->append(cur_token);
}
else
{
@ -249,7 +248,7 @@ BOOL LLGestureList::triggerAndReviseString(const std::string &string, std::strin
{
revised_string->append( " " );
}
revised_string->append( *token_iter );
revised_string->append( cur_token );
}
first_token = FALSE;

57
indra/llcharacter/lljoint.cpp
View File

@ -67,11 +67,10 @@ void LLVector3OverrideMap::showJointVector3Overrides( std::ostringstream& os ) c
map_type::const_iterator max_it = std::max_element(m_map.begin(),
m_map.end(),
attachment_map_iter_compare_key<map_type::value_type>);
for (map_type::const_iterator it = m_map.begin();
it != m_map.end(); ++it)
for (const map_type::value_type& pos_pair : m_map)
{
const LLVector3& pos = it->second;
os << " " << "[" << it->first <<": " << pos << "]" << ((it==max_it) ? "*" : "");
const LLVector3& pos = pos_pair.second;
os << " " << "[" << pos_pair.first <<": " << pos << "]" << ((pos_pair==(*max_it)) ? "*" : "");
}
}
@ -209,10 +208,8 @@ void LLJoint::touch(U32 flags)
child_flags |= POSITION_DIRTY;
}
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* joint : mChildren)
{
LLJoint* joint = *iter;
joint->touch(child_flags);
}
}
@ -251,10 +248,8 @@ LLJoint *LLJoint::findJoint( const std::string &name )
if (name == getName())
return this;
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* joint : mChildren)
{
LLJoint* joint = *iter;
LLJoint *found = joint->findJoint(name);
if (found)
{
@ -514,10 +509,9 @@ void LLJoint::getAllAttachmentPosOverrides(S32& num_pos_overrides,
std::set<LLVector3>& distinct_pos_overrides) const
{
num_pos_overrides = m_attachmentPosOverrides.count();
LLVector3OverrideMap::map_type::const_iterator it = m_attachmentPosOverrides.getMap().begin();
for (; it != m_attachmentPosOverrides.getMap().end(); ++it)
for (const LLVector3OverrideMap::map_type::value_type& pos_override_pair : m_attachmentPosOverrides.getMap())
{
distinct_pos_overrides.insert(it->second);
distinct_pos_overrides.insert(pos_override_pair.second);
}
}
@ -528,10 +522,9 @@ void LLJoint::getAllAttachmentScaleOverrides(S32& num_scale_overrides,
std::set<LLVector3>& distinct_scale_overrides) const
{
num_scale_overrides = m_attachmentScaleOverrides.count();
LLVector3OverrideMap::map_type::const_iterator it = m_attachmentScaleOverrides.getMap().begin();
for (; it != m_attachmentScaleOverrides.getMap().end(); ++it)
for (const LLVector3OverrideMap::map_type::value_type& scale_override_pair : m_attachmentScaleOverrides.getMap())
{
distinct_scale_overrides.insert(it->second);
distinct_scale_overrides.insert(scale_override_pair.second);
}
}
@ -556,10 +549,9 @@ void LLJoint::showAttachmentPosOverrides(const std::string& av_info) const
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " has " << count << " attachment pos overrides" << LL_ENDL;
std::set<LLVector3> distinct_offsets;
LLVector3OverrideMap::map_type::const_iterator it = m_attachmentPosOverrides.getMap().begin();
for (; it != m_attachmentPosOverrides.getMap().end(); ++it)
for (const LLVector3OverrideMap::map_type::value_type& pos_override_pair : m_attachmentPosOverrides.getMap())
{
distinct_offsets.insert(it->second);
distinct_offsets.insert(pos_override_pair.second);
}
if (distinct_offsets.size()>1)
{
@ -569,11 +561,10 @@ void LLJoint::showAttachmentPosOverrides(const std::string& av_info) const
{
LL_DEBUGS("Avatar") << "no conflicts" << LL_ENDL;
}
std::set<LLVector3>::iterator dit = distinct_offsets.begin();
for ( ; dit != distinct_offsets.end(); ++dit)
for (const LLVector3& offset : distinct_offsets)
{
std::string highlight = (has_active_override && *dit == active_override) ? "*" : "";
LL_DEBUGS("Avatar") << " POS " << highlight << "" << (*dit) << " default " << mDefaultPosition << LL_ENDL;
std::string highlight = (has_active_override && offset == active_override) ? "*" : "";
LL_DEBUGS("Avatar") << " POS " << highlight << "" << offset << " default " << mDefaultPosition << LL_ENDL;
}
}
}
@ -717,10 +708,9 @@ void LLJoint::showAttachmentScaleOverrides(const std::string& av_info) const
{
LL_DEBUGS("Avatar") << "av " << av_info << " joint " << getName() << " has " << count << " attachment scale overrides" << LL_ENDL;
std::set<LLVector3> distinct_offsets;
LLVector3OverrideMap::map_type::const_iterator it = m_attachmentScaleOverrides.getMap().begin();
for (; it != m_attachmentScaleOverrides.getMap().end(); ++it)
for (const LLVector3OverrideMap::map_type::value_type& scale_override_pair : m_attachmentScaleOverrides.getMap())
{
distinct_offsets.insert(it->second);
distinct_offsets.insert(scale_override_pair.second);
}
if (distinct_offsets.size()>1)
{
@ -730,11 +720,10 @@ void LLJoint::showAttachmentScaleOverrides(const std::string& av_info) const
{
LL_DEBUGS("Avatar") << "no conflicts" << LL_ENDL;
}
std::set<LLVector3>::iterator dit = distinct_offsets.begin();
for ( ; dit != distinct_offsets.end(); ++dit)
for (const LLVector3& offset : distinct_offsets)
{
std::string highlight = (has_active_override && *dit == active_override) ? "*" : "";
LL_DEBUGS("Avatar") << " POS " << highlight << "" << (*dit) << " default " << mDefaultScale << LL_ENDL;
std::string highlight = (has_active_override && offset == active_override) ? "*" : "";
LL_DEBUGS("Avatar") << " POS " << highlight << "" << offset << " default " << mDefaultScale << LL_ENDL;
}
}
}
@ -993,10 +982,8 @@ void LLJoint::updateWorldMatrixChildren()
{
updateWorldMatrix();
}
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* joint : mChildren)
{
LLJoint* joint = *iter;
joint->updateWorldMatrixChildren();
}
}
@ -1040,10 +1027,8 @@ void LLJoint::clampRotation(LLQuaternion old_rot, LLQuaternion new_rot)
{
LLVector3 main_axis(1.f, 0.f, 0.f);
for (joints_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
for (LLJoint* joint : mChildren)
{
LLJoint* joint = *iter;
if (joint->isAnimatable())
{
main_axis = joint->getPosition();

41
indra/llcharacter/llkeyframemotion.cpp
View File

@ -626,10 +626,8 @@ BOOL LLKeyframeMotion::setupPose()
}
// initialize joint constraints
for (JointMotionList::constraint_list_t::iterator iter = mJointMotionList->mConstraints.begin();
iter != mJointMotionList->mConstraints.end(); ++iter)
for (JointConstraintSharedData* shared_constraintp : mJointMotionList->mConstraints)
{
JointConstraintSharedData* shared_constraintp = *iter;
JointConstraint* constraintp = new JointConstraint(shared_constraintp);
initializeConstraint(constraintp);
mConstraints.push_front(constraintp);
@ -764,19 +762,15 @@ void LLKeyframeMotion::applyConstraints(F32 time, U8* joint_mask)
if (mCharacter->getSkeletonSerialNum() != mLastSkeletonSerialNum)
{
mLastSkeletonSerialNum = mCharacter->getSkeletonSerialNum();
for (constraint_list_t::iterator iter = mConstraints.begin();
iter != mConstraints.end(); ++iter)
for (JointConstraint* constraintp : mConstraints)
{
JointConstraint* constraintp = *iter;
initializeConstraint(constraintp);
}
}
// apply constraints
for (constraint_list_t::iterator iter = mConstraints.begin();
iter != mConstraints.end(); ++iter)
for (JointConstraint* constraintp : mConstraints)
{
JointConstraint* constraintp = *iter;
applyConstraint(constraintp, time, joint_mask);
}
}
@ -786,10 +780,8 @@ void LLKeyframeMotion::applyConstraints(F32 time, U8* joint_mask)
//-----------------------------------------------------------------------------
void LLKeyframeMotion::onDeactivate()
{
for (constraint_list_t::iterator iter = mConstraints.begin();
iter != mConstraints.end(); ++iter)
for (JointConstraint* constraintp : mConstraints)
{
JointConstraint* constraintp = *iter;
deactivateConstraint(constraintp);
}
}
@ -2038,14 +2030,13 @@ BOOL LLKeyframeMotion::serialize(LLDataPacker& dp) const
success &= dp.packS32(joint_motionp->mPriority, "joint_priority");
success &= dp.packS32(joint_motionp->mRotationCurve.mKeys.size(), "num_rot_keys");
LL_DEBUGS("BVH") << "Joint " << i
LL_DEBUGS("BVH") << "Joint " << i
<< " name: " << joint_motionp->mJointName
<< " Rotation keys: " << joint_motionp->mRotationCurve.mKeys.size()
<< " Position keys: " << joint_motionp->mPositionCurve.mKeys.size() << LL_ENDL;
for (RotationCurve::key_map_t::iterator iter = joint_motionp->mRotationCurve.mKeys.begin();
iter != joint_motionp->mRotationCurve.mKeys.end(); ++iter)
for (RotationCurve::key_map_t::value_type& rot_pair : joint_motionp->mRotationCurve.mKeys)
{
RotationKey& rot_key = iter->second;
RotationKey& rot_key = rot_pair.second;
U16 time_short = F32_to_U16(rot_key.mTime, 0.f, mJointMotionList->mDuration);
success &= dp.packU16(time_short, "time");
@ -2063,11 +2054,10 @@ BOOL LLKeyframeMotion::serialize(LLDataPacker& dp) const
LL_DEBUGS("BVH") << " rot: t " << rot_key.mTime << " angles " << rot_angles.mV[VX] <<","<< rot_angles.mV[VY] <<","<< rot_angles.mV[VZ] << LL_ENDL;
}
success &= dp.packS32(joint_motionp->mPositionCurve.mKeys.size(), "num_pos_keys");
for (PositionCurve::key_map_t::iterator iter = joint_motionp->mPositionCurve.mKeys.begin();
iter != joint_motionp->mPositionCurve.mKeys.end(); ++iter)
success &= dp.packS32(joint_motionp->mPositionCurve.mNumKeys, "num_pos_keys");
for (PositionCurve::key_map_t::value_type& pos_pair : joint_motionp->mPositionCurve.mKeys)
{
PositionKey& pos_key = iter->second;
PositionKey& pos_key = pos_pair.second;
U16 time_short = F32_to_U16(pos_key.mTime, 0.f, mJointMotionList->mDuration);
success &= dp.packU16(time_short, "time");
@ -2086,10 +2076,8 @@ BOOL LLKeyframeMotion::serialize(LLDataPacker& dp) const
success &= dp.packS32(mJointMotionList->mConstraints.size(), "num_constraints");
LL_DEBUGS("BVH") << "num_constraints " << mJointMotionList->mConstraints.size() << LL_ENDL;
for (JointMotionList::constraint_list_t::const_iterator iter = mJointMotionList->mConstraints.begin();
iter != mJointMotionList->mConstraints.end(); ++iter)
for (JointConstraintSharedData* shared_constraintp : mJointMotionList->mConstraints)
{
JointConstraintSharedData* shared_constraintp = *iter;
success &= dp.packU8(shared_constraintp->mChainLength, "chain_length");
success &= dp.packU8(shared_constraintp->mConstraintType, "constraint_type");
char source_volume[16]; /* Flawfinder: ignore */
@ -2441,14 +2429,13 @@ void LLKeyframeDataCache::dumpDiagInfo()
LL_INFOS() << "-----------------------------------------------------" << LL_ENDL;
// print each loaded mesh, and it's memory usage
for (keyframe_data_map_t::iterator map_it = sKeyframeDataMap.begin();
map_it != sKeyframeDataMap.end(); ++map_it)
for (keyframe_data_map_t::value_type& data_pair : sKeyframeDataMap)
{
U32 joint_motion_kb;
LLKeyframeMotion::JointMotionList *motion_list_p = map_it->second;
LLKeyframeMotion::JointMotionList *motion_list_p = data_pair.second;
LL_INFOS() << "Motion: " << map_it->first << LL_ENDL;
LL_INFOS() << "Motion: " << data_pair.first << LL_ENDL;
joint_motion_kb = motion_list_p->dumpDiagInfo();

58
indra/llcharacter/llkeyframemotionparam.cpp
View File

@ -64,13 +64,11 @@ LLKeyframeMotionParam::LLKeyframeMotionParam( const LLUUID &id) : LLMotion(id)
//-----------------------------------------------------------------------------
LLKeyframeMotionParam::~LLKeyframeMotionParam()
{
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
delete paramMotion.mMotion;
}
motionList.clear();
@ -90,13 +88,11 @@ LLMotion::LLMotionInitStatus LLKeyframeMotionParam::onInitialize(LLCharacter *ch
return STATUS_FAILURE;
}
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
LLMotion* motion = paramMotion.mMotion;
motion->onInitialize(character);
@ -139,13 +135,11 @@ LLMotion::LLMotionInitStatus LLKeyframeMotionParam::onInitialize(LLCharacter *ch
//-----------------------------------------------------------------------------
BOOL LLKeyframeMotionParam::onActivate()
{
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
paramMotion.mMotion->activate(mActivationTimestamp);
}
}
@ -162,23 +156,20 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
F32 weightFactor = 1.f / (F32)mParameterizedMotions.size();
// zero out all pose weights
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
// LL_INFOS() << "Weight for pose " << paramMotion.mMotion->getName() << " is " << paramMotion.mMotion->getPose()->getWeight() << LL_ENDL;
paramMotion.mMotion->getPose()->setWeight(0.f);
}
}
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
const std::string& paramName = iter->first;
const std::string& paramName = motion_pair.first;
F32* paramValue = (F32 *)mCharacter->getAnimationData(paramName);
if (NULL == paramValue) // unexpected, but...
{
@ -190,10 +181,9 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
const ParameterizedMotion* firstMotion = NULL;
const ParameterizedMotion* secondMotion = NULL;
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
paramMotion.mMotion->onUpdate(time, joint_mask);
F32 distToParam = paramMotion.mParam - *paramValue;
@ -280,13 +270,11 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
//-----------------------------------------------------------------------------
void LLKeyframeMotionParam::onDeactivate()
{
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
paramMotion.mMotion->onDeactivate();
}
}
@ -318,13 +306,11 @@ BOOL LLKeyframeMotionParam::addKeyframeMotion(char *name, const LLUUID &id, char
//-----------------------------------------------------------------------------
void LLKeyframeMotionParam::setDefaultKeyframeMotion(char *name)
{
for (motion_map_t::iterator iter = mParameterizedMotions.begin();
iter != mParameterizedMotions.end(); ++iter)
for (motion_map_t::value_type& motion_pair : mParameterizedMotions)
{
motion_list_t& motionList = iter->second;
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
motion_list_t& motionList = motion_pair.second;
for (const ParameterizedMotion& paramMotion : motionList)
{
const ParameterizedMotion& paramMotion = *iter2;
if (paramMotion.mMotion->getName() == name)
{
mDefaultKeyframeMotion = paramMotion.mMotion;

27
indra/llcharacter/llmotioncontroller.cpp
View File

@ -211,11 +211,8 @@ void LLMotionController::purgeExcessMotions()
{
// too many motions active this frame, kill all blenders
mPoseBlender.clearBlenders();
for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin();
loaded_motion_it != mLoadedMotions.end();
++loaded_motion_it)
for (LLMotion* cur_motionp : mLoadedMotions)
{
LLMotion* cur_motionp = *loaded_motion_it;
// motion isn't playing, delete it
if (!isMotionActive(cur_motionp))
{
@ -225,13 +222,10 @@ void LLMotionController::purgeExcessMotions()
}
// clean up all inactive, loaded motions
for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin();
motion_it != motions_to_kill.end();
++motion_it)
for (LLUUID motion_id : motions_to_kill)
{
// look up the motion again by ID to get canonical instance
// and kill it only if that one is inactive
LLUUID motion_id = *motion_it;
LLMotion* motionp = findMotion(motion_id);
if (motionp && !isMotionActive(motionp))
{
@ -1059,12 +1053,11 @@ LLMotion* LLMotionController::findMotion(const LLUUID& id) const
void LLMotionController::dumpMotions()
{
LL_INFOS() << "=====================================" << LL_ENDL;
for (motion_map_t::iterator iter = mAllMotions.begin();
iter != mAllMotions.end(); iter++)
for (motion_map_t::value_type& motion_pair : mAllMotions)
{
LLUUID id = iter->first;
LLUUID id = motion_pair.first;
std::string state_string;
LLMotion *motion = iter->second;
LLMotion *motion = motion_pair.second;
if (mLoadingMotions.find(motion) != mLoadingMotions.end())
state_string += std::string("l");
if (mLoadedMotions.find(motion) != mLoadedMotions.end())
@ -1083,10 +1076,9 @@ void LLMotionController::dumpMotions()
//-----------------------------------------------------------------------------
void LLMotionController::deactivateAllMotions()
{
for (motion_map_t::iterator iter = mAllMotions.begin();
iter != mAllMotions.end(); iter++)
for (motion_map_t::value_type& motion_pair : mAllMotions)
{
LLMotion* motionp = iter->second;
LLMotion* motionp = motion_pair.second;
deactivateMotionInstance(motionp);
}
}
@ -1118,10 +1110,9 @@ void LLMotionController::flushAllMotions()
mCharacter->removeAnimationData("Hand Pose");
// restart motions
for (std::vector<std::pair<LLUUID,F32> >::iterator iter = active_motions.begin();
iter != active_motions.end(); ++iter)
for (std::vector<std::pair<LLUUID,F32> >::value_type& motion_pair : active_motions)
{
startMotion(iter->first, iter->second);
startMotion(motion_pair.first, motion_pair.second);
}
}

4
indra/llcharacter/llmultigesture.cpp
View File

@ -88,10 +88,8 @@ S32 LLMultiGesture::getMaxSerialSize() const
max_size += 64; // step count S32
std::vector<LLGestureStep*>::const_iterator it;
for (it = mSteps.begin(); it != mSteps.end(); ++it)
for (LLGestureStep* step : mSteps)
{
LLGestureStep* step = *it;
max_size += 64; // type S32
max_size += step->getMaxSerialSize();
}

6
indra/llcharacter/llpose.cpp
View File

@ -148,11 +148,9 @@ LLJointState* LLPose::findJointState(const std::string &name)
void LLPose::setWeight(F32 weight)
{
joint_map_iterator iter;
for(iter = mJointMap.begin();
iter != mJointMap.end();
++iter)
for (joint_map_value_type& joint_pair : mJointMap)
{
iter->second->setWeight(weight);
joint_pair.second->setWeight(weight);
}
mWeight = weight;
}

58
indra/llcharacter/llstatemachine.cpp
View File

@ -169,10 +169,9 @@ void LLStateDiagram::setDefaultState(LLFSMState& default_state)
S32 LLStateDiagram::numDeadendStates()
{
S32 numDeadends = 0;
StateMap::iterator state_it;
for(state_it = mStates.begin(); state_it != mStates.end(); ++state_it)
for (StateMap::value_type& state_pair : mStates)
{
if (state_it->second.size() == 0)
if (state_pair.second.size() == 0)
{
numDeadends++;
}
@ -191,12 +190,11 @@ BOOL LLStateDiagram::stateIsValid(LLFSMState& state)
LLFSMState* LLStateDiagram::getState(U32 state_id)
{
StateMap::iterator state_it;
for(state_it = mStates.begin(); state_it != mStates.end(); ++state_it)
for (StateMap::value_type& state_pair : mStates)
{
if (state_it->first->getID() == state_id)
if (state_pair.first->getID() == state_id)
{
return state_it->first;
return state_pair.first;
}
}
return NULL;
@ -215,18 +213,16 @@ BOOL LLStateDiagram::saveDotFile(const std::string& filename)
}
apr_file_printf(dot_file, "digraph StateMachine {\n\tsize=\"100,100\";\n\tfontsize=40;\n\tlabel=\"Finite State Machine\";\n\torientation=landscape\n\tratio=.77\n");
StateMap::iterator state_it;
for(state_it = mStates.begin(); state_it != mStates.end(); ++state_it)
for (StateMap::value_type& state_pair : mStates)
{
apr_file_printf(dot_file, "\t\"%s\" [fontsize=28,shape=box]\n", state_it->first->getName().c_str());
apr_file_printf(dot_file, "\t\"%s\" [fontsize=28,shape=box]\n", state_pair.first->getName().c_str());
}
apr_file_printf(dot_file, "\t\"All States\" [fontsize=30,style=bold,shape=box]\n");
Transitions::iterator transitions_it;
for(transitions_it = mDefaultTransitions.begin(); transitions_it != mDefaultTransitions.end(); ++transitions_it)
for (Transitions::value_type& transition_pair : mDefaultTransitions)
{
apr_file_printf(dot_file, "\t\"All States\" -> \"%s\" [label = \"%s\",fontsize=24];\n", transitions_it->second->getName().c_str(),
transitions_it->second->getName().c_str());
apr_file_printf(dot_file, "\t\"All States\" -> \"%s\" [label = \"%s\",fontsize=24];\n", transition_pair.second->getName().c_str(),
transition_pair.second->getName().c_str());
}
if (mDefaultState)
@ -235,18 +231,15 @@ BOOL LLStateDiagram::saveDotFile(const std::string& filename)
}
for(state_it = mStates.begin(); state_it != mStates.end(); ++state_it)
for (StateMap::value_type& state_pair : mStates)
{
LLFSMState *state = state_it->first;
LLFSMState *state = state_pair.first;
Transitions::iterator transitions_it;
for(transitions_it = state_it->second.begin();
transitions_it != state_it->second.end();
++transitions_it)
for (Transitions::value_type& transition_pair : state_pair.second)
{
std::string state_name = state->getName();
std::string target_name = transitions_it->second->getName();
std::string transition_name = transitions_it->first->getName();
std::string target_name = transition_pair.second->getName();
std::string transition_name = transition_pair.first->getName();
apr_file_printf(dot_file, "\t\"%s\" -> \"%s\" [label = \"%s\",fontsize=24];\n", state->getName().c_str(),
target_name.c_str(),
transition_name.c_str());
@ -265,25 +258,18 @@ std::ostream& operator<<(std::ostream &s, LLStateDiagram &FSM)
s << "Default State: " << FSM.mDefaultState->getName() << "\n";
}
LLStateDiagram::Transitions::iterator transitions_it;
for(transitions_it = FSM.mDefaultTransitions.begin();
transitions_it != FSM.mDefaultTransitions.end();
++transitions_it)
for (LLStateDiagram::Transitions::value_type& transition_pair : FSM.mDefaultTransitions)
{
s << "Any State -- " << transitions_it->first->getName()
<< " --> " << transitions_it->second->getName() << "\n";
s << "Any State -- " << transition_pair.first->getName()
<< " --> " << transition_pair.second->getName() << "\n";
}
LLStateDiagram::StateMap::iterator state_it;
for(state_it = FSM.mStates.begin(); state_it != FSM.mStates.end(); ++state_it)
for (LLStateDiagram::StateMap::value_type& state_pair : FSM.mStates)
{
LLStateDiagram::Transitions::iterator transitions_it;
for(transitions_it = state_it->second.begin();
transitions_it != state_it->second.end();
++transitions_it)
for (LLStateDiagram::Transitions::value_type& transition_pair : state_pair.second)
{
s << state_it->first->getName() << " -- " << transitions_it->first->getName()
<< " --> " << transitions_it->second->getName() << "\n";
s << state_pair.first->getName() << " -- " << transition_pair.first->getName()
<< " --> " << transition_pair.second->getName() << "\n";
}
s << "\n";
}

2
indra/llcommon/CMakeLists.txt
View File

@ -105,6 +105,7 @@ set(llcommon_SOURCE_FILES
lluriparser.cpp
lluuid.cpp
llworkerthread.cpp
hbxxh.cpp
u64.cpp
threadpool.cpp
workqueue.cpp
@ -241,6 +242,7 @@ set(llcommon_HEADER_FILES
llwin32headers.h
llwin32headerslean.h
llworkerthread.h
hbxxh.h
lockstatic.h
stdtypes.h
stringize.h

377
indra/llcommon/hbxxh.cpp Normal file
View File

@ -0,0 +1,377 @@
/**
* @file hbxxh.cpp
* @brief High performances vectorized hashing based on xxHash.
*
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (c) 2023, Henri Beauchamp.
*
* 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"
// This define ensures that xxHash will be compiled within this module, with
// vectorized (*) and inlined functions (with no exported API symbol); our
// xxhash "pre-built library" package actually only contains the xxhash.h
// header (no library needed at link time).
// (*) SSE2 is normally used for x86(_64) builds, unless you enabled AVX2
// in your build, in which case the latter would be used instead. For ARM64
// builds, this would also automatically enable NEON vectorization.
#define XXH_INLINE_ALL
#include "xxhash/xxhash.h"
#include "hbxxh.h"
// How many bytes to grab at a time when hashing files or streams
constexpr size_t BLOCK_LEN = 4096;
///////////////////////////////////////////////////////////////////////////////
// HBXXH64 class
///////////////////////////////////////////////////////////////////////////////
//static
U64 HBXXH64::digest(const void* buffer, size_t len)
{
return XXH3_64bits(buffer, len);
}
//static
U64 HBXXH64::digest(const char* str)
{
return XXH3_64bits((const void*)str, strlen(str));
}
//static
U64 HBXXH64::digest(const std::string& str)
{
return XXH3_64bits((const void*)str.c_str(), str.size());
}
// Must be called by all constructors.
void HBXXH64::init()
{
mDigest = 0;
mState = (void*)XXH3_createState();
if (!mState || XXH3_64bits_reset((XXH3_state_t*)mState) != XXH_OK)
{
LL_WARNS() << "Failed to initialize state !" << LL_ENDL;
}
}
HBXXH64::~HBXXH64()
{
if (mState)
{
XXH3_freeState((XXH3_state_t*)mState);
}
}
void HBXXH64::update(const void* buffer, size_t len)
{
if (mState)
{
XXH3_64bits_update((XXH3_state_t*)mState, buffer, len);
}
else
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
}
}
void HBXXH64::update(const std::string& str)
{
if (mState)
{
XXH3_64bits_update((XXH3_state_t*)mState, (const void*)str.c_str(),
str.length());
}
else
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
}
}
void HBXXH64::update(std::istream& stream)
{
if (!mState)
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
return;
}
char buffer[BLOCK_LEN];
size_t len;
while (stream.good())
{
stream.read(buffer, BLOCK_LEN);
len = stream.gcount();
XXH3_64bits_update((XXH3_state_t*)mState, (const void*)buffer, len);
}
}
void HBXXH64::update(FILE* file)
{
if (!mState)
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
return;
}
char buffer[BLOCK_LEN];
size_t len;
while ((len = fread((void*)buffer, 1, BLOCK_LEN, file)))
{
XXH3_64bits_update((XXH3_state_t*)mState, (const void*)buffer, len);
}
fclose(file);
}
void HBXXH64::finalize()
{
if (!mState)
{
LL_WARNS() << "Already finalized !" << LL_ENDL;
return;
}
mDigest = XXH3_64bits_digest((XXH3_state_t*)mState);
XXH3_freeState((XXH3_state_t*)mState);
mState = NULL;
}
U64 HBXXH64::digest() const
{
return mState ? XXH3_64bits_digest((XXH3_state_t*)mState) : mDigest;
}
std::ostream& operator<<(std::ostream& stream, HBXXH64 context)
{
stream << context.digest();
return stream;
}
///////////////////////////////////////////////////////////////////////////////
// HBXXH128 class
///////////////////////////////////////////////////////////////////////////////
//static
LLUUID HBXXH128::digest(const void* buffer, size_t len)
{
XXH128_hash_t hash = XXH3_128bits(buffer, len);
LLUUID id;
U64* data = (U64*)id.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
return id;
}
//static
LLUUID HBXXH128::digest(const char* str)
{
XXH128_hash_t hash = XXH3_128bits((const void*)str, strlen(str));
LLUUID id;
U64* data = (U64*)id.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
return id;
}
//static
LLUUID HBXXH128::digest(const std::string& str)
{
XXH128_hash_t hash = XXH3_128bits((const void*)str.c_str(), str.size());
LLUUID id;
U64* data = (U64*)id.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
return id;
}
//static
void HBXXH128::digest(LLUUID& result, const void* buffer, size_t len)
{
XXH128_hash_t hash = XXH3_128bits(buffer, len);
U64* data = (U64*)result.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
}
//static
void HBXXH128::digest(LLUUID& result, const char* str)
{
XXH128_hash_t hash = XXH3_128bits((const void*)str, strlen(str));
U64* data = (U64*)result.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
}
//static
void HBXXH128::digest(LLUUID& result, const std::string& str)
{
XXH128_hash_t hash = XXH3_128bits((const void*)str.c_str(), str.size());
U64* data = (U64*)result.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
}
// Must be called by all constructors.
void HBXXH128::init()
{
mState = (void*)XXH3_createState();
if (!mState || XXH3_128bits_reset((XXH3_state_t*)mState) != XXH_OK)
{
LL_WARNS() << "Failed to initialize state !" << LL_ENDL;
}
}
HBXXH128::~HBXXH128()
{
if (mState)
{
XXH3_freeState((XXH3_state_t*)mState);
}
}
void HBXXH128::update(const void* buffer, size_t len)
{
if (mState)
{
XXH3_128bits_update((XXH3_state_t*)mState, buffer, len);
}
else
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
}
}
void HBXXH128::update(const std::string& str)
{
if (mState)
{
XXH3_128bits_update((XXH3_state_t*)mState, (const void*)str.c_str(),
str.length());
}
else
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
}
}
void HBXXH128::update(std::istream& stream)
{
if (!mState)
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
return;
}
char buffer[BLOCK_LEN];
size_t len;
while (stream.good())
{
stream.read(buffer, BLOCK_LEN);
len = stream.gcount();
XXH3_128bits_update((XXH3_state_t*)mState, (const void*)buffer, len);
}
}
void HBXXH128::update(FILE* file)
{
if (!mState)
{
LL_WARNS() << "Cannot update a finalized digest !" << LL_ENDL;
return;
}
char buffer[BLOCK_LEN];
size_t len;
while ((len = fread((void*)buffer, 1, BLOCK_LEN, file)))
{
XXH3_128bits_update((XXH3_state_t*)mState, (const void*)buffer, len);
}
fclose(file);
}
void HBXXH128::finalize()
{
if (!mState)
{
LL_WARNS() << "Already finalized !" << LL_ENDL;
return;
}
XXH128_hash_t hash = XXH3_128bits_digest((XXH3_state_t*)mState);
U64* data = (U64*)mDigest.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
XXH3_freeState((XXH3_state_t*)mState);
mState = NULL;
}
const LLUUID& HBXXH128::digest() const
{
if (mState)
{
XXH128_hash_t hash = XXH3_128bits_digest((XXH3_state_t*)mState);
// We cheat the const-ness of the method here, but this is OK, since
// mDigest is private and cannot be accessed indirectly by other
// methods than digest() ones, that do check for mState to decide
// wether mDigest's current value may be provided as is or not. This
// cheat saves us a temporary LLLUID copy.
U64* data = (U64*)mDigest.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
}
return mDigest;
}
void HBXXH128::digest(LLUUID& result) const
{
if (!mState)
{
result = mDigest;
return;
}
XXH128_hash_t hash = XXH3_128bits_digest((XXH3_state_t*)mState);
U64* data = (U64*)result.mData;
// Note: we do not check endianness here and we just store in the same
// order as XXH128_hash_t, that is low word "first".
data[0] = hash.low64;
data[1] = hash.high64;
}
std::ostream& operator<<(std::ostream& stream, HBXXH128 context)
{
stream << context.digest();
return stream;
}

259
indra/llcommon/hbxxh.h Normal file
View File

@ -0,0 +1,259 @@
/**
* @file hbxxh.h
* @brief High performances vectorized hashing based on xxHash.
*
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (c) 2023, Henri Beauchamp.
*
* 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$
*/
#ifndef LL_HBXXH_H
#define LL_HBXXH_H
#include "lluuid.h"
// HBXXH* classes are to be used where speed matters and cryptographic quality
// is not required (no "one-way" guarantee, though they are likely not worst in
// this respect than MD5 which got busted and is now considered too weak). The
// xxHash code they are built upon is vectorized and about 50 times faster than
// MD5. A 64 bits hash class is also provided for when 128 bits of entropy are
// not needed. The hashes collision rate is similar to MD5's.
// See https://github.com/Cyan4973/xxHash#readme for details.
// 64 bits hashing class
class HBXXH64
{
friend std::ostream& operator<<(std::ostream&, HBXXH64);
protected:
LOG_CLASS(HBXXH64);
public:
inline HBXXH64() { init(); }
// Constructors for special circumstances; they all digest the first passed
// parameter. Set 'do_finalize' to false if you do not want to finalize the
// context, which is useful/needed when you want to update() it afterwards.
// Ideally, the compiler should be smart enough to get our clue and
// optimize out the const bool test during inlining...
inline HBXXH64(const void* buffer, size_t len,
const bool do_finalize = true)
{
init();
update(buffer, len);
if (do_finalize)
{
finalize();
}
}
inline HBXXH64(const std::string& str, const bool do_finalize = true)
{
init();
update(str);
if (do_finalize)
{
finalize();
}
}
inline HBXXH64(std::istream& s, const bool do_finalize = true)
{
init();
update(s);
if (do_finalize)
{
finalize();
}
}
inline HBXXH64(FILE* file, const bool do_finalize = true)
{
init();
update(file);
if (do_finalize)
{
finalize();
}
}
~HBXXH64();
void update(const void* buffer, size_t len);
void update(const std::string& str);
void update(std::istream& s);
void update(FILE* file);
// Note that unlike what happens with LLMD5, you do not need to finalize()
// HBXXH64 before using digest(), and you may keep updating() it even after
// you got a first digest() (the next digest would of course change after
// any update). It is still useful to use finalize() when you do not want
// to store a final digest() result in a separate U64; after this method
// has been called, digest() simply returns mDigest value.
void finalize();
U64 digest() const;
// Fast static methods. Use them when hashing just one contiguous block of
// data.
static U64 digest(const void* buffer, size_t len);
static U64 digest(const char* str); // str must be NUL-terminated
static U64 digest(const std::string& str);
private:
void init();
private:
// We use a void pointer to avoid including xxhash.h here for XXH3_state_t
// (which cannot either be trivially forward-declared, due to complex API
// related pre-processor macros in xxhash.h).
void* mState;
U64 mDigest;
};
inline bool operator==(const HBXXH64& a, const HBXXH64& b)
{
return a.digest() == b.digest();
}
inline bool operator!=(const HBXXH64& a, const HBXXH64& b)
{
return a.digest() != b.digest();
}
// 128 bits hashing class
class HBXXH128
{
friend std::ostream& operator<<(std::ostream&, HBXXH128);
protected:
LOG_CLASS(HBXXH128);
public:
inline HBXXH128() { init(); }
// Constructors for special circumstances; they all digest the first passed
// parameter. Set 'do_finalize' to false if you do not want to finalize the
// context, which is useful/needed when you want to update() it afterwards.
// Ideally, the compiler should be smart enough to get our clue and
// optimize out the const bool test during inlining...
inline HBXXH128(const void* buffer, size_t len,
const bool do_finalize = true)
{
init();
update(buffer, len);
if (do_finalize)
{
finalize();
}
}
inline HBXXH128(const std::string& str, const bool do_finalize = true)
{
init();
update(str);
if (do_finalize)
{
finalize();
}
}
inline HBXXH128(std::istream& s, const bool do_finalize = true)
{
init();
update(s);
if (do_finalize)
{
finalize();
}
}
inline HBXXH128(FILE* file, const bool do_finalize = true)
{
init();
update(file);
if (do_finalize)
{
finalize();
}
}
~HBXXH128();
void update(const void* buffer, size_t len);
void update(const std::string& str);
void update(std::istream& s);
void update(FILE* file);
// Note that unlike what happens with LLMD5, you do not need to finalize()
// HBXXH128 before using digest(), and you may keep updating() it even
// after you got a first digest() (the next digest would of course change
// after any update). It is still useful to use finalize() when you do not
// want to store a final digest() result in a separate LLUUID; after this
// method has been called, digest() simply returns a reference on mDigest.
void finalize();
// We use an LLUUID for the digest, since this is a 128 bits wide native
// type available in the viewer code, making it easy to manipulate. It also
// allows to use HBXXH128 efficiently in LLUUID generate() and combine()
// methods.
const LLUUID& digest() const;
// Here, we avoid an LLUUID copy whenever we already got one to store the
// result *and* we did not yet call finalize().
void digest(LLUUID& result) const;
// Fast static methods. Use them when hashing just one contiguous block of
// data.
static LLUUID digest(const void* buffer, size_t len);
static LLUUID digest(const char* str); // str must be NUL-terminated
static LLUUID digest(const std::string& str);
// Same as above, but saves you from an LLUUID copy when you already got
// one for storage use.
static void digest(LLUUID& result, const void* buffer, size_t len);
static void digest(LLUUID& result, const char* str); // str NUL-terminated
static void digest(LLUUID& result, const std::string& str);
private:
void init();
private:
// We use a void pointer to avoid including xxhash.h here for XXH3_state_t
// (which cannot either be trivially forward-declared, due to complex API
// related pre-processor macros in xxhash.h).
void* mState;
LLUUID mDigest;
};
inline bool operator==(const HBXXH128& a, const HBXXH128& b)
{
return a.digest() == b.digest();
}
inline bool operator!=(const HBXXH128& a, const HBXXH128& b)
{
return a.digest() != b.digest();
}
#endif // LL_HBXXH_H

10
indra/llcommon/llallocator_heap_profile.cpp
View File

@ -130,15 +130,13 @@ void LLAllocatorHeapProfile::parse(std::string const & prof_text)
void LLAllocatorHeapProfile::dump(std::ostream & out) const
{
lines_t::const_iterator i;
for(i = mLines.begin(); i != mLines.end(); ++i)
for (const LLAllocatorHeapProfile::line& line : mLines)
{
out << i->mLiveCount << ": " << i->mLiveSize << '[' << i->mTotalCount << ": " << i->mTotalSize << "] @";
out << line.mLiveCount << ": " << line.mLiveSize << '[' << line.mTotalCount << ": " << line.mTotalSize << "] @";
stack_trace::const_iterator j;
for(j = i->mTrace.begin(); j != i->mTrace.end(); ++j)
for (const stack_marker marker : line.mTrace)
{
out << ' ' << *j;
out << ' ' << marker;
}
out << '\n';
}

6
indra/llcommon/llapp.cpp
View File

@ -862,14 +862,14 @@ bool unix_post_minidump_callback(const char *dump_dir,
// heap allocations in a crash handler.
// path format: <dump_dir>/<minidump_id>.dmp
int dirPathLength = strlen(dump_dir);
int idLength = strlen(minidump_id);
auto dirPathLength = strlen(dump_dir);
auto idLength = strlen(minidump_id);
// The path must not be truncated.
llassert((dirPathLength + idLength + 5) <= LLApp::MAX_MINDUMP_PATH_LENGTH);
char * path = LLApp::instance()->getMiniDumpFilename();
S32 remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
auto remaining = LLApp::MAX_MINDUMP_PATH_LENGTH;
strncpy(path, dump_dir, remaining);
remaining -= dirPathLength;
path += dirPathLength;

16
indra/llcommon/llassettype.cpp
View File

@ -150,14 +150,12 @@ LLAssetType::EType LLAssetType::lookup(const char* name)
LLAssetType::EType LLAssetType::lookup(const std::string& type_name)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
for (LLAssetDictionary::const_iterator iter = dict->begin();
iter != dict->end();
iter++)
for (const LLAssetDictionary::value_type& pair : *dict)
{
const AssetEntry *entry = iter->second;
const AssetEntry *entry = pair.second;
if (type_name == entry->mTypeName)
{
return iter->first;
return pair.first;
}
}
return AT_UNKNOWN;
@ -188,14 +186,12 @@ LLAssetType::EType LLAssetType::lookupHumanReadable(const char* name)
LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_name)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
for (LLAssetDictionary::const_iterator iter = dict->begin();
iter != dict->end();
iter++)
for (const LLAssetDictionary::value_type& pair : *dict)
{
const AssetEntry *entry = iter->second;
const AssetEntry *entry = pair.second;
if (entry->mHumanName && (readable_name == entry->mHumanName))
{
return iter->first;
return pair.first;
}
}
return AT_NONE;

4
indra/llcommon/llbase64.cpp
View File

@ -42,7 +42,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
&& input_size > 0)
{
// Yes, it returns int.
int b64_buffer_length = apr_base64_encode_len(input_size);
int b64_buffer_length = apr_base64_encode_len(narrow(input_size));
char* b64_buffer = new char[b64_buffer_length];
// This is faster than apr_base64_encode() if you know
@ -52,7 +52,7 @@ std::string LLBase64::encode(const U8* input, size_t input_size)
b64_buffer_length = apr_base64_encode_binary(
b64_buffer,
input,
input_size);
narrow(input_size));
output.assign(b64_buffer);
delete[] b64_buffer;
}

2
indra/llcommon/llcallbacklist.cpp
View File

@ -109,7 +109,7 @@ void LLCallbackList::deleteAllFunctions()
void LLCallbackList::callFunctions()
{
for (callback_list_t::iterator iter = mCallbackList.begin(); iter != mCallbackList.end(); )
for (callback_list_t::iterator iter = mCallbackList.begin(); iter != mCallbackList.end(); )
{
callback_list_t::iterator curiter = iter++;
curiter->first(curiter->second);

18
indra/llcommon/llcallstack.cpp
View File

@ -91,10 +91,9 @@ LLCallStack::LLCallStack(S32 skip_count, bool verbose):
bool LLCallStack::contains(const std::string& str)
{
for (std::vector<std::string>::const_iterator it = m_strings.begin();
it != m_strings.end(); ++it)
for (const std::string& src_str : m_strings)
{
if (it->find(str) != std::string::npos)
if (src_str.find(str) != std::string::npos)
{
return true;
}
@ -105,10 +104,9 @@ bool LLCallStack::contains(const std::string& str)
std::ostream& operator<<(std::ostream& s, const LLCallStack& call_stack)
{
#ifndef LL_RELEASE_FOR_DOWNLOAD
std::vector<std::string>::const_iterator it;
for (it=call_stack.m_strings.begin(); it!=call_stack.m_strings.end(); ++it)
for (const std::string& str : call_stack.m_strings)
{
s << *it;
s << str;
}
#else
s << "UNAVAILABLE IN RELEASE";
@ -156,9 +154,9 @@ bool LLContextStrings::contains(const std::string& str)
{
const std::map<std::string,S32>& strings =
LLThreadLocalSingletonPointer<LLContextStrings>::getInstance()->m_contextStrings;
for (std::map<std::string,S32>::const_iterator it = strings.begin(); it!=strings.end(); ++it)
for (const std::map<std::string,S32>::value_type& str_pair : strings)
{
if (it->first.find(str) != std::string::npos)
if (str_pair.first.find(str) != std::string::npos)
{
return true;
}
@ -171,9 +169,9 @@ void LLContextStrings::output(std::ostream& os)
{
const std::map<std::string,S32>& strings =
LLThreadLocalSingletonPointer<LLContextStrings>::getInstance()->m_contextStrings;
for (std::map<std::string,S32>::const_iterator it = strings.begin(); it!=strings.end(); ++it)
for (const std::map<std::string,S32>::value_type& str_pair : strings)
{
os << it->first << "[" << it->second << "]" << "\n";
os << str_pair.first << "[" << str_pair.second << "]" << "\n";
}
}

62
indra/llcommon/lldefs.h
View File

@ -28,6 +28,7 @@
#define LL_LLDEFS_H
#include "stdtypes.h"
#include <type_traits>
// Often used array indices
const U32 VX = 0;
@ -168,80 +169,79 @@ const U32 MAXADDRSTR = 17; // 123.567.901.345 = 15 chars + \0 + 1 for good luc
// llclampb(a) // clamps a to [0 .. 255]
//
template <class LLDATATYPE>
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2)
template <typename T1, typename T2>
inline auto llmax(T1 d1, T2 d2)
{
return (d1 > d2) ? d1 : d2;
}
template <class LLDATATYPE>
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
template <typename T1, typename T2, typename T3>
inline auto llmax(T1 d1, T2 d2, T3 d3)
{
LLDATATYPE r = llmax(d1,d2);
auto r = llmax(d1,d2);
return llmax(r, d3);
}
template <class LLDATATYPE>
inline LLDATATYPE llmax(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
template <typename T1, typename T2, typename T3, typename T4>
inline auto llmax(T1 d1, T2 d2, T3 d3, T4 d4)
{
LLDATATYPE r1 = llmax(d1,d2);
LLDATATYPE r2 = llmax(d3,d4);
auto r1 = llmax(d1,d2);
auto r2 = llmax(d3,d4);
return llmax(r1, r2);
}
template <class LLDATATYPE>
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2)
template <typename T1, typename T2>
inline auto llmin(T1 d1, T2 d2)
{
return (d1 < d2) ? d1 : d2;
}
template <class LLDATATYPE>
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3)
template <typename T1, typename T2, typename T3>
inline auto llmin(T1 d1, T2 d2, T3 d3)
{
LLDATATYPE r = llmin(d1,d2);
auto r = llmin(d1,d2);
return (r < d3 ? r : d3);
}
template <class LLDATATYPE>
inline LLDATATYPE llmin(const LLDATATYPE& d1, const LLDATATYPE& d2, const LLDATATYPE& d3, const LLDATATYPE& d4)
template <typename T1, typename T2, typename T3, typename T4>
inline auto llmin(T1 d1, T2 d2, T3 d3, T4 d4)
{
LLDATATYPE r1 = llmin(d1,d2);
LLDATATYPE r2 = llmin(d3,d4);
auto r1 = llmin(d1,d2);
auto r2 = llmin(d3,d4);
return llmin(r1, r2);
}
template <class LLDATATYPE>
inline LLDATATYPE llclamp(const LLDATATYPE& a, const LLDATATYPE& minval, const LLDATATYPE& maxval)
template <typename A, typename MIN, typename MAX>
inline A llclamp(A a, MIN minval, MAX maxval)
{
if ( a < minval )
A aminval{ static_cast<A>(minval) }, amaxval{ static_cast<A>(maxval) };
if ( a < aminval )
{
return minval;
return aminval;
}
else if ( a > maxval )
else if ( a > amaxval )
{
return maxval;
return amaxval;
}
return a;
}
template <class LLDATATYPE>
inline LLDATATYPE llclampf(const LLDATATYPE& a)
inline LLDATATYPE llclampf(LLDATATYPE a)
{
return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)1);
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(1));
}
template <class LLDATATYPE>
inline LLDATATYPE llclampb(const LLDATATYPE& a)
inline LLDATATYPE llclampb(LLDATATYPE a)
{
return llmin(llmax(a, (LLDATATYPE)0), (LLDATATYPE)255);
return llmin(llmax(a, LLDATATYPE(0)), LLDATATYPE(255));
}
template <class LLDATATYPE>
inline void llswap(LLDATATYPE& lhs, LLDATATYPE& rhs)
{
LLDATATYPE tmp = lhs;
lhs = rhs;
rhs = tmp;
std::swap(lhs, rhs);
}
#endif // LL_LLDEFS_H

2
indra/llcommon/lldependencies.cpp
View File

@ -42,7 +42,7 @@
// other Linden headers
#include "llexception.h"
LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(int vertices, const EdgeList& edges) const
LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(size_t vertices, const EdgeList& edges) const
{
// Construct a Boost Graph Library graph according to the constraints
// we've collected. It seems as though we ought to be able to capture

4
indra/llcommon/lldependencies.h
View File

@ -126,7 +126,7 @@ public:
protected:
typedef std::vector< std::pair<std::size_t, std::size_t> > EdgeList;
typedef std::vector<std::size_t> VertexList;
VertexList topo_sort(int vertices, const EdgeList& edges) const;
VertexList topo_sort(size_t vertices, const EdgeList& edges) const;
/**
* refpair is specifically intended to capture a pair of references. This
@ -539,7 +539,7 @@ public:
for (typename DepNodeMap::const_iterator nmi = mNodes.begin(), nmend = mNodes.end();
nmi != nmend; ++nmi)
{
int thisnode = vmap[nmi->first];
auto thisnode = vmap[nmi->first];
// after dependencies: build edges from the named node to this one
for (typename DepNode::dep_set::const_iterator ai = nmi->second.after.begin(),
aend = nmi->second.after.end();

14
indra/llcommon/llerror.cpp
View File

@ -586,11 +586,9 @@ namespace
void Globals::invalidateCallSites()
{
for (CallSiteVector::const_iterator i = callSites.begin();
i != callSites.end();
++i)
for (LLError::CallSite* site : callSites)
{
(*i)->invalidate();
site->invalidate();
}
callSites.clear();
@ -1224,12 +1222,8 @@ namespace
std::string escaped_message;
LLMutexLock lock(&s->mRecorderMutex);
for (Recorders::const_iterator i = s->mRecorders.begin();
i != s->mRecorders.end();
++i)
for (LLError::RecorderPtr& r : s->mRecorders)
{
LLError::RecorderPtr r = *i;
if (!r->enabled())
{
continue;
@ -1514,7 +1508,7 @@ namespace LLError
const size_t BUF_SIZE = 64;
char time_str[BUF_SIZE]; /* Flawfinder: ignore */
int chars = strftime(time_str, BUF_SIZE,
auto chars = strftime(time_str, BUF_SIZE,
"%Y-%m-%dT%H:%M:%SZ",
gmtime(&now));

16
indra/llcommon/llevent.cpp
View File

@ -203,10 +203,9 @@ void LLSimpleDispatcher::removeListener(LLEventListener* listener)
std::vector<LLListenerEntry> LLSimpleDispatcher::getListeners() const
{
std::vector<LLListenerEntry> ret;
std::vector<LLListenerEntry>::const_iterator itor;
for (itor=mListeners.begin(); itor!=mListeners.end(); ++itor)
for (const LLListenerEntry& entry : mListeners)
{
ret.push_back(*itor);
ret.push_back(entry);
}
return ret;
@ -215,14 +214,12 @@ std::vector<LLListenerEntry> LLSimpleDispatcher::getListeners() const
// virtual
bool LLSimpleDispatcher::fireEvent(LLPointer<LLEvent> event, LLSD filter)
{
std::vector<LLListenerEntry>::iterator itor;
std::string filter_string = filter.asString();
for (itor=mListeners.begin(); itor!=mListeners.end(); ++itor)
for (LLListenerEntry& entry : mListeners)
{
LLListenerEntry& entry = *itor;
if (filter_string == "" || entry.filter.asString() == filter_string)
{
(entry.listener)->handleEvent(event, (*itor).userdata);
(entry.listener)->handleEvent(event, entry.userdata);
}
}
return true;
@ -276,10 +273,9 @@ void LLSimpleListener::clearDispatchers()
bool LLSimpleListener::handleAttach(LLEventDispatcher *dispatcher)
{
// Add dispatcher if it doesn't already exist
std::vector<LLEventDispatcher *>::iterator itor;
for (itor = mDispatchers.begin(); itor != mDispatchers.end(); ++itor)
for (LLEventDispatcher* disp : mDispatchers)
{
if ((*itor) == dispatcher) return true;
if (disp == dispatcher) return true;
}
mDispatchers.push_back(dispatcher);
return true;

24
indra/llcommon/lleventdispatcher.cpp
View File

@ -178,7 +178,7 @@ private:
// store it as a map from name string to position index. Of course that's
// easy to generate from the incoming names array, but why do it more than
// once?
typedef std::map<LLSD::String, LLSD::Integer> IndexMap;
typedef std::map<LLSD::String, size_t> IndexMap;
IndexMap _indexes;
// Generated array of default values, aligned with the array of param names.
LLSD _defaults;
@ -197,9 +197,9 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
{
LL_ERRS("LLSDArgsMapper") << function << " names must be an array, not " << names << LL_ENDL;
}
LLSD::Integer nparams(_names.size());
auto nparams(_names.size());
// From _names generate _indexes.
for (LLSD::Integer ni = 0, nend = _names.size(); ni < nend; ++ni)
for (size_t ni = 0, nend = _names.size(); ni < nend; ++ni)
{
_indexes[_names[ni]] = ni;
}
@ -214,7 +214,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
if (defaults.isUndefined() || defaults.isArray())
{
LLSD::Integer ndefaults = defaults.size();
auto ndefaults = defaults.size();
// defaults is a (possibly empty) array. Right-align it with names.
if (ndefaults > nparams)
{
@ -224,10 +224,10 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
// Offset by which we slide defaults array right to right-align with
// _names array
LLSD::Integer offset = nparams - ndefaults;
auto offset = nparams - ndefaults;
// Fill rightmost _defaults entries from defaults, and mark them as
// filled
for (LLSD::Integer i = 0, iend = ndefaults; i < iend; ++i)
for (size_t i = 0, iend = ndefaults; i < iend; ++i)
{
_defaults[i + offset] = defaults[i];
_has_dft[i + offset] = 1;
@ -247,7 +247,7 @@ LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
continue;
}
LLSD::Integer pos = ixit->second;
auto pos = ixit->second;
// Store default value at that position in the _defaults array.
_defaults[pos] = mi->second;
// Don't forget to record the fact that we've filled this
@ -301,7 +301,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
{
// Fill args from array. If there are too many args in passed array,
// ignore the rest.
LLSD::Integer size(argsmap.size());
auto size(argsmap.size());
if (size > args.size())
{
// We don't just use std::min() because we want to sneak in this
@ -338,7 +338,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
<< mi->first << "=" << mi->second << LL_ENDL;
continue;
}
LLSD::Integer pos = ixit->second;
auto pos = ixit->second;
// Store the value at that position in the args array.
args[pos] = mi->second;
// Don't forget to record the fact that we've filled this
@ -349,7 +349,7 @@ LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
// Fill any remaining holes from _defaults.
LLSD unfilled(LLSD::emptyArray());
for (LLSD::Integer i = 0, iend = args.size(); i < iend; ++i)
for (size_t i = 0, iend = args.size(); i < iend; ++i)
{
if (! filled[i])
{
@ -503,9 +503,9 @@ struct LLEventDispatcher::MapParamsDispatchEntry: public LLEventDispatcher::Para
if (defaults.isArray() || defaults.isUndefined())
{
// Right-align the params and defaults arrays.
LLSD::Integer offset = params.size() - defaults.size();
auto offset = params.size() - defaults.size();
// Now the name of every defaults[i] is at params[i + offset].
for (LLSD::Integer i(0), iend(defaults.size()); i < iend; ++i)
for (size_t i(0), iend(defaults.size()); i < iend; ++i)
{
// Erase this optional param from mRequired.
mRequired.erase(params[i + offset].asString());

10
indra/llcommon/llheteromap.cpp
View File

@ -22,11 +22,11 @@ LLHeteroMap::~LLHeteroMap()
{
// For each entry in our map, we must call its deleter, which is the only
// record we have of its original type.
for (TypeMap::iterator mi(mMap.begin()), me(mMap.end()); mi != me; ++mi)
for (TypeMap::value_type& pair : mMap)
{
// mi->second is the std::pair; mi->second.first is the void*;
// mi->second.second points to the deleter function
(mi->second.second)(mi->second.first);
mi->second.first = NULL;
// pair.second is the std::pair; pair.second.first is the void*;
// pair.second.second points to the deleter function
(pair.second.second)(pair.second.first);
pair.second.first = NULL;
}
}

7
indra/llcommon/llinitdestroyclass.cpp
View File

@ -21,10 +21,9 @@
void LLCallbackRegistry::fireCallbacks() const
{
for (FuncList::const_iterator fi = mCallbacks.begin(), fe = mCallbacks.end();
fi != fe; ++fi)
for (FuncList::value_type pair : mCallbacks)
{
LL_INFOS("LLInitDestroyClass") << "calling " << fi->first << "()" << LL_ENDL;
fi->second();
LL_INFOS("LLInitDestroyClass") << "calling " << pair.first << "()" << LL_ENDL;
pair.second();
}
}

86
indra/llcommon/llinitparam.cpp
View File

@ -207,10 +207,10 @@ namespace LLInitParam
if (!mValidated)
{
const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
for (BlockDescriptor::param_validation_list_t::const_iterator it = block_data.mValidationList.begin(); it != block_data.mValidationList.end(); ++it)
for (const BlockDescriptor::param_validation_list_t::value_type& pair : block_data.mValidationList)
{
const Param* param = getParamFromHandle(it->first);
if (!it->second(param))
const Param* param = getParamFromHandle(pair.first);
if (!pair.second(param))
{
if (emit_errors)
{
@ -235,13 +235,11 @@ namespace LLInitParam
// unnamed param is like LLView::Params::rect - implicit
const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
for (BlockDescriptor::param_list_t::const_iterator it = block_data.mUnnamedParams.begin();
it != block_data.mUnnamedParams.end();
++it)
for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
{
param_handle_t param_handle = (*it)->mParamHandle;
param_handle_t param_handle = ptr->mParamHandle;
const Param* param = getParamFromHandle(param_handle);
ParamDescriptor::serialize_func_t serialize_func = (*it)->mSerializeFunc;
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;
@ -249,23 +247,19 @@ namespace LLInitParam
}
}
for(BlockDescriptor::param_map_t::const_iterator it = block_data.mNamedParams.begin();
it != block_data.mNamedParams.end();
++it)
for (const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams)
{
param_handle_t param_handle = it->second->mParamHandle;
param_handle_t param_handle = pair.second->mParamHandle;
const Param* param = getParamFromHandle(param_handle);
ParamDescriptor::serialize_func_t serialize_func = it->second->mSerializeFunc;
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 (BlockDescriptor::param_list_t::const_iterator it2 = block_data.mUnnamedParams.begin();
it2 != block_data.mUnnamedParams.end();
++it2)
for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
{
if (param_handle == (*it2)->mParamHandle)
if (param_handle == ptr->mParamHandle)
{
duplicate = true;
break;
@ -279,7 +273,7 @@ namespace LLInitParam
continue;
}
name_stack.push_back(std::make_pair(it->first, !duplicate));
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();
@ -300,45 +294,39 @@ namespace LLInitParam
// unnamed param is like LLView::Params::rect - implicit
const BlockDescriptor& block_data = mostDerivedBlockDescriptor();
for (BlockDescriptor::param_list_t::const_iterator it = block_data.mUnnamedParams.begin();
it != block_data.mUnnamedParams.end();
++it)
for (const ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
{
param_handle_t param_handle = (*it)->mParamHandle;
param_handle_t param_handle = ptr->mParamHandle;
const Param* param = getParamFromHandle(param_handle);
ParamDescriptor::inspect_func_t inspect_func = (*it)->mInspectFunc;
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, (*it)->mMinCount, (*it)->mMaxCount);
inspect_func(*param, parser, name_stack, ptr->mMinCount, ptr->mMaxCount);
name_stack.pop_back();
}
}
for(BlockDescriptor::param_map_t::const_iterator it = block_data.mNamedParams.begin();
it != block_data.mNamedParams.end();
++it)
for(const BlockDescriptor::param_map_t::value_type& pair : block_data.mNamedParams)
{
param_handle_t param_handle = it->second->mParamHandle;
param_handle_t param_handle = pair.second->mParamHandle;
const Param* param = getParamFromHandle(param_handle);
ParamDescriptor::inspect_func_t inspect_func = it->second->mInspectFunc;
ParamDescriptor::inspect_func_t inspect_func = pair.second->mInspectFunc;
if (inspect_func)
{
// Ensure this param has not already been inspected
bool duplicate = false;
for (BlockDescriptor::param_list_t::const_iterator it2 = block_data.mUnnamedParams.begin();
it2 != block_data.mUnnamedParams.end();
++it2)
for (const ParamDescriptorPtr &ptr : block_data.mUnnamedParams)
{
if (param_handle == (*it2)->mParamHandle)
if (param_handle == ptr->mParamHandle)
{
duplicate = true;
break;
}
}
name_stack.push_back(std::make_pair(it->first, !duplicate));
inspect_func(*param, parser, name_stack, it->second->mMinCount, it->second->mMaxCount);
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();
}
}
@ -382,12 +370,10 @@ namespace LLInitParam
}
// try to parse unnamed parameters, in declaration order
for ( BlockDescriptor::param_list_t::iterator it = block_data.mUnnamedParams.begin();
it != block_data.mUnnamedParams.end();
++it)
for (ParamDescriptorPtr& ptr : block_data.mUnnamedParams)
{
Param* paramp = getParamFromHandle((*it)->mParamHandle);
ParamDescriptor::deserialize_func_t deserialize_func = (*it)->mDeserializeFunc;
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))
{
@ -453,12 +439,9 @@ namespace LLInitParam
{
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)
for (ParamDescriptorPtr& ptr : descriptor.mAllParams)
{
if ((*it)->mParamHandle == handle) return *it;
if (ptr->mParamHandle == handle) return ptr;
}
return ParamDescriptorPtr();
}
@ -468,17 +451,14 @@ namespace LLInitParam
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();
for (BlockDescriptor::all_params_list_t::const_iterator it = block_data.mAllParams.begin();
it != end_it;
++it)
for (const ParamDescriptorPtr& ptr : block_data.mAllParams)
{
const Param* other_paramp = other.getParamFromHandle((*it)->mParamHandle);
ParamDescriptor::merge_func_t merge_func = (*it)->mMergeFunc;
const Param* other_paramp = other.getParamFromHandle(ptr->mParamHandle);
ParamDescriptor::merge_func_t merge_func = ptr->mMergeFunc;
if (merge_func)
{
Param* paramp = getParamFromHandle((*it)->mParamHandle);
llassert(paramp->getEnclosingBlockOffset() == (*it)->mParamHandle);
Param* paramp = getParamFromHandle(ptr->mParamHandle);
llassert(paramp->getEnclosingBlockOffset() == ptr->mParamHandle);
some_param_changed |= merge_func(*paramp, *other_paramp, overwrite);
}
}

14
indra/llcommon/llinitparam.h
View File

@ -325,13 +325,11 @@ namespace LLInitParam
std::string calcValueName(const value_t& value) const
{
value_name_map_t* map = getValueNames();
for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end();
it != end_it;
++it)
for (typename value_name_map_t::value_type& map_pair : *map)
{
if (ParamCompare<T>::equals(it->second, value))
if (ParamCompare<T>::equals(map_pair.second, value))
{
return it->first;
return map_pair.first;
}
}
@ -376,11 +374,9 @@ namespace LLInitParam
static std::vector<std::string> sValues;
value_name_map_t* map = getValueNames();
for (typename value_name_map_t::iterator it = map->begin(), end_it = map->end();
it != end_it;
++it)
for (typename value_name_map_t::value_type& map_pair : *map)
{
sValues.push_back(it->first);
sValues.push_back(map_pair.first);
}
return &sValues;
}

4
indra/llcommon/llinstancetracker.h
View File

@ -99,7 +99,7 @@ public:
return mSelf;
}
static S32 instanceCount()
static size_t instanceCount()
{
return LockStatic()->mMap.size();
}
@ -363,7 +363,7 @@ public:
return mSelf;
}
static S32 instanceCount()
static size_t instanceCount()
{
return LockStatic()->mSet.size();
}

68
indra/llcommon/llkeybind.cpp
View File

@ -30,6 +30,7 @@
#include "llsd.h"
#include "llsdutil.h"
#include <algorithm>
LLKeyData::LLKeyData()
:
@ -180,10 +181,10 @@ LLKeyBind::LLKeyBind(const LLSD &key_bind)
bool LLKeyBind::operator==(const LLKeyBind& rhs)
{
U32 size = mData.size();
auto size = mData.size();
if (size != rhs.mData.size()) return false;
for (U32 i = 0; i < size; i++)
for (size_t i = 0; i < size; i++)
{
if (mData[i] != rhs.mData[i]) return false;
}
@ -193,7 +194,7 @@ bool LLKeyBind::operator==(const LLKeyBind& rhs)
bool LLKeyBind::operator!=(const LLKeyBind& rhs)
{
U32 size = mData.size();
auto size = mData.size();
if (size != rhs.mData.size()) return true;
for (U32 i = 0; i < size; i++)
@ -206,26 +207,29 @@ bool LLKeyBind::operator!=(const LLKeyBind& rhs)
bool LLKeyBind::isEmpty() const
{
for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
for (const LLKeyData& key_data : mData)
{
if (!iter->isEmpty()) return false;
if (!key_data.isEmpty()) return false;
}
return true;
}
LLKeyBind::data_vector_t::const_iterator LLKeyBind::endNonEmpty() const
{
// search backwards for last non-empty entry, then turn back into forwards
// iterator (.base() call)
return std::find_if_not(mData.rbegin(), mData.rend(),
[](const auto& kdata){ return kdata.empty(); }).base();
}
LLSD LLKeyBind::asLLSD() const
{
S32 last = mData.size() - 1;
while (mData[last].empty())
{
last--;
}
LLSD data;
for (S32 i = 0; i <= last; ++i)
for (const LLKeyData& key_data : mData)
{
// append even if empty to not affect visual representation
data.append(mData[i].asLLSD());
// append intermediate entries even if empty to not affect visual
// representation
data.append(key_data.asLLSD());
}
return data;
}
@ -238,9 +242,9 @@ bool LLKeyBind::canHandle(EMouseClickType mouse, KEY key, MASK mask) const
return false;
}
for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
for (const LLKeyData& key_data : mData)
{
if (iter->canHandle(mouse, key, mask))
if (key_data.canHandle(mouse, key, mask))
{
return true;
}
@ -262,12 +266,12 @@ bool LLKeyBind::hasKeyData(EMouseClickType mouse, KEY key, MASK mask, bool ignor
{
if (mouse != CLICK_NONE || key != KEY_NONE)
{
for (data_vector_t::const_iterator iter = mData.begin(); iter != mData.end(); iter++)
for (const LLKeyData& key_data : mData)
{
if (iter->mKey == key
&& iter->mMask == mask
&& iter->mMouse == mouse
&& iter->mIgnoreMasks == ignore)
if (key_data.mKey == key
&& key_data.mMask == mask
&& key_data.mMouse == mouse
&& key_data.mIgnoreMasks == ignore)
{
return true;
}
@ -349,16 +353,16 @@ void LLKeyBind::replaceKeyData(const LLKeyData& data, U32 index)
{
// if both click and key are none (isEmpty()), we are inserting a placeholder, we don't want to reset anything
// otherwise reset identical key
for (data_vector_t::iterator iter = mData.begin(); iter != mData.end(); iter++)
for (LLKeyData& key_data : mData)
{
if (iter->mKey == data.mKey
&& iter->mMouse == data.mMouse
&& iter->mIgnoreMasks == data.mIgnoreMasks
&& iter->mMask == data.mMask)
if (key_data.mKey == data.mKey
&& key_data.mMouse == data.mMouse
&& key_data.mIgnoreMasks == data.mIgnoreMasks
&& key_data.mMask == data.mMask)
{
// Replacing only fully equal combinations even in case 'ignore' is set
// Reason: Simplicity and user might decide to do a 'move' command as W and Shift+Ctrl+W, and 'run' as Shift+W
iter->reset();
key_data.reset();
break;
}
}
@ -380,16 +384,10 @@ void LLKeyBind::resetKeyData(S32 index)
void LLKeyBind::trimEmpty()
{
S32 last = mData.size() - 1;
while (last >= 0 && mData[last].empty())
{
mData.erase(mData.begin() + last);
last--;
}
mData.erase(endNonEmpty(), mData.end());
}
U32 LLKeyBind::getDataCount()
size_t LLKeyBind::getDataCount()
{
return mData.size();
}

4
indra/llcommon/llkeybind.h
View File

@ -95,11 +95,13 @@ public:
void clear() { mData.clear(); }
// if there any empty LLKeyData in the end of the array, remove them
void trimEmpty();
U32 getDataCount();
size_t getDataCount();
private:
typedef std::vector<LLKeyData> data_vector_t;
data_vector_t mData;
data_vector_t::const_iterator endNonEmpty() const;
};

6
indra/llcommon/llleap.cpp
View File

@ -231,7 +231,8 @@ public:
}
|*==========================================================================*/
LL_DEBUGS("EventHost") << "Sending: " << buffer.tellp() << ':';
LL_DEBUGS("EventHost") << "Sending: "
<< static_cast<U64>(buffer.tellp()) << ':';
std::string::size_type truncate(80);
if (buffer.tellp() <= truncate)
{
@ -244,7 +245,8 @@ public:
LL_CONT << LL_ENDL;
LLProcess::WritePipe& childin(mChild->getWritePipe(LLProcess::STDIN));
childin.get_ostream() << buffer.tellp() << ':' << buffer.str() << std::flush;
childin.get_ostream() << static_cast<U64>(buffer.tellp())
<< ':' << buffer.str() << std::flush;
return false;
}

34
indra/llcommon/llmd5.cpp
View File

@ -96,10 +96,10 @@ LLMD5::LLMD5()
// operation, processing another message block, and updating the
// context.
void LLMD5::update (const uint1 *input, const uint4 input_length) {
void LLMD5::update (const uint1 *input, const size_t input_length) {
uint4 input_index, buffer_index;
uint4 buffer_space; // how much space is left in buffer
size_t input_index, buffer_index;
size_t buffer_space; // how much space is left in buffer
if (finalized){ // so we can't update!
std::cerr << "LLMD5::update: Can't update a finalized digest!" << std::endl;
@ -107,14 +107,10 @@ void LLMD5::update (const uint1 *input, const uint4 input_length) {
}
// Compute number of bytes mod 64
buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
buffer_index = size_t((count >> 3) & 0x3F);
// Update number of bits
if ( (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
count[1]++;
count[1] += ((uint4)input_length >> 29);
count += input_length << 3;
buffer_space = 64 - buffer_index; // how much space is left in buffer
@ -192,7 +188,7 @@ void LLMD5::update(const std::string& s)
void LLMD5::finalize (){
unsigned char bits[8]; /* Flawfinder: ignore */
unsigned int index, padLen;
size_t index, padLen;
static uint1 PADDING[64]={
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -204,11 +200,12 @@ void LLMD5::finalize (){
return;
}
// Save number of bits
encode (bits, count, 8);
// Save number of bits.
// Treat count, a uint64_t, as uint4[2].
encode (bits, reinterpret_cast<uint4*>(&count), 8);
// Pad out to 56 mod 64.
index = (uint4) ((count[0] >> 3) & 0x3f);
index = size_t((count >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
update (PADDING, padLen);
@ -340,8 +337,7 @@ void LLMD5::init(){
finalized=0; // we just started!
// Nothing counted, so count=0
count[0] = 0;
count[1] = 0;
count = 0;
// Load magic initialization constants.
state[0] = 0x67452301;
@ -508,9 +504,9 @@ void LLMD5::transform (const U8 block[64]){
// Encodes input (UINT4) into output (unsigned char). Assumes len is
// a multiple of 4.
void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
void LLMD5::encode (uint1 *output, const uint4 *input, const size_t len) {
unsigned int i, j;
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (uint1) (input[i] & 0xff);
@ -525,9 +521,9 @@ void LLMD5::encode (uint1 *output, const uint4 *input, const uint4 len) {
// Decodes input (unsigned char) into output (UINT4). Assumes len is
// a multiple of 4.
void LLMD5::decode (uint4 *output, const uint1 *input, const uint4 len){
void LLMD5::decode (uint4 *output, const uint1 *input, const size_t len){
unsigned int i, j;
size_t i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |

8
indra/llcommon/llmd5.h
View File

@ -86,7 +86,7 @@ class LL_COMMON_API LLMD5 {
public:
// methods for controlled operation:
LLMD5 (); // simple initializer
void update (const uint1 *input, const uint4 input_length);
void update (const uint1 *input, const size_t input_length);
void update (std::istream& stream);
void update (FILE *file);
void update (const std::string& str);
@ -110,7 +110,7 @@ private:
// next, the private data:
uint4 state[4];
uint4 count[2]; // number of *bits*, mod 2^64
uint64_t count; // number of *bits*, mod 2^64
uint1 buffer[64]; // input buffer
uint1 digest[16];
uint1 finalized;
@ -120,8 +120,8 @@ private:
void transform (const uint1 *buffer); // does the real update work. Note
// that length is implied to be 64.
static void encode (uint1 *dest, const uint4 *src, const uint4 length);
static void decode (uint4 *dest, const uint1 *src, const uint4 length);
static void encode (uint1 *dest, const uint4 *src, const size_t length);
static void decode (uint4 *dest, const uint1 *src, const size_t length);
};

13
indra/llcommon/llmetricperformancetester.cpp
View File

@ -42,9 +42,9 @@ LLMetricPerformanceTesterBasic::name_tester_map_t LLMetricPerformanceTesterBasic
/*static*/
void LLMetricPerformanceTesterBasic::cleanupClass()
{
for (name_tester_map_t::iterator iter = sTesterMap.begin() ; iter != sTesterMap.end() ; ++iter)
for (name_tester_map_t::value_type& pair : sTesterMap)
{
delete iter->second ;
delete pair.second;
}
sTesterMap.clear() ;
}
@ -111,8 +111,8 @@ LLSD LLMetricPerformanceTesterBasic::analyzeMetricPerformanceLog(std::istream& i
{
ret[label]["Name"] = iter->second["Name"] ;
S32 num_of_metrics = tester->getNumberOfMetrics() ;
for(S32 index = 0 ; index < num_of_metrics ; index++)
auto num_of_metrics = tester->getNumberOfMetrics() ;
for(size_t index = 0 ; index < num_of_metrics ; index++)
{
ret[label][ tester->getMetricName(index) ] = iter->second[ tester->getMetricName(index) ] ;
}
@ -154,10 +154,9 @@ void LLMetricPerformanceTesterBasic::doAnalysisMetrics(std::string baseline, std
llofstream os(output.c_str());
os << "Label, Metric, Base(B), Target(T), Diff(T-B), Percentage(100*T/B)\n";
for(LLMetricPerformanceTesterBasic::name_tester_map_t::iterator iter = LLMetricPerformanceTesterBasic::sTesterMap.begin() ;
iter != LLMetricPerformanceTesterBasic::sTesterMap.end() ; ++iter)
for (LLMetricPerformanceTesterBasic::name_tester_map_t::value_type& pair : LLMetricPerformanceTesterBasic::sTesterMap)
{
LLMetricPerformanceTesterBasic* tester = ((LLMetricPerformanceTesterBasic*)iter->second) ;
LLMetricPerformanceTesterBasic* tester = ((LLMetricPerformanceTesterBasic*)pair.second);
tester->analyzePerformance(&os, &base, &current) ;
}

4
indra/llcommon/llmetricperformancetester.h
View File

@ -67,12 +67,12 @@ public:
/**
* @return Returns the number of the test metrics in this tester instance.
*/
S32 getNumberOfMetrics() const { return mMetricStrings.size() ;}
auto getNumberOfMetrics() const { return mMetricStrings.size() ;}
/**
* @return Returns the metric name at index
* @param[in] index - Index on the list of metrics managed by this tester instance.
*/
std::string getMetricName(S32 index) const { return mMetricStrings[index] ;}
std::string getMetricName(size_t index) const { return mMetricStrings[index] ;}
protected:
/**

4
indra/llcommon/llmortician.cpp
View File

@ -37,9 +37,9 @@ LLMortician::~LLMortician()
sGraveyard.remove(this);
}
U32 LLMortician::logClass(std::stringstream &str)
size_t LLMortician::logClass(std::stringstream &str)
{
U32 size = sGraveyard.size();
auto size = sGraveyard.size();
str << "Mortician graveyard count: " << size;
str << " Zealous: " << (sDestroyImmediate ? "True" : "False");
if (size == 0)

4
indra/llcommon/llmortician.h
View File

@ -34,8 +34,8 @@ class LL_COMMON_API LLMortician
{
public:
LLMortician() { mIsDead = FALSE; }
static U32 graveyardCount() { return sGraveyard.size(); };
static U32 logClass(std::stringstream &str);
static auto graveyardCount() { return sGraveyard.size(); };
static size_t logClass(std::stringstream &str);
static void updateClass();
virtual ~LLMortician();
void die();

8
indra/llcommon/llnametable.h
View File

@ -86,12 +86,10 @@ public:
// O(N)! (currently only used in one place... (newsim/llstate.cpp))
const char *resolveData(const DATA &data) const
{
const_iter_t iter = mNameMap.begin();
const_iter_t end = mNameMap.end();
for (; iter != end; ++iter)
for (const name_map_t::value_type& pair : mNameMap)
{
if (iter->second == data)
return iter->first;
if (pair.second == data)
return pair.first;
}
return NULL;
}

4
indra/llcommon/llpriqueuemap.h
View File

@ -115,9 +115,9 @@ public:
LL_WARNS() << "Data not on priority queue!" << LL_ENDL;
// OK, try iterating through all of the data and seeing if we just screwed up the priority
// somehow.
for (iter = mMap.begin(); iter != mMap.end(); iter++)
for (pqm_pair pair : mMap)
{
if ((*(iter)).second == data)
if (pair.second == data)
{
LL_ERRS() << "Data on priority queue but priority not matched!" << LL_ENDL;
}

17
indra/llcommon/llqueuedthread.cpp
View File

@ -110,7 +110,7 @@ void LLQueuedThread::shutdown()
// MAIN THREAD
// virtual
S32 LLQueuedThread::update(F32 max_time_ms)
size_t LLQueuedThread::update(F32 max_time_ms)
{
if (!mStarted)
{
@ -123,11 +123,11 @@ S32 LLQueuedThread::update(F32 max_time_ms)
return updateQueue(max_time_ms);
}
S32 LLQueuedThread::updateQueue(F32 max_time_ms)
size_t LLQueuedThread::updateQueue(F32 max_time_ms)
{
F64 max_time = (F64)max_time_ms * .001;
LLTimer timer;
S32 pending = 1;
size_t pending = 1;
// Frame Update
if (mThreaded)
@ -164,9 +164,9 @@ void LLQueuedThread::incQueue()
//virtual
// May be called from any thread
S32 LLQueuedThread::getPending()
size_t LLQueuedThread::getPending()
{
S32 res;
size_t res;
lockData();
res = mRequestQueue.size();
unlockData();
@ -399,7 +399,7 @@ bool LLQueuedThread::check()
//============================================================================
// Runs on its OWN thread
S32 LLQueuedThread::processNextRequest()
size_t LLQueuedThread::processNextRequest()
{
QueuedRequest *req;
// Get next request from pool
@ -473,8 +473,7 @@ S32 LLQueuedThread::processNextRequest()
LLTrace::get_thread_recorder()->pushToParent();
}
S32 pending = getPending();
return pending;
return getPending();
}
// virtual
@ -511,7 +510,7 @@ void LLQueuedThread::run()
threadedUpdate();
int pending_work = processNextRequest();
auto pending_work = processNextRequest();
if (pending_work == 0)
{

10
indra/llcommon/llqueuedthread.h
View File

@ -167,19 +167,19 @@ private:
protected:
handle_t generateHandle();
bool addRequest(QueuedRequest* req);
S32 processNextRequest(void);
size_t processNextRequest(void);
void incQueue();
public:
bool waitForResult(handle_t handle, bool auto_complete = true);
virtual S32 update(F32 max_time_ms);
S32 updateQueue(F32 max_time_ms);
virtual size_t update(F32 max_time_ms);
size_t updateQueue(F32 max_time_ms);
void waitOnPending();
void printQueueStats();
virtual S32 getPending();
virtual size_t getPending();
bool getThreaded() { return mThreaded ? true : false; }
// Request accessors

24
indra/llcommon/llregistry.h
View File

@ -141,11 +141,9 @@ public:
ptr_value_t getValue(ref_const_key_t key)
{
for(scope_list_iterator_t it = mActiveScopes.begin();
it != mActiveScopes.end();
++it)
for(Registrar* scope : mActiveScopes)
{
ptr_value_t valuep = (*it)->getValue(key);
ptr_value_t valuep = scope->getValue(key);
if (valuep != NULL) return valuep;
}
return mDefaultRegistrar.getValue(key);
@ -153,11 +151,9 @@ public:
ptr_const_value_t getValue(ref_const_key_t key) const
{
for(scope_list_const_iterator_t it = mActiveScopes.begin();
it != mActiveScopes.end();
++it)
for(const Registrar* scope : mActiveScopes)
{
ptr_value_t valuep = (*it)->getValue(key);
ptr_const_value_t valuep = scope->getValue(key);
if (valuep != NULL) return valuep;
}
return mDefaultRegistrar.getValue(key);
@ -165,11 +161,9 @@ public:
bool exists(ref_const_key_t key) const
{
for(scope_list_const_iterator_t it = mActiveScopes.begin();
it != mActiveScopes.end();
++it)
for(const Registrar* scope : mActiveScopes)
{
if ((*it)->exists(key)) return true;
if (scope->exists(key)) return true;
}
return mDefaultRegistrar.exists(key);
@ -177,11 +171,9 @@ public:
bool empty() const
{
for(scope_list_const_iterator_t it = mActiveScopes.begin();
it != mActiveScopes.end();
++it)
for(const Registrar* scope : mActiveScopes)
{
if (!(*it)->empty()) return false;
if (!scope->empty()) return false;
}
return mDefaultRegistrar.empty();

2
indra/llcommon/llrun.cpp
View File

@ -47,7 +47,7 @@ LLRunner::~LLRunner()
mRunEvery.clear();
}
S32 LLRunner::run()
size_t LLRunner::run()
{
// We collect all of the runnables which should be run. Since the
// runnables are allowed to adjust the run list, we need to copy

2
indra/llcommon/llrun.h
View File

@ -85,7 +85,7 @@ public:
*
* @return Returns the number of runnables run.
*/
S32 run();
size_t run();
/**
* @brief Add a runnable to the run list.

120
indra/llcommon/llsd.cpp
View File

@ -36,6 +36,18 @@
#include "llsdserialize.h"
#include "stringize.h"
#include <limits>
// Defend against a caller forcibly passing a negative number into an unsigned
// size_t index param
inline
bool was_negative(size_t i)
{
return (i > std::numeric_limits<int>::max());
}
#define NEGATIVE_EXIT(i) if (was_negative(i)) return
#define NEGATIVE_RETURN(i, result) NEGATIVE_EXIT(i) (result)
#ifndef LL_RELEASE_FOR_DOWNLOAD
#define NAME_UNNAMED_NAMESPACE
#endif
@ -136,10 +148,10 @@ public:
virtual void erase(const String&) { }
virtual const LLSD& ref(const String&) const{ return undef(); }
virtual int size() const { return 0; }
virtual LLSD get(Integer) const { return LLSD(); }
virtual void erase(Integer) { }
virtual const LLSD& ref(Integer) const { return undef(); }
virtual size_t size() const { return 0; }
virtual LLSD get(size_t) const { return LLSD(); }
virtual void erase(size_t) { }
virtual const LLSD& ref(size_t) const { return undef(); }
virtual LLSD::map_const_iterator beginMap() const { return endMap(); }
virtual LLSD::map_const_iterator endMap() const { static const std::map<String, LLSD> empty; return empty.end(); }
@ -272,7 +284,7 @@ namespace
virtual LLSD::UUID asUUID() const { return LLUUID(mValue); }
virtual LLSD::Date asDate() const { return LLDate(mValue); }
virtual LLSD::URI asURI() const { return LLURI(mValue); }
virtual int size() const { return mValue.size(); }
virtual size_t size() const { return mValue.size(); }
virtual const LLSD::String& asStringRef() const { return mValue; }
};
@ -377,9 +389,9 @@ namespace
virtual bool has(const LLSD::String&) const;
using LLSD::Impl::get; // Unhiding get(LLSD::Integer)
using LLSD::Impl::erase; // Unhiding erase(LLSD::Integer)
using LLSD::Impl::ref; // Unhiding ref(LLSD::Integer)
using LLSD::Impl::get; // Unhiding get(size_t)
using LLSD::Impl::erase; // Unhiding erase(size_t)
using LLSD::Impl::ref; // Unhiding ref(size_t)
virtual LLSD get(const LLSD::String&) const;
virtual LLSD getKeys() const;
void insert(const LLSD::String& k, const LLSD& v);
@ -387,7 +399,7 @@ namespace
LLSD& ref(const LLSD::String&);
virtual const LLSD& ref(const LLSD::String&) const;
virtual int size() const { return mData.size(); }
virtual size_t size() const { return mData.size(); }
LLSD::map_iterator beginMap() { return mData.begin(); }
LLSD::map_iterator endMap() { return mData.end(); }
@ -518,14 +530,14 @@ namespace
using LLSD::Impl::get; // Unhiding get(LLSD::String)
using LLSD::Impl::erase; // Unhiding erase(LLSD::String)
using LLSD::Impl::ref; // Unhiding ref(LLSD::String)
virtual int size() const;
virtual LLSD get(LLSD::Integer) const;
void set(LLSD::Integer, const LLSD&);
void insert(LLSD::Integer, const LLSD&);
virtual size_t size() const;
virtual LLSD get(size_t) const;
void set(size_t, const LLSD&);
void insert(size_t, const LLSD&);
LLSD& append(const LLSD&);
virtual void erase(LLSD::Integer);
LLSD& ref(LLSD::Integer);
virtual const LLSD& ref(LLSD::Integer) const;
virtual void erase(size_t);
LLSD& ref(size_t);
virtual const LLSD& ref(size_t) const;
LLSD::array_iterator beginArray() { return mData.begin(); }
LLSD::array_iterator endArray() { return mData.end(); }
@ -550,85 +562,82 @@ namespace
return *this;
}
}
int ImplArray::size() const { return mData.size(); }
LLSD ImplArray::get(LLSD::Integer i) const
size_t ImplArray::size() const { return mData.size(); }
LLSD ImplArray::get(size_t i) const
{
if (i < 0) { return LLSD(); }
NEGATIVE_RETURN(i, LLSD());
DataVector::size_type index = i;
return (index < mData.size()) ? mData[index] : LLSD();
}
void ImplArray::set(LLSD::Integer i, const LLSD& v)
void ImplArray::set(size_t i, const LLSD& v)
{
if (i < 0) { return; }
NEGATIVE_EXIT(i);
DataVector::size_type index = i;
if (index >= mData.size())
{
mData.resize(index + 1);
}
mData[index] = v;
}
void ImplArray::insert(LLSD::Integer i, const LLSD& v)
void ImplArray::insert(size_t i, const LLSD& v)
{
if (i < 0)
{
return;
}
NEGATIVE_EXIT(i);
DataVector::size_type index = i;
if (index >= mData.size()) // tbd - sanity check limit for index ?
{
mData.resize(index + 1);
}
mData.insert(mData.begin() + index, v);
}
LLSD& ImplArray::append(const LLSD& v)
{
mData.push_back(v);
return mData.back();
}
void ImplArray::erase(LLSD::Integer i)
void ImplArray::erase(size_t i)
{
if (i < 0) { return; }
NEGATIVE_EXIT(i);
DataVector::size_type index = i;
if (index < mData.size())
{
mData.erase(mData.begin() + index);
}
}
LLSD& ImplArray::ref(LLSD::Integer i)
LLSD& ImplArray::ref(size_t i)
{
DataVector::size_type index = i >= 0 ? i : 0;
DataVector::size_type index = was_negative(i)? 0 : i;
if (index >= mData.size())
{
mData.resize(i + 1);
mData.resize(index + 1);
}
return mData[index];
}
const LLSD& ImplArray::ref(LLSD::Integer i) const
const LLSD& ImplArray::ref(size_t i) const
{
if (i < 0) { return undef(); }
NEGATIVE_RETURN(i, undef());
DataVector::size_type index = i;
if (index >= mData.size())
{
return undef();
}
return mData[index];
}
@ -841,9 +850,6 @@ LLSD::LLSD(const Date& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const URI& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
LLSD::LLSD(const Binary& v) : impl(0) { ALLOC_LLSD_OBJECT; assign(v); }
// Convenience Constructors
LLSD::LLSD(F32 v) : impl(0) { ALLOC_LLSD_OBJECT; assign((Real)v); }
// Scalar Assignment
void LLSD::assign(Boolean v) { safe(impl).assign(impl, v); }
void LLSD::assign(Integer v) { safe(impl).assign(impl, v); }
@ -912,7 +918,7 @@ LLSD LLSD::emptyArray()
return v;
}
int LLSD::size() const { return safe(impl).size(); }
size_t LLSD::size() const { return safe(impl).size(); }
LLSD LLSD::get(Integer i) const { return safe(impl).get(i); }
void LLSD::set(Integer i, const LLSD& v){ makeArray(impl).set(i, v); }
@ -926,12 +932,12 @@ LLSD& LLSD::with(Integer i, const LLSD& v)
LLSD& LLSD::append(const LLSD& v) { return makeArray(impl).append(v); }
void LLSD::erase(Integer i) { makeArray(impl).erase(i); }
LLSD& LLSD::operator[](Integer i)
LLSD& LLSD::operator[](size_t i)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
return makeArray(impl).ref(i);
}
const LLSD& LLSD::operator[](Integer i) const
const LLSD& LLSD::operator[](size_t i) const
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_LLSD;
return safe(impl).ref(i);
@ -956,7 +962,7 @@ static const char *llsd_dump(const LLSD &llsd, bool useXMLFormat)
out << LLSDNotationStreamer(llsd);
out_string = out.str();
}
int len = out_string.length();
auto len = out_string.length();
sStorage = new char[len + 1];
memcpy(sStorage, out_string.c_str(), len);
sStorage[len] = '\0';

32
indra/llcommon/llsd.h
View File

@ -192,7 +192,17 @@ public:
/** @name Convenience Constructors */
//@{
LLSD(F32); // F32 -> Real
// support construction from size_t et al.
template <typename VALUE,
typename std::enable_if<std::is_integral<VALUE>::value &&
! std::is_same<VALUE, Boolean>::value,
bool>::type = true>
LLSD(VALUE v): LLSD(Integer(narrow(v))) {}
// support construction from F32 et al.
template <typename VALUE,
typename std::enable_if<std::is_floating_point<VALUE>::value,
bool>::type = true>
LLSD(VALUE v): LLSD(Real(narrow(v))) {}
//@}
/** @name Scalar Assignment */
@ -275,7 +285,7 @@ public:
//@{
LLSD(const char*);
void assign(const char*);
LLSD& operator=(const char* v) { assign(v); return *this; }
LLSD& operator=(const char* v) { assign(v); return *this; }
//@}
/** @name Map Values */
@ -313,14 +323,24 @@ public:
LLSD& append(const LLSD&);
void erase(Integer);
LLSD& with(Integer, const LLSD&);
const LLSD& operator[](Integer) const;
LLSD& operator[](Integer);
// accept size_t so we can index relative to size()
const LLSD& operator[](size_t) const;
LLSD& operator[](size_t);
// template overloads to support int literals, U32 et al.
template <typename IDX,
typename std::enable_if<std::is_convertible<IDX, size_t>::value,
bool>::type = true>
const LLSD& operator[](IDX i) const { return (*this)[size_t(i)]; }
template <typename IDX,
typename std::enable_if<std::is_convertible<IDX, size_t>::value,
bool>::type = true>
LLSD& operator[](IDX i) { return (*this)[size_t(i)]; }
//@}
/** @name Iterators */
//@{
int size() const;
size_t size() const;
typedef std::map<String, LLSD>::iterator map_iterator;
typedef std::map<String, LLSD>::const_iterator map_const_iterator;

6
indra/llcommon/llsdparam.cpp
View File

@ -113,11 +113,9 @@ void LLParamSDParser::writeSDImpl(LLSD& sd, const LLInitParam::BaseBlock& block,
/*virtual*/ std::string LLParamSDParser::getCurrentElementName()
{
std::string full_name = "sd";
for (name_stack_t::iterator it = mNameStack.begin();
it != mNameStack.end();
++it)
for (name_stack_t::value_type& stack_pair : mNameStack)
{
full_name += llformat("[%s]", it->first.c_str());
full_name += llformat("[%s]", stack_pair.first.c_str());
}
return full_name;

84
indra/llcommon/llsdserialize.cpp
View File

@ -53,7 +53,7 @@
#include "lluri.h"
// File constants
static const int MAX_HDR_LEN = 20;
static const size_t MAX_HDR_LEN = 20;
static const S32 UNZIP_LLSD_MAX_DEPTH = 96;
static const char LEGACY_NON_HEADER[] = "<llsd>";
const std::string LLSD_BINARY_HEADER("LLSD/Binary");
@ -102,7 +102,7 @@ void LLSDSerialize::serialize(const LLSD& sd, std::ostream& str, ELLSD_Serialize
}
// static
bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, S32 max_bytes)
bool LLSDSerialize::deserialize(LLSD& sd, std::istream& str, llssize max_bytes)
{
LLPointer<LLSDParser> p = NULL;
char hdr_buf[MAX_HDR_LEN + 1] = ""; /* Flawfinder: ignore */
@ -255,7 +255,7 @@ F64 ll_ntohd(F64 netdouble)
* @return Returns number of bytes read off of the stream. Returns
* PARSE_FAILURE (-1) on failure.
*/
int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes);
/**
* @brief Parse a delimited string.
@ -266,7 +266,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes);
* @return Returns number of bytes read off of the stream. Returns
* PARSE_FAILURE (-1) on failure.
*/
int deserialize_string_delim(std::istream& istr, std::string& value, char d);
llssize deserialize_string_delim(std::istream& istr, std::string& value, char d);
/**
* @brief Read a raw string off the stream.
@ -280,10 +280,10 @@ int deserialize_string_delim(std::istream& istr, std::string& value, char d);
* @return Returns number of bytes read off of the stream. Returns
* PARSE_FAILURE (-1) on failure.
*/
int deserialize_string_raw(
llssize deserialize_string_raw(
std::istream& istr,
std::string& value,
S32 max_bytes);
llssize max_bytes);
/**
* @brief helper method for dealing with the different notation boolean format.
@ -295,7 +295,7 @@ int deserialize_string_raw(
* @return Returns number of bytes read off of the stream. Returns
* PARSE_FAILURE (-1) on failure.
*/
int deserialize_boolean(
llssize deserialize_boolean(
std::istream& istr,
LLSD& data,
const std::string& compare,
@ -332,7 +332,7 @@ LLSDParser::LLSDParser()
LLSDParser::~LLSDParser()
{ }
S32 LLSDParser::parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth)
S32 LLSDParser::parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth)
{
mCheckLimits = (LLSDSerialize::SIZE_UNLIMITED == max_bytes) ? false : true;
mMaxBytesLeft = max_bytes;
@ -362,7 +362,7 @@ std::istream& LLSDParser::get(
char delim) const
{
istr.get(s, n, delim);
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
return istr;
}
@ -372,7 +372,7 @@ std::istream& LLSDParser::get(
char delim) const
{
istr.get(sb, delim);
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
return istr;
}
@ -396,11 +396,11 @@ std::istream& LLSDParser::read(
std::streamsize n) const
{
istr.read(s, n);
if(mCheckLimits) mMaxBytesLeft -= (int)istr.gcount();
if(mCheckLimits) mMaxBytesLeft -= istr.gcount();
return istr;
}
void LLSDParser::account(S32 bytes) const
void LLSDParser::account(llssize bytes) const
{
if(mCheckLimits) mMaxBytesLeft -= bytes;
}
@ -505,7 +505,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
c = istr.peek();
if(isalpha(c))
{
int cnt = deserialize_boolean(
auto cnt = deserialize_boolean(
istr,
data,
NOTATION_FALSE_SERIAL,
@ -535,7 +535,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
c = istr.peek();
if(isalpha(c))
{
int cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
auto cnt = deserialize_boolean(istr,data,NOTATION_TRUE_SERIAL,true);
if(PARSE_FAILURE == cnt) parse_count = cnt;
else account(cnt);
}
@ -611,7 +611,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
c = get(istr); // pop the 'l'
c = get(istr); // pop the delimiter
std::string str;
int cnt = deserialize_string_delim(istr, str, c);
auto cnt = deserialize_string_delim(istr, str, c);
if(PARSE_FAILURE == cnt)
{
parse_count = PARSE_FAILURE;
@ -634,7 +634,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
c = get(istr); // pop the 'd'
c = get(istr); // pop the delimiter
std::string str;
int cnt = deserialize_string_delim(istr, str, c);
auto cnt = deserialize_string_delim(istr, str, c);
if(PARSE_FAILURE == cnt)
{
parse_count = PARSE_FAILURE;
@ -666,7 +666,7 @@ S32 LLSDNotationParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) c
default:
parse_count = PARSE_FAILURE;
LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
<< ")" << LL_ENDL;
break;
}
@ -697,7 +697,7 @@ S32 LLSDNotationParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) c
{
putback(istr, c);
found_name = true;
int count = deserialize_string(istr, name, mMaxBytesLeft);
auto count = deserialize_string(istr, name, mMaxBytesLeft);
if(PARSE_FAILURE == count) return PARSE_FAILURE;
account(count);
}
@ -779,7 +779,7 @@ S32 LLSDNotationParser::parseArray(std::istream& istr, LLSD& array, S32 max_dept
bool LLSDNotationParser::parseString(std::istream& istr, LLSD& data) const
{
std::string value;
int count = deserialize_string(istr, value, mMaxBytesLeft);
auto count = deserialize_string(istr, value, mMaxBytesLeft);
if(PARSE_FAILURE == count) return false;
account(count);
data = value;
@ -806,13 +806,13 @@ bool LLSDNotationParser::parseBinary(std::istream& istr, LLSD& data) const
{
// We probably have a valid raw binary stream. determine
// the size, and read it.
S32 len = strtol(buf + 2, NULL, 0);
auto len = strtol(buf + 2, NULL, 0);
if(mCheckLimits && (len > mMaxBytesLeft)) return false;
std::vector<U8> value;
if(len)
{
value.resize(len);
account((int)fullread(istr, (char *)&value[0], len));
account(fullread(istr, (char *)&value[0], len));
}
c = get(istr); // strip off the trailing double-quote
data = value;
@ -1009,7 +1009,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
case '"':
{
std::string value;
int cnt = deserialize_string_delim(istr, value, c);
auto cnt = deserialize_string_delim(istr, value, c);
if(PARSE_FAILURE == cnt)
{
parse_count = PARSE_FAILURE;
@ -1096,7 +1096,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
if(size > 0)
{
value.resize(size);
account((int)fullread(istr, (char*)&value[0], size));
account(fullread(istr, (char*)&value[0], size));
}
data = value;
}
@ -1110,7 +1110,7 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data, S32 max_depth) con
default:
parse_count = PARSE_FAILURE;
LL_INFOS() << "Unrecognized character while parsing: int(" << (int)c
LL_INFOS() << "Unrecognized character while parsing: int(" << int(c)
<< ")" << LL_ENDL;
break;
}
@ -1144,7 +1144,7 @@ S32 LLSDBinaryParser::parseMap(std::istream& istr, LLSD& map, S32 max_depth) con
case '\'':
case '"':
{
int cnt = deserialize_string_delim(istr, name, c);
auto cnt = deserialize_string_delim(istr, name, c);
if(PARSE_FAILURE == cnt) return PARSE_FAILURE;
account(cnt);
break;
@ -1228,7 +1228,7 @@ bool LLSDBinaryParser::parseString(
if(size)
{
buf.resize(size);
account((int)fullread(istr, &buf[0], size));
account(fullread(istr, &buf[0], size));
value.assign(buf.begin(), buf.end());
}
return true;
@ -1432,7 +1432,7 @@ S32 LLSDNotationFormatter::format_impl(const LLSD& data, std::ostream& ostr,
ostr << std::uppercase;
auto oldfill(ostr.fill('0'));
auto oldwidth(ostr.width());
for (int i = 0; i < buffer.size(); i++)
for (size_t i = 0; i < buffer.size(); i++)
{
// have to restate setw() before every conversion
ostr << std::setw(2) << (int) buffer[i];
@ -1595,7 +1595,7 @@ void LLSDBinaryFormatter::formatString(
/**
* local functions
*/
int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
llssize deserialize_string(std::istream& istr, std::string& value, llssize max_bytes)
{
int c = istr.get();
if(istr.fail())
@ -1605,7 +1605,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
return LLSDParser::PARSE_FAILURE;
}
int rv = LLSDParser::PARSE_FAILURE;
llssize rv = LLSDParser::PARSE_FAILURE;
switch(c)
{
case '\'':
@ -1625,7 +1625,7 @@ int deserialize_string(std::istream& istr, std::string& value, S32 max_bytes)
return rv + 1; // account for the character grabbed at the top.
}
int deserialize_string_delim(
llssize deserialize_string_delim(
std::istream& istr,
std::string& value,
char delim)
@ -1635,7 +1635,7 @@ int deserialize_string_delim(
bool found_hex = false;
bool found_digit = false;
U8 byte = 0;
int count = 0;
llssize count = 0;
while (true)
{
@ -1650,7 +1650,7 @@ int deserialize_string_delim(
}
char next_char = (char)next_byte; // Now that we know it's not EOF
if(found_escape)
{
// next character(s) is a special sequence.
@ -1728,16 +1728,16 @@ int deserialize_string_delim(
return count;
}
int deserialize_string_raw(
llssize deserialize_string_raw(
std::istream& istr,
std::string& value,
S32 max_bytes)
llssize max_bytes)
{
int count = 0;
llssize count = 0;
const S32 BUF_LEN = 20;
char buf[BUF_LEN]; /* Flawfinder: ignore */
istr.get(buf, BUF_LEN - 1, ')');
count += (int)istr.gcount();
count += istr.gcount();
int c = istr.get();
c = istr.get();
count += 2;
@ -1746,13 +1746,13 @@ int deserialize_string_raw(
// We probably have a valid raw string. determine
// the size, and read it.
// *FIX: This is memory inefficient.
S32 len = strtol(buf + 1, NULL, 0);
auto len = strtol(buf + 1, NULL, 0);
if((max_bytes>0)&&(len>max_bytes)) return LLSDParser::PARSE_FAILURE;
std::vector<char> buf;
if(len)
{
buf.resize(len);
count += (int)fullread(istr, (char *)&buf[0], len);
count += fullread(istr, (char *)&buf[0], len);
value.assign(buf.begin(), buf.end());
}
c = istr.get();
@ -2041,7 +2041,7 @@ void serialize_string(const std::string& value, std::ostream& str)
}
}
int deserialize_boolean(
llssize deserialize_boolean(
std::istream& istr,
LLSD& data,
const std::string& compare,
@ -2058,7 +2058,7 @@ int deserialize_boolean(
// * set data to LLSD::null
// * return LLSDParser::PARSE_FAILURE (-1)
//
int bytes_read = 0;
llssize bytes_read = 0;
std::string::size_type ii = 0;
char c = istr.peek();
while((++ii < compare.size())
@ -2113,7 +2113,7 @@ std::string zip_llsd(LLSD& data)
U8 out[CHUNK];
strm.avail_in = source.size();
strm.avail_in = narrow(source.size());
strm.next_in = (U8*) source.data();
U8* output = NULL;
@ -2287,7 +2287,7 @@ LLUZipHelper::EZipRresult LLUZipHelper::unzip_llsd(LLSD& data, const U8* in, S32
//This unzip function will only work with a gzip header and trailer - while the contents
//of the actual compressed data is the same for either format (gzip vs zlib ), the headers
//and trailers are different for the formats.
U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize, std::istream& is, S32 size )
U8* unzip_llsdNavMesh( bool& valid, size_t& outsize, std::istream& is, S32 size )
{
if (size == 0)
{

20
indra/llcommon/llsdserialize.h
View File

@ -77,7 +77,7 @@ public:
* @return Returns the number of LLSD objects parsed into
* data. Returns PARSE_FAILURE (-1) on parse failure.
*/
S32 parse(std::istream& istr, LLSD& data, S32 max_bytes, S32 max_depth = -1);
S32 parse(std::istream& istr, LLSD& data, llssize max_bytes, S32 max_depth = -1);
/** Like parse(), but uses a different call (istream.getline()) to read by lines
* This API is better suited for XML, where the parse cannot tell
@ -194,7 +194,7 @@ protected:
* Conceptually const since it only modifies mutable members.
* @param bytes The number of bytes read.
*/
void account(S32 bytes) const;
void account(llssize bytes) const;
protected:
/**
@ -205,7 +205,7 @@ protected:
/**
* @brief The maximum number of bytes left to be parsed.
*/
mutable S32 mMaxBytesLeft;
mutable llssize mMaxBytesLeft;
/**
* @brief Use line-based reading to get text
@ -336,7 +336,7 @@ private:
class Impl;
Impl& impl;
void parsePart(const char* buf, int len);
void parsePart(const char* buf, llssize len);
friend class LLSDSerialize;
};
@ -756,7 +756,7 @@ public:
* @param max_bytes the maximum number of bytes to parse
* @return Returns true if the stream appears to contain valid data
*/
static bool deserialize(LLSD& sd, std::istream& str, S32 max_bytes);
static bool deserialize(LLSD& sd, std::istream& str, llssize max_bytes);
/*
* Notation Methods
@ -778,12 +778,12 @@ public:
LLSDFormatter::EFormatterOptions(LLSDFormatter::OPTIONS_PRETTY |
LLSDFormatter::OPTIONS_PRETTY_BINARY));
}
static S32 fromNotation(LLSD& sd, std::istream& str, S32 max_bytes)
static S32 fromNotation(LLSD& sd, std::istream& str, llssize max_bytes)
{
LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
return p->parse(str, sd, max_bytes);
}
static LLSD fromNotation(std::istream& str, S32 max_bytes)
static LLSD fromNotation(std::istream& str, llssize max_bytes)
{
LLPointer<LLSDNotationParser> p = new LLSDNotationParser;
LLSD sd;
@ -834,12 +834,12 @@ public:
LLPointer<LLSDBinaryFormatter> f = new LLSDBinaryFormatter;
return f->format(sd, str, LLSDFormatter::OPTIONS_NONE);
}
static S32 fromBinary(LLSD& sd, std::istream& str, S32 max_bytes, S32 max_depth = -1)
static S32 fromBinary(LLSD& sd, std::istream& str, llssize max_bytes, S32 max_depth = -1)
{
LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
return p->parse(str, sd, max_bytes, max_depth);
}
static LLSD fromBinary(std::istream& str, S32 max_bytes, S32 max_depth = -1)
static LLSD fromBinary(std::istream& str, llssize max_bytes, S32 max_depth = -1)
{
LLPointer<LLSDBinaryParser> p = new LLSDBinaryParser;
LLSD sd;
@ -870,7 +870,7 @@ public:
LL_COMMON_API std::string zip_llsd(LLSD& data);
LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, unsigned int& outsize,std::istream& is, S32 size);
LL_COMMON_API U8* unzip_llsdNavMesh( bool& valid, size_t& outsize,std::istream& is, S32 size);
// returns a pointer to the array or past the array if the deprecated header exists
LL_COMMON_API char* strip_deprecated_header(char* in, U32& cur_size, U32* header_size = nullptr);

10
indra/llcommon/llsdserialize_xml.cpp
View File

@ -196,12 +196,12 @@ S32 LLSDXMLFormatter::format_impl(const LLSD& data, std::ostream& ostr,
// *FIX: memory inefficient.
// *TODO: convert to use LLBase64
ostr << pre << "<binary encoding=\"base64\">";
int b64_buffer_length = apr_base64_encode_len(buffer.size());
int b64_buffer_length = apr_base64_encode_len(narrow(buffer.size()));
char* b64_buffer = new char[b64_buffer_length];
b64_buffer_length = apr_base64_encode_binary(
b64_buffer,
&buffer[0],
buffer.size());
narrow(buffer.size()));
ostr.write(b64_buffer, b64_buffer_length - 1);
delete[] b64_buffer;
ostr << "</binary>" << post;
@ -260,7 +260,7 @@ public:
S32 parse(std::istream& input, LLSD& data);
S32 parseLines(std::istream& input, LLSD& data);
void parsePart(const char *buf, int len);
void parsePart(const char *buf, llssize len);
void reset();
@ -542,7 +542,7 @@ LLSDXMLParser::Impl::findAttribute(const XML_Char* name, const XML_Char** pairs)
return NULL;
}
void LLSDXMLParser::Impl::parsePart(const char* buf, int len)
void LLSDXMLParser::Impl::parsePart(const char* buf, llssize len)
{
if ( buf != NULL
&& len > 0 )
@ -915,7 +915,7 @@ LLSDXMLParser::~LLSDXMLParser()
delete &impl;
}
void LLSDXMLParser::parsePart(const char *buf, int len)
void LLSDXMLParser::parsePart(const char *buf, llssize len)
{
impl.parsePart(buf, len);
}

5
indra/llcommon/llsdutil.cpp
View File

@ -148,10 +148,9 @@ LLSD ll_binary_from_string(const LLSD& sd)
std::vector<U8> binary_value;
std::string string_value = sd.asString();
for (std::string::iterator iter = string_value.begin();
iter != string_value.end(); ++iter)
for (const U8 c : string_value)
{
binary_value.push_back(*iter);
binary_value.push_back(c);
}
binary_value.push_back('\0');

40
indra/llcommon/llstreamtools.cpp
View File

@ -118,7 +118,7 @@ bool skip_to_next_word(std::istream& input_stream)
bool skip_to_end_of_next_keyword(const char* keyword, std::istream& input_stream)
{
int key_length = strlen(keyword); /*Flawfinder: ignore*/
auto key_length = strlen(keyword); /*Flawfinder: ignore*/
if (0 == key_length)
{
return false;
@ -315,7 +315,7 @@ bool unget_line(const std::string& line, std::istream& input_stream)
// returns true if removed last char
bool remove_last_char(char c, std::string& line)
{
int line_size = line.size();
auto line_size = line.size();
if (line_size > 1
&& c == line[line_size - 1])
{
@ -330,9 +330,8 @@ bool remove_last_char(char c, std::string& line)
// "\\n" ---> '\n' (backslash n becomes carriage return)
void unescape_string(std::string& line)
{
int line_size = line.size();
int index = 0;
while (index < line_size - 1)
auto line_size = line.size();
for (size_t index = 0; line_size >= 1 && index < line_size - 1; ++index)
{
if ('\\' == line[index])
{
@ -347,7 +346,6 @@ void unescape_string(std::string& line)
line_size--;
}
}
index++;
}
}
@ -356,9 +354,8 @@ void unescape_string(std::string& line)
// '\n' ---> "\\n" (carriage return becomes backslash n)
void escape_string(std::string& line)
{
int line_size = line.size();
int index = 0;
while (index < line_size)
auto line_size = line.size();
for (size_t index = 0; index < line_size; ++index)
{
if ('\\' == line[index])
{
@ -372,31 +369,27 @@ void escape_string(std::string& line)
line_size++;
index++;
}
index++;
}
}
// removes '\n' characters
void replace_newlines_with_whitespace(std::string& line)
{
int line_size = line.size();
int index = 0;
while (index < line_size)
auto line_size = line.size();
for (size_t index = 0; index < line_size; ++index)
{
if ('\n' == line[index])
{
line.replace(index, 1, " ");
}
index++;
}
}
// erases any double-quote characters in 'line'
void remove_double_quotes(std::string& line)
{
int index = 0;
int line_size = line.size();
while (index < line_size)
auto line_size = line.size();
for (size_t index = 0; index < line_size; )
{
if ('"' == line[index])
{
@ -424,22 +417,21 @@ void get_keyword_and_value(std::string& keyword,
const std::string& line)
{
// skip initial whitespace
int line_size = line.size();
int line_index = 0;
auto line_size = line.size();
size_t line_index = 0;
char c;
while (line_index < line_size)
for ( ; line_index < line_size; ++line_index)
{
c = line[line_index];
if (!LLStringOps::isSpace(c))
{
break;
}
line_index++;
}
// get the keyword
keyword.clear();
while (line_index < line_size)
for ( ; line_index < line_size; ++line_index)
{
c = line[line_index];
if (LLStringOps::isSpace(c) || '\r' == c || '\n' == c)
@ -447,7 +439,6 @@ void get_keyword_and_value(std::string& keyword,
break;
}
keyword += c;
line_index++;
}
// get the value
@ -465,7 +456,7 @@ void get_keyword_and_value(std::string& keyword,
line_index++;
}
while (line_index < line_size)
for ( ; line_index < line_size; ++line_index)
{
c = line[line_index];
if ('\r' == c || '\n' == c)
@ -473,7 +464,6 @@ void get_keyword_and_value(std::string& keyword,
break;
}
value += c;
line_index++;
}
}
}

10
indra/llcommon/llstring.cpp
View File

@ -141,7 +141,7 @@ std::string rawstr_to_utf8(const std::string& raw)
return wstring_to_utf8str(wstr);
}
S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
std::ptrdiff_t wchar_to_utf8chars(llwchar in_char, char* outchars)
{
U32 cur_char = (U32)in_char;
char* base = outchars;
@ -192,7 +192,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
return outchars - base;
}
S32 utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
auto utf16chars_to_wchar(const U16* inchars, llwchar* outchar)
{
const U16* base = inchars;
U16 cur_char = *inchars++;
@ -310,7 +310,7 @@ S32 wstring_utf16_length(const LLWString &wstr, const S32 woffset, const S32 wle
// and whose equivalent utf-16 string does not exceeds the given utf16_length.
S32 wstring_wstring_length_from_utf16_length(const LLWString & wstr, const S32 woffset, const S32 utf16_length, BOOL *unaligned)
{
const S32 end = wstr.length();
const auto end = wstr.length();
BOOL u = FALSE;
S32 n = woffset + utf16_length;
S32 i = woffset;
@ -426,7 +426,7 @@ LLWString utf8str_to_wstring(const char* utf8str, size_t len)
}
// Check that this character doesn't go past the end of the string
S32 end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
auto end = (len < (i + cont_bytes)) ? len : (i + cont_bytes);
do
{
++i;
@ -471,7 +471,7 @@ std::string wstring_to_utf8str(const llwchar* utf32str, size_t len)
while (i < len)
{
char tchars[8]; /* Flawfinder: ignore */
S32 n = wchar_to_utf8chars(utf32str[i], tchars);
auto n = wchar_to_utf8chars(utf32str[i], tchars);
tchars[n] = 0;
out += tchars;
i++;

2
indra/llcommon/llstring.h
View File

@ -664,7 +664,7 @@ ll_convert_forms(ll_convert_alias, LLWString, std::string, utf8str_to_
// Same function, better name. JC
inline LLWString utf8string_to_wstring(const std::string& utf8_string) { return utf8str_to_wstring(utf8_string); }
LL_COMMON_API S32 wchar_to_utf8chars(llwchar inchar, char* outchars);
LL_COMMON_API std::ptrdiff_t wchar_to_utf8chars(llwchar inchar, char* outchars);
ll_convert_forms(ll_convert_alias, std::string, LLWString, wstring_to_utf8str);
ll_convert_forms(ll_convert_u16_alias, std::string, llutf16string, utf16str_to_utf8str);

23
indra/llcommon/llstringtable.cpp
View File

@ -89,9 +89,8 @@ LLStringTable::~LLStringTable()
{
if (mStringList[i])
{
string_list_t::iterator iter;
for (iter = mStringList[i]->begin(); iter != mStringList[i]->end(); iter++)
delete *iter; // *iter = (LLStringTableEntry*)
for (LLStringTableEntry* entry : *mStringList[i])
delete entry;
}
delete mStringList[i];
}
@ -156,9 +155,9 @@ LLStringTableEntry* LLStringTable::checkStringEntry(const char *str)
if (str)
{
char *ret_val;
LLStringTableEntry *entry;
U32 hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
LLStringTableEntry *entry;
#if 1 // Microsoft
string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@ -180,10 +179,8 @@ LLStringTableEntry* LLStringTable::checkStringEntry(const char *str)
string_list_t *strlist = mStringList[hash_value];
if (strlist)
{
string_list_t::iterator iter;
for (iter = strlist->begin(); iter != strlist->end(); iter++)
for (LLStringTableEntry* entry : *strlist)
{
entry = *iter;
ret_val = entry->mString;
if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
{
@ -226,9 +223,9 @@ LLStringTableEntry* LLStringTable::addStringEntry(const char *str)
if (str)
{
char *ret_val = NULL;
LLStringTableEntry *entry;
U32 hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
LLStringTableEntry *entry;
#if 1 // Microsoft
string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@ -257,10 +254,8 @@ LLStringTableEntry* LLStringTable::addStringEntry(const char *str)
if (strlist)
{
string_list_t::iterator iter;
for (iter = strlist->begin(); iter != strlist->end(); iter++)
for (LLStringTableEntry* entry : *strlist)
{
entry = *iter;
ret_val = entry->mString;
if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
{
@ -294,10 +289,10 @@ void LLStringTable::removeString(const char *str)
if (str)
{
char *ret_val;
LLStringTableEntry *entry;
U32 hash_value = hash_my_string(str, mMaxEntries);
#if STRING_TABLE_HASH_MAP
{
LLStringTableEntry *entry;
#if 1 // Microsoft
string_hash_t::iterator lower = mStringHash.lower_bound(hash_value);
string_hash_t::iterator upper = mStringHash.upper_bound(hash_value);
@ -331,10 +326,8 @@ void LLStringTable::removeString(const char *str)
if (strlist)
{
string_list_t::iterator iter;
for (iter = strlist->begin(); iter != strlist->end(); iter++)
for (LLStringTableEntry* entry : *strlist)
{
entry = *iter;
ret_val = entry->mString;
if (!strncmp(ret_val, str, MAX_STRINGS_LENGTH))
{

4
indra/llcommon/llstringtable.h
View File

@ -136,9 +136,9 @@ public:
for (S32 i = 0; i<mTableSize; i++)
{
string_set_t& stringset = mStringList[i];
for (string_set_t::iterator iter = stringset.begin(); iter != stringset.end(); iter++)
for (LLStdStringHandle str : stringset)
{
delete *iter;
delete str;
}
stringset.clear();
}

14
indra/llcommon/llsys.cpp
View File

@ -273,7 +273,7 @@ LLOSInfo::LLOSInfo() :
{
const char * DARWIN_PRODUCT_NAME = "Mac OS X";
S32 major_version, minor_version, bugfix_version = 0;
int64_t major_version, minor_version, bugfix_version = 0;
if (LLGetDarwinOSInfo(major_version, minor_version, bugfix_version))
{
@ -454,14 +454,14 @@ LLOSInfo::LLOSInfo() :
#ifndef LL_WINDOWS
// static
S32 LLOSInfo::getMaxOpenFiles()
long LLOSInfo::getMaxOpenFiles()
{
const S32 OPEN_MAX_GUESS = 256;
const long OPEN_MAX_GUESS = 256;
#ifdef OPEN_MAX
static S32 open_max = OPEN_MAX;
static long open_max = OPEN_MAX;
#else
static S32 open_max = 0;
static long open_max = 0;
#endif
if (0 == open_max)
@ -909,7 +909,7 @@ void LLMemoryInfo::stream(std::ostream& s) const
// Now stream stats
BOOST_FOREACH(const MapEntry& pair, inMap(mStatsMap))
{
s << pfx << std::setw(key_width+1) << (pair.first + ':') << ' ';
s << pfx << std::setw(narrow(key_width+1)) << (pair.first + ':') << ' ';
LLSD value(pair.second);
if (value.isInteger())
s << std::setw(12) << value.asInteger();
@ -1280,7 +1280,7 @@ public:
<< " seconds ";
}
S32 precision = LL_CONT.precision();
auto precision = LL_CONT.precision();
LL_CONT << std::fixed << std::setprecision(1) << framerate << '\n'
<< LLMemoryInfo();

2
indra/llcommon/llsys.h
View File

@ -59,7 +59,7 @@ public:
S32 mBuild;
#ifndef LL_WINDOWS
static S32 getMaxOpenFiles();
static long getMaxOpenFiles();
#endif
static bool is64Bit();

6
indra/llcommon/llsys_objc.h
View File

@ -27,7 +27,11 @@
#ifndef LL_LLSYS_OBJC_H
#define LL_LLSYS_OBJC_H
bool LLGetDarwinOSInfo(int &major, int &minor, int &patch);
#include <cstdint>
// C++ land doesn't define NSInteger, and we don't want to introduce that for
// this one case, so use int64_t instead (which is equivalent).
bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch);
#endif // LL_LLSYS_OBJC_H

4
indra/llcommon/llsys_objc.mm
View File

@ -27,12 +27,12 @@
#import "llsys_objc.h"
#import <AppKit/AppKit.h>
static int intAtStringIndex(NSArray *array, int index)
static auto intAtStringIndex(NSArray *array, int index)
{
return [(NSString *)[array objectAtIndex:index] integerValue];
}
bool LLGetDarwinOSInfo(int &major, int &minor, int &patch)
bool LLGetDarwinOSInfo(int64_t &major, int64_t &minor, int64_t &patch)
{
if (NSAppKitVersionNumber > NSAppKitVersionNumber10_8)
{

6
indra/llcommon/llthreadsafequeue.h
View File

@ -82,7 +82,7 @@ public:
// Limiting the number of pending items prevents unbounded growth of the
// underlying queue.
LLThreadSafeQueue(U32 capacity = 1024);
LLThreadSafeQueue(size_t capacity = 1024);
virtual ~LLThreadSafeQueue() {}
// Add an element to the queue (will block if the queue has reached
@ -179,7 +179,7 @@ public:
protected:
typedef QueueT queue_type;
QueueT mStorage;
U32 mCapacity;
size_t mCapacity;
bool mClosed;
boost::fibers::timed_mutex mLock;
@ -262,7 +262,7 @@ namespace LL
* LLThreadSafeQueue implementation
*****************************************************************************/
template<typename ElementT, typename QueueT>
LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(U32 capacity) :
LLThreadSafeQueue<ElementT, QueueT>::LLThreadSafeQueue(size_t capacity) :
mCapacity(capacity),
mClosed(false)
{

9
indra/llcommon/lltimer.cpp
View File

@ -121,9 +121,14 @@ U32 micro_sleep(U64 us, U32 max_yields)
U64 start = get_clock_count();
// This is kernel dependent. Currently, our kernel generates software clock
// interrupts at 250 Hz (every 4,000 microseconds).
const U64 KERNEL_SLEEP_INTERVAL_US = 4000;
const S64 KERNEL_SLEEP_INTERVAL_US = 4000;
S32 num_sleep_intervals = (us - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
// Use signed arithmetic to discover whether a sleep is even necessary. If
// either 'us' or KERNEL_SLEEP_INTERVAL_US is unsigned, the compiler
// promotes the difference to unsigned. If 'us' is less than half
// KERNEL_SLEEP_INTERVAL_US, the unsigned difference will be hugely
// positive, resulting in a crazy long wait.
auto num_sleep_intervals = (S64(us) - (KERNEL_SLEEP_INTERVAL_US >> 1)) / KERNEL_SLEEP_INTERVAL_US;
if (num_sleep_intervals > 0)
{
U64 sleep_time = (num_sleep_intervals * KERNEL_SLEEP_INTERVAL_US) - (KERNEL_SLEEP_INTERVAL_US >> 1);

2
indra/llcommon/lltrace.cpp
View File

@ -65,7 +65,7 @@ void TimeBlockTreeNode::setParent( BlockTimerStatHandle* parent )
llassert_always(parent != mBlock);
llassert_always(parent != NULL);
TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(parent->getIndex());
TimeBlockTreeNode* parent_tree_node = get_thread_recorder()->getTimeBlockTreeNode(narrow(parent->getIndex()));
if (!parent_tree_node) return;
if (mParent)

4
indra/llcommon/lltrace.h
View File

@ -340,7 +340,7 @@ inline void claim_alloc(MemStatHandle& measurement, const T& value)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
#if LL_TRACE_ENABLED
S32 size = MeasureMem<T>::measureFootprint(value);
auto size = MeasureMem<T>::measureFootprint(value);
if(size == 0) return;
MemAccumulator& accumulator = measurement.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() + (F64)size : (F64)size);
@ -353,7 +353,7 @@ inline void disclaim_alloc(MemStatHandle& measurement, const T& value)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
#if LL_TRACE_ENABLED
S32 size = MeasureMem<T>::measureFootprint(value);
auto size = MeasureMem<T>::measureFootprint(value);
if(size == 0) return;
MemAccumulator& accumulator = measurement.getCurrentAccumulator();
accumulator.mSize.sample(accumulator.mSize.hasValue() ? accumulator.mSize.getLastValue() - (F64)size : -(F64)size);

4
indra/llcommon/lltraceaccumulators.cpp
View File

@ -96,9 +96,9 @@ void AccumulatorBufferGroup::makeCurrent()
ThreadRecorder* thread_recorder = get_thread_recorder();
AccumulatorBuffer<TimeBlockAccumulator>& timer_accumulator_buffer = mStackTimers;
// update stacktimer parent pointers
for (S32 i = 0, end_i = mStackTimers.size(); i < end_i; i++)
for (size_t i = 0, end_i = mStackTimers.size(); i < end_i; i++)
{
TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(i);
TimeBlockTreeNode* tree_node = thread_recorder->getTimeBlockTreeNode(narrow(i));
if (tree_node)
{
timer_accumulator_buffer[i].mParent = tree_node->mParent;

75
indra/llcommon/lltracerecording.cpp
View File

@ -606,7 +606,8 @@ void PeriodicRecording::nextPeriod()
mCurPeriod = (mCurPeriod + 1) % mRecordingPeriods.size();
old_recording.splitTo(getCurRecording());
mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
mNumRecordedPeriods = mRecordingPeriods.empty()? 0 :
llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + 1);
}
void PeriodicRecording::appendRecording(Recording& recording)
@ -625,21 +626,21 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
getCurRecording().update();
other.getCurRecording().update();
const S32 other_recording_slots = other.mRecordingPeriods.size();
const S32 other_num_recordings = other.getNumRecordedPeriods();
const S32 other_current_recording_index = other.mCurPeriod;
const S32 other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
const auto other_recording_slots = other.mRecordingPeriods.size();
const auto other_num_recordings = other.getNumRecordedPeriods();
const auto other_current_recording_index = other.mCurPeriod;
const auto other_oldest_recording_index = (other_current_recording_index + other_recording_slots - other_num_recordings) % other_recording_slots;
// append first recording into our current slot
getCurRecording().appendRecording(other.mRecordingPeriods[other_oldest_recording_index]);
// from now on, add new recordings for everything after the first
S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
if (mAutoResize)
{
// push back recordings for everything in the middle
S32 other_index = (other_oldest_recording_index + 1) % other_recording_slots;
auto other_index = (other_oldest_recording_index + 1) % other_recording_slots;
while (other_index != other_current_recording_index)
{
mRecordingPeriods.push_back(other.mRecordingPeriods[other_index]);
@ -652,8 +653,8 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
mRecordingPeriods.push_back(other.mRecordingPeriods[other_current_recording_index]);
}
mCurPeriod = mRecordingPeriods.size() - 1;
mNumRecordedPeriods = mRecordingPeriods.size() - 1;
mCurPeriod = mRecordingPeriods.empty()? 0 : mRecordingPeriods.size() - 1;
mNumRecordedPeriods = mCurPeriod;
}
else
{
@ -682,7 +683,7 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
llassert(num_to_copy >= 1);
// advance to last recording period copied, and make that our current period
mCurPeriod = (mCurPeriod + num_to_copy - 1) % mRecordingPeriods.size();
mNumRecordedPeriods = llmin((S32)mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
mNumRecordedPeriods = llmin(mRecordingPeriods.size() - 1, mNumRecordedPeriods + num_to_copy - 1);
}
// end with fresh period, otherwise next appendPeriodicRecording() will merge the first
@ -695,10 +696,10 @@ F64Seconds PeriodicRecording::getDuration() const
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
F64Seconds duration;
S32 num_periods = mRecordingPeriods.size();
for (S32 i = 1; i <= num_periods; i++)
auto num_periods = mRecordingPeriods.size();
for (size_t i = 1; i <= num_periods; i++)
{
S32 index = (mCurPeriod + num_periods - i) % num_periods;
auto index = (mCurPeriod + num_periods - i) % num_periods;
duration += mRecordingPeriods[index].getDuration();
}
return duration;
@ -734,16 +735,16 @@ const Recording& PeriodicRecording::getCurRecording() const
return mRecordingPeriods[mCurPeriod];
}
Recording& PeriodicRecording::getPrevRecording( S32 offset )
Recording& PeriodicRecording::getPrevRecording( size_t offset )
{
S32 num_periods = mRecordingPeriods.size();
auto num_periods = mRecordingPeriods.size();
offset = llclamp(offset, 0, num_periods - 1);
return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
}
const Recording& PeriodicRecording::getPrevRecording( S32 offset ) const
const Recording& PeriodicRecording::getPrevRecording( size_t offset ) const
{
S32 num_periods = mRecordingPeriods.size();
auto num_periods = mRecordingPeriods.size();
offset = llclamp(offset, 0, num_periods - 1);
return mRecordingPeriods[(mCurPeriod + num_periods - offset) % num_periods];
}
@ -772,11 +773,9 @@ void PeriodicRecording::handleReset()
}
else
{
for (std::vector<Recording>::iterator it = mRecordingPeriods.begin(), end_it = mRecordingPeriods.end();
it != end_it;
++it)
for (Recording& rec : mRecordingPeriods)
{
it->reset();
rec.reset();
}
}
mCurPeriod = 0;
@ -790,7 +789,7 @@ void PeriodicRecording::handleSplitTo(PeriodicRecording& other)
getCurRecording().splitTo(other.getCurRecording());
}
F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -812,7 +811,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<EventAccumulator>& stat, S32
: NaN;
}
F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -835,7 +834,7 @@ F64 PeriodicRecording::getPeriodMax( const StatType<EventAccumulator>& stat, S32
}
// calculates means using aggregates per period
F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -858,7 +857,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<EventAccumulator>& stat, S3
: NaN;
}
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -883,7 +882,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<EventAccumulat
: NaN;
}
F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -905,7 +904,7 @@ F64 PeriodicRecording::getPeriodMin( const StatType<SampleAccumulator>& stat, S3
: NaN;
}
F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -928,7 +927,7 @@ F64 PeriodicRecording::getPeriodMax(const StatType<SampleAccumulator>& stat, S32
}
F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -951,7 +950,7 @@ F64 PeriodicRecording::getPeriodMean( const StatType<SampleAccumulator>& stat, S
: NaN;
}
F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -977,7 +976,7 @@ F64 PeriodicRecording::getPeriodMedian( const StatType<SampleAccumulator>& stat,
return F64((buf.size() % 2 == 0) ? (buf[buf.size() / 2 - 1] + buf[buf.size() / 2]) / 2 : buf[buf.size() / 2]);
}
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -1003,7 +1002,7 @@ F64 PeriodicRecording::getPeriodStandardDeviation( const StatType<SampleAccumula
}
F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -1018,12 +1017,12 @@ F64Kilobytes PeriodicRecording::getPeriodMin( const StatType<MemAccumulator>& st
return min_val;
}
F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, S32 num_periods)
F64Kilobytes PeriodicRecording::getPeriodMin(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMin(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
}
F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/)
F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -1038,12 +1037,12 @@ F64Kilobytes PeriodicRecording::getPeriodMax(const StatType<MemAccumulator>& sta
return max_val;
}
F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, S32 num_periods)
F64Kilobytes PeriodicRecording::getPeriodMax(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMax(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
}
F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -1059,12 +1058,12 @@ F64Kilobytes PeriodicRecording::getPeriodMean( const StatType<MemAccumulator>& s
return mean / F64(num_periods);
}
F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, S32 num_periods)
F64Kilobytes PeriodicRecording::getPeriodMean(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodMean(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
}
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, S32 num_periods /*= S32_MAX*/ )
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAccumulator>& stat, size_t num_periods /*= S32_MAX*/ )
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -1089,7 +1088,7 @@ F64Kilobytes PeriodicRecording::getPeriodStandardDeviation( const StatType<MemAc
: NaN);
}
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods)
F64Kilobytes PeriodicRecording::getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods)
{
return getPeriodStandardDeviation(static_cast<const StatType<MemAccumulator>&>(stat), num_periods);
}

100
indra/llcommon/lltracerecording.h
View File

@ -334,7 +334,7 @@ namespace LLTrace
~PeriodicRecording();
void nextPeriod();
S32 getNumRecordedPeriods()
auto getNumRecordedPeriods()
{
// current period counts if not active
return mNumRecordedPeriods + (isStarted() ? 0 : 1);
@ -348,24 +348,24 @@ namespace LLTrace
const Recording& getLastRecording() const;
Recording& getCurRecording();
const Recording& getCurRecording() const;
Recording& getPrevRecording(S32 offset);
const Recording& getPrevRecording(S32 offset) const;
Recording& getPrevRecording(size_t offset);
const Recording& getPrevRecording(size_t offset) const;
Recording snapshotCurRecording() const;
template <typename T>
S32 getSampleCount(const StatType<T>& stat, S32 num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
auto getSampleCount(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
S32 num_samples = 0;
for (S32 i = 1; i <= num_periods; i++)
size_t num_samples = 0;
for (size_t i = 1; i <= num_periods; i++)
{
Recording& recording = getPrevRecording(i);
num_samples += recording.getSampleCount(stat);
}
return num_samples;
}
}
//
// PERIODIC MIN
@ -373,7 +373,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
typename T::value_t getPeriodMin(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename T::value_t getPeriodMin(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -396,33 +396,33 @@ namespace LLTrace
}
template<typename T>
T getPeriodMin(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMin(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMin(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
}
F64 getPeriodMin(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMin(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
T getPeriodMin(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMin(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMin(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
}
F64 getPeriodMin(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMin(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
T getPeriodMin(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMin(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMin(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
}
F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMin(const MemStatHandle& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMin(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
F64Kilobytes getPeriodMin(const MemStatHandle& stat, size_t num_periods = S32_MAX);
template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMinPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -437,7 +437,7 @@ namespace LLTrace
}
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMinPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMinPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@ -449,7 +449,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
typename T::value_t getPeriodMax(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename T::value_t getPeriodMax(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -472,33 +472,33 @@ namespace LLTrace
}
template<typename T>
T getPeriodMax(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMax(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMax(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
}
F64 getPeriodMax(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMax(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
T getPeriodMax(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMax(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMax(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
}
F64 getPeriodMax(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMax(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
T getPeriodMax(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
T getPeriodMax(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return T(getPeriodMax(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
}
F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMax(const MemStatHandle& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMax(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
F64Kilobytes getPeriodMax(const MemStatHandle& stat, size_t num_periods = S32_MAX);
template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMaxPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -513,7 +513,7 @@ namespace LLTrace
}
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMaxPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMaxPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@ -525,7 +525,7 @@ namespace LLTrace
// catch all for stats that have a defined sum
template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMean(const StatType<T >& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -546,32 +546,32 @@ namespace LLTrace
}
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMean(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
}
F64 getPeriodMean(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMean(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMean(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
}
F64 getPeriodMean(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMean(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMean(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMean(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
}
F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMean(const MemStatHandle& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodMean(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
F64Kilobytes getPeriodMean(const MemStatHandle& stat, size_t num_periods = S32_MAX);
template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMeanPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -593,16 +593,16 @@ namespace LLTrace
}
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMeanPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMeanPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
}
F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodMedian( const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
template <typename T>
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<typename T::value_t>::fractional_t getPeriodMedianPerSec(const StatType<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
num_periods = llmin(num_periods, getNumRecordedPeriods());
@ -622,7 +622,7 @@ namespace LLTrace
}
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodMedianPerSec(const CountStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodMedianPerSec(static_cast<const StatType<CountAccumulator>&>(stat), num_periods));
@ -632,25 +632,25 @@ namespace LLTrace
// PERIODIC STANDARD DEVIATION
//
F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodStandardDeviation(const StatType<SampleAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const SampleStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<SampleAccumulator>&>(stat), num_periods));
}
F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, S32 num_periods = S32_MAX);
F64 getPeriodStandardDeviation(const StatType<EventAccumulator>& stat, size_t num_periods = S32_MAX);
template<typename T>
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, S32 num_periods = S32_MAX)
typename RelatedTypes<T>::fractional_t getPeriodStandardDeviation(const EventStatHandle<T>& stat, size_t num_periods = S32_MAX)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_STATS;
return typename RelatedTypes<T>::fractional_t(getPeriodStandardDeviation(static_cast<const StatType<EventAccumulator>&>(stat), num_periods));
}
F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, S32 num_periods = S32_MAX);
F64Kilobytes getPeriodStandardDeviation(const StatType<MemAccumulator>& stat, size_t num_periods = S32_MAX);
F64Kilobytes getPeriodStandardDeviation(const MemStatHandle& stat, size_t num_periods = S32_MAX);
private:
// implementation for LLStopWatchControlsMixin
@ -662,8 +662,8 @@ namespace LLTrace
private:
std::vector<Recording> mRecordingPeriods;
const bool mAutoResize;
S32 mCurPeriod;
S32 mNumRecordedPeriods;
size_t mCurPeriod;
size_t mNumRecordedPeriods;
};
PeriodicRecording& get_frame_recording();

12
indra/llcommon/lltracethreadrecorder.cpp
View File

@ -125,7 +125,7 @@ ThreadRecorder::~ThreadRecorder()
#endif
}
TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( S32 index )
TimeBlockTreeNode* ThreadRecorder::getTimeBlockTreeNode( size_t index )
{
#if LL_TRACE_ENABLED
if (0 <= index && index < mNumTimeBlockTreeNodes)
@ -284,13 +284,11 @@ void ThreadRecorder::pullFromChildren()
AccumulatorBufferGroup& target_recording_buffers = mActiveRecordings.back()->mPartialRecording;
target_recording_buffers.sync();
for (child_thread_recorder_list_t::iterator it = mChildThreadRecorders.begin(), end_it = mChildThreadRecorders.end();
it != end_it;
++it)
{ LLMutexLock lock(&(*it)->mSharedRecordingMutex);
for (LLTrace::ThreadRecorder* rec : mChildThreadRecorders)
{ LLMutexLock lock(&(rec->mSharedRecordingMutex));
target_recording_buffers.merge((*it)->mSharedRecordingBuffers);
(*it)->mSharedRecordingBuffers.reset();
target_recording_buffers.merge(rec->mSharedRecordingBuffers);
rec->mSharedRecordingBuffers.reset();
}
}
#endif

2
indra/llcommon/lltracethreadrecorder.h
View File

@ -57,7 +57,7 @@ namespace LLTrace
void pullFromChildren();
void pushToParent();
TimeBlockTreeNode* getTimeBlockTreeNode(S32 index);
TimeBlockTreeNode* getTimeBlockTreeNode(size_t index);
protected:
void init();

4
indra/llcommon/lluri.cpp
View File

@ -663,9 +663,9 @@ LLSD LLURI::pathArray() const
tokenizer::iterator end = tokens.end();
LLSD params;
for ( ; it != end; ++it)
for (const std::string& str : tokens)
{
params.append(*it);
params.append(str);
}
return params;
}

24
indra/llcommon/lluuid.cpp
View File

@ -40,11 +40,12 @@
#include "lluuid.h"
#include "llerror.h"
#include "llrand.h"
#include "llmd5.h"
#include "llstring.h"
#include "lltimer.h"
#include "llthread.h"
#include "llmutex.h"
#include "llmd5.h"
#include "hbxxh.h"
const LLUUID LLUUID::null;
const LLTransactionID LLTransactionID::tnull;
@ -400,6 +401,9 @@ LLUUID LLUUID::operator^(const LLUUID& rhs) const
return id;
}
// WARNING: this algorithm SHALL NOT be changed. It is also used by the server
// and plays a role in some assets validation (e.g. clothing items). Changing
// it would cause invalid assets.
void LLUUID::combine(const LLUUID& other, LLUUID& result) const
{
LLMD5 md5_uuid;
@ -857,17 +861,12 @@ void LLUUID::generate()
tmp >>= 8;
mData[8] = (unsigned char) tmp;
LLMD5 md5_uuid;
md5_uuid.update(mData,16);
md5_uuid.finalize();
md5_uuid.raw_digest(mData);
HBXXH128::digest(*this, (const void*)mData, 16);
}
void LLUUID::generate(const std::string& hash_string)
{
LLMD5 md5_uuid((U8*)hash_string.c_str());
md5_uuid.raw_digest(mData);
HBXXH128::digest(*this, hash_string);
}
U32 LLUUID::getRandomSeed()
@ -885,13 +884,8 @@ U32 LLUUID::getRandomSeed()
seed[7]=(unsigned char)(pid);
getSystemTime((uuid_time_t *)(&seed[8]));
LLMD5 md5_seed;
md5_seed.update(seed,16);
md5_seed.finalize();
md5_seed.raw_digest(seed);
return(*(U32 *)seed);
U64 seed64 = HBXXH64((const void*)seed, 16).digest();
return U32(seed64) ^ U32(seed64 >> 32);
}
BOOL LLUUID::parseUUID(const std::string& buf, LLUUID* value)

23
indra/llcommon/llworkerthread.cpp
View File

@ -69,11 +69,11 @@ void LLWorkerThread::clearDeleteList()
<< " entries in delete list." << LL_ENDL;
mDeleteMutex->lock();
for (delete_list_t::iterator iter = mDeleteList.begin(); iter != mDeleteList.end(); ++iter)
for (LLWorkerClass* worker : mDeleteList)
{
(*iter)->mRequestHandle = LLWorkerThread::nullHandle();
(*iter)->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
delete *iter ;
worker->mRequestHandle = LLWorkerThread::nullHandle();
worker->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
delete worker;
}
mDeleteList.clear() ;
mDeleteMutex->unlock() ;
@ -81,9 +81,9 @@ void LLWorkerThread::clearDeleteList()
}
// virtual
S32 LLWorkerThread::update(F32 max_time_ms)
size_t LLWorkerThread::update(F32 max_time_ms)
{
S32 res = LLQueuedThread::update(max_time_ms);
auto res = LLQueuedThread::update(max_time_ms);
// Delete scheduled workers
std::vector<LLWorkerClass*> delete_list;
std::vector<LLWorkerClass*> abort_list;
@ -108,15 +108,12 @@ S32 LLWorkerThread::update(F32 max_time_ms)
}
mDeleteMutex->unlock();
// abort and delete after releasing mutex
for (std::vector<LLWorkerClass*>::iterator iter = abort_list.begin();
iter != abort_list.end(); ++iter)
for (LLWorkerClass* worker : abort_list)
{
(*iter)->abortWork(false);
worker->abortWork(false);
}
for (std::vector<LLWorkerClass*>::iterator iter = delete_list.begin();
iter != delete_list.end(); ++iter)
for (LLWorkerClass* worker : delete_list)
{
LLWorkerClass* worker = *iter;
if (worker->mRequestHandle)
{
// Finished but not completed
@ -124,7 +121,7 @@ S32 LLWorkerThread::update(F32 max_time_ms)
worker->mRequestHandle = LLWorkerThread::nullHandle();
worker->clearFlags(LLWorkerClass::WCF_HAVE_WORK);
}
delete *iter;
delete worker;
}
// delete and aborted entries mean there's still work to do
res += delete_list.size() + abort_list.size();

2
indra/llcommon/llworkerthread.h
View File

@ -88,7 +88,7 @@ public:
LLWorkerThread(const std::string& name, bool threaded = true, bool should_pause = false);
~LLWorkerThread();
/*virtual*/ S32 update(F32 max_time_ms);
/*virtual*/ size_t update(F32 max_time_ms);
handle_t addWorkRequest(LLWorkerClass* workerclass, S32 param, U32 priority = PRIORITY_NORMAL);

106
indra/llcommon/stdtypes.h
View File

@ -26,16 +26,23 @@
#ifndef LL_STDTYPES_H
#define LL_STDTYPES_H
#include <cassert>
#include <cfloat>
#include <climits>
#include <limits>
#include <type_traits>
typedef signed char S8;
typedef signed char S8;
typedef unsigned char U8;
typedef signed short S16;
typedef unsigned short U16;
typedef signed int S32;
typedef signed int S32;
typedef unsigned int U32;
// to express an index that might go negative
// (ssize_t is provided by SOME compilers, don't collide)
typedef typename std::make_signed<size_t>::type llssize;
#if LL_WINDOWS
// https://docs.microsoft.com/en-us/cpp/build/reference/zc-wchar-t-wchar-t-is-native-type
// https://docs.microsoft.com/en-us/cpp/cpp/fundamental-types-cpp
@ -45,7 +52,7 @@ typedef unsigned int U32;
// The version of clang available with VS 2019 also defines wchar_t as __wchar_t
// which is also 16 bits.
// In any case, llwchar should be a UTF-32 type.
typedef U32 llwchar;
typedef U32 llwchar;
#else
typedef wchar_t llwchar;
// What we'd actually want is a simple module-scope 'if constexpr' to test
@ -76,7 +83,7 @@ typedef double F64;
typedef S32 BOOL;
typedef U8 KEY;
typedef U32 MASK;
typedef U32 TPACKETID;
typedef U32 TPACKETID;
// Use #define instead of consts to avoid conversion headaches
#define S8_MAX (SCHAR_MAX)
@ -118,4 +125,95 @@ typedef U8 LLPCode;
typedef int intptr_t;
#endif
/*****************************************************************************
* Narrowing
*****************************************************************************/
/**
* narrow() is used to cast a wider type to a narrower type with validation.
*
* In many cases we take the size() of a container and try to pass it to an
* S32 or a U32 parameter. We used to be able to assume that the size of
* anything we could fit into memory could be expressed as a 32-bit int. With
* 64-bit viewers, though, size_t as returned by size() and length() and so
* forth is 64 bits, and the compiler is unhappy about stuffing such values
* into 32-bit types.
*
* It works to force the compiler to truncate, e.g. static_cast<S32>(len) or
* S32(len) or (S32)len, but we can do better.
*
* For:
* @code
* std::vector<Object> container;
* void somefunc(S32 size);
* @endcode
* call:
* @code
* somefunc(narrow(container.size()));
* @endcode
*
* narrow() truncates but, in RelWithDebInfo builds, it validates (using
* assert()) that the passed value can validly be expressed by the destination
* type.
*/
// narrow_holder is a struct that accepts the passed value as its original
// type and provides templated conversion functions to other types. Once we're
// building with compilers that support Class Template Argument Deduction, we
// can rename this class template 'narrow' and eliminate the narrow() factory
// function below.
template <typename FROM>
class narrow_holder
{
private:
FROM mValue;
public:
narrow_holder(FROM value): mValue(value) {}
/*---------------------- Narrowing unsigned to signed ----------------------*/
template <typename TO,
typename std::enable_if<std::is_unsigned<FROM>::value &&
std::is_signed<TO>::value,
bool>::type = true>
inline
operator TO() const
{
// The reason we skip the
// assert(value >= std::numeric_limits<TO>::lowest());
// like the overload below is that to perform the above comparison,
// the compiler promotes the signed lowest() to the unsigned FROM
// type, making it hugely positive -- so a reasonable 'value' will
// always fail the assert().
assert(mValue <= std::numeric_limits<TO>::max());
return static_cast<TO>(mValue);
}
/*----------------------- Narrowing all other cases ------------------------*/
template <typename TO,
typename std::enable_if<! (std::is_unsigned<FROM>::value &&
std::is_signed<TO>::value),
bool>::type = true>
inline
operator TO() const
{
// two different assert()s so we can tell which condition failed
assert(mValue <= std::numeric_limits<TO>::max());
// Funny, with floating point types min() is "positive epsilon" rather
// than "largest negative" -- that's lowest().
assert(mValue >= std::numeric_limits<TO>::lowest());
// Do we really expect to use this with floating point types?
// If so, does it matter if a very small value truncates to zero?
//assert(fabs(mValue) >= std::numeric_limits<TO>::min());
return static_cast<TO>(mValue);
}
};
/// narrow() factory function returns a narrow_holder<FROM>(), which can be
/// implicitly converted to the target type.
template <typename FROM>
inline
narrow_holder<FROM> narrow(FROM value)
{
return { value };
}
#endif

2
indra/llcommon/tests/lleventdispatcher_test.cpp
View File

@ -335,7 +335,7 @@ namespace tut
// Full, partial defaults arrays for params for freena(), freenb()
LLSD dft_array_full, dft_array_partial;
// Start index of partial defaults arrays
const LLSD::Integer partial_offset;
const size_t partial_offset;
// Full, partial defaults maps for params for freena(), freenb()
LLSD dft_map_full, dft_map_partial;
// Most of the above are indexed by "a" or "b". Useful to have an

Some files were not shown because too many files have changed in this diff Show More