#!/bin/bash
[ "$1" = "--bashx" ] && { shift ; /bin/bash -x "$0" "$@" ; exit ; }


	# Delete a field and shift the others to the left
awk_delfield=' function delfield(n,  _i) {
#		if(_i>=DNF) return;
		for(_i=n;_i<DNF;_i++)  $_i = $(_i+1);
		$DNF=""; DNF= DNF -1
};
{ DNF=NF }
function print_d(  _i){
		for(_i=1; _i < DNF; _i++) printf("%s%s",$_i,OFS);
		printf("%s%s",$_i, ORS);
};'


	# Escape double quotes
awk_esc=' function esc(s) { gsub(/"/,"\\\"",s); return s; }; '

awk_frange='function frange(fields, beg, end, valid,  _i, _n) { 
	beg = ncol(beg) ; end = ncol(end); if(""==end) end=beg; 
	if(beg < end) {
		for(_i=beg; _i <= end; _i++) if(!valid || _i<=NF) fields[++_n]=_i;
	} else {
		for(_i=beg; _i >= end; _i--) if(!valid || _i<=NF) fields[++_n]=_i;
	}
#if(NR==4){
#for(_i=1; _i<=_n;_i++) printf " " fields[_i] > "/dev/stderr"
#print " b:"beg " "end  > "/dev/stderr"
#}
	return _n;
};'

	# Translate logical (NF, negatives) to current row's field nubmers
awk_ncol='function ncol(str) {
		if("NF" == str)  return NF;
		if(0 > str+0) { if(NF+str<1) return 1; return NF+str}
		if(str+0 == str) return str;
		return "";
};'

	# Gnu awk only feature
awk_delete='function delete_a(a,  _i) { for(_i in _a) delete a[_i]; }'

cutpaths()
{ # beg [end] <  all > columns
	$AWK "$awk_delfield$awk_frange$awk_ncol$awk_delete"'
		BEGIN{FS="/";B="'"$1"'"; E="'"$2"'"; };
		{ delete_a(f); n=frange(f,B,E,1); s="";
		  for(i=1;i<=n;i++) { printf("%s%s",s,$f[i]); s="/" }
		  print ""
		}'
}

delpaths()
{ # [^][~]pat beg [end] <  all_cols > remaining_cols
	typeset  p="$1" b="$2" e="$3" if c  bz ez
	bz="$(echo "$b"|$AWK '{print $0+0}')"
	ez="$(echo "$e"|$AWK '{print $0+0}')"

	[ "$e" = "NF" ] && { b="$3" ; e="$2" ; }
	[ "$bz" -lt "$ez" ] && { b="$3" ; e="$2" ; }
	if [ ! -z "$p" ] ; then
		[ "${p:0:1}" = "^" ] && { c='!'; p="${p:1}" ; }
		if [ "${p:0:1}" = "~" ] ; then
			p="${p:1}"
			c="$c~"
		else
			[ -z "$c" ] && c='='
			c="$c="
		fi
		if='if($f[i] '"$c"' "'"$p"'")'
		[ ! -z "$SW_V" ] && echo "D: $if" >&2
	fi
	$AWK -F/ "$awk_delfield$awk_ncol$awk_frange$awk_delete"'
		BEGIN{ B="'"$b"'"; E="'"$e"'"; OFS="/" };
		B==0 {print "";next}
		{ delete_a(f); n=frange(f,B,E,1);
		  for(i=1;i<=n;i++) '"$if"' delfield(f[i]) }
		{print_d()}'
}


# ----------- These shortcuts reduce buffer copying -----------

gbr() { echoNL "$out" |cutpaths $1 $2 ; }
gbn() { echoNL "$out" |cutpaths $brange ; }
ghn() { echoNL "$hold" |cutpaths $hrange ; }

# Must not be called as a subprocess!!
sbr() { out="$(echoNL  "$out"  |subpaths "$1" $2 $3)" ; }
sbn() { out="$(echoNL  "$out"  |subpaths "$1" $brange)" ; }
shn() { hold="$(echoNL "$hold" |subpaths "$1" $hrange)" ; }

# ensure that we have at least NL lines
echoNL() { echo "$1"|$AWK '1;END{for(i=NR;i<'"$NL"';i++)print ""}' ; }

# ----------- -----------

extensions()
{ # extstring < text > replaced
	$AWK -F'\\.' "$awk_delfield"'BEGIN{ ext="'"$1"'";
		                  ep=substr(ext,1,1); ext=substr(ext,2);     # -|+
		                  if(substr(ext,1,1)==ep) {
		                    ep=ep ep; ext=substr(ext,2);             # --|++
		                  }
		                  i=index(ext,"e");
		                  es=substr(ext,1,i-1); ext=substr(ext,i+1); # n
		                  er=substr(ext,1,1); if(er=="/") ext=substr(ext,2);
		                  if(i = index(ext,"/")) {
		                    oext=substr(ext,1,i-1); ext=substr(ext,i+1);
		                  }
		                  OFS="."; esz=es+0; esf=es+1;
		                }
		ep=="--" && esz { d=0;
		                  for(i=NF; i>1 && d<es; i--) { # --ne[Ext]
		                    if(ext=="" || $i==ext) { delfield(i); d++ }
		                  }
		                  print_d() ; next
		                }
		                #printf("NF:"nf" er:"er" ep:"ep" ");
		NF>=esf && NF>1 {
		                  if(esf>1) nf = esf ; else nf = NF
		                  if(ep=="++") { $NF = $NF "." ext
		                                                # ++eExt
		                  } else if(er=="/") {
		                    if(ep=="+") {  $nf= ext     # +e/Ext (!forced)
		                    } else if(oext=="" || oext==$nf) $nf= ext
		                                                # -[n]e/[Ext]
		                  } else if(ep=="--") {
		                    if(ext=="") { DNF=1;        # --e
		                    } else {                    # --eExt
		                      for(i=2; i<=NF; i++) if($i==ext) delfield(i--);
		                    }                           # -[n]e[Ext]
		                  } else if($nf==ext || ext=="") delfield(nf)
		                }
		NF==esz         { if(ep=="+") $NF = $NF "." ext }
                                                                # +neExt
		!esz && NF==1   {
		                  if(ep=="+"||ep=="++") $NF = $NF "." ext
		                                                # +[+]e[/]Ext (!forced)
#		                  if(er=="/" && ep=="--") $NF = $NF "." ext
		                 # old way, use +e/Ext instead  # --e/Ext (forced)
		                }
				{print_d()}
	'
}

expoptions()
{ # abc [legal] > -a -b -c
	echo | $AWK 'END{O="'"$1"'";L="'"$2"'"; if(L=="")L=O; for(i=1;i<=length(O);i++){s=substr(O,i,1); if(index(L,s)) printf("-%s ",s)}}'
}

subpaths()
{ # paths beg [end] < orig > replaced
	[ "$2" = "0" ] && { echoNL "$1" ; return ; }
	typeset  awk_l="$(echoNL "$1"| $AWK "$awk_esc"'{print "L[" NR "]=\"" esc($0) "\";"}')"

	$AWK "$awk_delfield$awk_frange$awk_ncol$awk_delete"'
		BEGIN{FS="/";OFS=FS; B="'"$2"'"; E="'"$3"'";'"$awk_l"'};
		{ delete_a(f); n=frange(f,B,E,1); if(n) $f[1]=L[NR];
		  s=f[2]; for(i=2;i<=n;i++) delfield(s) }
	{print_d()}'
}

pasteCols()
{ # in out sep [-nb] > in out
	[ -z "$1$2" ] && return
	typeset  awk_in="$(echoNL "$1" | $AWK "$awk_esc"'{print "L[" NR "]=\"" esc($0) "\";"}')"

	[ "$4" != "-nb" ] && { awkb='{BK=0};/^$/||L[NR]~/^$/{BK=1};' ; }
	echoNL "$2" | $AWK "${awkb}BEGIN{$awk_in};"'!BK{print L[NR] "'"$3"'" $0}'
}

# must NOT be called as a subprocess!
filterN()
{ # [!] [-rs RS] [-fs FS] - linenumbers
	typeset  awk_ns fs=':' rs='\n' eq='' nl

	while [ $# -gt 0 ] ; do
		case "$1" in
			"!") eq='!' ;;
			-rs) shift ; rs="$1" ;;
			-fs) shift ; fs="$1" ;;
			-) shift ; break ;;
			*) break ;;
		esac
		shift
	done

	[ -z "$1" ] && { in=''; out='' ; return ; }
	awk_ns="$(echo "$1"| $AWK 'BEGIN{FS="'"$fs"'";RS="'"$rs"'"}; $1+0 == $1 {print "L[" $1 "]=1"}')"
	nl="$(echo "$awk_ns" |wc -l)"

	hold="$(echoNL "$hold"| $AWK "BEGIN{$awk_ns}; $eq"'L[NR]')"
	out="$( echoNL "$out" | $AWK "BEGIN{$awk_ns}; $eq"'L[NR]')"
	in="$(  echoNL "$in"  | $AWK "BEGIN{$awk_ns}; $eq"'L[NR]')"
	if [ -z "$eq" ] ; then  NL=$nl ; else  NL=$(($NL - nl)) ; fi
}

diffcols()
{ # in out > linenumbers
	awk_in="$(echoNL "$1" | $AWK "$awk_esc"'{print "L[" NR "]=\"" esc($0) "\";"}')"

	echoNL "$2" | $AWK "BEGIN{$awk_in};"'$0 != L[NR] {print NR}'
}

parseRange()
{ # rstr > beg end
	[ "${1:0:1}" != "%" ] && { echo NF ; return ; }
	typeset  b="$(echo "${1:1}"|sed -e'/^[-0-9]*/!d; s/:.*$//')"
	typeset  s="$(echo "${1:1}"|sed -e'/^[-0-9]*:/!d; s/^.*:.*$/:/')"
	typeset  e="$(echo "${1:1}"|sed -e'/^[-0-9]*:/!d; s/^.*://')"
	[ "$SW_V" = "-vr" ] && echo "bse($1):$b,$s,$e" >&2

	[ "$b" = "-" ] && b=NF
	[ "$e" = "-" ] && e=NF
	if [ -z "$s" ] ; then
		[ -z "$b" ] && b=0
	else
		[ -z "$b" ] && b=1
		[ -z "$e" ] && e=NF
	fi
	echo $b $e
}

parseRanges()
{ # b|h|c str > b(brange),h(hrange),c(cmd)
	typeset  b="$(echo "$2"| sed -e'/^-%/!d; s/-\(%[-0-9:]*\).*$/\1/')"
	typeset  h="$(echo "$2"| sed -e'/^-%[-0-9:]*%/!d; s/^-%[-0-9:]*\(%[-0-9:]*\).*$/\1/')"
	typeset  c="$(echo "$2"| sed -e's/^-[-%0-9:]*/-/')"

	[ "$SW_V" = "-vr" ] && echo -n "BHC($2):$b,$h,$c  " >&2

	case "$1" in
		b)  parseRange "$b" ;;
		h)  [ "${h:0:1}" != "%" ] && { parseRange "$b" ; return ; }
			parseRange "$h" ;;
		c) echo "$c" ;;
	esac
}

Usage()
{
	cat - >&2 <<EOF

  Usage(v$VER):  $PROG [OPTIONS] [-[%[-][n][:][-][m]][OPERATION]]...

  Operations:
   d[[^][~]pat]        delete current path section (matching 'pat')
   p[path]             discard main buffer contents and fill with 'path'
   s/pat/rep/          perform substitution with 'sed'
   t[flags] [s1 [s2]]  perform translation with 'tr'.  Flags: 'cCdsul'
   g[flags] pat        filter entries with 'grep'.  Flags: 'Fwvix'
   x cmd [arg]... ;    process the main buffer by executing cmd [args]
   xk|xf[sep] cmd...   like 'x', but keep/filter lines (marked like 'grep -n')
   hy|hs               yank/swap main buffer into/with hold buffer
   ha|hp[s]            append/prepend hold buffer to main buffer, 's' as separator
   hc|hn               keep main/hold buffers entries which are ('hn' not) common 
   hi                  place original entries in the hold buffer
   +[+]eEXT            add 'EXT' extension (2nd '+' forces addition)
   +e/EXT              set (replace or add) extension to 'EXT'
   -[n]e[EXT]          remove ('n'th) extension ('EXT' only) if it exists
   --[n]e              remove all (or up to 'n') extensions
   -[n]e/[OLD/]EXT     replace ('n'th)('OLD') extension with 'EXT'

  Options:
   -h              short help (usage) (*this*)
   --help          full help
   -+v             toggle verbose
   --|++debug      toggle debug (lots of output)

   -of|--ofirst    start interleaving with output entries
   -oo|--oonly     output entries only (omit input entries)
   -ob|--oblank    output pairs which contain blank input entries
   -oc|--ocommon   output common (unmodified) entries also
   -os|--osepSEP   set output separator to 'SEP' (default is newline)
   -ot             set output separator to a tab (for easier analysis)
   -od|--odebug    --ounchanged -ot
   -oa|oall        --ocommon --oblank

EOF
}

Help()
{
	cat - >&2 <<EOF

  Help(v$VER):  $PROG [OPTIONS] [-[%PATH_ADD][OPERATION]]...

  Process entries (lines) as if they are file/directory paths.
  Copy the input entries and perform processing operations on
  the copied entries leaving the originals intact.  Finally,
  output the original entries interleaved with the processed
  entries for easy processing as filenames/paths using the 'xargs'
  command with the '-l2' switch.  Simple renames and powerful
  directory manipulation schemes should become easy to formulate.

  Path Addresses:

    no_address  the last path section (usually the filename)
    %-          last path section
    %n          'n'th path section
    %-n         'n'th path section counting from the right
    %[-][n]:[-][m]
               'n'th through 'm'th path sections.  An omitted
               'n' will be set to 1 and an omitted 'm' will
                be set to the last section.
    %|%0        the entire path

  Hold buffer path addresses are by default set to the same as
  the primary path address.  However, you may specify a hold
  buffer specific range by appending it after the primary
  path address separating the two addresses by another '%'.


  Operations:

   d[[^][~]pat] delete current path section (removes '/'s
                cleanly).  If 'pat' is specified, only delete
                path section if it is equal to 'pat'.  '^'
                signifies negation and '~' signifies an RE
                match instead of a full section fixed string
                comparison.

   p[path]      discard main buffer contents and fill with 'path'

   s/pat/rep/   perform substitution with 'sed'

   t[flags] [s1 [s2]]
                perform translation with 'tr'.  The following
                flags will be passed to 'tr': 'cCds' as options.
                The following additional flags 'u' and 'l'
                convert to 'upper' and 'lowercase' respectively
                and do not take any string arguments.  The 'd'
                and 's' flags only take one string argument
                unless used together.  All other flags take 2
                arguments.

   g[flags] pat filter entries with 'grep'.  The following flags
                will be passed to 'grep': 'Fwvix' as options.

   x cmd [arg]... ;
                process the main buffer by executing the args
                which follow 'x'.  The args list should be
                semi-colon ';' terminiated.  Don't forget to
                escape the semi-colon '\;' to bypass your
                shell (similar to 'find --exec'.)

   xk|xf[sep] cmd [arg]... ;
                execute keep/filter - like 'x', except that the
                output of the executed commands should be a list
                of line numbers to keep (like 'grep -n').  The
                first column of each line represents an entry to
                keep/filter.  The columns are delimited by 'sep'
                or ':' by default.  If column is not a number
                the line is ignored.

  Hold Buffer Operations:

   hy|hs        yank/swap main buffer into/with hold buffer
   ha|hp[s]     append/prepend hold buffer to main buffer, use 's'
                as the separator
   hc|hn        keep entries in the main buffer which are ('hn' not)
                the common entries with the hold buffer
   hi           place the contents of the (remaining) original
                entries in the hold buffer (filtered entries
                can never be restored)

  Extension Operations (operate on last path section only):

   +[+]eEXT     add EXT extension (2nd + forces addition when one exists)
   +e/EXT       set (replace or add) extension to 'EXT'
   -[n]e[EXT]   remove ('n'th) extension ('EXT' only) if it exists
   --[n]e       remove all (or up to 'n') extensions
   -[n]e/[OLD/]EXT
                replace ('n'th)('OLD') extension with 'EXT' if it exists

  Options:

   -h           short help (usage)
   --help       full help (*this*)
   -+v          toggle verbose
   --|++debug   toggle debug (lots of output)

  Output Specific Options:

   -of|--ofirst      start interleaving with output entries instead
                     of input entries
   -oo|--oonly       output entries only (omit input entries)
   -ob|--oblank      output pairs which contain blank input and/or output
                     entries
   -oc|--ocommon     output entries which would normally be filtered
                     because they are common to the input entries
   -os|--osepSEP     set output separator to 'SEP' (default is newline)
   -ot               set output separator to a tab (for easier analysis)
   -od|--odebug      --ounchanged -ot
   -oa|oall          --ocommon --oblank


  Processing the copied entries consists of either modifying
  or filtering out entries.  By default only entries which have
  been modified will be output.

  OPERATIONS which are not Extension Operations, Operations and
  Hold Buffer Operations, may be preceeded by a PATH_ADD to
  designate which part of each entry to operate on, see Path
  Addresses above.  Operations are performed in the order that
  they appear.  The default behavior is to operate only on the
  last section of the path if no Path Address is specified for the
  current operation.  It is possible to change the Path Address
  for all subsequent operations by specifying a Path Address
  without an operation: '-%ADD'.

  Most processing operations operate on the main buffer with each
  operation using the main buffer as input and placing its output
  back in the main buffer.  However, there are a few operations
  which operate on a hold buffer.  The hold buffer is initially
  populated with the original input lines, but it may be
  populated by certain operations and applied to the main buffer
  by others.  It is also possible to recall the original entries
  buffer (minus filtered entries) at any time even after
  modifying the main and hold buffers.

  If entries are filtered from the main buffer, the respective
  original and hold buffer entries are also removed.  The final
  output will interleave original and new entries on separate
  lines (unless a different separator is specified) which makes
  the use of spaces safe within entries.  The only character
  restriction on entries should be newlines.  The creation of
  original/new path pairs is optimized for use with commands
  such as 'xargs -l2 mv' which will perform renames on line 
  pairs.

  Examples:

  1) Rename files with 'jpeg' to 'JPG' extensions while
     uppercasing the whole filename (but not the directories):

    find . -type f| PROG -e/jpeg/JPG/ -tu | xargs -l2 mv


  2) Restore all .bak files to their original filenames:

    find . -type f -name '*.bak' | fargs -ebak |xargs -l2 mv

   More selectively, get a list of backup files which are not
   the same as their originals:

    find foo -type f | fargs -ebak | xargs -l2 cmp | awk '{print \$1}'

   Or, alternatetively, find all the backup files which are the
   same as their originals and delete them:

    find foo -type f | fargs -ebak | \\
     xargs -l2 sh -c 'cmp -s "\$0" "\$1" && echo "\$0"'|xargs -l rm


  3) Replicate a directory hierarchy (no files):

    find foo -type d | fargs -%1s/foo/bar/ -oo | xargs -l mkdir -p

   Now, replicate all the files to the new directory structure
   while running dos2unix on them:

    find foo -type f | fargs -%1s/foo/bar/ | \\
      xargs -l2 sh -c 'dos2unix < "\$0" > "\$1"' 


  4) Perform a subversion mv on many c files, one entry per
     command (old subversion limitation):

    ls mypath/to/files/*/*.c | fargs -%p./newdir -%ha/ | \\
      xargs -l2 svn mv


  Bugs:

  -Does not support gnu find -print0 (all user -x executed
   utilities would need to support it)
  -One tr option should be able to support 2 arguments
  -Reverse address range insertion is not supported
  -Failed operations do not cause the entire program to fail
  -Dot files and current directory entries may confuse extension
   manipulations

EOF
return
	cat - >&2 <<EOF

    -We could perhaps create multiple hold buffers? 
     Addressing could come after h: '-h2y' (perhaps too complicated)
    -Provide an option to not use separators when appending if
     one of the fields is blank.
    -Add mechanisms to repeat last command with different address?
       (requires argument storing, not easy)
    -Does addressing work with +[+]e...?

EOF
}

                ### --------- Intialization ------------ ### 

PROG="$(basename "$0")" ; VER='1.0'

if [ -z "$AWK" ] ; then
	AWK=awk   ; [ -x /usr/xpg4/bin/awk ] && AWK=/usr/xpg4/bin/awk
fi
if [ -z "$GREP" ] ; then
	GREP=grep ; [ -x /usr/xpg4/bin/grep ] && GREP=/usr/xpg4/bin/grep
fi


[ "$1" = "-h"  ] && { Usage ; exit ; }
[ "$1" = "--help" ] && { Help ; exit ; }



in="$(cat - )"
out="$in" ; hold="$in" ; NL="$(echo "$in"|wc -l)"

SW_COM='' ; SW_BLANK='' ; SW_DEB='' ; SW_OMIT='' ; SW_FIRST=''
defbrange='NF' ; defhrange='NF' ; SW_OFS='\n'



              ### --------- Process Arguments ------------ ### 

while [ $# -gt 0 ] ; do

	### Process Options and Figure out path address range ###
	cmd="$1" ; brange="$defbrange" ; hrange="$defhrange" ; opt='yes'
	case "$1" in
		-h) Usage ; exit ;;
		--help) Help ; exit ;;
		-v*) SW_V="$1" ;;
		+v) SW_V='' ;;
		--debug) SW_DEB="$1" ;;
		++debug) SW_DEB='' ;;

		-os)    SW_OFS="${1:3}" ;;
		--osep) SW_OFS="${1:6}" ;;
		-ot)    SW_OFS='\t' ;;
		-oc|--ocommon)  SW_COM="$1" ;;
		-od|--odebug)   SW_OFS='\t' ; SW_COM="$1" ;;
		-of|--ofirst)   SW_FIRST="$1" ;;
		-oo|--oonly)    SW_OMIT="$1" ;;
		-ob|--oblank)   SW_BLANK="$1" ;;
		-oa|--oall)     SW_BLANK="$1" ; SW_COM="$1" ;;

		-%*)	brange="$(parseRanges b "$1")"
			hrange="$(parseRanges h "$1")"
			cmd="$(parseRanges c "$1")"
			if [ "$cmd" = "-" ] ; then
				defbrange="$brange" ; defhrange="$hrange"
				[ ! -z "$SW_V" ] && echo "NEW RANGES[main($brange),hold($hrange)]">&2
				shift ; continue
			fi
			opt=''
			;;
		*) opt='' ;;
	esac
	if [ ! -z "$opt" ] ; then
		[ ! -z "$SW_V" ] && echo "OPT:$1" >&2
		shift ; continue
	fi

	### Process each command ($cmd) ###
	[ ! -z "$SW_V" ] && echo "CMD:$cmd RANGES[main($brange),hold($hrange)]">&2
	case "$cmd" in
		-d*) out="$(echoNL "$out"|delpaths "${cmd:2}" $brange)" ;;
		-p*) sbn "$(yes "${cmd:2}"|sed -e"$NL"q)" ;;

		[+-]e*|[+-][0-9+-]e*|[+-][+-][0-9]e*)
			sbr "$(gbr NF| extensions "$cmd")" NF ;;
		-s*) sbn "$(gbn| sed -es"${cmd:2}")" ;;

		-tu) sbn "$(gbn| tr '[:lower:]' '[:upper:]')" ;;
		-tl) sbn "$(gbn| tr '[:upper:]' '[:lower:]')" ;;
		-t[sd]|-t[sd][cC]|-t[cC][sd])
			TOPTS="$(expoptions "${cmd:2}" "cSsd")"
			shift ; sbn "$(gbn| tr $TOPTS "$1")"
			;;
		-t*) TOPTS="$(expoptions "${cmd:2}" "cSsdt")"
			shift ; sbn "$(gbn| tr $TOPTS "$1" "$2")" ; shift
			;;

		-g*) GOPTS="$(expoptions "${cmd:2}" "Fwvix")"
			shift ; filterN - "$(gbn|$GREP -n $GOPTS "$1")"
			;;

		-hy) shn "$(gbn)" ;;
		-hi) shn "$(echoNL "$in"|cutpaths $brange)" ;;
		-hs) tmp="$(ghn)" ; shn "$(gbn)" ; sbn "$tmp" ; unset tmp ;;
		-ha*) sbn "$(pasteCols "$(gbn)" "$(ghn)" "${cmd:3}")" ;;
		-hp*) sbn "$(pasteCols "$(ghn)" "$(gbn)" "${cmd:3}")" ;;
		-hc) filterN '!' - "$(diffcols "$(ghn)" "$(gbn)")" ;;
		-hn) filterN     - "$(diffcols "$(ghn)" "$(gbn)")" ;;

		-x|-xf*|-xk*) unset args ; i=0 ; shift
			while [ $# -gt 0  -a  "$1" != ";" ] ; do
				args[$i]="$1" ; i=$(($i+1)); shift
			done
			if [ "$cmd" = "-x" ] ; then
				sbn "$(gbn|"${args[@]}")"
			else
				fs="${cmd:3}" ; [ -z "$fs" ] && fs=":"
				f='' ; [ "${cmd:2:1}" = "f" ] && f='!'
				filterN $f -fs "$fs" - "$(gbn|"${args[@]}")"
			fi
			;;

		*) Usage ; echo "ERR($PROG): argument not understood ($cmd)" >&2 ; exit ;;
	esac
	[ ! -z "$SW_DEB" ] && echoNL "$out">&2
	shift
done


[ -z "$SW_COM" ] &&  filterN - "$(diffcols "$in" "$out")"


### ---  Main Output Section --- ###
[ -z "$SW_BLANK" ] && { awkb='{BK=0};/^$/{BK=1};' ; }
[ ! -z "$SW_OMIT" ] && { echo "$out" |$AWK "$awkb"'BEGIN{OFS="'"$SW_OFS"'"};!BK'; exit ; }

[ ! -z "$SW_BLANK" ] && { SW_BLANK='-nb' ; }
if [ -z "$SW_FIRST" ] ; then
	pasteCols "$in" "$out" "$SW_OFS" $SW_BLANK
else
	pasteCols "$out" "$in" "$SW_OFS" $SW_BLANK
fi