*
*
* utility job for sending signals
* 1995 Richard Zidlicky
*

version equ     '0.02'

svars   equ     0
chid    equ     4       * con channel
kjjid   equ     8
schid   equ     8+4     * channel for sending signals
prior   equ     schid+4
usrval  equ     prior+4
jobstart        equ     usrval+4
ourjob  equ     jobstart+4
tmout   equ     ourjob+4
tmpprior        equ     tmout+4

bl      equ     tmpprior+4      * space for length word
buffer  equ     bl+2    * io buffer
bufflen equ     60
stack   equ     buffer+bufflen  
stacklen        equ     80
sttop   equ     stack+stacklen

* message structure
msg.magic       equ     0
msg.len equ     4
msg.type        equ     8
msg.txi equ     10
msg.jobid       equ     12
msg.signr       equ     16
msg.prio        equ     20
msg.uval        equ     24
msg_len equ     28

* some key defs
UP      equ     208
DOWN    equ     216
LEFT    equ     192
RIGHT   equ     200
ENTER   equ     10
ESC     equ     27

* signame defs
SIGHUP  equ     1
SIGINT  equ     2
SIGQUIT equ     3
SIGILL  equ     4
SIGPIPE equ     5
SIGSEGV equ     6
SIGBUS  equ     7
SIGFPE  equ     8
SIGKILL equ     9
SIGALRM equ     10
SIGABRT equ     11
SIGTRACE        equ     12
SIGWINCHD       equ     13
SIGWMREQ        equ     14
SIGTERM equ     15
SIGUSR1 equ     16
SIGUSR2 equ     17

        SECTION    TEXT

tj:     bra.s   start
        dc.l    0
        dc.w    $4afb
        dc.w    10
        dc.b    'SendSignal'
        dc.w    0

start:
        lea     0(a6,a4.l),a6
        clr.l   d0
        trap    #1
        move.l  a0,svars(a6)

        move.l  def_prior,prior(a6)     * init defaults
        move.l  def_usrval,usrval(a6)
        move.l  def_tmout,tmout(a6)

opwin   move.w  $c6,a2          * ut.con
        lea     wdef,a1
        jsr     (a2)
        tst.l   d0
        bne     err
        move.l  a0,chid(a6)

*************
* some obscure disassembled code to
* get jobid of current top window job,
* I wish I knew what it does

        MOVEQ   #-$01,D1
        MOVEQ   #$7F,D2                     * 127
        MOVEQ   #$0B,D0                     * mt.prior
        TRAP    #$01
        move.l  d1,ourjob(a6)

        MOVE    SR,D7
        TRAP    #$00                        * -> sv.mode  ***********

        lea     xw,a1
        MOVEQ   #$7A,D0                     * iop.outl
        MOVEQ   #$00,D1
        moveq   #0,d3
        move.l  chid(a6),a0
        trap    #3
        tst.l   d0
        bne.s   sv_err

        MOVEQ   #$6F,D0                     * iop.slnk
        moveq   #0,d3
        moveq   #0,d2
        move.l  chid(a6),a0
        trap    #3
        tst.l   d0
        bne.s   sv_err

            MOVEA.L A1,A3
            MOVE.L  $68(A3),D0

_loop       MOVEA.L D0,A2
            MOVE.L  (A2),D0
            BEQ.S   sv_err              *  kill
            MOVEA.L D0,A0

            CMPI.B  #1,$14(A0)
            BEQ.S   _loop

        MOVE.L  -$24(A0),D1             * get the jobid

        move.w  d7,sr           * user mode again!! *******

        move.l  d1,kjjid(a6)    * save jobid
        BEQ     err             *  SuperBasic

        MOVEQ   #$02,D0
        MOVEQ   #$00,D2
        TRAP    #$01                *  mt.jinf
        TST.L   D0
        bne     err_nj
        move.l  a0,jobstart(a6)
        bra.s   opnsig

                     
sv_err  move.w  d7,sr
        bra     err

*************

opnsig
        lea     sigdname,a0     * open channel for signals
        moveq   #-1,d1
        clr.l   d3
        moveq   #1,d0
        trap    #2
        tst.l   d0
        bne     errsignoopn
        move.l  a0,schid(a6)

pmenu:
        move.l  chid(a6),a0
        moveq   #0,d3
        moveq   #$20,d0
        trap    #3              * clear window

        move.l  chid(a6),a0
        move.w  $d0,a2
        lea     title,a1
        jsr     (a2)

        lea     jtext,a1
        jsr     (a2)

        move.l  jobstart(a6),a1
        lea     6(a1),a1
        cmpi.w  #$4afb,(a1)+
        bne     noname

pjname  move.w  $d0,a2
        jsr     (a2)            * print jobname

        lea     menu,a1         * print menu
        jsr     (a2)

cmdloop:
        moveq   #1,d0
        moveq   #-1,d3
        trap    #3              * getchar
        tst.l   d0
        bne     err

        cmpi.b  #ESC,d1         * ESC
        beq     end

        cmpi.b  #'1',d1
        beq.s   susr1

        cmpi.b  #'2',d1
        beq.s   susr2   

        cmpi.b  #ENTER,d1               * ENTER
        beq.s   sint

        andi.b  #$df,d1         * make it uppercase

        cmpi.b  #'A',d1
        beq.s   sabrt

        cmpi.b  #'H',d1
        beq.s   shup

        cmpi.b  #'K',d1
        beq.s   skill

        cmpi.b  #'L',d1
        beq.s   salrm

        cmpi.b  #'Q',d1
        beq.s     squit

        cmpi.b  #'T',d1
        beq.s   sterm

        cmpi.b  #'F',d1
        beq     do_frjob

        cmpi.b  #'P',d1
        beq     cprior

        cmpi.b  #'U',d1
        beq     cusrval

        bra     cmdloop
****

sabrt:  moveq   #SIGABRT,d2
        bra.s   dosig   
shup:   moveq   #SIGHUP,d2
        bra.s   dosig
sint:   moveq   #SIGINT,d2
        bra.s   dosig
skill:  moveq   #SIGKILL,d2
        bra.s   dosig
salrm:  moveq   #SIGALRM,d2
        bra.s   dosig
squit:  moveq   #SIGQUIT,d2
        bra.s   dosig
sterm:  moveq   #SIGTERM,d2
        bra.s   dosig
susr1:  moveq   #SIGUSR1,d2
        bra.s   dosig
susr2:  moveq   #SIGUSR2,d2

dosig   move.l  chid(a6),a0
        move.l  kjjid(a6),d1
        moveq   #0,d3
        moveq   #$7c,d0
        trap    #3              * pick that job
        

*       moveq   #$2f,d0         * old code
*       move.l  kjjid(a6),d1
*       move.l  tmout(a6),d3
*       move.l  schid(a6),a0
*       move.l  prior(a6),a1
*       move.l  usrval(a6),a2
*       trap    #3
*       tst.l   d0


        lea     buffer(a6),a1
        move.l  #'%MSG',msg.magic(a1)
        move.l  #msg_len,msg.len(a1)
        move.l  #0,msg.type(a1)
        move.l  kjjid(a6),msg.jobid(a1)
        move.l  d2,msg.signr(a1)
        move.l  prior(a6),msg.prio(a1)
        move.l  usrval(a6),msg.uval(a1)
        moveq   #$7,d0
        moveq   #msg_len,d2
        move.l  tmout(a6),d3
        move.l  schid(a6),a0

        trap    #3
        tst.w   d0
        beq     end

perror  move.l  d0,d5

etx     move.l  chid(a6),a0
        move.l  ourjob(a6),d1
        moveq   #$7c,d0
        moveq   #0,d3
        trap    #3              * pick this job

        move.l  d5,d0
        move.w  $cc,a2
        jsr     (a2)
        bra     wkey
****

do_frjob        move.l  kjjid(a6),d1
        moveq   #5,d0
        clr.l   d3
        trap    #1
        tst.l   d0
        bne.s   perror
        bra     end
****

cprior:
        move.l  chid(a6),a0
        moveq   #-1,d3
        moveq   #$20,d0
        trap    #3              * clear

        lea     cprior_txt,a1
        move.w  $d0,a2
        jsr     (a2)

        move.l  prior(a6),tmpprior(a6)
        moveq   #6,d4           * field 7
        lea     itable,a4               * position table
dloo:
        bsr     prfld
        dbra    d4,dloo

        moveq   #0,d4
eloop:  bsr     hilitfld
        moveq   #1,d0
        moveq   #-1,d3
        trap    #3
        tst.w   d0
        bne.s   exprio
        move.b  d1,d7
        bsr     hilitfld
        move.b  d7,d1

        cmpi.b  #UP,d1
        beq.s   chup
        cmpi.b  #DOWN,d1
        beq.s   chdown
        cmpi.b  #LEFT,d1
        beq.s   lstfld
        cmpi.b  #RIGHT,d1
        beq.s   nxfld
        cmpi.b  #ESC,d1
        beq.s   exprio
        cmpi.b  #ENTER,d1
        beq.s   eprio
        bra.s   eloop

chup:   moveq   #1,d6
        bsr.s   chfld
        bsr.s   prfld
        bra.s   eloop
chdown  moveq   #-1,d6
        bsr.s   chfld
        bsr.s   prfld
        bra.s   eloop
lstfld  
        subq.l  #1,d4
        bge.s   eloop
        addq.l  #7,d4
        bra.s   eloop

nxfld   
        addq.l  #1,d4
        divu    #7,d4
        clr.w   d4
        swap    d4
        bra.s   eloop

eprio:  move.l  tmpprior(a6),prior(a6)
exprio: bra     pmenu

chfld:  move.w  d4,d5   * d4 fld, a4 itable, d6 +/-change
        add.w   d4,d5
        add.w   d4,d5
        add.w   d5,d5   * x6

        moveq   #0,d0
        move.l  tmpprior(a6),d1
        move.b  shift(a4,d5.w),d0
        asr.l   d0,d1
        moveq   #0,d2
        move.b  mask(a4,d5.w),d2
        and.l   d2,d1           * old value of field
        add.b   d6,d1
        and.l   d2,d1           * new val
        asl.l   d0,d2
        not.l   d2
        and.l   d2,tmpprior(a6) * clear field
        asl.l   d0,d1
        or.l    d1,tmpprior(a6)

        rts

prfld:  move.w  d4,d5   * d4 field, a4 itable
        add.w   d4,d5
        add.w   d4,d5
        add.w   d5,d5   * x6

        move.w  row(a4,d5.w),d1 * row
        move.w  line(a4,d5.w),d2        * line
        addq.w  #2,d1           *  center
        moveq   #-1,d3
        moveq   #$10,d0
        trap    #3
        
        move.l  tmpprior(a6),d1
        moveq   #0,d0
        move.b  shift(a4,d5.w),d0
        asr.l   d0,d1
        moveq   #0,d0
        move.b  mask(a4,d5.w),d0
        and.l   d0,d1           * shift & mask to get value
        add.b   #$30,d1
        moveq   #-1,d3
        moveq   #5,d0
        trap    #3              * print the value

        rts

hilitfld:       move.w  d4,d5   * d4 field, a4 itable
        add.w   d4,d5
        add.w   d4,d5
        add.w   d5,d5   * x6

        moveq   #$2c,d0
        moveq   #-1,d3
        move.w  d3,d1
        trap    #3              * XOR mode

        lea     -8(a7),a7
        move.l  a7,a1
        move.w  row(a4,d5.w),d1 * row-x
        mulu    #6,d1
        move.w  d1,4(a1)
        move.w  line(a4,d5.w),d2        * line-y
        mulu    #10,d2
        move.w  d2,6(a1)
        move.w  #24,(a1)
        move.w  #10,2(a1)

        moveq   #-1,d3
        moveq   #4,d1
        moveq   #$2e,d0
        trap    #3
        lea     8(a7),a7

        moveq   #$2c,d0
        moveq   #-1,d3
        moveq   #0,d1
        trap    #3              * normal mode
        rts



itable: dc.w    7,0
        dc.b    9,7
        dc.w    7,5
        dc.b    6,7
        dc.w    7,10
        dc.b    3,7
        dc.w    7,15
        dc.b    0,7

        dc.w    11,0
        dc.b    14,1
        dc.w    11,5
        dc.b    13,1
        dc.w    11,10
        dc.b    12,1



line:   equ     0
row:    equ     2
shift:  equ     4
mask:   equ     5

****

cusrval:
        move.l  chid(a6),a0
        moveq   #-1,d3
        moveq   #$20,d0
        trap    #3              * clear

        lea     cusr_txt,a1
        move.w  $d0,a2
        jsr     (a2)

        lea     sttop(a6),a1
        move.l  usrval(a6),(a1)                 
        lea     buffer(a6),a0
        move.w  $fe,a2
        sub.l   a6,a1           * adjust
        sub.l   a6,a0
        jsr     (a2)            * cn.itohl

        lea     8+buffer(a6),a1
        moveq.l #8,d1

        moveq   #4,d0           * io.edlin
        moveq   #bufflen,d2
        moveq   #-1,d3
        move.l  chid(a6),a0

        trap    #3
        tst.l   d0
        bne.s   cusrval

        move.b  0,-1(a1)                * \0 terminator
        lea     buffer(a6),a0
usl     cmp.b   #'0',(a0)
        bne.s   usc
        adda.w  #1,a0
        bra.s   usl     
usc     
        cmp.b   #0,(a0)
        bne.s   usn
        sub.w   #1,a0
usn
        move.l  a0,a3
        lea     sttop(a6),a1

        moveq   #0,d7
        move.w  $10e,a2
        sub.l   a6,a1           * adjust
        sub.l   a6,a0
        jsr     (a2)
        add.l   a6,a0
        cmpa.l  a0,a3
        beq     cusrval         * error ?

        move.l  0(a6,a1.l),usrval(a6)
        bra     pmenu
****            

noname  lea     anon,a1
        bra     pjname
****

errsignoopn:
        move.w  $d0,a2
        move.l  chid(a6),a0
        lea     snf_txt,a1
        jsr     (a2)
        bra.s   wkey
****

err_nj  lea     err_nj_text,a1
        move.l  chid(a6),a0
        move.w  $d0,a2
        jsr     (a2)

wkey
        moveq   #1,d0
        move.w  #600,d3
        trap    #3              * pause

end
err     move.l  d0,d3                   * kill
        moveq   #5,d0
        moveq   #-1,d1
        trap    #1
        bra     err
****

title   dc.w    16
        dc.b    'Signal utility ',10,10

jtext   dc.w    7
        dc.b    10,'Job : ',0

anon    dc.w    6
        dc.b    '*anon*'

menu    dc.w    mend-*-2
        dc.b    10,'ESC (U)servalue (P)riority',10,10
        dc.b    ' INT       ... ENTER',10
        dc.b    ' TERM      ... T',10
        dc.b    ' ABRT      ... A',10
        dc.b    ' ALRM      ... L',10
        dc.b    ' HUP       ... H',10
        dc.b    ' KILL      ... K',10
        dc.b    ' QUIT      ... Q',10
        dc.b    ' USR1      ... 1',10
        dc.b    ' USR2      ... 2',10,10
        dc.b    ' FRJOB     ... F',10
mend
        DS.W    0

cusr_txt        dc.w    cusr_end-*-2
        dc.b    'edit usrvalue (HEX),',10
        dc.b    'and ENTER',10
cusr_end
        DS.W    0

cprior_txt      dc.w    cpt_end-*-2
        dc.b    'Change Priority',10,10
        dc.b    'use ¼ ½ ¾ ¿ to change',10
        dc.b    ' ESC discard changes',10
        dc.b    ' RET confirm',10,10
        dc.b    'WFJ  SYSC SUSP RUNN',10,10,10
        dc.b    ' defer flags :',10
        dc.b    'WFJ  SYSC SUSP',10
cpt_end


err_nj_text
        dc.w    te-*-2
        dc.b    10,'could not estimate',10
        dc.b    'job id',10
te
        DS.W    0

snf_txt dc.w    snf_end-*-2
        dc.b    'sorry, signal device',10
        dc.b    'not found',10
snf_end
        DS.W    0

sigdname        dc.w    9
        dc.b    '*signal_s'
        DS.W    0     


LINES   equ     17
HLINES  equ     1               * header lines
COLS    equ     30


wdef    dc.b    4,1             * bc,bw
        dc.b    0,7             * pc,ic
xw      dc.w    6*COLS+4                        * 30 chars
yw      dc.w    10*LINES+4                      * 16 lines
        dc.w    256-3*COLS,128-LINES*5  * at x,y 

outl:   dc.w    6*COLS                  * x
        dc.w    10*(LINES+HLINES)               * y
        dc.w    256-3*COLS                      * at x,
        dc.w    128-LINES*5-HLINES*10           *      y

def_prior       dc.l    %111111111111111        * highest priority,defer all
def_usrval      dc.l    $0              * 
def_tmout       dc.l    30

        data    stack+stacklen+400
        END