#!/bin/sh

 # Get our required options

 base="$1"

 src="$2"

 dst="$3"

 shift 3

 # The remainder is for diff

 diff="$@"

 do_help() {

     cat <<-_EOF_

 		${0##*/}: transform a patchset of non-p1 patches into -p1 patches

 		Usage:

 		    ${0##*/} <basedir> <src> <dst> [diffopts ...]

 		Where:

 		    basedir

 		        points to the directory of the component to patch

 		    src

 		        points to the directory containing the existing patchset

 		        to transform

 		    dst

 		        points to the directory where to put transformed patches

 		    diffopts

 		        optional options to pass to diff, for debug purposes. You

 		        should not need it

 		Example:

 		    Transform Gentoo patches against gcc-4.4.2 (some of which are

 		    -p0, -p1 or even -p2 patches) into all -p1 patches:

 		        tar xjf gcc-4.4.2.tar.bz2

 		        patch-rework.sh gcc-4.4.2                   \\

 		                        /path/to/gentoo/gcc/patches \\

 		                        gcc-4.4.2.patches

 		_EOF_

 }

 # Sanity checks

 if [    -z "${base}"                    \

      -o ! -d "${base}"                  \

      -o ! -d "${src}"                   \

      -o -e "${dst}" -a ! -d "${dst}"    \

    ]; then

 	do_help

 	exit 1

 fi

 mkdir -p "${dst}"

 base="${base%%/}"

 src="$( cd "${src}"; pwd )"

 dst="$( cd "${dst}"; pwd )"

 # This function checks that the files listed in the file in "$1"

 # do exist, at the given depth-stripping level (aka diff -p#)

 do_check_files_at_depth() {

   local flist="$1"

   local depth="$2"

   local ret=0   # 0: OK,  !0: KO

   exec 6<&0

   exec 7<"${flist}"

   while read -u7 f; do

     f="$( echo "${f}" |sed -r -e "s:^([^/]+/){${depth}}::;" )"

     [ -f "${f}" ] || ret=1

   done

   exec 7<&-

   exec <&6

   return ${ret}

 }

 # Iterate through patches

 for p in "${src}/"*.patch; do

   pname="$( basename "${p}" )"

   printf "Handling patch '${pname}'...\n"

   printf "  creating reference..."

   cp -a "${base}" "${base}.orig"

   printf " done\n"

   printf "  retrieving patch comment..."

   comment="$( awk '

 BEGIN { mark=0; }

 $0~/^diff --/ { nextfile; }

 $1=="---" { mark=1; next; }

 $1=="+++" && mark==1 { nextfile; }

 { mark=0; print; }

 ' "${p}" )"

   printf " done\n"

   printf "  creating patched file list..."

   diffstat -f 4 -r 2 -u -p 0 "${p}"                         \

   |head -n -1                                               \

   |awk '{ for(i=NF;i>=NF-5;i--) { $(i) = ""; } print; }'    \

   |sort                                                     \

   >"diffstat.orig"

   printf " done\n"

   pushd "${base}" >/dev/null 2>&1

   # Check all files exist, up to depth 3

   printf "  checking depth:"

   for((d=0;d<4;d++)); do

     printf " ${d}"

     if do_check_files_at_depth "../diffstat.orig" ${d}; then

       printf " ok, using depth '${d}'\n"

       break

     fi

   done

   if [ ${d} -ge 4 ]; then

     printf "\n"

     printf "  checking depth failed\n"

     read -p "  --> enter patch depth (or Ctrl-C to abort): " d

   fi

   # Store the original list of files touched by the patch,

   # removing the $d leading components

   sed -r -e "s:^([^/]+/){${d}}::;" "../diffstat.orig" >"${dst}/${pname}.diffstat.orig"

   # Apply the patch proper, and check it applied cleanly.

   # We can't check with --dry-run because of patches that

   # contain multiple accumulated patches onto a single file.

   printf "  applying patch..."

   if ! patch -g0 -F1 -f -p${d} <"${p}" >"../patch.out" 2>&1; then

     printf " ERROR\n\n"

     popd >/dev/null 2>&1

     printf "There was an error while applying:\n  -->  ${p}  <--\n"

     printf "'${base}' was restored to the state it was prior to applying this faulty patch.\n"

     printf "Here's the 'patch' command, and its output:\n"

     printf "  ----8<----\n"

     printf "  patch -g0 -F1 -f -p${d} <'${p}'\n"

     sed -r -e 's/^/  /;' "patch.out"

     printf "  ----8<----\n"

     exit 1

   fi

   printf " done\n"

   printf "  removing '.orig' files..."

   find . -type f -name '*.orig' -exec rm -f {} +

   printf " done\n"

   popd >/dev/null 2>&1

   printf "  re-diffing the patch..."

   printf "%s\n\n" "${comment}" >"${dst}/${pname}"

   diff -durN "${base}.orig" "${base}" >>"${dst}/${pname}"

   printf " done\n"

   if [ -n "${diff}" ]; then

     printf "  applying diff filter..."

     filterdiff -x "${diff}" "${dst}/${pname}" >"tmp-diff"

     mv "tmp-diff" "${dst}/${pname}"

     printf " done\n"

   fi

   printf "  creating new patched file list..."

   diffstat -f 4 -r 2 -u -p 1 "${dst}/${pname}"              \

   |head -n -1                                               \

   |awk '{ for(i=NF;i>=NF-5;i--) { $(i) = ""; } print; }'    \

   |sort                                                     \

   >"${dst}/${pname}.diffstat.new"

   printf " done\n"

   printf "  removing temporary files/dirs..."

   rm -f "patch.out"

   rm -f "diffstat.tmp"

   rm -f "diffstat.orig"

   rm -rf "${base}.orig"

   printf " done\n"

 done

 # Scan all new patches to see if they touch

 # more files than the original patches

 printf "\nChecking resulting patchset:\n"

 for p in "${dst}/"*.patch; do

   pname="$( basename "${p}" )"

   if ! cmp "${p}.diffstat.orig" "${p}.diffstat.new" >/dev/null; then

     printf "  --> '${pname}' differ in touched files <--\n"

   else

     rm -f "${p}.diffstat.orig" "${p}.diffstat.new"

   fi

 done

 printf "  done.\n"