aclocal.m4

#=========================================================================
# Local Autoconf Macros
#=========================================================================
# This file contains the macros for the Modular C++ Build System and
# additional autoconf macros which developers can use in their
# configure.ac scripts. Please read the documentation in
# mcppbs-uguide.txt for more details on how the Modular C++ Build
# System works. The documenation for each macro should include
# information about the author, date, and copyright.

#-------------------------------------------------------------------------
# MCPPBS_INIT
#-------------------------------------------------------------------------
# Setup any global configure command line arguments and the primary
# running shell variables which will be substituted into the makefile.

AC_DEFUN([MCPPBS_INIT],
[
  # Add command line argument to enable all optional subprojects

  AC_ARG_WITH(optional-subprojects,
    AS_HELP_STRING([--with-optional-subprojects],
      [Include all optional subprojects]))

  # Running variables to substitute into make

  AC_SUBST([mcppbs_include_internal])
  AC_SUBST([mcppbs_include_internal_en])
  AC_SUBST([mcppbs_include_external])
  AC_SUBST([mcppbs_include_external_en])
  AC_SUBST([mcppbs_install])
])

#-------------------------------------------------------------------------
# MCPPBS_ALWAYS_USE_CXX
#-------------------------------------------------------------------------
# If the user calls this macro then change the C compiler shell
# variables so that they use the C++ compiler.

AC_DEFUN([MCPPBS_ALWAYS_USE_CXX],
[
  AC_MSG_NOTICE([Will use ${CXX} for C and assembly source files])
  CC=${CXX}
  CFLAGS=${CXXFLAGS}
])

#-------------------------------------------------------------------------
# MCPPBS_PROG_INSTALL
#-------------------------------------------------------------------------
# This macro will add an --enable-stow command line option to the
# configure script. When enabled, this macro will first check to see if
# the stow program is available and if so it will set the $stow shell
# variable to the binary name and the $enable_stow shell variable to
# "yes". These variables can be used in a makefile to conditionally use
# stow for installation.
#
# This macro uses two environment variables to help setup default stow
# locations. The $STOW_PKGS_PREFIX is used for stowing native built
# packages. The packages are staged in $STOW_PKGS_PREFIX/pkgs and then
# symlinks are created from within $STOW_PKGS_PREFIX into the pkgs
# subdirectory. If you only do native builds then this is all you need to
# set. If you don't set $STOW_PKGS_PREFIX then the default is just the
# normal default prefix which is almost always /usr/local.
#
# For non-native builds we probably want to install the packages in a
# different location which includes the host architecture name as part of
# the prefix. For these kind of builds, we can specify the $STOW_PKGS_ROOT
# environment variable and the effective prefix will be
# $STOW_PKGS_ROOT/${host_alias} where ${host_alias} is specified on the
# configure command line with "--host".
#
# Here is an example setup:
#
#  ARCH="i386-macosx10.4"
#  STOW_PKGS_ROOT="${HOME}/install/stow-pkgs"
#  STOW_PKGS_PREFIX="${STOW_PKGS_ROOT}/${ARCH}"
#

AC_DEFUN([MCPPBS_PROG_INSTALL],
[

  # Configure command line option

  AC_ARG_ENABLE(stow,
    AS_HELP_STRING(--enable-stow,[Enable stow-based install]),
      [enable_stow="yes"],[enable_stow="no"])

  AC_SUBST([enable_stow])

  # Environment variables

  AC_ARG_VAR([STOW_PKGS_ROOT],   [Root for non-native stow-based installs])
  AC_ARG_VAR([STOW_PKGS_PREFIX], [Prefix for stow-based installs])

  # Check for install script

  AC_PROG_INSTALL

  # Deterimine if native build and set prefix appropriately

  AS_IF([ test "${enable_stow}" = "yes" ],
  [
    AC_CHECK_PROGS([stow],[stow],[no])
    AS_IF([ test "${stow}" = "no" ],
    [
      AC_MSG_ERROR([Cannot use --enable-stow since stow is not available])
    ])

    # Check if native or non-native build

    AS_IF([ test "${build}" = "${host}" ],
    [

      # build == host so this is a native build. Make sure --prefix not
      # set and $STOW_PKGS_PREFIX is set, then set prefix=$STOW_PKGS_PREFIX.

      AS_IF([ test "${prefix}" = "NONE" && test -n "${STOW_PKGS_PREFIX}" ],
      [
        prefix="${STOW_PKGS_PREFIX}"
        AC_MSG_NOTICE([Using \$STOW_PKGS_PREFIX from environment])
        AC_MSG_NOTICE([prefix=${prefix}])
      ])

    ],[

      # build != host so this is a non-native build. Make sure --prefix
      # not set and $STOW_PKGS_ROOT is set, then set
      # prefix=$STOW_PKGS_ROOT/${host_alias}.

      AS_IF([ test "${prefix}" = "NONE" && test -n "${STOW_PKGS_ROOT}" ],
      [
        prefix="${STOW_PKGS_ROOT}/${host_alias}"
        AC_MSG_NOTICE([Using \$STOW_PKGS_ROOT from environment])
        AC_MSG_NOTICE([prefix=${prefix}])
      ])

    ])

  ])

])

#-------------------------------------------------------------------------
# MCPPBS_PROG_RUN
#-------------------------------------------------------------------------
# If we are doing a non-native build then we look for an isa simulator
# to use for running tests. We set the RUN substitution variable to be
# empty for native builds or to the name of the isa simulator for
# non-native builds. Thus a makefile can run compiled programs
# regardless if we are doing a native or non-native build like this:
#
#  $(RUN) $(RUNFLAGS) ./test-program
#

AC_DEFUN([MCPPBS_PROG_RUN],
[
  # berkin: temporarily disabling isa sim check for arm xcc
  AS_IF([ test "${build}" != "${host}" && test "${host}" != "arm-unknown-linux-gnueabi" ],
  [
    AC_CHECK_TOOLS([RUN],[isa-run run],[no])
    AS_IF([ test ${RUN} = "no" ],
    [
      AC_MSG_ERROR([Cannot find simulator for target ${target_alias}])
    ])
  ],[
    RUN=""
  ])
  AC_SUBST([RUN])
  AC_SUBST([RUNFLAGS])
])

#-------------------------------------------------------------------------
# MCPPBS_HLS
#-------------------------------------------------------------------------
# Check for vivado_hls and the XILINX_VIVADO_HLS_INCLUDE_DIR

AC_DEFUN([MCPPBS_HLS],
[
  # Look for vivado_hls

  AC_CHECK_TOOLS([HLS],[vivado_hls],[no])
  AS_IF([ test ${HLS} = "no" ],
  [
    AC_MSG_ERROR([Cannot find vivado_hls])
  ])

  AC_SUBST([HLS])

  # Verify that XILINX_VIVADO_HLS_INCLUDE_DIR is set

  AS_IF([ test -n "${XILINX_VIVADO_HLS_INCLUDE_DIR}" ],
  [
    AS_VAR_APPEND([CXXFLAGS],
      " -I${XILINX_VIVADO_HLS_INCLUDE_DIR} -DXILINX_VIVADO_HLS_TESTING ")
  ],[
    AC_MSG_ERROR([XILINX_VIVADO_HLS_INCLUDE_DIR not set!])
  ])
])

#-------------------------------------------------------------------------
# MCPPBS_INCLUDE_INTERNAL([subproject])
#-------------------------------------------------------------------------
# Use this macro to include an internal subproject meaning that the
# subproject's source code is included in a subdirectory of the
# top-level source directory. One should order the includes such that
# any given subproject only depends on subprojects listed before it. The
# subproject name can also include an * suffix which indicates that this
# is an optional subproject. Optional subprojects are only included as
# part of the project build if enabled on the configure command line
# with a --with-<subproject> flag. The user can also specify that all
# optional subprojects should be included in the build with the
# --with-optional-subprojects flag.
#
# Both required and optional subprojects should have a subproject.ac
# file. The script's filename should be the abbreivated subproject name.
# This macro includes the subproject.ac files for enabled subprojects.
# The very first macro in subproject.ac should be a call to
# MCPPBS_SUBPROJECT with the subproject's name and dependencies.
#
# Internal subprojects must also have a subproject.mk.in file which
# includes make variables for the compiler and linker flags specificly
# needed to build the subproject and also lists all of the source files
# for the subproject. The user should use the following configure
# substitution variables in their make fragment (assuming the
# subproject's name is foo).
#
#  - @foo_intdeps@  : List of internal subproject dependencies
#  - @foo_cppflags@ : List of include paths (-I)
#  - @foo_ldflags@  : List of library paths (-L)
#  - @foo_libs@     : List of libraries (-l)
#
# Note that we use a m4_define instead of AC_DEFUN for now because
# otherwise autoconf will call macros specified with AC_REQUIRE at the
# very outer AC_DEFUN which can be pretty confusing.

m4_define([MCPPBS_INCLUDE_INTERNAL],
[
  # Determine if this is a required or an optional subproject and create
  # a m4 variable for his subproject name with and without dashes.

  m4_define([MCPPBS_IS_OPTIONAL],
    m4_bmatch(m4_normalize($1),[\*],[true],[false]))

  m4_define([MCPPBS_SPROJ],  m4_bpatsubst(m4_normalize($1),[*],[]))
  m4_define([MCPPBS_SPROJU], m4_bpatsubst(MCPPBS_SPROJ,[-],[_]))

  # Set the type of this subproject and add it to a shell and m4 list

  MCPPBS_SPROJU[]_type="internal"
  AS_VAR_APPEND([mcppbs_include_internal],"MCPPBS_SPROJ ")
  m4_set_add([MCPPBS_SPROJS],MCPPBS_SPROJ)

  # Optional subprojects add an --with-subproject command line options,
  # while default subprojects just make sure the shell enabled variable
  # is set to "yes" so we always configure this subproject.

  m4_if(MCPPBS_IS_OPTIONAL,[true],
  [
    AC_ARG_WITH(MCPPBS_SPROJ,
      AS_HELP_STRING(--with-MCPPBS_SPROJ,
        [Internal subproject MCPPBS_SPROJ]),
      [with_[]MCPPBS_SPROJU="yes"],[with_[]MCPPBS_SPROJU="no"])
  ],[
    with_[]MCPPBS_SPROJU="yes"
  ])

  # We create a shell function which contains all the code to actually
  # configure this project including adding it to the
  # $mcppbs_include_internal_en running shell variable, setting an
  # HAVE_SUBPROJECT C define, and actually processing the appropriate
  # subproject.ac. This will allow us to easily configure optional
  # subproject later by just executing this function.

  MCPPBS_SPROJU[]_cfg ()
  {
    AC_CONFIG_HEADERS(MCPPBS_SPROJ[]/config.h:config.h.in)
    AC_CONFIG_FILES(MCPPBS_SPROJ[]/MCPPBS_SPROJ[].mk:MCPPBS_SPROJ[]/MCPPBS_SPROJ[].mk.in)
    AC_DEFINE(m4_toupper(HAVE_[]MCPPBS_SPROJU),,
      [Define if we should include subproject] MCPPBS_SPROJ )
    AS_VAR_APPEND([mcppbs_include_internal_en],"MCPPBS_SPROJ ")
    with_[]MCPPBS_SPROJU="yes"
    m4_include(MCPPBS_SPROJ[]/MCPPBS_SPROJ[].ac)
  };

  # See if we should actually configure this subproject and if so then
  # call the shell function we just created.

  AS_IF([    test "${with_optional_subprojects}" = "yes" \
          || test "${with_[]MCPPBS_SPROJU}" = "yes"  ],
  [
    eval "MCPPBS_SPROJU[]_cfg"
  ])

])

#-------------------------------------------------------------------------
# MCPPBS_INCLUDE_EXTERNAL([subproject])
#-------------------------------------------------------------------------
# Use this macro to include an external subproject meaning that the
# subproject is installed as a library with an appropriate pkg-config
# meta-data file named subproject.pc. The subproject.pc file should
# contain the compiler and linker flags necessary for linking to the
# subproject. One should order the includes such that any given
# subproject only depends on subprojects listed before it. The
# subproject name can also include an * suffix which indicates that this
# is an optional subproject. Optional subprojects are only included as
# part of the project build if enabled on the configure command line
# with a --with-<subproject> flag. The user can also specify that all
# optional subprojects should be included in the build with the
# --with-optional-subprojects flag.

AC_DEFUN([MCPPBS_INCLUDE_EXTERNAL],
[
  # Determine if this is a required or an optional subproject and create
  # a m4 variable for his subproject name with and without dashes.

  m4_define([MCPPBS_IS_OPTIONAL],
    m4_bmatch(m4_normalize($1),[\*],[true],[false]))

  m4_define([MCPPBS_SPROJ],  m4_bpatsubst(m4_normalize($1),[*],[]))
  m4_define([MCPPBS_SPROJU], m4_bpatsubst(MCPPBS_SPROJ,[-],[_]))

  # Set the type of this subproject and add it to a shell and m4 list

  MCPPBS_SPROJU[]_type="external"
  AS_VAR_APPEND([mcppbs_include_external],"MCPPBS_SPROJ ")
  m4_set_add([MCPPBS_SPROJS],MCPPBS_SPROJ)

  # Optional subprojects add an --with-subproject command line options,
  # while default subprojects just make sure the shell enabled variable
  # is set to "yes" so we always configure this subproject.

  m4_if(MCPPBS_IS_OPTIONAL,[true],
  [
    AC_ARG_WITH(MCPPBS_SPROJ,
      AS_HELP_STRING(--with-MCPPBS_SPROJ,
        [External subproject MCPPBS_SPROJ]),
      [with_[]MCPPBS_SPROJU="yes"],[with_[]MCPPBS_SPROJU="no"])
  ],[
    with_[]MCPPBS_SPROJU="yes"
  ])

  # We create a shell function which contains all the code to actually
  # configure this project including adding it to the
  # $mcppbs_include_external_en running shell variable and setting an
  # HAVE_SUBPROJECT C define. This will allow us to easily configure
  # optional subproject later by just executing this function.

  MCPPBS_SPROJU[]_cfg ()
  {
    # First see if the PKG_CONFIG shell variable is already set. If not
    # then we check and see if pkg-config is in our path. We use
    # AC_CHECK_TOOL so that if this is a non-native build we
    # automatically look for host-pkg-config.

    AS_IF([ test -z "${PKG_CONFIG}" ],
    [
      AC_CHECK_TOOL([PKG_CONFIG],[pkg-config],[no])
      AS_IF([ test "${PKG_CONFIG}" = "no" ],
      [
        AC_MSG_ERROR([Could not find pkg-config which is required for
          linking against external subprojects.])
      ])
    ])

    # Now that we know that pkg-config is available we can see if the
    # given subproject exists.

    AS_IF([ ${PKG_CONFIG} --exists MCPPBS_SPROJ ],[],
    [
      AC_MSG_ERROR([Could not find MCPPBS_SPROJ library with pkg-config.
        Perhaps MCPPBS_SPROJ was not found in the pkg-config search
        path. Try adding the directory containing 'MCPPBS_SPROJ.pc' to
        the PKG_CONFIG_PATH environment variable.])
    ])

    # Some nice configure output

    AC_MSG_CHECKING([for external subproject MCPPBS_SPROJ])
    AC_MSG_RESULT([yes])

    # Create the compiler and linker flags for this subproject

    MCPPBS_SPROJU[]_cppflags=`${PKG_CONFIG} --cflags MCPPBS_SPROJ`
    MCPPBS_SPROJU[]_ldflags=`${PKG_CONFIG} --libs-only-L MCPPBS_SPROJ`
    MCPPBS_SPROJU[]_libs=`${PKG_CONFIG} --libs-only-l MCPPBS_SPROJ`
    AS_VAR_APPEND(MCPPBS_SPROJU[]_libs,
     `${PKG_CONFIG} --libs-only-other MCPPBS_SPROJ`)

    AC_SUBST(MCPPBS_SPROJU[]_cppflags)
    AC_SUBST(MCPPBS_SPROJU[]_ldflags)
    AC_SUBST(MCPPBS_SPROJU[]_libs)

    # Create a header define and set the approriate shell variables

    AC_DEFINE(m4_toupper(HAVE_[]MCPPBS_SPROJU),,
      [Define if we should include subproject MCPPBS_SPROJ])
    AS_VAR_APPEND([mcppbs_include_external_en],"MCPPBS_SPROJ ")
    with_[]MCPPBS_SPROJU="yes"
  };

  # See if we should actually configure this subproject and if so then
  # call the shell function we just created.

  AS_IF([    test "${with_optional_subprojects}" = "yes" \
          || test "${with_[]MCPPBS_SPROJU}" = "yes"  ],
  [
    eval "MCPPBS_SPROJU[]_cfg"
  ])

])

#-------------------------------------------------------------------------
# _MCPPBS_UNIQ([var])
#-------------------------------------------------------------------------
# Helper macro which looks through the given shell variable and
# eliminates redundant tokens (ie. whitespace delimited substrings) and
# writes the result back to the given shell variable. It terms of
# ordering the macro uses the placement of the last occurrence of the
# redundant token. This will do the right thing for linker library
# ordering. The current implementation is pretty inefficient. I think it
# is worse than quadratic, but it is simple and the number of tokens is
# usually pretty small.

m4_define([_MCPPBS_UNIQ],
[
  # Reverse the order of the input
  $1_rev=""
  for input_token in ${$1}; do
    $1_rev="${input_token} ${$1_rev}"
  done

  # Step through each input token (now in reverse order)
  $1=""
  for input_token in ${$1_rev}; do

    # See if input token is in output token list
    token_found="no"
    for output_token in ${$1}; do
      if ( test "${input_token}" = "${output_token}" ); then
        token_found="yes"
      fi
    done

    # If this is the first time we have seen token push it onto list
    if ( test "${token_found}" = "no" ); then
      $1="${input_token} ${$1}"
    fi
  done
])

#-------------------------------------------------------------------------
# MCPPBS_SUBPROJECT( [subproject], [ dep1, dep2, ... ] )
#-------------------------------------------------------------------------
# Go through list of subprojects which this subproject depends on and
# make sure they are configured. Create a cummulative list of all the
# compiler and linker flags from all the subprojects which this
# subproject depends on including both direct and indirect dependencies.
#
# Note that we use a m4_define instead of AC_DEFUN for now because
# otherwise autoconf will call macros specified with AC_REQUIRE at the
# very outer AC_DEFUN which can be pretty confusing.

m4_define([MCPPBS_SUBPROJECT],
[
  # Verify that the subproject name give in the configure.ac matches the
  # name give in the autoconf fragment.

  m4_if(m4_normalize($1),MCPPBS_SPROJ,[],
  [
    m4_fatal(Subproject name in configure.ac does not match name
             in MCPPBS_SPROJ.ac ('MCPPBS_SPROJ' != 'm4_normalize($1)'))
  ])

  m4_define([MCPPBS_SPROJ],  m4_normalize($1))
  m4_define([MCPPBS_SPROJU], m4_bpatsubst(MCPPBS_SPROJ,[-],[_]))

  # Save the list of direct dependencies (ie dirdeps) and a list of
  # dependencies which are comma separated for pkg-config file.

  MCPPBS_SPROJU[]_dirdeps="m4_join([ ],$2)"
  MCPPBS_SPROJU[]_pkcdeps="$2"

  # Initialize this subproject's compiler and linker flags

  MCPPBS_SPROJU[]_cppflags=""
  MCPPBS_SPROJU[]_ldflags="-L[]MCPPBS_SPROJ "
  MCPPBS_SPROJU[]_libs="-l[]MCPPBS_SPROJ "

  # Loop through the list of given subprojects and for each one see if
  # it has already been configured. If no then configure it by calling
  # the appropriate shell function created in MCPPBS_SUBPROJECT. This
  # will recursively configure transitively dependent subprojects.
  # Eventually maybe this should happen at configure run time as opposed
  # to autoconf run time.

  m4_foreach([MCPPBS_DEP],[$2],
  [
    # Determine if this dependency is required or optional

    m4_define([MCPPBS_DEP_OPTIONAL],
      m4_bmatch(MCPPBS_DEP,[\*],[true],[false]))

    # Create some names which characterize this dependency including a
    # shell variable indicating if this subproject has been configured,
    # the function name to call if we need to configure this dependency,
    # and a shell variable which has this dependency's dependencies.

    m4_define([MCPPBS_DEP],
      m4_normalize(m4_bpatsubsts(MCPPBS_DEP,[*],[])))

    m4_define([MCPPBS_DEPU], m4_bpatsubsts(MCPPBS_DEP,[-],[_]))

    # If the dependency is required and has not been configured then
    # configure it. Issue error if subproject does not exist.

    m4_if(MCPPBS_DEP_OPTIONAL,[false],
    [
      m4_set_contains(MCPPBS_SPROJS,MCPPBS_DEP,[],
      [
        m4_fatal(Subproject MCPPBS_SPROJ depends on non-existent
                 subproject MCPPBS_DEP)
      ])

      AS_IF([ test "${with_[]MCPPBS_DEPU}" = "no" ],
      [
        eval "MCPPBS_DEPU[]_cfg"
      ])
    ])

    # Add information about this dependency to our running lists

    AS_IF([ test "${with_[]MCPPBS_DEPU}" = "yes" ],
    [
      # Add the actual dependency to our libs list and our intdeps list
      # which are both ordered such that libs only depend on later libs

      AS_VAR_APPEND(MCPPBS_SPROJU[]_ldflags,"-L[]MCPPBS_DEP ")
      AS_VAR_APPEND(MCPPBS_SPROJU[]_libs,"-l[]MCPPBS_DEP ")
      AS_IF([ test "${MCPPBS_DEPU[]_type}" = "internal" ],
      [
        AS_VAR_APPEND(MCPPBS_SPROJU[]_intdeps,"MCPPBS_DEP ")
      ])

      # Add dependency's variables to our own

      AS_VAR_APPEND(MCPPBS_SPROJU[]_intdeps,"${MCPPBS_DEPU[]_intdeps} ")
      AS_VAR_APPEND(MCPPBS_SPROJU[]_cppflags,"${MCPPBS_DEPU[]_cppflags} ")
      AS_VAR_APPEND(MCPPBS_SPROJU[]_ldflags,"${MCPPBS_DEPU[]_ldflags} ")
      AS_VAR_APPEND(MCPPBS_SPROJU[]_libs,"${MCPPBS_DEPU[]_libs} ")
    ])
  ])

  # Make the dependency list, cppflags, ldflags, and libs variable unique
  # by eliminating redundant tokens in the full lists.

  _MCPPBS_UNIQ([MCPPBS_SPROJU[]_intdeps])
  _MCPPBS_UNIQ([MCPPBS_SPROJU[]_cppflags])
  _MCPPBS_UNIQ([MCPPBS_SPROJU[]_ldflags])
  _MCPPBS_UNIQ([MCPPBS_SPROJU[]_libs])

  # Keep a copy of the compiler and linker flags as they are now,
  # because if we want to install this project we don't really need to
  # include these flags in the pkg-config file. We do of course need to
  # keep the flags that a user might add later in their subproject.ac.

  MCPPBS_SPROJU[]_base_cppflags=${MCPPBS_SPROJU[]_cppflags}
  MCPPBS_SPROJU[]_base_ldflags=${MCPPBS_SPROJU[]_ldflags}
  MCPPBS_SPROJU[]_base_libs=${MCPPBS_SPROJU[]_libs}

  # Substitute variables for makefile

  AC_SUBST(MCPPBS_SPROJU[]_intdeps)
  AC_SUBST(MCPPBS_SPROJU[]_cppflags)
  AC_SUBST(MCPPBS_SPROJU[]_ldflags)
  AC_SUBST(MCPPBS_SPROJU[]_libs)

  # Substitute variables for pkg-config files (these will be set in the
  # MCPPBS_INSTALL_LIBS macro)

  AC_SUBST(MCPPBS_SPROJU[]_pkcdeps)
  AC_SUBST(MCPPBS_SPROJU[]_extra_cppflags)
  AC_SUBST(MCPPBS_SPROJU[]_extra_ldflags)
  AC_SUBST(MCPPBS_SPROJU[]_extra_libs)

  # Display that we are now configuring this subproject (ie running the
  # rest of the macros in the corresponding subproject.ac)

  AC_MSG_NOTICE([configuring internal subproject MCPPBS_SPROJ])

])

#-------------------------------------------------------------------------
# _MCPPBS_CREATE_EXTRA_FLAGS([var],[suffix])
#-------------------------------------------------------------------------
# Var is a bash shell variable while suffix is a string literal. This
# helper macro works with three variables:
#
#  eval var_suffix=\${${var}_suffix}
#  eval var_base_suffix=\${${var}_base_suffix}
#  eval var_extra_suffix=\${${var}_extra_suffix}
#
# The first two are inputs and the third is the output. The first input
# is the entire set of compiler or linker flags. The second are just the
# base flags defined at the time that MCPPBS_SUBPROJECT is finished. The
# output will be those flags which are in the first input but not in the
# second input. For now we just use sed to remove the base from the
# first input which should be fine assuming the user hasn't mucked with
# what was already in the standard variables.

m4_defun([_MCPPBS_CREATE_EXTRA_FLAGS],
[
  # Read the two input variables
  eval "$1_$2=\${${$1}_$2}"
  eval "$1_base_$2=\${${$1}_base_$2}"

  # If nothing would go in extra flags then we are done
  if ( test "${$1_$2}" = "${$1_base_$2}" ); then
    $1_extra_$2=""

  # As long as both inputs are non-empty then do the substitution
  elif ( test -n "${$1_$2}" && test -n "${$1_base_$2}" ); then
    $1_extra_$2=`echo "${$1_$2}" | sed "s|${$1_base_$2}||"`

  # If at least one input was empty then extra is just current value
  else
    $1_extra_$2="${$1_$2}"

  fi

  # Set the output variable
  eval "${$1}_extra_$2=\${$1_extra_$2}"
])

#-------------------------------------------------------------------------
# MCPPBS_INSTALL_LIBS([ subproject1, subproject2, ... ])
#-------------------------------------------------------------------------
# Configure the project so that it will install the libraries (and
# headers of course) for the given subproject. For a subproject to be
# able to be installed it must have a pkg-config subproject.pc.in file
# which can use the following substitution variables:
#
#  - @foo_pkcdeps@        : List of all subproject dependencies
#  - @foo_extra_cppflags@ : List of include paths (-I)
#  - @foo_extra_ldflags@  : List of library paths (-L)
#  - @foo_extra_libs@     : List of libraries (-l)
#
# The "extra" compiler and linker flags are the subset of the compiler
# and linker flags used in the makefile which are not provided by other
# subprojects.
#
# It is an error for an "install" subproject to depend on subprojects
# which are internal and not marked for installation.

AC_DEFUN([MCPPBS_INSTALL_LIBS],
[
  # Normalize input list and step through each subproject on list

  mcppbs_install=`echo "$1" | tr -s ",\n " "   "`
  for mcppbs_sproj in ${mcppbs_install}; do

    # Change dashes to underscores in given subproject

    mcppbs_sproju=`echo "${mcppbs_sproj}" | tr "-" "_"`

    # Make sure this is a valid subproject

    eval "with_mcppbs_sproju=\${with_${mcppbs_sproju}}"
    AS_IF([ test -z "${with_mcppbs_sproju}" ],
    [
       AC_MSG_ERROR([Subproject ${mcppbs_sproj} is in
         MCPPBS_[]INSTALL_LIBS but has not been initialized with a call
         to MCPPBS_[]INCLUDE_INTERNAL.])
    ])

    # Verify that all of the dependencies for this subproject are either
    # external or also on this install list. You cannot install a
    # subproject which depends on other subprojects which are not also
    # installed (or will be installed).

    eval "mcppbs_sproju_dirdeps=\${${mcppbs_sproju}_dirdeps}"
    for mcppbs_dep in ${mcppbs_sproju_dirdeps}; do

      mcppbs_depu=`echo ${mcppbs_dep} | tr "-" "_"`
      eval "mcppbs_depu_type=\${${mcppbs_depu}_type}"
      AS_IF([ test "${mcppbs_depu_type}" = "internal" ],
      [
        AS_IF([ echo "${mcppbs_install}" | grep -qvw "${mcppbs_dep}" ],
        [
          AC_MSG_ERROR([Subproject ${mcppbs_sproj} is in
            MCPPBS_[]INSTALL_LIBS but it depends on subproject
            ${mcppbs_dep} which is an internal subproject not marked for
            installation. Maybe you should add subproject ${mcppbs_dep}
            to MCPPBS_[]INSTALL_LIBS?])
        ])
      ])
    done

    # Only install subprojects which are enabled

    AS_IF([ test "${with_mcppbs_sproju}" = "yes" ],
    [
      # Create the "extra" version of the compiler and linker flags

      _MCPPBS_CREATE_EXTRA_FLAGS([mcppbs_sproju],[cppflags])
      _MCPPBS_CREATE_EXTRA_FLAGS([mcppbs_sproju],[ldflags])
      _MCPPBS_CREATE_EXTRA_FLAGS([mcppbs_sproju],[libs])

      # Create subproject.pc from subproject.pc.in

      AC_CONFIG_FILES(${mcppbs_sproj}/${mcppbs_sproj}.pc:${mcppbs_sproj}/${mcppbs_sproj}.pc.in)
    ])

  done
])