STORM-826 (workaround): correct mixed and dos-style line endings

2 files changed, 1062 insertions, 1062 deletions

diff --git a/indra/cmake/GetPrerequisites_2_8.cmake b/indra/cmake/GetPrerequisites_2_8.cmake
index 5a24842c89..05ec1539ba 100644
--- a/indra/cmake/GetPrerequisites_2_8.cmake
+++ b/indra/cmake/GetPrerequisites_2_8.cmake
@@ -1,786 +1,786 @@
-# GetPrerequisites.cmake

-#

-# This script provides functions to list the .dll, .dylib or .so files that an

-# executable or shared library file depends on. (Its prerequisites.)

-#

-# It uses various tools to obtain the list of required shared library files:

-#   dumpbin (Windows)

-#   ldd (Linux/Unix)

-#   otool (Mac OSX)

-#

-# The following functions are provided by this script:

-#   gp_append_unique

-#   is_file_executable

-#   gp_item_default_embedded_path

-#     (projects can override with gp_item_default_embedded_path_override)

-#   gp_resolve_item

-#     (projects can override with gp_resolve_item_override)

-#   gp_resolved_file_type

-#   gp_file_type

-#   get_prerequisites

-#   list_prerequisites

-#   list_prerequisites_by_glob

-#

-# Requires CMake 2.6 or greater because it uses function, break, return and

-# PARENT_SCOPE.

-

-#=============================================================================

-# Copyright 2008-2009 Kitware, Inc.

-#

-# Distributed under the OSI-approved BSD License (the "License");

-# see accompanying file Copyright.txt for details.

-#

-# This software is distributed WITHOUT ANY WARRANTY; without even the

-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

-# See the License for more information.

-#=============================================================================

-# (To distributed this file outside of CMake, substitute the full

-#  License text for the above reference.)

-

-# gp_append_unique list_var value

-#

-# Append value to the list variable ${list_var} only if the value is not

-# already in the list.

-#

-function(gp_append_unique list_var value)

-  set(contains 0)

-

-  foreach(item ${${list_var}})

-    if("${item}" STREQUAL "${value}")

-      set(contains 1)

-      break()

-    endif("${item}" STREQUAL "${value}")

-  endforeach(item)

-

-  if(NOT contains)

-    set(${list_var} ${${list_var}} "${value}" PARENT_SCOPE)

-  endif(NOT contains)

-endfunction(gp_append_unique)

-

-

-# is_file_executable file result_var

-#

-# Return 1 in ${result_var} if ${file} is a binary executable.

-#

-# Return 0 in ${result_var} otherwise.

-#

-function(is_file_executable file result_var)

-  #

-  # A file is not executable until proven otherwise:

-  #

-  set(${result_var} 0 PARENT_SCOPE)

-

-  get_filename_component(file_full "${file}" ABSOLUTE)

-  string(TOLOWER "${file_full}" file_full_lower)

-

-  # If file name ends in .exe on Windows, *assume* executable:

-  #

-  if(WIN32)

-    if("${file_full_lower}" MATCHES "\\.exe$")

-      set(${result_var} 1 PARENT_SCOPE)

-      return()

-    endif("${file_full_lower}" MATCHES "\\.exe$")

-

-    # A clause could be added here that uses output or return value of dumpbin

-    # to determine ${result_var}. In 99%+? practical cases, the exe name

-    # match will be sufficient...

-    #

-  endif(WIN32)

-

-  # Use the information returned from the Unix shell command "file" to

-  # determine if ${file_full} should be considered an executable file...

-  #

-  # If the file command's output contains "executable" and does *not* contain

-  # "text" then it is likely an executable suitable for prerequisite analysis

-  # via the get_prerequisites macro.

-  #

-  if(UNIX)

-    if(NOT file_cmd)

-      find_program(file_cmd "file")

-    endif(NOT file_cmd)

-

-    if(file_cmd)

-      execute_process(COMMAND "${file_cmd}" "${file_full}"

-        OUTPUT_VARIABLE file_ov

-        OUTPUT_STRIP_TRAILING_WHITESPACE

-        )

-

-      # Replace the name of the file in the output with a placeholder token

-      # (the string " _file_full_ ") so that just in case the path name of

-      # the file contains the word "text" or "executable" we are not fooled

-      # into thinking "the wrong thing" because the file name matches the

-      # other 'file' command output we are looking for...

-      #

-      string(REPLACE "${file_full}" " _file_full_ " file_ov "${file_ov}")

-      string(TOLOWER "${file_ov}" file_ov)

-

-      #message(STATUS "file_ov='${file_ov}'")

-      if("${file_ov}" MATCHES "executable")

-        #message(STATUS "executable!")

-        if("${file_ov}" MATCHES "text")

-          #message(STATUS "but text, so *not* a binary executable!")

-        else("${file_ov}" MATCHES "text")

-          set(${result_var} 1 PARENT_SCOPE)

-          return()

-        endif("${file_ov}" MATCHES "text")

-      endif("${file_ov}" MATCHES "executable")

-    else(file_cmd)

-      message(STATUS "warning: No 'file' command, skipping execute_process...")

-    endif(file_cmd)

-  endif(UNIX)

-endfunction(is_file_executable)

-

-

-# gp_item_default_embedded_path item default_embedded_path_var

-#

-# Return the path that others should refer to the item by when the item

-# is embedded inside a bundle.

-#

-# Override on a per-project basis by providing a project-specific

-# gp_item_default_embedded_path_override function.

-#

-function(gp_item_default_embedded_path item default_embedded_path_var)

-

-  # On Windows and Linux, "embed" prerequisites in the same directory

-  # as the executable by default:

-  #

-  set(path "@executable_path")

-  set(overridden 0)

-

-  # On the Mac, relative to the executable depending on the type

-  # of the thing we are embedding:

-  #

-  if(APPLE)

-    #

-    # The assumption here is that all executables in the bundle will be

-    # in same-level-directories inside the bundle. The parent directory

-    # of an executable inside the bundle should be MacOS or a sibling of

-    # MacOS and all embedded paths returned from here will begin with

-    # "@executable_path/../" and will work from all executables in all

-    # such same-level-directories inside the bundle.

-    #

-

-    # By default, embed things right next to the main bundle executable:

-    #

-    set(path "@executable_path/../../Contents/MacOS")

-

-    # Embed .dylibs right next to the main bundle executable:

-    #

-    if(item MATCHES "\\.dylib$")

-      set(path "@executable_path/../MacOS")

-      set(overridden 1)

-    endif(item MATCHES "\\.dylib$")

-

-    # Embed frameworks in the embedded "Frameworks" directory (sibling of MacOS):

-    #

-    if(NOT overridden)

-      if(item MATCHES "[^/]+\\.framework/")

-        set(path "@executable_path/../Frameworks")

-        set(overridden 1)

-      endif(item MATCHES "[^/]+\\.framework/")

-    endif(NOT overridden)

-  endif()

-

-  # Provide a hook so that projects can override the default embedded location

-  # of any given library by whatever logic they choose:

-  #

-  if(COMMAND gp_item_default_embedded_path_override)

-    gp_item_default_embedded_path_override("${item}" path)

-  endif(COMMAND gp_item_default_embedded_path_override)

-

-  set(${default_embedded_path_var} "${path}" PARENT_SCOPE)

-endfunction(gp_item_default_embedded_path)

-

-

-# gp_resolve_item context item exepath dirs resolved_item_var

-#

-# Resolve an item into an existing full path file.

-#

-# Override on a per-project basis by providing a project-specific

-# gp_resolve_item_override function.

-#

-function(gp_resolve_item context item exepath dirs resolved_item_var)

-  set(resolved 0)

-  set(resolved_item "${item}")

-

-  # Is it already resolved?

-  #

-  if(EXISTS "${resolved_item}")

-    set(resolved 1)

-  endif(EXISTS "${resolved_item}")

-

-  if(NOT resolved)

-    if(item MATCHES "@executable_path")

-      #

-      # @executable_path references are assumed relative to exepath

-      #

-      string(REPLACE "@executable_path" "${exepath}" ri "${item}")

-      get_filename_component(ri "${ri}" ABSOLUTE)

-

-      if(EXISTS "${ri}")

-        #message(STATUS "info: embedded item exists (${ri})")

-        set(resolved 1)

-        set(resolved_item "${ri}")

-      else(EXISTS "${ri}")

-        message(STATUS "warning: embedded item does not exist '${ri}'")

-      endif(EXISTS "${ri}")

-    endif(item MATCHES "@executable_path")

-  endif(NOT resolved)

-

-  if(NOT resolved)

-    if(item MATCHES "@loader_path")

-      #

-      # @loader_path references are assumed relative to the

-      # PATH of the given "context" (presumably another library)

-      #

-      get_filename_component(contextpath "${context}" PATH)

-      string(REPLACE "@loader_path" "${contextpath}" ri "${item}")

-      get_filename_component(ri "${ri}" ABSOLUTE)

-

-      if(EXISTS "${ri}")

-        #message(STATUS "info: embedded item exists (${ri})")

-        set(resolved 1)

-        set(resolved_item "${ri}")

-      else(EXISTS "${ri}")

-        message(STATUS "warning: embedded item does not exist '${ri}'")

-      endif(EXISTS "${ri}")

-    endif(item MATCHES "@loader_path")

-  endif(NOT resolved)

-

-  if(NOT resolved)

-    set(ri "ri-NOTFOUND")

-    find_file(ri "${item}" ${exepath} ${dirs} NO_DEFAULT_PATH)

-    find_file(ri "${item}" ${exepath} ${dirs} /usr/lib)

-    if(ri)

-      #message(STATUS "info: 'find_file' in exepath/dirs (${ri})")

-      set(resolved 1)

-      set(resolved_item "${ri}")

-      set(ri "ri-NOTFOUND")

-    endif(ri)

-  endif(NOT resolved)

-

-  if(NOT resolved)

-    if(item MATCHES "[^/]+\\.framework/")

-      set(fw "fw-NOTFOUND")

-      find_file(fw "${item}"

-        "~/Library/Frameworks"

-        "/Library/Frameworks"

-        "/System/Library/Frameworks"

-      )

-      if(fw)

-        #message(STATUS "info: 'find_file' found framework (${fw})")

-        set(resolved 1)

-        set(resolved_item "${fw}")

-        set(fw "fw-NOTFOUND")

-      endif(fw)

-    endif(item MATCHES "[^/]+\\.framework/")

-  endif(NOT resolved)

-

-  # Using find_program on Windows will find dll files that are in the PATH.

-  # (Converting simple file names into full path names if found.)

-  #

-  if(WIN32)

-  if(NOT resolved)

-    set(ri "ri-NOTFOUND")

-    find_program(ri "${item}" PATHS "${exepath};${dirs}" NO_DEFAULT_PATH)

-    find_program(ri "${item}" PATHS "${exepath};${dirs}")

-    if(ri)

-      #message(STATUS "info: 'find_program' in exepath/dirs (${ri})")

-      set(resolved 1)

-      set(resolved_item "${ri}")

-      set(ri "ri-NOTFOUND")

-    endif(ri)

-  endif(NOT resolved)

-  endif(WIN32)

-

-  # Provide a hook so that projects can override item resolution

-  # by whatever logic they choose:

-  #

-  if(COMMAND gp_resolve_item_override)

-    gp_resolve_item_override("${context}" "${item}" "${exepath}" "${dirs}" resolved_item resolved)

-  endif(COMMAND gp_resolve_item_override)

-

-  if(NOT resolved)

-    message(STATUS "

-warning: cannot resolve item '${item}'

-

-  possible problems:

-    need more directories?

-    need to use InstallRequiredSystemLibraries?

-    run in install tree instead of build tree?

-")

-#    message(STATUS "

-#******************************************************************************

-#warning: cannot resolve item '${item}'

-#

-#  possible problems:

-#    need more directories?

-#    need to use InstallRequiredSystemLibraries?

-#    run in install tree instead of build tree?

-#

-#    context='${context}'

-#    item='${item}'

-#    exepath='${exepath}'

-#    dirs='${dirs}'

-#    resolved_item_var='${resolved_item_var}'

-#******************************************************************************

-#")

-  endif(NOT resolved)

-

-  set(${resolved_item_var} "${resolved_item}" PARENT_SCOPE)

-endfunction(gp_resolve_item)

-

-

-# gp_resolved_file_type original_file file exepath dirs type_var

-#

-# Return the type of ${file} with respect to ${original_file}. String

-# describing type of prerequisite is returned in variable named ${type_var}.

-#

-# Use ${exepath} and ${dirs} if necessary to resolve non-absolute ${file}

-# values -- but only for non-embedded items.

-#

-# Possible types are:

-#   system

-#   local

-#   embedded

-#   other

-#

-function(gp_resolved_file_type original_file file exepath dirs type_var)

-  #message(STATUS "**")

-

-  if(NOT IS_ABSOLUTE "${original_file}")

-    message(STATUS "warning: gp_resolved_file_type expects absolute full path for first arg original_file")

-  endif()

-

-  set(is_embedded 0)

-  set(is_local 0)

-  set(is_system 0)

-

-  set(resolved_file "${file}")

-

-  if("${file}" MATCHES "^@(executable|loader)_path")

-    set(is_embedded 1)

-  endif()

-

-  if(NOT is_embedded)

-    if(NOT IS_ABSOLUTE "${file}")

-      gp_resolve_item("${original_file}" "${file}" "${exepath}" "${dirs}" resolved_file)

-    endif()

-

-    string(TOLOWER "${original_file}" original_lower)

-    string(TOLOWER "${resolved_file}" lower)

-

-    if(UNIX)

-      if(resolved_file MATCHES "^(/lib/|/lib32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/lib64/|/usr/X11R6/)")

-        set(is_system 1)

-      endif()

-    endif()

-

-    if(APPLE)

-      if(resolved_file MATCHES "^(/System/Library/|/usr/lib/)")

-        set(is_system 1)

-      endif()

-    endif()

-

-    if(WIN32)

-      string(TOLOWER "$ENV{SystemRoot}" sysroot)

-      string(REGEX REPLACE "\\\\" "/" sysroot "${sysroot}")

-

-      string(TOLOWER "$ENV{windir}" windir)

-      string(REGEX REPLACE "\\\\" "/" windir "${windir}")

-

-      if(lower MATCHES "^(${sysroot}/system|${windir}/system|${sysroot}/syswow|${windir}/syswow|(.*/)*msvc[^/]+dll)")

-        set(is_system 1)

-      endif()

-    endif()

-

-    if(NOT is_system)

-      get_filename_component(original_path "${original_lower}" PATH)

-      get_filename_component(path "${lower}" PATH)

-      if("${original_path}" STREQUAL "${path}")

-        set(is_local 1)

-      endif()

-    endif()

-  endif()

-

-  # Return type string based on computed booleans:

-  #

-  set(type "other")

-

-  if(is_system)

-    set(type "system")

-  elseif(is_embedded)

-    set(type "embedded")

-  elseif(is_local)

-    set(type "local")

-  endif()

-

-  #message(STATUS "gp_resolved_file_type: '${file}' '${resolved_file}'")

-  #message(STATUS "                type: '${type}'")

-

-  if(NOT is_embedded)

-    if(NOT IS_ABSOLUTE "${resolved_file}")

-      if(lower MATCHES "^msvc[^/]+dll" AND is_system)

-        message(STATUS "info: non-absolute msvc file '${file}' returning type '${type}'")

-      else()

-        message(STATUS "warning: gp_resolved_file_type non-absolute file '${file}' returning type '${type}' -- possibly incorrect")

-      endif()

-    endif()

-  endif()

-

-  set(${type_var} "${type}" PARENT_SCOPE)

-

-  #message(STATUS "**")

-endfunction()

-

-

-# gp_file_type original_file file type_var

-#

-# Return the type of ${file} with respect to ${original_file}. String

-# describing type of prerequisite is returned in variable named ${type_var}.

-#

-# Possible types are:

-#   system

-#   local

-#   embedded

-#   other

-#

-function(gp_file_type original_file file type_var)

-  if(NOT IS_ABSOLUTE "${original_file}")

-    message(STATUS "warning: gp_file_type expects absolute full path for first arg original_file")

-  endif()

-

-  get_filename_component(exepath "${original_file}" PATH)

-

-  set(type "")

-  gp_resolved_file_type("${original_file}" "${file}" "${exepath}" "" type)

-

-  set(${type_var} "${type}" PARENT_SCOPE)

-endfunction(gp_file_type)

-

-

-# get_prerequisites target prerequisites_var exclude_system recurse dirs

-#

-# Get the list of shared library files required by ${target}. The list in

-# the variable named ${prerequisites_var} should be empty on first entry to

-# this function. On exit, ${prerequisites_var} will contain the list of

-# required shared library files.

-#

-#  target is the full path to an executable file

-#

-#  prerequisites_var is the name of a CMake variable to contain the results

-#

-#  exclude_system is 0 or 1: 0 to include "system" prerequisites , 1 to

-#   exclude them

-#

-#  recurse is 0 or 1: 0 for direct prerequisites only, 1 for all prerequisites

-#   recursively

-#

-#  exepath is the path to the top level executable used for @executable_path

-#   replacment on the Mac

-#

-#  dirs is a list of paths where libraries might be found: these paths are

-#   searched first when a target without any path info is given. Then standard

-#   system locations are also searched: PATH, Framework locations, /usr/lib...

-#

-function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)

-  set(verbose 0)

-  set(eol_char "E")

-

-  if(NOT IS_ABSOLUTE "${target}")

-    message("warning: target '${target}' is not absolute...")

-  endif(NOT IS_ABSOLUTE "${target}")

-

-  if(NOT EXISTS "${target}")

-    message("warning: target '${target}' does not exist...")

-  endif(NOT EXISTS "${target}")

-

-  # <setup-gp_tool-vars>

-  #

-  # Try to choose the right tool by default. Caller can set gp_tool prior to

-  # calling this function to force using a different tool.

-  #

-  if("${gp_tool}" STREQUAL "")

-    set(gp_tool "ldd")

-    if(APPLE)

-      set(gp_tool "otool")

-    endif(APPLE)

-    if(WIN32)

-      set(gp_tool "dumpbin")

-    endif(WIN32)

-  endif("${gp_tool}" STREQUAL "")

-

-  set(gp_tool_known 0)

-

-  if("${gp_tool}" STREQUAL "ldd")

-    set(gp_cmd_args "")

-    set(gp_regex "^[\t ]*[^\t ]+ => ([^\t ]+).*${eol_char}$")

-    set(gp_regex_cmp_count 1)

-    set(gp_tool_known 1)

-  endif("${gp_tool}" STREQUAL "ldd")

-

-  if("${gp_tool}" STREQUAL "otool")

-    set(gp_cmd_args "-L")

-    set(gp_regex "^\t([^\t]+) \\(compatibility version ([0-9]+.[0-9]+.[0-9]+), current version ([0-9]+.[0-9]+.[0-9]+)\\)${eol_char}$")

-    set(gp_regex_cmp_count 3)

-    set(gp_tool_known 1)

-  endif("${gp_tool}" STREQUAL "otool")

-

-  if("${gp_tool}" STREQUAL "dumpbin")

-    set(gp_cmd_args "/dependents")

-    set(gp_regex "^    ([^ ].*[Dd][Ll][Ll])${eol_char}$")

-    set(gp_regex_cmp_count 1)

-    set(gp_tool_known 1)

-    set(ENV{VS_UNICODE_OUTPUT} "") # Block extra output from inside VS IDE.

-  endif("${gp_tool}" STREQUAL "dumpbin")

-

-  if(NOT gp_tool_known)

-    message(STATUS "warning: gp_tool='${gp_tool}' is an unknown tool...")

-    message(STATUS "CMake function get_prerequisites needs more code to handle '${gp_tool}'")

-    message(STATUS "Valid gp_tool values are dumpbin, ldd and otool.")

-    return()

-  endif(NOT gp_tool_known)

-

-  set(gp_cmd_paths ${gp_cmd_paths}

-    "C:/Program Files/Microsoft Visual Studio 9.0/VC/bin"

-    "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/bin"

-    "C:/Program Files/Microsoft Visual Studio 8/VC/BIN"

-    "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/BIN"

-    "C:/Program Files/Microsoft Visual Studio .NET 2003/VC7/BIN"

-    "C:/Program Files (x86)/Microsoft Visual Studio .NET 2003/VC7/BIN"

-    "/usr/local/bin"

-    "/usr/bin"

-    )

-

-  find_program(gp_cmd ${gp_tool} PATHS ${gp_cmd_paths})

-

-  if(NOT gp_cmd)

-    message(STATUS "warning: could not find '${gp_tool}' - cannot analyze prerequisites...")

-    return()

-  endif(NOT gp_cmd)

-

-  if("${gp_tool}" STREQUAL "dumpbin")

-    # When running dumpbin, it also needs the "Common7/IDE" directory in the

-    # PATH. It will already be in the PATH if being run from a Visual Studio

-    # command prompt. Add it to the PATH here in case we are running from a

-    # different command prompt.

-    #

-    get_filename_component(gp_cmd_dir "${gp_cmd}" PATH)

-    get_filename_component(gp_cmd_dlls_dir "${gp_cmd_dir}/../../Common7/IDE" ABSOLUTE)

-    if(EXISTS "${gp_cmd_dlls_dir}")

-      # only add to the path if it is not already in the path

-      if(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")

-        set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")

-      endif(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")

-    endif(EXISTS "${gp_cmd_dlls_dir}")

-  endif("${gp_tool}" STREQUAL "dumpbin")

-  #

-  # </setup-gp_tool-vars>

-

-  if("${gp_tool}" STREQUAL "ldd")

-    set(old_ld_env "$ENV{LD_LIBRARY_PATH}")

-    foreach(dir ${exepath} ${dirs})

-      set(ENV{LD_LIBRARY_PATH} "${dir}:$ENV{LD_LIBRARY_PATH}")

-    endforeach(dir)

-  endif("${gp_tool}" STREQUAL "ldd")

-

-

-  # Track new prerequisites at each new level of recursion. Start with an

-  # empty list at each level:

-  #

-  set(unseen_prereqs)

-

-  # Run gp_cmd on the target:

-  #

-  execute_process(

-    COMMAND ${gp_cmd} ${gp_cmd_args} ${target}

-    OUTPUT_VARIABLE gp_cmd_ov

-    )

-

-  if("${gp_tool}" STREQUAL "ldd")

-    set(ENV{LD_LIBRARY_PATH} "${old_ld_env}")

-  endif("${gp_tool}" STREQUAL "ldd")

-

-  if(verbose)

-    message(STATUS "<RawOutput cmd='${gp_cmd} ${gp_cmd_args} ${target}'>")

-    message(STATUS "gp_cmd_ov='${gp_cmd_ov}'")

-    message(STATUS "</RawOutput>")

-  endif(verbose)

-

-  get_filename_component(target_dir "${target}" PATH)

-

-  # Convert to a list of lines:

-  #

-  string(REGEX REPLACE ";" "\\\\;" candidates "${gp_cmd_ov}")

-  string(REGEX REPLACE "\n" "${eol_char};" candidates "${candidates}")

-

-  # Analyze each line for file names that match the regular expression:

-  #

-  foreach(candidate ${candidates})

-  if("${candidate}" MATCHES "${gp_regex}")

-    # Extract information from each candidate:

-    string(REGEX REPLACE "${gp_regex}" "\\1" raw_item "${candidate}")

-

-    if(gp_regex_cmp_count GREATER 1)

-      string(REGEX REPLACE "${gp_regex}" "\\2" raw_compat_version "${candidate}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" compat_major_version "${raw_compat_version}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" compat_minor_version "${raw_compat_version}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" compat_patch_version "${raw_compat_version}")

-    endif(gp_regex_cmp_count GREATER 1)

-

-    if(gp_regex_cmp_count GREATER 2)

-      string(REGEX REPLACE "${gp_regex}" "\\3" raw_current_version "${candidate}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" current_major_version "${raw_current_version}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" current_minor_version "${raw_current_version}")

-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" current_patch_version "${raw_current_version}")

-    endif(gp_regex_cmp_count GREATER 2)

-

-    # Use the raw_item as the list entries returned by this function. Use the

-    # gp_resolve_item function to resolve it to an actual full path file if

-    # necessary.

-    #

-    set(item "${raw_item}")

-

-    # Add each item unless it is excluded:

-    #

-    set(add_item 1)

-

-    if(${exclude_system})

-      set(type "")

-      gp_resolved_file_type("${target}" "${item}" "${exepath}" "${dirs}" type)

-      if("${type}" STREQUAL "system")

-        set(add_item 0)

-      endif("${type}" STREQUAL "system")

-    endif(${exclude_system})

-

-    if(add_item)

-      list(LENGTH ${prerequisites_var} list_length_before_append)

-      gp_append_unique(${prerequisites_var} "${item}")

-      list(LENGTH ${prerequisites_var} list_length_after_append)

-

-      if(${recurse})

-        # If item was really added, this is the first time we have seen it.

-        # Add it to unseen_prereqs so that we can recursively add *its*

-        # prerequisites...

-        #

-        # But first: resolve its name to an absolute full path name such

-        # that the analysis tools can simply accept it as input.

-        #

-        if(NOT list_length_before_append EQUAL list_length_after_append)

-          gp_resolve_item("${target}" "${item}" "${exepath}" "${dirs}" resolved_item)

-          set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")

-        endif(NOT list_length_before_append EQUAL list_length_after_append)

-      endif(${recurse})

-    endif(add_item)

-  else("${candidate}" MATCHES "${gp_regex}")

-    if(verbose)

-      message(STATUS "ignoring non-matching line: '${candidate}'")

-    endif(verbose)

-  endif("${candidate}" MATCHES "${gp_regex}")

-  endforeach(candidate)

-

-  list(LENGTH ${prerequisites_var} prerequisites_var_length)

-  if(prerequisites_var_length GREATER 0)

-    list(SORT ${prerequisites_var})

-  endif(prerequisites_var_length GREATER 0)

-  if(${recurse})

-    set(more_inputs ${unseen_prereqs})

-    foreach(input ${more_inputs})

-      get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")

-    endforeach(input)

-  endif(${recurse})

-

-  set(${prerequisites_var} ${${prerequisites_var}} PARENT_SCOPE)

-endfunction(get_prerequisites)

-

-

-# list_prerequisites target all exclude_system verbose

-#

-#  ARGV0 (target) is the full path to an executable file

-#

-#  optional ARGV1 (all) is 0 or 1: 0 for direct prerequisites only,

-#   1 for all prerequisites recursively

-#

-#  optional ARGV2 (exclude_system) is 0 or 1: 0 to include "system"

-#   prerequisites , 1 to exclude them

-#

-#  optional ARGV3 (verbose) is 0 or 1: 0 to print only full path

-#   names of prerequisites, 1 to print extra information

-#

-function(list_prerequisites target)

-  if("${ARGV1}" STREQUAL "")

-    set(all 1)

-  else("${ARGV1}" STREQUAL "")

-    set(all "${ARGV1}")

-  endif("${ARGV1}" STREQUAL "")

-

-  if("${ARGV2}" STREQUAL "")

-    set(exclude_system 0)

-  else("${ARGV2}" STREQUAL "")

-    set(exclude_system "${ARGV2}")

-  endif("${ARGV2}" STREQUAL "")

-

-  if("${ARGV3}" STREQUAL "")

-    set(verbose 0)

-  else("${ARGV3}" STREQUAL "")

-    set(verbose "${ARGV3}")

-  endif("${ARGV3}" STREQUAL "")

-

-  set(count 0)

-  set(count_str "")

-  set(print_count "${verbose}")

-  set(print_prerequisite_type "${verbose}")

-  set(print_target "${verbose}")

-  set(type_str "")

-

-  get_filename_component(exepath "${target}" PATH)

-

-  set(prereqs "")

-  get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${exepath}" "")

-

-  if(print_target)

-    message(STATUS "File '${target}' depends on:")

-  endif(print_target)

-

-  foreach(d ${prereqs})

-    math(EXPR count "${count} + 1")

-

-    if(print_count)

-      set(count_str "${count}. ")

-    endif(print_count)

-

-    if(print_prerequisite_type)

-      gp_file_type("${target}" "${d}" type)

-      set(type_str " (${type})")

-    endif(print_prerequisite_type)

-

-    message(STATUS "${count_str}${d}${type_str}")

-  endforeach(d)

-endfunction(list_prerequisites)

-

-

-# list_prerequisites_by_glob glob_arg glob_exp

-#

-#  glob_arg is GLOB or GLOB_RECURSE

-#

-#  glob_exp is a globbing expression used with "file(GLOB" to retrieve a list

-#   of matching files. If a matching file is executable, its prerequisites are

-#   listed.

-#

-# Any additional (optional) arguments provided are passed along as the

-# optional arguments to the list_prerequisites calls.

-#

-function(list_prerequisites_by_glob glob_arg glob_exp)

-  message(STATUS "=============================================================================")

-  message(STATUS "List prerequisites of executables matching ${glob_arg} '${glob_exp}'")

-  message(STATUS "")

-  file(${glob_arg} file_list ${glob_exp})

-  foreach(f ${file_list})

-    is_file_executable("${f}" is_f_executable)

-    if(is_f_executable)

-      message(STATUS "=============================================================================")

-      list_prerequisites("${f}" ${ARGN})

-      message(STATUS "")

-    endif(is_f_executable)

-  endforeach(f)

-endfunction(list_prerequisites_by_glob)

+# GetPrerequisites.cmake
+#
+# This script provides functions to list the .dll, .dylib or .so files that an
+# executable or shared library file depends on. (Its prerequisites.)
+#
+# It uses various tools to obtain the list of required shared library files:
+#   dumpbin (Windows)
+#   ldd (Linux/Unix)
+#   otool (Mac OSX)
+#
+# The following functions are provided by this script:
+#   gp_append_unique
+#   is_file_executable
+#   gp_item_default_embedded_path
+#     (projects can override with gp_item_default_embedded_path_override)
+#   gp_resolve_item
+#     (projects can override with gp_resolve_item_override)
+#   gp_resolved_file_type
+#   gp_file_type
+#   get_prerequisites
+#   list_prerequisites
+#   list_prerequisites_by_glob
+#
+# Requires CMake 2.6 or greater because it uses function, break, return and
+# PARENT_SCOPE.
+
+#=============================================================================
+# Copyright 2008-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# gp_append_unique list_var value
+#
+# Append value to the list variable ${list_var} only if the value is not
+# already in the list.
+#
+function(gp_append_unique list_var value)
+  set(contains 0)
+
+  foreach(item ${${list_var}})
+    if("${item}" STREQUAL "${value}")
+      set(contains 1)
+      break()
+    endif("${item}" STREQUAL "${value}")
+  endforeach(item)
+
+  if(NOT contains)
+    set(${list_var} ${${list_var}} "${value}" PARENT_SCOPE)
+  endif(NOT contains)
+endfunction(gp_append_unique)
+
+
+# is_file_executable file result_var
+#
+# Return 1 in ${result_var} if ${file} is a binary executable.
+#
+# Return 0 in ${result_var} otherwise.
+#
+function(is_file_executable file result_var)
+  #
+  # A file is not executable until proven otherwise:
+  #
+  set(${result_var} 0 PARENT_SCOPE)
+
+  get_filename_component(file_full "${file}" ABSOLUTE)
+  string(TOLOWER "${file_full}" file_full_lower)
+
+  # If file name ends in .exe on Windows, *assume* executable:
+  #
+  if(WIN32)
+    if("${file_full_lower}" MATCHES "\\.exe$")
+      set(${result_var} 1 PARENT_SCOPE)
+      return()
+    endif("${file_full_lower}" MATCHES "\\.exe$")
+
+    # A clause could be added here that uses output or return value of dumpbin
+    # to determine ${result_var}. In 99%+? practical cases, the exe name
+    # match will be sufficient...
+    #
+  endif(WIN32)
+
+  # Use the information returned from the Unix shell command "file" to
+  # determine if ${file_full} should be considered an executable file...
+  #
+  # If the file command's output contains "executable" and does *not* contain
+  # "text" then it is likely an executable suitable for prerequisite analysis
+  # via the get_prerequisites macro.
+  #
+  if(UNIX)
+    if(NOT file_cmd)
+      find_program(file_cmd "file")
+    endif(NOT file_cmd)
+
+    if(file_cmd)
+      execute_process(COMMAND "${file_cmd}" "${file_full}"
+        OUTPUT_VARIABLE file_ov
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+
+      # Replace the name of the file in the output with a placeholder token
+      # (the string " _file_full_ ") so that just in case the path name of
+      # the file contains the word "text" or "executable" we are not fooled
+      # into thinking "the wrong thing" because the file name matches the
+      # other 'file' command output we are looking for...
+      #
+      string(REPLACE "${file_full}" " _file_full_ " file_ov "${file_ov}")
+      string(TOLOWER "${file_ov}" file_ov)
+
+      #message(STATUS "file_ov='${file_ov}'")
+      if("${file_ov}" MATCHES "executable")
+        #message(STATUS "executable!")
+        if("${file_ov}" MATCHES "text")
+          #message(STATUS "but text, so *not* a binary executable!")
+        else("${file_ov}" MATCHES "text")
+          set(${result_var} 1 PARENT_SCOPE)
+          return()
+        endif("${file_ov}" MATCHES "text")
+      endif("${file_ov}" MATCHES "executable")
+    else(file_cmd)
+      message(STATUS "warning: No 'file' command, skipping execute_process...")
+    endif(file_cmd)
+  endif(UNIX)
+endfunction(is_file_executable)
+
+
+# gp_item_default_embedded_path item default_embedded_path_var
+#
+# Return the path that others should refer to the item by when the item
+# is embedded inside a bundle.
+#
+# Override on a per-project basis by providing a project-specific
+# gp_item_default_embedded_path_override function.
+#
+function(gp_item_default_embedded_path item default_embedded_path_var)
+
+  # On Windows and Linux, "embed" prerequisites in the same directory
+  # as the executable by default:
+  #
+  set(path "@executable_path")
+  set(overridden 0)
+
+  # On the Mac, relative to the executable depending on the type
+  # of the thing we are embedding:
+  #
+  if(APPLE)
+    #
+    # The assumption here is that all executables in the bundle will be
+    # in same-level-directories inside the bundle. The parent directory
+    # of an executable inside the bundle should be MacOS or a sibling of
+    # MacOS and all embedded paths returned from here will begin with
+    # "@executable_path/../" and will work from all executables in all
+    # such same-level-directories inside the bundle.
+    #
+
+    # By default, embed things right next to the main bundle executable:
+    #
+    set(path "@executable_path/../../Contents/MacOS")
+
+    # Embed .dylibs right next to the main bundle executable:
+    #
+    if(item MATCHES "\\.dylib$")
+      set(path "@executable_path/../MacOS")
+      set(overridden 1)
+    endif(item MATCHES "\\.dylib$")
+
+    # Embed frameworks in the embedded "Frameworks" directory (sibling of MacOS):
+    #
+    if(NOT overridden)
+      if(item MATCHES "[^/]+\\.framework/")
+        set(path "@executable_path/../Frameworks")
+        set(overridden 1)
+      endif(item MATCHES "[^/]+\\.framework/")
+    endif(NOT overridden)
+  endif()
+
+  # Provide a hook so that projects can override the default embedded location
+  # of any given library by whatever logic they choose:
+  #
+  if(COMMAND gp_item_default_embedded_path_override)
+    gp_item_default_embedded_path_override("${item}" path)
+  endif(COMMAND gp_item_default_embedded_path_override)
+
+  set(${default_embedded_path_var} "${path}" PARENT_SCOPE)
+endfunction(gp_item_default_embedded_path)
+
+
+# gp_resolve_item context item exepath dirs resolved_item_var
+#
+# Resolve an item into an existing full path file.
+#
+# Override on a per-project basis by providing a project-specific
+# gp_resolve_item_override function.
+#
+function(gp_resolve_item context item exepath dirs resolved_item_var)
+  set(resolved 0)
+  set(resolved_item "${item}")
+
+  # Is it already resolved?
+  #
+  if(EXISTS "${resolved_item}")
+    set(resolved 1)
+  endif(EXISTS "${resolved_item}")
+
+  if(NOT resolved)
+    if(item MATCHES "@executable_path")
+      #
+      # @executable_path references are assumed relative to exepath
+      #
+      string(REPLACE "@executable_path" "${exepath}" ri "${item}")
+      get_filename_component(ri "${ri}" ABSOLUTE)
+
+      if(EXISTS "${ri}")
+        #message(STATUS "info: embedded item exists (${ri})")
+        set(resolved 1)
+        set(resolved_item "${ri}")
+      else(EXISTS "${ri}")
+        message(STATUS "warning: embedded item does not exist '${ri}'")
+      endif(EXISTS "${ri}")
+    endif(item MATCHES "@executable_path")
+  endif(NOT resolved)
+
+  if(NOT resolved)
+    if(item MATCHES "@loader_path")
+      #
+      # @loader_path references are assumed relative to the
+      # PATH of the given "context" (presumably another library)
+      #
+      get_filename_component(contextpath "${context}" PATH)
+      string(REPLACE "@loader_path" "${contextpath}" ri "${item}")
+      get_filename_component(ri "${ri}" ABSOLUTE)
+
+      if(EXISTS "${ri}")
+        #message(STATUS "info: embedded item exists (${ri})")
+        set(resolved 1)
+        set(resolved_item "${ri}")
+      else(EXISTS "${ri}")
+        message(STATUS "warning: embedded item does not exist '${ri}'")
+      endif(EXISTS "${ri}")
+    endif(item MATCHES "@loader_path")
+  endif(NOT resolved)
+
+  if(NOT resolved)
+    set(ri "ri-NOTFOUND")
+    find_file(ri "${item}" ${exepath} ${dirs} NO_DEFAULT_PATH)
+    find_file(ri "${item}" ${exepath} ${dirs} /usr/lib)
+    if(ri)
+      #message(STATUS "info: 'find_file' in exepath/dirs (${ri})")
+      set(resolved 1)
+      set(resolved_item "${ri}")
+      set(ri "ri-NOTFOUND")
+    endif(ri)
+  endif(NOT resolved)
+
+  if(NOT resolved)
+    if(item MATCHES "[^/]+\\.framework/")
+      set(fw "fw-NOTFOUND")
+      find_file(fw "${item}"
+        "~/Library/Frameworks"
+        "/Library/Frameworks"
+        "/System/Library/Frameworks"
+      )
+      if(fw)
+        #message(STATUS "info: 'find_file' found framework (${fw})")
+        set(resolved 1)
+        set(resolved_item "${fw}")
+        set(fw "fw-NOTFOUND")
+      endif(fw)
+    endif(item MATCHES "[^/]+\\.framework/")
+  endif(NOT resolved)
+
+  # Using find_program on Windows will find dll files that are in the PATH.
+  # (Converting simple file names into full path names if found.)
+  #
+  if(WIN32)
+  if(NOT resolved)
+    set(ri "ri-NOTFOUND")
+    find_program(ri "${item}" PATHS "${exepath};${dirs}" NO_DEFAULT_PATH)
+    find_program(ri "${item}" PATHS "${exepath};${dirs}")
+    if(ri)
+      #message(STATUS "info: 'find_program' in exepath/dirs (${ri})")
+      set(resolved 1)
+      set(resolved_item "${ri}")
+      set(ri "ri-NOTFOUND")
+    endif(ri)
+  endif(NOT resolved)
+  endif(WIN32)
+
+  # Provide a hook so that projects can override item resolution
+  # by whatever logic they choose:
+  #
+  if(COMMAND gp_resolve_item_override)
+    gp_resolve_item_override("${context}" "${item}" "${exepath}" "${dirs}" resolved_item resolved)
+  endif(COMMAND gp_resolve_item_override)
+
+  if(NOT resolved)
+    message(STATUS "
+warning: cannot resolve item '${item}'
+
+  possible problems:
+    need more directories?
+    need to use InstallRequiredSystemLibraries?
+    run in install tree instead of build tree?
+")
+#    message(STATUS "
+#******************************************************************************
+#warning: cannot resolve item '${item}'
+#
+#  possible problems:
+#    need more directories?
+#    need to use InstallRequiredSystemLibraries?
+#    run in install tree instead of build tree?
+#
+#    context='${context}'
+#    item='${item}'
+#    exepath='${exepath}'
+#    dirs='${dirs}'
+#    resolved_item_var='${resolved_item_var}'
+#******************************************************************************
+#")
+  endif(NOT resolved)
+
+  set(${resolved_item_var} "${resolved_item}" PARENT_SCOPE)
+endfunction(gp_resolve_item)
+
+
+# gp_resolved_file_type original_file file exepath dirs type_var
+#
+# Return the type of ${file} with respect to ${original_file}. String
+# describing type of prerequisite is returned in variable named ${type_var}.
+#
+# Use ${exepath} and ${dirs} if necessary to resolve non-absolute ${file}
+# values -- but only for non-embedded items.
+#
+# Possible types are:
+#   system
+#   local
+#   embedded
+#   other
+#
+function(gp_resolved_file_type original_file file exepath dirs type_var)
+  #message(STATUS "**")
+
+  if(NOT IS_ABSOLUTE "${original_file}")
+    message(STATUS "warning: gp_resolved_file_type expects absolute full path for first arg original_file")
+  endif()
+
+  set(is_embedded 0)
+  set(is_local 0)
+  set(is_system 0)
+
+  set(resolved_file "${file}")
+
+  if("${file}" MATCHES "^@(executable|loader)_path")
+    set(is_embedded 1)
+  endif()
+
+  if(NOT is_embedded)
+    if(NOT IS_ABSOLUTE "${file}")
+      gp_resolve_item("${original_file}" "${file}" "${exepath}" "${dirs}" resolved_file)
+    endif()
+
+    string(TOLOWER "${original_file}" original_lower)
+    string(TOLOWER "${resolved_file}" lower)
+
+    if(UNIX)
+      if(resolved_file MATCHES "^(/lib/|/lib32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/lib64/|/usr/X11R6/)")
+        set(is_system 1)
+      endif()
+    endif()
+
+    if(APPLE)
+      if(resolved_file MATCHES "^(/System/Library/|/usr/lib/)")
+        set(is_system 1)
+      endif()
+    endif()
+
+    if(WIN32)
+      string(TOLOWER "$ENV{SystemRoot}" sysroot)
+      string(REGEX REPLACE "\\\\" "/" sysroot "${sysroot}")
+
+      string(TOLOWER "$ENV{windir}" windir)
+      string(REGEX REPLACE "\\\\" "/" windir "${windir}")
+
+      if(lower MATCHES "^(${sysroot}/system|${windir}/system|${sysroot}/syswow|${windir}/syswow|(.*/)*msvc[^/]+dll)")
+        set(is_system 1)
+      endif()
+    endif()
+
+    if(NOT is_system)
+      get_filename_component(original_path "${original_lower}" PATH)
+      get_filename_component(path "${lower}" PATH)
+      if("${original_path}" STREQUAL "${path}")
+        set(is_local 1)
+      endif()
+    endif()
+  endif()
+
+  # Return type string based on computed booleans:
+  #
+  set(type "other")
+
+  if(is_system)
+    set(type "system")
+  elseif(is_embedded)
+    set(type "embedded")
+  elseif(is_local)
+    set(type "local")
+  endif()
+
+  #message(STATUS "gp_resolved_file_type: '${file}' '${resolved_file}'")
+  #message(STATUS "                type: '${type}'")
+
+  if(NOT is_embedded)
+    if(NOT IS_ABSOLUTE "${resolved_file}")
+      if(lower MATCHES "^msvc[^/]+dll" AND is_system)
+        message(STATUS "info: non-absolute msvc file '${file}' returning type '${type}'")
+      else()
+        message(STATUS "warning: gp_resolved_file_type non-absolute file '${file}' returning type '${type}' -- possibly incorrect")
+      endif()
+    endif()
+  endif()
+
+  set(${type_var} "${type}" PARENT_SCOPE)
+
+  #message(STATUS "**")
+endfunction()
+
+
+# gp_file_type original_file file type_var
+#
+# Return the type of ${file} with respect to ${original_file}. String
+# describing type of prerequisite is returned in variable named ${type_var}.
+#
+# Possible types are:
+#   system
+#   local
+#   embedded
+#   other
+#
+function(gp_file_type original_file file type_var)
+  if(NOT IS_ABSOLUTE "${original_file}")
+    message(STATUS "warning: gp_file_type expects absolute full path for first arg original_file")
+  endif()
+
+  get_filename_component(exepath "${original_file}" PATH)
+
+  set(type "")
+  gp_resolved_file_type("${original_file}" "${file}" "${exepath}" "" type)
+
+  set(${type_var} "${type}" PARENT_SCOPE)
+endfunction(gp_file_type)
+
+
+# get_prerequisites target prerequisites_var exclude_system recurse dirs
+#
+# Get the list of shared library files required by ${target}. The list in
+# the variable named ${prerequisites_var} should be empty on first entry to
+# this function. On exit, ${prerequisites_var} will contain the list of
+# required shared library files.
+#
+#  target is the full path to an executable file
+#
+#  prerequisites_var is the name of a CMake variable to contain the results
+#
+#  exclude_system is 0 or 1: 0 to include "system" prerequisites , 1 to
+#   exclude them
+#
+#  recurse is 0 or 1: 0 for direct prerequisites only, 1 for all prerequisites
+#   recursively
+#
+#  exepath is the path to the top level executable used for @executable_path
+#   replacment on the Mac
+#
+#  dirs is a list of paths where libraries might be found: these paths are
+#   searched first when a target without any path info is given. Then standard
+#   system locations are also searched: PATH, Framework locations, /usr/lib...
+#
+function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)
+  set(verbose 0)
+  set(eol_char "E")
+
+  if(NOT IS_ABSOLUTE "${target}")
+    message("warning: target '${target}' is not absolute...")
+  endif(NOT IS_ABSOLUTE "${target}")
+
+  if(NOT EXISTS "${target}")
+    message("warning: target '${target}' does not exist...")
+  endif(NOT EXISTS "${target}")
+
+  # <setup-gp_tool-vars>
+  #
+  # Try to choose the right tool by default. Caller can set gp_tool prior to
+  # calling this function to force using a different tool.
+  #
+  if("${gp_tool}" STREQUAL "")
+    set(gp_tool "ldd")
+    if(APPLE)
+      set(gp_tool "otool")
+    endif(APPLE)
+    if(WIN32)
+      set(gp_tool "dumpbin")
+    endif(WIN32)
+  endif("${gp_tool}" STREQUAL "")
+
+  set(gp_tool_known 0)
+
+  if("${gp_tool}" STREQUAL "ldd")
+    set(gp_cmd_args "")
+    set(gp_regex "^[\t ]*[^\t ]+ => ([^\t ]+).*${eol_char}$")
+    set(gp_regex_cmp_count 1)
+    set(gp_tool_known 1)
+  endif("${gp_tool}" STREQUAL "ldd")
+
+  if("${gp_tool}" STREQUAL "otool")
+    set(gp_cmd_args "-L")
+    set(gp_regex "^\t([^\t]+) \\(compatibility version ([0-9]+.[0-9]+.[0-9]+), current version ([0-9]+.[0-9]+.[0-9]+)\\)${eol_char}$")
+    set(gp_regex_cmp_count 3)
+    set(gp_tool_known 1)
+  endif("${gp_tool}" STREQUAL "otool")
+
+  if("${gp_tool}" STREQUAL "dumpbin")
+    set(gp_cmd_args "/dependents")
+    set(gp_regex "^    ([^ ].*[Dd][Ll][Ll])${eol_char}$")
+    set(gp_regex_cmp_count 1)
+    set(gp_tool_known 1)
+    set(ENV{VS_UNICODE_OUTPUT} "") # Block extra output from inside VS IDE.
+  endif("${gp_tool}" STREQUAL "dumpbin")
+
+  if(NOT gp_tool_known)
+    message(STATUS "warning: gp_tool='${gp_tool}' is an unknown tool...")
+    message(STATUS "CMake function get_prerequisites needs more code to handle '${gp_tool}'")
+    message(STATUS "Valid gp_tool values are dumpbin, ldd and otool.")
+    return()
+  endif(NOT gp_tool_known)
+
+  set(gp_cmd_paths ${gp_cmd_paths}
+    "C:/Program Files/Microsoft Visual Studio 9.0/VC/bin"
+    "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/bin"
+    "C:/Program Files/Microsoft Visual Studio 8/VC/BIN"
+    "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/BIN"
+    "C:/Program Files/Microsoft Visual Studio .NET 2003/VC7/BIN"
+    "C:/Program Files (x86)/Microsoft Visual Studio .NET 2003/VC7/BIN"
+    "/usr/local/bin"
+    "/usr/bin"
+    )
+
+  find_program(gp_cmd ${gp_tool} PATHS ${gp_cmd_paths})
+
+  if(NOT gp_cmd)
+    message(STATUS "warning: could not find '${gp_tool}' - cannot analyze prerequisites...")
+    return()
+  endif(NOT gp_cmd)
+
+  if("${gp_tool}" STREQUAL "dumpbin")
+    # When running dumpbin, it also needs the "Common7/IDE" directory in the
+    # PATH. It will already be in the PATH if being run from a Visual Studio
+    # command prompt. Add it to the PATH here in case we are running from a
+    # different command prompt.
+    #
+    get_filename_component(gp_cmd_dir "${gp_cmd}" PATH)
+    get_filename_component(gp_cmd_dlls_dir "${gp_cmd_dir}/../../Common7/IDE" ABSOLUTE)
+    if(EXISTS "${gp_cmd_dlls_dir}")
+      # only add to the path if it is not already in the path
+      if(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")
+        set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")
+      endif(NOT "$ENV{PATH}" MATCHES "${gp_cmd_dlls_dir}")
+    endif(EXISTS "${gp_cmd_dlls_dir}")
+  endif("${gp_tool}" STREQUAL "dumpbin")
+  #
+  # </setup-gp_tool-vars>
+
+  if("${gp_tool}" STREQUAL "ldd")
+    set(old_ld_env "$ENV{LD_LIBRARY_PATH}")
+    foreach(dir ${exepath} ${dirs})
+      set(ENV{LD_LIBRARY_PATH} "${dir}:$ENV{LD_LIBRARY_PATH}")
+    endforeach(dir)
+  endif("${gp_tool}" STREQUAL "ldd")
+
+
+  # Track new prerequisites at each new level of recursion. Start with an
+  # empty list at each level:
+  #
+  set(unseen_prereqs)
+
+  # Run gp_cmd on the target:
+  #
+  execute_process(
+    COMMAND ${gp_cmd} ${gp_cmd_args} ${target}
+    OUTPUT_VARIABLE gp_cmd_ov
+    )
+
+  if("${gp_tool}" STREQUAL "ldd")
+    set(ENV{LD_LIBRARY_PATH} "${old_ld_env}")
+  endif("${gp_tool}" STREQUAL "ldd")
+
+  if(verbose)
+    message(STATUS "<RawOutput cmd='${gp_cmd} ${gp_cmd_args} ${target}'>")
+    message(STATUS "gp_cmd_ov='${gp_cmd_ov}'")
+    message(STATUS "</RawOutput>")
+  endif(verbose)
+
+  get_filename_component(target_dir "${target}" PATH)
+
+  # Convert to a list of lines:
+  #
+  string(REGEX REPLACE ";" "\\\\;" candidates "${gp_cmd_ov}")
+  string(REGEX REPLACE "\n" "${eol_char};" candidates "${candidates}")
+
+  # Analyze each line for file names that match the regular expression:
+  #
+  foreach(candidate ${candidates})
+  if("${candidate}" MATCHES "${gp_regex}")
+    # Extract information from each candidate:
+    string(REGEX REPLACE "${gp_regex}" "\\1" raw_item "${candidate}")
+
+    if(gp_regex_cmp_count GREATER 1)
+      string(REGEX REPLACE "${gp_regex}" "\\2" raw_compat_version "${candidate}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" compat_major_version "${raw_compat_version}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" compat_minor_version "${raw_compat_version}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" compat_patch_version "${raw_compat_version}")
+    endif(gp_regex_cmp_count GREATER 1)
+
+    if(gp_regex_cmp_count GREATER 2)
+      string(REGEX REPLACE "${gp_regex}" "\\3" raw_current_version "${candidate}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" current_major_version "${raw_current_version}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" current_minor_version "${raw_current_version}")
+      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" current_patch_version "${raw_current_version}")
+    endif(gp_regex_cmp_count GREATER 2)
+
+    # Use the raw_item as the list entries returned by this function. Use the
+    # gp_resolve_item function to resolve it to an actual full path file if
+    # necessary.
+    #
+    set(item "${raw_item}")
+
+    # Add each item unless it is excluded:
+    #
+    set(add_item 1)
+
+    if(${exclude_system})
+      set(type "")
+      gp_resolved_file_type("${target}" "${item}" "${exepath}" "${dirs}" type)
+      if("${type}" STREQUAL "system")
+        set(add_item 0)
+      endif("${type}" STREQUAL "system")
+    endif(${exclude_system})
+
+    if(add_item)
+      list(LENGTH ${prerequisites_var} list_length_before_append)
+      gp_append_unique(${prerequisites_var} "${item}")
+      list(LENGTH ${prerequisites_var} list_length_after_append)
+
+      if(${recurse})
+        # If item was really added, this is the first time we have seen it.
+        # Add it to unseen_prereqs so that we can recursively add *its*
+        # prerequisites...
+        #
+        # But first: resolve its name to an absolute full path name such
+        # that the analysis tools can simply accept it as input.
+        #
+        if(NOT list_length_before_append EQUAL list_length_after_append)
+          gp_resolve_item("${target}" "${item}" "${exepath}" "${dirs}" resolved_item)
+          set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")
+        endif(NOT list_length_before_append EQUAL list_length_after_append)
+      endif(${recurse})
+    endif(add_item)
+  else("${candidate}" MATCHES "${gp_regex}")
+    if(verbose)
+      message(STATUS "ignoring non-matching line: '${candidate}'")
+    endif(verbose)
+  endif("${candidate}" MATCHES "${gp_regex}")
+  endforeach(candidate)
+
+  list(LENGTH ${prerequisites_var} prerequisites_var_length)
+  if(prerequisites_var_length GREATER 0)
+    list(SORT ${prerequisites_var})
+  endif(prerequisites_var_length GREATER 0)
+  if(${recurse})
+    set(more_inputs ${unseen_prereqs})
+    foreach(input ${more_inputs})
+      get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")
+    endforeach(input)
+  endif(${recurse})
+
+  set(${prerequisites_var} ${${prerequisites_var}} PARENT_SCOPE)
+endfunction(get_prerequisites)
+
+
+# list_prerequisites target all exclude_system verbose
+#
+#  ARGV0 (target) is the full path to an executable file
+#
+#  optional ARGV1 (all) is 0 or 1: 0 for direct prerequisites only,
+#   1 for all prerequisites recursively
+#
+#  optional ARGV2 (exclude_system) is 0 or 1: 0 to include "system"
+#   prerequisites , 1 to exclude them
+#
+#  optional ARGV3 (verbose) is 0 or 1: 0 to print only full path
+#   names of prerequisites, 1 to print extra information
+#
+function(list_prerequisites target)
+  if("${ARGV1}" STREQUAL "")
+    set(all 1)
+  else("${ARGV1}" STREQUAL "")
+    set(all "${ARGV1}")
+  endif("${ARGV1}" STREQUAL "")
+
+  if("${ARGV2}" STREQUAL "")
+    set(exclude_system 0)
+  else("${ARGV2}" STREQUAL "")
+    set(exclude_system "${ARGV2}")
+  endif("${ARGV2}" STREQUAL "")
+
+  if("${ARGV3}" STREQUAL "")
+    set(verbose 0)
+  else("${ARGV3}" STREQUAL "")
+    set(verbose "${ARGV3}")
+  endif("${ARGV3}" STREQUAL "")
+
+  set(count 0)
+  set(count_str "")
+  set(print_count "${verbose}")
+  set(print_prerequisite_type "${verbose}")
+  set(print_target "${verbose}")
+  set(type_str "")
+
+  get_filename_component(exepath "${target}" PATH)
+
+  set(prereqs "")
+  get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${exepath}" "")
+
+  if(print_target)
+    message(STATUS "File '${target}' depends on:")
+  endif(print_target)
+
+  foreach(d ${prereqs})
+    math(EXPR count "${count} + 1")
+
+    if(print_count)
+      set(count_str "${count}. ")
+    endif(print_count)
+
+    if(print_prerequisite_type)
+      gp_file_type("${target}" "${d}" type)
+      set(type_str " (${type})")
+    endif(print_prerequisite_type)
+
+    message(STATUS "${count_str}${d}${type_str}")
+  endforeach(d)
+endfunction(list_prerequisites)
+
+
+# list_prerequisites_by_glob glob_arg glob_exp
+#
+#  glob_arg is GLOB or GLOB_RECURSE
+#
+#  glob_exp is a globbing expression used with "file(GLOB" to retrieve a list
+#   of matching files. If a matching file is executable, its prerequisites are
+#   listed.
+#
+# Any additional (optional) arguments provided are passed along as the
+# optional arguments to the list_prerequisites calls.
+#
+function(list_prerequisites_by_glob glob_arg glob_exp)
+  message(STATUS "=============================================================================")
+  message(STATUS "List prerequisites of executables matching ${glob_arg} '${glob_exp}'")
+  message(STATUS "")
+  file(${glob_arg} file_list ${glob_exp})
+  foreach(f ${file_list})
+    is_file_executable("${f}" is_f_executable)
+    if(is_f_executable)
+      message(STATUS "=============================================================================")
+      list_prerequisites("${f}" ${ARGN})
+      message(STATUS "")
+    endif(is_f_executable)
+  endforeach(f)
+endfunction(list_prerequisites_by_glob)
diff --git a/indra/cmake/LLAddBuildTest.cmake b/indra/cmake/LLAddBuildTest.cmake
index 62b764bb30..05f0492234 100644
--- a/indra/cmake/LLAddBuildTest.cmake
+++ b/indra/cmake/LLAddBuildTest.cmake
@@ -1,276 +1,276 @@
-# -*- cmake -*-

-include(LLTestCommand)

-include(GoogleMock)

-

-MACRO(LL_ADD_PROJECT_UNIT_TESTS project sources)

-  # Given a project name and a list of sourcefiles (with optional properties on each),

-  # add targets to build and run the tests specified.

-  # ASSUMPTIONS:

-  # * this macro is being executed in the project file that is passed in

-  # * current working SOURCE dir is that project dir

-  # * there is a subfolder tests/ with test code corresponding to the filenames passed in

-  # * properties for each sourcefile passed in indicate what libs to link that file with (MAKE NO ASSUMPTIONS ASIDE FROM TUT)

-  #

-  # More info and examples at: https://wiki.secondlife.com/wiki/How_to_add_unit_tests_to_indra_code

-  #

-  # WARNING: do NOT modify this code without working with poppy -

-  # there is another branch that will conflict heavily with any changes here.

-INCLUDE(GoogleMock)

-

-

-  IF(LL_TEST_VERBOSE)

-    MESSAGE("LL_ADD_PROJECT_UNIT_TESTS UNITTEST_PROJECT_${project} sources: ${sources}")

-  ENDIF(LL_TEST_VERBOSE)

-

-  # Start with the header and project-wide setup before making targets

-  #project(UNITTEST_PROJECT_${project})

-  # Setup includes, paths, etc

-  SET(alltest_SOURCE_FILES

-    ${CMAKE_SOURCE_DIR}/test/test.cpp

-    ${CMAKE_SOURCE_DIR}/test/lltut.cpp

-    )

-  SET(alltest_DEP_TARGETS

-    # needed by the test harness itself

-    ${APRUTIL_LIBRARIES}

-    ${APR_LIBRARIES}

-    llcommon

-    )

-  IF(NOT "${project}" STREQUAL "llmath")

-    # add llmath as a dep unless the tested module *is* llmath!

-    LIST(APPEND alltest_DEP_TARGETS

-      llmath

-      )

-  ENDIF(NOT "${project}" STREQUAL "llmath")

-  SET(alltest_INCLUDE_DIRS

-    ${LLMATH_INCLUDE_DIRS}

-    ${LLCOMMON_INCLUDE_DIRS}

-    ${LIBS_OPEN_DIR}/test

-    ${GOOGLEMOCK_INCLUDE_DIRS}

-    )

-  SET(alltest_LIBRARIES

-    ${GOOGLEMOCK_LIBRARIES}

-    ${PTHREAD_LIBRARY}

-    ${WINDOWS_LIBRARIES}

-    )

-  # Headers, for convenience in targets.

-  SET(alltest_HEADER_FILES

-    ${CMAKE_SOURCE_DIR}/test/test.h

-    )

-

-  # Use the default flags

-  if (LINUX)

-    SET(CMAKE_EXE_LINKER_FLAGS "")

-  endif (LINUX)

-

-  # start the source test executable definitions

-  SET(${project}_TEST_OUTPUT "")

-  FOREACH (source ${sources})

-    STRING( REGEX REPLACE "(.*)\\.[^.]+$" "\\1" name ${source} )

-    STRING( REGEX REPLACE ".*\\.([^.]+)$" "\\1" extension ${source} )

-    IF(LL_TEST_VERBOSE)

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS UNITTEST_PROJECT_${project} individual source: ${source} (${name}.${extension})")

-    ENDIF(LL_TEST_VERBOSE)

-

-    #

-    # Per-codefile additional / external source, header, and include dir property extraction

-    #

-    # Source

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_SOURCE_FILES ${source} LL_TEST_ADDITIONAL_SOURCE_FILES)

-    IF(${name}_test_additional_SOURCE_FILES MATCHES NOTFOUND)

-      SET(${name}_test_additional_SOURCE_FILES "")

-    ENDIF(${name}_test_additional_SOURCE_FILES MATCHES NOTFOUND)

-    SET(${name}_test_SOURCE_FILES ${source} tests/${name}_test.${extension} ${alltest_SOURCE_FILES} ${${name}_test_additional_SOURCE_FILES} )

-    IF(LL_TEST_VERBOSE)

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_SOURCE_FILES ${${name}_test_SOURCE_FILES}")

-    ENDIF(LL_TEST_VERBOSE)

-    # Headers

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_HEADER_FILES ${source} LL_TEST_ADDITIONAL_HEADER_FILES)

-    IF(${name}_test_additional_HEADER_FILES MATCHES NOTFOUND)

-      SET(${name}_test_additional_HEADER_FILES "")

-    ENDIF(${name}_test_additional_HEADER_FILES MATCHES NOTFOUND)

-    SET(${name}_test_HEADER_FILES ${name}.h ${${name}_test_additional_HEADER_FILES})

-    set_source_files_properties(${${name}_test_HEADER_FILES} PROPERTIES HEADER_FILE_ONLY TRUE)

-    LIST(APPEND ${name}_test_SOURCE_FILES ${${name}_test_HEADER_FILES})

-    IF(LL_TEST_VERBOSE)

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_HEADER_FILES ${${name}_test_HEADER_FILES}")

-    ENDIF(LL_TEST_VERBOSE)

-    # Include dirs

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_INCLUDE_DIRS ${source} LL_TEST_ADDITIONAL_INCLUDE_DIRS)

-    IF(${name}_test_additional_INCLUDE_DIRS MATCHES NOTFOUND)

-      SET(${name}_test_additional_INCLUDE_DIRS "")

-    ENDIF(${name}_test_additional_INCLUDE_DIRS MATCHES NOTFOUND)

-    INCLUDE_DIRECTORIES(${alltest_INCLUDE_DIRS} ${name}_test_additional_INCLUDE_DIRS )

-    IF(LL_TEST_VERBOSE)

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_INCLUDE_DIRS ${${name}_test_additional_INCLUDE_DIRS}")

-    ENDIF(LL_TEST_VERBOSE)

-

-

-    # Setup target

-    ADD_EXECUTABLE(PROJECT_${project}_TEST_${name} ${${name}_test_SOURCE_FILES})

-    SET_TARGET_PROPERTIES(PROJECT_${project}_TEST_${name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${EXE_STAGING_DIR}")

-

-    #

-    # Per-codefile additional / external project dep and lib dep property extraction

-    #

-    # WARNING: it's REALLY IMPORTANT to not mix these. I guarantee it will not work in the future. + poppy 2009-04-19

-    # Projects

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_PROJECTS ${source} LL_TEST_ADDITIONAL_PROJECTS)

-    IF(${name}_test_additional_PROJECTS MATCHES NOTFOUND)

-      SET(${name}_test_additional_PROJECTS "")

-    ENDIF(${name}_test_additional_PROJECTS MATCHES NOTFOUND)

-    # Libraries

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_LIBRARIES ${source} LL_TEST_ADDITIONAL_LIBRARIES)

-    IF(${name}_test_additional_LIBRARIES MATCHES NOTFOUND)

-      SET(${name}_test_additional_LIBRARIES "")

-    ENDIF(${name}_test_additional_LIBRARIES MATCHES NOTFOUND)

-    IF(LL_TEST_VERBOSE)

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_PROJECTS ${${name}_test_additional_PROJECTS}")

-      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_LIBRARIES ${${name}_test_additional_LIBRARIES}")

-    ENDIF(LL_TEST_VERBOSE)

-    # Add to project

-    TARGET_LINK_LIBRARIES(PROJECT_${project}_TEST_${name} ${alltest_LIBRARIES} ${alltest_DEP_TARGETS} ${${name}_test_additional_PROJECTS} ${${name}_test_additional_LIBRARIES} )

-    # Compile-time Definitions

-    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_CFLAGS ${source} LL_TEST_ADDITIONAL_CFLAGS)

-     IF(NOT ${name}_test_additional_CFLAGS MATCHES NOTFOUND)

-       SET_TARGET_PROPERTIES(PROJECT_${project}_TEST_${name} PROPERTIES COMPILE_FLAGS ${${name}_test_additional_CFLAGS} )

-       IF(LL_TEST_VERBOSE)

-         MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_CFLAGS ${${name}_test_additional_CFLAGS}")

-       ENDIF(LL_TEST_VERBOSE)

-     ENDIF(NOT ${name}_test_additional_CFLAGS MATCHES NOTFOUND)

-     

-    #

-    # Setup test targets

-    #

-    GET_TARGET_PROPERTY(TEST_EXE PROJECT_${project}_TEST_${name} LOCATION)

-    SET(TEST_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/PROJECT_${project}_TEST_${name}_ok.txt)

-    SET(TEST_CMD ${TEST_EXE} --touch=${TEST_OUTPUT} --sourcedir=${CMAKE_CURRENT_SOURCE_DIR})

-

-    # daveh - what configuration does this use? Debug? it's cmake-time, not build time. + poppy 2009-04-19

-    IF(LL_TEST_VERBOSE)

-      MESSAGE(STATUS "LL_ADD_PROJECT_UNIT_TESTS ${name} test_cmd  = ${TEST_CMD}")

-    ENDIF(LL_TEST_VERBOSE)

-

-    SET_TEST_PATH(LD_LIBRARY_PATH)

-    LL_TEST_COMMAND(TEST_SCRIPT_CMD "${LD_LIBRARY_PATH}" ${TEST_CMD})

-    IF(LL_TEST_VERBOSE)

-      MESSAGE(STATUS "LL_ADD_PROJECT_UNIT_TESTS ${name} test_script  = ${TEST_SCRIPT_CMD}")

-    ENDIF(LL_TEST_VERBOSE)

-    # Add test 

-    ADD_CUSTOM_COMMAND(

-        OUTPUT ${TEST_OUTPUT}

-        COMMAND ${TEST_SCRIPT_CMD}

-        DEPENDS PROJECT_${project}_TEST_${name}

-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

-        )

-    # Why not add custom target and add POST_BUILD command?

-    # Slightly less uncertain behavior

-    # (OUTPUT commands run non-deterministically AFAIK) + poppy 2009-04-19

-    # > I did not use a post build step as I could not make it notify of a 

-    # > failure after the first time you build and fail a test. - daveh 2009-04-20

-    LIST(APPEND ${project}_TEST_OUTPUT ${TEST_OUTPUT})

-  ENDFOREACH (source)

-

-  # Add the test runner target per-project

-  # (replaces old _test_ok targets all over the place)

-  ADD_CUSTOM_TARGET(${project}_tests ALL DEPENDS ${${project}_TEST_OUTPUT})

-  ADD_DEPENDENCIES(${project} ${project}_tests)

-ENDMACRO(LL_ADD_PROJECT_UNIT_TESTS)

-

-FUNCTION(LL_ADD_INTEGRATION_TEST 

-    testname

-    additional_source_files

-    library_dependencies

-# variable args

-    )

-  if(TEST_DEBUG)

-    message(STATUS "Adding INTEGRATION_TEST_${testname} - debug output is on")

-  endif(TEST_DEBUG)

-  

-  SET(source_files

-    tests/${testname}_test.cpp

-    ${CMAKE_SOURCE_DIR}/test/test.cpp

-    ${CMAKE_SOURCE_DIR}/test/lltut.cpp

-    ${additional_source_files}

-    )

-

-  SET(libraries

-    ${library_dependencies}

-    ${GOOGLEMOCK_LIBRARIES}

-    ${PTHREAD_LIBRARY}

-    )

-

-  # Add test executable build target

-  if(TEST_DEBUG)

-    message(STATUS "ADD_EXECUTABLE(INTEGRATION_TEST_${testname} ${source_files})")

-  endif(TEST_DEBUG)

-  ADD_EXECUTABLE(INTEGRATION_TEST_${testname} ${source_files})

-  SET_TARGET_PROPERTIES(INTEGRATION_TEST_${testname} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${EXE_STAGING_DIR}")

-  if(STANDALONE)

-    SET_TARGET_PROPERTIES(INTEGRATION_TEST_${testname} PROPERTIES COMPILE_FLAGS -I"${TUT_INCLUDE_DIR}")

-  endif(STANDALONE)

-

-  # Add link deps to the executable

-  if(TEST_DEBUG)

-    message(STATUS "TARGET_LINK_LIBRARIES(INTEGRATION_TEST_${testname} ${libraries})")

-  endif(TEST_DEBUG)

-  TARGET_LINK_LIBRARIES(INTEGRATION_TEST_${testname} ${libraries})

-

-  # Create the test running command

-  SET(test_command ${ARGN})

-  GET_TARGET_PROPERTY(TEST_EXE INTEGRATION_TEST_${testname} LOCATION)

-  LIST(FIND test_command "{}" test_exe_pos)

-  IF(test_exe_pos LESS 0)

-    # The {} marker means "the full pathname of the test executable."

-    # test_exe_pos -1 means we didn't find it -- so append the test executable

-    # name to $ARGN, the variable part of the arg list. This is convenient

-    # shorthand for both straightforward execution of the test program (empty

-    # $ARGN) and for running a "wrapper" program of some kind accepting the

-    # pathname of the test program as the last of its args. You need specify

-    # {} only if the test program's pathname isn't the last argument in the

-    # desired command line.

-    LIST(APPEND test_command "${TEST_EXE}")

-  ELSE (test_exe_pos LESS 0)

-    # Found {} marker at test_exe_pos. Remove the {}...

-    LIST(REMOVE_AT test_command test_exe_pos)

-    # ...and replace it with the actual name of the test executable.

-    LIST(INSERT test_command test_exe_pos "${TEST_EXE}")

-  ENDIF (test_exe_pos LESS 0)

-

-  SET_TEST_PATH(LD_LIBRARY_PATH)

-  LL_TEST_COMMAND(TEST_SCRIPT_CMD "${LD_LIBRARY_PATH}" ${test_command})

-

-  if(TEST_DEBUG)

-    message(STATUS "TEST_SCRIPT_CMD: ${TEST_SCRIPT_CMD}")

-  endif(TEST_DEBUG)

-

-  ADD_CUSTOM_COMMAND(

-    TARGET INTEGRATION_TEST_${testname}

-    POST_BUILD

-    COMMAND ${TEST_SCRIPT_CMD}

-    )

-

-  # Use CTEST? Not sure how to yet...

-  # ADD_TEST(INTEGRATION_TEST_RUNNER_${testname} ${TEST_SCRIPT_CMD})

-

-ENDFUNCTION(LL_ADD_INTEGRATION_TEST)

-

-MACRO(SET_TEST_PATH LISTVAR)

-  IF(WINDOWS)

-    # We typically build/package only Release variants of third-party

-    # libraries, so append the Release staging dir in case the library being

-    # sought doesn't have a debug variant.

-    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR} ${SHARED_LIB_STAGING_DIR}/Release)

-  ELSEIF(DARWIN)

-    # We typically build/package only Release variants of third-party

-    # libraries, so append the Release staging dir in case the library being

-    # sought doesn't have a debug variant.

-    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources ${SHARED_LIB_STAGING_DIR}/Release/Resources /usr/lib)

-  ELSE(WINDOWS)

-    # Linux uses a single staging directory anyway.

-    IF (STANDALONE)

-      set(${LISTVAR} ${CMAKE_BINARY_DIR}/llcommon /usr/lib /usr/local/lib)

-    ELSE (STANDALONE)

-      set(${LISTVAR} ${SHARED_LIB_STAGING_DIR} /usr/lib)

-    ENDIF (STANDALONE)

-  ENDIF(WINDOWS)

-ENDMACRO(SET_TEST_PATH)

+# -*- cmake -*-
+include(LLTestCommand)
+include(GoogleMock)
+
+MACRO(LL_ADD_PROJECT_UNIT_TESTS project sources)
+  # Given a project name and a list of sourcefiles (with optional properties on each),
+  # add targets to build and run the tests specified.
+  # ASSUMPTIONS:
+  # * this macro is being executed in the project file that is passed in
+  # * current working SOURCE dir is that project dir
+  # * there is a subfolder tests/ with test code corresponding to the filenames passed in
+  # * properties for each sourcefile passed in indicate what libs to link that file with (MAKE NO ASSUMPTIONS ASIDE FROM TUT)
+  #
+  # More info and examples at: https://wiki.secondlife.com/wiki/How_to_add_unit_tests_to_indra_code
+  #
+  # WARNING: do NOT modify this code without working with poppy -
+  # there is another branch that will conflict heavily with any changes here.
+INCLUDE(GoogleMock)
+
+
+  IF(LL_TEST_VERBOSE)
+    MESSAGE("LL_ADD_PROJECT_UNIT_TESTS UNITTEST_PROJECT_${project} sources: ${sources}")
+  ENDIF(LL_TEST_VERBOSE)
+
+  # Start with the header and project-wide setup before making targets
+  #project(UNITTEST_PROJECT_${project})
+  # Setup includes, paths, etc
+  SET(alltest_SOURCE_FILES
+    ${CMAKE_SOURCE_DIR}/test/test.cpp
+    ${CMAKE_SOURCE_DIR}/test/lltut.cpp
+    )
+  SET(alltest_DEP_TARGETS
+    # needed by the test harness itself
+    ${APRUTIL_LIBRARIES}
+    ${APR_LIBRARIES}
+    llcommon
+    )
+  IF(NOT "${project}" STREQUAL "llmath")
+    # add llmath as a dep unless the tested module *is* llmath!
+    LIST(APPEND alltest_DEP_TARGETS
+      llmath
+      )
+  ENDIF(NOT "${project}" STREQUAL "llmath")
+  SET(alltest_INCLUDE_DIRS
+    ${LLMATH_INCLUDE_DIRS}
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LIBS_OPEN_DIR}/test
+    ${GOOGLEMOCK_INCLUDE_DIRS}
+    )
+  SET(alltest_LIBRARIES
+    ${GOOGLEMOCK_LIBRARIES}
+    ${PTHREAD_LIBRARY}
+    ${WINDOWS_LIBRARIES}
+    )
+  # Headers, for convenience in targets.
+  SET(alltest_HEADER_FILES
+    ${CMAKE_SOURCE_DIR}/test/test.h
+    )
+
+  # Use the default flags
+  if (LINUX)
+    SET(CMAKE_EXE_LINKER_FLAGS "")
+  endif (LINUX)
+
+  # start the source test executable definitions
+  SET(${project}_TEST_OUTPUT "")
+  FOREACH (source ${sources})
+    STRING( REGEX REPLACE "(.*)\\.[^.]+$" "\\1" name ${source} )
+    STRING( REGEX REPLACE ".*\\.([^.]+)$" "\\1" extension ${source} )
+    IF(LL_TEST_VERBOSE)
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS UNITTEST_PROJECT_${project} individual source: ${source} (${name}.${extension})")
+    ENDIF(LL_TEST_VERBOSE)
+
+    #
+    # Per-codefile additional / external source, header, and include dir property extraction
+    #
+    # Source
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_SOURCE_FILES ${source} LL_TEST_ADDITIONAL_SOURCE_FILES)
+    IF(${name}_test_additional_SOURCE_FILES MATCHES NOTFOUND)
+      SET(${name}_test_additional_SOURCE_FILES "")
+    ENDIF(${name}_test_additional_SOURCE_FILES MATCHES NOTFOUND)
+    SET(${name}_test_SOURCE_FILES ${source} tests/${name}_test.${extension} ${alltest_SOURCE_FILES} ${${name}_test_additional_SOURCE_FILES} )
+    IF(LL_TEST_VERBOSE)
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_SOURCE_FILES ${${name}_test_SOURCE_FILES}")
+    ENDIF(LL_TEST_VERBOSE)
+    # Headers
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_HEADER_FILES ${source} LL_TEST_ADDITIONAL_HEADER_FILES)
+    IF(${name}_test_additional_HEADER_FILES MATCHES NOTFOUND)
+      SET(${name}_test_additional_HEADER_FILES "")
+    ENDIF(${name}_test_additional_HEADER_FILES MATCHES NOTFOUND)
+    SET(${name}_test_HEADER_FILES ${name}.h ${${name}_test_additional_HEADER_FILES})
+    set_source_files_properties(${${name}_test_HEADER_FILES} PROPERTIES HEADER_FILE_ONLY TRUE)
+    LIST(APPEND ${name}_test_SOURCE_FILES ${${name}_test_HEADER_FILES})
+    IF(LL_TEST_VERBOSE)
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_HEADER_FILES ${${name}_test_HEADER_FILES}")
+    ENDIF(LL_TEST_VERBOSE)
+    # Include dirs
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_INCLUDE_DIRS ${source} LL_TEST_ADDITIONAL_INCLUDE_DIRS)
+    IF(${name}_test_additional_INCLUDE_DIRS MATCHES NOTFOUND)
+      SET(${name}_test_additional_INCLUDE_DIRS "")
+    ENDIF(${name}_test_additional_INCLUDE_DIRS MATCHES NOTFOUND)
+    INCLUDE_DIRECTORIES(${alltest_INCLUDE_DIRS} ${name}_test_additional_INCLUDE_DIRS )
+    IF(LL_TEST_VERBOSE)
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_INCLUDE_DIRS ${${name}_test_additional_INCLUDE_DIRS}")
+    ENDIF(LL_TEST_VERBOSE)
+
+
+    # Setup target
+    ADD_EXECUTABLE(PROJECT_${project}_TEST_${name} ${${name}_test_SOURCE_FILES})
+    SET_TARGET_PROPERTIES(PROJECT_${project}_TEST_${name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${EXE_STAGING_DIR}")
+
+    #
+    # Per-codefile additional / external project dep and lib dep property extraction
+    #
+    # WARNING: it's REALLY IMPORTANT to not mix these. I guarantee it will not work in the future. + poppy 2009-04-19
+    # Projects
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_PROJECTS ${source} LL_TEST_ADDITIONAL_PROJECTS)
+    IF(${name}_test_additional_PROJECTS MATCHES NOTFOUND)
+      SET(${name}_test_additional_PROJECTS "")
+    ENDIF(${name}_test_additional_PROJECTS MATCHES NOTFOUND)
+    # Libraries
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_LIBRARIES ${source} LL_TEST_ADDITIONAL_LIBRARIES)
+    IF(${name}_test_additional_LIBRARIES MATCHES NOTFOUND)
+      SET(${name}_test_additional_LIBRARIES "")
+    ENDIF(${name}_test_additional_LIBRARIES MATCHES NOTFOUND)
+    IF(LL_TEST_VERBOSE)
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_PROJECTS ${${name}_test_additional_PROJECTS}")
+      MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_LIBRARIES ${${name}_test_additional_LIBRARIES}")
+    ENDIF(LL_TEST_VERBOSE)
+    # Add to project
+    TARGET_LINK_LIBRARIES(PROJECT_${project}_TEST_${name} ${alltest_LIBRARIES} ${alltest_DEP_TARGETS} ${${name}_test_additional_PROJECTS} ${${name}_test_additional_LIBRARIES} )
+    # Compile-time Definitions
+    GET_SOURCE_FILE_PROPERTY(${name}_test_additional_CFLAGS ${source} LL_TEST_ADDITIONAL_CFLAGS)
+     IF(NOT ${name}_test_additional_CFLAGS MATCHES NOTFOUND)
+       SET_TARGET_PROPERTIES(PROJECT_${project}_TEST_${name} PROPERTIES COMPILE_FLAGS ${${name}_test_additional_CFLAGS} )
+       IF(LL_TEST_VERBOSE)
+         MESSAGE("LL_ADD_PROJECT_UNIT_TESTS ${name}_test_additional_CFLAGS ${${name}_test_additional_CFLAGS}")
+       ENDIF(LL_TEST_VERBOSE)
+     ENDIF(NOT ${name}_test_additional_CFLAGS MATCHES NOTFOUND)
+     
+    #
+    # Setup test targets
+    #
+    GET_TARGET_PROPERTY(TEST_EXE PROJECT_${project}_TEST_${name} LOCATION)
+    SET(TEST_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/PROJECT_${project}_TEST_${name}_ok.txt)
+    SET(TEST_CMD ${TEST_EXE} --touch=${TEST_OUTPUT} --sourcedir=${CMAKE_CURRENT_SOURCE_DIR})
+
+    # daveh - what configuration does this use? Debug? it's cmake-time, not build time. + poppy 2009-04-19
+    IF(LL_TEST_VERBOSE)
+      MESSAGE(STATUS "LL_ADD_PROJECT_UNIT_TESTS ${name} test_cmd  = ${TEST_CMD}")
+    ENDIF(LL_TEST_VERBOSE)
+
+    SET_TEST_PATH(LD_LIBRARY_PATH)
+    LL_TEST_COMMAND(TEST_SCRIPT_CMD "${LD_LIBRARY_PATH}" ${TEST_CMD})
+    IF(LL_TEST_VERBOSE)
+      MESSAGE(STATUS "LL_ADD_PROJECT_UNIT_TESTS ${name} test_script  = ${TEST_SCRIPT_CMD}")
+    ENDIF(LL_TEST_VERBOSE)
+    # Add test 
+    ADD_CUSTOM_COMMAND(
+        OUTPUT ${TEST_OUTPUT}
+        COMMAND ${TEST_SCRIPT_CMD}
+        DEPENDS PROJECT_${project}_TEST_${name}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        )
+    # Why not add custom target and add POST_BUILD command?
+    # Slightly less uncertain behavior
+    # (OUTPUT commands run non-deterministically AFAIK) + poppy 2009-04-19
+    # > I did not use a post build step as I could not make it notify of a 
+    # > failure after the first time you build and fail a test. - daveh 2009-04-20
+    LIST(APPEND ${project}_TEST_OUTPUT ${TEST_OUTPUT})
+  ENDFOREACH (source)
+
+  # Add the test runner target per-project
+  # (replaces old _test_ok targets all over the place)
+  ADD_CUSTOM_TARGET(${project}_tests ALL DEPENDS ${${project}_TEST_OUTPUT})
+  ADD_DEPENDENCIES(${project} ${project}_tests)
+ENDMACRO(LL_ADD_PROJECT_UNIT_TESTS)
+
+FUNCTION(LL_ADD_INTEGRATION_TEST 
+    testname
+    additional_source_files
+    library_dependencies
+# variable args
+    )
+  if(TEST_DEBUG)
+    message(STATUS "Adding INTEGRATION_TEST_${testname} - debug output is on")
+  endif(TEST_DEBUG)
+  
+  SET(source_files
+    tests/${testname}_test.cpp
+    ${CMAKE_SOURCE_DIR}/test/test.cpp
+    ${CMAKE_SOURCE_DIR}/test/lltut.cpp
+    ${additional_source_files}
+    )
+
+  SET(libraries
+    ${library_dependencies}
+    ${GOOGLEMOCK_LIBRARIES}
+    ${PTHREAD_LIBRARY}
+    )
+
+  # Add test executable build target
+  if(TEST_DEBUG)
+    message(STATUS "ADD_EXECUTABLE(INTEGRATION_TEST_${testname} ${source_files})")
+  endif(TEST_DEBUG)
+  ADD_EXECUTABLE(INTEGRATION_TEST_${testname} ${source_files})
+  SET_TARGET_PROPERTIES(INTEGRATION_TEST_${testname} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${EXE_STAGING_DIR}")
+  if(STANDALONE)
+    SET_TARGET_PROPERTIES(INTEGRATION_TEST_${testname} PROPERTIES COMPILE_FLAGS -I"${TUT_INCLUDE_DIR}")
+  endif(STANDALONE)
+
+  # Add link deps to the executable
+  if(TEST_DEBUG)
+    message(STATUS "TARGET_LINK_LIBRARIES(INTEGRATION_TEST_${testname} ${libraries})")
+  endif(TEST_DEBUG)
+  TARGET_LINK_LIBRARIES(INTEGRATION_TEST_${testname} ${libraries})
+
+  # Create the test running command
+  SET(test_command ${ARGN})
+  GET_TARGET_PROPERTY(TEST_EXE INTEGRATION_TEST_${testname} LOCATION)
+  LIST(FIND test_command "{}" test_exe_pos)
+  IF(test_exe_pos LESS 0)
+    # The {} marker means "the full pathname of the test executable."
+    # test_exe_pos -1 means we didn't find it -- so append the test executable
+    # name to $ARGN, the variable part of the arg list. This is convenient
+    # shorthand for both straightforward execution of the test program (empty
+    # $ARGN) and for running a "wrapper" program of some kind accepting the
+    # pathname of the test program as the last of its args. You need specify
+    # {} only if the test program's pathname isn't the last argument in the
+    # desired command line.
+    LIST(APPEND test_command "${TEST_EXE}")
+  ELSE (test_exe_pos LESS 0)
+    # Found {} marker at test_exe_pos. Remove the {}...
+    LIST(REMOVE_AT test_command test_exe_pos)
+    # ...and replace it with the actual name of the test executable.
+    LIST(INSERT test_command test_exe_pos "${TEST_EXE}")
+  ENDIF (test_exe_pos LESS 0)
+
+  SET_TEST_PATH(LD_LIBRARY_PATH)
+  LL_TEST_COMMAND(TEST_SCRIPT_CMD "${LD_LIBRARY_PATH}" ${test_command})
+
+  if(TEST_DEBUG)
+    message(STATUS "TEST_SCRIPT_CMD: ${TEST_SCRIPT_CMD}")
+  endif(TEST_DEBUG)
+
+  ADD_CUSTOM_COMMAND(
+    TARGET INTEGRATION_TEST_${testname}
+    POST_BUILD
+    COMMAND ${TEST_SCRIPT_CMD}
+    )
+
+  # Use CTEST? Not sure how to yet...
+  # ADD_TEST(INTEGRATION_TEST_RUNNER_${testname} ${TEST_SCRIPT_CMD})
+
+ENDFUNCTION(LL_ADD_INTEGRATION_TEST)
+
+MACRO(SET_TEST_PATH LISTVAR)
+  IF(WINDOWS)
+    # We typically build/package only Release variants of third-party
+    # libraries, so append the Release staging dir in case the library being
+    # sought doesn't have a debug variant.
+    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR} ${SHARED_LIB_STAGING_DIR}/Release)
+  ELSEIF(DARWIN)
+    # We typically build/package only Release variants of third-party
+    # libraries, so append the Release staging dir in case the library being
+    # sought doesn't have a debug variant.
+    set(${LISTVAR} ${SHARED_LIB_STAGING_DIR}/${CMAKE_CFG_INTDIR}/Resources ${SHARED_LIB_STAGING_DIR}/Release/Resources /usr/lib)
+  ELSE(WINDOWS)
+    # Linux uses a single staging directory anyway.
+    IF (STANDALONE)
+      set(${LISTVAR} ${CMAKE_BINARY_DIR}/llcommon /usr/lib /usr/local/lib)
+    ELSE (STANDALONE)
+      set(${LISTVAR} ${SHARED_LIB_STAGING_DIR} /usr/lib)
+    ENDIF (STANDALONE)
+  ENDIF(WINDOWS)
+ENDMACRO(SET_TEST_PATH)