Return to man.sh CVS log

Up to [Research Unix] / researchv10no / cmd / man

Annotation of researchv10no/cmd/man/man.sh, revision 1.1

1.1     ! root        1: #!/bin/sh
        !             2: set -p
        !             3: PATH=/bin:/usr/bin
        !             4: SOURCE=/usr/man
        !             5: CACHE=/usr/spool/man
        !             6: cmd=-q sec='?*' secn= c=x s=x
        !             7: opt= slow= quick= T=
        !             8: 
        !             9: (cd $CACHE 2>/dev/null) && c=c
        !            10: (cd $SOURCE 2>/dev/null) && s=s
        !            11: 
        !            12: while  case $1 in
        !            13:        [1-9]|10)       sec=$1 secn=$1 ;;
        !            14:        -f)     c=f s=f ;;
        !            15:        -[qw])  cmd=$1 ;;
        !            16:        -[nt])  cmd=$1 ;;
        !            17:        -T*)    T=$1 ;;
        !            18:        -*)     opt="$opt $1" ;;
        !            19:        *)      break
        !            20:        esac
        !            21: do     shift
        !            22: done
        !            23: 
        !            24: csc=$c$s$cmd
        !            25: case $csc in
        !            26: ff-q)        cmd=-t ;;
        !            27: xx-?|?x-[nt]) echo man data not available 1>&2; exit ;;        
        !            28: c?-[qw])      cd $CACHE ;;
        !            29: ?s-?)        cd $SOURCE
        !            30: esac
        !            31: 
        !            32: for i
        !            33: do     case $csc in
        !            34:        ff-?)   slow="$slow $i" ;;
        !            35:        *)      fil=`echo man$sec/$i.*`
        !            36:                for j in $fil
        !            37:                do      case $csc$j in
        !            38:                        cs-[qw]*\*)     man -n $secn $i ;;
        !            39:                        *\*)    echo man: $i not found 1>&2 ;;
        !            40:                        cx-[qw]*) quick="$quick $j" ;;
        !            41:                        cs-[qw]*) if newer $SOURCE/$j $j
        !            42:                                then    slow="$slow $SOURCE/$j"
        !            43:                                else    quick="$quick $j"
        !            44:                                fi ;;
        !            45:                        *)      slow="$slow $j"
        !            46:                        esac
        !            47:                done
        !            48:        esac
        !            49: done
        !            50: 
        !            51: case "$slow$quick" in
        !            52: "")    exit
        !            53: esac
        !            54: 
        !            55: #slightly faster than the honest way: doctype
        !            56: typeset() { tbl $slow | ${1}eqn $T | ${1}roff -man $T $opt }
        !            57: teqn() { eqn $* }
        !            58: 
        !            59: case $cmd in
        !            60: -q)    if test -t
        !            61:        then    undln="| ul"
        !            62:        else    undln=
        !            63:        fi
        !            64:        eval '( case "$quick" in
        !            65:                ?*)     cat $quick
        !            66:                esac
        !            67:                case "$slow" in
        !            68:                ?*)     typeset n
        !            69:                esac)' $undln  ;;
        !            70: -t)    typeset t ;;
        !            71: -n)    typeset n ;;
        !            72: -w)    echo $quick $slow
        !            73: esac

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.