Update FMOD

- Many instances of null-checking if statements include both variable declaration and initialization (for scoping)
- Modern(ish) C++ conventions (e.g. range-based for loops, auto keyword)
- Local variable caching for array/iterator elements
- const keyword for variables that should not be mutated (optimization possible)
- const keyword for instance methods that should not mutate (affects LLModelLoader in one case)
- Consistent usage of un/signed types for array indexing
- Better readability/simplicity of branching
- Consolidated extractTranslation/ViaElement logic (reusability)
- Formatting
- Changes based on code review

.gitlab-ci.yml

@@ -1,166 +1,286 @@
 stages:
   - build
-  - deploy
+  - upload
+
+default:
+  interruptible: true
+  timeout: 4h
 
 variables:
+  AUTOBUILD_BUILD_ID: $CI_PIPELINE_ID
+  AUTOBUILD_INSTALLABLE_CACHE: "$CI_PROJECT_DIR/.cache/autobuild"
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
   VIEWER_USE_CRASHPAD: "TRUE"
   VIEWER_CRASHPAD_URL: $SENTRY_DSN
 
-.win_build: &win_build
+.win_build:
   stage: build
   tags:
     - autobuild
     - windows
+  cache:
+    key:
+      files:
+        - autobuild.xml
+      prefix: ${CI_JOB_NAME}
+    paths:
+      - .cache/autobuild
+      - .cache/pip
+      - .venv/
+    when: 'always'
   before_script:
-    - pipenv install
+    - virtualenv .venv
+    - .\.venv\Scripts\activate.ps1
+    - pip install --upgrade autobuild -i https://pkg.alchemyviewer.org/repository/autobuild/simple --extra-index-url https://pypi.org/simple
   script:
-    - If ($env:VIEWER_CHANNEL_TYPE -eq 'Project')
-      {
-          $env:VIEWER_CHANNEL_CODENAME = $env:CI_COMMIT_REF_NAME[8..100] -join ''
-      }
-    - pipenv run autobuild configure -c Release -- -DUSE_FMODSTUDIO=ON -DUSE_NVAPI=ON -DUSE_LTO=ON -DVS_DISABLE_FATAL_WARNINGS=ON
-    - pipenv run autobuild build -c Release --no-configure
-    - If ($env:VIEWER_USE_CRASHPAD -eq 'TRUE') {
-    - Push-Location .\build-vc-*\newview\Release\
-    - sentry-cli upload-dif --include-sources singularity-bin.exe singularity-bin.pdb crashpad_handler.exe crashpad_handler.pdb fmod.dll libcrypto-1_1.dll libcrypto-1_1.pdb libssl-1_1.dll libssl-1_1.pdb libcrypto-1_1-x64.dll libcrypto-1_1-x64.pdb libssl-1_1-x64.dll libssl-1_1-x64.pdb vcruntime140.dll msvcp140.dll libhunspell.dll libhunspell.pdb glod.dll
-    - Pop-Location }
+    - |
+        autobuild configure -c Release -- -DUSE_FMODSTUDIO=ON -DUSE_NVAPI=ON -DUSE_LTO=ON -DVS_DISABLE_FATAL_WARNINGS=ON -DREVISION_FROM_VCS=FALSE
+        autobuild build -c Release --no-configure
   artifacts:
     name: "$env:CI_COMMIT_REF_NAME-$env:CI_COMMIT_SHORT_SHA"
-    expire_in: 2 week
+    expire_in: 1 week
     paths:
       - build-vc-*/newview/Release/build_data.json
-      - build-vc-*/newview/Release/singularity-bin.pdb
+      - build-vc-*/newview/Release/singularity-bin.exe
+      - build-vc-*/newview/Release/*.pdb
+      - build-vc-*/newview/Release/*.dll
       - build-vc-*/newview/Release/Singularity_*_Setup.exe
 
-.beta_rules: &beta_rules
-  only:
-    - /^.*-beta$/
-  except:
-    - branches
+.linux_build:
+  stage: build
+  image: r.alchemyviewer.org/singularity/infrastructure/debian-build-image:latest
+  tags:
+    - linux
+    - docker
+  cache:
+    key:
+      files:
+        - autobuild.xml
+      prefix: ${CI_JOB_NAME}
+    paths:
+      - .cache/autobuild
+      - .cache/pip
+      - .venv
+    when: 'always'
+  before_script:
+    - virtualenv .venv -p python2
+    - source .venv/bin/activate
+    - pip install --upgrade autobuild -i https://pkg.alchemyviewer.org/repository/autobuild/simple --extra-index-url https://pypi.org/simple
+  script:
+    - |
+        autobuild configure -c Release -- -DUSE_FMODSTUDIO=ON -DUSE_NVAPI=ON -DUSE_LTO=ON -DUNIX_DISABLE_FATAL_WARNINGS=ON -DREVISION_FROM_VCS=FALSE
+        autobuild build -c Release --no-configure
+  artifacts:
+    name: "$env:CI_COMMIT_REF_NAME-$env:CI_COMMIT_SHORT_SHA"
+    expire_in: 1 week
+    paths:
+      - build-linux-*/build_data.json
+      - build-linux-*/newview/Singularity_*.tar.xz
 
-.release_rules: &release_rules
-  only:
-    - /^.*-release$/
-  except:
-    - branches
+.win32_build:
+  extends: .win_build
+  variables:
+    AUTOBUILD_ADDRSIZE: 32
+    VIEWER_USE_CRASHPAD: "FALSE"
+  cache:
+    key:
+      prefix: windows32
+
+.win64_build:
+  extends: .win_build
+  variables:
+    AUTOBUILD_ADDRSIZE: 64
+  cache:
+    key:
+      prefix: windows64
+
+.linux32_build:
+  extends: .linux_build
+  variables:
+    AUTOBUILD_ADDRSIZE: 32
+  cache:
+    key:
+      prefix: linux32
+
+.linux64_build:
+  extends: .linux_build
+  variables:
+    AUTOBUILD_ADDRSIZE: 64
+  cache:
+    key:
+      prefix: linux64
+
+.master_rules:
+  rules:
+    - if: $BUILD_CHANNEL || $CI_COMMIT_TAG
+      when: never
+    - if: '$CI_PIPELINE_SOURCE == "web"'
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+    #- if: '$CI_COMMIT_BRANCH == "master" && $CI_PIPELINE_SOURCE == "push"'
+    #  when: delayed
+    #  start_in: '12 hours'
+  variables:
+    VIEWER_CHANNEL_TYPE: Test
+    VIEWER_USE_CRASHPAD: "FALSE"
+
+.project_rules:
+  rules:
+    - if: '$BUILD_CHANNEL == "Project" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+    - if: '$CI_COMMIT_TAG =~ /.*-project/'
+  variables:
+    VIEWER_CHANNEL_TYPE: Project
+
+.beta_rules:
+  rules:
+    - if: '$BUILD_CHANNEL == "Beta" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+    - if: '$CI_COMMIT_TAG =~ /.*-beta/'
+  variables:
+    VIEWER_CHANNEL_TYPE: Beta
+
+.release_rules:
+  rules:
+    - if: '$BUILD_CHANNEL == "Release" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+    - if: '$CI_COMMIT_TAG =~ /.*-release/'
+  variables:
+    VIEWER_CHANNEL_TYPE: Release
+
+.build:master:linux64:
+  extends:
+    - .linux64_build
+    - .master_rules
 
 build:master:windows32:
-  <<: *win_build
-  interruptible: true
-  variables:
-    AUTOBUILD_ADDRSIZE: 32
-    VIEWER_CHANNEL_TYPE: Test
-    VIEWER_USE_CRASHPAD: "FALSE"
-  only:
-    - schedules
+  extends:
+    - .win32_build
+    - .master_rules
 
 build:master:windows64:
-  <<: *win_build
-  interruptible: true
-  variables:
-    AUTOBUILD_ADDRSIZE: 64
-    VIEWER_CHANNEL_TYPE: Test
-    VIEWER_USE_CRASHPAD: "FALSE"
-  only:
-    - schedules
+  extends:
+    - .win64_build
+    - .master_rules
+
+.build:project:linux64:
+  extends:
+    - .linux64_build
+    - .project_rules
 
 build:project:windows32:
-  <<: *win_build
-  interruptible: true
-  variables:
-    AUTOBUILD_ADDRSIZE: 32
-    VIEWER_CHANNEL_TYPE: Project
-    VIEWER_USE_CRASHPAD: "FALSE"
-  only:
-    - /^project-.*$/
+  extends:
+    - .win32_build
+    - .project_rules
 
 build:project:windows64:
-  <<: *win_build
-  interruptible: true
-  variables:
-    AUTOBUILD_ADDRSIZE: 64
-    VIEWER_CHANNEL_TYPE: Project
-  only:
-    - /^project-.*$/
+  extends:
+    - .win64_build
+    - .project_rules
+
+.build:beta:linux64:
+  extends:
+    - .linux64_build
+    - .beta_rules
 
 build:beta:windows32:
-  <<: *win_build
-  variables:
-    AUTOBUILD_ADDRSIZE: 32
-    VIEWER_CHANNEL_TYPE: Beta
-    VIEWER_USE_CRASHPAD: "FALSE"
-  <<: *beta_rules
+  extends:
+    - .win32_build
+    - .beta_rules
 
 build:beta:windows64:
-  <<: *win_build
-  variables:
-    AUTOBUILD_ADDRSIZE: 64
-    VIEWER_CHANNEL_TYPE: Beta
-  <<: *beta_rules
+  extends:
+    - .win64_build
+    - .beta_rules
+
+.build:release:linux64:
+  extends:
+    - .linux64_build
+    - .release_rules
 
 build:release:windows32:
-  <<: *win_build
-  variables:
-    AUTOBUILD_ADDRSIZE: 32
-    VIEWER_CHANNEL_TYPE: Release
-    VIEWER_USE_CRASHPAD: "FALSE"
-  <<: *release_rules
+  extends:
+    - .win32_build
+    - .release_rules
 
 build:release:windows64:
-  <<: *win_build
-  variables:
-    AUTOBUILD_ADDRSIZE: 64
-    VIEWER_CHANNEL_TYPE: Release
-  <<: *release_rules
+  extends:
+    - .win64_build
+    - .release_rules
 
-.deploy_template: &deploy_template
-  stage: deploy
+.upload_template:
+  stage: upload
   tags:
     - autobuild
     - windows
+  allow_failure: false
   script:
-    - $BuildData = Get-Content .\build-vc-64\newview\Release\build_data.json | ConvertFrom-Json
-    - $BuildChannelVersion = $BuildData."Channel" + ' ' + $BuildData."Version"
-    - $UploadDestViewerDir = $BuildChannelVersion.ToLower().Replace(" ", "/")
-    - $UploadDestURL = "https://pkg.alchemyviewer.org/repository/viewer/${UploadDestViewerDir}"
+    - |
+        $BuildData = Get-Content .\build-vc-64\newview\Release\build_data.json | ConvertFrom-Json
+        $BuildChannelVersion = $BuildData."Channel" + ' ' + $BuildData."Version"
+        $UploadDestViewerDir = $BuildChannelVersion.ToLower().Replace(" ", "/")
+        $UploadDestURL = "https://pkg.alchemyviewer.org/repository/viewer/${UploadDestViewerDir}"
 
-    - $UploadParams = @{ UseBasicParsing = $true;
-      Method = "PUT";
-      Headers         = @{
-        ContentType = "application/x-executable";
-        Authorization = "Basic $([System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes("$env:AUTOBUILD_HTTP_USER`:$env:AUTOBUILD_HTTP_PASS")))"; };
-      Verbose = $true; };
+        $UploadParams = @{ UseBasicParsing = $true;
+         Method = "PUT";
+         Headers = @{
+           ContentType = "application/x-executable";
+           Authorization = "Basic $([System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes("$env:AUTOBUILD_HTTP_USER`:$env:AUTOBUILD_HTTP_PASS")))"; };
+         Verbose = $true; };
 
-    - Push-Location .\build-vc-32\newview\Release\
-    - $FileNameWin32 = Get-ChildItem -Path . -Name -Include Singularity_*_Setup.exe
-    - Invoke-WebRequest @UploadParams -InFile .\$FileNameWin32 -Uri "${UploadDestURL}/${FileNameWin32}"
-    - Pop-Location
+        Function try_upload($build_type, $file_pattern)
+        {
+          $build_newview = ".\build-${build_type}\newview\"
+          If (Test-Path -LiteralPath $build_newview)
+          {
+            Push-Location $build_newview
+              $FileName = Get-ChildItem -Path . -Name -Include $file_pattern
+              Invoke-WebRequest @UploadParams -InFile .\$FileName -Uri "${UploadDestURL}/${FileName}"
 
-    - Push-Location .\build-vc-64\newview\Release\
-    - $FileNameWin64 = Get-ChildItem -Path . -Name -Include Singularity_*_Setup.exe
-    - Invoke-WebRequest @UploadParams -InFile .\$FileNameWin64 -Uri "${UploadDestURL}/${FileNameWin64}"
-    - Pop-Location
+              If (($env:VIEWER_USE_CRASHPAD -eq 'TRUE') -and ($build_type -eq "vc-64"))
+              {
+                sentry-cli upload-dif --include-sources singularity-bin.exe singularity-bin.pdb crashpad_handler.exe crashpad_handler.pdb fmod.dll libcrypto-1_1.dll libcrypto-1_1.pdb libssl-1_1.dll libssl-1_1.pdb libcrypto-1_1-x64.dll libcrypto-1_1-x64.pdb libssl-1_1-x64.dll libssl-1_1-x64.pdb vcruntime140.dll msvcp140.dll libhunspell.dll libhunspell.pdb glod.dll
+              }
+            Pop-Location
+          }
+        }
 
-    - sentry-cli releases new $BuildChannelVersion
-    - sentry-cli releases set-commits --auto $BuildChannelVersion
-    - sentry-cli releases finalize $BuildChannelVersion
-  when: manual
+        try_upload("linux-64", "Singularity_*.tar.xz")
+        try_upload("vc-64", "Singularity_*_Setup.exe")
+        try_upload("vc-32", "Singularity_*_Setup.exe")
 
-deploy_project:
-  <<: *deploy_template
+        If ($env:VIEWER_USE_CRASHPAD -eq 'TRUE')
+        {
+          sentry-cli releases new $BuildChannelVersion
+          sentry-cli releases set-commits --auto $BuildChannelVersion
+          sentry-cli releases finalize $BuildChannelVersion
+        }
+
+upload:project:
+  extends:
+    - .upload_template
+  rules:
+    - if: '$BUILD_CHANNEL == "Project" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+      when: manual
+    - if: '$CI_COMMIT_TAG =~ /.*-project/'
+      when: manual
   environment:
     name: qa
-  only:
-    - /^project-.*$/
 
-deploy_beta:
-  <<: *deploy_template
+upload:beta:
+  extends:
+    - .upload_template
+  rules:
+    - if: '$BUILD_CHANNEL == "Beta" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+      when: manual
+    - if: '$CI_COMMIT_TAG =~ /.*-beta/'
+      when: manual
   environment:
-    name: staging
-  <<: *beta_rules
+    name: beta
 
-deploy_release:
-  <<: *deploy_template
+upload:release:
+  extends:
+    - .upload_template
+  rules:
+    - if: '$BUILD_CHANNEL == "Release" && ($CI_PIPELINE_SOURCE == "web" || $CI_PIPELINE_SOURCE == "schedule")'
+      when: manual
+    - if: '$CI_COMMIT_TAG =~ /.*-release/'
+      when: manual
   environment:
-    name: production
-  <<: *release_rules
+    name: release

autobuild.xml

@@ -829,58 +829,34 @@
         <string>fmodstudio</string>
         <key>platforms</key>
         <map>
-          <key>darwin</key>
-          <map>
-            <key>archive</key>
-            <map>
-              <key>hash</key>
-              <string>4a4e1bfd0e1e982643e75533ead10c55</string>
-              <key>hash_algorithm</key>
-              <string>md5</string>
-              <key>url</key>
-              <string>https://pkg.alchemyviewer.org/repository/autobuild-internal/fmodstudio/darwin/fmodstudio-2.00.03.192211300-darwin-192211300.tar.bz2</string>
-            </map>
-            <key>name</key>
-            <string>darwin</string>
-          </map>
           <key>darwin64</key>
           <map>
             <key>archive</key>
             <map>
+              <key>creds</key>
+              <string>gitlab</string>
               <key>hash</key>
-              <string>fe1a606582fb72d5d1c9ec4a2d906830</string>
+              <string>db27e5c974e41d822c75038a6816b07362d54f1b0a64f21a63f0b7076f94c4a34934145bc326a1cc946996abec4b9a5c47e8ef9c68a694e129f09876080d74ac</string>
               <key>hash_algorithm</key>
-              <string>md5</string>
+              <string>blake2b</string>
               <key>url</key>
-              <string>https://pkg.alchemyviewer.org/repository/autobuild-internal/fmodstudio/darwin64/fmodstudio-2.00.03.192211302-darwin64-192211302.tar.bz2</string>
+              <string>https://git.alchemyviewer.org/api/v4/projects/49/packages/generic/fmodstudio/2.02.06.1475/fmodstudio-2.02.06-darwin64-1475.tar.zst</string>
             </map>
             <key>name</key>
             <string>darwin64</string>
           </map>
-          <key>linux</key>
-          <map>
-            <key>archive</key>
-            <map>
-              <key>hash</key>
-              <string>1331456a3df95294eaf44fab990f62cd</string>
-              <key>hash_algorithm</key>
-              <string>md5</string>
-              <key>url</key>
-              <string>https://depot.alchemyviewer.org/pub/linux/lib/fmodstudio-1.06.07-linux-201507231333.tar.bz2</string>
-            </map>
-            <key>name</key>
-            <string>linux</string>
-          </map>
           <key>linux64</key>
           <map>
             <key>archive</key>
             <map>
+              <key>creds</key>
+              <string>gitlab</string>
               <key>hash</key>
-              <string>ccd495598894c8e2e541a348015ee3f0</string>
+              <string>f430175d7af2a8f5e084cd789df904944b117eebb462211eafa80ea5c7f23399449c5a52faf35b3b81a09c51fdff0273741fb32c55f9c615a51b1f15a5094ca5</string>
               <key>hash_algorithm</key>
-              <string>md5</string>
+              <string>blake2b</string>
               <key>url</key>
-              <string>/opt/devel/fmodstudio-2.00.07.200182252-linux64-200182252.tar.bz2</string>
+              <string>https://git.alchemyviewer.org/api/v4/projects/49/packages/generic/fmodstudio/2.02.06.1475/fmodstudio-2.02.06-linux64-1475.tar.zst</string>
             </map>
             <key>name</key>
             <string>linux64</string>
@@ -890,11 +866,11 @@
             <key>archive</key>
             <map>
               <key>hash</key>
-              <string>d32efb193ffcd73bcba4875ddfd17bf0</string>
+              <string>50ce25e855c10d3b39f5461f34661c7f</string>
               <key>hash_algorithm</key>
               <string>md5</string>
               <key>url</key>
-              <string>https://pkg.alchemyviewer.org/repository/autobuild-internal/fmodstudio/windows/fmodstudio-2.00.07.4-windows-4.tar.bz2</string>
+              <string>https://pkg.alchemyviewer.org/repository/autobuild-internal/fmodstudio/windows/fmodstudio-2.01.04.417-windows-417.tar.bz2</string>
             </map>
             <key>name</key>
             <string>windows</string>
@@ -903,19 +879,21 @@
           <map>
             <key>archive</key>
             <map>
+              <key>creds</key>
+              <string>gitlab</string>
               <key>hash</key>
-              <string>0604fd6b53ceaf14ce04d0de1bea51b8</string>
+              <string>7ad5fe064e3a7f45234a3658315a86d80b85f5f49f8a1767e1453116bd23eda67a014c521cf26529fb6bbada3441e64ddffef98ddfa85ae846d8aec72ba6fc70</string>
               <key>hash_algorithm</key>
-              <string>md5</string>
+              <string>blake2b</string>
               <key>url</key>
-              <string>https://pkg.alchemyviewer.org/repository/autobuild-internal/fmodstudio/windows64/fmodstudio-2.00.07.4-windows64-4.tar.bz2</string>
+              <string>https://git.alchemyviewer.org/api/v4/projects/49/packages/generic/fmodstudio/2.02.06.1475/fmodstudio-2.02.06-windows64-1475.tar.zst</string>
             </map>
             <key>name</key>
             <string>windows64</string>
           </map>
         </map>
         <key>version</key>
-        <string>2.00.07.4</string>
+        <string>2.02.06</string>
       </map>
       <key>fonts</key>
       <map>

indra/cmake/00-Common.cmake

@@ -85,6 +85,7 @@ if (WINDOWS)
       /TP
       /W3
       /c
+      /Zc:__cplusplus
       /Zc:forScope
       /Zc:rvalueCast
       /Zc:wchar_t
@@ -135,6 +136,10 @@ if (LINUX)
     -DLL_LINUX=1
     -DAPPID=secondlife
     -D_REENTRANT
+    -DGDK_DISABLE_DEPRECATED 
+    -DGTK_DISABLE_DEPRECATED
+    -DGSEAL_ENABLE
+    -DGTK_DISABLE_SINGLE_INCLUDES
   )
 
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
@@ -204,10 +209,10 @@ if (LINUX)
 
     if (${ARCH} STREQUAL "x86_64")
       add_definitions(-pipe)
-      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffast-math")
-      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffast-math")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ffast-math")
-      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -ffast-math")
+      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffast-math -msse4.1")
+      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffast-math -msse4.1")
+      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ffast-math -msse4.1")
+      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -ffast-math -msse4.1")
     else (${ARCH} STREQUAL "x86_64")
       if (NOT STANDALONE)
         set(MARCH_FLAG " -march=pentium4")

indra/cmake/LLCommon.cmake

@@ -3,6 +3,7 @@
 include(APR)
 include(Boost)
 include(EXPAT)
+include(Linking)
 include(ZLIB)
 
 if (DARWIN)
@@ -18,7 +19,9 @@ set(LLCOMMON_INCLUDE_DIRS
     ${Boost_INCLUDE_DIRS}
     )
 
-set(LLCOMMON_LIBRARIES llcommon)
+set(LLCOMMON_LIBRARIES llcommon
+    fmt::fmt
+    )
 
 set(LLCOMMON_LINK_SHARED OFF CACHE BOOL "Build the llcommon target as a shared library.")
 if(LLCOMMON_LINK_SHARED)

indra/cmake/LLWindow.cmake

@@ -1,9 +1,8 @@
 # -*- cmake -*-
 
 include(OpenGL)
-include(Prebuilt)
 
-if (STANDALONE)
+if (LINUX)
   include(FindSDL)
 
   # This should be done by FindSDL.  Sigh.
@@ -12,14 +11,7 @@ if (STANDALONE)
       SDL_INCLUDE_DIR
       SDL_LIBRARY
       )
-else (STANDALONE)
-  if (LINUX)
-    use_prebuilt_binary(SDL)
-    set (SDL_FOUND TRUE)
-    set (SDL_INCLUDE_DIR ${LIBS_PREBUILT_DIR}/include)
-    set (SDL_LIBRARY SDL)
-  endif (LINUX)
-endif (STANDALONE)
+endif (LINUX)
 
 if (SDL_FOUND)
   add_definitions(-DLL_SDL=1)

indra/cmake/Linking.cmake

@@ -50,12 +50,10 @@ if (LINUX)
   set(DL_LIBRARY dl)
   set(RT_LIBRARY rt)
   set(PTHREAD_LIBRARY pthread)
-  set(FMT_LIBRARY "")
 else (LINUX)
   set(DL_LIBRARY "")
   set(RT_LIBRARY "")
   set(PTHREAD_LIBRARY "")
-  set(FMT_LIBRARY fmt::fmt)
 endif (LINUX)
 
 if (WINDOWS)
@@ -77,6 +75,6 @@ else (WINDOWS)
   set(WINDOWS_LIBRARIES "")
 endif (WINDOWS)
     
-mark_as_advanced(DL_LIBRARY RT_LIBRARY PTHREAD_LIBRARY FMT_LIBRARY WINDOWS_LIBRARIES)
+mark_as_advanced(DL_LIBRARY RT_LIBRARY PTHREAD_LIBRARY WINDOWS_LIBRARIES)
 
 endif(NOT DEFINED ${CMAKE_CURRENT_LIST_FILE}_INCLUDED)

indra/cmake/Python.cmake

@@ -30,8 +30,8 @@ if (WINDOWS)
       )
   endif()
 
-elseif (EXISTS /etc/arch-release)
-  # On Archlinux, use Python 2
+elseif (EXISTS /usr/bin/python2)
+  # if this is there, use it
 
   find_program(PYTHON_EXECUTABLE python2 PATHS /usr/bin)
 

indra/cmake/run_build_test.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file   run_build_test.py
 @author Nat Goodspeed

indra/copy_win_scripts/start-client.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file   start-client.py
 

indra/deps/CMakeLists.txt

@@ -9,21 +9,23 @@ FetchContent_Declare(
   Catch2
   GIT_REPOSITORY https://github.com/catchorg/Catch2.git
   GIT_TAG        v2.11.0
+  GIT_SHALLOW    TRUE
   )
 FetchContent_Declare(
   fmt
   GIT_REPOSITORY https://github.com/fmtlib/fmt.git
-  GIT_TAG        6.1.2
+  GIT_TAG        8d78045e7cb44d39ad4cd95dd27816b8749e1944
   )
 FetchContent_Declare(
   nlohmann_json
   GIT_REPOSITORY https://github.com/nlohmann/json.git
   GIT_TAG        v3.7.3
+  GIT_SHALLOW    TRUE
   )
 FetchContent_Declare(
   absl
   GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
-  GIT_TAG        0033c9ea91a52ade7c6b725aa2ef3cbe15463421
+  GIT_TAG        768eb2ca2857342673fcd462792ce04b8bac3fa3
 )
 
 # This is a hack because absl has dumb cmake
@@ -45,9 +47,7 @@ if (BUILD_TESTING)
 endif()
 
 #Download the rest of the libraries
-if(WINDOWS)
 FetchContent_MakeAvailable(fmt)
-endif()
 
 # Typically you don't care so much for a third party library's tests to be
 # run from your own project's code.

indra/lib/python/indra/util/test_win32_manifest.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file test_win32_manifest.py
 @brief Test an assembly binding version and uniqueness in a windows dll or exe.  

indra/libopenjpeg/CMakeLists.txt

@@ -26,6 +26,7 @@ set(openjpeg_SOURCE_FILES
     mct.c
     mqc.c
     openjpeg.c
+    opj_malloc.c
     phix_manager.c
     pi.c
     ppix_manager.c

indra/libopenjpeg/dwt.c

@@ -31,11 +31,16 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#define OPJ_SKIP_POISON
+#include "opj_includes.h"
+
 #ifdef __SSE__
 #include <xmmintrin.h>
 #endif
 
-#include "opj_includes.h"
+#if defined(__GNUC__)
+#pragma GCC poison malloc calloc realloc free
+#endif
 
 /** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
 /*@{*/
@@ -499,7 +504,7 @@ void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec) {
 /* <summary>                             */
 /* Determine maximum computed resolution level for inverse wavelet transform */
 /* </summary>                            */
-static int dwt_decode_max_resolution(opj_tcd_resolution_t* restrict r, int i) {
+static int dwt_decode_max_resolution(opj_tcd_resolution_t* OPJ_RESTRICT r, int i) {
 	int mr	= 1;
 	int w;
 	while( --i ) {
@@ -531,7 +536,7 @@ static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int numres, DWT1DFN dwt_1
 	v.mem = h.mem;
 
 	while( --numres) {
-		int * restrict tiledp = tilec->data;
+		int * OPJ_RESTRICT tiledp = tilec->data;
 		int j;
 
 		++tr;
@@ -565,48 +570,49 @@ static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int numres, DWT1DFN dwt_1
 	opj_aligned_free(h.mem);
 }
 
-static void v4dwt_interleave_h(v4dwt_t* restrict w, float* restrict a, int x, int size){
-	float* restrict bi = (float*) (w->wavelet + w->cas);
+static void v4dwt_interleave_h(v4dwt_t* OPJ_RESTRICT w, float* OPJ_RESTRICT a, int x, int size) {
+	float* OPJ_RESTRICT bi = (float*)(w->wavelet + w->cas);
 	int count = w->sn;
 	int i, k;
-	for(k = 0; k < 2; ++k){
-		if (count + 3 * x < size && ((size_t) a & 0x0f) == 0 && ((size_t) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
+	for (k = 0; k < 2; ++k) {
+		if (count + 3 * x < size && ((size_t)a & 0x0f) == 0 && ((size_t)bi & 0x0f) == 0 && (x & 0x0f) == 0) {
 			/* Fast code path */
-			for(i = 0; i < count; ++i){
+			for (i = 0; i < count; ++i) {
 				int j = i;
-				bi[i*8    ] = a[j];
+				bi[i * 8] = a[j];
 				j += x;
-				bi[i*8 + 1] = a[j];
+				bi[i * 8 + 1] = a[j];
 				j += x;
-				bi[i*8 + 2] = a[j];
+				bi[i * 8 + 2] = a[j];
 				j += x;
-				bi[i*8 + 3] = a[j];
+				bi[i * 8 + 3] = a[j];
 			}
-		} else {
+		}
+		else {
 			/* Slow code path */
-		for(i = 0; i < count; ++i){
-			int j = i;
-			bi[i*8    ] = a[j];
-			j += x;
-			if(j > size) continue;
-			bi[i*8 + 1] = a[j];
-			j += x;
-			if(j > size) continue;
-			bi[i*8 + 2] = a[j];
-			j += x;
-			if(j > size) continue;
-			bi[i*8 + 3] = a[j];
+			for (i = 0; i < count; ++i) {
+				int j = i;
+				bi[i * 8] = a[j];
+				j += x;
+				if (j > size) continue;
+				bi[i * 8 + 1] = a[j];
+				j += x;
+				if (j > size) continue;
+				bi[i * 8 + 2] = a[j];
+				j += x;
+				if (j > size) continue;
+				bi[i * 8 + 3] = a[j];
+			}
 		}
-		}
-		bi = (float*) (w->wavelet + 1 - w->cas);
+		bi = (float*)(w->wavelet + 1 - w->cas);
 		a += w->sn;
 		size -= w->sn;
 		count = w->dn;
 	}
 }
 
-static void v4dwt_interleave_v(v4dwt_t* restrict v , float* restrict a , int x){
-	v4* restrict bi = v->wavelet + v->cas;
+static void v4dwt_interleave_v(v4dwt_t* OPJ_RESTRICT v , float* OPJ_RESTRICT a , int x){
+	v4* OPJ_RESTRICT bi = v->wavelet + v->cas;
 	int i;
 	for(i = 0; i < v->sn; ++i){
 		memcpy(&bi[i*2], &a[i*x], 4 * sizeof(float));
@@ -621,7 +627,7 @@ static void v4dwt_interleave_v(v4dwt_t* restrict v , float* restrict a , int x){
 #ifdef __SSE__
 
 static void v4dwt_decode_step1_sse(v4* w, int count, const __m128 c){
-	__m128* restrict vw = (__m128*) w;
+	__m128* OPJ_RESTRICT vw = (__m128*) w;
 	int i;
 	/* 4x unrolled loop */
 	for(i = 0; i < count >> 2; ++i){
@@ -642,22 +648,39 @@ static void v4dwt_decode_step1_sse(v4* w, int count, const __m128 c){
 }
 
 static void v4dwt_decode_step2_sse(v4* l, v4* w, int k, int m, __m128 c){
-	__m128* restrict vl = (__m128*) l;
-	__m128* restrict vw = (__m128*) w;
+	__m128* OPJ_RESTRICT vl = (__m128*) l;
+	__m128* OPJ_RESTRICT vw = (__m128*) w;
 	int i;
 	__m128 tmp1, tmp2, tmp3;
 	tmp1 = vl[0];
-	for(i = 0; i < m; ++i){
+	for (i = 0; i < m - 3; i += 4) {
+		__m128 tmp4, tmp5, tmp6, tmp7, tmp8, tmp9;
+		tmp2 = vw[-1];
+		tmp3 = vw[0];
+		tmp4 = vw[1];
+		tmp5 = vw[2];
+		tmp6 = vw[3];
+		tmp7 = vw[4];
+		tmp8 = vw[5];
+		tmp9 = vw[6];
+		vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
+		vw[1] = _mm_add_ps(tmp4, _mm_mul_ps(_mm_add_ps(tmp3, tmp5), c));
+		vw[3] = _mm_add_ps(tmp6, _mm_mul_ps(_mm_add_ps(tmp5, tmp7), c));
+		vw[5] = _mm_add_ps(tmp8, _mm_mul_ps(_mm_add_ps(tmp7, tmp9), c));
+		tmp1 = tmp9;
+		vw += 8;
+	}
+	for ( ; i < m; ++i) {
 		tmp2 = vw[-1];
 		tmp3 = vw[ 0];
 		vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
 		tmp1 = tmp3;
 		vw += 2;
 	}
-	vl = vw - 2;
 	if(m >= k){
 		return;
 	}
+	vl = vw - 2;
 	c = _mm_add_ps(c, c);
 	c = _mm_mul_ps(c, vl[0]);
 	for(; m < k; ++m){
@@ -670,7 +693,7 @@ static void v4dwt_decode_step2_sse(v4* l, v4* w, int k, int m, __m128 c){
 #else
 
 static void v4dwt_decode_step1(v4* w, int count, const float c){
-	float* restrict fw = (float*) w;
+	float* OPJ_RESTRICT fw = (float*) w;
 	int i;
 	for(i = 0; i < count; ++i){
 		float tmp1 = fw[i*8    ];
@@ -685,8 +708,8 @@ static void v4dwt_decode_step1(v4* w, int count, const float c){
 }
 
 static void v4dwt_decode_step2(v4* l, v4* w, int k, int m, float c){
-	float* restrict fl = (float*) l;
-	float* restrict fw = (float*) w;
+	float* OPJ_RESTRICT fl = (float*) l;
+	float* OPJ_RESTRICT fw = (float*) w;
 	int i;
 	for(i = 0; i < m; ++i){
 		float tmp1_1 = fl[0];
@@ -737,42 +760,44 @@ static void v4dwt_decode_step2(v4* l, v4* w, int k, int m, float c){
 /* <summary>                             */
 /* Inverse 9-7 wavelet transform in 1-D. */
 /* </summary>                            */
-static void v4dwt_decode(v4dwt_t* restrict dwt){
+static void v4dwt_decode(v4dwt_t* OPJ_RESTRICT dwt){
 	int a, b;
 	if(dwt->cas == 0) {
-		if(!((dwt->dn > 0) || (dwt->sn > 1))){
+		if (dwt->dn <= 0 && dwt->sn <= 1) {
 			return;
 		}
 		a = 0;
 		b = 1;
 	}else{
-		if(!((dwt->sn > 0) || (dwt->dn > 1))) {
+		if (dwt->sn <= 0 && dwt->dn <= 1) {
 			return;
 		}
 		a = 1;
 		b = 0;
 	}
+	v4* OPJ_RESTRICT waveleta = dwt->wavelet + a;
+	v4* OPJ_RESTRICT waveletb = dwt->wavelet + b;
 #ifdef __SSE__
-	v4dwt_decode_step1_sse(dwt->wavelet+a, dwt->sn, _mm_set1_ps(K));
-	v4dwt_decode_step1_sse(dwt->wavelet+b, dwt->dn, _mm_set1_ps(c13318));
-	v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_delta));
-	v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_gamma));
-	v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_beta));
-	v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_alpha));
+	v4dwt_decode_step1_sse(waveleta, dwt->sn, _mm_set1_ps(K));
+	v4dwt_decode_step1_sse(waveletb, dwt->dn, _mm_set1_ps(c13318));
+	v4dwt_decode_step2_sse(waveletb, waveleta + 1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_delta));
+	v4dwt_decode_step2_sse(waveleta, waveletb + 1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_gamma));
+	v4dwt_decode_step2_sse(waveletb, waveleta + 1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_beta));
+	v4dwt_decode_step2_sse(waveleta, waveletb + 1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_alpha));
 #else
-	v4dwt_decode_step1(dwt->wavelet+a, dwt->sn, K);
-	v4dwt_decode_step1(dwt->wavelet+b, dwt->dn, c13318);
-	v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_delta);
-	v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_gamma);
-	v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_beta);
-	v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_alpha);
+	v4dwt_decode_step1(waveleta, dwt->sn, K);
+	v4dwt_decode_step1(waveletb, dwt->dn, c13318);
+	v4dwt_decode_step2(waveletb, waveleta + 1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_delta);
+	v4dwt_decode_step2(waveleta, waveletb + 1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_gamma);
+	v4dwt_decode_step2(waveletb, waveleta + 1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_beta);
+	v4dwt_decode_step2(waveleta, waveletb + 1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_alpha);
 #endif
 }
 
 /* <summary>                             */
 /* Inverse 9-7 wavelet transform in 2-D. */
 /* </summary>                            */
-void dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, int numres){
+void dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec, int numres){
 	v4dwt_t h;
 	v4dwt_t v;
 
@@ -787,7 +812,7 @@ void dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, int numres){
 	v.wavelet = h.wavelet;
 
 	while( --numres) {
-		float * restrict aj = (float*) tilec->data;
+		float * OPJ_RESTRICT aj = (float*) tilec->data;
 		int bufsize = (tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0);
 		int j;
 

indra/libopenjpeg/mct.c

@@ -29,11 +29,16 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#define OPJ_SKIP_POISON
+#include "opj_includes.h"
+
 #ifdef __SSE__
 #include <xmmintrin.h>
 #endif
 
-#include "opj_includes.h"
+#if defined(__GNUC__)
+#pragma GCC poison malloc calloc realloc free
+#endif
 
 /* <summary> */
 /* This table contains the norms of the basis function of the reversible MCT. */
@@ -49,17 +54,38 @@ static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
 /* Foward reversible MCT. */
 /* </summary> */
 void mct_encode(
-		int* restrict c0,
-		int* restrict c1,
-		int* restrict c2,
+		int* OPJ_RESTRICT c0,
+		int* OPJ_RESTRICT c1,
+		int* OPJ_RESTRICT c2,
 		int n)
 {
-	int i;
-	for(i = 0; i < n; ++i) {
+	int i = 0;
+#ifdef __SSE2__
+	/* Buffers are normally aligned on 16 bytes... */
+	if (((size_t)c0 & 0xf) == 0 && ((size_t)c1 & 0xf) == 0 && ((size_t)c2 & 0xf) == 0) {
+		const int cnt = n & ~3U;
+		for (; i < cnt; i += 4) {
+			__m128i y, u, v;
+			__m128i r = _mm_load_si128((const __m128i*) & (c0[i]));
+			__m128i g = _mm_load_si128((const __m128i*) & (c1[i]));
+			__m128i b = _mm_load_si128((const __m128i*) & (c2[i]));
+			y = _mm_add_epi32(g, g);
+			y = _mm_add_epi32(y, b);
+			y = _mm_add_epi32(y, r);
+			y = _mm_srai_epi32(y, 2);
+			u = _mm_sub_epi32(b, g);
+			v = _mm_sub_epi32(r, g);
+			_mm_store_si128((__m128i*) & (c0[i]), y);
+			_mm_store_si128((__m128i*) & (c1[i]), u);
+			_mm_store_si128((__m128i*) & (c2[i]), v);
+		}
+	}
+#endif
+	for (; i < n; ++i) {
 		int r = c0[i];
 		int g = c1[i];
 		int b = c2[i];
-		int y = (r + (g * 2) + b) >> 2;
+		int y = (r + g + g + b) >> 2;
 		int u = b - g;
 		int v = r - g;
 		c0[i] = y;
@@ -72,13 +98,32 @@ void mct_encode(
 /* Inverse reversible MCT. */
 /* </summary> */
 void mct_decode(
-		int* restrict c0,
-		int* restrict c1, 
-		int* restrict c2, 
+		int* OPJ_RESTRICT c0,
+		int* OPJ_RESTRICT c1,
+		int* OPJ_RESTRICT c2,
 		int n)
 {
-	int i;
-	for (i = 0; i < n; ++i) {
+	int i = 0;
+#ifdef __SSE2__
+	/* Buffers are normally aligned on 16 bytes... */
+	if (((size_t)c0 & 0xf) == 0 && ((size_t)c1 & 0xf) == 0 && ((size_t)c2 & 0xf) == 0) {
+		const int cnt = n & ~3U;
+		for (; i < cnt; i += 4) {
+			__m128i r, g, b;
+			__m128i y = _mm_load_si128((const __m128i*) & (c0[i]));
+			__m128i u = _mm_load_si128((const __m128i*) & (c1[i]));
+			__m128i v = _mm_load_si128((const __m128i*) & (c2[i]));
+			g = y;
+			g = _mm_sub_epi32(g, _mm_srai_epi32(_mm_add_epi32(u, v), 2));
+			r = _mm_add_epi32(v, g);
+			b = _mm_add_epi32(u, g);
+			_mm_store_si128((__m128i*) & (c0[i]), r);
+			_mm_store_si128((__m128i*) & (c1[i]), g);
+			_mm_store_si128((__m128i*) & (c2[i]), b);
+}
+	}
+#endif
+	for (; i < n; ++i) {
 		int y = c0[i];
 		int u = c1[i];
 		int v = c2[i];
@@ -102,13 +147,119 @@ double mct_getnorm(int compno) {
 /* Foward irreversible MCT. */
 /* </summary> */
 void mct_encode_real(
-		int* restrict c0,
-		int* restrict c1,
-		int* restrict c2,
+		int* OPJ_RESTRICT c0,
+		int* OPJ_RESTRICT c1,
+		int* OPJ_RESTRICT c2,
 		int n)
 {
-	int i;
-	for(i = 0; i < n; ++i) {
+	int i = 0;
+#ifdef __SSE4_1__
+	/* Buffers are normally aligned on 16 bytes... */
+	if (((size_t)c0 & 0xf) == 0 && ((size_t)c1 & 0xf) == 0 && ((size_t)c2 & 0xf) == 0) {
+		const int cnt = n & ~3U;
+		const __m128i ry = _mm_set1_epi32(2449);
+		const __m128i gy = _mm_set1_epi32(4809);
+		const __m128i by = _mm_set1_epi32(934);
+		const __m128i ru = _mm_set1_epi32(1382);
+		const __m128i gu = _mm_set1_epi32(2714);
+		const __m128i gv = _mm_set1_epi32(3430);
+		const __m128i bv = _mm_set1_epi32(666);
+		const __m128i mulround = _mm_shuffle_epi32(_mm_cvtsi32_si128(4096), _MM_SHUFFLE(1, 0, 1, 0));
+		for (; i < cnt; i += 4) {
+			__m128i lo, hi, y, u, v;
+			__m128i r = _mm_load_si128((const __m128i*) & (c0[i]));
+			__m128i g = _mm_load_si128((const __m128i*) & (c1[i]));
+			__m128i b = _mm_load_si128((const __m128i*) & (c2[i]));
+
+			hi = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(r, ry);
+			hi = _mm_mul_epi32(hi, ry);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			y = _mm_blend_epi16(lo, hi, 0xCC);
+
+			hi = _mm_shuffle_epi32(g, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(g, gy);
+			hi = _mm_mul_epi32(hi, gy);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			y = _mm_add_epi32(y, _mm_blend_epi16(lo, hi, 0xCC));
+
+			hi = _mm_shuffle_epi32(b, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(b, by);
+			hi = _mm_mul_epi32(hi, by);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			y = _mm_add_epi32(y, _mm_blend_epi16(lo, hi, 0xCC));
+			_mm_store_si128((__m128i*) & (c0[i]), y);
+
+			lo = _mm_cvtepi32_epi64(_mm_shuffle_epi32(b, _MM_SHUFFLE(3, 2, 2, 0)));
+			hi = _mm_cvtepi32_epi64(_mm_shuffle_epi32(b, _MM_SHUFFLE(3, 2, 3, 1)));
+			lo = _mm_slli_epi64(lo, 12);
+			hi = _mm_slli_epi64(hi, 12);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			u = _mm_blend_epi16(lo, hi, 0xCC);
+
+			hi = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(r, ru);
+			hi = _mm_mul_epi32(hi, ru);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			u = _mm_sub_epi32(u, _mm_blend_epi16(lo, hi, 0xCC));
+
+			hi = _mm_shuffle_epi32(g, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(g, gu);
+			hi = _mm_mul_epi32(hi, gu);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			u = _mm_sub_epi32(u, _mm_blend_epi16(lo, hi, 0xCC));
+			_mm_store_si128((__m128i*) & (c1[i]), u);
+
+			lo = _mm_cvtepi32_epi64(_mm_shuffle_epi32(r, _MM_SHUFFLE(3, 2, 2, 0)));
+			hi = _mm_cvtepi32_epi64(_mm_shuffle_epi32(r, _MM_SHUFFLE(3, 2, 3, 1)));
+			lo = _mm_slli_epi64(lo, 12);
+			hi = _mm_slli_epi64(hi, 12);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			v = _mm_blend_epi16(lo, hi, 0xCC);
+
+			hi = _mm_shuffle_epi32(g, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(g, gv);
+			hi = _mm_mul_epi32(hi, gv);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			v = _mm_sub_epi32(v, _mm_blend_epi16(lo, hi, 0xCC));
+
+			hi = _mm_shuffle_epi32(b, _MM_SHUFFLE(3, 3, 1, 1));
+			lo = _mm_mul_epi32(b, bv);
+			hi = _mm_mul_epi32(hi, bv);
+			lo = _mm_add_epi64(lo, mulround);
+			hi = _mm_add_epi64(hi, mulround);
+			lo = _mm_srli_epi64(lo, 13);
+			hi = _mm_slli_epi64(hi, 32 - 13);
+			v = _mm_sub_epi32(v, _mm_blend_epi16(lo, hi, 0xCC));
+			_mm_store_si128((__m128i*) & (c2[i]), v);
+		}
+	}
+#endif
+	for (; i < n; ++i) {
 		int r = c0[i];
 		int g = c1[i];
 		int b = c2[i];
@@ -125,19 +276,21 @@ void mct_encode_real(
 /* Inverse irreversible MCT. */
 /* </summary> */
 void mct_decode_real(
-		float* restrict c0,
-		float* restrict c1,
-		float* restrict c2,
+		float* OPJ_RESTRICT c0,
+		float* OPJ_RESTRICT c1,
+		float* OPJ_RESTRICT c2,
 		int n)
 {
 	int i;
 #ifdef __SSE__
+	int count;
 	__m128 vrv, vgu, vgv, vbu;
 	vrv = _mm_set1_ps(1.402f);
 	vgu = _mm_set1_ps(0.34413f);
 	vgv = _mm_set1_ps(0.71414f);
 	vbu = _mm_set1_ps(1.772f);
-	for (i = 0; i < (n >> 3); ++i) {
+	count = n >> 3;
+	for (i = 0; i < count; ++i) {
 		__m128 vy, vu, vv;
 		__m128 vr, vg, vb;
 
@@ -174,7 +327,7 @@ void mct_decode_real(
 		float u = c1[i];
 		float v = c2[i];
 		float r = y + (v * 1.402f);
-		float g = y - (u * 0.34413f) - (v * (0.71414f));
+		float g = y - (u * 0.34413f) - (v * 0.71414f);
 		float b = y + (u * 1.772f);
 		c0[i] = r;
 		c1[i] = g;

indra/libopenjpeg/openjpeg.h

@@ -40,33 +40,71 @@
 ==========================================================
 */
 
+/*
+The inline keyword is supported by C99 but not by C90.
+Most compilers implement their own version of this keyword ...
+*/
+#ifndef INLINE
+#if defined(_MSC_VER)
+#define INLINE __forceinline
+#elif defined(__GNUC__)
+#define INLINE __inline__
+#elif defined(__MWERKS__)
+#define INLINE inline
+#else
+/* add other compilers here ... */
+#define INLINE
+#endif /* defined(<Compiler>) */
+#endif /* INLINE */
 #if defined(OPJ_STATIC) || !defined(_WIN32)
 #define OPJ_API
 #define OPJ_CALLCONV
 #else
 #define OPJ_CALLCONV __stdcall
 /*
-The following ifdef block is the standard way of creating macros which make exporting 
+The following ifdef block is the standard way of creating macros which make exporting
 from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
 symbol defined on the command line. this symbol should not be defined on any project
-that uses this DLL. This way any other project whose source files include this file see 
-OPJ_API functions as being imported from a DLL, wheras this DLL sees symbols
+that uses this DLL. This way any other project whose source files include this file see
+OPJ_API functions as being imported from a DLL, whereas this DLL sees symbols
 defined with this macro as being exported.
 */
-#if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
-#define OPJ_API __declspec(dllexport)
-#else
-#define OPJ_API __declspec(dllimport)
-#endif /* OPJ_EXPORTS */
+#   if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
+#       define OPJ_API __declspec(dllexport)
+#   else
+#       define OPJ_API __declspec(dllimport)
+#   endif /* OPJ_EXPORTS */
 #endif /* !OPJ_STATIC || !_WIN32 */
 
 typedef int opj_bool;
 #define OPJ_TRUE 1
 #define OPJ_FALSE 0
 
+typedef char          OPJ_CHAR;
+typedef float         OPJ_FLOAT32;
+typedef double        OPJ_FLOAT64;
+typedef unsigned char OPJ_BYTE;
+
+#include "opj_stdint.h"
+
+typedef int8_t   OPJ_INT8;
+typedef uint8_t  OPJ_UINT8;
+typedef int16_t  OPJ_INT16;
+typedef uint16_t OPJ_UINT16;
+typedef int32_t  OPJ_INT32;
+typedef uint32_t OPJ_UINT32;
+typedef int64_t  OPJ_INT64;
+typedef uint64_t OPJ_UINT64;
+
+typedef int64_t  OPJ_OFF_T; /* 64-bit file offset type */
+
+#include <stdio.h>
+typedef size_t   OPJ_SIZE_T;
+
 /* Avoid compile-time warning because parameter is not used */
 #define OPJ_ARG_NOT_USED(x) (void)(x)
-/* 
+
+/*
 ==========================================================
    Useful constant definitions
 ==========================================================

indra/libopenjpeg/opj_includes.h

@@ -40,6 +40,8 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <ctype.h>
+#include <assert.h>
+#include <limits.h>
 
 /*
  ==========================================================
@@ -54,56 +56,115 @@
  ==========================================================
 */
 
+/* Are restricted pointers available? (C99) */
+#if (__STDC_VERSION__ >= 199901L)
+#define OPJ_RESTRICT restrict
+#else
+/* Not a C99 compiler */
+#if defined(__GNUC__)
+#define OPJ_RESTRICT __restrict__
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define OPJ_RESTRICT __restrict
+#else
+#define OPJ_RESTRICT /* restrict */
+#endif
+#endif
+
 /* Ignore GCC attributes if this is not GCC */
 #ifndef __GNUC__
 	#define __attribute__(x) /* __attribute__(x) */
 #endif
 
-/*
-The inline keyword is supported by C99 but not by C90. 
-Most compilers implement their own version of this keyword ... 
-*/
-#ifndef INLINE
-	#if defined(_MSC_VER)
-		#define INLINE __forceinline
-	#elif defined(__GNUC__)
-		#define INLINE __inline__
-	#elif defined(__MWERKS__)
-		#define INLINE inline
-	#else 
-		/* add other compilers here ... */
-		#define INLINE 
-	#endif /* defined(<Compiler>) */
-#endif /* INLINE */
 
-/* Are restricted pointers available? (C99) */
-#if (__STDC_VERSION__ != 199901L)
-	/* Not a C99 compiler */
-	#ifdef __GNUC__
-		#define restrict __restrict__
-	#else
-		#define restrict /* restrict */
-	#endif
-#endif
-
-/* MSVC and Borland C do not have lrintf */
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-static INLINE long lrintf(float f){
+/* MSVC before 2013 and Borland C do not have lrintf */
+#if defined(_MSC_VER)
+#include <intrin.h>
+static INLINE long opj_lrintf(float f)
+{
 #ifdef _M_X64
-    return (long)((f>0.0f) ? (f + 0.5f):(f -0.5f));
-#else
+    return _mm_cvt_ss2si(_mm_load_ss(&f));
+
+    /* commented out line breaks many tests */
+    /* return (long)((f>0.0f) ? (f + 0.5f):(f -0.5f)); */
+#elif defined(_M_IX86)
     int i;
- 
     _asm{
         fld f
         fistp i
     };
- 
+
+    return i;
+#else
+    return (long)((f>0.0f) ? (f + 0.5f) : (f - 0.5f));
+#endif
+}
+#elif defined(__BORLANDC__)
+static INLINE long opj_lrintf(float f)
+{
+#ifdef _M_X64
+    return (long)((f > 0.0f) ? (f + 0.5f) : (f - 0.5f));
+#else
+    int i;
+
+    _asm {
+        fld f
+        fistp i
+    };
+
     return i;
 #endif
 }
+#else
+static INLINE long opj_lrintf(float f)
+{
+    return lrintf(f);
+}
 #endif
 
+#if defined(_MSC_VER) && (_MSC_VER < 1400)
+#define vsnprintf _vsnprintf
+#endif
+
+/* MSVC x86 is really bad at doing int64 = int32 * int32 on its own. Use intrinsic. */
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__INTEL_COMPILER) && defined(_M_IX86)
+#   include <intrin.h>
+#   pragma intrinsic(__emul)
+#endif
+
+/* Apparently Visual Studio doesn't define __SSE__ / __SSE2__ macros */
+#if defined(_M_X64)
+/* Intel 64bit support SSE and SSE2 */
+#   ifndef __SSE__
+#       define __SSE__ 1
+#   endif
+#   ifndef __SSE2__
+#       define __SSE2__ 1
+#   endif
+#   if !defined(__SSE4_1__) && defined(__AVX__)
+#       define __SSE4_1__ 1
+#   endif
+#endif
+
+/* For x86, test the value of the _M_IX86_FP macro. */
+/* See https://msdn.microsoft.com/en-us/library/b0084kay.aspx */
+#if defined(_M_IX86_FP)
+#   if _M_IX86_FP >= 1
+#       ifndef __SSE__
+#           define __SSE__ 1
+#       endif
+#   endif
+#   if _M_IX86_FP >= 2
+#       ifndef __SSE2__
+#           define __SSE2__ 1
+#       endif
+#   endif
+#endif
+
+/* Type to use for bit-fields in internal headers */
+typedef unsigned int OPJ_BITFIELD;
+
+#define OPJ_UNUSED(x) (void)x
+
 #include "j2k_lib.h"
 #include "opj_malloc.h"
 #include "event.h"

indra/libopenjpeg/opj_malloc.c

@@ -0,0 +1,249 @@
+/*
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
+ * party and contributor rights, including patent rights, and no such rights
+ * are granted under this license.
+ *
+ * Copyright (c) 2015, Mathieu Malaterre <mathieu.malaterre@gmail.com>
+ * Copyright (c) 2015, Matthieu Darbois
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#define OPJ_SKIP_POISON
+#include "opj_includes.h"
+
+#if defined(OPJ_HAVE_MALLOC_H) && defined(OPJ_HAVE_MEMALIGN)
+# include <malloc.h>
+#endif
+
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t) -1)
+#endif
+
+static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size)
+{
+    void* ptr;
+
+    /* alignment shall be power of 2 */
+    assert((alignment != 0U) && ((alignment & (alignment - 1U)) == 0U));
+    /* alignment shall be at least sizeof(void*) */
+    assert(alignment >= sizeof(void*));
+
+    if (size == 0U) { /* prevent implementation defined behavior of realloc */
+        return NULL;
+    }
+
+#if defined(OPJ_HAVE_POSIX_MEMALIGN)
+    /* aligned_alloc requires c11, restrict to posix_memalign for now. Quote:
+     * This function was introduced in POSIX 1003.1d. Although this function is
+     * superseded by aligned_alloc, it is more portable to older POSIX systems
+     * that do not support ISO C11.  */
+    if (posix_memalign(&ptr, alignment, size)) {
+        ptr = NULL;
+    }
+    /* older linux */
+#elif defined(OPJ_HAVE_MEMALIGN)
+    ptr = memalign(alignment, size);
+    /* _MSC_VER */
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
+    ptr = _aligned_malloc(size, alignment);
+#else
+    /*
+     * Generic aligned malloc implementation.
+     * Uses size_t offset for the integer manipulation of the pointer,
+     * as uintptr_t is not available in C89 to do
+     * bitwise operations on the pointer itself.
+     */
+    alignment--;
+    {
+        size_t offset;
+        OPJ_UINT8 *mem;
+
+        /* Room for padding and extra pointer stored in front of allocated area */
+        size_t overhead = alignment + sizeof(void *);
+
+        /* let's be extra careful */
+        assert(alignment <= (SIZE_MAX - sizeof(void *)));
+
+        /* Avoid integer overflow */
+        if (size > (SIZE_MAX - overhead)) {
+            return NULL;
+        }
+
+        mem = (OPJ_UINT8*)malloc(size + overhead);
+        if (mem == NULL) {
+            return mem;
+        }
+        /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
+        /* Use the fact that alignment + 1U is a power of 2 */
+        offset = ((alignment ^ ((size_t)(mem + sizeof(void*)) & alignment)) + 1U) &
+                 alignment;
+        ptr = (void *)(mem + sizeof(void*) + offset);
+        ((void**) ptr)[-1] = mem;
+    }
+#endif
+    return ptr;
+}
+static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment,
+        size_t new_size)
+{
+    void *r_ptr;
+
+    /* alignment shall be power of 2 */
+    assert((alignment != 0U) && ((alignment & (alignment - 1U)) == 0U));
+    /* alignment shall be at least sizeof(void*) */
+    assert(alignment >= sizeof(void*));
+
+    if (new_size == 0U) { /* prevent implementation defined behavior of realloc */
+        return NULL;
+    }
+
+    /* no portable aligned realloc */
+#if defined(OPJ_HAVE_POSIX_MEMALIGN) || defined(OPJ_HAVE_MEMALIGN)
+    /* glibc doc states one can mix aligned malloc with realloc */
+    r_ptr = realloc(ptr, new_size);   /* fast path */
+    /* we simply use `size_t` to cast, since we are only interest in binary AND
+     * operator */
+    if (((size_t)r_ptr & (alignment - 1U)) != 0U) {
+        /* this is non-trivial to implement a portable aligned realloc, so use a
+         * simple approach where we do not need a function that return the size of an
+         * allocated array (eg. _msize on Windows, malloc_size on MacOS,
+         * malloc_usable_size on systems with glibc) */
+        void *a_ptr = opj_aligned_alloc_n(alignment, new_size);
+        if (a_ptr != NULL) {
+            memcpy(a_ptr, r_ptr, new_size);
+        }
+        free(r_ptr);
+        r_ptr = a_ptr;
+    }
+    /* _MSC_VER */
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
+    r_ptr = _aligned_realloc(ptr, new_size, alignment);
+#else
+    if (ptr == NULL) {
+        return opj_aligned_alloc_n(alignment, new_size);
+    }
+    alignment--;
+    {
+        void *oldmem;
+        OPJ_UINT8 *newmem;
+        size_t overhead = alignment + sizeof(void *);
+
+        /* let's be extra careful */
+        assert(alignment <= (SIZE_MAX - sizeof(void *)));
+
+        /* Avoid integer overflow */
+        if (new_size > SIZE_MAX - overhead) {
+            return NULL;
+        }
+
+        oldmem = ((void**) ptr)[-1];
+        newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead);
+        if (newmem == NULL) {
+            return newmem;
+        }
+
+        if (newmem == oldmem) {
+            r_ptr = ptr;
+        } else {
+            size_t old_offset;
+            size_t new_offset;
+
+            /* realloc created a new copy, realign the copied memory block */
+            old_offset = (size_t)((OPJ_UINT8*)ptr - (OPJ_UINT8*)oldmem);
+
+            /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
+            /* Use the fact that alignment + 1U is a power of 2 */
+            new_offset  = ((alignment ^ ((size_t)(newmem + sizeof(void*)) & alignment)) +
+                           1U) & alignment;
+            new_offset += sizeof(void*);
+            r_ptr = (void *)(newmem + new_offset);
+
+            if (new_offset != old_offset) {
+                memmove(newmem + new_offset, newmem + old_offset, new_size);
+            }
+            ((void**) r_ptr)[-1] = newmem;
+        }
+    }
+#endif
+    return r_ptr;
+}
+void * opj_malloc(size_t size)
+{
+    if (size == 0U) { /* prevent implementation defined behavior of realloc */
+        return NULL;
+    }
+    return malloc(size);
+}
+void * opj_calloc(size_t num, size_t size)
+{
+    if (num == 0 || size == 0) {
+        /* prevent implementation defined behavior of realloc */
+        return NULL;
+    }
+    return calloc(num, size);
+}
+
+void *opj_aligned_malloc(size_t size)
+{
+    return opj_aligned_alloc_n(16U, size);
+}
+void * opj_aligned_realloc(void *ptr, size_t size)
+{
+    return opj_aligned_realloc_n(ptr, 16U, size);
+}
+
+void *opj_aligned_32_malloc(size_t size)
+{
+    return opj_aligned_alloc_n(32U, size);
+}
+void * opj_aligned_32_realloc(void *ptr, size_t size)
+{
+    return opj_aligned_realloc_n(ptr, 32U, size);
+}
+
+void opj_aligned_free(void* ptr)
+{
+#if defined(OPJ_HAVE_POSIX_MEMALIGN) || defined(OPJ_HAVE_MEMALIGN)
+    free(ptr);
+#elif defined(OPJ_HAVE__ALIGNED_MALLOC)
+    _aligned_free(ptr);
+#else
+    /* Generic implementation has malloced pointer stored in front of used area */
+    if (ptr != NULL) {
+        free(((void**) ptr)[-1]);
+    }
+#endif
+}
+
+void * opj_realloc(void *ptr, size_t new_size)
+{
+    if (new_size == 0U) { /* prevent implementation defined behavior of realloc */
+        return NULL;
+    }
+    return realloc(ptr, new_size);
+}
+void opj_free(void *ptr)
+{
+    free(ptr);
+}

indra/libopenjpeg/opj_malloc.h

@@ -1,4 +1,9 @@
 /*
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
+ * party and contributor rights, including patent rights, and no such rights
+ * are granted under this license.
+ *
  * Copyright (c) 2005, Herve Drolon, FreeImage Team
  * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
  * All rights reserved.
@@ -24,8 +29,10 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-#ifndef __OPJ_MALLOC_H
-#define __OPJ_MALLOC_H
+#ifndef OPJ_MALLOC_H
+#define OPJ_MALLOC_H
+
+#include <stddef.h>
 /**
 @file opj_malloc.h
 @brief Internal functions
@@ -36,6 +43,17 @@ The functions in opj_malloc.h are internal utilities used for memory management.
 /** @defgroup MISC MISC - Miscellaneous internal functions */
 /*@{*/
 
+/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
+#ifdef _WIN32
+#define OPJ_HAVE__ALIGNED_MALLOC
+#else /* Not _WIN32 */
+#if defined(__sun)
+#define OPJ_HAVE_MEMALIGN
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+#define OPJ_HAVE_POSIX_MEMALIGN
+#endif
+#endif
+
 /** @name Exported functions */
 /*@{*/
 /* ----------------------------------------------------------------------- */
@@ -45,90 +63,32 @@ Allocate an uninitialized memory block
 @param size Bytes to allocate
 @return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
 */
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_malloc(size_t size);
-#else
-#define opj_malloc(size) malloc(size)
-#endif
+void * opj_malloc(size_t size);
 
 /**
 Allocate a memory block with elements initialized to 0
-@param num Blocks to allocate
-@param size Bytes per block to allocate
+@param numOfElements  Blocks to allocate
+@param sizeOfElements Bytes per block to allocate
 @return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
 */
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_calloc(size_t _NumOfElements, size_t _SizeOfElements);
-#else
-#define opj_calloc(num, size) calloc(num, size)
-#endif
+void * opj_calloc(size_t numOfElements, size_t sizeOfElements);
 
 /**
-Allocate memory aligned to a 16 byte boundry
+Allocate memory aligned to a 16 byte boundary
 @param size Bytes to allocate
 @return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
 */
-/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
-#ifdef _WIN32
-	/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
-	#ifdef __GNUC__
-		#include <mm_malloc.h>
-		#define HAVE_MM_MALLOC
-	#else /* MSVC, Intel C++ */
-		#include <malloc.h>
-		#ifdef _mm_malloc
-			#define HAVE_MM_MALLOC
-		#endif
-	#endif
-#else /* Not _WIN32 */
-	#if defined(__sun)
-		#define HAVE_MEMALIGN
-  #elif defined(__FreeBSD__)
-    #define HAVE_POSIX_MEMALIGN
-	/* Linux x86_64 and OSX always align allocations to 16 bytes */
-	#elif !defined(__amd64__) && !defined(__APPLE__) && !defined(_AIX)
-		#define HAVE_MEMALIGN
-		#include <malloc.h>			
-	#endif
-#endif
+void * opj_aligned_malloc(size_t size);
+void * opj_aligned_realloc(void *ptr, size_t size);
+void opj_aligned_free(void* ptr);
 
-#define opj_aligned_malloc(size) malloc(size)
-#define opj_aligned_free(m) free(m)
-
-#ifdef HAVE_MM_MALLOC
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) _mm_malloc(size, 16)
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) _mm_free(m)
-#endif
-
-#ifdef HAVE_MEMALIGN
-	extern void* memalign(size_t, size_t);
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) memalign(16, (size))
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) free(m)
-#endif
-
-#ifdef HAVE_POSIX_MEMALIGN
-	#undef opj_aligned_malloc
-	extern int posix_memalign(void**, size_t, size_t);
-
-	static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
-		void* mem = NULL;
-		posix_memalign(&mem, 16, size);
-		return mem;
-	}
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) free(m)
-#endif
-
-#ifdef ALLOC_PERF_OPT
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) opj_malloc(size)
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) opj_free(m)
-#endif
+/**
+Allocate memory aligned to a 32 byte boundary
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+void * opj_aligned_32_malloc(size_t size);
+void * opj_aligned_32_realloc(void *ptr, size_t size);
 
 /**
 Reallocate memory blocks.
@@ -136,23 +96,15 @@ Reallocate memory blocks.
 @param s New size in bytes
 @return Returns a void pointer to the reallocated (and possibly moved) memory block
 */
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_realloc(void * m, size_t s);
-#else
-#define opj_realloc(m, s) realloc(m, s)
-#endif
+void * opj_realloc(void * m, size_t s);
 
 /**
 Deallocates or frees a memory block.
 @param m Previously allocated memory block to be freed
 */
-#ifdef ALLOC_PERF_OPT
-void OPJ_CALLCONV opj_free(void * m);
-#else
-#define opj_free(m) free(m)
-#endif
+void opj_free(void * m);
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(OPJ_SKIP_POISON)
 #pragma GCC poison malloc calloc realloc free
 #endif
 
@@ -161,5 +113,5 @@ void OPJ_CALLCONV opj_free(void * m);
 
 /*@}*/
 
-#endif /* __OPJ_MALLOC_H */
+#endif /* OPJ_MALLOC_H */
 

indra/libopenjpeg/opj_stdint.h

@@ -0,0 +1,51 @@
+/*
+ * The copyright in this software is being made available under the 2-clauses
+ * BSD License, included below. This software may be subject to other third
+ * party and contributor rights, including patent rights, and no such rights
+ * are granted under this license.
+ *
+ * Copyright (c) 2012, Mathieu Malaterre <mathieu.malaterre@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef OPJ_STDINT_H
+#define OPJ_STDINT_H
+
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || _MSC_VER >= 1900
+#include <stdint.h>
+#else
+#if defined(_WIN32)
+typedef   signed __int8   int8_t;
+typedef unsigned __int8   uint8_t;
+typedef   signed __int16  int16_t;
+typedef unsigned __int16  uint16_t;
+typedef   signed __int32  int32_t;
+typedef unsigned __int32  uint32_t;
+typedef   signed __int64  int64_t;
+typedef unsigned __int64  uint64_t;
+#else
+#error unsupported platform
+#endif
+#endif
+
+#endif /* OPJ_STDINT_H */

indra/libopenjpeg/t1.c

@@ -1427,7 +1427,7 @@ void t1_encode_cblks(
 			opj_tcd_resolution_t *res = &tilec->resolutions[resno];
 
 			for (bandno = 0; bandno < res->numbands; ++bandno) {
-				opj_tcd_band_t* restrict band = &res->bands[bandno];
+				opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
         int bandconst = 8192 * 8192 / ((int) floor(band->stepsize * 8192));
 
 				for (precno = 0; precno < res->pw * res->ph; ++precno) {
@@ -1435,8 +1435,8 @@ void t1_encode_cblks(
 
 					for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
 						opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
-						int* restrict datap;
-						int* restrict tiledp;
+						int* OPJ_RESTRICT datap;
+						int* OPJ_RESTRICT tiledp;
 						int cblk_w;
 						int cblk_h;
 						int i, j;
@@ -1517,14 +1517,14 @@ void t1_decode_cblks(
 		opj_tcd_resolution_t* res = &tilec->resolutions[resno];
 
 		for (bandno = 0; bandno < res->numbands; ++bandno) {
-			opj_tcd_band_t* restrict band = &res->bands[bandno];
+			opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
 
 			for (precno = 0; precno < res->pw * res->ph; ++precno) {
 				opj_tcd_precinct_t* precinct = &band->precincts[precno];
 
 				for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
 					opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
-					int* restrict datap;
+					int* OPJ_RESTRICT datap;
 					int cblk_w, cblk_h;
 					int x, y;
 					int i, j;
@@ -1566,7 +1566,7 @@ void t1_decode_cblks(
 					}
 
 					if (tccp->qmfbid == 1) {
-						int* restrict tiledp = &tilec->data[(y * tile_w) + x];
+						int* OPJ_RESTRICT tiledp = &tilec->data[(y * tile_w) + x];
 						for (j = 0; j < cblk_h; ++j) {
 							for (i = 0; i < cblk_w; ++i) {
 								int tmp = datap[(j * cblk_w) + i];
@@ -1574,9 +1574,9 @@ void t1_decode_cblks(
 							}
 						}
 					} else {		/* if (tccp->qmfbid == 0) */
-						float* restrict tiledp = (float*) &tilec->data[(y * tile_w) + x];
+						float* OPJ_RESTRICT tiledp = (float*) &tilec->data[(y * tile_w) + x];
 						for (j = 0; j < cblk_h; ++j) {
-							float* restrict tiledp2 = tiledp;
+							float* OPJ_RESTRICT tiledp2 = tiledp;
 							for (i = 0; i < cblk_w; ++i) {
 								float tmp = *datap * band->stepsize;
 								*tiledp2 = tmp;

indra/libopenjpeg/t1_generate_luts.c

@@ -194,7 +194,7 @@ int main(){
 
 	printf("/* This file was automatically generated by t1_generate_luts.c */\n\n");
 
-	// lut_ctxno_zc
+	/* lut_ctxno_zc */
 	for (j = 0; j < 4; ++j) {
 		for (i = 0; i < 256; ++i) {
 			int orient = j;
@@ -215,7 +215,7 @@ int main(){
 	}
 	printf("%i\n};\n\n", lut_ctxno_zc[1023]);
 
-	// lut_ctxno_sc
+	/* lut_ctxno_sc */
 	printf("static char lut_ctxno_sc[256] = {\n  ");
 	for (i = 0; i < 255; ++i) {
 		printf("0x%x, ", t1_init_ctxno_sc(i << 4));
@@ -224,7 +224,7 @@ int main(){
 	}
 	printf("0x%x\n};\n\n", t1_init_ctxno_sc(255 << 4));
 
-	// lut_spb
+	/* lut_spb */
 	printf("static char lut_spb[256] = {\n  ");
 	for (i = 0; i < 255; ++i) {
 		printf("%i, ", t1_init_spb(i << 4));

indra/libopenjpeg/t2.c

@@ -30,6 +30,7 @@
  */
 
 #include "opj_includes.h"
+#include <assert.h>
 
 /** @defgroup T2 T2 - Implementation of a tier-2 coding */
 /*@{*/
@@ -340,13 +341,15 @@ static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_t
 	int precno = pi->precno;	/* precinct value */
 	int layno  = pi->layno;		/* quality layer value */
 
-	opj_tcd_resolution_t* res = &tile->comps[compno].resolutions[resno];
-
 	unsigned char *hd = NULL;
 	int present;
 	
 	opj_bio_t *bio = NULL;	/* BIO component */
-	
+
+	opj_tcd_resolution_t* res;
+	assert(&tile->comps[compno] != NULL);
+	res = &tile->comps[compno].resolutions[resno];
+
 	if (layno == 0) {
 		for (bandno = 0; bandno < res->numbands; bandno++) {
 			opj_tcd_band_t *band = &res->bands[bandno];

indra/libopenjpeg/tcd.c

@@ -1507,7 +1507,7 @@ opj_bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno
 			for(j = res->y0; j < res->y1; ++j) {
 				for(i = res->x0; i < res->x1; ++i) {
 					float tmp = ((float*)tilec->data)[i - res->x0 + (j - res->y0) * tw];
-					int v = lrintf(tmp);
+					int v = opj_lrintf(tmp);
 					v += adjust;
 					imagec->data[(i - offset_x) + (j - offset_y) * w] = int_clamp(v, min, max);
 				}

indra/llappearance/llavatarappearance.cpp

@@ -24,11 +24,6 @@
  * $/LicenseInfo$
  */
 
-#if LL_MSVC
-// disable warning about boost::lexical_cast returning uninitialized data
-// when it fails to parse the string
-#pragma warning (disable:4701)
-#endif
 
 #include "linden_common.h"
 
@@ -230,7 +225,7 @@ void LLAvatarAppearance::initInstance()
 		for (U32 lod = 0; lod < mesh_dict->mLOD; lod++)
 		{
 			LLAvatarJointMesh* mesh = createAvatarJointMesh();
-			std::string mesh_name = "m" + mesh_dict->mName + std::to_string(lod);
+			std::string mesh_name = fmt::format(FMT_STRING("m{:s}{:d}"), mesh_dict->mName, lod);
 			// We pre-pended an m - need to capitalize first character for camelCase
 			mesh_name[1] = toupper(mesh_name[1]);
 			mesh->setName(mesh_name);

indra/llcommon/CMakeLists.txt

@@ -299,7 +299,9 @@ target_link_libraries(
     ${Boost_SYSTEM_LIBRARY}
     ${CORESERVICES_LIBRARY}
     ${URIPARSER_LIBRARY}
+    fmt::fmt
     nlohmann_json::nlohmann_json
+    absl::strings
     ${RT_LIBRARY}
     )
 

indra/llcommon/llformat.h

@@ -34,6 +34,16 @@
 #ifndef LL_LLFORMAT_H
 #define LL_LLFORMAT_H
 
+#if defined(LL_CLANG)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+#include <fmt/format.h>
+#include <fmt/printf.h>
+#if defined(LL_CLANG)
+#pragma clang diagnostic pop
+#endif
+
 // Use as follows:
 // LL_INFOS() << llformat("Test:%d (%.2f %.2f)", idx, x, y) << LL_ENDL;
 //

indra/llcommon/llsdserialize.cpp

@@ -1072,8 +1072,8 @@ S32 LLSDBinaryParser::doParse(std::istream& istr, LLSD& data) const
 		// the size, and read it.
 		U32 size_nbo = 0;
 		read(istr, (char*)&size_nbo, sizeof(U32));	/*Flawfinder: ignore*/
-		S32 size = (S32)ntohl(size_nbo);
-		if(mCheckLimits && (size > mMaxBytesLeft))
+		S32 size = (S32)ntohl(size_nbo); // Can return negative size if > 2^31.
+		if(size < 0 || mCheckLimits && (size > mMaxBytesLeft))
 		{
 			parse_count = PARSE_FAILURE;
 		}
@@ -1113,7 +1113,11 @@ S32 LLSDBinaryParser::parseMap(std::istream& istr, LLSD& map) const
 	map = LLSD::emptyMap();
 	U32 value_nbo = 0;
 	read(istr, (char*)&value_nbo, sizeof(U32));		 /*Flawfinder: ignore*/
-	S32 size = (S32)ntohl(value_nbo);
+	S32 size = (S32)ntohl(value_nbo);  // Can return negative size if > 2^31.
+	if (size < 0)
+	{
+		return PARSE_FAILURE;
+	}
 	S32 parse_count = 0;
 	S32 count = 0;
 	char c = get(istr);
@@ -1167,7 +1171,11 @@ S32 LLSDBinaryParser::parseArray(std::istream& istr, LLSD& array) const
 	array = LLSD::emptyArray();
 	U32 value_nbo = 0;
 	read(istr, (char*)&value_nbo, sizeof(U32));		 /*Flawfinder: ignore*/
-	S32 size = (S32)ntohl(value_nbo);
+	S32 size = (S32)ntohl(value_nbo); // Can return negative size if > 2^31.
+	if (size < 0)
+	{
+		return PARSE_FAILURE;
+	}
 
 	// *FIX: This would be a good place to reserve some space in the
 	// array...
@@ -1208,8 +1216,8 @@ bool LLSDBinaryParser::parseString(
 	// *FIX: This is memory inefficient.
 	U32 value_nbo = 0;
 	read(istr, (char*)&value_nbo, sizeof(U32));		 /*Flawfinder: ignore*/
-	S32 size = (S32)ntohl(value_nbo);
-	if(mCheckLimits && (size > mMaxBytesLeft)) return false;
+	S32 size = (S32)ntohl(value_nbo); // Can return negative size if > 2^31.
+	if(size < 0 || mCheckLimits && (size > mMaxBytesLeft)) return false;
 	std::vector<char> buf;
 	if(size)
 	{

indra/llcommon/llstring.cpp

@@ -1354,8 +1354,7 @@ void LLStringUtil::formatNumber(std::string& numStr, std::string decimals)
 
 		if (convertToS32(numStr, intStr))
 		{
-			strStream << intStr;
-			numStr = strStream.str();
+			numStr = fmt::to_string(intStr);
 		}
 	}
 	else
@@ -1435,14 +1434,14 @@ bool LLStringUtil::formatDatetime(std::string& replacement, std::string token,
 	{
 		struct tm * gmt = gmtime (&loc_seconds);
 		LLStringUtil::format_map_t args;
-		args["[MDAY]"] = llformat ("%d", gmt->tm_mday);
+		args["[MDAY]"] = fmt::to_string(gmt->tm_mday);
 		replacement = LLStringOps::sDayFormat;
 		LLStringUtil::format(replacement, args);
 	}
 	else if (code == "%-d")
 	{
 		struct tm * gmt = gmtime (&loc_seconds);
-		replacement = llformat ("%d", gmt->tm_mday); // day of the month without leading zero
+		replacement = fmt::to_string(gmt->tm_mday); // day of the month without leading zero
 	}
 	else if( !LLStringOps::sAM.empty() && !LLStringOps::sPM.empty() && code == "%p" )
 	{

indra/llcommon/llstring.h

@@ -29,6 +29,16 @@
 
 #include <boost/optional/optional.hpp>
 #include <string>
+
+#if __cplusplus < 201606
+#include <absl/strings/string_view.h>
+namespace std {
+    typedef absl::string_view string_view;
+}
+#else
+    #include <string_view>
+#endif
+
 #include <cstdio>
 //#include <locale>
 #include <iomanip>

indra/llmath/llmatrix3a.h

@@ -126,9 +126,12 @@ public:
 	// Returns true if this rotation is orthonormal with det ~= 1
 	inline bool isOkRotation() const;		
 } LL_ALIGN_POSTFIX(16);
+
+#if !defined(LL_DEBUG)
 static_assert(std::is_trivial<LLMatrix3a>::value, "LLMatrix3a must be a trivial type");
 static_assert(std::is_standard_layout<LLMatrix3a>::value, "LLMatrix3a must be a standard layout type");
 
 static_assert(std::is_trivial<LLRotation>::value, "LLRotation must be a trivial type");
 static_assert(std::is_standard_layout<LLRotation>::value, "LLRotation must be a standard layout type");
 #endif
+#endif

indra/llmath/llmatrix4a.h

@@ -718,6 +718,8 @@ inline std::ostream& operator<<(std::ostream& s, const LLMatrix4a& m)
 
 void matMulBoundBox(const LLMatrix4a &a, const LLVector4a *in_extents, LLVector4a *out_extents);
 
+#if !defined(LL_DEBUG)
 static_assert(std::is_trivial<LLMatrix4a>::value, "LLMatrix4a must be a trivial type");
 static_assert(std::is_standard_layout<LLMatrix4a>::value, "LLMatrix4a must be a standard layout type");
 #endif
+#endif

indra/llmath/llplane.h

@@ -104,7 +104,8 @@ private:
 	LL_ALIGN_16(LLVector4a mV);
 } LL_ALIGN_POSTFIX(16);
 
+#if !defined(LL_DEBUG)
 static_assert(std::is_trivial<LLPlane>::value, "LLPlane must be a trivial type");
 static_assert(std::is_standard_layout<LLPlane>::value, "LLPlane must be a standard layout type");
-
+#endif
 #endif // LL_LLPLANE_H

indra/llmath/llquaternion2.h

@@ -105,7 +105,9 @@ protected:
 
 } LL_ALIGN_POSTFIX(16);
 
+#if !defined(LL_DEBUG)
 static_assert(std::is_trivial<LLQuaternion2>::value, "LLQuaternion2 must be a trivial type");
 static_assert(std::is_standard_layout<LLQuaternion2>::value, "LLQuaternion2 must be a standard layout type");
+#endif
 
 #endif

indra/llmath/llvector4a.h

@@ -350,6 +350,8 @@ inline std::ostream& operator<<(std::ostream& s, const LLVector4a& v)
 	return s;
 }
 
+#if !defined(LL_DEBUG)
 static_assert(std::is_trivial<LLVector4a>::value, "LLVector4a must be a be a trivial type");
 static_assert(std::is_standard_layout<LLVector4a>::value, "LLVector4a must be a standard layout type");
 #endif
+#endif

indra/llmessage/CMakeLists.txt

@@ -64,7 +64,6 @@ set(llmessage_SOURCE_FILES
     llmessagetemplate.cpp
     llmessagetemplateparser.cpp
     llmessagethrottle.cpp
-    llmime.cpp
     llnamevalue.cpp
     llnullcipher.cpp
     llpacketack.cpp
@@ -163,7 +162,6 @@ set(llmessage_HEADER_FILES
     llmessagetemplate.h
     llmessagetemplateparser.h
     llmessagethrottle.h
-    llmime.h
     llmsgvariabletype.h
     llnamevalue.h
     llnullcipher.h
@@ -241,7 +239,6 @@ if (LL_TESTS)
   include(Tut)
 
   SET(llmessage_TEST_SOURCE_FILES
-    llmime.cpp
     llnamevalue.cpp
     lltrustedmessageservice.cpp
     lltemplatemessagedispatcher.cpp

indra/llmessage/llcachename.cpp

@@ -262,6 +262,8 @@ LLCacheName::~LLCacheName()
 	delete &impl;
 }
 
+const ReverseCache& LLCacheName::getReverseMap() const { return impl.mReverseCache; }
+
 LLCacheName::Impl::Impl(LLMessageSystem* msg)
 	: mMsg(msg), mUpstreamHost(LLHost::invalid)
 {

indra/llmessage/llcachename.h

@@ -57,6 +57,8 @@ public:
 	LLCacheName(LLMessageSystem* msg, const LLHost& upstream_host);
 	~LLCacheName();
 
+	const std::map<std::string, LLUUID>& getReverseMap() const;
+
 	// registers the upstream host
 	// for viewers, this is the currently connected simulator
 	// for simulators, this is the data server

indra/llmessage/llmime.cpp

@@ -1,629 +0,0 @@
-/** 
- * @file llmime.cpp
- * @author Phoenix
- * @date 2006-12-20
- * @brief Implementation of mime tools.
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llmime.h"
-
-#include <vector>
-
-#include "llmemorystream.h"
-
-/**
- * Useful constants.
- */
-// Headers specified in rfc-2045 will be canonicalized below.
-static const std::string CONTENT_LENGTH("Content-Length");
-static const std::string CONTENT_TYPE("Content-Type");
-static const S32 KNOWN_HEADER_COUNT = 6;
-static const std::string KNOWN_HEADER[KNOWN_HEADER_COUNT] =
-{
-	CONTENT_LENGTH,
-	CONTENT_TYPE,
-	std::string("MIME-Version"),
-	std::string("Content-Transfer-Encoding"),
-	std::string("Content-ID"),
-	std::string("Content-Description"),
-};
-
-// parser helpers
-static const std::string MULTIPART("multipart");
-static const std::string BOUNDARY("boundary");
-static const std::string END_OF_CONTENT_PARAMETER("\r\n ;\t");
-static const std::string SEPARATOR_PREFIX("--");
-//static const std::string SEPARATOR_SUFFIX("\r\n");
-
-/*
-Content-Type: multipart/mixed; boundary="segment"
-Content-Length: 24832
-
---segment
-Content-Type: image/j2c
-Content-Length: 23715
-
-<data>
-
---segment
-Content-Type: text/xml; charset=UTF-8
-
-<meta data>
-EOF
-
-*/
-
-/**
- * LLMimeIndex
- */
-
-/** 
- * @class LLMimeIndex::Impl
- * @brief Implementation details of the mime index class.
- * @see LLMimeIndex
- */
-class LLMimeIndex::Impl
-{
-public:
-	Impl() : mOffset(-1), mUseCount(1)
-	{}
-	Impl(LLSD headers, S32 offset) :
-		mHeaders(headers), mOffset(offset), mUseCount(1)
-	{}
-public:
-	LLSD mHeaders;
-	S32 mOffset;
-	S32 mUseCount;
-
-	typedef std::vector<LLMimeIndex> sub_part_t;
-	sub_part_t mAttachments;
-};
-
-LLSD LLMimeIndex::headers() const
-{
-	return mImpl->mHeaders;
-}
-
-S32 LLMimeIndex::offset() const
-{
-	return mImpl->mOffset;
-}
-
-S32 LLMimeIndex::contentLength() const
-{
-	// Find the content length in the headers.
-	S32 length = -1;
-	LLSD content_length = mImpl->mHeaders[CONTENT_LENGTH];
-	if(content_length.isDefined())
-	{
-		length = content_length.asInteger();
-	}
-	return length;
-}
-
-std::string LLMimeIndex::contentType() const
-{
-	std::string type;
-	LLSD content_type = mImpl->mHeaders[CONTENT_TYPE];
-	if(content_type.isDefined())
-	{
-		type = content_type.asString();
-	}
-	return type;
-}
-
-bool LLMimeIndex::isMultipart() const
-{
-	bool multipart = false;
-	LLSD content_type = mImpl->mHeaders[CONTENT_TYPE];
-	if(content_type.isDefined())
-	{
-		std::string type = content_type.asString();
-		int comp = type.compare(0, MULTIPART.size(), MULTIPART);
-		if(0 == comp)
-		{
-			multipart = true;
-		}
-	}
-	return multipart;
-}
-
-S32 LLMimeIndex::subPartCount() const
-{
-	return mImpl->mAttachments.size();
-}
-
-LLMimeIndex LLMimeIndex::subPart(S32 index) const
-{
-	LLMimeIndex part;
-	if((index >= 0) && (index < (S32)mImpl->mAttachments.size()))
-	{
-		part = mImpl->mAttachments[index];
-	}
-	return part;
-}
-
-LLMimeIndex::LLMimeIndex() : mImpl(new LLMimeIndex::Impl)
-{
-}
-
-LLMimeIndex::LLMimeIndex(LLSD headers, S32 content_offset) :
-	mImpl(new LLMimeIndex::Impl(headers, content_offset))
-{
-}
-
-LLMimeIndex::LLMimeIndex(const LLMimeIndex& mime) :
-	mImpl(mime.mImpl)
-{
-	++mImpl->mUseCount;
-}
-
-LLMimeIndex::~LLMimeIndex()
-{
-	if(0 == --mImpl->mUseCount)
-	{
-		delete mImpl;
-	}
-}
-
-LLMimeIndex& LLMimeIndex::operator=(const LLMimeIndex& mime)
-{
-	// Increment use count first so that we handle self assignment
-	// automatically.
-	++mime.mImpl->mUseCount;
-	if(0 == --mImpl->mUseCount)
-	{
-		delete mImpl;
-	}
-	mImpl = mime.mImpl;
-	return *this;
-}
-
-bool LLMimeIndex::attachSubPart(LLMimeIndex sub_part)
-{
-	// *FIX: Should we check for multi-part?
-	if(mImpl->mAttachments.size() < S32_MAX)
-	{
-		mImpl->mAttachments.push_back(sub_part);
-		return true;
-	}
-	return false;
-}
-
-/**
- * LLMimeParser
- */
-/** 
- * @class LLMimeParser::Impl
- * @brief Implementation details of the mime parser class.
- * @see LLMimeParser
- */
-class LLMimeParser::Impl
-{
-public:
-	// @brief Constructor.
-	Impl();
-
-	// @brief Reset this for a new parse.
-	void reset();
-
-	/** 
-	 * @brief Parse a mime entity to find the index information.
-	 *
-	 * This method will scan the istr until a single complete mime
-	 * entity is read, an EOF, or limit bytes have been scanned. The
-	 * istr will be modified by this parsing, so pass in a temporary
-	 * stream or rewind/reset the stream after this call.
-	 * @param istr An istream which contains a mime entity.
-	 * @param limit The maximum number of bytes to scan.
-	 * @param separator The multipart separator if it is known.
-	 * @param is_subpart Set true if parsing a multipart sub part.
-	 * @param index[out] The parsed output.
-	 * @return Returns true if an index was parsed and no errors occurred.
-	 */
-	bool parseIndex(
-		std::istream& istr,
-		S32 limit,
-		const std::string& separator,
-		bool is_subpart,
-		LLMimeIndex& index);
-
-protected:
-	/**
-	 * @brief parse the headers.
-	 *
-	 * At the end of a successful parse, mScanCount will be at the
-	 * start of the content.
-	 * @param istr The input stream.
-	 * @param limit maximum number of bytes to process
-	 * @param headers[out] A map of the headers found.
-	 * @return Returns true if the parse was successful.
-	 */
-	bool parseHeaders(std::istream& istr, S32 limit, LLSD& headers);
-
-	/**
-	 * @brief Figure out the separator string from a content type header.
-	 * 
-	 * @param multipart_content_type The content type value from the headers.
-	 * @return Returns the separator string.
-	 */
-	std::string findSeparator(std::string multipart_content_type);
-
-	/**
-	 * @brief Scan through istr past the separator.
-	 *
-	 * @param istr The input stream.
-	 * @param limit Maximum number of bytes to scan.
-	 * @param separator The multipart separator.
-	 */
-	void scanPastSeparator(
-		std::istream& istr,
-		S32 limit,
-		const std::string& separator);
-
-	/**
-	 * @brief Scan through istr past the content of the current mime part.
-	 *
-	 * @param istr The input stream.
-	 * @param limit Maximum number of bytes to scan.
-	 * @param headers The headers for this mime part.
-	 * @param separator The multipart separator if known.
-	 */
-	void scanPastContent(
-		std::istream& istr,
-		S32 limit,
-		LLSD headers,
-		const std::string separator);
-
-	/**
-	 * @brief Eat CRLF.
-	 *
-	 * This method has no concept of the limit, so ensure you have at
-	 * least 2 characters left to eat before hitting the limit. This
-	 * method will increment mScanCount as it goes.
-	 * @param istr The input stream.
-	 * @return Returns true if CRLF was found and consumed off of istr.
-	 */
-	bool eatCRLF(std::istream& istr);
-
-	// @brief Returns true if parsing should continue.
-	bool continueParse() const { return (!mError && mContinue); }
-
-	// @brief anonymous enumeration for parse buffer size.
-	enum
-	{
-		LINE_BUFFER_LENGTH = 1024
-	};
-
-protected:
-	S32 mScanCount;
-	bool mContinue;
-	bool mError;
-	char mBuffer[LINE_BUFFER_LENGTH];
-};
-
-LLMimeParser::Impl::Impl()
-{
-	reset();
-}
-
-void LLMimeParser::Impl::reset()
-{
-	mScanCount = 0;
-	mContinue = true;
-	mError = false;
-	mBuffer[0] = '\0';
-}
-
-bool LLMimeParser::Impl::parseIndex(
-	std::istream& istr,
-	S32 limit,
-	const std::string& separator,
-	bool is_subpart,
-	LLMimeIndex& index)
-{
-	LLSD headers;
-	bool parsed_something = false;
-	if(parseHeaders(istr, limit, headers))
-	{
-		parsed_something = true;
-		LLMimeIndex mime(headers, mScanCount);
-		index = mime;
-		if(index.isMultipart())
-		{
-			// Figure out the separator, scan past it, and recurse.
-			std::string ct = headers[CONTENT_TYPE].asString();
-			std::string sep = findSeparator(ct);
-			scanPastSeparator(istr, limit, sep);
-			while(continueParse() && parseIndex(istr, limit, sep, true, mime))
-			{
-				index.attachSubPart(mime);
-			}
-		}
-		else
-		{
-			// Scan to the end of content.
-			scanPastContent(istr, limit, headers, separator);
-			if(is_subpart)
-			{
-				scanPastSeparator(istr, limit, separator);
-			}
-		}
-	}
-	if(mError) return false;
-	return parsed_something;
-}
-
-bool LLMimeParser::Impl::parseHeaders(
-	std::istream& istr,
-	S32 limit,
-	LLSD& headers)
-{
-	while(continueParse())
-	{
-		// Get the next line.
-		// We subtract 1 from the limit so that we make sure
-		// not to read past limit when we get() the newline.
-		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
-		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += (S32)istr.gcount();
-		int c = istr.get();
-		if(EOF == c)
-		{
-			mContinue = false;
-			return false;
-		}
-		++mScanCount;
-		if(c != '\n')
-		{
-			mError = true;
-			return false;
-		}
-		if(mScanCount >= limit)
-		{
-			mContinue = false;
-		}
-
-		// Check if that's the end of headers.
-		if('\0' == mBuffer[0])
-		{
-			break;
-		}
-
-		// Split out the name and value.
-		// *NOTE: The use of strchr() here is safe since mBuffer is
-		// guaranteed to be NULL terminated from the call to getline()
-		// above.
-		char* colon = strchr(mBuffer, ':');
-		if(!colon)
-		{
-			mError = true;
-			return false;
-		}
-
-		// Cononicalize the name part, and store the name: value in
-		// the headers structure. We do this by iterating through
-		// 'known' headers and replacing the value found with the
-		// correct one.
-		// *NOTE: Not so efficient, but iterating through a small
-		// subset should not be too much of an issue.
-		std::string name(mBuffer, colon++ - mBuffer);
-		while(isspace(*colon)) ++colon;
-		std::string value(colon);
-		for(S32 ii = 0; ii < KNOWN_HEADER_COUNT; ++ii)
-		{
-			if(0 == LLStringUtil::compareInsensitive(name, KNOWN_HEADER[ii]))
-			{
-				name = KNOWN_HEADER[ii];
-				break;
-			}
-		}
-		headers[name] = value;
-	}
-	if(headers.isUndefined()) return false;
-	return true;
-}
-
-std::string LLMimeParser::Impl::findSeparator(std::string header)
-{
-	//                               01234567890
-	//Content-Type: multipart/mixed; boundary="segment"
-	std::string separator;
-	std::string::size_type pos = header.find(BOUNDARY);
-	if(std::string::npos == pos) return separator;
-	pos += BOUNDARY.size() + 1;
-	std::string::size_type end;
-	if(header[pos] == '"')
-	{
-		// the boundary is quoted, find the end from pos, and take the
-		// substring.
-		end = header.find('"', ++pos);
-		if(std::string::npos == end)
-		{
-			// poorly formed boundary.
-			mError = true;
-		}
-	}
-	else
-	{
-		// otherwise, it's every character until a whitespace, end of
-		// line, or another parameter begins.
-		end = header.find_first_of(END_OF_CONTENT_PARAMETER, pos);
-		if(std::string::npos == end)
-		{
-			// it goes to the end of the string.
-			end = header.size();
-		}
-	}
-	if(!mError) separator = header.substr(pos, end - pos);
-	return separator;
-}
-
-void LLMimeParser::Impl::scanPastSeparator(
-	std::istream& istr,
-	S32 limit,
-	const std::string& sep)
-{
-	std::ostringstream ostr;
-	ostr << SEPARATOR_PREFIX << sep;
-	std::string separator = ostr.str();
-	bool found_separator = false;
-	while(!found_separator && continueParse())
-	{
-		// Subtract 1 from the limit so that we make sure not to read
-		// past limit when we get() the newline.
-		S32 max_get = llmin((S32)LINE_BUFFER_LENGTH, limit - mScanCount - 1);
-		istr.getline(mBuffer, max_get, '\r');
-		mScanCount += (S32)istr.gcount();
-		if(istr.gcount() >= LINE_BUFFER_LENGTH - 1)
-		{
-			// that's way too long to be a separator, so ignore it.
-			continue;
-		}
-		int c = istr.get();
-		if(EOF == c)
-		{
-			mContinue = false;
-			return;
-		}
-		++mScanCount;
-		if(c != '\n')
-		{
-			mError = true;
-			return;
-		}
-		if(mScanCount >= limit)
-		{
-			mContinue = false;
-		}
-		if(0 == LLStringUtil::compareStrings(std::string(mBuffer), separator))
-		{
-			found_separator = true;
-		}
-	}
-}
-
-void LLMimeParser::Impl::scanPastContent(
-	std::istream& istr,
-	S32 limit,
-	LLSD headers,
-	const std::string separator)
-{
-	if(headers.has(CONTENT_LENGTH))
-	{
-		S32 content_length = headers[CONTENT_LENGTH].asInteger();
-		// Subtract 2 here for the \r\n after the content.
-		S32 max_skip = llmin(content_length, limit - mScanCount - 2);
-		istr.ignore(max_skip);
-		mScanCount += max_skip;
-
-		// *NOTE: Check for hitting the limit and eof here before
-		// checking for the trailing EOF, because our mime parser has
-		// to gracefully handle incomplete mime entites.
-		if((mScanCount >= limit) || istr.eof())
-		{
-			mContinue = false;
-		}
-		else if(!eatCRLF(istr))
-		{
-			mError = true;
-			return;
-		}
-	}
-}
-
-bool LLMimeParser::Impl::eatCRLF(std::istream& istr)
-{
-	int c = istr.get();
-	++mScanCount;
-	if(c != '\r')
-	{
-		return false;
-	}
-	c = istr.get();
-	++mScanCount;
-	if(c != '\n')
-	{
-		return false;
-	}
-	return true;
-}
-	
-
-LLMimeParser::LLMimeParser() : mImpl(* new LLMimeParser::Impl)
-{
-}
-
-LLMimeParser::~LLMimeParser()
-{
-	delete & mImpl;
-}
-
-void LLMimeParser::reset()
-{
-	mImpl.reset();
-}
-
-bool LLMimeParser::parseIndex(std::istream& istr, LLMimeIndex& index)
-{
-	std::string separator;
-	return mImpl.parseIndex(istr, S32_MAX, separator, false, index);
-}
-
-bool LLMimeParser::parseIndex(
-	const std::vector<U8>& buffer,
-	LLMimeIndex& index)
-{
-	LLMemoryStream mstr(&buffer[0], buffer.size());
-	return parseIndex(mstr, buffer.size() + 1, index);
-}
-
-bool LLMimeParser::parseIndex(
-	std::istream& istr,
-	S32 limit,
-	LLMimeIndex& index)
-{
-	std::string separator;
-	return mImpl.parseIndex(istr, limit, separator, false, index);
-}
-
-bool LLMimeParser::parseIndex(const U8* buffer, S32 length, LLMimeIndex& index)
-{
-	LLMemoryStream mstr(buffer, length);
-	return parseIndex(mstr, length + 1, index);
-}
-
-/*
-bool LLMimeParser::verify(std::istream& isr, LLMimeIndex& index) const
-{
-	return false;
-}
-
-bool LLMimeParser::verify(U8* buffer, S32 length, LLMimeIndex& index) const
-{
-	LLMemoryStream mstr(buffer, length);
-	return verify(mstr, index);
-}
-*/

indra/llmessage/llmime.h

@@ -1,292 +0,0 @@
-/** 
- * @file llmime.h
- * @author Phoenix
- * @date 2006-12-20
- * @brief Declaration of mime tools.
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLMIME_H
-#define LL_LLMIME_H
-
-#include <string>
-#include "llsd.h"
-
-/**
- * This file declares various tools for parsing and creating MIME
- * objects as described in RFCs 2045, 2046, 2047, 2048, and 2049.
- */
-
-/** 
- * @class LLMimeIndex
- * @brief Skeletal information useful for handling mime packages.
- * @see LLMimeParser
- *
- * An instance of this class is the parsed output from a LLMimeParser
- * which then allows for easy access into a data stream to find and
- * get what you want out of it.
- *
- * This class meant as a tool to quickly find what you seek in a
- * parsed mime entity. As such, it does not have useful support for
- * modification of a mime entity and specializes the interface toward
- * querying data from a fixed mime entity. Modifying an instance of
- * LLMimeIndx does not alter a mime entity and changes to a mime
- * entity itself are not propogated into an instance of a LLMimeIndex.
- *
- * Usage:<br>
- *  LLMimeIndex mime_index;<br>
- *  std::ifstream fstr("package.mime", ios::binary);<br>
- *  LLMimeParser parser;<br>
- *  if(parser.parseIndex(fstr, mime_index))<br>
- *  {<br>
- *    std::vector<U8> content;<br>
- *    content.resize(mime_index.contentLength());<br>
- *    fstr.seekg(mime_index.offset(), ios::beg);<br>
- *    // ...do work on fstr and content<br>
- *  }<br>
- */
-class LLMimeIndex
-{
-public:
-	/* @name Client interface.
-	 */
-	//@{
-	/** 
-	 * @brief Get the full parsed headers for this.
-	 *
-	 * If there are any headers, it will be a map of header name to
-	 * the value found on the line. The name is everything before the
-	 * colon, and the value is the string found after the colon to the
-	 * end of the line after trimming leading whitespace. So, for
-	 * example:
-	 * Content-Type:  text/plain
-	 * would become an entry in the headers of:
-	 * headers["Content-Type"] == "text/plain"
-	 *
-	 * If this instance of an index was generated by the
-	 * LLMimeParser::parseIndex() call, all header names in rfc2045
-	 * will be capitalized as in rfc, eg Content-Length and
-	 * MIME-Version, not content-length and mime-version.
-	 * @return Returns an LLSD map of header name to value. Returns
-	 * undef if there are no headers.
-	 */
-	LLSD headers() const;
-
-	/** 
-	 * @brief Get the content offset.
-	 *
-	 * @return Returns the number of bytes to the start of the data
-	 * segment from the start of serialized mime entity. Returns -1 if
-	 * offset is not known.
-	 */
-	S32 offset() const;
-
-	/** 
-	 * @brief Get the length of the data segment for this mime part.
-	 *
-	 * @return Returns the content length in bytes. Returns -1 if
-	 * length is not known.
-	 */
-	S32 contentLength() const;
-
-	/** 
-	 * @brief Get the mime type associated with this node.
-	 *
-	 * @return Returns the mimetype.
-	 */
-	std::string contentType() const;
-
-	/** 
-	 * @brief Helper method which simplifies parsing the return from type()
-	 *
-	 * @return Returns true if this is a multipart mime, and therefore
-	 * getting subparts will succeed.
-	 */
-	bool isMultipart() const;
-
-	/** 
-	 * @brief Get the number of atachments.
-	 *
-	 * @return Returns the number of sub-parts for this.
-	 */
-	S32 subPartCount() const;
-
-	/** 
-	 * @brief Get the indicated attachment.
-	 *
-	 * @param index Value from 0 to (subPartCount() - 1).
-	 * @return Returns the indicated sub-part, or an invalid mime
-	 * index on failure.
-	 */
-	LLMimeIndex subPart(S32 index) const;
-	//@}
-
-	/* @name Interface for building, testing, and helpers for typical use.
-	 */
-	//@{
-	/**
-	 * @brief Default constructor - creates a useless LLMimeIndex.
-	 */
-	LLMimeIndex();
-
-	/**
-	 * @brief Full constructor.
-	 *
-	 * @param headers The complete headers.
-	 * @param content_offset The number of bytes to the start of the
-	 * data segment of this mime entity from the start of the stream
-	 * or buffer.
-	 */
-	LLMimeIndex(LLSD headers, S32 content_offset);
-
-	/**
-	 * @brief Copy constructor.
-	 *
-	 * @param mime The other mime object.
-	 */
-	LLMimeIndex(const LLMimeIndex& mime);
-
-	// @brief Destructor.
-	~LLMimeIndex();
-
-	/*
-	 * @breif Assignment operator.
-	 *
-	 * @param mime The other mime object.
-	 * @return Returns this after assignment.
-	 */
-	LLMimeIndex& operator=(const LLMimeIndex& mime);
-
-	/** 
-	 * @brief Add attachment information as a sub-part to a multipart mime.
-	 *
-	 * @param sub_part the part to attach.
-	 * @return Returns true on success, false on failure.
-	 */
-	bool attachSubPart(LLMimeIndex sub_part);
-	//@}
-
-protected:
-	// Implementation.
-	class Impl;
-	Impl* mImpl;
-};
-
-
-/** 
- * @class LLMimeParser
- * @brief This class implements a MIME parser and verifier.
- *
- * THOROUGH_DESCRIPTION
- */
-class LLMimeParser
-{
-public:
-	// @brief Make a new mime parser.
-	LLMimeParser();
-	
-	// @brief Mime parser Destructor.
-	~LLMimeParser();
-
-	// @brief Reset internal state of this parser.
-	void reset();
-
-	
-	/* @name Index generation interface.
-	 */
-	//@{
-	/** 
-	 * @brief Parse a stream to find the mime index information.
-	 *
-	 * This method will scan the istr until a single complete mime
-	 * entity is read or EOF. The istr will be modified by this
-	 * parsing, so pass in a temporary stream or rewind/reset the
-	 * stream after this call.
-	 * @param istr An istream which contains a mime entity.
-	 * @param index[out] The parsed output.
-	 * @return Returns true if an index was parsed and no errors occurred.
-	 */
-	bool parseIndex(std::istream& istr, LLMimeIndex& index);
-
-	/** 
-	 * @brief Parse a vector to find the mime index information.
-	 *
-	 * @param buffer A vector with data to parse.
-	 * @param index[out] The parsed output.
-	 * @return Returns true if an index was parsed and no errors occurred.
-	 */
-	bool parseIndex(const std::vector<U8>& buffer, LLMimeIndex& index);
-
-	/** 
-	 * @brief Parse a stream to find the mime index information.
-	 *
-	 * This method will scan the istr until a single complete mime
-	 * entity is read, an EOF, or limit bytes have been scanned. The
-	 * istr will be modified by this parsing, so pass in a temporary
-	 * stream or rewind/reset the stream after this call.
-	 * @param istr An istream which contains a mime entity.
-	 * @param limit The maximum number of bytes to scan.
-	 * @param index[out] The parsed output.
-	 * @return Returns true if an index was parsed and no errors occurred.
-	 */
-	bool parseIndex(std::istream& istr, S32 limit, LLMimeIndex& index);
-
-	/** 
-	 * @brief Parse a memory bufffer to find the mime index information.
-	 *
-	 * @param buffer The start of the buffer to parse.
-	 * @param buffer_length The length of the buffer.
-	 * @param index[out] The parsed output.
-	 * @return Returns true if an index was parsed and no errors occurred.
-	 */
-	bool parseIndex(const U8* buffer, S32 buffer_length, LLMimeIndex& index);
-	//@}
-
-	/** 
-	 * @brief 
-	 *
-	 * @return
-	 */
-	//bool verify(std::istream& istr, LLMimeIndex& index) const;
-
-	/** 
-	 * @brief 
-	 *
-	 * @return
-	 */
-	//bool verify(U8* buffer, S32 buffer_length, LLMimeIndex& index) const;
-
-protected:
-	// Implementation.
-	class Impl;
-	Impl& mImpl;
-
-private:
-	// @brief Not implemneted to prevent copy consturction.
-	LLMimeParser(const LLMimeParser& parser);
-
-	// @brief Not implemneted to prevent assignment.
-	LLMimeParser& operator=(const LLMimeParser& mime);
-};
-
-#endif // LL_LLMIME_H

indra/llmessage/llnamevalue.cpp

@@ -31,7 +31,6 @@
 
 #include "llnamevalue.h"
 
-#include "u64.h"
 #include "llstring.h"
 #include "llstringtable.h"
 
@@ -149,7 +148,7 @@ void LLNameValue::init(const char *name, const char *data, const char *type, con
 	else if (!strcmp(mStringType, "U64"))
 	{
 		mType = NVT_U64;
-		mNameValueReference.u64 = new U64(str_to_U64(ll_safe_string(data)));
+		mNameValueReference.u64 = new U64(std::stoull(data));
 	}
 	else if (!strcmp(mStringType, "VEC3"))
 	{
@@ -919,9 +918,7 @@ std::string LLNameValue::printData() const
 		break;
 	case NVT_U64:
 		{
-			char u64_string[U64_BUFFER_LEN];	/* Flawfinder: ignore */
-			U64_to_str(*mNameValueReference.u64, u64_string, sizeof(u64_string));
-			buffer = u64_string;
+			buffer = fmt::to_string(*mNameValueReference.u64);
 		}
 		break;
 	case NVT_VEC3:
@@ -952,11 +949,7 @@ std::ostream&		operator<<(std::ostream& s, const LLNameValue &a)
 		s << *(a.mNameValueReference.u32);
 		break;
 	case NVT_U64:
-		{
-			char u64_string[U64_BUFFER_LEN];	/* Flawfinder: ignore */
-			U64_to_str(*a.mNameValueReference.u64, u64_string, sizeof(u64_string));
-			s << u64_string;
-		}
+		s << (*a.mNameValueReference.u64);
 		break;
 	case NVT_VEC3:
 		s << *(a.mNameValueReference.vec3);

indra/llmessage/llxfer.cpp

@@ -30,7 +30,6 @@
 #include "lluuid.h"
 #include "llerror.h"
 #include "llmath.h"
-#include "u64.h"
 
 //number of bytes sent in each message
 const U32 LL_XFER_CHUNK_SIZE = 1000;
@@ -347,12 +346,12 @@ void LLXfer::abort (S32 result_code)
 
 	if (result_code != LL_ERR_CIRCUIT_GONE)
 	{
-	gMessageSystem->newMessageFast(_PREHASH_AbortXfer);
-	gMessageSystem->nextBlockFast(_PREHASH_XferID);
-	gMessageSystem->addU64Fast(_PREHASH_ID, mID);
-	gMessageSystem->addS32Fast(_PREHASH_Result, result_code);
-	
-	gMessageSystem->sendMessage(mRemoteHost);
+		gMessageSystem->newMessageFast(_PREHASH_AbortXfer);
+		gMessageSystem->nextBlockFast(_PREHASH_XferID);
+		gMessageSystem->addU64Fast(_PREHASH_ID, mID);
+		gMessageSystem->addS32Fast(_PREHASH_Result, result_code);
+
+		gMessageSystem->sendMessage(mRemoteHost);
 	}
 
 	mStatus = e_LL_XFER_ABORTED;
@@ -363,7 +362,7 @@ void LLXfer::abort (S32 result_code)
 
 std::string LLXfer::getFileName() 
 {
-	return U64_to_str(mID);
+	return fmt::to_string(mID);
 }
 
 ///////////////////////////////////////////////////////////

indra/llmessage/llxfermanager.cpp

@@ -35,7 +35,6 @@
 
 #include "llerror.h"
 #include "lluuid.h"
-#include "u64.h"
 
 const F32 LL_XFER_REGISTRATION_TIMEOUT = 60.0f;  // timeout if a registered transfer hasn't been requested in 60 seconds
 const F32 LL_PACKET_TIMEOUT = 3.0f;             // packet timeout at 3 s
@@ -543,11 +542,10 @@ void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user
 	if (fdata_size < 0 ||
 		fdata_size > BUF_SIZE)
 	{
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
 		LL_WARNS("Xfer") << "Received invalid xfer data size of " << fdata_size
 			<< " in packet number " << packetnum 
 			<< " from " << mesgsys->getSender()
-			<< " for xfer id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF)) 
+			<< " for xfer id: " << fmt::to_string(id) 
 			<< LL_ENDL;
 		return;
 	}
@@ -556,10 +554,9 @@ void LLXferManager::processReceiveData (LLMessageSystem *mesgsys, void ** /*user
 	xferp = findXferByID(id, mReceiveList);
 	if (!xferp)
 	{
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
 		LL_WARNS("Xfer") << "received xfer data from " << mesgsys->getSender()
 			<< " for non-existent xfer id: "
-			<< U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << LL_ENDL;
+			<< fmt::to_string(id) << LL_ENDL;
 		return;
 	}
 
@@ -765,8 +762,7 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 	mesgsys->getBOOL("XferID", "UseBigPackets", b_use_big_packets);
 	
 	mesgsys->getU64Fast(_PREHASH_XferID, _PREHASH_ID, id);
-	char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
-	LL_INFOS("Xfer") << "xfer request id: " << U64_to_str(id, U64_BUF, sizeof(U64_BUF))
+	LL_INFOS("Xfer") << "xfer request id: " << fmt::to_string(id)
 		   << " to " << mesgsys->getSender() << LL_ENDL;
 
 	mesgsys->getStringFast(_PREHASH_XferID, _PREHASH_Filename, local_filename);
@@ -890,9 +886,8 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 	}
 	else
 	{	// no uuid or filename - use the ID sent
-		char U64_BUF[MAX_STRING];		/* Flawfinder : ignore */
 		LL_INFOS("Xfer") << "starting memory transfer: "
-			<< U64_to_str(id, U64_BUF, sizeof(U64_BUF)) << " to "
+			<< fmt::to_string(id) << " to "
 			<< mesgsys->getSender() << LL_ENDL;
 
 		xferp = findXferByID(id, mSendList);
@@ -903,7 +898,7 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 		}
 		else
 		{
-			LL_INFOS("Xfer") << "Warning: xfer ID " << U64_BUF << " not found." << LL_ENDL;
+			LL_INFOS("Xfer") << "Warning: xfer ID " << fmt::to_string(id) << " not found." << LL_ENDL;
 			result = LL_ERR_FILE_NOT_FOUND;
 		}
 	}
@@ -937,12 +932,12 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 			{	// Not many transfers in progress already, so start immediately
 				xferp->sendNextPacket();
 				changeNumActiveXfers(xferp->mRemoteHost,1);
-				LL_DEBUGS("Xfer") << "Starting xfer ID " << U64_to_str(id) << " immediately" << LL_ENDL;
+				LL_DEBUGS("Xfer") << "Starting xfer ID " << fmt::to_string(id) << " immediately" << LL_ENDL;
 			}
 			else if (mHardLimitOutgoingXfersPerCircuit == 0 ||
 				     (host_statusp->mNumActive + host_statusp->mNumPending) < mHardLimitOutgoingXfersPerCircuit)
 			{	// Must close the file handle and wait for earlier ones to complete
-				LL_INFOS("Xfer") << "  queueing xfer request id " << U64_to_str(id) << ", " 
+				LL_INFOS("Xfer") << "  queueing xfer request id " << fmt::to_string(id) << ", "
 								 << host_statusp->mNumActive << " active and "
 								 << host_statusp->mNumPending << " pending ahead of this one" 
 								 << LL_ENDL;
@@ -983,13 +978,13 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
 		}
 		else
 		{
-			LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no LLHostStatus found for id " << U64_to_str(id)	
+			LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no LLHostStatus found for id " << fmt::to_string(id)
 				<< " host " << xferp->mRemoteHost << LL_ENDL;
 		}
 	}
 	else
 	{
-		LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no xfer found for id " << U64_to_str(id)	<< LL_ENDL;
+		LL_WARNS("Xfer") << "LLXferManager::processFileRequest() - no xfer found for id " << fmt::to_string(id)	<< LL_ENDL;
 	}
 }
  
@@ -1113,7 +1108,7 @@ void LLXferManager::retransmitUnackedPackets()
 			{
 				if (xferp->reopenFileHandle())
 				{
-					LL_WARNS("Xfer") << "Error re-opening file handle for xfer ID " << U64_to_str(xferp->mID)
+					LL_WARNS("Xfer") << "Error re-opening file handle for xfer ID " << fmt::to_string(xferp->mID)
 						<< " to host " << xferp->mRemoteHost << LL_ENDL;
 					xferp->abort(LL_ERR_CANNOT_OPEN_FILE);
 					iter = mSendList.erase(iter);
@@ -1122,7 +1117,7 @@ void LLXferManager::retransmitUnackedPackets()
 				}
 				else
 				{	// No error re-opening the file, send the first packet
-					LL_DEBUGS("Xfer") << "Moving pending xfer ID " << U64_to_str(xferp->mID) << " to active" << LL_ENDL;
+					LL_DEBUGS("Xfer") << "Moving pending xfer ID " << fmt::to_string(xferp->mID) << " to active" << LL_ENDL;
 					xferp->sendNextPacket();
 					changeNumActiveXfers(xferp->mRemoteHost,1);
 				}
@@ -1136,7 +1131,7 @@ void LLXferManager::retransmitUnackedPackets()
 	// so we don't blow through bandwidth.
 	//
 
-	while (mXferAckQueue.size())
+	while (!mXferAckQueue.empty())
 	{
 		if (mAckThrottle.checkOverflow(1000.0f*8.0f))
 		{

indra/llmessage/message.cpp

@@ -73,7 +73,6 @@
 #include "llxfermanager.h"
 #include "timing.h"
 #include "llquaternion.h"
-#include "u64.h"
 #include "v3dmath.h"
 #include "v3math.h"
 #include "v4math.h"
@@ -2600,54 +2599,54 @@ void LLMessageSystem::summarizeLogs(std::ostream& str)
 
 	// Incoming
 	str << buffer << std::endl << "Incoming:" << std::endl;
-	tmp_str = U64_to_str(mTotalBytesIn);
+	tmp_str = fmt::to_string(mTotalBytesIn);
 	buffer = llformat( "Total bytes received:      %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesIn * 0.008f) / run_time);
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mPacketsIn);
+	tmp_str = fmt::to_string(mPacketsIn);
 	buffer = llformat( "Total packets received:    %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32) mPacketsIn / run_time));
 	str << buffer << std::endl;
 	buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesIn / (F32)mPacketsIn);
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mReliablePacketsIn);
+	tmp_str = fmt::to_string(mReliablePacketsIn);
 	buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsIn)/((F32) mPacketsIn + 1));
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mCompressedPacketsIn);
+	tmp_str = fmt::to_string(mCompressedPacketsIn);
 	buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsIn)/((F32) mPacketsIn + 1));
 	str << buffer << std::endl;
 	S64 savings = mUncompressedBytesIn - mCompressedBytesIn;
-	tmp_str = U64_to_str(savings);
+	tmp_str = fmt::to_string(savings);
 	buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(savings/(mCompressedPacketsIn +1));
+	tmp_str = fmt::to_string(savings/(mCompressedPacketsIn +1));
 	buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesIn)/((F32) mCompressedBytesIn+1));
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(savings/(mPacketsIn+1));
+	tmp_str = fmt::to_string(savings/(mPacketsIn+1));
 	buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesIn + (F32) savings)/((F32) mTotalBytesIn + 1.f));
 
 	// Outgoing
 	str << buffer << std::endl << std::endl << "Outgoing:" << std::endl;
-	tmp_str = U64_to_str(mTotalBytesOut);
+	tmp_str = fmt::to_string(mTotalBytesOut);
 	buffer = llformat( "Total bytes sent:          %20s (%5.2f kbits per second)", tmp_str.c_str(), ((F32)mTotalBytesOut * 0.008f) / run_time );
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mPacketsOut);
+	tmp_str = fmt::to_string(mPacketsOut);
 	buffer = llformat( "Total packets sent:        %20s (%5.2f packets per second)", tmp_str.c_str(), ((F32)mPacketsOut / run_time));
 	str << buffer << std::endl;
 	buffer = llformat( "Average packet size:       %20.0f bytes", (F32)mTotalBytesOut / (F32)mPacketsOut);
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mReliablePacketsOut);
+	tmp_str = fmt::to_string(mReliablePacketsOut);
 	buffer = llformat( "Total reliable packets:    %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mReliablePacketsOut)/((F32) mPacketsOut + 1));
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(mCompressedPacketsOut);
+	tmp_str = fmt::to_string(mCompressedPacketsOut);
 	buffer = llformat( "Total compressed packets:  %20s (%5.2f%%)", tmp_str.c_str(), 100.f * ((F32) mCompressedPacketsOut)/((F32) mPacketsOut + 1));
 	str << buffer << std::endl;
 	savings = mUncompressedBytesOut - mCompressedBytesOut;
-	tmp_str = U64_to_str(savings);
+	tmp_str = fmt::to_string(savings);
 	buffer = llformat( "Total compression savings: %20s bytes", tmp_str.c_str());
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(savings/(mCompressedPacketsOut +1));
+	tmp_str = fmt::to_string(savings/(mCompressedPacketsOut +1));
 	buffer = llformat( "Avg comp packet savings:   %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mUncompressedBytesOut)/((F32) mCompressedBytesOut+1));
 	str << buffer << std::endl;
-	tmp_str = U64_to_str(savings/(mPacketsOut+1));
+	tmp_str = fmt::to_string(savings/(mPacketsOut+1));
 	buffer = llformat( "Avg overall comp savings:  %20s (%5.2f : 1)", tmp_str.c_str(), ((F32) mTotalBytesOut + (F32) savings)/((F32) mTotalBytesOut + 1.f));
 	str << buffer << std::endl << std::endl;
 	buffer = llformat( "SendPacket failures:       %20d", mSendPacketFailureCount);

indra/llmessage/tests/llmime_test.cpp

@@ -1,445 +0,0 @@
-/** 
- * @file llmime_test.cpp
- * @author Phoenix
- * @date 2006-12-24
- * @brief BRIEF_DESC of llmime_test.cpp
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llsdserialize.h"
-
-#include "../llmime.h"
-
-#include "../test/lltut.h"
-
-namespace tut
-{
-	struct mime_index
-	{
-	};
-	typedef test_group<mime_index> mime_index_t;
-	typedef mime_index_t::object mime_index_object_t;
-	tut::mime_index_t tut_mime_index("LLMime");
-
-	template<> template<>
-	void mime_index_object_t::test<1>()
-	{
-		LLMimeIndex mime;
-		ensure("no headers", mime.headers().isUndefined());
-		ensure_equals("invalid offset", mime.offset(), -1);
-		ensure_equals("invalid content length", mime.contentLength(), -1);
-		ensure("no content type", mime.contentType().empty());
-		ensure("not multipart", !mime.isMultipart());
-		ensure_equals("no attachments", mime.subPartCount(), 0);
-	}
-
-	template<> template<>
-	void mime_index_object_t::test<2>()
-	{
-		const S32 CONTENT_LENGTH = 6000;
-		const S32 CONTENT_OFFSET = 100;
-		const std::string CONTENT_TYPE = std::string("image/j2c");
-		LLSD headers;
-		headers["Content-Length"] = CONTENT_LENGTH;
-		headers["Content-Type"] = CONTENT_TYPE;
-		LLMimeIndex mime(headers, CONTENT_OFFSET);
-		ensure("headers are map", mime.headers().isMap());
-		ensure_equals("offset", mime.offset(), CONTENT_OFFSET);
-		ensure_equals("content length", mime.contentLength(), CONTENT_LENGTH);
-		ensure_equals("type is image/j2c", mime.contentType(), CONTENT_TYPE);
-		ensure("not multipart", !mime.isMultipart());
-		ensure_equals("no attachments", mime.subPartCount(), 0);
-	}
-
-	template<> template<>
-	void mime_index_object_t::test<3>()
-	{
-		const S32 MULTI_CONTENT_LENGTH = 8000;
-		const S32 MULTI_CONTENT_OFFSET = 100;
-		const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
-		LLSD headers;
-		headers["Content-Length"] = MULTI_CONTENT_LENGTH;
-		headers["Content-Type"] = MULTI_CONTENT_TYPE;
-		LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
-		LL_INFOS() << "headers: " << LLSDOStreamer<LLSDNotationFormatter>(headers)
-			<< LL_ENDL;
-
-
-		const S32 META_CONTENT_LENGTH = 700;
-		const S32 META_CONTENT_OFFSET = 69;
-		const std::string META_CONTENT_TYPE = std::string(
-			"text/llsd+xml");
-		headers = LLSD::emptyMap();
-		headers["Content-Length"] = META_CONTENT_LENGTH;
-		headers["Content-Type"] = META_CONTENT_TYPE;
-		LLMimeIndex meta(headers, META_CONTENT_OFFSET);
-		mime.attachSubPart(meta);
-
-		const S32 IMAGE_CONTENT_LENGTH = 6000;
-		const S32 IMAGE_CONTENT_OFFSET = 200;
-		const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
-		headers = LLSD::emptyMap();
-		headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
-		headers["Content-Type"] = IMAGE_CONTENT_TYPE;
-		LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
-		mime.attachSubPart(image);
-
-		// make sure we have a valid multi-part
-		ensure("is multipart", mime.isMultipart());
-		ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
-		ensure_equals(
-			"multi content length",
-			mime.contentLength(),
-			MULTI_CONTENT_LENGTH);
-		ensure_equals("two attachments", mime.subPartCount(), 2);
-
-		// make sure ranged gets do the right thing with out of bounds
-		// sub-parts.
-		LLMimeIndex invalid_child(mime.subPart(-1));
-		ensure("no headers", invalid_child.headers().isUndefined());
-		ensure_equals("invalid offset", invalid_child.offset(), -1);
-		ensure_equals(
-			"invalid content length", invalid_child.contentLength(), -1);
-		ensure("no content type", invalid_child.contentType().empty());
-		ensure("not multipart", !invalid_child.isMultipart());
-		ensure_equals("no attachments", invalid_child.subPartCount(), 0);
-
-		invalid_child = mime.subPart(2);
-		ensure("no headers", invalid_child.headers().isUndefined());
-		ensure_equals("invalid offset", invalid_child.offset(), -1);
-		ensure_equals(
-			"invalid content length", invalid_child.contentLength(), -1);
-		ensure("no content type", invalid_child.contentType().empty());
-		ensure("not multipart", !invalid_child.isMultipart());
-		ensure_equals("no attachments", invalid_child.subPartCount(), 0);
-	}
-
-	template<> template<>
-	void mime_index_object_t::test<4>()
-	{
-		const S32 MULTI_CONTENT_LENGTH = 8000;
-		const S32 MULTI_CONTENT_OFFSET = 100;
-		const std::string MULTI_CONTENT_TYPE = std::string("multipart/mixed");
-		LLSD headers;
-		headers["Content-Length"] = MULTI_CONTENT_LENGTH;
-		headers["Content-Type"] = MULTI_CONTENT_TYPE;
-		LLMimeIndex mime(headers, MULTI_CONTENT_OFFSET);
-
-		const S32 META_CONTENT_LENGTH = 700;
-		const S32 META_CONTENT_OFFSET = 69;
-		const std::string META_CONTENT_TYPE = std::string(
-			"application/llsd+xml");
-		headers = LLSD::emptyMap();
-		headers["Content-Length"] = META_CONTENT_LENGTH;
-		headers["Content-Type"] = META_CONTENT_TYPE;
-		LLMimeIndex meta(headers, META_CONTENT_OFFSET);
-		mime.attachSubPart(meta);
-
-		const S32 IMAGE_CONTENT_LENGTH = 6000;
-		const S32 IMAGE_CONTENT_OFFSET = 200;
-		const std::string IMAGE_CONTENT_TYPE = std::string("image/j2c");
-		headers = LLSD::emptyMap();
-		headers["Content-Length"] = IMAGE_CONTENT_LENGTH;
-		headers["Content-Type"] = IMAGE_CONTENT_TYPE;
-		LLMimeIndex image(headers, IMAGE_CONTENT_OFFSET);
-		mime.attachSubPart(image);
-
-		// check what we have
-		ensure("is multipart", mime.isMultipart());
-		ensure_equals("multi offset", mime.offset(), MULTI_CONTENT_OFFSET);
-		ensure_equals(
-			"multi content length",
-			mime.contentLength(),
-			MULTI_CONTENT_LENGTH);
-		ensure_equals("two attachments", mime.subPartCount(), 2);
-
-		LLMimeIndex actual_meta = mime.subPart(0);
-		ensure_equals(
-			"meta type", actual_meta.contentType(), META_CONTENT_TYPE);
-		ensure_equals(
-			"meta offset", actual_meta.offset(), META_CONTENT_OFFSET);
-		ensure_equals(
-			"meta content length",
-			actual_meta.contentLength(),
-			META_CONTENT_LENGTH);
-
-		LLMimeIndex actual_image = mime.subPart(1);
-		ensure_equals(
-			"image type", actual_image.contentType(), IMAGE_CONTENT_TYPE);
-		ensure_equals(
-			"image offset", actual_image.offset(), IMAGE_CONTENT_OFFSET);
-		ensure_equals(
-			"image content length",
-			actual_image.contentLength(),
-			IMAGE_CONTENT_LENGTH);
-	}
-
-/*
-	template<> template<>
-	void mime_index_object_t::test<5>()
-	{
-	}
-	template<> template<>
-	void mime_index_object_t::test<6>()
-	{
-	}
-	template<> template<>
-	void mime_index_object_t::test<7>()
-	{
-	}
-	template<> template<>
-	void mime_index_object_t::test<8>()
-	{
-	}
-	template<> template<>
-	void mime_index_object_t::test<>()
-	{
-	}
-*/
-}
-
-
-namespace tut
-{
-	struct mime_parse
-	{
-	};
-	typedef test_group<mime_parse> mime_parse_t;
-	typedef mime_parse_t::object mime_parse_object_t;
-	tut::mime_parse_t tut_mime_parse("LLMimeParse");
-
-	template<> template<>
-	void mime_parse_object_t::test<1>()
-	{
-		// parse one mime object
-		const std::string SERIALIZED_MIME("Content-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure_equals("content type", mime.contentType(), "text/plain");
-		ensure_equals("content length", mime.contentLength(), 200);
-		ensure_equals("offset", mime.offset(), 49);
- 	}
-
-	template<> template<>
-	void mime_parse_object_t::test<2>()
-	{
-		// make sure we only parse one.
-		const std::string SERIALIZED_MIME("Content-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n\r\nContent-Length: 200\r\nContent-Type: text/plain\r\n\r\naaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcccccccccc\r\n\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure("not multipart.", !mime.isMultipart());
-		ensure_equals("content type", mime.contentType(), "text/plain");
-		ensure_equals("content length", mime.contentLength(), 200);
-		ensure_equals("offset", mime.offset(), 49);
-	}
-
-	template<> template<>
-	void mime_parse_object_t::test<3>()
-	{
-		// test multi-part and lack of content length for some of it.
-		/*
-Content-Type: multipart/mixed; boundary="segment"rnContent-Length: 148rnrn--segmentrnContent-Type: text/plainrnrnsome datarnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
-		 */
-		const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=\"segment\"\r\nContent-Length: 150\r\n\r\n--segment\r\nContent-Type: text/plain\r\n\r\nsome data\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure("is multipart.", mime.isMultipart());
-		ensure_equals("sub-part count", mime.subPartCount(), 2);
-		ensure_equals("content length", mime.contentLength(), 150);
-		ensure_equals("data offset for multipart", mime.offset(), 74);
-
-		LLMimeIndex mime_plain(mime.subPart(0));
-		ensure_equals(
-			"first part type",
-			mime_plain.contentType(),
-			"text/plain");
-		ensure_equals(
-			"first part content length not known.",
-			mime_plain.contentLength(),
-			-1);
-		ensure_equals("first part offset", mime_plain.offset(), 113);
-
-		LLMimeIndex mime_xml(mime.subPart(1));
-		ensure_equals(
-			"second part type",
-			mime_xml.contentType(),
-			"text/xml; charset=UTF-8");
-		ensure_equals(
-			"second part content length",
-			mime_xml.contentLength(),
-			22);
-		ensure_equals("second part offset", mime_xml.offset(), 198);
-	}
-
-	template<> template<>
-	void mime_parse_object_t::test<4>()
-	{
-		// test multi-part, unquoted separator, and premature eof conditions
-		/*
-Content-Type: multipart/mixed; boundary=segmentrnContent-Length: 220rnrn--segmentrnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--segmentrnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn		 */
-		const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segment\r\nContent-Length: 220\r\n\r\n--segment\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure("is multipart.", mime.isMultipart());
-		ensure_equals("sub-part count", mime.subPartCount(), 2);
-		ensure_equals("content length", mime.contentLength(), 220);
-		ensure_equals("data offset for multipart", mime.offset(), 72);
-
-		LLMimeIndex mime_plain(mime.subPart(0));
-		ensure_equals(
-			"first part type",
-			mime_plain.contentType(),
-			"text/plain");
-		ensure_equals(
-			"first part content length",
-			mime_plain.contentLength(),
-			55);
-		ensure_equals("first part offset", mime_plain.offset(), 131);
-
-		LLMimeIndex mime_xml(mime.subPart(1));
-		ensure_equals(
-			"second part type",
-			mime_xml.contentType(),
-			"text/xml; charset=UTF-8");
-		ensure_equals(
-			"second part content length",
-			mime_xml.contentLength(),
-			22);
-		ensure_equals("second part offset", mime_xml.offset(), 262);
-	}
-
-	template<> template<>
-	void mime_parse_object_t::test<5>()
-	{
-		// test multi-part with multiple params
-		const std::string SERIALIZED_MIME("Content-Type: multipart/mixed; boundary=segment; comment=\"testing multiple params.\"\r\nContent-Length: 220\r\n\r\n--segment\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--segment\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure("is multipart.", mime.isMultipart());
-		ensure_equals("sub-part count", mime.subPartCount(), 2);
-		ensure_equals("content length", mime.contentLength(), 220);
-
-		LLMimeIndex mime_plain(mime.subPart(0));
-		ensure_equals(
-			"first part type",
-			mime_plain.contentType(),
-			"text/plain");
-		ensure_equals(
-			"first part content length",
-			mime_plain.contentLength(),
-			55);
-
-		LLMimeIndex mime_xml(mime.subPart(1));
-		ensure_equals(
-			"second part type",
-			mime_xml.contentType(),
-			"text/xml; charset=UTF-8");
-		ensure_equals(
-			"second part content length",
-			mime_xml.contentLength(),
-			22);
-	}
-
-	template<> template<>
-	void mime_parse_object_t::test<6>()
-	{
-		// test multi-part with no specified boundary and eof
-/*
-Content-Type: multipart/relatedrnContent-Length: 220rnrn--rnContent-Type: text/plainrnContent-Length: 55rnrnhow are you today?rnI do not know. I guess I am:n'fine'rnrn--rnContent-Type: text/xml; charset=UTF-8rnContent-Length: 22rnrn<llsd><undef /></llsd>rnrn
-*/
-		const std::string SERIALIZED_MIME("Content-Type: multipart/related\r\nContent-Length: 500\r\n\r\n--\r\nContent-Type: text/plain\r\nContent-Length: 55\r\n\r\nhow are you today?\r\nI do not know. I guess I am:\n'fine'\r\n\r\n--\r\nContent-Type: text/xml; charset=UTF-8\r\nContent-Length: 22\r\n\r\n<llsd><undef /></llsd>\r\n\r\n");
-		std::stringstream istr;
-		istr.str(SERIALIZED_MIME);
-		LLMimeIndex mime;
-		LLMimeParser parser;
-		bool ok = parser.parseIndex(istr, mime);
-		ensure("Parse successful.", ok);
-		ensure("is multipart.", mime.isMultipart());
-		ensure_equals("sub-part count", mime.subPartCount(), 2);
-		ensure_equals("content length", mime.contentLength(), 500);
-		ensure_equals("data offset for multipart", mime.offset(), 56);
-
-		LLMimeIndex mime_plain(mime.subPart(0));
-		ensure_equals(
-			"first part type",
-			mime_plain.contentType(),
-			"text/plain");
-		ensure_equals(
-			"first part content length",
-			mime_plain.contentLength(),
-			55);
-		ensure_equals("first part offset", mime_plain.offset(), 108);
-
-		LLMimeIndex mime_xml(mime.subPart(1));
-		ensure_equals(
-			"second part type",
-			mime_xml.contentType(),
-			"text/xml; charset=UTF-8");
-		ensure_equals(
-			"second part content length",
-			mime_xml.contentLength(),
-			22);
-		ensure_equals("second part offset", mime_xml.offset(), 232);
-	}
-
-/*
-	template<> template<>
-	void mime_parse_object_t::test<>()
-	{
-	}
-	template<> template<>
-	void mime_parse_object_t::test<>()
-	{
-	}
-	template<> template<>
-	void mime_parse_object_t::test<>()
-	{
-	}
-	template<> template<>
-	void mime_parse_object_t::test<>()
-	{
-	}
-*/
-}

indra/llmessage/tests/test_llsdmessage_peer.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file   test_llsdmessage_peer.py
 @author Nat Goodspeed

indra/llmessage/tests/testrunner.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file   testrunner.py
 @author Nat Goodspeed

indra/llprimitive/lldaeloader.h

@@ -5,21 +5,21 @@
  * $LicenseInfo:firstyear=2013&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2013, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -42,13 +42,13 @@ class domMesh;
 class LLDAELoader : public LLModelLoader
 {
 public:
-	typedef std::map<std::string, LLImportMaterial>							material_map;
+	typedef std::map<std::string, LLImportMaterial>						material_map;
 	typedef std::map<daeElement*, std::vector<LLPointer<LLModel> > >	dae_model_map;
-	dae_model_map	mModelsMap;
+	dae_model_map 														mModelsMap;
 
 	LLDAELoader(
-		std::string									filename,
-		S32											lod, 
+		std::string 						filename,
+		S32									lod,
 		LLModelLoader::load_callback_t		load_cb,
 		LLModelLoader::joint_lookup_func_t	joint_lookup_func,
 		LLModelLoader::texture_load_func_t	texture_load_func,
@@ -56,41 +56,40 @@ public:
 		void*								opaque_userdata,
 		JointTransformMap&					jointTransformMap,
 		JointNameSet&						jointsFromNodes,
-		std::map<std::string, std::string>&	jointAliasMap,
+		std::map<std::string, std::string>& jointAliasMap,
 		U32									maxJointsPerMesh,
 		U32									modelLimit,
 		bool								preprocess);
-	virtual ~LLDAELoader() ;
+	virtual ~LLDAELoader();
 
 	virtual bool OpenFile(const std::string& filename);
 
 protected:
 
-	void processElement(daeElement* element, bool& badElement, DAE* dae);
+	void processElement(daeElement* element, bool& badElement, DAE* dae, daeElement* domRoot);
 	void processDomModel(LLModel* model, DAE* dae, daeElement* pRoot, domMesh* mesh, domSkin* skin);
 
-	material_map getMaterials(LLModel* model, domInstance_geometry* instance_geo, DAE* dae);
-	LLImportMaterial profileToMaterial(domProfile_COMMON* material, DAE* dae);	
-	LLColor4 getDaeColor(daeElement* element);
-	
-	daeElement* getChildFromElement( daeElement* pElement, std::string const & name );
-	
-	bool isNodeAJoint( domNode* pNode );
-	void processJointNode( domNode* pNode, std::map<std::string,LLMatrix4>& jointTransforms );
-	void extractTranslation( domTranslate* pTranslate, LLMatrix4& transform );
-	void extractTranslationViaElement( daeElement* pTranslateElement, LLMatrix4& transform );
-	void extractTranslationViaSID( daeElement* pElement, LLMatrix4& transform );
-	void buildJointToNodeMappingFromScene( daeElement* pRoot );
-	void processJointToNodeMapping( domNode* pNode );
-	void processChildJoints( domNode* pParentNode );
+	material_map getMaterials(LLModel* model, domInstance_geometry* instance_geo, DAE* dae) const;
+	LLImportMaterial profileToMaterial(domProfile_COMMON* material, DAE* dae) const;
+	LLColor4 getDaeColor(daeElement* element) const;
 
-	bool verifyCount( int expected, int result );
+	daeElement* getChildFromElement(daeElement* pElement, std::string const& name);
+
+	bool isNodeAJoint(const domNode* pNode) const;
+	void processJointNode(domNode* pNode, JointTransformMap& jointTransforms);
+	void extractTranslation(const domTranslate* pTranslate, LLMatrix4& transform) const;
+	void extractTranslationViaSID(daeElement* pElement, LLMatrix4& transform) const;
+	void buildJointToNodeMappingFromScene(daeElement* pRoot);
+	void processJointToNodeMapping(domNode* pNode);
+	void processChildJoints(domNode* pParentNode);
+
+	bool verifyCount(const size_t expected, const size_t result) const;
 
 	//Verify that a controller matches vertex counts
-	bool verifyController( domController* pController );
+	bool verifyController(const domController* pController) const;
 
 	static bool addVolumeFacesFromDomMesh(LLModel* model, domMesh* mesh);
-	static bool createVolumeFacesFromDomMesh(LLModel* model, domMesh *mesh);
+	static bool createVolumeFacesFromDomMesh(LLModel* model, domMesh* mesh);
 
 	static LLModel* loadModelFromDomMesh(domMesh* mesh);
 
@@ -99,11 +98,11 @@ protected:
 	//
 	bool loadModelsFromDomMesh(domMesh* mesh, std::vector<LLModel*>& models_out, U32 submodel_limit);
 
-	static std::string getElementLabel(daeElement *element);
-	static size_t getSuffixPosition(std::string label);
-	static std::string getLodlessLabel(daeElement *element);
+	static std::string getElementLabel(daeElement* element);
+	static size_t getSuffixPosition(const std::string label);
+	static std::string getLodlessLabel(daeElement* element);
 
-	static std::string preprocessDAE(std::string filename);
+	static std::string preprocessDAE(const std::string filename);
 
 private:
 	U32 mGeneratedModelLimit; // Attempt to limit amount of generated submodels

indra/llprimitive/llmodelloader.h

@@ -99,7 +99,7 @@ public:
 	
 	S32 mLod;
 	
-	LLMatrix4 mTransform;
+	LLMatrix4 mTransform, mBindTransform;
 	BOOL mFirstTransform;
 	LLVector3 mExtents[2];
 	
@@ -180,7 +180,7 @@ public:
 	//-----------------------------------------------------------------------------
 	// isNodeAJoint()
 	//-----------------------------------------------------------------------------
-	bool isNodeAJoint(const char* name)
+	bool isNodeAJoint(const char* name) const
 	{
 		return name != NULL && mJointMap.find(name) != mJointMap.end();
 	}

indra/llrender/llrender.cpp

@@ -2146,7 +2146,7 @@ void LLRender::setLineWidth(F32 line_width)
 	}
 	if (mNewContext.lineWidth != line_width || mDirty)
 	{
-		if (mMode == LLRender::LINES || LLRender::LINE_STRIP)
+		if (mMode == LLRender::LINES || mMode == LLRender::LINE_STRIP)
 		{
 			flush();
 		}
@@ -2483,16 +2483,17 @@ void LLRender::vertexBatchPreTransformed(LLVector4a* verts, S32 vert_count)
 		mTexcoordsp[mCount] = mTexcoordsp[mCount - 1];
 	}
 
+	mVerticesp.copyArray(mCount, verts, vert_count);
+
 	for (S32 i = 0; i < vert_count; i++)
 	{
-		mVerticesp[mCount] = verts[i];
-
 		mCount++;
 		mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
 		mColorsp[mCount] = mColorsp[mCount-1];
 	}
 
-	mVerticesp[mCount] = mVerticesp[mCount-1];
+	if (mCount > 0) // ND: Guard against crashes if mCount is zero, yes it can happen
+		mVerticesp[mCount] = mVerticesp[mCount-1];
 
 	mPrimitiveReset = false;
 }
@@ -2520,17 +2521,20 @@ void LLRender::vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, S32
 		mTexcoordsp[mCount] = mTexcoordsp[mCount - 1];
 	}
 
+	mVerticesp.copyArray(mCount, verts, vert_count);
+	mTexcoordsp.copyArray(mCount, uvs, vert_count);
+
 	for (S32 i = 0; i < vert_count; i++)
 	{
-		mVerticesp[mCount] = verts[i];
-		mTexcoordsp[mCount] = uvs[i];
-
 		mCount++;
 		mColorsp[mCount] = mColorsp[mCount-1];
 	}
-	
-	mVerticesp[mCount] = mVerticesp[mCount-1];
-	mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+
+	if (mCount > 0)
+	{
+		mVerticesp[mCount] = mVerticesp[mCount - 1];
+		mTexcoordsp[mCount] = mTexcoordsp[mCount - 1];
+	}
 
 	mPrimitiveReset = false;
 }
@@ -2564,9 +2568,12 @@ void LLRender::vertexBatchPreTransformed(LLVector4a* verts, LLVector2* uvs, LLCo
 	mColorsp.copyArray(mCount, colors, vert_count);
 	mCount += vert_count;
 
-	mVerticesp[mCount] = mVerticesp[mCount-1];
-	mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-	mColorsp[mCount] = mColorsp[mCount-1];
+	if (mCount > 0)
+	{
+		mVerticesp[mCount] = mVerticesp[mCount - 1];
+		mTexcoordsp[mCount] = mTexcoordsp[mCount - 1];
+		mColorsp[mCount] = mColorsp[mCount - 1];
+	}
 
 	mPrimitiveReset = false;
 }

indra/llrender/llvertexbuffer.cpp

@@ -1197,6 +1197,10 @@ void LLVertexBuffer::genBuffer(U32 size)
 	{
 		mMappedData = sDynamicVBOPool.allocate(mGLBuffer, mSize);
 	}
+	if ((sDisableVBOMapping || mUsage != GL_DYNAMIC_DRAW_ARB) && !mMappedData)
+	{
+		LL_ERRS() << "mMappedData allocation failedd" << LL_ENDL;
+	}
 	
 	sGLCount++;
 }
@@ -1213,6 +1217,10 @@ void LLVertexBuffer::genIndices(U32 size)
 	{
 		mMappedIndexData = sDynamicIBOPool.allocate(mGLIndices, mIndicesSize);
 	}
+	if ((sDisableVBOMapping || mUsage != GL_DYNAMIC_DRAW_ARB) && !mMappedIndexData)
+	{
+		LL_ERRS() << "mMappedIndexData allocation failedd" << LL_ENDL;
+	}
 	
 	sGLCount++;
 }
@@ -1848,6 +1856,7 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 			LL_ERRS() << "Attempted to map a specific range of a buffer that was already mapped." << LL_ENDL;
 		}
 
+		bool was_locked = mIndexLocked;
 		if (!mIndexLocked)
 		{
 			mIndexLocked = true;
@@ -1942,6 +1951,10 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
 
 				LL_ERRS() << "glMapBuffer returned NULL (no index data)" << LL_ENDL;
 			}
+			else if (was_locked)
+			{
+				LL_ERRS() << "mIndexLocked was true but no Index data allocated" << LL_ENDL;
+			}
 			else
 			{
 				LL_ERRS() << "memory allocation for Index data failed. " << LL_ENDL;

indra/llui/lllineeditor.cpp

@@ -2475,7 +2475,7 @@ BOOL LLLineEditor::evaluateFloat()
 		else
 		{
 			// Replace the expression with the result
-			std::string result_str = llformat("%f", result);
+			std::string result_str = fmt::to_string(result);
 			setText(result_str);
 			selectAll();
 		}

indra/llui/llnotifications.cpp

@@ -74,8 +74,9 @@ private:
 	bool historyHandler(const LLSD& payload)
 	{
 		// we ignore "load" messages, but rewrite the persistence file on any other
+		// onDelete handes "delete" message, so skip that too.
 		std::string sigtype = payload["sigtype"];
-		if (sigtype != "load")
+		if (sigtype != "load" && sigtype !=  "delete")
 		{
 			savePersistentNotifications();
 		}
@@ -85,11 +86,15 @@ private:
 	// The history channel gets all notifications except those that have been cancelled
 	static bool historyFilter(LLNotificationPtr pNotification)
 	{
-		return !pNotification->isCancelled();
+		return pNotification->isPersistent() && !pNotification->isCancelled() && !pNotification->isRespondedTo() && !pNotification->isExpired();
 	}
 
 	void savePersistentNotifications()
 	{
+		if (mLoading)
+		{
+			return;
+		}
 		LL_INFOS() << "Saving open notifications to " << mFileName << LL_ENDL;
 
 		llofstream notify_file(mFileName.c_str());
@@ -104,6 +109,9 @@ private:
 		LLSD& data = output["data"];
 
 		AILOCK_mItems;
+
+		static LLCachedControl<S32> maxPersistentNotificaitons("MaxPersistentNotifications");
+
 		for (LLNotificationSet::iterator it = mItems.begin(); it != mItems.end(); ++it)
 		{
 			if (!LLNotificationTemplates::instance().templateExists((*it)->getName())) continue;
@@ -111,7 +119,15 @@ private:
 			// only store notifications flagged as persisting
 			LLNotificationTemplatePtr templatep = LLNotificationTemplates::instance().getTemplate((*it)->getName());
 			if (!templatep->mPersist) continue;
+			if ((*it)->isCancelled() || (*it)->isExpired() || (*it)->isRespondedTo()) continue;
 
+			if (data.size() >= maxPersistentNotificaitons)
+			{
+				LL_WARNS() << "Too many persistent notifications."
+					<< " Saved " << maxPersistentNotificaitons << " of " << mItems.size()
+					<< " persistent notifications." << LL_ENDL;
+				break;
+			}
 			data.append((*it)->asLLSD());
 		}
 
@@ -121,53 +137,75 @@ private:
 
 	void loadPersistentNotifications()
 	{
+		if (mLoading)
+		{
+			return;
+		}
+		mLoading = true;
 		LL_INFOS() << "Loading open notifications from " << mFileName << LL_ENDL;
 
-		llifstream notify_file(mFileName.c_str());
-		if (!notify_file.is_open()) 
+		while (true)
 		{
-			LL_WARNS() << "Failed to open " << mFileName << LL_ENDL;
-			return;
-		}
+			llifstream notify_file(mFileName.c_str());
+			if (!notify_file.is_open())
+			{
+				LL_WARNS() << "Failed to open " << mFileName << LL_ENDL;
+				break;
+			}
 
-		LLSD input;
-		LLPointer<LLSDParser> parser = new LLSDXMLParser();
-		if (parser->parse(notify_file, input, LLSDSerialize::SIZE_UNLIMITED) < 0)
-		{
-			LL_WARNS() << "Failed to parse open notifications" << LL_ENDL;
-			return;
-		}
+			LLSD input;
+			LLPointer<LLSDParser> parser = new LLSDXMLParser();
+			if (parser->parse(notify_file, input, LLSDSerialize::SIZE_UNLIMITED) < 0)
+			{
+				LL_WARNS() << "Failed to parse open notifications" << LL_ENDL;
+				break;
+			}
 
-		if (input.isUndefined()) return;
-		std::string version = input["version"];
-		if (version != NOTIFICATION_PERSIST_VERSION)
-		{
-			LL_WARNS() << "Bad open notifications version: " << version << LL_ENDL;
-			return;
-		}
-		LLSD& data = input["data"];
-		if (data.isUndefined()) return;
+			if (input.isUndefined()) return;
+			std::string version = input["version"];
+			if (version != NOTIFICATION_PERSIST_VERSION)
+			{
+				LL_WARNS() << "Bad open notifications version: " << version << LL_ENDL;
+				break;
+			}
+			LLSD& data = input["data"];
+			if (data.isUndefined()) break;
 
-		LLNotifications& instance = LLNotifications::instance();
-		for (LLSD::array_const_iterator notification_it = data.beginArray();
-			notification_it != data.endArray();
-			++notification_it)
-		{
-			instance.add(LLNotificationPtr(new LLNotification(*notification_it)));
+			S32 processed_notifications = 0;
+			static LLCachedControl<S32> maxPersistentNotificaitons("MaxPersistentNotifications");
+
+			LLNotifications& instance = LLNotifications::instance();
+			for (LLSD::array_const_iterator notification_it = data.beginArray();
+				notification_it != data.endArray();
+				++notification_it)
+			{
+				if (processed_notifications++ >= maxPersistentNotificaitons)
+				{
+					LL_WARNS() << "Too many persistent notifications."
+						<< " Processed " << maxPersistentNotificaitons << " of " << data.size() << " persistent notifications." << LL_ENDL;
+					break;
+				}
+				instance.add(LLNotificationPtr(new LLNotification(*notification_it)));
+				
+			}
+			break;
 		}
+		mLoading = false;
+		savePersistentNotifications();
 	}
 
 	//virtual
 	void onDelete(LLNotificationPtr pNotification)
 	{
-		// we want to keep deleted notifications in our log
-		AILOCK_mItems;
-		mItems.insert(pNotification);
-		
-		return;
+		{
+			AILOCK_mItems;
+			mItems.erase(pNotification); // Delete immediately.
+		}
+		savePersistentNotifications();
 	}
 	
 private:
+	bool mLoading = false;
 	std::string mFileName;
 };
 
@@ -277,6 +315,7 @@ LLNotificationForm::LLNotificationForm(const std::string& name, const LLXMLNodeP
 }
 
 LLNotificationForm::LLNotificationForm(const LLSD& sd)
+	: mIgnore(IGNORE_NO)
 {
 	if (sd.isArray())
 	{
@@ -904,9 +943,9 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
 		// if we have it in our list, pass on the delete, then delete it, else do nothing
 		if (wasFound)
 		{
+			onDelete(pNotification);
 			abortProcessing = mChanged(payload);
 			mItems.erase(pNotification);
-			onDelete(pNotification);
 		}
 	}
 	return abortProcessing;
@@ -1146,13 +1185,6 @@ void LLNotifications::createDefaultChannels()
 	LLNotificationChannel::buildChannel("Visible", "Ignore",
 		&LLNotificationFilters::includeEverything);
 
-	// create special history channel
-	//std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_PER_SL_ACCOUNT, "open_notifications.xml" );
-	// use ^^^ when done debugging notifications serialization
-	std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_USER_SETTINGS, "open_notifications.xml" );
-	// this isn't a leak, don't worry about the empty "new"
-	new LLNotificationHistoryChannel(notifications_log_file);
-
 	// connect action methods to these channels
 	LLNotifications::instance().getChannel("Expiration")->
 		connectChanged(boost::bind(&LLNotifications::expirationHandler, this, _1));
@@ -1164,6 +1196,14 @@ void LLNotifications::createDefaultChannels()
 		connectFailedFilter(&handleIgnoredNotification);
 }
 
+void LLNotifications::onLoginCompleted()
+{
+	// create special history channel
+	std::string notifications_log_file = gDirUtilp->getExpandedFilename ( LL_PATH_PER_SL_ACCOUNT, "singu_open_notifications_" + gHippoGridManager->getCurrentGrid()->getGridName() + ".xml");
+	// this isn't a leak, don't worry about the empty "new"
+	new LLNotificationHistoryChannel(notifications_log_file );
+}
+
 static std::string sStringSkipNextTime("Skip this dialog next time");
 static std::string sStringAlwaysChoose("Always choose this option");
 

indra/llui/llnotifications.h

@@ -796,6 +796,7 @@ public:
 	// OK to call more than once because it will reload
 	bool loadNotifications();
 	void createDefaultChannels();
+	void onLoginCompleted();
 
 	// we provide a collection of simple add notification functions so that it's reasonable to create notifications in one line
 	LLNotificationPtr add(const std::string& name,

indra/llui/llresmgr.cpp

@@ -414,7 +414,7 @@ void LLResMgr::getIntegerString( std::string& output, S32 input ) const
 		{
 			if (fraction == remaining_count)
 			{
-				fraction_string = llformat("%d", fraction);
+				fraction_string = fmt::to_string(fraction);
 			}
 			else
 			{

indra/llui/llscrolllistctrl.cpp

@@ -3201,7 +3201,7 @@ LLScrollListItem* LLScrollListCtrl::addRow(LLScrollListItem *new_item, const LLS
 		// empty columns strings index by ordinal
 		if (column.empty())
 		{
-			column = llformat("%d", col_index);
+			column = fmt::to_string(col_index);
 		}
 
 		LLScrollListColumn* columnp = getColumn(column);

indra/llwindow/llwindowsdl.cpp

@@ -45,12 +45,13 @@
 
 #if LL_GTK
 extern "C" {
-# include <gtk/gtk.h>
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
 #if GTK_CHECK_VERSION(2, 24, 0)
 #include <gdk/gdkx.h>
 #endif
 }
-#include <locale.h>
+#include <clocale>
 #endif // LL_GTK
 
 extern "C" {
@@ -1543,7 +1544,7 @@ BOOL LLWindowSDL::SDLReallyCaptureInput(BOOL capture)
 				
 				XUngrabPointer(mSDL_Display, CurrentTime);
 				// Make sure the ungrab happens RIGHT NOW.
-				XSync(mSDL_Display, False);
+				XSync(mSDL_Display, FALSE);
 			} else
 			{
 				newmode = SDL_GRAB_QUERY; // neutral
@@ -2269,8 +2270,12 @@ S32 OSMessageBoxSDL(const std::string& text, const std::string& caption, U32 typ
 		    gWindowImplementation->mSDL_XWindowID != None)
 		{
 			gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
-			GdkWindow *gdkwin = gdk_window_foreign_new(gWindowImplementation->mSDL_XWindowID);
-			gdk_window_set_transient_for(GTK_WIDGET(win)->window, gdkwin);
+#if GTK_CHECK_VERSION(2, 24, 0)
+			GdkWindow* gdkwin = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), static_cast<Window>(gWindowImplementation->mSDL_XWindowID));
+#else
+			GdkWindow* gdkwin = gdk_window_foreign_new(static_cast<GdkNativeWindow>(gWindowImplementation->mSDL_XWindowID));
+#endif
+			gdk_window_set_transient_for(gtk_widget_get_window(GTK_WIDGET(win)), gdkwin);
 		}
 # endif //LL_X11
 
@@ -2384,12 +2389,16 @@ BOOL LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
 		if (mSDL_XWindowID != None)
 		{
 			gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
-			GdkWindow *gdkwin = gdk_window_foreign_new(mSDL_XWindowID);
-			gdk_window_set_transient_for(GTK_WIDGET(win)->window, gdkwin);
+#if GTK_CHECK_VERSION(2, 24, 0)
+			GdkWindow* gdkwin = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), static_cast<Window>(mSDL_XWindowID));
+#else
+			GdkWindow* gdkwin = gdk_window_foreign_new(static_cast<GdkNativeWindow>(mSDL_XWindowID));
+#endif	  
+			gdk_window_set_transient_for(gtk_widget_get_window(GTK_WIDGET(win)), gdkwin);
 		}
-# endif //LL_X11
+#endif //LL_X11
 
-		GtkColorSelection *colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG(win)->colorsel);
+		GtkColorSelection *colorsel = GTK_COLOR_SELECTION (gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG(win)));
 
 		GdkColor color, orig_color;
 		orig_color.pixel = 0;
@@ -2415,8 +2424,6 @@ BOOL LLWindowSDL::dialogColorPicker( F32 *r, F32 *g, F32 *b)
 
 		gtk_window_set_modal(GTK_WINDOW(win), TRUE);
 		gtk_widget_show_all(win);
-		// hide the help button - we don't service it.
-		gtk_widget_hide(GTK_COLOR_SELECTION_DIALOG(win)->help_button);
 		gtk_main();
 
 		if (response == GTK_RESPONSE_OK &&
@@ -2498,7 +2505,7 @@ void LLWindowSDL::spawnWebBrowser(const std::string& escaped_url, bool async)
 	if (mSDL_Display)
 	{
 		// Just in case - before forking.
-		XSync(mSDL_Display, False);
+		XSync(mSDL_Display, FALSE);
 	}
 # endif // LL_X11
 
@@ -2548,7 +2555,7 @@ void LLWindowSDL::bringToFront()
 	if (mSDL_Display && !mFullscreen)
 	{
 		XRaiseWindow(mSDL_Display, mSDL_XWindowID);
-		XSync(mSDL_Display, False);
+		XSync(mSDL_Display, FALSE);
 	}
 #endif // LL_X11
 }

indra/newview/CMakeLists.txt

@@ -1709,7 +1709,7 @@ target_link_libraries(${VIEWER_BINARY_NAME}
     absl::flat_hash_map
     absl::node_hash_map
     nlohmann_json::nlohmann_json
-    ${FMT_LIBRARY}
+    fmt::fmt
     )
 
 if (LINUX)

indra/newview/NACLantispam.cpp

@@ -24,7 +24,6 @@
 #include "llviewerobjectlist.h"
 
 #include <time.h>
-#include <boost/lexical_cast.hpp>
 
 class NACLAntiSpamQueue
 {

indra/newview/app_settings/settings.xml

@@ -10576,6 +10576,17 @@ This should be as low as possible, but too low may break functionality</string>
       <key>Value</key>
       <real>1.6</real>
     </map>
+    <key>MaxPersistentNotifications</key>
+    <map>
+      <key>Comment</key>
+      <string>Maximum amount of persistent notifications</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>S32</string>
+      <key>Value</key>
+      <real>250</real>
+    </map>
     <key>MaxSelectDistance</key>
     <map>
       <key>Comment</key>

indra/newview/generate_breakpad_symbols.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 """\
 @file generate_breakpad_symbols.py
 @author Brad Kittenbrink <brad@lindenlab.com>

indra/newview/installers/windows/installer_template.nsi

@@ -95,6 +95,9 @@
   ;File Handling
   SetOverwrite on
 
+  ;Verify CRC
+  CRCCheck on
+
 ;--------------------------------
 ;Interface Settings
 
@@ -209,6 +212,7 @@
   !insertmacro MUI_RESERVEFILE_LANGDLL
   ReserveFile "${NSISDIR}\Plugins\x86-unicode\INetC.dll"
   ReserveFile "${NSISDIR}\Plugins\x86-unicode\nsDialogs.dll"
+  ReserveFile "${NSISDIR}\Plugins\x86-unicode\nsis7z.dll"
   ReserveFile "${NSISDIR}\Plugins\x86-unicode\StartMenu.dll"
   ReserveFile "${NSISDIR}\Plugins\x86-unicode\StdUtils.dll"
   ReserveFile "${NSISDIR}\Plugins\x86-unicode\System.dll"
@@ -406,7 +410,14 @@ Section "Viewer"
   SetOutPath "$INSTDIR"  
   ;Remove old shader files first so fallbacks will work.
   RMDir /r "$INSTDIR\app_settings\shaders\*"
-  
+  ;Remove old Microsoft DLLs, reboot if needed
+  Delete /REBOOTOK "$INSTDIR\api-ms-win-*.dll"
+  Delete /REBOOTOK "$INSTDIR\concrt*.dll"
+  Delete /REBOOTOK "$INSTDIR\msvcp*.dll"
+  Delete /REBOOTOK "$INSTDIR\ucrtbase.dll"
+  Delete /REBOOTOK "$INSTDIR\vccorlib*.dll"
+  Delete /REBOOTOK "$INSTDIR\vcruntime*.dll"
+
   ;This placeholder is replaced by the complete list of all the files in the installer, by viewer_manifest.py
   %%INSTALL_FILES%%
 
@@ -416,9 +427,9 @@ Section "Viewer"
 
   ;Download LibVLC
 !ifdef WIN64_BIN_BUILD
-  inetc::get /RESUME "Failed to download VLC media package. Retry?" "https://videolan.mirrors.hivelocity.net/vlc/3.0.8/win64/vlc-3.0.8-win64.7z" "$TEMP\AlchemyInst\libvlc.7z" /END
+  inetc::get /RESUME "Failed to download VLC media package. Retry?" "https://download.videolan.org/pub/videolan/vlc/3.0.8/win64/vlc-3.0.8-win64.7z" "$TEMP\AlchemyInst\libvlc.7z" /END
 !else
-  inetc::get /RESUME "Failed to download VLC media package. Retry?" "https://videolan.mirrors.hivelocity.net/vlc/3.0.8/win32/vlc-3.0.8-win32.7z" "$TEMP\AlchemyInst\libvlc.7z" /END
+  inetc::get /RESUME "Failed to download VLC media package. Retry?" "https://download.videolan.org/pub/videolan/vlc/3.0.8/win32/vlc-3.0.8-win32.7z" "$TEMP\AlchemyInst\libvlc.7z" /END
 !endif
   Nsis7z::ExtractWithDetails "$TEMP\AlchemyInst\libvlc.7z" "Unpacking media plugins %s..."
   Rename "$TEMP\AlchemyInst\vlc-3.0.8\libvlc.dll" "$INSTDIR\llplugin\libvlc.dll"
@@ -457,9 +468,9 @@ Section "Viewer"
     CreateShortCut	"$SMPROGRAMS\$STARTMENUFOLDER\$INSTSHORTCUT.lnk" "$\"$INSTDIR\$INSTEXE$\"" "$SHORTCUT_LANG_PARAM"
     CreateShortCut	"$SMPROGRAMS\$STARTMENUFOLDER\Uninstall $INSTSHORTCUT.lnk" "$\"$INSTDIR\uninst.exe$\"" ""
 !endif
-    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Create Account.url" "InternetShortcut" "URL" "http://join.secondlife.com/"
-    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Your Account.url"	"InternetShortcut" "URL" "http://www.secondlife.com/account/"
-    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Scripting Language Help.url" "InternetShortcut" "URL" "http://wiki.secondlife.com/wiki/LSL_Portal"
+    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Create Account.url" "InternetShortcut" "URL" "https://join.secondlife.com/"
+    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Your Account.url"	"InternetShortcut" "URL" "https://www.secondlife.com/account/"
+    WriteINIStr		"$SMPROGRAMS\$STARTMENUFOLDER\SL Scripting Language Help.url" "InternetShortcut" "URL" "https://wiki.secondlife.com/wiki/LSL_Portal"
 
   !insertmacro MUI_STARTMENU_WRITE_END
 

indra/newview/linux_tools/handle_secondlifeprotocol.sh.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Send a URL of the form secondlife://... to Second Life.
 #

indra/newview/linux_tools/install.sh.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Install @VIEWER_CHANNEL@. This script can install the viewer both
 # system-wide and for an individual user.

indra/newview/linux_tools/launch_url.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # This script loads a web page in the 'default' graphical web browser.
 # It MUST return immediately (or soon), so the browser should be

indra/newview/linux_tools/refresh_desktop_app_entry.sh.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 SCRIPTSRC=`readlink -f "$0" || echo "$0"`
 RUN_PATH=`dirname "${SCRIPTSRC}" || echo .`

indra/newview/linux_tools/register_secondlifeprotocol.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Register a protocol handler (default: handle_secondlifeprotocol.sh) for
 # URLs of the form secondlife://...

indra/newview/linux_tools/wrapper.sh.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 ## Here are some configuration options for Linux Client Testers.
 ## These options are for self-assisted troubleshooting during this beta
@@ -55,9 +55,8 @@
 
 ## - For advanced debugging cases, you can run the viewer under the
 ##   control of another program, such as strace, gdb, or valgrind.  If
-##   you're building your own viewer, bear in mind that the executable
-##   in the bin directory will be stripped: you should replace it with
-##   an unstripped binary before you run.
+##   you're building your own viewer, run the configure step with
+##   -DPACKAGE:BOOL=OFF to produce an unstripped binary for debugging.
 if [ -n "$ASCENDED_DEVELOPER" ]; then
 	if [ "$ASCENDED_DEVELOPER" = "1" ]; then
 		export LL_WRAPPER='gdb --args'

indra/newview/llappearancemgr.cpp

@@ -26,7 +26,6 @@
 
 #include "llviewerprecompiledheaders.h"
 
-#include <boost/lexical_cast.hpp>
 #include "llagent.h"
 #include "llagentcamera.h"
 #include "llagentwearables.h"
@@ -3994,7 +3993,7 @@ LLSD LLAppearanceMgr::dumpCOF() const
 			LLUUID linked_asset_id(linked_item->getAssetUUID());
 			md5.update((unsigned char*)linked_asset_id.mData, 16);
 			U32 flags = linked_item->getFlags();
-			md5.update(boost::lexical_cast<std::string>(flags));
+			md5.update(fmt::to_string(flags));
 		}
 		else if (LLAssetType::AT_LINK_FOLDER != inv_item->getActualType())
 		{

indra/newview/llappviewer.cpp

@@ -1348,8 +1348,8 @@ bool LLAppViewer::mainLoop()
 
 #ifdef USE_CRASHPAD
 			// Not event based. Update per frame
-			SET_CRASHPAD_ANNOTATION_VALUE(session_duration, std::to_string(LLFrameTimer::getElapsedSeconds()));
-			SET_CRASHPAD_ANNOTATION_VALUE(memory_alloc, std::to_string((LLMemory::getCurrentRSS() >> 10)/1000.f));
+			SET_CRASHPAD_ANNOTATION_VALUE(session_duration, fmt::to_string(LLFrameTimer::getElapsedSeconds()));
+			SET_CRASHPAD_ANNOTATION_VALUE(memory_alloc, fmt::to_string((LLMemory::getCurrentRSS() >> 10)/1000.f));
 #endif
 
 			//check memory availability information
@@ -2809,9 +2809,9 @@ void LLAppViewer::writeDebugInfo(bool isStatic)
 	SET_CRASHPAD_ANNOTATION_VALUE(cpu_string, gDebugInfo["CPUInfo"]["CPUString"].asString());
 	SET_CRASHPAD_ANNOTATION_VALUE(gpu_string, gDebugInfo["GraphicsCard"].asString());
 	SET_CRASHPAD_ANNOTATION_VALUE(gl_version, gDebugInfo["GLInfo"]["GLVersion"].asString());
-	SET_CRASHPAD_ANNOTATION_VALUE(session_duration, std::to_string(LLFrameTimer::getElapsedSeconds()));
-	SET_CRASHPAD_ANNOTATION_VALUE(memory_alloc, std::to_string((LLMemory::getCurrentRSS() >> 10) / 1000.f));
-	SET_CRASHPAD_ANNOTATION_VALUE(memory_sys, std::to_string(gDebugInfo["RAMInfo"]["Physical"].asInteger() * 0.001f));
+	SET_CRASHPAD_ANNOTATION_VALUE(session_duration, fmt::to_string(LLFrameTimer::getElapsedSeconds()));
+	SET_CRASHPAD_ANNOTATION_VALUE(memory_alloc, fmt::to_string((LLMemory::getCurrentRSS() >> 10) / 1000.f));
+	SET_CRASHPAD_ANNOTATION_VALUE(memory_sys, fmt::to_string(gDebugInfo["RAMInfo"]["Physical"].asInteger() * 0.001f));
 #endif
 }
 
@@ -5084,6 +5084,10 @@ void LLAppViewer::handleLoginComplete()
 	}
 
 	mOnLoginCompleted();
+	
+	// Singu Note: This would usually be registered via mOnLoginCompleted, but that would require code in newview regardless so.. just call directly here.
+	LLNotifications::instance().onLoginCompleted();
+
 	// Singu Note: Due to MAINT-4001, we must do this here, it lives in LLSidepanelInventory::updateInbox upstream.
 	// Consolidate Received items
 	// We shouldn't have to do that but with a client/server system relying on a "well known folder" convention,

indra/newview/llattachmentsmgr.cpp

@@ -349,7 +349,10 @@ bool LLAttachmentsMgr::getPendingAttachments(uuid_set_t& ids) const
 	ids.clear();
 
 	// Returns the union of the LL maintained list of attachments that are waiting for link creation and our maintained list of attachments that are pending link creation
-	set_union(mRecentlyArrivedAttachments.begin(), mRecentlyArrivedAttachments.end(), mPendingAttachLinks.begin(), mPendingAttachLinks.end(), std::inserter(ids, ids.begin()));
+	ids.insert(mRecentlyArrivedAttachments.begin(), mRecentlyArrivedAttachments.end());
+	ids.insert(mPendingAttachLinks.begin(), mPendingAttachLinks.end());
+	// Singu Note: "Expression: Sequence not ordered" using std::set_union
+	//set_union(mRecentlyArrivedAttachments.begin(), mRecentlyArrivedAttachments.end(), mPendingAttachLinks.begin(), mPendingAttachLinks.end(), std::inserter(ids, ids.begin()));
 
 	return !ids.empty();
 }

indra/newview/llchatbar.cpp

@@ -531,17 +531,24 @@ void LLChatBar::sendChat( EChatType type )
 // static 
 void LLChatBar::startChat(const char* line)
 {
+	if (!gChatBar || !gChatBar->getParent())
+	{
+		return;
+	}
 	gChatBar->getParent()->setVisible(TRUE);
 	gChatBar->setKeyboardFocus(TRUE);
 	gSavedSettings.setBOOL("ChatVisible", TRUE);
 
-	if (line && gChatBar->mInputEditor)
+	if (gChatBar->mInputEditor)
 	{
-		std::string line_string(line);
-		gChatBar->mInputEditor->setText(line_string);
+		if (line)
+		{
+			std::string line_string(line);
+			gChatBar->mInputEditor->setText(line_string);
+		}
+		// always move cursor to end so users don't obliterate chat when accidentally hitting WASD
+		gChatBar->mInputEditor->setCursorToEnd();
 	}
-	// always move cursor to end so users don't obliterate chat when accidentally hitting WASD
-	gChatBar->mInputEditor->setCursorToEnd();
 }
 
 
@@ -550,7 +557,8 @@ void LLChatBar::startChat(const char* line)
 void LLChatBar::stopChat()
 {
 	// In simple UI mode, we never release focus from the chat bar
-	gChatBar->setKeyboardFocus(FALSE);
+	if (gChatBar)
+		gChatBar->setKeyboardFocus(FALSE);
 
 	// If we typed a movement key and pressed return during the
 	// same frame, the keyboard handlers will see the key as having
@@ -562,7 +570,8 @@ void LLChatBar::stopChat()
 	gAgent.stopTyping();
 
 	// hide chat bar so it doesn't grab focus back
-	gChatBar->getParent()->setVisible(FALSE);
+	if (gChatBar && gChatBar->getParent())
+		gChatBar->getParent()->setVisible(FALSE);
 	gSavedSettings.setBOOL("ChatVisible", FALSE);
 }
 

indra/newview/llcloud.cpp

@@ -515,6 +515,10 @@ void LLCloudLayer::connectNeighbor(LLCloudLayer *cloudp, U32 direction)
 		return;
 	}
 
+	if (mNeighbors[direction])
+	{
+		mNeighbors[direction]->mNeighbors[gDirOpposite[direction]] = NULL;
+	}
 	mNeighbors[direction] = cloudp;
 	if (cloudp)
 		mNeighbors[direction]->mNeighbors[gDirOpposite[direction]] = this;

indra/newview/lldrawable.cpp

@@ -1596,11 +1596,7 @@ void LLSpatialBridge::cleanupReferences()
 	LLDrawable::cleanupReferences();
 	if (mDrawable)
 	{
-		/*
-		
-		DON'T DO THIS -- this should happen through octree destruction
-
-		mDrawable->setSpatialGroup(NULL);
+		mDrawable->setGroup(NULL);
 		if (mDrawable->getVObj())
 		{
 			LLViewerObject::const_child_list_t& child_list = mDrawable->getVObj()->getChildren();
@@ -1608,17 +1604,18 @@ void LLSpatialBridge::cleanupReferences()
 				 iter != child_list.end(); iter++)
 			{
 				LLViewerObject* child = *iter;
-				LLDrawable* drawable = child->mDrawable;					
+				LLDrawable* drawable = child->mDrawable;
 				if (drawable)
 				{
-					drawable->setSpatialGroup(NULL);
+					drawable->setGroup(NULL);
 				}
 			}
-		}*/
+		}
 
-		LLPointer<LLDrawable> drawablep = mDrawable;
+		LLPointer<LLSpatialBridge> bridgep = mDrawable->getSpatialBridge();
+		mDrawable->setSpatialBridge(nullptr);
 		mDrawable = nullptr;
-		drawablep->setSpatialBridge(nullptr);
+		bridgep = nullptr;
 	}
 }
 

indra/newview/llfloateravatarlist.cpp

@@ -52,7 +52,6 @@
 #include "llworld.h"
 
 #include <boost/date_time.hpp>
-#include <boost/lexical_cast.hpp>
 
 // [RLVa:KB]
 #include "rlvhandler.h"
@@ -1006,7 +1005,7 @@ void LLFloaterAvatarList::refreshAvatarList()
 					color = sRadarTextYoung;
 				}
 			}
-			agep.value = age_set ? boost::lexical_cast<std::string>(entry->mAge) : "?";
+			agep.value = age_set ? fmt::to_string(entry->mAge) : "?";
 			agep.color = color;
 			element.columns.add(agep);
 		}
@@ -1069,7 +1068,7 @@ void LLFloaterAvatarList::refreshAvatarList()
 	else
 	{
 		LLStringUtil::format_map_t args;
-		args["[COUNT]"] = boost::lexical_cast<std::string>(mAvatars.size());
+		args["[COUNT]"] = fmt::to_string(mAvatars.size());
 		setTitle(getString("TitleWithCount", args));
 	}
 

indra/newview/llfloaterbuycurrency.cpp

@@ -277,19 +277,19 @@ void LLFloaterBuyCurrencyUI::updateUI()
 		S32 balance = gStatusBar->getBalance();
 		childShow("balance_label");
 		childShow("balance_amount");
-		childSetTextArg("balance_amount", "[AMT]", llformat("%d", balance));
+		childSetTextArg("balance_amount", "[AMT]", fmt::to_string(balance));
 		childSetTextArg("balance_amount", "[CURRENCY]", gHippoGridManager->getConnectedGrid()->getCurrencySymbol());
 		
 		S32 buying = mManager.getAmount();
 		childShow("buying_label");
 		childShow("buying_amount");
-		childSetTextArg("buying_amount", "[AMT]", llformat("%d", buying));
+		childSetTextArg("buying_amount", "[AMT]", fmt::to_string(buying));
 		childSetTextArg("buying_amount", "[CURRENCY]", gHippoGridManager->getConnectedGrid()->getCurrencySymbol());
 		
 		S32 total = balance + buying;
 		childShow("total_label");
 		childShow("total_amount");
-		childSetTextArg("total_amount", "[AMT]", llformat("%d", total));
+		childSetTextArg("total_amount", "[AMT]", fmt::to_string(total));
 		childSetTextArg("total_amount", "[CURRENCY]", gHippoGridManager->getConnectedGrid()->getCurrencySymbol());
 
 		childSetVisible("purchase_warning_repurchase", false);

indra/newview/llfloaterchat.cpp

@@ -79,7 +79,7 @@
 //
 LLColor4 agent_chat_color(const LLUUID& id, const std::string&, bool local_chat = true);
 LLColor4 get_text_color(const LLChat& chat, bool from_im = false);
-void show_log_browser(const std::string&, const std::string&);
+void show_log_browser(const std::string&, const LLUUID&);
 
 //
 // Member Functions
@@ -96,7 +96,7 @@ LLFloaterChat::LLFloaterChat(const LLSD& seed)
 
 	LLTextEditor* history_editor_with_mute = getChild<LLTextEditor>("Chat History Editor with mute");
 	getChild<LLUICtrl>("show mutes")->setCommitCallback(boost::bind(&LLFloaterChat::onClickToggleShowMute, this, _2, getChild<LLTextEditor>("Chat History Editor"), history_editor_with_mute));
-	getChild<LLUICtrl>("chat_history_open")->setCommitCallback(boost::bind(show_log_browser, "chat", "chat"));
+	getChild<LLUICtrl>("chat_history_open")->setCommitCallback(boost::bind(show_log_browser, "chat", LLUUID::null));
 }
 
 LLFloaterChat::~LLFloaterChat()
@@ -243,7 +243,7 @@ void log_chat_text(const LLChat& chat)
 	else
 		histstr = chat.mText;
 
-	LLLogChat::saveHistory(std::string("chat"), histstr);
+	LLLogChat::saveHistory("chat", LLUUID::null, histstr);
 }
 // static
 void LLFloaterChat::addChatHistory(LLChat& chat, bool log_to_file)
@@ -535,28 +535,19 @@ LLColor4 get_text_color(const LLChat& chat, bool from_im)
 //static
 void LLFloaterChat::loadHistory()
 {
-	LLLogChat::loadHistory("chat", &chatFromLogFile, (void*)LLFloaterChat::getInstance()); 
+	LLLogChat::loadHistory("chat", LLUUID::null, boost::bind(&LLFloaterChat::chatFromLogFile, getInstance(), _1, _2));
 }
 
-//static
-void LLFloaterChat::chatFromLogFile(LLLogChat::ELogLineType type, std::string line, void* userdata)
+
+void LLFloaterChat::chatFromLogFile(LLLogChat::ELogLineType type, const std::string& line)
 {
-	switch (type)
+	bool log_line = type == LLLogChat::LOG_LINE;
+	if (log_line || gSavedPerAccountSettings.getBOOL("LogChat"))
 	{
-	case LLLogChat::LOG_EMPTY:
-		if (gSavedPerAccountSettings.getBOOL("LogChat"))
-			addChatHistory(static_cast<LLFloaterChat*>(userdata)->getString("IM_logging_string"), false);
-		break;
-	case LLLogChat::LOG_END:
-		if (gSavedPerAccountSettings.getBOOL("LogChat"))
-			addChatHistory(static_cast<LLFloaterChat*>(userdata)->getString("IM_end_log_string"), false);
-		break;
-	case LLLogChat::LOG_LINE:
-		addChatHistory(line, FALSE);
-		break;
-	default:
-		// nothing
-		break;
+		LLStyleSP style(new LLStyle(true, gSavedSettings.getColor4("LogChatColor"), LLStringUtil::null));
+		const auto text = log_line ? line : getString(type == LLLogChat::LOG_END ? "IM_end_log_string" : "IM_logging_string");
+		for (const auto& ed_name : { "Chat History Editor", "Chat History Editor with mute" })
+			getChild<LLTextEditor>(ed_name)->appendText(text, false, true, style, false);
 	}
 }
 

indra/newview/llfloaterchat.h

@@ -73,7 +73,7 @@ public:
 	static void triggerAlerts(const std::string& text);
 
 	void onClickToggleShowMute(bool show_mute, class LLTextEditor* history_editor, LLTextEditor* history_editor_with_mute);
-	static void chatFromLogFile(LLLogChat::ELogLineType type, std::string line, void* userdata);
+	void chatFromLogFile(LLLogChat::ELogLineType type, const std::string& line);
 	static void loadHistory();
 	static void* createSpeakersPanel(void* data);
 	static void* createChatPanel(void* data);

indra/newview/llfloaterland.cpp

@@ -1454,7 +1454,7 @@ void LLPanelLandObjects::onClickReturnOwnerList()
 
 	LLSD args;
 	args["NAME"] = mSelectedName;
-	args["N"] = std::to_string(mSelectedCount);
+	args["N"] = fmt::to_string(mSelectedCount);
 	if (mSelectedIsGroup)
 	{
 		LLNotificationsUtil::add("ReturnObjectsDeededToGroup", args, LLSD(), boost::bind(&LLPanelLandObjects::callbackReturnOwnerList, this, _1, _2));
@@ -1665,7 +1665,7 @@ void LLPanelLandObjects::onClickReturnOwnerObjects()
 	LLUUID owner_id = parcel->getOwnerID();
 	
 	LLSD args;
-	args["N"] = std::to_string(owned);
+	args["N"] = fmt::to_string(owned);
 
 	if (owner_id == gAgent.getID())
 	{

indra/newview/llfloatermute.cpp

@@ -45,8 +45,6 @@
 #include "llmutelist.h"
 #include "llnamelistctrl.h"
 
-#include <boost/lexical_cast.hpp>
-
 //
 // Constants
 //

indra/newview/llfloaterpostcard.cpp

@@ -103,11 +103,7 @@ void LLFloaterPostcard::init()
 	if(!gAgent.getID().isNull())
 	{
 		// we're logged in, so we can get this info.
-		gMessageSystem->newMessageFast(_PREHASH_UserInfoRequest);
-		gMessageSystem->nextBlockFast(_PREHASH_AgentData);
-		gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-		gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-		gAgent.sendReliableMessage();
+		gAgent.sendAgentUserInfoRequest();
 	}
 
 	sInstances.insert(this);
@@ -233,7 +229,7 @@ void LLFloaterPostcard::onClose(bool app_quitting)
 	destroy();
 }
 
-class LLSendPostcardResponder : public LLAssetUploadResponder
+class LLSendPostcardResponder final : public LLAssetUploadResponder
 {
 private:
 	int mSnapshotIndex;
@@ -248,22 +244,22 @@ public:
 	{	
 	}
 	// *TODO define custom uploadFailed here so it's not such a generic message
-	/*virtual*/ void uploadComplete(const LLSD& content)
+	void uploadComplete(const LLSD& content) override final
 	{
 		// we don't care about what the server returns from this post, just clean up the UI
 		LLFloaterSnapshot::savePostcardDone(true, mSnapshotIndex);
 	}
-	/*virtual*/ void uploadFailure(const LLSD& content)
+	void uploadFailure(const LLSD& content) override final
 	{
 		LLAssetUploadResponder::uploadFailure(content);
 		LLFloaterSnapshot::savePostcardDone(false, mSnapshotIndex);
 	}
-	/*virtual*/ void httpFailure(void)
+	void httpFailure(void) override final
 	{
 		LLAssetUploadResponder::httpFailure();
 		LLFloaterSnapshot::savePostcardDone(false, mSnapshotIndex);
 	}
-	/*virtual*/ char const* getName(void) const { return "LLSendPostcardResponder"; }
+	char const* getName(void) const override final { return "LLSendPostcardResponder"; }
 };
 
 // static
@@ -273,7 +269,6 @@ void LLFloaterPostcard::onClickSend(void* data)
 	{
 		LLFloaterPostcard *self = (LLFloaterPostcard *)data;
 
-		std::string from(self->childGetValue("from_form").asString());
 		std::string to(self->childGetValue("to_form").asString());
 		
 		boost::regex emailFormat("[A-Za-z0-9.%+-_]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}(,[ \t]*[A-Za-z0-9.%+-_]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,})*");
@@ -284,12 +279,6 @@ void LLFloaterPostcard::onClickSend(void* data)
 			return;
 		}
 
-		if (from.empty() || !boost::regex_match(from, emailFormat))
-		{
-			LLNotificationsUtil::add("PromptSelfEmail");
-			return;
-		}
-
 		std::string subject(self->childGetValue("subject_form").asString());
 		if(subject.empty() || !self->mHasFirstMsgFocus)
 		{
@@ -349,10 +338,8 @@ void LLFloaterPostcard::uploadCallback(const LLUUID& asset_id, void *user_data,
 // static
 void LLFloaterPostcard::updateUserInfo(const std::string& email)
 {
-	for (instance_list_t::iterator iter = sInstances.begin();
-		 iter != sInstances.end(); ++iter)
+	for (auto& instance : sInstances)
 	{
-		LLFloaterPostcard *instance = *iter;
 		const std::string& text = instance->childGetValue("from_form").asString();
 		if (text.empty())
 		{
@@ -416,7 +403,6 @@ void LLFloaterPostcard::sendPostcard()
 		// the capability already encodes: agent ID, region ID
 		body["pos-global"] = mPosTakenGlobal.getValue();
 		body["to"] = childGetValue("to_form").asString();
-		body["from"] = childGetValue("from_form").asString();
 		body["name"] = childGetValue("name_form").asString();
 		body["subject"] = childGetValue("subject_form").asString();
 		body["msg"] = childGetValue("msg_form").asString();

indra/newview/llfloaterpostcard.h

@@ -46,17 +46,17 @@ class LLLineEditor;
 class LLButton;
 class LLImageJPEG;
 
-class LLFloaterPostcard 
+class LLFloaterPostcard final
 : public LLFloater
 {
 public:
 	LLFloaterPostcard(LLImageJPEG* jpeg, LLViewerTexture *img, const LLVector2& img_scale, const LLVector3d& pos_taken_global, int index);
-	/*virtual*/ ~LLFloaterPostcard();
+	/*virtual*/ ~LLFloaterPostcard() override;
 
-	/*virtual*/ void init();
-	/*virtual*/ BOOL postBuild();
-	/*virtual*/ void draw();
-	/*virtual*/ void onClose(bool app_quitting);
+	void init();
+	/*virtual*/ BOOL postBuild() override;
+	/*virtual*/ void draw() override;
+	/*virtual*/ void onClose(bool app_quitting) override;
 
 	static LLFloaterPostcard* showFromSnapshot(LLImageJPEG *jpeg, LLViewerTexture *img, const LLVector2& img_scale, const LLVector3d& pos_taken_global, int index);
 

indra/newview/llfloaterpostprocess.cpp

@@ -43,11 +43,6 @@
 #include "llcombobox.h"
 #include "lllineeditor.h"
 #include "llviewerwindow.h"
-#if LL_MSVC
-// disable boost::lexical_cast warning
-#pragma warning (disable:4702)
-#endif
-#include <boost/lexical_cast.hpp>
 
 LLFloaterPostProcess* LLFloaterPostProcess::sPostProcess = NULL;
 
@@ -190,7 +185,7 @@ void LLFloaterPostProcess::syncMenu()
 			//llsd["uniform"][1]=>"uniform[1]"
 			for(S32 i=0;i<it->second.size();++i)
 			{
-				childSetValue(it->first+'['+boost::lexical_cast<std::string>(i)+']',it->second[i]);
+				childSetValue(it->first+'['+fmt::to_string(i)+']',it->second[i]);
 			}
 		}
 		else

indra/newview/llfloaterwindlight.cpp

@@ -302,10 +302,10 @@ void LLFloaterWindLight::syncMenu()
 	// blue horizon
 	param_mgr->mBlueHorizon = cur_params.getVector(param_mgr->mBlueHorizon.mName, err);
 	//setColorSwatch("WLBlueHorizon", param_mgr->mBlueHorizon, WL_BLUE_HORIZON_DENSITY_SCALE);
-	childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r);
-	childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g);
-	childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b);
-	childSetValue("WLBlueHorizonI", param_mgr->mBlueHorizon.i);
+	childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueHorizonI", param_mgr->mBlueHorizon.i / WL_BLUE_HORIZON_DENSITY_SCALE);
 
 	// haze density, horizon, mult, and altitude
 	param_mgr->mHazeDensity = cur_params.getFloat(param_mgr->mHazeDensity.mName, err);
@@ -320,20 +320,20 @@ void LLFloaterWindLight::syncMenu()
 	// blue density
 	param_mgr->mBlueDensity = cur_params.getVector(param_mgr->mBlueDensity.mName, err);
 	//setColorSwatch("WLBlueDensity", param_mgr->mBlueDensity, WL_BLUE_HORIZON_DENSITY_SCALE);
-	childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r);
-	childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g);
-	childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b);
-	childSetValue("WLBlueDensityI", param_mgr->mBlueDensity.i);
+	childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b / WL_BLUE_HORIZON_DENSITY_SCALE);
+	childSetValue("WLBlueDensityI", param_mgr->mBlueDensity.i / WL_BLUE_HORIZON_DENSITY_SCALE);
 
 	// Lighting
 
 	// sunlight
 	param_mgr->mSunlight = cur_params.getVector(param_mgr->mSunlight.mName, err);
 	//setColorSwatch("WLSunlight", param_mgr->mSunlight, WL_SUN_AMBIENT_SLIDER_SCALE);
-	childSetValue("WLSunlightR", param_mgr->mSunlight.r);
-	childSetValue("WLSunlightG", param_mgr->mSunlight.g);
-	childSetValue("WLSunlightB", param_mgr->mSunlight.b);
-	childSetValue("WLSunlightI", param_mgr->mSunlight.i);
+	childSetValue("WLSunlightR", param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLSunlightG", param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLSunlightB", param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLSunlightI", param_mgr->mSunlight.i / WL_SUN_AMBIENT_SLIDER_SCALE);
 
 	// glow
 	param_mgr->mGlow = cur_params.getVector(param_mgr->mGlow.mName, err);
@@ -343,10 +343,10 @@ void LLFloaterWindLight::syncMenu()
 	// ambient
 	param_mgr->mAmbient = cur_params.getVector(param_mgr->mAmbient.mName, err);
 	//setColorSwatch("WLAmbient", param_mgr->mAmbient, WL_SUN_AMBIENT_SLIDER_SCALE);
-	childSetValue("WLAmbientR", param_mgr->mAmbient.r);
-	childSetValue("WLAmbientG", param_mgr->mAmbient.g);
-	childSetValue("WLAmbientB", param_mgr->mAmbient.b);
-	childSetValue("WLAmbientI", param_mgr->mAmbient.i);
+	childSetValue("WLAmbientR", param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLAmbientG", param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLAmbientB", param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE);
+	childSetValue("WLAmbientI", param_mgr->mAmbient.i / WL_SUN_AMBIENT_SLIDER_SCALE);
 
 	childSetValue("WLSunAngle", param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI);
 	childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI);
@@ -356,10 +356,10 @@ void LLFloaterWindLight::syncMenu()
 	// Cloud Color
 	param_mgr->mCloudColor = cur_params.getVector(param_mgr->mCloudColor.mName, err);
 	//setColorSwatch("WLCloudColor", param_mgr->mCloudColor, WL_CLOUD_SLIDER_SCALE);
-	childSetValue("WLCloudColorR", param_mgr->mCloudColor.r);
-	childSetValue("WLCloudColorG", param_mgr->mCloudColor.g);
-	childSetValue("WLCloudColorB", param_mgr->mCloudColor.b);
-	childSetValue("WLCloudColorI", param_mgr->mCloudColor.i);
+	childSetValue("WLCloudColorR", param_mgr->mCloudColor.r / WL_CLOUD_SLIDER_SCALE);
+	childSetValue("WLCloudColorG", param_mgr->mCloudColor.g / WL_CLOUD_SLIDER_SCALE);
+	childSetValue("WLCloudColorB", param_mgr->mCloudColor.b / WL_CLOUD_SLIDER_SCALE);
+	childSetValue("WLCloudColorI", param_mgr->mCloudColor.i / WL_CLOUD_SLIDER_SCALE);
 
 	// Cloud
 	param_mgr->mCloudMain = cur_params.getVector(param_mgr->mCloudMain.mName, err);
@@ -513,18 +513,7 @@ void LLFloaterWindLight::onColorControlRMoved(LLUICtrl* ctrl, void* userdata)
 		std::string name = color_ctrl->mSliderName;
 		name.append("I");
 
-		if (color_ctrl->isSunOrAmbientColor)
-		{
-			childSetValue(name, color_ctrl->r / WL_SUN_AMBIENT_SLIDER_SCALE);
-		}
-		else if	(color_ctrl->isBlueHorizonOrDensity)
-		{
-			childSetValue(name, color_ctrl->r / WL_BLUE_HORIZON_DENSITY_SCALE);
-		}
-		else
-		{
-			childSetValue(name, color_ctrl->r);
-		}
+		childSetValue(name, sldr_ctrl->getValueF32());
 	}
 
 	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);

indra/newview/llgivemoney.cpp

@@ -54,7 +54,6 @@
 
 #include "hippogridmanager.h"
 
-#include <boost/lexical_cast.hpp>
 ///----------------------------------------------------------------------------
 /// Local function declarations, constants, enums, and typedefs
 ///----------------------------------------------------------------------------
@@ -97,7 +96,7 @@ LLFloaterPay::LLFloaterPay(const std::string& name,
 
 	for(U32 i = 0; i < MAX_PAY_BUTTONS; ++i)
 	{
-		mQuickPayButton[i] = getChild<LLButton>("fastpay " + boost::lexical_cast<std::string>(mQuickPayInfo[i]));
+		mQuickPayButton[i] = getChild<LLButton>("fastpay " + fmt::to_string(mQuickPayInfo[i]));
 		mQuickPayButton[i]->setClickedCallback(boost::bind(&LLFloaterPay::onGive,this,boost::ref(mQuickPayInfo[i])));
 		mQuickPayButton[i]->setVisible(FALSE);
 		mQuickPayButton[i]->setLabelArg("[CURRENCY]", gHippoGridManager->getConnectedGrid()->getCurrencySymbol());

indra/newview/llhudicon.cpp

@@ -94,7 +94,7 @@ void LLHUDIcon::renderIcon(BOOL for_select)
 	if (mHidden)
 		return;
 
-	if (mSourceObject.isNull() || mImagep.isNull())
+	if (mSourceObject.isNull() || mImagep.isNull() || mSourceObject->mDrawable.isNull())
 	{
 		markDead();
 		return;

indra/newview/llimpanel.cpp

@@ -375,9 +375,7 @@ LLFloaterIMPanel::LLFloaterIMPanel(
 
 	if ( gSavedPerAccountSettings.getBOOL("LogShowHistory") )
 	{
-		LLLogChat::loadHistory(mLogLabel,
-				       &chatFromLogFile,
-				       (void *)this);
+		LLLogChat::loadHistory(mLogLabel, mSessionType == P2P_SESSION ? mOtherParticipantUUID : mSessionUUID, boost::bind(&LLFloaterIMPanel::chatFromLogFile, this, _1, _2));
 	}
 
 	if ( !mSessionInitialized )
@@ -861,7 +859,7 @@ void LLFloaterIMPanel::addHistoryLine(const std::string &utf8msg, LLColor4 incol
 		// Floater title contains display name -> bad idea to use that as filename
 		// mLogLabel, however, is the old legacy name
 		//LLLogChat::saveHistory(getTitle(),histstr);
-		LLLogChat::saveHistory(mLogLabel, histstr);
+		LLLogChat::saveHistory(mLogLabel, mSessionType == P2P_SESSION ? mOtherParticipantUUID : mSessionUUID, histstr);
 		// [/Ansariel: Display name support]
 	}
 
@@ -1179,9 +1177,9 @@ void LLFloaterIMPanel::onFlyoutCommit(LLComboBox* flyout, const LLSD& value)
 	}
 }
 
-void show_log_browser(const std::string& name, const std::string& id)
+void show_log_browser(const std::string& name, const LLUUID& id)
 {
-	const std::string file(LLLogChat::makeLogFileName(name));
+	const std::string file(LLLogChat::makeLogFileName(name, id));
 	if (!LLFile::isfile(file))
 	{
 		make_ui_sound("UISndBadKeystroke");
@@ -1195,7 +1193,7 @@ void show_log_browser(const std::string& name, const std::string& id)
 	}
 	LLFloaterWebContent::Params p;
 	p.url("file:///" + file);
-	p.id(id);
+	p.id(id.asString());
 	p.show_chrome(false);
 	p.trusted_content(true);
 	LLFloaterWebContent::showInstance("log", p); // If we passed id instead of "log", there would be no control over how many log browsers opened at once.
@@ -1206,8 +1204,8 @@ void LLFloaterIMPanel::onClickHistory()
 	if (mOtherParticipantUUID.notNull())
 	{
 		// [Ansariel: Display name support]
-		//show_log_browser(getTitle(), mOtherParticipantUUID.asString());
-		show_log_browser(mLogLabel, mOtherParticipantUUID.asString());
+		//show_log_browser(getTitle(), mSessionType == P2P_SESSION ? mOtherParticipantUUID : mSessionUUID);
+		show_log_browser(mLogLabel, mSessionType == P2P_SESSION ? mOtherParticipantUUID : mSessionUUID);
 		// [/Ansariel: Display name support]
 	}
 }
@@ -1651,6 +1649,7 @@ Note: OTHER_TYPING_TIMEOUT must be > ME_TYPING_TIMEOUT for proper operation of t
 		{
 			speaker_mgr->setSpeakerTyping(from_id, TRUE);
 		}
+		mOtherTyping = true; // addHistoryLine clears this flag. Set it again.
 	}
 }
 
@@ -1670,39 +1669,16 @@ void LLFloaterIMPanel::removeTypingIndicator(const LLUUID& from_id)
 	}
 }
 
-//static
-void LLFloaterIMPanel::chatFromLogFile(LLLogChat::ELogLineType type, std::string line, void* userdata)
+void LLFloaterIMPanel::chatFromLogFile(LLLogChat::ELogLineType type, const std::string& line)
 {
-	LLFloaterIMPanel* self = (LLFloaterIMPanel*)userdata;
-	std::string message = line;
-
-	switch (type)
+	bool log_line = type == LLLogChat::LOG_LINE;
+	if (log_line || gSavedPerAccountSettings.getBOOL("LogInstantMessages"))
 	{
-	case LLLogChat::LOG_EMPTY:
-		// add warning log enabled message
-		if (gSavedPerAccountSettings.getBOOL("LogInstantMessages"))
-		{
-			message = LLFloaterChat::getInstance()->getString("IM_logging_string");
-		}
-		break;
-	case LLLogChat::LOG_END:
-		// add log end message
-		if (gSavedPerAccountSettings.getBOOL("LogInstantMessages"))
-		{
-			message = LLFloaterChat::getInstance()->getString("IM_end_log_string");
-		}
-		break;
-	case LLLogChat::LOG_LINE:
-		// just add normal lines from file
-		break;
-	default:
-		// nothing
-		break;
+		LLStyleSP style(new LLStyle(true, gSavedSettings.getColor4("LogChatColor"), LLStringUtil::null));
+		mHistoryEditor->appendText(log_line ? line :
+			getString(type == LLLogChat::LOG_END ? "IM_end_log_string" : "IM_logging_string"),
+			false, true, style, false);
 	}
-
-	//self->addHistoryLine(line, LLColor4::grey, FALSE);
-	LLStyleSP style(new LLStyle(true, gSavedSettings.getColor4("LogChatColor"), LLStringUtil::null));
-	self->mHistoryEditor->appendText(message, false, true, style, false);
 }
 
 void LLFloaterIMPanel::showSessionStartError(

indra/newview/llimpanel.h

@@ -126,7 +126,7 @@ public:
 
 	// Handle other participant in the session typing.
 	void processIMTyping(const LLUUID& from_id, BOOL typing);
-	static void chatFromLogFile(LLLogChat::ELogLineType type, std::string line, void* userdata);
+	void chatFromLogFile(LLLogChat::ELogLineType type, const std::string& line);
 
 	//show error statuses to the user
 	void showSessionStartError(const std::string& error_string);

indra/newview/llimprocessing.cpp

@@ -560,7 +560,7 @@ void LLIMProcessing::processNewMessage(const LLUUID& from_id,
 	chat.mFromID = from_id;
 	chat.mFromName = name;
 	chat.mSourceType = (from_id.isNull() || (name == SYSTEM_FROM)) ? CHAT_SOURCE_SYSTEM :
-		(dialog == IM_FROM_TASK && dialog == IM_FROM_TASK_AS_ALERT) ? CHAT_SOURCE_OBJECT : CHAT_SOURCE_AGENT;
+		(dialog == IM_FROM_TASK || dialog == IM_FROM_TASK_AS_ALERT) ? CHAT_SOURCE_OBJECT : CHAT_SOURCE_AGENT;
 
 	bool is_muted = LLMuteList::getInstance()->isMuted(from_id, name, LLMute::flagTextChat)
 		// object IMs contain sender object id in session_id (STORM-1209)
@@ -1196,41 +1196,41 @@ void LLIMProcessing::processNewMessage(const LLUUID& from_id,
 			}
 			else // IM_TASK_INVENTORY_OFFERED
 			{
-                if (offline == IM_OFFLINE && session_id.isNull() && aux_id.notNull() && binary_bucket_size > sizeof(S8)* 5)
+                if (sizeof(S8) == binary_bucket_size)
                 {
-                    // cap received offline message
-                    std::string str_bucket = ll_safe_string((char*)binary_bucket, binary_bucket_size);
-                    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-                    boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
-                    tokenizer tokens(str_bucket, sep);
-                    tokenizer::iterator iter = tokens.begin();
-
-                    info->mType = (LLAssetType::EType)(atoi((*(iter++)).c_str()));
-                    // Note There is more elements in 'tokens' ...
-
-                    info->mObjectID = LLUUID::null;
-                    info->mFromObject = TRUE;
+                   info->mType = (LLAssetType::EType) binary_bucket[0];
                 }
                 else
                 {
-					if (sizeof(S8) != binary_bucket_size)
-					{
-						LL_WARNS("Messaging") << "Malformed inventory offer from object" << LL_ENDL;
-						delete info;
-						break;
-					}
-					info->mType = (LLAssetType::EType) binary_bucket[0];
-					info->mObjectID = LLUUID::null;
-					info->mFromObject = TRUE;
-				}
+                    /*RIDER*/ // The previous version of the protocol returned the wrong binary bucket... we 
+                    // still might be able to figure out the type... even though the offer is not retrievable. 
+
+                    // Should be safe to remove once DRTSIM-451 fully deploys
+                    std::string str_bucket(reinterpret_cast<char *>(binary_bucket));
+                    std::string str_type(str_bucket.substr(0, str_bucket.find('|')));
+
+                    std::stringstream type_convert(str_type);
+
+                    S32 type;
+                    type_convert >> type;
+
+                    // We could try AT_UNKNOWN which would be more accurate, but that causes an auto decline
+                    info->mType = static_cast<LLAssetType::EType>(type);
+                    // Don't break in the case of a bad binary bucket.  Go ahead and show the 
+                    // accept/decline popup even though it will not do anything.
+                    LL_WARNS("Messaging") << "Malformed inventory offer from object, type might be " << info->mType << LL_ENDL;
+                }
+                info->mObjectID = LLUUID::null;
+                info->mFromObject = TRUE;
             }
 
 			info->mIM = dialog;
 			info->mFromID = from_id;
 			info->mFromGroup = from_group;
-			info->mTransactionID = session_id;
 			info->mFolderID = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(info->mType));
 
+            info->mTransactionID = session_id.notNull() ? session_id : aux_id;
+
 			info->mFromName = name;
 			info->mDesc = message;
             info->mHost = sender;
@@ -1895,6 +1895,11 @@ void LLIMProcessing::requestOfflineMessages()
 
 void LLIMProcessing::requestOfflineMessagesCoro(const LLCoroResponder& responder)
 {
+	if (LLApp::isQuitting() || !gAgent.getRegion())
+	{
+		return;
+	}
+
     auto status = responder.getStatus();
 
     if (!responder.isGoodStatus(status)) // success = httpResults["success"].asBoolean();
@@ -1943,8 +1948,6 @@ void LLIMProcessing::requestOfflineMessagesCoro(const LLCoroResponder& responder
 
     LL_INFOS("Messaging") << "Processing offline messages." << LL_ENDL;
 
-    std::vector<U8> data;
-    S32 binary_bucket_size = 0;
     LLHost sender = gAgent.getRegion()->getHost();
 
     LLSD::array_iterator i = messages.beginArray();
@@ -1953,12 +1956,31 @@ void LLIMProcessing::requestOfflineMessagesCoro(const LLCoroResponder& responder
     {
         const LLSD &message_data(*i);
 
-        LLVector3 position(message_data["local_x"].asReal(), message_data["local_y"].asReal(), message_data["local_z"].asReal());
-        data = message_data["binary_bucket"].asBinary();
-        binary_bucket_size = data.size(); // message_data["count"] always 0
-        U32 parent_estate_id = message_data.has("parent_estate_id") ? message_data["parent_estate_id"].asInteger() : 1; // 1 - IMMainland
+        /* RIDER: Many fields in this message are using a '_' rather than the standard '-'.  This 
+         * should be changed but would require tight coordination with the simulator. 
+         */
+        LLVector3 position;
+        if (message_data.has("position"))
+        {
+            position.setValue(message_data["position"]);
+        }
+        else
+        {
+            position.set(message_data["local_x"].asReal(), message_data["local_y"].asReal(), message_data["local_z"].asReal());
+        }
 
-        // Todo: once dirtsim-369 releases, remove one of the int/str options
+        std::vector<U8> bin_bucket;
+        if (message_data.has("binary_bucket"))
+        {
+            bin_bucket = message_data["binary_bucket"].asBinary();
+        }
+#if 0
+        else
+        {
+            bin_bucket.push_back(0);
+        }
+#endif
+        // Todo: once drtsim-451 releases, remove the string option
         BOOL from_group;
         if (message_data["from_group"].isInteger())
         {
@@ -1971,20 +1993,21 @@ void LLIMProcessing::requestOfflineMessagesCoro(const LLCoroResponder& responder
 
         auto agentName = message_data["from_agent_name"].asString();
         auto message = message_data["message"].asString();
-        LLIMProcessing::processNewMessage(message_data["from_agent_id"].asUUID(),
+        LLIMProcessing::processNewMessage(
+            message_data["from_agent_id"].asUUID(),
             from_group,
             message_data["to_agent_id"].asUUID(),
-            IM_OFFLINE,
-            (EInstantMessage)message_data["dialog"].asInteger(),
-            LLUUID::null, // session id, since there is none we can only use frienship/group invite caps
-            message_data["timestamp"].asInteger(),
+            message_data.has("offline") ? static_cast<U8>(message_data["offline"].asInteger()) : IM_OFFLINE,
+            static_cast<EInstantMessage>(message_data["dialog"].asInteger()),
+            message_data["transaction-id"].asUUID(),
+            static_cast<U32>(message_data["timestamp"].asInteger()),
             agentName,
             message,
-            parent_estate_id,
+            message_data.has("parent_estate_id") ? static_cast<U32>(message_data["parent_estate_id"].asInteger()) : 1U, // 1 - IMMainland
             message_data["region_id"].asUUID(),
             position,
-            &data[0],
-            binary_bucket_size,
+            bin_bucket.data(),
+            bin_bucket.size(),
             sender,
             message_data["asset_id"].asUUID()); // not necessarily an asset
     }

indra/newview/llinventorybridge.cpp

@@ -3152,7 +3152,7 @@ void LLFolderBridge::performAction(LLInventoryModel* model, std::string action)
 	else if ("marketplace_copy_id" == action)
 	{
 		auto id = LLMarketplaceData::instance().getListingID(mUUID);
-		gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(std::to_string(id)));
+		gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(fmt::to_string(id)));
 	}
 	// <singu> Move displaced inventory to lost and found
 	else if ("move_to_lost_and_found" == action)
@@ -3889,6 +3889,9 @@ void build_context_menu_folder_options(LLInventoryModel* model, const LLUUID& mU
 	const LLInventoryCategory* category = model->getCategory(mUUID);
 	if(!category) return;
 
+	items.push_back(std::string("Open Folder In New Window"));
+	items.push_back(std::string("Copy Folder UUID"));
+
 	const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
 	if (trash_id == mUUID) return;
 	if (model->isObjectDescendentOf(mUUID, trash_id)) return;
@@ -3902,9 +3905,6 @@ void build_context_menu_folder_options(LLInventoryModel* model, const LLUUID& mU
 	const LLUUID listings_folder = gInventory.findCategoryUUIDForType(LLFolderType::FT_MARKETPLACE_LISTINGS, false);
 	if (listings_folder.notNull() && gInventory.isObjectDescendentOf(mUUID, listings_folder)) return;
 
-	items.push_back(std::string("Open Folder In New Window"));
-	items.push_back(std::string("Copy Folder UUID"));
-
 	LLFolderType::EType type = category->getPreferredType();
 	const bool is_system_folder = LLFolderType::lookupIsProtectedType(type);
 	// calling card related functionality for folders.

indra/newview/lllogchat.cpp

@@ -36,35 +36,132 @@
 #include "lllogchat.h"
 #include "llappviewer.h"
 #include "llfloaterchat.h"
+#include "llsdserialize.h"
 
+static std::string get_log_dir_file(const std::string& filename)
+{
+	return gDirUtilp->getExpandedFilename(LL_PATH_PER_ACCOUNT_CHAT_LOGS, filename);
+}
 
 //static
-std::string LLLogChat::makeLogFileName(std::string filename)
+std::string LLLogChat::makeLogFileNameInternal(std::string filename)
 {
-	if (gSavedPerAccountSettings.getBOOL("LogFileNamewithDate"))
+	static const LLCachedControl<bool> with_date(gSavedPerAccountSettings, "LogFileNamewithDate");
+	if (with_date)
 	{
 		time_t now; 
 		time(&now); 
-		char dbuffer[100];               /* Flawfinder: ignore */
-		if (filename == "chat") 
-		{ 
-			static const LLCachedControl<std::string> local_chat_date_format(gSavedPerAccountSettings, "LogFileLocalChatDateFormat", "-%Y-%m-%d");
-			strftime(dbuffer, 100, local_chat_date_format().c_str(), localtime(&now));
-		} 
-		else 
-		{ 
-			static const LLCachedControl<std::string> ims_date_format(gSavedPerAccountSettings, "LogFileIMsDateFormat", "-%Y-%m");
-			strftime(dbuffer, 100, ims_date_format().c_str(), localtime(&now));
-		} 
-		filename += dbuffer; 
+		std::array<char, 100> dbuffer;
+		static const LLCachedControl<std::string> local_chat_date_format(gSavedPerAccountSettings, "LogFileLocalChatDateFormat", "-%Y-%m-%d");
+		static const LLCachedControl<std::string> ims_date_format(gSavedPerAccountSettings, "LogFileIMsDateFormat", "-%Y-%m");
+		strftime(dbuffer.data(), dbuffer.size(), (filename == "chat" ? local_chat_date_format : ims_date_format)().c_str(), localtime(&now));
+		filename += dbuffer.data();
+	}
+	cleanFileName(filename);
+	return get_log_dir_file(filename + ".txt");
+}
+
+bool LLLogChat::migrateFile(const std::string& old_name, const std::string& filename)
+{
+	std::string oldfile = makeLogFileNameInternal(old_name);
+	if (!LLFile::isfile(oldfile)) return false; // An old file by this name doesn't exist
+
+	if (LLFile::isfile(filename)) // A file by the new name also exists, but wasn't being tracked yet
+	{
+		auto&& new_untracked_log = llifstream(filename);
+		auto&& tracked_log = llofstream(oldfile, llofstream::out|llofstream::app);
+		// Append new to old and find out if it failed
+		bool failed = !(tracked_log << new_untracked_log.rdbuf());
+		// Close streams
+		new_untracked_log.close();
+		tracked_log.close();
+		if (failed || LLFile::remove(filename)) // Delete the untracked new file so that reclaiming its name won't fail
+			return true; // We failed to remove it or update the old file, let's just use the new file and leave the old one alone
+	}
+
+	LLFile::rename(oldfile, filename); // Move the existing file to the new name
+	return true; // Report success
+}
+
+static LLSD sIDMap;
+
+static std::string get_ids_map_file() { return get_log_dir_file("ids_to_names.json"); }
+void LLLogChat::initializeIDMap()
+{
+	const auto map_file = get_ids_map_file();
+	bool write = true; // Do we want to write back to map_file?
+	if (LLFile::isfile(map_file)) // If we've already made this file, load our map from it
+	{
+		if (auto&& fstr = llifstream(map_file))
+		{
+			LLSDSerialize::fromNotation(sIDMap, fstr, LLSDSerialize::SIZE_UNLIMITED);
+			fstr.close();
+		}
+		write = false; // Don't write what we just read
+	}
+
+	if (gCacheName) // Load what we can from name cache to initialize or update the map and its file
+	{
+		bool empty = sIDMap.size() == 0; // Opt out of searching the map for IDs we added if we started with none
+		for (const auto& r : gCacheName->getReverseMap()) // For every name id pair
+		{
+			const auto id = r.second.asString();
+			const auto& name = r.first;
+			const auto filename = makeLogFileNameInternal(name);
+			bool id_known = !empty && sIDMap.has(id); // Is this ID known?
+			if (id_known ? name != sIDMap[id].asStringRef() // If names don't match
+					&& migrateFile(sIDMap[id].asStringRef(), filename) // Do we need to migrate an existing log?
+				: LLFile::isfile(filename)) // Otherwise if there's a log file for them but they're not in the map yet
+			{
+				if (id_known) write = true; // We updated, write
+				sIDMap[id] = name; // Add them to the map
+			}
+		}
+
+		if (write)
+		if (auto&& fstr = llofstream(map_file))
+		{
+			LLSDSerialize::toPrettyNotation(sIDMap, fstr);
+			fstr.close();
+		}
+	}
+
+}
+
+//static
+std::string LLLogChat::makeLogFileName(const std::string& username, const LLUUID& id)
+{
+	const auto name = username.empty() ? id.asString() : username; // Fall back on ID if the grid sucks and we have no name
+	std::string filename = makeLogFileNameInternal(name);
+	if (id.notNull() && !LLFile::isfile(filename)) // No existing file by this user's current name, check for possible file rename
+	{
+		auto& entry = sIDMap[id.asString()];
+		const bool empty = !entry.size();
+		if (empty || entry != name) // If we haven't seen this entry yet, or the name is different than we remember
+		{
+			if (empty) // We didn't see this entry on load
+			{
+				// Ideally, we would look up the old names here via server request
+				// In lieu of that, our reverse cache has old names and new names that we've gained since our initialization of the ID map
+				for (const auto& r : gCacheName->getReverseMap())
+					if (r.second == id && migrateFile(r.first, filename))
+						break;
+			}
+			else migrateFile(entry.asStringRef(), filename); // We've seen this entry before, migrate old file if it exists
+
+			entry = name; // Update the entry to point to the new name
+
+			if (auto&& fstr = llofstream(get_ids_map_file())) // Write back to our map file
+			{
+				LLSDSerialize::toPrettyNotation(sIDMap, fstr);
+				fstr.close();
+			}
+		}
 	}
-	filename = cleanFileName(filename);
-	filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_ACCOUNT_CHAT_LOGS,filename);
-	filename += ".txt";
 	return filename;
 }
 
-std::string LLLogChat::cleanFileName(std::string filename)
+void LLLogChat::cleanFileName(std::string& filename)
 {
 	std::string invalidChars = "\"\'\\/?*:<>|[]{}~"; // Cannot match glob or illegal filename chars
 	S32 position = filename.find_first_of(invalidChars);
@@ -73,7 +170,6 @@ std::string LLLogChat::cleanFileName(std::string filename)
 		filename[position] = '_';
 		position = filename.find_first_of(invalidChars, position);
 	}
-	return filename;
 }
 
 static void time_format(std::string& out, const char* fmt, const std::tm* time)
@@ -92,6 +188,7 @@ static void time_format(std::string& out, const char* fmt, const std::tm* time)
 		charvector.resize(1+size); // Use the String Stone
 		format_the_time();
 	}
+	#undef format_the_time
 	out.assign(charvector.data());
 }
 
@@ -117,15 +214,15 @@ std::string LLLogChat::timestamp(bool withdate)
 
 
 //static
-void LLLogChat::saveHistory(std::string const& filename, std::string line)
+void LLLogChat::saveHistory(const std::string& name, const LLUUID& id, const std::string& line)
 {
-	if(!filename.size())
+	if(name.empty() && id.isNull())
 	{
 		LL_INFOS() << "Filename is Empty!" << LL_ENDL;
 		return;
 	}
 
-	LLFILE* fp = LLFile::fopen(LLLogChat::makeLogFileName(filename), "a"); 		/*Flawfinder: ignore*/
+	LLFILE* fp = LLFile::fopen(LLLogChat::makeLogFileName(name, id), "a"); 		/*Flawfinder: ignore*/
 	if (!fp)
 	{
 		LL_INFOS() << "Couldn't open chat history log!" << LL_ENDL;
@@ -140,10 +237,9 @@ void LLLogChat::saveHistory(std::string const& filename, std::string line)
 
 static long const LOG_RECALL_BUFSIZ = 2048;
 
-void LLLogChat::loadHistory(std::string const& filename , void (*callback)(ELogLineType, std::string, void*), void* userdata)
+void LLLogChat::loadHistory(const std::string& name, const LLUUID& id, std::function<void (ELogLineType, const std::string&)> callback)
 {
-	bool filename_empty = filename.empty();
-	if (filename_empty)
+	if (name.empty() && id.isNull())
 	{
 		LL_WARNS() << "filename is empty!" << LL_ENDL;
 	}
@@ -154,7 +250,7 @@ void LLLogChat::loadHistory(std::string const& filename , void (*callback)(ELogL
 		if (lines == 0) break;
 
 		// Open the log file.
-		LLFILE* fptr = LLFile::fopen(makeLogFileName(filename), "rb");
+		LLFILE* fptr = LLFile::fopen(makeLogFileName(name, id), "rb");
 		if (!fptr) break;
 
 		// Set pos to point to the last character of the file, if any.
@@ -199,20 +295,15 @@ void LLLogChat::loadHistory(std::string const& filename , void (*callback)(ELogL
 		// Read lines from the file one by one until we reach the end of the file.
 		while (fgets(buffer, LOG_RECALL_BUFSIZ, fptr))
 		{
-		  size_t len = strlen(buffer);
-		  int i = len - 1;
-		  while (i >= 0 && (buffer[i] == '\r' || buffer[i] == '\n')) // strip newline chars from the end of the string
-		  {
-			  buffer[i] = '\0';
-			  i--;
-		  }
-		  callback(LOG_LINE, buffer, userdata);
+			// strip newline chars from the end of the string
+			for (S32 i = strlen(buffer) - 1; i >= 0 && (buffer[i] == '\r' || buffer[i] == '\n'); --i)
+				buffer[i] = '\0';
+			callback(LOG_LINE, buffer);
 		}
 
 		fclose(fptr);
-		callback(LOG_END, LLStringUtil::null, userdata);
+		callback(LOG_END, LLStringUtil::null);
 		return;
 	}
-	callback(LOG_EMPTY, LLStringUtil::null, userdata);
+	callback(LOG_EMPTY, LLStringUtil::null);
 }
-

indra/newview/lllogchat.h

@@ -45,14 +45,16 @@ public:
 		LOG_LINE,
 		LOG_END
 	};
+	static void initializeIDMap();
 	static std::string timestamp(bool withdate = false);
-	static std::string makeLogFileName(std::string filename);
-	static void saveHistory(std::string const& filename, std::string line);
-	static void loadHistory(std::string const& filename, 
-		                    void (*callback)(ELogLineType,std::string,void*), 
-							void* userdata);
+	static std::string makeLogFileName(const std::string& name, const LLUUID& id);
+	static void saveHistory(const std::string& name, const LLUUID& id, const std::string& line);
+	static void loadHistory(const std::string& name, const LLUUID& id,
+		                    std::function<void (ELogLineType, const std::string&)> callback);
 private:
-	static std::string cleanFileName(std::string filename);
+	static std::string makeLogFileNameInternal(std::string filename);
+	static bool migrateFile(const std::string& old_name, const std::string& filename);
+	static void cleanFileName(std::string& filename);
 };
 
 #endif

indra/newview/llmediadataclient.cpp

@@ -28,13 +28,6 @@
 
 #include "llmediadataclient.h"
 
-#if LL_MSVC
-// disable boost::lexical_cast warning
-#pragma warning (disable:4702)
-#endif
-
-#include <boost/lexical_cast.hpp>
-
 #include "llhttpstatuscodes.h"
 #include "llsdutil.h"
 #include "llmediaentry.h"

indra/newview/llmenucommands.cpp

@@ -148,7 +148,7 @@ struct CommWrapper
 
 struct MenuFloaterDict final : public LLSingleton<MenuFloaterDict>
 {
-	typedef std::map<const std::string, std::pair<std::function<void ()>, std::function<bool ()> > > menu_floater_map_t;
+	typedef std::map<const std::string, std::pair<std::function<void ()>, std::function<bool ()>>> menu_floater_map_t;
 	menu_floater_map_t mEntries;
 
 	MenuFloaterDict()

indra/newview/llmeshrepository.cpp

@@ -66,7 +66,6 @@
 #include "aicurl.h"
 
 #include <mutex>
-#include "boost/lexical_cast.hpp"
 
 #ifndef LL_WINDOWS
 #include "netdb.h"
@@ -110,7 +109,7 @@ const U32 MAX_TEXTURE_UPLOAD_RETRIES = 5;
 static S32 dump_num = 0;
 std::string make_dump_name(std::string prefix, S32 num)
 {
-	return prefix + boost::lexical_cast<std::string>(num) + std::string(".xml");
+	return prefix + fmt::to_string(num) + std::string(".xml");
 	
 }
 void dump_llsd_to_file(const LLSD& content, std::string filename);

indra/newview/llmimetypes.h

@@ -34,9 +34,6 @@
 #ifndef LLMIMETYPES_H
 #define LLMIMETYPES_H
 
-#include <string>
-#include <map>
-
 class LLMIMETypes
 {
 public:

indra/newview/llnotify.cpp

@@ -553,6 +553,7 @@ BOOL LLNotifyBox::tick()
 {
 	if (mIsTip)
 	{
+		LLNotifications::instance().cancel(mNotification);
 		close();
 	}
 	return FALSE;

indra/newview/llpanelavatar.cpp

@@ -199,8 +199,8 @@ void LLPanelAvatarSecondLife::processProperties(void* data, EAvatarProcessorType
 				{
 					date birthday(year, month, day), today(day_clock::local_day());
 					std::ostringstream born_on;
-					const std::locale fmt(std::locale::classic(), new date_facet(gSavedSettings.getString("ShortDateFormat").data()));
-					born_on.imbue(fmt);
+					const std::locale date_fmt(std::locale::classic(), new date_facet(gSavedSettings.getString("ShortDateFormat").data()));
+					born_on.imbue(date_fmt);
 					born_on << birthday << " (" << today - birthday << ')';
 					childSetValue("born", born_on.str());
 				}
@@ -340,7 +340,7 @@ static std::string profile_picture_title(const std::string& str) { return "Profi
 static void show_partner_help() { LLNotificationsUtil::add("ClickPartnerHelpAvatar", LLSD(), LLSD(), boost::bind(LLPanelAvatarSecondLife::onClickPartnerHelpLoadURL, _1, _2)); }
 void show_log_browser(const LLUUID& id, const LFIDBearer::Type& type)
 {
-	void show_log_browser(const std::string& name, const std::string& id);
+	void show_log_browser(const std::string& name, const LLUUID& id);
 	std::string name;
 	if (type == LFIDBearer::AVATAR)
 	{
@@ -352,7 +352,7 @@ void show_log_browser(const LLUUID& id, const LFIDBearer::Type& type)
 	{
 		gCacheName->getGroupName(id, name);
 	}
-	show_log_browser(name, id.asString());
+	show_log_browser(name, id);
 }
 BOOL LLPanelAvatarSecondLife::postBuild()
 {

indra/newview/llpaneldirfind.cpp

@@ -67,12 +67,7 @@
 #include "hippogridmanager.h"
 #include "lfsimfeaturehandler.h"
 
-#if LL_MSVC
-// disable boost::lexical_cast warning
-#pragma warning (disable:4702)
-#endif
 #include <boost/tokenizer.hpp>
-#include <boost/lexical_cast.hpp>
 
 //---------------------------------------------------------------------------
 // LLPanelDirFindAll - Google search appliance based search
@@ -468,7 +463,7 @@ const std::string LLPanelDirFind::getSearchURLSuffix(bool inc_pg, bool inc_matur
 				(inc_pg ? SEARCH_PG : SEARCH_NONE) |
 				(inc_mature ? SEARCH_MATURE : SEARCH_NONE) |
 				(inc_adult ? SEARCH_ADULT : SEARCH_NONE);
-			url.replace(url.find(substring), substring.length(), boost::lexical_cast<std::string>(maturityFlag));
+			url.replace(url.find(substring), substring.length(), fmt::to_string(maturityFlag));
 			
 			// Include region and x/y position, not for the GSA, but
 			// just to get logs on the web server for search_proxy.php

indra/newview/llpanelgroupgeneral.cpp

@@ -60,7 +60,6 @@
 #include "llviewerwindow.h"
 
 #include "hippogridmanager.h"
-#include <boost/lexical_cast.hpp>
 
 // consts
 const S32 MATURE_CONTENT = 1;
@@ -268,7 +267,7 @@ BOOL LLPanelGroupGeneral::postBuild()
 
 	std::string member_count(LLTrans::getString("LoadingData"));
 	if (LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID))
-		member_count = boost::lexical_cast<std::string>(gdatap->mMembers.size());
+		member_count = fmt::to_string(gdatap->mMembers.size());
 	getChild<LLUICtrl>("text_owners_and_visible_members")->setTextArg("[COUNT]", member_count);
 
 	return LLPanelGroupTab::postBuild();
@@ -836,7 +835,7 @@ void LLPanelGroupGeneral::updateMembers()
 		}
 	}
 
-	getChild<LLUICtrl>("text_owners_and_visible_members")->setTextArg("[COUNT]", boost::lexical_cast<std::string>(gdatap->mMembers.size()));
+	getChild<LLUICtrl>("text_owners_and_visible_members")->setTextArg("[COUNT]", fmt::to_string(gdatap->mMembers.size()));
 
 	if (mMemberProgress == gdatap->mMembers.end())
 	{