[asterisk-scf-commits] asterisk-scf/integration/cmake.git branch "single-api-lib" updated.

Commits to the Asterisk SCF project code repositories asterisk-scf-commits at lists.digium.com
Thu Jan 13 14:47:41 CST 2011


branch "single-api-lib" has been updated
       via  0e015db028ac1d9f72e9e8c54331a22a2bc99f38 (commit)
       via  787eba376cf49b90159955863421080929f9f903 (commit)
      from  419edd281ed4e2cf7fec527d6950edc1d7d512fa (commit)

Summary of changes:
 AsteriskSCF.cmake      | 1152 +++++++++++++++++++++---------------------------
 example/CMakeLists.txt |   21 +-
 2 files changed, 497 insertions(+), 676 deletions(-)


- Log -----------------------------------------------------------------
commit 0e015db028ac1d9f72e9e8c54331a22a2bc99f38
Author: David M. Lee <dlee at digium.com>
Date:   Wed Jan 12 13:34:38 2011 -0600

    Changed add_slice to be more consistent with add_file.
    
    asterisk_scf_component_add_slice will now add that slice file as a
    source for the named component, adding whatever rules are necessary for
    proper translation.

diff --git a/AsteriskSCF.cmake b/AsteriskSCF.cmake
index c05b57f..06d201b 100644
--- a/AsteriskSCF.cmake
+++ b/AsteriskSCF.cmake
@@ -55,6 +55,8 @@ if(NOT integrated_build)
     message(FATAL_ERROR "This project can not be built in a non-integrated fashion. Please use the gitall script present in the gitall repository.")
 endif()
 
+message(STATUS "Installation prefix set to ${CMAKE_INSTALL_PREFIX}")
+
 # installation directories (these are all relative to ${CMAKE_INSTALL_PREFIX})
 set(INSTALL_SYS_CONF_DIR etc CACHE FILEPATH
     "read-only data files that pertain to a single machine")
@@ -424,12 +426,6 @@ function(asterisk_scf_slice_include_directories)
     set(SLICE_INCLUDE_DIRECTORIES ${paths} PARENT_SCOPE)
 endfunction()
 
-# Function which remembers definitions needed for a particular Slice target
-function(asterisk_scf_slice_compile_definitions SLICE_FILE)
-    get_filename_component(SLICE ${SLICE_FILE} NAME_WE)
-    set(SLICE_COMPILE_DEFINITIONS_${SLICE} ${ARGN} PARENT_SCOPE)
-endfunction()
-
 # Function which remembers Ice libraries needed by a Slice target
 function(asterisk_scf_slice_add_ice_libraries TARGET)
     if(NOT ARGN)
@@ -455,287 +451,12 @@ function(asterisk_scf_slice_add_dependencies TARGET)
     endforeach()
 endfunction()
 
-# Function which compiles one or more Slice definition files
-#
-# Syntax:
-# asterisk_scf_compile_slice(<target> [SOURCES source1 ... sourceN])
-#
-# Notes:
-# If only a target name is provided, it must include the '.ice'
-# extension; the target name will be the filename with the extension
-# removed.
-#
-# If SOURCES are provided, the function produces targets named
-# using the provided target name, but builds them from the listed
-# source files. The '.ice' extension must be included. Source file
-# names can be glob patterns.
-#
-# sets these variables (where SLICE is the target name computed):
-#
-# ASTERISK_SCF_SLICE_${SLICE}
-#  marker indicating this Slice has been built
-# ASTERISK_SCF_SLICE_${SLICE}_INCLUDE_DIRS
-#  directories where generated header files needed for this target live
-function(asterisk_scf_compile_slice TARGET_IN DIR_IN DESC_IN GROUP_IN)
-    if(ARGN)
-        foreach(arg ${ARGN})
-            if(NOT source_mode)
-	        if(arg STREQUAL "SOURCES")
-	            set(source_mode true)
-	        else()
-	            message(FATAL_ERROR "Unsupported argument '${arg}' passed to asterisk_scf_compile_slice")
-	        endif()
-            else()
-	        list(APPEND inputs "${arg}")
-            endif()
-        endforeach()
-        set(TARGET "${TARGET_IN}")
-    else()
-        set(slice_files "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_IN}")
-        get_filename_component(file "${TARGET_IN}" NAME_WE)
-        set(TARGET "${file}")
-    endif()
-
-    # Now that we have the list of inputs, convert any of them
-    # that are glob-patterns into the list of files that match
-    if(source_mode)
-        foreach(input ${inputs})
-            if(IS_ABSOLUTE "${input}")
-	        file(GLOB globbed "${input}")
-            else()
-	        file(GLOB globbed "${CMAKE_CURRENT_SOURCE_DIR}/${input}")
-            endif()
-            if(globbed)
-	        foreach (glob ${globbed})
-	            file(TO_CMAKE_PATH "${glob}" cmake_path)
-	            if(glob MATCHES "\\.ice$")
-	                list(APPEND slice_files "${cmake_path}")
-	            endif()
-	            if(glob MATCHES "\\.h$")
-	                list(APPEND cpp_header_files "${cmake_path}")
-	            endif()
-	            if(glob MATCHES "\\.cpp$")
-	                list(APPEND cpp_source_files "${cmake_path}")
-	            endif()
-	        endforeach()
-            else()
-	        if(input MATCHES "\\.ice$")
-	            list(APPEND slice_files "${input}")
-	        endif()
-            endif()
-        endforeach()
-    endif()
-
-    # This makes the Slice definitions display in their own folder in the IDE,
-    # specifically Visual Studio
-    source_group("Slice Definitions" REGULAR_EXPRESSION "\\.ice$")
-
-    # Append the needed include directories for Slice definitions
-    # (global and the ones stored for this target)
-    if(ICE_SLICE_DIR)
-        list(APPEND slice_compiler_arguments "-I${ICE_SLICE_DIR}")
-    endif()
-    foreach(include ${SLICE_INCLUDE_DIRECTORIES})
-        # Each directory in this list will be in the source tree,
-        # which is what the Slice compiler will need
-        list(APPEND slice_compiler_arguments "-I${include}")
-        # If there are any CXX targets that depend on this target,
-        # they'll need a path to the *parallel* directory in the build
-        # tree where the Slice compiler will have generated the
-        # header file(s) for the Slice definitions in the source tree
-        # but only if the Slice include path is actually part of the
-        # source tree... if it's not, it is assumed that the relevant
-        # header files live in the same directory as the Slice files
-        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${include}")
-        if(relpath MATCHES "^../")
-            # The directory is not located in the source tree, so use the
-            # original path
-            list(APPEND target_includes "${include}")
-        else()
-            # The directory is located in the source tree, so use the
-            # parallel path in the build tree
-            list(APPEND target_includes "${CMAKE_BINARY_DIR}/${relpath}")
-        endif()
-    endforeach()
-
-    # Append any definitions stored for this target
-    foreach(SLICEDEF ${SLICE_COMPILE_DEFINITIONS_${TARGET}})
-        list(APPEND slice_compiler_arguments "-D${SLICEDEF}")
-    endforeach()
-    list(REMOVE_DUPLICATES slice_compiler_arguments)
-
-    foreach(file ${slice_files})
-        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${file}")
-        string(REPLACE "/" "_" file_variable ${relpath})
-        set_cache_var(TARGET_${file_variable} ${TARGET})
-    endforeach()
-
-    message(STATUS "Building Slice target ${TARGET} as a library")
-    set(suffixes cpp h)
-    include_directories("${CMAKE_CURRENT_BINARY_DIR}")
-
-    if(NOT SLICE_COMPILER)
-        # Find the actual Slice compiler
-        find_program(SLICE_COMPILER slice2cpp PATHS "${ICE_DIR}/bin" NO_DEFAULT_PATH)
-
-        # If we fail to find it we have to abort here, we can go no further
-        if(SLICE_COMPILER)
-            message(STATUS "Found Slice compiler at ${SLICE_COMPILER}")
-        else()
-            message(FATAL_ERROR "Failed to find Slice compiler")
-        endif()
-    endif()
-
-    # Look for the dependencies for this slice definition, we have to do it now since the target was just added
-    message(STATUS "Determining dependencies for Slice target ${TARGET}")
-    execute_process(COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments}
-        --depend ${slice_files} OUTPUT_VARIABLE raw_dependencies
-        ERROR_VARIABLE slice_errors)
-    if(slice_errors)
-        message(FATAL_ERROR "Slice compiler produced errors:\n ${slice_errors}")
-    endif()
-
-    if(raw_dependencies)
-        # The next block of stuff sanitizes the output we got from the slice compiler into a non-Makefile specific foo
-        # Get rid of all the \ characters
-        string(REPLACE "\\" "" raw_dependencies "${raw_dependencies}")
-        # Turn the newlines into CMake list item separators, since the compiler spits out one dependency per line
-        string(REPLACE "\n" ";" raw_dependencies "${raw_dependencies}")
-        string(REPLACE " ;" ";" raw_dependencies "${raw_dependencies}")
-        string(REPLACE "; " ";" raw_dependencies "${raw_dependencies}")
-
-        foreach(dep ${raw_dependencies})
-            # If the name ends with a colon, it's actually a Makefile target name and should be
-            # skipped
-            if(NOT dep MATCHES ":$")
-                # Convert the path into a cmake one so we can absolutely get the filename
-	        file(TO_CMAKE_PATH ${dep} dep)
-	        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${dep}")
-	        string(REPLACE "/" "_" file_variable "${relpath}")
-	        set(dep_target ${TARGET_${file_variable}})
-	        if(dep_target)
-	            # If this is not already us add it as a dependency
-	            if(NOT dep_target STREQUAL ${TARGET})
-	                message(STATUS "Auto-adding dependency on Slice target ${dep_target} to ${TARGET}")
-	                list(APPEND source_dependencies ${dep})
-	                list(APPEND target_dependencies ${dep_target})
-	                list(APPEND target_includes ${ASTERISK_SCF_SLICE_${dep_target}_INCLUDE_DIRS})
-	            endif()
-	        else()
-	            # Remember sources that are not associated with targets too
-	            message(STATUS "Auto-adding dependency on Slice source ${dep} to ${TARGET}")
-	            list(APPEND source_dependencies ${dep})
-	        endif()
-            endif()
-        endforeach()
-    endif()
-
-    foreach(file ${slice_files})
-        foreach(suffix ${suffixes})
-            get_filename_component(source "${file}" NAME_WE)
-            list(APPEND generated_files "${CMAKE_CURRENT_BINARY_DIR}/${source}.${suffix}")
-        endforeach()
-    endforeach()
-
-    set_source_files_properties(${generated_files} PROPERTIES GENERATED 1)
-
-    # create a preprocessor definition in the generated CXX files that enables
-    # the generated classes to be exported from the library (only necessary on Windows)
-    # the definition for a target named 'FOO' will be 'FOO_EXPORTS', and if this
-    # preprocessor macro is defined, then the Slice-generated classes will be marked
-    # with 'dllexport'. add_library() (used below) automatically generates a definition
-    # for the appropriately-named macro when the library is built in SHARED mode.
-    if(WIN32)
-        list(APPEND slice_export_arguments "--dll-export" "${TARGET}")
-    endif()
-
-    add_custom_command(
-        OUTPUT ${generated_files}
-        COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments} ${slice_export_arguments} ${slice_files}
-        COMMENT "Building ${TARGET} from ${slice_files} using slice2cpp"
-        DEPENDS ${slice_files} ${source_dependencies}
-        )
-
-    if(target_includes)
-        list(REMOVE_DUPLICATES target_includes)
-    endif()
-
-    # Note that slice_files are included as sources here even though they won't be compiled
-    # by the actual compiler; this is to get them to show up as sources in the project
-    # created for this target
-    include_directories(${target_includes})
-    # If there are any non-generated header files required for this Slice target, copy
-    # them to the binary directory where they will be needed later. The destination
-    # path to file() defaults to the binary directory, so there is no need to
-    # re-specify it here.
-    if(cpp_header_files)
-        file(COPY ${cpp_header_files} DESTINATION .)
-    endif()
-    add_library(${TARGET} ${generated_files} ${slice_files} ${cpp_source_files})
-    install(TARGETS ${TARGET} DESTINATION ${DIR_IN} COMPONENT ${TARGET})
-    if(ASTERISKSCF_CPACK)
-        # Adds a component to the packager. The first arg must have been previously defined
-        # as a COMPONENT arg to install.
-        cpack_add_component(${TARGET} DESCRIPTION ${DESC_IN} GROUP ${GROUP_IN})
-    endif()
-    foreach(lib ${${TARGET}_ICE_LIBRARIES} ${ASTERISK_SCF_ICE_LIBRARIES})
-        if(UNIX)
-            list(APPEND target_libs "${lib}")
-        else()
-            list(APPEND target_libs "${ICE_LIB_${lib}}")
-        endif()
-    endforeach()
-    if(target_libs)
-        target_link_libraries(${TARGET} ${target_libs})
-    endif()
-    if(APPLE)
-        target_link_libraries(${TARGET} ${ICE_LIB_IceUtil})
-        target_link_libraries(${TARGET} ${ICE_LIB_ZeroCIce})
-    endif()
-    if(target_dependencies)
-        message(STATUS "Linking ${TARGET} to ${target_dependencies}")
-        target_link_libraries(${TARGET} ${target_dependencies})
-        add_dependencies(${TARGET} ${target_dependencies})
-    endif()
-    if(UNIX)
-        set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "-fPIC")
-    endif()
-    set_cache_var(ASTERISK_SCF_SLICE_${TARGET}_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} ${target_includes})
-    set_cache_var(ASTERISK_SCF_SLICE_${TARGET} Bob)
-endfunction()
-
 # Function which initializes a component for building
 function(asterisk_scf_component_init COMPONENT)
     message(STATUS "Setting up to build component ${COMPONENT}")
     set(ASTERISK_SCF_${COMPONENT} Bob PARENT_SCOPE)
 endfunction()
 
-# Function which adds the compiled Slice targets to a component to be built
-function(asterisk_scf_component_add_slice COMPONENT)
-    if(NOT ARGN)
-        message(FATAL_ERROR "You must pass at least one Slice target to this function")
-    endif()
-    if(NOT ASTERISK_SCF_${COMPONENT})
-        message(FATAL_ERROR "Must call asterisk_scf_component_init for component ${COMPONENT} before asterisk_scf_component_add_slice")
-    endif()
-    set(slice_list ${${COMPONENT}_SLICES})
-    foreach(slice ${ARGN})
-        get_filename_component(f ${slice} NAME_WE)
-        if(NOT ASTERISK_SCF_SLICE_${f})
-            message(FATAL_ERROR "Must call asterisk_scf_compile_slice for ${f} before asterisk_scf_component_add_slice")
-        endif()
-        message(STATUS "Adding Slice ${f} to component ${COMPONENT}")
-        list(APPEND slice_list ${f})
-        list(APPEND include_dirs ${ASTERISK_SCF_SLICE_${slice}_INCLUDE_DIRS})
-    endforeach()
-    list(REMOVE_DUPLICATES slice_list)
-    set(${COMPONENT}_SLICES ${slice_list} PARENT_SCOPE)
-    if(include_dirs)
-        list(REMOVE_DUPLICATES include_dirs)
-        include_directories(${include_dirs})
-    endif()
-endfunction()
-
 # Function which adds source or header files to a component to be built
 function(asterisk_scf_component_add_file COMPONENT)
     if(NOT ARGN)
@@ -782,6 +503,123 @@ function(asterisk_scf_component_add_boost_libraries COMPONENT)
     link_directories(${Boost_LIBRARY_DIRS})
 endfunction()
 
+# Adds a slice file to a target.  This handles all the magic of creating the
+# rules to run slice2cpp, adding the generated headers to the include path,
+# adding the generated .cpp file to the component, etc.  The generated files
+# are placed in ${CMAKE_CURRENT_BINARY_DIR}/generated.
+function(asterisk_scf_component_add_slice COMPONENT SLICE)
+    if(NOT SLICE_COMPILER)
+        # Find the actual Slice compiler
+        find_program(SLICE_COMPILER slice2cpp PATHS "${ICE_DIR}/bin"
+            NO_DEFAULT_PATH)
+
+        # If we fail to find it we have to abort here, we can go no further
+        if(SLICE_COMPILER)
+            message(STATUS "Found Slice compiler at ${SLICE_COMPILER}")
+        else()
+            message(FATAL_ERROR "Failed to find Slice compiler")
+        endif()
+    endif()
+
+    # This makes the Slice definitions display in their own folder in the IDE,
+    # specifically Visual Studio
+    source_group("Slice Definitions" REGULAR_EXPRESSION "\\.ice$")
+
+    # Append the needed include directories for Slice definitions
+    # (global and the ones stored for this target)
+    if(ICE_SLICE_DIR)
+        list(APPEND slice_compiler_arguments "-I${ICE_SLICE_DIR}")
+    endif()
+    foreach(include ${SLICE_INCLUDE_DIRECTORIES})
+        # Each directory in this list will be in the source tree,
+        # which is what the Slice compiler will need
+        list(APPEND slice_compiler_arguments "-I${include}")
+    endforeach()
+
+    message(STATUS "Adding ${SLICE} to ${COMPONENT}")
+    # get subdirectory slice is in
+    get_filename_component(slice_subdir "${SLICE}" PATH)
+
+    # get the directory in which to put the generated code
+    set(slice_out_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
+    # if the slice file is in a subdirectory, maintain that structure
+    if(slice_subdir AND NOT ${slice_subdir} MATCHES "\\.\\.")
+        set(slice_out_dir "${slice_out_dir}/${slice_subdir}")
+    endif()
+    get_filename_component(slice_basename "${SLICE}" NAME_WE)
+    # headers are generated, so add them to the include path
+    include_directories("${CMAKE_CURRENT_BINARY_DIR}/generated")
+    # generated .cpp files #include <.h> directly, which requires the out_dir
+    # itself to be in the include path
+    include_directories("${slice_out_dir}")
+
+    # fully specify SLICE's path
+    set(SLICE "${CMAKE_CURRENT_SOURCE_DIR}/${SLICE}")
+
+    # Look for the dependencies for this slice definition, we have to do it now
+    # since the target was just added
+    message(STATUS "Determining dependencies for ${slice_basename}")
+    execute_process(
+        COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments} --depend ${SLICE}
+        OUTPUT_VARIABLE raw_dependencies
+        ERROR_VARIABLE slice_errors)
+    if(slice_errors)
+        message(FATAL_ERROR "Slice compiler produced errors:\n ${slice_errors}")
+    endif()
+
+    if(raw_dependencies)
+        # get rid of folded newlines
+        string(REPLACE "\\\n" "" raw_dependencies "${raw_dependencies}")
+        # turn newlines into item separators
+        string(REPLACE "\n" ";" raw_dependencies "${raw_dependencies}")
+
+        foreach(dep ${raw_dependencies})
+            # each dep is of the form:
+            #target1 target2 [...] target_n: source1 source2 [...] source_n
+
+            # parse targets
+            string(REGEX MATCHALL "^[^:]+" dep_targets "${dep}")
+            string(REGEX MATCHALL "[^ ]+" dep_targets "${dep_targets}")
+            list(APPEND targets ${dep_targets})
+
+            # parse sources
+            string(REGEX MATCHALL "[^:]+$" dep_sources "${dep}")
+            string(REGEX MATCHALL "[^ ]+" dep_sources "${dep_sources}")
+            list(APPEND sources ${dep_sources})
+        endforeach()
+    endif()
+
+    # prepend the slice_out_dir to the targets
+    foreach(target ${targets})
+        list(APPEND generated_files "${slice_out_dir}/${target}")
+    endforeach()
+    # you would think that would be enough, but slice2cpp doesn't generate a
+    # dep for the .h file
+    list(APPEND generated_files "${slice_out_dir}/${slice_basename}.h")
+    # and be resilient in case it does so in the future...
+    list(REMOVE_DUPLICATES generated_files)
+    set_source_files_properties(${generated_files} PROPERTIES GENERATED 1)
+
+    # create a preprocessor definition in the generated CXX files that enables
+    # the generated classes to be exported from the library (only necessary on
+    # Windows)
+    if(WIN32)
+        list(APPEND slice_compiler_arguments "--dll-export" "ASTERISK_SCF_ICEBOX_EXPORT")
+    endif()
+
+    file(MAKE_DIRECTORY ${slice_out_dir})
+    add_custom_command(
+        OUTPUT ${generated_files}
+        COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments} ${SLICE}
+        --output-dir ${slice_out_dir}
+        COMMENT "slice2cpp translating ${SLICE}"
+        DEPENDS ${sources})
+
+    # now the generated_files are sources for the component
+    list(APPEND ${COMPONENT}_SOURCES ${generated_files})
+    set(${COMPONENT}_SOURCES ${${COMPONENT}_SOURCES} PARENT_SCOPE)
+endfunction()
+
 # Function which builds a component as an IceBox service
 function(asterisk_scf_component_build_icebox COMPONENT)
     message(STATUS "Building component ${COMPONENT} as an IceBox service")
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 63feb16..5e09015 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -51,9 +51,6 @@ asterisk_scf_component_init(examplebox)
 # its subdirectories
 asterisk_scf_slice_include_directories(/home/zaphod/slice)
 
-# If a Slice definition requires macro definitions, they can be specified with this function.
-asterisk_scf_slice_compile_definitions(fluxcapacitor SERVER JOSH=LEET2)
-
 # If a Slice definition uses any Ice-provided definitions (for example, IceBox or IceStorm), then for
 # some languages it is necessary to reference the Ice-provided libraries containing those definitions
 # when building the target. The names of the needed libraries can be provided using this function.
@@ -62,23 +59,9 @@ asterisk_scf_slice_compile_definitions(fluxcapacitor SERVER JOSH=LEET2)
 # TODO: still needed?
 asterisk_scf_slice_add_ice_libraries(fluxcapacitor IceStorm)
 
-# This function compiles a Slice definition (or more than one) into a library.
-# It produces a target named the same as the Slice file without the extension, which can be used in calls to
-# asterisk_scf_slice_include_directories(), asterisk_scf_slice_compile_definitions(),
-# asterisk_scf_component_add_slice(), and asterisk_scf_slice_add_ice_libraries().
-#  Parameters to asterisk_scf_compile_slice:
-#     - The target Slice definition filename. 
-#     - The subdirectory in which to install the output of the build. "lib" is good for most cases, but some 
-#       optional components may choose to install elsewhere. 
-#     - Description for use by the packager. This text typically appears when the user hovers over the component's name
-#       in the installer. 
-#     - Group for use by the packager. The group should be previously configured in the CPackConfig.cmake file. The user
-#       is typically allowed to select specific groups during a custom install process. 
-asterisk_scf_compile_slice(fluxcapacitor.ice lib "Slice Defined API" Core)
-
 # This function takes a component name and Slice target as parameters. It adds the Slice target
 # to the component so it is compiled in and so the headers are made available.
-asterisk_scf_component_add_slice(examplebox fluxcapacitor)
+asterisk_scf_component_add_slice(examplebox fluxcapacitor.ice)
 
 # This function takes a component name and source file as parameters. The source file is added in so it gets
 # compiled into the component. This *must* be called from the same directory that the source file exists in.
@@ -101,7 +84,7 @@ asterisk_scf_component_install(examplebox LIBRARY lib "Icebox example component.
 
 # Now we move on to the next component, a standalone executable.
 asterisk_scf_component_init(example)
-asterisk_scf_component_add_slice(example fluxcapacitor)
+asterisk_scf_component_add_slice(example fluxcapacitor.ice)
 asterisk_scf_component_add_file(example example.cpp)
 
 # This function takes a component name as the parameter. It builds a standalone executable.

commit 787eba376cf49b90159955863421080929f9f903
Author: David M. Lee <dlee at digium.com>
Date:   Tue Jan 11 15:30:10 2011 -0600

    Fixed indention to match style guide.

diff --git a/AsteriskSCF.cmake b/AsteriskSCF.cmake
index c4831c5..c05b57f 100644
--- a/AsteriskSCF.cmake
+++ b/AsteriskSCF.cmake
@@ -47,12 +47,12 @@
 #
 
 if(CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR)
-  message(FATAL_ERROR "This project must not be built in the source directory")
+    message(FATAL_ERROR "This project must not be built in the source directory")
 endif()
 
 # Only permit integrated builds to be done at this time
 if(NOT integrated_build)
-  message(FATAL_ERROR "This project can not be built in a non-integrated fashion. Please use the gitall script present in the gitall repository.")
+    message(FATAL_ERROR "This project can not be built in a non-integrated fashion. Please use the gitall script present in the gitall repository.")
 endif()
 
 # installation directories (these are all relative to ${CMAKE_INSTALL_PREFIX})
@@ -108,28 +108,28 @@ mark_as_advanced(
 
 # Use a compile test to see if shared_ptr is supported. If present then C++0x support exists.
 if(CMAKE_COMPILER_IS_GNUCXX)
-  try_compile(SHARED_PTR_PRESENT
-    ${CMAKE_BINARY_DIR}
-    ${CMAKE_SOURCE_DIR}/cmake/tests/SharedPtr.cpp
-    COMPILE_DEFINITIONS "-std=c++0x"
-    OUTPUT_VARIABLE OUTPUT
-    )
-  if(SHARED_PTR_PRESENT)
-    message(STATUS "Support for C++0x Enabled")
-    add_definitions("-DCPP_ZEROX_SUPPORT")
-    set(CPP_ZEROX_STD "-std=c++0x")
-  else()
-    message(STATUS "Support for C++0x Disabled")
-  endif()
+    try_compile(SHARED_PTR_PRESENT
+        ${CMAKE_BINARY_DIR}
+        ${CMAKE_SOURCE_DIR}/cmake/tests/SharedPtr.cpp
+        COMPILE_DEFINITIONS "-std=c++0x"
+        OUTPUT_VARIABLE OUTPUT
+        )
+    if(SHARED_PTR_PRESENT)
+        message(STATUS "Support for C++0x Enabled")
+        add_definitions("-DCPP_ZEROX_SUPPORT")
+        set(CPP_ZEROX_STD "-std=c++0x")
+    else()
+        message(STATUS "Support for C++0x Disabled")
+    endif()
 endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
 
 # If a build type has not been explicitly specified then use debug
 if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE debug CACHE STRING
-    "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Profile."
-    FORCE)
+    set(CMAKE_BUILD_TYPE debug CACHE STRING
+        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Profile."
+        FORCE)
 endif()
 
 # since Debug, debug and DeBuG all mean the same thing to cmake, tolower it
@@ -140,66 +140,66 @@ string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE)
 find_package(Threads REQUIRED)
 
 if(CMAKE_SYSTEM MATCHES "SunOS.*")
-  set(CMAKE_CXX_FLAGS "-pthreads ")
+    set(CMAKE_CXX_FLAGS "-pthreads ")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUC)
-  set(CMAKE_C_FLAGS_DEBUG "-Werror -Wall -g3"
-    CACHE STRING "Flags used by the compiler during debug builds." FORCE)
+    set(CMAKE_C_FLAGS_DEBUG "-Werror -Wall -g3"
+        CACHE STRING "Flags used by the compiler during debug builds." FORCE)
 endif()
 if(CMAKE_COMPILER_IS_GNUCXX)
-  set(CMAKE_CXX_FLAGS "${CPP_ZEROX_STD}"
-    CACHE STRING "Flags used by the compiler during release builds." FORCE)
-  set(CMAKE_CXX_FLAGS_DEBUG "-Werror -Wall -g3"
-    CACHE STRING "Flags used by the compiler during debug builds." FORCE)
+    set(CMAKE_CXX_FLAGS "${CPP_ZEROX_STD}"
+        CACHE STRING "Flags used by the compiler during release builds." FORCE)
+    set(CMAKE_CXX_FLAGS_DEBUG "-Werror -Wall -g3"
+        CACHE STRING "Flags used by the compiler during debug builds." FORCE)
 endif()
 
 if(WIN32 AND ${CMAKE_BUILD_TYPE} STREQUAL profile)
-  message(FATAL_ERROR "Profile builds not supported")
+    message(FATAL_ERROR "Profile builds not supported")
 endif()
 
 if(NOT WIN32)
-  message(STATUS "Adding profile flags")
-  set(CMAKE_C_FLAGS_PROFILE
-    "${CMAKE_C_FLAGS_DEBUG} -ftest-coverage -fprofile-arcs"
-    CACHE STRING "Flags used by the compiler during profile builds." FORCE)
-  set(CMAKE_CXX_FLAGS_PROFILE
-    "${CMAKE_CXX_FLAGS_DEBUG} -ftest-coverage -fprofile-arcs"
-    CACHE STRING "Flags used by the compiler during profile builds." FORCE)
-  set(CMAKE_EXE_LINKER_FLAGS_PROFILE
-    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}"
-    CACHE STRING "Flags used by the linker during profile builds." FORCE)
-
-  mark_as_advanced(
-    CMAKE_C_FLAGS_PROFILE
-    CMAKE_CXX_FLAGS_PROFILE
-    CMAKE_EXE_LINKER_FLAGS_PROFILE)
+    message(STATUS "Adding profile flags")
+    set(CMAKE_C_FLAGS_PROFILE
+        "${CMAKE_C_FLAGS_DEBUG} -ftest-coverage -fprofile-arcs"
+        CACHE STRING "Flags used by the compiler during profile builds." FORCE)
+    set(CMAKE_CXX_FLAGS_PROFILE
+        "${CMAKE_CXX_FLAGS_DEBUG} -ftest-coverage -fprofile-arcs"
+        CACHE STRING "Flags used by the compiler during profile builds." FORCE)
+    set(CMAKE_EXE_LINKER_FLAGS_PROFILE
+        "${CMAKE_EXE_LINKER_FLAGS_DEBUG}"
+        CACHE STRING "Flags used by the linker during profile builds." FORCE)
+
+    mark_as_advanced(
+        CMAKE_C_FLAGS_PROFILE
+        CMAKE_CXX_FLAGS_PROFILE
+        CMAKE_EXE_LINKER_FLAGS_PROFILE)
 endif()
 
 if(${CMAKE_BUILD_TYPE} STREQUAL profile)
-  message(STATUS "Disabling shared libs.")
-  set(BUILD_SHARED_LIBS false
-    CACHE BOOL "Enables building shared libraries." FORCE)
+    message(STATUS "Disabling shared libs.")
+    set(BUILD_SHARED_LIBS false
+        CACHE BOOL "Enables building shared libraries." FORCE)
 endif()
 
 if(NOT DEFINED BUILD_SHARED_LIBS)
-  message(STATUS "Enabling shared libs.")
-  set(BUILD_SHARED_LIBS true
-    CACHE BOOL "Enables building shared libraries." FORCE)
+    message(STATUS "Enabling shared libs.")
+    set(BUILD_SHARED_LIBS true
+        CACHE BOOL "Enables building shared libraries." FORCE)
 endif()
 
 # Enable the use of CTest for running unit tests
 enable_testing()
 
 if(UNIX AND EXISTS "${CMAKE_SOURCE_DIR}/.svn")
-  add_custom_target(update COMMAND svn update WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating checkout")
+    add_custom_target(update COMMAND svn update WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating checkout")
 elseif(UNIX AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
-  add_custom_target(update COMMAND git pull WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating clone")
-  add_custom_target(pull COMMAND git pull WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating clone")
+    add_custom_target(update COMMAND git pull WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating clone")
+    add_custom_target(pull COMMAND git pull WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" COMMENT "Updating clone")
 endif()
 
 macro(set_cache_var)
-  set(${ARGV} CACHE INTERNAL Bob FORCE)
+    set(${ARGV} CACHE INTERNAL Bob FORCE)
 endmacro()
 
 # Function which scans a path for matching files or directories,
@@ -208,251 +208,251 @@ endmacro()
 # if there were no matches. Single-character globs (?) can
 # be used in the base string, but not multi-character globs (*).
 function(find_best_version output base)
-  get_filename_component(base_full "${base}" ABSOLUTE)
-  file(GLOB path_list "${base_full}*")
-  string(LENGTH "${base_full}" base_length)
-  foreach(path ${path_list})
-    get_filename_component(path_full "${path}" ABSOLUTE)
-    string(LENGTH "${path_full}" path_length)
-    math(EXPR get "${path_length} - ${base_length}")
-    string(SUBSTRING "${path_full}" ${base_length} ${get} ver)
-    if(NOT DEFINED best_ver)
-      set(best_ver ${ver})
-      set(best_path "${path_full}")
-    elseif(best_ver VERSION_LESS ver)
-      set(best_ver ${ver})
-      set(best_path "${path_full}")
-    endif()
-  endforeach()
-  if(DEFINED best_ver)
-    set(${output} "${best_path}" PARENT_SCOPE)
-  else()
-    set(${output} "NOTFOUND" PARENT_SCOPE)
-  endif()
+    get_filename_component(base_full "${base}" ABSOLUTE)
+    file(GLOB path_list "${base_full}*")
+    string(LENGTH "${base_full}" base_length)
+    foreach(path ${path_list})
+        get_filename_component(path_full "${path}" ABSOLUTE)
+        string(LENGTH "${path_full}" path_length)
+        math(EXPR get "${path_length} - ${base_length}")
+        string(SUBSTRING "${path_full}" ${base_length} ${get} ver)
+        if(NOT DEFINED best_ver)
+            set(best_ver ${ver})
+            set(best_path "${path_full}")
+        elseif(best_ver VERSION_LESS ver)
+            set(best_ver ${ver})
+            set(best_path "${path_full}")
+        endif()
+    endforeach()
+    if(DEFINED best_ver)
+        set(${output} "${best_path}" PARENT_SCOPE)
+    else()
+        set(${output} "NOTFOUND" PARENT_SCOPE)
+    endif()
 endfunction()
 
 # Find Ice installation for a specific major/minor version
 function(find_ICE version)
-  set(ice "$ENV{ICE_HOME}")
-  if(NOT ice)
-    if(WIN32)
-      find_best_version(ice "C:/Ice-${version}")
-    elseif(UNIX)
-      find_best_version(ice "/opt/Ice-${version}")
-    endif()
-  endif()
-
-  if(NOT ice)
-    message(FATAL_ERROR "Could not find an installation of Ice with version ${version}")
-  endif()
-  find_path(ICE_SLICE_DIR Ice/Current.ice PATHS "${ice}/../slice" "${ice}/slice" NO_DEFAULT_PATH)
-  if(ICE_SLICE_DIR)
-    message(STATUS "Found Ice Slice definitions in ${ICE_SLICE_DIR}")
-  else()
-    message(FATAL_ERROR "Ice installation located at ${ice} is incomplete or broken (missing 'slice' directory)")
-  endif()
-  file(TO_CMAKE_PATH "${ice}" ice_cmake_path)
-  set_cache_var(ICE_DIR "${ice_cmake_path}")
-
-  # find icebox executable
-  # XXX Need to look for iceboxd.exe for debug windows builds
-  find_program(ICEBOX icebox PATHS "${ICE_DIR}/bin" NO_DEFAULT_PATH)
-
-  if(ICEBOX)
-    message(STATUS "Found icebox at ${ICEBOX}")
-  else()
-    message(WARNING "Failed to find icebox ${ICE_DIR}")
-  endif()
-  find_path(ICE_INCLUDE_DIR Ice/Ice.h PATHS "${ICE_DIR}/include" NO_DEFAULT_PATH)
-  if(ICE_INCLUDE_DIR)
-    message(STATUS "Found Ice headers in ${ICE_INCLUDE_DIR}")
-  else()
-    message(FATAL_ERROR "Failed to find Ice headers")
-  endif()
-  # This block essentially tricks the GNU compiler into treating the Ice header files as system headers. This has
-  # the benefit of having warnings emitted by the headers NOT treated as errors, even if the compiler has been told
-  # to do so. This is currently being utilized by the C++0x support in this file so that Ice itself does not have to
-  # be updated to be C++0x safe.
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${ICE_INCLUDE_DIR}"
-      CACHE STRING "Flags used by the compiler during release builds." FORCE)
-  endif()
+    set(ice "$ENV{ICE_HOME}")
+    if(NOT ice)
+        if(WIN32)
+            find_best_version(ice "C:/Ice-${version}")
+        elseif(UNIX)
+            find_best_version(ice "/opt/Ice-${version}")
+        endif()
+    endif()
+
+    if(NOT ice)
+        message(FATAL_ERROR "Could not find an installation of Ice with version ${version}")
+    endif()
+    find_path(ICE_SLICE_DIR Ice/Current.ice PATHS "${ice}/../slice" "${ice}/slice" NO_DEFAULT_PATH)
+    if(ICE_SLICE_DIR)
+        message(STATUS "Found Ice Slice definitions in ${ICE_SLICE_DIR}")
+    else()
+        message(FATAL_ERROR "Ice installation located at ${ice} is incomplete or broken (missing 'slice' directory)")
+    endif()
+    file(TO_CMAKE_PATH "${ice}" ice_cmake_path)
+    set_cache_var(ICE_DIR "${ice_cmake_path}")
+
+    # find icebox executable
+    # XXX Need to look for iceboxd.exe for debug windows builds
+    find_program(ICEBOX icebox PATHS "${ICE_DIR}/bin" NO_DEFAULT_PATH)
+
+    if(ICEBOX)
+        message(STATUS "Found icebox at ${ICEBOX}")
+    else()
+        message(WARNING "Failed to find icebox ${ICE_DIR}")
+    endif()
+    find_path(ICE_INCLUDE_DIR Ice/Ice.h PATHS "${ICE_DIR}/include" NO_DEFAULT_PATH)
+    if(ICE_INCLUDE_DIR)
+        message(STATUS "Found Ice headers in ${ICE_INCLUDE_DIR}")
+    else()
+        message(FATAL_ERROR "Failed to find Ice headers")
+    endif()
+    # This block essentially tricks the GNU compiler into treating the Ice header files as system headers. This has
+    # the benefit of having warnings emitted by the headers NOT treated as errors, even if the compiler has been told
+    # to do so. This is currently being utilized by the C++0x support in this file so that Ice itself does not have to
+    # be updated to be C++0x safe.
+    if(CMAKE_COMPILER_IS_GNUCXX)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${ICE_INCLUDE_DIR}"
+            CACHE STRING "Flags used by the compiler during release builds." FORCE)
+    endif()
 endfunction()
 
 # Find an Ice library.
 function(find_ICE_library LIBRARY)
-  if(NOT ICE_LIB_${LIBRARY})
-    if(WIN32)
-      string(TOLOWER ${LIBRARY} lib)
-      find_library(ICE_LIB_RELEASE_${LIBRARY} ${lib} PATHS "${ICE_DIR}/lib" NO_DEFAULT_PATH)
-      if(ICE_LIB_RELEASE_${LIBRARY})
-	message(STATUS "Found Ice '${LIBRARY}' library (release build) at ${ICE_LIB_RELEASE_${LIBRARY}}")
-	list(APPEND ficxxl_libs optimized "${ICE_LIB_RELEASE_${LIBRARY}}")
-      endif()
-      find_library(ICE_LIB_DEBUG_${LIBRARY} ${lib}d PATHS "${ICE_DIR}/lib" NO_DEFAULT_PATH)
-      if(ICE_LIB_DEBUG_${LIBRARY})
-	message(STATUS "Found Ice '${LIBRARY}' library (debug build) at ${ICE_LIB_DEBUG_${LIBRARY}}")
-	list(APPEND ficxxl_libs debug "${ICE_LIB_DEBUG_${LIBRARY}}")
-      endif()
-      if(ficxxl_libs)
-	set_cache_var(ICE_LIB_${LIBRARY} ${ficxxl_libs})
-      else()
-	message(FATAL_ERROR "Failed to find Ice '${LIBRARY}' library")
-      endif()
-    elseif(UNIX)
-      find_library(ICE_LIB_${LIBRARY} ${LIBRARY} PATHS "${ICE_DIR}/lib" "${ICE_DIR}/lib32" "${ICE_DIR}/lib64" NO_DEFAULT_PATH)
-      if(ICE_LIB_${LIBRARY})
-	message(STATUS "Found Ice '${LIBRARY}' library at ${ICE_LIB_${LIBRARY}}")
-      else()
-	message(FATAL_ERROR "Failed to find Ice '${LIBRARY}' library")
-      endif()
-    endif()
-  endif()
-
-  if(UNIX)
-    get_filename_component(library_path ${ICE_LIB_${LIBRARY}} PATH)
-    link_directories(${library_path})
-  endif()
+    if(NOT ICE_LIB_${LIBRARY})
+        if(WIN32)
+            string(TOLOWER ${LIBRARY} lib)
+            find_library(ICE_LIB_RELEASE_${LIBRARY} ${lib} PATHS "${ICE_DIR}/lib" NO_DEFAULT_PATH)
+            if(ICE_LIB_RELEASE_${LIBRARY})
+	        message(STATUS "Found Ice '${LIBRARY}' library (release build) at ${ICE_LIB_RELEASE_${LIBRARY}}")
+	        list(APPEND ficxxl_libs optimized "${ICE_LIB_RELEASE_${LIBRARY}}")
+            endif()
+            find_library(ICE_LIB_DEBUG_${LIBRARY} ${lib}d PATHS "${ICE_DIR}/lib" NO_DEFAULT_PATH)
+            if(ICE_LIB_DEBUG_${LIBRARY})
+	        message(STATUS "Found Ice '${LIBRARY}' library (debug build) at ${ICE_LIB_DEBUG_${LIBRARY}}")
+	        list(APPEND ficxxl_libs debug "${ICE_LIB_DEBUG_${LIBRARY}}")
+            endif()
+            if(ficxxl_libs)
+	        set_cache_var(ICE_LIB_${LIBRARY} ${ficxxl_libs})
+            else()
+	        message(FATAL_ERROR "Failed to find Ice '${LIBRARY}' library")
+            endif()
+        elseif(UNIX)
+            find_library(ICE_LIB_${LIBRARY} ${LIBRARY} PATHS "${ICE_DIR}/lib" "${ICE_DIR}/lib32" "${ICE_DIR}/lib64" NO_DEFAULT_PATH)
+            if(ICE_LIB_${LIBRARY})
+	        message(STATUS "Found Ice '${LIBRARY}' library at ${ICE_LIB_${LIBRARY}}")
+            else()
+	        message(FATAL_ERROR "Failed to find Ice '${LIBRARY}' library")
+            endif()
+        endif()
+    endif()
+
+    if(UNIX)
+        get_filename_component(library_path ${ICE_LIB_${LIBRARY}} PATH)
+        link_directories(${library_path})
+    endif()
 endfunction()
 
 # Find a Boost library.
 function(find_Boost_library LIBRARY)
-  if(NOT Boost_FOUND)
-    set(Boost_ADDITIONAL_VERSIONS "1.39" "1.39.0" "1.40" "1.40.0" "1.41" "1.41.0" "1.42" "1.42.0" "1.44" "1.44.0")
-    find_package(Boost)
     if(NOT Boost_FOUND)
-      message(FATAL_ERROR "Boost libraries not found")
-    endif()
-    set(Boost_CORE_FOUND "bazinga" PARENT_SCOPE)
-    set(Boost_CORE_FOUND "bazinga")
-  endif()
-  string(TOUPPER ${LIBRARY} libtag)
-  if(NOT Boost_${libtag}_FOUND)
-    find_package(Boost COMPONENTS ${LIBRARY})
+        set(Boost_ADDITIONAL_VERSIONS "1.39" "1.39.0" "1.40" "1.40.0" "1.41" "1.41.0" "1.42" "1.42.0" "1.44" "1.44.0")
+        find_package(Boost)
+        if(NOT Boost_FOUND)
+            message(FATAL_ERROR "Boost libraries not found")
+        endif()
+        set(Boost_CORE_FOUND "bazinga" PARENT_SCOPE)
+        set(Boost_CORE_FOUND "bazinga")
+    endif()
+    string(TOUPPER ${LIBRARY} libtag)
     if(NOT Boost_${libtag}_FOUND)
-      message(FATAL_ERROR "Failed to find Boost library ${LIBRARY}")
+        find_package(Boost COMPONENTS ${LIBRARY})
+        if(NOT Boost_${libtag}_FOUND)
+            message(FATAL_ERROR "Failed to find Boost library ${LIBRARY}")
+        endif()
     endif()
-  endif()
 endfunction()
 
 # Function which initializes project specific things
 function(asterisk_scf_project NAME ICE_VERSION)
-  message(STATUS "Setting up project ${NAME} for Ice version ${ICE_VERSION}")
-  set(ASTERISK_SCF_ICE_VERSION ${ICE_VERSION} PARENT_SCOPE)
-  project(${NAME} CXX)
-  # On Windows, IceBox C++ services must be compiled with some symbols exported;
-  # the source code should use ASTERISK_SCF_ICEBOX_EXPORT to accomplish this, and this
-  if(WIN32)
-    message(STATUS "Setting ASTERISK_SCF_ICEBOX_EXPORT definition for Windows IceBox services")
-    add_definitions(-DASTERISK_SCF_ICEBOX_EXPORT=__declspec\(dllexport\))
-  else()
-    add_definitions(-DASTERISK_SCF_ICEBOX_EXPORT=)
-  endif()
-  # On Windows, 'debug' libraries should have a "d" suffix to indicate that they
-  # are debug libraries
-  if(WIN32)
-    set(CMAKE_DEBUG_POSTFIX "d" PARENT_SCOPE)
-  endif()
-  find_ICE(${ICE_VERSION})
-  message(STATUS "Performing requirement checks for components")
-  find_ICE_library(Ice)
-  find_ICE_library(IceUtil)
-  if(WIN32)
-    # On Windows, the IceUtil library must be explicitly linked
-    set(ASTERISK_SCF_ICE_LIBRARIES Ice IceUtil PARENT_SCOPE)
-  else()
-    set(ASTERISK_SCF_ICE_LIBRARIES Ice PARENT_SCOPE)
-  endif()
-  message(STATUS "Include directories ${ICE_INCLUDE_DIR}")
-  include_directories("${ICE_INCLUDE_DIR}")
-  message(STATUS "Passed requirement checks for CXX components")
+    message(STATUS "Setting up project ${NAME} for Ice version ${ICE_VERSION}")
+    set(ASTERISK_SCF_ICE_VERSION ${ICE_VERSION} PARENT_SCOPE)
+    project(${NAME} CXX)
+    # On Windows, IceBox C++ services must be compiled with some symbols exported;
+    # the source code should use ASTERISK_SCF_ICEBOX_EXPORT to accomplish this, and this
+    if(WIN32)
+        message(STATUS "Setting ASTERISK_SCF_ICEBOX_EXPORT definition for Windows IceBox services")
+        add_definitions(-DASTERISK_SCF_ICEBOX_EXPORT=__declspec\(dllexport\))
+    else()
+        add_definitions(-DASTERISK_SCF_ICEBOX_EXPORT=)
+    endif()
+    # On Windows, 'debug' libraries should have a "d" suffix to indicate that they
+    # are debug libraries
+    if(WIN32)
+        set(CMAKE_DEBUG_POSTFIX "d" PARENT_SCOPE)
+    endif()
+    find_ICE(${ICE_VERSION})
+    message(STATUS "Performing requirement checks for components")
+    find_ICE_library(Ice)
+    find_ICE_library(IceUtil)
+    if(WIN32)
+        # On Windows, the IceUtil library must be explicitly linked
+        set(ASTERISK_SCF_ICE_LIBRARIES Ice IceUtil PARENT_SCOPE)
+    else()
+        set(ASTERISK_SCF_ICE_LIBRARIES Ice PARENT_SCOPE)
+    endif()
+    message(STATUS "Include directories ${ICE_INCLUDE_DIR}")
+    include_directories("${ICE_INCLUDE_DIR}")
+    message(STATUS "Passed requirement checks for CXX components")
 endfunction()
 
 # Function which adds Ice libraries to all components in the current
 # directory and below
 function(asterisk_scf_add_ice_libraries)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one library to this function")
-  endif()
-  set(libs ${ASTERISK_SCF_ICE_LIBRARIES})
-  foreach(lib ${ARGN})
-    find_ICE_library(${lib})
-    list(APPEND libs ${lib})
-  endforeach()
-  list(REMOVE_DUPLICATES libs)
-  set(ASTERISK_SCF_ICE_LIBRARIES ${libs} PARENT_SCOPE)
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one library to this function")
+    endif()
+    set(libs ${ASTERISK_SCF_ICE_LIBRARIES})
+    foreach(lib ${ARGN})
+        find_ICE_library(${lib})
+        list(APPEND libs ${lib})
+    endforeach()
+    list(REMOVE_DUPLICATES libs)
+    set(ASTERISK_SCF_ICE_LIBRARIES ${libs} PARENT_SCOPE)
 endfunction()
 
 # Function which adds Boost libraries to all components in the current
 # directory and below
 function(asterisk_scf_add_boost_libraries)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one library to this function")
-  endif()
-  set(libs ${ASTERISK_SCF_BOOST_LIBRARIES})
-  # By default we are disabling boost auto-linking and specifying dynamic linking. 
-  add_definitions(-DBOOST_ALL_NO_LIB -DBOOST_ALL_DYN_LINK)  
-  foreach(lib ${ARGN})
-    find_Boost_library(${lib})
-    list(APPEND libs ${lib})
-  endforeach()
-  list(REMOVE_DUPLICATES libs)
-  set(ASTERISK_SCF_BOOST_LIBRARIES ${libs} PARENT_SCOPE)
-  include_directories(${Boost_INCLUDE_DIR})
-  link_directories(${Boost_LIBRARY_DIRS})
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one library to this function")
+    endif()
+    set(libs ${ASTERISK_SCF_BOOST_LIBRARIES})
+    # By default we are disabling boost auto-linking and specifying dynamic linking.
+    add_definitions(-DBOOST_ALL_NO_LIB -DBOOST_ALL_DYN_LINK)
+    foreach(lib ${ARGN})
+        find_Boost_library(${lib})
+        list(APPEND libs ${lib})
+    endforeach()
+    list(REMOVE_DUPLICATES libs)
+    set(ASTERISK_SCF_BOOST_LIBRARIES ${libs} PARENT_SCOPE)
+    include_directories(${Boost_INCLUDE_DIR})
+    link_directories(${Boost_LIBRARY_DIRS})
 endfunction()
 
 # Ensures that a list of paths are all absolute paths.
 macro(ensure_abs_paths pathlist)
-  unset(eap_temp)
-  foreach(p ${${pathlist}})
-    get_filename_component(newpath "${p}" ABSOLUTE)
-    list(APPEND eap_temp "${newpath}")
-  endforeach()
-  list(REMOVE_DUPLICATES eap_temp)
-  set(${pathlist} ${eap_temp})
+    unset(eap_temp)
+    foreach(p ${${pathlist}})
+        get_filename_component(newpath "${p}" ABSOLUTE)
+        list(APPEND eap_temp "${newpath}")
+    endforeach()
+    list(REMOVE_DUPLICATES eap_temp)
+    set(${pathlist} ${eap_temp})
 endmacro()
 
 # Function which remembers include directories needed for a particular Slice target
 function(asterisk_scf_slice_include_directories)
-  set(paths ${ARGN})
-  ensure_abs_paths(paths)
-  if(SLICE_INCLUDE_DIRECTORIES)
-    list(INSERT paths 0 ${SLICE_INCLUDE_DIRECTORIES})
-  endif()
-  list(REMOVE_DUPLICATES paths)
-  set(SLICE_INCLUDE_DIRECTORIES ${paths} PARENT_SCOPE)
+    set(paths ${ARGN})
+    ensure_abs_paths(paths)
+    if(SLICE_INCLUDE_DIRECTORIES)
+        list(INSERT paths 0 ${SLICE_INCLUDE_DIRECTORIES})
+    endif()
+    list(REMOVE_DUPLICATES paths)
+    set(SLICE_INCLUDE_DIRECTORIES ${paths} PARENT_SCOPE)
 endfunction()
 
 # Function which remembers definitions needed for a particular Slice target
 function(asterisk_scf_slice_compile_definitions SLICE_FILE)
-  get_filename_component(SLICE ${SLICE_FILE} NAME_WE)
-  set(SLICE_COMPILE_DEFINITIONS_${SLICE} ${ARGN} PARENT_SCOPE)
+    get_filename_component(SLICE ${SLICE_FILE} NAME_WE)
+    set(SLICE_COMPILE_DEFINITIONS_${SLICE} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # Function which remembers Ice libraries needed by a Slice target
 function(asterisk_scf_slice_add_ice_libraries TARGET)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one library to this function")
-  endif()
-  set(libs ${${TARGET}_ICE_LIBRARIES})
-  foreach(lib ${ARGN})
-    find_ICE_library(${lib})
-    list(APPEND libs ${lib})
-  endforeach()
-  list(REMOVE_DUPLICATES libs)
-  set(${TARGET}_ICE_LIBRARIES ${libs} PARENT_SCOPE)
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one library to this function")
+    endif()
+    set(libs ${${TARGET}_ICE_LIBRARIES})
+    foreach(lib ${ARGN})
+        find_ICE_library(${lib})
+        list(APPEND libs ${lib})
+    endforeach()
+    list(REMOVE_DUPLICATES libs)
+    set(${TARGET}_ICE_LIBRARIES ${libs} PARENT_SCOPE)
 endfunction()
 
 # Function which adds a dependency for a Slice definition
 function(asterisk_scf_slice_add_dependencies TARGET)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one dependency to this function")
-  endif()
-  foreach(d ${ARGN})
-    message(STATUS "Adding dependency on slice definition ${d} to ${TARGET}")
-    add_dependencies(${TARGET}_${l} ${d}_${l})
-  endforeach()
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one dependency to this function")
+    endif()
+    foreach(d ${ARGN})
+        message(STATUS "Adding dependency on slice definition ${d} to ${TARGET}")
+        add_dependencies(${TARGET}_${l} ${d}_${l})
+    endforeach()
 endfunction()
 
 # Function which compiles one or more Slice definition files
@@ -477,436 +477,436 @@ endfunction()
 # ASTERISK_SCF_SLICE_${SLICE}_INCLUDE_DIRS
 #  directories where generated header files needed for this target live
 function(asterisk_scf_compile_slice TARGET_IN DIR_IN DESC_IN GROUP_IN)
-  if(ARGN)
-    foreach(arg ${ARGN})
-      if(NOT source_mode)
-	if(arg STREQUAL "SOURCES")
-	  set(source_mode true)
-	else()
-	  message(FATAL_ERROR "Unsupported argument '${arg}' passed to asterisk_scf_compile_slice")
-	endif()
-      else()
-	list(APPEND inputs "${arg}")
-      endif()
+    if(ARGN)
+        foreach(arg ${ARGN})
+            if(NOT source_mode)
+	        if(arg STREQUAL "SOURCES")
+	            set(source_mode true)
+	        else()
+	            message(FATAL_ERROR "Unsupported argument '${arg}' passed to asterisk_scf_compile_slice")
+	        endif()
+            else()
+	        list(APPEND inputs "${arg}")
+            endif()
+        endforeach()
+        set(TARGET "${TARGET_IN}")
+    else()
+        set(slice_files "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_IN}")
+        get_filename_component(file "${TARGET_IN}" NAME_WE)
+        set(TARGET "${file}")
+    endif()
+
+    # Now that we have the list of inputs, convert any of them
+    # that are glob-patterns into the list of files that match
+    if(source_mode)
+        foreach(input ${inputs})
+            if(IS_ABSOLUTE "${input}")
+	        file(GLOB globbed "${input}")
+            else()
+	        file(GLOB globbed "${CMAKE_CURRENT_SOURCE_DIR}/${input}")
+            endif()
+            if(globbed)
+	        foreach (glob ${globbed})
+	            file(TO_CMAKE_PATH "${glob}" cmake_path)
+	            if(glob MATCHES "\\.ice$")
+	                list(APPEND slice_files "${cmake_path}")
+	            endif()
+	            if(glob MATCHES "\\.h$")
+	                list(APPEND cpp_header_files "${cmake_path}")
+	            endif()
+	            if(glob MATCHES "\\.cpp$")
+	                list(APPEND cpp_source_files "${cmake_path}")
+	            endif()
+	        endforeach()
+            else()
+	        if(input MATCHES "\\.ice$")
+	            list(APPEND slice_files "${input}")
+	        endif()
+            endif()
+        endforeach()
+    endif()
+
+    # This makes the Slice definitions display in their own folder in the IDE,
+    # specifically Visual Studio
+    source_group("Slice Definitions" REGULAR_EXPRESSION "\\.ice$")
+
+    # Append the needed include directories for Slice definitions
+    # (global and the ones stored for this target)
+    if(ICE_SLICE_DIR)
+        list(APPEND slice_compiler_arguments "-I${ICE_SLICE_DIR}")
+    endif()
+    foreach(include ${SLICE_INCLUDE_DIRECTORIES})
+        # Each directory in this list will be in the source tree,
+        # which is what the Slice compiler will need
+        list(APPEND slice_compiler_arguments "-I${include}")
+        # If there are any CXX targets that depend on this target,
+        # they'll need a path to the *parallel* directory in the build
+        # tree where the Slice compiler will have generated the
+        # header file(s) for the Slice definitions in the source tree
+        # but only if the Slice include path is actually part of the
+        # source tree... if it's not, it is assumed that the relevant
+        # header files live in the same directory as the Slice files
+        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${include}")
+        if(relpath MATCHES "^../")
+            # The directory is not located in the source tree, so use the
+            # original path
+            list(APPEND target_includes "${include}")
+        else()
+            # The directory is located in the source tree, so use the
+            # parallel path in the build tree
+            list(APPEND target_includes "${CMAKE_BINARY_DIR}/${relpath}")
+        endif()
     endforeach()
-    set(TARGET "${TARGET_IN}")
-  else()
-    set(slice_files "${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_IN}")
-    get_filename_component(file "${TARGET_IN}" NAME_WE)
-    set(TARGET "${file}")
-  endif()
-
-  # Now that we have the list of inputs, convert any of them
-  # that are glob-patterns into the list of files that match
-  if(source_mode)
-    foreach(input ${inputs})
-      if(IS_ABSOLUTE "${input}")
-	file(GLOB globbed "${input}")
-      else()
-	file(GLOB globbed "${CMAKE_CURRENT_SOURCE_DIR}/${input}")
-      endif()
-      if(globbed)
-	foreach (glob ${globbed})
-	  file(TO_CMAKE_PATH "${glob}" cmake_path)
-	  if(glob MATCHES "\\.ice$")
-	    list(APPEND slice_files "${cmake_path}")
-	  endif()
-	  if(glob MATCHES "\\.h$")
-	    list(APPEND cpp_header_files "${cmake_path}")
-	  endif()
-	  if(glob MATCHES "\\.cpp$")
-	    list(APPEND cpp_source_files "${cmake_path}")
-	  endif()
-	endforeach()
-      else()
-	if(input MATCHES "\\.ice$")
-	  list(APPEND slice_files "${input}")
-	endif()
-      endif()
+
+    # Append any definitions stored for this target
+    foreach(SLICEDEF ${SLICE_COMPILE_DEFINITIONS_${TARGET}})
+        list(APPEND slice_compiler_arguments "-D${SLICEDEF}")
     endforeach()
-  endif()
-
-  # This makes the Slice definitions display in their own folder in the IDE,
-  # specifically Visual Studio
-  source_group("Slice Definitions" REGULAR_EXPRESSION "\\.ice$")
-
-  # Append the needed include directories for Slice definitions
-  # (global and the ones stored for this target)
-  if(ICE_SLICE_DIR)
-    list(APPEND slice_compiler_arguments "-I${ICE_SLICE_DIR}")
-  endif()
-  foreach(include ${SLICE_INCLUDE_DIRECTORIES})
-    # Each directory in this list will be in the source tree,
-    # which is what the Slice compiler will need
-    list(APPEND slice_compiler_arguments "-I${include}")
-    # If there are any CXX targets that depend on this target,
-    # they'll need a path to the *parallel* directory in the build
-    # tree where the Slice compiler will have generated the
-    # header file(s) for the Slice definitions in the source tree
-    # but only if the Slice include path is actually part of the
-    # source tree... if it's not, it is assumed that the relevant
-    # header files live in the same directory as the Slice files
-    file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${include}")
-    if(relpath MATCHES "^../")
-      # The directory is not located in the source tree, so use the
-      # original path
-      list(APPEND target_includes "${include}")
-    else()
-      # The directory is located in the source tree, so use the
-      # parallel path in the build tree
-      list(APPEND target_includes "${CMAKE_BINARY_DIR}/${relpath}")
-    endif()
-  endforeach()
-
-  # Append any definitions stored for this target
-  foreach(SLICEDEF ${SLICE_COMPILE_DEFINITIONS_${TARGET}})
-    list(APPEND slice_compiler_arguments "-D${SLICEDEF}")
-  endforeach()
-  list(REMOVE_DUPLICATES slice_compiler_arguments)
-
-  foreach(file ${slice_files})
-    file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${file}")
-    string(REPLACE "/" "_" file_variable ${relpath})
-    set_cache_var(TARGET_${file_variable} ${TARGET})
-  endforeach()
-
-  message(STATUS "Building Slice target ${TARGET} as a library")
-  set(suffixes cpp h)
-  include_directories("${CMAKE_CURRENT_BINARY_DIR}")
-
-  if(NOT SLICE_COMPILER)
-    # Find the actual Slice compiler
-    find_program(SLICE_COMPILER slice2cpp PATHS "${ICE_DIR}/bin" NO_DEFAULT_PATH)
-
-    # If we fail to find it we have to abort here, we can go no further
-    if(SLICE_COMPILER)
-      message(STATUS "Found Slice compiler at ${SLICE_COMPILER}")
-    else()
-      message(FATAL_ERROR "Failed to find Slice compiler")
-    endif()
-  endif()
-
-  # Look for the dependencies for this slice definition, we have to do it now since the target was just added
-  message(STATUS "Determining dependencies for Slice target ${TARGET}")
-  execute_process(COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments}
-    --depend ${slice_files} OUTPUT_VARIABLE raw_dependencies
-    ERROR_VARIABLE slice_errors)
-  if(slice_errors)
-    message(FATAL_ERROR "Slice compiler produced errors:\n ${slice_errors}")
-  endif()
-
-  if(raw_dependencies)
-    # The next block of stuff sanitizes the output we got from the slice compiler into a non-Makefile specific foo
-    # Get rid of all the \ characters
-    string(REPLACE "\\" "" raw_dependencies "${raw_dependencies}")
-    # Turn the newlines into CMake list item separators, since the compiler spits out one dependency per line
-    string(REPLACE "\n" ";" raw_dependencies "${raw_dependencies}")
-    string(REPLACE " ;" ";" raw_dependencies "${raw_dependencies}")
-    string(REPLACE "; " ";" raw_dependencies "${raw_dependencies}")
-    
-    foreach(dep ${raw_dependencies})
-      # If the name ends with a colon, it's actually a Makefile target name and should be
-      # skipped
-      if(NOT dep MATCHES ":$")
-        # Convert the path into a cmake one so we can absolutely get the filename
-	file(TO_CMAKE_PATH ${dep} dep)
-	file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${dep}")
-	string(REPLACE "/" "_" file_variable "${relpath}")
-	set(dep_target ${TARGET_${file_variable}})
-	if(dep_target)
-	  # If this is not already us add it as a dependency
-	  if(NOT dep_target STREQUAL ${TARGET})
-	    message(STATUS "Auto-adding dependency on Slice target ${dep_target} to ${TARGET}")
-	    list(APPEND source_dependencies ${dep})
-	    list(APPEND target_dependencies ${dep_target})
-	    list(APPEND target_includes ${ASTERISK_SCF_SLICE_${dep_target}_INCLUDE_DIRS})
-	  endif()
-	else()
-	  # Remember sources that are not associated with targets too
-	  message(STATUS "Auto-adding dependency on Slice source ${dep} to ${TARGET}")
-	  list(APPEND source_dependencies ${dep})
-	endif()
-      endif()
+    list(REMOVE_DUPLICATES slice_compiler_arguments)
+
+    foreach(file ${slice_files})
+        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${file}")
+        string(REPLACE "/" "_" file_variable ${relpath})
+        set_cache_var(TARGET_${file_variable} ${TARGET})
+    endforeach()
+
+    message(STATUS "Building Slice target ${TARGET} as a library")
+    set(suffixes cpp h)
+    include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+
+    if(NOT SLICE_COMPILER)
+        # Find the actual Slice compiler
+        find_program(SLICE_COMPILER slice2cpp PATHS "${ICE_DIR}/bin" NO_DEFAULT_PATH)
+
+        # If we fail to find it we have to abort here, we can go no further
+        if(SLICE_COMPILER)
+            message(STATUS "Found Slice compiler at ${SLICE_COMPILER}")
+        else()
+            message(FATAL_ERROR "Failed to find Slice compiler")
+        endif()
+    endif()
+
+    # Look for the dependencies for this slice definition, we have to do it now since the target was just added
+    message(STATUS "Determining dependencies for Slice target ${TARGET}")
+    execute_process(COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments}
+        --depend ${slice_files} OUTPUT_VARIABLE raw_dependencies
+        ERROR_VARIABLE slice_errors)
+    if(slice_errors)
+        message(FATAL_ERROR "Slice compiler produced errors:\n ${slice_errors}")
+    endif()
+
+    if(raw_dependencies)
+        # The next block of stuff sanitizes the output we got from the slice compiler into a non-Makefile specific foo
+        # Get rid of all the \ characters
+        string(REPLACE "\\" "" raw_dependencies "${raw_dependencies}")
+        # Turn the newlines into CMake list item separators, since the compiler spits out one dependency per line
+        string(REPLACE "\n" ";" raw_dependencies "${raw_dependencies}")
+        string(REPLACE " ;" ";" raw_dependencies "${raw_dependencies}")
+        string(REPLACE "; " ";" raw_dependencies "${raw_dependencies}")
+
+        foreach(dep ${raw_dependencies})
+            # If the name ends with a colon, it's actually a Makefile target name and should be
+            # skipped
+            if(NOT dep MATCHES ":$")
+                # Convert the path into a cmake one so we can absolutely get the filename
+	        file(TO_CMAKE_PATH ${dep} dep)
+	        file(RELATIVE_PATH relpath "${CMAKE_SOURCE_DIR}" "${dep}")
+	        string(REPLACE "/" "_" file_variable "${relpath}")
+	        set(dep_target ${TARGET_${file_variable}})
+	        if(dep_target)
+	            # If this is not already us add it as a dependency
+	            if(NOT dep_target STREQUAL ${TARGET})
+	                message(STATUS "Auto-adding dependency on Slice target ${dep_target} to ${TARGET}")
+	                list(APPEND source_dependencies ${dep})
+	                list(APPEND target_dependencies ${dep_target})
+	                list(APPEND target_includes ${ASTERISK_SCF_SLICE_${dep_target}_INCLUDE_DIRS})
+	            endif()
+	        else()
+	            # Remember sources that are not associated with targets too
+	            message(STATUS "Auto-adding dependency on Slice source ${dep} to ${TARGET}")
+	            list(APPEND source_dependencies ${dep})
+	        endif()
+            endif()
+        endforeach()
+    endif()
+
+    foreach(file ${slice_files})
+        foreach(suffix ${suffixes})
+            get_filename_component(source "${file}" NAME_WE)
+            list(APPEND generated_files "${CMAKE_CURRENT_BINARY_DIR}/${source}.${suffix}")
+        endforeach()
     endforeach()
-  endif()
 
-  foreach(file ${slice_files})
-    foreach(suffix ${suffixes})
-      get_filename_component(source "${file}" NAME_WE)
-      list(APPEND generated_files "${CMAKE_CURRENT_BINARY_DIR}/${source}.${suffix}")
+    set_source_files_properties(${generated_files} PROPERTIES GENERATED 1)
+
+    # create a preprocessor definition in the generated CXX files that enables
+    # the generated classes to be exported from the library (only necessary on Windows)
+    # the definition for a target named 'FOO' will be 'FOO_EXPORTS', and if this
+    # preprocessor macro is defined, then the Slice-generated classes will be marked
+    # with 'dllexport'. add_library() (used below) automatically generates a definition
+    # for the appropriately-named macro when the library is built in SHARED mode.
+    if(WIN32)
+        list(APPEND slice_export_arguments "--dll-export" "${TARGET}")
+    endif()
+
+    add_custom_command(
+        OUTPUT ${generated_files}
+        COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments} ${slice_export_arguments} ${slice_files}
+        COMMENT "Building ${TARGET} from ${slice_files} using slice2cpp"
+        DEPENDS ${slice_files} ${source_dependencies}
+        )
+
+    if(target_includes)
+        list(REMOVE_DUPLICATES target_includes)
+    endif()
+
+    # Note that slice_files are included as sources here even though they won't be compiled
+    # by the actual compiler; this is to get them to show up as sources in the project
+    # created for this target
+    include_directories(${target_includes})
+    # If there are any non-generated header files required for this Slice target, copy
+    # them to the binary directory where they will be needed later. The destination
+    # path to file() defaults to the binary directory, so there is no need to
+    # re-specify it here.
+    if(cpp_header_files)
+        file(COPY ${cpp_header_files} DESTINATION .)
+    endif()
+    add_library(${TARGET} ${generated_files} ${slice_files} ${cpp_source_files})
+    install(TARGETS ${TARGET} DESTINATION ${DIR_IN} COMPONENT ${TARGET})
+    if(ASTERISKSCF_CPACK)
+        # Adds a component to the packager. The first arg must have been previously defined
+        # as a COMPONENT arg to install.
+        cpack_add_component(${TARGET} DESCRIPTION ${DESC_IN} GROUP ${GROUP_IN})
+    endif()
+    foreach(lib ${${TARGET}_ICE_LIBRARIES} ${ASTERISK_SCF_ICE_LIBRARIES})
+        if(UNIX)
+            list(APPEND target_libs "${lib}")
+        else()
+            list(APPEND target_libs "${ICE_LIB_${lib}}")
+        endif()
     endforeach()
-  endforeach()
-
-  set_source_files_properties(${generated_files} PROPERTIES GENERATED 1)
-
-  # create a preprocessor definition in the generated CXX files that enables
-  # the generated classes to be exported from the library (only necessary on Windows)
-  # the definition for a target named 'FOO' will be 'FOO_EXPORTS', and if this
-  # preprocessor macro is defined, then the Slice-generated classes will be marked
-  # with 'dllexport'. add_library() (used below) automatically generates a definition
-  # for the appropriately-named macro when the library is built in SHARED mode.
-  if(WIN32)
-    list(APPEND slice_export_arguments "--dll-export" "${TARGET}")
-  endif()
-
-  add_custom_command(
-    OUTPUT ${generated_files}
-    COMMAND ${SLICE_COMPILER} ${slice_compiler_arguments} ${slice_export_arguments} ${slice_files}
-    COMMENT "Building ${TARGET} from ${slice_files} using slice2cpp"
-    DEPENDS ${slice_files} ${source_dependencies}
-    )
-
-  if(target_includes)
-    list(REMOVE_DUPLICATES target_includes)
-  endif()
-
-  # Note that slice_files are included as sources here even though they won't be compiled
-  # by the actual compiler; this is to get them to show up as sources in the project
-  # created for this target
-  include_directories(${target_includes})
-  # If there are any non-generated header files required for this Slice target, copy
-  # them to the binary directory where they will be needed later. The destination
-  # path to file() defaults to the binary directory, so there is no need to
-  # re-specify it here.
-  if(cpp_header_files)
-    file(COPY ${cpp_header_files} DESTINATION .)
-  endif()
-  add_library(${TARGET} ${generated_files} ${slice_files} ${cpp_source_files})
-  install(TARGETS ${TARGET} DESTINATION ${DIR_IN} COMPONENT ${TARGET})
-  if(ASTERISKSCF_CPACK)
-    # Adds a component to the packager. The first arg must have been previously defined
-    # as a COMPONENT arg to install.
-    cpack_add_component(${TARGET} DESCRIPTION ${DESC_IN} GROUP ${GROUP_IN})
-  endif()
-  foreach(lib ${${TARGET}_ICE_LIBRARIES} ${ASTERISK_SCF_ICE_LIBRARIES})
+    if(target_libs)
+        target_link_libraries(${TARGET} ${target_libs})
+    endif()
+    if(APPLE)
+        target_link_libraries(${TARGET} ${ICE_LIB_IceUtil})
+        target_link_libraries(${TARGET} ${ICE_LIB_ZeroCIce})
+    endif()
+    if(target_dependencies)
+        message(STATUS "Linking ${TARGET} to ${target_dependencies}")
+        target_link_libraries(${TARGET} ${target_dependencies})
+        add_dependencies(${TARGET} ${target_dependencies})
+    endif()
     if(UNIX)
-      list(APPEND target_libs "${lib}")
-    else()
-      list(APPEND target_libs "${ICE_LIB_${lib}}")
-    endif()
-  endforeach()
-  if(target_libs)
-    target_link_libraries(${TARGET} ${target_libs})
-  endif()
-  if(APPLE)
-    target_link_libraries(${TARGET} ${ICE_LIB_IceUtil})
-    target_link_libraries(${TARGET} ${ICE_LIB_ZeroCIce})
-  endif()
-  if(target_dependencies)
-    message(STATUS "Linking ${TARGET} to ${target_dependencies}")
-    target_link_libraries(${TARGET} ${target_dependencies})
-    add_dependencies(${TARGET} ${target_dependencies})
-  endif()
-  if(UNIX)
-    set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "-fPIC")
-  endif()
-  set_cache_var(ASTERISK_SCF_SLICE_${TARGET}_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} ${target_includes})
-  set_cache_var(ASTERISK_SCF_SLICE_${TARGET} Bob)
+        set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "-fPIC")
+    endif()
+    set_cache_var(ASTERISK_SCF_SLICE_${TARGET}_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} ${target_includes})
+    set_cache_var(ASTERISK_SCF_SLICE_${TARGET} Bob)
 endfunction()
 
 # Function which initializes a component for building
 function(asterisk_scf_component_init COMPONENT)
-  message(STATUS "Setting up to build component ${COMPONENT}")
-  set(ASTERISK_SCF_${COMPONENT} Bob PARENT_SCOPE)
+    message(STATUS "Setting up to build component ${COMPONENT}")
+    set(ASTERISK_SCF_${COMPONENT} Bob PARENT_SCOPE)
 endfunction()
 
 # Function which adds the compiled Slice targets to a component to be built
 function(asterisk_scf_component_add_slice COMPONENT)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one Slice target to this function")
-  endif()
-  if(NOT ASTERISK_SCF_${COMPONENT})
-    message(FATAL_ERROR "Must call asterisk_scf_component_init for component ${COMPONENT} before asterisk_scf_component_add_slice")
-  endif()
-  set(slice_list ${${COMPONENT}_SLICES})
-  foreach(slice ${ARGN})
-    get_filename_component(f ${slice} NAME_WE)
-    if(NOT ASTERISK_SCF_SLICE_${f})
-      message(FATAL_ERROR "Must call asterisk_scf_compile_slice for ${f} before asterisk_scf_component_add_slice")
-    endif()
-    message(STATUS "Adding Slice ${f} to component ${COMPONENT}")
-    list(APPEND slice_list ${f})
-    list(APPEND include_dirs ${ASTERISK_SCF_SLICE_${slice}_INCLUDE_DIRS})
-  endforeach()
-  list(REMOVE_DUPLICATES slice_list)
-  set(${COMPONENT}_SLICES ${slice_list} PARENT_SCOPE)
-  if(include_dirs)
-    list(REMOVE_DUPLICATES include_dirs)
-    include_directories(${include_dirs})
-  endif()
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one Slice target to this function")
+    endif()
+    if(NOT ASTERISK_SCF_${COMPONENT})
+        message(FATAL_ERROR "Must call asterisk_scf_component_init for component ${COMPONENT} before asterisk_scf_component_add_slice")
+    endif()
+    set(slice_list ${${COMPONENT}_SLICES})
+    foreach(slice ${ARGN})
+        get_filename_component(f ${slice} NAME_WE)
+        if(NOT ASTERISK_SCF_SLICE_${f})
+            message(FATAL_ERROR "Must call asterisk_scf_compile_slice for ${f} before asterisk_scf_component_add_slice")
+        endif()
+        message(STATUS "Adding Slice ${f} to component ${COMPONENT}")
+        list(APPEND slice_list ${f})
+        list(APPEND include_dirs ${ASTERISK_SCF_SLICE_${slice}_INCLUDE_DIRS})
+    endforeach()
+    list(REMOVE_DUPLICATES slice_list)
+    set(${COMPONENT}_SLICES ${slice_list} PARENT_SCOPE)
+    if(include_dirs)
+        list(REMOVE_DUPLICATES include_dirs)
+        include_directories(${include_dirs})
+    endif()
 endfunction()
 
 # Function which adds source or header files to a component to be built
 function(asterisk_scf_component_add_file COMPONENT)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one source file to this function")
-  endif()
-  message(STATUS "Adding ${ARGN} to component ${COMPONENT}")
-  set(file_list ${${COMPONENT}_SOURCES})
-  foreach(file ${ARGN})
-    list(APPEND file_list ${CMAKE_CURRENT_SOURCE_DIR}/${file})
-  endforeach()
-  list(REMOVE_DUPLICATES file_list)
-  set(${COMPONENT}_SOURCES ${file_list} PARENT_SCOPE)
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one source file to this function")
+    endif()
+    message(STATUS "Adding ${ARGN} to component ${COMPONENT}")
+    set(file_list ${${COMPONENT}_SOURCES})
+    foreach(file ${ARGN})
+        list(APPEND file_list ${CMAKE_CURRENT_SOURCE_DIR}/${file})
+    endforeach()
+    list(REMOVE_DUPLICATES file_list)
+    set(${COMPONENT}_SOURCES ${file_list} PARENT_SCOPE)
 endfunction()
 
 # Function which adds Ice libraries needed by a component
 function(asterisk_scf_component_add_ice_libraries COMPONENT)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one library to this function")
-  endif()
-  set(libs ${${COMPONENT}_ICE_LIBRARIES})
-  foreach(lib ${ARGN})
-    find_ICE_library(${lib})
-    list(APPEND libs ${lib})
-  endforeach()
-  list(REMOVE_DUPLICATES libs)
-  set(${COMPONENT}_ICE_LIBRARIES ${libs} PARENT_SCOPE)
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one library to this function")
+    endif()
+    set(libs ${${COMPONENT}_ICE_LIBRARIES})
+    foreach(lib ${ARGN})
+        find_ICE_library(${lib})
+        list(APPEND libs ${lib})
+    endforeach()
+    list(REMOVE_DUPLICATES libs)
+    set(${COMPONENT}_ICE_LIBRARIES ${libs} PARENT_SCOPE)
 endfunction()
 
 # Function which adds Boost libraries needed by a component
 function(asterisk_scf_component_add_boost_libraries COMPONENT)
-  if(NOT ARGN)
-    message(FATAL_ERROR "You must pass at least one library to this function")
-  endif()
-  set(libs ${${COMPONENT}_BOOST_LIBRARIES})
-  # By default we are disabling boost auto-linking and specifying dynamic linking. 
-  add_definitions(-DBOOST_ALL_NO_LIB -DBOOST_ALL_DYN_LINK)  
-  foreach(lib ${ARGN})
-    find_Boost_library(${lib})
-    list(APPEND libs ${lib})
-  endforeach()
-  list(REMOVE_DUPLICATES libs)
-  set(${COMPONENT}_BOOST_LIBRARIES ${libs} PARENT_SCOPE)
-  include_directories(${Boost_INCLUDE_DIR})
-  link_directories(${Boost_LIBRARY_DIRS})
+    if(NOT ARGN)
+        message(FATAL_ERROR "You must pass at least one library to this function")
+    endif()
+    set(libs ${${COMPONENT}_BOOST_LIBRARIES})
+    # By default we are disabling boost auto-linking and specifying dynamic linking.
+    add_definitions(-DBOOST_ALL_NO_LIB -DBOOST_ALL_DYN_LINK)
+    foreach(lib ${ARGN})
+        find_Boost_library(${lib})
+        list(APPEND libs ${lib})
+    endforeach()
+    list(REMOVE_DUPLICATES libs)
+    set(${COMPONENT}_BOOST_LIBRARIES ${libs} PARENT_SCOPE)
+    include_directories(${Boost_INCLUDE_DIR})
+    link_directories(${Boost_LIBRARY_DIRS})
 endfunction()
 
 # Function which builds a component as an IceBox service
 function(asterisk_scf_component_build_icebox COMPONENT)
-  message(STATUS "Building component ${COMPONENT} as an IceBox service")
-  find_ICE_library(IceBox)
-  list(APPEND icelibs IceBox ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
-  list(REMOVE_DUPLICATES icelibs)
-  foreach(lib ${icelibs})
-    if(UNIX)
-      list(APPEND target_libs "${lib}")
-    else()
-      list(APPEND target_libs "${ICE_LIB_${lib}}")
-    endif()
-  endforeach()
-
-  # Now we actually create the library
-  # while one would think that MODULE would be the right setting, it
-  # has to be shared due to how icebox finds these libraries on a Mac
-  # (it loads .dylib instead of loading .so)
-  add_library(${COMPONENT} SHARED ${${COMPONENT}_SOURCES})
-  # Link required libraries and Slice libraries
-  list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
-  if(boostlibs)
-    list(REMOVE_DUPLICATES boostlibs)
-    foreach(lib ${boostlibs})
-      string(TOUPPER ${lib} libtag)
-      list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+    message(STATUS "Building component ${COMPONENT} as an IceBox service")
+    find_ICE_library(IceBox)
+    list(APPEND icelibs IceBox ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
+    list(REMOVE_DUPLICATES icelibs)
+    foreach(lib ${icelibs})
+        if(UNIX)
+            list(APPEND target_libs "${lib}")
+        else()
+            list(APPEND target_libs "${ICE_LIB_${lib}}")
+        endif()
     endforeach()
-  endif()
-  if(UNIX)
-    list(FIND target_libs Ice _Ice_FOUND)
-    if(_Ice_FOUND GREATER -1)
-      list(APPEND target_libs "IceUtil")
-      list(APPEND target_libs "pthread")
-    endif()
-  endif()
-  target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
+
+    # Now we actually create the library
+    # while one would think that MODULE would be the right setting, it
+    # has to be shared due to how icebox finds these libraries on a Mac
+    # (it loads .dylib instead of loading .so)
+    add_library(${COMPONENT} SHARED ${${COMPONENT}_SOURCES})
+    # Link required libraries and Slice libraries
+    list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
+    if(boostlibs)
+        list(REMOVE_DUPLICATES boostlibs)
+        foreach(lib ${boostlibs})
+            string(TOUPPER ${lib} libtag)
+            list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+        endforeach()
+    endif()
+    if(UNIX)
+        list(FIND target_libs Ice _Ice_FOUND)
+        if(_Ice_FOUND GREATER -1)
+            list(APPEND target_libs "IceUtil")
+            list(APPEND target_libs "pthread")
+        endif()
+    endif()
+    target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
 endfunction()
 
 # Function which builds a component standalone
 function(asterisk_scf_component_build_standalone COMPONENT)
-  message(STATUS "Building component ${COMPONENT} as a standalone executable")
-  list(APPEND icelibs ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
-  list(REMOVE_DUPLICATES icelibs)
-  foreach(lib ${icelibs})
-    if(UNIX)
-      list(APPEND target_libs "${lib}")
-    else()
-      list(APPEND target_libs "${ICE_LIB_${lib}}")
-    endif()
-  endforeach()
-
-  # Now we actually create the component
-  add_executable(${COMPONENT} ${${COMPONENT}_SOURCES})
-  # Link required libraries and Slice libraries
-  list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
-  if(boostlibs)
-    list(REMOVE_DUPLICATES boostlibs)
-    foreach(lib ${boostlibs})
-      string(TOUPPER ${lib} libtag)
-      list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+    message(STATUS "Building component ${COMPONENT} as a standalone executable")
+    list(APPEND icelibs ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
+    list(REMOVE_DUPLICATES icelibs)
+    foreach(lib ${icelibs})
+        if(UNIX)
+            list(APPEND target_libs "${lib}")
+        else()
+            list(APPEND target_libs "${ICE_LIB_${lib}}")
+        endif()
     endforeach()
-  endif()
-  if(UNIX)
-    list(FIND target_libs Ice _Ice_FOUND)
-    if(_Ice_FOUND GREATER -1)
-      list(APPEND target_libs "IceUtil")
-      list(APPEND target_libs "pthread")
-    endif()
-  endif()
-  target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
+
+    # Now we actually create the component
+    add_executable(${COMPONENT} ${${COMPONENT}_SOURCES})
+    # Link required libraries and Slice libraries
+    list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
+    if(boostlibs)
+        list(REMOVE_DUPLICATES boostlibs)
+        foreach(lib ${boostlibs})
+            string(TOUPPER ${lib} libtag)
+            list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+        endforeach()
+    endif()
+    if(UNIX)
+        list(FIND target_libs Ice _Ice_FOUND)
+        if(_Ice_FOUND GREATER -1)
+            list(APPEND target_libs "IceUtil")
+            list(APPEND target_libs "pthread")
+        endif()
+    endif()
+    target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
 endfunction()
 
 function(asterisk_scf_component_build_library COMPONENT)
-  message(STATUS "Building component ${COMPONENT} as a library")
-  list(APPEND icelibs ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
-  list(LENGTH icelibs numicelibs)
-  if(numicelibs GREATER 0)
-    list(REMOVE_DUPLICATES icelibs)
-  endif()
-  foreach(lib ${icelibs})
-    if(UNIX)
-      list(APPEND target_libs "${lib}")
-    else()
-      list(APPEND target_libs "${ICE_LIB_${lib}}")
-    endif()
-  endforeach()
-
-  # Now we actually create the component
-  add_library(${COMPONENT} ${${COMPONENT}_SOURCES})
-  # Link required libraries and Slice libraries
-  list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
-  if(boostlibs)
-    list(REMOVE_DUPLICATES boostlibs)
-    foreach(lib ${boostlibs})
-      string(TOUPPER ${lib} libtag)
-      list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+    message(STATUS "Building component ${COMPONENT} as a library")
+    list(APPEND icelibs ${ASTERISK_SCF_ICE_LIBRARIES} ${${COMPONENT}_ICE_LIBRARIES})
+    list(LENGTH icelibs numicelibs)
+    if(numicelibs GREATER 0)
+        list(REMOVE_DUPLICATES icelibs)
+    endif()
+    foreach(lib ${icelibs})
+        if(UNIX)
+            list(APPEND target_libs "${lib}")
+        else()
+            list(APPEND target_libs "${ICE_LIB_${lib}}")
+        endif()
     endforeach()
-  endif()
-  target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
+
+    # Now we actually create the component
+    add_library(${COMPONENT} ${${COMPONENT}_SOURCES})
+    # Link required libraries and Slice libraries
+    list(APPEND boostlibs ${ASTERISK_SCF_BOOST_LIBRARIES} ${${COMPONENT}_BOOST_LIBRARIES})
+    if(boostlibs)
+        list(REMOVE_DUPLICATES boostlibs)
+        foreach(lib ${boostlibs})
+            string(TOUPPER ${lib} libtag)
+            list(APPEND target_libs "${Boost_${libtag}_LIBRARY}")
+        endforeach()
+    endif()
+    target_link_libraries(${COMPONENT} ${${COMPONENT}_SLICES} ${target_libs})
 endfunction()
 
 # Function which adds information for installing a component
 function(asterisk_scf_component_install COMPONENTNAME TYPE DIR DESC GROUP)
-  install(TARGETS ${COMPONENTNAME} ${TYPE} DESTINATION ${DIR} COMPONENT ${COMPONENTNAME} ${ARGN})
+    install(TARGETS ${COMPONENTNAME} ${TYPE} DESTINATION ${DIR} COMPONENT ${COMPONENTNAME} ${ARGN})
 
-  if(ASTERISKSCF_CPACK)
-    asterisk_scf_component_package(${COMPONENTNAME} ${DESC} ${GROUP})
-  endif()
+    if(ASTERISKSCF_CPACK)
+        asterisk_scf_component_package(${COMPONENTNAME} ${DESC} ${GROUP})
+    endif()
 endfunction()
 
 # Adds a component to the packager. COMPONENTNAME must have been previously defined
 # via the install command.
 function(asterisk_scf_component_package COMPONENTNAME DESC GROUPNAME)
-  cpack_add_component(${COMPONENTNAME} DESCRIPTION ${DESC} GROUP ${GROUP})
+    cpack_add_component(${COMPONENTNAME} DESCRIPTION ${DESC} GROUP ${GROUP})
 endfunction()
 
 # Adds a boost test executable to CTest.  These executable will be run
 # with 'make test' @param EXE - boost test executable.  Probably built
 # using asterisk_scf_component_build_standalone.
 function(boost_add_test EXE)
-  add_test(NAME ${EXE} COMMAND ${EXE}
-    --report_sink=${CMAKE_BINARY_DIR}/${EXE}-result.xml
-    --report_format=XML --report_level=detailed)
+    add_test(NAME ${EXE} COMMAND ${EXE}
+        --report_sink=${CMAKE_BINARY_DIR}/${EXE}-result.xml
+        --report_format=XML --report_level=detailed)
 endfunction()
 
 function(icebox_add_test NAME CONFIG)
-  add_test(NAME ${NAME} COMMAND ${ICEBOX} --Ice.Config=${CONFIG})
+    add_test(NAME ${NAME} COMMAND ${ICEBOX} --Ice.Config=${CONFIG})
 endfunction()

-----------------------------------------------------------------------


-- 
asterisk-scf/integration/cmake.git



More information about the asterisk-scf-commits mailing list