#! /usr/bin/env bash
# icecc -- A simple distributed compiler system
#
# Copyright (C) 2004 by the Icecream Authors
# GPL

target_files=

is_contained ()
{
  case " $target_files " in
    *" $1 "* ) return 0 ;;
    *"=$1 "* ) return 0;;
    * ) return 1 ;;
  esac
}

add_file ()
{
  local name="$1"
  local path="$1";
  if test -n "$2"; then
    name="$2"
  fi
  test -z "$name" && return
  # ls -H isn't really the same as readlink, but
  # readlink is not portable enough.
  path=`ls -H $path`
  toadd="$name=$path"
  is_contained "$toadd" && return
  if test -z "$silent"; then
    echo "adding file $toadd"
  fi
  target_files="$target_files $toadd"
  if test -x "$path"; then
    # Only call ldd when it makes sense
    if file -L "$path" | grep 'ELF' > /dev/null 2>&1; then
      if ! file -L "$path" | grep 'static' > /dev/null 2>&1; then
           # ldd now outputs ld as /lib/ld-linux.so.xx on current nptl based glibc
           # this regexp parse the outputs like:
           # ldd /usr/bin/gcc
           #         linux-gate.so.1 =>  (0xffffe000)
           #         libc.so.6 => /lib/tls/libc.so.6 (0xb7e81000)
           #         /lib/ld-linux.so.2 (0xb7fe8000)
           # covering both situations ( with => and without )
           for lib in `ldd "$path" | sed -n 's,^[^/]*\(/[^ ]*\).*,\1,p'`; do
             test -f "$lib" || continue
             # Check wether the same library also exists in the parent directory,
             # and prefer that on the assumption that it is a more generic one.
             local baselib=`echo "$lib" | sed 's,\(/[^/]*\)/.*\(/[^/]*\)$,\1\2,'`
             test -f "$baselib" && lib=$baselib
             add_file "$lib"
           done
      fi
    fi
  fi
}

# returns abs path to filedir
abs_path()
{
    local path=$1
    if test -f "$path"; then
        pushd $(dirname $path) > /dev/null 2>&1
        dir_path=`pwd -P`
        path=$dir_path/$(basename $path)
        popd > /dev/null 2>&1
    elif test -d "$path"; then
        pushd $path > /dev/null 2>&1
        path=`pwd -P`
        popd > /dev/null 2>&1
    fi
    echo $path
}

# Search and add file to the tarball file.
search_addfile()
{
    local compiler=$1
    local file_name=$2
    local file_installdir=$3
    local file=""

    file=$($compiler -print-prog-name=$file_name)

    if test -z "$file" || test "$file" = "$file_name" || ! test -e "$file"; then
        file=`$compiler -print-file-name=$file_name`
    fi

    if ! test -e "$file"; then
        return 1
    fi

    if test -z "$file_installdir"; then
        # The file is going to be added to the tarball
        # in the same path where the compiler found it.

        file_installdir=$(dirname $file)
        abs_installdir=$(abs_path $file_installdir)

        if test "$file_installdir" != "$abs_installdir"; then
            # The path where the compiler found the file is relative!
            # If the path where the compiler found the file is relative
            # to compiler's path, we must change it to be relative to
            # /usr/bin path where the compiler is going to be installed
            # in the tarball file.
            # Replacing relative path by abs path because the tar command
            # used to create the tarball file doesn't work well with
            # relative path as installdir.

            compiler_basedir=$(abs_path ${compiler%/*/*})
            file_installdir=${abs_installdir/$compiler_basedir/"/usr"}
        fi
    fi

    add_file "$file" "$file_installdir/$file_name"

    return 0
}

# backward compat
if test "$1" = "--respect-path"; then
  shift
fi

#add a --silent switch to avoid "broken pipe" errors when calling this scipt from within OE
if test "$1" = "--silent"; then
 silent=1
 shift
fi

if test "$1" != "--gcc" -a "$1" != "--clang"; then
    # backward compat
    added_gcc=$1
    shift
    added_gxx=$1
    shift
    added_as=$1
    shift
    archive_name=$1
    shift
    gcc=1
else
    if test "$1" = "--gcc"; then
        shift
        added_gcc=$1
        shift
        added_gxx=$1
        shift
        added_as=$1
        shift
        archive_name=$1
        shift
        gcc=1
    elif test "$1" = "--clang"; then
        shift
        added_clang=$1
        shift
        added_compilerwrapper=$1
        shift
        clang=1
    else
        usage
        exit 1
    fi
fi

if test -n "$gcc"; then
    if test -z "$added_gcc" || test -z "$added_gxx"; then
        usage
        exit 1
    fi
    if ! test -x "$added_gcc" ; then
        echo "'$added_gcc' is no executable."
        exit 1
    fi
    if ! test -x "$added_gxx" ; then
        echo "'$added_gxx' is no executable."
        exit 1
    fi
    if test -z "$added_as" ; then
      add_file /usr/bin/as /usr/bin/as
    else
      if ! test -x "$added_as" ; then
        echo "'$added_as' is no executable."
        exit 1
      fi
      add_file $added_as  /usr/bin/as
    fi
fi

if test -n "$clang"; then
    if ! test -x "$added_clang" ; then
        echo "'$added_clang' is no executable."
        exit 1
    fi
    if ! test -x "$added_compilerwrapper" ; then
        echo "'$added_compilerwrapper' is no executable."
        exit 1
    fi
fi

extrafiles=
while test "x$1" = "x--addfile"; do
    shift
    extrafiles="$extrafiles $1"
    shift
done

tempdir=`mktemp -d /tmp/iceccenvXXXXXX`

# for testing the environment is usable at all
add_file /bin/true

if test -n "$gcc"; then
    # getting compilers abs path
    added_gcc=$(abs_path $added_gcc)
    added_gxx=$(abs_path $added_gxx)

    if test -z "$clang"; then
        add_file $added_gcc /usr/bin/gcc
        add_file $added_gxx /usr/bin/g++
    else
        # HACK: The clang case below will add a wrapper in place of gcc, so add the real
        # gcc under a different name that the wrapper will call.
        add_file $added_gcc /usr/bin/gcc.bin
        add_file $added_gxx /usr/bin/g++.bin
    fi
    add_file `$added_gcc -print-prog-name=cc1` /usr/bin/cc1
    add_file `$added_gxx -print-prog-name=cc1plus` /usr/bin/cc1plus

    gcc_as=$($added_gcc -print-prog-name=as)
    if test "$gcc_as" = "as"; then
      add_file /usr/bin/as
    else
      add_file "$gcc_as" /usr/bin/as
    fi

    search_addfile $added_gcc specs
    search_addfile $added_gcc liblto_plugin.so
fi

if test -n "$clang"; then
    add_file $added_clang /usr/bin/clang
    # HACK: Older icecream remotes have /usr/bin/{gcc|g++} hardcoded and wouldn't
    # call /usr/bin/clang at all. So include a wrapper binary that will call gcc or clang
    # depending on an extra argument added by icecream.
    add_file $added_compilerwrapper /usr/bin/gcc
    add_file $added_compilerwrapper /usr/bin/g++

    add_file $($added_clang -print-prog-name=as) /usr/bin/as

    # clang always uses its internal .h files
    clangincludes=$(dirname $($added_clang -print-file-name=include/limits.h))
    clangprefix=$(dirname $(dirname $added_clang))
    for file in $(find $clangincludes -type f); do
      # get path without ..
      destfile=$(readlink -e $file)
      # and convert from <prefix> to /usr if needed
      destfile=$(echo $destfile | sed "s#$clangprefix#/usr#" )
      add_file "$file" "$destfile"
    done
fi

for extrafile in $extrafiles; do
    add_file $extrafile
done

# special case for weird multilib setups
for dir in /lib /lib64 /usr/lib /usr/lib64; do
    test -L $dir && cp -p $dir $tempdir$dir
done

new_target_files=
for i in $target_files; do
 case $i in
   *=/*)
    target=`echo $i | cut -d= -f1`
    path=`echo $i | cut -d= -f2`
    ;;
   *)
    path=$i
    target=$i
    ;;
  esac
  mkdir -p $tempdir/`dirname $target`
  cp -p $path $tempdir/$target
  if test -f $tempdir/$target -a -x $tempdir/$target; then
    strip -s $tempdir/$target 2>/dev/null
  fi
  target=`echo $target | cut -b2-`
  new_target_files="$new_target_files $target"
done

#sort the files
target_files=`for i in $new_target_files; do echo $i; done | sort`

#test if an archive name was supplied
#if not use the md5 of all files as the archive name
if test -z "$archive_name"; then
  md5sum=NONE
  for file in /usr/bin/md5sum /bin/md5 /usr/bin/md5 /sbin/md5; do
     if test -x $file; then
       md5sum=$file
       break
     fi
  done

  #calculate md5 and use it as the archive name
  archive_name=`for i in $target_files; do test -f $tempdir/$i && $md5sum $tempdir/$i; done | sed -e 's/ .*$//' | $md5sum | sed -e 's/ .*$//'`.tar.gz || {
    if test -z "$silent"; then
     echo "Couldn't compute MD5 sum."
    fi
    exit 2
  }
  mydir=`pwd`
else
  mydir="`dirname "$archive_name"`"

  #check if we have a full path or only a filename
  if test "$mydir" = "." ; then
    mydir=`pwd`
  else
    mydir=""
  fi
fi

if test -z "$silent"; then
echo "creating $archive_name"
fi

cd $tempdir
tar -czhf "$mydir/$archive_name" $target_files || {
 if test -z "$silent"; then
  echo "Couldn't create archive"
 fi
  exit 3
}
cd ..
rm -rf $tempdir