# Try to find/download a C++ Arrow binary,

"${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" "tools/nixlibs.R" $VERSION

# If binary not found, script exits nonzero

if [ $? -ne 0 ]; then

_LIBARROW_FOUND="false"

echo "Arrow C++ library was not found"

# return 0 so set -e doesn't exit the script

return 0

fi

OPENSSL_LIBS="-lcrypto -lcrypt32"

MIMALLOC_LIBS="-lbcrypt -lpsapi"

BROTLI_LIBS="-lbrotlienc -lbrotlidec -lbrotlicommon" # Common goes last since dec and enc depend on it

# We build aws-sdk-cpp bundled now, so the AWS libs are included in arrow_bundled_dependencies

# but we also need to include these Windows system libraries

AWS_LIBS="-luserenv -lversion -lws2_32 -lbcrypt -lwininet -lwinhttp -lsecur32 -lshlwapi -lncrypt"

# pkg-config --libs libcurl

GCS_LIBS="-lcurl -lnormaliz -lssh2 -lgdi32 -lssl -lcrypto -lcrypt32 -lwldap32 \

# AZURE_LIBS="-lcurl -lssl -lxml2"

# Set the right flags to point to and enable arrow/parquet

if [ -d "windows/r-libarrow-windows-x86_64-$VERSION" ]; then

RWINLIB="../windows/r-libarrow-windows-x86_64-$VERSION"

else

# It's possible that the version of the libarrow binary is not identical to the

# R version, e.g. if the R build is a patch release, so find what the dir is

# actually called. If there is more than one version present, use the one

# with the highest version:

RWINLIB="../windows/$(ls windows/ | grep ^r-libarrow- | tail -n 1)"

fi

# NOTE: If you make changes to the libraries below, you should also change

# ci/scripts/r_windows_build.sh and ci/scripts/PKGBUILD

PKG_CFLAGS="-I${RWINLIB}/include -DARROW_STATIC -DARROW_COMPUTE_STATIC -DPARQUET_STATIC \

-DARROW_R_WITH_S3 -DARROW_R_WITH_GCS" # -DARROW_R_WITH_AZURE

PKG_LIBS="-L${RWINLIB}/lib"'$(subst gcc,,$(COMPILED_BY))$(R_ARCH) '

PKG_LIBS="$PKG_LIBS -L${RWINLIB}/lib"'$(R_ARCH)$(CRT) '

PKG_LIBS="$PKG_LIBS -larrow_dataset -larrow_acero -lparquet -larrow_compute -larrow_s3 -larrow -larrow_bundled_dependencies \

${MIMALLOC_LIBS} ${OPENSSL_LIBS} -lre2 ${AWS_LIBS} ${GCS_LIBS}" # ${AZURE_LIBS}

set_lib_dir_with_pc

# Check cmake options for enabled features. This uses LIB_DIR that

# is set by the above set_lib_dir_* call.

add_feature_flags

set_pkg_vars_with_pc

# Set any user-defined CXXFLAGS

if [ "$ARROW_R_CXXFLAGS" ]; then

PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"

fi

pkg_config_names="${PKG_CONFIG_NAME} ${PKG_CONFIG_NAMES_FEATURES}"

PKG_CFLAGS="`${PKG_CONFIG} --cflags ${pkg_config_names}` $PKG_CFLAGS"

PKG_CFLAGS="$PKG_CFLAGS $PKG_CFLAGS_FEATURES"

PKG_LIBS=`${PKG_CONFIG} --libs-only-l --libs-only-other ${pkg_config_names}`

PKG_LIBS="$PKG_LIBS $PKG_LIBS_FEATURES"

PKG_DIRS=`${PKG_CONFIG} --libs-only-L ${pkg_config_names}`

PKG_CFLAGS_FEATURES=""

PKG_CONFIG_NAMES_FEATURES=""

PKG_LIBS_FEATURES=""

PKG_LIBS_FEATURES_WITHOUT_PC=""

# Now we need to check what features it was built with and enable

# the corresponding feature flags in the R bindings (-DARROW_R_WITH_stuff).

# We do this by inspecting ArrowOptions.cmake, which the libarrow build

# generates.

ARROW_OPTS_CMAKE="$LIB_DIR/cmake/Arrow/ArrowOptions.cmake"

if [ ! -f "${ARROW_OPTS_CMAKE}" ]; then

echo "*** $ARROW_OPTS_CMAKE not found; some features will not be enabled"

else

if arrow_built_with ARROW_PARQUET; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_PARQUET"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES parquet"

PKG_LIBS_FEATURES_WITHOUT_PC="-lparquet $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: parquet is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

if arrow_built_with ARROW_COMPUTE; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_COMPUTE"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-compute"

PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_compute $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: arrow_compute is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

if arrow_built_with ARROW_DATASET; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_DATASET"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-dataset"

PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_dataset $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: arrow_dataset is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

if arrow_built_with ARROW_ACERO; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_ACERO"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-acero"

PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_acero $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: arrow_acero is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

if arrow_built_with ARROW_SUBSTRAIT; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_SUBSTRAIT"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-substrait"

PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_substrait $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: arrow_substrait is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

if arrow_built_with ARROW_JSON; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_JSON"

fi

if arrow_built_with ARROW_S3; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_S3"

PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-s3"

PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_s3 $PKG_LIBS_FEATURES_WITHOUT_PC"

# NOTE: arrow_s3 is assumed to have the same -L flag as arrow

# so there is no need to add its location to PKG_DIRS

fi

# if arrow_built_with ARROW_AZURE; then

# PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_AZURE"

# PKG_LIBS_FEATURES="$PKG_LIBS_FEATURES -lxml2"

# fi

if arrow_built_with ARROW_GCS; then

PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_GCS"

fi

if arrow_built_with ARROW_GCS || arrow_built_with ARROW_S3; then

# If pkg-config is available it will handle this for us automatically

SSL_LIBS_WITHOUT_PC="-lcurl -lssl -lcrypto"

fi

fi

# Use pkg-config to find arrow from rtools

_LIBARROW_PREFIX="`${PKG_CONFIG} --variable=prefix ${PKG_CONFIG_NAME}`"

_LIBARROW_FOUND="true"

echo "*** Trying Arrow C++ found by pkg-config: $_LIBARROW_PREFIX"

PC_LIB_VERSION=`${PKG_CONFIG} --modversion ${PKG_CONFIG_NAME}`

# This is in an R script for convenience and testability.

# Success means the found C++ library is ok to use.

# Error means the versions don't line up and we shouldn't use it.

# More specific messaging to the user is in the R script

if ! ${R_HOME}/bin/Rscript tools/check-versions.R $VERSION $PC_LIB_VERSION 2> /dev/null; then

_LIBARROW_FOUND="false"

fi

# We should have a valid libarrow build in $_LIBARROW_FOUND

if [ "$_LIBARROW_FOUND" == "true" ]; then

set_pkg_vars ${_LIBARROW_PREFIX}

# add mingw specific windows flags

PKG_LIBS="$PKG_LIBS -lws2_32 -lole32 -lwldap32 -lsecur32 -lncrypt -lcrypt32 -lshlwapi"

# override -fno-exceptions from aws-cpp-sdk pc file

PKG_CFLAGS="$PKG_CFLAGS -fexceptions"

# To make it easier to debug which code path was taken add a specific

# message to the log in addition to the 'NOTE'

echo "*** Failed to find Arrow C++ libraries in rtools"

if [ "$ARROW_USE_PKG_CONFIG" != "false" ] && $PKG_CONFIG --exists $PKG_CONFIG_NAME; then

configure_rtools

else

configure_binaries

fi

if [ "$_LIBARROW_FOUND" == "false" ]; then

echo "------------------------- NOTE ---------------------------"

echo "There was an issue preparing the Arrow C++ libraries."

echo "See https://arrow.apache.org/docs/r/articles/install.html"

echo "----------------------------------------------------------"

exit 1

fi

echo "*** Using locally built Arrow at $ARROW_HOME"

RWINLIB=$(cygpath $ARROW_HOME)

export PKG_CONFIG_PATH=$(cygpath $ARROW_HOME)/lib/pkgconfig:$(cygpath $MSYSTEM_PREFIX)/lib

PKG_CONFIG_PACKAGES="arrow"

PKG_CFLAGS=""

if [ $(cmake_option ARROW_PARQUET) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_PARQUET"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES parquet"

fi

if [ $(cmake_option ARROW_COMPUTE) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_COMPUTE"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES arrow-compute"

fi

if [ $(cmake_option ARROW_ACERO) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_ACERO"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES arrow-acero"

fi

if [ $(cmake_option ARROW_DATASET) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_DATASET"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES arrow-dataset"

fi

if [ $(cmake_option ARROW_S3) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_S3"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES arrow-s3"

fi

if [ $(cmake_option ARROW_GCS) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_GCS"

fi

# if [ $(cmake_option ARROW_AZURE) -eq 1 ]; then

# PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_AZURE"

# fi

if [ $(cmake_option ARROW_JSON) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_JSON"

fi

if [ $(cmake_option ARROW_SUBSTRAIT) -eq 1 ]; then

PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_SUBSTRAIT"

PKG_CONFIG_PACKAGES="$PKG_CONFIG_PACKAGES arrow-substrait"

fi

PKG_CFLAGS="$(pkg-config --cflags $PKG_CONFIG_PACKAGES) $PKG_CFLAGS"

PKG_LIBS=$(pkg-config --libs $PKG_CONFIG_PACKAGES)