mulle-objc-unarchive

#! /usr/bin/env mulle-bash
#
# this script unpacks an .a file and creates a list of defined methods
# for each .o file
#

MULLE_EXECUTABLE_VERSION=0.9.1

MULLE_EXECUTABLE_FUNCTIONS_MIN="3.9"
MULLE_EXECUTABLE_FUNCTIONS_MAX="4"


usage()
{
   cat <<EOF >&2
Usage:
   ${MULLE_USAGE_NAME} [options] [library] ...

   Unarchive the given static libraries and prepare them for optimization.
   If no libraries are given, ${MULLE_USAGE_NAME} will unarchive all static
   libraries contained in \${MULLE_SDK_DIR}/lib unless a different directory
   has been specified with --library-path.

Options:
   --library-path <dir>  : list of directories to unarchive libraries from
   --unarchive-dir <dir> : where to unarchive libraries to

EOF

   options_technical_flags_usage | sort >&2

   exit 1
}


r_shlib_cflags()
{
   case "${MULLE_UNAME}" in
      darwin)
         RVAL="-fno-common"
      ;;

      *)
         RVAL="-fPIC -fno-common"
       ;;
   esac
}


r_shlib_ldflags()
{
   case "${MULLE_UNAME}" in
      darwin)
         RVAL="-dynamiclib -all_load -Os -flat_namespace -undefined suppress"
      ;;

      *)
         RVAL="-shared"
       ;;
   esac
}


#
# read symbols from .o file, figure out the ones that we need to "spoof"
# so that we can dummy link it
#
nm_global_undefined_names()
{
   local filename="$1"

   case "${MULLE_UNAME}" in
      darwin)
         exekutor nm -g -u -j "${filename}"
      ;;

      linux|*)
         # -p no sort, -P posix style (name first)
         exekutor nm -g --undefined-only -p -P "${filename}" | awk '{ print $1} '
      ;;
   esac

}


create_undefined_linkage_c()
{
   local infile="$1"

   local symbols

   # global, undefined, no type info
   case "${MULLE_UNAME}" in
      darwin)
         symbols="`nm_global_undefined_names "${infile}" | sed 's/^_//'`" || exit 1
      ;;

      *)
         symbols="`nm_global_undefined_names "${infile}"`" || exit 1
      ;;
   esac


   local i

   #
   # if we redefine standard library symbols, the compiler is not
   # happy so we copy the definitions here
   #
   # egrep '^LIBBUILTIN' mulle-clang/include/clang/Basic/Builtins.def | \
   #  sed s'/^LIBBUILTIN(\([^,]*\).*$/\1/' | \
   #  sort | \
   #  sed s'/\(.*\)/         \1) ;;/'
   #
   for i in ${symbols}
   do
      case $i in
#         NSLog) ;;
#         NSLogv) ;;
         _Block_object_assign) ;;
         _Block_object_dispose) ;;
         _Exit) ;;
         __cospi);;
         __cospif) ;;
         __exp10) ;;
         __exp10f) ;;
         __finite) ;;
         __finitef) ;;
         __finitel) ;;
         __sigsetjmp) ;;
         __sinpi);;
         __sinpif) ;;
         __tanpi) ;;
         __tanpif) ;;
         _byteswap_uint64) ;;
         _byteswap_ulong) ;;
         _byteswap_ushort);;
         _longjmp) ;;
         _setjmp) ;;
         _setjmpex) ;;
         abs) ;;
         acos) ;;
         acosf) ;;
         acosh) ;;
         acoshf) ;;
         acoshl) ;;
         acosl) ;;
         alloca);;
         asin) ;;
         asinf) ;;
         asinh) ;;
         asinhf) ;;
         asinhl) ;;
         asinl) ;;
         atan) ;;
         atan2) ;;
         atan2f) ;;
         atan2l) ;;
         atanf) ;;
         atanh);;
         atanhf) ;;
         atanhl) ;;
         atanl) ;;
         bzero) ;;
         cabs) ;;
         cabsf) ;;
         cabsl) ;;
         cacos) ;;
         cacosf) ;;
         cacosh) ;;
         cacoshf);;
         cacoshl) ;;
         cacosl) ;;
         calloc) ;;
         carg) ;;
         cargf) ;;
         cargl) ;;
         casin) ;;
         casinf) ;;
         casinh) ;;
         casinhf) ;;
         casinhl);;
         casinl) ;;
         catan) ;;
         catanf) ;;
         catanh) ;;
         catanhf) ;;
         catanhl) ;;
         catanl) ;;
         cbrt) ;;
         cbrtf) ;;
         cbrtl) ;;
         ccos) ;;
         ccosf);;
         ccosh) ;;
         ccoshf) ;;
         ccoshl) ;;
         ccosl) ;;
         ceil) ;;
         ceilf) ;;
         ceill) ;;
         cexp) ;;
         cexpf) ;;
         cexpl) ;;
         cimag) ;;
         cimagf);;
         cimagl) ;;
         clog) ;;
         clogf) ;;
         clogl) ;;
         conj) ;;
         conjf) ;;
         conjl) ;;
         copysign) ;;
         copysignf) ;;
         copysignl) ;;
         cos);;
         cosf) ;;
         cosh) ;;
         coshf) ;;
         coshl) ;;
         cosl) ;;
         cpow) ;;
         cpowf) ;;
         cpowl) ;;
         cproj) ;;
         cprojf) ;;
         cprojl) ;;
         creal) ;;
         crealf);;
         creall) ;;
         csin) ;;
         csinf) ;;
         csinh) ;;
         csinhf) ;;
         csinhl) ;;
         csinl) ;;
         csqrt) ;;
         csqrtf) ;;
         csqrtl) ;;
         ctan) ;;
         ctanf);;
         ctanh) ;;
         ctanhf) ;;
         ctanhl) ;;
         ctanl) ;;
         erf) ;;
         erfc) ;;
         erfcf) ;;
         erfcl) ;;
         erff) ;;
         erfl) ;;
         exp) ;;
         exp2) ;;
         exp2f) ;;
         exp2l);;
         expf) ;;
         expl) ;;
         expm1) ;;
         expm1f) ;;
         expm1l) ;;
         fabs) ;;
         fabsf) ;;
         fabsl) ;;
         fdim) ;;
         fdimf) ;;
         fdiml) ;;
         finite);;
         finitef) ;;
         finitel) ;;
         floor) ;;
         floorf) ;;
         floorl) ;;
         fma) ;;
         fmaf) ;;
         fmal) ;;
         fmax) ;;
         fmaxf) ;;
         fmaxl) ;;
         fmin) ;;
         fminf) ;;
         fminl) ;;
         fmod) ;;
         fmodf) ;;
         fmodl) ;;
         fprintf) ;;
         frexp) ;;
         frexpf) ;;
         frexpl) ;;
         fscanf) ;;
         getcontext) ;;
         hypot) ;;
         hypotf) ;;
         hypotl) ;;
         ilogb) ;;
         ilogbf) ;;
         ilogbl) ;;
         index) ;;
         isalnum) ;;
         isalpha) ;;
         isblank) ;;
         iscntrl) ;;
         isdigit) ;;
         isgraph) ;;
         islower) ;;
         isprint) ;;
         ispunct) ;;
         isspace) ;;
         isupper) ;;
         isxdigit) ;;
         labs) ;;
         ldexp) ;;
         ldexpf) ;;
         ldexpl) ;;
         lgamma) ;;
         lgammaf) ;;
         lgammal) ;;
         llabs) ;;
#         llrint) ;;
#         llrintf) ;;
#         llrintl) ;;
         llround) ;;
         llroundf) ;;
         llroundl) ;;
         log) ;;
         log10) ;;
         log10f) ;;
         log10l) ;;
         log1p) ;;
         log1pf) ;;
         log1pl) ;;
         log2) ;;
         log2f) ;;
         log2l) ;;
         logb) ;;
         logbf) ;;
         logbl) ;;
         logf) ;;
         logl) ;;
         longjmp) ;;
         lrint) ;;
         lrintf) ;;
         lrintl) ;;
         lround) ;;
         lroundf) ;;
         lroundl) ;;
         malloc) ;;
         memchr) ;;
         memcmp) ;;
         memcpy) ;;
         memmove) ;;
         memset) ;;
         modf) ;;
         modff) ;;
         modfl) ;;
         nan) ;;
         nanf) ;;
         nanl) ;;
         nearbyint) ;;
         nearbyintf) ;;
         nearbyintl) ;;
         nextafter) ;;
         nextafterf) ;;
         nextafterl) ;;
         nexttoward) ;;
         nexttowardf) ;;
         nexttowardl) ;;
         objc_assign_global) ;;
         objc_assign_ivar) ;;
         objc_assign_strongCast) ;;
         objc_assign_weak) ;;
         objc_enumerationMutation) ;;
         objc_exception_extract) ;;
         objc_exception_match) ;;
         objc_exception_throw) ;;
         objc_exception_tryenter) ;;
         objc_exception_tryexit) ;;
         objc_getClass) ;;
         objc_getMetaClass) ;;
         objc_msgSend) ;;
         objc_msgSendSuper) ;;
         objc_msgSendSuper_stret) ;;
         objc_msgSend_fp2ret) ;;
         objc_msgSend_fpret) ;;
         objc_msgSend_stret) ;;
         objc_read_weak) ;;
         objc_sync_enter) ;;
         objc_sync_exit) ;;
         pow) ;;
         powf) ;;
         powl) ;;
         printf) ;;
         qsetjmp) ;;
         realloc) ;;
         remainder);;
         remainderf) ;;
         remainderl) ;;
         rindex) ;;
         rint) ;;
         rintf) ;;
         rintl) ;;
         round) ;;
         roundf) ;;
         roundl) ;;
         savectx);;
         scalbln) ;;
         scalblnf) ;;
         scalblnl) ;;
         scalbn) ;;
         scalbnf) ;;
         scalbnl) ;;
         scanf) ;;
         setjmp) ;;
         setjmp_syscall);;
         siglongjmp) ;;
         sigsetjmp) ;;
         sin) ;;
         sinf) ;;
         sinh) ;;
         sinhf) ;;
         sinhl) ;;
         sinl) ;;
         snprintf) ;;
         sprintf) ;;
         sqrt);;
         sqrtf) ;;
         sqrtl) ;;
         sscanf) ;;
         stpcpy) ;;
         stpncpy) ;;
         strcasecmp) ;;
         strcat) ;;
         strchr) ;;
         strcmp) ;;
         strcpy);;
         strcspn) ;;
         strdup) ;;
         strerror) ;;
         strlcat) ;;
         strlcpy) ;;
         strlen) ;;
         strncasecmp) ;;
         strncat) ;;
         strncmp);;
         strncpy) ;;
         strndup) ;;
         strpbrk) ;;
         strrchr) ;;
         strspn) ;;
         strstr) ;;
         strtok) ;;
         strxfrm) ;;
         tan) ;;
         tanf) ;;
         tanh);;
         tanhf) ;;
         tanhl) ;;
         tanl) ;;
         tgamma) ;;
         tgammaf) ;;
         tgammal) ;;
         tolower) ;;
         toupper) ;;
         trunc) ;;
         truncf) ;;
         truncl);;
         vfork) ;;
         vfprintf) ;;
         vfscanf) ;;
         vprintf) ;;
         vscanf) ;;
         vsnprintf) ;;
         vsprintf) ;;
         vsscanf) ;;
         wcschr);;
         wcscmp) ;;
         wcslen) ;;
         wcsncmp) ;;
         wmemchr) ;;
         wmemcmp) ;;
# CRT symbols
         _GLOBAL_OFFSET_TABLE_) ;;

         mulle_objc_loadinfo_enqueue_nofail) ;;

         *)
            echo "void  $i() {}"
         ;;
      esac
   done
}


#
# create a  .o file with (almost) all the symbols that
# are missing from "$1"
#
create_undefined_linkage()
{
   log_entry "create_undefined_linkage" "$@"

   local infile="$1"
   local outfile="$2"

   local text

   text="`create_undefined_linkage_c "${infile}"`"
   if [ -z "${text}" ]
   then
      log_fluff "No undefined symbols to spoof for \"${infile}\""
      return 1
   fi

   local cfile
   local folder

   r_dirname "${outfile}"
   folder="${RVAL}"

   cfile="${folder}/`basename -- "${outfile}" .o`".c
   redirect_exekutor "${cfile}" echo "${text}"

   local cflags

   r_shlib_cflags
   cflags="${RVAL}"

   log_fluff "Compile undefined symbol linkage \"${cfile}\"..."
   exekutor mulle-clang ${cflags} -w \
                                  -c \
                                  -o "${outfile}" \
                                  "${cfile}" || exit 1
}


r_name_from_library()
{
   log_entry "r_name_from_library" "$@"

   local library="$1"

   # remove extension
   r_extensionless_basename "${library}"

   # remove prefix
   RVAL="${RVAL#${MULLE_PLATFORM_LIBRARY_PREFIX}}"
   # remove Standalone suffix (old)
   RVAL="${RVAL%Standalone}"
   RVAL="${RVAL-standalone}"
}


r_foldername_from_library()
{
   log_entry "r_foldername_from_library" "$@"

   local library="$1"
   local prefix="$2"

   r_name_from_library "${library}"
   RVAL="${prefix}${RVAL}.d"
}


#
# create a shared library for each .o file
#
create_shlibs()
{
   log_entry "create_shlibs" "$@"

   local folder="$1"

   local i
   local name
   local undefined
   local files
   local shlib

   local ext
   local ldflags

   ext="${MULLE_PLATFORM_LIBRARY_SUFFIX_DYNAMIC}"
   r_shlib_ldflags
   ldflags="${RVAL}"

   for i in "${folder}/"*.o
   do
      case "${i}" in
         "${folder}/*.o")
            log_warning "No .o files found in \"${folder}\""
            continue
         ;;

         #
         # can happen in non-optimizable case, where we still produce
         # method-db.csv and class-db.csv
         #
         "${folder}/MulleObjCLoader"*)
            continue
         ;;
      esac

      r_basename "$i"
      name="${RVAL%.o}"
      undefined="${folder}/${name}.undef.o"
      files="${i}"
      shlib="${folder}/${name}${ext}"

      if create_undefined_linkage "${i}" "${undefined}"
      then
         files="${files} ${undefined}" # order important for linux ?
      fi

      log_fluff "Create shlib \"${shlib}\"..."

      exekutor mulle-clang ${ldflags} ${files} -o "${shlib}" \
      || fail "Failed to produce \"${shlib}\", can't optimize \"${name}\""

      if [ "${OPTION_KEEP_TMP}" = "YES" ]
      then
         exekutor mv "${undefined}" "${undefined}.tmp"
      else
         remove_file_if_present "${undefined}"
      fi
   done

   return 0
}


unpack_library_into_folder()
{
   log_entry "unpack_library_into_folder" "$@"

   local library="$1"
   local folder="$2"

   if [ -d "${folder}" ]
   then
      exekutor rm -rf "${folder}" || return 1
   fi

   case "${library}" in
      /*|~*)
      ;;

      *)
         library="`pwd -P`/${library}"
      ;;
   esac

   (
      mkdir_if_missing "${folder}" &&
      exekutor cd "${folder}" &&
      exekutor ar x "${library}"
   ) || return 1
}


emit_loader_source()
{
   log_entry "emit_loader_source" "$@"

   name="$1"

   cat <<EOF
#include <MulleObjC/MulleObjC.h>


@implementation MulleObjCLoader( ${name})

+ (struct _mulle_objc_dependency *) dependencies
{
   static struct _mulle_objc_dependency   dependencies[] =
   {
#include "dependencies-objc-loader.inc"
#include "class-objc-loader.inc"
#include "category-objc-loader.inc"
      { MULLE_OBJC_NO_CLASSID, MULLE_OBJC_NO_CATEGORYID }
   };

   return( dependencies);
}

@end
EOF
}


prepare_for_optimizer()
{
   log_entry "prepare_for_optimizer" "$*"

   local folder="$1"
   local infofolder="$2"
   local library="$3"

   local name
   local includedir
   local libpath
   local libdir

   r_absolutepath "${library}"
   libpath="${RVAL}"
   r_dirname "${libpath}"
   libdir="${RVAL}"
   r_name_from_library "${library}"
   name="${RVAL}"
   includedir="${libdir}/../include/${name}"

   r_simplified_absolutepath "${includedir}"
   includedir="${RVAL}"

   local count
   local has_objc
   local loaderinc

   loaderinc="${includedir}/objc-loader.inc"

   count="`ls -1 "${folder}/MulleObjCLoader"*.o 2> /dev/null | wc -l | awk '{ print $1 }'`"
   case "${count}" in
      1)
         if [ ! -f "${loaderinc}" ]
         then
            log_warning "\"${name}\" is not optimizable as \"${loaderinc}\" was not found"
            exekutor touch "${infofolder}/.unoptimizable" || exit 1
            return
         fi
         # fall thru
      ;;

      0)
         #
         # if it's a plain c library, memorize this
         #
         has_objc="`mulle-objc-lista -i "${libpath}" 2> /dev/null`"
         if [ -z "${has_objc}" ]
         then
            log_fluff "\"${name}\" has been deemed C only"
            exekutor touch "${infofolder}/.c_only" || exit 1
         else
            log_warning "\"${name}\" is not optimizable as it contains no MulleObjCLoader category .o file"
            exekutor touch "${infofolder}/.unoptimizable" || exit 1
         fi

         return
      ;;

      *)
         log_warning "\"${name}\" is not optimizable as it contains multiple MulleObjCLoader category .o files"
         exekutor touch "${infofolder}/.unoptimizable" || exit 1

         return
      ;;
   esac

   local loader
   local filename
   local loadername
   local categoryname

   loader="`ls -1 "${folder}/MulleObjCLoader"*.o`"
   r_basename "${loader}"
   filename="${RVAL}"
   loadername="${filename%%.*}"
   categoryname="${loadername/MulleObjCLoader[ _+-]/}"

   if [ -z "${categoryname}" ]
   then
      log_info "\"${name}\" is not optimizable as it contains the MulleObjCLoader class .o file"
      exekutor touch "${infofolder}/.unoptimizable" || exit 1
      return
   fi

   if [ "${categoryname}" != "${name}" ]
   then
      log_warning "\"${name}\" is not optimizable as it contains \"${filename}\", but expected \"MulleObjCLoader+${name}.o\""
      exekutor touch "${infofolder}/.unoptimizable" || exit 1
      return 1
   fi

   log_fluff "Loader \"${filename}\" and \"objc-loader.inc\" found"

   # keep comments only
   redirect_exekutor "${folder}/dependencies_db.csv" \
      sed 's|^.*// *||' "${loaderinc}"

   # Grab MulleObjCLoader statements (47a9beb6->MulleObjCLoader)
   exekutor egrep '// *47a9beb6;' "${loaderinc}" \
   | redirect_exekutor "${infofolder}/dependencies-objc-loader.inc" fgrep -v ';;'

   redirect_exekutor "${folder}/MulleObjCLoader+${name}.m" \
      emit_loader_source "${name}"

   #
   # remove the loader that we will regenerate later
   #
   exekutor rm -f "${loader}" || fail "Could not remove \"${loader}\""

   return 0
}


unpack_library()
{
   log_entry "unpack_library" "$@"

   local library="$1"

   local folder
   local infofolder
   local name

   [ ! -f "${library}" ] && fail "\"${library}\" not found"

   r_foldername_from_library "${library}" "${UNARCHIVE_PREFIX}"
   folder="${RVAL}"

   if [ "${OPTION_FORCE}" = "NO" ] && [ "${folder}/.unpack_done" -nt "${library}" ]
   then
      log_verbose "${folder} is up to date"
      return 0
   fi

   r_name_from_library "${library}"
   name="${RVAL}"

   log_info "Unpacking ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE} ..."

   unpack_library_into_folder "${library}" "${folder}" || fail "unpack failed"

   if [ "${OPTION_JUST_UNPACK}" = 'YES' ]
   then
      log_verbose "Unpacked ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE}"
   else
      r_foldername_from_library "${library}" "${UNARCHIVE_INFO_PREFIX}"
      infofolder="${RVAL}"

      mkdir_if_missing "${infofolder}"
      prepare_for_optimizer "${folder}" "${infofolder}" "${library}"

      if [ ! -f "${infofolder}/.c_only" ]
      then
         if [ ! -f "${infofolder}/.unoptimizable" ]
         then
            create_shlibs "${folder}"

            log_verbose "Unpacked ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE} as ObjC"

            #
            # only in this case do we want to post-process
            #
            echo "${library}"
         else
            log_verbose "Unpacked ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE} as unoptimizable ObjC"
         fi
      else
         log_verbose "Unpacked ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE} as C"
      fi
   fi

   exekutor touch "${folder}/.unpack_done"

   # global marker that something has changed
   exekutor touch "${UNARCHIVE_PREFIX}.unpack_done"
}


unpack_all()
{
   log_entry "unpack_all" "$@"

   while [ $# -ne 0 ]
   do
      unpack_library "$1" || return 1

      shift
   done
}


# run this with "folder" as PWD
create_method_csv()
{
   log_entry "create_method_csv" "$*"

   local folder="$1"

   local ext
   local ofile
   local name
   local sedexpr
   local shlib
   local libname

   ext="${MULLE_PLATFORM_LIBRARY_SUFFIX_DYNAMIC}"

# namespacing not needed because files are optimized within their folder only
#   r_basename "${folder}"
#   libname="${RVAL}"

   (
      cd "${folder}" || exit 1

      for shlib in *"${ext}"
      do
         if [ "${shlib}" = "*${ext}" ]
         then
            log_fluff "No shared libraries were produced"
            continue
         fi

         r_basename "${shlib}" "${ext}"
         name="${RVAL%${ext}}"
#         r_filepath_concat "${folder}" "${name}.o"
         ofile="${name}.o"

         log_fluff "Create entries for methods of \"${ofile}\"..."

         sedexpr="s|\$|;${ofile}|"
         ( rexekutor mulle-objc-list -T "${shlib}" | rexekutor sed -e "${sedexpr}" ) || exit 1
      done
   )
}


# run this with "folder" as PWD
create_class_csv()
{
   log_entry "create_class_csv" "$*"

   local folder="$1"

   local ext
   local i
   local name
   local sedexpr
   local shlib
   local ofile
#   local libname

   ext="${MULLE_PLATFORM_LIBRARY_SUFFIX_DYNAMIC}"

#   r_basename "${folder}"
#   libname="${RVAL}"
   (
      cd "${folder}" || exit 1

      for shlib in *"${ext}"
      do
         if [ "${shlib}" = "*${ext}" ]
         then
            log_fluff "No shared libraries were produced"
            continue
         fi

         r_basename "${shlib}" "${ext}"
         name="${RVAL%${ext}}"
#         r_filepath_concat "${folder}" "${name}.o"
         ofile="${name}.o"

         log_fluff "Create entries for classes of \"$ofile\"..."

         sedexpr="s|\$|;${ofile}|"
         ( exekutor mulle-objc-list -C "${shlib}" | exekutor sed "${sedexpr}" ) \
         || fail "mulle-objc-list \"${shlib}\" failed"
      done
   )
}


create_method_csv_db()
{
   log_entry "create_method_csv_db" "$*"

   local folder="$1"
   local infofolder="$2"

   log_fluff "Add methods in \"${folder}\" ..."

   redirect_exekutor "${infofolder}/method_db.csv" \
      create_method_csv "${folder}" || fail "failed to produce method_db.csv"
}


create_class_csv_db()
{
   log_entry "create_class_csv_db" "$*"

   local folder="$1"
   local infofolder="$2"

   log_fluff "Add classes in \"${folder}\" ..."

   redirect_exekutor "${infofolder}/class_db.csv" \
      create_class_csv "${folder}" || fail "failed to produce class_db.csv"
}


clean_folder_tmp()
{
   log_entry "clean_folder_tmp" "$*"

   local folder="$1"

   ext="${MULLE_PLATFORM_LIBRARY_SUFFIX_DYNAMIC}"

   log_fluff "Removing shlibs in \"${folder}\" ..."

   (
      cd "${folder}" && exekutor rm -f *"${ext}" 2> /dev/null
   )
}


create_databases()
{
   log_entry "create_databases" "$@"

   libraries="$1"

   [ -e "${UNARCHIVE_PREFIX}.unpack_done" ] || internal_fail "\"${UNARCHIVE_PREFIX}.unpack_done\" is missing"

   if [ "${OPTION_FORCE}" = "NO" ] &&
      [ "${UNARCHIVE_INFO_PREFIX}.unarchive_done" -nt "${UNARCHIVE_PREFIX}.unpack_done" ]
   then
      log_info "Database files are up to date"
      return
   fi

   local old
   local lib
   local folder
   local infofolder
   local name

   .foreachline lib in ${libraries}
   .do
      r_foldername_from_library "${lib}" "${UNARCHIVE_PREFIX}"
      folder="${RVAL}"
      r_foldername_from_library "${lib}" "${UNARCHIVE_INFO_PREFIX}"
      infofolder="${RVAL}"

      r_name_from_library "${lib}"
      name="${RVAL}"

      log_setting "name       : ${name}"
      log_setting "folder     : ${folder}"
      log_setting "infofolder : ${infofolder}"

      [ -e "${folder}/.unpack_done" ] || internal_fail "\"${folder}/.unpack_done\" is missing"

      if [ ! -f "${infofolder}/.c_only" ]
      then
         log_verbose "Create databases for ${C_MAGENTA}${C_BOLD}${name}${C_VERBOSE} ..."

         create_method_csv_db "${folder}" "${infofolder}"
         create_class_csv_db "${folder}" "${infofolder}"

         if [ "${OPTION_KEEP_TMP}" = "NO" ]
         then
            clean_folder_tmp "${folder}"
         fi

         exekutor touch "${infofolder}/.unarchive_done"
      else
         log_fluff "${lib} is C only"
      fi
   .done

   mkdir_if_missing "${UNARCHIVE_INFO_PREFIX}"
   exekutor touch "${UNARCHIVE_INFO_PREFIX}.unarchive_done"
}


unarchive()
{
   log_entry "unarchive" "$@"

   if [ $# -ne 0 ]
   then
      log_info "Unpacking libraries ..."
      unpack_all "$@"
      return $?
   fi

   [ -z "${LIBRARY_PATH}" ] && usage

   local directory
   local libext
   local lib
   local i

   .foreachpath directory in ${LIBRARY_PATH}
   .do
      if [ ! -d "${directory}" ]
      then
         .continue
      fi

      log_info "Unpacking libraries found in ${C_RESET}${C_BOLD}${directory}${C_INFO} ..."

      libext="${MULLE_PLATFORM_LIBRARY_SUFFIX_STATIC}"

      IFS=$'\n'
      for i in `ls -1 "${directory}"/*${libext}`
      do
         unpack_library "$i" || return 1
      done
   .done

   return 0
}


main()
{
   local UNARCHIVE_PREFIX=""
   local UNARCHIVE_INFO_PREFIX=""
   local DB_PREFIX=""
   local OPTION_FORCE="NO"
   local OPTION_KEEP_TMP="NO"
   local LIBRARY_PATH
   local OPTION_JUST_UNPACK='NO'

   while [ $# -ne 0 ]
   do
      if options_technical_flags "$1"
      then
         shift
         continue
      fi

      # your option handling
      case "$1" in
         --version)
            echo "${MULLE_EXECUTABLE_VERSION}"
            exit 0
         ;;

         -f|--force)
            OPTION_FORCE='YES'
         ;;

         --keep-tmp)
            OPTION_KEEP_TMP='YES'
         ;;

         --just-unpack)
            OPTION_JUST_UNPACK='YES'
         ;;

         --library-path)
            [ $# -eq 1 ] && fail "missing argument to $1"
            shift

            LIBRARY_PATH="$1"
         ;;

         --unarchive-dir)
            [ $# -eq 1 ] && fail "missing argument to $1"
            shift

            UNARCHIVE_PREFIX="$1"
            UNARCHIVE_PREFIX="${UNARCHIVE_PREFIX%%/}/"
         ;;

         --unarchive-info-dir)
            [ $# -eq 1 ] && fail "missing argument to $1"
            shift

            UNARCHIVE_INFO_PREFIX="$1"
            UNARCHIVE_INFO_PREFIX="${UNARCHIVE_INFO_PREFIX%%/}/"
         ;;

         -h|--help)
            usage
         ;;

         -*)
            fail "unknown option $1"
         ;;

         *)
            break
         ;;
      esac

      shift
   done

   options_setup_trace "${MULLE_TRACE}" && set -x

   if [ -z "${MULLE_VIRTUAL_ROOT}" ]
   then
      MULLE_VIRTUAL_ROOT="`mulle-sde project-dir`"
      [ -z "${MULLE_VIRTUAL_ROOT}" ] && fail "MULLE_VIRTUAL_ROOT can not be determined"
   fi

   DEPENDENCY_DIR="${DEPENDENCY_DIR:-`mulle-sde dependency-dir`}"
   DEPENDENCY_DIR="${DEPENDENCY_DIR:-"${MULLE_VIRTUAL_ROOT}/dependency"}"

   LIBRARY_DIR="${LIBRARY_DIR:-"${DEPENDENCY_DIR}/lib"}"

   # default fallback
   UNARCHIVE_INFO_PREFIX="${UNARCHIVE_INFO_PREFIX:-${UNARCHIVE_PREFIX}}"

   if [ -z "`command -v mulle-platform`" ]
   then
      fail "mulle-platform not in PATH"
   fi

   local MULLE_PLATFORM_FRAMEWORK_PATH_LDFLAG
   local MULLE_PLATFORM_FRAMEWORK_PREFIX
   local MULLE_PLATFORM_FRAMEWORK_SUFFIX
   local MULLE_PLATFORM_LIBRARY_LDFLAG
   local MULLE_PLATFORM_LIBRARY_PATH_LDFLAG
   local MULLE_PLATFORM_LIBRARY_PREFIX
   local MULLE_PLATFORM_LIBRARY_SUFFIX_STATIC
   local MULLE_PLATFORM_LIBRARY_SUFFIX_DYNAMIC
   local MULLE_PLATFORM_LINK_MODE
   local MULLE_PLATFORM_RPATH_LDFLAG
   local MULLE_PLATFORM_WHOLE_ARCHIVE_LDFLAG_DEFAULT
   local MULLE_PLATFORM_WHOLE_ARCHIVE_LDFLAG_STATIC

   eval_rexekutor `mulle-platform environment`

   log_setting "LIBRARY_DIR=${LIBRARY_DIR}"
   log_setting "UNARCHIVE_PREFIX=${UNARCHIVE_PREFIX}"
   log_setting "UNARCHIVE_INFO_PREFIX=${UNARCHIVE_INFO_PREFIX}"

   local libraries

   libraries="`unarchive "$@"`" || fail "Unpacking failed, exiting"

   if [ ! -z "${libraries}" ]
   then
      # your code follows here
      if [ -z "`command -v mulle-objc-list`" ]
      then
         fail "mulle-objc-list not in PATH"
      fi
      if [ -z "`command -v mulle-objc-lista`" ]
      then
         fail "mulle-objc-lista not in PATH"
      fi

      log_info "Creating object databases..."

      create_databases "${libraries}"

      log_info "Done"
   else
      log_info "Object databases are up to date."
   fi
}


main "$@"