libdune-common-dev 2.4.1-1 / usr / lib / dunemodules.lib

# -*-sh-*-

###############################################
###
### Configuration
###

# name of the "control" files
CONTROL="dune.module"

###############################################
###
### check for environment variables
###

if test -z $GREP; then
  GREP=grep
fi
if test -z "$SED"; then
  SED=sed
fi
# SunOS [e]grep does not seem to comprehend character classes.  Set up
# some variables to spell them out
UPPER=ABCDEFGHIJKLMNOPQRSTUVWXYZ
LOWER=abcdefghijklmnopqrstuvwxyz
ALPHA="$UPPER$LOWER"
DIGIT=0123456789
ALNUM="$ALPHA$DIGIT"

space=" "
formfeed=""
newline="
"
cr="
"
tab="	"
vtab=""
# $SPACE will unfortunately not work since grep will not accept an
# embedded newline.  Instead one can often get away with using $BLANK
SPACE="$space$formfeed$newline$cr$tab$vtab"
BLANK="$space$tab"
NOBLANK="^$space$tab"

#
# read paramters from a $CONTROL file
#
# paramters:
# $1 file to read
#
PARSER_TRIM="awk '{gsub(/^[ \\t]+|[ \\t]+$/,\"\");printf(\"%s\", \$0);}'"
parse_control() {
  # check file existence
  if test ! -f "$1" -o "$(basename "$1")" != "$CONTROL"; then
    echo "ERROR: '$1' is no $CONTROL file" >&2
    exit 1
  fi
  # reset information handling
  module=""
  module_inst="no"
  # read parameters from control file
  local name="$($GREP Module: "$1" | cut -d ':' -f2 | eval $PARSER_TRIM)"
  if test "x$name" = "x"; then
    echo "ERROR: $CONTROL files $1 does not contain a Module entry" >&2
    exit 1
  fi
  # create and check variable name from module name
  export module=$(fix_variable_name $name)
  if ! check_modname "$module"; then
    echo "ERROR: $CONTROL files $1 contains an invalid Module entry" >&2
    exit 1
  fi
  # read dune.module file
  local deps="$($GREP "^[BLANK]*Depends:" "$1" | cut -d ':' -f2 | eval $PARSER_TRIM)"
  local sugs="$($GREP "^[BLANK]*Suggests:" "$1" | cut -d ':' -f2 | eval $PARSER_TRIM)"
  local vers="$($GREP "^[BLANK]*Version:" "$1" | cut -d ':' -f2 | eval $PARSER_TRIM)"
  local main="$($GREP "^[BLANK]*Maintainer:" "$1" | cut -d ':' -f2 | eval $PARSER_TRIM)"
  # check whether the module is installed.
  # - installed modules can be found via pkg-config
  # - pkg-config --var=prefix should be the same as $path
  #
  # the path contains a different sub structure
  # for installed and source modules
  # - installed module: ${path}/lib/dunecontrol/${name}/dune.module
  #   and there is a file ${path}/lib/pkgconfig/${name}.pc
  # - source module: ${path}/dune.module
  #   and there is a file ${path}/${name}.pc.in
  local path="$(canonicalpath "$1")"
  if pkg-config $name; then
    local prefix="$(pkg-config --variable=prefix $name)"
    local pkgpath=$(canonicalname "$prefix/lib/dunecontrol/$name")
    if test x"$pkgpath" = x"$path"; then
	  path="$prefix"
      module_inst="yes"
    fi
  fi
  # avoid multiple definition of the same module
  if eval test "x\$HAVE_$module" != "x"; then
    # make sure we don't stumble over the same module twice
    if eval test "\$PATH_$module" = "$path"; then
      return
    fi
    local old_mod_inst
    eval old_mod_inst=\$INST_$module
    case "$old_mod_inst$module_inst" in
    # multiple local modules are an error
    # multiple installed modules are an error
    nono|yesyes)
      echo "ERROR: multiple definition of module $name" >&2
      echo "previous defined in:" >&2
      if eval test x\$INST_$module = "xyes"; then
        echo "  $(eval echo \$PATH_$module)/lib/dunecontrol/$name/$CONTROL" >&2
      else
        echo "  $(eval echo \$PATH_$module)/$CONTROL" >&2
      fi
      echo "redefined in:" >&2
      if test "$module_inst" = "yes"; then
        echo "  $path/lib/dunecontrol/$name/$CONTROL" >&2
      else
        echo "  $path/$CONTROL" >&2
      fi
      exit 1
    ;;
    # installed modules are superseded by locally built modules
    noyes)
      return
    ;;
    # local modules supersede installed modules
    yesno)
      superseded_modules="$superseded_modules $path"
      true # do nothing, ignore the previously found module
    ;;
    esac
  fi
  # set status variables
  export HAVE_$module=yes
  export PATH_$module="$path"
  export VERS_$module="$vers"
  export NAME_$module="$name"
  export MAIN_$module="$main"
  export DEPS_$module="$deps"
  export INST_$module="$module_inst"
  for name in $deps; do
    mod=$(fix_variable_name $name)
    export NAME_$mod="$name"
  done
  export SUGS_$module="$sugs"
  for name in $sugs; do
    mod=$(fix_variable_name $name)
    export NAME_$mod="$name"
  done
  # update list of modules
  if test "$module_inst" = "yes"; then
    export INSTMODULES="$INSTMODULES$module "
  else
    export LOCALMODULES="$LOCALMODULES$module "
  fi
}

# Uses the current compiler to extract information about the
# multiarch triplets and sets the export variable MULTIARCH_LIBDIR
# according to it.
# If not compiler is specified then cc or gcc is used.
extract_multiarch_pkg_config_path(){
  local my_cxx_compiler
  if test "x$MULTIARCH_LIBDIR" != "x"; then
    return
  fi
  set +e #error in the multiarch detection should not be fatal.
  $(which cc &>/dev/null)
  if test $? -eq "0"; then
      my_cxx_compiler=cc
  else
      my_cxx_compiler=gcc
  fi
  multiarch=$($my_cxx_compiler --print-multiarch 2>/dev/null)
  if test $? -gt 0; then
    for i in "target=" "Target:"; do
      multiarch=$($my_cxx_compiler -v 2>&1| $GREP "$i" | sed "s/.*$i[$BLANK]*\([a-z0-9_-]*\)/\1/" | $SED "s/-[a-z]*-linux-gnu/-linux-gnu/")
     if test -n "$multiarch"; then break; fi
   done
  fi
  set -e # set to old value.
  export MULTIARCH_LIBDIR="lib/$multiarch"

  # create PKG_CONFIG_PATH for installed dune modules
  for i in $MULTIARCH_LIBDIR lib64 lib32 lib; do
    if test -d "$PREFIX_DIR/$i/pkgconfig"; then
      export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$PREFIX_DIR/$i/pkgconfig"
    fi
  done
}


#
# try to setup the control path
#
setup_control_path() {
  if test -z "$DUNE_CONTROL_PATH"; then
    DUNE_CONTROL_PATH=.
    # try pkg-config locations
    if ! pkg-config dune-common; then
      # try usual locations of installed modules
      for i in /usr/local/lib/dunecontrol/ /usr/lib/dunecontrol/; do
        if test -d $i; then
          DUNE_CONTROL_PATH=$DUNE_CONTROL_PATH:"$i"
        fi
      done
      for i in `echo $PKG_CONFIG_PATH | tr ':' ' '`; do
        if test -d "$i/../dunecontrol"; then 
          DUNE_CONTROL_PATH=$DUNE_CONTROL_PATH:"$i/../dunecontrol"
        fi
      done
    else
      NEW_DUNE_CONTROL_DIR=$(pkg-config dune-common --variable=prefix)/lib/dunecontrol
      # There might be old version of DUNE lying around, that do not contain
      # lib/dunecontrol, yet. To prevent failur at a later stage of dunecontrol
      # we check that the directory really exists.
      if test -d "$NEW_DUNE_CONTROL_DIR"; then
        DUNE_CONTROL_PATH=$DUNE_CONTROL_PATH:$NEW_DUNE_CONTROL_DIR
      fi
    fi
  fi
  # try to read DUNE_CONTROL_PATH from OPTS file
  if test -n "$DUNE_OPTS_FILE"; then
    DUNE_CONTROL_PATH="$(. $DUNE_OPTS_FILE; eval echo $DUNE_CONTROL_PATH)"
  fi
  # canonicalize path
  local TMP=""
  # foreach dir in $@
  while read dir; do
    TMP=$TMP:"$(canonicalname "$dir")"
  done <<EOF
    $(echo $DUNE_CONTROL_PATH | sed -e 's/:\+/:/g' | tr ':' '\n')
EOF
  # sort+uniq path
  DUNE_CONTROL_PATH="$(echo $TMP | tr ':' '\n' | sort -u | tr '\n' ':' | sed -e 's/^://' -e 's/:$//')"
  # safe result
  export DUNE_CONTROL_PATH
}

#
# search for modules in each directory in DUNE_CONTROL_PATH
#
find_modules_in_path() {
  setup_control_path
  if test -z "$FOUND_MODULES"; then
    # foreach dir in $@
    while read dir; do
      if test -d "$dir"; then
        while read m; do
          test -n "$m" && parse_control "$m"
        done <<EOFM
        $(find -H "$dir" -name '.?*' -prune -o -name $CONTROL -print | $GREP -v 'dune-[-_a-zA-Z]/dune-[-a-zA-Z_]*-[0-9]\{1,\}.[0-9]\{1,\}/')
EOFM
	  else
        parse_control "$dir"
	  fi
    done <<EOF
    $(echo $DUNE_CONTROL_PATH | sed -e 's/:\+/:/g' | tr ':' '\n') 
EOF
    export MODULES="$LOCALMODULES$INSTMODULES"
    export FOUND_MODULES="$MODULES"
  else
    export MODULES="$FOUND_MODULES"
  fi
}

#
# sort $MODULES according to the dependencies
#
sort_modules() {
  # reset lists
  export SORTEDMODULES=""
  export REVERSEMODULES=""
  export SORTEDMODULES_SUB=""
  # handle each modules passed as parameter
  for m in "$@"; do
    # did we find a module file for this module?
    if eval test x\$HAVE_$m != x; then
      _sort_module $m MAIN
    else
      echo "ERROR: could not find module $(eval echo \$NAME_$m)" >&2
      exit 1
    fi
  done
  # save result
  export MODULES="$SORTEDMODULES"
  # setup list of SUGS/DEPS and the INFO list
  export SORTEDMODULES_INFO=""
  export SORTEDMODULES_DEPS=""
  export SORTEDMODULES_MAIN=""
  export SORTEDMODULES_SUGS=""
  local mode
  for m in $MODULES; do
    eval mode=\$MODE_$m
    SORTEDMODULES_INFO="$SORTEDMODULES_INFO $m[$mode]"
    eval SORTEDMODULES_$mode=\"\$SORTEDMODULES_$mode $m\"
  done
  export SORTEDMODULES_INFO
  export SORTEDMODULES_DEPS
  export SORTEDMODULES_SUGS
  export SORTEDMODULES_MAIN
  # clean up temporary variables
  for m in $MODULES; do
    export MODE_$m=""
    export SORT_DONE_$m=""
    export SORT_DEPS_DONE_$m=""
    export SORT_SUGS_DONE_$m=""
  done
}

_check_deps()
{
  local module="$1"
  local mode="$2"
  local depmode="$3"
  local report="ERROR"
  local requires="requires"
  local required="required"
  local dependency="dependency"
  if test "x$mode" = "xSUGS"; then
    report="WARNING"
    requires="suggests"
    required="suggested"
    dependency="suggestion"
  fi
  eval deps=\$${mode}_$module
  #initially remove leading space
  deps=`echo ${deps//^[, ]}`
  while test -n "$deps"; do
    #the end of the name is marked either by space, opening parenthesis,
    #or comma
    name="${deps%%[ (,]*}"
    #remove the name and adjacent whitespace
    deps=`echo "$deps" | sed 's/^[^ (,]* *//'`
    #check whether there is a dependency version
    case "$deps" in
    '('*) deps="${deps#(}"
          depver="${deps%%)*}"
          deps="${deps#*)}"
          ;;
    *)    depver=
          ;;
    esac
    #remove any leading whitespace or commas for the next iteration
    deps=`echo ${deps//^[, ]}`
    dep=$(fix_variable_name $name)
    if ! check_modname $dep; then
      echo "ERROR: invalid module name $name ($dependency of $module)" >&2
      exit 1
    fi
    if eval test x\$HAVE_$dep != "x"; then
      eval ver=\$VERS_$dep
      if test "$SKIPVERSIONCHECK" != "yes" && ! check_version "$ver" "$depver"; then
        echo "$report: version mismatch." >&2
        echo "       $modname $requires $name $depver," >&2
        echo "       but only $name = $ver is available." >&2
        if test "x$mode" = "xDEPS"; then
          exit 1
        else
          echo "Skipping $name!" >&2
          continue
        fi
      fi
      _sort_module $dep $depmode
    else
      # perhaps this module is installed,
      # then it should be handled via pkg-config
      if ! pkg-config $name; then
        echo "$report: could not find module $name," >&2
        echo "       module is also unknown to pkg-config." >&2
        echo "       Maybe you need to adjust PKG_CONFIG_PATH!" >&2
        echo "       $name is $required by $modname" >&2
        if test "x$mode" = "xDEPS"; then
          exit 1
        else
          echo "Skipping $name!" >&2
          continue
        fi
      else
        eval ver=$(pkg-config $name --modversion)
        if test "$SKIPVERSIONCHECK" != "yes" && ! check_version "$ver" "$depver"; then
          echo "$report: version mismatch." >&2
          echo "       $modname $requires $name $depver," >&2
          echo "       but only $name = $ver is installed." >&2
          if test "x$mode" = "xDEPS"; then
            exit 1
          else
            echo "Skipping $name!" >&2
            continue
          fi
        fi
        # update module list
        parse_control $(pkg-config $name --variable=prefix)/lib/dunecontrol/$name/dune.module
        _sort_module $dep $depmode
      fi
    fi
  done
}

#
# recursive part of sort_modules
# evaluate dependencies of one module
#
# paramters:
# $1 name of the modules
# $2 parser mode:
#    DEPS: search for dependencies
#    SUSG: search for suggestions (DEPS of SUGS are handled as SUGS)
#    MAIN: primary invocation of a DEPS search, 
#          MAIN modules are not added to the list of DEPS/SUGS
#
_sort_module() {
  local module="$1"
  local mode="$2"
  test -n "$mode"
  local modname=""
  eval modname=\$NAME_$module
  local deps=""
  local name=""
  local dep=""
  local ver=""
  local depver=""
  shift 1
  if ! check_modname $module; then 
    echo "ERROR: invalid module name $module" >&2
    exit 1
  fi
  depmode=$(test $mode = SUGS && echo SUGS || echo DEPS)
  if eval test "x\$SORT_${depmode}_DONE_$module" != "xyes"; then
    # stop any recursion
    export SORT_${depmode}_DONE_$module=yes
    # resolve dependencies
    _check_deps $module DEPS $depmode # it might happen that the DEPS are actually SUGS
    # resolve suggestions
    _check_deps $module SUGS SUGS
    # remember mode of the module
    if eval test "x\$MODE_$module" = xSUGS -o  "x\$MODE_$module" = x; then
      export MODE_$module=$mode
    fi
    # topological list of the module and its dependencies/suggestions
    if eval test "x\$SORT_DONE_$module" != "xyes"; then
      export SORT_DONE_$module=yes
      export SORTEDMODULES="$SORTEDMODULES $module"
      export REVERSEMODULES="$module $REVERSEMODULES"
    fi
  fi
}

#
# load the $CONTROL file, skip all control variables
# and run a command
#
# parameters:
# $1 command to execute
# $2 full path of the $CONTROL file
#
eval_control() {
  local command="$1"
  local file="$2"
  shift 2
  if test -f "$file"; then
    # open subshell
    (
      set -e
      # load functions defined in $file
      # if $command is not defined in $file,
      # then the default implementation will be executed
      eval "$($GREP -v "^[-$ALNUM]\{1,\}:" "$file")"
      # execute $command
      $command
    ) || false
  else
    echo "ERROR: could not find $file" >&2
    exit 1
  fi
}

#
# fix a value such that it is suitable for a variable name
#
# parameters:
# $1 value
#
fix_variable_name() {
  echo ${@//[[:punct:]]/_}
}

#
# fix a value such that it is suitable for a variable name and assign it
#
# parameters:
# $1 name of variable
# $2 value
#
fix_and_assign() {
  local name="$1"
  if ! check_modname $name; then
    echo "ERROR: error in assignment. $name is not a valid variabel name." >&2
  fi
  shift 1
  export $name=$(fix_variable_name $@)
}

#
# make sure the module name fits the naming convention
# (we try to assign the name and report upon failure)
#
# parameters:
# $1 module name
#
check_modname() {
  # magic pattern match, see http://www.linuxmisc.com/9-unix-questions/67d307ca51f16ed4.htm
  [ -n "${1##*[!A-Za-z0-9_]*}" ] && [ -n "${1##[!A-Za-z_]*}" ]
}

#
# compare a sub part of the version string
#
# parameters:
# $1 version
# $2 part
#
# parts:
# 1: major
# 2: minor
# 3: revision
#
get_sub_version() {
  #it would be nice to give the part to awk via a "-v FIELD=$2"
  #command line argument.  Unfortunatly, SunOS does not support this.
  #Worse, we cannot use awks int() function here, since under SunOS it
  #will always return 0 for string input.
  echo $1 | cut -d. -f"$2" | sed 's/[^0-9].*$//;s/^$/0/'
}

#
# compare two versions
#
# parameters:
# $1 version1
# $2 version1
#
# return:
# 0: equal
# 1: v1 > v2
# 2: v1 < v2
#
compare_versions() {
  local v1="$1"
  local v2="$2"

  for i in 1 2 3; do
    compare_sub_version $v1 $v2 $i || return 0
  done

  echo "eq"
}

compare_sub_version() {
  # compare sub version number
  local sub1=`get_sub_version $1 $3`
  local sub2=`get_sub_version $2 $3`

  if test $sub1 -gt $sub2; then
    echo "gt"
	return 1
  fi
  if test $sub1 -lt $sub2; then
    echo "lt"
	return 1
  fi

  return 0
}

check_version() {
  if test -z "$2"; then # if no constraint is given, check_version is true
    return 0
  fi
  local v=$1
  local PATTERN="^ *\([<>=]*\) *\([0-9.]*\)\(.*\)$"
  if test x != `echo "$2" | sed -e "s/$PATTERN/x/"`; then
    echo "ERROR: invalid version constraint $2" >&2
    exit 1
  fi
  local op=`echo "$2" | sed -e "s/$PATTERN/\1/"`
  local v2=`echo "$2" | sed -e "s/$PATTERN/\2/"`
  local rest=`echo "$2" | sed -e "s/$PATTERN/\3/" -e 's/ //g'`
  local result=1
  
  local rel=`compare_versions $v $v2`

  case $rel$op in
  "eq<="|"eq="|"eq>="|\
  "gt>="|"gt>"|\
  "lt<="|"lt<")
    result=0
	;;
  esac
  if test -z "$rest"; then
    return $result
  fi
  PATTERN="\([|&]\{2\}\)\(.*\)$"
  if test xx != x`echo "$rest" | sed -e "s/$PATTERN/x/"`; then
    echo "ERROR: invalid version constraint '$rest'" >&2
    exit 1
  fi
  op=`echo "$rest" | sed -e "s/$PATTERN/\1/"`
  v2=`echo "$rest" | sed -e "s/$PATTERN/\2/"`
  if eval "test $result -eq 0" $op "check_version \"$v\" \"$v2\""; then
    return 0
  fi
  return 1
}

#
# Function that the translates options for configure
# The arguments are the case sensitive cmake package names.
# It is assumed that their lowercase version is used
# for the autotools. This function either deactivates
# a package using CMAKE_DISABLE_FIND_PACKAGE_<package>=TRUE
# or passes th provided path using
# the  <CMAKE_PACKAGE_ALL_UPPERCASE>_ROOT variable
default_am2cmake_options(){
    while test "$#" -gt 0; do
        local package=$1
        local lowercase=`tr 'A-Z' 'a-z' <<< $1`
        local uppercase=`tr 'a-z' 'A-Z' <<< $1`
        shift
        if eval test \$"$lowercase"_processed ; then
            continue
        fi
        export "$lowercase"_processed=1
        # check for --without-$lowercase
        echo $PARAMS | grep \\-\\-without-$lowercase > /dev/null
        if test "$?" -eq 0 ; then
            CMAKE_PARAMS="$CMAKE_PARAMS -DCMAKE_DISABLE_FIND_PACKAGE_$package=TRUE"
            continue
        fi
        # process --with-$lowercase=<arg>
        local arg=`echo $PARAMS| sed "s/.*--with-$lowercase=\([$NOBLANK]*\).*/\1/"`
        local arg=`eval echo $arg` # expand tilde to prevent problems
        if test "x$arg" = "xno"; then
            CMAKE_PARAMS="$CMAKE_PARAMS -DCMAKE_DISABLE_FIND_PACKAGE_$package=TRUE"
            continue
        fi
        if  test -d "$arg"; then
            CMAKE_PARAMS="$CMAKE_PARAMS -D$uppercase""_ROOT=$arg"
        fi
    done
    export CMAKE_PARAMS
}


# Default translation routine for libraries.
# Arguments are the CMake package names.
# Searches for --with-<package>lib=<library>
# in the configure options and translates them
# to -D<PACKAGE>_LIBRARY=<library>
default_am2cmake_libraries(){
    while test "$#" -gt 0; do
        lib=$1
        local lowercase=`tr 'A-Z' 'a-z' <<< $1`
        local uppercase=`tr 'a-z' 'A-Z' <<< $1`
        shift
	if eval test \$"$lowercase"-lib_processed; then
	    continue
	fi
	export "$lowercase"-lib_processed=1
	term="s/.*--with-""$lowercase""-lib=\([$NOBLANK]*\).*/\1/"
        arg=`echo "$PARAMS" | grep \\-\\-with-$lowercase | sed "$term"`
	if test "x$arg" != "x"; then
	    CMAKE_PARAMS="$CMAKE_PARAMS -D$uppercase""_LIBRARY=$arg"
	fi
    done
}

module_translate_options_am2cmake()
{
    local module=$1 # the module name
    local path=$2 # where the sh libs reside

    # Check whether the module provides a lib named
    # <module-without-dashes>autotools2cmake.lib
    local module_undashed=`echo $module | sed "s/[-_]//g"`
    local libfile="$path/$module_undashed""am2cmake.lib"
    if test -e "$libfile"; then
        . $libfile
        local module_underline=`echo $module | sed "s/-/_/g"`
        eval "$module_underline"_options_am2cmake
    else
        echo "$libfile for converting options does not exist"
    fi
}