r/configure

#!/bin/sh

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

# Anticonf (tm) script by Jeroen Ooms, Jim Hester (2017)
# License: MIT
#
# This script will query 'pkg-config' for the required cflags and ldflags.
# If pkg-config is unavailable or does not find the library, try setting
# INCLUDE_DIR and LIB_DIR manually via e.g:
# R CMD INSTALL --configure-vars='INCLUDE_DIR=/.../include LIB_DIR=/.../lib'

# Library settings
PKG_CONFIG_NAME="arrow parquet arrow-dataset"
PKG_DEB_NAME="(unsuppored)"
PKG_RPM_NAME="(unsuppored)"
PKG_BREW_NAME="apache-arrow"
PKG_TEST_HEADER="<arrow/api.h>"
# These must be the same order as $(pkg-config --libs arrow-dataset)
PKG_LIBS="-larrow_dataset -lparquet -larrow"

# Make some env vars case-insensitive
ARROW_R_DEV=`echo $ARROW_R_DEV | tr '[:upper:]' '[:lower:]'`
LOCAL_AUTOBREW=`echo $LOCAL_AUTOBREW | tr '[:upper:]' '[:lower:]'`
FORCE_AUTOBREW=`echo $FORCE_AUTOBREW | tr '[:upper:]' '[:lower:]'`
ARROW_USE_PKG_CONFIG=`echo $ARROW_USE_PKG_CONFIG | tr '[:upper:]' '[:lower:]'`

VERSION=`grep ^Version DESCRIPTION | sed s/Version:\ //`
UNAME=`uname -s`

# generate code
if [ "$ARROW_R_DEV" = "true" ]; then
  echo "*** Generating code with data-raw/codegen.R"
  ${R_HOME}/bin/Rscript data-raw/codegen.R
fi

if [ "$LOCAL_AUTOBREW" = "true" ]; then
  # LOCAL_AUTOBREW means use the script in tools/
  # If you want to use a local apache-arrow.rb formula, do:
  # $ cp ../dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb tools/apache-arrow.rb
  # before R CMD build (assuming a local checkout of the apache/arrow repository)
  # FORCE_AUTOBREW without LOCAL_AUTOBREW means to pull from jeroen.github.io
  cp tools/autobrew .
  cp tools/apache-arrow.rb .
  FORCE_AUTOBREW="true"
  ARROW_USE_PKG_CONFIG="false"
fi

# Note that cflags may be empty in case of success
if [ "$INCLUDE_DIR" ] || [ "$LIB_DIR" ]; then
  echo "*** Using INCLUDE_DIR/LIB_DIR"
  PKG_CFLAGS="-I$INCLUDE_DIR $PKG_CFLAGS"
  PKG_LIBS="-L$LIB_DIR $PKG_LIBS"
else
  # Use pkg-config if available and allowed
  pkg-config --version >/dev/null 2>&1
  if [ "$ARROW_USE_PKG_CONFIG" != "false" ] && [ $? -eq 0 ]; then
    PKGCONFIG_CFLAGS=`pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}`
    PKGCONFIG_LIBS=`pkg-config --libs --silence-errors ${PKG_CONFIG_NAME}`
  fi

  if [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then
    echo "*** Arrow C++ libraries found via pkg-config"
    PKG_CFLAGS="$PKGCONFIG_CFLAGS"
    PKG_LIBS=${PKGCONFIG_LIBS}

    # Check for version mismatch
    PC_LIB_VERSION=`pkg-config --modversion arrow`
    echo $PC_LIB_VERSION | grep -e 'SNAPSHOT$' >/dev/null 2>&1
    # If on a release (i.e. not SNAPSHOT) and version != R package version, warn
    if [ $? -eq 1 ] && [ "$PC_LIB_VERSION" != "$VERSION" ]; then
      echo "**** Warning: library version mismatch"
      echo "**** C++ is $PC_LIB_VERSION but R is $VERSION"
      echo "**** If installation fails, upgrade the C++ library to match"
      echo "**** or retry with ARROW_USE_PKG_CONFIG=false"
    fi
  else
    if [ "$UNAME" = "Darwin" ]; then
      if [ "$FORCE_AUTOBREW" != "true" ] && [ "`command -v brew`" ] && [ "`brew ls --versions ${PKG_BREW_NAME}`" != "" ]; then
        echo "*** Using Homebrew ${PKG_BREW_NAME}"
        BREWDIR=`brew --prefix`
      else
        echo "*** Downloading ${PKG_BREW_NAME}"
        if [ -f "autobrew" ]; then
          echo "**** Using local manifest for ${PKG_BREW_NAME}"
        else
          curl -sfL "https://jeroen.github.io/autobrew/$PKG_BREW_NAME" > autobrew
          if [ $? -ne 0 ]; then
            echo "Failed to download manifest for ${PKG_BREW_NAME}"
          fi
        fi
        . autobrew
        if [ $? -ne 0 ]; then
          echo "Failed to retrieve binary for ${PKG_BREW_NAME}"
        fi
      fi
      PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include"
      PKG_LIBS="-L$BREWDIR/opt/$PKG_BREW_NAME/lib $PKG_LIBS"
    elif [ "$UNAME" = "Linux" ]; then
      # Set some default values/backwards compatibility
      if [ "${LIBARROW_DOWNLOAD}" = "" ] && [ "${NOT_CRAN}" != "" ]; then
        LIBARROW_DOWNLOAD=$NOT_CRAN; export LIBARROW_DOWNLOAD
      fi
      if [ "${LIBARROW_BINARY}" = "" ] && [ "${LIBARROW_DOWNLOAD}" != "" ]; then
        LIBARROW_BINARY=$LIBARROW_DOWNLOAD; export LIBARROW_BINARY
      fi
      if [ "${LIBARROW_MINIMAL}" = "" ] && [ "${LIBARROW_DOWNLOAD}" = "true" ]; then
        LIBARROW_MINIMAL=false; export LIBARROW_MINIMAL
      fi
      if [ "${LIBARROW_MINIMAL}" = "" ] && [ "${NOT_CRAN}" = "true" ]; then
        LIBARROW_MINIMAL=false; export LIBARROW_MINIMAL
      fi
      ${R_HOME}/bin/Rscript tools/linuxlibs.R $VERSION
      PKG_CFLAGS="-I$(pwd)/libarrow/arrow-${VERSION}/include $PKG_CFLAGS"
      # Also enumerate the static libs (technically repeating arrow libs so they're in the right order)
      # TODO: there must be a better way; also what about non-bundled deps?
      BUNDLED_LIBS=`cd libarrow/arrow-${VERSION}/lib && ls *.a`
      BUNDLED_LIBS=`echo $BUNDLED_LIBS | sed -E "s/lib(.*)\.a/-l\1/" | sed -e "s/\\.a lib/ -l/g"`
      PKG_LIBS="-L$(pwd)/libarrow/arrow-${VERSION}/lib $PKG_LIBS $BUNDLED_LIBS"
    fi
  fi
fi

# Find compiler
CXXCPP="`${R_HOME}/bin/R CMD config CXX11` -E"
CXX11FLAGS=`"${R_HOME}"/bin/R CMD config CXX11FLAGS`
CXX11STD=`"${R_HOME}"/bin/R CMD config CXX11STD`
CPPFLAGS=`"${R_HOME}"/bin/R CMD config CPPFLAGS`

# If libarrow uses the old GLIBCXX ABI, so we have to use it too
if [ "$ARROW_USE_OLD_CXXABI" ]; then
  PKG_CFLAGS="$PKG_CFLAGS -D_GLIBCXX_USE_CXX11_ABI=0"
fi

# Set any user-defined CXXFLAGS
if [ "$ARROW_R_CXXFLAGS" ]; then
  PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"
fi

# Test configuration
TEST_CMD="${CXXCPP} ${CPPFLAGS} ${PKG_CFLAGS} ${CXX11FLAGS} ${CXX11STD} -xc++ -"
echo "#include $PKG_TEST_HEADER" | ${TEST_CMD} >/dev/null 2>&1

if [ $? -eq 0 ] || [ "$UNAME" = "Darwin" ]; then
  # Always build with arrow on macOS
  PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_ARROW"
  echo "PKG_CFLAGS=$PKG_CFLAGS"
  echo "PKG_LIBS=$PKG_LIBS"
else
  if [ "$UNAME" = "Darwin" ]; then
    # Just for debugging: is this possible?
    echo "Test to load header failed. Command:"
    echo "$TEST_CMD"
  fi
  echo "------------------------- NOTE ---------------------------"
  echo "After installation, please run arrow::install_arrow()"
  echo "for help installing required runtime libraries"
  echo "---------------------------------------------------------"
  PKG_LIBS=""
  PKG_CFLAGS=""
fi

# Write to Makevars
sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars

# Success
exit 0