#!/bin/sh

ver=1.2

Usage() {
prog=`basename $0`
cat <<END
Lineup v$ver

Use: $prog [-h] [-c m-n] [-C m-n] [-l l1,l2-l3,...] \\
	[-F c] [-I iii] [-i iii] [-a aaa] [-b ppp] \\
	[-B ppp] [-m mmm] [-r m[-n],...] [-w n1,n2,...] [-t] [file...]

Aligns the columns from the named file(s) (stdin is used if there
are no file arguments).

Options:
    -h	print this help info, then exit.

    -c m-n	Only align columns m..n (default (1..inf).  However, spaces
		between unaligned columns are reduced to 1.
    -C m-n	Don't lineup lines with fewer than m or more than n columns.
		(Default 1-inf).
    -l l1,l2-l3,... Don't lineup lines l1, l2 .. l3, ....
    -F c	Field separator (default whitespace).
    -t		invoke "less" to print the file, using the first line
		as the less title (caption).
    -I iii	Use string iii as indentation before non-formatted lines.
    -i iii	Use string iii as indentation before formatted lines.
    -a aaa	Don't align lines that begin with plain string aaa, and
		discard the "aaa" before printing.
    -b ppp	Don't align lines until the first one containing the awk
		pattern ppp (-b == begin_at).
    -B ppp	Don't align lines until the first one _after_ the line
		containing the awk pattern ppp (-B == begin_after).
    -m mmm	Don't align lines that contain a match to the awk pattern mmm.
    -r m[-n],... Right-align columns m[-n],... (e.g. 3,6-7).
    -w n1,n2,... Try to limit width of cols to n1, n2,... (nX=0=no limit).
END
}


cols=0.1000000
linelist=0
title1=no
sep=
rightalign=

# Use: need [optionname] args-available args-needed
need() {
    if [ $2 -lt $3 ] ; then
	case "$1" in
	"" ) echo "Not enough arguments" ;;
	* ) echo "Not enough arguments after '$1'" ;;
	esac
	exit 1
    fi
}

# Big inconvenience here: getopt is broken because it doesn't quote
# arguments before it returns the string.  As a result, the single
# argument "x y z" becomes three arguments upon return.  Since patterns
# can reasonably contain spaces, we can't readily use getopt.
while true ; do
    case "$1" in
    -a ) dontaligntag="$2"	; need "$1" $# 2 ; shift ;;
    -b ) beginat="$2"		; need "$1" $# 2 ; shift ;;
    -B ) beginafter="$2"	; need "$1" $# 2 ; shift ;;
    -m ) dontmatchpat="$2"	; need "$1" $# 2 ; shift ;;
    -c ) okcols="$2"		; need "$1" $# 2 ; shift ;;
    -C ) colrange="$2"		; need "$1" $# 2 ; shift ;;
    -F ) sep="$2"		; need "$1" $# 2 ; shift ;;
    -l ) linelist="$2"		; need "$1" $# 2 ; shift ;;
    -I ) Indentation="$2"	; need "$1" $# 2 ; shift ;;
    -i ) indentation="$2"	; need "$1" $# 2 ; shift ;;
    -r ) rightalign="$2"	; need "$1" $# 2 ; shift ;;
    -w ) maxcolwidth="$2"	; need "$1" $# 2 ; shift ;;
    -h ) Usage ; exit 0 ;;
    -t ) title1=yes ;;
    -- ) need "$1" $# 1 ; shift ; break ;;
    -* ) echo "*** Unknown option: $1 ***" ; Usage ; exit 1 ;;
    * ) break ;;
    esac
    need "" $# 1 ; shift
done

# Find a file in the path
locate() {
    IFS=":"
    for d in $PATH; do
        test -x "$d/$1" -a ! -d "$d/$1" && return 0
    done
    return 1
}

# Find a variant of awk
AWK=awk
for f in gawk nawk ; do
    if locate "$f" ; then
        AWK=$f
        break
    fi
done

test X"$sep" = X && cmd="$AWK" || cmd="$AWK -F$sep"

# Use this funny substitution-inside-BEGIN, because not all awks
# (old awk, gawk, nawk, mawk, posix awk) agree on when or how to pass
# variables.
$cmd '
BEGIN {'"
    dontaligntag=\"$dontaligntag\"
    beginat=\"$beginat\"
    beginafter=\"$beginafter\"
    ldontaligntag = length(dontaligntag)
    dontmatchpat=\"$dontmatchpat\"
    ldontmatch = length(dontmatchpat)
    linelist=\"$linelist\"
    okcols=\"$okcols\"
    colrange=\"$colrange\"
    maxcolwidth=\"$maxcolwidth\"
    Indentation=\"$Indentation\"
    indentation=\"$indentation\"
    rightalign=\"$rightalign\"
    "'
    if (beginat == "" && beginafter == "")
	begun=1;
    else
	begun=0;
    n = split(rightalign, rightalignsets, ",")
    for (i=1; i<=n; i++) {
	m = split(rightalignsets[i], ab, "-")
	if (m == 0) {
	    print "Invalid column range: " rightalignsets[i]
	    exit 1
	} else if (m == 1) {
	    upper = ab[1]
	} else {
	    upper = ab[2]
	}
	for (j=ab[1]; j<=upper; j++) {
	    tabright[j] = 1
	}
    }
    nl = split(linelist, linesets, ",")
    for (i=1; i<=nl ; i++) {
	m = split(linesets[i], lx, "-")
	if (m == 0) {
	    print "Invalid line range: " linesets[i]
	    exit 1
	} else if (m == 1) {
	    lines["l" i] = lx[1]
	    lines["r" i] = lx[1]
	} else {
	    lines["l" i] = lx[1]
	    lines["r" i] = lx[2]
	}
    }
    j = split(okcols, c, "-")
    if (c[1] == "")
	firstcol = 1
    else
	firstcol = c[1]+0
    if (j==1)
	lastcol = firstcol
    else if (c[2] == "")
	lastcol = 1000000
    else
	lastcol = c[2]+0

    j = split(colrange, c, "-")
    if (c[1] == "")
	mincol = 1
    else
	mincol = c[1]+0
    if (c[2] == "")
	maxcol = 1000000
    else
	maxcol = c[2]+0

    nw = split(maxcolwidth, colwidth, ",")
    for (i=1; i<=nw ; i++) {
	if (!match(colwidth[i], /^[0-9]+$/)) {
	    print "Invalid column width: " colwidth[i]
	    exit 1
	}
    }
}

{ text[NR] = $0 }

begun==0 && beginat != "" && match($0, beginat)>0 { begun = 1 }

begun==0 && beginafter != "" && match($0, beginafter)>0 {
	begun = 1
	dontfmt[NR] = 1
	next
    }

begun==0 { dontfmt[NR] = 1; next }

NF < mincol || NF > maxcol { dontfmt[NR] = 1 ; next }

ldontaligntag > 0 && substr($0, 1, ldontaligntag) == dontaligntag {
	$0 = substr($0, ldontaligntag+1, 1000)
	dontfmt[NR] = 1
	next
    }

ldontmatch > 0 && match($0, dontmatchpat)>0  {
	dontfmt[NR] = 1
	next
    }

{
    for (i=1; i<=nl; i++) {
	if (lines["l" i] <= NR && NR <= lines["r" i]) {
	    dontfmt[NR] = 1
	    next
	}
    }
}

{
    dontfmt[NR] = 0
    if (NF > maxnf)
	maxnf = NF

    for (i=1; i<=NF; i++) {
	l = length($i)
	if (l > len[i])
	    len[i] = l
    }
}

END {
for (i=1; i<NR; i++)

    if (firstcol > maxnf)
	firstcol = maxnf+1
    if (lastcol > maxnf)
	lastcol = maxnf
    # "nleft" is number of spaces required to display columns before firstcol.
    nleft = 0;
    for (i=1; i<=maxnf; i++) {
	if (colwidth[i] > 0 && colwidth[i] < len[i]) {
	    l = colwidth[i]
	} else {
	    l = len[i]
	}
	if (tabright[i]) {
	    fmt[i] = "%" l "s  "
	} else {
	    fmt[i] = "%-" l "s  "
	}
	if (i < firstcol) {
	    nleft += l + 1
	}
    }
    ### print "firstcol" firstcol, "lastcol", lastcol, "nleft", nleft
    # Trim trailing whitespace
    fmt[maxnf] = substr(fmt[maxnf], 1, length(fmt[maxnf])-1)

    for (i=1; i<=NR; i++) {
	if (dontfmt[i] == 1) {
	    printf("%s", Indentation)
	    print text[i]
	} else {
	    printf("%s", indentation)
	    nf = split(text[i], x)
	    # First print unformatted columns, and keep track of amount
	    # of space used.
	    l = 0;
	    for (j = 1; j < firstcol; j++) {
		l += length(x[j]) + 1
		printf("%s ", x[j])
	    }
	    # Then skip over remaining part of "nleft" spaces.
	    if (firstcol > 1 && nleft > l)
		printf("%*.*s", nleft-l, nleft-l, "");

	    if (nf < lastcol)
		m = nf
	    else
		m = lastcol
	    for (j = firstcol; j <= m; j++)
		printf(fmt[j], x[j])
	    for (j = m+1; j <= nf; j++)
		printf("%s ", x[j])
	    print ""
	}
    }
}' ${1+"$@"} | case "$title1" in
	yes )	read line1
		LESS=`echo "$line1"|sed -e 's/./\\\\&/g' -e 's/^/-imeP/'`
		export LESS
		less ;;
	* )	cat ;;
    esac