Commit e9efa19a authored by jan.koester's avatar jan.koester
Browse files

fixes

parent c6b5bb04

CMakeLists.txt

+2 −3
Original line number Diff line number Diff line 
cmake_minimum_required(VERSION 3.12)



set(CMAKE_INCLUDE_PATH "${CMAKE_INCLUDE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake" )



project(libconfplus)



set(WINDOWS_EXPORT_ALL_SYMBOLS ON)



list(APPEND CMAKE_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" PARENT_SCOPE)



if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Windows")

    set(CMAKE_INSTALL_PREFIX ON CACHE PATH "c:/Program Files/libconfplus")

    set(CMAKE_CXX_FLAGS

        "/EHsc"

    )

backends/CMakeLists.txt

+2 −2
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ include_directories( 
)



# --- YAML BACKEND (Corrected) ---

find_package(YAML REQUIRED)

find_package(yaml REQUIRED)



# The conditional check needs a standard CMake variable check, not a dereference.

if(YAML_FOUND)
@@ -31,7 +31,7 @@ if(YAML_FOUND) 
endif()



# --- INIPARSER BACKEND (Corrected) ---

find_package(INIPARSER)

find_package(iniparser REQUIRED)



if(INIPARSER_FOUND)

    set( inisrc ini/ini.cpp)

cmake/FindINIPARSER.cmake

+70 −94
Original line number Diff line number Diff line 
# iniparser-config.cmake

# Unterstützt find_package(INIPARSER) ohne REQUIRED-Flag.

# =====================================================================

# FindINIPARSER.cmake

# Prüft auf INIPARSER-Header/Bibliothek und definiert das Target iniparser::iniparser.

# =====================================================================



# --------------------------------------------------------------------------

# 1. Definieren der Pfadvariablen (Pfadsuche und Fallbacks)

# --------------------------------------------------------------------------

include(FindPackageHandleStandardArgs)



set(INIPARSER_FOUND FALSE) # Standardmäßig nicht gefunden



# --- Definiere plattformspezifische Dateinamen für STATIC Libs (für Windows-Prüfung) ---

# -----------------------------------------------------------------------------

# 0. Definieren von Hilfsvariablen

# -----------------------------------------------------------------------------

set(INIPARSER_FOUND FALSE)

if (WIN32)

    set(_INIPARSER_LIB_NAME_STATIC "iniparser-static.lib")

    set(_INIPARSER_LIB_NAME_STATIC_DEBUG "iniparser-static-d.lib")

    set(_INIPARSER_LIB_NAME "iniparser-static")

    set(_INIPARSER_LIB_NAME_DEBUG "iniparser-static-d")

else()

    set(_INIPARSER_LIB_NAME_STATIC "libiniparser.a")

    set(_INIPARSER_LIB_NAME "iniparser")

    set(_INIPARSER_LIB_NAME_DEBUG "iniparser")

endif()



if(DEFINED CMAKE_PREFIX_PATH)

    foreach(PREFIX_PATH ${CMAKE_PREFIX_PATH})

        set(_POTENTIAL_INCLUDE_DIR "${PREFIX_PATH}/include")

        set(_POTENTIAL_LIB_FILE "${PREFIX_PATH}/lib/${_INIPARSER_LIB_NAME_STATIC}")



        # Verwende AND, um sicherzustellen, dass sowohl Header als auch Bibliothek existieren

        if (EXISTS "${_POTENTIAL_INCLUDE_DIR}/iniparser/iniparser.h" AND EXISTS "${_POTENTIAL_LIB_FILE}")

            set(INIPARSER_ROOT "${PREFIX_PATH}")

            message(STATUS "iniparser-config: Found INIPARSER_ROOT at ${INIPARSER_ROOT}")

            break()

        endif()

    endforeach()

endif()

# -----------------------------------------------------------------------------

# 1. Hauptsuche 

# -----------------------------------------------------------------------------



if(NOT INIPARSER_ROOT)

    # Prüfe auf CMAKE_INSTALL_PREFIX

    if(DEFINED CMAKE_INSTALL_PREFIX)

        set(INIPARSER_ROOT "${CMAKE_INSTALL_PREFIX}")

    # FIX: Füge den UNIX-Standardpfad-Fallback hinzu, um /usr/local/lib Fehler zu verhindern

    elseif(UNIX)

        set(INIPARSER_ROOT "/usr")

    else()

        # Fallback zur Berechnung basierend auf dem Speicherort dieser Datei

        get_filename_component(INIPARSER_ROOT "${CMAKE_CURRENT_LIST_DIR}/../../" ABSOLUTE)

    endif()

endif()

# Sucht den Pfad zum Header (iniparser.h)

# WICHTIG: Wir suchen nach der Datei selbst, aber speichern den PFAD zum VERZEICHNIS,

# das den Header enthält (z.B. C:/.../install/include).

find_path(INIPARSER_INCLUDE_DIR

	NAMES iniparser/iniparser.h iniparser.h

	PATH_SUFFIXES include

)



# Setze den Include-Pfad (ist i.d.R. immer ${INIPARSER_ROOT}/include)

set(INIPARSER_INCLUDE_DIR "${INIPARSER_ROOT}/include")

message(STATUS "DIAGNOSE: INIPARSER_INCLUDE_DIR: ${INIPARSER_INCLUDE_DIR}")

# Sucht nach der Release-Version

find_library(INIPARSER_LIBRARY

	NAMES ${_INIPARSER_LIB_NAME}

)



# Sucht nach der Debug-Version

find_library(INIPARSER_LIBRARY_DEBUG

	NAMES ${_INIPARSER_LIB_NAME_DEBUG}

)



# --------------------------------------------------------------------------

# 2. Bibliothek suchen und FOUND-Variable setzen (KORRIGIERT für Windows-Konsistenz)

# --------------------------------------------------------------------------



if (WIN32)

    # Windows: Wir gehen davon aus, dass die Dateien unter ${INIPARSER_ROOT}/lib liegen

    set(INIPARSER_LIBRARY_DIR "${INIPARSER_ROOT}/lib")

# -----------------------------------------------------------------------------

# 2. Fehlerbehandlung und Setzen der FOUND-Variable

# -----------------------------------------------------------------------------



    # Prüfe die Existenz der Release-Bibliothek, um INIPARSER_FOUND zu setzen

    set(_INIPARSER_LIB_PATH_STATIC "${INIPARSER_LIBRARY_DIR}/${_INIPARSER_LIB_NAME_STATIC}")

find_package_handle_standard_args(INIPARSER

    FOUND_VAR           INIPARSER_FOUND

    REQUIRED_VARS       INIPARSER_INCLUDE_DIR

                        INIPARSER_LIBRARY

    FAIL_MESSAGE        "Could NOT find INIPARSER static library or headers."

)



    if (EXISTS "${_INIPARSER_LIB_PATH_STATIC}")

        set(INIPARSER_FOUND TRUE)

        # NEU: Setze die Variable INIPARSER_LIBRARY auf den gefundenen Release-Pfad 

        # (Wichtig für Konsistenz und manche ältere CMake-Verlinkungen)

        set(INIPARSER_LIBRARY "${_INIPARSER_LIB_PATH_STATIC}")

    endif()

else()

    # Unix/Linux: Verwende find_library für Multiarch-Unterstützung

    # Suche die statische Bibliothek; der gefundene Pfad ist ABSOLUT

    find_library(INIPARSER_LIBRARY NAMES iniparser)

# -----------------------------------------------------------------------------

# 3. Definiere Imported Static Target (Wenn gefunden)

# -----------------------------------------------------------------------------



    if (INIPARSER_LIBRARY)

        set(INIPARSER_FOUND TRUE)

    endif()

endif()

if(INIPARSER_FOUND)

    

message(STATUS "DIAGNOSE: INIPARSER_LIBRARY (Pfad): ${INIPARSER_LIBRARY}")

message(STATUS "DIAGNOSE: INIPARSER_FOUND ist: ${INIPARSER_FOUND}")

    # NEU: Überprüfe, ob der Include-Pfad das 'iniparser'-Verzeichnis bereits enthält.

    # Da der Include-Pfad im Quellcode "iniparser/iniparser.h" ist, 

    # muss der Compiler nur den Pfad bis zum "include"-Ordner kennen.

    # INIPARSER_INCLUDE_DIR sollte C:/.../install/include sein.

    

    set(_INIPARSER_INTERFACE_INCLUDES "${INIPARSER_INCLUDE_DIR}")



# --------------------------------------------------------------------------

# 3. Erstellen des Namespaced IMPORTED Targets (Nur wenn gefunden)

# --------------------------------------------------------------------------

    # Fix: Wenn der Header im include-Ordner in einem Unterordner liegt (install/include/iniparser),

    # müssen wir iniparser/iniparser.h verwenden. Das ist hier der Fall, also ist 

    # INIPARSER_INCLUDE_DIR = C:/.../install/include korrekt.



if (NOT TARGET iniparser::iniparser AND INIPARSER_FOUND)

    message(STATUS "DIAGNOSE: Target iniparser::iniparser wird erstellt.")

    

    add_library(iniparser::iniparser STATIC IMPORTED)

    add_library(iniparser::iniparser SHARED IMPORTED)

    

    # 2. Setze die öffentlichen Header

    set_target_properties(iniparser::iniparser PROPERTIES

        IMPORTED_CONFIGURATIONS "Release;Debug"

        INTERFACE_INCLUDE_DIRECTORIES "${INIPARSER_INCLUDE_DIR}"

    )



    # --- Windows Implementierung (.lib) ---

    if (WIN32)

        # Pfade wurden oben bereits definiert und geprüft

        set_target_properties(iniparser::iniparser PROPERTIES

            IMPORTED_LOCATION_RELEASE "${INIPARSER_LIBRARY}" # NUTZT die neu gesetzte INIPARSER_LIBRARY Variable

            IMPORTED_LOCATION_DEBUG "${INIPARSER_LIBRARY_DIR}/${_INIPARSER_LIB_NAME_STATIC_DEBUG}"

        )

    # --- Linux/Unix Implementierung (.a) ---

    else()

        # NUTZT den von find_library gefundenen ABSOLUTEN PFAD

        set_target_properties(iniparser::iniparser PROPERTIES

        INTERFACE_INCLUDE_DIRECTORIES "${_INIPARSER_INTERFACE_INCLUDES}"

        IMPORTED_CONFIGURATIONS "Release;Debug;RelWithDebInfo"

        # Die Debug-Bibliothek wird in den Build-Typen RelWithDebInfo und Debug verwendet

        IMPORTED_LOCATION_RELEASE "${INIPARSER_LIBRARY}"

            IMPORTED_LOCATION_DEBUG "${INIPARSER_LIBRARY}"

        IMPORTED_LOCATION_RELWITHDEBINFO "${INIPARSER_LIBRARY}"

        IMPORTED_LOCATION_DEBUG "${INIPARSER_LIBRARY_DEBUG}"

    )

    endif()

else()

    if(NOT INIPARSER_FOUND)

         message(STATUS "DIAGNOSE: Target iniparser::iniparser WURDE NICHT erstellt, da INIPARSER_FOUND=FALSE.")

    endif()



    add_library(iniparser::iniparser ALIAS iniparser::iniparser)

endif()



# Verhindert, dass die Variable am Ende des Skripts auf FALSE zurückgesetzt wird

set(INIPARSER_LIBRARIES "iniparser::iniparser" CACHE STRING "The INIPARSER library target.")
 
 No newline at end of file
 
# Verstecke interne Variablen

mark_as_advanced(

    INIPARSER_INCLUDE_DIR

    INIPARSER_LIBRARY

    INIPARSER_LIBRARY_DEBUG

)
 
 No newline at end of file

cmake/FindYAML.cmake

+38 −20
Original line number Diff line number Diff line 
# =====================================================================

# FindYAML.cmake (Adaptiert nach Findjson-c.cmake)

# FindYAML.cmake

# Prüft auf YAML-Header/Bibliothek und definiert das Target yaml::yaml.

# =====================================================================



include(FindPackageHandleStandardArgs)



# --- Define platform-specific names ---

# -----------------------------------------------------------------------------

# 0. Definieren von Hilfsvariablen

# -----------------------------------------------------------------------------



set(YAML_FOUND FALSE) # Standardmäßig nicht gefunden



if (WIN32)

    set(_YAML_DLL_NAME "yaml.dll")

    set(_YAML_IMPLIB_NAME "yaml.lib")

    set(_YAML_LIB_NAME "yaml") # Für find_library (findet die .lib)

    set(_YAML_LIB_NAME_DEBUG "yaml-d")

else()

    set(_YAML_LIB_NAME "yaml")

    set(_YAML_LIB_NAME_DEBUG "yaml") # Unter Linux ist der Name oft gleich

endif()





# -----------------------------------------------------------------------------

# 1. Find Header and Link Libraries

# 1. Hauptsuche (Verwendet CMAKE_PREFIX_PATH und CMAKE_MODULE_PATH)

# -----------------------------------------------------------------------------



# Sucht den Pfad zum Header (yaml.h)

find_path(YAML_INCLUDE_DIR

	NAMES yaml.h

	PATH_SUFFIXES include

)



# Find out the path to the library (Findet die .lib-Datei auf Windows)

# Sucht den Pfad zur Import-Bibliothek (.lib unter Windows, .so unter Linux)

# Sucht nach der Release-Version

find_library(YAML_LIBRARY

	NAMES ${_YAML_LIB_NAME}

)



# Sucht nach der Debug-Version (wichtig für Visual Studio)

find_library(YAML_LIBRARY_DEBUG

	NAMES ${_YAML_LIB_NAME_DEBUG}

)





# -----------------------------------------------------------------------------

# 2. Handle Required Arguments

# 2. Fehlerbehandlung und Setzen der FOUND-Variable

# -----------------------------------------------------------------------------



find_package_handle_standard_args(YAML
@@ -39,36 +56,36 @@ find_package_handle_standard_args(YAML 
)



# -----------------------------------------------------------------------------

# 3. Define Imported Shared Target (Internal Name)

# 3. Definiere Imported Shared Target (Wenn gefunden)

# -----------------------------------------------------------------------------



if(YAML_FOUND)

    

    # 1. Define the primary target with the name 'YAML::YAML' (Großschreibung)

    # 1. Definiere das primäre Target (YAML::YAML)

    add_library(YAML::YAML SHARED IMPORTED)

    

    # 2. Set the public interface (headers)

    # 2. Setze die öffentlichen Header

    set_target_properties(YAML::YAML PROPERTIES

        INTERFACE_INCLUDE_DIRECTORIES "${YAML_INCLUDE_DIR}"

    )

    

    # 3. Set the location properties

    # 3. Setze die Speicherort-Eigenschaften

    if(WIN32)

        

        # Bestimme Pfade basierend auf dem Speicherort der gefundenen .lib-Datei.

        #  (Logik aus Findjson-c)

        # --- Pfad-Ableitung (Annahme: /install/lib für .lib, /install/bin für .dll) ---

        get_filename_component(_LIB_DIR "${YAML_LIBRARY}" DIRECTORY)  # z.B. C:/.../install/lib

        get_filename_component(_PARENT_DIR "${_LIB_DIR}" DIRECTORY)   # z.B. C:/.../install

        

        # Set IMPORTED_IMPLIB (the .lib) for linking [cite: 10]

        # Setze IMPORTED_IMPLIB (die .lib) für Linker

        set_target_properties(YAML::YAML PROPERTIES

            IMPORTED_IMPLIB "${YAML_LIBRARY}" # Der gefundene .lib Pfad

            IMPORTED_IMPLIB "${YAML_LIBRARY}"

            IMPORTED_IMPLIB_DEBUG "${YAML_LIBRARY_DEBUG}"

        )

        

        # Set IMPORTED_LOCATION for configurations (geht davon aus, dass die DLL nach /bin geht) [cite: 12]

        # Setze IMPORTED_LOCATION (die .dll) für die Runtime

        set_target_properties(YAML::YAML PROPERTIES

            IMPORTED_LOCATION_RELEASE "${_PARENT_DIR}/bin/${_YAML_DLL_NAME}"

            IMPORTED_LOCATION_DEBUG   "${_PARENT_DIR}/bin/yaml-d.dll" # Annahme für Debug-DLL

            IMPORTED_LOCATION_DEBUG   "${_PARENT_DIR}/bin/yaml-d.dll" 

            IMPORTED_LOCATION_RELWITHDEBINFO "${_PARENT_DIR}/bin/${_YAML_DLL_NAME}"

        )
@@ -76,20 +93,21 @@ if(YAML_FOUND) 
        # Non-Windows systems: link file is the runtime file

        set_target_properties(YAML::YAML PROPERTIES

            IMPORTED_LOCATION "${YAML_LIBRARY}"

            IMPORTED_LOCATION_DEBUG "${YAML_LIBRARY_DEBUG}"

        )

    endif()



    # -----------------------------------------------------------------------------

    # 4. Define Alias for Consumer (Fixes the yaml::yaml-NOTFOUND error)

    # 4. Definiere Alias für den Konsumenten

    # -----------------------------------------------------------------------------

    # Der Konsument (libconfplus) sucht nach yaml::yaml (Kleinbuchstaben-Namespace).

    # Erstelle ein ALIAS-Target, das auf das primäre Target YAML::YAML zeigt. 

    add_library(yaml::yaml ALIAS YAML::YAML)

    

endif()



# Hide internal variables from the CMake GUI

# Verstecke interne Variablen

mark_as_advanced(

    YAML_INCLUDE_DIR

    YAML_LIBRARY

    YAML_LIBRARY_DEBUG

)
 
 No newline at end of file