#!/bin/ksh

PROGNAME=`basename $0`
NL="
"
CL="Command line was: $PROGNAME $*$NL"
doneUsage=""

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

usage ()
    {
    [[ -n "$doneUsage" ]] && return

    if [[ $# -ne 0 ]]; then
        echo "$*" 1>&2;
    elif [[ "$errorstr" != "" ]]; then
        echo "$errorstr" 1>&2;
    fi
    cat 1>&2 <<End
${CL}Usage: $PROGNAME [options] ([-e] <pattern> | -p <lineno>)... file...
  Flags:
    -n                  add file line number to each line
    -F                  add file name to each line
    -b                  leave blank line between blocks
    -m                  mark lines matched
                        (>> indicates a pattern match, ## a line number match)
    -d                  show awk script ("debug") and add flags to lines

  Lines to match:
    -e <pattern>        pattern for which to search
    -p <lineno>[,...]   treat each numbered line <lineno> as a match

  Context scope:
    -s <beginpat>       pattern to detect for start of context block
    -f <finishpat>      pattern to detect for finish of context block
    -l <minlines>       minimum lines to print before/after match (default 0)
    -L <minprevlines>   override minimum lines to print before match

    file...             names of files in which to search; - is stdin (the
                        default) If no -p or -e option is given, the first
                        "file name" will be treated as a match pattern instead.
End
    doneUsage=yes
    }

dietrap ()
    {
    usage "$@"
    errorstr=""
    }

die ()
    {
    usage "$@"
    errorstr=""
    trap - ERR EXIT
    exit
    }

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

escapeSlash ()
    {
    (
    sed -e s:/:\\\\/:g <<End
$1
End
    )
    }

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

# simple case - print usage
[[ $# -eq 0 ]] && CL="" && die && exit

trap "dietrap" ERR EXIT

n_expr=0
n_line=0
minlines=0
minprevlines=0
showline=0
showfile=0
maxline=0
showmark=0
showblank=0
errorstr="" # used by 
start=""
finish=""
debug=""

# assemble options
while getopts :s:f:l:L:p:nFe:dmb opt "$@"; do

    if [[ "$opt" == : ]]; then
        die "Option -$OPTARG requires an argument"
    fi
    multiOpt="Option -$opt set more than once"

    case "$opt" in
        # Flags:
        n)      showline=1 ;;
        F)      showfile=1 ;;
        b)      showblank=1 ;;
        m)      showmark=1 ;;
        d)      debug=y ;;

        # Lines to match:
        # match by pattern
        e)      expr[n_expr]="$OPTARG"; (( n_expr = n_expr + 1 )) ;;
        # match by line number (counted from 1)
        p)      errorstr="Option -$opt must be numeric: $OPTARG"
                # allow comma separation
                lines=$(echo "$OPTARG" | tr , ' ')
                for lnNum in $lines; do
                   [[ $lnNum -le 0 ]] && die "Non-positive line number for -$opt"
                   line[n_line]=$((lnNum + 0)); (( n_line = n_line + 1 ))
                   [[ $maxline -lt $lnNum ]] && (( maxline = lnNum))
                done
                haveLine=1 ;;

        # Context scope:
        s)      [[ -n "$start" ]] && die "$multiOpt"
                start="$OPTARG" ;;
        f)      [[ -n "$finish" ]] && die "$multiOpt"
                finish="$OPTARG" ;;
        l)      errorstr="Option -$opt must be numeric: $OPTARG"
                [[ $OPTARG -lt 0 ]] && die "Negative line count for -$opt"
                [[ $minlines -ne 0 ]] && die "$multiOpt"
                minlines=$((OPTARG + 0))
                ;;
        L)      errorstr="Option -$opt must be numeric: $OPTARG"
                [[ $OPTARG -lt 0 ]] && die "Negative line count for -$opt"
                [[ $minprevlines -ne 0 ]] && die "$multiOpt"
                minprevlines=$((OPTARG + 0))
                ;;

        # Invalid arguments:
        '?')    echo "Invalid option: -$OPTARG" && usage && exit 1 ;;
        *)      echo "Option error: $opt" && usage && exit 1 ;;
    esac
    # clear the error string for next time
    errorstr=""
done

# build a string of just the options
if [[ -n "$debug" ]]; then
    set -A optargs -- "$PROGNAME" "$@"
    optlist=""
    i=1
    while [[ $i -lt $OPTIND ]]; do
        optlist="$optlist ${optargs[i]}"
        (( i = i + 1 ))
    done
fi


# forget the options in the command line now
shift $(($OPTIND - 1))

# do we have an expression yet? if not, take the first "file" arg
if (( ! n_expr && ! n_line )); then
    if (( $# < 1 )); then
        die "No line numbers (-p) nor expressions (-e) given to find"
    fi
    expr[0]="$1"; (( n_expr = 1 ))
    shift
fi

(( minlines = minlines + 0 ))
(( ! $minprevlines )) && (( minprevlines = minlines ))

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

# right: opt processing done - clear the trap
trap - ERR EXIT

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

# build nawk program using preference settings
empty='""'
D0='$0'
PcS='"%s"'

# prefix filename and/or line numbers?
prfxfn=""
prefix=""
colon=""
(( showfile )) && prfxfn="$prfxfn FILENAME colon"
(( showline )) && prfxfn="$prfxfn FNR colon"
if [[ -n "$prfxfn" ]]; then
    prfxfn="
    function prfx( pf)  { return$prfxfn }"
    prefix=" prfx()"
    colon='
                          colon = ":"'
fi

# mark lines matched?
gotlinearg="() "
prevmark=""
whatmark=""
clrmark=""
setmark=""
begmark=""
markE=""
markL=""
markN=""
if (( showmark )); then
    markE='">> "'
    markL='"## "'
    markN='"   "'
    prevmark="$markN"
    whatmark=" domark"
    clrmark="; domark = $markN"
    setmark="; domark = m"  # m is parameter to gotline()
    gotlinearg='(m)'
fi

# do we need a finish marker?
clrend=${finish:+"needend = 0"}
setend=${finish:+"needend = 1"}

# do we need to turn on non-contiguous block breaks?
setblk=""
clrblk=""
prnblk=""
if (( showblank )); then
    setblk="
                          if (lastl != FNR)
                            block = ORS"
    clrblk="; block = $empty"
    prnblk="printf $PcS, block"
fi

# do we have a useful maximum line number match?
beg_doexit=""
now_doexit="$NL"
[[ $n_expr -ne 0 ]] && maxline=0    # we also have to search for patterns
if [[ $maxline -ne 0 ]]; then
    # no patterns, so we can give up searching after the highest line number
    beg_doexit="; doexit = $empty"
    now_doexit="
                        # now_doexit:
                        # all done for this file?
    !println            { if (doexit == FILENAME)
                            next
                          else
                            doexit = $empty
                        }"
fi

# debugging line prefixes
PREV=""
HEAD=""
NEXT=""
SUCC=""
FINI=""
dbgNEXT=""
clrDbg=""
dbgSucc=""
if [[ $debug == y ]]; then
    PREV=' "-L "'
    HEAD=' "-s "'
    NEXT=' "   "'
    SUCC=' "-l "'
    FINI=' "-f "'
    dbgNEXT=" dbg"
    clrDbg="; dbg = $NEXT"
    dbgSucc="; dbg = (nxt > 0) ? $SUCC : $FINI"
fi

# do we have a start expression?
clrPreH=""
addpreH=""
prnPreH=""
begPreH=""
callpreH=""
if [[ -n "$start" ]]; then
    clrPreH="; preH = $empty"
    addpreH="
    function addpreH(s) { if (havebeg && lastl < FNR)
                            preH = preH$HEAD$prefix $prevmark s
                        }"
    prnPreH="
                          if (havebeg && length(preH) >= length (prev)) {
                            prev = preH
                            havebeg = 0
                          }
                          preH = $empty"
    begPreH="
                          havebeg = 0$clrPreH"
    callpreH="
                          addpreH(ln)"
fi

# add the -s beginpat clause
beginpat=""
if [[ -n "$start" ]]; then
    xpr=$(printf %-19s '/'$(escapeSlash "$start")'/')
    beginpat="
                        # beginpat:
                        # match start marker?
    $xpr { havebeg = 1$clrPreH }"
fi

# add the -p line clauses
plines=""
i=0
comment="
                        # plines:
                        # match chosen line numbers?"
while [[ $i -lt $n_line ]]; do
    xit=""
    [[ ${line[i]} -eq $maxline ]] && xit="; doexit = FILENAME"
    xpr=$(printf %-19s "FNR == ${line[i]}")
    plines="$plines$comment
    $xpr { gotline($markL)$xit }"
    comment=""
    (( i = i + 1 ))
done

# and the -e pattern clauses
epatterns=""
i=0
comment="
                        # epatterns:
                        # match search expressions?"
while [[ $i -lt $n_expr ]]; do
    xpat=$(escapeSlash "${expr[i]}")
    xpr=$(printf %-19s "/$xpat/")
    epatterns="$epatterns$comment
    $xpr { gotline($markE); }"
    comment=""
    (( i = i + 1 ))
done

# add to previous lines lists
addtoprev=""
if [[ $minprevlines -gt 0 || -n "$finish" ]]; then
    addtoprev="
                        # addtoprev:
                        # add lines to prev
    !println            { if (lastl == FNR) {
                            prv = 0
                            prev = $empty
                          }
                          else if (prv < minprevlines) {
                            prv++
                            addprev(ln)
                          }
                          else {
                            prevdrop()
                            addprev(ln)
                          }$callpreH$setblk
                        }"
fi

# add the -f finishpat clause
finishpat=""
if [[ -n "$finish" ]]; then
    xpr=$(printf %-19s '/'$(escapeSlash "$finish")'/')
    finishpat="
                        # finishpat:
                        # match end marker
    $xpr { if (nxt <= 0)
                            needend = 0$setblk
                          println = 0$clrPreH
                        }"
fi

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

# start our program...
prg="# $PROGNAME$optlist
$prfxfn
    function addprev(s) { prev = prev$PREV$prefix $prevmark s }$addpreH
    function prevdrop() { prev = substr(prev, (index(prev, ORS) + 1)) }
    function prnline(s) { s = $dbgNEXT$prefix$whatmark s;
                          printf $PcS, s$clrmark }
    function gotline$gotlinearg { println = FNR$setmark$prnPreH
                          $prnblk$clrblk
                          if (prev != $empty)
                            print substr(prev, 1, length(prev)-1)
                          prev = $empty$clrDbg
                          prv = 0
                          nxt = minlines + 1
                          $setend
                        }
    function resetAll() { println = 0$beg_doexit$setblk
                          oldFNR = 0
                          prev = $empty$clrDbg
                          prv = 0$begPreH$clrmark
                          $clrend
                        }

    BEGIN               { lastl = 0$colon
                          resetAll()$clrblk
                        }

                        { if (oldFNR > FNR)
                            resetAll()
                          else
                            oldFNR = FNR
                          ln = $D0 ORS
                        }$now_doexit$beginpat$plines$epatterns

    nxt > 0 || needend  { prnline(ln)$clrblk
                          lastl = FNR$dbgSucc
                          if (--nxt <= 0 && !needend) {
                            println = 0
                          }
                          prev = $empty
                          prv = 0$clrPreH
                        }
$finishpat
$addtoprev"

[[ $debug == y ]] && echo "$prg" | awk '{ printf "%3d ", NR; print $0 }' 1>&2

nawk "$prg" minlines=$minlines minprevlines=$minprevlines \
            showblank=$showblank \
            "$@"