Pakete mit ServBay neu kompilieren

ServBay bietet Nutzern auf macOS und Windows eine leistungsstarke und vollständige lokale Webentwicklungsumgebung mit einer Vielzahl von Paketen und Tools. Auch wenn ServBay schon viele Softwarepakete vorinstalliert, kann es sein, dass Entwickler Pakete für besondere Anforderungen neu kompilieren müssen, beispielsweise:

• Aktivieren spezieller Build-Optionen für ein Paket.
• Hinzufügen von Modulen oder Erweiterungen, die ServBay standardmäßig nicht enthält (z. B. neue PHP- oder PostgreSQL-Module).
• Kompilieren gegen eine alternative Bibliothek-Version als die von ServBay vorgegebene.
• Individuelle Anpassungen an einem von ServBay bereitgestellten Paket.

ServBay stellt die notwendige Build-Umgebung und Toolchain zur Verfügung, damit Nutzer diese Aufgaben bequem erledigen können.

Um Pakete erfolgreich neu zu kompilieren, sollten Sie mit den jeweiligen Kompiliervorgängen Ihres Betriebssystems vertraut sein:

• macOS/Linux: Werkzeuge wie configure, make, make install aus der Unix/Linux-Toolchain
• Windows: Visual Studio Build-System, MSBuild, cmake und ähnliche Build-Umgebungen

Voraussetzungen

Stellen Sie vor einer Neukompilierung sicher, dass die folgenden Voraussetzungen erfüllt sind:

1. Installation der ServBay Development Library: Diese ist die zentrale Voraussetzung für eine Neukompilierung. Das Paket beinhaltet alle für die ServBay-Umgebung benötigten Bibliotheken, Header-Dateien und Entwicklungsressourcen. Sie können es im ServBay-Interface unter dem Reiter Pakete finden und installieren.

   

2. Installation der Entwickler-Tools:

   macOS

   Installation der Xcode Command Line Tools: Dieses Basis-Toolkit für macOS enthält den Compiler (Clang), Linker und weitere notwendige Tools. Öffnen Sie das Terminal und führen Sie folgenden Befehl aus:

   xcode-select --install

   Falls bereits installiert, erhalten Sie einen entsprechenden Hinweis des Systems.

   Zusätzliche Build-Tools installieren: Für die meisten Open-Source-Projekte benötigen Sie auch autoconf, automake, libtool usw. Diese Tools lassen sich meist per Homebrew installieren:

   brew install autoconf automake libtool cmake

   Sollten Sie Homebrew noch nicht installiert haben, folgen Sie zuerst der offiziellen Anleitung auf der Homebrew-Website.

   Windows

   Installation von Visual Studio Build Tools oder Visual Studio Community: Auf Windows werden Microsoft Visual C++ Compiler und Build-Tools benötigt. Sie können eine der folgenden Optionen wählen:

   Option 1: Visual Studio Build Tools (empfohlen, da kleiner)

   1. Laden Sie die Visual Studio Build Tools herunter und installieren Sie sie.
   2. Während der Installation wählen Sie die Arbeitslast "C++ build tools".
   3. Achten Sie auf folgende Komponenten:
      • MSVC v143 – VS 2022 C++ x64/x86 Build Tools
      • Windows 11 SDK (neueste Version)
      • CMake Tools

   Option 2: Visual Studio Community

   1. Laden Sie Visual Studio Community herunter und installieren Sie es.
   2. Während der Installation wählen Sie die Arbeitslast "Desktopentwicklung mit C++".
   3. Stellen Sie sicher, dass CMake-Tools und das Windows SDK enthalten sind.

   Zusätzliche Tools installieren: Für manche Open-Source-Projekte benötigen Sie außerdem:

   • Git for Windows: Für den Quellcode-Download
   • MSYS2 oder vcpkg: Für die Verwaltung von C/C++-Bibliotheken
   • Python: Manche Build-Skripte benötigen Python

   # Installation zusätzlicher Tools per chocolatey (optional)
   choco install git cmake python msys2

Build-Umgebung einrichten

Nachdem Sie die ServBay Development Library und alle notwendigen Tools installiert haben, müssen Sie die Build-Umgebung initialisieren. Dabei werden diverse Umgebungsvariablen gesetzt, damit Compiler und Build-System die ServBay-Bibliotheken, Header und Binärdateien korrekt finden und verlinken.

Die Konfiguration variiert je nach Betriebssystem und Architektur:

macOS

Die ServBay-Umgebung unterscheidet sich je nach CPU: Intel-Prozessor (x86_64) oder Apple Silicon (Arm64). Je nach aktuell verwendeter ServBay Runtime müssen Sie den entsprechenden Initialisierungsbefehl wählen.

Windows

ServBay für Windows unterstützt die x64-Architektur und wird unter C:\ServBay installiert.

CPU-Architektur der ServBay Runtime prüfen

macOS

Um die Architektur festzustellen, können Sie in der ServBay-bin-Directory eine beliebige ausführbare Datei prüfen, z. B. bison:

Arm64 (Apple Silicon)

# Führen Sie das folgende Kommando im Terminal aus, um die Architektur zu prüfen
$ file /Applications/ServBay/bin/bison
/Applications/ServBay/bin/bison: Mach-O 64-bit executable arm64

x86_64 (Intel)

# Führen Sie das folgende Kommando im Terminal aus, um die Architektur zu prüfen
$ file /Applications/ServBay/bin/bison
/Applications/ServBay/bin/bison: Mach-O 64-bit executable x86_64

Windows

Die Windows-Version von ServBay unterstützt aktuell x64. Die Architektur können Sie im PowerShell prüfen:

# Führen Sie das folgende Kommando in PowerShell aus, um Infos zur Ausführung zu erhalten
PS> Get-Command "C:\ServBay\bin\bison.exe" | Select-Object -ExpandProperty FileVersionInfo | Select-Object ProductName, FileDescription

Alternativ können Sie auch direkt die Dateieigenschaften prüfen.

Je nach Architektur wählen Sie dann das passende Initialisierungsskript für die Build-Umgebung.

Build-Umgebungsvariablen initialisieren

Je nach Betriebssystem/Architektur führen Sie das zugehörige Skript aus:

macOS

Öffnen Sie ein neues Terminal und kopieren Sie das passende Skript für Ihre CPU herein. Die Skripte setzen alle nötigen Pfade und Flags für die ServBay-Build-Umgebung.

Arm64 (Apple Silicon)

# Setzt die Anzahl der CPU-Kerne für paralleles Kompilieren
CPU_NUMBER=$(sysctl -n hw.ncpu)
# Basis-Installationspfad von ServBay
SERVBAY_BASE_FULL_PATH="/Applications/ServBay"
# Name des Paketverzeichnisses
SERVBAY_PACKAGE_DIR_NAME="package"
# Vollständiger Paketpfad
SERVBAY_PACKAGE_FULL_PATH="${SERVBAY_BASE_FULL_PATH}/${SERVBAY_PACKAGE_DIR_NAME}"
# Pfade zu ServBay-Binaries
SERVBAY_BIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/bin"
SERVBAY_SBIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/sbin"
# Pfad zu Konfigurationen
SERVBAY_ETC_PATH="${SERVBAY_PACKAGE_FULL_PATH}/etc"
# Pfad zu Variablen-Daten
SERVBAY_VAR_PATH="${SERVBAY_PACKAGE_FULL_PATH}/var"
# Pfad der ServBay Development Library
SERVBAY_COMMON_PATH="${SERVBAY_PACKAGE_FULL_PATH}/common"
# Pfad zu Header-Dateien der Development Library
SERVBAY_COMMON_INCLUDE_PATH="${SERVBAY_COMMON_PATH}/include"
# Pfad zu Library-Dateien der Development Library
SERVBAY_COMMON_LIB_PATH="${SERVBAY_COMMON_PATH}/lib"
SERVBAY_COMMON_LIBEXEC_PATH="${SERVBAY_COMMON_PATH}/libexec"
SERVBAY_COMMON_SHARE_PATH="${SERVBAY_COMMON_PATH}/share"
SERVBAY_COMMON_MAN_PATH="${SERVBAY_COMMON_PATH}/man"
SERVBAY_COMMON_DOC_PATH="${SERVBAY_COMMON_PATH}/doc"
# Aktuelles Build-Verzeichnis
SERVBAY_BUILD_DIR=$(pwd)
SERVBAY_BUILD_SRC_DIR=${SERVBAY_BUILD_DIR}/src
# OpenSSL-Version
OPENSSL_SELECTED_VERSION="3.2"
OPENSSL_VERSION="3.2.1"
# Mindestversion des Zielbetriebssystems
BUILD_OS_MIN_VERSION="12.00" # macOS Monterey oder neuer
# Build-Flag für CPU-Architektur
BUILD_CPU_ARCH="-arch arm64"
BUILD_CPU_ARCH_CMAKE="arm64"
BUILD_MACOS_TARGET="" # Arm64 benötigt i. d. R. kein -target-Flag

# Setzt CFLAGS für den C-Compiler
export CFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Setzt LDFLAGS für den Linker
export LDFLAGS="-Wl,-rpath -Wl,${SERVBAY_COMMON_LIB_PATH} -L${SERVBAY_COMMON_LIB_PATH} -L${SERVBAY_PACKAGE_FULL_PATH} -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Setzt CPPFLAGS für den Präprozessor
export CPPFLAGS="-I${SERVBAY_COMMON_INCLUDE_PATH}"
# Setzt CXXFLAGS für den C++-Compiler
export CXXFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Priorisiert ServBay bin/sbin in PATH
export PATH="${SERVBAY_BIN_PATH}:${SERVBAY_SBIN_PATH}:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin"
# Setzt pkg-config-Pfad
export PKG_CONFIG_PATH="${SERVBAY_COMMON_LIB_PATH}/pkgconfig"
export PKG_CONFIG="${SERVBAY_BIN_PATH}/pkg-config"
export PKG_CONFIG_LIBDIR="${SERVBAY_COMMON_LIB_PATH}/pkgconfig"
# Füge System/Homebrew Pfade ans Ende von PATH hinzu
export PATH=$PATH:"/usr/local/bin:/usr/local/sbin"
export PATH=$PATH:"/opt/homebrew/bin/" # Standardpfad Homebrew

# Fügt OpenSSL Pfade zu LDFLAGS und CPPFLAGS hinzu
export LDFLAGS="-L${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib ${LDFLAGS}"
export CPPFLAGS="-I${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/include ${CPPFLAGS}"
# Fügt OpenSSL pkgconfig-Pfade hinzu
export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib/pkgconfig"
export PKG_CONFIG_LIBDIR="${PKG_CONFIG_LIBDIR}:${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib/pkgconfig"

# Nach Setzen der Variablen können Sie nun Build-Vorgänge im aktuellen Terminal ausführen
echo "ServBay Arm64 Build-Umgebung ist konfiguriert."

x86_64 (Intel)

# Setzt die Anzahl der CPU-Kerne für paralleles Kompilieren
CPU_NUMBER=$(sysctl -n hw.ncpu)
# Basis-Installationspfad von ServBay
SERVBAY_BASE_FULL_PATH="/Applications/ServBay"
# Name des Paketverzeichnisses
SERVBAY_PACKAGE_DIR_NAME="package"
# Vollständiger Paketpfad
SERVBAY_PACKAGE_FULL_PATH="${SERVBAY_BASE_FULL_PATH}/${SERVBAY_PACKAGE_DIR_NAME}"
# Pfade zu ServBay-Binaries
SERVBAY_BIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/bin"
SERVBAY_SBIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/sbin"
# Pfad zu Konfigurationen
SERVBAY_ETC_PATH="${SERVBAY_PACKAGE_FULL_PATH}/etc"
# Pfad zu Variablen-Daten
SERVBAY_VAR_PATH="${SERVBAY_PACKAGE_FULL_PATH}/var"
# Pfad der ServBay Development Library
SERVBAY_COMMON_PATH="${SERVBAY_PACKAGE_FULL_PATH}/common"
# Pfad zu Header-Dateien der Development Library
SERVBAY_COMMON_INCLUDE_PATH="${SERVBAY_COMMON_PATH}/include"
# Pfad zu Library-Dateien der Development Library
SERVBAY_COMMON_LIB_PATH="${SERVBAY_COMMON_PATH}/lib"
SERVBAY_COMMON_LIBEXEC_PATH="${SERVBAY_COMMON_PATH}/libexec"
SERVBAY_COMMON_SHARE_PATH="${SERVBAY_COMMON_PATH}/share"
SERVBAY_COMMON_MAN_PATH="${SERVBAY_COMMON_PATH}/man"
SERVBAY_COMMON_DOC_PATH="${SERVBAY_COMMON_PATH}/doc"
# Aktuelles Build-Verzeichnis
SERVBAY_BUILD_DIR=$(pwd)
SERVBAY_BUILD_SRC_DIR=${SERVBAY_BUILD_DIR}/src
# OpenSSL-Version
OPENSSL_SELECTED_VERSION="1.1.1u"
OPENSSL_VERSION="1.1.1u"
# Mindestversion des Zielbetriebssystems
BUILD_OS_MIN_VERSION="12.00" # macOS Monterey oder neuer
# Build-Flag für CPU-Architektur
BUILD_CPU_ARCH="-arch x86_64"
BUILD_CPU_ARCH_CMAKE="x86_64"
# Zielplattform-Flag (bei Intel nötig)
BUILD_MACOS_TARGET="-target x86_64-apple-macos${BUILD_OS_MIN_VERSION}"

# Setzt CFLAGS für den C-Compiler
export CFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Setzt LDFLAGS für den Linker
export LDFLAGS="-Wl,-rpath -Wl,${SERVBAY_COMMON_LIB_PATH} -L${SERVBAY_COMMON_LIB_PATH} -L${SERVBAY_PACKAGE_FULL_PATH} -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Setzt CPPFLAGS für den Präprozessor
export CPPFLAGS="-I${SERVBAY_COMMON_INCLUDE_PATH}"
# Setzt CXXFLAGS für den C++-Compiler
export CXXFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Priorisiert ServBay bin/sbin in PATH
export PATH="${SERVBAY_BIN_PATH}:${SERVBAY_SBIN_PATH}:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin"
# Setzt pkg-config-Pfad
export PKG_CONFIG_PATH="${SERVBAY_COMMON_LIB_PATH}/pkgconfig"
export PKG_CONFIG="${SERVBAY_BIN_PATH}/pkg-config"
export PKG_CONFIG_LIBDIR="${SERVBAY_COMMON_LIB_PATH}/pkgconfig"
# Füge System/Homebrew Pfade ans Ende von PATH hinzu
export PATH=$PATH:"/usr/local/bin:/usr/local/sbin"
export PATH=$PATH:"/opt/homebrew/bin/" # Standardpfad Homebrew

# Fügt OpenSSL Pfade zu LDFLAGS und CPPFLAGS hinzu
export LDFLAGS="-L${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib ${LDFLAGS}"
export CPPFLAGS="-I${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/include ${CPPFLAGS}"
# Fügt OpenSSL pkgconfig-Pfade hinzu
export PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib/pkgconfig"
export PKG_CONFIG_LIBDIR="${PKG_CONFIG_LIBDIR}:${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib/pkgconfig"

# Nach Setzen der Variablen können Sie nun Build-Vorgänge im aktuellen Terminal ausführen
echo "ServBay x86_64 Build-Umgebung ist konfiguriert."

Windows

Für Windows müssen Sie die Variablen in PowerShell oder Developer Command Prompt setzen. Folgendes Skript ist für Windows x64 geeignet:

# Festlegen der CPU-Kern-Anzahl für paralleles Kompilieren
$CPU_NUMBER = (Get-WmiObject -Class Win32_Processor).NumberOfLogicalProcessors

# ServBay Basis-Installationsverzeichnis (Windows)
$SERVBAY_BASE_FULL_PATH = "C:\ServBay"
# Paketverzeichnisname
$SERVBAY_PACKAGE_DIR_NAME = "package"
# Vollständiges Paketverzeichnis
$SERVBAY_PACKAGE_FULL_PATH = "${SERVBAY_BASE_FULL_PATH}\${SERVBAY_PACKAGE_DIR_NAME}"

# ServBay-Binary-Pfad
$SERVBAY_BIN_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\bin"
$SERVBAY_SBIN_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\sbin"
# Pfad für Konfiguration
$SERVBAY_ETC_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\etc"
# Pfad für variable Daten
$SERVBAY_VAR_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\var"

# ServBay Development Library Verzeichnis
$SERVBAY_COMMON_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\common"
# Header-Dateien-Verzeichnis
$SERVBAY_COMMON_INCLUDE_PATH = "${SERVBAY_COMMON_PATH}\include"
# Bibliotheksverzeichnis
$SERVBAY_COMMON_LIB_PATH = "${SERVBAY_COMMON_PATH}\lib"
$SERVBAY_COMMON_LIBEXEC_PATH = "${SERVBAY_COMMON_PATH}\libexec"
$SERVBAY_COMMON_SHARE_PATH = "${SERVBAY_COMMON_PATH}\share"
$SERVBAY_COMMON_DOC_PATH = "${SERVBAY_COMMON_PATH}\doc"

# Aktuelles Build-Verzeichnis
$SERVBAY_BUILD_DIR = Get-Location
$SERVBAY_BUILD_SRC_DIR = "${SERVBAY_BUILD_DIR}\src"

# OpenSSL-Version (Windows)
$OPENSSL_SELECTED_VERSION = "3.2"
$OPENSSL_VERSION = "3.2.1"

# Windows Build-Konfiguration
$BUILD_PLATFORM = "x64"
$BUILD_CONFIG = "Release"

# Setzen der Umgebungsvariablen
$env:SERVBAY_BASE_FULL_PATH = $SERVBAY_BASE_FULL_PATH
$env:SERVBAY_COMMON_PATH = $SERVBAY_COMMON_PATH
$env:SERVBAY_COMMON_INCLUDE_PATH = $SERVBAY_COMMON_INCLUDE_PATH
$env:SERVBAY_COMMON_LIB_PATH = $SERVBAY_COMMON_LIB_PATH

# PATH zuerst um ServBay bin/sbin erweitern
$env:PATH = "${SERVBAY_BIN_PATH};${SERVBAY_SBIN_PATH};$env:PATH"

# Compiler-Umgebungsvariablen ergänzen
$env:INCLUDE = "${SERVBAY_COMMON_INCLUDE_PATH};$env:INCLUDE"
$env:LIB = "${SERVBAY_COMMON_LIB_PATH};$env:LIB"
$env:LIBPATH = "${SERVBAY_COMMON_LIB_PATH};$env:LIBPATH"

# pkg-config Variablen (falls relevant)
$env:PKG_CONFIG_PATH = "${SERVBAY_COMMON_LIB_PATH}\pkgconfig"

# OpenSSL Header- und Library-Pfad ergänzen
$env:INCLUDE = "${SERVBAY_COMMON_PATH}\openssl\${OPENSSL_SELECTED_VERSION}\include;$env:INCLUDE"
$env:LIB = "${SERVBAY_COMMON_PATH}\openssl\${OPENSSL_SELECTED_VERSION}\lib;$env:LIB"

# CMAKE Variablen setzen
$env:CMAKE_PREFIX_PATH = $SERVBAY_COMMON_PATH
$env:CMAKE_INSTALL_PREFIX = $SERVBAY_COMMON_PATH

# Build-Umgebung fertig
Write-Host "ServBay Windows x64 Build-Umgebung ist konfiguriert."

Wer den Developer Command Prompt verwendet, kann auch ein Batch-Skript nutzen:

@echo off
REM ServBay Build-Umgebung für Windows konfigurieren

REM ServBay Basisverzeichnis
set SERVBAY_BASE_FULL_PATH=C:\ServBay
set SERVBAY_PACKAGE_FULL_PATH=%SERVBAY_BASE_FULL_PATH%\package

REM ServBay-Pfade einstellen
set SERVBAY_BIN_PATH=%SERVBAY_PACKAGE_FULL_PATH%\bin
set SERVBAY_COMMON_PATH=%SERVBAY_PACKAGE_FULL_PATH%\common
set SERVBAY_COMMON_INCLUDE_PATH=%SERVBAY_COMMON_PATH%\include
set SERVBAY_COMMON_LIB_PATH=%SERVBAY_COMMON_PATH%\lib

REM OpenSSL-Version
set OPENSSL_SELECTED_VERSION=3.2

REM Umgebungsvariablen setzen
set PATH=%SERVBAY_BIN_PATH%;%PATH%
set INCLUDE=%SERVBAY_COMMON_INCLUDE_PATH%;%SERVBAY_COMMON_PATH%\openssl\%OPENSSL_SELECTED_VERSION%\include;%INCLUDE%
set LIB=%SERVBAY_COMMON_LIB_PATH%;%SERVBAY_COMMON_PATH%\openssl\%OPENSSL_SELECTED_VERSION%\lib;%LIB%
set CMAKE_PREFIX_PATH=%SERVBAY_COMMON_PATH%

echo ServBay Build-Umgebung für Windows ist eingerichtet.

Wichtiger Hinweis: Diese Variablen sind nur für das aktuelle Terminal gültig. Wenn Sie das Terminal schließen, müssen Sie das Skript erneut ausführen.

Beispiel: Kompilierung

Im fertig konfigurierten Terminal können Sie Quellen downloaden und kompilieren. Im Folgenden finden Sie typische plattformübergreifende Beispiele.

ImageMagick kompilieren

ImageMagick ist eine starke Grafik-Bibliothek und Voraussetzung für die PHP-Extension imagick. ServBay installiert ImageMagick standardmäßig; ein manueller Build ist daher meistens nicht nötig. Das Beispiel dient der Veranschaulichung des Workflows.

macOS / Linux

1. ImageMagick-Quellen herunterladen und entpacken:

   # Bitte die Versionsnummer nach Bedarf anpassen
   wget https://imagemagick.org/archive/releases/ImageMagick-7.1.1-33.tar.gz
   tar zxvf ImageMagick-7.1.1-33.tar.gz
   cd ImageMagick-7.1.1-33

2. Konfiguration via ./configure: Mit den zuvor gesetzten Umgebungsvariablen führen Sie das Skript aus. Die Optionen --prefix, --libdir, --includedir etc. zeigen auf die ServBay Development Library, sodass andere ServBay-Komponenten wie die PHP-Extension imagick die Bibliotheken/Headers finden.

   ./configure \
   --prefix=${SERVBAY_COMMON_PATH} \
   --libdir=${SERVBAY_COMMON_LIB_PATH} \
   --includedir=${SERVBAY_COMMON_INCLUDE_PATH} \
   --oldincludedir=${SERVBAY_COMMON_INCLUDE_PATH} \
   --bindir=${SERVBAY_BIN_PATH} \
   --sbindir=${SERVBAY_SBIN_PATH} \
   --sysconfdir=${SERVBAY_ETC_PATH} \
   --datarootdir=${SERVBAY_COMMON_SHARE_PATH} \
   --enable-osx-universal-binary=no \
   --disable-silent-rules \
   --disable-opencl \
   --enable-shared \
   --enable-static \
   --with-freetype=yes \
   --with-gvc=no \
   --with-modules \
   --with-webp=yes \
   --with-heic=no \
   --without-gslib \
   --with-fpx=no \
   --without-openexexr \
   --with-raw=yes \
   --without-lqr \
   --without-djvu \
   --without-fftw \
   --without-pango \
   --without-wmf \
   --without-x \
   --with-gs-font-dir=${SERVBAY_COMMON_SHARE_PATH}/ghostscript/10.02.1/Resource/Font

3. Kompilieren und Installieren mit make und make install: Mit dem Parameter -j ${CPU_NUMBER} nutzt make alle Kerne für schnellen Build. make install installiert in die ServBay Development Library.

   make -j ${CPU_NUMBER}
   make install

Windows

Auf Windows nutzen Sie typischerweise Visual Studio oder CMake. Da der Build von ImageMagick dort komplexer ist, empfiehlt sich die CMake-Methode:

1. Quellen herunterladen:

   # Download per curl oder alternativ im Browser
   curl -O https://imagemagick.org/archive/releases/ImageMagick-7.1.1-33.tar.gz
   # Entpacken via 7zip etc.
   tar -xzf ImageMagick-7.1.1-33.tar.gz
   cd ImageMagick-7.1.1-33

2. CMake-Konfiguration (im Developer Command Prompt / PowerShell):

   # Build-Ordner anlegen
   mkdir builddir
   cd builddir
   
   # CMake für Konfiguration nutzen
   cmake .. `
       -DCMAKE_INSTALL_PREFIX="$env:SERVBAY_COMMON_PATH" `
       -DCMAKE_BUILD_TYPE=Release `
       -DBUILD_SHARED_LIBS=ON `
       -DMAGICKCORE_QUANTUM_DEPTH=16 `
       -DMAGICKCORE_HDRI_ENABLE=OFF `
       -DWITH_BZLIB=ON `
       -DWITH_ZLIB=ON `
       -DWITH_PNG=ON `
       -DWITH_JPEG=ON `
       -DWITH_TIFF=ON `
       -DWITH_FREETYPE=ON `
       -DWITH_WEBP=ON

3. Build und Installation:

   # Kompilieren
   cmake --build . --config Release --parallel $CPU_NUMBER
   # Installieren
   cmake --install . --config Release

Kompilieren mit cmake

Für Pakete mit cmake als Build-System ist der Ablauf plattformübergreifend ähnlich. Das Beispiel zeigt den Build von protobuf (Protocol Buffers).

1. protobuf-Quellen laden und Verzeichnis wechseln.

macOS / Linux

2. Projekt mit cmake konfigurieren: -S . gibt das Source-Verzeichnis an, -B builddir das Build-Verzeichnis. Mit -DCMAKE_INSTALL_PREFIX und Co. landen die Installationen in der ServBay Library. Weitere D-Flags sind spezifisch für protobuf, und RPATH-Konfigurationen sorgen für korrekte Bibliotheksauflösung.

   # Verzeichnis mit protobuf-Quellen betreten
   cmake -S . -B builddir \
   -DCMAKE_INSTALL_PREFIX=${SERVBAY_COMMON_PATH} \
   -DCMAKE_INSTALL_LIBDIR=${SERVBAY_COMMON_LIB_PATH} \
   -DCMAKE_INSTALL_INCLUDEDIR=${SERVBAY_COMMON_INCLUDE_PATH} \
   -DCMAKE_INSTALL_BINDIR=${SERVBAY_BIN_PATH} \
   -DCMAKE_INSTALL_SBINDIR=${SERVBAY_SBIN_PATH} \
   -DCMAKE_INSTALL_SYSCONFDIR=${SERVBAY_ETC_PATH} \
   -DCMAKE_INSTALL_DATAROOTDIR=${SERVBAY_COMMON_SHARE_PATH} \
   -DCMAKE_MACOSX_RPATH=1 \
   -DCMAKE_INSTALL_RPATH=${SERVBAY_COMMON_LIB_PATH} \
   -DCMAKE_BUILD_WITH_INSTALL_RPATH=TRUE \
   -DCMAKE_PREFIX_PATH=${SERVBAY_COMMON_PATH} \
   -DBUILD_SHARED_LIBS=ON \
   -Dprotobuf_BUILD_LIBPROTOC=ON \
   -Dprotobuf_BUILD_SHARED_LIBS=ON \
   -Dprotobuf_INSTALL_EXAMPLES=OFF \
   -Dprotobuf_BUILD_TESTS=OFF \
   -Dprotobuf_ABSL_PROVIDER=package \
   -Dprotobuf_JSONCPP_PROVIDER=module \
   -DCMAKE_CXX_STANDARD=17

3. Kompilieren und installieren:

   cmake --build builddir -j ${CPU_NUMBER}
   cmake --install builddir

Windows

2. Projekt mit cmake konfigurieren (in PowerShell / Developer Command Prompt):

   # protobuf-Quellverzeichnis betreten
   cmake -S . -B builddir `
       -DCMAKE_INSTALL_PREFIX="$env:SERVBAY_COMMON_PATH" `
       -DCMAKE_BUILD_TYPE=Release `
       -DCMAKE_PREFIX_PATH="$env:SERVBAY_COMMON_PATH" `
       -DBUILD_SHARED_LIBS=ON `
       -Dprotobuf_BUILD_LIBPROTOC=ON `
       -Dprotobuf_BUILD_SHARED_LIBS=ON `
       -Dprotobuf_INSTALL_EXAMPLES=OFF `
       -Dprotobuf_BUILD_TESTS=OFF `
       -Dprotobuf_MSVC_STATIC_RUNTIME=OFF `
       -DCMAKE_CXX_STANDARD=17

3. Build und Installation:

   # Kompilieren
   cmake --build builddir --config Release --parallel $CPU_NUMBER
   # Installieren
   cmake --install builddir --config Release

PHP-Module kompilieren

Falls Sie zusätzliche Erweiterungen für ein in ServBay verwendetes PHP kompilieren möchten (z. B. swoole, redis, mongodb), nutzen Sie bitte die spezifische Anleitung:

Wie man PHP-Module kompiliert

PostgreSQL-Module kompilieren

Wenn Sie zusätzliche Module für PostgreSQL in ServBay kompilieren möchten, folgen Sie bitte der separaten Anleitung:

Wie man PostgreSQL-Module kompiliert

Fazit

Dank der ServBay Development Library und der übersichtlichen Konfiguration der Umgebungsvariablen können Entwickler unter macOS und Windows Pakete einfach neu kompilieren und individuell anpassen. So erhalten Sie maximale Flexibilität für Ihre Projekte – etwa, um maßgeschneiderte Anforderungen zu erfüllen oder Bibliotheken aktuell zu halten.

Wichtige Punkte

• Plattformübergreifende Unterstützung: ServBay unterstützt Build-Umgebungen unter macOS und Windows.
• Pfade beachten: macOS installiert unter /Applications/ServBay, Windows unter C:\ServBay.
• Toolchain-Unterschiede: macOS setzt Xcode Command Line Tools ein, Windows nutzt Visual Studio Build Tools.
• Umgebung konfigurieren: Wählen Sie je nach Plattform das passende Umgebungsvariablen-Skript.

Hinweise

• Lesen Sie stets die offiziellen Build-Anleitungen der jeweiligen Pakete.
• Passen Sie Ihre Konfiguration und Schritte an Ihre Zielplattform an.
• Für Windows empfiehlt sich die Verwendung von CMake.
• Manche Open-Source-Projekte stellen je nach OS unterschiedliche Anforderungen/Abhängigkeiten.

Mit dieser Dokumentation gelingt Ihnen die Paket-Kompilierung unter ServBay auf beiden Plattformen zuverlässig.