Compilazione Secondaria con ServBay

ServBay offre a utenti macOS e Windows un ambiente locale di sviluppo web potente e completo, ricco di pacchetti software e strumenti. Oltre alle versioni preinstallate dei pacchetti forniti da ServBay, talvolta gli sviluppatori possono avere la necessità di eseguire una seconda compilazione per soddisfare esigenze specifiche, ad esempio:

• Abilitare opzioni di compilazione dedicate per un pacchetto software.
• Aggiungere moduli o estensioni non inclusi di default in ServBay (come nuove estensioni PHP o moduli PostgreSQL).
• Compilare utilizzando librerie diverse da quelle predefinite di ServBay.
• Personalizzare i pacchetti forniti da ServBay con modifiche mirate.

ServBay mette a disposizione l’ambiente di compilazione e la toolchain necessari per gestire agevolmente queste operazioni di ricompilazione.

Per ricompilare correttamente, è necessaria una conoscenza di base dei processi di compilazione specifici del sistema operativo utilizzato:

• macOS/Linux: toolchain Unix/Linux (configure, make, make install, ecc.)
• Windows: sistema di build Visual Studio, MSBuild, cmake e simili

Prerequisiti

Prima di procedere con la ricompilazione, assicurati di soddisfare i seguenti requisiti:

1. Installazione della ServBay Development Library: Questo è un elemento fondamentale. Il pacchetto include tutte le librerie, i file header e le risorse di sviluppo necessari per la compilazione nella tua infrastruttura ServBay. Puoi trovarlo e installarlo dalla sezione Pacchetti dell'interfaccia ServBay.

   

2. Installazione degli strumenti di sviluppo:

   macOS

   Installa Xcode Command Line Tools: Il set di strumenti essenziale fornito da macOS, include compilatore (Clang), linker e altri strumenti necessari. Avvia il Terminale ed esegui:

   xcode-select --install

   Se è già installato, il sistema lo segnalerà.

   Installa strumenti di compilazione aggiuntivi: Per compilare software open source, occorrono anche autoconf, automake, libtool, ecc. Generalmente si installano tramite Homebrew:

   brew install autoconf automake libtool cmake

   Se Homebrew non è presente, consulta le istruzioni sul sito ufficiale per l’installazione.

   Windows

   Installa Visual Studio Build Tools o Visual Studio Community: Su Windows sono richiesti il compilatore Microsoft Visual C++ e altri strumenti di build. Scegli una delle seguenti modalità:

   Opzione 1: Visual Studio Build Tools (consigliata, più leggera)

   1. Scarica e installa Visual Studio Build Tools
   2. Durante l’installazione, seleziona il carico di lavoro "C++ build tools"
   3. Verifica però che siano inclusi:
      • MSVC v143 - VS 2022 C++ x64/x86 Build Tools
      • SDK Windows 11 (ultima versione)
      • Tool CMake

   Opzione 2: Visual Studio Community

   1. Scarica e installa Visual Studio Community
   2. Seleziona "Sviluppo desktop con C++" tra i carichi di lavoro
   3. Assicurati che sia presente sia CMake sia il Windows SDK

   Installa strumenti supplementari: Per alcuni progetti open source possono servire:

   • Git for Windows: per scaricare il codice sorgente
   • MSYS2 o vcpkg: per la gestione delle dipendenze C/C++
   • Python: alcuni script di build lo richiedono

   # Installazione rapida dei tool supplementari (opzionale) con chocolatey
   choco install git cmake python msys2

Configurazione dell’ambiente di compilazione

Dopo aver installato la ServBay Development Library e gli strumenti necessari, occorre inizializzare l’ambiente di compilazione: questa fase serve a impostare una serie di variabili d’ambiente che indirizzano compilatori e sistemi di build verso le librerie, gli header e i binari ServBay, assicurando che dipendenze e collegamenti siano gestiti correttamente.

La configurazione varia secondo sistema operativo e architettura:

macOS

L’ambiente ServBay è distinto tra CPU Intel (x86_64) e Apple Silicon (Arm64). Scegli il comando di inizializzazione corrispondente alla Runtime ServBay attuale.

Windows

Su Windows, ServBay supporta l’architettura x64 e viene installato in C:\ServBay.

Verifica dell’architettura della CPU di ServBay Runtime

macOS

Puoi individuare l’architettura di ServBay controllando un eseguibile nella directory bin, ad esempio bison:

Arm64 (Apple Silicon)

# Esegui il seguente comando nel terminale per controllare
$ file /Applications/ServBay/bin/bison
/Applications/ServBay/bin/bison: Mach-O 64-bit executable arm64

x86_64 (Intel)

# Esegui il seguente comando nel terminale per controllare
$ file /Applications/ServBay/bin/bison
/Applications/ServBay/bin/bison: Mach-O 64-bit executable x86_64

Windows

Su Windows ServBay supporta x64; puoi controllare tramite PowerShell:

# Esegui in PowerShell per controllare
PS> Get-Command "C:\ServBay\bin\bison.exe" | Select-Object -ExpandProperty FileVersionInfo | Select-Object ProductName, FileDescription

Oppure, verifica tramite le proprietà del file.

Identificata l’architettura, scegli lo script di inizializzazione ambiente corrispondente.

Inizializzazione delle variabili d’ambiente di compilazione

Scegli lo script di inizializzazione ambiente adatto al tuo sistema operativo e architettura.

macOS

Apri un nuovo terminale, copia e incolla lo script sotto, in base all’architettura CPU. Il processo imposta tutti i path e i flag necessari per la compilazione con ServBay.

Arm64 (Apple Silicon)

# Imposta il numero di core CPU per la compilazione parallela
CPU_NUMBER=$(sysctl -n hw.ncpu)
# Percorsi base d'installazione ServBay
SERVBAY_BASE_FULL_PATH="/Applications/ServBay"
SERVBAY_PACKAGE_DIR_NAME="package"
SERVBAY_PACKAGE_FULL_PATH="${SERVBAY_BASE_FULL_PATH}/${SERVBAY_PACKAGE_DIR_NAME}"
# Percorsi binari ServBay
SERVBAY_BIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/bin"
SERVBAY_SBIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/sbin"
# Percorsi config, dati, librerie
SERVBAY_ETC_PATH="${SERVBAY_PACKAGE_FULL_PATH}/etc"
SERVBAY_VAR_PATH="${SERVBAY_PACKAGE_FULL_PATH}/var"
SERVBAY_COMMON_PATH="${SERVBAY_PACKAGE_FULL_PATH}/common"
SERVBAY_COMMON_INCLUDE_PATH="${SERVBAY_COMMON_PATH}/include"
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"
SERVBAY_BUILD_DIR=$(pwd)
SERVBAY_BUILD_SRC_DIR=${SERVBAY_BUILD_DIR}/src
# Info versione OpenSSL
OPENSSL_SELECTED_VERSION="3.2"
OPENSSL_VERSION="3.2.1"
# Versione minima OS target
BUILD_OS_MIN_VERSION="12.00" # Monterey o superiore
BUILD_CPU_ARCH="-arch arm64"
BUILD_CPU_ARCH_CMAKE="arm64"
BUILD_MACOS_TARGET=""
# Flag compilatore C: livello ottimizzazione, versione, architettura
export CFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# Flag linker: rpath, percorsi librerie, versione, architettura
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}"
# Flag preprocessore e CXX: master-header
export CPPFLAGS="-I${SERVBAY_COMMON_INCLUDE_PATH}"
export CXXFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
# PATH prioritario
export PATH="${SERVBAY_BIN_PATH}:${SERVBAY_SBIN_PATH}:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin"
# Percorso pkg-config
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"
# PATH supplementare
export PATH=$PATH:"/usr/local/bin:/usr/local/sbin"
export PATH=$PATH:"/opt/homebrew/bin/"
# Includi librerie/headers OpenSSL
export LDFLAGS="-L${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib ${LDFLAGS}"
export CPPFLAGS="-I${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/include ${CPPFLAGS}"
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"
echo "Ambiente di compilazione ServBay Arm64 pronto."

x86_64 (Intel)

# Imposta il numero di core CPU per la compilazione parallela
CPU_NUMBER=$(sysctl -n hw.ncpu)
# Percorsi base d'installazione ServBay
SERVBAY_BASE_FULL_PATH="/Applications/ServBay"
SERVBAY_PACKAGE_DIR_NAME="package"
SERVBAY_PACKAGE_FULL_PATH="${SERVBAY_BASE_FULL_PATH}/${SERVBAY_PACKAGE_DIR_NAME}"
# Percorsi binari ServBay
SERVBAY_BIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/bin"
SERVBAY_SBIN_PATH="${SERVBAY_PACKAGE_FULL_PATH}/sbin"
# Percorsi config, dati, librerie
SERVBAY_ETC_PATH="${SERVBAY_PACKAGE_FULL_PATH}/etc"
SERVBAY_VAR_PATH="${SERVBAY_PACKAGE_FULL_PATH}/var"
SERVBAY_COMMON_PATH="${SERVBAY_PACKAGE_FULL_PATH}/common"
SERVBAY_COMMON_INCLUDE_PATH="${SERVBAY_COMMON_PATH}/include"
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"
SERVBAY_BUILD_DIR=$(pwd)
SERVBAY_BUILD_SRC_DIR=${SERVBAY_BUILD_DIR}/src
OPENSSL_SELECTED_VERSION="1.1.1u"
OPENSSL_VERSION="1.1.1u"
BUILD_OS_MIN_VERSION="12.00"
BUILD_CPU_ARCH="-arch x86_64"
BUILD_CPU_ARCH_CMAKE="x86_64"
BUILD_MACOS_TARGET="-target x86_64-apple-macos${BUILD_OS_MIN_VERSION}"
export CFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
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}"
export CPPFLAGS="-I${SERVBAY_COMMON_INCLUDE_PATH}"
export CXXFLAGS="-Qunused-arguments -O3 -mmacosx-version-min=${BUILD_OS_MIN_VERSION} ${BUILD_CPU_ARCH} ${BUILD_MACOS_TARGET}"
export PATH="${SERVBAY_BIN_PATH}:${SERVBAY_SBIN_PATH}:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin"
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"
export PATH=$PATH:"/usr/local/bin:/usr/local/sbin"
export PATH=$PATH:"/opt/homebrew/bin/"
export LDFLAGS="-L${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/lib ${LDFLAGS}"
export CPPFLAGS="-I${SERVBAY_COMMON_PATH}/openssl/${OPENSSL_SELECTED_VERSION}/include ${CPPFLAGS}"
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"
echo "Ambiente di compilazione ServBay x86_64 pronto."

Windows

Su Windows, configura le variabili d'ambiente in PowerShell o nel Developer Command Prompt. Utilizza lo script sottostante per architettura x64:

# Imposta il numero di core CPU per la compilazione parallela
$CPU_NUMBER = (Get-WmiObject -Class Win32_Processor).NumberOfLogicalProcessors

# Percorso base ServBay (Windows)
$SERVBAY_BASE_FULL_PATH = "C:\ServBay"
$SERVBAY_PACKAGE_DIR_NAME = "package"
$SERVBAY_PACKAGE_FULL_PATH = "${SERVBAY_BASE_FULL_PATH}\${SERVBAY_PACKAGE_DIR_NAME}"
$SERVBAY_BIN_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\bin"
$SERVBAY_SBIN_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\sbin"
$SERVBAY_ETC_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\etc"
$SERVBAY_VAR_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\var"
$SERVBAY_COMMON_PATH = "${SERVBAY_PACKAGE_FULL_PATH}\common"
$SERVBAY_COMMON_INCLUDE_PATH = "${SERVBAY_COMMON_PATH}\include"
$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"
$SERVBAY_BUILD_DIR = Get-Location
$SERVBAY_BUILD_SRC_DIR = "${SERVBAY_BUILD_DIR}\src"
$OPENSSL_SELECTED_VERSION = "3.2"
$OPENSSL_VERSION = "3.2.1"
$BUILD_PLATFORM = "x64"
$BUILD_CONFIG = "Release"
$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
$env:PATH = "${SERVBAY_BIN_PATH};${SERVBAY_SBIN_PATH};$env:PATH"
$env:INCLUDE = "${SERVBAY_COMMON_INCLUDE_PATH};$env:INCLUDE"
$env:LIB = "${SERVBAY_COMMON_LIB_PATH};$env:LIB"
$env:LIBPATH = "${SERVBAY_COMMON_LIB_PATH};$env:LIBPATH"
$env:PKG_CONFIG_PATH = "${SERVBAY_COMMON_LIB_PATH}\pkgconfig"
$env:INCLUDE = "${SERVBAY_COMMON_PATH}\openssl\${OPENSSL_SELECTED_VERSION}\include;$env:INCLUDE"
$env:LIB = "${SERVBAY_COMMON_PATH}\openssl\${OPENSSL_SELECTED_VERSION}\lib;$env:LIB"
$env:CMAKE_PREFIX_PATH = $SERVBAY_COMMON_PATH
$env:CMAKE_INSTALL_PREFIX = $SERVBAY_COMMON_PATH
Write-Host "Ambiente di compilazione ServBay Windows x64 pronto."

Se utilizzi Developer Command Prompt, puoi anche impiegare uno script batch:

@echo off
REM Configura l'ambiente di compilazione ServBay Windows

REM Percorso base installazione ServBay
set SERVBAY_BASE_FULL_PATH=C:\ServBay
set SERVBAY_PACKAGE_FULL_PATH=%SERVBAY_BASE_FULL_PATH%\package

REM Path ServBay
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 Versione OpenSSL
set OPENSSL_SELECTED_VERSION=3.2

REM Imposta variabili d'ambiente
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 Ambiente di compilazione ServBay Windows pronto.

Nota importante: Queste variabili d’ambiente funzioneranno solo nella sessione terminale corrente. Alla chiusura della finestra o apertura di una nuova, dovrai rieseguire lo script.

Esempi di compilazione

Con l’ambiente predisposto, puoi ora scaricare il codice sorgente e compilare. Di seguito alcuni esempi standard di compilazione multipiattaforma.

Compilazione di ImageMagick

ImageMagick è una potente libreria per l’elaborazione di immagini, dipendenza critica dell’estensione PHP imagick. ServBay include ImageMagick di default, quindi la compilazione manuale è di solito superflua; quest’esempio serve solo a mostrare il processo.

macOS / Linux

1. Scarica il codice sorgente ImageMagick e decomprimilo:

   # Sostituisci col numero di versione desiderato
   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. Esegui lo script ./configure: Utilizzando le variabili d’ambiente configurate, esegui il configure. Gli argomenti --prefix, --libdir, --includedir ecc. puntano alla ServBay Development Library, così le librerie e gli headers saranno correttamente riconosciuti da ServBay e moduli PHP. Gli altri flag vanno impostati secondo le esigenze di ImageMagick.

   ./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. Esegui make e make install: make compila i file secondo la configurazione, usando -j ${CPU_NUMBER} per il multithreading. make install installa il prodotto nella ServBay Development Library.

   make -j ${CPU_NUMBER}
   make install

Windows

Su Windows, ImageMagick di solito si compila con Visual Studio o CMake; visto che la compilazione nativa può essere complessa, si consiglia CMake:

1. Scarica il codice sorgente ImageMagick:

   # Usa curl o scarica via browser
   curl -O https://imagemagick.org/archive/releases/ImageMagick-7.1.1-33.tar.gz
   # Decomprimere (richiede 7zip o simili)
   tar -xzf ImageMagick-7.1.1-33.tar.gz
   cd ImageMagick-7.1.1-33

2. Configura con CMake (in Developer Command Prompt o PowerShell):

   # Crea la cartella di build
   mkdir builddir
   cd builddir
   
   # Configura il progetto con CMake
   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. Compila e installa:

   # Compilazione
   cmake --build . --config Release --parallel $CPU_NUMBER
   # Installazione
   cmake --install . --config Release

Compilazione di pacchetti con cmake

Per pacchetti che usano il sistema di build cmake, il procedimento è uniforme su diversi sistemi. Qui di seguito l’esempio con protobuf (Protocol Buffers).

1. Scarica il codice sorgente protobuf ed entra nella cartella dedicata.

macOS / Linux

2. Configura il progetto con cmake: -S . indica che il sorgente è la cartella corrente, -B builddir specifica la cartella di build; -DCMAKE_INSTALL_PREFIX e altri argomenti portano all’installazione nella ServBay Development Library. I restanti flag sono tipici per protobuf. -DCMAKE_MACOSX_RPATH e -DCMAKE_INSTALL_RPATH assicurano la corretta localizzazione delle librerie addizionali.

   # In cartella sorgente protobuf
   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. Esegui cmake --build e cmake --install: Compilazione e installazione nella folder configurata con DCMAKE_INSTALL_PREFIX.

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

Windows

2. Configura il progetto con cmake (in PowerShell o Developer Command Prompt):

   # In cartella sorgente protobuf
   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. Compila e installa:

   # Compilazione
   cmake --build builddir --config Release --parallel $CPU_NUMBER
   # Installazione
   cmake --install builddir --config Release

Compilazione di moduli PHP

Se vuoi compilare estensioni aggiuntive per una versione PHP presente in ServBay (es. swoole, redis, mongodb ecc.), consulta la guida dedicata:

Come compilare moduli PHP

Compilazione di moduli PostgreSQL

Per aggiungere moduli supplementari a una versione di PostgreSQL in ServBay, consulta la documentazione specifica:

Come compilare moduli PostgreSQL

Conclusione

Grazie alla ServBay Development Library e alla precisa configurazione delle variabili d’ambiente, gli sviluppatori possono ricompilare e personalizzare pacchetti software su macOS e Windows in modo semplice. Questo porta grande flessibilità nel gestire esigenze progettuali specifiche e adottare le ultime versioni delle librerie.

Punti chiave

• Supporto multipiattaforma: ServBay offre ambienti di compilazione sia per macOS sia per Windows
• Differenza dei percorsi: Attenzione ai path d’installazione (macOS: /Applications/ServBay, Windows: C:\ServBay)
• Differenza toolchain: macOS usa Xcode Command Line Tools, Windows Visual Studio Build Tools
• Configurazione ambiente: Scegli sempre lo script di variabili d’ambiente adatto alla piattaforma

Attenzione

• Consulta sempre le guide ufficiali di compilazione del pacchetto
• Adatta configurazione e procedure in base alle caratteristiche della piattaforma target
• Su Windows è consigliata la costruzione via CMake
• Alcuni software open source potrebbero avere requisiti e dipendenze di compilazione diversi tra piattaforme

Seguendo questa guida, potrai compilare correttamente pacchetti nell’ambiente ServBay sia su macOS che su Windows.