LINK_DIRECTORIES(${LIBRARY_OUTPUT_PATH})


#############################
##### MAQAO: Added code #####
#############################

if (use_zlib)
  message(STATUS "Compiling libdwarf with support of sections compressed with libz")
  add_definitions(-DHAVE_ZLIB=1)
  add_definitions(-DHAVE_ZLIB_H=1)
else()
  message(WARNING "Compiling libdwarf without support of sections compressed with libz")
endif()

if (use_zstd)
  message(STATUS "Compiling libdwarf with support of sections compressed with libzstd")
  add_definitions(-DHAVE_ZSTD=1)
  add_definitions(-DHAVE_ZSTD_H=1)
else()
  message(WARNING "Compiling libdwarf without support of sections compressed with libzstd")
endif()

####################################
##### MAQAO: End of added code #####
####################################



#####################################################################################################
#### The following code was imported from the CMakeLists.txt at the root of the libdwarf package ####
#####################################################################################################
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include_directories( ${CMAKE_BINARY_DIR} )

# used to compile on MSVC upto 2013 where snprintf is not available
macro(msvc_posix target)
    if(MSVC AND ("${MSVC_VERSION}" LESS 1900))
        # under VS 2015
	target_compile_definitions(${target} PUBLIC
	    snprintf=_snprintf)
    endif()
endmacro()

set(LIBDWARF_CRT "MD" CACHE STRING "Either MT or MD, specifies whether to use the static or dynamic MSVCRT.")

if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
  # Use CMAKE_MSVC_RUNTIME in versions 3.15 and up
  if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.15")
    cmake_policy(SET CMP0091 NEW)
    if (LIBDWARF_CRT STREQUAL "MT")
      message(STATUS "Using MT runtime by CMAKE_MSVC_RUNTIME_LIBRARY")
      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
    elseif(LIBDWARF_CRT STREQUAL "MD")
      message(STATUS "Using MD runtime by CMAKE_MSVC_RUNTIME_LIBRARY")
      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
    else()
      message(FATAL_ERROR "LIBDWARF_CRT must be MT or MD")
    endif()
  # Use regexes in versions before 3.15
  else()
    if (LIBDWARF_CRT STREQUAL "MT")
      message(STATUS "Using MT runtime by compile flag replacement")
      # taken from the CMake FAQ
      foreach(flag_v
      CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG
      CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL
      CMAKE_C_FLAGS_RELWITHDEBINFO
      CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG
      CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL
      CMAKE_CXX_FLAGS_RELWITHDEBINFO)
        if (${flag_v} MATCHES "([\\/\\-]M)D")
          string(REGEX REPLACE "([\\/\\-]M)D" "\\1T"
          ${flag_v} "${${flag_v}}")
        endif()
      endforeach()
    elseif(LIBDWARF_CRT STREQUAL "MD")
      message(STATUS "Using MD runtime by cmake default")
    else()
      message(FATAL_ERROR "LIBDWARF_CRT must be MT or MD")
    endif()
  endif()
endif()

# message("CMake flags are:")
# message("  CMAKE_C_FLAGS: ${CMAKE_C_FLAGS}")
# message("  CMAKE_C_FLAGS_DEBUG: ${CMAKE_C_FLAGS_DEBUG}")
# message("  CMAKE_C_FLAGS_RELEASE: ${CMAKE_C_FLAGS_RELEASE}")
# message("  CMAKE_C_FLAGS_MINSIZEREL: ${CMAKE_C_FLAGS_MINSIZEREL}")
# message("  CMAKE_C_FLAGS_RELWITHDEBINFO: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
# message("  CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
# message("  CMAKE_CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
# message("  CMAKE_CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}")
# message("  CMAKE_CXX_FLAGS_MINSIZEREL: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
# message("  CMAKE_CXX_FLAGS_RELWITHDEBINFO: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")


# set target folder on IDE
macro(set_folder target folder)
  set_target_properties(${target} PROPERTIES FOLDER ${folder})
endmacro()

# set source groups on IDE
macro(set_source_group list_name group_name)
    set(${list_name} ${ARGN})
    source_group(${group_name} FILES ${ARGN})
endmacro()

# view folders on supported IDEs
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

# tells cmake to look in 64bit first (cmake
# would probably do this anyway).
set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)

enable_testing()

# always include project's folder to includes
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE ON)

### begin what was configure.cmake
# cmake macros
include(TestBigEndian)
include(CheckIncludeFile)
include(CheckCSourceCompiles)
include(CheckCSourceRuns)
include(CheckSymbolExists)
### Version also appears in configure.ac
set(PACKAGE_BUGREPORT "https://github.com/davea42/libdwarf-code/issues")
set(PACKAGE_STRING "${PROJECT_NAME} ${PROJECT_VERSION}")
string(REGEX REPLACE "[\"]" "" tarname1 "${PACKAGE_STRING}" )
string(REGEX REPLACE "[^a-zA-Z0-9_]" "-" tarname "${tarname1}" )
set(PACKAGE_TARNAME "\"${tarname}\"" )

test_big_endian(isBigEndian)
if (${isBigEndian})
  set ( WORDS_BIGENDIAN 1 )
endif()

check_include_file( "sys/types.h"     HAVE_SYS_TYPES_H)
check_include_file( "sys/stat.h"      HAVE_SYS_STAT_H )
check_include_file( "stdint.h"        HAVE_STDINT_H   )
check_include_file( "unistd.h"        HAVE_UNISTD_H   )
check_include_file( "stdafx.h"        HAVE_STDAFX_H   )
check_include_file( "fcntl.h"         HAVE_FCNTL_H   )

### cmake provides no way to guarantee uint32_t present.
### configure does guarantee that.
if(HAVE_STDINT_H)
  check_c_source_compiles("
  #include <stdint.h>
  int main()
  {
      uintptr_t i; i = 12;
      return (int)i;
  }" HAVE_UINTPTR_T)
  check_c_source_compiles("
  #include <stdint.h>
  int main()
  {
      intptr_t i; i = 12;
      return (int)i;
  }" HAVE_INTPTR_T)
endif()
if (HAVE_UINTPTR_T)
  message(STATUS "HAVE_UINTPTR_T 1: uintptr_t defined in stdint.h... YES")
else()
  message(STATUS "uintptr_t defined in stdint.h... NO")
  set(uintptr_t "unsigned long long int" )
  message(STATUS "Setting #define uintptr_t " ${uintptr_t})
endif()
if (uintptr_t)
  message(STATUS "uintptr_t value considered YES ")
else()
  message(STATUS "uintptr_t value considered NO ")
endif()
if (HAVE_INTPTR_T)
  message(STATUS "HAVE_INTPTR_T 1: intptr_t defined in stdint.h... YES")
else()
  message(STATUS "intptr_t defined in stdint.h... NO")
  set(intptr_t "long long int" )
  message(STATUS "Setting #define intptr_t " ${intptr_t})
endif()
if (intptr_t)
  message(STATUS "intptr_t value considered YES ")
else()
  message(STATUS "intptr_t value considered NO ")
endif()

configure_file(cmake/config.h.in config.h)

##########################################################################################
#### End of code imported from the CMakeLists.txt at the root of the libdwarf package ####
##########################################################################################

# Creating list expected by the code imported from libdwarf CMakeLists.txt 
set(DWARF_TARGETS dwarf-obj-static)
set(DWARF_TYPES OBJECT)
set(DWARF_COMPILE_FLAGS "${C_STATIC_FLAGS}")
IF (is_WINDOWS)
	list(APPEND DWARF_TARGETS dwarf-obj-dyn)
	list(APPEND DWARF_TYPES OBJECT)
	list(APPEND DWARF_COMPILE_FLAGS "${C_DYNAMIC_FLAGS}")
ENDIF(is_WINDOWS)

################################################################################################################################
#### The following code was imported from the CMakeLists.txt in the src/lib/libdwarf subdirectory from the libdwarf package ####
################################################################################################################################


set_source_group(SOURCES "Source Files" dwarf_abbrev.c
dwarf_alloc.c dwarf_crc.c dwarf_crc32.c dwarf_arange.c
dwarf_debug_sup.c
dwarf_debugaddr.c
dwarf_debuglink.c dwarf_die_deliv.c
dwarf_debugnames.c dwarf_dsc.c
dwarf_elf_load_headers.c
dwarf_elfread.c
dwarf_elf_rel_detector.c
dwarf_error.c
dwarf_fill_in_attr_form.c
dwarf_find_sigref.c dwarf_fission_to_cu.c
dwarf_form.c dwarf_form_class_names.c
dwarf_frame.c dwarf_frame2.c dwarf_frame_iter.c
dwarf_frame_cfa_read.c
dwarf_gdbindex.c dwarf_global.c
dwarf_gnu_index.c dwarf_groups.c
dwarf_harmless.c dwarf_generic_init.c dwarf_init_finish.c
dwarf_leb.c
dwarf_line.c dwarf_loc.c
dwarf_loclists.c
dwarf_locationop_read.c
dwarf_local_malloc.c
dwarf_lname_version.c
dwarf_lvn_name.c
dwarf_machoread.c dwarf_64machoread.c dwarf_macro.c dwarf_macro5.c
dwarf_memcpy_swap.c
dwarf_names.c
dwarf_object_read_common.c dwarf_object_detector.c
dwarf_peread.c
dwarf_query.c dwarf_ranges.c
dwarf_rnglists.c
dwarf_safe_arithmetic.c
dwarf_safe_strcpy.c
dwarf_secname_ck.c
dwarf_seekr.c
dwarf_setup_sections.c
dwarf_string.h dwarf_string.c
dwarf_stringsection.c
dwarf_tied.c
dwarf_str_offsets.c
dwarf_tsearchhash.c dwarf_util.c
dwarf_xu_index.c
dwarf_print_lines.c )

set_source_group(HEADERS "Header Files" dwarf.h dwarf_abbrev.h
dwarf_alloc.h dwarf_arange.h dwarf_base_types.h
dwarf_debugaddr.h
dwarf_debuglink.h dwarf_die_deliv.h
dwarf_debugnames.h dwarf_dsc.h
dwarf_elf_access.h dwarf_elf_defines.h dwarf_elfread.h
dwarf_elf_rel_detector.h
dwarf_elfstructs.h
dwarf_error.h dwarf_frame.h
dwarf_gdbindex.h dwarf_global.h dwarf_harmless.h
dwarf_gnu_index.h
dwarf_line.h dwarf_loc.h dwarf_loclists.h
dwarf_local_malloc.h
dwarf_machoread.h dwarf_macro.h dwarf_macro5.h
dwarf_object_detector.h dwarf_opaque.h
dwarf_pe_descr.h dwarf_peread.h
dwarf_reading.h
dwarf_rnglists.h
dwarf_safe_arithmetic.h
dwarf_safe_strcpy.h
dwarf_tied_decls.h
dwarf_tsearch.h
dwarf_setup_sections.h
dwarf_str_offsets.h
dwarf_universal.h
dwarf_util.h
dwarf_xu_index.h libdwarf_private.h
dwarf_macho_loader.h
dwarf_memcpy_swap.h)

set_source_group(CONFIGURATION_FILES "Configuration Files"
    #${CMAKE_CURRENT_SOURCE_DIR}/cmake/config.h.in
    config.h)

MESSAGE (${CONFIGURATION_FILES})

list(LENGTH DWARF_TARGETS targetCount)
math(EXPR targetCount "${targetCount} - 1")
list(APPEND DWARF_LIBS ${LIBELF_LIBRARIES})
if(UNIX)
    list(APPEND DWARF_LIBS z)
endif()
foreach(i RANGE ${targetCount})
	list(GET DWARF_TARGETS ${i} target)
	list(GET DWARF_TYPES ${i} type)
	add_library(${target} ${type} ${SOURCES} ${HEADERS}
            ${GENNAMES_OUTPUT} ${CONFIGURATION_FILES})

	set_folder(${target} src/lib/libdwarf)
	target_include_directories(${target} PUBLIC 
            ${LIBELF_INCLUDE_DIRS})
        target_compile_options(${target} PRIVATE ${DW_FWALL})
	msvc_posix(${target})
endforeach()

# The -DPIC is so we find the right DW_API value in libdwarf.h
# with cmake with Linux.
# Dwarfgen requires all symbols in .so to be visible, so
# do not say hidden on libdwarf in that case.
if (BUILD_SHARED)
    if(NOT BUILD_DWARFGEN)
      set(CMAKE_C_VISIBILITY_PRESET hidden)
    endif()
    set(DEFS LIBDWARF_BUILD PIC)
else()
    set(DEFS LIBDWARF_STATIC)
endif()

if (PIC_ALWAYS)
  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
  list(APPEND DEFS PIC)
endif()

if(BUILD_SHARED)
    add_library(dwarf SHARED ${SOURCES} ${HEADERS} ${CONFIGURATION_FILES})
    add_library(libdwarf::dwarf-shared ALIAS dwarf)
else()
    add_library(dwarf STATIC ${SOURCES} ${HEADERS} ${CONFIGURATION_FILES})
    add_library(libdwarf::dwarf-static ALIAS dwarf)
endif()
set_folder(dwarf src/lib/libdwarf)
target_compile_options(dwarf PRIVATE ${COMPILER_FLAGS} ${DW_FWALL}
    -D_GNU_SOURCE)
msvc_posix(dwarf)
target_compile_definitions(dwarf PUBLIC ${DEFS})
target_include_directories(dwarf PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
#if(ZLIB_FOUND AND zstd_FOUND)
#  target_link_libraries(dwarf PRIVATE  ZLIB::ZLIB ${ZSTD_LIB} )
#endif()

# MAQAO: using use_zlib/LIBZ_PATH and use_zstd/LIBZSTD_PATH
if(use_zlib)
   if(BUILD_SHARED)
      target_link_libraries(dwarf PRIVATE ${LIBZ_DYN_PATH})
   else()
      target_link_libraries(dwarf PRIVATE ${LIBZ_STATIC_PATH})
   endif()
endif()
if(use_zstd)
   if(BUILD_SHARED)
      target_link_libraries(dwarf PRIVATE ${LIBZSTD_DYN_PATH})
   else()
      target_link_libraries(dwarf PRIVATE ${LIBZSTD_STATIC_PATH})
   endif()
endif()

#set_target_properties(dwarf PROPERTIES PUBLIC_HEADER "libdwarf.h;dwarf.h")
#set_target_properties(dwarf PROPERTIES VERSION "${PROJECT_VERSION}" SOVERSION "${PROJECT_VERSION_MAJOR}")

# MAQAO: following code not needed, done elsewhere in MAQAO
#install(TARGETS dwarf
#        RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
#        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
#        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
#        PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
#        )
#
#configure_file(libdwarf.pc.in libdwarf.pc @ONLY)
#
# The install has to be here, not in
# another CMakeLists.txt  to make install work properly
# for cmake before cmake 3.13. This also works
# for newer cmake.
#include(CMakePackageConfigHelpers)
#configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/libdwarfConfig.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/libdwarfConfig.cmake" INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/libdwarf")
#write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/libdwarfConfigVersion.cmake" VERSION "${PROJECT_VERSION}" COMPATIBILITY SameMinorVersion)
#install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libdwarfConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/libdwarfConfigVersion.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/libdwarf")
#install(TARGETS dwarf EXPORT libdwarfTargets
#        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
#        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
#        PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
#install(EXPORT libdwarfTargets
#        FILE libdwarf-targets.cmake
#        NAMESPACE libdwarf::
#        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/libdwarf")
#export(
#  TARGETS dwarf
#  NAMESPACE libdwarf::
#  FILE "${CMAKE_CURRENT_BINARY_DIR}/libdwarf-targets.cmake"
#)
#install(FILES "${PROJECT_BINARY_DIR}/src/lib/libdwarf/libdwarf.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
#install(FILES "${PROJECT_SOURCE_DIR}/cmake/Findzstd.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/libdwarf")


#############################################################################################################
#### End of code imported from the CMakeLists.txt in the libdwarf subdirectory from the libdwarf package ####
#############################################################################################################

# Add a target to build dependences on dwarf #
ADD_CUSTOM_TARGET(do_dwarf DEPENDS dwarf-obj-static)
IF(is_WINDOWS)
	ADD_DEPENDENCIES(do_dwarf dwarf-obj-dyn)
ENDIf(is_WINDOWS)

### --- Install the headers --- ###
FILE(COPY ${CMAKE_CURRENT_SOURCE_DIR}/dwarf.h    DESTINATION ${INCLUDE_OUTPUT_PATH})
FILE(COPY ${CMAKE_CURRENT_SOURCE_DIR}/libdwarf.h DESTINATION ${INCLUDE_OUTPUT_PATH})
