Changeset 4f508e6 in buchla-68k for ram


Ignore:
Timestamp:
07/01/2017 02:34:46 PM (7 years ago)
Author:
Thomas Lopatic <thomas@…>
Branches:
master
Children:
08e1da1
Parents:
f40a309
Message:

Converted assembly language files.

Location:
ram
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • ram/execins.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * execins.s -- execute an instrument selection
    3 * Version 9 -- 1988-09-09 -- D.N. Lynx Crowe
    4 *
    5 * Hand optimized C object code from:  execins.c -- ver 2 -- 1988-06-29
    6 * ------------------------------------------------------------------------------
    7 *
     1| ------------------------------------------------------------------------------
     2| execins.s -- execute an instrument selection
     3| Version 9 -- 1988-09-09 -- D.N. Lynx Crowe
     4
     5| Hand optimized C object code from:  execins.c -- ver 2 -- 1988-06-29
     6| ------------------------------------------------------------------------------
     7
    88                .text
    9 *
    10 DOUBLED         .equ    1                       * double output to WS table
    11 *
     9
     10DOUBLED         =       1                       | double output to WS table
     11
    1212                .xdef   _execins
    13 *
     13
    1414                .xref   _clrvce
    1515                .xref   _execkey
    16 *
     16
    1717                .xref   _io_fpu
    1818                .xref   _instmod
    … …  
    2020                .xref   _idefs
    2121                .xref   _vbufs
    22 *
    23 * register equates
    24 * ----------------
    25 SYNC            .equ    D4
    26 OLDSR           .equ    D5
    27 VCE             .equ    D7
    28 *
    29 IP              .equ    A5
    30 P1              .equ    A4
    31 P2              .equ    A3
    32 *
    33 P3              .equ    A2
    34 P4              .equ    A1
    35 *
    36 * parameter offsets
    37 * -----------------
    38 VOICE           .equ    8
    39 INS             .equ    10
    40 TAG             .equ    12
    41 *
    42                 .page
    43 *
    44 _execins:       link    A6,#0                   * link stack frames
    45                 movem.l D3-VCE/P2-IP,-(sp)      * preserve registers
    46                 move.w  VOICE(A6),VCE           * get voice number
    47                 move.w  VCE,D0                  * calculate IP
    48                 add.w   D0,D0                   * ...
    49                 add.w   D0,D0                   * ...
    50                 lea     vibtabl,A0              * ...
    51                 movea.l 0(A0,D0.W),IP           * ...
    52                 add.l   #_vbufs,IP              * ...
    53                 move.w  VCE,(sp)                * clrvce(vce)
    54                 jsr     _clrvce                 * ...
    55                 tst.w   TAG(A6)                 * if (tag) {
    56                 beq     L2                      * ...
    57 *
    58                 move.l  IP,P1                   * p1 = ip;
    59                 move.w  INS(A6),D0              * p2 = &idefs[ins]
    60                 add.w   D0,D0                   * ...
    61                 add.w   D0,D0                   * ...
    62                 lea     vibtabl,A0              * ...
    63                 movea.l 0(A0,D0.W),P2           * ...
    64                 add.l   #_idefs,P2              * ...
    65                 move.w  #1968,D0                * set move count
    66 *
    67 L6:             move.w  (P2)+,(P1)+             * load voice buffer
    68                 dbra    D0,L6                   * ...
    69 *
    70                 .page
    71 *
    72                 move.w  VCE,D0                  * calculate FPU offset for voice
    73                 move.w  #9,D1                   * ...
    74                 asl.w   D1,D0                   * ...
    75                 asl.w   #1,D0                   * ...
    76                 ext.l   D0                      * ...
    77                 move.l  D0,P1                   * ...
    78                 move.l  D0,P3                   * ...
    79                 add.l   #_io_fpu,P1             * point P1 at FPU WS A
    80                 add.l   #$202,P1                * ...
    81                 lea     1778(IP),P2             * point P2 at instdef WS A
    82                 add.l   #_io_fpu,P3             * point P3 at FPU WS B
    83                 add.l   #2,P3                   * ...
    84                 lea     2858(IP),P4             * point P4 at instdef WS B
    85                 move.w  #253,D0                 * setup move count
    86 *
     22
     23| register equates
     24| ----------------
     25SYNC            =       D4
     26OLDSR           =       D5
     27VCE             =       D7
     28
     29IP              =       A5
     30P1              =       A4
     31P2              =       A3
     32
     33P3              =       A2
     34P4              =       A1
     35
     36| parameter offsets
     37| -----------------
     38VOICE           =       8
     39INS             =       10
     40TAG             =       12
     41
     42                .page
     43
     44_execins:       link    A6,#0                   | link stack frames
     45                movem.l D3-VCE/P2-IP,-(sp)      | preserve registers
     46                move.w  VOICE(A6),VCE           | get voice number
     47                move.w  VCE,D0                  | calculate IP
     48                add.w   D0,D0                   | ...
     49                add.w   D0,D0                   | ...
     50                lea     vibtabl,A0              | ...
     51                movea.l 0(A0,D0.W),IP           | ...
     52                add.l   #_vbufs,IP              | ...
     53                move.w  VCE,(sp)                | clrvce(vce)
     54                jsr     _clrvce                 | ...
     55                tst.w   TAG(A6)                 | if (tag) {
     56                beq     L2                      | ...
     57
     58                move.l  IP,P1                   | p1 = ip;
     59                move.w  INS(A6),D0              | p2 = &idefs[ins]
     60                add.w   D0,D0                   | ...
     61                add.w   D0,D0                   | ...
     62                lea     vibtabl,A0              | ...
     63                movea.l 0(A0,D0.W),P2           | ...
     64                add.l   #_idefs,P2              | ...
     65                move.w  #1968,D0                | set move count
     66
     67L6:             move.w  (P2)+,(P1)+             | load voice buffer
     68                dbra    D0,L6                   | ...
     69
     70                .page
     71
     72                move.w  VCE,D0                  | calculate FPU offset for voice
     73                move.w  #9,D1                   | ...
     74                asl.w   D1,D0                   | ...
     75                asl.w   #1,D0                   | ...
     76                ext.l   D0                      | ...
     77                move.l  D0,P1                   | ...
     78                move.l  D0,P3                   | ...
     79                add.l   #_io_fpu,P1             | point P1 at FPU WS A
     80                add.l   #0x202,P1               | ...
     81                lea     1778(IP),P2             | point P2 at instdef WS A
     82                add.l   #_io_fpu,P3             | point P3 at FPU WS B
     83                add.l   #2,P3                   | ...
     84                lea     2858(IP),P4             | point P4 at instdef WS B
     85                move.w  #253,D0                 | setup move count
     86
    8787                .ifne   DOUBLED
    88                 move.l  P1,-(a7)                * save P1 on stack
    89                 move.l  P2,-(a7)                * save P2 on stack
    90                 move.l  P3,-(a7)                * save P3 on stack
    91                 move.l  P4,-(a7)                * save P4 on stack
    92                 move.w  D0,-(a7)                * save D0 on stack
     88                move.l  P1,-(a7)                | save P1 on stack
     89                move.l  P2,-(a7)                | save P2 on stack
     90                move.l  P3,-(a7)                | save P3 on stack
     91                move.l  P4,-(a7)                | save P4 on stack
     92                move.w  D0,-(a7)                | save D0 on stack
    9393                .endc
    94 *
    95                 move.w  SR,OLDSR                * turn off FPU interrupts
    96                 move.w  #$2200,SR               * ...
    97 *
    98 L10:            move.w  (P2)+,(P1)+             * set FPU WS A from instdef
    99                 nop                             * delay for FPU timing
    100                 nop                             * ...
    101                 nop                             * ...
    102                 move.w  (P4)+,(P3)+             * set FPU WS B from instdef
    103                 nop                             * delay for FPU timing
    104                 nop                             * ...
    105                 dbra    D0,L10                  * loop until done
    106 *
     94
     95                move.w  SR,OLDSR                | turn off FPU interrupts
     96                move.w  #0x2200,SR              | ...
     97
     98L10:            move.w  (P2)+,(P1)+             | set FPU WS A from instdef
     99                nop                             | delay for FPU timing
     100                nop                             | ...
     101                nop                             | ...
     102                move.w  (P4)+,(P3)+             | set FPU WS B from instdef
     103                nop                             | delay for FPU timing
     104                nop                             | ...
     105                dbra    D0,L10                  | loop until done
     106
    107107                .ifne   DOUBLED
    108                 move.w  (a7)+,D0                * restore D0 from stack
    109                 movea.l (a7)+,P4                * restore P4 from stack
    110                 movea.l (a7)+,P3                * restore P3 from stack
    111                 movea.l (a7)+,P2                * restore P2 from stack
    112                 movea.l (a7)+,P1                * restore P1 from stack
    113 *
    114 L10A:           move.w  (P2)+,(P1)+             * set FPU WS A from instdef
    115                 nop                             * delay for FPU timing
    116                 nop                             * ...
    117                 nop                             * ...
    118                 move.w  (P4)+,(P3)+             * set FPU WS B from instdef
    119                 nop                             * delay for FPU timing
    120                 nop                             * ...
    121                 dbra    D0,L10A                 * loop until done
    122 *
     108                move.w  (a7)+,D0                | restore D0 from stack
     109                movea.l (a7)+,P4                | restore P4 from stack
     110                movea.l (a7)+,P3                | restore P3 from stack
     111                movea.l (a7)+,P2                | restore P2 from stack
     112                movea.l (a7)+,P1                | restore P1 from stack
     113
     114L10A:           move.w  (P2)+,(P1)+             | set FPU WS A from instdef
     115                nop                             | delay for FPU timing
     116                nop                             | ...
     117                nop                             | ...
     118                move.w  (P4)+,(P3)+             | set FPU WS B from instdef
     119                nop                             | delay for FPU timing
     120                nop                             | ...
     121                dbra    D0,L10A                 | loop until done
     122
    123123                .endc
    124 *
    125                 move.w  OLDSR,SR                * enable FPU interrupts
    126 *
    127                 .page
    128 *
    129                 move.w  VCE,A0                  * instmod[vce] = FALSE
    130                 add.l   A0,A0                   * ...
    131                 add.l   #_instmod,A0            * ...
    132                 clr.w   (A0)                    * ...
    133                 move.w  VCE,A0                  * s_inst[vce] = ins
    134                 add.l   A0,A0                   * ...
    135                 add.l   #_s_inst,A0             * ...
    136                 move.w  INS(A6),(A0)            * ...
    137                 move.b  70(IP),SYNC             * get config bits
    138                 ext.w   SYNC                    * ...
    139                 asl.w   #8,SYNC                 * ...
    140                 btst    #2,74(IP)               * sync 2nd osc
    141                 beq     L15                     * ...
    142 *
    143                 ori.w   #$2000,SYNC             * ...
    144 *
    145 L15:            btst    #2,75(IP)               * sync 3rd osc
    146                 beq     L16                     * ...
    147 *
    148                 ori.w   #$4000,SYNC             * ...
    149 *
    150 L16:            btst    #2,76(IP)               * sync 4th osc
    151                 beq     L17                     * ...
    152 *
    153                 ori.w   #$8000,SYNC             * ...
    154 *
    155 L17:            move.w  VCE,A0                  * send sync to FPU
    156                 add.l   A0,A0                   * ...
    157                 add.l   #_io_fpu,A0             * ...
    158                 add.l   #$5FE0,A0               * ...
    159                 move.w  SYNC,(A0)               * ...
    160 *
    161 L2:             move.w  #1,(sp)                 * execkey(-1, 0, vce, 1)
    162                 move.w  VCE,-(sp)               * ...
    163                 clr.w   -(sp)                   * ...
    164                 move.w  #-1,-(sp)               * ...
    165                 jsr     _execkey                * ...
    166                 addq.l  #6,sp                   * ...
    167                 tst.l   (sp)+                   * clean up stack
    168                 movem.l (sp)+,SYNC-VCE/P2-IP    * restore registers
    169                 unlk    A6                      * unlink stack frames
    170                 rts                             * return
    171 *
    172                 .page
    173 *
     124
     125                move.w  OLDSR,SR                | enable FPU interrupts
     126
     127                .page
     128
     129                move.w  VCE,A0                  | instmod[vce] = FALSE
     130                add.l   A0,A0                   | ...
     131                add.l   #_instmod,A0            | ...
     132                clr.w   (A0)                    | ...
     133                move.w  VCE,A0                  | s_inst[vce] = ins
     134                add.l   A0,A0                   | ...
     135                add.l   #_s_inst,A0             | ...
     136                move.w  INS(A6),(A0)            | ...
     137                move.b  70(IP),SYNC             | get config bits
     138                ext.w   SYNC                    | ...
     139                asl.w   #8,SYNC                 | ...
     140                btst    #2,74(IP)               | sync 2nd osc
     141                beq     L15                     | ...
     142
     143                ori.w   #0x2000,SYNC            | ...
     144
     145L15:            btst    #2,75(IP)               | sync 3rd osc
     146                beq     L16                     | ...
     147
     148                ori.w   #0x4000,SYNC            | ...
     149
     150L16:            btst    #2,76(IP)               | sync 4th osc
     151                beq     L17                     | ...
     152
     153                ori.w   #0x8000,SYNC            | ...
     154
     155L17:            move.w  VCE,A0                  | send sync to FPU
     156                add.l   A0,A0                   | ...
     157                add.l   #_io_fpu,A0             | ...
     158                add.l   #0x5FE0,A0              | ...
     159                move.w  SYNC,(A0)               | ...
     160
     161L2:             move.w  #1,(sp)                 | execkey(-1, 0, vce, 1)
     162                move.w  VCE,-(sp)               | ...
     163                clr.w   -(sp)                   | ...
     164                move.w  #-1,-(sp)               | ...
     165                jsr     _execkey                | ...
     166                addq.l  #6,sp                   | ...
     167                tst.l   (sp)+                   | clean up stack
     168                movem.l (sp)+,SYNC-VCE/P2-IP    | restore registers
     169                unlk    A6                      | unlink stack frames
     170                rts                             | return
     171
     172                .page
     173
    174174                .data
    175 *
    176 * vibtabl -- voice and instrument buffer offset table
    177 * -------    ----------------------------------------
    178 vibtabl:        .dc.l   0               * 0
    179                 .dc.l   3938            * 1
    180                 .dc.l   7876            * 2
    181                 .dc.l   11814           * 3
    182                 .dc.l   15752           * 4
    183                 .dc.l   19690           * 5
    184                 .dc.l   23628           * 6
    185                 .dc.l   27566           * 7
    186                 .dc.l   31504           * 8
    187                 .dc.l   35442           * 9
    188                 .dc.l   39380           * 10
    189                 .dc.l   43318           * 11
    190                 .dc.l   47256           * 12
    191                 .dc.l   51194           * 13
    192                 .dc.l   55132           * 14
    193                 .dc.l   59070           * 15
    194                 .dc.l   63008           * 16
    195                 .dc.l   66946           * 17
    196                 .dc.l   70884           * 18
    197                 .dc.l   74822           * 19
    198                 .dc.l   78760           * 20
    199                 .dc.l   82698           * 21
    200                 .dc.l   86636           * 22
    201                 .dc.l   90574           * 23
    202                 .dc.l   94512           * 24
    203                 .dc.l   98450           * 25
    204                 .dc.l   102388          * 26
    205                 .dc.l   106326          * 27
    206                 .dc.l   110264          * 28
    207                 .dc.l   114202          * 29
    208                 .dc.l   118140          * 30
    209                 .dc.l   122078          * 31
    210                 .dc.l   126016          * 32
    211                 .dc.l   129954          * 33
    212                 .dc.l   133892          * 34
    213                 .dc.l   137830          * 35
    214                 .dc.l   141768          * 36
    215                 .dc.l   145706          * 37
    216                 .dc.l   149644          * 38
    217                 .dc.l   153582          * 39
    218                 .dc.l   157520          * 40
    219 *
     175
     176| vibtabl -- voice and instrument buffer offset table
     177| -------    ----------------------------------------
     178vibtabl:        .dc.l   0               | 0
     179                .dc.l   3938            | 1
     180                .dc.l   7876            | 2
     181                .dc.l   11814           | 3
     182                .dc.l   15752           | 4
     183                .dc.l   19690           | 5
     184                .dc.l   23628           | 6
     185                .dc.l   27566           | 7
     186                .dc.l   31504           | 8
     187                .dc.l   35442           | 9
     188                .dc.l   39380           | 10
     189                .dc.l   43318           | 11
     190                .dc.l   47256           | 12
     191                .dc.l   51194           | 13
     192                .dc.l   55132           | 14
     193                .dc.l   59070           | 15
     194                .dc.l   63008           | 16
     195                .dc.l   66946           | 17
     196                .dc.l   70884           | 18
     197                .dc.l   74822           | 19
     198                .dc.l   78760           | 20
     199                .dc.l   82698           | 21
     200                .dc.l   86636           | 22
     201                .dc.l   90574           | 23
     202                .dc.l   94512           | 24
     203                .dc.l   98450           | 25
     204                .dc.l   102388          | 26
     205                .dc.l   106326          | 27
     206                .dc.l   110264          | 28
     207                .dc.l   114202          | 29
     208                .dc.l   118140          | 30
     209                .dc.l   122078          | 31
     210                .dc.l   126016          | 32
     211                .dc.l   129954          | 33
     212                .dc.l   133892          | 34
     213                .dc.l   137830          | 35
     214                .dc.l   141768          | 36
     215                .dc.l   145706          | 37
     216                .dc.l   149644          | 38
     217                .dc.l   153582          | 39
     218                .dc.l   157520          | 40
     219
    220220                .end

  • ram/execkey.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * execkey.s -- execute key -- FPU function start subroutine
    3 * Version 15 -- 1988-08-29 -- D.N. Lynx Crowe
    4 * Hand optimized version of execkey() and fnstart() from C compiler output
    5 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| execkey.s -- execute key -- FPU function start subroutine
     3| Version 15 -- 1988-08-29 -- D.N. Lynx Crowe
     4| Hand optimized version of execkey() and fnstart() from C compiler output
     5| ------------------------------------------------------------------------------
    66                .text
    7 *
    8 LOC_EOR         .equ    0
    9 LOC_SUB         .equ    1
    10 *
     7
     8LOC_EOR         =       0
     9LOC_SUB         =       1
     10
    1111                .xdef   _execkey
    12 *
     12
    1313                .xref   _xgetran
    14 *
     14
    1515                .xref   _rsntab
    1616                .xref   _expbit
    … …  
    2626                .xref   _veltab
    2727                .xref   _vpsms
    28 *
    29                 .page
    30 *
    31 * Offsets for execkey() parameters
    32 * --------------------------------
    33 TRG             .equ    8               * WORD -- trigger
    34 PCH             .equ    10              * WORD -- pitch
    35 VCE             .equ    12              * WORD -- voice  (0..11)
    36 TAG             .equ    14              * WORD -- I_TM_... inversion tag
    37 *
    38 * Register variables
    39 * ------------------
    40 A_FP            .equ    A5              * LONG -- struct idfnhdr *
    41 A_FPU           .equ    A4              * LONG -- FPU base address
    42 A_SMP           .equ    A3              * LONG -- struct sment *
    43 *
    44 R_FPMANT        .equ    D7              * WORD -- FPU time mantissa
    45 R_FPEXP         .equ    D6              * WORD -- FPU time exponent
    46 R_FPCTL         .equ    D5              * WORD -- FPU control word
    47 R_I             .equ    D4              * WORD -- loop index
    48 R_FPVAL         .equ    D3              * WORD -- FPU value
    49 *
    50 * Local (stack) variables
    51 * -----------------------
    52 PT              .equ    -4              * LONG -- instpnt *
    53 VEP             .equ    -8              * LONG -- struct valent *
    54 OLDI            .equ    -10             * WORD -- old IPL  (sr)
    55 OCTYPE          .equ    -12             * WORD -- oscillator 1 mode / scratch
    56 VP              .equ    -14             * WORD -- voice # + function # index
    57 SRCNUM          .equ    -16             * WORD -- general source #
    58 SRCVAL          .equ    -18             * WORD -- general source value
    59 TSRCVAL         .equ    -20             * WORD -- temporary general source value
    60 MLTVAL          .equ    -22             * WORD -- general source multiplier
    61 TFPVAL          .equ    -24             * WORD -- temporary FPU value
    62 LTMP            .equ    -28             * LONG -- long temporary
    63 IP              .equ    -32             * LONG -- struct instdef *
    64 GROUP           .equ    -34             * WORD -- group number << 4
    65 *
    66 * Symbolic constants
    67 * ------------------
    68 LASTLOCL        .equ    GROUP           * last local on the stack
    69 *
    70 FPU_DI          .equ    $2200           * sr value for disabling FPU interrupts
    71 PITCHMAX        .equ    21920           * maximum pitch value
    72 VALMAX          .equ    $00007D00       * maximum FPU value
    73 VALMIN          .equ    $FFFF8300       * minimum FPU value
    74 VBLEN           .equ    3938            * length of a voice buffer
    75 LSPCH           .equ    2               * left shift for pitch sources
    76 *
    77                 .page
    78 *
    79 * execkey(trg, pch, vce)
    80 * short trg, pch, vce;
    81 * {
    82 *
     28
     29                .page
     30
     31| Offsets for execkey() parameters
     32| --------------------------------
     33TRG             =       8               | WORD -- trigger
     34PCH             =       10              | WORD -- pitch
     35VCE             =       12              | WORD -- voice  (0..11)
     36TAG             =       14              | WORD -- I_TM_... inversion tag
     37
     38| Register variables
     39| ------------------
     40A_FP            =       A5              | LONG -- struct idfnhdr |
     41A_FPU           =       A4              | LONG -- FPU base address
     42A_SMP           =       A3              | LONG -- struct sment |
     43
     44R_FPMANT        =       D7              | WORD -- FPU time mantissa
     45R_FPEXP         =       D6              | WORD -- FPU time exponent
     46R_FPCTL         =       D5              | WORD -- FPU control word
     47R_I             =       D4              | WORD -- loop index
     48R_FPVAL         =       D3              | WORD -- FPU value
     49
     50| Local (stack) variables
     51| -----------------------
     52PT              =       -4              | LONG -- instpnt |
     53VEP             =       -8              | LONG -- struct valent |
     54OLDI            =       -10             | WORD -- old IPL  (sr)
     55OCTYPE          =       -12             | WORD -- oscillator 1 mode / scratch
     56VP              =       -14             | WORD -- voice # + function # index
     57SRCNUM          =       -16             | WORD -- general source #
     58SRCVAL          =       -18             | WORD -- general source value
     59TSRCVAL         =       -20             | WORD -- temporary general source value
     60MLTVAL          =       -22             | WORD -- general source multiplier
     61TFPVAL          =       -24             | WORD -- temporary FPU value
     62LTMP            =       -28             | LONG -- long temporary
     63IP              =       -32             | LONG -- struct instdef |
     64GROUP           =       -34             | WORD -- group number << 4
     65
     66| Symbolic constants
     67| ------------------
     68LASTLOCL        =       GROUP           | last local on the stack
     69
     70FPU_DI          =       0x2200          | sr value for disabling FPU interrupts
     71PITCHMAX        =       21920           | maximum pitch value
     72VALMAX          =       0x00007D00      | maximum FPU value
     73VALMIN          =       0xFFFF8300      | minimum FPU value
     74VBLEN           =       3938            | length of a voice buffer
     75LSPCH           =       2               | left shift for pitch sources
     76
     77                .page
     78
     79| execkey(trg, pch, vce)
     80| short trg, pch, vce;
     81| {
     82
    8383_execkey:       link    A6,#LASTLOCL
    8484                movem.l D2-R_FPMANT/A_SMP-A_FP,-(sp)
    85 *
    86 *       ip = &vbufs[vce];
    87 *
     85
     86|       ip = &vbufs[vce];
     87
    8888                move.w  VCE(A6),D0
    8989                asl.w   #2,D0
    9090                lea     vbtab,A0
    9191                move.l  0(A0,D0.W),IP(A6)
    92 *
    93 *       vce2trg[vce] = trg;
    94 *
     92
     93|       vce2trg[vce] = trg;
     94
    9595                lsr.w   #1,D0
    9696                lea     _vce2trg,A0
    9797                move.w  TRG(A6),0(A0,D0.W)
    98 *
    99 *       group = (vce2grp[vce] - 1) << 4;
    100 *
     98
     99|       group = (vce2grp[vce] - 1) << 4;
     100
    101101                move.w  VCE(A6),A0
    102102                add.l   A0,A0
    … …  
    107107                asl.w   #4,D0
    108108                move.w  D0,GROUP(A6)
    109 *
    110                 .page
    111 * ------------------------------------------------------------------------------
    112 * Start function 0 -- Frq 1
    113 * ------------------------------------------------------------------------------
    114 *
    115 *    if (ip->idhfnc[0].idftmd & I_TM_KEY) {
    116 *
     109
     110                .page
     111| ------------------------------------------------------------------------------
     112| Start function 0 -- Frq 1
     113| ------------------------------------------------------------------------------
     114
     115|    if (ip->idhfnc[0].idftmd & I_TM_KEY) {
     116
    117117                move.l  IP(A6),A0
    118118                move.b  93(A0),D0
    … …  
    121121                btst    #0,D0
    122122                bne     FN00A
    123 *
     123
    124124                jmp     FN01
    125 *
    126 *       vp = (vce << 4) + 1;
    127 *
     125
     126|       vp = (vce << 4) + 1;
     127
    128128FN00A:          move    VCE(A6),D0
    129129                asl     #4,D0
    130130                add.w   #1,D0
    131131                move    D0,VP(A6)
    132 *
    133 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    134 *
     132
     133|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     134
    135135                asl     #5,D0
    136136                ext.l   D0
    137137                move.l  D0,A_FPU
    138                 add.l   #_io_fpu+$4000,A_FPU
    139 *
    140 *       fp = &ip->idhfnc[0];
    141 *
     138                add.l   #_io_fpu+0x4000,A_FPU
     139
     140|       fp = &ip->idhfnc[0];
     141
    142142                move.l  IP(A6),A_FP
    143143                add.l   #86,A_FP
    144 *
    145 *       pt = &ip->idhpnt[fp->idfpt1];
    146 *
     144
     145|       pt = &ip->idhpnt[fp->idfpt1];
     146
    147147                clr.l   D0
    148148                move.b  6(A_FP),D0
    … …  
    154154                add.l   #242,D0
    155155                move.l  D0,PT(A6)
    156 *
    157                 .page
    158 *
    159 *       srcnum = group | fp->idfsrc;
    160 *
     156
     157                .page
     158
     159|       srcnum = group | fp->idfsrc;
     160
    161161                move.w  GROUP(A6),D0
    162162                ext.l   D0
    … …  
    165165                or      D1,D0
    166166                move    D0,SRCNUM(A6)
    167 *
    168 *       vep = &valents[srcnum];
    169 *
     167
     168|       vep = &valents[srcnum];
     169
    170170                add.l   D0,D0
    171171                move.l  D0,D1
    … …  
    174174                add.l   #_valents,D0
    175175                move.l  D0,VEP(A6)
    176 *
    177 *       smp = vpsms[vp];
    178 *
     176
     177|       smp = vpsms[vp];
     178
    179179                move    VP(A6),A0
    180180                add.l   A0,A0
    … …  
    182182                add.l   #_vpsms,A0
    183183                move.l  (A0),A_SMP
    184 *
    185 *       if (srcnum NE smp->sm) {
    186 *
     184
     185|       if (srcnum NE smp->sm) {
     186
    187187                clr     D0
    188188                move    10(A_SMP),D0
    189189                cmp     SRCNUM(A6),D0
    190190                beq     F00L113
    191 *
    192 *               (smp->prv)->nxt = smp->nxt;
    193 *
     191
     192|               (smp->prv)->nxt = smp->nxt;
     193
    194194                move.l  4(A_SMP),A0
    195195                move.l  (A_SMP),(A0)
    196 *
    197 *               (smp->nxt)->prv = smp->prv;
    198 *
     196
     197|               (smp->nxt)->prv = smp->prv;
     198
    199199                move.l  (A_SMP),A0
    200200                move.l  4(A_SMP),4(A0)
    201 *
    202 *               smp->prv = (struct sment *)vep;
    203 *
     201
     202|               smp->prv = (struct sment |)vep;
     203
    204204                move.l  VEP(A6),4(A_SMP)
    205 *
    206 *               smp->nxt = vep->nxt;
    207 *
     205
     206|               smp->nxt = vep->nxt;
     207
    208208                move.l  VEP(A6),A0
    209209                move.l  (A0),(A_SMP)
    210 *
    211 *               (vep->nxt)->prv = smp;
    212 *
     210
     211|               (vep->nxt)->prv = smp;
     212
    213213                move.l  VEP(A6),A0
    214214                move.l  (A0),A0
    215215                move.l  A_SMP,4(A0)
    216 *
    217 *               vep->nxt = smp;
    218 *
     216
     217|               vep->nxt = smp;
     218
    219219                move.l  VEP(A6),A0
    220220                move.l  A_SMP,(A0)
    221 *
    222 *               smp->sm = srcnum;
    223 *
     221
     222|               smp->sm = srcnum;
     223
    224224                move    SRCNUM(A6),10(A_SMP)
    225 *
    226 *       }
    227 *
    228 *       mltval = fp->idfmlt;
    229 *
     225
     226|       }
     227
     228|       mltval = fp->idfmlt;
     229
    230230F00L113:        move    2(A_FP),MLTVAL(A6)
    231 *
    232                 .page
    233 *
    234 *       switch (fp->idfsrc) {
    235 *
     231
     232                .page
     233
     234|       switch (fp->idfsrc) {
     235
    236236                move.b  4(A_FP),D0
    237237                ext.w   d0
    238238                cmp     #10,D0
    239239                bhi     F00L122
    240 *
     240
    241241                asl     #2,D0
    242242                lea     F00L123,A0
    243243                movea.l 0(A0,D0.W),A0
    244244                jmp     (A0)
    245 *
    246 *       case SM_NONE:
    247 *               mltval = 0;
    248 *
     245
     246|       case SM_NONE:
     247|               mltval = 0;
     248
    249249F00L116:        clr     MLTVAL(A6)
    250 *
    251 *               tsrcval = 0;
    252 *
     250
     251|               tsrcval = 0;
     252
    253253                clr     TSRCVAL(A6)
    254 *
    255 *               break;
    256 *
     254
     255|               break;
     256
    257257                bra     F00L114
    258 *
    259 *       case SM_RAND:
    260 *               tsrcval = xgetran(mltval);
    261 *
     258
     259|       case SM_RAND:
     260|               tsrcval = xgetran(mltval);
     261
    262262F00L117:        move    MLTVAL(A6),(sp)
    263263                jsr     _xgetran
    264264                move    D0,TSRCVAL(A6)
    265 *
    266 *               break;
    267 *
     265
     266|               break;
     267
    268268                bra     F00L114
    269 *
    270 *       case SM_PTCH:
    271 *               tsrcval = pch;
    272 *
     269
     270|       case SM_PTCH:
     271|               tsrcval = pch;
     272
    273273F00L118:        move    PCH(A6),TSRCVAL(A6)
    274 *
    275 *               break;
    276 *
     274
     275|               break;
     276
    277277                bra     F00L114
    278 *
    279                 .page
    280 *
    281 *       case SM_FREQ:
    282 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    283 *
     278
     279                .page
     280
     281|       case SM_FREQ:
     282|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     283
    284284F00L119:        move.w  PCH(A6),D0
    285285                asr.w   #7,D0
    286                 and.w   #$00FF,D0
     286                and.w   #0x00FF,D0
    287287                move.w  D0,A0
    288288                add.l   A0,A0
    289289                add.l   #_ptoftab,A0
    290290                move.w  (A0),TSRCVAL(A6)
    291 *
    292 *               break;
    293 *
     291
     292|               break;
     293
    294294                bra     F00L114
    295 *
    296 *       case SM_KVEL:
    297 *               tsrcval = veltab[trg];
    298 *
     295
     296|       case SM_KVEL:
     297|               tsrcval = veltab[trg];
     298
    299299F00L120:        move.w  TRG(A6),A0
    300300                add.l   A0,A0
    301301                add.l   #_veltab,A0
    302302                move.w  (A0),TSRCVAL(A6)
    303 *
    304 *               break;
    305 *
     303
     304|               break;
     305
    306306                bra     F00L114
    307 *
    308 *       case SM_KPRS:
    309 *               tsrcval = prstab[trg];
    310 *
     307
     308|       case SM_KPRS:
     309|               tsrcval = prstab[trg];
     310
    311311F00L121:        move.w  TRG(A6),A0
    312312                add.l   A0,A0
    313313                add.l   #_prstab,A0
    314314                move.w  (A0),TSRCVAL(A6)
    315 *
    316 *               break;
    317 *
     315
     316|               break;
     317
    318318                bra     F00L114
    319 *
    320 *       default:
    321 *               tsrcval = vep->val;
    322 *
     319
     320|       default:
     321|               tsrcval = vep->val;
     322
    323323F00L122:        move.l  VEP(A6),A0
    324324                move.w  8(A0),TSRCVAL(A6)
    325 *
    326 *       }
    327 *
    328                 .page
    329 *
    330 *               srcval = addpch(tsrcval, 0);
    331 *
     325
     326|       }
     327
     328                .page
     329
     330|               srcval = addpch(tsrcval, 0);
     331
    332332F00L114:        move.w  TSRCVAL(A6),D0
    333333                ext.l   D0
    334334                asr.l   #5,D0
    335 *               sub.l   #500,D0
     335|               sub.l   #500,D0
    336336                asl.l   #LSPCH,D0
    337337                cmp.l   #PITCHMAX,D0
    338338                ble     F00L129A
    339 *
     339
    340340                move.l  #PITCHMAX,D0
    341 *
     341
    342342F00L129A:       move    D0,SRCVAL(A6)
    343 *
    344                 .page
    345 *
    346 *       if (pt->ipvsrc) {
    347 *
     343
     344                .page
     345
     346|       if (pt->ipvsrc) {
     347
    348348F00L124:        move.l  PT(A6),A0
    349349                tst.b   6(A0)
    350350                beq     F00L136
    351 *
    352 *               switch (pt->ipvsrc) {
    353 *
     351
     352|               switch (pt->ipvsrc) {
     353
    354354                move.l  PT(A6),A0
    355355                move.b  6(A0),D0
    … …  
    358358                cmp     #9,D0
    359359                bhi     F00L144
    360 *
     360
    361361                asl     #2,D0
    362362                lea     F00L145,A0
    363363                move.l  0(A0,D0.W),A0
    364364                jmp     (A0)
    365 *
    366 *               case SM_RAND:
    367 *                       ltmp = xgetran(pt_>ipvmlt);
    368 *
     365
     366|               case SM_RAND:
     367|                       ltmp = xgetran(pt_>ipvmlt);
     368
    369369F00L139:        move.l  PT(A6),A0
    370370                move    4(A0),(sp)
    … …  
    372372                ext.l   D0
    373373                move.l  D0,LTMP(A6)
    374 *
    375 *                       break;
    376 *
     374
     375|                       break;
     376
    377377                bra     F00L137
    378 *
    379 *               case SM_PTCH:
    380 *                       ltmp = pch;
    381 *
     378
     379|               case SM_PTCH:
     380|                       ltmp = pch;
     381
    382382F00L140:        move    PCH(A6),A0
    383383                move.l  A0,LTMP(A6)
    384 *
    385 *                       break;
    386 *
     384
     385|                       break;
     386
    387387                bra     F00L137
    388 *
    389                 .page
    390 *
    391 *               case SM_FREQ:
    392 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    393 *
     388
     389                .page
     390
     391|               case SM_FREQ:
     392|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     393
    394394F00L141:        move    PCH(A6),D0
    395395                asr     #7,D0
    … …  
    401401                ext.l   D0
    402402                move.l  D0,LTMP(A6)
    403 *
    404 *                       break;
    405 *
     403
     404|                       break;
     405
    406406                bra     F00L137
    407 *
    408 *               case SM_KVEL:
    409 *                       ltmp = veltab[trg];
    410 *
     407
     408|               case SM_KVEL:
     409|                       ltmp = veltab[trg];
     410
    411411F00L142:        move    TRG(A6),A0
    412412                add.l   A0,A0
    … …  
    415415                ext.l   D0
    416416                move.l  D0,LTMP(A6)
    417 *
    418 *                       break;
    419 *
     417
     418|                       break;
     419
    420420                bra     F00L137
    421 *
    422                 .page
    423 *
    424 *               case SM_KPRS:
    425 *                       ltmp = prstab[trg];
    426 *
     421
     422                .page
     423
     424|               case SM_KPRS:
     425|                       ltmp = prstab[trg];
     426
    427427F00L143:        move    TRG(A6),A0
    428428                add.l   A0,A0
    … …  
    431431                ext.l   D0
    432432                move.l  D0,LTMP(A6)
    433 *
    434 *                       break;
    435 *
     433
     434|                       break;
     435
    436436                bra     F00L137
    437 *
    438                 .page
    439 *
    440 *               default:
    441 *                       ltmp = valents[group | pt->ipvsrc].val;
    442 *
     437
     438                .page
     439
     440|               default:
     441|                       ltmp = valents[group | pt->ipvsrc].val;
     442
    443443F00L144:        move.l  PT(A6),A0
    444444                clr.l   D0
    … …  
    454454                move    8(A0,A1.l),D0
    455455                move.l  D0,LTMP(A6)
    456 *
    457 *               }
    458 *
    459 *
    460                 .page
    461 *
    462 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    463 *
     456
     457|               }
     458
     459
     460                .page
     461
     462|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     463
    464464F00L137:        move.l  PT(A6),A0
    465465                move.w  4(A0),D0
    … …  
    469469                asr.l   D1,D0
    470470                move.l  D0,LTMP(A6)
    471 *
    472 *               ltmp += (long)pt->ipval;
    473 *
     471
     472|               ltmp += (long)pt->ipval;
     473
    474474                move.l  PT(A6),A0
    475475                move    2(A0),D0
    476476                ext.l   D0
    477477                add.l   D0,LTMP(A6)
    478 *
    479 *               if (ltmp GT (long)VALMAX)
    480 *                       ltmp = (long)VALMAX;
    481 *
     478
     479|               if (ltmp GT (long)VALMAX)
     480|                       ltmp = (long)VALMAX;
     481
    482482                cmp.l   #VALMAX,LTMP(A6)
    483483                ble     F00L146
    484 *
     484
    485485                move.l  #VALMAX,LTMP(A6)
    486486                bra     F00L147
    487 *
    488 *               else if (ltmp LT (long)VALMIN)
    489 *                       ltmp = (long)VALMIN;
    490 *
     487
     488|               else if (ltmp LT (long)VALMIN)
     489|                       ltmp = (long)VALMIN;
     490
    491491F00L146:        cmp.l   #VALMIN,LTMP(A6)
    492492                bge     F00L147
    493 *
     493
    494494                move.l  #VALMIN,LTMP(A6)
    495 *
    496 *               tfpval = (short)ltmp;
    497 *
     495
     496|               tfpval = (short)ltmp;
     497
    498498F00L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    499499                bra     F00L149
    500 *
    501 *       } else {
    502 *
    503 *               tfpval = pt->ipval;
    504 *
     500
     501|       } else {
     502
     503|               tfpval = pt->ipval;
     504
    505505F00L136:        move.l  PT(A6),A0
    506506                move    2(A0),TFPVAL(A6)
    507 *
    508 *       }
    509 *
    510                 .page
    511 *
    512 *       fpmant = (((long)pt->iptim & 0x0000FFF0L)
    513 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    514 *
     507
     508|       }
     509
     510                .page
     511
     512|       fpmant = (((long)pt->iptim & 0x0000FFF0L)
     513|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     514
    515515F00L149:        move.l  PT(A6),A0
    516516                move.w  (A0),D0
    517517                move.w  D0,D2
    518                 andi.w  #$FFF0,D0
     518                andi.w  #0xFFF0,D0
    519519                move.w  _timemlt,D1
    520520                muls    D1,D0
    … …  
    522522                asr.l   D1,D0
    523523                move    D0,R_FPMANT
    524 *
    525 *       fpexp = expbit[pt->iptim & 0x000F];
    526 *
    527                 and     #$000F,D2
     524
     525|       fpexp = expbit[pt->iptim & 0x000F];
     526
     527                and     #0x000F,D2
    528528                move    D2,A0
    529529                add.l   A0,A0
    530530                add.l   #_expbit,A0
    531531                move    (A0),R_FPEXP
    532 *
    533                 .page
    534 *
    535 *               octype = ip->idhos1c & OC_MOD;
    536 *
     532
     533                .page
     534
     535|               octype = ip->idhos1c & OC_MOD;
     536
    537537F00L152:        move.l  IP(A6),A0
    538538                move.b  74(A0),D0
    539539                and     #3,D0
    540 *
    541 *               if ((octype EQ OC_FRQ) OR (octype EQ OC_PCH))
    542 *
     540
     541|               if ((octype EQ OC_FRQ) OR (octype EQ OC_PCH))
     542
    543543                cmp     #2,D0
    544544                beq     F00L1001
    545 *
     545
    546546                cmp     #3,D0
    547547                bne     F00L153
    548 *
    549 *                       fp->idfpch = ip->idhos1v;
    550 *
     548
     549|                       fp->idfpch = ip->idhos1v;
     550
    551551F00L1001:       move.l  IP(A6),A0
    552552                move    78(A0),(A_FP)
    553553                bra     F00L154
    554 *
    555 *               else
    556 *                       fp->idfpch = pch + ip->idhos1v;
    557 *
     554
     555|               else
     556|                       fp->idfpch = pch + ip->idhos1v;
     557
    558558F00L153:        move.w  PCH(A6),D0
    559559                ext.l   D0
    … …  
    561561                ext.l   D1
    562562                add.l   d1,d0
    563 *
    564 *               if (fp->idfpch > PITCHMAX)
    565 *                       fp->idfpch = PITCHMAX;
    566 *
     563
     564|               if (fp->idfpch > PITCHMAX)
     565|                       fp->idfpch = PITCHMAX;
     566
    567567                cmp.l   #PITCHMAX,d0
    568568                ble     F00153A
    569 *
     569
    570570                move.l  #PITCHMAX,d0
    571 *
     571
    572572F00153A:        move.w  d0,(A_FP)
    573 *
    574 *               fpval = addpch(tfpval, fp->idfpch);
    575 *
     573
     574|               fpval = addpch(tfpval, fp->idfpch);
     575
    576576F00L154:        move.w  TFPVAL(A6),D1
    577577                ext.l   D1
    … …  
    584584                cmp.l   #PITCHMAX,D0
    585585                ble     F00L154A
    586 *
     586
    587587                move.l  #PITCHMAX,D0
    588 *
     588
    589589F00L154A:       move    D0,R_FPVAL
    590 *
    591                 .page
    592 *
     590
     591                .page
     592
    593593                move.b  5(A_FP),D0
    594594                ext.w   D0
    595595                sub.w   #1,D0
    596596                movea.l PT(A6),A0
    597 *
    598 *       oldi = setipl(FPU_DI);
    599 *
     597
     598|       oldi = setipl(FPU_DI);
     599
    600600                move    sr,OLDI(A6)
    601601                move    #FPU_DI,sr
    602 *
     602
    603603F00L168:        clr.b   10(A0)
    604604                add.l   #12,A0
    605605                dbra    D0,F00L168
    606 *
    607                 .page
    608 *
    609 *       fp->idftmd ^= I_NVBITS;
    610 *
     606
     607                .page
     608
     609|       fp->idftmd ^= I_NVBITS;
     610
    611611F00L165:        eor.b   #24,7(A_FP)
    612 *
    613 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    614 *
     612
     613|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     614
    615615                move.b  7(A_FP),R_FPCTL
    616616                and     #28,R_FPCTL
    617617                or      #3,R_FPCTL
    618 *
    619 *       fp->idfcpt = fp->idfpt1;
    620 *
     618
     619|       fp->idfcpt = fp->idfpt1;
     620
    621621                move.b  6(A_FP),8(A_FP)
    622 *
    623 *       fp->idftmd |= I_ACTIVE;
    624 *
     622
     623|       fp->idftmd |= I_ACTIVE;
     624
    625625                or.b    #2,7(A_FP)
    626 *
    627 *       fp->idftrf = trg;
    628 *
     626
     627|       fp->idftrf = trg;
     628
    629629                move    TRG(A6),10(A_FP)
    630 *
    631 *       *(fpu + (long)FPU_TCV1) = srcval;
    632 *
    633                 move    SRCVAL(A6),$8(A_FPU)
    634 *
    635 *       ++octype;
    636 *
     630
     631|       |(fpu + (long)FPU_TCV1) = srcval;
     632
     633                move    SRCVAL(A6),0x8(A_FPU)
     634
     635|       ++octype;
     636
    637637                add     #1,OCTYPE(A6)
    638 *
    639 *       *(fpu + (long)FPU_TSF1) = mltval;
    640 *
    641                 move    MLTVAL(A6),$A(A_FPU)
    642 *
    643 *       ++octype;
    644 *
     638
     639|       |(fpu + (long)FPU_TSF1) = mltval;
     640
     641                move    MLTVAL(A6),0xA(A_FPU)
     642
     643|       ++octype;
     644
    645645                add     #1,OCTYPE(A6)
    646 *
    647 *       *(fpu + (long)FPU_TMNT) = fpmant;
    648 *
    649                 move    R_FPMANT,$14(A_FPU)
    650 *
    651 *       ++octype;
    652 *
     646
     647|       |(fpu + (long)FPU_TMNT) = fpmant;
     648
     649                move    R_FPMANT,0x14(A_FPU)
     650
     651|       ++octype;
     652
    653653                add     #1,OCTYPE(A6)
    654 *
    655 *       *(fpu + (long)FPU_TEXP) = fpexp;
    656 *
    657                 move    R_FPEXP,$16(A_FPU)
    658 *
    659 *       ++octype;
    660 *
     654
     655|       |(fpu + (long)FPU_TEXP) = fpexp;
     656
     657                move    R_FPEXP,0x16(A_FPU)
     658
     659|       ++octype;
     660
    661661                add     #1,OCTYPE(A6)
    662 *
    663                 .page
    664 *
    665 *       if (fp->idftmd & I_VNSUBN)
    666 *
     662
     663                .page
     664
     665|       if (fp->idftmd & I_VNSUBN)
     666
    667667                btst    #3,7(A_FP)
    668668                beq     F00L169
    669 *
    670 *               *(fpu + (long)FPU_TNV1) = fpval;
    671 *
    672                 move    R_FPVAL,$1C(A_FPU)
     669
     670|               |(fpu + (long)FPU_TNV1) = fpval;
     671
     672                move    R_FPVAL,0x1C(A_FPU)
    673673                bra     F00L170
    674 *
    675 *       else
    676 *               *(fpu + (long)FPU_TNV0) = fpval;
    677 *
     674
     675|       else
     676|               |(fpu + (long)FPU_TNV0) = fpval;
     677
    678678F00L169:        move    R_FPVAL,2(A_FPU)
    679 *
    680 *       ++octype;
    681 *
     679
     680|       ++octype;
     681
    682682F00L170:        add     #1,OCTYPE(A6)
    683 *
    684 *       *(fpu + (long)FPU_TCTL) = fpctl;
    685 *
     683
     684|       |(fpu + (long)FPU_TCTL) = fpctl;
     685
    686686                move    R_FPCTL,(A_FPU)
    687 *
    688 *       setipl(oldi);
    689 *
     687
     688|       setipl(oldi);
     689
    690690                move    OLDI(A6),sr
    691 *    }
    692 *
    693                 .page
    694 * ------------------------------------------------------------------------------
    695 * Start function 1 -- Frq 2
    696 * ------------------------------------------------------------------------------
    697 *    if (legato) {
    698 *
    699 *       legato = 0;
    700 *       return;
    701 *    }
     691|    }
     692
     693                .page
     694| ------------------------------------------------------------------------------
     695| Start function 1 -- Frq 2
     696| ------------------------------------------------------------------------------
     697|    if (legato) {
     698
     699|       legato = 0;
     700|       return;
     701|    }
    702702FN01:           tst.w   _legato
    703703                beq     FN01AA
    704 *
     704
    705705                clr.w   _legato
    706706                bra     FNEXIT
    707 *
    708 *    if (ip->idhfnc[1].idftmd & I_TM_KEY) {
    709 *
     707
     708|    if (ip->idhfnc[1].idftmd & I_TM_KEY) {
     709
    710710FN01AA:         move.l  IP(A6),A0
    711711                move.b  105(A0),D0
    … …  
    714714                btst    #0,D0
    715715                bne     FN01A
    716 *
     716
    717717                jmp     FN02
    718 *
    719 *       vp = (vce << 4) + 3;
    720 *
     718
     719|       vp = (vce << 4) + 3;
     720
    721721FN01A:          move    VCE(A6),D0
    722722                asl     #4,D0
    723723                add.w   #3,D0
    724724                move    D0,VP(A6)
    725 *
    726 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    727 *
     725
     726|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     727
    728728                asl     #5,D0
    729729                ext.l   D0
    730730                move.l  D0,A_FPU
    731                 add.l   #_io_fpu+$4000,A_FPU
    732 *
    733 *       fp = &ip->idhfnc[1];
    734 *
     731                add.l   #_io_fpu+0x4000,A_FPU
     732
     733|       fp = &ip->idhfnc[1];
     734
    735735                move.l  #12,A_FP
    736736                add.l   IP(A6),A_FP
    737737                add.l   #86,A_FP
    738 *
    739 *       pt = &ip->idhpnt[fp->idfpt1];
    740 *
     738
     739|       pt = &ip->idhpnt[fp->idfpt1];
     740
    741741                clr.l   D0
    742742                move.b  6(A_FP),D0
    … …  
    748748                add.l   #242,D0
    749749                move.l  D0,PT(A6)
    750 *
    751                 .page
    752 *
    753 *       srcnum = group | fp->idfsrc;
    754 *
     750
     751                .page
     752
     753|       srcnum = group | fp->idfsrc;
     754
    755755                move.w  GROUP(A6),D0
    756756                ext.l   D0
    … …  
    759759                or      D1,D0
    760760                move    D0,SRCNUM(A6)
    761 *
    762 *       vep = &valents[srcnum];
    763 *
     761
     762|       vep = &valents[srcnum];
     763
    764764                add.l   D0,D0
    765765                move.l  D0,D1
    … …  
    768768                add.l   #_valents,D0
    769769                move.l  D0,VEP(A6)
    770 *
    771 *       smp = vpsms[vp];
    772 *
     770
     771|       smp = vpsms[vp];
     772
    773773                move    VP(A6),A0
    774774                add.l   A0,A0
    … …  
    776776                add.l   #_vpsms,A0
    777777                move.l  (A0),A_SMP
    778 *
    779 *       if (srcnum NE smp->sm) {
    780 *
     778
     779|       if (srcnum NE smp->sm) {
     780
    781781                clr     D0
    782782                move    10(A_SMP),D0
    783783                cmp     SRCNUM(A6),D0
    784784                beq     F01L113
    785 *
    786 *               (smp->prv)->nxt = smp->nxt;
    787 *
     785
     786|               (smp->prv)->nxt = smp->nxt;
     787
    788788                move.l  4(A_SMP),A0
    789789                move.l  (A_SMP),(A0)
    790 *
    791 *               (smp->nxt)->prv = smp->prv;
    792 *
     790
     791|               (smp->nxt)->prv = smp->prv;
     792
    793793                move.l  (A_SMP),A0
    794794                move.l  4(A_SMP),4(A0)
    795 *
    796 *               smp->prv = (struct sment *)vep;
    797 *
     795
     796|               smp->prv = (struct sment |)vep;
     797
    798798                move.l  VEP(A6),4(A_SMP)
    799 *
    800 *               smp->nxt = vep->nxt;
    801 *
     799
     800|               smp->nxt = vep->nxt;
     801
    802802                move.l  VEP(A6),A0
    803803                move.l  (A0),(A_SMP)
    804 *
    805 *               (vep->nxt)->prv = smp;
    806 *
     804
     805|               (vep->nxt)->prv = smp;
     806
    807807                move.l  VEP(A6),A0
    808808                move.l  (A0),A0
    809809                move.l  A_SMP,4(A0)
    810 *
    811 *               vep->nxt = smp;
    812 *
     810
     811|               vep->nxt = smp;
     812
    813813                move.l  VEP(A6),A0
    814814                move.l  A_SMP,(A0)
    815 *
    816 *               smp->sm = srcnum;
    817 *
     815
     816|               smp->sm = srcnum;
     817
    818818                move    SRCNUM(A6),10(A_SMP)
    819 *
    820 *       }
    821 *
    822 *       mltval = fp->idfmlt;
    823 *
     819
     820|       }
     821
     822|       mltval = fp->idfmlt;
     823
    824824F01L113:        move    2(A_FP),MLTVAL(A6)
    825 *
    826                 .page
    827 *
    828 *       switch (fp->idfsrc) {
    829 *
     825
     826                .page
     827
     828|       switch (fp->idfsrc) {
     829
    830830                move.b  4(A_FP),D0
    831831                ext.w   d0
    832832                cmp     #10,D0
    833833                bhi     F01L122
    834 *
     834
    835835                asl     #2,D0
    836836                lea     F01L123,A0
    837837                movea.l 0(A0,D0.W),A0
    838838                jmp     (A0)
    839 *
    840 *       case SM_NONE:
    841 *               mltval = 0;
    842 *
     839
     840|       case SM_NONE:
     841|               mltval = 0;
     842
    843843F01L116:        clr     MLTVAL(A6)
    844 *
    845 *               tsrcval = 0;
    846 *
     844
     845|               tsrcval = 0;
     846
    847847                clr     TSRCVAL(A6)
    848 *
    849 *               break;
    850 *
     848
     849|               break;
     850
    851851                bra     F01L114
    852 *
    853 *       case SM_RAND:
    854 *               tsrcval = xgetran(mltval);
    855 *
     852
     853|       case SM_RAND:
     854|               tsrcval = xgetran(mltval);
     855
    856856F01L117:        move    MLTVAL(A6),(sp)
    857857                jsr     _xgetran
    858858                move    D0,TSRCVAL(A6)
    859 *
    860 *               break;
    861 *
     859
     860|               break;
     861
    862862                bra     F01L114
    863 *
    864 *       case SM_PTCH:
    865 *               tsrcval = pch;
    866 *
     863
     864|       case SM_PTCH:
     865|               tsrcval = pch;
     866
    867867F01L118:        move    PCH(A6),TSRCVAL(A6)
    868 *
    869 *               break;
    870 *
     868
     869|               break;
     870
    871871                bra     F01L114
    872 *
    873                 .page
    874 *
    875 *       case SM_FREQ:
    876 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    877 *
     872
     873                .page
     874
     875|       case SM_FREQ:
     876|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     877
    878878F01L119:        move    PCH(A6),D0
    879879                asr     #7,D0
    … …  
    883883                add.l   #_ptoftab,A0
    884884                move    (A0),TSRCVAL(A6)
    885 *
    886 *               break;
    887 *
     885
     886|               break;
     887
    888888                bra     F01L114
    889 *
    890 *       case SM_KVEL:
    891 *               tsrcval = veltab[trg];
    892 *
     889
     890|       case SM_KVEL:
     891|               tsrcval = veltab[trg];
     892
    893893F01L120:        move    TRG(A6),A0
    894894                add.l   A0,A0
    895895                add.l   #_veltab,A0
    896896                move    (A0),TSRCVAL(A6)
    897 *
    898 *               break;
    899 *
     897
     898|               break;
     899
    900900                bra     F01L114
    901 *
    902 *       case SM_KPRS:
    903 *               tsrcval = prstab[trg];
    904 *
     901
     902|       case SM_KPRS:
     903|               tsrcval = prstab[trg];
     904
    905905F01L121:        move    TRG(A6),A0
    906906                add.l   A0,A0
    907907                add.l   #_prstab,A0
    908908                move    (A0),TSRCVAL(A6)
    909 *
    910 *               break;
    911 *
     909
     910|               break;
     911
    912912                bra     F01L114
    913 *
    914 *       default:
    915 *               tsrcval = vep->val;
    916 *
     913
     914|       default:
     915|               tsrcval = vep->val;
     916
    917917F01L122:        move.l  VEP(A6),A0
    918918                move    8(A0),TSRCVAL(A6)
    919 *
    920 *       }
    921 *
    922                 .page
    923 *
    924 *               srcval = addpch(tsrcval, 0);
    925 *
     919
     920|       }
     921
     922                .page
     923
     924|               srcval = addpch(tsrcval, 0);
     925
    926926F01L114:        move.w  TSRCVAL(A6),D0
    927927                ext.l   D0
    928928                asr.l   #5,D0
    929 *               sub.l   #500,D0
     929|               sub.l   #500,D0
    930930                asl.l   #LSPCH,D0
    931931                cmp.l   #PITCHMAX,D0
    932932                ble     F01L129A
    933 *
     933
    934934                move.l  #PITCHMAX,D0
    935 *
     935
    936936F01L129A:       move    D0,SRCVAL(A6)
    937 *
    938                 .page
    939 *
    940 *       if (pt->ipvsrc) {
    941 *
     937
     938                .page
     939
     940|       if (pt->ipvsrc) {
     941
    942942F01L124:        move.l  PT(A6),A0
    943943                tst.b   6(A0)
    944944                beq     F01L136
    945 *
    946 *               switch (pt->ipvsrc) {
    947 *
     945
     946|               switch (pt->ipvsrc) {
     947
    948948                move.l  PT(A6),A0
    949949                move.b  6(A0),D0
    … …  
    952952                cmp     #9,D0
    953953                bhi     F01L144
    954 *
     954
    955955                asl     #2,D0
    956956                lea     F01L145,A0
    957957                move.l  0(A0,D0.W),A0
    958958                jmp     (A0)
    959 *
    960 *               case SM_RAND:
    961 *                       ltmp = xgetran(pt_>ipvmlt);
    962 *
     959
     960|               case SM_RAND:
     961|                       ltmp = xgetran(pt_>ipvmlt);
     962
    963963F01L139:        move.l  PT(A6),A0
    964964                move    4(A0),(sp)
    … …  
    966966                ext.l   D0
    967967                move.l  D0,LTMP(A6)
    968 *
    969 *                       break;
    970 *
     968
     969|                       break;
     970
    971971                bra     F01L137
    972 *
    973 *               case SM_PTCH:
    974 *                       ltmp = pch;
    975 *
     972
     973|               case SM_PTCH:
     974|                       ltmp = pch;
     975
    976976F01L140:        move    PCH(A6),A0
    977977                move.l  A0,LTMP(A6)
    978 *
    979 *                       break;
    980 *
     978
     979|                       break;
     980
    981981                bra     F01L137
    982 *
    983                 .page
    984 *
    985 *               case SM_FREQ:
    986 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    987 *
     982
     983                .page
     984
     985|               case SM_FREQ:
     986|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     987
    988988F01L141:        move    PCH(A6),D0
    989989                asr     #7,D0
    … …  
    995995                ext.l   D0
    996996                move.l  D0,LTMP(A6)
    997 *
    998 *                       break;
    999 *
     997
     998|                       break;
     999
    10001000                bra     F01L137
    1001 *
    1002 *               case SM_KVEL:
    1003 *                       ltmp = veltab[trg];
    1004 *
     1001
     1002|               case SM_KVEL:
     1003|                       ltmp = veltab[trg];
     1004
    10051005F01L142:        move    TRG(A6),A0
    10061006                add.l   A0,A0
    … …  
    10091009                ext.l   D0
    10101010                move.l  D0,LTMP(A6)
    1011 *
    1012 *                       break;
    1013 *
     1011
     1012|                       break;
     1013
    10141014                bra     F01L137
    1015 *
    1016                 .page
    1017 *
    1018 *               case SM_KPRS:
    1019 *                       ltmp = prstab[trg];
    1020 *
     1015
     1016                .page
     1017
     1018|               case SM_KPRS:
     1019|                       ltmp = prstab[trg];
     1020
    10211021F01L143:        move    TRG(A6),A0
    10221022                add.l   A0,A0
    … …  
    10251025                ext.l   D0
    10261026                move.l  D0,LTMP(A6)
    1027 *
    1028 *                       break;
    1029 *
     1027
     1028|                       break;
     1029
    10301030                bra     F01L137
    1031 *
    1032                 .page
    1033 *
    1034 *               default:
    1035 *                       ltmp = valents[group | pt->ipvsrc].val;
    1036 *
     1031
     1032                .page
     1033
     1034|               default:
     1035|                       ltmp = valents[group | pt->ipvsrc].val;
     1036
    10371037F01L144:        move.l  PT(A6),A0
    10381038                clr.l   D0
    … …  
    10481048                move    8(A0,A1.l),D0
    10491049                move.l  D0,LTMP(A6)
    1050 *
    1051 *               }
    1052 *
    1053 *
    1054                 .page
    1055 *
    1056 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    1057 *
     1050
     1051|               }
     1052
     1053
     1054                .page
     1055
     1056|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     1057
    10581058F01L137:        move.l  PT(A6),A0
    10591059                move.w  4(A0),D0
    … …  
    10631063                asr.l   D1,D0
    10641064                move.l  D0,LTMP(A6)
    1065 *
    1066 *               ltmp += (long)pt->ipval;
    1067 *
     1065
     1066|               ltmp += (long)pt->ipval;
     1067
    10681068                move.l  PT(A6),A0
    10691069                move    2(A0),D0
    10701070                ext.l   D0
    10711071                add.l   D0,LTMP(A6)
    1072 *
    1073 *               if (ltmp GT (long)VALMAX)
    1074 *                       ltmp = (long)VALMAX;
    1075 *
     1072
     1073|               if (ltmp GT (long)VALMAX)
     1074|                       ltmp = (long)VALMAX;
     1075
    10761076                cmp.l   #VALMAX,LTMP(A6)
    10771077                ble     F01L146
    1078 *
     1078
    10791079                move.l  #VALMAX,LTMP(A6)
    10801080                bra     F01L147
    1081 *
    1082 *               else if (ltmp LT (long)VALMIN)
    1083 *                       ltmp = (long)VALMIN;
    1084 *
     1081
     1082|               else if (ltmp LT (long)VALMIN)
     1083|                       ltmp = (long)VALMIN;
     1084
    10851085F01L146:        cmp.l   #VALMIN,LTMP(A6)
    10861086                bge     F01L147
    1087 *
     1087
    10881088                move.l  #VALMIN,LTMP(A6)
    1089 *
    1090 *               tfpval = (short)ltmp;
    1091 *
     1089
     1090|               tfpval = (short)ltmp;
     1091
    10921092F01L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    10931093                bra     F01L149
    1094 *
    1095 *       } else {
    1096 *
    1097 *               tfpval = pt->ipval;
    1098 *
     1094
     1095|       } else {
     1096
     1097|               tfpval = pt->ipval;
     1098
    10991099F01L136:        move.l  PT(A6),A0
    11001100                move    2(A0),TFPVAL(A6)
    1101 *
    1102 *       }
    1103 *
    1104                 .page
    1105 *
    1106 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    1107 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    1108 *
     1101
     1102|       }
     1103
     1104                .page
     1105
     1106|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     1107|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     1108
    11091109F01L149:        move.l  PT(A6),A0
    11101110                move.w  (A0),D0
    11111111                move.w  D0,D2
    1112                 andi.w  #$FFF0,D0
     1112                andi.w  #0xFFF0,D0
    11131113                move.w  _timemlt,D1
    11141114                muls    D1,D0
    … …  
    11161116                asr.l   D1,D0
    11171117                move    D0,R_FPMANT
    1118 *
    1119 *       fpexp = expbit[pt->iptim & 0x000F];
    1120 *
    1121                 and     #$000F,D2
     1118
     1119|       fpexp = expbit[pt->iptim & 0x000F];
     1120
     1121                and     #0x000F,D2
    11221122                move    D2,A0
    11231123                add.l   A0,A0
    11241124                add.l   #_expbit,A0
    11251125                move    (A0),R_FPEXP
    1126 *
    1127                 .page
    1128 *
    1129 *               fp->idfpch = ip->idhos2v;
    1130 *
     1126
     1127                .page
     1128
     1129|               fp->idfpch = ip->idhos2v;
     1130
    11311131F01L155:        move.l  IP(A6),A0
    11321132                move.w  80(A0),(A_FP)
    1133 *
    1134 *               fpval = addpch(tfpval, fp_>idfpch);
    1135 *
     1133
     1134|               fpval = addpch(tfpval, fp_>idfpch);
     1135
    11361136                move.w  TFPVAL(A6),D1
    11371137                ext.l   D1
    … …  
    11441144                cmp.l   #PITCHMAX,D0
    11451145                ble     F01L155A
    1146 *
     1146
    11471147                move.l  #PITCHMAX,D0
    1148 *
     1148
    11491149F01L155A:       move    D0,R_FPVAL
    1150 *
    1151                 .page
    1152 *
     1150
     1151                .page
     1152
    11531153                move.b  5(A_FP),D0
    11541154                ext.w   D0
    11551155                sub.w   #1,D0
    11561156                movea.l PT(A6),A0
    1157 *
    1158 *       oldi = setipl(FPU_DI);
    1159 *
     1157
     1158|       oldi = setipl(FPU_DI);
     1159
    11601160                move    sr,OLDI(A6)
    11611161                move    #FPU_DI,sr
    1162 *
     1162
    11631163F01L168:        clr.b   10(A0)
    11641164                add.l   #12,a0
    11651165                dbra    D0,F01L168
    1166 *
    1167                 .page
    1168 *
    1169 *       fp->idftmd ^= I_NVBITS;
    1170 *
     1166
     1167                .page
     1168
     1169|       fp->idftmd ^= I_NVBITS;
     1170
    11711171F01L165:        eor.b   #24,7(A_FP)
    1172 *
    1173 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    1174 *
     1172
     1173|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     1174
    11751175                move.b  7(A_FP),R_FPCTL
    11761176                and     #28,R_FPCTL
    11771177                or      #3,R_FPCTL
    1178 *
    1179 *       fp->idfcpt = fp->idfpt1;
    1180 *
     1178
     1179|       fp->idfcpt = fp->idfpt1;
     1180
    11811181                move.b  6(A_FP),8(A_FP)
    1182 *
    1183 *       fp->idftmd |= I_ACTIVE;
    1184 *
     1182
     1183|       fp->idftmd |= I_ACTIVE;
     1184
    11851185                or.b    #2,7(A_FP)
    1186 *
    1187 *       fp->idftrf = trg;
    1188 *
     1186
     1187|       fp->idftrf = trg;
     1188
    11891189                move    TRG(A6),10(A_FP)
    1190 *
    1191 *       *(fpu + (long)FPU_TCV1) = srcval;
    1192 *
    1193                 move    SRCVAL(A6),$8(A_FPU)
    1194 *
    1195 *       ++octype;
    1196 *
     1190
     1191|       |(fpu + (long)FPU_TCV1) = srcval;
     1192
     1193                move    SRCVAL(A6),0x8(A_FPU)
     1194
     1195|       ++octype;
     1196
    11971197                add     #1,OCTYPE(A6)
    1198 *
    1199 *       *(fpu + (long)FPU_TSF1) = mltval;
    1200 *
    1201                 move    MLTVAL(A6),$A(A_FPU)
    1202 *
    1203 *       ++octype;
    1204 *
     1198
     1199|       |(fpu + (long)FPU_TSF1) = mltval;
     1200
     1201                move    MLTVAL(A6),0xA(A_FPU)
     1202
     1203|       ++octype;
     1204
    12051205                add     #1,OCTYPE(A6)
    1206 *
    1207 *       *(fpu + (long)FPU_TMNT) = fpmant;
    1208 *
    1209                 move    R_FPMANT,$14(A_FPU)
    1210 *
    1211 *       ++octype;
    1212 *
     1206
     1207|       |(fpu + (long)FPU_TMNT) = fpmant;
     1208
     1209                move    R_FPMANT,0x14(A_FPU)
     1210
     1211|       ++octype;
     1212
    12131213                add     #1,OCTYPE(A6)
    1214 *
    1215 *       *(fpu + (long)FPU_TEXP) = fpexp;
    1216 *
    1217                 move    R_FPEXP,$16(A_FPU)
    1218 *
    1219 *       ++octype;
    1220 *
     1214
     1215|       |(fpu + (long)FPU_TEXP) = fpexp;
     1216
     1217                move    R_FPEXP,0x16(A_FPU)
     1218
     1219|       ++octype;
     1220
    12211221                add     #1,OCTYPE(A6)
    1222 *
    1223                 .page
    1224 *
    1225 *       if (fp->idftmd & I_VNSUBN)
    1226 *
     1222
     1223                .page
     1224
     1225|       if (fp->idftmd & I_VNSUBN)
     1226
    12271227                btst    #3,7(A_FP)
    12281228                beq     F01L169
    1229 *
    1230 *               *(fpu + (long)FPU_TNV1) = fpval;
    1231 *
    1232                 move    R_FPVAL,$1C(A_FPU)
     1229
     1230|               |(fpu + (long)FPU_TNV1) = fpval;
     1231
     1232                move    R_FPVAL,0x1C(A_FPU)
    12331233                bra     F01L170
    1234 *
    1235 *       else
    1236 *               *(fpu + (long)FPU_TNV0) = fpval;
    1237 *
     1234
     1235|       else
     1236|               |(fpu + (long)FPU_TNV0) = fpval;
     1237
    12381238F01L169:        move    R_FPVAL,2(A_FPU)
    1239 *
    1240 *       ++octype;
    1241 *
     1239
     1240|       ++octype;
     1241
    12421242F01L170:        add     #1,OCTYPE(A6)
    1243 *
    1244 *       *(fpu + (long)FPU_TCTL) = fpctl;
    1245 *
     1243
     1244|       |(fpu + (long)FPU_TCTL) = fpctl;
     1245
    12461246                move    R_FPCTL,(A_FPU)
    1247 *
    1248 *       setipl(oldi);
    1249 *
     1247
     1248|       setipl(oldi);
     1249
    12501250                move    OLDI(A6),sr
    1251 *
    1252                 .page
    1253 * ------------------------------------------------------------------------------
    1254 * Start function 2 -- Frq 3
    1255 * ------------------------------------------------------------------------------
    1256 *
    1257 *    if (ip->idhfnc[2].idftmd & I_TM_KEY) {
    1258 *
     1251
     1252                .page
     1253| ------------------------------------------------------------------------------
     1254| Start function 2 -- Frq 3
     1255| ------------------------------------------------------------------------------
     1256
     1257|    if (ip->idhfnc[2].idftmd & I_TM_KEY) {
     1258
    12591259FN02:           move.l  IP(A6),A0
    12601260                move.b  117(A0),D0
    … …  
    12631263                btst    #0,D0
    12641264                bne     FN02A
    1265 *
     1265
    12661266                jmp     FN03
    1267 *
    1268 *       vp = (vce << 4) + 5;
    1269 *
     1267
     1268|       vp = (vce << 4) + 5;
     1269
    12701270FN02A:          move    VCE(A6),D0
    12711271                asl     #4,D0
    12721272                add.w   #5,D0
    12731273                move    D0,VP(A6)
    1274 *
    1275 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    1276 *
     1274
     1275|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     1276
    12771277                asl     #5,D0
    12781278                ext.l   D0
    12791279                move.l  D0,A_FPU
    1280                 add.l   #_io_fpu+$4000,A_FPU
    1281 *
    1282 *       fp = &ip->idhfnc[2];
    1283 *
     1280                add.l   #_io_fpu+0x4000,A_FPU
     1281
     1282|       fp = &ip->idhfnc[2];
     1283
    12841284                move.l  #24,A_FP
    12851285                add.l   IP(A6),A_FP
    12861286                add.l   #86,A_FP
    1287 *
    1288 *       pt = &ip->idhpnt[fp->idfpt1];
    1289 *
     1287
     1288|       pt = &ip->idhpnt[fp->idfpt1];
     1289
    12901290                clr.l   D0
    12911291                move.b  6(A_FP),D0
    … …  
    12971297                add.l   #242,D0
    12981298                move.l  D0,PT(A6)
    1299 *
    1300                 .page
    1301 *
    1302 *       srcnum = group | fp->idfsrc;
    1303 *
     1299
     1300                .page
     1301
     1302|       srcnum = group | fp->idfsrc;
     1303
    13041304                move.w  GROUP(A6),D0
    13051305                ext.l   D0
    … …  
    13081308                or      D1,D0
    13091309                move    D0,SRCNUM(A6)
    1310 *
    1311 *       vep = &valents[srcnum];
    1312 *
     1310
     1311|       vep = &valents[srcnum];
     1312
    13131313                add.l   D0,D0
    13141314                move.l  D0,D1
    … …  
    13171317                add.l   #_valents,D0
    13181318                move.l  D0,VEP(A6)
    1319 *
    1320 *       smp = vpsms[vp];
    1321 *
     1319
     1320|       smp = vpsms[vp];
     1321
    13221322                move    VP(A6),A0
    13231323                add.l   A0,A0
    … …  
    13251325                add.l   #_vpsms,A0
    13261326                move.l  (A0),A_SMP
    1327 *
    1328 *       if (srcnum NE smp->sm) {
    1329 *
     1327
     1328|       if (srcnum NE smp->sm) {
     1329
    13301330                clr     D0
    13311331                move    10(A_SMP),D0
    13321332                cmp     SRCNUM(A6),D0
    13331333                beq     F02L113
    1334 *
    1335 *               (smp->prv)->nxt = smp->nxt;
    1336 *
     1334
     1335|               (smp->prv)->nxt = smp->nxt;
     1336
    13371337                move.l  4(A_SMP),A0
    13381338                move.l  (A_SMP),(A0)
    1339 *
    1340 *               (smp->nxt)->prv = smp->prv;
    1341 *
     1339
     1340|               (smp->nxt)->prv = smp->prv;
     1341
    13421342                move.l  (A_SMP),A0
    13431343                move.l  4(A_SMP),4(A0)
    1344 *
    1345 *               smp->prv = (struct sment *)vep;
    1346 *
     1344
     1345|               smp->prv = (struct sment |)vep;
     1346
    13471347                move.l  VEP(A6),4(A_SMP)
    1348 *
    1349 *               smp->nxt = vep->nxt;
    1350 *
     1348
     1349|               smp->nxt = vep->nxt;
     1350
    13511351                move.l  VEP(A6),A0
    13521352                move.l  (A0),(A_SMP)
    1353 *
    1354 *               (vep->nxt)->prv = smp;
    1355 *
     1353
     1354|               (vep->nxt)->prv = smp;
     1355
    13561356                move.l  VEP(A6),A0
    13571357                move.l  (A0),A0
    13581358                move.l  A_SMP,4(A0)
    1359 *
    1360 *               vep->nxt = smp;
    1361 *
     1359
     1360|               vep->nxt = smp;
     1361
    13621362                move.l  VEP(A6),A0
    13631363                move.l  A_SMP,(A0)
    1364 *
    1365 *               smp->sm = srcnum;
    1366 *
     1364
     1365|               smp->sm = srcnum;
     1366
    13671367                move    SRCNUM(A6),10(A_SMP)
    1368 *
    1369 *       }
    1370 *
    1371 *       mltval = fp->idfmlt;
    1372 *
     1368
     1369|       }
     1370
     1371|       mltval = fp->idfmlt;
     1372
    13731373F02L113:        move    2(A_FP),MLTVAL(A6)
    1374 *
    1375                 .page
    1376 *
    1377 *       switch (fp->idfsrc) {
    1378 *
     1374
     1375                .page
     1376
     1377|       switch (fp->idfsrc) {
     1378
    13791379                move.b  4(A_FP),D0
    13801380                ext.w   d0
    13811381                cmp     #10,D0
    13821382                bhi     F02L122
    1383 *
     1383
    13841384                asl     #2,D0
    13851385                lea     F02L123,A0
    13861386                movea.l 0(A0,D0.W),A0
    13871387                jmp     (A0)
    1388 *
    1389 *       case SM_NONE:
    1390 *               mltval = 0;
    1391 *
     1388
     1389|       case SM_NONE:
     1390|               mltval = 0;
     1391
    13921392F02L116:        clr     MLTVAL(A6)
    1393 *
    1394 *               tsrcval = 0;
    1395 *
     1393
     1394|               tsrcval = 0;
     1395
    13961396                clr     TSRCVAL(A6)
    1397 *
    1398 *               break;
    1399 *
     1397
     1398|               break;
     1399
    14001400                bra     F02L114
    1401 *
    1402 *       case SM_RAND:
    1403 *               tsrcval = xgetran(mltval);
    1404 *
     1401
     1402|       case SM_RAND:
     1403|               tsrcval = xgetran(mltval);
     1404
    14051405F02L117:        move    MLTVAL(A6),(sp)
    14061406                jsr     _xgetran
    14071407                move    D0,TSRCVAL(A6)
    1408 *
    1409 *               break;
    1410 *
     1408
     1409|               break;
     1410
    14111411                bra     F02L114
    1412 *
    1413 *       case SM_PTCH:
    1414 *               tsrcval = pch;
    1415 *
     1412
     1413|       case SM_PTCH:
     1414|               tsrcval = pch;
     1415
    14161416F02L118:        move    PCH(A6),TSRCVAL(A6)
    1417 *
    1418 *               break;
    1419 *
     1417
     1418|               break;
     1419
    14201420                bra     F02L114
    1421 *
    1422                 .page
    1423 *
    1424 *       case SM_FREQ:
    1425 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    1426 *
     1421
     1422                .page
     1423
     1424|       case SM_FREQ:
     1425|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     1426
    14271427F02L119:        move    PCH(A6),D0
    14281428                asr     #7,D0
    … …  
    14321432                add.l   #_ptoftab,A0
    14331433                move    (A0),TSRCVAL(A6)
    1434 *
    1435 *               break;
    1436 *
     1434
     1435|               break;
     1436
    14371437                bra     F02L114
    1438 *
    1439 *       case SM_KVEL:
    1440 *               tsrcval = veltab[trg];
    1441 *
     1438
     1439|       case SM_KVEL:
     1440|               tsrcval = veltab[trg];
     1441
    14421442F02L120:        move    TRG(A6),A0
    14431443                add.l   A0,A0
    14441444                add.l   #_veltab,A0
    14451445                move    (A0),TSRCVAL(A6)
    1446 *
    1447 *               break;
    1448 *
     1446
     1447|               break;
     1448
    14491449                bra     F02L114
    1450 *
    1451 *       case SM_KPRS:
    1452 *               tsrcval = prstab[trg];
    1453 *
     1450
     1451|       case SM_KPRS:
     1452|               tsrcval = prstab[trg];
     1453
    14541454F02L121:        move    TRG(A6),A0
    14551455                add.l   A0,A0
    14561456                add.l   #_prstab,A0
    14571457                move    (A0),TSRCVAL(A6)
    1458 *
    1459 *               break;
    1460 *
     1458
     1459|               break;
     1460
    14611461                bra     F02L114
    1462 *
    1463 *       default:
    1464 *               tsrcval = vep->val;
    1465 *
     1462
     1463|       default:
     1464|               tsrcval = vep->val;
     1465
    14661466F02L122:        move.l  VEP(A6),A0
    14671467                move    8(A0),TSRCVAL(A6)
    1468 *
    1469 *       }
    1470 *
    1471                 .page
    1472 *
    1473 *               srcval = addpch(tsrcval, 0);
    1474 *
     1468
     1469|       }
     1470
     1471                .page
     1472
     1473|               srcval = addpch(tsrcval, 0);
     1474
    14751475F02L114:        move.w  TSRCVAL(A6),D0
    14761476                ext.l   D0
    14771477                asr.l   #5,D0
    1478 *               sub.l   #500,D0
     1478|               sub.l   #500,D0
    14791479                asl.l   #LSPCH,D0
    14801480                cmp.l   #PITCHMAX,D0
    14811481                ble     F02L129A
    1482 *
     1482
    14831483                move.l  #PITCHMAX,D0
    1484 *
     1484
    14851485F02L129A:       move    D0,SRCVAL(A6)
    1486 *
    1487                 .page
    1488 *
    1489 *       if (pt->ipvsrc) {
    1490 *
     1486
     1487                .page
     1488
     1489|       if (pt->ipvsrc) {
     1490
    14911491F02L124:        move.l  PT(A6),A0
    14921492                tst.b   6(A0)
    14931493                beq     F02L136
    1494 *
    1495 *               switch (pt->ipvsrc) {
    1496 *
     1494
     1495|               switch (pt->ipvsrc) {
     1496
    14971497                move.l  PT(A6),A0
    14981498                move.b  6(A0),D0
    … …  
    15011501                cmp     #9,D0
    15021502                bhi     F02L144
    1503 *
     1503
    15041504                asl     #2,D0
    15051505                lea     F02L145,A0
    15061506                move.l  0(A0,D0.W),A0
    15071507                jmp     (A0)
    1508 *
    1509 *               case SM_RAND:
    1510 *                       ltmp = xgetran(pt_>ipvmlt);
    1511 *
     1508
     1509|               case SM_RAND:
     1510|                       ltmp = xgetran(pt_>ipvmlt);
     1511
    15121512F02L139:        move.l  PT(A6),A0
    15131513                move    4(A0),(sp)
    … …  
    15151515                ext.l   D0
    15161516                move.l  D0,LTMP(A6)
    1517 *
    1518 *                       break;
    1519 *
     1517
     1518|                       break;
     1519
    15201520                bra     F02L137
    1521 *
    1522 *               case SM_PTCH:
    1523 *                       ltmp = pch;
    1524 *
     1521
     1522|               case SM_PTCH:
     1523|                       ltmp = pch;
     1524
    15251525F02L140:        move    PCH(A6),A0
    15261526                move.l  A0,LTMP(A6)
    1527 *
    1528 *                       break;
    1529 *
     1527
     1528|                       break;
     1529
    15301530                bra     F02L137
    1531 *
    1532                 .page
    1533 *
    1534 *               case SM_FREQ:
    1535 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    1536 *
     1531
     1532                .page
     1533
     1534|               case SM_FREQ:
     1535|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     1536
    15371537F02L141:        move    PCH(A6),D0
    15381538                asr     #7,D0
    … …  
    15441544                ext.l   D0
    15451545                move.l  D0,LTMP(A6)
    1546 *
    1547 *                       break;
    1548 *
     1546
     1547|                       break;
     1548
    15491549                bra     F02L137
    1550 *
    1551 *               case SM_KVEL:
    1552 *                       ltmp = veltab[trg];
    1553 *
     1550
     1551|               case SM_KVEL:
     1552|                       ltmp = veltab[trg];
     1553
    15541554F02L142:        move    TRG(A6),A0
    15551555                add.l   A0,A0
    … …  
    15581558                ext.l   D0
    15591559                move.l  D0,LTMP(A6)
    1560 *
    1561 *                       break;
    1562 *
     1560
     1561|                       break;
     1562
    15631563                bra     F02L137
    1564 *
    1565                 .page
    1566 *
    1567 *               case SM_KPRS:
    1568 *                       ltmp = prstab[trg];
    1569 *
     1564
     1565                .page
     1566
     1567|               case SM_KPRS:
     1568|                       ltmp = prstab[trg];
     1569
    15701570F02L143:        move    TRG(A6),A0
    15711571                add.l   A0,A0
    … …  
    15741574                ext.l   D0
    15751575                move.l  D0,LTMP(A6)
    1576 *
    1577 *                       break;
    1578 *
     1576
     1577|                       break;
     1578
    15791579                bra     F02L137
    1580 *
    1581                 .page
    1582 *
    1583 *               default:
    1584 *                       ltmp = valents[group | pt->ipvsrc].val;
    1585 *
     1580
     1581                .page
     1582
     1583|               default:
     1584|                       ltmp = valents[group | pt->ipvsrc].val;
     1585
    15861586F02L144:        move.l  PT(A6),A0
    15871587                clr.l   D0
    … …  
    15971597                move    8(A0,A1.l),D0
    15981598                move.l  D0,LTMP(A6)
    1599 *
    1600 *               }
    1601 *
    1602 *
    1603                 .page
    1604 *
    1605 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    1606 *
     1599
     1600|               }
     1601
     1602
     1603                .page
     1604
     1605|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     1606
    16071607F02L137:        move.l  PT(A6),A0
    16081608                move.w  4(A0),D0
    … …  
    16121612                asr.l   D1,D0
    16131613                move.l  D0,LTMP(A6)
    1614 *
    1615 *               ltmp += (long)pt->ipval;
    1616 *
     1614
     1615|               ltmp += (long)pt->ipval;
     1616
    16171617                move.l  PT(A6),A0
    16181618                move    2(A0),D0
    16191619                ext.l   D0
    16201620                add.l   D0,LTMP(A6)
    1621 *
    1622 *               if (ltmp GT (long)VALMAX)
    1623 *                       ltmp = (long)VALMAX;
    1624 *
     1621
     1622|               if (ltmp GT (long)VALMAX)
     1623|                       ltmp = (long)VALMAX;
     1624
    16251625                cmp.l   #VALMAX,LTMP(A6)
    16261626                ble     F02L146
    1627 *
     1627
    16281628                move.l  #VALMAX,LTMP(A6)
    16291629                bra     F02L147
    1630 *
    1631 *               else if (ltmp LT (long)VALMIN)
    1632 *                       ltmp = (long)VALMIN;
    1633 *
     1630
     1631|               else if (ltmp LT (long)VALMIN)
     1632|                       ltmp = (long)VALMIN;
     1633
    16341634F02L146:        cmp.l   #VALMIN,LTMP(A6)
    16351635                bge     F02L147
    1636 *
     1636
    16371637                move.l  #VALMIN,LTMP(A6)
    1638 *
    1639 *               tfpval = (short)ltmp;
    1640 *
     1638
     1639|               tfpval = (short)ltmp;
     1640
    16411641F02L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    16421642                bra     F02L149
    1643 *
    1644 *       } else {
    1645 *
    1646 *               tfpval = pt->ipval;
    1647 *
     1643
     1644|       } else {
     1645
     1646|               tfpval = pt->ipval;
     1647
    16481648F02L136:        move.l  PT(A6),A0
    16491649                move    2(A0),TFPVAL(A6)
    1650 *
    1651 *       }
    1652 *
    1653                 .page
    1654 *
    1655 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    1656 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    1657 *
     1650
     1651|       }
     1652
     1653                .page
     1654
     1655|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     1656|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     1657
    16581658F02L149:        move.l  PT(A6),A0
    16591659                move.w  (A0),D0
    16601660                move.w  D0,D2
    1661                 andi.w  #$FFF0,D0
     1661                andi.w  #0xFFF0,D0
    16621662                move.w  _timemlt,D1
    16631663                muls    D1,D0
    … …  
    16651665                asr.l   D1,D0
    16661666                move    D0,R_FPMANT
    1667 *
    1668 *       fpexp = expbit[pt->iptim & 0x000F];
    1669 *
    1670                 and     #$000F,D2
     1667
     1668|       fpexp = expbit[pt->iptim & 0x000F];
     1669
     1670                and     #0x000F,D2
    16711671                move    D2,A0
    16721672                add.l   A0,A0
    16731673                add.l   #_expbit,A0
    16741674                move    (A0),R_FPEXP
    1675 *
    1676                 .page
    1677 *
    1678 *               fp->idfpch = ip->idhos3v;
    1679 *
     1675
     1676                .page
     1677
     1678|               fp->idfpch = ip->idhos3v;
     1679
    16801680F02L156:        move.l  IP(A6),A0
    16811681                move.w  82(A0),(A_FP)
    1682 *
    1683 *               fpval = addpch(tfpval, fp->idfpch);
    1684 *
     1682
     1683|               fpval = addpch(tfpval, fp->idfpch);
     1684
    16851685                move.w  TFPVAL(A6),D1
    16861686                ext.l   D1
    … …  
    16931693                cmp.l   #PITCHMAX,D0
    16941694                ble     F02L156A
    1695 *
     1695
    16961696                move.l  #PITCHMAX,D0
    1697 *
     1697
    16981698F02L156A:       move    D0,R_FPVAL
    1699 *
    1700                 .page
    1701 *
     1699
     1700                .page
     1701
    17021702                move.b  5(A_FP),D0
    17031703                ext.w   D0
    17041704                sub.w   #1,D0
    17051705                movea.l PT(A6),A0
    1706 *
    1707 *       oldi = setipl(FPU_DI);
    1708 *
     1706
     1707|       oldi = setipl(FPU_DI);
     1708
    17091709                move    sr,OLDI(A6)
    17101710                move    #FPU_DI,sr
    1711 *
     1711
    17121712F02L168:        clr.b   10(A0)
    17131713                add.l   #12,a0
    17141714                dbra    D0,F02L168
    1715 *
    1716                 .page
    1717 *
    1718 *       fp->idftmd ^= I_NVBITS;
    1719 *
     1715
     1716                .page
     1717
     1718|       fp->idftmd ^= I_NVBITS;
     1719
    17201720F02L165:        eor.b   #24,7(A_FP)
    1721 *
    1722 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    1723 *
     1721
     1722|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     1723
    17241724                move.b  7(A_FP),R_FPCTL
    17251725                and     #28,R_FPCTL
    17261726                or      #3,R_FPCTL
    1727 *
    1728 *       fp->idfcpt = fp->idfpt1;
    1729 *
     1727
     1728|       fp->idfcpt = fp->idfpt1;
     1729
    17301730                move.b  6(A_FP),8(A_FP)
    1731 *
    1732 *       fp->idftmd |= I_ACTIVE;
    1733 *
     1731
     1732|       fp->idftmd |= I_ACTIVE;
     1733
    17341734                or.b    #2,7(A_FP)
    1735 *
    1736 *       fp->idftrf = trg;
    1737 *
     1735
     1736|       fp->idftrf = trg;
     1737
    17381738                move    TRG(A6),10(A_FP)
    1739 *
    1740 *       *(fpu + (long)FPU_TCV1) = srcval;
    1741 *
    1742                 move    SRCVAL(A6),$8(A_FPU)
    1743 *
    1744 *       ++octype;
    1745 *
     1739
     1740|       |(fpu + (long)FPU_TCV1) = srcval;
     1741
     1742                move    SRCVAL(A6),0x8(A_FPU)
     1743
     1744|       ++octype;
     1745
    17461746                add     #1,OCTYPE(A6)
    1747 *
    1748 *       *(fpu + (long)FPU_TSF1) = mltval;
    1749 *
    1750                 move    MLTVAL(A6),$A(A_FPU)
    1751 *
    1752 *       ++octype;
    1753 *
     1747
     1748|       |(fpu + (long)FPU_TSF1) = mltval;
     1749
     1750                move    MLTVAL(A6),0xA(A_FPU)
     1751
     1752|       ++octype;
     1753
    17541754                add     #1,OCTYPE(A6)
    1755 *
    1756 *       *(fpu + (long)FPU_TMNT) = fpmant;
    1757 *
    1758                 move    R_FPMANT,$14(A_FPU)
    1759 *
    1760 *       ++octype;
    1761 *
     1755
     1756|       |(fpu + (long)FPU_TMNT) = fpmant;
     1757
     1758                move    R_FPMANT,0x14(A_FPU)
     1759
     1760|       ++octype;
     1761
    17621762                add     #1,OCTYPE(A6)
    1763 *
    1764 *       *(fpu + (long)FPU_TEXP) = fpexp;
    1765 *
    1766                 move    R_FPEXP,$16(A_FPU)
    1767 *
    1768 *       ++octype;
    1769 *
     1763
     1764|       |(fpu + (long)FPU_TEXP) = fpexp;
     1765
     1766                move    R_FPEXP,0x16(A_FPU)
     1767
     1768|       ++octype;
     1769
    17701770                add     #1,OCTYPE(A6)
    1771 *
    1772                 .page
    1773 *
    1774 *       if (fp->idftmd & I_VNSUBN)
    1775 *
     1771
     1772                .page
     1773
     1774|       if (fp->idftmd & I_VNSUBN)
     1775
    17761776                btst    #3,7(A_FP)
    17771777                beq     F02L169
    1778 *
    1779 *               *(fpu + (long)FPU_TNV1) = fpval;
    1780 *
    1781                 move    R_FPVAL,$1C(A_FPU)
     1778
     1779|               |(fpu + (long)FPU_TNV1) = fpval;
     1780
     1781                move    R_FPVAL,0x1C(A_FPU)
    17821782                bra     F02L170
    1783 *
    1784 *       else
    1785 *               *(fpu + (long)FPU_TNV0) = fpval;
    1786 *
     1783
     1784|       else
     1785|               |(fpu + (long)FPU_TNV0) = fpval;
     1786
    17871787F02L169:        move    R_FPVAL,2(A_FPU)
    1788 *
    1789 *       ++octype;
    1790 *
     1788
     1789|       ++octype;
     1790
    17911791F02L170:        add     #1,OCTYPE(A6)
    1792 *
    1793 *       *(fpu + (long)FPU_TCTL) = fpctl;
    1794 *
     1792
     1793|       |(fpu + (long)FPU_TCTL) = fpctl;
     1794
    17951795                move    R_FPCTL,(A_FPU)
    1796 *
    1797 *       setipl(oldi);
    1798 *
     1796
     1797|       setipl(oldi);
     1798
    17991799                move    OLDI(A6),sr
    1800 *
    1801                 .page
    1802 * ------------------------------------------------------------------------------
    1803 * Start function 3 -- Frq 4
    1804 * ------------------------------------------------------------------------------
    1805 *
    1806 *    if (ip->idhfnc[3].idftmd & I_TM_KEY) {
    1807 *
     1800
     1801                .page
     1802| ------------------------------------------------------------------------------
     1803| Start function 3 -- Frq 4
     1804| ------------------------------------------------------------------------------
     1805
     1806|    if (ip->idhfnc[3].idftmd & I_TM_KEY) {
     1807
    18081808FN03:           move.l  IP(A6),A0
    18091809                move.b  129(A0),D0
    … …  
    18121812                btst    #0,D0
    18131813                bne     FN03A
    1814 *
     1814
    18151815                jmp     FN04
    1816 *
    1817 *       vp = (vce << 4) + 7;
    1818 *
     1816
     1817|       vp = (vce << 4) + 7;
     1818
    18191819FN03A:          move    VCE(A6),D0
    18201820                asl     #4,D0
    18211821                add.w   #7,D0
    18221822                move    D0,VP(A6)
    1823 *
    1824 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    1825 *
     1823
     1824|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     1825
    18261826                asl     #5,D0
    18271827                ext.l   D0
    18281828                move.l  D0,A_FPU
    1829                 add.l   #_io_fpu+$4000,A_FPU
    1830 *
    1831 *       fp = &ip->idhfnc[3];
    1832 *
     1829                add.l   #_io_fpu+0x4000,A_FPU
     1830
     1831|       fp = &ip->idhfnc[3];
     1832
    18331833                move.l  #36,A_FP
    18341834                add.l   IP(A6),A_FP
    18351835                add.l   #86,A_FP
    1836 *
    1837 *       pt = &ip->idhpnt[fp->idfpt1];
    1838 *
     1836
     1837|       pt = &ip->idhpnt[fp->idfpt1];
     1838
    18391839                clr.l   D0
    18401840                move.b  6(A_FP),D0
    … …  
    18461846                add.l   #242,D0
    18471847                move.l  D0,PT(A6)
    1848 *
    1849                 .page
    1850 *
    1851 *       srcnum = group | fp->idfsrc;
    1852 *
     1848
     1849                .page
     1850
     1851|       srcnum = group | fp->idfsrc;
     1852
    18531853                move.w  GROUP(A6),D0
    18541854                ext.l   D0
    … …  
    18571857                or      D1,D0
    18581858                move    D0,SRCNUM(A6)
    1859 *
    1860 *       vep = &valents[srcnum];
    1861 *
     1859
     1860|       vep = &valents[srcnum];
     1861
    18621862                add.l   D0,D0
    18631863                move.l  D0,D1
    … …  
    18661866                add.l   #_valents,D0
    18671867                move.l  D0,VEP(A6)
    1868 *
    1869 *       smp = vpsms[vp];
    1870 *
     1868
     1869|       smp = vpsms[vp];
     1870
    18711871                move    VP(A6),A0
    18721872                add.l   A0,A0
    … …  
    18741874                add.l   #_vpsms,A0
    18751875                move.l  (A0),A_SMP
    1876 *
    1877 *       if (srcnum NE smp->sm) {
    1878 *
     1876
     1877|       if (srcnum NE smp->sm) {
     1878
    18791879                clr     D0
    18801880                move    10(A_SMP),D0
    18811881                cmp     SRCNUM(A6),D0
    18821882                beq     F03L113
    1883 *
    1884 *               (smp->prv)->nxt = smp->nxt;
    1885 *
     1883
     1884|               (smp->prv)->nxt = smp->nxt;
     1885
    18861886                move.l  4(A_SMP),A0
    18871887                move.l  (A_SMP),(A0)
    1888 *
    1889 *               (smp->nxt)->prv = smp->prv;
    1890 *
     1888
     1889|               (smp->nxt)->prv = smp->prv;
     1890
    18911891                move.l  (A_SMP),A0
    18921892                move.l  4(A_SMP),4(A0)
    1893 *
    1894 *               smp->prv = (struct sment *)vep;
    1895 *
     1893
     1894|               smp->prv = (struct sment |)vep;
     1895
    18961896                move.l  VEP(A6),4(A_SMP)
    1897 *
    1898 *               smp->nxt = vep->nxt;
    1899 *
     1897
     1898|               smp->nxt = vep->nxt;
     1899
    19001900                move.l  VEP(A6),A0
    19011901                move.l  (A0),(A_SMP)
    1902 *
    1903 *               (vep->nxt)->prv = smp;
    1904 *
     1902
     1903|               (vep->nxt)->prv = smp;
     1904
    19051905                move.l  VEP(A6),A0
    19061906                move.l  (A0),A0
    19071907                move.l  A_SMP,4(A0)
    1908 *
    1909 *               vep->nxt = smp;
    1910 *
     1908
     1909|               vep->nxt = smp;
     1910
    19111911                move.l  VEP(A6),A0
    19121912                move.l  A_SMP,(A0)
    1913 *
    1914 *               smp->sm = srcnum;
    1915 *
     1913
     1914|               smp->sm = srcnum;
     1915
    19161916                move    SRCNUM(A6),10(A_SMP)
    1917 *
    1918 *       }
    1919 *
    1920 *       mltval = fp->idfmlt;
    1921 *
     1917
     1918|       }
     1919
     1920|       mltval = fp->idfmlt;
     1921
    19221922F03L113:        move    2(A_FP),MLTVAL(A6)
    1923 *
    1924                 .page
    1925 *
    1926 *       switch (fp->idfsrc) {
    1927 *
     1923
     1924                .page
     1925
     1926|       switch (fp->idfsrc) {
     1927
    19281928                move.b  4(A_FP),D0
    19291929                ext.w   d0
    19301930                cmp     #10,D0
    19311931                bhi     F03L122
    1932 *
     1932
    19331933                asl     #2,D0
    19341934                lea     F03L123,A0
    19351935                movea.l 0(A0,D0.W),A0
    19361936                jmp     (A0)
    1937 *
    1938 *       case SM_NONE:
    1939 *               mltval = 0;
    1940 *
     1937
     1938|       case SM_NONE:
     1939|               mltval = 0;
     1940
    19411941F03L116:        clr     MLTVAL(A6)
    1942 *
    1943 *               tsrcval = 0;
    1944 *
     1942
     1943|               tsrcval = 0;
     1944
    19451945                clr     TSRCVAL(A6)
    1946 *
    1947 *               break;
    1948 *
     1946
     1947|               break;
     1948
    19491949                bra     F03L114
    1950 *
    1951 *       case SM_RAND:
    1952 *               tsrcval = xgetran(mltval);
    1953 *
     1950
     1951|       case SM_RAND:
     1952|               tsrcval = xgetran(mltval);
     1953
    19541954F03L117:        move    MLTVAL(A6),(sp)
    19551955                jsr     _xgetran
    19561956                move    D0,TSRCVAL(A6)
    1957 *
    1958 *               break;
    1959 *
     1957
     1958|               break;
     1959
    19601960                bra     F03L114
    1961 *
    1962 *       case SM_PTCH:
    1963 *               tsrcval = pch;
    1964 *
     1961
     1962|       case SM_PTCH:
     1963|               tsrcval = pch;
     1964
    19651965F03L118:        move    PCH(A6),TSRCVAL(A6)
    1966 *
    1967 *               break;
    1968 *
     1966
     1967|               break;
     1968
    19691969                bra     F03L114
    1970 *
    1971                 .page
    1972 *
    1973 *       case SM_FREQ:
    1974 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    1975 *
     1970
     1971                .page
     1972
     1973|       case SM_FREQ:
     1974|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     1975
    19761976F03L119:        move    PCH(A6),D0
    19771977                asr     #7,D0
    … …  
    19811981                add.l   #_ptoftab,A0
    19821982                move    (A0),TSRCVAL(A6)
    1983 *
    1984 *               break;
    1985 *
     1983
     1984|               break;
     1985
    19861986                bra     F03L114
    1987 *
    1988 *       case SM_KVEL:
    1989 *               tsrcval = veltab[trg];
    1990 *
     1987
     1988|       case SM_KVEL:
     1989|               tsrcval = veltab[trg];
     1990
    19911991F03L120:        move    TRG(A6),A0
    19921992                add.l   A0,A0
    19931993                add.l   #_veltab,A0
    19941994                move    (A0),TSRCVAL(A6)
    1995 *
    1996 *               break;
    1997 *
     1995
     1996|               break;
     1997
    19981998                bra     F03L114
    1999 *
    2000 *       case SM_KPRS:
    2001 *               tsrcval = prstab[trg];
    2002 *
     1999
     2000|       case SM_KPRS:
     2001|               tsrcval = prstab[trg];
     2002
    20032003F03L121:        move    TRG(A6),A0
    20042004                add.l   A0,A0
    20052005                add.l   #_prstab,A0
    20062006                move    (A0),TSRCVAL(A6)
    2007 *
    2008 *               break;
    2009 *
     2007
     2008|               break;
     2009
    20102010                bra     F03L114
    2011 *
    2012 *       default:
    2013 *               tsrcval = vep->val;
    2014 *
     2011
     2012|       default:
     2013|               tsrcval = vep->val;
     2014
    20152015F03L122:        move.l  VEP(A6),A0
    20162016                move    8(A0),TSRCVAL(A6)
    2017 *
    2018 *       }
    2019 *
    2020                 .page
    2021 *
    2022 *               srcval = addpch(tsrcval, 0);
    2023 *
     2017
     2018|       }
     2019
     2020                .page
     2021
     2022|               srcval = addpch(tsrcval, 0);
     2023
    20242024F03L114:        move.w  TSRCVAL(A6),D0
    20252025                ext.l   D0
    20262026                asr.l   #5,D0
    2027 *               sub.l   #500,D0
     2027|               sub.l   #500,D0
    20282028                asl.l   #LSPCH,D0
    20292029                cmp.l   #PITCHMAX,D0
    20302030                ble     F03L129A
    2031 *
     2031
    20322032                move.l  #PITCHMAX,D0
    20332033
    20342034F03L129A:       move    D0,SRCVAL(A6)
    2035 *
    2036                 .page
    2037 *
    2038 *       if (pt->ipvsrc) {
    2039 *
     2035
     2036                .page
     2037
     2038|       if (pt->ipvsrc) {
     2039
    20402040F03L124:        move.l  PT(A6),A0
    20412041                tst.b   6(A0)
    20422042                beq     F03L136
    2043 *
    2044 *               switch (pt->ipvsrc) {
    2045 *
     2043
     2044|               switch (pt->ipvsrc) {
     2045
    20462046                move.l  PT(A6),A0
    20472047                move.b  6(A0),D0
    … …  
    20502050                cmp     #9,D0
    20512051                bhi     F03L144
    2052 *
     2052
    20532053                asl     #2,D0
    20542054                lea     F03L145,A0
    20552055                move.l  0(A0,D0.W),A0
    20562056                jmp     (A0)
    2057 *
    2058 *               case SM_RAND:
    2059 *                       ltmp = xgetran(pt_>ipvmlt);
    2060 *
     2057
     2058|               case SM_RAND:
     2059|                       ltmp = xgetran(pt_>ipvmlt);
     2060
    20612061F03L139:        move.l  PT(A6),A0
    20622062                move    4(A0),(sp)
    … …  
    20642064                ext.l   D0
    20652065                move.l  D0,LTMP(A6)
    2066 *
    2067 *                       break;
    2068 *
     2066
     2067|                       break;
     2068
    20692069                bra     F03L137
    2070 *
    2071 *               case SM_PTCH:
    2072 *                       ltmp = pch;
    2073 *
     2070
     2071|               case SM_PTCH:
     2072|                       ltmp = pch;
     2073
    20742074F03L140:        move    PCH(A6),A0
    20752075                move.l  A0,LTMP(A6)
    2076 *
    2077 *                       break;
    2078 *
     2076
     2077|                       break;
     2078
    20792079                bra     F03L137
    2080 *
    2081                 .page
    2082 *
    2083 *               case SM_FREQ:
    2084 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    2085 *
     2080
     2081                .page
     2082
     2083|               case SM_FREQ:
     2084|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     2085
    20862086F03L141:        move    PCH(A6),D0
    20872087                asr     #7,D0
    … …  
    20932093                ext.l   D0
    20942094                move.l  D0,LTMP(A6)
    2095 *
    2096 *                       break;
    2097 *
     2095
     2096|                       break;
     2097
    20982098                bra     F03L137
    2099 *
    2100 *               case SM_KVEL:
    2101 *                       ltmp = veltab[trg];
    2102 *
     2099
     2100|               case SM_KVEL:
     2101|                       ltmp = veltab[trg];
     2102
    21032103F03L142:        move    TRG(A6),A0
    21042104                add.l   A0,A0
    … …  
    21072107                ext.l   D0
    21082108                move.l  D0,LTMP(A6)
    2109 *
    2110 *                       break;
    2111 *
     2109
     2110|                       break;
     2111
    21122112                bra     F03L137
    2113 *
    2114                 .page
    2115 *
    2116 *               case SM_KPRS:
    2117 *                       ltmp = prstab[trg];
    2118 *
     2113
     2114                .page
     2115
     2116|               case SM_KPRS:
     2117|                       ltmp = prstab[trg];
     2118
    21192119F03L143:        move    TRG(A6),A0
    21202120                add.l   A0,A0
    … …  
    21232123                ext.l   D0
    21242124                move.l  D0,LTMP(A6)
    2125 *
    2126 *                       break;
    2127 *
     2125
     2126|                       break;
     2127
    21282128                bra     F03L137
    2129 *
    2130                 .page
    2131 *
    2132 *               default:
    2133 *                       ltmp = valents[group | pt->ipvsrc].val;
    2134 *
     2129
     2130                .page
     2131
     2132|               default:
     2133|                       ltmp = valents[group | pt->ipvsrc].val;
     2134
    21352135F03L144:        move.l  PT(A6),A0
    21362136                clr.l   D0
    … …  
    21462146                move    8(A0,A1.l),D0
    21472147                move.l  D0,LTMP(A6)
    2148 *
    2149 *               }
    2150 *
    2151 *
    2152                 .page
    2153 *
    2154 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    2155 *
     2148
     2149|               }
     2150
     2151
     2152                .page
     2153
     2154|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     2155
    21562156F03L137:        move.l  PT(A6),A0
    21572157                move.w  4(A0),D0
    … …  
    21612161                asr.l   D1,D0
    21622162                move.l  D0,LTMP(A6)
    2163 *
    2164 *               ltmp += (long)pt->ipval;
    2165 *
     2163
     2164|               ltmp += (long)pt->ipval;
     2165
    21662166                move.l  PT(A6),A0
    21672167                move    2(A0),D0
    21682168                ext.l   D0
    21692169                add.l   D0,LTMP(A6)
    2170 *
    2171 *               if (ltmp GT (long)VALMAX)
    2172 *                       ltmp = (long)VALMAX;
    2173 *
     2170
     2171|               if (ltmp GT (long)VALMAX)
     2172|                       ltmp = (long)VALMAX;
     2173
    21742174                cmp.l   #VALMAX,LTMP(A6)
    21752175                ble     F03L146
    2176 *
     2176
    21772177                move.l  #VALMAX,LTMP(A6)
    21782178                bra     F03L147
    2179 *
    2180 *               else if (ltmp LT (long)VALMIN)
    2181 *                       ltmp = (long)VALMIN;
    2182 *
     2179
     2180|               else if (ltmp LT (long)VALMIN)
     2181|                       ltmp = (long)VALMIN;
     2182
    21832183F03L146:        cmp.l   #VALMIN,LTMP(A6)
    21842184                bge     F03L147
    2185 *
     2185
    21862186                move.l  #VALMIN,LTMP(A6)
    2187 *
    2188 *               tfpval = (short)ltmp;
    2189 *
     2187
     2188|               tfpval = (short)ltmp;
     2189
    21902190F03L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    21912191                bra     F03L149
    2192 *
    2193 *       } else {
    2194 *
    2195 *               tfpval = pt->ipval;
    2196 *
     2192
     2193|       } else {
     2194
     2195|               tfpval = pt->ipval;
     2196
    21972197F03L136:        move.l  PT(A6),A0
    21982198                move    2(A0),TFPVAL(A6)
    2199 *
    2200 *       }
    2201 *
    2202                 .page
    2203 *
    2204 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    2205 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    2206 *
     2199
     2200|       }
     2201
     2202                .page
     2203
     2204|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     2205|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     2206
    22072207F03L149:        move.l  PT(A6),A0
    22082208                move.w  (A0),D0
    22092209                move.w  D0,D2
    2210                 andi.w  #$FFF0,D0
     2210                andi.w  #0xFFF0,D0
    22112211                move.w  _timemlt,D1
    22122212                muls    D1,D0
    … …  
    22142214                asr.l   D1,D0
    22152215                move    D0,R_FPMANT
    2216 *
    2217 *       fpexp = expbit[pt->iptim & 0x000F];
    2218 *
    2219                 and     #$000F,D2
     2216
     2217|       fpexp = expbit[pt->iptim & 0x000F];
     2218
     2219                and     #0x000F,D2
    22202220                move    D2,A0
    22212221                add.l   A0,A0
    22222222                add.l   #_expbit,A0
    22232223                move    (A0),R_FPEXP
    2224 *
    2225                 .page
    2226 *
    2227 *               fp->idfpch = ip->idhos4v;
    2228 *
     2224
     2225                .page
     2226
     2227|               fp->idfpch = ip->idhos4v;
     2228
    22292229F03L157:        move.l  IP(A6),A0
    22302230                move.w  84(A0),(A_FP)
    2231 *
    2232 *               fpval = addpch(tfpval, fp->idfpch);
    2233 *
     2231
     2232|               fpval = addpch(tfpval, fp->idfpch);
     2233
    22342234                move.w  TFPVAL(A6),D1
    22352235                ext.l   D1
    … …  
    22422242                cmp.l   #PITCHMAX,D0
    22432243                ble     F03L157A
    2244 *
     2244
    22452245                move.l  #PITCHMAX,D0
    2246 *
     2246
    22472247F03L157A:       move    D0,R_FPVAL
    2248 *
    2249                 .page
    2250 *
     2248
     2249                .page
     2250
    22512251                move.b  5(A_FP),D0
    22522252                ext.w   D0
    22532253                sub.w   #1,D0
    22542254                movea.l PT(A6),A0
    2255 *
    2256 *       oldi = setipl(FPU_DI);
    2257 *
     2255
     2256|       oldi = setipl(FPU_DI);
     2257
    22582258                move    sr,OLDI(A6)
    22592259                move    #FPU_DI,sr
    2260 *
     2260
    22612261F03L168:        clr.b   10(A0)
    22622262                add.l   #12,a0
    22632263                dbra    D0,F03L168
    2264 *
    2265                 .page
    2266 *
    2267 *       fp->idftmd ^= I_NVBITS;
    2268 *
     2264
     2265                .page
     2266
     2267|       fp->idftmd ^= I_NVBITS;
     2268
    22692269F03L165:        eor.b   #24,7(A_FP)
    2270 *
    2271 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    2272 *
     2270
     2271|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     2272
    22732273                move.b  7(A_FP),R_FPCTL
    22742274                and     #28,R_FPCTL
    22752275                or      #3,R_FPCTL
    2276 *
    2277 *       fp->idfcpt = fp->idfpt1;
    2278 *
     2276
     2277|       fp->idfcpt = fp->idfpt1;
     2278
    22792279                move.b  6(A_FP),8(A_FP)
    2280 *
    2281 *       fp->idftmd |= I_ACTIVE;
    2282 *
     2280
     2281|       fp->idftmd |= I_ACTIVE;
     2282
    22832283                or.b    #2,7(A_FP)
    2284 *
    2285 *       fp->idftrf = trg;
    2286 *
     2284
     2285|       fp->idftrf = trg;
     2286
    22872287                move    TRG(A6),10(A_FP)
    2288 *
    2289 *       *(fpu + (long)FPU_TCV1) = srcval;
    2290 *
    2291                 move    SRCVAL(A6),$8(A_FPU)
    2292 *
    2293 *       ++octype;
    2294 *
     2288
     2289|       |(fpu + (long)FPU_TCV1) = srcval;
     2290
     2291                move    SRCVAL(A6),0x8(A_FPU)
     2292
     2293|       ++octype;
     2294
    22952295                add     #1,OCTYPE(A6)
    2296 *
    2297 *       *(fpu + (long)FPU_TSF1) = mltval;
    2298 *
    2299                 move    MLTVAL(A6),$A(A_FPU)
    2300 *
    2301 *       ++octype;
    2302 *
     2296
     2297|       |(fpu + (long)FPU_TSF1) = mltval;
     2298
     2299                move    MLTVAL(A6),0xA(A_FPU)
     2300
     2301|       ++octype;
     2302
    23032303                add     #1,OCTYPE(A6)
    2304 *
    2305 *       *(fpu + (long)FPU_TMNT) = fpmant;
    2306 *
    2307                 move    R_FPMANT,$14(A_FPU)
    2308 *
    2309 *       ++octype;
    2310 *
     2304
     2305|       |(fpu + (long)FPU_TMNT) = fpmant;
     2306
     2307                move    R_FPMANT,0x14(A_FPU)
     2308
     2309|       ++octype;
     2310
    23112311                add     #1,OCTYPE(A6)
    2312 *
    2313 *       *(fpu + (long)FPU_TEXP) = fpexp;
    2314 *
    2315                 move    R_FPEXP,$16(A_FPU)
    2316 *
    2317 *       ++octype;
    2318 *
     2312
     2313|       |(fpu + (long)FPU_TEXP) = fpexp;
     2314
     2315                move    R_FPEXP,0x16(A_FPU)
     2316
     2317|       ++octype;
     2318
    23192319                add     #1,OCTYPE(A6)
    2320 *
    2321                 .page
    2322 *
    2323 *       if (fp->idftmd & I_VNSUBN)
    2324 *
     2320
     2321                .page
     2322
     2323|       if (fp->idftmd & I_VNSUBN)
     2324
    23252325                btst    #3,7(A_FP)
    23262326                beq     F03L169
    2327 *
    2328 *               *(fpu + (long)FPU_TNV1) = fpval;
    2329 *
    2330                 move    R_FPVAL,$1C(A_FPU)
     2327
     2328|               |(fpu + (long)FPU_TNV1) = fpval;
     2329
     2330                move    R_FPVAL,0x1C(A_FPU)
    23312331                bra     F03L170
    2332 *
    2333 *       else
    2334 *               *(fpu + (long)FPU_TNV0) = fpval;
    2335 *
     2332
     2333|       else
     2334|               |(fpu + (long)FPU_TNV0) = fpval;
     2335
    23362336F03L169:        move    R_FPVAL,2(A_FPU)
    2337 *
    2338 *       ++octype;
    2339 *
     2337
     2338|       ++octype;
     2339
    23402340F03L170:        add     #1,OCTYPE(A6)
    2341 *
    2342 *       *(fpu + (long)FPU_TCTL) = fpctl;
    2343 *
     2341
     2342|       |(fpu + (long)FPU_TCTL) = fpctl;
     2343
    23442344                move    R_FPCTL,(A_FPU)
    2345 *
    2346 *       setipl(oldi);
    2347 *
     2345
     2346|       setipl(oldi);
     2347
    23482348                move    OLDI(A6),sr
    2349 *
    2350                 .page
    2351 * ------------------------------------------------------------------------------
    2352 * Start function 4 -- Filtr
    2353 * ------------------------------------------------------------------------------
    2354 *
    2355 *    if (ip->idhfnc[4].idftmd & I_TM_KEY) {
    2356 *
     2349
     2350                .page
     2351| ------------------------------------------------------------------------------
     2352| Start function 4 -- Filtr
     2353| ------------------------------------------------------------------------------
     2354
     2355|    if (ip->idhfnc[4].idftmd & I_TM_KEY) {
     2356
    23572357FN04:           move.l  IP(A6),A0
    23582358                move.b  141(A0),D0
    … …  
    23612361                btst    #0,D0
    23622362                bne     FN04A
    2363 *
     2363
    23642364                jmp     FN05
    2365 *
    2366 *       vp = (vce << 4) + 10;
    2367 *
     2365
     2366|       vp = (vce << 4) + 10;
     2367
    23682368FN04A:          move    VCE(A6),D0
    23692369                asl     #4,D0
    23702370                add.w   #10,D0
    23712371                move    D0,VP(A6)
    2372 *
    2373 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    2374 *
     2372
     2373|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     2374
    23752375                asl     #5,D0
    23762376                ext.l   D0
    23772377                move.l  D0,A_FPU
    2378                 add.l   #_io_fpu+$4000,A_FPU
    2379 *
    2380 *       fp = &ip->idhfnc[4];
    2381 *
     2378                add.l   #_io_fpu+0x4000,A_FPU
     2379
     2380|       fp = &ip->idhfnc[4];
     2381
    23822382                move.l  #48,A_FP
    23832383                add.l   IP(A6),A_FP
    23842384                add.l   #86,A_FP
    2385 *
    2386                 .page
    2387 *
    2388 *       Added code:
    2389 *
    2390 *               output resonance via table lookup with FPU interrupts off
    2391 *
     2385
     2386                .page
     2387
     2388|       Added code:
     2389
     2390|               output resonance via table lookup with FPU interrupts off
     2391
    23922392                lea     _rsntab,A0
    23932393                clr.w   D0
    … …  
    24012401                ext.l   D0
    24022402                move.l  D0,A0
    2403                 add.l   #_io_fpu+$4000,A0
     2403                add.l   #_io_fpu+0x4000,A0
    24042404                move.w  sr,OLDI(A6)
    24052405                move.w  #FPU_DI,sr
    24062406                move.w  d1,2(A0)
    24072407                add.w   #1,OCTYPE(A6)
    2408                 move.w  d1,$1C(A0)
     2408                move.w  d1,0x1C(A0)
    24092409                add.w   #1,OCTYPE(A6)
    2410                 move.w  #$0015,(A0)
     2410                move.w  #0x0015,(A0)
    24112411                move.w  OLDI(A6),sr
    2412 *
    2413 *       pt = &ip->idhpnt[fp->idfpt1];
    2414 *
     2412
     2413|       pt = &ip->idhpnt[fp->idfpt1];
     2414
    24152415                clr.l   D0
    24162416                move.b  6(A_FP),D0
    … …  
    24222422                add.l   #242,D0
    24232423                move.l  D0,PT(A6)
    2424 *
    2425                 .page
    2426 *
    2427 *       srcnum = group | fp->idfsrc;
    2428 *
     2424
     2425                .page
     2426
     2427|       srcnum = group | fp->idfsrc;
     2428
    24292429                move.w  GROUP(A6),D0
    24302430                ext.l   D0
    … …  
    24332433                or      D1,D0
    24342434                move    D0,SRCNUM(A6)
    2435 *
    2436 *       vep = &valents[srcnum];
    2437 *
     2435
     2436|       vep = &valents[srcnum];
     2437
    24382438                add.l   D0,D0
    24392439                move.l  D0,D1
    … …  
    24422442                add.l   #_valents,D0
    24432443                move.l  D0,VEP(A6)
    2444 *
    2445 *       smp = vpsms[vp];
    2446 *
     2444
     2445|       smp = vpsms[vp];
     2446
    24472447                move    VP(A6),A0
    24482448                add.l   A0,A0
    … …  
    24502450                add.l   #_vpsms,A0
    24512451                move.l  (A0),A_SMP
    2452 *
    2453 *       if (srcnum NE smp->sm) {
    2454 *
     2452
     2453|       if (srcnum NE smp->sm) {
     2454
    24552455                clr     D0
    24562456                move    10(A_SMP),D0
    24572457                cmp     SRCNUM(A6),D0
    24582458                beq     F04L113
    2459 *
    2460 *               (smp->prv)->nxt = smp->nxt;
    2461 *
     2459
     2460|               (smp->prv)->nxt = smp->nxt;
     2461
    24622462                move.l  4(A_SMP),A0
    24632463                move.l  (A_SMP),(A0)
    2464 *
    2465 *               (smp->nxt)->prv = smp->prv;
    2466 *
     2464
     2465|               (smp->nxt)->prv = smp->prv;
     2466
    24672467                move.l  (A_SMP),A0
    24682468                move.l  4(A_SMP),4(A0)
    2469 *
    2470 *               smp->prv = (struct sment *)vep;
    2471 *
     2469
     2470|               smp->prv = (struct sment |)vep;
     2471
    24722472                move.l  VEP(A6),4(A_SMP)
    2473 *
    2474 *               smp->nxt = vep->nxt;
    2475 *
     2473
     2474|               smp->nxt = vep->nxt;
     2475
    24762476                move.l  VEP(A6),A0
    24772477                move.l  (A0),(A_SMP)
    2478 *
    2479 *               (vep->nxt)->prv = smp;
    2480 *
     2478
     2479|               (vep->nxt)->prv = smp;
     2480
    24812481                move.l  VEP(A6),A0
    24822482                move.l  (A0),A0
    24832483                move.l  A_SMP,4(A0)
    2484 *
    2485 *               vep->nxt = smp;
    2486 *
     2484
     2485|               vep->nxt = smp;
     2486
    24872487                move.l  VEP(A6),A0
    24882488                move.l  A_SMP,(A0)
    2489 *
    2490 *               smp->sm = srcnum;
    2491 *
     2489
     2490|               smp->sm = srcnum;
     2491
    24922492                move    SRCNUM(A6),10(A_SMP)
    2493 *
    2494 *       }
    2495 *
    2496 *       mltval = fp->idfmlt;
    2497 *
     2493
     2494|       }
     2495
     2496|       mltval = fp->idfmlt;
     2497
    24982498F04L113:        move    2(A_FP),MLTVAL(A6)
    2499 *
    2500                 .page
    2501 *
    2502 *       switch (fp->idfsrc) {
    2503 *
     2499
     2500                .page
     2501
     2502|       switch (fp->idfsrc) {
     2503
    25042504                move.b  4(A_FP),D0
    25052505                ext.w   d0
    25062506                cmp     #10,D0
    25072507                bhi     F04L122
    2508 *
     2508
    25092509                asl     #2,D0
    25102510                lea     F04L123,A0
    25112511                movea.l 0(A0,D0.W),A0
    25122512                jmp     (A0)
    2513 *
    2514 *       case SM_NONE:
    2515 *               mltval = 0;
    2516 *
     2513
     2514|       case SM_NONE:
     2515|               mltval = 0;
     2516
    25172517F04L116:        clr     MLTVAL(A6)
    2518 *
    2519 *               tsrcval = 0;
    2520 *
     2518
     2519|               tsrcval = 0;
     2520
    25212521                clr     TSRCVAL(A6)
    2522 *
    2523 *               break;
    2524 *
     2522
     2523|               break;
     2524
    25252525                bra     F04L114
    2526 *
    2527 *       case SM_RAND:
    2528 *               tsrcval = xgetran(mltval);
    2529 *
     2526
     2527|       case SM_RAND:
     2528|               tsrcval = xgetran(mltval);
     2529
    25302530F04L117:        move    MLTVAL(A6),(sp)
    25312531                jsr     _xgetran
    25322532                move    D0,TSRCVAL(A6)
    2533 *
    2534 *               break;
    2535 *
     2533
     2534|               break;
     2535
    25362536                bra     F04L114
    2537 *
    2538 *       case SM_PTCH:
    2539 *               tsrcval = pch;
    2540 *
     2537
     2538|       case SM_PTCH:
     2539|               tsrcval = pch;
     2540
    25412541F04L118:        move    PCH(A6),TSRCVAL(A6)
    2542 *
    2543 *               break;
    2544 *
     2542
     2543|               break;
     2544
    25452545                bra     F04L114
    2546 *
    2547                 .page
    2548 *
    2549 *       case SM_FREQ:
    2550 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    2551 *
     2546
     2547                .page
     2548
     2549|       case SM_FREQ:
     2550|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     2551
    25522552F04L119:        move    PCH(A6),D0
    25532553                asr     #7,D0
    … …  
    25572557                add.l   #_ptoftab,A0
    25582558                move    (A0),TSRCVAL(A6)
    2559 *
    2560 *               break;
    2561 *
     2559
     2560|               break;
     2561
    25622562                bra     F04L114
    2563 *
    2564 *       case SM_KVEL:
    2565 *               tsrcval = veltab[trg];
    2566 *
     2563
     2564|       case SM_KVEL:
     2565|               tsrcval = veltab[trg];
     2566
    25672567F04L120:        move    TRG(A6),A0
    25682568                add.l   A0,A0
    25692569                add.l   #_veltab,A0
    25702570                move    (A0),TSRCVAL(A6)
    2571 *
    2572 *               break;
    2573 *
     2571
     2572|               break;
     2573
    25742574                bra     F04L114
    2575 *
    2576 *       case SM_KPRS:
    2577 *               tsrcval = prstab[trg];
    2578 *
     2575
     2576|       case SM_KPRS:
     2577|               tsrcval = prstab[trg];
     2578
    25792579F04L121:        move    TRG(A6),A0
    25802580                add.l   A0,A0
    25812581                add.l   #_prstab,A0
    25822582                move    (A0),TSRCVAL(A6)
    2583 *
    2584 *               break;
    2585 *
     2583
     2584|               break;
     2585
    25862586                bra     F04L114
    2587 *
    2588 *       default:
    2589 *               tsrcval = vep->val;
    2590 *
     2587
     2588|       default:
     2589|               tsrcval = vep->val;
     2590
    25912591F04L122:        move.l  VEP(A6),A0
    25922592                move    8(A0),TSRCVAL(A6)
    2593 *
    2594 *       }
    2595 *
    2596                 .page
    2597 *
    2598 *               ltmp = ((long)tsrcval >> 1) + ((long)tsrcval >> 2);
    2599 *
     2593
     2594|       }
     2595
     2596                .page
     2597
     2598|               ltmp = ((long)tsrcval >> 1) + ((long)tsrcval >> 2);
     2599
    26002600F04L114:        move    TSRCVAL(A6),D0
    26012601                ext.l   D0
    … …  
    26062606                add.l   D1,D0
    26072607                move.l  D0,LTMP(A6)
    2608 *
    2609 *               if (ltmp GT (long)VALMAX)
    2610 *                       ltmp = (long)VALMAX;
    2611 *
     2608
     2609|               if (ltmp GT (long)VALMAX)
     2610|                       ltmp = (long)VALMAX;
     2611
    26122612                cmp.l   #VALMAX,LTMP(A6)
    26132613                ble     F04L131
    2614 *
     2614
    26152615                move.l  #VALMAX,LTMP(A6)
    26162616                bra     F04L132
    2617 *
    2618 *               else if (ltmp LT (long)VALMIN)
    2619 *                       ltmp = (long)VALMIN;
    2620 *
     2617
     2618|               else if (ltmp LT (long)VALMIN)
     2619|                       ltmp = (long)VALMIN;
     2620
    26212621F04L131:        cmp.l   #VALMIN,LTMP(A6)
    26222622                bge     F04L132
    2623 *
     2623
    26242624                move.l  #VALMIN,LTMP(A6)
    2625 *
    2626 *               srcval = (short)ltmp;
    2627 *
     2625
     2626|               srcval = (short)ltmp;
     2627
    26282628F04L132:        move.l  LTMP(A6),D0
    26292629                move    D0,SRCVAL(A6)
    2630 *
    2631                 .page
    2632 *
    2633 *       if (pt->ipvsrc) {
    2634 *
     2630
     2631                .page
     2632
     2633|       if (pt->ipvsrc) {
     2634
    26352635F04L124:        move.l  PT(A6),A0
    26362636                tst.b   6(A0)
    26372637                beq     F04L136
    2638 *
    2639 *               switch (pt->ipvsrc) {
    2640 *
     2638
     2639|               switch (pt->ipvsrc) {
     2640
    26412641                move.l  PT(A6),A0
    26422642                move.b  6(A0),D0
    … …  
    26452645                cmp     #9,D0
    26462646                bhi     F04L144
    2647 *
     2647
    26482648                asl     #2,D0
    26492649                lea     F04L145,A0
    26502650                move.l  0(A0,D0.W),A0
    26512651                jmp     (A0)
    2652 *
    2653 *               case SM_RAND:
    2654 *                       ltmp = xgetran(pt_>ipvmlt);
    2655 *
     2652
     2653|               case SM_RAND:
     2654|                       ltmp = xgetran(pt_>ipvmlt);
     2655
    26562656F04L139:        move.l  PT(A6),A0
    26572657                move    4(A0),(sp)
    … …  
    26592659                ext.l   D0
    26602660                move.l  D0,LTMP(A6)
    2661 *
    2662 *                       break;
    2663 *
     2661
     2662|                       break;
     2663
    26642664                bra     F04L137
    2665 *
    2666 *               case SM_PTCH:
    2667 *                       ltmp = pch;
    2668 *
     2665
     2666|               case SM_PTCH:
     2667|                       ltmp = pch;
     2668
    26692669F04L140:        move    PCH(A6),A0
    26702670                move.l  A0,LTMP(A6)
    2671 *
    2672 *                       break;
    2673 *
     2671
     2672|                       break;
     2673
    26742674                bra     F04L137
    2675 *
    2676                 .page
    2677 *
    2678 *               case SM_FREQ:
    2679 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    2680 *
     2675
     2676                .page
     2677
     2678|               case SM_FREQ:
     2679|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     2680
    26812681F04L141:        move    PCH(A6),D0
    26822682                asr     #7,D0
    … …  
    26882688                ext.l   D0
    26892689                move.l  D0,LTMP(A6)
    2690 *
    2691 *                       break;
    2692 *
     2690
     2691|                       break;
     2692
    26932693                bra     F04L137
    2694 *
    2695 *               case SM_KVEL:
    2696 *                       ltmp = veltab[trg];
    2697 *
     2694
     2695|               case SM_KVEL:
     2696|                       ltmp = veltab[trg];
     2697
    26982698F04L142:        move    TRG(A6),A0
    26992699                add.l   A0,A0
    … …  
    27022702                ext.l   D0
    27032703                move.l  D0,LTMP(A6)
    2704 *
    2705 *                       break;
    2706 *
     2704
     2705|                       break;
     2706
    27072707                bra     F04L137
    2708 *
    2709                 .page
    2710 *
    2711 *               case SM_KPRS:
    2712 *                       ltmp = prstab[trg];
    2713 *
     2708
     2709                .page
     2710
     2711|               case SM_KPRS:
     2712|                       ltmp = prstab[trg];
     2713
    27142714F04L143:        move    TRG(A6),A0
    27152715                add.l   A0,A0
    … …  
    27182718                ext.l   D0
    27192719                move.l  D0,LTMP(A6)
    2720 *
    2721 *                       break;
    2722 *
     2720
     2721|                       break;
     2722
    27232723                bra     F04L137
    2724 *
    2725                 .page
    2726 *
    2727 *               default:
    2728 *                       ltmp = valents[group | pt->ipvsrc].val;
    2729 *
     2724
     2725                .page
     2726
     2727|               default:
     2728|                       ltmp = valents[group | pt->ipvsrc].val;
     2729
    27302730F04L144:        move.l  PT(A6),A0
    27312731                clr.l   D0
    … …  
    27412741                move    8(A0,A1.l),D0
    27422742                move.l  D0,LTMP(A6)
    2743 *
    2744 *               }
    2745 *
    2746 *
    2747                 .page
    2748 *
    2749 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    2750 *
     2743
     2744|               }
     2745
     2746
     2747                .page
     2748
     2749|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     2750
    27512751F04L137:        move.l  PT(A6),A0
    27522752                move.w  4(A0),D0
    … …  
    27562756                asr.l   D1,D0
    27572757                move.l  D0,LTMP(A6)
    2758 *
    2759 *               ltmp += (long)pt->ipval;
    2760 *
     2758
     2759|               ltmp += (long)pt->ipval;
     2760
    27612761                move.l  PT(A6),A0
    27622762                move    2(A0),D0
    27632763                ext.l   D0
    27642764                add.l   D0,LTMP(A6)
    2765 *
    2766 *               if (ltmp GT (long)VALMAX)
    2767 *                       ltmp = (long)VALMAX;
    2768 *
     2765
     2766|               if (ltmp GT (long)VALMAX)
     2767|                       ltmp = (long)VALMAX;
     2768
    27692769                cmp.l   #VALMAX,LTMP(A6)
    27702770                ble     F04L146
    2771 *
     2771
    27722772                move.l  #VALMAX,LTMP(A6)
    27732773                bra     F04L147
    2774 *
    2775 *               else if (ltmp LT (long)VALMIN)
    2776 *                       ltmp = (long)VALMIN;
    2777 *
     2774
     2775|               else if (ltmp LT (long)VALMIN)
     2776|                       ltmp = (long)VALMIN;
     2777
    27782778F04L146:        cmp.l   #VALMIN,LTMP(A6)
    27792779                bge     F04L147
    2780 *
     2780
    27812781                move.l  #VALMIN,LTMP(A6)
    2782 *
    2783 *               tfpval = (short)ltmp;
    2784 *
     2782
     2783|               tfpval = (short)ltmp;
     2784
    27852785F04L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    27862786                bra     F04L149
    2787 *
    2788 *       } else {
    2789 *
    2790 *               tfpval = pt->ipval;
    2791 *
     2787
     2788|       } else {
     2789
     2790|               tfpval = pt->ipval;
     2791
    27922792F04L136:        move.l  PT(A6),A0
    27932793                move    2(A0),TFPVAL(A6)
    2794 *
    2795 *       }
    2796 *
    2797                 .page
    2798 *
    2799 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    2800 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    2801 *
     2794
     2795|       }
     2796
     2797                .page
     2798
     2799|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     2800|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     2801
    28022802F04L149:        move.l  PT(A6),A0
    28032803                move.w  (A0),D0
    28042804                move.w  D0,D2
    2805                 andi.w  #$FFF0,D0
     2805                andi.w  #0xFFF0,D0
    28062806                move.w  _timemlt,D1
    28072807                muls    D1,D0
    … …  
    28092809                asr.l   D1,D0
    28102810                move    D0,R_FPMANT
    2811 *
    2812 *       fpexp = expbit[pt->iptim & 0x000F];
    2813 *
    2814                 and     #$000F,D2
     2811
     2812|       fpexp = expbit[pt->iptim & 0x000F];
     2813
     2814                and     #0x000F,D2
    28152815                move    D2,A0
    28162816                add.l   A0,A0
    28172817                add.l   #_expbit,A0
    28182818                move    (A0),R_FPEXP
    2819 *
    2820                 .page
    2821 *
    2822 *               fp->idfpch = pch;
    2823 *
     2819
     2820                .page
     2821
     2822|               fp->idfpch = pch;
     2823
    28242824F04L158:        move    PCH(A6),(A_FP)
    2825 *
    2826 *               ltmp = ((long)tfpval >> 1) + ((longtfpval >>2)
    2827 *                       + (long)fp->idfpch;
    2828 *
     2825
     2826|               ltmp = ((long)tfpval >> 1) + ((longtfpval >>2)
     2827|                       + (long)fp->idfpch;
     2828
    28292829                move    TFPVAL(A6),D0
    28302830                ext.l   D0
    … …  
    28382838                add.l   D1,D0
    28392839                move.l  D0,LTMP(A6)
    2840 *
    2841 *               if (ltmp GT (long)VALMAX)
    2842 *                       ltmp = (long)VALMAX;
    2843 *
     2840
     2841|               if (ltmp GT (long)VALMAX)
     2842|                       ltmp = (long)VALMAX;
     2843
    28442844                cmp.l   #VALMAX,LTMP(A6)
    28452845                ble     F04L159
    2846 *
     2846
    28472847                move.l  #VALMAX,LTMP(A6)
    28482848                bra     F04L160
    2849 *
    2850 *               else if (ltmp LT (long)VALMIN)
    2851 *                       ltmp = (long)VALMIN;
    2852 *
     2849
     2850|               else if (ltmp LT (long)VALMIN)
     2851|                       ltmp = (long)VALMIN;
     2852
    28532853F04L159:        cmp.l   #VALMIN,LTMP(A6)
    28542854                bge     F04L160
    2855 *
     2855
    28562856                move.l  #VALMIN,LTMP(A6)
    2857 *
    2858 *               fpval = (short)ltmp;
    2859 *
     2857
     2858|               fpval = (short)ltmp;
     2859
    28602860F04L160:        move.l  LTMP(A6),D0
    28612861                move    D0,R_FPVAL
    2862 *
    2863                 .page
    2864 *
     2862
     2863                .page
     2864
    28652865                move.b  5(A_FP),D0
    28662866                ext.w   D0
    28672867                sub.w   #1,D0
    28682868                movea.l PT(A6),A0
    2869 *
    2870 *       oldi = setipl(FPU_DI);
    2871 *
     2869
     2870|       oldi = setipl(FPU_DI);
     2871
    28722872                move    sr,OLDI(A6)
    28732873                move    #FPU_DI,sr
    2874 *
     2874
    28752875F04L168:        clr.b   10(A0)
    28762876                add.l   #12,a0
    28772877                dbra    D0,F04L168
    2878 *
    2879                 .page
    2880 *
    2881 *       fp->idftmd ^= I_NVBITS;
    2882 *
     2878
     2879                .page
     2880
     2881|       fp->idftmd ^= I_NVBITS;
     2882
    28832883F04L165:        eor.b   #24,7(A_FP)
    2884 *
    2885 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    2886 *
     2884
     2885|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     2886
    28872887                move.b  7(A_FP),R_FPCTL
    28882888                and     #28,R_FPCTL
    28892889                or      #3,R_FPCTL
    2890 *
    2891 *       fp->idfcpt = fp->idfpt1;
    2892 *
     2890
     2891|       fp->idfcpt = fp->idfpt1;
     2892
    28932893                move.b  6(A_FP),8(A_FP)
    2894 *
    2895 *       fp->idftmd |= I_ACTIVE;
    2896 *
     2894
     2895|       fp->idftmd |= I_ACTIVE;
     2896
    28972897                or.b    #2,7(A_FP)
    2898 *
    2899 *       fp->idftrf = trg;
    2900 *
     2898
     2899|       fp->idftrf = trg;
     2900
    29012901                move    TRG(A6),10(A_FP)
    2902 *
    2903 *       *(fpu + (long)FPU_TCV1) = srcval;
    2904 *
    2905                 move    SRCVAL(A6),$8(A_FPU)
    2906 *
    2907 *       ++octype;
    2908 *
     2902
     2903|       |(fpu + (long)FPU_TCV1) = srcval;
     2904
     2905                move    SRCVAL(A6),0x8(A_FPU)
     2906
     2907|       ++octype;
     2908
    29092909                add     #1,OCTYPE(A6)
    2910 *
    2911 *       *(fpu + (long)FPU_TSF1) = mltval;
    2912 *
    2913                 move    MLTVAL(A6),$A(A_FPU)
    2914 *
    2915 *       ++octype;
    2916 *
     2910
     2911|       |(fpu + (long)FPU_TSF1) = mltval;
     2912
     2913                move    MLTVAL(A6),0xA(A_FPU)
     2914
     2915|       ++octype;
     2916
    29172917                add     #1,OCTYPE(A6)
    2918 *
    2919 *       *(fpu + (long)FPU_TMNT) = fpmant;
    2920 *
    2921                 move    R_FPMANT,$14(A_FPU)
    2922 *
    2923 *       ++octype;
    2924 *
     2918
     2919|       |(fpu + (long)FPU_TMNT) = fpmant;
     2920
     2921                move    R_FPMANT,0x14(A_FPU)
     2922
     2923|       ++octype;
     2924
    29252925                add     #1,OCTYPE(A6)
    2926 *
    2927 *       *(fpu + (long)FPU_TEXP) = fpexp;
    2928 *
    2929                 move    R_FPEXP,$16(A_FPU)
    2930 *
    2931 *       ++octype;
    2932 *
     2926
     2927|       |(fpu + (long)FPU_TEXP) = fpexp;
     2928
     2929                move    R_FPEXP,0x16(A_FPU)
     2930
     2931|       ++octype;
     2932
    29332933                add     #1,OCTYPE(A6)
    2934 *
    2935                 .page
    2936 *
    2937 *       if (fp->idftmd & I_VNSUBN)
    2938 *
     2934
     2935                .page
     2936
     2937|       if (fp->idftmd & I_VNSUBN)
     2938
    29392939                btst    #3,7(A_FP)
    29402940                beq     F04L169
    2941 *
    2942 *               *(fpu + (long)FPU_TNV1) = fpval;
    2943 *
    2944                 move    R_FPVAL,$1C(A_FPU)
     2941
     2942|               |(fpu + (long)FPU_TNV1) = fpval;
     2943
     2944                move    R_FPVAL,0x1C(A_FPU)
    29452945                bra     F04L170
    2946 *
    2947 *       else
    2948 *               *(fpu + (long)FPU_TNV0) = fpval;
    2949 *
     2946
     2947|       else
     2948|               |(fpu + (long)FPU_TNV0) = fpval;
     2949
    29502950F04L169:        move    R_FPVAL,2(A_FPU)
    2951 *
    2952 *       ++octype;
    2953 *
     2951
     2952|       ++octype;
     2953
    29542954F04L170:        add     #1,OCTYPE(A6)
    2955 *
    2956 *       *(fpu + (long)FPU_TCTL) = fpctl;
    2957 *
     2955
     2956|       |(fpu + (long)FPU_TCTL) = fpctl;
     2957
    29582958                move    R_FPCTL,(A_FPU)
    2959 *
    2960 *       setipl(oldi);
    2961 *
     2959
     2960|       setipl(oldi);
     2961
    29622962                move    OLDI(A6),sr
    2963 *
    2964                 .page
    2965 * ------------------------------------------------------------------------------
    2966 * Start function 5 -- Loctn
    2967 * ------------------------------------------------------------------------------
    2968 *
    2969 *    if (ip->idhfnc[5].idftmd & I_TM_KEY) {
    2970 *
     2963
     2964                .page
     2965| ------------------------------------------------------------------------------
     2966| Start function 5 -- Loctn
     2967| ------------------------------------------------------------------------------
     2968
     2969|    if (ip->idhfnc[5].idftmd & I_TM_KEY) {
     2970
    29712971FN05:           move.l  IP(A6),A0
    29722972                move.b  153(A0),D0
    … …  
    29752975                btst    #0,D0
    29762976                bne     FN05A
    2977 *
     2977
    29782978                jmp     FN06
    2979 *
    2980 *       vp = (vce << 4) + 4;
    2981 *
     2979
     2980|       vp = (vce << 4) + 4;
     2981
    29822982FN05A:          move    VCE(A6),D0
    29832983                asl     #4,D0
    29842984                add.w   #4,D0
    29852985                move    D0,VP(A6)
    2986 *
    2987 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    2988 *
     2986
     2987|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     2988
    29892989                asl     #5,D0
    29902990                ext.l   D0
    29912991                move.l  D0,A_FPU
    2992                 add.l   #_io_fpu+$4000,A_FPU
    2993 *
    2994 *       fp = &ip->idhfnc[5];
    2995 *
     2992                add.l   #_io_fpu+0x4000,A_FPU
     2993
     2994|       fp = &ip->idhfnc[5];
     2995
    29962996                move.l  #60,A_FP
    29972997                add.l   IP(A6),A_FP
    29982998                add.l   #86,A_FP
    2999 *
    3000 *       pt = &ip->idhpnt[fp->idfpt1];
    3001 *
     2999
     3000|       pt = &ip->idhpnt[fp->idfpt1];
     3001
    30023002                clr.l   D0
    30033003                move.b  6(A_FP),D0
    … …  
    30093009                add.l   #242,D0
    30103010                move.l  D0,PT(A6)
    3011 *
    3012                 .page
    3013 *
    3014 *       srcnum = group | fp->idfsrc;
    3015 *
     3011
     3012                .page
     3013
     3014|       srcnum = group | fp->idfsrc;
     3015
    30163016                move.w  GROUP(A6),D0
    30173017                ext.l   D0
    … …  
    30203020                or      D1,D0
    30213021                move    D0,SRCNUM(A6)
    3022 *
    3023 *       vep = &valents[srcnum];
    3024 *
     3022
     3023|       vep = &valents[srcnum];
     3024
    30253025                add.l   D0,D0
    30263026                move.l  D0,D1
    … …  
    30293029                add.l   #_valents,D0
    30303030                move.l  D0,VEP(A6)
    3031 *
    3032 *       smp = vpsms[vp];
    3033 *
     3031
     3032|       smp = vpsms[vp];
     3033
    30343034                move    VP(A6),A0
    30353035                add.l   A0,A0
    … …  
    30373037                add.l   #_vpsms,A0
    30383038                move.l  (A0),A_SMP
    3039 *
    3040 *       if (srcnum NE smp->sm) {
    3041 *
     3039
     3040|       if (srcnum NE smp->sm) {
     3041
    30423042                clr     D0
    30433043                move    10(A_SMP),D0
    30443044                cmp     SRCNUM(A6),D0
    30453045                beq     F05L113
    3046 *
    3047 *               (smp->prv)->nxt = smp->nxt;
    3048 *
     3046
     3047|               (smp->prv)->nxt = smp->nxt;
     3048
    30493049                move.l  4(A_SMP),A0
    30503050                move.l  (A_SMP),(A0)
    3051 *
    3052 *               (smp->nxt)->prv = smp->prv;
    3053 *
     3051
     3052|               (smp->nxt)->prv = smp->prv;
     3053
    30543054                move.l  (A_SMP),A0
    30553055                move.l  4(A_SMP),4(A0)
    3056 *
    3057 *               smp->prv = (struct sment *)vep;
    3058 *
     3056
     3057|               smp->prv = (struct sment |)vep;
     3058
    30593059                move.l  VEP(A6),4(A_SMP)
    3060 *
    3061 *               smp->nxt = vep->nxt;
    3062 *
     3060
     3061|               smp->nxt = vep->nxt;
     3062
    30633063                move.l  VEP(A6),A0
    30643064                move.l  (A0),(A_SMP)
    3065 *
    3066 *               (vep->nxt)->prv = smp;
    3067 *
     3065
     3066|               (vep->nxt)->prv = smp;
     3067
    30683068                move.l  VEP(A6),A0
    30693069                move.l  (A0),A0
    30703070                move.l  A_SMP,4(A0)
    3071 *
    3072 *               vep->nxt = smp;
    3073 *
     3071
     3072|               vep->nxt = smp;
     3073
    30743074                move.l  VEP(A6),A0
    30753075                move.l  A_SMP,(A0)
    3076 *
    3077 *               smp->sm = srcnum;
    3078 *
     3076
     3077|               smp->sm = srcnum;
     3078
    30793079                move    SRCNUM(A6),10(A_SMP)
    3080 *
    3081 *       }
    3082 *
    3083 *       mltval = fp->idfmlt;
    3084 *
     3080
     3081|       }
     3082
     3083|       mltval = fp->idfmlt;
     3084
    30853085F05L113:        move    2(A_FP),MLTVAL(A6)
    3086 *
    3087                 .page
    3088 *
    3089 *       switch (fp->idfsrc) {
    3090 *
     3086
     3087                .page
     3088
     3089|       switch (fp->idfsrc) {
     3090
    30913091                move.b  4(A_FP),D0
    30923092                ext.w   d0
    30933093                cmp     #10,D0
    30943094                bhi     F05L122
    3095 *
     3095
    30963096                asl     #2,D0
    30973097                lea     F05L123,A0
    30983098                movea.l 0(A0,D0.W),A0
    30993099                jmp     (A0)
    3100 *
    3101 *       case SM_NONE:
    3102 *               mltval = 0;
    3103 *
     3100
     3101|       case SM_NONE:
     3102|               mltval = 0;
     3103
    31043104F05L116:        clr     MLTVAL(A6)
    3105 *
    3106 *               tsrcval = 0;
    3107 *
     3105
     3106|               tsrcval = 0;
     3107
    31083108                clr     TSRCVAL(A6)
    3109 *
    3110 *               break;
    3111 *
     3109
     3110|               break;
     3111
    31123112                bra     F05L114
    3113 *
    3114 *       case SM_RAND:
    3115 *               tsrcval = xgetran(mltval);
    3116 *
     3113
     3114|       case SM_RAND:
     3115|               tsrcval = xgetran(mltval);
     3116
    31173117F05L117:        move    MLTVAL(A6),(sp)
    31183118                jsr     _xgetran
    31193119                move    D0,TSRCVAL(A6)
    3120 *
    3121 *               break;
    3122 *
     3120
     3121|               break;
     3122
    31233123                bra     F05L114
    3124 *
    3125 *       case SM_PTCH:
    3126 *               tsrcval = pch;
    3127 *
     3124
     3125|       case SM_PTCH:
     3126|               tsrcval = pch;
     3127
    31283128F05L118:        move    PCH(A6),TSRCVAL(A6)
    3129 *
    3130 *               break;
    3131 *
     3129
     3130|               break;
     3131
    31323132                bra     F05L114
    3133 *
    3134                 .page
    3135 *
    3136 *       case SM_FREQ:
    3137 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    3138 *
     3133
     3134                .page
     3135
     3136|       case SM_FREQ:
     3137|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     3138
    31393139F05L119:        move    PCH(A6),D0
    31403140                asr     #7,D0
    … …  
    31443144                add.l   #_ptoftab,A0
    31453145                move    (A0),TSRCVAL(A6)
    3146 *
    3147 *               break;
    3148 *
     3146
     3147|               break;
     3148
    31493149                bra     F05L114
    3150 *
    3151 *       case SM_KVEL:
    3152 *               tsrcval = veltab[trg];
    3153 *
     3150
     3151|       case SM_KVEL:
     3152|               tsrcval = veltab[trg];
     3153
    31543154F05L120:        move    TRG(A6),A0
    31553155                add.l   A0,A0
    31563156                add.l   #_veltab,A0
    31573157                move    (A0),TSRCVAL(A6)
    3158 *
    3159 *               break;
    3160 *
     3158
     3159|               break;
     3160
    31613161                bra     F05L114
    3162 *
    3163 *       case SM_KPRS:
    3164 *               tsrcval = prstab[trg];
    3165 *
     3162
     3163|       case SM_KPRS:
     3164|               tsrcval = prstab[trg];
     3165
    31663166F05L121:        move    TRG(A6),A0
    31673167                add.l   A0,A0
    31683168                add.l   #_prstab,A0
    31693169                move    (A0),TSRCVAL(A6)
    3170 *
    3171 *               break;
    3172 *
     3170
     3171|               break;
     3172
    31733173                bra     F05L114
    3174 *
    3175 *       default:
    3176 *               tsrcval = vep->val;
    3177 *
     3174
     3175|       default:
     3176|               tsrcval = vep->val;
     3177
    31783178F05L122:        move.l  VEP(A6),A0
    31793179                move    8(A0),TSRCVAL(A6)
    3180 *
    3181 *       }
    3182 *
    3183                 .page
    3184 *
    3185 *               srcval = tsrcval;
    3186 *
     3180
     3181|       }
     3182
     3183                .page
     3184
     3185|               srcval = tsrcval;
     3186
    31873187F05L114:        move    TSRCVAL(A6),SRCVAL(A6)
    3188 *
    3189                 .page
    3190 *
    3191 *       if (pt->ipvsrc) {
    3192 *
     3188
     3189                .page
     3190
     3191|       if (pt->ipvsrc) {
     3192
    31933193F05L124:        move.l  PT(A6),A0
    31943194                tst.b   6(A0)
    31953195                beq     F05L136
    3196 *
    3197 *               switch (pt->ipvsrc) {
    3198 *
     3196
     3197|               switch (pt->ipvsrc) {
     3198
    31993199                move.l  PT(A6),A0
    32003200                move.b  6(A0),D0
    … …  
    32033203                cmp     #9,D0
    32043204                bhi     F05L144
    3205 *
     3205
    32063206                asl     #2,D0
    32073207                lea     F05L145,A0
    32083208                move.l  0(A0,D0.W),A0
    32093209                jmp     (A0)
    3210 *
    3211 *               case SM_RAND:
    3212 *                       ltmp = xgetran(pt_>ipvmlt);
    3213 *
     3210
     3211|               case SM_RAND:
     3212|                       ltmp = xgetran(pt_>ipvmlt);
     3213
    32143214F05L139:        move.l  PT(A6),A0
    32153215                move    4(A0),(sp)
    … …  
    32173217                ext.l   D0
    32183218                move.l  D0,LTMP(A6)
    3219 *
    3220 *                       break;
    3221 *
     3219
     3220|                       break;
     3221
    32223222                bra     F05L137
    3223 *
    3224 *               case SM_PTCH:
    3225 *                       ltmp = pch;
    3226 *
     3223
     3224|               case SM_PTCH:
     3225|                       ltmp = pch;
     3226
    32273227F05L140:        move    PCH(A6),A0
    32283228                move.l  A0,LTMP(A6)
    3229 *
    3230 *                       break;
    3231 *
     3229
     3230|                       break;
     3231
    32323232                bra     F05L137
    3233 *
    3234                 .page
    3235 *
    3236 *               case SM_FREQ:
    3237 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    3238 *
     3233
     3234                .page
     3235
     3236|               case SM_FREQ:
     3237|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     3238
    32393239F05L141:        move    PCH(A6),D0
    32403240                asr     #7,D0
    … …  
    32463246                ext.l   D0
    32473247                move.l  D0,LTMP(A6)
    3248 *
    3249 *                       break;
    3250 *
     3248
     3249|                       break;
     3250
    32513251                bra     F05L137
    3252 *
    3253 *               case SM_KVEL:
    3254 *                       ltmp = veltab[trg];
    3255 *
     3252
     3253|               case SM_KVEL:
     3254|                       ltmp = veltab[trg];
     3255
    32563256F05L142:        move    TRG(A6),A0
    32573257                add.l   A0,A0
    … …  
    32603260                ext.l   D0
    32613261                move.l  D0,LTMP(A6)
    3262 *
    3263 *                       break;
    3264 *
     3262
     3263|                       break;
     3264
    32653265                bra     F05L137
    3266 *
    3267                 .page
    3268 *
    3269 *               case SM_KPRS:
    3270 *                       ltmp = prstab[trg];
    3271 *
     3266
     3267                .page
     3268
     3269|               case SM_KPRS:
     3270|                       ltmp = prstab[trg];
     3271
    32723272F05L143:        move    TRG(A6),A0
    32733273                add.l   A0,A0
    … …  
    32763276                ext.l   D0
    32773277                move.l  D0,LTMP(A6)
    3278 *
    3279 *                       break;
    3280 *
     3278
     3279|                       break;
     3280
    32813281                bra     F05L137
    3282 *
    3283                 .page
    3284 *
    3285 *               default:
    3286 *                       ltmp = valents[group | pt->ipvsrc].val;
    3287 *
     3282
     3283                .page
     3284
     3285|               default:
     3286|                       ltmp = valents[group | pt->ipvsrc].val;
     3287
    32883288F05L144:        move.l  PT(A6),A0
    32893289                clr.l   D0
    … …  
    32993299                move    8(A0,A1.l),D0
    33003300                move.l  D0,LTMP(A6)
    3301 *
    3302 *               }
    3303 *
    3304 *
    3305                 .page
    3306 *
    3307 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    3308 *
     3301
     3302|               }
     3303
     3304
     3305                .page
     3306
     3307|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     3308
    33093309F05L137:        move.l  PT(A6),A0
    33103310                move.w  4(A0),D0
    … …  
    33143314                asr.l   D1,D0
    33153315                move.l  D0,LTMP(A6)
    3316 *
    3317 *               ltmp += (long)pt->ipval;
    3318 *
     3316
     3317|               ltmp += (long)pt->ipval;
     3318
    33193319                move.l  PT(A6),A0
    33203320                move    2(A0),D0
    33213321                ext.l   D0
    33223322                add.l   D0,LTMP(A6)
    3323 *
    3324 *               if (ltmp GT (long)VALMAX)
    3325 *                       ltmp = (long)VALMAX;
    3326 *
     3323
     3324|               if (ltmp GT (long)VALMAX)
     3325|                       ltmp = (long)VALMAX;
     3326
    33273327                cmp.l   #VALMAX,LTMP(A6)
    33283328                ble     F05L146
    3329 *
     3329
    33303330                move.l  #VALMAX,LTMP(A6)
    33313331                bra     F05L147
    3332 *
    3333 *               else if (ltmp LT (long)VALMIN)
    3334 *                       ltmp = (long)VALMIN;
    3335 *
     3332
     3333|               else if (ltmp LT (long)VALMIN)
     3334|                       ltmp = (long)VALMIN;
     3335
    33363336F05L146:        cmp.l   #VALMIN,LTMP(A6)
    33373337                bge     F05L147
    3338 *
     3338
    33393339                move.l  #VALMIN,LTMP(A6)
    3340 *
    3341 *               tfpval = (short)ltmp;
    3342 *
     3340
     3341|               tfpval = (short)ltmp;
     3342
    33433343F05L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    33443344                bra     F05L149
    3345 *
    3346 *       } else {
    3347 *
    3348 *               tfpval = pt->ipval;
    3349 *
     3345
     3346|       } else {
     3347
     3348|               tfpval = pt->ipval;
     3349
    33503350F05L136:        move.l  PT(A6),A0
    33513351                move    2(A0),TFPVAL(A6)
    3352 *
    3353 *       }
    3354 *
    3355                 .page
    3356 *
    3357 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    3358 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    3359 *
     3352
     3353|       }
     3354
     3355                .page
     3356
     3357|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     3358|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     3359
    33603360F05L149:        move.l  PT(A6),A0
    33613361                move.w  (A0),D0
    33623362                move.w  D0,D2
    3363                 andi.w  #$FFF0,D0
     3363                andi.w  #0xFFF0,D0
    33643364                move.w  _timemlt,D1
    33653365                muls    D1,D0
    … …  
    33673367                asr.l   D1,D0
    33683368                move    D0,R_FPMANT
    3369 *
    3370 *       fpexp = expbit[pt->iptim & 0x000F];
    3371 *
    3372                 and     #$000F,D2
     3369
     3370|       fpexp = expbit[pt->iptim & 0x000F];
     3371
     3372                and     #0x000F,D2
    33733373                move    D2,A0
    33743374                add.l   A0,A0
    33753375                add.l   #_expbit,A0
    33763376                move    (A0),R_FPEXP
    3377 *
    3378                 .page
    3379 *
    3380 *               fp->idfpch = pch;
    3381 *
     3377
     3378                .page
     3379
     3380|               fp->idfpch = pch;
     3381
    33823382F05L163:        move    PCH(A6),(A_FP)
    3383 *
    3384 *               if (tfpval > VALMAX)
    3385 *                       tfpval = VALMAX;
    3386 *               else if (tfpval < 0)
    3387 *                       tfpval = 0;
    3388 *
     3383
     3384|               if (tfpval > VALMAX)
     3385|                       tfpval = VALMAX;
     3386|               else if (tfpval < 0)
     3387|                       tfpval = 0;
     3388
    33893389                move.w  TFPVAL(A6),D0
    3390                 cmp.w   #$7D00,D0
     3390                cmp.w   #0x7D00,D0
    33913391                ble     F05L163B
    3392 *
    3393                 move.w  #$7D00,D0
     3392
     3393                move.w  #0x7D00,D0
    33943394                bra     F05L163A
    3395                
     3395
    33963396F05L163B:       tst.w   D0
    33973397                bpl     F05L163A
    3398 *
     3398
    33993399                clr.w   D0
    3400 *
    3401 *#if    LOC_EOR
    3402 *               fpval = (tfpval << 1) ^ 0x8000;
    3403 *#endif
    3404 *
     3400
     3401|#if    LOC_EOR
     3402|               fpval = (tfpval << 1) ^ 0x8000;
     3403|#endif
     3404
    34053405                .ifne   LOC_EOR
    34063406F05L163A:       add.w   D0,D0
    3407                 eor.w   #$8000,D0
     3407                eor.w   #0x8000,D0
    34083408                .endc
    3409 *
    3410 *#if    LOC_SUB
    3411 *               fpval = ((tfpval >> 5) - 500) << 6;
    3412 *#endif
    3413 *
     3409
     3410|#if    LOC_SUB
     3411|               fpval = ((tfpval >> 5) - 500) << 6;
     3412|#endif
     3413
    34143414                .ifne   LOC_SUB
    34153415F05L163A:       asr.w   #5,D0
    … …  
    34173417                asl.w   #6,D0
    34183418                .endc
    3419 *
     3419
    34203420                move.w  D0,R_FPVAL
    3421 *
    3422                 .page
    3423 *
     3421
     3422                .page
     3423
    34243424                move.b  5(A_FP),D0
    34253425                ext.w   D0
    34263426                sub.w   #1,D0
    34273427                movea.l PT(A6),A0
    3428 *
    3429 *       oldi = setipl(FPU_DI);
    3430 *
     3428
     3429|       oldi = setipl(FPU_DI);
     3430
    34313431                move    sr,OLDI(A6)
    34323432                move    #FPU_DI,sr
    3433 *
     3433
    34343434F05L168:        clr.b   10(A0)
    34353435                add.l   #12,a0
    34363436                dbra    D0,F05L168
    3437 *
    3438                 .page
    3439 *
    3440 *       fp->idftmd ^= I_NVBITS;
    3441 *
     3437
     3438                .page
     3439
     3440|       fp->idftmd ^= I_NVBITS;
     3441
    34423442F05L165:        eor.b   #24,7(A_FP)
    3443 *
    3444 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    3445 *
     3443
     3444|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     3445
    34463446                move.b  7(A_FP),R_FPCTL
    34473447                and     #28,R_FPCTL
    34483448                or      #3,R_FPCTL
    3449 *
    3450 *       fp->idfcpt = fp->idfpt1;
    3451 *
     3449
     3450|       fp->idfcpt = fp->idfpt1;
     3451
    34523452                move.b  6(A_FP),8(A_FP)
    3453 *
    3454 *       fp->idftmd |= I_ACTIVE;
    3455 *
     3453
     3454|       fp->idftmd |= I_ACTIVE;
     3455
    34563456                or.b    #2,7(A_FP)
    3457 *
    3458 *       fp->idftrf = trg;
    3459 *
     3457
     3458|       fp->idftrf = trg;
     3459
    34603460                move    TRG(A6),10(A_FP)
    3461 *
    3462 *       *(fpu + (long)FPU_TCV1) = srcval;
    3463 *
    3464                 move    SRCVAL(A6),$8(A_FPU)
    3465 *
    3466 *       ++octype;
    3467 *
     3461
     3462|       |(fpu + (long)FPU_TCV1) = srcval;
     3463
     3464                move    SRCVAL(A6),0x8(A_FPU)
     3465
     3466|       ++octype;
     3467
    34683468                add     #1,OCTYPE(A6)
    3469 *
    3470 *       *(fpu + (long)FPU_TSF1) = mltval;
    3471 *
    3472                 move    MLTVAL(A6),$A(A_FPU)
    3473 *
    3474 *       ++octype;
    3475 *
     3469
     3470|       |(fpu + (long)FPU_TSF1) = mltval;
     3471
     3472                move    MLTVAL(A6),0xA(A_FPU)
     3473
     3474|       ++octype;
     3475
    34763476                add     #1,OCTYPE(A6)
    3477 *
    3478 *       *(fpu + (long)FPU_TMNT) = fpmant;
    3479 *
    3480                 move    R_FPMANT,$14(A_FPU)
    3481 *
    3482 *       ++octype;
    3483 *
     3477
     3478|       |(fpu + (long)FPU_TMNT) = fpmant;
     3479
     3480                move    R_FPMANT,0x14(A_FPU)
     3481
     3482|       ++octype;
     3483
    34843484                add     #1,OCTYPE(A6)
    3485 *
    3486 *       *(fpu + (long)FPU_TEXP) = fpexp;
    3487 *
    3488                 move    R_FPEXP,$16(A_FPU)
    3489 *
    3490 *       ++octype;
    3491 *
     3485
     3486|       |(fpu + (long)FPU_TEXP) = fpexp;
     3487
     3488                move    R_FPEXP,0x16(A_FPU)
     3489
     3490|       ++octype;
     3491
    34923492                add     #1,OCTYPE(A6)
    3493 *
    3494                 .page
    3495 *
    3496 *       if (fp->idftmd & I_VNSUBN)
    3497 *
     3493
     3494                .page
     3495
     3496|       if (fp->idftmd & I_VNSUBN)
     3497
    34983498                btst    #3,7(A_FP)
    34993499                beq     F05L169
    3500 *
    3501 *               *(fpu + (long)FPU_TNV1) = fpval;
    3502 *
    3503                 move    R_FPVAL,$1C(A_FPU)
     3500
     3501|               |(fpu + (long)FPU_TNV1) = fpval;
     3502
     3503                move    R_FPVAL,0x1C(A_FPU)
    35043504                bra     F05L170
    3505 *
    3506 *       else
    3507 *               *(fpu + (long)FPU_TNV0) = fpval;
    3508 *
     3505
     3506|       else
     3507|               |(fpu + (long)FPU_TNV0) = fpval;
     3508
    35093509F05L169:        move    R_FPVAL,2(A_FPU)
    3510 *
    3511 *       ++octype;
    3512 *
     3510
     3511|       ++octype;
     3512
    35133513F05L170:        add     #1,OCTYPE(A6)
    3514 *
    3515 *       *(fpu + (long)FPU_TCTL) = fpctl;
    3516 *
     3514
     3515|       |(fpu + (long)FPU_TCTL) = fpctl;
     3516
    35173517                move    R_FPCTL,(A_FPU)
    3518 *
    3519 *       setipl(oldi);
    3520 *
     3518
     3519|       setipl(oldi);
     3520
    35213521                move    OLDI(A6),sr
    3522 *
    3523                 .page
    3524 * ------------------------------------------------------------------------------
    3525 * Start function 6 -- Ind 1
    3526 * ------------------------------------------------------------------------------
    3527 *
    3528 *    if (ip->idhfnc[2].idftmd & I_TM_KEY) {
    3529 *
     3522
     3523                .page
     3524| ------------------------------------------------------------------------------
     3525| Start function 6 -- Ind 1
     3526| ------------------------------------------------------------------------------
     3527
     3528|    if (ip->idhfnc[2].idftmd & I_TM_KEY) {
     3529
    35303530FN06:           move.l  IP(A6),A0
    35313531                move.b  165(A0),D0
    … …  
    35343534                btst    #0,D0
    35353535                bne     FN06A
    3536 *
     3536
    35373537                jmp     FN07
    3538 *
    3539 *       vp = (vce << 4) + 9;
    3540 *
     3538
     3539|       vp = (vce << 4) + 9;
     3540
    35413541FN06A:          move    VCE(A6),D0
    35423542                asl     #4,D0
    35433543                add.w   #9,D0
    35443544                move    D0,VP(A6)
    3545 *
    3546 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    3547 *
     3545
     3546|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     3547
    35483548                asl     #5,D0
    35493549                ext.l   D0
    35503550                move.l  D0,A_FPU
    3551                 add.l   #_io_fpu+$4000,A_FPU
    3552 *
    3553 *       fp = &ip->idhfnc[6];
    3554 *
     3551                add.l   #_io_fpu+0x4000,A_FPU
     3552
     3553|       fp = &ip->idhfnc[6];
     3554
    35553555                move.l  #72,A_FP
    35563556                add.l   IP(A6),A_FP
    35573557                add.l   #86,A_FP
    3558 *
    3559 *       pt = &ip->idhpnt[fp->idfpt1];
    3560 *
     3558
     3559|       pt = &ip->idhpnt[fp->idfpt1];
     3560
    35613561                clr.l   D0
    35623562                move.b  6(A_FP),D0
    … …  
    35683568                add.l   #242,D0
    35693569                move.l  D0,PT(A6)
    3570 *
    3571                 .page
    3572 *
    3573 *       srcnum = group | fp->idfsrc;
    3574 *
     3570
     3571                .page
     3572
     3573|       srcnum = group | fp->idfsrc;
     3574
    35753575                move.w  GROUP(A6),D0
    35763576                ext.l   D0
    … …  
    35793579                or      D1,D0
    35803580                move    D0,SRCNUM(A6)
    3581 *
    3582 *       vep = &valents[srcnum];
    3583 *
     3581
     3582|       vep = &valents[srcnum];
     3583
    35843584                add.l   D0,D0
    35853585                move.l  D0,D1
    … …  
    35883588                add.l   #_valents,D0
    35893589                move.l  D0,VEP(A6)
    3590 *
    3591 *       smp = vpsms[vp];
    3592 *
     3590
     3591|       smp = vpsms[vp];
     3592
    35933593                move    VP(A6),A0
    35943594                add.l   A0,A0
    … …  
    35963596                add.l   #_vpsms,A0
    35973597                move.l  (A0),A_SMP
    3598 *
    3599 *       if (srcnum NE smp->sm) {
    3600 *
     3598
     3599|       if (srcnum NE smp->sm) {
     3600
    36013601                clr     D0
    36023602                move    10(A_SMP),D0
    36033603                cmp     SRCNUM(A6),D0
    36043604                beq     F06L113
    3605 *
    3606 *               (smp->prv)->nxt = smp->nxt;
    3607 *
     3605
     3606|               (smp->prv)->nxt = smp->nxt;
     3607
    36083608                move.l  4(A_SMP),A0
    36093609                move.l  (A_SMP),(A0)
    3610 *
    3611 *               (smp->nxt)->prv = smp->prv;
    3612 *
     3610
     3611|               (smp->nxt)->prv = smp->prv;
     3612
    36133613                move.l  (A_SMP),A0
    36143614                move.l  4(A_SMP),4(A0)
    3615 *
    3616 *               smp->prv = (struct sment *)vep;
    3617 *
     3615
     3616|               smp->prv = (struct sment |)vep;
     3617
    36183618                move.l  VEP(A6),4(A_SMP)
    3619 *
    3620 *               smp->nxt = vep->nxt;
    3621 *
     3619
     3620|               smp->nxt = vep->nxt;
     3621
    36223622                move.l  VEP(A6),A0
    36233623                move.l  (A0),(A_SMP)
    3624 *
    3625 *               (vep->nxt)->prv = smp;
    3626 *
     3624
     3625|               (vep->nxt)->prv = smp;
     3626
    36273627                move.l  VEP(A6),A0
    36283628                move.l  (A0),A0
    36293629                move.l  A_SMP,4(A0)
    3630 *
    3631 *               vep->nxt = smp;
    3632 *
     3630
     3631|               vep->nxt = smp;
     3632
    36333633                move.l  VEP(A6),A0
    36343634                move.l  A_SMP,(A0)
    3635 *
    3636 *               smp->sm = srcnum;
    3637 *
     3635
     3636|               smp->sm = srcnum;
     3637
    36383638                move    SRCNUM(A6),10(A_SMP)
    3639 *
    3640 *       }
    3641 *
    3642 *       mltval = fp->idfmlt;
    3643 *
     3639
     3640|       }
     3641
     3642|       mltval = fp->idfmlt;
     3643
    36443644F06L113:        move    2(A_FP),MLTVAL(A6)
    3645 *
    3646                 .page
    3647 *
    3648 *       switch (fp->idfsrc) {
    3649 *
     3645
     3646                .page
     3647
     3648|       switch (fp->idfsrc) {
     3649
    36503650                move.b  4(A_FP),D0
    36513651                ext.w   d0
    36523652                cmp     #10,D0
    36533653                bhi     F06L122
    3654 *
     3654
    36553655                asl     #2,D0
    36563656                lea     F06L123,A0
    36573657                movea.l 0(A0,D0.W),A0
    36583658                jmp     (A0)
    3659 *
    3660 *       case SM_NONE:
    3661 *               mltval = 0;
    3662 *
     3659
     3660|       case SM_NONE:
     3661|               mltval = 0;
     3662
    36633663F06L116:        clr     MLTVAL(A6)
    3664 *
    3665 *               tsrcval = 0;
    3666 *
     3664
     3665|               tsrcval = 0;
     3666
    36673667                clr     TSRCVAL(A6)
    3668 *
    3669 *               break;
    3670 *
     3668
     3669|               break;
     3670
    36713671                bra     F06L114
    3672 *
    3673 *       case SM_RAND:
    3674 *               tsrcval = xgetran(mltval);
    3675 *
     3672
     3673|       case SM_RAND:
     3674|               tsrcval = xgetran(mltval);
     3675
    36763676F06L117:        move    MLTVAL(A6),(sp)
    36773677                jsr     _xgetran
    36783678                move    D0,TSRCVAL(A6)
    3679 *
    3680 *               break;
    3681 *
     3679
     3680|               break;
     3681
    36823682                bra     F06L114
    3683 *
    3684 *       case SM_PTCH:
    3685 *               tsrcval = pch;
    3686 *
     3683
     3684|       case SM_PTCH:
     3685|               tsrcval = pch;
     3686
    36873687F06L118:        move    PCH(A6),TSRCVAL(A6)
    3688 *
    3689 *               break;
    3690 *
     3688
     3689|               break;
     3690
    36913691                bra     F06L114
    3692 *
    3693                 .page
    3694 *
    3695 *       case SM_FREQ:
    3696 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    3697 *
     3692
     3693                .page
     3694
     3695|       case SM_FREQ:
     3696|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     3697
    36983698F06L119:        move    PCH(A6),D0
    36993699                asr     #7,D0
    … …  
    37033703                add.l   #_ptoftab,A0
    37043704                move    (A0),TSRCVAL(A6)
    3705 *
    3706 *               break;
    3707 *
     3705
     3706|               break;
     3707
    37083708                bra     F06L114
    3709 *
    3710 *       case SM_KVEL:
    3711 *               tsrcval = veltab[trg];
    3712 *
     3709
     3710|       case SM_KVEL:
     3711|               tsrcval = veltab[trg];
     3712
    37133713F06L120:        move    TRG(A6),A0
    37143714                add.l   A0,A0
    37153715                add.l   #_veltab,A0
    37163716                move    (A0),TSRCVAL(A6)
    3717 *
    3718 *               break;
    3719 *
     3717
     3718|               break;
     3719
    37203720                bra     F06L114
    3721 *
    3722 *       case SM_KPRS:
    3723 *               tsrcval = prstab[trg];
    3724 *
     3721
     3722|       case SM_KPRS:
     3723|               tsrcval = prstab[trg];
     3724
    37253725F06L121:        move    TRG(A6),A0
    37263726                add.l   A0,A0
    37273727                add.l   #_prstab,A0
    37283728                move    (A0),TSRCVAL(A6)
    3729 *
    3730 *               break;
    3731 *
     3729
     3730|               break;
     3731
    37323732                bra     F06L114
    3733 *
    3734 *       default:
    3735 *               tsrcval = vep->val;
    3736 *
     3733
     3734|       default:
     3735|               tsrcval = vep->val;
     3736
    37373737F06L122:        move.l  VEP(A6),A0
    37383738                move    8(A0),TSRCVAL(A6)
    3739 *
    3740 *       }
    3741 *
    3742                 .page
    3743 *
    3744 *               srcval = tsrcval;
    3745 *
     3739
     3740|       }
     3741
     3742                .page
     3743
     3744|               srcval = tsrcval;
     3745
    37463746F06L114:        move    TSRCVAL(A6),SRCVAL(A6)
    3747 *
    3748                 .page
    3749 *
    3750 *       if (pt->ipvsrc) {
    3751 *
     3747
     3748                .page
     3749
     3750|       if (pt->ipvsrc) {
     3751
    37523752F06L124:        move.l  PT(A6),A0
    37533753                tst.b   6(A0)
    37543754                beq     F06L136
    3755 *
    3756 *               switch (pt->ipvsrc) {
    3757 *
     3755
     3756|               switch (pt->ipvsrc) {
     3757
    37583758                move.l  PT(A6),A0
    37593759                move.b  6(A0),D0
    … …  
    37623762                cmp     #9,D0
    37633763                bhi     F06L144
    3764 *
     3764
    37653765                asl     #2,D0
    37663766                lea     F06L145,A0
    37673767                move.l  0(A0,D0.W),A0
    37683768                jmp     (A0)
    3769 *
    3770 *               case SM_RAND:
    3771 *                       ltmp = xgetran(pt_>ipvmlt);
    3772 *
     3769
     3770|               case SM_RAND:
     3771|                       ltmp = xgetran(pt_>ipvmlt);
     3772
    37733773F06L139:        move.l  PT(A6),A0
    37743774                move    4(A0),(sp)
    … …  
    37763776                ext.l   D0
    37773777                move.l  D0,LTMP(A6)
    3778 *
    3779 *                       break;
    3780 *
     3778
     3779|                       break;
     3780
    37813781                bra     F06L137
    3782 *
    3783 *               case SM_PTCH:
    3784 *                       ltmp = pch;
    3785 *
     3782
     3783|               case SM_PTCH:
     3784|                       ltmp = pch;
     3785
    37863786F06L140:        move    PCH(A6),A0
    37873787                move.l  A0,LTMP(A6)
    3788 *
    3789 *                       break;
    3790 *
     3788
     3789|                       break;
     3790
    37913791                bra     F06L137
    3792 *
    3793                 .page
    3794 *
    3795 *               case SM_FREQ:
    3796 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    3797 *
     3792
     3793                .page
     3794
     3795|               case SM_FREQ:
     3796|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     3797
    37983798F06L141:        move    PCH(A6),D0
    37993799                asr     #7,D0
    … …  
    38053805                ext.l   D0
    38063806                move.l  D0,LTMP(A6)
    3807 *
    3808 *                       break;
    3809 *
     3807
     3808|                       break;
     3809
    38103810                bra     F06L137
    3811 *
    3812 *               case SM_KVEL:
    3813 *                       ltmp = veltab[trg];
    3814 *
     3811
     3812|               case SM_KVEL:
     3813|                       ltmp = veltab[trg];
     3814
    38153815F06L142:        move    TRG(A6),A0
    38163816                add.l   A0,A0
    … …  
    38193819                ext.l   D0
    38203820                move.l  D0,LTMP(A6)
    3821 *
    3822 *                       break;
    3823 *
     3821
     3822|                       break;
     3823
    38243824                bra     F06L137
    3825 *
    3826                 .page
    3827 *
    3828 *               case SM_KPRS:
    3829 *                       ltmp = prstab[trg];
    3830 *
     3825
     3826                .page
     3827
     3828|               case SM_KPRS:
     3829|                       ltmp = prstab[trg];
     3830
    38313831F06L143:        move    TRG(A6),A0
    38323832                add.l   A0,A0
    … …  
    38353835                ext.l   D0
    38363836                move.l  D0,LTMP(A6)
    3837 *
    3838 *                       break;
    3839 *
     3837
     3838|                       break;
     3839
    38403840                bra     F06L137
    3841 *
    3842                 .page
    3843 *
    3844 *               default:
    3845 *                       ltmp = valents[group | pt->ipvsrc].val;
    3846 *
     3841
     3842                .page
     3843
     3844|               default:
     3845|                       ltmp = valents[group | pt->ipvsrc].val;
     3846
    38473847F06L144:        move.l  PT(A6),A0
    38483848                clr.l   D0
    … …  
    38583858                move    8(A0,A1.l),D0
    38593859                move.l  D0,LTMP(A6)
    3860 *
    3861 *               }
    3862 *
    3863 *
    3864                 .page
    3865 *
    3866 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    3867 *
     3860
     3861|               }
     3862
     3863
     3864                .page
     3865
     3866|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     3867
    38683868F06L137:        move.l  PT(A6),A0
    38693869                move.w  4(A0),D0
    … …  
    38733873                asr.l   D1,D0
    38743874                move.l  D0,LTMP(A6)
    3875 *
    3876 *               ltmp += (long)pt->ipval;
    3877 *
     3875
     3876|               ltmp += (long)pt->ipval;
     3877
    38783878                move.l  PT(A6),A0
    38793879                move    2(A0),D0
    38803880                ext.l   D0
    38813881                add.l   D0,LTMP(A6)
    3882 *
    3883 *               if (ltmp GT (long)VALMAX)
    3884 *                       ltmp = (long)VALMAX;
    3885 *
     3882
     3883|               if (ltmp GT (long)VALMAX)
     3884|                       ltmp = (long)VALMAX;
     3885
    38863886                cmp.l   #VALMAX,LTMP(A6)
    38873887                ble     F06L146
    3888 *
     3888
    38893889                move.l  #VALMAX,LTMP(A6)
    38903890                bra     F06L147
    3891 *
    3892 *               else if (ltmp LT (long)VALMIN)
    3893 *                       ltmp = (long)VALMIN;
    3894 *
     3891
     3892|               else if (ltmp LT (long)VALMIN)
     3893|                       ltmp = (long)VALMIN;
     3894
    38953895F06L146:        cmp.l   #VALMIN,LTMP(A6)
    38963896                bge     F06L147
    3897 *
     3897
    38983898                move.l  #VALMIN,LTMP(A6)
    3899 *
    3900 *               tfpval = (short)ltmp;
    3901 *
     3899
     3900|               tfpval = (short)ltmp;
     3901
    39023902F06L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    39033903                bra     F06L149
    3904 *
    3905 *       } else {
    3906 *
    3907 *               tfpval = pt->ipval;
    3908 *
     3904
     3905|       } else {
     3906
     3907|               tfpval = pt->ipval;
     3908
    39093909F06L136:        move.l  PT(A6),A0
    39103910                move    2(A0),TFPVAL(A6)
    3911 *
    3912 *       }
    3913 *
    3914                 .page
    3915 *
    3916 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    3917 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    3918 *
     3911
     3912|       }
     3913
     3914                .page
     3915
     3916|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     3917|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     3918
    39193919F06L149:        move.l  PT(A6),A0
    39203920                move.w  (A0),D0
    39213921                move.w  D0,D2
    3922                 andi.w  #$FFF0,D0
     3922                andi.w  #0xFFF0,D0
    39233923                move.w  _timemlt,D1
    39243924                muls    D1,D0
    … …  
    39263926                asr.l   D1,D0
    39273927                move    D0,R_FPMANT
    3928 *
    3929 *       fpexp = expbit[pt->iptim & 0x000F];
    3930 *
    3931                 and     #$000F,D2
     3928
     3929|       fpexp = expbit[pt->iptim & 0x000F];
     3930
     3931                and     #0x000F,D2
    39323932                move    D2,A0
    39333933                add.l   A0,A0
    39343934                add.l   #_expbit,A0
    39353935                move    (A0),R_FPEXP
    3936 *
    3937                 .page
    3938 *
    3939 *               fp->idfpch = pch;
    3940 *
     3936
     3937                .page
     3938
     3939|               fp->idfpch = pch;
     3940
    39413941F06L163:        move    PCH(A6),(A_FP)
    3942 *
    3943 *               fpval = tfpval;
    3944 *
     3942
     3943|               fpval = tfpval;
     3944
    39453945                move    TFPVAL(A6),R_FPVAL
    3946 *
    3947                 .page
    3948 *
     3946
     3947                .page
     3948
    39493949                move.b  5(A_FP),D0
    39503950                ext.w   D0
    39513951                sub.w   #1,D0
    39523952                movea.l PT(A6),A0
    3953 *
    3954 *       oldi = setipl(FPU_DI);
    3955 *
     3953
     3954|       oldi = setipl(FPU_DI);
     3955
    39563956                move    sr,OLDI(A6)
    39573957                move    #FPU_DI,sr
    3958 *
     3958
    39593959F06L168:        clr.b   10(A0)
    39603960                add.l   #12,a0
    39613961                dbra    D0,F06L168
    3962 *
    3963                 .page
    3964 *
    3965 *       fp->idftmd ^= I_NVBITS;
    3966 *
     3962
     3963                .page
     3964
     3965|       fp->idftmd ^= I_NVBITS;
     3966
    39673967F06L165:        eor.b   #24,7(A_FP)
    3968 *
    3969 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    3970 *
     3968
     3969|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     3970
    39713971                move.b  7(A_FP),R_FPCTL
    39723972                and     #28,R_FPCTL
    39733973                or      #3,R_FPCTL
    3974 *
    3975 *       fp->idfcpt = fp->idfpt1;
    3976 *
     3974
     3975|       fp->idfcpt = fp->idfpt1;
     3976
    39773977                move.b  6(A_FP),8(A_FP)
    3978 *
    3979 *       fp->idftmd |= I_ACTIVE;
    3980 *
     3978
     3979|       fp->idftmd |= I_ACTIVE;
     3980
    39813981                or.b    #2,7(A_FP)
    3982 *
    3983 *       fp->idftrf = trg;
    3984 *
     3982
     3983|       fp->idftrf = trg;
     3984
    39853985                move    TRG(A6),10(A_FP)
    3986 *
    3987 *       *(fpu + (long)FPU_TCV1) = srcval;
    3988 *
    3989                 move    SRCVAL(A6),$8(A_FPU)
    3990 *
    3991 *       ++octype;
    3992 *
     3986
     3987|       |(fpu + (long)FPU_TCV1) = srcval;
     3988
     3989                move    SRCVAL(A6),0x8(A_FPU)
     3990
     3991|       ++octype;
     3992
    39933993                add     #1,OCTYPE(A6)
    3994 *
    3995 *       *(fpu + (long)FPU_TSF1) = mltval;
    3996 *
    3997                 move    MLTVAL(A6),$A(A_FPU)
    3998 *
    3999 *       ++octype;
    4000 *
     3994
     3995|       |(fpu + (long)FPU_TSF1) = mltval;
     3996
     3997                move    MLTVAL(A6),0xA(A_FPU)
     3998
     3999|       ++octype;
     4000
    40014001                add     #1,OCTYPE(A6)
    4002 *
    4003 *       *(fpu + (long)FPU_TMNT) = fpmant;
    4004 *
    4005                 move    R_FPMANT,$14(A_FPU)
    4006 *
    4007 *       ++octype;
    4008 *
     4002
     4003|       |(fpu + (long)FPU_TMNT) = fpmant;
     4004
     4005                move    R_FPMANT,0x14(A_FPU)
     4006
     4007|       ++octype;
     4008
    40094009                add     #1,OCTYPE(A6)
    4010 *
    4011 *       *(fpu + (long)FPU_TEXP) = fpexp;
    4012 *
    4013                 move    R_FPEXP,$16(A_FPU)
    4014 *
    4015 *       ++octype;
    4016 *
     4010
     4011|       |(fpu + (long)FPU_TEXP) = fpexp;
     4012
     4013                move    R_FPEXP,0x16(A_FPU)
     4014
     4015|       ++octype;
     4016
    40174017                add     #1,OCTYPE(A6)
    4018 *
    4019                 .page
    4020 *
    4021 *       if (fp->idftmd & I_VNSUBN)
    4022 *
     4018
     4019                .page
     4020
     4021|       if (fp->idftmd & I_VNSUBN)
     4022
    40234023                btst    #3,7(A_FP)
    40244024                beq     F06L169
    4025 *
    4026 *               *(fpu + (long)FPU_TNV1) = fpval;
    4027 *
    4028                 move    R_FPVAL,$1C(A_FPU)
     4025
     4026|               |(fpu + (long)FPU_TNV1) = fpval;
     4027
     4028                move    R_FPVAL,0x1C(A_FPU)
    40294029                bra     F06L170
    4030 *
    4031 *       else
    4032 *               *(fpu + (long)FPU_TNV0) = fpval;
    4033 *
     4030
     4031|       else
     4032|               |(fpu + (long)FPU_TNV0) = fpval;
     4033
    40344034F06L169:        move    R_FPVAL,2(A_FPU)
    4035 *
    4036 *       ++octype;
    4037 *
     4035
     4036|       ++octype;
     4037
    40384038F06L170:        add     #1,OCTYPE(A6)
    4039 *
    4040 *       *(fpu + (long)FPU_TCTL) = fpctl;
    4041 *
     4039
     4040|       |(fpu + (long)FPU_TCTL) = fpctl;
     4041
    40424042                move    R_FPCTL,(A_FPU)
    4043 *
    4044 *       setipl(oldi);
    4045 *
     4043
     4044|       setipl(oldi);
     4045
    40464046                move    OLDI(A6),sr
    4047 *
    4048                 .page
    4049 * ------------------------------------------------------------------------------
    4050 * Start function 7 -- Ind 2
    4051 * ------------------------------------------------------------------------------
    4052 *
    4053 *    if (ip->idhfnc[7].idftmd & I_TM_KEY) {
    4054 *
     4047
     4048                .page
     4049| ------------------------------------------------------------------------------
     4050| Start function 7 -- Ind 2
     4051| ------------------------------------------------------------------------------
     4052
     4053|    if (ip->idhfnc[7].idftmd & I_TM_KEY) {
     4054
    40554055FN07:           move.l  IP(A6),A0
    40564056                move.b  177(A0),D0
    … …  
    40594059                btst    #0,D0
    40604060                bne     FN07A
    4061 *
     4061
    40624062                jmp     FN08
    4063 *
    4064 *       vp = (vce << 4) + 11;
    4065 *
     4063
     4064|       vp = (vce << 4) + 11;
     4065
    40664066FN07A:          move    VCE(A6),D0
    40674067                asl     #4,D0
    40684068                add.w   #11,D0
    40694069                move    D0,VP(A6)
    4070 *
    4071 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    4072 *
     4070
     4071|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     4072
    40734073                asl     #5,D0
    40744074                ext.l   D0
    40754075                move.l  D0,A_FPU
    4076                 add.l   #_io_fpu+$4000,A_FPU
    4077 *
    4078 *       fp = &ip->idhfnc[7];
    4079 *
     4076                add.l   #_io_fpu+0x4000,A_FPU
     4077
     4078|       fp = &ip->idhfnc[7];
     4079
    40804080                move.l  #84,A_FP
    40814081                add.l   IP(A6),A_FP
    40824082                add.l   #86,A_FP
    4083 *
    4084 *       pt = &ip->idhpnt[fp->idfpt1];
    4085 *
     4083
     4084|       pt = &ip->idhpnt[fp->idfpt1];
     4085
    40864086                clr.l   D0
    40874087                move.b  6(A_FP),D0
    … …  
    40934093                add.l   #242,D0
    40944094                move.l  D0,PT(A6)
    4095 *
    4096                 .page
    4097 *
    4098 *       srcnum = group | fp->idfsrc;
    4099 *
     4095
     4096                .page
     4097
     4098|       srcnum = group | fp->idfsrc;
     4099
    41004100                move.w  GROUP(A6),D0
    41014101                ext.l   D0
    … …  
    41044104                or      D1,D0
    41054105                move    D0,SRCNUM(A6)
    4106 *
    4107 *       vep = &valents[srcnum];
    4108 *
     4106
     4107|       vep = &valents[srcnum];
     4108
    41094109                add.l   D0,D0
    41104110                move.l  D0,D1
    … …  
    41134113                add.l   #_valents,D0
    41144114                move.l  D0,VEP(A6)
    4115 *
    4116 *       smp = vpsms[vp];
    4117 *
     4115
     4116|       smp = vpsms[vp];
     4117
    41184118                move    VP(A6),A0
    41194119                add.l   A0,A0
    … …  
    41214121                add.l   #_vpsms,A0
    41224122                move.l  (A0),A_SMP
    4123 *
    4124 *       if (srcnum NE smp->sm) {
    4125 *
     4123
     4124|       if (srcnum NE smp->sm) {
     4125
    41264126                clr     D0
    41274127                move    10(A_SMP),D0
    41284128                cmp     SRCNUM(A6),D0
    41294129                beq     F07L113
    4130 *
    4131 *               (smp->prv)->nxt = smp->nxt;
    4132 *
     4130
     4131|               (smp->prv)->nxt = smp->nxt;
     4132
    41334133                move.l  4(A_SMP),A0
    41344134                move.l  (A_SMP),(A0)
    4135 *
    4136 *               (smp->nxt)->prv = smp->prv;
    4137 *
     4135
     4136|               (smp->nxt)->prv = smp->prv;
     4137
    41384138                move.l  (A_SMP),A0
    41394139                move.l  4(A_SMP),4(A0)
    4140 *
    4141 *               smp->prv = (struct sment *)vep;
    4142 *
     4140
     4141|               smp->prv = (struct sment |)vep;
     4142
    41434143                move.l  VEP(A6),4(A_SMP)
    4144 *
    4145 *               smp->nxt = vep->nxt;
    4146 *
     4144
     4145|               smp->nxt = vep->nxt;
     4146
    41474147                move.l  VEP(A6),A0
    41484148                move.l  (A0),(A_SMP)
    4149 *
    4150 *               (vep->nxt)->prv = smp;
    4151 *
     4149
     4150|               (vep->nxt)->prv = smp;
     4151
    41524152                move.l  VEP(A6),A0
    41534153                move.l  (A0),A0
    41544154                move.l  A_SMP,4(A0)
    4155 *
    4156 *               vep->nxt = smp;
    4157 *
     4155
     4156|               vep->nxt = smp;
     4157
    41584158                move.l  VEP(A6),A0
    41594159                move.l  A_SMP,(A0)
    4160 *
    4161 *               smp->sm = srcnum;
    4162 *
     4160
     4161|               smp->sm = srcnum;
     4162
    41634163                move    SRCNUM(A6),10(A_SMP)
    4164 *
    4165 *       }
    4166 *
    4167 *       mltval = fp->idfmlt;
    4168 *
     4164
     4165|       }
     4166
     4167|       mltval = fp->idfmlt;
     4168
    41694169F07L113:        move    2(A_FP),MLTVAL(A6)
    4170 *
    4171                 .page
    4172 *
    4173 *       switch (fp->idfsrc) {
    4174 *
     4170
     4171                .page
     4172
     4173|       switch (fp->idfsrc) {
     4174
    41754175                move.b  4(A_FP),D0
    41764176                ext.w   d0
    41774177                cmp     #10,D0
    41784178                bhi     F07L122
    4179 *
     4179
    41804180                asl     #2,D0
    41814181                lea     F07L123,A0
    41824182                movea.l 0(A0,D0.W),A0
    41834183                jmp     (A0)
    4184 *
    4185 *       case SM_NONE:
    4186 *               mltval = 0;
    4187 *
     4184
     4185|       case SM_NONE:
     4186|               mltval = 0;
     4187
    41884188F07L116:        clr     MLTVAL(A6)
    4189 *
    4190 *               tsrcval = 0;
    4191 *
     4189
     4190|               tsrcval = 0;
     4191
    41924192                clr     TSRCVAL(A6)
    4193 *
    4194 *               break;
    4195 *
     4193
     4194|               break;
     4195
    41964196                bra     F07L114
    4197 *
    4198 *       case SM_RAND:
    4199 *               tsrcval = xgetran(mltval);
    4200 *
     4197
     4198|       case SM_RAND:
     4199|               tsrcval = xgetran(mltval);
     4200
    42014201F07L117:        move    MLTVAL(A6),(sp)
    42024202                jsr     _xgetran
    42034203                move    D0,TSRCVAL(A6)
    4204 *
    4205 *               break;
    4206 *
     4204
     4205|               break;
     4206
    42074207                bra     F07L114
    4208 *
    4209 *       case SM_PTCH:
    4210 *               tsrcval = pch;
    4211 *
     4208
     4209|       case SM_PTCH:
     4210|               tsrcval = pch;
     4211
    42124212F07L118:        move    PCH(A6),TSRCVAL(A6)
    4213 *
    4214 *               break;
    4215 *
     4213
     4214|               break;
     4215
    42164216                bra     F07L114
    4217 *
    4218                 .page
    4219 *
    4220 *       case SM_FREQ:
    4221 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    4222 *
     4217
     4218                .page
     4219
     4220|       case SM_FREQ:
     4221|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     4222
    42234223F07L119:        move    PCH(A6),D0
    42244224                asr     #7,D0
    … …  
    42284228                add.l   #_ptoftab,A0
    42294229                move    (A0),TSRCVAL(A6)
    4230 *
    4231 *               break;
    4232 *
     4230
     4231|               break;
     4232
    42334233                bra     F07L114
    4234 *
    4235 *       case SM_KVEL:
    4236 *               tsrcval = veltab[trg];
    4237 *
     4234
     4235|       case SM_KVEL:
     4236|               tsrcval = veltab[trg];
     4237
    42384238F07L120:        move    TRG(A6),A0
    42394239                add.l   A0,A0
    42404240                add.l   #_veltab,A0
    42414241                move    (A0),TSRCVAL(A6)
    4242 *
    4243 *               break;
    4244 *
     4242
     4243|               break;
     4244
    42454245                bra     F07L114
    4246 *
    4247 *       case SM_KPRS:
    4248 *               tsrcval = prstab[trg];
    4249 *
     4246
     4247|       case SM_KPRS:
     4248|               tsrcval = prstab[trg];
     4249
    42504250F07L121:        move    TRG(A6),A0
    42514251                add.l   A0,A0
    42524252                add.l   #_prstab,A0
    42534253                move    (A0),TSRCVAL(A6)
    4254 *
    4255 *               break;
    4256 *
     4254
     4255|               break;
     4256
    42574257                bra     F07L114
    4258 *
    4259 *       default:
    4260 *               tsrcval = vep->val;
    4261 *
     4258
     4259|       default:
     4260|               tsrcval = vep->val;
     4261
    42624262F07L122:        move.l  VEP(A6),A0
    42634263                move    8(A0),TSRCVAL(A6)
    4264 *
    4265 *       }
    4266 *
    4267                 .page
    4268 *
    4269 *               srcval = tsrcval;
    4270 *
     4264
     4265|       }
     4266
     4267                .page
     4268
     4269|               srcval = tsrcval;
     4270
    42714271F07L114:        move    TSRCVAL(A6),SRCVAL(A6)
    4272 *
    4273                 .page
    4274 *
    4275 *       if (pt->ipvsrc) {
    4276 *
     4272
     4273                .page
     4274
     4275|       if (pt->ipvsrc) {
     4276
    42774277F07L124:        move.l  PT(A6),A0
    42784278                tst.b   6(A0)
    42794279                beq     F07L136
    4280 *
    4281 *               switch (pt->ipvsrc) {
    4282 *
     4280
     4281|               switch (pt->ipvsrc) {
     4282
    42834283                move.l  PT(A6),A0
    42844284                move.b  6(A0),D0
    … …  
    42874287                cmp     #9,D0
    42884288                bhi     F07L144
    4289 *
     4289
    42904290                asl     #2,D0
    42914291                lea     F07L145,A0
    42924292                move.l  0(A0,D0.W),A0
    42934293                jmp     (A0)
    4294 *
    4295 *               case SM_RAND:
    4296 *                       ltmp = xgetran(pt_>ipvmlt);
    4297 *
     4294
     4295|               case SM_RAND:
     4296|                       ltmp = xgetran(pt_>ipvmlt);
     4297
    42984298F07L139:        move.l  PT(A6),A0
    42994299                move    4(A0),(sp)
    … …  
    43014301                ext.l   D0
    43024302                move.l  D0,LTMP(A6)
    4303 *
    4304 *                       break;
    4305 *
     4303
     4304|                       break;
     4305
    43064306                bra     F07L137
    4307 *
    4308 *               case SM_PTCH:
    4309 *                       ltmp = pch;
    4310 *
     4307
     4308|               case SM_PTCH:
     4309|                       ltmp = pch;
     4310
    43114311F07L140:        move    PCH(A6),A0
    43124312                move.l  A0,LTMP(A6)
    4313 *
    4314 *                       break;
    4315 *
     4313
     4314|                       break;
     4315
    43164316                bra     F07L137
    4317 *
    4318                 .page
    4319 *
    4320 *               case SM_FREQ:
    4321 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    4322 *
     4317
     4318                .page
     4319
     4320|               case SM_FREQ:
     4321|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     4322
    43234323F07L141:        move    PCH(A6),D0
    43244324                asr     #7,D0
    … …  
    43304330                ext.l   D0
    43314331                move.l  D0,LTMP(A6)
    4332 *
    4333 *                       break;
    4334 *
     4332
     4333|                       break;
     4334
    43354335                bra     F07L137
    4336 *
    4337 *               case SM_KVEL:
    4338 *                       ltmp = veltab[trg];
    4339 *
     4336
     4337|               case SM_KVEL:
     4338|                       ltmp = veltab[trg];
     4339
    43404340F07L142:        move    TRG(A6),A0
    43414341                add.l   A0,A0
    … …  
    43444344                ext.l   D0
    43454345                move.l  D0,LTMP(A6)
    4346 *
    4347 *                       break;
    4348 *
     4346
     4347|                       break;
     4348
    43494349                bra     F07L137
    4350 *
    4351                 .page
    4352 *
    4353 *               case SM_KPRS:
    4354 *                       ltmp = prstab[trg];
    4355 *
     4350
     4351                .page
     4352
     4353|               case SM_KPRS:
     4354|                       ltmp = prstab[trg];
     4355
    43564356F07L143:        move    TRG(A6),A0
    43574357                add.l   A0,A0
    … …  
    43604360                ext.l   D0
    43614361                move.l  D0,LTMP(A6)
    4362 *
    4363 *                       break;
    4364 *
     4362
     4363|                       break;
     4364
    43654365                bra     F07L137
    4366 *
    4367                 .page
    4368 *
    4369 *               default:
    4370 *                       ltmp = valents[group | pt->ipvsrc].val;
    4371 *
     4366
     4367                .page
     4368
     4369|               default:
     4370|                       ltmp = valents[group | pt->ipvsrc].val;
     4371
    43724372F07L144:        move.l  PT(A6),A0
    43734373                clr.l   D0
    … …  
    43834383                move    8(A0,A1.l),D0
    43844384                move.l  D0,LTMP(A6)
    4385 *
    4386 *               }
    4387 *
    4388 *
    4389                 .page
    4390 *
    4391 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    4392 *
     4385
     4386|               }
     4387
     4388
     4389                .page
     4390
     4391|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     4392
    43934393F07L137:        move.l  PT(A6),A0
    43944394                move.w  4(A0),D0
    … …  
    43984398                asr.l   D1,D0
    43994399                move.l  D0,LTMP(A6)
    4400 *
    4401 *               ltmp += (long)pt->ipval;
    4402 *
     4400
     4401|               ltmp += (long)pt->ipval;
     4402
    44034403                move.l  PT(A6),A0
    44044404                move    2(A0),D0
    44054405                ext.l   D0
    44064406                add.l   D0,LTMP(A6)
    4407 *
    4408 *               if (ltmp GT (long)VALMAX)
    4409 *                       ltmp = (long)VALMAX;
    4410 *
     4407
     4408|               if (ltmp GT (long)VALMAX)
     4409|                       ltmp = (long)VALMAX;
     4410
    44114411                cmp.l   #VALMAX,LTMP(A6)
    44124412                ble     F07L146
    4413 *
     4413
    44144414                move.l  #VALMAX,LTMP(A6)
    44154415                bra     F07L147
    4416 *
    4417 *               else if (ltmp LT (long)VALMIN)
    4418 *                       ltmp = (long)VALMIN;
    4419 *
     4416
     4417|               else if (ltmp LT (long)VALMIN)
     4418|                       ltmp = (long)VALMIN;
     4419
    44204420F07L146:        cmp.l   #VALMIN,LTMP(A6)
    44214421                bge     F07L147
    4422 *
     4422
    44234423                move.l  #VALMIN,LTMP(A6)
    4424 *
    4425 *               tfpval = (short)ltmp;
    4426 *
     4424
     4425|               tfpval = (short)ltmp;
     4426
    44274427F07L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    44284428                bra     F07L149
    4429 *
    4430 *       } else {
    4431 *
    4432 *               tfpval = pt->ipval;
    4433 *
     4429
     4430|       } else {
     4431
     4432|               tfpval = pt->ipval;
     4433
    44344434F07L136:        move.l  PT(A6),A0
    44354435                move    2(A0),TFPVAL(A6)
    4436 *
    4437 *       }
    4438 *
    4439                 .page
    4440 *
    4441 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    4442 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    4443 *
     4436
     4437|       }
     4438
     4439                .page
     4440
     4441|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     4442|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     4443
    44444444F07L149:        move.l  PT(A6),A0
    44454445                move.w  (A0),D0
    44464446                move.w  D0,D2
    4447                 andi.w  #$FFF0,D0
     4447                andi.w  #0xFFF0,D0
    44484448                move.w  _timemlt,D1
    44494449                muls    D1,D0
    … …  
    44514451                asr.l   D1,D0
    44524452                move    D0,R_FPMANT
    4453 *
    4454 *       fpexp = expbit[pt->iptim & 0x000F];
    4455 *
    4456                 and     #$000F,D2
     4453
     4454|       fpexp = expbit[pt->iptim & 0x000F];
     4455
     4456                and     #0x000F,D2
    44574457                move    D2,A0
    44584458                add.l   A0,A0
    44594459                add.l   #_expbit,A0
    44604460                move    (A0),R_FPEXP
    4461 *
    4462                 .page
    4463 *
    4464 *               fp->idfpch = pch;
    4465 *
     4461
     4462                .page
     4463
     4464|               fp->idfpch = pch;
     4465
    44664466F07L163:        move    PCH(A6),(A_FP)
    4467 *
    4468 *               fpval = tfpval;
    4469 *
     4467
     4468|               fpval = tfpval;
     4469
    44704470                move    TFPVAL(A6),R_FPVAL
    4471 *
    4472                 .page
    4473 *
     4471
     4472                .page
     4473
    44744474                move.b  5(A_FP),D0
    44754475                ext.w   D0
    44764476                sub.w   #1,D0
    44774477                movea.l PT(A6),A0
    4478 *
    4479 *       oldi = setipl(FPU_DI);
    4480 *
     4478
     4479|       oldi = setipl(FPU_DI);
     4480
    44814481                move    sr,OLDI(A6)
    44824482                move    #FPU_DI,sr
    4483 *
     4483
    44844484F07L168:        clr.b   10(A0)
    44854485                add.l   #12,a0
    44864486                dbra    D0,F07L168
    4487 *
    4488                 .page
    4489 *
    4490 *       fp->idftmd ^= I_NVBITS;
    4491 *
     4487
     4488                .page
     4489
     4490|       fp->idftmd ^= I_NVBITS;
     4491
    44924492F07L165:        eor.b   #24,7(A_FP)
    4493 *
    4494 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    4495 *
     4493
     4494|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     4495
    44964496                move.b  7(A_FP),R_FPCTL
    44974497                and     #28,R_FPCTL
    44984498                or      #3,R_FPCTL
    4499 *
    4500 *       fp->idfcpt = fp->idfpt1;
    4501 *
     4499
     4500|       fp->idfcpt = fp->idfpt1;
     4501
    45024502                move.b  6(A_FP),8(A_FP)
    4503 *
    4504 *       fp->idftmd |= I_ACTIVE;
    4505 *
     4503
     4504|       fp->idftmd |= I_ACTIVE;
     4505
    45064506                or.b    #2,7(A_FP)
    4507 *
    4508 *       fp->idftrf = trg;
    4509 *
     4507
     4508|       fp->idftrf = trg;
     4509
    45104510                move    TRG(A6),10(A_FP)
    4511 *
    4512 *       *(fpu + (long)FPU_TCV1) = srcval;
    4513 *
    4514                 move    SRCVAL(A6),$8(A_FPU)
    4515 *
    4516 *       ++octype;
    4517 *
     4511
     4512|       |(fpu + (long)FPU_TCV1) = srcval;
     4513
     4514                move    SRCVAL(A6),0x8(A_FPU)
     4515
     4516|       ++octype;
     4517
    45184518                add     #1,OCTYPE(A6)
    4519 *
    4520 *       *(fpu + (long)FPU_TSF1) = mltval;
    4521 *
    4522                 move    MLTVAL(A6),$A(A_FPU)
    4523 *
    4524 *       ++octype;
    4525 *
     4519
     4520|       |(fpu + (long)FPU_TSF1) = mltval;
     4521
     4522                move    MLTVAL(A6),0xA(A_FPU)
     4523
     4524|       ++octype;
     4525
    45264526                add     #1,OCTYPE(A6)
    4527 *
    4528 *       *(fpu + (long)FPU_TMNT) = fpmant;
    4529 *
    4530                 move    R_FPMANT,$14(A_FPU)
    4531 *
    4532 *       ++octype;
    4533 *
     4527
     4528|       |(fpu + (long)FPU_TMNT) = fpmant;
     4529
     4530                move    R_FPMANT,0x14(A_FPU)
     4531
     4532|       ++octype;
     4533
    45344534                add     #1,OCTYPE(A6)
    4535 *
    4536 *       *(fpu + (long)FPU_TEXP) = fpexp;
    4537 *
    4538                 move    R_FPEXP,$16(A_FPU)
    4539 *
    4540 *       ++octype;
    4541 *
     4535
     4536|       |(fpu + (long)FPU_TEXP) = fpexp;
     4537
     4538                move    R_FPEXP,0x16(A_FPU)
     4539
     4540|       ++octype;
     4541
    45424542                add     #1,OCTYPE(A6)
    4543 *
    4544                 .page
    4545 *
    4546 *       if (fp->idftmd & I_VNSUBN)
    4547 *
     4543
     4544                .page
     4545
     4546|       if (fp->idftmd & I_VNSUBN)
     4547
    45484548                btst    #3,7(A_FP)
    45494549                beq     F07L169
    4550 *
    4551 *               *(fpu + (long)FPU_TNV1) = fpval;
    4552 *
    4553                 move    R_FPVAL,$1C(A_FPU)
     4550
     4551|               |(fpu + (long)FPU_TNV1) = fpval;
     4552
     4553                move    R_FPVAL,0x1C(A_FPU)
    45544554                bra     F07L170
    4555 *
    4556 *       else
    4557 *               *(fpu + (long)FPU_TNV0) = fpval;
    4558 *
     4555
     4556|       else
     4557|               |(fpu + (long)FPU_TNV0) = fpval;
     4558
    45594559F07L169:        move    R_FPVAL,2(A_FPU)
    4560 *
    4561 *       ++octype;
    4562 *
     4560
     4561|       ++octype;
     4562
    45634563F07L170:        add     #1,OCTYPE(A6)
    4564 *
    4565 *       *(fpu + (long)FPU_TCTL) = fpctl;
    4566 *
     4564
     4565|       |(fpu + (long)FPU_TCTL) = fpctl;
     4566
    45674567                move    R_FPCTL,(A_FPU)
    4568 *
    4569 *       setipl(oldi);
    4570 *
     4568
     4569|       setipl(oldi);
     4570
    45714571                move    OLDI(A6),sr
    4572 *
    4573                 .page
    4574 * ------------------------------------------------------------------------------
    4575 * Start function 8 -- Ind 3
    4576 * ------------------------------------------------------------------------------
    4577 *
    4578 *    if (ip->idhfnc[8].idftmd & I_TM_KEY) {
    4579 *
     4572
     4573                .page
     4574| ------------------------------------------------------------------------------
     4575| Start function 8 -- Ind 3
     4576| ------------------------------------------------------------------------------
     4577
     4578|    if (ip->idhfnc[8].idftmd & I_TM_KEY) {
     4579
    45804580FN08:           move.l  IP(A6),A0
    45814581                move.b  189(A0),D0
    … …  
    45844584                btst    #0,D0
    45854585                bne     FN08A
    4586 *
     4586
    45874587                jmp     FN09
    4588 *
    4589 *       vp = (vce << 4) + 12;
    4590 *
     4588
     4589|       vp = (vce << 4) + 12;
     4590
    45914591FN08A:          move    VCE(A6),D0
    45924592                asl     #4,D0
    45934593                add.w   #12,D0
    45944594                move    D0,VP(A6)
    4595 *
    4596 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    4597 *
     4595
     4596|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     4597
    45984598                asl     #5,D0
    45994599                ext.l   D0
    46004600                move.l  D0,A_FPU
    4601                 add.l   #_io_fpu+$4000,A_FPU
    4602 *
    4603 *       fp = &ip->idhfnc[8];
    4604 *
     4601                add.l   #_io_fpu+0x4000,A_FPU
     4602
     4603|       fp = &ip->idhfnc[8];
     4604
    46054605                move.l  #96,A_FP
    46064606                add.l   IP(A6),A_FP
    46074607                add.l   #86,A_FP
    4608 *
    4609 *       pt = &ip->idhpnt[fp->idfpt1];
    4610 *
     4608
     4609|       pt = &ip->idhpnt[fp->idfpt1];
     4610
    46114611                clr.l   D0
    46124612                move.b  6(A_FP),D0
    … …  
    46184618                add.l   #242,D0
    46194619                move.l  D0,PT(A6)
    4620 *
    4621                 .page
    4622 *
    4623 *       srcnum = group | fp->idfsrc;
    4624 *
     4620
     4621                .page
     4622
     4623|       srcnum = group | fp->idfsrc;
     4624
    46254625                move.w  GROUP(A6),D0
    46264626                ext.l   D0
    … …  
    46294629                or      D1,D0
    46304630                move    D0,SRCNUM(A6)
    4631 *
    4632 *       vep = &valents[srcnum];
    4633 *
     4631
     4632|       vep = &valents[srcnum];
     4633
    46344634                add.l   D0,D0
    46354635                move.l  D0,D1
    … …  
    46384638                add.l   #_valents,D0
    46394639                move.l  D0,VEP(A6)
    4640 *
    4641 *       smp = vpsms[vp];
    4642 *
     4640
     4641|       smp = vpsms[vp];
     4642
    46434643                move    VP(A6),A0
    46444644                add.l   A0,A0
    … …  
    46464646                add.l   #_vpsms,A0
    46474647                move.l  (A0),A_SMP
    4648 *
    4649 *       if (srcnum NE smp->sm) {
    4650 *
     4648
     4649|       if (srcnum NE smp->sm) {
     4650
    46514651                clr     D0
    46524652                move    10(A_SMP),D0
    46534653                cmp     SRCNUM(A6),D0
    46544654                beq     F08L113
    4655 *
    4656 *               (smp->prv)->nxt = smp->nxt;
    4657 *
     4655
     4656|               (smp->prv)->nxt = smp->nxt;
     4657
    46584658                move.l  4(A_SMP),A0
    46594659                move.l  (A_SMP),(A0)
    4660 *
    4661 *               (smp->nxt)->prv = smp->prv;
    4662 *
     4660
     4661|               (smp->nxt)->prv = smp->prv;
     4662
    46634663                move.l  (A_SMP),A0
    46644664                move.l  4(A_SMP),4(A0)
    4665 *
    4666 *               smp->prv = (struct sment *)vep;
    4667 *
     4665
     4666|               smp->prv = (struct sment |)vep;
     4667
    46684668                move.l  VEP(A6),4(A_SMP)
    4669 *
    4670 *               smp->nxt = vep->nxt;
    4671 *
     4669
     4670|               smp->nxt = vep->nxt;
     4671
    46724672                move.l  VEP(A6),A0
    46734673                move.l  (A0),(A_SMP)
    4674 *
    4675 *               (vep->nxt)->prv = smp;
    4676 *
     4674
     4675|               (vep->nxt)->prv = smp;
     4676
    46774677                move.l  VEP(A6),A0
    46784678                move.l  (A0),A0
    46794679                move.l  A_SMP,4(A0)
    4680 *
    4681 *               vep->nxt = smp;
    4682 *
     4680
     4681|               vep->nxt = smp;
     4682
    46834683                move.l  VEP(A6),A0
    46844684                move.l  A_SMP,(A0)
    4685 *
    4686 *               smp->sm = srcnum;
    4687 *
     4685
     4686|               smp->sm = srcnum;
     4687
    46884688                move    SRCNUM(A6),10(A_SMP)
    4689 *
    4690 *       }
    4691 *
    4692 *       mltval = fp->idfmlt;
    4693 *
     4689
     4690|       }
     4691
     4692|       mltval = fp->idfmlt;
     4693
    46944694F08L113:        move    2(A_FP),MLTVAL(A6)
    4695 *
    4696                 .page
    4697 *
    4698 *       switch (fp->idfsrc) {
    4699 *
     4695
     4696                .page
     4697
     4698|       switch (fp->idfsrc) {
     4699
    47004700                move.b  4(A_FP),D0
    47014701                ext.w   d0
    47024702                cmp     #10,D0
    47034703                bhi     F08L122
    4704 *
     4704
    47054705                asl     #2,D0
    47064706                lea     F08L123,A0
    47074707                movea.l 0(A0,D0.W),A0
    47084708                jmp     (A0)
    4709 *
    4710 *       case SM_NONE:
    4711 *               mltval = 0;
    4712 *
     4709
     4710|       case SM_NONE:
     4711|               mltval = 0;
     4712
    47134713F08L116:        clr     MLTVAL(A6)
    4714 *
    4715 *               tsrcval = 0;
    4716 *
     4714
     4715|               tsrcval = 0;
     4716
    47174717                clr     TSRCVAL(A6)
    4718 *
    4719 *               break;
    4720 *
     4718
     4719|               break;
     4720
    47214721                bra     F08L114
    4722 *
    4723 *       case SM_RAND:
    4724 *               tsrcval = xgetran(mltval);
    4725 *
     4722
     4723|       case SM_RAND:
     4724|               tsrcval = xgetran(mltval);
     4725
    47264726F08L117:        move    MLTVAL(A6),(sp)
    47274727                jsr     _xgetran
    47284728                move    D0,TSRCVAL(A6)
    4729 *
    4730 *               break;
    4731 *
     4729
     4730|               break;
     4731
    47324732                bra     F08L114
    4733 *
    4734 *       case SM_PTCH:
    4735 *               tsrcval = pch;
    4736 *
     4733
     4734|       case SM_PTCH:
     4735|               tsrcval = pch;
     4736
    47374737F08L118:        move    PCH(A6),TSRCVAL(A6)
    4738 *
    4739 *               break;
    4740 *
     4738
     4739|               break;
     4740
    47414741                bra     F08L114
    4742 *
    4743                 .page
    4744 *
    4745 *       case SM_FREQ:
    4746 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    4747 *
     4742
     4743                .page
     4744
     4745|       case SM_FREQ:
     4746|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     4747
    47484748F08L119:        move    PCH(A6),D0
    47494749                asr     #7,D0
    … …  
    47534753                add.l   #_ptoftab,A0
    47544754                move    (A0),TSRCVAL(A6)
    4755 *
    4756 *               break;
    4757 *
     4755
     4756|               break;
     4757
    47584758                bra     F08L114
    4759 *
    4760 *       case SM_KVEL:
    4761 *               tsrcval = veltab[trg];
    4762 *
     4759
     4760|       case SM_KVEL:
     4761|               tsrcval = veltab[trg];
     4762
    47634763F08L120:        move    TRG(A6),A0
    47644764                add.l   A0,A0
    47654765                add.l   #_veltab,A0
    47664766                move    (A0),TSRCVAL(A6)
    4767 *
    4768 *               break;
    4769 *
     4767
     4768|               break;
     4769
    47704770                bra     F08L114
    4771 *
    4772 *       case SM_KPRS:
    4773 *               tsrcval = prstab[trg];
    4774 *
     4771
     4772|       case SM_KPRS:
     4773|               tsrcval = prstab[trg];
     4774
    47754775F08L121:        move    TRG(A6),A0
    47764776                add.l   A0,A0
    47774777                add.l   #_prstab,A0
    47784778                move    (A0),TSRCVAL(A6)
    4779 *
    4780 *               break;
    4781 *
     4779
     4780|               break;
     4781
    47824782                bra     F08L114
    4783 *
    4784 *       default:
    4785 *               tsrcval = vep->val;
    4786 *
     4783
     4784|       default:
     4785|               tsrcval = vep->val;
     4786
    47874787F08L122:        move.l  VEP(A6),A0
    47884788                move    8(A0),TSRCVAL(A6)
    4789 *
    4790 *       }
    4791 *
    4792                 .page
    4793 *
    4794 *               srcval = tsrcval;
    4795 *
     4789
     4790|       }
     4791
     4792                .page
     4793
     4794|               srcval = tsrcval;
     4795
    47964796F08L114:        move    TSRCVAL(A6),SRCVAL(A6)
    4797 *
    4798                 .page
    4799 *
    4800 *       if (pt->ipvsrc) {
    4801 *
     4797
     4798                .page
     4799
     4800|       if (pt->ipvsrc) {
     4801
    48024802F08L124:        move.l  PT(A6),A0
    48034803                tst.b   6(A0)
    48044804                beq     F08L136
    4805 *
    4806 *               switch (pt->ipvsrc) {
    4807 *
     4805
     4806|               switch (pt->ipvsrc) {
     4807
    48084808                move.l  PT(A6),A0
    48094809                move.b  6(A0),D0
    … …  
    48124812                cmp     #9,D0
    48134813                bhi     F08L144
    4814 *
     4814
    48154815                asl     #2,D0
    48164816                lea     F08L145,A0
    48174817                move.l  0(A0,D0.W),A0
    48184818                jmp     (A0)
    4819 *
    4820 *               case SM_RAND:
    4821 *                       ltmp = xgetran(pt_>ipvmlt);
    4822 *
     4819
     4820|               case SM_RAND:
     4821|                       ltmp = xgetran(pt_>ipvmlt);
     4822
    48234823F08L139:        move.l  PT(A6),A0
    48244824                move    4(A0),(sp)
    … …  
    48264826                ext.l   D0
    48274827                move.l  D0,LTMP(A6)
    4828 *
    4829 *                       break;
    4830 *
     4828
     4829|                       break;
     4830
    48314831                bra     F08L137
    4832 *
    4833 *               case SM_PTCH:
    4834 *                       ltmp = pch;
    4835 *
     4832
     4833|               case SM_PTCH:
     4834|                       ltmp = pch;
     4835
    48364836F08L140:        move    PCH(A6),A0
    48374837                move.l  A0,LTMP(A6)
    4838 *
    4839 *                       break;
    4840 *
     4838
     4839|                       break;
     4840
    48414841                bra     F08L137
    4842 *
    4843                 .page
    4844 *
    4845 *               case SM_FREQ:
    4846 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    4847 *
     4842
     4843                .page
     4844
     4845|               case SM_FREQ:
     4846|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     4847
    48484848F08L141:        move    PCH(A6),D0
    48494849                asr     #7,D0
    … …  
    48554855                ext.l   D0
    48564856                move.l  D0,LTMP(A6)
    4857 *
    4858 *                       break;
    4859 *
     4857
     4858|                       break;
     4859
    48604860                bra     F08L137
    4861 *
    4862 *               case SM_KVEL:
    4863 *                       ltmp = veltab[trg];
    4864 *
     4861
     4862|               case SM_KVEL:
     4863|                       ltmp = veltab[trg];
     4864
    48654865F08L142:        move    TRG(A6),A0
    48664866                add.l   A0,A0
    … …  
    48694869                ext.l   D0
    48704870                move.l  D0,LTMP(A6)
    4871 *
    4872 *                       break;
    4873 *
     4871
     4872|                       break;
     4873
    48744874                bra     F08L137
    4875 *
    4876                 .page
    4877 *
    4878 *               case SM_KPRS:
    4879 *                       ltmp = prstab[trg];
    4880 *
     4875
     4876                .page
     4877
     4878|               case SM_KPRS:
     4879|                       ltmp = prstab[trg];
     4880
    48814881F08L143:        move    TRG(A6),A0
    48824882                add.l   A0,A0
    … …  
    48854885                ext.l   D0
    48864886                move.l  D0,LTMP(A6)
    4887 *
    4888 *                       break;
    4889 *
     4887
     4888|                       break;
     4889
    48904890                bra     F08L137
    4891 *
    4892                 .page
    4893 *
    4894 *               default:
    4895 *                       ltmp = valents[group | pt->ipvsrc].val;
    4896 *
     4891
     4892                .page
     4893
     4894|               default:
     4895|                       ltmp = valents[group | pt->ipvsrc].val;
     4896
    48974897F08L144:        move.l  PT(A6),A0
    48984898                clr.l   D0
    … …  
    49084908                move    8(A0,A1.l),D0
    49094909                move.l  D0,LTMP(A6)
    4910 *
    4911 *               }
    4912 *
    4913 *
    4914                 .page
    4915 *
    4916 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    4917 *
     4910
     4911|               }
     4912
     4913
     4914                .page
     4915
     4916|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     4917
    49184918F08L137:        move.l  PT(A6),A0
    49194919                move.w  4(A0),D0
    … …  
    49234923                asr.l   D1,D0
    49244924                move.l  D0,LTMP(A6)
    4925 *
    4926 *               ltmp += (long)pt->ipval;
    4927 *
     4925
     4926|               ltmp += (long)pt->ipval;
     4927
    49284928                move.l  PT(A6),A0
    49294929                move    2(A0),D0
    49304930                ext.l   D0
    49314931                add.l   D0,LTMP(A6)
    4932 *
    4933 *               if (ltmp GT (long)VALMAX)
    4934 *                       ltmp = (long)VALMAX;
    4935 *
     4932
     4933|               if (ltmp GT (long)VALMAX)
     4934|                       ltmp = (long)VALMAX;
     4935
    49364936                cmp.l   #VALMAX,LTMP(A6)
    49374937                ble     F08L146
    4938 *
     4938
    49394939                move.l  #VALMAX,LTMP(A6)
    49404940                bra     F08L147
    4941 *
    4942 *               else if (ltmp LT (long)VALMIN)
    4943 *                       ltmp = (long)VALMIN;
    4944 *
     4941
     4942|               else if (ltmp LT (long)VALMIN)
     4943|                       ltmp = (long)VALMIN;
     4944
    49454945F08L146:        cmp.l   #VALMIN,LTMP(A6)
    49464946                bge     F08L147
    4947 *
     4947
    49484948                move.l  #VALMIN,LTMP(A6)
    4949 *
    4950 *               tfpval = (short)ltmp;
    4951 *
     4949
     4950|               tfpval = (short)ltmp;
     4951
    49524952F08L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    49534953                bra     F08L149
    4954 *
    4955 *       } else {
    4956 *
    4957 *               tfpval = pt->ipval;
    4958 *
     4954
     4955|       } else {
     4956
     4957|               tfpval = pt->ipval;
     4958
    49594959F08L136:        move.l  PT(A6),A0
    49604960                move    2(A0),TFPVAL(A6)
    4961 *
    4962 *       }
    4963 *
    4964                 .page
    4965 *
    4966 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    4967 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    4968 *
     4961
     4962|       }
     4963
     4964                .page
     4965
     4966|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     4967|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     4968
    49694969F08L149:        move.l  PT(A6),A0
    49704970                move.w  (A0),D0
    49714971                move.w  D0,D2
    4972                 andi.w  #$FFF0,D0
     4972                andi.w  #0xFFF0,D0
    49734973                move.w  _timemlt,D1
    49744974                muls    D1,D0
    … …  
    49764976                asr.l   D1,D0
    49774977                move    D0,R_FPMANT
    4978 *
    4979 *       fpexp = expbit[pt->iptim & 0x000F];
    4980 *
    4981                 and     #$000F,D2
     4978
     4979|       fpexp = expbit[pt->iptim & 0x000F];
     4980
     4981                and     #0x000F,D2
    49824982                move    D2,A0
    49834983                add.l   A0,A0
    49844984                add.l   #_expbit,A0
    49854985                move    (A0),R_FPEXP
    4986 *
    4987                 .page
    4988 *
    4989 *               fp->idfpch = pch;
    4990 *
     4986
     4987                .page
     4988
     4989|               fp->idfpch = pch;
     4990
    49914991F08L163:        move    PCH(A6),(A_FP)
    4992 *
    4993 *               fpval = tfpval;
    4994 *
     4992
     4993|               fpval = tfpval;
     4994
    49954995                move    TFPVAL(A6),R_FPVAL
    4996 *
    4997                 .page
    4998 *
     4996
     4997                .page
     4998
    49994999                move.b  5(A_FP),D0
    50005000                ext.w   D0
    50015001                sub.w   #1,D0
    50025002                movea.l PT(A6),A0
    5003 *
    5004 *       oldi = setipl(FPU_DI);
    5005 *
     5003
     5004|       oldi = setipl(FPU_DI);
     5005
    50065006                move    sr,OLDI(A6)
    50075007                move    #FPU_DI,sr
    5008 *
     5008
    50095009F08L168:        clr.b   10(A0)
    50105010                add.l   #12,a0
    50115011                dbra    D0,F08L168
    5012 *
    5013                 .page
    5014 *
    5015 *       fp->idftmd ^= I_NVBITS;
    5016 *
     5012
     5013                .page
     5014
     5015|       fp->idftmd ^= I_NVBITS;
     5016
    50175017F08L165:        eor.b   #24,7(A_FP)
    5018 *
    5019 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    5020 *
     5018
     5019|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     5020
    50215021                move.b  7(A_FP),R_FPCTL
    50225022                and     #28,R_FPCTL
    50235023                or      #3,R_FPCTL
    5024 *
    5025 *       fp->idfcpt = fp->idfpt1;
    5026 *
     5024
     5025|       fp->idfcpt = fp->idfpt1;
     5026
    50275027                move.b  6(A_FP),8(A_FP)
    5028 *
    5029 *       fp->idftmd |= I_ACTIVE;
    5030 *
     5028
     5029|       fp->idftmd |= I_ACTIVE;
     5030
    50315031                or.b    #2,7(A_FP)
    5032 *
    5033 *       fp->idftrf = trg;
    5034 *
     5032
     5033|       fp->idftrf = trg;
     5034
    50355035                move    TRG(A6),10(A_FP)
    5036 *
    5037 *       *(fpu + (long)FPU_TCV1) = srcval;
    5038 *
    5039                 move    SRCVAL(A6),$8(A_FPU)
    5040 *
    5041 *       ++octype;
    5042 *
     5036
     5037|       |(fpu + (long)FPU_TCV1) = srcval;
     5038
     5039                move    SRCVAL(A6),0x8(A_FPU)
     5040
     5041|       ++octype;
     5042
    50435043                add     #1,OCTYPE(A6)
    5044 *
    5045 *       *(fpu + (long)FPU_TSF1) = mltval;
    5046 *
    5047                 move    MLTVAL(A6),$A(A_FPU)
    5048 *
    5049 *       ++octype;
    5050 *
     5044
     5045|       |(fpu + (long)FPU_TSF1) = mltval;
     5046
     5047                move    MLTVAL(A6),0xA(A_FPU)
     5048
     5049|       ++octype;
     5050
    50515051                add     #1,OCTYPE(A6)
    5052 *
    5053 *       *(fpu + (long)FPU_TMNT) = fpmant;
    5054 *
    5055                 move    R_FPMANT,$14(A_FPU)
    5056 *
    5057 *       ++octype;
    5058 *
     5052
     5053|       |(fpu + (long)FPU_TMNT) = fpmant;
     5054
     5055                move    R_FPMANT,0x14(A_FPU)
     5056
     5057|       ++octype;
     5058
    50595059                add     #1,OCTYPE(A6)
    5060 *
    5061 *       *(fpu + (long)FPU_TEXP) = fpexp;
    5062 *
    5063                 move    R_FPEXP,$16(A_FPU)
    5064 *
    5065 *       ++octype;
    5066 *
     5060
     5061|       |(fpu + (long)FPU_TEXP) = fpexp;
     5062
     5063                move    R_FPEXP,0x16(A_FPU)
     5064
     5065|       ++octype;
     5066
    50675067                add     #1,OCTYPE(A6)
    5068 *
    5069                 .page
    5070 *
    5071 *       if (fp->idftmd & I_VNSUBN)
    5072 *
     5068
     5069                .page
     5070
     5071|       if (fp->idftmd & I_VNSUBN)
     5072
    50735073                btst    #3,7(A_FP)
    50745074                beq     F08L169
    5075 *
    5076 *               *(fpu + (long)FPU_TNV1) = fpval;
    5077 *
    5078                 move    R_FPVAL,$1C(A_FPU)
     5075
     5076|               |(fpu + (long)FPU_TNV1) = fpval;
     5077
     5078                move    R_FPVAL,0x1C(A_FPU)
    50795079                bra     F08L170
    5080 *
    5081 *       else
    5082 *               *(fpu + (long)FPU_TNV0) = fpval;
    5083 *
     5080
     5081|       else
     5082|               |(fpu + (long)FPU_TNV0) = fpval;
     5083
    50845084F08L169:        move    R_FPVAL,2(A_FPU)
    5085 *
    5086 *       ++octype;
    5087 *
     5085
     5086|       ++octype;
     5087
    50885088F08L170:        add     #1,OCTYPE(A6)
    5089 *
    5090 *       *(fpu + (long)FPU_TCTL) = fpctl;
    5091 *
     5089
     5090|       |(fpu + (long)FPU_TCTL) = fpctl;
     5091
    50925092                move    R_FPCTL,(A_FPU)
    5093 *
    5094 *       setipl(oldi);
    5095 *
     5093
     5094|       setipl(oldi);
     5095
    50965096                move    OLDI(A6),sr
    5097 *
    5098                 .page
    5099 * ------------------------------------------------------------------------------
    5100 * Start function 9 -- Ind 4
    5101 * ------------------------------------------------------------------------------
    5102 *
    5103 *    if (ip->idhfnc[9].idftmd & I_TM_KEY) {
    5104 *
     5097
     5098                .page
     5099| ------------------------------------------------------------------------------
     5100| Start function 9 -- Ind 4
     5101| ------------------------------------------------------------------------------
     5102
     5103|    if (ip->idhfnc[9].idftmd & I_TM_KEY) {
     5104
    51055105FN09:           move.l  IP(A6),A0
    51065106                move.b  201(A0),D0
    … …  
    51095109                btst    #0,D0
    51105110                bne     FN09A
    5111 *
     5111
    51125112                jmp     FN10
    5113 *
    5114 *       vp = (vce << 4) + 13;
    5115 *
     5113
     5114|       vp = (vce << 4) + 13;
     5115
    51165116FN09A:          move    VCE(A6),D0
    51175117                asl     #4,D0
    51185118                add.w   #13,D0
    51195119                move    D0,VP(A6)
    5120 *
    5121 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    5122 *
     5120
     5121|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     5122
    51235123                asl     #5,D0
    51245124                ext.l   D0
    51255125                move.l  D0,A_FPU
    5126                 add.l   #_io_fpu+$4000,A_FPU
    5127 *
    5128 *       fp = &ip->idhfnc[9];
    5129 *
     5126                add.l   #_io_fpu+0x4000,A_FPU
     5127
     5128|       fp = &ip->idhfnc[9];
     5129
    51305130                move.l  #108,A_FP
    51315131                add.l   IP(A6),A_FP
    51325132                add.l   #86,A_FP
    5133 *
    5134 *       pt = &ip->idhpnt[fp->idfpt1];
    5135 *
     5133
     5134|       pt = &ip->idhpnt[fp->idfpt1];
     5135
    51365136                clr.l   D0
    51375137                move.b  6(A_FP),D0
    … …  
    51435143                add.l   #242,D0
    51445144                move.l  D0,PT(A6)
    5145 *
    5146                 .page
    5147 *
    5148 *       srcnum = group | fp->idfsrc;
    5149 *
     5145
     5146                .page
     5147
     5148|       srcnum = group | fp->idfsrc;
     5149
    51505150                move.w  GROUP(A6),D0
    51515151                ext.l   D0
    … …  
    51545154                or      D1,D0
    51555155                move    D0,SRCNUM(A6)
    5156 *
    5157 *       vep = &valents[srcnum];
    5158 *
     5156
     5157|       vep = &valents[srcnum];
     5158
    51595159                add.l   D0,D0
    51605160                move.l  D0,D1
    … …  
    51635163                add.l   #_valents,D0
    51645164                move.l  D0,VEP(A6)
    5165 *
    5166 *       smp = vpsms[vp];
    5167 *
     5165
     5166|       smp = vpsms[vp];
     5167
    51685168                move    VP(A6),A0
    51695169                add.l   A0,A0
    … …  
    51715171                add.l   #_vpsms,A0
    51725172                move.l  (A0),A_SMP
    5173 *
    5174 *       if (srcnum NE smp->sm) {
    5175 *
     5173
     5174|       if (srcnum NE smp->sm) {
     5175
    51765176                clr     D0
    51775177                move    10(A_SMP),D0
    51785178                cmp     SRCNUM(A6),D0
    51795179                beq     F09L113
    5180 *
    5181 *               (smp->prv)->nxt = smp->nxt;
    5182 *
     5180
     5181|               (smp->prv)->nxt = smp->nxt;
     5182
    51835183                move.l  4(A_SMP),A0
    51845184                move.l  (A_SMP),(A0)
    5185 *
    5186 *               (smp->nxt)->prv = smp->prv;
    5187 *
     5185
     5186|               (smp->nxt)->prv = smp->prv;
     5187
    51885188                move.l  (A_SMP),A0
    51895189                move.l  4(A_SMP),4(A0)
    5190 *
    5191 *               smp->prv = (struct sment *)vep;
    5192 *
     5190
     5191|               smp->prv = (struct sment |)vep;
     5192
    51935193                move.l  VEP(A6),4(A_SMP)
    5194 *
    5195 *               smp->nxt = vep->nxt;
    5196 *
     5194
     5195|               smp->nxt = vep->nxt;
     5196
    51975197                move.l  VEP(A6),A0
    51985198                move.l  (A0),(A_SMP)
    5199 *
    5200 *               (vep->nxt)->prv = smp;
    5201 *
     5199
     5200|               (vep->nxt)->prv = smp;
     5201
    52025202                move.l  VEP(A6),A0
    52035203                move.l  (A0),A0
    52045204                move.l  A_SMP,4(A0)
    5205 *
    5206 *               vep->nxt = smp;
    5207 *
     5205
     5206|               vep->nxt = smp;
     5207
    52085208                move.l  VEP(A6),A0
    52095209                move.l  A_SMP,(A0)
    5210 *
    5211 *               smp->sm = srcnum;
    5212 *
     5210
     5211|               smp->sm = srcnum;
     5212
    52135213                move    SRCNUM(A6),10(A_SMP)
    5214 *
    5215 *       }
    5216 *
    5217 *       mltval = fp->idfmlt;
    5218 *
     5214
     5215|       }
     5216
     5217|       mltval = fp->idfmlt;
     5218
    52195219F09L113:        move    2(A_FP),MLTVAL(A6)
    5220 *
    5221                 .page
    5222 *
    5223 *       switch (fp->idfsrc) {
    5224 *
     5220
     5221                .page
     5222
     5223|       switch (fp->idfsrc) {
     5224
    52255225                move.b  4(A_FP),D0
    52265226                ext.w   d0
    52275227                cmp     #10,D0
    52285228                bhi     F09L122
    5229 *
     5229
    52305230                asl     #2,D0
    52315231                lea     F09L123,A0
    52325232                movea.l 0(A0,D0.W),A0
    52335233                jmp     (A0)
    5234 *
    5235 *       case SM_NONE:
    5236 *               mltval = 0;
    5237 *
     5234
     5235|       case SM_NONE:
     5236|               mltval = 0;
     5237
    52385238F09L116:        clr     MLTVAL(A6)
    5239 *
    5240 *               tsrcval = 0;
    5241 *
     5239
     5240|               tsrcval = 0;
     5241
    52425242                clr     TSRCVAL(A6)
    5243 *
    5244 *               break;
    5245 *
     5243
     5244|               break;
     5245
    52465246                bra     F09L114
    5247 *
    5248 *       case SM_RAND:
    5249 *               tsrcval = xgetran(mltval);
    5250 *
     5247
     5248|       case SM_RAND:
     5249|               tsrcval = xgetran(mltval);
     5250
    52515251F09L117:        move    MLTVAL(A6),(sp)
    52525252                jsr     _xgetran
    52535253                move    D0,TSRCVAL(A6)
    5254 *
    5255 *               break;
    5256 *
     5254
     5255|               break;
     5256
    52575257                bra     F09L114
    5258 *
    5259 *       case SM_PTCH:
    5260 *               tsrcval = pch;
    5261 *
     5258
     5259|       case SM_PTCH:
     5260|               tsrcval = pch;
     5261
    52625262F09L118:        move    PCH(A6),TSRCVAL(A6)
    5263 *
    5264 *               break;
    5265 *
     5263
     5264|               break;
     5265
    52665266                bra     F09L114
    5267 *
    5268                 .page
    5269 *
    5270 *       case SM_FREQ:
    5271 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    5272 *
     5267
     5268                .page
     5269
     5270|       case SM_FREQ:
     5271|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     5272
    52735273F09L119:        move    PCH(A6),D0
    52745274                asr     #7,D0
    … …  
    52785278                add.l   #_ptoftab,A0
    52795279                move    (A0),TSRCVAL(A6)
    5280 *
    5281 *               break;
    5282 *
     5280
     5281|               break;
     5282
    52835283                bra     F09L114
    5284 *
    5285 *       case SM_KVEL:
    5286 *               tsrcval = veltab[trg];
    5287 *
     5284
     5285|       case SM_KVEL:
     5286|               tsrcval = veltab[trg];
     5287
    52885288F09L120:        move    TRG(A6),A0
    52895289                add.l   A0,A0
    52905290                add.l   #_veltab,A0
    52915291                move    (A0),TSRCVAL(A6)
    5292 *
    5293 *               break;
    5294 *
     5292
     5293|               break;
     5294
    52955295                bra     F09L114
    5296 *
    5297 *       case SM_KPRS:
    5298 *               tsrcval = prstab[trg];
    5299 *
     5296
     5297|       case SM_KPRS:
     5298|               tsrcval = prstab[trg];
     5299
    53005300F09L121:        move    TRG(A6),A0
    53015301                add.l   A0,A0
    53025302                add.l   #_prstab,A0
    53035303                move    (A0),TSRCVAL(A6)
    5304 *
    5305 *               break;
    5306 *
     5304
     5305|               break;
     5306
    53075307                bra     F09L114
    5308 *
    5309 *       default:
    5310 *               tsrcval = vep->val;
    5311 *
     5308
     5309|       default:
     5310|               tsrcval = vep->val;
     5311
    53125312F09L122:        move.l  VEP(A6),A0
    53135313                move    8(A0),TSRCVAL(A6)
    5314 *
    5315 *       }
    5316 *
    5317                 .page
    5318 *
    5319 *               srcval = tsrcval;
    5320 *
     5314
     5315|       }
     5316
     5317                .page
     5318
     5319|               srcval = tsrcval;
     5320
    53215321F09L114:        move    TSRCVAL(A6),SRCVAL(A6)
    5322 *
    5323                 .page
    5324 *
    5325 *       if (pt->ipvsrc) {
    5326 *
     5322
     5323                .page
     5324
     5325|       if (pt->ipvsrc) {
     5326
    53275327F09L124:        move.l  PT(A6),A0
    53285328                tst.b   6(A0)
    53295329                beq     F09L136
    5330 *
    5331 *               switch (pt->ipvsrc) {
    5332 *
     5330
     5331|               switch (pt->ipvsrc) {
     5332
    53335333                move.l  PT(A6),A0
    53345334                move.b  6(A0),D0
    … …  
    53375337                cmp     #9,D0
    53385338                bhi     F09L144
    5339 *
     5339
    53405340                asl     #2,D0
    53415341                lea     F09L145,A0
    53425342                move.l  0(A0,D0.W),A0
    53435343                jmp     (A0)
    5344 *
    5345 *               case SM_RAND:
    5346 *                       ltmp = xgetran(pt_>ipvmlt);
    5347 *
     5344
     5345|               case SM_RAND:
     5346|                       ltmp = xgetran(pt_>ipvmlt);
     5347
    53485348F09L139:        move.l  PT(A6),A0
    53495349                move    4(A0),(sp)
    … …  
    53515351                ext.l   D0
    53525352                move.l  D0,LTMP(A6)
    5353 *
    5354 *                       break;
    5355 *
     5353
     5354|                       break;
     5355
    53565356                bra     F09L137
    5357 *
    5358 *               case SM_PTCH:
    5359 *                       ltmp = pch;
    5360 *
     5357
     5358|               case SM_PTCH:
     5359|                       ltmp = pch;
     5360
    53615361F09L140:        move    PCH(A6),A0
    53625362                move.l  A0,LTMP(A6)
    5363 *
    5364 *                       break;
    5365 *
     5363
     5364|                       break;
     5365
    53665366                bra     F09L137
    5367 *
    5368                 .page
    5369 *
    5370 *               case SM_FREQ:
    5371 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    5372 *
     5367
     5368                .page
     5369
     5370|               case SM_FREQ:
     5371|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     5372
    53735373F09L141:        move    PCH(A6),D0
    53745374                asr     #7,D0
    … …  
    53805380                ext.l   D0
    53815381                move.l  D0,LTMP(A6)
    5382 *
    5383 *                       break;
    5384 *
     5382
     5383|                       break;
     5384
    53855385                bra     F09L137
    5386 *
    5387 *               case SM_KVEL:
    5388 *                       ltmp = veltab[trg];
    5389 *
     5386
     5387|               case SM_KVEL:
     5388|                       ltmp = veltab[trg];
     5389
    53905390F09L142:        move    TRG(A6),A0
    53915391                add.l   A0,A0
    … …  
    53945394                ext.l   D0
    53955395                move.l  D0,LTMP(A6)
    5396 *
    5397 *                       break;
    5398 *
     5396
     5397|                       break;
     5398
    53995399                bra     F09L137
    5400 *
    5401                 .page
    5402 *
    5403 *               case SM_KPRS:
    5404 *                       ltmp = prstab[trg];
    5405 *
     5400
     5401                .page
     5402
     5403|               case SM_KPRS:
     5404|                       ltmp = prstab[trg];
     5405
    54065406F09L143:        move    TRG(A6),A0
    54075407                add.l   A0,A0
    … …  
    54105410                ext.l   D0
    54115411                move.l  D0,LTMP(A6)
    5412 *
    5413 *                       break;
    5414 *
     5412
     5413|                       break;
     5414
    54155415                bra     F09L137
    5416 *
    5417                 .page
    5418 *
    5419 *               default:
    5420 *                       ltmp = valents[group | pt->ipvsrc].val;
    5421 *
     5416
     5417                .page
     5418
     5419|               default:
     5420|                       ltmp = valents[group | pt->ipvsrc].val;
     5421
    54225422F09L144:        move.l  PT(A6),A0
    54235423                clr.l   D0
    … …  
    54335433                move    8(A0,A1.l),D0
    54345434                move.l  D0,LTMP(A6)
    5435 *
    5436 *               }
    5437 *
    5438 *
    5439                 .page
    5440 *
    5441 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    5442 *
     5435
     5436|               }
     5437
     5438
     5439                .page
     5440
     5441|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     5442
    54435443F09L137:        move.l  PT(A6),A0
    54445444                move.w  4(A0),D0
    … …  
    54485448                asr.l   D1,D0
    54495449                move.l  D0,LTMP(A6)
    5450 *
    5451 *               ltmp += (long)pt->ipval;
    5452 *
     5450
     5451|               ltmp += (long)pt->ipval;
     5452
    54535453                move.l  PT(A6),A0
    54545454                move    2(A0),D0
    54555455                ext.l   D0
    54565456                add.l   D0,LTMP(A6)
    5457 *
    5458 *               if (ltmp GT (long)VALMAX)
    5459 *                       ltmp = (long)VALMAX;
    5460 *
     5457
     5458|               if (ltmp GT (long)VALMAX)
     5459|                       ltmp = (long)VALMAX;
     5460
    54615461                cmp.l   #VALMAX,LTMP(A6)
    54625462                ble     F09L146
    5463 *
     5463
    54645464                move.l  #VALMAX,LTMP(A6)
    54655465                bra     F09L147
    5466 *
    5467 *               else if (ltmp LT (long)VALMIN)
    5468 *                       ltmp = (long)VALMIN;
    5469 *
     5466
     5467|               else if (ltmp LT (long)VALMIN)
     5468|                       ltmp = (long)VALMIN;
     5469
    54705470F09L146:        cmp.l   #VALMIN,LTMP(A6)
    54715471                bge     F09L147
    5472 *
     5472
    54735473                move.l  #VALMIN,LTMP(A6)
    5474 *
    5475 *               tfpval = (short)ltmp;
    5476 *
     5474
     5475|               tfpval = (short)ltmp;
     5476
    54775477F09L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    54785478                bra     F09L149
    5479 *
    5480 *       } else {
    5481 *
    5482 *               tfpval = pt->ipval;
    5483 *
     5479
     5480|       } else {
     5481
     5482|               tfpval = pt->ipval;
     5483
    54845484F09L136:        move.l  PT(A6),A0
    54855485                move    2(A0),TFPVAL(A6)
    5486 *
    5487 *       }
    5488 *
    5489                 .page
    5490 *
    5491 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    5492 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    5493 *
     5486
     5487|       }
     5488
     5489                .page
     5490
     5491|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     5492|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     5493
    54945494F09L149:        move.l  PT(A6),A0
    54955495                move.w  (A0),D0
    54965496                move.w  D0,D2
    5497                 andi.w  #$FFF0,D0
     5497                andi.w  #0xFFF0,D0
    54985498                move.w  _timemlt,D1
    54995499                muls    D1,D0
    … …  
    55015501                asr.l   D1,D0
    55025502                move    D0,R_FPMANT
    5503 *
    5504 *       fpexp = expbit[pt->iptim & 0x000F];
    5505 *
    5506                 and     #$000F,D2
     5503
     5504|       fpexp = expbit[pt->iptim & 0x000F];
     5505
     5506                and     #0x000F,D2
    55075507                move    D2,A0
    55085508                add.l   A0,A0
    55095509                add.l   #_expbit,A0
    55105510                move    (A0),R_FPEXP
    5511 *
    5512                 .page
    5513 *
    5514 *               fp->idfpch = pch;
    5515 *
     5511
     5512                .page
     5513
     5514|               fp->idfpch = pch;
     5515
    55165516F09L163:        move    PCH(A6),(A_FP)
    5517 *
    5518 *               fpval = tfpval;
    5519 *
     5517
     5518|               fpval = tfpval;
     5519
    55205520                move    TFPVAL(A6),R_FPVAL
    5521 *
    5522                 .page
    5523 *
     5521
     5522                .page
     5523
    55245524                move.b  5(A_FP),D0
    55255525                ext.w   D0
    55265526                sub.w   #1,D0
    55275527                movea.l PT(A6),A0
    5528 *
    5529 *       oldi = setipl(FPU_DI);
    5530 *
     5528
     5529|       oldi = setipl(FPU_DI);
     5530
    55315531                move    sr,OLDI(A6)
    55325532                move    #FPU_DI,sr
    5533 *
     5533
    55345534F09L168:        clr.b   10(A0)
    55355535                add.l   #12,a0
    55365536                dbra    D0,F09L168
    5537 *
    5538                 .page
    5539 *
    5540 *       fp->idftmd ^= I_NVBITS;
    5541 *
     5537
     5538                .page
     5539
     5540|       fp->idftmd ^= I_NVBITS;
     5541
    55425542F09L165:        eor.b   #24,7(A_FP)
    5543 *
    5544 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    5545 *
     5543
     5544|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     5545
    55465546                move.b  7(A_FP),R_FPCTL
    55475547                and     #28,R_FPCTL
    55485548                or      #3,R_FPCTL
    5549 *
    5550 *       fp->idfcpt = fp->idfpt1;
    5551 *
     5549
     5550|       fp->idfcpt = fp->idfpt1;
     5551
    55525552                move.b  6(A_FP),8(A_FP)
    5553 *
    5554 *       fp->idftmd |= I_ACTIVE;
    5555 *
     5553
     5554|       fp->idftmd |= I_ACTIVE;
     5555
    55565556                or.b    #2,7(A_FP)
    5557 *
    5558 *       fp->idftrf = trg;
    5559 *
     5557
     5558|       fp->idftrf = trg;
     5559
    55605560                move    TRG(A6),10(A_FP)
    5561 *
    5562 *       *(fpu + (long)FPU_TCV1) = srcval;
    5563 *
    5564                 move    SRCVAL(A6),$8(A_FPU)
    5565 *
    5566 *       ++octype;
    5567 *
     5561
     5562|       |(fpu + (long)FPU_TCV1) = srcval;
     5563
     5564                move    SRCVAL(A6),0x8(A_FPU)
     5565
     5566|       ++octype;
     5567
    55685568                add     #1,OCTYPE(A6)
    5569 *
    5570 *       *(fpu + (long)FPU_TSF1) = mltval;
    5571 *
    5572                 move    MLTVAL(A6),$A(A_FPU)
    5573 *
    5574 *       ++octype;
    5575 *
     5569
     5570|       |(fpu + (long)FPU_TSF1) = mltval;
     5571
     5572                move    MLTVAL(A6),0xA(A_FPU)
     5573
     5574|       ++octype;
     5575
    55765576                add     #1,OCTYPE(A6)
    5577 *
    5578 *       *(fpu + (long)FPU_TMNT) = fpmant;
    5579 *
    5580                 move    R_FPMANT,$14(A_FPU)
    5581 *
    5582 *       ++octype;
    5583 *
     5577
     5578|       |(fpu + (long)FPU_TMNT) = fpmant;
     5579
     5580                move    R_FPMANT,0x14(A_FPU)
     5581
     5582|       ++octype;
     5583
    55845584                add     #1,OCTYPE(A6)
    5585 *
    5586 *       *(fpu + (long)FPU_TEXP) = fpexp;
    5587 *
    5588                 move    R_FPEXP,$16(A_FPU)
    5589 *
    5590 *       ++octype;
    5591 *
     5585
     5586|       |(fpu + (long)FPU_TEXP) = fpexp;
     5587
     5588                move    R_FPEXP,0x16(A_FPU)
     5589
     5590|       ++octype;
     5591
    55925592                add     #1,OCTYPE(A6)
    5593 *
    5594                 .page
    5595 *
    5596 *       if (fp->idftmd & I_VNSUBN)
    5597 *
     5593
     5594                .page
     5595
     5596|       if (fp->idftmd & I_VNSUBN)
     5597
    55985598                btst    #3,7(A_FP)
    55995599                beq     F09L169
    5600 *
    5601 *               *(fpu + (long)FPU_TNV1) = fpval;
    5602 *
    5603                 move    R_FPVAL,$1C(A_FPU)
     5600
     5601|               |(fpu + (long)FPU_TNV1) = fpval;
     5602
     5603                move    R_FPVAL,0x1C(A_FPU)
    56045604                bra     F09L170
    5605 *
    5606 *       else
    5607 *               *(fpu + (long)FPU_TNV0) = fpval;
    5608 *
     5605
     5606|       else
     5607|               |(fpu + (long)FPU_TNV0) = fpval;
     5608
    56095609F09L169:        move    R_FPVAL,2(A_FPU)
    5610 *
    5611 *       ++octype;
    5612 *
     5610
     5611|       ++octype;
     5612
    56135613F09L170:        add     #1,OCTYPE(A6)
    5614 *
    5615 *       *(fpu + (long)FPU_TCTL) = fpctl;
    5616 *
     5614
     5615|       |(fpu + (long)FPU_TCTL) = fpctl;
     5616
    56175617                move    R_FPCTL,(A_FPU)
    5618 *
    5619 *       setipl(oldi);
    5620 *
     5618
     5619|       setipl(oldi);
     5620
    56215621                move    OLDI(A6),sr
    5622 *
    5623                 .page
    5624 * ------------------------------------------------------------------------------
    5625 * Start function 10 -- Ind 5
    5626 * ------------------------------------------------------------------------------
    5627 *
    5628 *    if (ip->idhfnc[10].idftmd & I_TM_KEY) {
    5629 *
     5622
     5623                .page
     5624| ------------------------------------------------------------------------------
     5625| Start function 10 -- Ind 5
     5626| ------------------------------------------------------------------------------
     5627
     5628|    if (ip->idhfnc[10].idftmd & I_TM_KEY) {
     5629
    56305630FN10:           move.l  IP(A6),A0
    56315631                move.b  213(A0),D0
    … …  
    56345634                btst    #0,D0
    56355635                bne     FN10A
    5636 *
     5636
    56375637                jmp     FN11
    5638 *
    5639 *       vp = (vce << 4) + 14;
    5640 *
     5638
     5639|       vp = (vce << 4) + 14;
     5640
    56415641FN10A:          move    VCE(A6),D0
    56425642                asl     #4,D0
    56435643                add.w   #14,D0
    56445644                move    D0,VP(A6)
    5645 *
    5646 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    5647 *
     5645
     5646|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     5647
    56485648                asl     #5,D0
    56495649                ext.l   D0
    56505650                move.l  D0,A_FPU
    5651                 add.l   #_io_fpu+$4000,A_FPU
    5652 *
    5653 *       fp = &ip->idhfnc[10];
    5654 *
     5651                add.l   #_io_fpu+0x4000,A_FPU
     5652
     5653|       fp = &ip->idhfnc[10];
     5654
    56555655                move.l  #120,A_FP
    56565656                add.l   IP(A6),A_FP
    56575657                add.l   #86,A_FP
    5658 *
    5659 *       pt = &ip->idhpnt[fp->idfpt1];
    5660 *
     5658
     5659|       pt = &ip->idhpnt[fp->idfpt1];
     5660
    56615661                clr.l   D0
    56625662                move.b  6(A_FP),D0
    … …  
    56685668                add.l   #242,D0
    56695669                move.l  D0,PT(A6)
    5670 *
    5671                 .page
    5672 *
    5673 *       srcnum = group | fp->idfsrc;
    5674 *
     5670
     5671                .page
     5672
     5673|       srcnum = group | fp->idfsrc;
     5674
    56755675                move.w  GROUP(A6),D0
    56765676                ext.l   D0
    … …  
    56795679                or      D1,D0
    56805680                move    D0,SRCNUM(A6)
    5681 *
    5682 *       vep = &valents[srcnum];
    5683 *
     5681
     5682|       vep = &valents[srcnum];
     5683
    56845684                add.l   D0,D0
    56855685                move.l  D0,D1
    … …  
    56885688                add.l   #_valents,D0
    56895689                move.l  D0,VEP(A6)
    5690 *
    5691 *       smp = vpsms[vp];
    5692 *
     5690
     5691|       smp = vpsms[vp];
     5692
    56935693                move    VP(A6),A0
    56945694                add.l   A0,A0
    … …  
    56965696                add.l   #_vpsms,A0
    56975697                move.l  (A0),A_SMP
    5698 *
    5699 *       if (srcnum NE smp->sm) {
    5700 *
     5698
     5699|       if (srcnum NE smp->sm) {
     5700
    57015701                clr     D0
    57025702                move    10(A_SMP),D0
    57035703                cmp     SRCNUM(A6),D0
    57045704                beq     F10L113
    5705 *
    5706 *               (smp->prv)->nxt = smp->nxt;
    5707 *
     5705
     5706|               (smp->prv)->nxt = smp->nxt;
     5707
    57085708                move.l  4(A_SMP),A0
    57095709                move.l  (A_SMP),(A0)
    5710 *
    5711 *               (smp->nxt)->prv = smp->prv;
    5712 *
     5710
     5711|               (smp->nxt)->prv = smp->prv;
     5712
    57135713                move.l  (A_SMP),A0
    57145714                move.l  4(A_SMP),4(A0)
    5715 *
    5716 *               smp->prv = (struct sment *)vep;
    5717 *
     5715
     5716|               smp->prv = (struct sment |)vep;
     5717
    57185718                move.l  VEP(A6),4(A_SMP)
    5719 *
    5720 *               smp->nxt = vep->nxt;
    5721 *
     5719
     5720|               smp->nxt = vep->nxt;
     5721
    57225722                move.l  VEP(A6),A0
    57235723                move.l  (A0),(A_SMP)
    5724 *
    5725 *               (vep->nxt)->prv = smp;
    5726 *
     5724
     5725|               (vep->nxt)->prv = smp;
     5726
    57275727                move.l  VEP(A6),A0
    57285728                move.l  (A0),A0
    57295729                move.l  A_SMP,4(A0)
    5730 *
    5731 *               vep->nxt = smp;
    5732 *
     5730
     5731|               vep->nxt = smp;
     5732
    57335733                move.l  VEP(A6),A0
    57345734                move.l  A_SMP,(A0)
    5735 *
    5736 *               smp->sm = srcnum;
    5737 *
     5735
     5736|               smp->sm = srcnum;
     5737
    57385738                move    SRCNUM(A6),10(A_SMP)
    5739 *
    5740 *       }
    5741 *
    5742 *       mltval = fp->idfmlt;
    5743 *
     5739
     5740|       }
     5741
     5742|       mltval = fp->idfmlt;
     5743
    57445744F10L113:        move    2(A_FP),MLTVAL(A6)
    5745 *
    5746                 .page
    5747 *
    5748 *       switch (fp->idfsrc) {
    5749 *
     5745
     5746                .page
     5747
     5748|       switch (fp->idfsrc) {
     5749
    57505750                move.b  4(A_FP),D0
    57515751                ext.w   d0
    57525752                cmp     #10,D0
    57535753                bhi     F10L122
    5754 *
     5754
    57555755                asl     #2,D0
    57565756                lea     F10L123,A0
    57575757                movea.l 0(A0,D0.W),A0
    57585758                jmp     (A0)
    5759 *
    5760 *       case SM_NONE:
    5761 *               mltval = 0;
    5762 *
     5759
     5760|       case SM_NONE:
     5761|               mltval = 0;
     5762
    57635763F10L116:        clr     MLTVAL(A6)
    5764 *
    5765 *               tsrcval = 0;
    5766 *
     5764
     5765|               tsrcval = 0;
     5766
    57675767                clr     TSRCVAL(A6)
    5768 *
    5769 *               break;
    5770 *
     5768
     5769|               break;
     5770
    57715771                bra     F10L114
    5772 *
    5773 *       case SM_RAND:
    5774 *               tsrcval = xgetran(mltval);
    5775 *
     5772
     5773|       case SM_RAND:
     5774|               tsrcval = xgetran(mltval);
     5775
    57765776F10L117:        move    MLTVAL(A6),(sp)
    57775777                jsr     _xgetran
    57785778                move    D0,TSRCVAL(A6)
    5779 *
    5780 *               break;
    5781 *
     5779
     5780|               break;
     5781
    57825782                bra     F10L114
    5783 *
    5784 *       case SM_PTCH:
    5785 *               tsrcval = pch;
    5786 *
     5783
     5784|       case SM_PTCH:
     5785|               tsrcval = pch;
     5786
    57875787F10L118:        move    PCH(A6),TSRCVAL(A6)
    5788 *
    5789 *               break;
    5790 *
     5788
     5789|               break;
     5790
    57915791                bra     F10L114
    5792 *
    5793                 .page
    5794 *
    5795 *       case SM_FREQ:
    5796 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    5797 *
     5792
     5793                .page
     5794
     5795|       case SM_FREQ:
     5796|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     5797
    57985798F10L119:        move    PCH(A6),D0
    57995799                asr     #7,D0
    … …  
    58035803                add.l   #_ptoftab,A0
    58045804                move    (A0),TSRCVAL(A6)
    5805 *
    5806 *               break;
    5807 *
     5805
     5806|               break;
     5807
    58085808                bra     F10L114
    5809 *
    5810 *       case SM_KVEL:
    5811 *               tsrcval = veltab[trg];
    5812 *
     5809
     5810|       case SM_KVEL:
     5811|               tsrcval = veltab[trg];
     5812
    58135813F10L120:        move    TRG(A6),A0
    58145814                add.l   A0,A0
    58155815                add.l   #_veltab,A0
    58165816                move    (A0),TSRCVAL(A6)
    5817 *
    5818 *               break;
    5819 *
     5817
     5818|               break;
     5819
    58205820                bra     F10L114
    5821 *
    5822 *       case SM_KPRS:
    5823 *               tsrcval = prstab[trg];
    5824 *
     5821
     5822|       case SM_KPRS:
     5823|               tsrcval = prstab[trg];
     5824
    58255825F10L121:        move    TRG(A6),A0
    58265826                add.l   A0,A0
    58275827                add.l   #_prstab,A0
    58285828                move    (A0),TSRCVAL(A6)
    5829 *
    5830 *               break;
    5831 *
     5829
     5830|               break;
     5831
    58325832                bra     F10L114
    5833 *
    5834 *       default:
    5835 *               tsrcval = vep->val;
    5836 *
     5833
     5834|       default:
     5835|               tsrcval = vep->val;
     5836
    58375837F10L122:        move.l  VEP(A6),A0
    58385838                move    8(A0),TSRCVAL(A6)
    5839 *
    5840 *       }
    5841 *
    5842                 .page
    5843 *
    5844 *               srcval = tsrcval;
    5845 *
     5839
     5840|       }
     5841
     5842                .page
     5843
     5844|               srcval = tsrcval;
     5845
    58465846F10L114:        move    TSRCVAL(A6),SRCVAL(A6)
    5847 *
    5848                 .page
    5849 *
    5850 *       if (pt->ipvsrc) {
    5851 *
     5847
     5848                .page
     5849
     5850|       if (pt->ipvsrc) {
     5851
    58525852F10L124:        move.l  PT(A6),A0
    58535853                tst.b   6(A0)
    58545854                beq     F10L136
    5855 *
    5856 *               switch (pt->ipvsrc) {
    5857 *
     5855
     5856|               switch (pt->ipvsrc) {
     5857
    58585858                move.l  PT(A6),A0
    58595859                move.b  6(A0),D0
    … …  
    58625862                cmp     #9,D0
    58635863                bhi     F10L144
    5864 *
     5864
    58655865                asl     #2,D0
    58665866                lea     F10L145,A0
    58675867                move.l  0(A0,D0.W),A0
    58685868                jmp     (A0)
    5869 *
    5870 *               case SM_RAND:
    5871 *                       ltmp = xgetran(pt_>ipvmlt);
    5872 *
     5869
     5870|               case SM_RAND:
     5871|                       ltmp = xgetran(pt_>ipvmlt);
     5872
    58735873F10L139:        move.l  PT(A6),A0
    58745874                move    4(A0),(sp)
    … …  
    58765876                ext.l   D0
    58775877                move.l  D0,LTMP(A6)
    5878 *
    5879 *                       break;
    5880 *
     5878
     5879|                       break;
     5880
    58815881                bra     F10L137
    5882 *
    5883 *               case SM_PTCH:
    5884 *                       ltmp = pch;
    5885 *
     5882
     5883|               case SM_PTCH:
     5884|                       ltmp = pch;
     5885
    58865886F10L140:        move    PCH(A6),A0
    58875887                move.l  A0,LTMP(A6)
    5888 *
    5889 *                       break;
    5890 *
     5888
     5889|                       break;
     5890
    58915891                bra     F10L137
    5892 *
    5893                 .page
    5894 *
    5895 *               case SM_FREQ:
    5896 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    5897 *
     5892
     5893                .page
     5894
     5895|               case SM_FREQ:
     5896|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     5897
    58985898F10L141:        move    PCH(A6),D0
    58995899                asr     #7,D0
    … …  
    59055905                ext.l   D0
    59065906                move.l  D0,LTMP(A6)
    5907 *
    5908 *                       break;
    5909 *
     5907
     5908|                       break;
     5909
    59105910                bra     F10L137
    5911 *
    5912 *               case SM_KVEL:
    5913 *                       ltmp = veltab[trg];
    5914 *
     5911
     5912|               case SM_KVEL:
     5913|                       ltmp = veltab[trg];
     5914
    59155915F10L142:        move    TRG(A6),A0
    59165916                add.l   A0,A0
    … …  
    59195919                ext.l   D0
    59205920                move.l  D0,LTMP(A6)
    5921 *
    5922 *                       break;
    5923 *
     5921
     5922|                       break;
     5923
    59245924                bra     F10L137
    5925 *
    5926                 .page
    5927 *
    5928 *               case SM_KPRS:
    5929 *                       ltmp = prstab[trg];
    5930 *
     5925
     5926                .page
     5927
     5928|               case SM_KPRS:
     5929|                       ltmp = prstab[trg];
     5930
    59315931F10L143:        move    TRG(A6),A0
    59325932                add.l   A0,A0
    … …  
    59355935                ext.l   D0
    59365936                move.l  D0,LTMP(A6)
    5937 *
    5938 *                       break;
    5939 *
     5937
     5938|                       break;
     5939
    59405940                bra     F10L137
    5941 *
    5942                 .page
    5943 *
    5944 *               default:
    5945 *                       ltmp = valents[group | pt->ipvsrc].val;
    5946 *
     5941
     5942                .page
     5943
     5944|               default:
     5945|                       ltmp = valents[group | pt->ipvsrc].val;
     5946
    59475947F10L144:        move.l  PT(A6),A0
    59485948                clr.l   D0
    … …  
    59585958                move    8(A0,A1.l),D0
    59595959                move.l  D0,LTMP(A6)
    5960 *
    5961 *               }
    5962 *
    5963 *
    5964                 .page
    5965 *
    5966 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    5967 *
     5960
     5961|               }
     5962
     5963
     5964                .page
     5965
     5966|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     5967
    59685968F10L137:        move.l  PT(A6),A0
    59695969                move.w  4(A0),D0
    … …  
    59735973                asr.l   D1,D0
    59745974                move.l  D0,LTMP(A6)
    5975 *
    5976 *               ltmp += (long)pt->ipval;
    5977 *
     5975
     5976|               ltmp += (long)pt->ipval;
     5977
    59785978                move.l  PT(A6),A0
    59795979                move    2(A0),D0
    59805980                ext.l   D0
    59815981                add.l   D0,LTMP(A6)
    5982 *
    5983 *               if (ltmp GT (long)VALMAX)
    5984 *                       ltmp = (long)VALMAX;
    5985 *
     5982
     5983|               if (ltmp GT (long)VALMAX)
     5984|                       ltmp = (long)VALMAX;
     5985
    59865986                cmp.l   #VALMAX,LTMP(A6)
    59875987                ble     F10L146
    5988 *
     5988
    59895989                move.l  #VALMAX,LTMP(A6)
    59905990                bra     F10L147
    5991 *
    5992 *               else if (ltmp LT (long)VALMIN)
    5993 *                       ltmp = (long)VALMIN;
    5994 *
     5991
     5992|               else if (ltmp LT (long)VALMIN)
     5993|                       ltmp = (long)VALMIN;
     5994
    59955995F10L146:        cmp.l   #VALMIN,LTMP(A6)
    59965996                bge     F10L147
    5997 *
     5997
    59985998                move.l  #VALMIN,LTMP(A6)
    5999 *
    6000 *               tfpval = (short)ltmp;
    6001 *
     5999
     6000|               tfpval = (short)ltmp;
     6001
    60026002F10L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    60036003                bra     F10L149
    6004 *
    6005 *       } else {
    6006 *
    6007 *               tfpval = pt->ipval;
    6008 *
     6004
     6005|       } else {
     6006
     6007|               tfpval = pt->ipval;
     6008
    60096009F10L136:        move.l  PT(A6),A0
    60106010                move    2(A0),TFPVAL(A6)
    6011 *
    6012 *       }
    6013 *
    6014                 .page
    6015 *
    6016 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    6017 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    6018 *
     6011
     6012|       }
     6013
     6014                .page
     6015
     6016|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     6017|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     6018
    60196019F10L149:        move.l  PT(A6),A0
    60206020                move.w  (A0),D0
    60216021                move.w  D0,D2
    6022                 andi.w  #$FFF0,D0
     6022                andi.w  #0xFFF0,D0
    60236023                move.w  _timemlt,D1
    60246024                muls    D1,D0
    … …  
    60266026                asr.l   D1,D0
    60276027                move    D0,R_FPMANT
    6028 *
    6029 *       fpexp = expbit[pt->iptim & 0x000F];
    6030 *
    6031                 and     #$000F,D2
     6028
     6029|       fpexp = expbit[pt->iptim & 0x000F];
     6030
     6031                and     #0x000F,D2
    60326032                move    D2,A0
    60336033                add.l   A0,A0
    60346034                add.l   #_expbit,A0
    60356035                move    (A0),R_FPEXP
    6036 *
    6037                 .page
    6038 *
    6039 *               fp->idfpch = pch;
    6040 *
     6036
     6037                .page
     6038
     6039|               fp->idfpch = pch;
     6040
    60416041F10L163:        move    PCH(A6),(A_FP)
    6042 *
    6043 *               fpval = tfpval;
    6044 *
     6042
     6043|               fpval = tfpval;
     6044
    60456045                move    TFPVAL(A6),R_FPVAL
    6046 *
    6047                 .page
    6048 *
     6046
     6047                .page
     6048
    60496049                move.b  5(A_FP),D0
    60506050                ext.w   D0
    60516051                sub.w   #1,D0
    60526052                movea.l PT(A6),A0
    6053 *
    6054 *       oldi = setipl(FPU_DI);
    6055 *
     6053
     6054|       oldi = setipl(FPU_DI);
     6055
    60566056                move    sr,OLDI(A6)
    60576057                move    #FPU_DI,sr
    6058 *
     6058
    60596059F10L168:        clr.b   10(A0)
    60606060                add.l   #12,a0
    60616061                dbra    D0,F10L168
    6062 *
    6063                 .page
    6064 *
    6065 *       fp->idftmd ^= I_NVBITS;
    6066 *
     6062
     6063                .page
     6064
     6065|       fp->idftmd ^= I_NVBITS;
     6066
    60676067F10L165:        eor.b   #24,7(A_FP)
    6068 *
    6069 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    6070 *
     6068
     6069|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     6070
    60716071                move.b  7(A_FP),R_FPCTL
    60726072                and     #28,R_FPCTL
    60736073                or      #3,R_FPCTL
    6074 *
    6075 *       fp->idfcpt = fp->idfpt1;
    6076 *
     6074
     6075|       fp->idfcpt = fp->idfpt1;
     6076
    60776077                move.b  6(A_FP),8(A_FP)
    6078 *
    6079 *       fp->idftmd |= I_ACTIVE;
    6080 *
     6078
     6079|       fp->idftmd |= I_ACTIVE;
     6080
    60816081                or.b    #2,7(A_FP)
    6082 *
    6083 *       fp->idftrf = trg;
    6084 *
     6082
     6083|       fp->idftrf = trg;
     6084
    60856085                move    TRG(A6),10(A_FP)
    6086 *
    6087 *       *(fpu + (long)FPU_TCV1) = srcval;
    6088 *
    6089                 move    SRCVAL(A6),$8(A_FPU)
    6090 *
    6091 *       ++octype;
    6092 *
     6086
     6087|       |(fpu + (long)FPU_TCV1) = srcval;
     6088
     6089                move    SRCVAL(A6),0x8(A_FPU)
     6090
     6091|       ++octype;
     6092
    60936093                add     #1,OCTYPE(A6)
    6094 *
    6095 *       *(fpu + (long)FPU_TSF1) = mltval;
    6096 *
    6097                 move    MLTVAL(A6),$A(A_FPU)
    6098 *
    6099 *       ++octype;
    6100 *
     6094
     6095|       |(fpu + (long)FPU_TSF1) = mltval;
     6096
     6097                move    MLTVAL(A6),0xA(A_FPU)
     6098
     6099|       ++octype;
     6100
    61016101                add     #1,OCTYPE(A6)
    6102 *
    6103 *       *(fpu + (long)FPU_TMNT) = fpmant;
    6104 *
    6105                 move    R_FPMANT,$14(A_FPU)
    6106 *
    6107 *       ++octype;
    6108 *
     6102
     6103|       |(fpu + (long)FPU_TMNT) = fpmant;
     6104
     6105                move    R_FPMANT,0x14(A_FPU)
     6106
     6107|       ++octype;
     6108
    61096109                add     #1,OCTYPE(A6)
    6110 *
    6111 *       *(fpu + (long)FPU_TEXP) = fpexp;
    6112 *
    6113                 move    R_FPEXP,$16(A_FPU)
    6114 *
    6115 *       ++octype;
    6116 *
     6110
     6111|       |(fpu + (long)FPU_TEXP) = fpexp;
     6112
     6113                move    R_FPEXP,0x16(A_FPU)
     6114
     6115|       ++octype;
     6116
    61176117                add     #1,OCTYPE(A6)
    6118 *
    6119                 .page
    6120 *
    6121 *       if (fp->idftmd & I_VNSUBN)
    6122 *
     6118
     6119                .page
     6120
     6121|       if (fp->idftmd & I_VNSUBN)
     6122
    61236123                btst    #3,7(A_FP)
    61246124                beq     F10L169
    6125 *
    6126 *               *(fpu + (long)FPU_TNV1) = fpval;
    6127 *
    6128                 move    R_FPVAL,$1C(A_FPU)
     6125
     6126|               |(fpu + (long)FPU_TNV1) = fpval;
     6127
     6128                move    R_FPVAL,0x1C(A_FPU)
    61296129                bra     F10L170
    6130 *
    6131 *       else
    6132 *               *(fpu + (long)FPU_TNV0) = fpval;
    6133 *
     6130
     6131|       else
     6132|               |(fpu + (long)FPU_TNV0) = fpval;
     6133
    61346134F10L169:        move    R_FPVAL,2(A_FPU)
    6135 *
    6136 *       ++octype;
    6137 *
     6135
     6136|       ++octype;
     6137
    61386138F10L170:        add     #1,OCTYPE(A6)
    6139 *
    6140 *       *(fpu + (long)FPU_TCTL) = fpctl;
    6141 *
     6139
     6140|       |(fpu + (long)FPU_TCTL) = fpctl;
     6141
    61426142                move    R_FPCTL,(A_FPU)
    6143 *
    6144 *       setipl(oldi);
    6145 *
     6143
     6144|       setipl(oldi);
     6145
    61466146                move    OLDI(A6),sr
    6147 *
    6148                 .page
    6149 * ------------------------------------------------------------------------------
    6150 * Start function 11 -- Ind 6
    6151 * ------------------------------------------------------------------------------
    6152 *
    6153 *    if (ip->idhfnc[11].idftmd & I_TM_KEY) {
    6154 *
     6147
     6148                .page
     6149| ------------------------------------------------------------------------------
     6150| Start function 11 -- Ind 6
     6151| ------------------------------------------------------------------------------
     6152
     6153|    if (ip->idhfnc[11].idftmd & I_TM_KEY) {
     6154
    61556155FN11:           move.l  IP(A6),A0
    61566156                move.b  225(A0),D0
    … …  
    61596159                btst    #0,D0
    61606160                bne     FN11A
    6161 *
     6161
    61626162                jmp     FN12
    6163 *
    6164 *       vp = (vce << 4) + 15;
    6165 *
     6163
     6164|       vp = (vce << 4) + 15;
     6165
    61666166FN11A:          move    VCE(A6),D0
    61676167                asl     #4,D0
    61686168                add.w   #15,D0
    61696169                move    D0,VP(A6)
    6170 *
    6171 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    6172 *
     6170
     6171|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     6172
    61736173                asl     #5,D0
    61746174                ext.l   D0
    61756175                move.l  D0,A_FPU
    6176                 add.l   #_io_fpu+$4000,A_FPU
    6177 *
    6178 *       fp = &ip->idhfnc[11];
    6179 *
     6176                add.l   #_io_fpu+0x4000,A_FPU
     6177
     6178|       fp = &ip->idhfnc[11];
     6179
    61806180                move.l  #132,A_FP
    61816181                add.l   IP(A6),A_FP
    61826182                add.l   #86,A_FP
    6183 *
    6184 *       pt = &ip->idhpnt[fp->idfpt1];
    6185 *
     6183
     6184|       pt = &ip->idhpnt[fp->idfpt1];
     6185
    61866186                clr.l   D0
    61876187                move.b  6(A_FP),D0
    … …  
    61936193                add.l   #242,D0
    61946194                move.l  D0,PT(A6)
    6195 *
    6196                 .page
    6197 *
    6198 *       srcnum = group | fp->idfsrc;
    6199 *
     6195
     6196                .page
     6197
     6198|       srcnum = group | fp->idfsrc;
     6199
    62006200                move.w  GROUP(A6),D0
    62016201                ext.l   D0
    … …  
    62046204                or      D1,D0
    62056205                move    D0,SRCNUM(A6)
    6206 *
    6207 *       vep = &valents[srcnum];
    6208 *
     6206
     6207|       vep = &valents[srcnum];
     6208
    62096209                add.l   D0,D0
    62106210                move.l  D0,D1
    … …  
    62136213                add.l   #_valents,D0
    62146214                move.l  D0,VEP(A6)
    6215 *
    6216 *       smp = vpsms[vp];
    6217 *
     6215
     6216|       smp = vpsms[vp];
     6217
    62186218                move    VP(A6),A0
    62196219                add.l   A0,A0
    … …  
    62216221                add.l   #_vpsms,A0
    62226222                move.l  (A0),A_SMP
    6223 *
    6224 *       if (srcnum NE smp->sm) {
    6225 *
     6223
     6224|       if (srcnum NE smp->sm) {
     6225
    62266226                clr     D0
    62276227                move    10(A_SMP),D0
    62286228                cmp     SRCNUM(A6),D0
    62296229                beq     F11L113
    6230 *
    6231 *               (smp->prv)->nxt = smp->nxt;
    6232 *
     6230
     6231|               (smp->prv)->nxt = smp->nxt;
     6232
    62336233                move.l  4(A_SMP),A0
    62346234                move.l  (A_SMP),(A0)
    6235 *
    6236 *               (smp->nxt)->prv = smp->prv;
    6237 *
     6235
     6236|               (smp->nxt)->prv = smp->prv;
     6237
    62386238                move.l  (A_SMP),A0
    62396239                move.l  4(A_SMP),4(A0)
    6240 *
    6241 *               smp->prv = (struct sment *)vep;
    6242 *
     6240
     6241|               smp->prv = (struct sment |)vep;
     6242
    62436243                move.l  VEP(A6),4(A_SMP)
    6244 *
    6245 *               smp->nxt = vep->nxt;
    6246 *
     6244
     6245|               smp->nxt = vep->nxt;
     6246
    62476247                move.l  VEP(A6),A0
    62486248                move.l  (A0),(A_SMP)
    6249 *
    6250 *               (vep->nxt)->prv = smp;
    6251 *
     6249
     6250|               (vep->nxt)->prv = smp;
     6251
    62526252                move.l  VEP(A6),A0
    62536253                move.l  (A0),A0
    62546254                move.l  A_SMP,4(A0)
    6255 *
    6256 *               vep->nxt = smp;
    6257 *
     6255
     6256|               vep->nxt = smp;
     6257
    62586258                move.l  VEP(A6),A0
    62596259                move.l  A_SMP,(A0)
    6260 *
    6261 *               smp->sm = srcnum;
    6262 *
     6260
     6261|               smp->sm = srcnum;
     6262
    62636263                move    SRCNUM(A6),10(A_SMP)
    6264 *
    6265 *       }
    6266 *
    6267 *       mltval = fp->idfmlt;
    6268 *
     6264
     6265|       }
     6266
     6267|       mltval = fp->idfmlt;
     6268
    62696269F11L113:        move    2(A_FP),MLTVAL(A6)
    6270 *
    6271                 .page
    6272 *
    6273 *       switch (fp->idfsrc) {
    6274 *
     6270
     6271                .page
     6272
     6273|       switch (fp->idfsrc) {
     6274
    62756275                move.b  4(A_FP),D0
    62766276                ext.w   d0
    62776277                cmp     #10,D0
    62786278                bhi     F11L122
    6279 *
     6279
    62806280                asl     #2,D0
    62816281                lea     F11L123,A0
    62826282                movea.l 0(A0,D0.W),A0
    62836283                jmp     (A0)
    6284 *
    6285 *       case SM_NONE:
    6286 *               mltval = 0;
    6287 *
     6284
     6285|       case SM_NONE:
     6286|               mltval = 0;
     6287
    62886288F11L116:        clr     MLTVAL(A6)
    6289 *
    6290 *               tsrcval = 0;
    6291 *
     6289
     6290|               tsrcval = 0;
     6291
    62926292                clr     TSRCVAL(A6)
    6293 *
    6294 *               break;
    6295 *
     6293
     6294|               break;
     6295
    62966296                bra     F11L114
    6297 *
    6298 *       case SM_RAND:
    6299 *               tsrcval = xgetran(mltval);
    6300 *
     6297
     6298|       case SM_RAND:
     6299|               tsrcval = xgetran(mltval);
     6300
    63016301F11L117:        move    MLTVAL(A6),(sp)
    63026302                jsr     _xgetran
    63036303                move    D0,TSRCVAL(A6)
    6304 *
    6305 *               break;
    6306 *
     6304
     6305|               break;
     6306
    63076307                bra     F11L114
    6308 *
    6309 *       case SM_PTCH:
    6310 *               tsrcval = pch;
    6311 *
     6308
     6309|       case SM_PTCH:
     6310|               tsrcval = pch;
     6311
    63126312F11L118:        move    PCH(A6),TSRCVAL(A6)
    6313 *
    6314 *               break;
    6315 *
     6313
     6314|               break;
     6315
    63166316                bra     F11L114
    6317 *
    6318                 .page
    6319 *
    6320 *       case SM_FREQ:
    6321 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    6322 *
     6317
     6318                .page
     6319
     6320|       case SM_FREQ:
     6321|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     6322
    63236323F11L119:        move    PCH(A6),D0
    63246324                asr     #7,D0
    … …  
    63286328                add.l   #_ptoftab,A0
    63296329                move    (A0),TSRCVAL(A6)
    6330 *
    6331 *               break;
    6332 *
     6330
     6331|               break;
     6332
    63336333                bra     F11L114
    6334 *
    6335 *       case SM_KVEL:
    6336 *               tsrcval = veltab[trg];
    6337 *
     6334
     6335|       case SM_KVEL:
     6336|               tsrcval = veltab[trg];
     6337
    63386338F11L120:        move    TRG(A6),A0
    63396339                add.l   A0,A0
    63406340                add.l   #_veltab,A0
    63416341                move    (A0),TSRCVAL(A6)
    6342 *
    6343 *               break;
    6344 *
     6342
     6343|               break;
     6344
    63456345                bra     F11L114
    6346 *
    6347 *       case SM_KPRS:
    6348 *               tsrcval = prstab[trg];
    6349 *
     6346
     6347|       case SM_KPRS:
     6348|               tsrcval = prstab[trg];
     6349
    63506350F11L121:        move    TRG(A6),A0
    63516351                add.l   A0,A0
    63526352                add.l   #_prstab,A0
    63536353                move    (A0),TSRCVAL(A6)
    6354 *
    6355 *               break;
    6356 *
     6354
     6355|               break;
     6356
    63576357                bra     F11L114
    6358 *
    6359 *       default:
    6360 *               tsrcval = vep->val;
    6361 *
     6358
     6359|       default:
     6360|               tsrcval = vep->val;
     6361
    63626362F11L122:        move.l  VEP(A6),A0
    63636363                move    8(A0),TSRCVAL(A6)
    6364 *
    6365 *       }
    6366 *
    6367                 .page
    6368 *
    6369 *               srcval = tsrcval;
    6370 *
     6364
     6365|       }
     6366
     6367                .page
     6368
     6369|               srcval = tsrcval;
     6370
    63716371F11L114:        move    TSRCVAL(A6),SRCVAL(A6)
    6372 *
    6373                 .page
    6374 *
    6375 *       if (pt->ipvsrc) {
    6376 *
     6372
     6373                .page
     6374
     6375|       if (pt->ipvsrc) {
     6376
    63776377F11L124:        move.l  PT(A6),A0
    63786378                tst.b   6(A0)
    63796379                beq     F11L136
    6380 *
    6381 *               switch (pt->ipvsrc) {
    6382 *
     6380
     6381|               switch (pt->ipvsrc) {
     6382
    63836383                move.l  PT(A6),A0
    63846384                move.b  6(A0),D0
    … …  
    63876387                cmp     #9,D0
    63886388                bhi     F11L144
    6389 *
     6389
    63906390                asl     #2,D0
    63916391                lea     F11L145,A0
    63926392                move.l  0(A0,D0.W),A0
    63936393                jmp     (A0)
    6394 *
    6395 *               case SM_RAND:
    6396 *                       ltmp = xgetran(pt_>ipvmlt);
    6397 *
     6394
     6395|               case SM_RAND:
     6396|                       ltmp = xgetran(pt_>ipvmlt);
     6397
    63986398F11L139:        move.l  PT(A6),A0
    63996399                move    4(A0),(sp)
    … …  
    64016401                ext.l   D0
    64026402                move.l  D0,LTMP(A6)
    6403 *
    6404 *                       break;
    6405 *
     6403
     6404|                       break;
     6405
    64066406                bra     F11L137
    6407 *
    6408 *               case SM_PTCH:
    6409 *                       ltmp = pch;
    6410 *
     6407
     6408|               case SM_PTCH:
     6409|                       ltmp = pch;
     6410
    64116411F11L140:        move    PCH(A6),A0
    64126412                move.l  A0,LTMP(A6)
    6413 *
    6414 *                       break;
    6415 *
     6413
     6414|                       break;
     6415
    64166416                bra     F11L137
    6417 *
    6418                 .page
    6419 *
    6420 *               case SM_FREQ:
    6421 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    6422 *
     6417
     6418                .page
     6419
     6420|               case SM_FREQ:
     6421|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     6422
    64236423F11L141:        move    PCH(A6),D0
    64246424                asr     #7,D0
    … …  
    64306430                ext.l   D0
    64316431                move.l  D0,LTMP(A6)
    6432 *
    6433 *                       break;
    6434 *
     6432
     6433|                       break;
     6434
    64356435                bra     F11L137
    6436 *
    6437 *               case SM_KVEL:
    6438 *                       ltmp = veltab[trg];
    6439 *
     6436
     6437|               case SM_KVEL:
     6438|                       ltmp = veltab[trg];
     6439
    64406440F11L142:        move    TRG(A6),A0
    64416441                add.l   A0,A0
    … …  
    64446444                ext.l   D0
    64456445                move.l  D0,LTMP(A6)
    6446 *
    6447 *                       break;
    6448 *
     6446
     6447|                       break;
     6448
    64496449                bra     F11L137
    6450 *
    6451                 .page
    6452 *
    6453 *               case SM_KPRS:
    6454 *                       ltmp = prstab[trg];
    6455 *
     6450
     6451                .page
     6452
     6453|               case SM_KPRS:
     6454|                       ltmp = prstab[trg];
     6455
    64566456F11L143:        move    TRG(A6),A0
    64576457                add.l   A0,A0
    … …  
    64606460                ext.l   D0
    64616461                move.l  D0,LTMP(A6)
    6462 *
    6463 *                       break;
    6464 *
     6462
     6463|                       break;
     6464
    64656465                bra     F11L137
    6466 *
    6467                 .page
    6468 *
    6469 *               default:
    6470 *                       ltmp = valents[group | pt->ipvsrc].val;
    6471 *
     6466
     6467                .page
     6468
     6469|               default:
     6470|                       ltmp = valents[group | pt->ipvsrc].val;
     6471
    64726472F11L144:        move.l  PT(A6),A0
    64736473                clr.l   D0
    … …  
    64836483                move    8(A0,A1.l),D0
    64846484                move.l  D0,LTMP(A6)
    6485 *
    6486 *               }
    6487 *
    6488 *
    6489                 .page
    6490 *
    6491 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    6492 *
     6485
     6486|               }
     6487
     6488
     6489                .page
     6490
     6491|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     6492
    64936493F11L137:        move.l  PT(A6),A0
    64946494                move.w  4(A0),D0
    … …  
    64986498                asr.l   D1,D0
    64996499                move.l  D0,LTMP(A6)
    6500 *
    6501 *               ltmp += (long)pt->ipval;
    6502 *
     6500
     6501|               ltmp += (long)pt->ipval;
     6502
    65036503                move.l  PT(A6),A0
    65046504                move    2(A0),D0
    65056505                ext.l   D0
    65066506                add.l   D0,LTMP(A6)
    6507 *
    6508 *               if (ltmp GT (long)VALMAX)
    6509 *                       ltmp = (long)VALMAX;
    6510 *
     6507
     6508|               if (ltmp GT (long)VALMAX)
     6509|                       ltmp = (long)VALMAX;
     6510
    65116511                cmp.l   #VALMAX,LTMP(A6)
    65126512                ble     F11L146
    6513 *
     6513
    65146514                move.l  #VALMAX,LTMP(A6)
    65156515                bra     F11L147
    6516 *
    6517 *               else if (ltmp LT (long)VALMIN)
    6518 *                       ltmp = (long)VALMIN;
    6519 *
     6516
     6517|               else if (ltmp LT (long)VALMIN)
     6518|                       ltmp = (long)VALMIN;
     6519
    65206520F11L146:        cmp.l   #VALMIN,LTMP(A6)
    65216521                bge     F11L147
    6522 *
     6522
    65236523                move.l  #VALMIN,LTMP(A6)
    6524 *
    6525 *               tfpval = (short)ltmp;
    6526 *
     6524
     6525|               tfpval = (short)ltmp;
     6526
    65276527F11L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    65286528                bra     F11L149
    6529 *
    6530 *       } else {
    6531 *
    6532 *               tfpval = pt->ipval;
    6533 *
     6529
     6530|       } else {
     6531
     6532|               tfpval = pt->ipval;
     6533
    65346534F11L136:        move.l  PT(A6),A0
    65356535                move    2(A0),TFPVAL(A6)
    6536 *
    6537 *       }
    6538 *
    6539                 .page
    6540 *
    6541 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    6542 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    6543 *
     6536
     6537|       }
     6538
     6539                .page
     6540
     6541|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     6542|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     6543
    65446544F11L149:        move.l  PT(A6),A0
    65456545                move.w  (A0),D0
    65466546                move.w  D0,D2
    6547                 andi.w  #$FFF0,D0
     6547                andi.w  #0xFFF0,D0
    65486548                move.w  _timemlt,D1
    65496549                muls    D1,D0
    … …  
    65516551                asr.l   D1,D0
    65526552                move    D0,R_FPMANT
    6553 *
    6554 *       fpexp = expbit[pt->iptim & 0x000F];
    6555 *
    6556                 and     #$000F,D2
     6553
     6554|       fpexp = expbit[pt->iptim & 0x000F];
     6555
     6556                and     #0x000F,D2
    65576557                move    D2,A0
    65586558                add.l   A0,A0
    65596559                add.l   #_expbit,A0
    65606560                move    (A0),R_FPEXP
    6561 *
    6562                 .page
    6563 *
    6564 *               fp->idfpch = pch;
    6565 *
     6561
     6562                .page
     6563
     6564|               fp->idfpch = pch;
     6565
    65666566F11L163:        move    PCH(A6),(A_FP)
    6567 *
    6568 *               fpval = tfpval;
    6569 *
     6567
     6568|               fpval = tfpval;
     6569
    65706570                move    TFPVAL(A6),R_FPVAL
    6571 *
    6572                 .page
    6573 *
     6571
     6572                .page
     6573
    65746574                move.b  5(A_FP),D0
    65756575                ext.w   D0
    65766576                sub.w   #1,D0
    65776577                movea.l PT(A6),A0
    6578 *
    6579 *       oldi = setipl(FPU_DI);
    6580 *
     6578
     6579|       oldi = setipl(FPU_DI);
     6580
    65816581                move    sr,OLDI(A6)
    65826582                move    #FPU_DI,sr
    6583 *
     6583
    65846584F11L168:        clr.b   10(A0)
    65856585                add.l   #12,a0
    65866586                dbra    D0,F11L168
    6587 *
    6588                 .page
    6589 *
    6590 *       fp->idftmd ^= I_NVBITS;
    6591 *
     6587
     6588                .page
     6589
     6590|       fp->idftmd ^= I_NVBITS;
     6591
    65926592F11L165:        eor.b   #24,7(A_FP)
    6593 *
    6594 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    6595 *
     6593
     6594|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     6595
    65966596                move.b  7(A_FP),R_FPCTL
    65976597                and     #28,R_FPCTL
    65986598                or      #3,R_FPCTL
    6599 *
    6600 *       fp->idfcpt = fp->idfpt1;
    6601 *
     6599
     6600|       fp->idfcpt = fp->idfpt1;
     6601
    66026602                move.b  6(A_FP),8(A_FP)
    6603 *
    6604 *       fp->idftmd |= I_ACTIVE;
    6605 *
     6603
     6604|       fp->idftmd |= I_ACTIVE;
     6605
    66066606                or.b    #2,7(A_FP)
    6607 *
    6608 *       fp->idftrf = trg;
    6609 *
     6607
     6608|       fp->idftrf = trg;
     6609
    66106610                move    TRG(A6),10(A_FP)
    6611 *
    6612 *       *(fpu + (long)FPU_TCV1) = srcval;
    6613 *
    6614                 move    SRCVAL(A6),$8(A_FPU)
    6615 *
    6616 *       ++octype;
    6617 *
     6611
     6612|       |(fpu + (long)FPU_TCV1) = srcval;
     6613
     6614                move    SRCVAL(A6),0x8(A_FPU)
     6615
     6616|       ++octype;
     6617
    66186618                add     #1,OCTYPE(A6)
    6619 *
    6620 *       *(fpu + (long)FPU_TSF1) = mltval;
    6621 *
    6622                 move    MLTVAL(A6),$A(A_FPU)
    6623 *
    6624 *       ++octype;
    6625 *
     6619
     6620|       |(fpu + (long)FPU_TSF1) = mltval;
     6621
     6622                move    MLTVAL(A6),0xA(A_FPU)
     6623
     6624|       ++octype;
     6625
    66266626                add     #1,OCTYPE(A6)
    6627 *
    6628 *       *(fpu + (long)FPU_TMNT) = fpmant;
    6629 *
    6630                 move    R_FPMANT,$14(A_FPU)
    6631 *
    6632 *       ++octype;
    6633 *
     6627
     6628|       |(fpu + (long)FPU_TMNT) = fpmant;
     6629
     6630                move    R_FPMANT,0x14(A_FPU)
     6631
     6632|       ++octype;
     6633
    66346634                add     #1,OCTYPE(A6)
    6635 *
    6636 *       *(fpu + (long)FPU_TEXP) = fpexp;
    6637 *
    6638                 move    R_FPEXP,$16(A_FPU)
    6639 *
    6640 *       ++octype;
    6641 *
     6635
     6636|       |(fpu + (long)FPU_TEXP) = fpexp;
     6637
     6638                move    R_FPEXP,0x16(A_FPU)
     6639
     6640|       ++octype;
     6641
    66426642                add     #1,OCTYPE(A6)
    6643 *
    6644                 .page
    6645 *
    6646 *       if (fp->idftmd & I_VNSUBN)
    6647 *
     6643
     6644                .page
     6645
     6646|       if (fp->idftmd & I_VNSUBN)
     6647
    66486648                btst    #3,7(A_FP)
    66496649                beq     F11L169
    6650 *
    6651 *               *(fpu + (long)FPU_TNV1) = fpval;
    6652 *
    6653                 move    R_FPVAL,$1C(A_FPU)
     6650
     6651|               |(fpu + (long)FPU_TNV1) = fpval;
     6652
     6653                move    R_FPVAL,0x1C(A_FPU)
    66546654                bra     F11L170
    6655 *
    6656 *       else
    6657 *               *(fpu + (long)FPU_TNV0) = fpval;
    6658 *
     6655
     6656|       else
     6657|               |(fpu + (long)FPU_TNV0) = fpval;
     6658
    66596659F11L169:        move    R_FPVAL,2(A_FPU)
    6660 *
    6661 *       ++octype;
    6662 *
     6660
     6661|       ++octype;
     6662
    66636663F11L170:        add     #1,OCTYPE(A6)
    6664 *
    6665 *       *(fpu + (long)FPU_TCTL) = fpctl;
    6666 *
     6664
     6665|       |(fpu + (long)FPU_TCTL) = fpctl;
     6666
    66676667                move    R_FPCTL,(A_FPU)
    6668 *
    6669 *       setipl(oldi);
    6670 *
     6668
     6669|       setipl(oldi);
     6670
    66716671                move    OLDI(A6),sr
    6672 *
    6673                 .page
    6674 * ------------------------------------------------------------------------------
    6675 * Start function 12 -- Level
    6676 * ------------------------------------------------------------------------------
    6677 *
    6678 *    if (ip->idhfnc[12].idftmd & I_TM_KEY) {
    6679 *
     6672
     6673                .page
     6674| ------------------------------------------------------------------------------
     6675| Start function 12 -- Level
     6676| ------------------------------------------------------------------------------
     6677
     6678|    if (ip->idhfnc[12].idftmd & I_TM_KEY) {
     6679
    66806680FN12:           move.l  IP(A6),A0
    66816681                move.b  237(A0),D0
    … …  
    66846684                btst    #0,D0
    66856685                bne     FN12A
    6686 *
     6686
    66876687                jmp     FNEXIT
    6688 *
    6689 *       vp = (vce << 4) + 2;
    6690 *
     6688
     6689|       vp = (vce << 4) + 2;
     6690
    66916691FN12A:          move    VCE(A6),D0
    66926692                asl     #4,D0
    66936693                add.w   #2,D0
    66946694                move    D0,VP(A6)
    6695 *
    6696 *       fpu = io_fpu + FPU_OFNC + (vp << 4);
    6697 *
     6695
     6696|       fpu = io_fpu + FPU_OFNC + (vp << 4);
     6697
    66986698                asl     #5,D0
    66996699                ext.l   D0
    67006700                move.l  D0,A_FPU
    6701                 add.l   #_io_fpu+$4000,A_FPU
    6702 *
    6703 *       fp = &ip->idhfnc[12];
    6704 *
     6701                add.l   #_io_fpu+0x4000,A_FPU
     6702
     6703|       fp = &ip->idhfnc[12];
     6704
    67056705                move.l  #144,A_FP
    67066706                add.l   IP(A6),A_FP
    67076707                add.l   #86,A_FP
    6708 *
    6709 *       pt = &ip->idhpnt[fp->idfpt1];
    6710 *
     6708
     6709|       pt = &ip->idhpnt[fp->idfpt1];
     6710
    67116711                clr.l   D0
    67126712                move.b  6(A_FP),D0
    … …  
    67186718                add.l   #242,D0
    67196719                move.l  D0,PT(A6)
    6720 *
    6721                 .page
    6722 *
    6723 *       srcnum = group | fp->idfsrc;
    6724 *
     6720
     6721                .page
     6722
     6723|       srcnum = group | fp->idfsrc;
     6724
    67256725                move.w  GROUP(A6),D0
    67266726                ext.l   D0
    … …  
    67296729                or      D1,D0
    67306730                move    D0,SRCNUM(A6)
    6731 *
    6732 *       vep = &valents[srcnum];
    6733 *
     6731
     6732|       vep = &valents[srcnum];
     6733
    67346734                add.l   D0,D0
    67356735                move.l  D0,D1
    … …  
    67386738                add.l   #_valents,D0
    67396739                move.l  D0,VEP(A6)
    6740 *
    6741 *       smp = vpsms[vp];
    6742 *
     6740
     6741|       smp = vpsms[vp];
     6742
    67436743                move    VP(A6),A0
    67446744                add.l   A0,A0
    … …  
    67466746                add.l   #_vpsms,A0
    67476747                move.l  (A0),A_SMP
    6748 *
    6749 *       if (srcnum NE smp->sm) {
    6750 *
     6748
     6749|       if (srcnum NE smp->sm) {
     6750
    67516751                clr     D0
    67526752                move    10(A_SMP),D0
    67536753                cmp     SRCNUM(A6),D0
    67546754                beq     F12L113
    6755 *
    6756 *               (smp->prv)->nxt = smp->nxt;
    6757 *
     6755
     6756|               (smp->prv)->nxt = smp->nxt;
     6757
    67586758                move.l  4(A_SMP),A0
    67596759                move.l  (A_SMP),(A0)
    6760 *
    6761 *               (smp->nxt)->prv = smp->prv;
    6762 *
     6760
     6761|               (smp->nxt)->prv = smp->prv;
     6762
    67636763                move.l  (A_SMP),A0
    67646764                move.l  4(A_SMP),4(A0)
    6765 *
    6766 *               smp->prv = (struct sment *)vep;
    6767 *
     6765
     6766|               smp->prv = (struct sment |)vep;
     6767
    67686768                move.l  VEP(A6),4(A_SMP)
    6769 *
    6770 *               smp->nxt = vep->nxt;
    6771 *
     6769
     6770|               smp->nxt = vep->nxt;
     6771
    67726772                move.l  VEP(A6),A0
    67736773                move.l  (A0),(A_SMP)
    6774 *
    6775 *               (vep->nxt)->prv = smp;
    6776 *
     6774
     6775|               (vep->nxt)->prv = smp;
     6776
    67776777                move.l  VEP(A6),A0
    67786778                move.l  (A0),A0
    67796779                move.l  A_SMP,4(A0)
    6780 *
    6781 *               vep->nxt = smp;
    6782 *
     6780
     6781|               vep->nxt = smp;
     6782
    67836783                move.l  VEP(A6),A0
    67846784                move.l  A_SMP,(A0)
    6785 *
    6786 *               smp->sm = srcnum;
    6787 *
     6785
     6786|               smp->sm = srcnum;
     6787
    67886788                move    SRCNUM(A6),10(A_SMP)
    6789 *
    6790 *       }
    6791 *
    6792 *       mltval = fp->idfmlt;
    6793 *
     6789
     6790|       }
     6791
     6792|       mltval = fp->idfmlt;
     6793
    67946794F12L113:        move    2(A_FP),MLTVAL(A6)
    6795 *
    6796                 .page
    6797 *
    6798 *       switch (fp->idfsrc) {
    6799 *
     6795
     6796                .page
     6797
     6798|       switch (fp->idfsrc) {
     6799
    68006800                move.b  4(A_FP),D0
    68016801                ext.w   d0
    68026802                cmp     #10,D0
    68036803                bhi     F12L122
    6804 *
     6804
    68056805                asl     #2,D0
    68066806                lea     F12L123,A0
    68076807                movea.l 0(A0,D0.W),A0
    68086808                jmp     (A0)
    6809 *
    6810 *       case SM_NONE:
    6811 *               mltval = 0;
    6812 *
     6809
     6810|       case SM_NONE:
     6811|               mltval = 0;
     6812
    68136813F12L116:        clr     MLTVAL(A6)
    6814 *
    6815 *               tsrcval = 0;
    6816 *
     6814
     6815|               tsrcval = 0;
     6816
    68176817                clr     TSRCVAL(A6)
    6818 *
    6819 *               break;
    6820 *
     6818
     6819|               break;
     6820
    68216821                bra     F12L114
    6822 *
    6823 *       case SM_RAND:
    6824 *               tsrcval = xgetran(mltval);
    6825 *
     6822
     6823|       case SM_RAND:
     6824|               tsrcval = xgetran(mltval);
     6825
    68266826F12L117:        move    MLTVAL(A6),(sp)
    68276827                jsr     _xgetran
    68286828                move    D0,TSRCVAL(A6)
    6829 *
    6830 *               break;
    6831 *
     6829
     6830|               break;
     6831
    68326832                bra     F12L114
    6833 *
    6834 *       case SM_PTCH:
    6835 *               tsrcval = pch;
    6836 *
     6833
     6834|       case SM_PTCH:
     6835|               tsrcval = pch;
     6836
    68376837F12L118:        move    PCH(A6),TSRCVAL(A6)
    6838 *
    6839 *               break;
    6840 *
     6838
     6839|               break;
     6840
    68416841                bra     F12L114
    6842 *
    6843                 .page
    6844 *
    6845 *       case SM_FREQ:
    6846 *               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
    6847 *
     6842
     6843                .page
     6844
     6845|       case SM_FREQ:
     6846|               tsrcval = ptoftab[(pch >> 7) & 0x00FF];
     6847
    68486848F12L119:        move    PCH(A6),D0
    68496849                asr     #7,D0
    … …  
    68536853                add.l   #_ptoftab,A0
    68546854                move    (A0),TSRCVAL(A6)
    6855 *
    6856 *               break;
    6857 *
     6855
     6856|               break;
     6857
    68586858                bra     F12L114
    6859 *
    6860 *       case SM_KVEL:
    6861 *               tsrcval = veltab[trg];
    6862 *
     6859
     6860|       case SM_KVEL:
     6861|               tsrcval = veltab[trg];
     6862
    68636863F12L120:        move    TRG(A6),A0
    68646864                add.l   A0,A0
    68656865                add.l   #_veltab,A0
    68666866                move    (A0),TSRCVAL(A6)
    6867 *
    6868 *               break;
    6869 *
     6867
     6868|               break;
     6869
    68706870                bra     F12L114
    6871 *
    6872 *       case SM_KPRS:
    6873 *               tsrcval = prstab[trg];
    6874 *
     6871
     6872|       case SM_KPRS:
     6873|               tsrcval = prstab[trg];
     6874
    68756875F12L121:        move    TRG(A6),A0
    68766876                add.l   A0,A0
    68776877                add.l   #_prstab,A0
    68786878                move    (A0),TSRCVAL(A6)
    6879 *
    6880 *               break;
    6881 *
     6879
     6880|               break;
     6881
    68826882                bra     F12L114
    6883 *
    6884 *       default:
    6885 *               tsrcval = vep->val;
    6886 *
     6883
     6884|       default:
     6885|               tsrcval = vep->val;
     6886
    68876887F12L122:        move.l  VEP(A6),A0
    68886888                move    8(A0),TSRCVAL(A6)
    6889 *
    6890 *       }
    6891 *
    6892                 .page
    6893 *
    6894 *               srcval = tsrcval;
    6895 *
     6889
     6890|       }
     6891
     6892                .page
     6893
     6894|               srcval = tsrcval;
     6895
    68966896F12L114:        move    TSRCVAL(A6),SRCVAL(A6)
    6897 *
    6898                 .page
    6899 *
    6900 *       if (pt->ipvsrc) {
    6901 *
     6897
     6898                .page
     6899
     6900|       if (pt->ipvsrc) {
     6901
    69026902F12L124:        move.l  PT(A6),A0
    69036903                tst.b   6(A0)
    69046904                beq     F12L136
    6905 *
    6906 *               switch (pt->ipvsrc) {
    6907 *
     6905
     6906|               switch (pt->ipvsrc) {
     6907
    69086908                move.l  PT(A6),A0
    69096909                move.b  6(A0),D0
    … …  
    69126912                cmp     #9,D0
    69136913                bhi     F12L144
    6914 *
     6914
    69156915                asl     #2,D0
    69166916                lea     F12L145,A0
    69176917                move.l  0(A0,D0.W),A0
    69186918                jmp     (A0)
    6919 *
    6920 *               case SM_RAND:
    6921 *                       ltmp = xgetran(pt_>ipvmlt);
    6922 *
     6919
     6920|               case SM_RAND:
     6921|                       ltmp = xgetran(pt_>ipvmlt);
     6922
    69236923F12L139:        move.l  PT(A6),A0
    69246924                move    4(A0),(sp)
    … …  
    69266926                ext.l   D0
    69276927                move.l  D0,LTMP(A6)
    6928 *
    6929 *                       break;
    6930 *
     6928
     6929|                       break;
     6930
    69316931                bra     F12L137
    6932 *
    6933 *               case SM_PTCH:
    6934 *                       ltmp = pch;
    6935 *
     6932
     6933|               case SM_PTCH:
     6934|                       ltmp = pch;
     6935
    69366936F12L140:        move    PCH(A6),A0
    69376937                move.l  A0,LTMP(A6)
    6938 *
    6939 *                       break;
    6940 *
     6938
     6939|                       break;
     6940
    69416941                bra     F12L137
    6942 *
    6943                 .page
    6944 *
    6945 *               case SM_FREQ:
    6946 *                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
    6947 *
     6942
     6943                .page
     6944
     6945|               case SM_FREQ:
     6946|                       ltmp = ptoftab[(pch >> 7) & 0x00FF];
     6947
    69486948F12L141:        move    PCH(A6),D0
    69496949                asr     #7,D0
    … …  
    69556955                ext.l   D0
    69566956                move.l  D0,LTMP(A6)
    6957 *
    6958 *                       break;
    6959 *
     6957
     6958|                       break;
     6959
    69606960                bra     F12L137
    6961 *
    6962 *               case SM_KVEL:
    6963 *                       ltmp = veltab[trg];
    6964 *
     6961
     6962|               case SM_KVEL:
     6963|                       ltmp = veltab[trg];
     6964
    69656965F12L142:        move    TRG(A6),A0
    69666966                add.l   A0,A0
    … …  
    69696969                ext.l   D0
    69706970                move.l  D0,LTMP(A6)
    6971 *
    6972 *                       break;
    6973 *
     6971
     6972|                       break;
     6973
    69746974                bra     F12L137
    6975 *
    6976                 .page
    6977 *
    6978 *               case SM_KPRS:
    6979 *                       ltmp = prstab[trg];
    6980 *
     6975
     6976                .page
     6977
     6978|               case SM_KPRS:
     6979|                       ltmp = prstab[trg];
     6980
    69816981F12L143:        move    TRG(A6),A0
    69826982                add.l   A0,A0
    … …  
    69856985                ext.l   D0
    69866986                move.l  D0,LTMP(A6)
    6987 *
    6988 *                       break;
    6989 *
     6987
     6988|                       break;
     6989
    69906990                bra     F12L137
    6991 *
    6992                 .page
    6993 *
    6994 *               default:
    6995 *                       ltmp = valents[group | pt->ipvsrc].val;
    6996 *
     6991
     6992                .page
     6993
     6994|               default:
     6995|                       ltmp = valents[group | pt->ipvsrc].val;
     6996
    69976997F12L144:        move.l  PT(A6),A0
    69986998                clr.l   D0
    … …  
    70087008                move    8(A0,A1.l),D0
    70097009                move.l  D0,LTMP(A6)
    7010 *
    7011 *               }
    7012 *
    7013 *
    7014                 .page
    7015 *
    7016 *               ltmp = (ltmp * pt->ipvmlt) >> 15;
    7017 *
     7010
     7011|               }
     7012
     7013
     7014                .page
     7015
     7016|               ltmp = (ltmp | pt->ipvmlt) >> 15;
     7017
    70187018F12L137:        move.l  PT(A6),A0
    70197019                move.w  4(A0),D0
    … …  
    70237023                asr.l   D1,D0
    70247024                move.l  D0,LTMP(A6)
    7025 *
    7026 *               ltmp += (long)pt->ipval;
    7027 *
     7025
     7026|               ltmp += (long)pt->ipval;
     7027
    70287028                move.l  PT(A6),A0
    70297029                move    2(A0),D0
    70307030                ext.l   D0
    70317031                add.l   D0,LTMP(A6)
    7032 *
    7033 *               if (ltmp GT (long)VALMAX)
    7034 *                       ltmp = (long)VALMAX;
    7035 *
     7032
     7033|               if (ltmp GT (long)VALMAX)
     7034|                       ltmp = (long)VALMAX;
     7035
    70367036                cmp.l   #VALMAX,LTMP(A6)
    70377037                ble     F12L146
    7038 *
     7038
    70397039                move.l  #VALMAX,LTMP(A6)
    70407040                bra     F12L147
    7041 *
    7042 *               else if (ltmp LT (long)VALMIN)
    7043 *                       ltmp = (long)VALMIN;
    7044 *
     7041
     7042|               else if (ltmp LT (long)VALMIN)
     7043|                       ltmp = (long)VALMIN;
     7044
    70457045F12L146:        cmp.l   #VALMIN,LTMP(A6)
    70467046                bge     F12L147
    7047 *
     7047
    70487048                move.l  #VALMIN,LTMP(A6)
    7049 *
    7050 *               tfpval = (short)ltmp;
    7051 *
     7049
     7050|               tfpval = (short)ltmp;
     7051
    70527052F12L147:        move.w  LTMP+2(A6),TFPVAL(A6)
    70537053                bra     F12L149
    7054 *
    7055 *       } else {
    7056 *
    7057 *               tfpval = pt->ipval;
    7058 *
     7054
     7055|       } else {
     7056
     7057|               tfpval = pt->ipval;
     7058
    70597059F12L136:        move.l  PT(A6),A0
    70607060                move    2(A0),TFPVAL(A6)
    7061 *
    7062 *       }
    7063 *
    7064                 .page
    7065 *
    7066 *       fpmant = (((long)pt->iptom & 0x0000FFF0L)
    7067 *               * ((long)timemlt & 0x0000FFFFL)) >> 15;
    7068 *
     7061
     7062|       }
     7063
     7064                .page
     7065
     7066|       fpmant = (((long)pt->iptom & 0x0000FFF0L)
     7067|               | ((long)timemlt & 0x0000FFFFL)) >> 15;
     7068
    70697069F12L149:        move.l  PT(A6),A0
    70707070                move.w  (A0),D0
    70717071                move.w  D0,D2
    7072                 andi.w  #$FFF0,D0
     7072                andi.w  #0xFFF0,D0
    70737073                move.w  _timemlt,D1
    70747074                muls    D1,D0
    … …  
    70767076                asr.l   D1,D0
    70777077                move    D0,R_FPMANT
    7078 *
    7079 *       fpexp = expbit[pt->iptim & 0x000F];
    7080 *
    7081                 and     #$000F,D2
     7078
     7079|       fpexp = expbit[pt->iptim & 0x000F];
     7080
     7081                and     #0x000F,D2
    70827082                move    D2,A0
    70837083                add.l   A0,A0
    70847084                add.l   #_expbit,A0
    70857085                move    (A0),R_FPEXP
    7086 *
    7087                 .page
    7088 *
    7089 *               fp->idfpch = pch;
    7090 *
     7086
     7087                .page
     7088
     7089|               fp->idfpch = pch;
     7090
    70917091F12L162:        move    PCH(A6),(A_FP)
    7092 *
    7093 *               fpval = ((tfpval >> 5) - 500) << 6;
    7094 *
     7092
     7093|               fpval = ((tfpval >> 5) - 500) << 6;
     7094
    70957095                move    TFPVAL(A6),R_FPVAL
    70967096                asr     #5,R_FPVAL
    70977097                add     #-500,R_FPVAL
    70987098                asl     #6,R_FPVAL
    7099 *
    7100                 .page
    7101 *
     7099
     7100                .page
     7101
    71027102                move.b  5(A_FP),D0
    71037103                ext.w   D0
    71047104                sub.w   #1,D0
    71057105                movea.l PT(A6),A0
    7106 *
    7107 *       oldi = setipl(FPU_DI);
    7108 *
     7106
     7107|       oldi = setipl(FPU_DI);
     7108
    71097109                move    sr,OLDI(A6)
    71107110                move    #FPU_DI,sr
    7111 *
     7111
    71127112F12L168:        clr.b   10(A0)
    71137113                add.l   #12,a0
    71147114                dbra    D0,F12L168
    7115 *
    7116                 .page
    7117 *
    7118 *       fp->idftmd ^= I_NVBITS;
    7119 *
     7115
     7116                .page
     7117
     7118|       fp->idftmd ^= I_NVBITS;
     7119
    71207120F12L165:        eor.b   #24,7(A_FP)
    7121 *
    7122 *       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
    7123 *
     7121
     7122|       fpctl = (fp->idftmd & (I_NRATIO | I_NVBITS)) | 0x0003;
     7123
    71247124                move.b  7(A_FP),R_FPCTL
    71257125                and     #28,R_FPCTL
    71267126                or      #3,R_FPCTL
    7127 *
    7128 *       fp->idfcpt = fp->idfpt1;
    7129 *
     7127
     7128|       fp->idfcpt = fp->idfpt1;
     7129
    71307130                move.b  6(A_FP),8(A_FP)
    7131 *
    7132 *       fp->idftmd |= I_ACTIVE;
    7133 *
     7131
     7132|       fp->idftmd |= I_ACTIVE;
     7133
    71347134                or.b    #2,7(A_FP)
    7135 *
    7136 *       fp->idftrf = trg;
    7137 *
     7135
     7136|       fp->idftrf = trg;
     7137
    71387138                move    TRG(A6),10(A_FP)
    7139 *
    7140 *       *(fpu + (long)FPU_TCV1) = srcval;
    7141 *
    7142                 move    SRCVAL(A6),$8(A_FPU)
    7143 *
    7144 *       ++octype;
    7145 *
     7139
     7140|       |(fpu + (long)FPU_TCV1) = srcval;
     7141
     7142                move    SRCVAL(A6),0x8(A_FPU)
     7143
     7144|       ++octype;
     7145
    71467146                add     #1,OCTYPE(A6)
    7147 *
    7148 *       *(fpu + (long)FPU_TSF1) = mltval;
    7149 *
    7150                 move    MLTVAL(A6),$A(A_FPU)
    7151 *
    7152 *       ++octype;
    7153 *
     7147
     7148|       |(fpu + (long)FPU_TSF1) = mltval;
     7149
     7150                move    MLTVAL(A6),0xA(A_FPU)
     7151
     7152|       ++octype;
     7153
    71547154                add     #1,OCTYPE(A6)
    7155 *
    7156 *       *(fpu + (long)FPU_TMNT) = fpmant;
    7157 *
    7158                 move    R_FPMANT,$14(A_FPU)
    7159 *
    7160 *       ++octype;
    7161 *
     7155
     7156|       |(fpu + (long)FPU_TMNT) = fpmant;
     7157
     7158                move    R_FPMANT,0x14(A_FPU)
     7159
     7160|       ++octype;
     7161
    71627162                add     #1,OCTYPE(A6)
    7163 *
    7164 *       *(fpu + (long)FPU_TEXP) = fpexp;
    7165 *
    7166                 move    R_FPEXP,$16(A_FPU)
    7167 *
    7168 *       ++octype;
    7169 *
     7163
     7164|       |(fpu + (long)FPU_TEXP) = fpexp;
     7165
     7166                move    R_FPEXP,0x16(A_FPU)
     7167
     7168|       ++octype;
     7169
    71707170                add     #1,OCTYPE(A6)
    7171 *
    7172                 .page
    7173 *
    7174 *       if (fp->idftmd & I_VNSUBN)
    7175 *
     7171
     7172                .page
     7173
     7174|       if (fp->idftmd & I_VNSUBN)
     7175
    71767176                btst    #3,7(A_FP)
    71777177                beq     F12L169
    7178 *
    7179 *               *(fpu + (long)FPU_TNV1) = fpval;
    7180 *
    7181                 move    R_FPVAL,$1C(A_FPU)
     7178
     7179|               |(fpu + (long)FPU_TNV1) = fpval;
     7180
     7181                move    R_FPVAL,0x1C(A_FPU)
    71827182                bra     F12L170
    7183 *
    7184 *       else
    7185 *               *(fpu + (long)FPU_TNV0) = fpval;
    7186 *
     7183
     7184|       else
     7185|               |(fpu + (long)FPU_TNV0) = fpval;
     7186
    71877187F12L169:        move    R_FPVAL,2(A_FPU)
    7188 *
    7189 *       ++octype;
    7190 *
     7188
     7189|       ++octype;
     7190
    71917191F12L170:        add     #1,OCTYPE(A6)
    7192 *
    7193 *       *(fpu + (long)FPU_TCTL) = fpctl;
    7194 *
     7192
     7193|       |(fpu + (long)FPU_TCTL) = fpctl;
     7194
    71957195                move    R_FPCTL,(A_FPU)
    7196 *
    7197 *       setipl(oldi);
    7198 *
     7196
     7197|       setipl(oldi);
     7198
    71997199                move    OLDI(A6),sr
    7200 *
    7201 *    }
    7202 *
    7203                 .page
    7204 *
     7200
     7201|    }
     7202
     7203                .page
     7204
    72057205FNEXIT:         tst.l   (sp)+
    72067206                movem.l (sp)+,R_FPVAL-R_FPMANT/A_SMP-A_FP
    72077207                unlk    A6
    72087208                rts
    7209 *
    7210 * }
    7211 *
    7212                 .page
    7213 *
     7209
     7210| }
     7211
     7212                .page
     7213
    72147214                .data
    7215 *
    7216 * Jump tables for switch statements
    7217 * ---------------------------------
    7218 *
     7215
     7216| Jump tables for switch statements
     7217| ---------------------------------
     7218
    72197219F00L123:        .dc.l   F00L116
    72207220                .dc.l   F00L117
    … …  
    72287228                .dc.l   F00L122
    72297229                .dc.l   F00L119
    7230 *
     7230
    72317231F00L145:        .dc.l   F00L139
    72327232                .dc.l   F00L144
    … …  
    72397239                .dc.l   F00L144
    72407240                .dc.l   F00L141
    7241 *
     7241
    72427242F01L123:        .dc.l   F01L116
    72437243                .dc.l   F01L117
    … …  
    72517251                .dc.l   F01L122
    72527252                .dc.l   F01L119
    7253 *
     7253
    72547254F01L145:        .dc.l   F01L139
    72557255                .dc.l   F01L144
    … …  
    72627262                .dc.l   F01L144
    72637263                .dc.l   F01L141
    7264 *
     7264
    72657265F02L123:        .dc.l   F02L116
    72667266                .dc.l   F02L117
    … …  
    72747274                .dc.l   F02L122
    72757275                .dc.l   F02L119
    7276 *
     7276
    72777277F02L145:        .dc.l   F02L139
    72787278                .dc.l   F02L144
    … …  
    72857285                .dc.l   F02L144
    72867286                .dc.l   F02L141
    7287 *
     7287
    72887288F03L123:        .dc.l   F03L116
    72897289                .dc.l   F03L117
    … …  
    72977297                .dc.l   F03L122
    72987298                .dc.l   F03L119
    7299 *
     7299
    73007300F03L145:        .dc.l   F03L139
    73017301                .dc.l   F03L144
    … …  
    73087308                .dc.l   F03L144
    73097309                .dc.l   F03L141
    7310 *
     7310
    73117311F04L123:        .dc.l   F04L116
    73127312                .dc.l   F04L117
    … …  
    73207320                .dc.l   F04L122
    73217321                .dc.l   F04L119
    7322 *
     7322
    73237323F04L145:        .dc.l   F04L139
    73247324                .dc.l   F04L144
    … …  
    73317331                .dc.l   F04L144
    73327332                .dc.l   F04L141
    7333 *
     7333
    73347334F05L123:        .dc.l   F05L116
    73357335                .dc.l   F05L117
    … …  
    73437343                .dc.l   F05L122
    73447344                .dc.l   F05L119
    7345 *
     7345
    73467346F05L145:        .dc.l   F05L139
    73477347                .dc.l   F05L144
    … …  
    73547354                .dc.l   F05L144
    73557355                .dc.l   F05L141
    7356 *
     7356
    73577357F06L123:        .dc.l   F06L116
    73587358                .dc.l   F06L117
    … …  
    73667366                .dc.l   F06L122
    73677367                .dc.l   F06L119
    7368 *
     7368
    73697369F06L145:        .dc.l   F06L139
    73707370                .dc.l   F06L144
    … …  
    73777377                .dc.l   F06L144
    73787378                .dc.l   F06L141
    7379 *
     7379
    73807380F07L123:        .dc.l   F07L116
    73817381                .dc.l   F07L117
    … …  
    73897389                .dc.l   F07L122
    73907390                .dc.l   F07L119
    7391 *
     7391
    73927392F07L145:        .dc.l   F07L139
    73937393                .dc.l   F07L144
    … …  
    74007400                .dc.l   F07L144
    74017401                .dc.l   F07L141
    7402 *
     7402
    74037403F08L123:        .dc.l   F08L116
    74047404                .dc.l   F08L117
    … …  
    74127412                .dc.l   F08L122
    74137413                .dc.l   F08L119
    7414 *
     7414
    74157415F08L145:        .dc.l   F08L139
    74167416                .dc.l   F08L144
    … …  
    74237423                .dc.l   F08L144
    74247424                .dc.l   F08L141
    7425 *
     7425
    74267426F09L123:        .dc.l   F09L116
    74277427                .dc.l   F09L117
    … …  
    74357435                .dc.l   F09L122
    74367436                .dc.l   F09L119
    7437 *
     7437
    74387438F09L145:        .dc.l   F09L139
    74397439                .dc.l   F09L144
    … …  
    74467446                .dc.l   F09L144
    74477447                .dc.l   F09L141
    7448 *
     7448
    74497449F10L123:        .dc.l   F10L116
    74507450                .dc.l   F10L117
    … …  
    74587458                .dc.l   F10L122
    74597459                .dc.l   F10L119
    7460 *
     7460
    74617461F10L145:        .dc.l   F10L139
    74627462                .dc.l   F10L144
    … …  
    74697469                .dc.l   F10L144
    74707470                .dc.l   F10L141
    7471 *
     7471
    74727472F11L123:        .dc.l   F11L116
    74737473                .dc.l   F11L117
    … …  
    74817481                .dc.l   F11L122
    74827482                .dc.l   F11L119
    7483 *
     7483
    74847484F11L145:        .dc.l   F11L139
    74857485                .dc.l   F11L144
    … …  
    74927492                .dc.l   F11L144
    74937493                .dc.l   F11L141
    7494 *
     7494
    74957495F12L123:        .dc.l   F12L116
    74967496                .dc.l   F12L117
    … …  
    75047504                .dc.l   F12L122
    75057505                .dc.l   F12L119
    7506 *
     7506
    75077507F12L145:        .dc.l   F12L139
    75087508                .dc.l   F12L144
    … …  
    75157515                .dc.l   F12L144
    75167516                .dc.l   F12L141
    7517 *
    7518 * vbtab -- vbuf pointer table -- indexed by voice number
    7519 * -----    ---------------------------------------------
     7517
     7518| vbtab -- vbuf pointer table -- indexed by voice number
     7519| -----    ---------------------------------------------
    75207520vbtab:          .dc.l   _vbufs
    75217521                .dc.l   _vbufs+VBLEN
    … …  
    75307530                .dc.l   _vbufs+(10*VBLEN)
    75317531                .dc.l   _vbufs+(11*VBLEN)
    7532 *
     7532
    75337533                .end

  • ram/fpuint.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * fpuint.s -- process FPU interrupts / clear FPU
    3 * Version 63 -- 1988-08-31 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| fpuint.s -- process FPU interrupts / clear FPU
     3| Version 63 -- 1988-08-31 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
    7                 .xdef   _fpuint         * process an FPU interrupt
    8                 .xdef   _fpuclr         * reset the FPU
    9                 .xdef   _clrvce         * quiet a voice
    10 *
    11                 .xdef   _fputrap        * a very good debug trap point
    12 *
    13                 .xdef   _fp_resv        * 'spare' function reset value table
    14                 .xdef   _fpuifnc        * FPU interrupt code  (voice / function)
    15 *
    16                 .xref   _irand          * ranged random number function
    17                 .xref   _scope          * diagnostic scope function
    18                 .xref   _xgetran        * random number function
    19 *
     6
     7                .xdef   _fpuint         | process an FPU interrupt
     8                .xdef   _fpuclr         | reset the FPU
     9                .xdef   _clrvce         | quiet a voice
     10
     11                .xdef   _fputrap        | a very good debug trap point
     12
     13                .xdef   _fp_resv        | 'spare' function reset value table
     14                .xdef   _fpuifnc        | FPU interrupt code  (voice / function)
     15
     16                .xref   _irand          | ranged random number function
     17                .xref   _scope          | diagnostic scope function
     18                .xref   _xgetran        | random number function
     19
    2020                .xref   _expbit
    2121                .xref   _funcndx
    … …  
    3333                .xref   _vce2trg
    3434                .xref   _veltab
    35 *
    36                 .page
    37 * ------------------------------------------------------------------------------
    38 * Register usage
    39 * --------------
    40 *       d0      scratch
    41 *       d1      FPU function index
    42 *       d2      point index from FH_CPT  (idfcpt)
    43 *       d3      scratch
    44 *       d4      jump point number from PT_PAR1  (ippar1)
    45 *       d5      scratch
    46 *
    47 *       a0      scratch
    48 *       a1      function header base
    49 *       a2      point table base
    50 *       a3      FPU base
    51 *
    52 * ------------------------------------------------------------------------------
    53 * FPU definitions
    54 * ---------------
    55 *
    56 UPD_BIT         .equ    $0001                   * update bit  (1 = update)
    57 INT_BIT         .equ    $0002                   * int. bit    (0 = disable)
    58 RAT_BIT         .equ    $0004                   * ratio bit   (0 = ratio)
    59 *
    60 VSUBNBIT        .equ    3                       * new value select bit number
    61 VAL_BITS        .equ    $0018                   * new value select bit mask
    62 *
    63 MSK_RNVB        .equ    $000C                   * new value / ratio bits
    64 MSK_ONVB        .equ    $0010                   * old new value bit
    65 *
    66 FKILL           .equ    $0014                   * kill value for function
    67 FSEND           .equ    $0015                   * send new value to function
    68 *
    69 CLREXP          .equ    $8000                   * clear value for time exponent
    70 CLRMNT          .equ    $8000                   * clear value for time mantissa
    71 *
    72 * ------------------------------------------------------------------------------
    73 * Miscellaneous definitions
    74 * -------------------------
    75 *
    76 PCHMAX          .equ    21920                   * maximum pitch value
    77 VALMAX          .equ    32000                   * maximum value to send to FPU
    78 VALMIN          .equ    -32000                  * minimum value to send to FPU
    79 *
    80 LSPCH           .equ    2                       * left shift for sources to freq
    81 *
    82 VALLEN          .equ    10                      * length of the 'valent' struct
    83 VT_VAL          .equ    8                       * value offset in 'valent'
    84 *
    85                 .page
    86 * ------------------------------------------------------------------------------
    87 * FPU addresses
    88 * -------------
    89 *
    90 FPUBASE         .equ    $180000                 * FPU base address
    91 *
    92 FPUWST          .equ    FPUBASE                 * FPU waveshape base
    93 FPUFUNC         .equ    FPUBASE+$4000           * FPU function base
    94 FPUINT1         .equ    FPUBASE+$4000           * FPU int. input address (R/O)
    95 FPUINT2         .equ    FPUBASE+$6000           * FPU int. reset address (W/O)
    96 FPUCFG          .equ    FPUBASE+$5FE0           * FPU config. data address (W/O)
    97 *
    98 F_CTL           .equ    $00                     * control word
    99 F_VAL10         .equ    $02                     * new value "10"
    100 F_CV1           .equ    $08                     * control voltage 1
    101 F_SF1           .equ    $0A                     * scale factor 1
    102 F_CV2           .equ    $0C                     * control voltage 2
    103 F_SF2           .equ    $0E                     * scale factor 2
    104 F_CV3           .equ    $10                     * control voltage 3
    105 F_SF3           .equ    $12                     * scale factor 3
    106 F_MNT           .equ    $14                     * time mantissa
    107 F_EXP           .equ    $16                     * time exponent
    108 F_VAL01         .equ    $1C                     * new value "01"
    109 *
    110 P_FREQ1         .equ    $0020                   * frequency 1
    111 P_FREQ2         .equ    $0060                   * frequency 2
    112 P_FREQ3         .equ    $00A0                   * frequency 3
    113 P_FREQ4         .equ    $00E0                   * frequency 4
    114 P_FILTER        .equ    $0140                   * filter
    115 P_FILTRQ        .equ    $00C0                   * filter q
    116 *
    117 P_INDEX1        .equ    $0120                   * index 1
    118 P_INDEX2        .equ    $0160                   * index 2
    119 P_INDEX3        .equ    $0180                   * index 3
    120 P_INDEX4        .equ    $01A0                   * index 4
    121 P_INDEX5        .equ    $01C0                   * index 5
    122 P_INDEX6        .equ    $01E0                   * index 6
    123 *
    124 P_LEVEL         .equ    $0040                   * level
    125 *
    126 P_LOCN          .equ    $0080                   * location
    127 P_DYNAM         .equ    $0100                   * dynamics
    128 *
    129                 .page
    130 * ------------------------------------------------------------------------------
    131 * Structure definitions
    132 * ------------------------------------------------------------------------------
    133 * The following MUST match the idfnhdr structure definition in instdsp.h:
    134 *
    135 FH_LEN          .equ    12              * length of the idfnhdr structure
    136 *
    137 FH_PCH          .equ    0               * WORD - pitch offset  (freq1 only)
    138 FH_MLT          .equ    2               * WORD - overall value multiplier
    139 FH_SRC          .equ    4               * BYTE - overall value source
    140 FH_PIF          .equ    5               * BYTE - # of points in the function
    141 FH_PT1          .equ    6               * BYTE - index of first point
    142 FH_TMD          .equ    7               * BYTE - trigger mode / control bits
    143 FH_CPT          .equ    8               * BYTE - current point
    144 FH_PRM          .equ    9               * BYTE - misc. function parameter
    145 FH_TRG          .equ    10              * WORD - trigger
    146 *
    147 I_ACTIVE        .equ    1               * 'Active' bit number        (in FH_TMD)
    148 *
    149 MSK_CTL         .equ    $001C           * mask for FPU hardware bits (in FH_TMD)
    150 *
    151 * ------------------------------------------------------------------------------
    152 * The following MUST match the instpnt structure definition in instdsp.h:
    153 *
    154 PT_LEN          .equ    12              * length of the instpnt structure
    155 *
    156 PT_TIM          .equ    0               * WORD - time (packed)
    157 PT_VAL          .equ    2               * WORD - value
    158 PT_VMLT         .equ    4               * WORD - value multiplier
    159 PT_VSRC         .equ    6               * BYTE - value source
    160 PT_ACT          .equ    7               * BYTE - action
    161 PT_PAR1         .equ    8               * BYTE - parameter 1
    162 PT_PAR2         .equ    9               * BYTE - parameter 2
    163 PT_PAR3         .equ    10              * BYTE - parameter 3
    164 PT_PAD          .equ    11              * BYTE - padding for even boundary
    165 *
    166 MSK_MNT         .equ    $FFF0           * mask for mantissa  (in PT_TIM)
    167 MSK_EXP         .equ    $000F           * mask for exponent  (in PT_TIM)
    168 *
    169 MAX_ACT         .equ    7               * maximum action code value
    170 *
    171                 .page
    172 *
    173 * ------------------------------------------------------------------------------
    174 * pflist definitions -- must match those in instdsp.h
    175 *
    176 PF_NEXT         .equ    0
    177 PF_TRIG         .equ    4
    178 PF_FUNC         .equ    6
    179 PF_D1           .equ    8
    180 PF_D2           .equ    12
    181 PF_D4           .equ    16
    182 PF_A1           .equ    20
    183 PF_A2           .equ    24
    184 PF_A3           .equ    28
    185 * ------------------------------------------------------------------------------
    186 * Source definitions -- must match those in 'smdefs.h'
    187 *
    188 SM_RAND         .equ    1               * random
    189 SM_PTCH         .equ    5               * pitch
    190 SM_KPRS         .equ    6               * key pressure
    191 SM_KVEL         .equ    7               * key velocity
    192 SM_FREQ         .equ    10              * frequency
    193 *
    194                 .page
    195 * ------------------------------------------------------------------------------
    196 * _fpuint() -- process FPU interrupts
    197 *
    198 *       void
    199 *       fpuint();
    200 *
    201 *               Processes FPU interrupts.  Must be the target of vector 26,
    202 *               which is Autovector Interrupt level 2.
    203 *
    204 * ------------------------------------------------------------------------------
    205 *
    206 _fpuint:        movem.l d0-d5/a0-a3,-(a7)       * preserve registers we use
    207                 move.w  FPUINT1,d0      * read FPU interrupt status
    208                 andi.w  #$00FF,d0       * mask out garbage in MS bits
    209                 move.w  d0,_fpuifnc     * save for later use
    210                 move.w  _ndisp,d1       * get display number
    211                 cmpi.w  #11,d1          * see if we display
    212                 bne     nodisp          * jump if not
    213 *
    214                 tst.w   _scopef         * ...
    215                 beq     nodisp          * ...
    216 *
    217                 move.w  d0,-(a7)        * display value
    218                 jsr     _scope          * ...
    219                 tst.w   (a7)+           * ...
    220 *
    221                 move.w  _fpuifnc,d0     * get FPU status
    222 *
    223 nodisp:         move.w  d0,d1           * save in d1  (becomes function offset)
    224 *
    225                 lsl.w   #5,d1           * develop FPU function offset
    226                 lea     FPUFUNC,a3      * setup FPU function base address
    227 *
    228                 lsl.w   #3,d0           * develop funcndx[] index
    229                 lea     _funcndx,a0     * setup funcndx[] base address
    230 *
    231                 tst.l   0(a0,d0.W)      * see if function is defined
    232                 bne     fnok            * jump if so
    233 *
    234                 move.w  d1,d0           * get function offset in d0
    235                 andi.w  #$1E00,d0       * mask for voice number
    236                 cmpi.w  #$1800,d0       * see if it's a real voice  (0..11)
    237                 bge     fpexit          * don't send a kill if not a real voice
    238 *
    239                 move.w  #FKILL,F_CTL(a3,d1.W)   * kill the undefined function
    240 *
    241 fpexit:         clr.w   FPUINT2         * reset the FPU interrupt latch
    242                 movem.l (a7)+,d0-d5/a0-a3       * restore the registers
    243                 rte                     * return to interrupted code
    244 *
    245                 .page
    246 * ------------------------------------------------------------------------------
    247 * set up to process active functions,  stop ones that should be inactive
    248 * ------------------------------------------------------------------------------
    249 fnok:           movea.l 0(a0,d0.W),a1   * get pointer to function header
    250                 movea.l 4(a0,d0.W),a2   * get pointer to point table
    251                 btst    #I_ACTIVE,FH_TMD(a1)    * see if function is active
    252                 bne     doact           * go process action if so
    253 *
    254 * ------------------------------------------------------------------------------
    255 * stop a function
    256 * ------------------------------------------------------------------------------
    257 stopfn:         move.b  FH_TMD(a1),d0   * get function control bits
    258                 andi.w  #MSK_RNVB,d0    * mask for ratio / new new-value bit
    259                 move.w  d0,d3           * isolate new new-value bit
    260                 add.w   d3,d3           * ... from function header
    261                 andi.w  #MSK_ONVB,d3    * ... shift to old new-value bit
    262                 or.w    d3,d0           * ... and put new bit in old bit       
    263                 move.w  d0,F_CTL(a3,d1.W)       * stop the function
    264                 bclr    #I_ACTIVE,FH_TMD(a1)    * reset the active bit
    265                 bra     fpexit          * go restore registers and exit
    266 *
    267                 .page
    268 * ------------------------------------------------------------------------------
    269 * setup for and dispatch to the proper action handler
    270 * ------------------------------------------------------------------------------
    271 doact:          clr.w   d2              * get current point index in d2
    272                 move.b  FH_CPT(a1),d2   * ...
    273                 lsl.w   #2,d2           * multiply it by the length of a point
    274                 move.w  d2,d0           * ...  (fast multiply by PT_LEN = 12
    275                 add.w   d2,d2           * ...   via shift and add)
    276                 add.w   d0,d2           * ...
    277                 clr.w   d4              * get jump point # into d4
    278                 move.b  PT_PAR1(a2,d2.W),d4     * ...
    279                 clr.w   d3              * get action code in d3
    280                 move.b  PT_ACT(a2,d2.W),d3      * ...
    281                 cmpi.b  #MAX_ACT,d3     * check against the limit
    282                 bgt     stopfn          * stop things if it's a bad action code
    283 *
    284                 lsl.w   #2,d3           * develop index to action dispatch table
    285                 lea     actab,a0        * get the address of the action handler
    286                 movea.l 0(a0,d3.W),a0   * ...
    287 *
    288 * ------------------------------------------------------------------------------
    289 * At this point we're ready to do the action associated with the point,
    290 * and the registers are set up,  and will remain,  as follows:
    291 *
    292 *       d1      FPU function index      a1      function header base
    293 *       d2      point table index       a2      point table base
    294 *                                       a3      FPU function base
    295 *       d4      jump point number
    296 *
    297 *       d0, d3, d5, and a0 are used as scratch throughout the code.
    298 *
    299 * ------------------------------------------------------------------------------
    300 *
    301 _fputrap:       jmp     (a0)            * dispatch to action handler
    302 *
    303                 .page
    304 * ------------------------------------------------------------------------------
    305 * act0 -- AC_NULL -- no action
    306 * ----    --------------------
    307 act0:           move.b  FH_PT1(a1),d0   * get first point number
    308                 add.b   FH_PIF(a1),d0   * add number of points in function
    309                 subq.b  #1,d0           * make it last point number
    310                 cmp.b   FH_CPT(a1),d0   * see if we're at the last point
    311                 beq     stopfn          * stop function if so
    312 *
    313                 addq.b  #1,FH_CPT(a1)   * update function header for next point
    314                 addi.w  #PT_LEN,d2      * advance the point index
    315 *
    316 * ------------------------------------------------------------------------------
    317 * outseg -- output a segment
    318 * ------    ----------------
    319 outseg:         move.w  PT_TIM(a2,d2.w),d3      * get packed time
    320                 move.w  d3,d0                   * extract mantissa
    321                 andi.w  #MSK_MNT,d0             * ...
    322                 mulu    _timemlt,d0             * multiply by panel time pot value
    323                 lsr.l   #8,d0                   * ... and scale it
    324                 lsr.l   #7,d0                   * ...
    325                 move.w  d0,F_MNT(a3,d1.W)       * send mantissa to FPU
    326                 andi.w  #MSK_EXP,d3             * extract exponent code
    327                 add.w   d3,d3                   * look up decoded exponent
    328                 lea     _expbit,a0              * ... in expbit
    329                 move.w  0(a0,d3.W),F_EXP(a3,d1.W)       * send exponent to FPU
    330                 move.w  PT_VAL(a2,d2.W),d3      * get the function value
    331 *
    332 * ------------------------------------------------------------------------------
    333 * get the point source, if any
    334 * ------------------------------------------------------------------------------
    335                 tst.w   PT_VMLT(a2,d2.W)        * see if we have a point mlt.
    336                 beq     nosrc                   * don't do anything for zero
    337 *
    338                 clr.w   d0                      * get the source number
    339                 move.b  PT_VSRC(a2,d2.W),d0     * ...
    340                 beq     nosrc                   * don't do anything for zero
    341 *
    342 * ------------------------------------------------------------------------------
    343 * SM_RAND -- random
    344 * ------------------------------------------------------------------------------
    345                 cmpi.w  #SM_RAND,d0             * is this the random source ?
    346                 bne     srctyp0                 * jump if not
    347 *
    348                 movem.l d1-d2/a0-a2,-(a7)       * preserve registers around call
    349                 move.w  PT_VMLT(a2,d2.W),-(a7)  * pass multiplier to xgetran()
    350                 jsr     _xgetran                * call for a random number
    351                 tst.w   (a7)+                   * clean up stack
    352                 movem.l (a7)+,d1-d2/a0-a2       * restore registers
    353                 move.w  d0,d5                   * put random value in the value register
    354                 bra     applym                  * go apply the multiplier
    355 *
    356                 .page
    357 * ------------------------------------------------------------------------------
    358 * SM_FREQ -- frequency
    359 * ------------------------------------------------------------------------------
    360 srctyp0:        cmpi.w  #SM_FREQ,d0     * is this the frequency source ?
    361                 bne     srctyp1         * jump if not
    362 *
    363                 move.w  (a1),d0         * get the pitch
    364                 lsr.w   #6,d0           * shift to a word index
    365                 andi.w  #$01FE,d0       * mask out extraneous bits
    366                 lea     _ptoftab,a0     * get entry from ptoftab[]
    367                 move.w  0(a0,d0.W),d5   * ...
    368                 bra     applym          * go apply the multiplier
    369 *
    370 * ------------------------------------------------------------------------------
    371 * SM_PTCH -- pitch
    372 * ------------------------------------------------------------------------------
    373 srctyp1:        cmpi.w  #SM_PTCH,d0     * is this the pitch source ?
    374                 bne     srctyp2         * jump if not
    375 *
    376                 move.w  (a1),d5         * get the pitch as the value
    377                 bra     applym          * go apply the multiplier
    378 *
    379 * ------------------------------------------------------------------------------
    380 * SM_KVEL -- velocity
    381 * ------------------------------------------------------------------------------
    382 srctyp2:        cmpi.w  #SM_KVEL,d0     * is this the key velocity source ?
    383                 bne     srctyp3         * jump if not
    384 *
    385                 move.w  FH_TRG(a1),d0   * get the trigger number
    386                 add.w   d0,d0           * ... as a word index
    387                 lea     _veltab,a0      * ... into veltab[]
    388                 move.w  0(a0,d0.W),d5   * get the velocity from veltab[trg]
    389                 bra     applym          * go apply the multiplier
    390 *
    391 * ------------------------------------------------------------------------------
    392 * SM_KPRS -- pressure
    393 * ------------------------------------------------------------------------------
    394 srctyp3:        cmpi.w  #SM_KPRS,d0     * is this the key pressure source ?
    395                 bne     srctyp4         * jump if not  (must be an analog input)
    396 *
    397                 move.w  FH_TRG(a1),d0   * get the trigger number
    398                 add.w   d0,d0           * ... as a word index
    399                 lea     _prstab,a0      * ... into prstab[]
    400                 move.w  0(a0,d0.W),d5   * get the pressure from prstab[trg]
    401                 bra     applym          * go apply the multiplier
    402 *
    403                 .page
    404 * ------------------------------------------------------------------------------
    405 * all other sources come out of the valents[] array
    406 * ------------------------------------------------------------------------------
    407 srctyp4:        lea     _vce2grp,a0     * point at vce2grp[]
    408                 move.w  _fpuifnc,d5     * get voice number in d5
    409                 lsr.w   #3,d5           * ...
    410                 andi.w  #$001E,d5       * ... as a word index
    411                 move.w  0(a0,d5.W),d5   * get the group number
    412                 subq.w  #1,d5           * ...
    413                 lsl.w   #4,d5           * shift it left a nybble
    414                 or.w    d5,d0           * OR it into the source number
    415                 add.w   d0,d0           * make source number a valents[] index
    416                 move.w  d0,d5           * ... (fast multiply by VALLEN = 10
    417                 lsl.w   #2,d0           * ...  via shift and add)
    418                 add.w   d5,d0           * ...
    419                 lea     _valents,a0     * get base of valents[]
    420                 move.w  VT_VAL(a0,d0.W),d5      * get value
    421 *
    422 * ------------------------------------------------------------------------------
    423 * apply the multiplier to the source, and add it to the function value
    424 * ------------------------------------------------------------------------------
    425 applym:         muls    PT_VMLT(a2,d2.W),d5     * apply the multiplier
    426                 asr.l   #7,d5           * scale the result
    427                 asr.l   #8,d5           * ...
    428                 ext.l   d3              * add the function value
    429                 add.l   d3,d5           * ...
    430                 cmpi.l  #VALMAX,d5      * check for overflow
    431                 ble     srcmlt1         * jump if no overflow
    432 *
    433                 move.l  #VALMAX,d5      * limit at VALMAX
    434                 bra     srcmlt2         * ...
    435 *
    436 srcmlt1:        cmpi.l  #VALMIN,d5      * check for underflow
    437                 bge     srcmlt2         * jump if no underflow
    438 *
    439                 move.l  #VALMIN,d5      * limit at VALMIN
    440 *
    441 srcmlt2:        move.w  d5,d3           * setup value for output to FPU
    442 *
    443                 .page
    444 * ------------------------------------------------------------------------------
    445 * adjust the value according to the function type
    446 * ------------------------------------------------------------------------------
    447 nosrc:          move.w  d1,d0           * get function type
    448                 andi.w  #$01E0,d0       * ...
    449 *
    450 * ------------------------------------------------------------------------------
    451 * level or location
    452 * ------------------------------------------------------------------------------
    453                 cmpi.w  #P_LEVEL,d0     * see if it's the level
    454                 beq     outsegl         * jump if so
    455 *
    456                 cmpi.w  #P_LOCN,d0      * see if it's the location
    457                 bne     outsegf         * jump if not
    458 *
    459                 tst.w   d3              * check sign of value
    460                 bpl     outsegc         * jump if positive
    461 *
    462                 clr.w   d3              * force negative values to 0
    463 *
    464 outsegc:        asr.w   #5,d3           * shift value to LS bits
    465                 sub.w   #500,d3         * subtract 5.00 from value
    466                 asl.w   #6,d3           * readjust to MS bits
    467                 bra     outseg3         * go output the value
    468 *
    469 outsegl:        tst.w   d3              * check sign of value
    470                 bpl     outsegm         * jump if positive
    471 *
    472                 clr.w   d3              * limit negative values at 0
    473 *
    474 outsegm:        asr.w   #5,d3           * shift value to LS bits
    475                 sub.w   #500,d3         * subtract 5.00 from value
    476                 asl.w   #6,d3           * readjust to MS bits
    477                 bra     outseg3         * go output the value
    478 *
    479                 .page
    480 * ------------------------------------------------------------------------------
    481 * filter
    482 * ------------------------------------------------------------------------------
    483 outsegf:        cmpi.w  #P_FILTER,d0    * see if it's filter
    484                 bne     outsegp         * jump if not
    485 *
    486                 ext.l   d3              * make function value a long
    487                 asr.l   #1,d3           * multiply function value by .75
    488                 move.l  d3,d0           * ...  (fast multiply by .75
    489                 asr.l   #1,d0           * ...   via shift and add)
    490                 add.l   d0,d3           * ...
    491                 move.w  (a1),d0         * add pitch
    492                 ext.l   d0              * ...
    493                 add.l   d0,d3           * ...
    494                 cmpi.l  #VALMAX,d3      * see if it's within limits
    495                 ble     outsega         * ...
    496 *
    497                 move.w  #VALMAX,d3      * limit at VALMAX
    498                 bra     outseg3         * ...
    499 *
    500 outsega:        cmpi.l  #VALMIN,d3      * ...
    501                 bge     outseg3         * ...
    502 *
    503                 move.w  #VALMIN,d3      * limit at VALMIN
    504                 bra     outseg3         * ...
    505 *
    506                 .page
    507 * ------------------------------------------------------------------------------
    508 * freq 1..4
    509 * ------------------------------------------------------------------------------
    510 outsegp:        cmpi.w  #P_FREQ1,d0     * see if it's freq1
    511                 beq     outseg0         * go process freq1
    512 *
    513 outsegq:        cmpi.w  #P_FREQ2,d0     * see if it's freq2
    514                 beq     outseg0         * process it if so
    515 *
    516                 cmpi.w  #P_FREQ3,d0     * see if it's freq3
    517                 beq     outseg0         * process it if so
    518 *
    519                 cmpi.w  #P_FREQ4,d0     * see if it's freq4
    520                 bne     outseg3         * jump if not
    521 *
    522 outseg0:        ext.l   d3              * scale the point value to cents offset
    523                 asr.l   #5,d3           * ...
    524                 sub.l   #500,d3         * ... value - 500
    525                 asl.l   #LSPCH,d3       * mult. by 2 and scale for 1/2 cent lsb
    526                 move.w  (a1),d0         * add pitch from function header
    527                 ext.l   d0              * ...
    528                 add.l   d0,d3           * ...
    529                 cmp.l   #PCHMAX,d3      * see if result is valid
    530                 ble     outseg3         * jump if within pitch limits
    531 *
    532                 move.l  #PCHMAX,d3      * limit at maximum pitch
    533 *
    534 * ------------------------------------------------------------------------------
    535 * send the value to the FPU
    536 * ------------------------------------------------------------------------------
    537 outseg3:        move.b  FH_TMD(a1),d0   * get hardware bits from function header
    538                 eor.w   #VAL_BITS,d0    * toggle new value select bits
    539                 move.b  d0,FH_TMD(a1)   * store updated word
    540                 btst.l  #VSUBNBIT,d0    * check which value address to use
     35
     36                .page
     37| ------------------------------------------------------------------------------
     38| Register usage
     39| --------------
     40|       d0      scratch
     41|       d1      FPU function index
     42|       d2      point index from FH_CPT  (idfcpt)
     43|       d3      scratch
     44|       d4      jump point number from PT_PAR1  (ippar1)
     45|       d5      scratch
     46
     47|       a0      scratch
     48|       a1      function header base
     49|       a2      point table base
     50|       a3      FPU base
     51
     52| ------------------------------------------------------------------------------
     53| FPU definitions
     54| ---------------
     55
     56UPD_BIT         =       0x0001                  | update bit  (1 = update)
     57INT_BIT         =       0x0002                  | int. bit    (0 = disable)
     58RAT_BIT         =       0x0004                  | ratio bit   (0 = ratio)
     59
     60VSUBNBIT        =       3                       | new value select bit number
     61VAL_BITS        =       0x0018                  | new value select bit mask
     62
     63MSK_RNVB        =       0x000C                  | new value / ratio bits
     64MSK_ONVB        =       0x0010                  | old new value bit
     65
     66FKILL           =       0x0014                  | kill value for function
     67FSEND           =       0x0015                  | send new value to function
     68
     69CLREXP          =       0x8000                  | clear value for time exponent
     70CLRMNT          =       0x8000                  | clear value for time mantissa
     71
     72| ------------------------------------------------------------------------------
     73| Miscellaneous definitions
     74| -------------------------
     75
     76PCHMAX          =       21920                   | maximum pitch value
     77VALMAX          =       32000                   | maximum value to send to FPU
     78VALMIN          =       -32000                  | minimum value to send to FPU
     79
     80LSPCH           =       2                       | left shift for sources to freq
     81
     82VALLEN          =       10                      | length of the 'valent' struct
     83VT_VAL          =       8                       | value offset in 'valent'
     84
     85                .page
     86| ------------------------------------------------------------------------------
     87| FPU addresses
     88| -------------
     89
     90FPUBASE         =       0x180000                | FPU base address
     91
     92FPUWST          =       FPUBASE                 | FPU waveshape base
     93FPUFUNC         =       FPUBASE+0x4000          | FPU function base
     94FPUINT1         =       FPUBASE+0x4000          | FPU int. input address (R/O)
     95FPUINT2         =       FPUBASE+0x6000          | FPU int. reset address (W/O)
     96FPUCFG          =       FPUBASE+0x5FE0          | FPU config. data address (W/O)
     97
     98F_CTL           =       0x00                    | control word
     99F_VAL10         =       0x02                    | new value "10"
     100F_CV1           =       0x08                    | control voltage 1
     101F_SF1           =       0x0A                    | scale factor 1
     102F_CV2           =       0x0C                    | control voltage 2
     103F_SF2           =       0x0E                    | scale factor 2
     104F_CV3           =       0x10                    | control voltage 3
     105F_SF3           =       0x12                    | scale factor 3
     106F_MNT           =       0x14                    | time mantissa
     107F_EXP           =       0x16                    | time exponent
     108F_VAL01         =       0x1C                    | new value "01"
     109
     110P_FREQ1         =       0x0020                  | frequency 1
     111P_FREQ2         =       0x0060                  | frequency 2
     112P_FREQ3         =       0x00A0                  | frequency 3
     113P_FREQ4         =       0x00E0                  | frequency 4
     114P_FILTER        =       0x0140                  | filter
     115P_FILTRQ        =       0x00C0                  | filter q
     116
     117P_INDEX1        =       0x0120                  | index 1
     118P_INDEX2        =       0x0160                  | index 2
     119P_INDEX3        =       0x0180                  | index 3
     120P_INDEX4        =       0x01A0                  | index 4
     121P_INDEX5        =       0x01C0                  | index 5
     122P_INDEX6        =       0x01E0                  | index 6
     123
     124P_LEVEL         =       0x0040                  | level
     125
     126P_LOCN          =       0x0080                  | location
     127P_DYNAM         =       0x0100                  | dynamics
     128
     129                .page
     130| ------------------------------------------------------------------------------
     131| Structure definitions
     132| ------------------------------------------------------------------------------
     133| The following MUST match the idfnhdr structure definition in instdsp.h:
     134
     135FH_LEN          =       12              | length of the idfnhdr structure
     136
     137FH_PCH          =       0               | WORD - pitch offset  (freq1 only)
     138FH_MLT          =       2               | WORD - overall value multiplier
     139FH_SRC          =       4               | BYTE - overall value source
     140FH_PIF          =       5               | BYTE - # of points in the function
     141FH_PT1          =       6               | BYTE - index of first point
     142FH_TMD          =       7               | BYTE - trigger mode / control bits
     143FH_CPT          =       8               | BYTE - current point
     144FH_PRM          =       9               | BYTE - misc. function parameter
     145FH_TRG          =       10              | WORD - trigger
     146
     147I_ACTIVE        =       1               | 'Active' bit number        (in FH_TMD)
     148
     149MSK_CTL         =       0x001C          | mask for FPU hardware bits (in FH_TMD)
     150
     151| ------------------------------------------------------------------------------
     152| The following MUST match the instpnt structure definition in instdsp.h:
     153
     154PT_LEN          =       12              | length of the instpnt structure
     155
     156PT_TIM          =       0               | WORD - time (packed)
     157PT_VAL          =       2               | WORD - value
     158PT_VMLT         =       4               | WORD - value multiplier
     159PT_VSRC         =       6               | BYTE - value source
     160PT_ACT          =       7               | BYTE - action
     161PT_PAR1         =       8               | BYTE - parameter 1
     162PT_PAR2         =       9               | BYTE - parameter 2
     163PT_PAR3         =       10              | BYTE - parameter 3
     164PT_PAD          =       11              | BYTE - padding for even boundary
     165
     166MSK_MNT         =       0xFFF0          | mask for mantissa  (in PT_TIM)
     167MSK_EXP         =       0x000F          | mask for exponent  (in PT_TIM)
     168
     169MAX_ACT         =       7               | maximum action code value
     170
     171                .page
     172
     173| ------------------------------------------------------------------------------
     174| pflist definitions -- must match those in instdsp.h
     175
     176PF_NEXT         =       0
     177PF_TRIG         =       4
     178PF_FUNC         =       6
     179PF_D1           =       8
     180PF_D2           =       12
     181PF_D4           =       16
     182PF_A1           =       20
     183PF_A2           =       24
     184PF_A3           =       28
     185| ------------------------------------------------------------------------------
     186| Source definitions -- must match those in 'smdefs.h'
     187
     188SM_RAND         =       1               | random
     189SM_PTCH         =       5               | pitch
     190SM_KPRS         =       6               | key pressure
     191SM_KVEL         =       7               | key velocity
     192SM_FREQ         =       10              | frequency
     193
     194                .page
     195| ------------------------------------------------------------------------------
     196| _fpuint() -- process FPU interrupts
     197
     198|       void
     199|       fpuint();
     200
     201|               Processes FPU interrupts.  Must be the target of vector 26,
     202|               which is Autovector Interrupt level 2.
     203
     204| ------------------------------------------------------------------------------
     205
     206_fpuint:        movem.l d0-d5/a0-a3,-(a7)       | preserve registers we use
     207                move.w  FPUINT1,d0      | read FPU interrupt status
     208                andi.w  #0x00FF,d0      | mask out garbage in MS bits
     209                move.w  d0,_fpuifnc     | save for later use
     210                move.w  _ndisp,d1       | get display number
     211                cmpi.w  #11,d1          | see if we display
     212                bne     nodisp          | jump if not
     213
     214                tst.w   _scopef         | ...
     215                beq     nodisp          | ...
     216
     217                move.w  d0,-(a7)        | display value
     218                jsr     _scope          | ...
     219                tst.w   (a7)+           | ...
     220
     221                move.w  _fpuifnc,d0     | get FPU status
     222
     223nodisp:         move.w  d0,d1           | save in d1  (becomes function offset)
     224
     225                lsl.w   #5,d1           | develop FPU function offset
     226                lea     FPUFUNC,a3      | setup FPU function base address
     227
     228                lsl.w   #3,d0           | develop funcndx[] index
     229                lea     _funcndx,a0     | setup funcndx[] base address
     230
     231                tst.l   0(a0,d0.W)      | see if function is defined
     232                bne     fnok            | jump if so
     233
     234                move.w  d1,d0           | get function offset in d0
     235                andi.w  #0x1E00,d0      | mask for voice number
     236                cmpi.w  #0x1800,d0      | see if it's a real voice  (0..11)
     237                bge     fpexit          | don't send a kill if not a real voice
     238
     239                move.w  #FKILL,F_CTL(a3,d1.W)   | kill the undefined function
     240
     241fpexit:         clr.w   FPUINT2         | reset the FPU interrupt latch
     242                movem.l (a7)+,d0-d5/a0-a3       | restore the registers
     243                rte                     | return to interrupted code
     244
     245                .page
     246| ------------------------------------------------------------------------------
     247| set up to process active functions,  stop ones that should be inactive
     248| ------------------------------------------------------------------------------
     249fnok:           movea.l 0(a0,d0.W),a1   | get pointer to function header
     250                movea.l 4(a0,d0.W),a2   | get pointer to point table
     251                btst    #I_ACTIVE,FH_TMD(a1)    | see if function is active
     252                bne     doact           | go process action if so
     253
     254| ------------------------------------------------------------------------------
     255| stop a function
     256| ------------------------------------------------------------------------------
     257stopfn:         move.b  FH_TMD(a1),d0   | get function control bits
     258                andi.w  #MSK_RNVB,d0    | mask for ratio / new new-value bit
     259                move.w  d0,d3           | isolate new new-value bit
     260                add.w   d3,d3           | ... from function header
     261                andi.w  #MSK_ONVB,d3    | ... shift to old new-value bit
     262                or.w    d3,d0           | ... and put new bit in old bit
     263                move.w  d0,F_CTL(a3,d1.W)       | stop the function
     264                bclr    #I_ACTIVE,FH_TMD(a1)    | reset the active bit
     265                bra     fpexit          | go restore registers and exit
     266
     267                .page
     268| ------------------------------------------------------------------------------
     269| setup for and dispatch to the proper action handler
     270| ------------------------------------------------------------------------------
     271doact:          clr.w   d2              | get current point index in d2
     272                move.b  FH_CPT(a1),d2   | ...
     273                lsl.w   #2,d2           | multiply it by the length of a point
     274                move.w  d2,d0           | ...  (fast multiply by PT_LEN = 12
     275                add.w   d2,d2           | ...   via shift and add)
     276                add.w   d0,d2           | ...
     277                clr.w   d4              | get jump point # into d4
     278                move.b  PT_PAR1(a2,d2.W),d4     | ...
     279                clr.w   d3              | get action code in d3
     280                move.b  PT_ACT(a2,d2.W),d3      | ...
     281                cmpi.b  #MAX_ACT,d3     | check against the limit
     282                bgt     stopfn          | stop things if it's a bad action code
     283
     284                lsl.w   #2,d3           | develop index to action dispatch table
     285                lea     actab,a0        | get the address of the action handler
     286                movea.l 0(a0,d3.W),a0   | ...
     287
     288| ------------------------------------------------------------------------------
     289| At this point we're ready to do the action associated with the point,
     290| and the registers are set up,  and will remain,  as follows:
     291
     292|       d1      FPU function index      a1      function header base
     293|       d2      point table index       a2      point table base
     294|                                       a3      FPU function base
     295|       d4      jump point number
     296
     297|       d0, d3, d5, and a0 are used as scratch throughout the code.
     298
     299| ------------------------------------------------------------------------------
     300
     301_fputrap:       jmp     (a0)            | dispatch to action handler
     302
     303                .page
     304| ------------------------------------------------------------------------------
     305| act0 -- AC_NULL -- no action
     306| ----    --------------------
     307act0:           move.b  FH_PT1(a1),d0   | get first point number
     308                add.b   FH_PIF(a1),d0   | add number of points in function
     309                subq.b  #1,d0           | make it last point number
     310                cmp.b   FH_CPT(a1),d0   | see if we're at the last point
     311                beq     stopfn          | stop function if so
     312
     313                addq.b  #1,FH_CPT(a1)   | update function header for next point
     314                addi.w  #PT_LEN,d2      | advance the point index
     315
     316| ------------------------------------------------------------------------------
     317| outseg -- output a segment
     318| ------    ----------------
     319outseg:         move.w  PT_TIM(a2,d2.w),d3      | get packed time
     320                move.w  d3,d0                   | extract mantissa
     321                andi.w  #MSK_MNT,d0             | ...
     322                mulu    _timemlt,d0             | multiply by panel time pot value
     323                lsr.l   #8,d0                   | ... and scale it
     324                lsr.l   #7,d0                   | ...
     325                move.w  d0,F_MNT(a3,d1.W)       | send mantissa to FPU
     326                andi.w  #MSK_EXP,d3             | extract exponent code
     327                add.w   d3,d3                   | look up decoded exponent
     328                lea     _expbit,a0              | ... in expbit
     329                move.w  0(a0,d3.W),F_EXP(a3,d1.W)       | send exponent to FPU
     330                move.w  PT_VAL(a2,d2.W),d3      | get the function value
     331
     332| ------------------------------------------------------------------------------
     333| get the point source, if any
     334| ------------------------------------------------------------------------------
     335                tst.w   PT_VMLT(a2,d2.W)        | see if we have a point mlt.
     336                beq     nosrc                   | don't do anything for zero
     337
     338                clr.w   d0                      | get the source number
     339                move.b  PT_VSRC(a2,d2.W),d0     | ...
     340                beq     nosrc                   | don't do anything for zero
     341
     342| ------------------------------------------------------------------------------
     343| SM_RAND -- random
     344| ------------------------------------------------------------------------------
     345                cmpi.w  #SM_RAND,d0             | is this the random source ?
     346                bne     srctyp0                 | jump if not
     347
     348                movem.l d1-d2/a0-a2,-(a7)       | preserve registers around call
     349                move.w  PT_VMLT(a2,d2.W),-(a7)  | pass multiplier to xgetran()
     350                jsr     _xgetran                | call for a random number
     351                tst.w   (a7)+                   | clean up stack
     352                movem.l (a7)+,d1-d2/a0-a2       | restore registers
     353                move.w  d0,d5                   | put random value in the value register
     354                bra     applym                  | go apply the multiplier
     355
     356                .page
     357| ------------------------------------------------------------------------------
     358| SM_FREQ -- frequency
     359| ------------------------------------------------------------------------------
     360srctyp0:        cmpi.w  #SM_FREQ,d0     | is this the frequency source ?
     361                bne     srctyp1         | jump if not
     362
     363                move.w  (a1),d0         | get the pitch
     364                lsr.w   #6,d0           | shift to a word index
     365                andi.w  #0x01FE,d0      | mask out extraneous bits
     366                lea     _ptoftab,a0     | get entry from ptoftab[]
     367                move.w  0(a0,d0.W),d5   | ...
     368                bra     applym          | go apply the multiplier
     369
     370| ------------------------------------------------------------------------------
     371| SM_PTCH -- pitch
     372| ------------------------------------------------------------------------------
     373srctyp1:        cmpi.w  #SM_PTCH,d0     | is this the pitch source ?
     374                bne     srctyp2         | jump if not
     375
     376                move.w  (a1),d5         | get the pitch as the value
     377                bra     applym          | go apply the multiplier
     378
     379| ------------------------------------------------------------------------------
     380| SM_KVEL -- velocity
     381| ------------------------------------------------------------------------------
     382srctyp2:        cmpi.w  #SM_KVEL,d0     | is this the key velocity source ?
     383                bne     srctyp3         | jump if not
     384
     385                move.w  FH_TRG(a1),d0   | get the trigger number
     386                add.w   d0,d0           | ... as a word index
     387                lea     _veltab,a0      | ... into veltab[]
     388                move.w  0(a0,d0.W),d5   | get the velocity from veltab[trg]
     389                bra     applym          | go apply the multiplier
     390
     391| ------------------------------------------------------------------------------
     392| SM_KPRS -- pressure
     393| ------------------------------------------------------------------------------
     394srctyp3:        cmpi.w  #SM_KPRS,d0     | is this the key pressure source ?
     395                bne     srctyp4         | jump if not  (must be an analog input)
     396
     397                move.w  FH_TRG(a1),d0   | get the trigger number
     398                add.w   d0,d0           | ... as a word index
     399                lea     _prstab,a0      | ... into prstab[]
     400                move.w  0(a0,d0.W),d5   | get the pressure from prstab[trg]
     401                bra     applym          | go apply the multiplier
     402
     403                .page
     404| ------------------------------------------------------------------------------
     405| all other sources come out of the valents[] array
     406| ------------------------------------------------------------------------------
     407srctyp4:        lea     _vce2grp,a0     | point at vce2grp[]
     408                move.w  _fpuifnc,d5     | get voice number in d5
     409                lsr.w   #3,d5           | ...
     410                andi.w  #0x001E,d5      | ... as a word index
     411                move.w  0(a0,d5.W),d5   | get the group number
     412                subq.w  #1,d5           | ...
     413                lsl.w   #4,d5           | shift it left a nybble
     414                or.w    d5,d0           | OR it into the source number
     415                add.w   d0,d0           | make source number a valents[] index
     416                move.w  d0,d5           | ... (fast multiply by VALLEN = 10
     417                lsl.w   #2,d0           | ...  via shift and add)
     418                add.w   d5,d0           | ...
     419                lea     _valents,a0     | get base of valents[]
     420                move.w  VT_VAL(a0,d0.W),d5      | get value
     421
     422| ------------------------------------------------------------------------------
     423| apply the multiplier to the source, and add it to the function value
     424| ------------------------------------------------------------------------------
     425applym:         muls    PT_VMLT(a2,d2.W),d5     | apply the multiplier
     426                asr.l   #7,d5           | scale the result
     427                asr.l   #8,d5           | ...
     428                ext.l   d3              | add the function value
     429                add.l   d3,d5           | ...
     430                cmpi.l  #VALMAX,d5      | check for overflow
     431                ble     srcmlt1         | jump if no overflow
     432
     433                move.l  #VALMAX,d5      | limit at VALMAX
     434                bra     srcmlt2         | ...
     435
     436srcmlt1:        cmpi.l  #VALMIN,d5      | check for underflow
     437                bge     srcmlt2         | jump if no underflow
     438
     439                move.l  #VALMIN,d5      | limit at VALMIN
     440
     441srcmlt2:        move.w  d5,d3           | setup value for output to FPU
     442
     443                .page
     444| ------------------------------------------------------------------------------
     445| adjust the value according to the function type
     446| ------------------------------------------------------------------------------
     447nosrc:          move.w  d1,d0           | get function type
     448                andi.w  #0x01E0,d0      | ...
     449
     450| ------------------------------------------------------------------------------
     451| level or location
     452| ------------------------------------------------------------------------------
     453                cmpi.w  #P_LEVEL,d0     | see if it's the level
     454                beq     outsegl         | jump if so
     455
     456                cmpi.w  #P_LOCN,d0      | see if it's the location
     457                bne     outsegf         | jump if not
     458
     459                tst.w   d3              | check sign of value
     460                bpl     outsegc         | jump if positive
     461
     462                clr.w   d3              | force negative values to 0
     463
     464outsegc:        asr.w   #5,d3           | shift value to LS bits
     465                sub.w   #500,d3         | subtract 5.00 from value
     466                asl.w   #6,d3           | readjust to MS bits
     467                bra     outseg3         | go output the value
     468
     469outsegl:        tst.w   d3              | check sign of value
     470                bpl     outsegm         | jump if positive
     471
     472                clr.w   d3              | limit negative values at 0
     473
     474outsegm:        asr.w   #5,d3           | shift value to LS bits
     475                sub.w   #500,d3         | subtract 5.00 from value
     476                asl.w   #6,d3           | readjust to MS bits
     477                bra     outseg3         | go output the value
     478
     479                .page
     480| ------------------------------------------------------------------------------
     481| filter
     482| ------------------------------------------------------------------------------
     483outsegf:        cmpi.w  #P_FILTER,d0    | see if it's filter
     484                bne     outsegp         | jump if not
     485
     486                ext.l   d3              | make function value a long
     487                asr.l   #1,d3           | multiply function value by .75
     488                move.l  d3,d0           | ...  (fast multiply by .75
     489                asr.l   #1,d0           | ...   via shift and add)
     490                add.l   d0,d3           | ...
     491                move.w  (a1),d0         | add pitch
     492                ext.l   d0              | ...
     493                add.l   d0,d3           | ...
     494                cmpi.l  #VALMAX,d3      | see if it's within limits
     495                ble     outsega         | ...
     496
     497                move.w  #VALMAX,d3      | limit at VALMAX
     498                bra     outseg3         | ...
     499
     500outsega:        cmpi.l  #VALMIN,d3      | ...
     501                bge     outseg3         | ...
     502
     503                move.w  #VALMIN,d3      | limit at VALMIN
     504                bra     outseg3         | ...
     505
     506                .page
     507| ------------------------------------------------------------------------------
     508| freq 1..4
     509| ------------------------------------------------------------------------------
     510outsegp:        cmpi.w  #P_FREQ1,d0     | see if it's freq1
     511                beq     outseg0         | go process freq1
     512
     513outsegq:        cmpi.w  #P_FREQ2,d0     | see if it's freq2
     514                beq     outseg0         | process it if so
     515
     516                cmpi.w  #P_FREQ3,d0     | see if it's freq3
     517                beq     outseg0         | process it if so
     518
     519                cmpi.w  #P_FREQ4,d0     | see if it's freq4
     520                bne     outseg3         | jump if not
     521
     522outseg0:        ext.l   d3              | scale the point value to cents offset
     523                asr.l   #5,d3           | ...
     524                sub.l   #500,d3         | ... value - 500
     525                asl.l   #LSPCH,d3       | mult. by 2 and scale for 1/2 cent lsb
     526                move.w  (a1),d0         | add pitch from function header
     527                ext.l   d0              | ...
     528                add.l   d0,d3           | ...
     529                cmp.l   #PCHMAX,d3      | see if result is valid
     530                ble     outseg3         | jump if within pitch limits
     531
     532                move.l  #PCHMAX,d3      | limit at maximum pitch
     533
     534| ------------------------------------------------------------------------------
     535| send the value to the FPU
     536| ------------------------------------------------------------------------------
     537outseg3:        move.b  FH_TMD(a1),d0   | get hardware bits from function header
     538                eor.w   #VAL_BITS,d0    | toggle new value select bits
     539                move.b  d0,FH_TMD(a1)   | store updated word
     540                btst.l  #VSUBNBIT,d0    | check which value address to use
    541541                beq     outseg1
    542 *
    543                 move.w  d3,F_VAL01(a3,d1.W)     * send value to FPU
     542
     543                move.w  d3,F_VAL01(a3,d1.W)     | send value to FPU
    544544                bra     outseg2
    545 *
    546 outseg1:        move.w  d3,F_VAL10(a3,d1.W)     * send value to FPU
    547 *
    548 outseg2:        andi.w  #MSK_CTL,d0             * mask off software bits
    549                 ori.w   #UPD_BIT+INT_BIT,d0     * set the update & !lastseg bits
    550                 move.w  d0,F_CTL(a3,d1.W)       * send control word to FPU
    551                 bra     fpexit                  * done -- exit
    552 *
    553                 .page
    554 *
    555 * ------------------------------------------------------------------------------
    556 * act1 -- AC_SUST -- pause if key is down  (sustain)
    557 * ----    ------------------------------------------
    558 act1:           move.w  _fpuifnc,d0     * get voice as a word index
    559                 lsr.w   #3,d0           * ...
    560                 andi.w  #$001E,d0       * ...
    561                 lea     _vce2trg,a0     * point at voice to trigger table
    562                 move.w  0(a0,d0.W),d0   * get trigger table entry into d0
    563                 cmpi.w  #-1,d0          * see if voice is free
    564                 beq     act0            * continue function if so
    565 *
    566                 btst    #15,d0          * see if voice is held by a pedal
    567                 bne     act1a           * sustain if so
    568 *
    569                 btst    #14,d0          * see if voice is sustained by a pedal
    570                 bne     act1a           * sustain if so
    571 *
    572                 lea     _trgtab,a0      * point at trigger table
    573                 tst.b   0(a0,d0.W)      * check trigger status
    574                 beq     act0            * continue function if not active
    575 *
    576 act1a:          move.l  _pfqhdr,d3      * see if any pflist entries remain
    577                 beq     act0            * continue if not  (shouldn't happen!)
    578 *
    579                 move.b  FH_PT1(a1),d0   * get first point number
    580                 add.b   FH_PIF(a1),d0   * add base to first point
    581                 subq.b  #1,d0           * make d0 last point number
    582                 cmp.b   FH_CPT(a1),d0   * check current point number
    583                 beq     stopfn          * done if this is the last point
    584 *
    585                 addq.b  #1,FH_CPT(a1)           * update current point number
    586                 addi.w  #PT_LEN,d2              * advance the point index
    587                 movea.l d3,a0                   * acquire a new pflist entry
    588                 move.l  (a0),_pfqhdr            * ...
    589                 move.l  _pflist,(a0)            * chain it to pflist
    590                 move.l  a0,_pflist              * ...
    591                 move.w  FH_TRG(a1),PF_TRIG(a0)          * set trigger number in entry
    592                 move.w  _fpuifnc,PF_FUNC(a0)            * set v/p word in entry
    593                 movem.l d1-d2/d4/a1-a3,PF_D1(a0)        * set registers in entry
    594                 move.b  FH_TMD(a1),d0           * stop the function
    595                 andi.w  #MSK_RNVB,d0            * ...
    596                 move.w  d0,d3                   * ...
    597                 add.w   d3,d3                   * ...
    598                 andi.w  #MSK_ONVB,d3            * ...
    599                 or.w    d3,d0                   * ...
    600                 move.w  d0,F_CTL(a3,d1.W)       * ...
    601                 bra     fpexit                  * exit
    602 *
    603                 .page
    604 *
    605 * ------------------------------------------------------------------------------
    606 * act2 -- AC_ENBL -- stop if key is up
    607 * ----    ----------------------------
    608 act2:           move.w  _fpuifnc,d0     * get voice as a word index
    609                 lsr.w   #3,d0           * ...
    610                 andi.w  #$001E,d0       * ...
    611                 lea     _vce2trg,a0     * check to see if voice is free
    612                 move.w  0(a0,d0.W),d0   * ...
    613                 cmpi.w  #-1,d0          * ...
    614                 beq     stopfn          * if so, stop the function
    615 *
    616                 btst    #15,d0          * see if voice is held
    617                 bne     act0            * continue if so
    618 *
    619                 btst    #14,d0          * ...
    620                 bne     act0            * ...
    621 *
    622                 lea     _trgtab,a0      * check trigger table entry
    623                 tst.b   0(a0,d0.W)      * ...
    624                 bne     act0            * if trigger is active, continue
    625 *
    626                 bra     stopfn          * if not, stop the function
    627 *
    628 * ------------------------------------------------------------------------------
    629 * act3 -- AC_JUMP -- unconditional jump
    630 * ----    -----------------------------
    631 act3:           cmp.b   FH_PIF(a1),d4   * check jump point against limit
    632                 bcc     stopfn          * stop function if jump point invalid
    633 *
    634                 clr.w   d2              * get index of first point
    635                 move.b  FH_PT1(a1),d2   * ...
    636                 add.b   d4,d2           * add jump point
    637                 move.b  d2,FH_CPT(a1)   * make it the current point
    638                 lsl.w   #2,d2           * develop new point index in d2
    639                 move.w  d2,d0           * ... (fast multiply by PT_LEN = 12
    640                 add.w   d2,d2           * ...  via shift and add)
    641                 add.w   d0,d2           * ...
    642                 bra     outseg          * output the segment
    643 *
    644                 .page
    645 *
    646 * ------------------------------------------------------------------------------
    647 * act4 -- AC_LOOP -- jump to point PT_PAR1 PT_PAR2 times
    648 * ----    ----------------------------------------------
    649 act4:           tst.b   PT_PAR3(a2,d2.W)        * check counter
    650                 bne     act4a                   * jump if it's running
    651 *
    652                 move.b  PT_PAR2(a2,d2.W),d0     * get parameter
    653                 subi.w  #90,d0                  * put parameter in random range
    654                 bmi     act4b                   * treat as normal if < 90
    655 *
    656                 movem.l d1-d2/a0-a2,-(a7)       * get ranged random number
    657                 move.w  d0,-(a7)                * ...
    658                 jsr     _irand                  * ...
    659                 tst.w   (a7)+                   * ...
    660                 movem.l (a7)+,d1-d2/a0-a2       * ...
    661                 move.b  d0,PT_PAR3(a2,d2.w)     * set counter
    662                 beq     act0                    * next segment if cntr set to 0
    663 *
    664                 bra     act3                    * else jump to the point
    665 *
    666 act4b:          move.b  PT_PAR2(a2,d2.W),PT_PAR3(a2,d2.W)       * set counter
    667                 beq     act0                    * next segment if cntr set to 0
    668 *
    669                 bra     act3                    * else jump to the point
    670 *
    671 act4a:          subq.b  #1,PT_PAR3(a2,d2.W)     * decrement counter
    672                 beq     act0                    * next segment if cntr ran out
    673 *
    674                 bra     act3                    * jump if it's still non-zero
    675 *
    676 * ------------------------------------------------------------------------------
    677 * act5 -- AC_KYUP -- jump if key is up
    678 * ----    ----------------------------
    679 act5:           move.w  _fpuifnc,d0     * get voice as a word index
    680                 lsr.w   #3,d0           * ...
    681                 andi.w  #$001E,d0       * ...
    682                 lea     _vce2trg,a0     * check to see if voice is free
    683                 move.w  0(a0,d0.W),d0   * ...
    684                 cmpi.w  #-1,d0          * ...
    685                 beq     act3            * if so (inactive), do the jump
    686 *
    687                 btst    #15,d0          * see if voice is held
    688                 bne     act0            * continue if so
    689 *
    690                 btst    #14,d0          * ...
    691                 bne     act0            * ...
    692 *
    693                 lea     _trgtab,a0      * check trigger table entry
    694                 tst.b   0(a0,d0.W)      * see if the trigger is active
    695                 beq     act3            * if not, do the jump
    696 *
    697                 bra     act0            * if so, do next segment
    698 *
    699                 .page
    700 *
    701 * ------------------------------------------------------------------------------
    702 * act6 -- AC_KYDN -- jump if key is down
    703 * ----    ------------------------------
    704 act6:           move.w  _fpuifnc,d0     * get voice as a word index
    705                 lsr.w   #3,d0           * ...
    706                 andi.w  #$001E,d0       * ...
    707                 lea     _vce2trg,a0     * check to see if voice is free
    708                 move.w  0(a0,d0.W),d0   * ...
    709                 cmpi.w  #-1,d0          * ...
    710                 beq     act0            * if so (inactive), continue
    711 *
    712                 btst    #15,d0          * see if voice is held
    713                 bne     act3            * do jump if so
    714 *
    715                 btst    #14,d0          * ...
    716                 bne     act3            * ...
    717 *
    718                 lea     _trgtab,a0      * check trigger table entry
    719                 tst.b   0(a0,d0.W)      * see if the trigger is active
    720                 bne     act3            * if so, do the jump
    721 *
    722                 bra     act0            * if not, do next segment
    723 *
    724 * ------------------------------------------------------------------------------
    725 * Test stub
    726 * ---------
    727 act7:           bra     act0            * AC_HERE: treat act7 as AC_NULL
    728 *
    729                 .page
    730 * ------------------------------------------------------------------------------
    731 *
    732 * _fpuclr -- clear the FPU
    733 * -------    -------------
    734 *
    735 *       void
    736 *       fpuclr()
    737 *
    738 *               Resets the FPU functions to their nominal values.
    739 *
    740 * ------------------------------------------------------------------------------
    741 *
    742 _fpuclr:        link    a6,#0                   * link stack frames
    743                 move.w  sr,-(a7)                * save the interrupt level
    744                 ori.w   #$0700,sr               * turn off interrupts
    745 *
    746                 lea     FPUFUNC,a0              * point at the first function
    747                 lea     _fp_resv,a2             * point at reset value table
    748                 move.w  #11,d1                  * set the outer loop count
    749 *
    750                 .page
    751 * ------------------------------------------------------------------------------
    752 * reset the 'spare' function for the voice
    753 * ------------------------------------------------------------------------------
    754 clr0:           move.w  #CLREXP,F_EXP(a0)       * set time exponent
    755                 tst.l   actab                   * delay
    756                 tst.l   actab                   * ...
    757                 move.w  #CLRMNT,F_MNT(a0)       * set time mantissa
    758                 tst.l   actab                   * delay
    759                 tst.l   actab                   * ...
    760 *
    761                 move.w  #0,F_SF3(a0)            * set scale factor 3
    762                 tst.l   actab                   * delay
    763                 tst.l   actab                   * ...
    764                 move.w  #0,F_CV3(a0)            * set voltage 3
    765                 tst.l   actab                   * delay
    766                 tst.l   actab                   * ...
    767 *
    768                 move.w  #0,F_SF2(a0)            * set scale factor 2
    769                 tst.l   actab                   * delay
    770                 tst.l   actab                   * ...
    771                 move.w  #0,F_CV2(a0)            * set voltage 2
    772                 tst.l   actab                   * delay
    773                 tst.l   actab                   * ...
    774 *
    775                 move.w  #0,F_SF1(a0)            * set scale factor 1
    776                 tst.l   actab                   * delay
    777                 tst.l   actab                   * ...
    778                 move.w  #0,F_CV1(a0)            * set voltage 1
    779                 tst.l   actab                   * delay
    780                 tst.l   actab                   * ...
    781 *
    782                 move.w  (a2),F_VAL10(a0)        * set value from variable table
    783                 tst.l   actab                   * delay
    784                 tst.l   actab                   * ...
    785                 move.w  (a2)+,F_VAL01(a0)       * ...
    786                 tst.l   actab                   * delay
    787                 tst.l   actab                   * ...
    788                 move.w  #FSEND,F_CTL(a0)        * set control word
    789                 tst.l   actab                   * delay
    790                 tst.l   actab                   * ...
    791 *
    792                 .page
    793                 adda.w  #$0020,a0               * point at 2nd function
    794                 lea     fprescon,a1             * set reset constant pointer
    795                 move.w  #14,d0                  * set inner loop count
    796 *
    797 * ------------------------------------------------------------------------------
    798 * reset the other functions for the voice
    799 * ------------------------------------------------------------------------------
    800 clr1:           move.w  #CLREXP,F_EXP(a0)       * set time exponent
    801                 tst.l   actab                   * delay
    802                 tst.l   actab                   * ...
    803                 move.w  #CLRMNT,F_MNT(a0)       * set time mantissa
    804                 tst.l   actab                   * delay
    805                 tst.l   actab                   * ...
    806 *
    807                 move.w  #0,F_SF3(a0)            * set scale factor 3
    808                 tst.l   actab                   * delay
    809                 tst.l   actab                   * ...
    810                 move.w  #0,F_CV3(a0)            * set voltage 3
    811                 tst.l   actab                   * delay
    812                 tst.l   actab                   * ...
    813 *
    814                 move.w  #0,F_SF2(a0)            * set scale factor 2
    815                 tst.l   actab                   * delay
    816                 tst.l   actab                   * ...
    817                 move.w  #0,F_CV2(a0)            * set voltage 2
    818                 tst.l   actab                   * delay
    819                 tst.l   actab                   * ...
    820 *
    821                 move.w  #0,F_SF1(a0)            * set scale factor 1
    822                 tst.l   actab                   * delay
    823                 tst.l   actab                   * ...
    824                 move.w  #0,F_CV1(a0)            * set voltage 1
    825                 tst.l   actab                   * delay
    826                 tst.l   actab                   * ...
    827 *
    828                 move.w  (a1),F_VAL10(a0)        * set value from constant table
    829                 tst.l   actab                   * delay
    830                 tst.l   actab                   * ...
    831                 move.w  (a1)+,F_VAL01(a0)       * ...
    832                 tst.l   actab                   * delay
    833                 tst.l   actab                   * ...
    834                 move.w  #FSEND,F_CTL(a0)        * set control word
    835                 tst.l   actab                   * delay
    836                 tst.l   actab                   * ...
    837 *
    838                 .page
    839 * ------------------------------------------------------------------------------
    840 * loop through reset for all of the voices and functions
    841 * ------------------------------------------------------------------------------
    842                 adda.w  #$0020,a0               * point at next function
    843                 dbra    d0,clr1                 * loop until all funcs. cleared
    844 *
    845                 dbra    d1,clr0                 * loop until all voices cleared
    846 * ------------------------------------------------------------------------------
    847 * clear the FPU interrupt, and return
    848 * ------------------------------------------------------------------------------
    849                 move.w  #0,FPUINT2              * clear FPU interrupt
    850                 move.w  (a7)+,sr                * restore interrupts
    851                 unlk    a6                      * unlink stack frames
    852                 rts                             * return to caller
    853 *
    854                 .page
    855 *
    856 * _clrvce -- quiet a voice
    857 * -------    -------------
    858 *
    859 *       void
    860 *       clrvce(vce)
    861 *       short vce;
    862 *
    863 *               Quiet the voice by resetting the FPU functions it uses.
    864 *
    865 _clrvce:        link    a6,#0                   * link stack frames
    866                 move.w  sr,-(a7)                * save the interrupt level
    867                 ori.w   #$0700,sr               * turn off interrupts
    868 *
    869                 lea     FPUFUNC+$20,a0          * point at the 2nd function
    870                 move.w  8(a6),d0                * get voice number
    871                 ext.l   d0                      * ...
    872                 lsl.l   #8,d0                   * shift into position
    873                 add.l   d0,d0                   * ...
    874                 adda.l  d0,a0                   * add to function base
    875                 lea     fprescon,a1             * set reset constant pointer
    876                 move.w  #14,d0                  * set inner loop count
    877 *
    878 vclr1:          move.l  a0,d1                   * see if we reset this function
    879                 and.w   #$01F0,d1               * ...
    880 *
    881                 cmpi.w  #$0100,d1               * dynamics ?
    882                 beq     vclr2                   * skip it if so
    883 *
    884                 move.w  #CLREXP,F_EXP(a0)       * set time exponent
    885                 tst.l   actab                   * delay
    886                 tst.l   actab                   * ...
    887                 move.w  #CLRMNT,F_MNT(a0)       * set time mantissa
    888                 tst.l   actab                   * delay
    889                 tst.l   actab                   * ...
    890 *
    891                 cmpi.w  #$0020,d1               * freq 1 ?
    892                 beq     vclr3                   * don't reset CV3 (fine tune)
    893 *
    894                 move.w  #0,F_SF3(a0)            * set scale factor 3
    895                 tst.l   actab                   * delay
    896                 tst.l   actab                   * ...
    897                 move.w  #0,F_CV3(a0)            * set voltage 3
    898                 tst.l   actab                   * delay
    899                 tst.l   actab                   * ...
    900 *
    901 vclr3:          move.w  #0,F_SF1(a0)            * set scale factor 1
    902                 tst.l   actab                   * delay
    903                 tst.l   actab                   * ...
    904                 move.w  #0,F_CV1(a0)            * set voltage 1
    905                 tst.l   actab                   * delay
    906                 tst.l   actab                   * ...
    907 *
    908                 .page
    909 *
    910                 move.w  (a1),F_VAL10(a0)        * set value from constant table
    911                 tst.l   actab                   * delay
    912                 tst.l   actab                   * ...
    913                 move.w  (a1),F_VAL01(a0)        * ...
    914                 tst.l   actab                   * delay
    915                 tst.l   actab                   * ...
    916                 move.w  #FSEND,F_CTL(a0)        * set control word
    917                 tst.l   actab                   * delay
    918                 tst.l   actab                   * ...
    919 *
    920 vclr2:          adda.w  #2,a1                   * point at next function
    921                 adda.w  #$0020,a0               *
    922                 dbra    d0,vclr1                * loop until all funcs. cleared
    923 *
    924                 move.w  (a7)+,sr                * restore interrupts
    925                 unlk    a6                      * unlink stack frames
    926                 rts                             * return to caller
    927 *
    928                 .page
    929 * ------------------------------------------------------------------------------
     545
     546outseg1:        move.w  d3,F_VAL10(a3,d1.W)     | send value to FPU
     547
     548outseg2:        andi.w  #MSK_CTL,d0             | mask off software bits
     549                ori.w   #UPD_BIT+INT_BIT,d0     | set the update & !lastseg bits
     550                move.w  d0,F_CTL(a3,d1.W)       | send control word to FPU
     551                bra     fpexit                  | done -- exit
     552
     553                .page
     554
     555| ------------------------------------------------------------------------------
     556| act1 -- AC_SUST -- pause if key is down  (sustain)
     557| ----    ------------------------------------------
     558act1:           move.w  _fpuifnc,d0     | get voice as a word index
     559                lsr.w   #3,d0           | ...
     560                andi.w  #0x001E,d0      | ...
     561                lea     _vce2trg,a0     | point at voice to trigger table
     562                move.w  0(a0,d0.W),d0   | get trigger table entry into d0
     563                cmpi.w  #-1,d0          | see if voice is free
     564                beq     act0            | continue function if so
     565
     566                btst    #15,d0          | see if voice is held by a pedal
     567                bne     act1a           | sustain if so
     568
     569                btst    #14,d0          | see if voice is sustained by a pedal
     570                bne     act1a           | sustain if so
     571
     572                lea     _trgtab,a0      | point at trigger table
     573                tst.b   0(a0,d0.W)      | check trigger status
     574                beq     act0            | continue function if not active
     575
     576act1a:          move.l  _pfqhdr,d3      | see if any pflist entries remain
     577                beq     act0            | continue if not  (shouldn't happen!)
     578
     579                move.b  FH_PT1(a1),d0   | get first point number
     580                add.b   FH_PIF(a1),d0   | add base to first point
     581                subq.b  #1,d0           | make d0 last point number
     582                cmp.b   FH_CPT(a1),d0   | check current point number
     583                beq     stopfn          | done if this is the last point
     584
     585                addq.b  #1,FH_CPT(a1)           | update current point number
     586                addi.w  #PT_LEN,d2              | advance the point index
     587                movea.l d3,a0                   | acquire a new pflist entry
     588                move.l  (a0),_pfqhdr            | ...
     589                move.l  _pflist,(a0)            | chain it to pflist
     590                move.l  a0,_pflist              | ...
     591                move.w  FH_TRG(a1),PF_TRIG(a0)          | set trigger number in entry
     592                move.w  _fpuifnc,PF_FUNC(a0)            | set v/p word in entry
     593                movem.l d1-d2/d4/a1-a3,PF_D1(a0)        | set registers in entry
     594                move.b  FH_TMD(a1),d0           | stop the function
     595                andi.w  #MSK_RNVB,d0            | ...
     596                move.w  d0,d3                   | ...
     597                add.w   d3,d3                   | ...
     598                andi.w  #MSK_ONVB,d3            | ...
     599                or.w    d3,d0                   | ...
     600                move.w  d0,F_CTL(a3,d1.W)       | ...
     601                bra     fpexit                  | exit
     602
     603                .page
     604
     605| ------------------------------------------------------------------------------
     606| act2 -- AC_ENBL -- stop if key is up
     607| ----    ----------------------------
     608act2:           move.w  _fpuifnc,d0     | get voice as a word index
     609                lsr.w   #3,d0           | ...
     610                andi.w  #0x001E,d0      | ...
     611                lea     _vce2trg,a0     | check to see if voice is free
     612                move.w  0(a0,d0.W),d0   | ...
     613                cmpi.w  #-1,d0          | ...
     614                beq     stopfn          | if so, stop the function
     615
     616                btst    #15,d0          | see if voice is held
     617                bne     act0            | continue if so
     618
     619                btst    #14,d0          | ...
     620                bne     act0            | ...
     621
     622                lea     _trgtab,a0      | check trigger table entry
     623                tst.b   0(a0,d0.W)      | ...
     624                bne     act0            | if trigger is active, continue
     625
     626                bra     stopfn          | if not, stop the function
     627
     628| ------------------------------------------------------------------------------
     629| act3 -- AC_JUMP -- unconditional jump
     630| ----    -----------------------------
     631act3:           cmp.b   FH_PIF(a1),d4   | check jump point against limit
     632                bcc     stopfn          | stop function if jump point invalid
     633
     634                clr.w   d2              | get index of first point
     635                move.b  FH_PT1(a1),d2   | ...
     636                add.b   d4,d2           | add jump point
     637                move.b  d2,FH_CPT(a1)   | make it the current point
     638                lsl.w   #2,d2           | develop new point index in d2
     639                move.w  d2,d0           | ... (fast multiply by PT_LEN = 12
     640                add.w   d2,d2           | ...  via shift and add)
     641                add.w   d0,d2           | ...
     642                bra     outseg          | output the segment
     643
     644                .page
     645
     646| ------------------------------------------------------------------------------
     647| act4 -- AC_LOOP -- jump to point PT_PAR1 PT_PAR2 times
     648| ----    ----------------------------------------------
     649act4:           tst.b   PT_PAR3(a2,d2.W)        | check counter
     650                bne     act4a                   | jump if it's running
     651
     652                move.b  PT_PAR2(a2,d2.W),d0     | get parameter
     653                subi.w  #90,d0                  | put parameter in random range
     654                bmi     act4b                   | treat as normal if < 90
     655
     656                movem.l d1-d2/a0-a2,-(a7)       | get ranged random number
     657                move.w  d0,-(a7)                | ...
     658                jsr     _irand                  | ...
     659                tst.w   (a7)+                   | ...
     660                movem.l (a7)+,d1-d2/a0-a2       | ...
     661                move.b  d0,PT_PAR3(a2,d2.w)     | set counter
     662                beq     act0                    | next segment if cntr set to 0
     663
     664                bra     act3                    | else jump to the point
     665
     666act4b:          move.b  PT_PAR2(a2,d2.W),PT_PAR3(a2,d2.W)       | set counter
     667                beq     act0                    | next segment if cntr set to 0
     668
     669                bra     act3                    | else jump to the point
     670
     671act4a:          subq.b  #1,PT_PAR3(a2,d2.W)     | decrement counter
     672                beq     act0                    | next segment if cntr ran out
     673
     674                bra     act3                    | jump if it's still non-zero
     675
     676| ------------------------------------------------------------------------------
     677| act5 -- AC_KYUP -- jump if key is up
     678| ----    ----------------------------
     679act5:           move.w  _fpuifnc,d0     | get voice as a word index
     680                lsr.w   #3,d0           | ...
     681                andi.w  #0x001E,d0      | ...
     682                lea     _vce2trg,a0     | check to see if voice is free
     683                move.w  0(a0,d0.W),d0   | ...
     684                cmpi.w  #-1,d0          | ...
     685                beq     act3            | if so (inactive), do the jump
     686
     687                btst    #15,d0          | see if voice is held
     688                bne     act0            | continue if so
     689
     690                btst    #14,d0          | ...
     691                bne     act0            | ...
     692
     693                lea     _trgtab,a0      | check trigger table entry
     694                tst.b   0(a0,d0.W)      | see if the trigger is active
     695                beq     act3            | if not, do the jump
     696
     697                bra     act0            | if so, do next segment
     698
     699                .page
     700
     701| ------------------------------------------------------------------------------
     702| act6 -- AC_KYDN -- jump if key is down
     703| ----    ------------------------------
     704act6:           move.w  _fpuifnc,d0     | get voice as a word index
     705                lsr.w   #3,d0           | ...
     706                andi.w  #0x001E,d0      | ...
     707                lea     _vce2trg,a0     | check to see if voice is free
     708                move.w  0(a0,d0.W),d0   | ...
     709                cmpi.w  #-1,d0          | ...
     710                beq     act0            | if so (inactive), continue
     711
     712                btst    #15,d0          | see if voice is held
     713                bne     act3            | do jump if so
     714
     715                btst    #14,d0          | ...
     716                bne     act3            | ...
     717
     718                lea     _trgtab,a0      | check trigger table entry
     719                tst.b   0(a0,d0.W)      | see if the trigger is active
     720                bne     act3            | if so, do the jump
     721
     722                bra     act0            | if not, do next segment
     723
     724| ------------------------------------------------------------------------------
     725| Test stub
     726| ---------
     727act7:           bra     act0            | AC_HERE: treat act7 as AC_NULL
     728
     729                .page
     730| ------------------------------------------------------------------------------
     731
     732| _fpuclr -- clear the FPU
     733| -------    -------------
     734
     735|       void
     736|       fpuclr()
     737
     738|               Resets the FPU functions to their nominal values.
     739
     740| ------------------------------------------------------------------------------
     741
     742_fpuclr:        link    a6,#0                   | link stack frames
     743                move.w  sr,-(a7)                | save the interrupt level
     744                ori.w   #0x0700,sr              | turn off interrupts
     745
     746                lea     FPUFUNC,a0              | point at the first function
     747                lea     _fp_resv,a2             | point at reset value table
     748                move.w  #11,d1                  | set the outer loop count
     749
     750                .page
     751| ------------------------------------------------------------------------------
     752| reset the 'spare' function for the voice
     753| ------------------------------------------------------------------------------
     754clr0:           move.w  #CLREXP,F_EXP(a0)       | set time exponent
     755                tst.l   actab                   | delay
     756                tst.l   actab                   | ...
     757                move.w  #CLRMNT,F_MNT(a0)       | set time mantissa
     758                tst.l   actab                   | delay
     759                tst.l   actab                   | ...
     760
     761                move.w  #0,F_SF3(a0)            | set scale factor 3
     762                tst.l   actab                   | delay
     763                tst.l   actab                   | ...
     764                move.w  #0,F_CV3(a0)            | set voltage 3
     765                tst.l   actab                   | delay
     766                tst.l   actab                   | ...
     767
     768                move.w  #0,F_SF2(a0)            | set scale factor 2
     769                tst.l   actab                   | delay
     770                tst.l   actab                   | ...
     771                move.w  #0,F_CV2(a0)            | set voltage 2
     772                tst.l   actab                   | delay
     773                tst.l   actab                   | ...
     774
     775                move.w  #0,F_SF1(a0)            | set scale factor 1
     776                tst.l   actab                   | delay
     777                tst.l   actab                   | ...
     778                move.w  #0,F_CV1(a0)            | set voltage 1
     779                tst.l   actab                   | delay
     780                tst.l   actab                   | ...
     781
     782                move.w  (a2),F_VAL10(a0)        | set value from variable table
     783                tst.l   actab                   | delay
     784                tst.l   actab                   | ...
     785                move.w  (a2)+,F_VAL01(a0)       | ...
     786                tst.l   actab                   | delay
     787                tst.l   actab                   | ...
     788                move.w  #FSEND,F_CTL(a0)        | set control word
     789                tst.l   actab                   | delay
     790                tst.l   actab                   | ...
     791
     792                .page
     793                adda.w  #0x0020,a0              | point at 2nd function
     794                lea     fprescon,a1             | set reset constant pointer
     795                move.w  #14,d0                  | set inner loop count
     796
     797| ------------------------------------------------------------------------------
     798| reset the other functions for the voice
     799| ------------------------------------------------------------------------------
     800clr1:           move.w  #CLREXP,F_EXP(a0)       | set time exponent
     801                tst.l   actab                   | delay
     802                tst.l   actab                   | ...
     803                move.w  #CLRMNT,F_MNT(a0)       | set time mantissa
     804                tst.l   actab                   | delay
     805                tst.l   actab                   | ...
     806
     807                move.w  #0,F_SF3(a0)            | set scale factor 3
     808                tst.l   actab                   | delay
     809                tst.l   actab                   | ...
     810                move.w  #0,F_CV3(a0)            | set voltage 3
     811                tst.l   actab                   | delay
     812                tst.l   actab                   | ...
     813
     814                move.w  #0,F_SF2(a0)            | set scale factor 2
     815                tst.l   actab                   | delay
     816                tst.l   actab                   | ...
     817                move.w  #0,F_CV2(a0)            | set voltage 2
     818                tst.l   actab                   | delay
     819                tst.l   actab                   | ...
     820
     821                move.w  #0,F_SF1(a0)            | set scale factor 1
     822                tst.l   actab                   | delay
     823                tst.l   actab                   | ...
     824                move.w  #0,F_CV1(a0)            | set voltage 1
     825                tst.l   actab                   | delay
     826                tst.l   actab                   | ...
     827
     828                move.w  (a1),F_VAL10(a0)        | set value from constant table
     829                tst.l   actab                   | delay
     830                tst.l   actab                   | ...
     831                move.w  (a1)+,F_VAL01(a0)       | ...
     832                tst.l   actab                   | delay
     833                tst.l   actab                   | ...
     834                move.w  #FSEND,F_CTL(a0)        | set control word
     835                tst.l   actab                   | delay
     836                tst.l   actab                   | ...
     837
     838                .page
     839| ------------------------------------------------------------------------------
     840| loop through reset for all of the voices and functions
     841| ------------------------------------------------------------------------------
     842                adda.w  #0x0020,a0              | point at next function
     843                dbra    d0,clr1                 | loop until all funcs. cleared
     844
     845                dbra    d1,clr0                 | loop until all voices cleared
     846| ------------------------------------------------------------------------------
     847| clear the FPU interrupt, and return
     848| ------------------------------------------------------------------------------
     849                move.w  #0,FPUINT2              | clear FPU interrupt
     850                move.w  (a7)+,sr                | restore interrupts
     851                unlk    a6                      | unlink stack frames
     852                rts                             | return to caller
     853
     854                .page
     855
     856| _clrvce -- quiet a voice
     857| -------    -------------
     858
     859|       void
     860|       clrvce(vce)
     861|       short vce;
     862
     863|               Quiet the voice by resetting the FPU functions it uses.
     864
     865_clrvce:        link    a6,#0                   | link stack frames
     866                move.w  sr,-(a7)                | save the interrupt level
     867                ori.w   #0x0700,sr              | turn off interrupts
     868
     869                lea     FPUFUNC+0x20,a0         | point at the 2nd function
     870                move.w  8(a6),d0                | get voice number
     871                ext.l   d0                      | ...
     872                lsl.l   #8,d0                   | shift into position
     873                add.l   d0,d0                   | ...
     874                adda.l  d0,a0                   | add to function base
     875                lea     fprescon,a1             | set reset constant pointer
     876                move.w  #14,d0                  | set inner loop count
     877
     878vclr1:          move.l  a0,d1                   | see if we reset this function
     879                and.w   #0x01F0,d1              | ...
     880
     881                cmpi.w  #0x0100,d1              | dynamics ?
     882                beq     vclr2                   | skip it if so
     883
     884                move.w  #CLREXP,F_EXP(a0)       | set time exponent
     885                tst.l   actab                   | delay
     886                tst.l   actab                   | ...
     887                move.w  #CLRMNT,F_MNT(a0)       | set time mantissa
     888                tst.l   actab                   | delay
     889                tst.l   actab                   | ...
     890
     891                cmpi.w  #0x0020,d1              | freq 1 ?
     892                beq     vclr3                   | don't reset CV3 (fine tune)
     893
     894                move.w  #0,F_SF3(a0)            | set scale factor 3
     895                tst.l   actab                   | delay
     896                tst.l   actab                   | ...
     897                move.w  #0,F_CV3(a0)            | set voltage 3
     898                tst.l   actab                   | delay
     899                tst.l   actab                   | ...
     900
     901vclr3:          move.w  #0,F_SF1(a0)            | set scale factor 1
     902                tst.l   actab                   | delay
     903                tst.l   actab                   | ...
     904                move.w  #0,F_CV1(a0)            | set voltage 1
     905                tst.l   actab                   | delay
     906                tst.l   actab                   | ...
     907
     908                .page
     909
     910                move.w  (a1),F_VAL10(a0)        | set value from constant table
     911                tst.l   actab                   | delay
     912                tst.l   actab                   | ...
     913                move.w  (a1),F_VAL01(a0)        | ...
     914                tst.l   actab                   | delay
     915                tst.l   actab                   | ...
     916                move.w  #FSEND,F_CTL(a0)        | set control word
     917                tst.l   actab                   | delay
     918                tst.l   actab                   | ...
     919
     920vclr2:          adda.w  #2,a1                   | point at next function
     921                adda.w  #0x0020,a0              |
     922                dbra    d0,vclr1                | loop until all funcs. cleared
     923
     924                move.w  (a7)+,sr                | restore interrupts
     925                unlk    a6                      | unlink stack frames
     926                rts                             | return to caller
     927
     928                .page
     929| ------------------------------------------------------------------------------
    930930                .data
    931 * ------------------------------------------------------------------------------
    932 *
    933 * actab -- action code dispatch table
    934 * -----    --------------------------
    935 actab:          dc.l    act0    * 0 - AC_NULL:  no action
    936                 dc.l    act1    * 1 - AC_SUST:  sustain
    937                 dc.l    act2    * 2 - AC_ENBL:  enable
    938                 dc.l    act3    * 3 - AC_JUMP:  unconditional jump
    939                 dc.l    act4    * 4 - AC_LOOP:  jump n times      (loop)
    940                 dc.l    act5    * 5 - AC_KYUP:  jump if key up    (enable jump)
    941                 dc.l    act6    * 6 - AC_KYDN:  jump if key down  (sustain jump)
    942                 dc.l    act7    * 7 - AC_HERE:  here on key up
    943 *
    944 * fprescon -- FPU reset constant table
    945 * --------    ------------------------
    946 fprescon:       dc.w    $0000   * frq 1           0.00
    947                 dc.w    $8300   * level         -10.00
    948                 dc.w    $0000   * frq 2           0.00
    949                 dc.w    $0000   * locn            0.00
    950                 dc.w    $0000   * frq 3           0.00
    951                 dc.w    $0000   * reson           0.00
    952                 dc.w    $0000   * frq 4           0.00
    953                 dc.w    $7D00   * dyn           +10.00
    954                 dc.w    $0000   * ind 1           0.00
    955                 dc.w    $3E80   * filt           +5.00
    956                 dc.w    $0000   * ind 2           0.00
    957                 dc.w    $0000   * ind 3           0.00
    958                 dc.w    $0000   * ind 4           0.00
    959                 dc.w    $0000   * ind 5           0.00
    960                 dc.w    $0000   * ind 6           0.00
    961 *
    962 * ------------------------------------------------------------------------------
     931| ------------------------------------------------------------------------------
     932
     933| actab -- action code dispatch table
     934| -----    --------------------------
     935actab:          dc.l    act0    | 0 - AC_NULL:  no action
     936                dc.l    act1    | 1 - AC_SUST:  sustain
     937                dc.l    act2    | 2 - AC_ENBL:  enable
     938                dc.l    act3    | 3 - AC_JUMP:  unconditional jump
     939                dc.l    act4    | 4 - AC_LOOP:  jump n times      (loop)
     940                dc.l    act5    | 5 - AC_KYUP:  jump if key up    (enable jump)
     941                dc.l    act6    | 6 - AC_KYDN:  jump if key down  (sustain jump)
     942                dc.l    act7    | 7 - AC_HERE:  here on key up
     943
     944| fprescon -- FPU reset constant table
     945| --------    ------------------------
     946fprescon:       dc.w    0x0000  | frq 1           0.00
     947                dc.w    0x8300  | level         -10.00
     948                dc.w    0x0000  | frq 2           0.00
     949                dc.w    0x0000  | locn            0.00
     950                dc.w    0x0000  | frq 3           0.00
     951                dc.w    0x0000  | reson           0.00
     952                dc.w    0x0000  | frq 4           0.00
     953                dc.w    0x7D00  | dyn           +10.00
     954                dc.w    0x0000  | ind 1           0.00
     955                dc.w    0x3E80  | filt           +5.00
     956                dc.w    0x0000  | ind 2           0.00
     957                dc.w    0x0000  | ind 3           0.00
     958                dc.w    0x0000  | ind 4           0.00
     959                dc.w    0x0000  | ind 5           0.00
     960                dc.w    0x0000  | ind 6           0.00
     961
     962| ------------------------------------------------------------------------------
    963963                .bss
    964 * ------------------------------------------------------------------------------
    965 *
    966 _fp_resv:       ds.w    12              * fpu spare function reset values
    967 _fpuifnc:       ds.w    1               * interrupting function number from FPU
    968 *
     964| ------------------------------------------------------------------------------
     965
     966_fp_resv:       ds.w    12              | fpu spare function reset values
     967_fpuifnc:       ds.w    1               | interrupting function number from FPU
     968
    969969                .end

  • ram/procpfl.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * procpfl.s -- process pendant functions  (sustain release processing)
    3 * Version 8 -- 1988-08-31 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| procpfl.s -- process pendant functions  (sustain release processing)
     3| Version 8 -- 1988-08-31 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   _procpfl
    8 *
    9                 .xdef   _curpf_f        * current function (v/p)
    10                 .xdef   _curpf_l        * current pflist entry
    11                 .xdef   _curpf_t        * current trigger
    12 *
     8
     9                .xdef   _curpf_f        | current function (v/p)
     10                .xdef   _curpf_l        | current pflist entry
     11                .xdef   _curpf_t        | current trigger
     12
    1313                .xref   _irand
    1414                .xref   _xgetran
    15 *
     15
    1616                .xref   _expbit
    1717                .xref   _funcndx
    … …  
    2626                .xref   _vce2trg
    2727                .xref   _veltab
    28 *
    29                 .page
    30 * ------------------------------------------------------------------------------
    31 * Register usage
    32 * --------------
    33 *       d0      scratch
    34 *       d1      FPU function index
    35 *       d2      point index from FH_CPT  (idfcpt)
    36 *       d3      scratch
    37 *       d4      jump point number from PT_PAR1  (ippar1)
    38 *       d5      scratch
    39 *
    40 *       a0      scratch
    41 *       a1      function header base
    42 *       a2      point table base
    43 *       a3      FPU base
    44 *
    45 * ------------------------------------------------------------------------------
    46 * FPU definitions
    47 * ---------------
    48 *
    49 UPD_BIT         .equ    $0001                   * update bit  (1 = update)
    50 INT_BIT         .equ    $0002                   * int. bit    (0 = disable)
    51 RAT_BIT         .equ    $0004                   * ratio bit   (0 = ratio)
    52 *
    53 VSUBNBIT        .equ    3                       * new value select bit number
    54 VAL_BITS        .equ    $0018                   * new value select bit mask
    55 *
    56 MSK_RNVB        .equ    $000C                   * new value / ratio bits
    57 MSK_ONVB        .equ    $0010                   * old new value bit
    58 *
    59 FKILL           .equ    $0014                   * kill value for function
    60 FSEND           .equ    $0015                   * send new value to function
    61 *
    62 CLREXP          .equ    $8000                   * clear value for time exponent
    63 CLRMNT          .equ    $8000                   * clear value for time mantissa
    64 *
    65 * ------------------------------------------------------------------------------
    66 * Miscellaneous definitions
    67 * -------------------------
    68 *
    69 PCHMAX          .equ    21920                   * maximum pitch value
    70 VALMAX          .equ    32000                   * maximum value to send to FPU
    71 VALMIN          .equ    -32000                  * minimum value to send to FPU
    72 *
    73 LSPCH           .equ    2                       * left shift for sources to freq
    74 *
    75 VALLEN          .equ    10                      * length of the 'valent' struct
    76 VT_VAL          .equ    8                       * value offset in 'valent'
    77 *
    78                 .page
    79 * ------------------------------------------------------------------------------
    80 * FPU addresses
    81 * -------------
    82 *
    83 FPUBASE         .equ    $180000                 * FPU base address
    84 *
    85 FPUWST          .equ    FPUBASE                 * FPU waveshape base
    86 FPUFUNC         .equ    FPUBASE+$4000           * FPU function base
    87 FPUINT1         .equ    FPUBASE+$4000           * FPU int. input address (R/O)
    88 FPUINT2         .equ    FPUBASE+$6000           * FPU int. reset address (W/O)
    89 FPUCFG          .equ    FPUBASE+$5FE0           * FPU config. data address (W/O)
    90 *
    91 F_CTL           .equ    $00                     * control word
    92 F_VAL10         .equ    $02                     * new value "10"
    93 F_CV1           .equ    $08                     * control voltage 1
    94 F_SF1           .equ    $0A                     * scale factor 1
    95 F_CV2           .equ    $0C                     * control voltage 2
    96 F_SF2           .equ    $0E                     * scale factor 2
    97 F_CV3           .equ    $10                     * control voltage 3
    98 F_SF3           .equ    $12                     * scale factor 3
    99 F_MNT           .equ    $14                     * time mantissa
    100 F_EXP           .equ    $16                     * time exponent
    101 F_VAL01         .equ    $1C                     * new value "01"
    102 *
    103 P_FREQ1         .equ    $0020                   * frequency 1
    104 P_FREQ2         .equ    $0060                   * frequency 2
    105 P_FREQ3         .equ    $00A0                   * frequency 3
    106 P_FREQ4         .equ    $00E0                   * frequency 4
    107 P_FILTER        .equ    $0140                   * filter
    108 P_FILTRQ        .equ    $00C0                   * filter q
    109 *
    110 P_INDEX1        .equ    $0120                   * index 1
    111 P_INDEX2        .equ    $0160                   * index 2
    112 P_INDEX3        .equ    $0180                   * index 3
    113 P_INDEX4        .equ    $01A0                   * index 4
    114 P_INDEX5        .equ    $01C0                   * index 5
    115 P_INDEX6        .equ    $01E0                   * index 6
    116 *
    117 P_LEVEL         .equ    $0040                   * level
    118 *
    119 P_LOCN          .equ    $0080                   * location
    120 P_DYNAM         .equ    $0100                   * dynamics
    121 *
    122                 .page
    123 * ------------------------------------------------------------------------------
    124 * Structure definitions
    125 * ------------------------------------------------------------------------------
    126 * The following MUST match the idfnhdr structure definition in instdsp.h:
    127 *
    128 FH_LEN          .equ    12              * length of the idfnhdr structure
    129 *
    130 FH_PCH          .equ    0               * WORD - pitch offset
    131 FH_MLT          .equ    2               * WORD - overall value multiplier
    132 FH_SRC          .equ    4               * BYTE - overall value source
    133 FH_PIF          .equ    5               * BYTE - # of points in the function
    134 FH_PT1          .equ    6               * BYTE - index of first point
    135 FH_TMD          .equ    7               * BYTE - trigger mode / control bits
    136 FH_CPT          .equ    8               * BYTE - current point
    137 FH_PRM          .equ    9               * BYTE - misc. function parameter
    138 FH_TRG          .equ    10              * WORD - trigger
    139 *
    140 I_ACTIVE        .equ    1               * 'Active' bit number        (in FH_TMD)
    141 *
    142 MSK_CTL         .equ    $001C           * mask for FPU hardware bits (in FH_TMD)
    143 *
    144 * ------------------------------------------------------------------------------
    145 * The following MUST match the instpnt structure definition in instdsp.h:
    146 *
    147 PT_LEN          .equ    12              * length of the instpnt structure
    148 *
    149 PT_TIM          .equ    0               * WORD - time (packed)
    150 PT_VAL          .equ    2               * WORD - value
    151 PT_VMLT         .equ    4               * WORD - value multiplier
    152 PT_VSRC         .equ    6               * BYTE - value source
    153 PT_ACT          .equ    7               * BYTE - action
    154 PT_PAR1         .equ    8               * BYTE - parameter 1
    155 PT_PAR2         .equ    9               * BYTE - parameter 2
    156 PT_PAR3         .equ    10              * BYTE - parameter 3
    157 PT_PAD          .equ    11              * BYTE - padding for even boundary
    158 *
    159 MSK_MNT         .equ    $FFF0           * mask for mantissa  (in PT_TIM)
    160 MSK_EXP         .equ    $000F           * mask for exponent  (in PT_TIM)
    161 *
    162 MAX_ACT         .equ    7               * maximum action code value
    163 *
    164 * ------------------------------------------------------------------------------
    165 * Source definitions -- must match those in 'smdefs.h'
    166 *
    167 SM_RAND         .equ    1               * random
    168 SM_PTCH         .equ    5               * pitch
    169 SM_KPRS         .equ    6               * key pressure
    170 SM_KVEL         .equ    7               * key velocity
    171 SM_FREQ         .equ    10              * frequency
    172 *
    173                 .page
    174 *
    175 * Layout of pflist entries      32 bytes each
    176 * ------------------------
    177 PF_NEXT         .equ    0               * LONG - next entry pointer
    178 PF_TRIG         .equ    4               * WORD - trigger number
    179 PF_FUNC         .equ    6               * WORD - fpuifnc value
    180 PF_D1           .equ    8               * LONG - d1
    181 PF_D2           .equ    12              * LONG - d2
    182 PF_D4           .equ    16              * LONG - d4
    183 PF_A1           .equ    20              * LONG - a1
    184 PF_A2           .equ    24              * LONG - a2
    185 PF_A3           .equ    28              * LONG - a3
    186 *
    187 * Parameter offset
    188 * ----------------
    189 TRIG            .equ    8               * WORD - trigger number
    190 *
    191 * Register equates
    192 * ----------------
    193 RCUR            .equ    a4              * current pflist entry pointer
    194 RPRV            .equ    a5              * previous pflist entry pointer
    195 *
    196                 .page
    197 * ------------------------------------------------------------------------------
    198 * _procpfl() -- process pendant functions
    199 *
    200 *       void
    201 *       procpfl(trig);
    202 *       unsigned trig;
    203 *
    204 *               Processes pendant (sustained) functions by restarting them
    205 *       when the trigger (trig) that's sustaining them is released.
    206 *       Invoked by key release processing in msm() and localkb().
    207 *
    208 * ------------------------------------------------------------------------------
    209 *
    210 _procpfl:       nop                             * FOR DEBUGGING PATCH
    211 *
    212                 link    a6,#0                   * allocate stack frame
    213                 movem.l d3-d7/a3-a5,-(a7)       * preserve registers we use
    214 *
    215                 move.w  sr,d7                   * save interrupt state
    216                 move.w  #$2200,sr               * turn off FPU interrupts
    217 *
    218                 move.w  TRIG(a6),d6             * get trigger we're processing
    219                 move.w  d6,_curpf_t             * ...
    220                 movea.l #_pflist,RPRV           * point at 'previous' pflist entry
    221                 bra     pfscan                  * go scan the chain
    222 *
    223 pfpass:         movea.l RCUR,RPRV               * point at previous entry
    224 *
    225 pfscan:         move.l  (RPRV),d5               * get next pflist entry pointer
    226                 beq     pfexit                  * done if no more
    227 *
    228                 movea.l d5,RCUR                 * point at  current entry
    229                 move.l  d5,_curpf_l             * ...
    230 *
    231                 cmp.w   PF_TRIG(RCUR),d6        * see if this entry is wanted
    232                 bne     pfpass                  * jump if not
    233 *
    234                 movem.l PF_D1(RCUR),d1-d2/d4/a1-a3      * restore processing state
    235                 move.w  PF_FUNC(RCUR),_curpf_f          * ...
    236 *
    237                 btst    #I_ACTIVE,FH_TMD(a1)    * see if function is active
    238                 bne     doact                   * continue function if so
    239 *
    240                 bra     stopfn                  * stop function if not
    241 *
    242 pfnext:         move.l  (RCUR),(RPRV)           * remove entry from pflist
    243                 move.l  _pfqhdr,(RCUR)          * chain entry to free list
    244                 move.l  RCUR,_pfqhdr            * ...
    245                 bra     pfscan                  * go look at next entry
    246 *
    247 pfexit:         move.w  d7,sr                   * restore interrupt level
    248                 movem.l (a7)+,d3-d7/a3-a5       * restore the registers we used
    249                 unlk    a6                      * deallocate stack frame
    250                 rts                             * return to caller
    251 *
    252                 .page
    253 *
    254 * ------------------------------------------------------------------------------
    255 * stop a function
    256 * ------------------------------------------------------------------------------
    257 stopfn:         move.b  FH_TMD(a1),d0   * get function control bits
    258                 andi.w  #MSK_RNVB,d0    * mask for ratio / new new-value bit
    259                 move.w  d0,d3           * isolate new new-value bit
    260                 add.w   d3,d3           * ... from function header
    261                 andi.w  #MSK_ONVB,d3    * ... shift to old new-value bit
    262                 or.w    d3,d0           * ... and put new bit in old bit       
    263                 move.w  d0,F_CTL(a3,d1.W)       * stop the function
    264                 bclr    #I_ACTIVE,FH_TMD(a1)    * reset the active bit
    265                 bra     pfnext          * go restore registers and exit
    266 *
    267 * ------------------------------------------------------------------------------
    268 * setup for and dispatch to the proper action handler
    269 * ------------------------------------------------------------------------------
    270 doact:          clr.w   d2              * get current point index in d2
    271                 move.b  FH_CPT(a1),d2   * ...
    272                 lsl.w   #2,d2           * multiply it by the length of a point
    273                 move.w  d2,d0           * ...  (fast multiply by PT_LEN = 12
    274                 add.w   d2,d2           * ...   via shift and add)
    275                 add.w   d0,d2           * ...
    276                 clr.w   d4              * get jump point # into d4
    277                 move.b  PT_PAR1(a2,d2.W),d4     * ...
    278                 clr.w   d3              * get action code in d3
    279                 move.b  PT_ACT(a2,d2.W),d3      * ...
    280                 cmpi.b  #MAX_ACT,d3     * check against the limit
    281                 bgt     stopfn          * stop things if it's a bad action code
    282 *
    283                 lsl.w   #2,d3           * develop index to action dispatch table
    284                 lea     actab,a0        * get the address of the action handler
    285                 movea.l 0(a0,d3.W),a0   * ...
    286 *
    287 * ------------------------------------------------------------------------------
    288 * At this point we're ready to do the action associated with the point,
    289 * and the registers are set up,  and will remain,  as follows:
    290 *
    291 *       d1      FPU function index      a1      function header base
    292 *       d2      point table index       a2      point table base
    293 *                                       a3      FPU function base
    294 *       d4      jump point number
    295 *
    296 *       d0, d3, d5, and a0 are used as scratch throughout the code.
    297 *
    298 * ------------------------------------------------------------------------------
    299 *
    300                 jmp     (a0)            * dispatch to action handler
    301 *
    302                 .page
    303 * ------------------------------------------------------------------------------
    304 * act0 -- AC_NULL -- no action
    305 * ----    --------------------
    306 act0:           move.b  FH_PT1(a1),d0   * get first point number
    307                 add.b   FH_PIF(a1),d0   * add number of points in function
    308                 subq.b  #1,d0           * make it last point number
    309                 cmp.b   FH_CPT(a1),d0   * see if we're at the last point
    310                 beq     stopfn          * stop function if so
    311 *
    312                 addq.b  #1,FH_CPT(a1)   * update function header for next point
    313                 addi.w  #PT_LEN,d2      * advance the point index
    314 *
    315 * ------------------------------------------------------------------------------
    316 * outseg -- output a segment
    317 * ------    ----------------
    318 outseg:         move.w  PT_TIM(a2,d2.w),d3      * get packed time
    319                 move.w  d3,d0                   * extract mantissa
    320                 andi.w  #MSK_MNT,d0             * ...
    321                 mulu    _timemlt,d0             * multiply by panel time pot value
    322                 lsr.l   #8,d0                   * ... and scale it
    323                 lsr.l   #7,d0                   * ...
    324                 move.w  d0,F_MNT(a3,d1.W)       * send mantissa to FPU
    325                 andi.w  #MSK_EXP,d3             * extract exponent code
    326                 add.w   d3,d3                   * look up decoded exponent
    327                 lea     _expbit,a0              * ... in expbit
    328                 move.w  0(a0,d3.W),F_EXP(a3,d1.W)       * send exponent to FPU
    329                 move.w  PT_VAL(a2,d2.W),d3      * get the function value
    330 *
    331                 .page
    332 * ------------------------------------------------------------------------------
    333 * get the point source, if any
    334 * ------------------------------------------------------------------------------
    335                 tst.w   PT_VMLT(a2,d2.W)        * see if we have a point mlt.
    336                 beq     nosrc                   * don't do anything for zero
    337 *
    338                 clr.w   d0                      * get the source number
    339                 move.b  PT_VSRC(a2,d2.W),d0     * ...
    340                 beq     nosrc                   * don't do anything for zero
    341 *
    342 * ------------------------------------------------------------------------------
    343 * SM_RAND -- random
    344 * ------------------------------------------------------------------------------
    345                 cmpi.w  #SM_RAND,d0             * is this the random source ?
    346                 bne     srctyp0                 * jump if not
    347 *
    348                 movem.l d1-d2/a0-a2,-(a7)       * preserve registers around call
    349                 move.w  PT_VMLT(a2,d2.W),-(a7)  * pass multiplier to xgetran()
    350                 jsr     _xgetran                * call for a random number
    351                 tst.w   (a7)+                   * clean up stack
    352                 movem.l (a7)+,d1-d2/a0-a2       * restore registers
    353                 move.w  d0,d5                   * put random value in the value register
    354                 bra     applym                  * go apply the multiplier
    355 *
    356                 .page
    357 * ------------------------------------------------------------------------------
    358 * SM_FREQ -- frequency
    359 * ------------------------------------------------------------------------------
    360 srctyp0:        cmpi.w  #SM_FREQ,d0     * is this the frequency source ?
    361                 bne     srctyp1         * jump if not
    362 *
    363                 move.w  (a1),d0         * get the pitch
    364                 lsr.w   #6,d0           * shift to a word index
    365                 andi.w  #$01FE,d0       * mask out extraneous bits
    366                 lea     _ptoftab,a0     * get entry from ptoftab[]
    367                 move.w  0(a0,d0.W),d5   * ...
    368                 bra     applym          * go apply the multiplier
    369 *
    370 * ------------------------------------------------------------------------------
    371 * SM_PTCH -- pitch
    372 * ------------------------------------------------------------------------------
    373 srctyp1:        cmpi.w  #SM_PTCH,d0     * is this the pitch source ?
    374                 bne     srctyp2         * jump if not
    375 *
    376                 move.w  (a1),d5         * get the pitch as the value
    377                 bra     applym          * go apply the multiplier
    378 *
    379 * ------------------------------------------------------------------------------
    380 * SM_KVEL -- velocity
    381 * ------------------------------------------------------------------------------
    382 srctyp2:        cmpi.w  #SM_KVEL,d0     * is this the key velocity source ?
    383                 bne     srctyp3         * jump if not
    384 *
    385                 move.w  FH_TRG(a1),d0   * get the trigger number
    386                 add.w   d0,d0           * ... as a word index
    387                 lea     _veltab,a0      * ... into veltab[]
    388                 move.w  0(a0,d0.W),d5   * get the velocity from veltab[trg]
    389                 bra     applym          * go apply the multiplier
    390 *
    391 * ------------------------------------------------------------------------------
    392 * SM_KPRS -- pressure
    393 * ------------------------------------------------------------------------------
    394 srctyp3:        cmpi.w  #SM_KPRS,d0     * is this the key pressure source ?
    395                 bne     srctyp4         * jump if not  (must be an analog input)
    396 *
    397                 move.w  FH_TRG(a1),d0   * get the trigger number
    398                 add.w   d0,d0           * ... as a word index
    399                 lea     _prstab,a0      * ... into prstab[]
    400                 move.w  0(a0,d0.W),d5   * get the pressure from prstab[trg]
    401                 bra     applym          * go apply the multiplier
    402 *
    403                 .page
    404 * ------------------------------------------------------------------------------
    405 * all other sources come out of the valents[] array
    406 * ------------------------------------------------------------------------------
    407 srctyp4:        lea     _vce2grp,a0     * point at vce2grp[]
    408                 move.w  _curpf_f,d5     * get voice number in d5
    409                 lsr.w   #3,d5           * ...
    410                 andi.w  #$001E,d5       * ... as a word index
    411                 move.w  0(a0,d5.W),d5   * get the group number
    412                 subq.w  #1,d5           * ...
    413                 lsl.w   #4,d5           * shift it left a nybble
    414                 or.w    d5,d0           * OR it into the source number
    415                 add.w   d0,d0           * make source number a valents[] index
    416                 move.w  d0,d5           * ... (fast multiply by VALLEN = 10
    417                 lsl.w   #2,d0           * ...  via shift and add)
    418                 add.w   d5,d0           * ...
    419                 lea     _valents,a0     * get base of valents[]
    420                 move.w  VT_VAL(a0,d0.W),d5      * get value
    421 *
    422 * ------------------------------------------------------------------------------
    423 * apply the multiplier to the source, and add it to the function value
    424 * ------------------------------------------------------------------------------
    425 applym:         muls    PT_VMLT(a2,d2.W),d5     * apply the multiplier
    426                 asr.l   #7,d5           * scale the result
    427                 asr.l   #8,d5           * ...
    428                 ext.l   d3              * add the function value
    429                 add.l   d3,d5           * ...
    430                 cmpi.l  #VALMAX,d5      * check for overflow
    431                 ble     srcmlt1         * jump if no overflow
    432 *
    433                 move.l  #VALMAX,d5      * limit at VALMAX
    434                 bra     srcmlt2         * ...
    435 *
    436 srcmlt1:        cmpi.l  #VALMIN,d5      * check for underflow
    437                 bge     srcmlt2         * jump if no underflow
    438 *
    439                 move.l  #VALMIN,d5      * limit at VALMIN
    440 *
    441 srcmlt2:        move.w  d5,d3           * setup value for output to FPU
    442 *
    443                 .page
    444 * ------------------------------------------------------------------------------
    445 * adjust the value according to the function type
    446 * ------------------------------------------------------------------------------
    447 nosrc:          move.w  d1,d0           * get function type
    448                 andi.w  #$01E0,d0       * ...
    449 *
    450 * ------------------------------------------------------------------------------
    451 * level or location
    452 * ------------------------------------------------------------------------------
    453                 cmpi.w  #P_LEVEL,d0     * see if it's the level
    454                 beq     outsegl         * jump if so
    455 *
    456                 cmpi.w  #P_LOCN,d0      * see if it's the location
    457                 bne     outsegf         * jump if not
    458 *
    459                 tst.w   d3              * check sign of value
    460                 bpl     outsegc         * jump if positive
    461 *
    462                 clr.w   d3              * force negative values to 0
    463 *
    464 outsegc:        asr.w   #5,d3           * shift value to LS bits
    465                 sub.w   #500,d3         * subtract 5.00 from value
    466                 asl.w   #6,d3           * readjust to MS bits
    467                 bra     outseg3         * go output the value
    468 *
    469 outsegl:        tst.w   d3              * check sign of value
    470                 bpl     outsegm         * jump if positive
    471 *
    472                 clr.w   d3              * limit negative values at 0
    473 *
    474 outsegm:        asr.w   #5,d3           * shift value to LS bits
    475                 sub.w   #500,d3         * subtract 5.00 from value
    476                 asl.w   #6,d3           * readjust to MS bits
    477                 bra     outseg3         * go output the value
    478 *
    479                 .page
    480 * ------------------------------------------------------------------------------
    481 * filter
    482 * ------------------------------------------------------------------------------
    483 outsegf:        cmpi.w  #P_FILTER,d0    * see if it's the filter
    484                 bne     outsegp         * jump if not
    485 *
    486                 ext.l   d3              * make function value a long
    487                 asr.l   #1,d3           * multiply function value by .75
    488                 move.l  d3,d0           * ...  (fast multiply by .75
    489                 asr.l   #1,d0           * ...   via shift and add)
    490                 add.l   d0,d3           * ...
    491                 move.w  (a1),d0         * add pitch
    492                 ext.l   d0              * ...
    493                 add.l   d0,d3           * ...
    494                 cmpi.l  #VALMAX,d3      * see if it's within limits
    495                 ble     outsega         * ...
    496 *
    497                 move.w  #VALMAX,d3      * limit at VALMAX
    498                 bra     outseg3         * ...
    499 *
    500 outsega:        cmpi.l  #VALMIN,d3      * ...
    501                 bge     outseg3         * ...
    502 *
    503                 move.w  #VALMIN,d3      * limit at VALMIN
    504                 bra     outseg3         * ...
    505 *
    506                 .page
    507 * ------------------------------------------------------------------------------
    508 * freq 1..4
    509 * ------------------------------------------------------------------------------
    510 outsegp:        cmpi.w  #P_FREQ1,d0     * see if it's freq1
    511                 beq     outseg0         * go process freq1
    512 *
    513 outsegq:        cmpi.w  #P_FREQ2,d0     * see if it's freq2
    514                 beq     outseg0         * process it if so
    515 *
    516                 cmpi.w  #P_FREQ3,d0     * see if it's freq3
    517                 beq     outseg0         * process it if so
    518 *
    519                 cmpi.w  #P_FREQ4,d0     * see if it's freq4
    520                 bne     outseg3         * jump if not
    521 *
    522 outseg0:        ext.l   d3              * scale the point value to cents offset
    523                 asr.l   #5,d3           * ...
    524                 sub.l   #500,d3         * ... value - 500
    525                 asl.l   #LSPCH,d3       * mult. by 2 and scale for 1/2 cent lsb
    526                 move.w  (a1),d0         * add pitch from function header
    527                 ext.l   d0              * ...
    528                 add.l   d0,d3           * ...
    529                 cmp.l   #PCHMAX,d3      * see if result is valid
    530                 ble     outseg3         * jump if within pitch limits
    531 *
    532                 move.l  #PCHMAX,d3      * limit at maximum pitch
    533 *
    534 * ------------------------------------------------------------------------------
    535 * send the value to the FPU
    536 * ------------------------------------------------------------------------------
    537 outseg3:        move.b  FH_TMD(a1),d0   * get hardware bits from function header
    538                 eor.w   #VAL_BITS,d0    * toggle new value select bits
    539                 move.b  d0,FH_TMD(a1)   * store updated word
    540                 btst.l  #VSUBNBIT,d0    * check which value address to use
     28
     29                .page
     30| ------------------------------------------------------------------------------
     31| Register usage
     32| --------------
     33|       d0      scratch
     34|       d1      FPU function index
     35|       d2      point index from FH_CPT  (idfcpt)
     36|       d3      scratch
     37|       d4      jump point number from PT_PAR1  (ippar1)
     38|       d5      scratch
     39
     40|       a0      scratch
     41|       a1      function header base
     42|       a2      point table base
     43|       a3      FPU base
     44
     45| ------------------------------------------------------------------------------
     46| FPU definitions
     47| ---------------
     48
     49UPD_BIT         =       0x0001                  | update bit  (1 = update)
     50INT_BIT         =       0x0002                  | int. bit    (0 = disable)
     51RAT_BIT         =       0x0004                  | ratio bit   (0 = ratio)
     52
     53VSUBNBIT        =       3                       | new value select bit number
     54VAL_BITS        =       0x0018                  | new value select bit mask
     55
     56MSK_RNVB        =       0x000C                  | new value / ratio bits
     57MSK_ONVB        =       0x0010                  | old new value bit
     58
     59FKILL           =       0x0014                  | kill value for function
     60FSEND           =       0x0015                  | send new value to function
     61
     62CLREXP          =       0x8000                  | clear value for time exponent
     63CLRMNT          =       0x8000                  | clear value for time mantissa
     64
     65| ------------------------------------------------------------------------------
     66| Miscellaneous definitions
     67| -------------------------
     68
     69PCHMAX          =       21920                   | maximum pitch value
     70VALMAX          =       32000                   | maximum value to send to FPU
     71VALMIN          =       -32000                  | minimum value to send to FPU
     72
     73LSPCH           =       2                       | left shift for sources to freq
     74
     75VALLEN          =       10                      | length of the 'valent' struct
     76VT_VAL          =       8                       | value offset in 'valent'
     77
     78                .page
     79| ------------------------------------------------------------------------------
     80| FPU addresses
     81| -------------
     82
     83FPUBASE         =       0x180000                | FPU base address
     84
     85FPUWST          =       FPUBASE                 | FPU waveshape base
     86FPUFUNC         =       FPUBASE+0x4000          | FPU function base
     87FPUINT1         =       FPUBASE+0x4000          | FPU int. input address (R/O)
     88FPUINT2         =       FPUBASE+0x6000          | FPU int. reset address (W/O)
     89FPUCFG          =       FPUBASE+0x5FE0          | FPU config. data address (W/O)
     90
     91F_CTL           =       0x00                    | control word
     92F_VAL10         =       0x02                    | new value "10"
     93F_CV1           =       0x08                    | control voltage 1
     94F_SF1           =       0x0A                    | scale factor 1
     95F_CV2           =       0x0C                    | control voltage 2
     96F_SF2           =       0x0E                    | scale factor 2
     97F_CV3           =       0x10                    | control voltage 3
     98F_SF3           =       0x12                    | scale factor 3
     99F_MNT           =       0x14                    | time mantissa
     100F_EXP           =       0x16                    | time exponent
     101F_VAL01         =       0x1C                    | new value "01"
     102
     103P_FREQ1         =       0x0020                  | frequency 1
     104P_FREQ2         =       0x0060                  | frequency 2
     105P_FREQ3         =       0x00A0                  | frequency 3
     106P_FREQ4         =       0x00E0                  | frequency 4
     107P_FILTER        =       0x0140                  | filter
     108P_FILTRQ        =       0x00C0                  | filter q
     109
     110P_INDEX1        =       0x0120                  | index 1
     111P_INDEX2        =       0x0160                  | index 2
     112P_INDEX3        =       0x0180                  | index 3
     113P_INDEX4        =       0x01A0                  | index 4
     114P_INDEX5        =       0x01C0                  | index 5
     115P_INDEX6        =       0x01E0                  | index 6
     116
     117P_LEVEL         =       0x0040                  | level
     118
     119P_LOCN          =       0x0080                  | location
     120P_DYNAM         =       0x0100                  | dynamics
     121
     122                .page
     123| ------------------------------------------------------------------------------
     124| Structure definitions
     125| ------------------------------------------------------------------------------
     126| The following MUST match the idfnhdr structure definition in instdsp.h:
     127
     128FH_LEN          =       12              | length of the idfnhdr structure
     129
     130FH_PCH          =       0               | WORD - pitch offset
     131FH_MLT          =       2               | WORD - overall value multiplier
     132FH_SRC          =       4               | BYTE - overall value source
     133FH_PIF          =       5               | BYTE - # of points in the function
     134FH_PT1          =       6               | BYTE - index of first point
     135FH_TMD          =       7               | BYTE - trigger mode / control bits
     136FH_CPT          =       8               | BYTE - current point
     137FH_PRM          =       9               | BYTE - misc. function parameter
     138FH_TRG          =       10              | WORD - trigger
     139
     140I_ACTIVE        =       1               | 'Active' bit number        (in FH_TMD)
     141
     142MSK_CTL         =       0x001C          | mask for FPU hardware bits (in FH_TMD)
     143
     144| ------------------------------------------------------------------------------
     145| The following MUST match the instpnt structure definition in instdsp.h:
     146
     147PT_LEN          =       12              | length of the instpnt structure
     148
     149PT_TIM          =       0               | WORD - time (packed)
     150PT_VAL          =       2               | WORD - value
     151PT_VMLT         =       4               | WORD - value multiplier
     152PT_VSRC         =       6               | BYTE - value source
     153PT_ACT          =       7               | BYTE - action
     154PT_PAR1         =       8               | BYTE - parameter 1
     155PT_PAR2         =       9               | BYTE - parameter 2
     156PT_PAR3         =       10              | BYTE - parameter 3
     157PT_PAD          =       11              | BYTE - padding for even boundary
     158
     159MSK_MNT         =       0xFFF0          | mask for mantissa  (in PT_TIM)
     160MSK_EXP         =       0x000F          | mask for exponent  (in PT_TIM)
     161
     162MAX_ACT         =       7               | maximum action code value
     163
     164| ------------------------------------------------------------------------------
     165| Source definitions -- must match those in 'smdefs.h'
     166
     167SM_RAND         =       1               | random
     168SM_PTCH         =       5               | pitch
     169SM_KPRS         =       6               | key pressure
     170SM_KVEL         =       7               | key velocity
     171SM_FREQ         =       10              | frequency
     172
     173                .page
     174
     175| Layout of pflist entries      32 bytes each
     176| ------------------------
     177PF_NEXT         =       0               | LONG - next entry pointer
     178PF_TRIG         =       4               | WORD - trigger number
     179PF_FUNC         =       6               | WORD - fpuifnc value
     180PF_D1           =       8               | LONG - d1
     181PF_D2           =       12              | LONG - d2
     182PF_D4           =       16              | LONG - d4
     183PF_A1           =       20              | LONG - a1
     184PF_A2           =       24              | LONG - a2
     185PF_A3           =       28              | LONG - a3
     186
     187| Parameter offset
     188| ----------------
     189TRIG            =       8               | WORD - trigger number
     190
     191| Register equates
     192| ----------------
     193RCUR            =       a4              | current pflist entry pointer
     194RPRV            =       a5              | previous pflist entry pointer
     195
     196                .page
     197| ------------------------------------------------------------------------------
     198| _procpfl() -- process pendant functions
     199
     200|       void
     201|       procpfl(trig);
     202|       unsigned trig;
     203
     204|               Processes pendant (sustained) functions by restarting them
     205|       when the trigger (trig) that's sustaining them is released.
     206|       Invoked by key release processing in msm() and localkb().
     207
     208| ------------------------------------------------------------------------------
     209
     210_procpfl:       nop                             | FOR DEBUGGING PATCH
     211
     212                link    a6,#0                   | allocate stack frame
     213                movem.l d3-d7/a3-a5,-(a7)       | preserve registers we use
     214
     215                move.w  sr,d7                   | save interrupt state
     216                move.w  #0x2200,sr              | turn off FPU interrupts
     217
     218                move.w  TRIG(a6),d6             | get trigger we're processing
     219                move.w  d6,_curpf_t             | ...
     220                movea.l #_pflist,RPRV           | point at 'previous' pflist entry
     221                bra     pfscan                  | go scan the chain
     222
     223pfpass:         movea.l RCUR,RPRV               | point at previous entry
     224
     225pfscan:         move.l  (RPRV),d5               | get next pflist entry pointer
     226                beq     pfexit                  | done if no more
     227
     228                movea.l d5,RCUR                 | point at  current entry
     229                move.l  d5,_curpf_l             | ...
     230
     231                cmp.w   PF_TRIG(RCUR),d6        | see if this entry is wanted
     232                bne     pfpass                  | jump if not
     233
     234                movem.l PF_D1(RCUR),d1-d2/d4/a1-a3      | restore processing state
     235                move.w  PF_FUNC(RCUR),_curpf_f          | ...
     236
     237                btst    #I_ACTIVE,FH_TMD(a1)    | see if function is active
     238                bne     doact                   | continue function if so
     239
     240                bra     stopfn                  | stop function if not
     241
     242pfnext:         move.l  (RCUR),(RPRV)           | remove entry from pflist
     243                move.l  _pfqhdr,(RCUR)          | chain entry to free list
     244                move.l  RCUR,_pfqhdr            | ...
     245                bra     pfscan                  | go look at next entry
     246
     247pfexit:         move.w  d7,sr                   | restore interrupt level
     248                movem.l (a7)+,d3-d7/a3-a5       | restore the registers we used
     249                unlk    a6                      | deallocate stack frame
     250                rts                             | return to caller
     251
     252                .page
     253
     254| ------------------------------------------------------------------------------
     255| stop a function
     256| ------------------------------------------------------------------------------
     257stopfn:         move.b  FH_TMD(a1),d0   | get function control bits
     258                andi.w  #MSK_RNVB,d0    | mask for ratio / new new-value bit
     259                move.w  d0,d3           | isolate new new-value bit
     260                add.w   d3,d3           | ... from function header
     261                andi.w  #MSK_ONVB,d3    | ... shift to old new-value bit
     262                or.w    d3,d0           | ... and put new bit in old bit
     263                move.w  d0,F_CTL(a3,d1.W)       | stop the function
     264                bclr    #I_ACTIVE,FH_TMD(a1)    | reset the active bit
     265                bra     pfnext          | go restore registers and exit
     266
     267| ------------------------------------------------------------------------------
     268| setup for and dispatch to the proper action handler
     269| ------------------------------------------------------------------------------
     270doact:          clr.w   d2              | get current point index in d2
     271                move.b  FH_CPT(a1),d2   | ...
     272                lsl.w   #2,d2           | multiply it by the length of a point
     273                move.w  d2,d0           | ...  (fast multiply by PT_LEN = 12
     274                add.w   d2,d2           | ...   via shift and add)
     275                add.w   d0,d2           | ...
     276                clr.w   d4              | get jump point # into d4
     277                move.b  PT_PAR1(a2,d2.W),d4     | ...
     278                clr.w   d3              | get action code in d3
     279                move.b  PT_ACT(a2,d2.W),d3      | ...
     280                cmpi.b  #MAX_ACT,d3     | check against the limit
     281                bgt     stopfn          | stop things if it's a bad action code
     282
     283                lsl.w   #2,d3           | develop index to action dispatch table
     284                lea     actab,a0        | get the address of the action handler
     285                movea.l 0(a0,d3.W),a0   | ...
     286
     287| ------------------------------------------------------------------------------
     288| At this point we're ready to do the action associated with the point,
     289| and the registers are set up,  and will remain,  as follows:
     290
     291|       d1      FPU function index      a1      function header base
     292|       d2      point table index       a2      point table base
     293|                                       a3      FPU function base
     294|       d4      jump point number
     295
     296|       d0, d3, d5, and a0 are used as scratch throughout the code.
     297
     298| ------------------------------------------------------------------------------
     299
     300                jmp     (a0)            | dispatch to action handler
     301
     302                .page
     303| ------------------------------------------------------------------------------
     304| act0 -- AC_NULL -- no action
     305| ----    --------------------
     306act0:           move.b  FH_PT1(a1),d0   | get first point number
     307                add.b   FH_PIF(a1),d0   | add number of points in function
     308                subq.b  #1,d0           | make it last point number
     309                cmp.b   FH_CPT(a1),d0   | see if we're at the last point
     310                beq     stopfn          | stop function if so
     311
     312                addq.b  #1,FH_CPT(a1)   | update function header for next point
     313                addi.w  #PT_LEN,d2      | advance the point index
     314
     315| ------------------------------------------------------------------------------
     316| outseg -- output a segment
     317| ------    ----------------
     318outseg:         move.w  PT_TIM(a2,d2.w),d3      | get packed time
     319                move.w  d3,d0                   | extract mantissa
     320                andi.w  #MSK_MNT,d0             | ...
     321                mulu    _timemlt,d0             | multiply by panel time pot value
     322                lsr.l   #8,d0                   | ... and scale it
     323                lsr.l   #7,d0                   | ...
     324                move.w  d0,F_MNT(a3,d1.W)       | send mantissa to FPU
     325                andi.w  #MSK_EXP,d3             | extract exponent code
     326                add.w   d3,d3                   | look up decoded exponent
     327                lea     _expbit,a0              | ... in expbit
     328                move.w  0(a0,d3.W),F_EXP(a3,d1.W)       | send exponent to FPU
     329                move.w  PT_VAL(a2,d2.W),d3      | get the function value
     330
     331                .page
     332| ------------------------------------------------------------------------------
     333| get the point source, if any
     334| ------------------------------------------------------------------------------
     335                tst.w   PT_VMLT(a2,d2.W)        | see if we have a point mlt.
     336                beq     nosrc                   | don't do anything for zero
     337
     338                clr.w   d0                      | get the source number
     339                move.b  PT_VSRC(a2,d2.W),d0     | ...
     340                beq     nosrc                   | don't do anything for zero
     341
     342| ------------------------------------------------------------------------------
     343| SM_RAND -- random
     344| ------------------------------------------------------------------------------
     345                cmpi.w  #SM_RAND,d0             | is this the random source ?
     346                bne     srctyp0                 | jump if not
     347
     348                movem.l d1-d2/a0-a2,-(a7)       | preserve registers around call
     349                move.w  PT_VMLT(a2,d2.W),-(a7)  | pass multiplier to xgetran()
     350                jsr     _xgetran                | call for a random number
     351                tst.w   (a7)+                   | clean up stack
     352                movem.l (a7)+,d1-d2/a0-a2       | restore registers
     353                move.w  d0,d5                   | put random value in the value register
     354                bra     applym                  | go apply the multiplier
     355
     356                .page
     357| ------------------------------------------------------------------------------
     358| SM_FREQ -- frequency
     359| ------------------------------------------------------------------------------
     360srctyp0:        cmpi.w  #SM_FREQ,d0     | is this the frequency source ?
     361                bne     srctyp1         | jump if not
     362
     363                move.w  (a1),d0         | get the pitch
     364                lsr.w   #6,d0           | shift to a word index
     365                andi.w  #0x01FE,d0      | mask out extraneous bits
     366                lea     _ptoftab,a0     | get entry from ptoftab[]
     367                move.w  0(a0,d0.W),d5   | ...
     368                bra     applym          | go apply the multiplier
     369
     370| ------------------------------------------------------------------------------
     371| SM_PTCH -- pitch
     372| ------------------------------------------------------------------------------
     373srctyp1:        cmpi.w  #SM_PTCH,d0     | is this the pitch source ?
     374                bne     srctyp2         | jump if not
     375
     376                move.w  (a1),d5         | get the pitch as the value
     377                bra     applym          | go apply the multiplier
     378
     379| ------------------------------------------------------------------------------
     380| SM_KVEL -- velocity
     381| ------------------------------------------------------------------------------
     382srctyp2:        cmpi.w  #SM_KVEL,d0     | is this the key velocity source ?
     383                bne     srctyp3         | jump if not
     384
     385                move.w  FH_TRG(a1),d0   | get the trigger number
     386                add.w   d0,d0           | ... as a word index
     387                lea     _veltab,a0      | ... into veltab[]
     388                move.w  0(a0,d0.W),d5   | get the velocity from veltab[trg]
     389                bra     applym          | go apply the multiplier
     390
     391| ------------------------------------------------------------------------------
     392| SM_KPRS -- pressure
     393| ------------------------------------------------------------------------------
     394srctyp3:        cmpi.w  #SM_KPRS,d0     | is this the key pressure source ?
     395                bne     srctyp4         | jump if not  (must be an analog input)
     396
     397                move.w  FH_TRG(a1),d0   | get the trigger number
     398                add.w   d0,d0           | ... as a word index
     399                lea     _prstab,a0      | ... into prstab[]
     400                move.w  0(a0,d0.W),d5   | get the pressure from prstab[trg]
     401                bra     applym          | go apply the multiplier
     402
     403                .page
     404| ------------------------------------------------------------------------------
     405| all other sources come out of the valents[] array
     406| ------------------------------------------------------------------------------
     407srctyp4:        lea     _vce2grp,a0     | point at vce2grp[]
     408                move.w  _curpf_f,d5     | get voice number in d5
     409                lsr.w   #3,d5           | ...
     410                andi.w  #0x001E,d5      | ... as a word index
     411                move.w  0(a0,d5.W),d5   | get the group number
     412                subq.w  #1,d5           | ...
     413                lsl.w   #4,d5           | shift it left a nybble
     414                or.w    d5,d0           | OR it into the source number
     415                add.w   d0,d0           | make source number a valents[] index
     416                move.w  d0,d5           | ... (fast multiply by VALLEN = 10
     417                lsl.w   #2,d0           | ...  via shift and add)
     418                add.w   d5,d0           | ...
     419                lea     _valents,a0     | get base of valents[]
     420                move.w  VT_VAL(a0,d0.W),d5      | get value
     421
     422| ------------------------------------------------------------------------------
     423| apply the multiplier to the source, and add it to the function value
     424| ------------------------------------------------------------------------------
     425applym:         muls    PT_VMLT(a2,d2.W),d5     | apply the multiplier
     426                asr.l   #7,d5           | scale the result
     427                asr.l   #8,d5           | ...
     428                ext.l   d3              | add the function value
     429                add.l   d3,d5           | ...
     430                cmpi.l  #VALMAX,d5      | check for overflow
     431                ble     srcmlt1         | jump if no overflow
     432
     433                move.l  #VALMAX,d5      | limit at VALMAX
     434                bra     srcmlt2         | ...
     435
     436srcmlt1:        cmpi.l  #VALMIN,d5      | check for underflow
     437                bge     srcmlt2         | jump if no underflow
     438
     439                move.l  #VALMIN,d5      | limit at VALMIN
     440
     441srcmlt2:        move.w  d5,d3           | setup value for output to FPU
     442
     443                .page
     444| ------------------------------------------------------------------------------
     445| adjust the value according to the function type
     446| ------------------------------------------------------------------------------
     447nosrc:          move.w  d1,d0           | get function type
     448                andi.w  #0x01E0,d0      | ...
     449
     450| ------------------------------------------------------------------------------
     451| level or location
     452| ------------------------------------------------------------------------------
     453                cmpi.w  #P_LEVEL,d0     | see if it's the level
     454                beq     outsegl         | jump if so
     455
     456                cmpi.w  #P_LOCN,d0      | see if it's the location
     457                bne     outsegf         | jump if not
     458
     459                tst.w   d3              | check sign of value
     460                bpl     outsegc         | jump if positive
     461
     462                clr.w   d3              | force negative values to 0
     463
     464outsegc:        asr.w   #5,d3           | shift value to LS bits
     465                sub.w   #500,d3         | subtract 5.00 from value
     466                asl.w   #6,d3           | readjust to MS bits
     467                bra     outseg3         | go output the value
     468
     469outsegl:        tst.w   d3              | check sign of value
     470                bpl     outsegm         | jump if positive
     471
     472                clr.w   d3              | limit negative values at 0
     473
     474outsegm:        asr.w   #5,d3           | shift value to LS bits
     475                sub.w   #500,d3         | subtract 5.00 from value
     476                asl.w   #6,d3           | readjust to MS bits
     477                bra     outseg3         | go output the value
     478
     479                .page
     480| ------------------------------------------------------------------------------
     481| filter
     482| ------------------------------------------------------------------------------
     483outsegf:        cmpi.w  #P_FILTER,d0    | see if it's the filter
     484                bne     outsegp         | jump if not
     485
     486                ext.l   d3              | make function value a long
     487                asr.l   #1,d3           | multiply function value by .75
     488                move.l  d3,d0           | ...  (fast multiply by .75
     489                asr.l   #1,d0           | ...   via shift and add)
     490                add.l   d0,d3           | ...
     491                move.w  (a1),d0         | add pitch
     492                ext.l   d0              | ...
     493                add.l   d0,d3           | ...
     494                cmpi.l  #VALMAX,d3      | see if it's within limits
     495                ble     outsega         | ...
     496
     497                move.w  #VALMAX,d3      | limit at VALMAX
     498                bra     outseg3         | ...
     499
     500outsega:        cmpi.l  #VALMIN,d3      | ...
     501                bge     outseg3         | ...
     502
     503                move.w  #VALMIN,d3      | limit at VALMIN
     504                bra     outseg3         | ...
     505
     506                .page
     507| ------------------------------------------------------------------------------
     508| freq 1..4
     509| ------------------------------------------------------------------------------
     510outsegp:        cmpi.w  #P_FREQ1,d0     | see if it's freq1
     511                beq     outseg0         | go process freq1
     512
     513outsegq:        cmpi.w  #P_FREQ2,d0     | see if it's freq2
     514                beq     outseg0         | process it if so
     515
     516                cmpi.w  #P_FREQ3,d0     | see if it's freq3
     517                beq     outseg0         | process it if so
     518
     519                cmpi.w  #P_FREQ4,d0     | see if it's freq4
     520                bne     outseg3         | jump if not
     521
     522outseg0:        ext.l   d3              | scale the point value to cents offset
     523                asr.l   #5,d3           | ...
     524                sub.l   #500,d3         | ... value - 500
     525                asl.l   #LSPCH,d3       | mult. by 2 and scale for 1/2 cent lsb
     526                move.w  (a1),d0         | add pitch from function header
     527                ext.l   d0              | ...
     528                add.l   d0,d3           | ...
     529                cmp.l   #PCHMAX,d3      | see if result is valid
     530                ble     outseg3         | jump if within pitch limits
     531
     532                move.l  #PCHMAX,d3      | limit at maximum pitch
     533
     534| ------------------------------------------------------------------------------
     535| send the value to the FPU
     536| ------------------------------------------------------------------------------
     537outseg3:        move.b  FH_TMD(a1),d0   | get hardware bits from function header
     538                eor.w   #VAL_BITS,d0    | toggle new value select bits
     539                move.b  d0,FH_TMD(a1)   | store updated word
     540                btst.l  #VSUBNBIT,d0    | check which value address to use
    541541                beq     outseg1
    542 *
    543                 move.w  d3,F_VAL01(a3,d1.W)     * send value to FPU
     542
     543                move.w  d3,F_VAL01(a3,d1.W)     | send value to FPU
    544544                bra     outseg2
    545 *
    546 outseg1:        move.w  d3,F_VAL10(a3,d1.W)     * send value to FPU
    547 *
    548 outseg2:        andi.w  #MSK_CTL,d0             * mask off software bits
    549                 ori.w   #UPD_BIT+INT_BIT,d0     * set the update & !lastseg bits
    550                 move.w  d0,F_CTL(a3,d1.W)       * send control word to FPU
    551                 bra     pfnext                  * done -- exit
    552 *
    553                 .page
    554 *
    555 * ------------------------------------------------------------------------------
    556 * act2 -- AC_ENBL -- stop if key is up
    557 * ----    ----------------------------
    558 act2:           move.w  _curpf_f,d0     * get voice as a word index
    559                 lsr.w   #3,d0           * ...
    560                 andi.w  #$001E,d0       * ...
    561                 lea     _vce2trg,a0     * check to see if voice is free
    562                 move.w  0(a0,d0.W),d0   * ...
    563                 cmpi.w  #-1,d0          * ...
    564                 beq     stopfn          * if so, stop the function
    565 *
    566                 btst    #15,d0          * see if voice is held
    567                 bne     act0            * continue if so
    568 *
    569                 btst    #14,d0          * ...
    570                 bne     act0            * ...
    571 *
    572                 lea     _trgtab,a0      * check trigger table entry
    573                 tst.b   0(a0,d0.W)      * ...
    574                 bne     act0            * if trigger is active, continue
    575 *
    576                 bra     stopfn          * if not, stop the function
    577 *
    578 * ------------------------------------------------------------------------------
    579 * act3 -- AC_JUMP -- unconditional jump
    580 * ----    -----------------------------
    581 act3:           cmp.b   FH_PIF(a1),d4   * check jump point against limit
    582                 bcc     stopfn          * stop function if jump point invalid
    583 *
    584                 clr.w   d2              * get index of first point
    585                 move.b  FH_PT1(a1),d2   * ...
    586                 add.b   d4,d2           * add jump point
    587                 move.b  d2,FH_CPT(a1)   * make it the current point
    588                 lsl.w   #2,d2           * develop new point index in d2
    589                 move.w  d2,d0           * ... (fast multiply by PT_LEN = 12
    590                 add.w   d2,d2           * ...  via shift and add)
    591                 add.w   d0,d2           * ...
    592                 bra     outseg          * output the segment
    593 *
    594                 .page
    595 *
    596 * ------------------------------------------------------------------------------
    597 * act4 -- AC_LOOP -- jump to point PT_PAR1 PT_PAR2 times
    598 * ----    ----------------------------------------------
    599 act4:           tst.b   PT_PAR3(a2,d2.W)        * check counter
    600                 bne     act4a                   * jump if it's running
    601 *
    602                 move.b  PT_PAR2(a2,d2.W),d0     * get parameter
    603                 subi.w  #90,d0                  * put parameter in random range
    604                 bmi     act4b                   * treat as normal if < 90
    605 *
    606                 movem.l d1-d2/a0-a2,-(a7)       * get ranged random number
    607                 move.w  d0,-(a7)                * ...
    608                 jsr     _irand                  * ...
    609                 tst.w   (a7)+                   * ...
    610                 movem.l (a7)+,d1-d2/a0-a2       * ...
    611                 move.b  d0,PT_PAR3(a2,d2.w)     * set counter
    612                 beq     act0                    * next segment if cntr set to 0
    613 *
    614                 bra     act3                    * else jump to the point
    615 *
    616 act4b:          move.b  PT_PAR2(a2,d2.W),PT_PAR3(a2,d2.W)       * set counter
    617                 beq     act0                    * next segment if cntr set to 0
    618 *
    619                 bra     act3                    * else jump to the point
    620 *
    621 act4a:          subq.b  #1,PT_PAR3(a2,d2.W)     * decrement counter
    622                 beq     act0                    * next segment if cntr ran out
    623 *
    624                 bra     act3                    * jump if it's still non-zero
    625 *
    626 * ------------------------------------------------------------------------------
    627 * act5 -- AC_KYUP -- jump if key is up
    628 * ----    ----------------------------
    629 act5:           move.w  _curpf_f,d0     * get voice as a word index
    630                 lsr.w   #3,d0           * ...
    631                 andi.w  #$001E,d0       * ...
    632                 lea     _vce2trg,a0     * check to see if voice is free
    633                 move.w  0(a0,d0.W),d0   * ...
    634                 cmpi.w  #-1,d0          * ...
    635                 beq     act3            * if so (inactive), do the jump
    636 *
    637                 btst    #15,d0          * see if voice is held
    638                 bne     act0            * continue if so
    639 *
    640                 btst    #14,d0          * ...
    641                 bne     act0            * ...
    642 *
    643                 lea     _trgtab,a0      * check trigger table entry
    644                 tst.b   0(a0,d0.W)      * see if the trigger is active
    645                 beq     act3            * if not, do the jump
    646 *
    647                 bra     act0            * if so, do next segment
    648 *
    649                 .page
    650 *
    651 * ------------------------------------------------------------------------------
    652 * act6 -- AC_KYDN -- jump if key is down
    653 * ----    ------------------------------
    654 act6:           move.w  _curpf_f,d0     * get voice as a word index
    655                 lsr.w   #3,d0           * ...
    656                 andi.w  #$001E,d0       * ...
    657                 lea     _vce2trg,a0     * check to see if voice is free
    658                 move.w  0(a0,d0.W),d0   * ...
    659                 cmpi.w  #-1,d0          * ...
    660                 beq     act0            * if so (inactive), continue
    661 *
    662                 btst    #15,d0          * see if voice is held
    663                 bne     act3            * do jump if so
    664 *
    665                 btst    #14,d0          * ...
    666                 bne     act3            * ...
    667 *
    668                 lea     _trgtab,a0      * check trigger table entry
    669                 tst.b   0(a0,d0.W)      * see if the trigger is active
    670                 bne     act3            * if so, do the jump
    671 *
    672                 bra     act0            * if not, do next segment
    673 *
    674 * ------------------------------------------------------------------------------
    675 act7:           bra     act0            * AC_HERE: treat act7 as AC_NULL
    676 *
    677                 .page
    678 *
    679 * act1 -- AC_SUST -- pause if key is down (sustain)
    680 * ----    -----------------------------------------
    681 act1:           move.w  _curpf_f,d0     * get voice as a word index
    682                 lsr.w   #3,d0           * ...
    683                 andi.w  #$001E,d0       * ...
    684                 lea     _vce2trg,a0     * point at voice to trigger table
    685                 move.w  0(a0,d0.W),d0   * get trigger table entry
    686                 cmpi.w  #-1,d0          * see if voice is free
    687                 beq     act0            * treat as no-op if so
    688 *
    689                 btst    #15,d0          * see if voice is held by a pedal
    690                 bne     act1a           * sustain if so
    691 *
    692                 btst    #14,d0          * see if voice is sustained by a pedal
    693                 bne     act1a           * sustain if so
    694 *
    695                 lea     _trgtab,a0      * point at trigger table
    696                 tst.b   0(a0,d0.W)      * check trigger status
    697                 beq     act0            * continue if not active
    698 *
    699 act1a:          move.l  _pfqhdr,d3      * see if any pflist entries remain
    700                 beq     act0            * no-op if not  (shouldn't happen ...)
    701 *
    702                 move.b  FH_PT1(a1),d0   * get first point number
    703                 add.b   FH_PIF(a1),d0   * add base to first point
    704                 subq.b  #1,d0           * make d0 last point number
    705                 cmp.b   FH_CPT(a1),d0   * check current point number
    706                 beq     stopfn          * done if this is the last point
    707 *
    708                 addq.b  #1,FH_CPT(a1)           * update current point number
    709                 addi.w  #PT_LEN,d2              * update point index
    710                 movea.l d3,a0                   * acquire a new pflist entry
    711                 move.l  (a0),_pfqhdr            * ...
    712                 move.l  _pflist,(a0)            * ...
    713                 move.l  a0,_pflist              * ...
    714                 move.w  FH_TRG(a1),PF_TRIG(a0)  * set trigger number in entry
    715                 move.w  _curpf_f,PF_FUNC(a0)    * set v/p word in entry
    716                 movem.l d1-d2/d4/a1-a3,PF_D1(a0)        * set registers in entry
    717                 move.b  FH_TMD(a1),d0           * stop the function
    718                 andi.w  #MSK_RNVB,d0            * ...
    719                 move.w  d0,d3                   * ...
    720                 add.w   d3,d3                   * ...
    721                 andi.w  #MSK_ONVB,d3            * ...
    722                 or.w    d3,d0                   * ...
    723                 move.w  d0,F_CTL(a3,d1.W)       * ...
    724                 bra     pfnext                  * go do next list entry
    725 *
    726                 .page
    727 * ------------------------------------------------------------------------------
     545
     546outseg1:        move.w  d3,F_VAL10(a3,d1.W)     | send value to FPU
     547
     548outseg2:        andi.w  #MSK_CTL,d0             | mask off software bits
     549                ori.w   #UPD_BIT+INT_BIT,d0     | set the update & !lastseg bits
     550                move.w  d0,F_CTL(a3,d1.W)       | send control word to FPU
     551                bra     pfnext                  | done -- exit
     552
     553                .page
     554
     555| ------------------------------------------------------------------------------
     556| act2 -- AC_ENBL -- stop if key is up
     557| ----    ----------------------------
     558act2:           move.w  _curpf_f,d0     | get voice as a word index
     559                lsr.w   #3,d0           | ...
     560                andi.w  #0x001E,d0      | ...
     561                lea     _vce2trg,a0     | check to see if voice is free
     562                move.w  0(a0,d0.W),d0   | ...
     563                cmpi.w  #-1,d0          | ...
     564                beq     stopfn          | if so, stop the function
     565
     566                btst    #15,d0          | see if voice is held
     567                bne     act0            | continue if so
     568
     569                btst    #14,d0          | ...
     570                bne     act0            | ...
     571
     572                lea     _trgtab,a0      | check trigger table entry
     573                tst.b   0(a0,d0.W)      | ...
     574                bne     act0            | if trigger is active, continue
     575
     576                bra     stopfn          | if not, stop the function
     577
     578| ------------------------------------------------------------------------------
     579| act3 -- AC_JUMP -- unconditional jump
     580| ----    -----------------------------
     581act3:           cmp.b   FH_PIF(a1),d4   | check jump point against limit
     582                bcc     stopfn          | stop function if jump point invalid
     583
     584                clr.w   d2              | get index of first point
     585                move.b  FH_PT1(a1),d2   | ...
     586                add.b   d4,d2           | add jump point
     587                move.b  d2,FH_CPT(a1)   | make it the current point
     588                lsl.w   #2,d2           | develop new point index in d2
     589                move.w  d2,d0           | ... (fast multiply by PT_LEN = 12
     590                add.w   d2,d2           | ...  via shift and add)
     591                add.w   d0,d2           | ...
     592                bra     outseg          | output the segment
     593
     594                .page
     595
     596| ------------------------------------------------------------------------------
     597| act4 -- AC_LOOP -- jump to point PT_PAR1 PT_PAR2 times
     598| ----    ----------------------------------------------
     599act4:           tst.b   PT_PAR3(a2,d2.W)        | check counter
     600                bne     act4a                   | jump if it's running
     601
     602                move.b  PT_PAR2(a2,d2.W),d0     | get parameter
     603                subi.w  #90,d0                  | put parameter in random range
     604                bmi     act4b                   | treat as normal if < 90
     605
     606                movem.l d1-d2/a0-a2,-(a7)       | get ranged random number
     607                move.w  d0,-(a7)                | ...
     608                jsr     _irand                  | ...
     609                tst.w   (a7)+                   | ...
     610                movem.l (a7)+,d1-d2/a0-a2       | ...
     611                move.b  d0,PT_PAR3(a2,d2.w)     | set counter
     612                beq     act0                    | next segment if cntr set to 0
     613
     614                bra     act3                    | else jump to the point
     615
     616act4b:          move.b  PT_PAR2(a2,d2.W),PT_PAR3(a2,d2.W)       | set counter
     617                beq     act0                    | next segment if cntr set to 0
     618
     619                bra     act3                    | else jump to the point
     620
     621act4a:          subq.b  #1,PT_PAR3(a2,d2.W)     | decrement counter
     622                beq     act0                    | next segment if cntr ran out
     623
     624                bra     act3                    | jump if it's still non-zero
     625
     626| ------------------------------------------------------------------------------
     627| act5 -- AC_KYUP -- jump if key is up
     628| ----    ----------------------------
     629act5:           move.w  _curpf_f,d0     | get voice as a word index
     630                lsr.w   #3,d0           | ...
     631                andi.w  #0x001E,d0      | ...
     632                lea     _vce2trg,a0     | check to see if voice is free
     633                move.w  0(a0,d0.W),d0   | ...
     634                cmpi.w  #-1,d0          | ...
     635                beq     act3            | if so (inactive), do the jump
     636
     637                btst    #15,d0          | see if voice is held
     638                bne     act0            | continue if so
     639
     640                btst    #14,d0          | ...
     641                bne     act0            | ...
     642
     643                lea     _trgtab,a0      | check trigger table entry
     644                tst.b   0(a0,d0.W)      | see if the trigger is active
     645                beq     act3            | if not, do the jump
     646
     647                bra     act0            | if so, do next segment
     648
     649                .page
     650
     651| ------------------------------------------------------------------------------
     652| act6 -- AC_KYDN -- jump if key is down
     653| ----    ------------------------------
     654act6:           move.w  _curpf_f,d0     | get voice as a word index
     655                lsr.w   #3,d0           | ...
     656                andi.w  #0x001E,d0      | ...
     657                lea     _vce2trg,a0     | check to see if voice is free
     658                move.w  0(a0,d0.W),d0   | ...
     659                cmpi.w  #-1,d0          | ...
     660                beq     act0            | if so (inactive), continue
     661
     662                btst    #15,d0          | see if voice is held
     663                bne     act3            | do jump if so
     664
     665                btst    #14,d0          | ...
     666                bne     act3            | ...
     667
     668                lea     _trgtab,a0      | check trigger table entry
     669                tst.b   0(a0,d0.W)      | see if the trigger is active
     670                bne     act3            | if so, do the jump
     671
     672                bra     act0            | if not, do next segment
     673
     674| ------------------------------------------------------------------------------
     675act7:           bra     act0            | AC_HERE: treat act7 as AC_NULL
     676
     677                .page
     678
     679| act1 -- AC_SUST -- pause if key is down (sustain)
     680| ----    -----------------------------------------
     681act1:           move.w  _curpf_f,d0     | get voice as a word index
     682                lsr.w   #3,d0           | ...
     683                andi.w  #0x001E,d0      | ...
     684                lea     _vce2trg,a0     | point at voice to trigger table
     685                move.w  0(a0,d0.W),d0   | get trigger table entry
     686                cmpi.w  #-1,d0          | see if voice is free
     687                beq     act0            | treat as no-op if so
     688
     689                btst    #15,d0          | see if voice is held by a pedal
     690                bne     act1a           | sustain if so
     691
     692                btst    #14,d0          | see if voice is sustained by a pedal
     693                bne     act1a           | sustain if so
     694
     695                lea     _trgtab,a0      | point at trigger table
     696                tst.b   0(a0,d0.W)      | check trigger status
     697                beq     act0            | continue if not active
     698
     699act1a:          move.l  _pfqhdr,d3      | see if any pflist entries remain
     700                beq     act0            | no-op if not  (shouldn't happen ...)
     701
     702                move.b  FH_PT1(a1),d0   | get first point number
     703                add.b   FH_PIF(a1),d0   | add base to first point
     704                subq.b  #1,d0           | make d0 last point number
     705                cmp.b   FH_CPT(a1),d0   | check current point number
     706                beq     stopfn          | done if this is the last point
     707
     708                addq.b  #1,FH_CPT(a1)           | update current point number
     709                addi.w  #PT_LEN,d2              | update point index
     710                movea.l d3,a0                   | acquire a new pflist entry
     711                move.l  (a0),_pfqhdr            | ...
     712                move.l  _pflist,(a0)            | ...
     713                move.l  a0,_pflist              | ...
     714                move.w  FH_TRG(a1),PF_TRIG(a0)  | set trigger number in entry
     715                move.w  _curpf_f,PF_FUNC(a0)    | set v/p word in entry
     716                movem.l d1-d2/d4/a1-a3,PF_D1(a0)        | set registers in entry
     717                move.b  FH_TMD(a1),d0           | stop the function
     718                andi.w  #MSK_RNVB,d0            | ...
     719                move.w  d0,d3                   | ...
     720                add.w   d3,d3                   | ...
     721                andi.w  #MSK_ONVB,d3            | ...
     722                or.w    d3,d0                   | ...
     723                move.w  d0,F_CTL(a3,d1.W)       | ...
     724                bra     pfnext                  | go do next list entry
     725
     726                .page
     727| ------------------------------------------------------------------------------
    728728                .data
    729 * ------------------------------------------------------------------------------
    730 *
    731 * actab -- action code dispatch table
    732 * -----    --------------------------
    733 actab:          dc.l    act0    * 0 - AC_NULL:  no action
    734                 dc.l    act1    * 1 - AC_SUST:  sustain
    735                 dc.l    act2    * 2 - AC_ENBL:  enable
    736                 dc.l    act3    * 3 - AC_JUMP:  unconditional jump
    737                 dc.l    act4    * 4 - AC_LOOP:  jump n times      (loop)
    738                 dc.l    act5    * 5 - AC_KYUP:  jump if key up    (enable jump)
    739                 dc.l    act6    * 6 - AC_KYDN:  jump if key down  (sustain jump)
    740                 dc.l    act7    * 7 - AC_HERE:  here on key up
    741 *
    742 * ------------------------------------------------------------------------------
     729| ------------------------------------------------------------------------------
     730
     731| actab -- action code dispatch table
     732| -----    --------------------------
     733actab:          dc.l    act0    | 0 - AC_NULL:  no action
     734                dc.l    act1    | 1 - AC_SUST:  sustain
     735                dc.l    act2    | 2 - AC_ENBL:  enable
     736                dc.l    act3    | 3 - AC_JUMP:  unconditional jump
     737                dc.l    act4    | 4 - AC_LOOP:  jump n times      (loop)
     738                dc.l    act5    | 5 - AC_KYUP:  jump if key up    (enable jump)
     739                dc.l    act6    | 6 - AC_KYDN:  jump if key down  (sustain jump)
     740                dc.l    act7    | 7 - AC_HERE:  here on key up
     741
     742| ------------------------------------------------------------------------------
    743743                .bss
    744 * ------------------------------------------------------------------------------
    745 *
    746 * ----------------- local variables --------------------------------------------
    747 *
    748 _curpf_f:       ds.w    1       * interrupting voice & parameter from FPU
    749 *
    750 * ----------------- debug variables --------------------------------------------
    751 *
    752 _curpf_t:       ds.w    1       * current trigger
    753 *
    754 _curpf_l:       ds.l    1       * current pflist entry
    755 *
    756 * ------------------------------------------------------------------------------
    757 *
     744| ------------------------------------------------------------------------------
     745
     746| ----------------- local variables --------------------------------------------
     747
     748_curpf_f:       ds.w    1       | interrupting voice & parameter from FPU
     749
     750| ----------------- debug variables --------------------------------------------
     751
     752_curpf_t:       ds.w    1       | current trigger
     753
     754_curpf_l:       ds.l    1       | current pflist entry
     755
     756| ------------------------------------------------------------------------------
     757
    758758                .end

  • ram/sedisp.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * sedisp.s -- score event display driver
    3 * Version 43 -- 1988-09-26 -- D.N. Lynx Crowe
    4 *
    5 *       se_disp(ep, sd, gdstb, cf)
    6 *       struct s_entry *ep;
    7 *       short sd;
    8 *       struct gdsel *gdstb[];
    9 *       short cf;
    10 *
    11 *               Displays the event at 'ep', scrolling in direction 'sd', by
    12 *               updating 'gdstb'.  Uses the accidental code in 'ac_code', and
    13 *               the note type table 'nsvtab'.  Checks 'cf' to determine if
    14 *               we're displaying in the center of the screen.
    15 *               Allocates gdsel events as needed for new events.
    16 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| sedisp.s -- score event display driver
     3| Version 43 -- 1988-09-26 -- D.N. Lynx Crowe
     4
     5|       se_disp(ep, sd, gdstb, cf)
     6|       struct s_entry |ep;
     7|       short sd;
     8|       struct gdsel |gdstb[];
     9|       short cf;
     10
     11|               Displays the event at 'ep', scrolling in direction 'sd', by
     12|               updating 'gdstb'.  Uses the accidental code in 'ac_code', and
     13|               the note type table 'nsvtab'.  Checks 'cf' to determine if
     14|               we're displaying in the center of the screen.
     15|               Allocates gdsel events as needed for new events.
     16| ------------------------------------------------------------------------------
    1717                .text
    18 *
     18
    1919                .xdef   _se_disp
    20 *
     20
    2121                .xdef   _ac_code
    2222                .xdef   numstr
    23 *
     23
    2424                .xref   _dclkmd
    2525                .xref   _dsgmodz
    … …  
    2929                .xref   _vputc
    3030                .xref   _vputs
    31 *
     31
    3232                .xref   _angroup
    3333                .xref   _ctrsw
    … …  
    4949                .xref   _vrbw15
    5050                .xref   _vrcw
    51 *
    52                 .page
    53 *
    54 * parameter offsets
    55 * -----------------
    56 * for se_disp:
    57 * ------------
    58 P_EP            .equ    8               * LONG - event pointer
    59 P_SD            .equ    12              * WORD - scroll direction
    60 P_SL            .equ    14              * LONG - slice control table pointer
    61 P_CF            .equ    18              * WORD - center slice flag
    62 *
    63 * for vputa:
    64 * ----------
    65 ROW             .equ    4               * WORD - 'row' parameter offset
    66 COL             .equ    6               * WORD - 'col' parameter offset
    67 ATR             .equ    8               * WORD - 'atr' parameter offset
    68 *
    69 * Character field attributes for highlighting
    70 * -------------------------------------------
    71 AT01            .equ    $0054
    72 AT04            .equ    $0053
    73 AT05            .equ    $0054
    74 AT06            .equ    $0053
    75 AT07            .equ    $0054
    76 AT08            .equ    $0053
    77 AT09            .equ    $0054
    78 AT10            .equ    $0053
    79 AT11            .equ    $0052
    80 AT12            .equ    $0052
    81 *
    82 * Special character equates
    83 * -------------------------
    84 SP_M1           .equ    $A1                     * -1
    85 SP_P1           .equ    $A0                     * +1
    86 *
    87                 .page
    88 *
    89 * event structure offsets
    90 * -----------------------
    91 *                     offset             length
    92 *                     ------             ------
    93 E_TIME          .equ    0               * LONG
    94 E_SIZE          .equ    4               * BYTE
    95 E_TYPE          .equ    5               * BYTE
    96 E_DATA1         .equ    6               * BYTE
    97 E_NOTE          .equ    6               * BYTE
    98 E_DATA2         .equ    7               * BYTE
    99 E_GROUP         .equ    7               * BYTE
    100 E_BAK           .equ    8               * LONG
    101 E_FWD           .equ    12              * LONG
    102 E_DN            .equ    16              * LONG
    103 E_VEL           .equ    16              * WORD
    104 E_DATA4         .equ    18              * WORD
    105 E_UP            .equ    20              * LONG
    106 E_LFT           .equ    24              * LONG
    107 E_RGT           .equ    28              * LONG
    108 *
    109 N_ETYPES        .equ    25              * number of event types
    110 *
    111 * gdsel structure definitions
    112 * ---------------------------
    113 G_NEXT          .equ    0               * long - 'next' field   (struct gdsel *)
    114 G_NOTE          .equ    4               * word - 'note' field   (short)
    115 G_CODE          .equ    6               * word - 'code' field   (short)
    116 *
    117 NATCH_B         .equ    3               * uslice note code:  'begin natural'
    118 NOTE_E          .equ    6               * uslice note code:  'end note'
    119 *
    120 NGDSEL          .equ    17              * number of event slots in gdstb
    121 *
    122 BARFLAG         .equ    4*(NGDSEL-1)    * offset to the bar marker flag
    123 *
    124                 .page
    125 *
    126 * A few words about se_disp:
    127 * --------------------------
    128 * se_disp has to be very fast, so it's written in assembly language,
    129 * rather than C, which is usually pretty good, but not quite good enough
    130 * for this application.  The faster this routine runs, the higher the
    131 * tempo we can keep up with.  If this code is fast enough, we end up
    132 * hardware limited by the maximum rate of the timer, and the VSDD update rate.
    133 *
    134 _se_disp:       link    a6,#0                   * allocate and link stack frame
    135                 movea.l P_EP(a6),a0             * get event pointer 'ep' into a0
    136                 move.b  E_TYPE(a0),d1           * get event type into d1.W
    137                 andi.w  #$007F,d1               * mask off new-note flag
    138                 cmp.b   #N_ETYPES,d1            * see if it's valid
    139                 blt     seds1                   * jump if it is
    140 *
    141 dsexit:         unlk    a6                      * done -- unlink stack frames
    142                 rts                             * return to caller
    143 *
    144 seds1:          lea     sddtab,a1               * get base of dispatch table
    145                 lsl.w   #2,d1                   * multiplty event by 4 for index
    146                 movea.l 0(a1,d1.W),a2           * get address of event routine
    147                 jmp     (a2)                    * jump to event display routine
    148 *
    149 * On entry, the individual display routines only depend on a0 pointing at the
    150 * event they were dispatched for.  Registers a6 and a7 have their usual meaning,
    151 * a6 = frame pointer, a7 = stack pointer.
    152 *
    153 * d0..d2 are used for scratch, as are a0..a2, and are not saved by this code.
    154 *
    155                 .page
    156 *
    157 * dsnbx -- dispatch to begin / end based on sd
    158 * -----    -----------------------------------
    159 dsnbx:          tst.w   P_SD(a7)                * check direction
    160                 bne     dsne                    * treat as end if going backward
    161 *
    162 * dsnb -- display note begin
    163 * ----    ------------------
    164 dsnb:           move.b  E_TYPE(a0),d1           * get event type
    165                 move.w  d1,d2                   * save in d2
    166                 andi.w  #$007F,d1               * clear new-note flag
    167                 move.b  d1,E_TYPE(a0)           * store type back in event
    168                 clr.w   d0                      * get group number
    169                 move.b  E_GROUP(a0),d0          * ... in d0
    170                 move.w  d0,d1                   * save group in d1
    171                 add.w   d0,d0                   * make d0 a word offset
    172                 lea     _grpstat,a1             * check grpstat[grp]
    173                 tst.w   0(a1,d0.W)              * ...
    174                 beq     dsexit                  * done if not enabled
    175 *
    176                 tst.w   P_CF(a6)                * check center slice flag
    177                 beq     dsnb0                   * jump if not center slice
    178 *
    179                 tst.w   _velflag                * see if we display velocity
    180                 beq     dsnvx                   * jump if not
    181 *
    182                 move.w  d2,-(a7)                * save new-note flag on stack
    183                 move.w  d1,-(a7)                * save group number on stack
    184                 move.w  E_VEL(a0),d0            * get velocity
    185                 move.w  d1,d2                   * point into lastvel[]
    186                 add.w   d2,d2                   * ...
    187                 lea     _lastvel,a1             * ...
    188                 move.w  d0,0(a1,d2.W)           * update lastvel[group]
    189                 ext.l   d0                      * scale
    190                 divu    #252,d0                 * ...
    191                 cmpi.w  #100,d0                 * convert MS digit
    192                 bcs     dsnv0                   * ...
    193 *
    194                 move.b  #'1',numstr             * ...
    195                 subi.w  #100,d0                 * ...
    196                 bra     dsnv1                   * ...
    197 *
    198 dsnv0:          move.b  #'0',numstr             * ...
    199 *
    200 dsnv1:          ext.l   d0                      * convert middle & LS digits
    201                 divu    #10,d0                  * ...
    202                 addi.l  #$00300030,d0           * ...
    203                 move.b  d0,numstr+1             * ...
    204                 swap    d0                      * ...
    205                 move.b  d0,numstr+2             * ...
    206                 clr.b   numstr+3                * terminate string
    207                 move.w  d1,d0                   * col = group
    208                 asl.w   #2,d0                   * ... * 5
    209                 add.w   d1,d0                   * ...
    210                 add.w   #6,d0                   * ... + 6
    211                 move.l  a0,-(a7)                * save event pointer on stack
    212                 move.w  #AT11,-(a7)             * put attribute on stack
    213                 move.l  #numstr,-(a7)           * put string address on stack
    214                 move.w  d0,-(a7)                * put column on stack
    215                 move.w  #5,-(a7)                * put row on stack
    216                 move.l  _obj8,-(a7)             * put VSDD address on stack
    217                 jsr     _vputs                  * update the screen
    218                 add.l   #14,a7                  * clean up stack
    219                 movea.l (a7)+,a0                * restore event pointer
    220 *
    221                 .page
    222 *
    223                 move.w  (a7)+,d0                * get group from stack
    224                 cmpi.w  #12,d0                  * see which byte it's in
    225                 bcc     dsnv2                   * jump if in MS byte
    226 *
    227                 bset    d0,_vrbw12+1            * set group bit in LS byte
    228                 bra     dsnv3                   * ...
    229 *
    230 dsnv2:          bset    d0,_vrbw12              * set group bit in MS byte
    231 *
    232 dsnv3:          bset    #4,_vrcw                * set video reset type bit
    233                 move.w  (a7)+,d2                * get new-note flag from stack
    234 *
    235 dsnvx:          btst.l  #7,d2                   * check new-note flag
    236                 beq     dsexit                  * done if not set
    237 *
    238 dsnb0:          clr.w   d1                      * get note number nn (0..127)
    239                 move.b  E_NOTE(a0),d1           * ... in d1
    240                 sub.w   #21,d1                  * subtract base of piano scale
    241                 bmi     dsexit                  * done if not displayable
    242 *
    243                 cmp.w   #87,d1                  * see if it's too high
    244                 bgt     dsexit                  * done if not displayable
    245 *
    246                 move.l  _gdfsep,d0              * quit if no elements left
    247                 beq     dsexit                  * ...
    248 *
    249                 movea.l d0,a1                   * a1 = gdsp
    250                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    251                 clr.w   d2                      * d2 = ep->group
    252                 move.b  E_GROUP(a0),d2          * ...
    253                 lsl.w   #2,d2                   * ... * 4
    254                 movea.l P_SL(a6),a2             * a2 points at gdstb
    255                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[ep->group]
    256                 move.l  a1,0(a2,d2.W)           * gdstb[ep->group] = gdsp
    257                 move.w  d1,G_NOTE(a1)           * gdsp->note = nn
    258                 lea     _nsvtab,a2              * a2 points at nsvtab
    259                 tst.b   0(a2,d1.W)              * check nsvtab[nn]
    260                 beq     dsnb1                   * jump if natural note
    261 *
    262                 move.b  _ac_code,d1             * setup for an accidental note
    263                 bra     dsnb2                   * ...
    264 *
    265 dsnb1:          move.b  #NATCH_B,d1             * setup for a natural note
    266 *
    267 dsnb2:          move.w  d1,G_CODE(a1)           * gdsp->code = note type
    268                 bra     dsexit                  * done
    269 *
    270                 .page
    271 *
    272 * dsnex -- dispatch to end/begin based on sd
    273 * -----    ---------------------------------
    274 dsnex:          tst.w   P_SD(a7)                * check direction
    275                 bne     dsnb                    * treat as begin if going backward
    276 *
    277 * dsne -- display note end
    278 * ----    ----------------
    279 dsne:           move.b  E_TYPE(a0),d1           * get event type
    280                 move.w  d1,d2                   * save in d2
    281                 andi.w  #$007F,d1               * clear new-note flag
    282                 move.b  d1,E_TYPE(a0)           * store type back in event
    283                 clr.w   d0                      * get group number
    284                 move.b  E_GROUP(a0),d0          * ... in d0
    285                 add.w   d0,d0                   * ... as a word offset
    286                 lea     _grpstat,a1             * check grpstat[grp]
    287                 tst.w   0(a1,d0.W)              * ...
    288                 beq     dsexit                  * done if not enabled
    289 *
    290                 tst.w   P_CF(a6)                * check center slice flag
    291                 beq     dsne3                   * jump if not center slice
    292 *
    293                 btst.l  #7,d2                   * check new-note flag
    294                 beq     dsexit                  * done if not set
    295 *
    296 dsne3:          move.b  E_NOTE(a0),d1           * d1 = note number nn (0..127)
    297                 sub.w   #21,d1                  * subtract base of piano scale
    298                 bmi     dsexit                  * done if not displayable
    299 *
    300                 cmp.w   #87,d1                  * see if it's too high
    301                 bgt     dsexit                  * done if not displayable
    302 *
    303                 movea.l P_SL(a6),a2             * a2 points at gdstb
    304                 clr.w   d2                      * get group in d2
    305                 move.b  E_GROUP(a0),d2          * ...
    306                 lsl.w   #2,d2                   * ... * 4
    307                 move.l  0(a2,d2.W),d0           * check gdstb[ep->group]
     51
     52                .page
     53
     54| parameter offsets
     55| -----------------
     56| for se_disp:
     57| ------------
     58P_EP            =       8               | LONG - event pointer
     59P_SD            =       12              | WORD - scroll direction
     60P_SL            =       14              | LONG - slice control table pointer
     61P_CF            =       18              | WORD - center slice flag
     62
     63| for vputa:
     64| ----------
     65ROW             =       4               | WORD - 'row' parameter offset
     66COL             =       6               | WORD - 'col' parameter offset
     67ATR             =       8               | WORD - 'atr' parameter offset
     68
     69| Character field attributes for highlighting
     70| -------------------------------------------
     71AT01            =       0x0054
     72AT04            =       0x0053
     73AT05            =       0x0054
     74AT06            =       0x0053
     75AT07            =       0x0054
     76AT08            =       0x0053
     77AT09            =       0x0054
     78AT10            =       0x0053
     79AT11            =       0x0052
     80AT12            =       0x0052
     81
     82| Special character equates
     83| -------------------------
     84SP_M1           =       0xA1                    | -1
     85SP_P1           =       0xA0                    | +1
     86
     87                .page
     88
     89| event structure offsets
     90| -----------------------
     91|                     offset             length
     92|                     ------             ------
     93E_TIME          =       0               | LONG
     94E_SIZE          =       4               | BYTE
     95E_TYPE          =       5               | BYTE
     96E_DATA1         =       6               | BYTE
     97E_NOTE          =       6               | BYTE
     98E_DATA2         =       7               | BYTE
     99E_GROUP         =       7               | BYTE
     100E_BAK           =       8               | LONG
     101E_FWD           =       12              | LONG
     102E_DN            =       16              | LONG
     103E_VEL           =       16              | WORD
     104E_DATA4         =       18              | WORD
     105E_UP            =       20              | LONG
     106E_LFT           =       24              | LONG
     107E_RGT           =       28              | LONG
     108
     109N_ETYPES        =       25              | number of event types
     110
     111| gdsel structure definitions
     112| ---------------------------
     113G_NEXT          =       0               | long - 'next' field   (struct gdsel |)
     114G_NOTE          =       4               | word - 'note' field   (short)
     115G_CODE          =       6               | word - 'code' field   (short)
     116
     117NATCH_B         =       3               | uslice note code:  'begin natural'
     118NOTE_E          =       6               | uslice note code:  'end note'
     119
     120NGDSEL          =       17              | number of event slots in gdstb
     121
     122BARFLAG         =       4|(NGDSEL-1)    | offset to the bar marker flag
     123
     124                .page
     125
     126| A few words about se_disp:
     127| --------------------------
     128| se_disp has to be very fast, so it's written in assembly language,
     129| rather than C, which is usually pretty good, but not quite good enough
     130| for this application.  The faster this routine runs, the higher the
     131| tempo we can keep up with.  If this code is fast enough, we end up
     132| hardware limited by the maximum rate of the timer, and the VSDD update rate.
     133
     134_se_disp:       link    a6,#0                   | allocate and link stack frame
     135                movea.l P_EP(a6),a0             | get event pointer 'ep' into a0
     136                move.b  E_TYPE(a0),d1           | get event type into d1.W
     137                andi.w  #0x007F,d1              | mask off new-note flag
     138                cmp.b   #N_ETYPES,d1            | see if it's valid
     139                blt     seds1                   | jump if it is
     140
     141dsexit:         unlk    a6                      | done -- unlink stack frames
     142                rts                             | return to caller
     143
     144seds1:          lea     sddtab,a1               | get base of dispatch table
     145                lsl.w   #2,d1                   | multiplty event by 4 for index
     146                movea.l 0(a1,d1.W),a2           | get address of event routine
     147                jmp     (a2)                    | jump to event display routine
     148
     149| On entry, the individual display routines only depend on a0 pointing at the
     150| event they were dispatched for.  Registers a6 and a7 have their usual meaning,
     151| a6 = frame pointer, a7 = stack pointer.
     152
     153| d0..d2 are used for scratch, as are a0..a2, and are not saved by this code.
     154
     155                .page
     156
     157| dsnbx -- dispatch to begin / end based on sd
     158| -----    -----------------------------------
     159dsnbx:          tst.w   P_SD(a7)                | check direction
     160                bne     dsne                    | treat as end if going backward
     161
     162| dsnb -- display note begin
     163| ----    ------------------
     164dsnb:           move.b  E_TYPE(a0),d1           | get event type
     165                move.w  d1,d2                   | save in d2
     166                andi.w  #0x007F,d1              | clear new-note flag
     167                move.b  d1,E_TYPE(a0)           | store type back in event
     168                clr.w   d0                      | get group number
     169                move.b  E_GROUP(a0),d0          | ... in d0
     170                move.w  d0,d1                   | save group in d1
     171                add.w   d0,d0                   | make d0 a word offset
     172                lea     _grpstat,a1             | check grpstat[grp]
     173                tst.w   0(a1,d0.W)              | ...
     174                beq     dsexit                  | done if not enabled
     175
     176                tst.w   P_CF(a6)                | check center slice flag
     177                beq     dsnb0                   | jump if not center slice
     178
     179                tst.w   _velflag                | see if we display velocity
     180                beq     dsnvx                   | jump if not
     181
     182                move.w  d2,-(a7)                | save new-note flag on stack
     183                move.w  d1,-(a7)                | save group number on stack
     184                move.w  E_VEL(a0),d0            | get velocity
     185                move.w  d1,d2                   | point into lastvel[]
     186                add.w   d2,d2                   | ...
     187                lea     _lastvel,a1             | ...
     188                move.w  d0,0(a1,d2.W)           | update lastvel[group]
     189                ext.l   d0                      | scale
     190                divu    #252,d0                 | ...
     191                cmpi.w  #100,d0                 | convert MS digit
     192                bcs     dsnv0                   | ...
     193
     194                move.b  #'1',numstr             | ...
     195                subi.w  #100,d0                 | ...
     196                bra     dsnv1                   | ...
     197
     198dsnv0:          move.b  #'0',numstr             | ...
     199
     200dsnv1:          ext.l   d0                      | convert middle & LS digits
     201                divu    #10,d0                  | ...
     202                addi.l  #0x00300030,d0          | ...
     203                move.b  d0,numstr+1             | ...
     204                swap    d0                      | ...
     205                move.b  d0,numstr+2             | ...
     206                clr.b   numstr+3                | terminate string
     207                move.w  d1,d0                   | col = group
     208                asl.w   #2,d0                   | ... | 5
     209                add.w   d1,d0                   | ...
     210                add.w   #6,d0                   | ... + 6
     211                move.l  a0,-(a7)                | save event pointer on stack
     212                move.w  #AT11,-(a7)             | put attribute on stack
     213                move.l  #numstr,-(a7)           | put string address on stack
     214                move.w  d0,-(a7)                | put column on stack
     215                move.w  #5,-(a7)                | put row on stack
     216                move.l  _obj8,-(a7)             | put VSDD address on stack
     217                jsr     _vputs                  | update the screen
     218                add.l   #14,a7                  | clean up stack
     219                movea.l (a7)+,a0                | restore event pointer
     220
     221                .page
     222
     223                move.w  (a7)+,d0                | get group from stack
     224                cmpi.w  #12,d0                  | see which byte it's in
     225                bcc     dsnv2                   | jump if in MS byte
     226
     227                bset    d0,_vrbw12+1            | set group bit in LS byte
     228                bra     dsnv3                   | ...
     229
     230dsnv2:          bset    d0,_vrbw12              | set group bit in MS byte
     231
     232dsnv3:          bset    #4,_vrcw                | set video reset type bit
     233                move.w  (a7)+,d2                | get new-note flag from stack
     234
     235dsnvx:          btst.l  #7,d2                   | check new-note flag
     236                beq     dsexit                  | done if not set
     237
     238dsnb0:          clr.w   d1                      | get note number nn (0..127)
     239                move.b  E_NOTE(a0),d1           | ... in d1
     240                sub.w   #21,d1                  | subtract base of piano scale
     241                bmi     dsexit                  | done if not displayable
     242
     243                cmp.w   #87,d1                  | see if it's too high
     244                bgt     dsexit                  | done if not displayable
     245
     246                move.l  _gdfsep,d0              | quit if no elements left
     247                beq     dsexit                  | ...
     248
     249                movea.l d0,a1                   | a1 = gdsp
     250                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     251                clr.w   d2                      | d2 = ep->group
     252                move.b  E_GROUP(a0),d2          | ...
     253                lsl.w   #2,d2                   | ... | 4
     254                movea.l P_SL(a6),a2             | a2 points at gdstb
     255                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[ep->group]
     256                move.l  a1,0(a2,d2.W)           | gdstb[ep->group] = gdsp
     257                move.w  d1,G_NOTE(a1)           | gdsp->note = nn
     258                lea     _nsvtab,a2              | a2 points at nsvtab
     259                tst.b   0(a2,d1.W)              | check nsvtab[nn]
     260                beq     dsnb1                   | jump if natural note
     261
     262                move.b  _ac_code,d1             | setup for an accidental note
     263                bra     dsnb2                   | ...
     264
     265dsnb1:          move.b  #NATCH_B,d1             | setup for a natural note
     266
     267dsnb2:          move.w  d1,G_CODE(a1)           | gdsp->code = note type
     268                bra     dsexit                  | done
     269
     270                .page
     271
     272| dsnex -- dispatch to end/begin based on sd
     273| -----    ---------------------------------
     274dsnex:          tst.w   P_SD(a7)                | check direction
     275                bne     dsnb                    | treat as begin if going backward
     276
     277| dsne -- display note end
     278| ----    ----------------
     279dsne:           move.b  E_TYPE(a0),d1           | get event type
     280                move.w  d1,d2                   | save in d2
     281                andi.w  #0x007F,d1              | clear new-note flag
     282                move.b  d1,E_TYPE(a0)           | store type back in event
     283                clr.w   d0                      | get group number
     284                move.b  E_GROUP(a0),d0          | ... in d0
     285                add.w   d0,d0                   | ... as a word offset
     286                lea     _grpstat,a1             | check grpstat[grp]
     287                tst.w   0(a1,d0.W)              | ...
     288                beq     dsexit                  | done if not enabled
     289
     290                tst.w   P_CF(a6)                | check center slice flag
     291                beq     dsne3                   | jump if not center slice
     292
     293                btst.l  #7,d2                   | check new-note flag
     294                beq     dsexit                  | done if not set
     295
     296dsne3:          move.b  E_NOTE(a0),d1           | d1 = note number nn (0..127)
     297                sub.w   #21,d1                  | subtract base of piano scale
     298                bmi     dsexit                  | done if not displayable
     299
     300                cmp.w   #87,d1                  | see if it's too high
     301                bgt     dsexit                  | done if not displayable
     302
     303                movea.l P_SL(a6),a2             | a2 points at gdstb
     304                clr.w   d2                      | get group in d2
     305                move.b  E_GROUP(a0),d2          | ...
     306                lsl.w   #2,d2                   | ... | 4
     307                move.l  0(a2,d2.W),d0           | check gdstb[ep->group]
    308308                beq     dsexit
    309 *
    310 dsne0:          movea.l d0,a1                   * a1 = gdsp
    311 *
    312 dsne1:          cmp.w   G_NOTE(a1),d1           * compare nn to gdsp->note
    313                 bne     dsne2                   * jump if not the one we want
    314 *
    315                 move.w  #NOTE_E,G_CODE(a1)      * gdsp->code = NOTE_E  (end note)
    316 *
    317 dsne2:          move.l  G_NEXT(a1),d0           * get gdsp->next
    318                 beq     dsexit                  * done if next = NULL
    319 *
    320                 bra     dsne0                   * loop for next one
    321 *
    322                 .page
    323 *
    324 * dssbgn -- display section begin
    325 * ------    ---------------------
    326 dssbgn:         tst.w   P_CF(a6)                * center update ?
    327                 beq     dsbgn0                  * jump if not
    328 *
    329                 clr.w   d1                      * get section number
    330                 move.b  E_DATA1(a0),d1          * ... from the event
    331                 addq.w  #1,d1                   * ... adjusted for display
    332                 ext.l   d1                      * ... as a long in d1
    333                 divu    #10,d1                  * divide by 10 for conversion
    334                 add.l   #$00300030,d1           * add '0' for ASCII conversion
    335                 move.b  d1,numstr               * put MS byte in work area
    336                 swap    d1                      * swap register halves
    337                 move.b  d1,numstr+1             * put LS byte in work area
    338                 clr.b   numstr+2                * terminate string
    339                 move.w  #AT01,-(a7)             * put attribute on stack
    340                 move.l  #numstr,-(a7)           * put buffer address on stack
    341                 move.w  #6,-(a7)                * put column on stack
    342                 move.w  #0,-(a7)                * put row on stack
    343                 move.l  _obj8,-(a7)             * put sbase on stack
    344                 jsr     _vputs                  * update the screen
    345                 add.l   #14,a7                  * clean up stack
    346                 bset    #4,_vrcw+1              * set video reset type bit
    347                 tst.w   _ctrsw                  * update center for scupd ?
    348                 beq     dsexit                  * done if not
    349 *
    350 dsbgn0:         move.l  _gdfsep,d0              * quit if no elements left
    351                 beq     dsexit                  * ...
    352 *
    353                 movea.l d0,a1                   * a1 = gdsp
    354                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    355                 move.w  #48,d2                  * d2 = event PRIORITY * 4
    356                 movea.l P_SL(a6),a2             * a2 points at gdstb
    357                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    358                 move.w  #$1111,G_NOTE(a1)       * gdsp->note = COLOR
    359                 move.w  #0,G_CODE(a1)           * gdsp->code = PATTERN
    360                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    361                 bra     dsexit                  * done
    362 *
    363                 .page
    364 *
    365 * dssend -- display section end
    366 * ------    -------------------
    367 dssend:         tst.w   P_CF(a6)                * center update ?
    368                 beq     dssend0                 * jump if not
    369 *
    370                 tst.w   _ctrsw                  * update center for scupd ?
    371                 beq     dsexit                  * done if not
    372 *
    373 dssend0:        move.l  _gdfsep,d0              * quit if no elements left
    374                 beq     dsexit                  * ...
    375 *
    376                 movea.l d0,a1                   * a1 = gdsp
    377                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    378                 move.w  #48,d2                  * d2 = event PRIORITY * 4
    379                 movea.l P_SL(a6),a2             * a2 points at gdstb
    380                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    381                 move.w  #$1111,G_NOTE(a1)       * gdsp->note = COLOR
    382                 move.w  #2,G_CODE(a1)           * gdsp->code = PATTERN
    383                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    384                 bra     dsexit                  * done
    385 *
    386 * dsbeat -- display beat
    387 * ------    ------------
    388 dsbeat:         tst.w   P_CF(a6)                * center update ?
    389                 bne     dsexit                  * done if so
    390 *
    391                 move.l  _gdfsep,d0              * quit if no elements left
    392                 beq     dsexit                  * ...
    393 *
    394                 movea.l d0,a1                   * a1 = gdsp
    395                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    396                 move.w  #48,d2                  * d2 = event PRIORITY * 4
    397                 movea.l P_SL(a6),a2             * a2 points at gdstb
    398                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    399                 move.w  #$1111,G_NOTE(a1)       * gdsp->note = COLOR
    400                 move.w  #1,G_CODE(a1)           * gdsp->code = PATTERN
    401                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    402                 bra     dsexit                  * done
    403 *
    404                 .page
    405 *
    406 * dstune -- display tuning
    407 * ------    --------------
    408 dstune:         tst.w   P_CF(a6)                * center update ?
    409                 beq     dstune0                 * jump if not
    410 *
    411                 clr.w   d1                      * get current tuning
    412                 move.b  E_DATA1(a0),d1          * ...
    413                 add.w   #$0030,d1               * add '0' for ASCII conversion
    414                 move.w  #AT05,-(a7)             * put attribute on stack
    415                 move.w  d1,-(a7)                * put character on stack
    416                 move.w  #19,-(a7)               * put column on stack
    417                 move.w  #1,-(a7)                * put row on stack
    418                 move.l  _obj8,-(a7)             * put sbase on stack
    419                 jsr     _vputc                  * display character
    420                 add.l   #12,a7                  * clean up stack
    421                 bset    #1,_vrcw+1              * set video reset type bit
    422                 tst.w   _ctrsw                  * update center for scupd ?
    423                 beq     dsexit                  * done if not
    424 *
    425 dstune0:        move.l  _gdfsep,d0              * quit if no elements left
    426                 beq     dsexit                  * ...
    427 *
    428                 movea.l d0,a1                   * a1 = gdsp
    429                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    430                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    431                 movea.l P_SL(a6),a2             * a2 points at gdstb
    432                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    433                 move.w  #$CCCC,G_NOTE(a1)       * gdsp->note = COLOR
    434                 move.w  #3,G_CODE(a1)           * gdsp->code = PATTERN
    435                 move.l  a1,0(a2,d2.W)           * gdstb[priority] = gdsp
    436                 bra     dsexit                  * done
    437 *
    438                 .page
    439 *
    440 * dstrns -- display transposition
    441 * ------    ---------------------
    442 dstrns:         clr.w   d0                      * get group number
    443                 move.b  E_DATA1(a0),d0          * ... in d0
    444                 add.w   d0,d0                   * ... as a word offset
    445                 lea     _grpstat,a1             * check grpstat[grp]
    446                 tst.w   0(a1,d0.W)              * ...
    447                 beq     dsexit                  * done if not enabled
    448 *
    449                 tst.w   P_CF(a6)                * center update
    450                 beq     dstrns0                 * jump if not
    451 *
    452                 move.w  E_LFT(a0),d1            * get transposition value
    453                 bpl     dstrns1                 * jump if positive
    454 *
    455                 move.b  #'-',numstr             * note negative sign
    456                 neg.w   d1                      * make number positive
    457                 bra     dstrns2                 * ...
    458 *
    459 dstrns1:        move.b  #'+',numstr             * note positive sign
    460 *
    461 dstrns2:        cmpi.w  #1000,d1                * is number GE 1000 ?
    462                 bcs     dstrns3                 * jump if not
    463 *
    464                 subi.w  #1000,d1                * adjust number
    465                 cmpi.b  #'-',numstr             * was number negative
    466                 bne     dstrns4                 * jump if not
    467 *
    468                 move.b  #SP_M1,numstr           * set -1 in numstr
    469                 bra     dstrns3                 * ...
    470 *
    471 dstrns4:        move.b  #SP_P1,numstr           * set +1 in numstr
    472 *
    473 dstrns3:        ext.l   d1                      * make d1 a long
    474                 divu    #100,d1                 * convert 1st digit
    475                 addi.w  #$0030,d1               * ... to ASCII
    476                 move.b  d1,numstr+1             * ... in numstr
    477                 swap    d1                      * convert 2nd digit
    478                 ext.l   d1                      * ...
    479                 divu    #10,d1                  * ...
    480                 addi.w  #$0030,d1               * ... to ASCII
    481                 move.b  d1,numstr+2             * ... in numstr
    482                 swap    d1                      * convert 3rd digit
    483                 addi.w  #$0030,d1               * ... to ASCII
    484                 move.b  d1,numstr+3             * ... in numstr
    485                 clr.b   numstr+4                * terminate numstr
    486 *
    487                 .page
    488 *
    489                 move.w  d0,d1                   * get group number
    490                 asr.w   #1,d1                   * ... in d1
    491                 move.w  d1,-(a7)                * save group number on stack
    492                 add.w   d0,d0                   * calculate column
    493                 add.w   d0,d1                   * ... = 5 * group
    494                 addi.w  #5,d1                   * ... + 5
    495                 move.w  #AT11,-(a7)             * vputs(obj8, 3, col, numstr, atr11)
    496                 move.l  #numstr,-(a7)           * ...
    497                 move.w  d1,-(a7)                * ...
    498                 move.w  #3,-(a7)                * ...
    499                 move.l  _obj8,-(a7)             * ...
    500                 jsr     _vputs                  * ...
    501                 add.l   #14,a7                  * ...
    502                 move.w  (a7)+,d0                * get group number
    503                 cmpi.w  #8,d0                   * see which byte it's in
    504                 bcc     dstrns5                 * jump if in MS byte
    505 *
    506                 bset    d0,_vrbw09+1            * set group bit in LS byte
    507                 bra     dstrns6                 * ...
    508 *
    509 dstrns5:        sub.w   #8,d0                   * adjust for byte
    510                 bset    d0,_vrbw09              * set group bit in MS byte
    511 *
    512 dstrns6:        bset    #1,_vrcw                * set video reset type bit
    513                 tst.w   _ctrsw                  * update center for scupd ?
    514                 beq     dsexit                  * done if not
    515 *
    516 dstrns0:        move.l  _gdfsep,d0              * quit if no elements left
    517                 beq     dsexit                  * ...
    518 *
    519                 movea.l d0,a1                   * a1 = gdsp
    520                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    521                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    522                 movea.l P_SL(a6),a2             * a2 points at gdstb
    523                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    524                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    525                 move.w  #4,G_CODE(a1)           * gdsp->code = PATTERN
    526                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    527                 bra     dsexit                  * done
    528 *
    529                 .page
    530 *
    531 * dsdyn -- display dynamics
    532 * -----    ----------------
    533 dsdyn:          clr.w   d0                      * get group number
    534                 move.b  E_DATA1(a0),d0          * ... in d0
    535                 add.w   d0,d0                   * ... as a word offset
    536                 lea     _grpstat,a1             * check grpstat[grp]
    537                 tst.w   0(a1,d0.W)              * ...
    538                 beq     dsexit                  * done if not enabled
    539 *
    540                 tst.w   P_CF(a6)                * center update ?
    541                 beq     dsdyn00                 * jump if not
    542 *
    543                 clr.w   d0                      * get dynamics
    544                 move.b  E_DATA2(a0),d0          * ... in d0
    545                 move.w  d0,-(a7)                * save dyanmics
    546                 clr.w   d1                      * get group number
    547                 move.b  E_DATA1(a0),d1          * ... in d1
    548                 move.w  d1,-(a7)                * save group number
    549                 move.w  (a7),d0                 * col = group number
    550                 add.w   d0,d0                   * ... * 5
    551                 add.w   d0,d0                   * ...
    552                 move.w  (a7)+,d2                * ...  (d2 = group number)
    553                 add.w   d2,d0                   * ...
    554                 add.w   #6,d0                   * ... + 6
    555                 move.w  (a7)+,d1                * get dynamics
    556                 add.w   #$0030,d1               * add '0' for ASCII conversion
    557                 move.w  d2,-(a7)                * save group number
    558                 move.w  #AT11,-(a7)             * put attribute on stack
    559                 move.w  d1,-(a7)                * put digit on stack
    560                 move.w  d0,-(a7)                * put column on stack
    561                 move.w  #4,-(a7)                * put row on stack
    562                 move.l  _obj8,-(a7)             * put object address on stack
    563                 jsr     _vputc                  * update the screen
    564                 add.l   #12,a7                  * clean up stack
    565                 move.w  (a7)+,d0                * get group number
    566                 cmp.w   #8,d0                   * see which word it's in
    567                 bcc     dsdyn1                  * jump if in MS word
    568 *
    569                 bset    d0,_vrbw10+1            * set group bit in LS byte
    570                 bra     dsdyn2                  * ...
    571 *
    572 dsdyn1:         sub.w   #8,d0                   * adjust for for byte
    573                 bset    d0,_vrbw10              * set group bit in MS byte
    574 *
    575 dsdyn2:         bset    #2,_vrcw                * set video reset type bit
    576                 tst.w   _ctrsw                  * update center for scupd ?
    577                 beq     dsexit                  * done if not
    578 *
    579                 .page
    580 dsdyn00:        move.l  _gdfsep,d0              * quit if no elements left
    581                 beq     dsexit                  * ...
    582 *
    583                 movea.l d0,a1                   * a1 = gdsp
    584                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    585                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    586                 movea.l P_SL(a6),a2             * a2 points at gdstb
    587                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    588                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    589                 move.w  #5,G_CODE(a1)           * gdsp->code = PATTERN
    590                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    591                 bra     dsexit                  * done
    592 *
    593                 .page
    594 *
    595 * dslocn -- display location
    596 * ------    ----------------
    597 dslocn:         clr.w   d0                      * get group number
    598                 move.b  E_DATA1(a0),d0          * ... in d0
    599                 add.w   d0,d0                   * ... as a word offset
    600                 lea     _grpstat,a1             * check grpstat[grp]
    601                 tst.w   0(a1,d0.W)              * ...
    602                 beq     dsexit                  * done if not enabled
    603 *
    604                 tst.w   P_CF(a6)                * center update ?
    605                 beq     dsloc00                 * jump if not
    606 *
    607                 clr.w   d0                      * get location
    608                 move.b  E_DATA2(a0),d0          * ... in d0
    609                 move.w  d0,-(a7)                * save location
    610                 clr.w   d1                      * get group number
    611                 move.b  E_DATA1(a0),d1          * ... in d1
    612                 move.w  d1,-(a7)                * save group number
    613                 move.w  (a7),d0                 * col = group number
    614                 add.w   d0,d0                   * ... * 5
    615                 add.w   d0,d0                   * ...
    616                 move.w  (a7)+,d2                * ...  (d2 = group number)
    617                 add.w   d2,d0                   * ...
    618                 add.w   #8,d0                   * ... + 8
    619                 move.w  (a7)+,d1                * get location
    620                 add.w   #$0031,d1               * add '0' for ASCII conversion
    621                 move.w  d2,-(a7)                * save group number
    622                 move.w  #AT11,-(a7)             * put attribute on stack
    623                 move.w  d1,-(a7)                * put character on stack
    624                 move.w  d0,-(a7)                * put column on stack
    625                 move.w  #4,-(a7)                * put row on stack
    626                 move.l  _obj8,-(a7)             * put object address on stack
    627                 jsr     _vputc                  * update the screen
    628                 add.l   #12,a7                  * clean up stack
    629                 move.w  (a7)+,d0                * get group number
    630                 cmp.w   #8,d0                   * see which word it's in
    631                 bcc     dslocn1                 * jump if in MS word
    632 *
    633                 bset    d0,_vrbw11+1            * set group bit in LS byte
    634                 bra     dslocn2                 * ...
    635 *
    636 dslocn1:        sub.w   #8,d0                   * adjust for for byte
    637                 bset    d0,_vrbw11              * set group bit in MS byte
    638 *
    639 dslocn2:        bset    #3,_vrcw                * set video reset type bit
    640                 tst.w   _ctrsw                  * update center for scupd ?
    641                 beq     dsexit                  * done if not
    642 *
    643                 .page
    644 dsloc00:        move.l  _gdfsep,d0              * quit if no elements left
    645                 beq     dsexit                  * ...
    646 *
    647                 movea.l d0,a1                   * a1 = gdsp
    648                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    649                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    650                 movea.l P_SL(a6),a2             * a2 points at gdstb
    651                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    652                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    653                 move.w  #5,G_CODE(a1)           * gdsp->code = PATTERN
    654                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    655                 bra     dsexit                  * done
    656 *
    657                 .page
    658 *
    659 * dsanrs -- display analog resolution
    660 * ------    -------------------------
    661 dsanrs:         move.b  E_DATA1(a0),d1          * get var / group
    662                 move.w  d1,d0                   * extract group number
    663                 andi.w  #$000F,d0               * ... in d0
    664                 add.w   d0,d0                   * ... as a word offset
    665                 lea     _grpstat,a1             * check grpstat[grp]
    666                 tst.w   0(a1,d0.W)              * ...
    667                 beq     dsexit                  * done if not enabled
    668 *
    669                 tst.w   P_CF(a6)                * center update ?
    670                 beq     dsanrs0                 * jump if not
    671 *
    672                 move.w  _angroup,d2             * see if we display
    673                 bmi     dsexit                  * jump if not
    674 *
    675                 subq.w  #1,d2                   * adust selected group number
    676                 move.w  d1,d0                   * extract group from event
    677                 andi.w  #$000F,d0               * ...
    678                 cmp.w   d0,d2                   * see if we display
    679                 bne     dsexit                  * jump if not
    680 *
    681                 lsr.w   #4,d1                   * extract variable number
    682                 andi.w  #$000F,d1               * ...
    683                 move.w  d1,-(a7)                * save variable number
    684                 move.w  d1,d0                   * calculate display offset
    685                 lsl.w   #3,d0                   * ... (var * 9) + 6
    686                 add.w   d0,d1                   * ... in d1
    687                 addq.w  #6,d1                   * ...
    688                 move.b  E_DATA2(a0),d0          * get resolution
    689                 addi.w  #$0030,d0               * convert for display
    690                 move.w  #AT12,-(a7)             * put attribute on stack
    691                 move.w  d0,-(a7)                * put character on stack
    692                 move.w  d1,-(a7)                * put column on stack
    693                 move.w  #7,-(a7)                * put row on stack
    694                 move.l  _obj8,-(a7)             * put sbase on stack
    695                 jsr     _vputc                  * update the screen
    696                 add.l   #12,a7                  * clean up stack
    697                 move.w  (a7)+,d0                * get variable number
    698                 bset    d0,_vrbw13+1            * set variable bit
    699                 bset    #5,_vrcw                * set video reset type bit
    700                 tst.w   _ctrsw                  * update center for scupd ?
    701                 beq     dsexit                  * done if not
    702 *
    703                 .page
    704 dsanrs0:        move.l  _gdfsep,d0              * quit if no elements left
    705                 beq     dsexit                  * ...
    706 *
    707                 movea.l d0,a1                   * a1 = gdsp
    708                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    709                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    710                 movea.l P_SL(a6),a2             * a2 points at gdstb
    711                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    712                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    713                 move.w  #6,G_CODE(a1)           * gdsp->code = PATTERN
    714                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    715                 bra     dsexit                  * done
    716 *
    717                 .page
    718 *
    719 * dsanvl -- display analog value
    720 * ------    --------------------
    721 dsanvl:         move.w  _angroup,d2             * see if we display
    722                 bmi     dsexit                  * jump if not
    723 *
    724                 move.b  E_DATA1(a0),d1          * get var / group
    725                 move.w  d1,d0                   * extract group number
    726                 andi.w  #$000F,d0               * ... in d0
    727                 add.w   d0,d0                   * ... as a word offset
    728                 lea     _grpstat,a1             * check grpstat[grp]
    729                 tst.w   0(a1,d0.W)              * ...
    730                 beq     dsexit                  * done if not enabled
    731 *
    732                 tst.w   P_CF(a6)                * center update ?
    733                 beq     dsanvl0                 * jump if not
    734 *
    735                 subq.w  #1,d2                   * adust group number
    736                 move.w  d1,d0                   * extract group
    737                 andi.w  #$000F,d0               * ...
    738                 cmp.w   d0,d2                   * see if we display
    739                 bne     dsexit                  * jump if not
    740 *
    741                 lsr.w   #4,d1                   * extract variable number
    742                 andi.w  #$000F,d1               * ...
    743                 move.w  d1,-(a7)                * save variable number
    744                 move.w  d1,d0                   * calculate display offset
    745                 lsl.w   #3,d0                   * ... (var * 9) + 8
    746                 add.w   d0,d1                   * ... in d1
    747                 addi.w  #8,d1                   * ...
    748                 move.w  E_DN(a0),d0             * get value
    749                 asr.w   #5,d0                   * adjust to low 11 bits
    750                 bpl     dsanvl1                 * jump if positive
    751 *
    752                 move.b  #'-',numstr             * set sign = '-'
    753                 neg.w   d0                      * make value positive
     309
     310dsne0:          movea.l d0,a1                   | a1 = gdsp
     311
     312dsne1:          cmp.w   G_NOTE(a1),d1           | compare nn to gdsp->note
     313                bne     dsne2                   | jump if not the one we want
     314
     315                move.w  #NOTE_E,G_CODE(a1)      | gdsp->code = NOTE_E  (end note)
     316
     317dsne2:          move.l  G_NEXT(a1),d0           | get gdsp->next
     318                beq     dsexit                  | done if next = NULL
     319
     320                bra     dsne0                   | loop for next one
     321
     322                .page
     323
     324| dssbgn -- display section begin
     325| ------    ---------------------
     326dssbgn:         tst.w   P_CF(a6)                | center update ?
     327                beq     dsbgn0                  | jump if not
     328
     329                clr.w   d1                      | get section number
     330                move.b  E_DATA1(a0),d1          | ... from the event
     331                addq.w  #1,d1                   | ... adjusted for display
     332                ext.l   d1                      | ... as a long in d1
     333                divu    #10,d1                  | divide by 10 for conversion
     334                add.l   #0x00300030,d1          | add '0' for ASCII conversion
     335                move.b  d1,numstr               | put MS byte in work area
     336                swap    d1                      | swap register halves
     337                move.b  d1,numstr+1             | put LS byte in work area
     338                clr.b   numstr+2                | terminate string
     339                move.w  #AT01,-(a7)             | put attribute on stack
     340                move.l  #numstr,-(a7)           | put buffer address on stack
     341                move.w  #6,-(a7)                | put column on stack
     342                move.w  #0,-(a7)                | put row on stack
     343                move.l  _obj8,-(a7)             | put sbase on stack
     344                jsr     _vputs                  | update the screen
     345                add.l   #14,a7                  | clean up stack
     346                bset    #4,_vrcw+1              | set video reset type bit
     347                tst.w   _ctrsw                  | update center for scupd ?
     348                beq     dsexit                  | done if not
     349
     350dsbgn0:         move.l  _gdfsep,d0              | quit if no elements left
     351                beq     dsexit                  | ...
     352
     353                movea.l d0,a1                   | a1 = gdsp
     354                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     355                move.w  #48,d2                  | d2 = event PRIORITY | 4
     356                movea.l P_SL(a6),a2             | a2 points at gdstb
     357                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     358                move.w  #0x1111,G_NOTE(a1)      | gdsp->note = COLOR
     359                move.w  #0,G_CODE(a1)           | gdsp->code = PATTERN
     360                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     361                bra     dsexit                  | done
     362
     363                .page
     364
     365| dssend -- display section end
     366| ------    -------------------
     367dssend:         tst.w   P_CF(a6)                | center update ?
     368                beq     dssend0                 | jump if not
     369
     370                tst.w   _ctrsw                  | update center for scupd ?
     371                beq     dsexit                  | done if not
     372
     373dssend0:        move.l  _gdfsep,d0              | quit if no elements left
     374                beq     dsexit                  | ...
     375
     376                movea.l d0,a1                   | a1 = gdsp
     377                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     378                move.w  #48,d2                  | d2 = event PRIORITY | 4
     379                movea.l P_SL(a6),a2             | a2 points at gdstb
     380                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     381                move.w  #0x1111,G_NOTE(a1)      | gdsp->note = COLOR
     382                move.w  #2,G_CODE(a1)           | gdsp->code = PATTERN
     383                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     384                bra     dsexit                  | done
     385
     386| dsbeat -- display beat
     387| ------    ------------
     388dsbeat:         tst.w   P_CF(a6)                | center update ?
     389                bne     dsexit                  | done if so
     390
     391                move.l  _gdfsep,d0              | quit if no elements left
     392                beq     dsexit                  | ...
     393
     394                movea.l d0,a1                   | a1 = gdsp
     395                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     396                move.w  #48,d2                  | d2 = event PRIORITY | 4
     397                movea.l P_SL(a6),a2             | a2 points at gdstb
     398                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     399                move.w  #0x1111,G_NOTE(a1)      | gdsp->note = COLOR
     400                move.w  #1,G_CODE(a1)           | gdsp->code = PATTERN
     401                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     402                bra     dsexit                  | done
     403
     404                .page
     405
     406| dstune -- display tuning
     407| ------    --------------
     408dstune:         tst.w   P_CF(a6)                | center update ?
     409                beq     dstune0                 | jump if not
     410
     411                clr.w   d1                      | get current tuning
     412                move.b  E_DATA1(a0),d1          | ...
     413                add.w   #0x0030,d1              | add '0' for ASCII conversion
     414                move.w  #AT05,-(a7)             | put attribute on stack
     415                move.w  d1,-(a7)                | put character on stack
     416                move.w  #19,-(a7)               | put column on stack
     417                move.w  #1,-(a7)                | put row on stack
     418                move.l  _obj8,-(a7)             | put sbase on stack
     419                jsr     _vputc                  | display character
     420                add.l   #12,a7                  | clean up stack
     421                bset    #1,_vrcw+1              | set video reset type bit
     422                tst.w   _ctrsw                  | update center for scupd ?
     423                beq     dsexit                  | done if not
     424
     425dstune0:        move.l  _gdfsep,d0              | quit if no elements left
     426                beq     dsexit                  | ...
     427
     428                movea.l d0,a1                   | a1 = gdsp
     429                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     430                move.w  #52,d2                  | d2 = event PRIORITY | 4
     431                movea.l P_SL(a6),a2             | a2 points at gdstb
     432                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     433                move.w  #0xCCCC,G_NOTE(a1)      | gdsp->note = COLOR
     434                move.w  #3,G_CODE(a1)           | gdsp->code = PATTERN
     435                move.l  a1,0(a2,d2.W)           | gdstb[priority] = gdsp
     436                bra     dsexit                  | done
     437
     438                .page
     439
     440| dstrns -- display transposition
     441| ------    ---------------------
     442dstrns:         clr.w   d0                      | get group number
     443                move.b  E_DATA1(a0),d0          | ... in d0
     444                add.w   d0,d0                   | ... as a word offset
     445                lea     _grpstat,a1             | check grpstat[grp]
     446                tst.w   0(a1,d0.W)              | ...
     447                beq     dsexit                  | done if not enabled
     448
     449                tst.w   P_CF(a6)                | center update
     450                beq     dstrns0                 | jump if not
     451
     452                move.w  E_LFT(a0),d1            | get transposition value
     453                bpl     dstrns1                 | jump if positive
     454
     455                move.b  #'-',numstr             | note negative sign
     456                neg.w   d1                      | make number positive
     457                bra     dstrns2                 | ...
     458
     459dstrns1:        move.b  #'+',numstr             | note positive sign
     460
     461dstrns2:        cmpi.w  #1000,d1                | is number GE 1000 ?
     462                bcs     dstrns3                 | jump if not
     463
     464                subi.w  #1000,d1                | adjust number
     465                cmpi.b  #'-',numstr             | was number negative
     466                bne     dstrns4                 | jump if not
     467
     468                move.b  #SP_M1,numstr           | set -1 in numstr
     469                bra     dstrns3                 | ...
     470
     471dstrns4:        move.b  #SP_P1,numstr           | set +1 in numstr
     472
     473dstrns3:        ext.l   d1                      | make d1 a long
     474                divu    #100,d1                 | convert 1st digit
     475                addi.w  #0x0030,d1              | ... to ASCII
     476                move.b  d1,numstr+1             | ... in numstr
     477                swap    d1                      | convert 2nd digit
     478                ext.l   d1                      | ...
     479                divu    #10,d1                  | ...
     480                addi.w  #0x0030,d1              | ... to ASCII
     481                move.b  d1,numstr+2             | ... in numstr
     482                swap    d1                      | convert 3rd digit
     483                addi.w  #0x0030,d1              | ... to ASCII
     484                move.b  d1,numstr+3             | ... in numstr
     485                clr.b   numstr+4                | terminate numstr
     486
     487                .page
     488
     489                move.w  d0,d1                   | get group number
     490                asr.w   #1,d1                   | ... in d1
     491                move.w  d1,-(a7)                | save group number on stack
     492                add.w   d0,d0                   | calculate column
     493                add.w   d0,d1                   | ... = 5 | group
     494                addi.w  #5,d1                   | ... + 5
     495                move.w  #AT11,-(a7)             | vputs(obj8, 3, col, numstr, atr11)
     496                move.l  #numstr,-(a7)           | ...
     497                move.w  d1,-(a7)                | ...
     498                move.w  #3,-(a7)                | ...
     499                move.l  _obj8,-(a7)             | ...
     500                jsr     _vputs                  | ...
     501                add.l   #14,a7                  | ...
     502                move.w  (a7)+,d0                | get group number
     503                cmpi.w  #8,d0                   | see which byte it's in
     504                bcc     dstrns5                 | jump if in MS byte
     505
     506                bset    d0,_vrbw09+1            | set group bit in LS byte
     507                bra     dstrns6                 | ...
     508
     509dstrns5:        sub.w   #8,d0                   | adjust for byte
     510                bset    d0,_vrbw09              | set group bit in MS byte
     511
     512dstrns6:        bset    #1,_vrcw                | set video reset type bit
     513                tst.w   _ctrsw                  | update center for scupd ?
     514                beq     dsexit                  | done if not
     515
     516dstrns0:        move.l  _gdfsep,d0              | quit if no elements left
     517                beq     dsexit                  | ...
     518
     519                movea.l d0,a1                   | a1 = gdsp
     520                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     521                move.w  #52,d2                  | d2 = event PRIORITY | 4
     522                movea.l P_SL(a6),a2             | a2 points at gdstb
     523                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     524                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     525                move.w  #4,G_CODE(a1)           | gdsp->code = PATTERN
     526                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     527                bra     dsexit                  | done
     528
     529                .page
     530
     531| dsdyn -- display dynamics
     532| -----    ----------------
     533dsdyn:          clr.w   d0                      | get group number
     534                move.b  E_DATA1(a0),d0          | ... in d0
     535                add.w   d0,d0                   | ... as a word offset
     536                lea     _grpstat,a1             | check grpstat[grp]
     537                tst.w   0(a1,d0.W)              | ...
     538                beq     dsexit                  | done if not enabled
     539
     540                tst.w   P_CF(a6)                | center update ?
     541                beq     dsdyn00                 | jump if not
     542
     543                clr.w   d0                      | get dynamics
     544                move.b  E_DATA2(a0),d0          | ... in d0
     545                move.w  d0,-(a7)                | save dyanmics
     546                clr.w   d1                      | get group number
     547                move.b  E_DATA1(a0),d1          | ... in d1
     548                move.w  d1,-(a7)                | save group number
     549                move.w  (a7),d0                 | col = group number
     550                add.w   d0,d0                   | ... | 5
     551                add.w   d0,d0                   | ...
     552                move.w  (a7)+,d2                | ...  (d2 = group number)
     553                add.w   d2,d0                   | ...
     554                add.w   #6,d0                   | ... + 6
     555                move.w  (a7)+,d1                | get dynamics
     556                add.w   #0x0030,d1              | add '0' for ASCII conversion
     557                move.w  d2,-(a7)                | save group number
     558                move.w  #AT11,-(a7)             | put attribute on stack
     559                move.w  d1,-(a7)                | put digit on stack
     560                move.w  d0,-(a7)                | put column on stack
     561                move.w  #4,-(a7)                | put row on stack
     562                move.l  _obj8,-(a7)             | put object address on stack
     563                jsr     _vputc                  | update the screen
     564                add.l   #12,a7                  | clean up stack
     565                move.w  (a7)+,d0                | get group number
     566                cmp.w   #8,d0                   | see which word it's in
     567                bcc     dsdyn1                  | jump if in MS word
     568
     569                bset    d0,_vrbw10+1            | set group bit in LS byte
     570                bra     dsdyn2                  | ...
     571
     572dsdyn1:         sub.w   #8,d0                   | adjust for for byte
     573                bset    d0,_vrbw10              | set group bit in MS byte
     574
     575dsdyn2:         bset    #2,_vrcw                | set video reset type bit
     576                tst.w   _ctrsw                  | update center for scupd ?
     577                beq     dsexit                  | done if not
     578
     579                .page
     580dsdyn00:        move.l  _gdfsep,d0              | quit if no elements left
     581                beq     dsexit                  | ...
     582
     583                movea.l d0,a1                   | a1 = gdsp
     584                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     585                move.w  #52,d2                  | d2 = event PRIORITY | 4
     586                movea.l P_SL(a6),a2             | a2 points at gdstb
     587                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     588                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     589                move.w  #5,G_CODE(a1)           | gdsp->code = PATTERN
     590                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     591                bra     dsexit                  | done
     592
     593                .page
     594
     595| dslocn -- display location
     596| ------    ----------------
     597dslocn:         clr.w   d0                      | get group number
     598                move.b  E_DATA1(a0),d0          | ... in d0
     599                add.w   d0,d0                   | ... as a word offset
     600                lea     _grpstat,a1             | check grpstat[grp]
     601                tst.w   0(a1,d0.W)              | ...
     602                beq     dsexit                  | done if not enabled
     603
     604                tst.w   P_CF(a6)                | center update ?
     605                beq     dsloc00                 | jump if not
     606
     607                clr.w   d0                      | get location
     608                move.b  E_DATA2(a0),d0          | ... in d0
     609                move.w  d0,-(a7)                | save location
     610                clr.w   d1                      | get group number
     611                move.b  E_DATA1(a0),d1          | ... in d1
     612                move.w  d1,-(a7)                | save group number
     613                move.w  (a7),d0                 | col = group number
     614                add.w   d0,d0                   | ... | 5
     615                add.w   d0,d0                   | ...
     616                move.w  (a7)+,d2                | ...  (d2 = group number)
     617                add.w   d2,d0                   | ...
     618                add.w   #8,d0                   | ... + 8
     619                move.w  (a7)+,d1                | get location
     620                add.w   #0x0031,d1              | add '0' for ASCII conversion
     621                move.w  d2,-(a7)                | save group number
     622                move.w  #AT11,-(a7)             | put attribute on stack
     623                move.w  d1,-(a7)                | put character on stack
     624                move.w  d0,-(a7)                | put column on stack
     625                move.w  #4,-(a7)                | put row on stack
     626                move.l  _obj8,-(a7)             | put object address on stack
     627                jsr     _vputc                  | update the screen
     628                add.l   #12,a7                  | clean up stack
     629                move.w  (a7)+,d0                | get group number
     630                cmp.w   #8,d0                   | see which word it's in
     631                bcc     dslocn1                 | jump if in MS word
     632
     633                bset    d0,_vrbw11+1            | set group bit in LS byte
     634                bra     dslocn2                 | ...
     635
     636dslocn1:        sub.w   #8,d0                   | adjust for for byte
     637                bset    d0,_vrbw11              | set group bit in MS byte
     638
     639dslocn2:        bset    #3,_vrcw                | set video reset type bit
     640                tst.w   _ctrsw                  | update center for scupd ?
     641                beq     dsexit                  | done if not
     642
     643                .page
     644dsloc00:        move.l  _gdfsep,d0              | quit if no elements left
     645                beq     dsexit                  | ...
     646
     647                movea.l d0,a1                   | a1 = gdsp
     648                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     649                move.w  #52,d2                  | d2 = event PRIORITY | 4
     650                movea.l P_SL(a6),a2             | a2 points at gdstb
     651                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     652                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     653                move.w  #5,G_CODE(a1)           | gdsp->code = PATTERN
     654                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     655                bra     dsexit                  | done
     656
     657                .page
     658
     659| dsanrs -- display analog resolution
     660| ------    -------------------------
     661dsanrs:         move.b  E_DATA1(a0),d1          | get var / group
     662                move.w  d1,d0                   | extract group number
     663                andi.w  #0x000F,d0              | ... in d0
     664                add.w   d0,d0                   | ... as a word offset
     665                lea     _grpstat,a1             | check grpstat[grp]
     666                tst.w   0(a1,d0.W)              | ...
     667                beq     dsexit                  | done if not enabled
     668
     669                tst.w   P_CF(a6)                | center update ?
     670                beq     dsanrs0                 | jump if not
     671
     672                move.w  _angroup,d2             | see if we display
     673                bmi     dsexit                  | jump if not
     674
     675                subq.w  #1,d2                   | adust selected group number
     676                move.w  d1,d0                   | extract group from event
     677                andi.w  #0x000F,d0              | ...
     678                cmp.w   d0,d2                   | see if we display
     679                bne     dsexit                  | jump if not
     680
     681                lsr.w   #4,d1                   | extract variable number
     682                andi.w  #0x000F,d1              | ...
     683                move.w  d1,-(a7)                | save variable number
     684                move.w  d1,d0                   | calculate display offset
     685                lsl.w   #3,d0                   | ... (var | 9) + 6
     686                add.w   d0,d1                   | ... in d1
     687                addq.w  #6,d1                   | ...
     688                move.b  E_DATA2(a0),d0          | get resolution
     689                addi.w  #0x0030,d0              | convert for display
     690                move.w  #AT12,-(a7)             | put attribute on stack
     691                move.w  d0,-(a7)                | put character on stack
     692                move.w  d1,-(a7)                | put column on stack
     693                move.w  #7,-(a7)                | put row on stack
     694                move.l  _obj8,-(a7)             | put sbase on stack
     695                jsr     _vputc                  | update the screen
     696                add.l   #12,a7                  | clean up stack
     697                move.w  (a7)+,d0                | get variable number
     698                bset    d0,_vrbw13+1            | set variable bit
     699                bset    #5,_vrcw                | set video reset type bit
     700                tst.w   _ctrsw                  | update center for scupd ?
     701                beq     dsexit                  | done if not
     702
     703                .page
     704dsanrs0:        move.l  _gdfsep,d0              | quit if no elements left
     705                beq     dsexit                  | ...
     706
     707                movea.l d0,a1                   | a1 = gdsp
     708                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     709                move.w  #52,d2                  | d2 = event PRIORITY | 4
     710                movea.l P_SL(a6),a2             | a2 points at gdstb
     711                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     712                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     713                move.w  #6,G_CODE(a1)           | gdsp->code = PATTERN
     714                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     715                bra     dsexit                  | done
     716
     717                .page
     718
     719| dsanvl -- display analog value
     720| ------    --------------------
     721dsanvl:         move.w  _angroup,d2             | see if we display
     722                bmi     dsexit                  | jump if not
     723
     724                move.b  E_DATA1(a0),d1          | get var / group
     725                move.w  d1,d0                   | extract group number
     726                andi.w  #0x000F,d0              | ... in d0
     727                add.w   d0,d0                   | ... as a word offset
     728                lea     _grpstat,a1             | check grpstat[grp]
     729                tst.w   0(a1,d0.W)              | ...
     730                beq     dsexit                  | done if not enabled
     731
     732                tst.w   P_CF(a6)                | center update ?
     733                beq     dsanvl0                 | jump if not
     734
     735                subq.w  #1,d2                   | adust group number
     736                move.w  d1,d0                   | extract group
     737                andi.w  #0x000F,d0              | ...
     738                cmp.w   d0,d2                   | see if we display
     739                bne     dsexit                  | jump if not
     740
     741                lsr.w   #4,d1                   | extract variable number
     742                andi.w  #0x000F,d1              | ...
     743                move.w  d1,-(a7)                | save variable number
     744                move.w  d1,d0                   | calculate display offset
     745                lsl.w   #3,d0                   | ... (var | 9) + 8
     746                add.w   d0,d1                   | ... in d1
     747                addi.w  #8,d1                   | ...
     748                move.w  E_DN(a0),d0             | get value
     749                asr.w   #5,d0                   | adjust to low 11 bits
     750                bpl     dsanvl1                 | jump if positive
     751
     752                move.b  #'-',numstr             | set sign = '-'
     753                neg.w   d0                      | make value positive
    754754                bra     dsanvl2
    755 *
    756 dsanvl1:        move.b  #'+',numstr             * set sign = '+'
    757 *
    758                 .page
    759 dsanvl2:        ext.l   d0                      * convert MS digit
    760                 divu    #1000,d0                * ...
    761                 add.w   #$0030,d0               * ...
    762                 move.b  d0,numstr+1             * ...
    763                 swap    d0                      * convert middle digit
    764                 ext.l   d0                      * ...
    765                 divu    #100,d0                 * ...
    766                 add.w   #$0030,d0               * ...
    767                 move.b  d0,numstr+2             * ...
    768                 move.b  #'.',numstr+3           * insert decimal point
    769                 swap    d0                      * convert LS digit
    770                 ext.l   d0                      * ...
    771                 divu    #10,d0                  * ...
    772                 add.w   #$0030,d0               * ...
    773                 move.b  d0,numstr+4             * ...
    774                 clr.b   numstr+5                * terminate string
    775                 move.w  #AT12,-(a7)             * put attribute on stack
    776                 move.l  #numstr,-(a7)           * put buffer address on stack
    777                 move.w  d1,-(a7)                * put column on stack
    778                 move.w  #7,-(a7)                * put row on stack
    779                 move.l  _obj8,-(a7)             * put sbase on stack
    780                 jsr     _vputs                  * update the screen
    781                 add.l   #14,a7                  * clean up stack
    782                 move.w  (a7)+,d0                * get variable number
    783                 bset    d0,_vrbw14+1            * set variable bit
    784                 bset    #6,_vrcw                * set video reset type bit
    785                 tst.w   _ctrsw                  * update center for scupd ?
    786                 beq     dsexit                  * done if not
    787 *
    788 dsanvl0:        move.l  _gdfsep,d0              * quit if no elements left
    789                 beq     dsexit                  * ...
    790 *
    791                 movea.l d0,a1                   * a1 = gdsp
    792                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    793                 move.w  #52,d2                  * d2 = event PRIORITY * 4
    794                 movea.l P_SL(a6),a2             * a2 points at gdstb
    795                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    796                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    797                 move.w  #6,G_CODE(a1)           * gdsp->code = PATTERN
    798                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    799                 bra     dsexit                  * done
    800 *
    801                 .page
    802 *
    803 * dsasgn -- display assignment
    804 * ------    ------------------
    805 dsasgn:         tst.w   P_CF(a6)                * center update ?
    806                 beq     dsasgn0                 * jump if not
    807 *
    808                 move.l  a0,-(a7)                * stash a0
    809                 jsr     _mpcupd                 * update changed stuff
    810                 movea.l (a7)+,a0                * restore a0
    811                 clr.w   d1                      * get assignment
    812                 move.b  E_DATA1(a0),d1          * ... from the event
    813                 ext.l   d1                      * ... as a long in d1
    814                 divu    #10,d1                  * divide by 10 for conversion
    815                 add.l   #$00300030,d1           * add '0' for ASCII conversion
    816                 move.b  d1,numstr               * put MS byte in work area
    817                 swap    d1                      * swap register halves
    818                 move.b  d1,numstr+1             * put LS byte in work area
    819                 clr.b   numstr+2                * terminate string
    820                 move.w  #AT04,-(a7)             * put attribute on stack
    821                 move.l  #numstr,-(a7)           * put buffer address on stack
    822                 move.w  #11,-(a7)               * put column on stack
    823                 move.w  #1,-(a7)                * put row on stack
    824                 move.l  _obj8,-(a7)             * put sbase on stack
    825                 jsr     _vputs                  * update the screen
    826                 add.l   #14,a7                  * clean up stack
    827                 bset    #0,_vrcw+1              * set video reset type bit
    828                 tst.w   _ctrsw                  * update center for scupd ?
    829                 beq     dsexit                  * done if not
    830 *
    831 dsasgn0:        move.l  _gdfsep,d0              * quit if no elements left
    832                 beq     dsexit                  * ...
    833 *
    834                 movea.l d0,a1                   * a1 = gdsp
    835                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    836                 move.w  #56,d2                  * d2 = event PRIORITY * 4
    837                 movea.l P_SL(a6),a2             * a2 points at gdstb
    838                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    839                 move.w  #$3333,G_NOTE(a1)       * gdsp->note = COLOR
    840                 move.w  #3,G_CODE(a1)           * gdsp->code = PATTERN
    841                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    842                 bra     dsexit                  * done
    843 *
    844                 .page
    845 *
    846 * dstmpo -- display tempo
    847 * ------    -------------
    848 dstmpo:         tst.w   P_CF(a6)                * center update ?
    849                 beq     dstmpo0                 * jump if not
    850 *
    851                 clr.w   d1                      * get tempo
    852                 move.b  E_DATA1(a0),d1          * ... from event
    853                 ext.l   d1                      * ... as a long in d1
    854                 divu    #10,d1                  * divide by 10 for conversion
    855                 swap    d1                      * swap register halves
    856                 add.w   #$0030,d1               * add '0' for ASCII conversion
    857                 move.b  d1,numstr+2             * put LS byte in work area
    858                 swap    d1                      * swap register halves
    859                 ext.l   d1                      * divide again
    860                 divu    #10,d1                  * ...
    861                 add.l   #$00300030,d1           * add '0' for ASCII conversion
    862                 move.b  d1,numstr               * put MS byte in work area
    863                 swap    d1                      * swap register halves
    864                 move.b  d1,numstr+1             * put middle byte in work area
    865                 clr.b   numstr+3                * terminate string
    866                 move.w  #AT06,-(a7)             * put attribute on stack
    867                 move.l  #numstr,-(a7)           * put buffer address on stack
    868                 move.w  #27,-(a7)               * put column on stack
    869                 move.w  #1,-(a7)                * put row on stack
    870                 move.l  _obj8,-(a7)             * put sbase on stack
    871                 jsr     _vputs                  * display tempo
    872                 add.l   #14,a7                  * clean up stack
    873                 bset    #2,_vrcw+1              * set video reset type bit
    874                 tst.w   _ctrsw                  * update center for scupd ?
    875                 beq     dsexit                  * done if not
    876 *
    877 dstmpo0:        move.l  _gdfsep,d0              * quit if no elements left
    878                 beq     dsexit                  * ...
    879 *
    880                 movea.l d0,a1                   * a1 = gdsp
    881                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    882                 move.w  #56,d2                  * d2 = event PRIORITY * 4
    883                 movea.l P_SL(a6),a2             * a2 points at gdstb
    884                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    885                 move.w  #$3333,G_NOTE(a1)       * gdsp->note = COLOR
    886                 move.w  #4,G_CODE(a1)           * gdsp->code = PATTERN
    887                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    888                 bra     dsexit                  * done
    889 *
    890                 .page
    891 *
    892 * dsstop -- display stop
    893 * ------    ------------
    894 dsstop:         tst.w   P_CF(a6)                * center update ?
    895                 beq     dsstop0                 * jump if not
    896 *
    897                 jsr     _dclkmd                 * show that clock is stopped
    898                 move.w  #AT08,-(a7)             * put attribute on stack
    899                 move.w  #40,-(a7)               * put 1st column on stack
    900                 move.w  #1,-(a7)                * put row on stack
    901                 move.l  _obj8,-(a7)             * put sbase on stack
    902                 jsr     _vputa                  * hilite first column
    903                 move.w  #41,COL(a7)             * put 2nd column on stack
    904                 jsr     _vputa                  * hilite second column
    905                 move.w  #42,COL(a7)             * put 3rd column on stack
    906                 jsr     _vputa                  * hilite third column
    907                 move.w  #43,COL(a7)             * put 4th column on stack
    908                 jsr     _vputa                  * hilite fourth column
    909                 add.l   #10,a7                  * clean up stack
    910                 bset    #7,_vrcw                * set video reset type bits
    911                 bset    #0,_vrbw15              * ...
    912                 tst.w   _ctrsw                  * update center for scupd ?
    913                 beq     dsexit                  * done if not
    914 *
    915 dsstop0:        move.l  _gdfsep,d0              * quit if no elements left
    916                 beq     dsexit                  * ...
    917 *
    918                 movea.l d0,a1                   * a1 = gdsp
    919                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    920                 move.w  #56,d2                  * d2 = event PRIORITY * 4
    921                 movea.l P_SL(a6),a2             * a2 points at gdstb
    922                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    923                 move.w  #$3333,G_NOTE(a1)       * gdsp->note = COLOR
    924                 move.w  #5,G_CODE(a1)           * gdsp->code = PATTERN
    925                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    926                 bra     dsexit                  * done
    927 *
    928                 .page
    929 *
    930 * dsnext -- display next
    931 * ------    ------------
    932 dsnext:         tst.w   P_CF(a6)                * center update ?
    933                 beq     dsnext0                 * jump if not
    934 *
    935                 move.w  #AT08,-(a7)             * put attribute on stack
    936                 move.w  #45,-(a7)               * put 1st column on stack
    937                 move.w  #1,-(a7)                * put row on stack
    938                 move.l  _obj8,-(a7)             * put sbase on stack
    939                 jsr     _vputa                  * hilite first column
    940                 move.w  #46,COL(a7)             * put 2nd column on stack
    941                 jsr     _vputa                  * hilite second column
    942                 move.w  #47,COL(a7)             * put 3rd column on stack
    943                 jsr     _vputa                  * hilite third column
    944                 move.w  #48,COL(a7)             * put 4th column on stack
    945                 jsr     _vputa                  * hilite fourth column
    946                 add.l   #10,a7                  * clean up stack
    947                 bset    #7,_vrcw                * set video reset type bits
    948                 bset    #1,_vrbw15              * ...
    949                 tst.w   _ctrsw                  * update center for scupd ?
    950                 beq     dsexit                  * done if not
    951 *
    952 dsnext0:        move.l  _gdfsep,d0              * quit if no elements left
    953                 beq     dsexit                  * ...
    954 *
    955                 movea.l d0,a1                   * a1 = gdsp
    956                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    957                 move.w  #56,d2                  * d2 = event PRIORITY * 4
    958                 movea.l P_SL(a6),a2             * a2 points at gdstb
    959                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    960                 move.w  #$3333,G_NOTE(a1)       * gdsp->note = COLOR
    961                 move.w  #5,G_CODE(a1)           * gdsp->code = PATTERN
    962                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    963                 bra     dsexit                  * done
    964 *
    965                 .page
    966 *
    967 * dsgrp -- display group status
    968 * -----    --------------------
    969 dsgrp:          tst.w   P_CF(a6)                * center update ?
    970                 beq     dsgrp0                  * jump if not
    971 *
    972                 tst.w   _ctrsw                  * update center for scupd ?
    973                 beq     dsexit                  * done if not
    974 *
    975 dsgrp0:         move.l  _gdfsep,d0              * quit if no elements left
    976                 beq     dsexit                  * ...
    977 *
    978                 movea.l d0,a1                   * a1 = gdsp
    979                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    980                 move.w  #60,d2                  * d2 = event PRIORITY * 4
    981                 movea.l P_SL(a6),a2             * a2 points at gdstb
    982                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    983                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    984                 move.w  #3,G_CODE(a1)           * gdsp->code = PATTERN
    985                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    986                 bra     dsexit                  * done
    987 *
    988                 .page
    989 *
    990 * dsinst -- display instrument
    991 * ------    ------------------
    992 dsinst:         clr.w   d0                      * get group number
    993                 move.b  E_DATA1(a0),d0          * ... in d0
    994                 add.w   d0,d0                   * ... as a word offset
    995                 lea     _grpstat,a1             * check grpstat[grp]
    996                 tst.w   0(a1,d0.W)              * ...
    997                 beq     dsexit                  * done if not enabled
    998 *
    999                 tst.w   P_CF(a6)                * center update ?
    1000                 beq     dsins00                 * jump if not
    1001 *
    1002                 lea     _ins2grp,a1             * point at ins2grp[]
    1003                 clr.w   d0                      * get instrument number
    1004                 move.b  E_DATA2(a0),d0          * ... in d0
    1005                 move.w  d0,-(a7)                * save instrument number
    1006                 clr.w   d1                      * get group number
    1007                 move.b  E_DATA1(a0),d1          * ... in d1
    1008                 move.w  d1,-(a7)                * save group number
    1009                 move.w  (a7),d0                 * col = group number
    1010                 add.w   d0,d0                   * ... * 5
    1011                 add.w   d0,d0                   * ...
    1012                 move.w  (a7)+,d2                * ...  (d2 = group number)
    1013                 add.w   d2,d0                   * ...
    1014                 add.w   #7,d0                   * ... + 7
    1015                 clr.l   d1                      * get instrument number
    1016                 move.w  (a7)+,d1                * ... as a long in d1
    1017                 divu    #10,d1                  * divide by 10 for conversion
    1018                 add.l   #$00300030,d1           * add '0' for ASCII conversion
    1019                 move.b  d1,numstr               * put MS byte in work area
    1020                 swap    d1                      * swap register halves
    1021                 move.b  d1,numstr+1             * put LS byte in work area
    1022                 clr.b   numstr+2                * terminate string
    1023                 move.w  d2,-(a7)                * save group number
    1024                 move.w  #AT11,-(a7)             * put attribute on stack
    1025                 move.l  #numstr,-(a7)           * put buffer address on stack
    1026                 move.w  d0,-(a7)                * put column on stack
    1027                 move.w  #2,-(a7)                * put row on stack
    1028                 move.l  _obj8,-(a7)             * put object address on stack
    1029                 jsr     _vputs                  * update the screen
    1030                 add.l   #14,a7                  * clean up stack
    1031 *
    1032                 .page
    1033                 move.w  (a7)+,d0                * get group number
    1034                 cmp.w   #8,d0                   * see which word it's in
    1035                 bcc     dsinst1                 * jump if in MS word
    1036 *
    1037                 bset    d0,_vrbw08+1            * set group bit in LS byte
    1038                 bra     dsinst2                 * ...
    1039 *
    1040 dsinst1:        sub.w   #8,d0                   * adjust for for byte
    1041                 bset    d0,_vrbw08              * set group bit in MS byte
    1042 *
    1043 dsinst2:        bset    #0,_vrcw                * set video reset type bit
    1044                 tst.w   _ctrsw                  * update center for scupd ?
    1045                 beq     dsexit                  * done if not
    1046 *
    1047 dsins00:        move.l  _gdfsep,d0              * quit if no elements left
    1048                 beq     dsexit                  * ...
    1049 *
    1050                 movea.l d0,a1                   * a1 = gdsp
    1051                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    1052                 move.w  #60,d2                  * d2 = event PRIORITY * 4
    1053                 movea.l P_SL(a6),a2             * a2 points at gdstb
    1054                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    1055                 move.w  #$9999,G_NOTE(a1)       * gdsp->note = COLOR
    1056                 move.w  #3,G_CODE(a1)           * gdsp->code = PATTERN
    1057                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    1058                 bra     dsexit                  * done
    1059 *
    1060                 .page
    1061 *
    1062 * dsintp -- display interpolation
    1063 * ------    ---------------------
    1064 dsintp:         tst.w   P_CF(a6)                * center update ?
    1065                 beq     dsintp0                 * jump if not
    1066 *
    1067                 move.w  E_DATA1(a0),-(a7)       * get interpolate value
    1068                 jsr     _fromfpu                * convert to milliseconds
    1069                 tst.w   (a7)+                   * ...
    1070                 andi.l  #$0000FFFF,d0           * clear high bits
    1071                 divu    #10000,d0               * convert 1st digit
    1072                 addi.w  #$0030,d0               * ... to ASCII
    1073                 move.b  d0,numstr               * ... in numstr
    1074                 swap    d0                      * convert 2nd digit
    1075                 ext.l   d0                      * ...
    1076                 divu    #1000,d0                * ...
    1077                 addi.w  #$0030,d0               * ... to ASCII
    1078                 move.b  d0,numstr+1             * ... in numstr
    1079                 move.b  #'.',numstr+2           * insert decimal point
    1080                 swap    d0                      * convert 3rd digit
    1081                 ext.l   d0                      * ...
    1082                 divu    #100,d0                 * ...
    1083                 addi.w  #$0030,d0               * ... to ASCII
    1084                 move.b  d0,numstr+3             * ... in numstr
    1085                 clr.b   numstr+4                * terminate numstr
    1086                 move.w  #AT07,-(a7)             * vputs(obj8, 1, 35, numstr, AT07)
    1087                 move.l  #numstr,-(a7)           * ...
    1088                 move.w  #35,-(a7)               * ...
    1089                 move.w  #1,-(a7)                * ...
    1090                 move.l  _obj8,-(a7)             * ...
    1091                 jsr     _vputs                  * ...
    1092                 add.l   #14,a7                  * ...
    1093                 bset    #3,_vrcw+1              * set video reset bit
    1094                 tst.w   _ctrsw                  * update center for scupd ?
    1095                 beq     dsexit                  * done if not
    1096 *
    1097 dsintp0:        move.l  _gdfsep,d0              * quit if no elements left
    1098                 beq     dsexit                  * ...
    1099 *
    1100                 movea.l d0,a1                   * a1 = gdsp
    1101                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    1102                 move.w  #60,d2                  * d2 = event PRIORITY * 4
    1103                 movea.l P_SL(a6),a2             * a2 points at gdstb
    1104                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    1105                 move.w  #$CCCC,G_NOTE(a1)       * gdsp->note = COLOR
    1106                 move.w  #4,G_CODE(a1)           * gdsp->code = PATTERN
    1107                 move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    1108                 bra     dsexit                  * done
    1109 *
    1110                 .page
    1111 *
    1112 * dspnch -- display punch in/out
    1113 * ------    --------------------
    1114 dspnch:         tst.w   P_CF(a6)                * center update ?
    1115                 beq     dspnch0                 * jump if not
    1116 *
    1117                 tst.w   E_DATA1(a0)             * punch in ?
    1118                 beq     dspnch1                 * jump if not
    1119 *
    1120                 move.w  #AT09,-(a7)             * put attribute on stack
    1121                 move.w  #50,-(a7)               * put 1st col on stack
    1122                 move.w  #1,-(a7)                * put row on stack
    1123                 move.l  _obj8,-(a7)             * put object address on stack
    1124                 jsr     _vputa                  * highlight 1st column
    1125                 move.w  #51,COL(a7)             * put 2nd col on stack
    1126                 jsr     _vputa                  * highlight 2nd col
    1127                 add.l   #10,a7                  * clean up stack
    1128                 bset    #5,_vrcw+1              * set video reset bit
    1129                 bra     dspnch2                 * go do maker update
    1130 *
    1131 dspnch1:        move.w  #AT09,-(a7)             * put attribute on stack
    1132                 move.w  #53,-(a7)               * put 1st col on stack
    1133                 move.w  #1,-(a7)                * put row on stack
    1134                 move.l  _obj8,-(a7)             * put object address on stack
    1135                 jsr     _vputa                  * highlight 1st column
    1136                 move.w  #54,COL(a7)             * put 2nd col on stack
    1137                 jsr     _vputa                  * highlight 2nd column
    1138                 move.w  #55,COL(a7)             * put 3rd col on stack
    1139                 jsr     _vputa                  * highlight 3rd column
    1140                 add.l   #10,a7                  * clean up stack
    1141                 bset    #6,_vrcw+1              * set video reset bit
    1142 *
    1143 dspnch2:        jsr     _dsgmodz                * display updated modes
    1144                 tst.w   _ctrsw                  * update center for scupd ?
    1145                 beq     dsexit                  * done if not
    1146 *
    1147 dspnch0:        move.l  _gdfsep,d0              * quit if no elements left
    1148                 beq     dsexit                  * ...
    1149 *
    1150                 movea.l d0,a1                   * a1 = gdsp
    1151                 move.l  G_NEXT(a1),_gdfsep      * gdfsep = gdsp->next
    1152                 move.w  #60,d2                  * d2 = event PRIORITY * 4
    1153                 movea.l P_SL(a6),a2             * a2 points at gdstb
    1154                 move.l  0(a2,d2.W),G_NEXT(a1)   * gdsp->next = gdstb[pri]
    1155                 move.w  #$CCCC,G_NOTE(a1)       * gdsp->note = COLOR
    1156                 tst.w   E_DATA1(a0)             * see which kind we have
    1157                 bne     dspnchi                 * jump if 'punch in'
    1158 *
    1159                 move.w  #6,G_CODE(a1)           * gdsp->code = 'out' PATTERN
     755
     756dsanvl1:        move.b  #'+',numstr             | set sign = '+'
     757
     758                .page
     759dsanvl2:        ext.l   d0                      | convert MS digit
     760                divu    #1000,d0                | ...
     761                add.w   #0x0030,d0              | ...
     762                move.b  d0,numstr+1             | ...
     763                swap    d0                      | convert middle digit
     764                ext.l   d0                      | ...
     765                divu    #100,d0                 | ...
     766                add.w   #0x0030,d0              | ...
     767                move.b  d0,numstr+2             | ...
     768                move.b  #'.',numstr+3           | insert decimal point
     769                swap    d0                      | convert LS digit
     770                ext.l   d0                      | ...
     771                divu    #10,d0                  | ...
     772                add.w   #0x0030,d0              | ...
     773                move.b  d0,numstr+4             | ...
     774                clr.b   numstr+5                | terminate string
     775                move.w  #AT12,-(a7)             | put attribute on stack
     776                move.l  #numstr,-(a7)           | put buffer address on stack
     777                move.w  d1,-(a7)                | put column on stack
     778                move.w  #7,-(a7)                | put row on stack
     779                move.l  _obj8,-(a7)             | put sbase on stack
     780                jsr     _vputs                  | update the screen
     781                add.l   #14,a7                  | clean up stack
     782                move.w  (a7)+,d0                | get variable number
     783                bset    d0,_vrbw14+1            | set variable bit
     784                bset    #6,_vrcw                | set video reset type bit
     785                tst.w   _ctrsw                  | update center for scupd ?
     786                beq     dsexit                  | done if not
     787
     788dsanvl0:        move.l  _gdfsep,d0              | quit if no elements left
     789                beq     dsexit                  | ...
     790
     791                movea.l d0,a1                   | a1 = gdsp
     792                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     793                move.w  #52,d2                  | d2 = event PRIORITY | 4
     794                movea.l P_SL(a6),a2             | a2 points at gdstb
     795                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     796                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     797                move.w  #6,G_CODE(a1)           | gdsp->code = PATTERN
     798                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     799                bra     dsexit                  | done
     800
     801                .page
     802
     803| dsasgn -- display assignment
     804| ------    ------------------
     805dsasgn:         tst.w   P_CF(a6)                | center update ?
     806                beq     dsasgn0                 | jump if not
     807
     808                move.l  a0,-(a7)                | stash a0
     809                jsr     _mpcupd                 | update changed stuff
     810                movea.l (a7)+,a0                | restore a0
     811                clr.w   d1                      | get assignment
     812                move.b  E_DATA1(a0),d1          | ... from the event
     813                ext.l   d1                      | ... as a long in d1
     814                divu    #10,d1                  | divide by 10 for conversion
     815                add.l   #0x00300030,d1          | add '0' for ASCII conversion
     816                move.b  d1,numstr               | put MS byte in work area
     817                swap    d1                      | swap register halves
     818                move.b  d1,numstr+1             | put LS byte in work area
     819                clr.b   numstr+2                | terminate string
     820                move.w  #AT04,-(a7)             | put attribute on stack
     821                move.l  #numstr,-(a7)           | put buffer address on stack
     822                move.w  #11,-(a7)               | put column on stack
     823                move.w  #1,-(a7)                | put row on stack
     824                move.l  _obj8,-(a7)             | put sbase on stack
     825                jsr     _vputs                  | update the screen
     826                add.l   #14,a7                  | clean up stack
     827                bset    #0,_vrcw+1              | set video reset type bit
     828                tst.w   _ctrsw                  | update center for scupd ?
     829                beq     dsexit                  | done if not
     830
     831dsasgn0:        move.l  _gdfsep,d0              | quit if no elements left
     832                beq     dsexit                  | ...
     833
     834                movea.l d0,a1                   | a1 = gdsp
     835                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     836                move.w  #56,d2                  | d2 = event PRIORITY | 4
     837                movea.l P_SL(a6),a2             | a2 points at gdstb
     838                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     839                move.w  #0x3333,G_NOTE(a1)      | gdsp->note = COLOR
     840                move.w  #3,G_CODE(a1)           | gdsp->code = PATTERN
     841                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     842                bra     dsexit                  | done
     843
     844                .page
     845
     846| dstmpo -- display tempo
     847| ------    -------------
     848dstmpo:         tst.w   P_CF(a6)                | center update ?
     849                beq     dstmpo0                 | jump if not
     850
     851                clr.w   d1                      | get tempo
     852                move.b  E_DATA1(a0),d1          | ... from event
     853                ext.l   d1                      | ... as a long in d1
     854                divu    #10,d1                  | divide by 10 for conversion
     855                swap    d1                      | swap register halves
     856                add.w   #0x0030,d1              | add '0' for ASCII conversion
     857                move.b  d1,numstr+2             | put LS byte in work area
     858                swap    d1                      | swap register halves
     859                ext.l   d1                      | divide again
     860                divu    #10,d1                  | ...
     861                add.l   #0x00300030,d1          | add '0' for ASCII conversion
     862                move.b  d1,numstr               | put MS byte in work area
     863                swap    d1                      | swap register halves
     864                move.b  d1,numstr+1             | put middle byte in work area
     865                clr.b   numstr+3                | terminate string
     866                move.w  #AT06,-(a7)             | put attribute on stack
     867                move.l  #numstr,-(a7)           | put buffer address on stack
     868                move.w  #27,-(a7)               | put column on stack
     869                move.w  #1,-(a7)                | put row on stack
     870                move.l  _obj8,-(a7)             | put sbase on stack
     871                jsr     _vputs                  | display tempo
     872                add.l   #14,a7                  | clean up stack
     873                bset    #2,_vrcw+1              | set video reset type bit
     874                tst.w   _ctrsw                  | update center for scupd ?
     875                beq     dsexit                  | done if not
     876
     877dstmpo0:        move.l  _gdfsep,d0              | quit if no elements left
     878                beq     dsexit                  | ...
     879
     880                movea.l d0,a1                   | a1 = gdsp
     881                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     882                move.w  #56,d2                  | d2 = event PRIORITY | 4
     883                movea.l P_SL(a6),a2             | a2 points at gdstb
     884                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     885                move.w  #0x3333,G_NOTE(a1)      | gdsp->note = COLOR
     886                move.w  #4,G_CODE(a1)           | gdsp->code = PATTERN
     887                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     888                bra     dsexit                  | done
     889
     890                .page
     891
     892| dsstop -- display stop
     893| ------    ------------
     894dsstop:         tst.w   P_CF(a6)                | center update ?
     895                beq     dsstop0                 | jump if not
     896
     897                jsr     _dclkmd                 | show that clock is stopped
     898                move.w  #AT08,-(a7)             | put attribute on stack
     899                move.w  #40,-(a7)               | put 1st column on stack
     900                move.w  #1,-(a7)                | put row on stack
     901                move.l  _obj8,-(a7)             | put sbase on stack
     902                jsr     _vputa                  | hilite first column
     903                move.w  #41,COL(a7)             | put 2nd column on stack
     904                jsr     _vputa                  | hilite second column
     905                move.w  #42,COL(a7)             | put 3rd column on stack
     906                jsr     _vputa                  | hilite third column
     907                move.w  #43,COL(a7)             | put 4th column on stack
     908                jsr     _vputa                  | hilite fourth column
     909                add.l   #10,a7                  | clean up stack
     910                bset    #7,_vrcw                | set video reset type bits
     911                bset    #0,_vrbw15              | ...
     912                tst.w   _ctrsw                  | update center for scupd ?
     913                beq     dsexit                  | done if not
     914
     915dsstop0:        move.l  _gdfsep,d0              | quit if no elements left
     916                beq     dsexit                  | ...
     917
     918                movea.l d0,a1                   | a1 = gdsp
     919                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     920                move.w  #56,d2                  | d2 = event PRIORITY | 4
     921                movea.l P_SL(a6),a2             | a2 points at gdstb
     922                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     923                move.w  #0x3333,G_NOTE(a1)      | gdsp->note = COLOR
     924                move.w  #5,G_CODE(a1)           | gdsp->code = PATTERN
     925                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     926                bra     dsexit                  | done
     927
     928                .page
     929
     930| dsnext -- display next
     931| ------    ------------
     932dsnext:         tst.w   P_CF(a6)                | center update ?
     933                beq     dsnext0                 | jump if not
     934
     935                move.w  #AT08,-(a7)             | put attribute on stack
     936                move.w  #45,-(a7)               | put 1st column on stack
     937                move.w  #1,-(a7)                | put row on stack
     938                move.l  _obj8,-(a7)             | put sbase on stack
     939                jsr     _vputa                  | hilite first column
     940                move.w  #46,COL(a7)             | put 2nd column on stack
     941                jsr     _vputa                  | hilite second column
     942                move.w  #47,COL(a7)             | put 3rd column on stack
     943                jsr     _vputa                  | hilite third column
     944                move.w  #48,COL(a7)             | put 4th column on stack
     945                jsr     _vputa                  | hilite fourth column
     946                add.l   #10,a7                  | clean up stack
     947                bset    #7,_vrcw                | set video reset type bits
     948                bset    #1,_vrbw15              | ...
     949                tst.w   _ctrsw                  | update center for scupd ?
     950                beq     dsexit                  | done if not
     951
     952dsnext0:        move.l  _gdfsep,d0              | quit if no elements left
     953                beq     dsexit                  | ...
     954
     955                movea.l d0,a1                   | a1 = gdsp
     956                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     957                move.w  #56,d2                  | d2 = event PRIORITY | 4
     958                movea.l P_SL(a6),a2             | a2 points at gdstb
     959                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     960                move.w  #0x3333,G_NOTE(a1)      | gdsp->note = COLOR
     961                move.w  #5,G_CODE(a1)           | gdsp->code = PATTERN
     962                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     963                bra     dsexit                  | done
     964
     965                .page
     966
     967| dsgrp -- display group status
     968| -----    --------------------
     969dsgrp:          tst.w   P_CF(a6)                | center update ?
     970                beq     dsgrp0                  | jump if not
     971
     972                tst.w   _ctrsw                  | update center for scupd ?
     973                beq     dsexit                  | done if not
     974
     975dsgrp0:         move.l  _gdfsep,d0              | quit if no elements left
     976                beq     dsexit                  | ...
     977
     978                movea.l d0,a1                   | a1 = gdsp
     979                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     980                move.w  #60,d2                  | d2 = event PRIORITY | 4
     981                movea.l P_SL(a6),a2             | a2 points at gdstb
     982                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     983                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     984                move.w  #3,G_CODE(a1)           | gdsp->code = PATTERN
     985                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     986                bra     dsexit                  | done
     987
     988                .page
     989
     990| dsinst -- display instrument
     991| ------    ------------------
     992dsinst:         clr.w   d0                      | get group number
     993                move.b  E_DATA1(a0),d0          | ... in d0
     994                add.w   d0,d0                   | ... as a word offset
     995                lea     _grpstat,a1             | check grpstat[grp]
     996                tst.w   0(a1,d0.W)              | ...
     997                beq     dsexit                  | done if not enabled
     998
     999                tst.w   P_CF(a6)                | center update ?
     1000                beq     dsins00                 | jump if not
     1001
     1002                lea     _ins2grp,a1             | point at ins2grp[]
     1003                clr.w   d0                      | get instrument number
     1004                move.b  E_DATA2(a0),d0          | ... in d0
     1005                move.w  d0,-(a7)                | save instrument number
     1006                clr.w   d1                      | get group number
     1007                move.b  E_DATA1(a0),d1          | ... in d1
     1008                move.w  d1,-(a7)                | save group number
     1009                move.w  (a7),d0                 | col = group number
     1010                add.w   d0,d0                   | ... | 5
     1011                add.w   d0,d0                   | ...
     1012                move.w  (a7)+,d2                | ...  (d2 = group number)
     1013                add.w   d2,d0                   | ...
     1014                add.w   #7,d0                   | ... + 7
     1015                clr.l   d1                      | get instrument number
     1016                move.w  (a7)+,d1                | ... as a long in d1
     1017                divu    #10,d1                  | divide by 10 for conversion
     1018                add.l   #0x00300030,d1          | add '0' for ASCII conversion
     1019                move.b  d1,numstr               | put MS byte in work area
     1020                swap    d1                      | swap register halves
     1021                move.b  d1,numstr+1             | put LS byte in work area
     1022                clr.b   numstr+2                | terminate string
     1023                move.w  d2,-(a7)                | save group number
     1024                move.w  #AT11,-(a7)             | put attribute on stack
     1025                move.l  #numstr,-(a7)           | put buffer address on stack
     1026                move.w  d0,-(a7)                | put column on stack
     1027                move.w  #2,-(a7)                | put row on stack
     1028                move.l  _obj8,-(a7)             | put object address on stack
     1029                jsr     _vputs                  | update the screen
     1030                add.l   #14,a7                  | clean up stack
     1031
     1032                .page
     1033                move.w  (a7)+,d0                | get group number
     1034                cmp.w   #8,d0                   | see which word it's in
     1035                bcc     dsinst1                 | jump if in MS word
     1036
     1037                bset    d0,_vrbw08+1            | set group bit in LS byte
     1038                bra     dsinst2                 | ...
     1039
     1040dsinst1:        sub.w   #8,d0                   | adjust for for byte
     1041                bset    d0,_vrbw08              | set group bit in MS byte
     1042
     1043dsinst2:        bset    #0,_vrcw                | set video reset type bit
     1044                tst.w   _ctrsw                  | update center for scupd ?
     1045                beq     dsexit                  | done if not
     1046
     1047dsins00:        move.l  _gdfsep,d0              | quit if no elements left
     1048                beq     dsexit                  | ...
     1049
     1050                movea.l d0,a1                   | a1 = gdsp
     1051                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     1052                move.w  #60,d2                  | d2 = event PRIORITY | 4
     1053                movea.l P_SL(a6),a2             | a2 points at gdstb
     1054                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     1055                move.w  #0x9999,G_NOTE(a1)      | gdsp->note = COLOR
     1056                move.w  #3,G_CODE(a1)           | gdsp->code = PATTERN
     1057                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     1058                bra     dsexit                  | done
     1059
     1060                .page
     1061
     1062| dsintp -- display interpolation
     1063| ------    ---------------------
     1064dsintp:         tst.w   P_CF(a6)                | center update ?
     1065                beq     dsintp0                 | jump if not
     1066
     1067                move.w  E_DATA1(a0),-(a7)       | get interpolate value
     1068                jsr     _fromfpu                | convert to milliseconds
     1069                tst.w   (a7)+                   | ...
     1070                andi.l  #0x0000FFFF,d0          | clear high bits
     1071                divu    #10000,d0               | convert 1st digit
     1072                addi.w  #0x0030,d0              | ... to ASCII
     1073                move.b  d0,numstr               | ... in numstr
     1074                swap    d0                      | convert 2nd digit
     1075                ext.l   d0                      | ...
     1076                divu    #1000,d0                | ...
     1077                addi.w  #0x0030,d0              | ... to ASCII
     1078                move.b  d0,numstr+1             | ... in numstr
     1079                move.b  #'.',numstr+2           | insert decimal point
     1080                swap    d0                      | convert 3rd digit
     1081                ext.l   d0                      | ...
     1082                divu    #100,d0                 | ...
     1083                addi.w  #0x0030,d0              | ... to ASCII
     1084                move.b  d0,numstr+3             | ... in numstr
     1085                clr.b   numstr+4                | terminate numstr
     1086                move.w  #AT07,-(a7)             | vputs(obj8, 1, 35, numstr, AT07)
     1087                move.l  #numstr,-(a7)           | ...
     1088                move.w  #35,-(a7)               | ...
     1089                move.w  #1,-(a7)                | ...
     1090                move.l  _obj8,-(a7)             | ...
     1091                jsr     _vputs                  | ...
     1092                add.l   #14,a7                  | ...
     1093                bset    #3,_vrcw+1              | set video reset bit
     1094                tst.w   _ctrsw                  | update center for scupd ?
     1095                beq     dsexit                  | done if not
     1096
     1097dsintp0:        move.l  _gdfsep,d0              | quit if no elements left
     1098                beq     dsexit                  | ...
     1099
     1100                movea.l d0,a1                   | a1 = gdsp
     1101                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     1102                move.w  #60,d2                  | d2 = event PRIORITY | 4
     1103                movea.l P_SL(a6),a2             | a2 points at gdstb
     1104                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     1105                move.w  #0xCCCC,G_NOTE(a1)      | gdsp->note = COLOR
     1106                move.w  #4,G_CODE(a1)           | gdsp->code = PATTERN
     1107                move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     1108                bra     dsexit                  | done
     1109
     1110                .page
     1111
     1112| dspnch -- display punch in/out
     1113| ------    --------------------
     1114dspnch:         tst.w   P_CF(a6)                | center update ?
     1115                beq     dspnch0                 | jump if not
     1116
     1117                tst.w   E_DATA1(a0)             | punch in ?
     1118                beq     dspnch1                 | jump if not
     1119
     1120                move.w  #AT09,-(a7)             | put attribute on stack
     1121                move.w  #50,-(a7)               | put 1st col on stack
     1122                move.w  #1,-(a7)                | put row on stack
     1123                move.l  _obj8,-(a7)             | put object address on stack
     1124                jsr     _vputa                  | highlight 1st column
     1125                move.w  #51,COL(a7)             | put 2nd col on stack
     1126                jsr     _vputa                  | highlight 2nd col
     1127                add.l   #10,a7                  | clean up stack
     1128                bset    #5,_vrcw+1              | set video reset bit
     1129                bra     dspnch2                 | go do maker update
     1130
     1131dspnch1:        move.w  #AT09,-(a7)             | put attribute on stack
     1132                move.w  #53,-(a7)               | put 1st col on stack
     1133                move.w  #1,-(a7)                | put row on stack
     1134                move.l  _obj8,-(a7)             | put object address on stack
     1135                jsr     _vputa                  | highlight 1st column
     1136                move.w  #54,COL(a7)             | put 2nd col on stack
     1137                jsr     _vputa                  | highlight 2nd column
     1138                move.w  #55,COL(a7)             | put 3rd col on stack
     1139                jsr     _vputa                  | highlight 3rd column
     1140                add.l   #10,a7                  | clean up stack
     1141                bset    #6,_vrcw+1              | set video reset bit
     1142
     1143dspnch2:        jsr     _dsgmodz                | display updated modes
     1144                tst.w   _ctrsw                  | update center for scupd ?
     1145                beq     dsexit                  | done if not
     1146
     1147dspnch0:        move.l  _gdfsep,d0              | quit if no elements left
     1148                beq     dsexit                  | ...
     1149
     1150                movea.l d0,a1                   | a1 = gdsp
     1151                move.l  G_NEXT(a1),_gdfsep      | gdfsep = gdsp->next
     1152                move.w  #60,d2                  | d2 = event PRIORITY | 4
     1153                movea.l P_SL(a6),a2             | a2 points at gdstb
     1154                move.l  0(a2,d2.W),G_NEXT(a1)   | gdsp->next = gdstb[pri]
     1155                move.w  #0xCCCC,G_NOTE(a1)      | gdsp->note = COLOR
     1156                tst.w   E_DATA1(a0)             | see which kind we have
     1157                bne     dspnchi                 | jump if 'punch in'
     1158
     1159                move.w  #6,G_CODE(a1)           | gdsp->code = 'out' PATTERN
    11601160                bra     dspnchx
    1161 *
    1162 dspnchi:        move.w  #5,G_CODE(a1)           * gdsp->code = 'in' PATTERN
    1163 *
    1164 dspnchx:        move.l  a1,0(a2,d2.W)           * gdstb[pri] = gdsp
    1165                 bra     dsexit                  * done
    1166 *
    1167                 .page
    1168 *
    1169 * dsbar -- display a bar marker
    1170 * -----    --------------------
    1171 dsbar:          tst.w   P_CF(a6)                * center update ?
    1172                 beq     dsbar0                  * jump if not
    1173 *
    1174                 tst.w   _ctrsw                  * update center for scupd ?
    1175                 beq     dsexit                  * done if not
    1176 *
    1177 dsbar0:         movea.l P_SL(a6),a2             * a2 points at gdstb
    1178                 move.l  #-1,BARFLAG(a2)         * set the bar marker flag
    1179                 bra     dsexit                  * done
    1180 *
    1181                 .page
    1182 *
    1183 * ==============================================================================
     1161
     1162dspnchi:        move.w  #5,G_CODE(a1)           | gdsp->code = 'in' PATTERN
     1163
     1164dspnchx:        move.l  a1,0(a2,d2.W)           | gdstb[pri] = gdsp
     1165                bra     dsexit                  | done
     1166
     1167                .page
     1168
     1169| dsbar -- display a bar marker
     1170| -----    --------------------
     1171dsbar:          tst.w   P_CF(a6)                | center update ?
     1172                beq     dsbar0                  | jump if not
     1173
     1174                tst.w   _ctrsw                  | update center for scupd ?
     1175                beq     dsexit                  | done if not
     1176
     1177dsbar0:         movea.l P_SL(a6),a2             | a2 points at gdstb
     1178                move.l  #-1,BARFLAG(a2)         | set the bar marker flag
     1179                bra     dsexit                  | done
     1180
     1181                .page
     1182
     1183| ==============================================================================
    11841184                .data
    1185 * ==============================================================================
    1186 *
    1187 * sddtab -- score display dispatch table -- MUST match score.h definitions
    1188 * ------    ----------------------------    ------------------------------
    1189 sddtab:         dc.l    dsexit          * 0     null
    1190                 dc.l    dsexit          * 1     score begin
    1191                 dc.l    dssbgn          * 2     section begin
    1192                 dc.l    dssend          * 3     section end
    1193                 dc.l    dsinst          * 4     instrument change
    1194                 dc.l    dsnbx           * 5     note begin
    1195                 dc.l    dsnex           * 6     note end
    1196                 dc.l    dsstop          * 7     stop
    1197                 dc.l    dsintp          * 8     interpolate
    1198                 dc.l    dstmpo          * 9     tempo
    1199                 dc.l    dstune          * 10    tuning
    1200                 dc.l    dsgrp           * 11    group status
    1201                 dc.l    dslocn          * 12    location
    1202                 dc.l    dsdyn           * 13    dynamics
    1203                 dc.l    dsanvl          * 14    analog value
    1204                 dc.l    dsanrs          * 15    analog resolution
    1205                 dc.l    dsasgn          * 16    I/O assign
    1206                 dc.l    dstrns          * 17    transposition
    1207                 dc.l    dsexit          * 18    repeat
    1208                 dc.l    dspnch          * 19    punch in/out
    1209                 dc.l    dsexit          * 20    polyphonic pressure
    1210                 dc.l    dsexit          * 21    score end
    1211                 dc.l    dsexit          * 22    channel pressure
    1212                 dc.l    dsbar           * 23    bar marker
    1213                 dc.l    dsnext          * 24    next score
    1214 *
    1215 * ==============================================================================
     1185| ==============================================================================
     1186
     1187| sddtab -- score display dispatch table -- MUST match score.h definitions
     1188| ------    ----------------------------    ------------------------------
     1189sddtab:         dc.l    dsexit          | 0     null
     1190                dc.l    dsexit          | 1     score begin
     1191                dc.l    dssbgn          | 2     section begin
     1192                dc.l    dssend          | 3     section end
     1193                dc.l    dsinst          | 4     instrument change
     1194                dc.l    dsnbx           | 5     note begin
     1195                dc.l    dsnex           | 6     note end
     1196                dc.l    dsstop          | 7     stop
     1197                dc.l    dsintp          | 8     interpolate
     1198                dc.l    dstmpo          | 9     tempo
     1199                dc.l    dstune          | 10    tuning
     1200                dc.l    dsgrp           | 11    group status
     1201                dc.l    dslocn          | 12    location
     1202                dc.l    dsdyn           | 13    dynamics
     1203                dc.l    dsanvl          | 14    analog value
     1204                dc.l    dsanrs          | 15    analog resolution
     1205                dc.l    dsasgn          | 16    I/O assign
     1206                dc.l    dstrns          | 17    transposition
     1207                dc.l    dsexit          | 18    repeat
     1208                dc.l    dspnch          | 19    punch in/out
     1209                dc.l    dsexit          | 20    polyphonic pressure
     1210                dc.l    dsexit          | 21    score end
     1211                dc.l    dsexit          | 22    channel pressure
     1212                dc.l    dsbar           | 23    bar marker
     1213                dc.l    dsnext          | 24    next score
     1214
     1215| ==============================================================================
    12161216                .bss
    1217 * ==============================================================================
    1218 *
    1219 * globals:
    1220 * --------
    1221 _ac_code:       ds.b    1               * accidental code
    1222 *
    1223 * locals:
    1224 * -------
    1225 numstr:         ds.b    65              * video display update work area
    1226 *
    1227 * ------------------------------------------------------------------------------
    1228 *
     1217| ==============================================================================
     1218
     1219| globals:
     1220| --------
     1221_ac_code:       ds.b    1               | accidental code
     1222
     1223| locals:
     1224| -------
     1225numstr:         ds.b    65              | video display update work area
     1226
     1227| ------------------------------------------------------------------------------
     1228
    12291229                .end

  • ram/seexec.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * seexec.s -- score event execution driver
    3 * Version 40 -- 1988-10-06 -- D.N. Lynx Crowe
    4 *
    5 *       struct s_entry *
    6 *       se_exec(ep, sd)
    7 *       struct s_entry *ep;
    8 *       short sd;
    9 *
    10 *               Executes the event at 'ep', scrolling in direction 'sd'.
    11 *
    12 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| seexec.s -- score event execution driver
     3| Version 40 -- 1988-10-06 -- D.N. Lynx Crowe
     4
     5|       struct s_entry |
     6|       se_exec(ep, sd)
     7|       struct s_entry |ep;
     8|       short sd;
     9
     10|               Executes the event at 'ep', scrolling in direction 'sd'.
     11
     12| ------------------------------------------------------------------------------
    1313                .text
    14 *
     14
    1515                .xdef   _se_exec
    16 *
     16
    1717                .xdef   BadEvnt
    18 *
     18
    1919                .xdef   _xevent
    20 *
     20
    2121                .xref   _asgvce
    2222                .xref   _clkset
    … …  
    3131                .xref   _settune
    3232                .xref   _setv2gi
    33 *
     33
    3434                .xref   _anrs
    3535                .xref   _var2src
    … …  
    4848                .xref   _vce2trg
    4949                .xref   _veltab
    50 *
    51                 .page
    52 *
    53 * parameter offsets
    54 * -----------------
    55 P_EP            .equ    8               * WORD - 'ep' parameter offset
    56 P_SD            .equ    12              * WORD - 'sd' parameter offset
    57 *
    58 * event structure offsets -- MUST match score.h definitions
    59 * -----------------------    ------------------------------
    60 *                     offset             length
    61 *                     ------             ------
    62 E_TIME          .equ    0               * LONG
    63 E_SIZE          .equ    4               * BYTE
    64 E_TYPE          .equ    5               * BYTE
    65 E_DATA1         .equ    6               * BYTE
    66 E_NOTE          .equ    6               * BYTE
    67 E_DATA2         .equ    7               * BYTE
    68 E_GROUP         .equ    7               * BYTE
    69 E_BAK           .equ    8               * LONG
    70 E_FWD           .equ    12              * LONG
    71 E_DN            .equ    16              * LONG
    72 E_VEL           .equ    16              * WORD
    73 E_DATA4         .equ    18              * WORD
    74 E_UP            .equ    20              * LONG
    75 E_LFT           .equ    24              * LONG
    76 E_RGT           .equ    28              * LONG
    77 *
    78 * Miscellaneous constants
    79 * -----------------------
    80 N_ETYPES        .equ    25              * number of event types
    81 *
    82 M_KSTATE        .equ    $01             * keys status bit
    83 N_KSTATE        .equ    $FE             * keys status bit complement
    84 *
    85 D_BAK           .equ    1               * code for backward scrolling
    86 *
    87 LCL_PRT         .equ    2               * 0-origin local port number
    88 LCL_PCH         .equ    $1080           * port and channel for trigger
    89 *
    90                 .page
    91 *
    92 * A few words about se_exec:
    93 *
    94 * se_exec has to be very fast, so it's written in assembly language,
    95 * rather than C, which is usually pretty good, but not quite good enough
    96 * for this application.  The faster this routine runs, the higher the
    97 * tempo we can keep up with.  If this code is fast enough, we end up
    98 * hardware limited by the timer.
    99 *
    100 _se_exec:       link    a6,#0                   * link stack frames
    101                 movea.l P_EP(a6),a0             * get event pointer 'ep' into a0
    102                 move.l  a0,_xevent              * save in xevent
    103                 move.b  E_TYPE(a0),d1           * get event type into d1.W
    104                 andi.w  #$007F,d1               * ... and mask off new-data flag
    105                 cmp.b   #N_ETYPES,d1            * see if it's valid
    106                 blt     sexc1                   * jump if it is
    107 *
    108 BadEvnt:        move.l  a0,d0                   * setup to return pointer we got
    109                 bra     done                    * exit
    110 *
    111 exexit:         movea.l _xevent,a0              * point at next event
    112                 move.l  E_FWD(a0),d0            * ...
    113 *
    114 done:           unlk    a6                      * done -- unlink stack frames
    115                 rts                             * return to caller
    116 *
    117 sexc1:          lea     sextab,a1               * get base of dispatch table
    118                 lsl.w   #2,d1                   * multiplty event by 4 for index
    119                 movea.l 0(a1,d1.W),a2           * get address of event routine
    120                 jmp     (a2)                    * jump to event execution routine
    121 *
    122 * On entry, the individual execution routines only depend on a0 pointing at the
    123 * event they were dispatched for.
    124 *
    125 * The usual C function register usage conventions apply:
    126 *
    127 * d0..d2 and a0..a2 are used for scratch, and are not preserved.
    128 *
    129 * d3..d6 and a3..a5 are register variables, and are preserved.
    130 * a6 = frame pointer, a7 = stack pointer, and are preserved.
    131 *
    132                 .page
    133 *
    134 * exnbeg -- execute note begin
    135 * ------    ------------------
    136 * If things need to be sped up, we could incorporate the functions of
    137 * asgvce() here, rather than calling it.  asgvce() could also be re-written in
    138 * assembly language to make it a shade faster.
    139 *
    140 exnbeg:         cmpi.w  #D_BAK,P_SD(a6)         * check direction
    141                 beq     nendex                  * if backward, treat as note end
    142 *
    143 nbegex:         clr.w   d1                      * clear d1
    144                 move.b  E_GROUP(a0),d1          * get group number
    145                 add.w   d1,d1                   * ... * 2
    146                 lea     _grpstat,a1             * point at grpstat
    147                 tst.w   0(a1,d1.W)              * see if group is enabled
    148                 beq     exexit                  * done if not
    149 *
    150                 move.b  E_NOTE(a0),d1           * d1 = note number nn (0..127)
    151                 move.w  #LCL_PCH,d2             * put port and channel in d2
    152                 add.w   d1,d2                   * d2 = trg
    153                 lea     _trgtab,a1              * point at trgtab[trg]
    154                 move.b  0(a1,d2.W),d0           * ...
    155                 or.b    #M_KSTATE,d0            * set trigger table entry on
    156                 move.b  d0,0(a1,d2.W)           * ...
    157                 lea     _veltab,a1              * point at veltab
    158                 add.w   d2,d2                   * ...
    159                 move.w  E_VEL(a0),0(a1,d2.W)    * put velocity in veltab
    160                 move.w  E_VEL(a0),-(a7)         * put velocity on the stack
    161                 move.w  d1,-(a7)                * put note number on the stack
    162                 move.w  #1,-(a7)                * put channel on the stack
    163                 move.w  #LCL_PRT,-(a7)          * put port on the stack
    164                 move.b  E_GROUP(a0),d1          * d1 = group number  (0..11)
    165                 move.w  d1,-(a7)                * put group number on the stack
    166                 jsr     _asgvce                 * start the note
    167                 add.l   #10,a7                  * clean up the stack           
    168                 bra     exexit                  * done
    169 *
    170                 .page
    171 *
    172 * exnend -- execute note end
    173 * ------    ----------------
    174 * If things need to be sped up, we could incorporate the functions of
    175 * procpfl() here, rather than calling it.  procpfl() could also be re-written in
    176 * assembly language to make it a shade faster.
    177 *
    178 exnend:         cmpi.w  #D_BAK,P_SD(a6)         * check direction
    179                 beq     nbegex                  * if backward, treat as beginning
    180 *
    181 nendex:         clr.w   d1                      * clear d1
    182                 move.b  E_GROUP(a0),d1          * get group number
    183                 add.w   d1,d1                   * ... * 2
    184                 lea     _grpstat,a1             * point at grpstat
    185                 tst.w   0(a1,d1.W)              * check group status
    186                 beq     exexit                  * done if disabled
    187 *
    188                 move.b  E_NOTE(a0),d1           * d1 = note number nn (0..127)
    189                 move.w  #LCL_PCH,d2             * put port and channel in d2
    190                 add.w   d1,d2                   * d2 = trg * 2
    191                 add.w   d2,d2                   * ...
    192                 lea     _trgtab,a1              * set trigger table entry off
    193                 move.b  0(a1,d2.W),d0           * ...
    194                 and.b   #N_KSTATE,d0            * ...
    195                 move.b  d0,0(a1,d2.W)           * ...
    196                 bne     exexit                  * done if note still active
    197 *
    198                 .page
    199 *
    200                 lsr.w   #1,d2                   * adjust d2
    201                 clr.w   d1                      * set loop index
    202                 lea     _vce2trg,a2             * point at vce2trg table
    203 *
    204 exnend1:        cmp.w   (a2),d2                 * see if this voice uses trg
    205                 bne     exnend2                 * jump if not
    206 *
    207                 move.w  #-1,(a2)                * set entry to -1
    208                 move.l  a2,-(a7)                * save a2 on stack
    209                 move.w  d1,-(a7)                * save d1 on stack
    210                 move.w  d2,-(a7)                * save d2 on stack
    211                 lea     _vce2grp,a1             * put group on stack
    212                 move.w  d1,d0                   * ...
    213                 add.w   d0,d0                   * ...
    214                 move.w  0(a1,d0.W),-(a7)        * ...
    215                 move.w  d2,-(a7)                * put trg on stack
    216                 jsr     _procpfl                * process sustained voices
    217                 addq.l  #4,a7                   * clean up stack
    218                 move.w  (a7)+,d2                * restore d2
    219                 move.w  (a7)+,d1                * restore d1
    220                 movea.l (a7)+,a2                * restore a2
    221 *
    222 exnend2:        addq.l  #2,a2                   * point at next vce2trg entry
    223                 addq.w  #1,d1                   * loop until all are checked
    224                 cmp.w   #12,d1                  * ...
    225                 bne     exnend1                 * ...
    226 *
    227                 bra     exexit                  * done
    228 *
    229                 .page
    230 *
    231 * exsbgn -- execute section begin
    232 * ------    ---------------------
    233 exsbgn:         clr.w   d0                      * get section number
    234                 move.b  E_DATA1(a0),d0          * ...
    235                 move.w  d0,_cursect             * set section number
    236                 bra     exexit                  * done
    237 *
    238 * exasgn -- execute assignment event
    239 * ------    ------------------------
    240 exasgn:         clr.w   d0                      * get assignment
    241                 move.b  E_DATA1(a0),d0          * ...
    242                 move.w  d0,-(a7)                * getasg(curasg = asgn)
    243                 move.w  d0,_curasg              * ...
    244                 jsr     _getasg                 * ...
    245                 tst.w   (a7)+                   * ...
    246                 bra     exexit                  * done
    247 *
    248 * extune -- execute tuning event
    249 * ------    --------------------
    250 extune:         clr.w   d0                      * get tuning
    251                 move.b  E_DATA1(a0),d0          * ...
    252                 move.w  d0,-(a7)                * gettun(tuning)
    253                 jsr     _gettun                 * ...
    254                 tst.w   (a7)+                   * ...
    255                 bra     exexit                  * done
    256 *
    257 * extrns -- execute transposition event
    258 * ------    ---------------------------
    259 extrns:         clr.w   d0                      * get group number
    260                 move.b  E_DATA1(a0),d0          * ...
    261                 add.w   d0,d0                   * ... as an index in d0
    262                 lea     _grpstat,a1             * check grpstat[grp]
    263                 tst.w   0(a1,d0.W)              * ...
    264                 beq     exexit                  * done if disabled
    265 *
    266                 lea     _s_trns,a1              * set group transposition
    267                 move.w  E_LFT(a0),0(a1,d0.W)    * ...
    268                 jsr     _settune                * ...
    269                 bra     exexit                  * done
    270 *
    271                 .page
    272 *
    273 * extmpo -- execute tempo event
    274 * ------    -------------------
    275 extmpo:         clr.w   d0                      * get tempo
    276                 move.b  E_DATA1(a0),d0          * ...
    277                 move.w  d0,-(a7)                * settmpo(tempo)
    278                 jsr     _settmpo                * ...
    279                 tst.w   (a7)+                   * ...
    280                 bra     exexit                  * done
    281 *
    282 * exstop -- execute stop event
    283 * ------    ------------------
    284 exstop:         clr.w   -(a7)                   * stop the clock
    285                 jsr     _clkset                 * ...
    286                 tst.w   (a7)+                   * ...
    287                 bra     exexit                  * that's all, folks
    288 *
    289 * exintp -- execute interpolate event
    290 * ------    -------------------------
    291 exintp:         move.w  E_DATA1(a0),_curintp    * set interpolate value
    292                 bra     exexit                  * done
    293 *
    294                 .page
    295 *
    296 * exinst -- execute instrument change event
    297 * ------    -------------------------------
    298 exinst:         clr.w   d0                      * get group number
    299                 move.b  E_DATA1(a0),d0          * ... in d0
    300                 add.w   d0,d0                   * ... as a word offset
    301                 lea     _grpstat,a1             * check grpstat[grp]
    302                 tst.w   0(a1,d0.W)              * ...
    303                 beq     exexit                  * done if not enabled
    304 *
    305                 lea     _ins2grp,a1             * point at ins2grp[]
    306                 clr.w   d0                      * get instrument number
    307                 move.b  E_DATA2(a0),d0          * ... in d0
    308                 clr.w   d1                      * get group number
    309                 move.b  E_DATA1(a0),d1          * ... in d1
    310                 move.w  d1,-(a7)                * put group number on stack
    311                 add.w   d1,d1                   * make d1 a word pointer
    312                 move.w  0(a1,d1.W),d2           * get ins2grp[group]
    313                 and.w   #$FF00,d2               * mask off GTAG1..GTAG8
    314                 or.w    d0,d2                   * OR in new instrument number
    315                 move.w  d2,0(a1,d1.W)           * set ins2grp[group]
    316                 jsr     _setv2gi                * setv2gi(group)
    317                 tst.w   (a7)+                   * clean up stack
    318                 bra     exexit                  * done
    319 *
    320                 .page
    321 *
    322 * exdyn -- execute dynamics event
    323 * -----    ----------------------
    324 exdyn:          clr.w   d0                      * get group number
    325                 move.b  E_DATA1(a0),d0          * ... in d0
    326                 add.w   d0,d0                   * ... as a word offset
    327                 lea     _grpstat,a1             * check grpstat[grp]
    328                 tst.w   0(a1,d0.W)              * ...
    329                 beq     exexit                  * done if not enabled
    330 *
    331                 clr.w   d0                      * get dynamics
    332                 move.b  E_DATA2(a0),d0          * ... in d0
    333                 clr.w   d1                      * get group number
    334                 move.b  E_DATA1(a0),d1          * ... in d1
    335                 move.w  d0,-(a7)                * setdyn(group, dyn)
    336                 move.w  d1,-(a7)                * ...
    337                 jsr     _setdyn                 * ...
    338                 adda.l  #4,a7                   * clean up stack
    339                 bra     exexit                  * done
    340 *
    341 * exlocn -- execute location event
    342 * ------    ----------------------
    343 exlocn:         clr.w   d0                      * get group number
    344                 move.b  E_DATA1(a0),d0          * ... in d0
    345                 add.w   d0,d0                   * ... as a word offset
    346                 lea     _grpstat,a1             * check grpstat[grp]
    347                 tst.w   0(a1,d0.W)              * ...
    348                 beq     exexit                  * done if not enabled
    349 *
    350                 clr.w   d0                      * get location
    351                 move.b  E_DATA2(a0),d0          * ... in d0
    352                 clr.w   d1                      * get group number
    353                 move.b  E_DATA1(a0),d1          * ... in d1
    354                 move.w  d0,-(a7)                * setloc(group, loc)
    355                 move.w  d1,-(a7)                * ...
    356                 jsr     _setloc                 * ...
    357                 adda.l  #4,a7                   * clean up stack
    358                 bra     exexit                  * done
    359 *
    360                 .page
    361 *
    362 * exanrs -- execute analog resolution event
    363 * ------    -------------------------------
    364 exanrs:         move.b  E_DATA1(a0),d0          * get group number
    365                 andi.w  #$000F,d0               * ... in d0
    366                 add.w   d0,d0                   * ... as a word offset
    367                 lea     _grpstat,a1             * check grpstat[grp]
    368                 tst.w   0(a1,d0.W)              * ...
    369                 beq     exexit                  * done if not enabled
    370 *
    371                 clr.w   d1                      * get variable / group numbers
    372                 move.b  E_DATA1(a0),d1          * ...
    373                 add.w   d1,d1                   * convert to word index
    374                 clr.w   d0                      * get resolution
    375                 move.b  E_DATA2(a0),d0          * ... in d0
    376                 lea     _anrs,a1                * point at resolution table base
    377                 move.w  d0,0(a1,d1.W)           * save resolution in table
    378                 bra     exexit                  * done
    379 *
    380 * exanvl -- execute analog value event
    381 * ------    --------------------------
    382 exanvl:         move.b  E_DATA1(a0),d0          * get group number
    383                 andi.w  #$000F,d0               * ... in d0
    384                 add.w   d0,d0                   * ... as a word offset
    385                 lea     _grpstat,a1             * check grpstat[grp]
    386                 tst.w   0(a1,d0.W)              * ...
    387                 beq     exexit                  * done if not enabled
    388 *
    389                 move.w  E_DN(a0),-(a7)          * put value on stack
    390                 clr.w   d2                      * get variable / group numbers
    391                 move.b  E_DATA1(a0),d2          * ... into d2
    392                 move.w  d2,d1                   * extract group number
    393                 andi.w  #$000F,d1               * ... into d1
    394                 lsr.w   #3,d2                   * extract variable number
    395                 andi.w  #$001E,d2               * ... as a word index in d2
    396                 lea     _var2src,a1             * point at variable map
    397                 move.w  0(a1,d2.W),-(a7)        * put source number on stack
    398                 move.w  d1,-(a7)                * put group number on stack
    399                 jsr     _setsv                  * setsv(group, src, val)
    400                 adda.l  #6,a7                   * clean up stack
    401                 bra     exexit                  * done
    402 *
    403 * exnext -- next score
    404 * ------    ----------
    405 exnext:         move.w  #1,_nxtflag             * set next score flag
    406                 bra     exexit                  * done
    407 *
    408                 .page
    409 *
    410 * expnch -- execute punch in/out
    411 * ------    --------------------
    412 expnch:         tst.w   _recsw                  * recording ?
    413                 beq     exexit                  * ignore if not
    414 *
    415                 tst.w   E_DATA1(a0)             * punch in ?
    416                 bne     expnch5                 * jump if so
    417 *
    418 * punch out
    419 *
    420                 lea     _grpmode,a1             * setup for group modes
    421                 move.w  #11,d0                  * ...
    422 *
    423 expnch0:        cmpi.w  #2,(a1)                 * in record mode ?
    424                 bne     expnch1                 * jump if not
    425 *
    426                 clr.w   (a1)                    * set to play mode
    427 *
    428 expnch1:        addq.l  #2,a1                   * point at next entry
    429                 dbra    d0,expnch0              * loop through all groups
    430 *
    431                 lea     _varmode,a1             * setup for variable modes
    432                 move.w  #5,d1                   * set variable count
    433 *
    434 expnch4:        clr.w   d0                      * clear offset
    435 *
    436 expnch2:        cmpi.w  #2,0(a1,d0.W)           * in record mode ?
    437                 bne     expnch3                 * jump if not
    438 *
    439                 clr.w   0(a1,d0.W)              * set to play mode
    440 *
    441 expnch3:        addq.w  #2,d0                   * update offset
    442                 cmpi.w  #24,d0                  * check for final group
    443                 bne     expnch2                 * loop through all groups
    444 *
    445                 add.l   #32,a1                  * point at next variable
    446                 dbra    d1,expnch4              * loop through all variables
    447 *
     50
     51                .page
     52
     53| parameter offsets
     54| -----------------
     55P_EP            =       8               | WORD - 'ep' parameter offset
     56P_SD            =       12              | WORD - 'sd' parameter offset
     57
     58| event structure offsets -- MUST match score.h definitions
     59| -----------------------    ------------------------------
     60|                     offset             length
     61|                     ------             ------
     62E_TIME          =       0               | LONG
     63E_SIZE          =       4               | BYTE
     64E_TYPE          =       5               | BYTE
     65E_DATA1         =       6               | BYTE
     66E_NOTE          =       6               | BYTE
     67E_DATA2         =       7               | BYTE
     68E_GROUP         =       7               | BYTE
     69E_BAK           =       8               | LONG
     70E_FWD           =       12              | LONG
     71E_DN            =       16              | LONG
     72E_VEL           =       16              | WORD
     73E_DATA4         =       18              | WORD
     74E_UP            =       20              | LONG
     75E_LFT           =       24              | LONG
     76E_RGT           =       28              | LONG
     77
     78| Miscellaneous constants
     79| -----------------------
     80N_ETYPES        =       25              | number of event types
     81
     82M_KSTATE        =       0x01            | keys status bit
     83N_KSTATE        =       0xFE            | keys status bit complement
     84
     85D_BAK           =       1               | code for backward scrolling
     86
     87LCL_PRT         =       2               | 0-origin local port number
     88LCL_PCH         =       0x1080          | port and channel for trigger
     89
     90                .page
     91
     92| A few words about se_exec:
     93
     94| se_exec has to be very fast, so it's written in assembly language,
     95| rather than C, which is usually pretty good, but not quite good enough
     96| for this application.  The faster this routine runs, the higher the
     97| tempo we can keep up with.  If this code is fast enough, we end up
     98| hardware limited by the timer.
     99
     100_se_exec:       link    a6,#0                   | link stack frames
     101                movea.l P_EP(a6),a0             | get event pointer 'ep' into a0
     102                move.l  a0,_xevent              | save in xevent
     103                move.b  E_TYPE(a0),d1           | get event type into d1.W
     104                andi.w  #0x007F,d1              | ... and mask off new-data flag
     105                cmp.b   #N_ETYPES,d1            | see if it's valid
     106                blt     sexc1                   | jump if it is
     107
     108BadEvnt:        move.l  a0,d0                   | setup to return pointer we got
     109                bra     done                    | exit
     110
     111exexit:         movea.l _xevent,a0              | point at next event
     112                move.l  E_FWD(a0),d0            | ...
     113
     114done:           unlk    a6                      | done -- unlink stack frames
     115                rts                             | return to caller
     116
     117sexc1:          lea     sextab,a1               | get base of dispatch table
     118                lsl.w   #2,d1                   | multiplty event by 4 for index
     119                movea.l 0(a1,d1.W),a2           | get address of event routine
     120                jmp     (a2)                    | jump to event execution routine
     121
     122| On entry, the individual execution routines only depend on a0 pointing at the
     123| event they were dispatched for.
     124
     125| The usual C function register usage conventions apply:
     126
     127| d0..d2 and a0..a2 are used for scratch, and are not preserved.
     128
     129| d3..d6 and a3..a5 are register variables, and are preserved.
     130| a6 = frame pointer, a7 = stack pointer, and are preserved.
     131
     132                .page
     133
     134| exnbeg -- execute note begin
     135| ------    ------------------
     136| If things need to be sped up, we could incorporate the functions of
     137| asgvce() here, rather than calling it.  asgvce() could also be re-written in
     138| assembly language to make it a shade faster.
     139
     140exnbeg:         cmpi.w  #D_BAK,P_SD(a6)         | check direction
     141                beq     nendex                  | if backward, treat as note end
     142
     143nbegex:         clr.w   d1                      | clear d1
     144                move.b  E_GROUP(a0),d1          | get group number
     145                add.w   d1,d1                   | ... | 2
     146                lea     _grpstat,a1             | point at grpstat
     147                tst.w   0(a1,d1.W)              | see if group is enabled
     148                beq     exexit                  | done if not
     149
     150                move.b  E_NOTE(a0),d1           | d1 = note number nn (0..127)
     151                move.w  #LCL_PCH,d2             | put port and channel in d2
     152                add.w   d1,d2                   | d2 = trg
     153                lea     _trgtab,a1              | point at trgtab[trg]
     154                move.b  0(a1,d2.W),d0           | ...
     155                or.b    #M_KSTATE,d0            | set trigger table entry on
     156                move.b  d0,0(a1,d2.W)           | ...
     157                lea     _veltab,a1              | point at veltab
     158                add.w   d2,d2                   | ...
     159                move.w  E_VEL(a0),0(a1,d2.W)    | put velocity in veltab
     160                move.w  E_VEL(a0),-(a7)         | put velocity on the stack
     161                move.w  d1,-(a7)                | put note number on the stack
     162                move.w  #1,-(a7)                | put channel on the stack
     163                move.w  #LCL_PRT,-(a7)          | put port on the stack
     164                move.b  E_GROUP(a0),d1          | d1 = group number  (0..11)
     165                move.w  d1,-(a7)                | put group number on the stack
     166                jsr     _asgvce                 | start the note
     167                add.l   #10,a7                  | clean up the stack
     168                bra     exexit                  | done
     169
     170                .page
     171
     172| exnend -- execute note end
     173| ------    ----------------
     174| If things need to be sped up, we could incorporate the functions of
     175| procpfl() here, rather than calling it.  procpfl() could also be re-written in
     176| assembly language to make it a shade faster.
     177
     178exnend:         cmpi.w  #D_BAK,P_SD(a6)         | check direction
     179                beq     nbegex                  | if backward, treat as beginning
     180
     181nendex:         clr.w   d1                      | clear d1
     182                move.b  E_GROUP(a0),d1          | get group number
     183                add.w   d1,d1                   | ... | 2
     184                lea     _grpstat,a1             | point at grpstat
     185                tst.w   0(a1,d1.W)              | check group status
     186                beq     exexit                  | done if disabled
     187
     188                move.b  E_NOTE(a0),d1           | d1 = note number nn (0..127)
     189                move.w  #LCL_PCH,d2             | put port and channel in d2
     190                add.w   d1,d2                   | d2 = trg | 2
     191                add.w   d2,d2                   | ...
     192                lea     _trgtab,a1              | set trigger table entry off
     193                move.b  0(a1,d2.W),d0           | ...
     194                and.b   #N_KSTATE,d0            | ...
     195                move.b  d0,0(a1,d2.W)           | ...
     196                bne     exexit                  | done if note still active
     197
     198                .page
     199
     200                lsr.w   #1,d2                   | adjust d2
     201                clr.w   d1                      | set loop index
     202                lea     _vce2trg,a2             | point at vce2trg table
     203
     204exnend1:        cmp.w   (a2),d2                 | see if this voice uses trg
     205                bne     exnend2                 | jump if not
     206
     207                move.w  #-1,(a2)                | set entry to -1
     208                move.l  a2,-(a7)                | save a2 on stack
     209                move.w  d1,-(a7)                | save d1 on stack
     210                move.w  d2,-(a7)                | save d2 on stack
     211                lea     _vce2grp,a1             | put group on stack
     212                move.w  d1,d0                   | ...
     213                add.w   d0,d0                   | ...
     214                move.w  0(a1,d0.W),-(a7)        | ...
     215                move.w  d2,-(a7)                | put trg on stack
     216                jsr     _procpfl                | process sustained voices
     217                addq.l  #4,a7                   | clean up stack
     218                move.w  (a7)+,d2                | restore d2
     219                move.w  (a7)+,d1                | restore d1
     220                movea.l (a7)+,a2                | restore a2
     221
     222exnend2:        addq.l  #2,a2                   | point at next vce2trg entry
     223                addq.w  #1,d1                   | loop until all are checked
     224                cmp.w   #12,d1                  | ...
     225                bne     exnend1                 | ...
     226
     227                bra     exexit                  | done
     228
     229                .page
     230
     231| exsbgn -- execute section begin
     232| ------    ---------------------
     233exsbgn:         clr.w   d0                      | get section number
     234                move.b  E_DATA1(a0),d0          | ...
     235                move.w  d0,_cursect             | set section number
     236                bra     exexit                  | done
     237
     238| exasgn -- execute assignment event
     239| ------    ------------------------
     240exasgn:         clr.w   d0                      | get assignment
     241                move.b  E_DATA1(a0),d0          | ...
     242                move.w  d0,-(a7)                | getasg(curasg = asgn)
     243                move.w  d0,_curasg              | ...
     244                jsr     _getasg                 | ...
     245                tst.w   (a7)+                   | ...
     246                bra     exexit                  | done
     247
     248| extune -- execute tuning event
     249| ------    --------------------
     250extune:         clr.w   d0                      | get tuning
     251                move.b  E_DATA1(a0),d0          | ...
     252                move.w  d0,-(a7)                | gettun(tuning)
     253                jsr     _gettun                 | ...
     254                tst.w   (a7)+                   | ...
     255                bra     exexit                  | done
     256
     257| extrns -- execute transposition event
     258| ------    ---------------------------
     259extrns:         clr.w   d0                      | get group number
     260                move.b  E_DATA1(a0),d0          | ...
     261                add.w   d0,d0                   | ... as an index in d0
     262                lea     _grpstat,a1             | check grpstat[grp]
     263                tst.w   0(a1,d0.W)              | ...
     264                beq     exexit                  | done if disabled
     265
     266                lea     _s_trns,a1              | set group transposition
     267                move.w  E_LFT(a0),0(a1,d0.W)    | ...
     268                jsr     _settune                | ...
     269                bra     exexit                  | done
     270
     271                .page
     272
     273| extmpo -- execute tempo event
     274| ------    -------------------
     275extmpo:         clr.w   d0                      | get tempo
     276                move.b  E_DATA1(a0),d0          | ...
     277                move.w  d0,-(a7)                | settmpo(tempo)
     278                jsr     _settmpo                | ...
     279                tst.w   (a7)+                   | ...
     280                bra     exexit                  | done
     281
     282| exstop -- execute stop event
     283| ------    ------------------
     284exstop:         clr.w   -(a7)                   | stop the clock
     285                jsr     _clkset                 | ...
     286                tst.w   (a7)+                   | ...
     287                bra     exexit                  | that's all, folks
     288
     289| exintp -- execute interpolate event
     290| ------    -------------------------
     291exintp:         move.w  E_DATA1(a0),_curintp    | set interpolate value
     292                bra     exexit                  | done
     293
     294                .page
     295
     296| exinst -- execute instrument change event
     297| ------    -------------------------------
     298exinst:         clr.w   d0                      | get group number
     299                move.b  E_DATA1(a0),d0          | ... in d0
     300                add.w   d0,d0                   | ... as a word offset
     301                lea     _grpstat,a1             | check grpstat[grp]
     302                tst.w   0(a1,d0.W)              | ...
     303                beq     exexit                  | done if not enabled
     304
     305                lea     _ins2grp,a1             | point at ins2grp[]
     306                clr.w   d0                      | get instrument number
     307                move.b  E_DATA2(a0),d0          | ... in d0
     308                clr.w   d1                      | get group number
     309                move.b  E_DATA1(a0),d1          | ... in d1
     310                move.w  d1,-(a7)                | put group number on stack
     311                add.w   d1,d1                   | make d1 a word pointer
     312                move.w  0(a1,d1.W),d2           | get ins2grp[group]
     313                and.w   #0xFF00,d2              | mask off GTAG1..GTAG8
     314                or.w    d0,d2                   | OR in new instrument number
     315                move.w  d2,0(a1,d1.W)           | set ins2grp[group]
     316                jsr     _setv2gi                | setv2gi(group)
     317                tst.w   (a7)+                   | clean up stack
     318                bra     exexit                  | done
     319
     320                .page
     321
     322| exdyn -- execute dynamics event
     323| -----    ----------------------
     324exdyn:          clr.w   d0                      | get group number
     325                move.b  E_DATA1(a0),d0          | ... in d0
     326                add.w   d0,d0                   | ... as a word offset
     327                lea     _grpstat,a1             | check grpstat[grp]
     328                tst.w   0(a1,d0.W)              | ...
     329                beq     exexit                  | done if not enabled
     330
     331                clr.w   d0                      | get dynamics
     332                move.b  E_DATA2(a0),d0          | ... in d0
     333                clr.w   d1                      | get group number
     334                move.b  E_DATA1(a0),d1          | ... in d1
     335                move.w  d0,-(a7)                | setdyn(group, dyn)
     336                move.w  d1,-(a7)                | ...
     337                jsr     _setdyn                 | ...
     338                adda.l  #4,a7                   | clean up stack
     339                bra     exexit                  | done
     340
     341| exlocn -- execute location event
     342| ------    ----------------------
     343exlocn:         clr.w   d0                      | get group number
     344                move.b  E_DATA1(a0),d0          | ... in d0
     345                add.w   d0,d0                   | ... as a word offset
     346                lea     _grpstat,a1             | check grpstat[grp]
     347                tst.w   0(a1,d0.W)              | ...
     348                beq     exexit                  | done if not enabled
     349
     350                clr.w   d0                      | get location
     351                move.b  E_DATA2(a0),d0          | ... in d0
     352                clr.w   d1                      | get group number
     353                move.b  E_DATA1(a0),d1          | ... in d1
     354                move.w  d0,-(a7)                | setloc(group, loc)
     355                move.w  d1,-(a7)                | ...
     356                jsr     _setloc                 | ...
     357                adda.l  #4,a7                   | clean up stack
     358                bra     exexit                  | done
     359
     360                .page
     361
     362| exanrs -- execute analog resolution event
     363| ------    -------------------------------
     364exanrs:         move.b  E_DATA1(a0),d0          | get group number
     365                andi.w  #0x000F,d0              | ... in d0
     366                add.w   d0,d0                   | ... as a word offset
     367                lea     _grpstat,a1             | check grpstat[grp]
     368                tst.w   0(a1,d0.W)              | ...
     369                beq     exexit                  | done if not enabled
     370
     371                clr.w   d1                      | get variable / group numbers
     372                move.b  E_DATA1(a0),d1          | ...
     373                add.w   d1,d1                   | convert to word index
     374                clr.w   d0                      | get resolution
     375                move.b  E_DATA2(a0),d0          | ... in d0
     376                lea     _anrs,a1                | point at resolution table base
     377                move.w  d0,0(a1,d1.W)           | save resolution in table
     378                bra     exexit                  | done
     379
     380| exanvl -- execute analog value event
     381| ------    --------------------------
     382exanvl:         move.b  E_DATA1(a0),d0          | get group number
     383                andi.w  #0x000F,d0              | ... in d0
     384                add.w   d0,d0                   | ... as a word offset
     385                lea     _grpstat,a1             | check grpstat[grp]
     386                tst.w   0(a1,d0.W)              | ...
     387                beq     exexit                  | done if not enabled
     388
     389                move.w  E_DN(a0),-(a7)          | put value on stack
     390                clr.w   d2                      | get variable / group numbers
     391                move.b  E_DATA1(a0),d2          | ... into d2
     392                move.w  d2,d1                   | extract group number
     393                andi.w  #0x000F,d1              | ... into d1
     394                lsr.w   #3,d2                   | extract variable number
     395                andi.w  #0x001E,d2              | ... as a word index in d2
     396                lea     _var2src,a1             | point at variable map
     397                move.w  0(a1,d2.W),-(a7)        | put source number on stack
     398                move.w  d1,-(a7)                | put group number on stack
     399                jsr     _setsv                  | setsv(group, src, val)
     400                adda.l  #6,a7                   | clean up stack
     401                bra     exexit                  | done
     402
     403| exnext -- next score
     404| ------    ----------
     405exnext:         move.w  #1,_nxtflag             | set next score flag
     406                bra     exexit                  | done
     407
     408                .page
     409
     410| expnch -- execute punch in/out
     411| ------    --------------------
     412expnch:         tst.w   _recsw                  | recording ?
     413                beq     exexit                  | ignore if not
     414
     415                tst.w   E_DATA1(a0)             | punch in ?
     416                bne     expnch5                 | jump if so
     417
     418| punch out
     419
     420                lea     _grpmode,a1             | setup for group modes
     421                move.w  #11,d0                  | ...
     422
     423expnch0:        cmpi.w  #2,(a1)                 | in record mode ?
     424                bne     expnch1                 | jump if not
     425
     426                clr.w   (a1)                    | set to play mode
     427
     428expnch1:        addq.l  #2,a1                   | point at next entry
     429                dbra    d0,expnch0              | loop through all groups
     430
     431                lea     _varmode,a1             | setup for variable modes
     432                move.w  #5,d1                   | set variable count
     433
     434expnch4:        clr.w   d0                      | clear offset
     435
     436expnch2:        cmpi.w  #2,0(a1,d0.W)           | in record mode ?
     437                bne     expnch3                 | jump if not
     438
     439                clr.w   0(a1,d0.W)              | set to play mode
     440
     441expnch3:        addq.w  #2,d0                   | update offset
     442                cmpi.w  #24,d0                  | check for final group
     443                bne     expnch2                 | loop through all groups
     444
     445                add.l   #32,a1                  | point at next variable
     446                dbra    d1,expnch4              | loop through all variables
     447
    448448                bra     exexit
    449 *
    450                 .page
    451 *
    452 * punch in
    453 *
    454 expnch5:        lea     _grpmode,a1             * setup for group modes
    455                 move.w  #11,d0                  * ...
    456 *
    457 expnch6:        cmpi.w  #1,(a1)                 * in standby mode ?
    458                 bne     expnch7                 * jump if not
    459 *
    460                 move.w  #2,(a1)                 * set to record mode
    461 *
    462 expnch7:        addq.l  #2,a1                   * point at next entry
    463                 dbra    d0,expnch6              * loop through all groups
    464 *
    465                 lea     _varmode,a1             * setup for variable modes
    466                 move.w  #5,d1                   * set variable count
    467 *
    468 expnch10:       clr.w   d0                      * clear offset
    469 *
    470 expnch8:        cmpi.w  #1,0(a1,d0.W)           * in standby mode ?
    471                 bne     expnch9                 * jump if not
    472 *
    473                 move.w  #2,0(a1,d0.W)           * set to record mode
    474 *
    475 expnch9:        addq.w  #2,d0                   * update offset
    476                 cmpi.w  #24,d0                  * check for final group
    477                 bne     expnch8                 * loop through all groups
    478 *
    479                 adda.l  #32,a1                  * point at next variable
    480                 dbra    d1,expnch10             * loop through all variables
    481 *
     449
     450                .page
     451
     452| punch in
     453
     454expnch5:        lea     _grpmode,a1             | setup for group modes
     455                move.w  #11,d0                  | ...
     456
     457expnch6:        cmpi.w  #1,(a1)                 | in standby mode ?
     458                bne     expnch7                 | jump if not
     459
     460                move.w  #2,(a1)                 | set to record mode
     461
     462expnch7:        addq.l  #2,a1                   | point at next entry
     463                dbra    d0,expnch6              | loop through all groups
     464
     465                lea     _varmode,a1             | setup for variable modes
     466                move.w  #5,d1                   | set variable count
     467
     468expnch10:       clr.w   d0                      | clear offset
     469
     470expnch8:        cmpi.w  #1,0(a1,d0.W)           | in standby mode ?
     471                bne     expnch9                 | jump if not
     472
     473                move.w  #2,0(a1,d0.W)           | set to record mode
     474
     475expnch9:        addq.w  #2,d0                   | update offset
     476                cmpi.w  #24,d0                  | check for final group
     477                bne     expnch8                 | loop through all groups
     478
     479                adda.l  #32,a1                  | point at next variable
     480                dbra    d1,expnch10             | loop through all variables
     481
    482482                bra     exexit
    483 *
    484                 .page
    485 *
    486 * sextab -- score execution dispatch table -- MUST match score.h definitions
    487 * ------    ----------------------------------------------------------------
    488 sextab:         dc.l    exexit          * 0     null
    489                 dc.l    exexit          * 1     score begin
    490                 dc.l    exsbgn          * 2     section begin
    491                 dc.l    exexit          * 3     section end
    492                 dc.l    exinst          * 4     instrument change
    493                 dc.l    exnbeg          * 5     note begin
    494                 dc.l    exnend          * 6     note end
    495                 dc.l    exstop          * 7     stop
    496                 dc.l    exintp          * 8     interpolate
    497                 dc.l    extmpo          * 9     tempo
    498                 dc.l    extune          * 10    tuning
    499                 dc.l    exexit          * 11    group status
    500                 dc.l    exlocn          * 12    location
    501                 dc.l    exdyn           * 13    dynamics
    502                 dc.l    exanvl          * 14    analog value
    503                 dc.l    exanrs          * 15    analog resolution
    504                 dc.l    exasgn          * 16    I/O assign
    505                 dc.l    extrns          * 17    transposition
    506                 dc.l    exexit          * 18    repeat
    507                 dc.l    expnch          * 19    punch in/out
    508                 dc.l    exexit          * 20    -unused- (polyphonic pressure)
    509                 dc.l    exexit          * 21    score end
    510                 dc.l    exexit          * 22    -unused- (channel pressure)
    511                 dc.l    exexit          * 23    bar marker
    512                 dc.l    exnext          * 24    next score
    513 *
     483
     484                .page
     485
     486| sextab -- score execution dispatch table -- MUST match score.h definitions
     487| ------    ----------------------------------------------------------------
     488sextab:         dc.l    exexit          | 0     null
     489                dc.l    exexit          | 1     score begin
     490                dc.l    exsbgn          | 2     section begin
     491                dc.l    exexit          | 3     section end
     492                dc.l    exinst          | 4     instrument change
     493                dc.l    exnbeg          | 5     note begin
     494                dc.l    exnend          | 6     note end
     495                dc.l    exstop          | 7     stop
     496                dc.l    exintp          | 8     interpolate
     497                dc.l    extmpo          | 9     tempo
     498                dc.l    extune          | 10    tuning
     499                dc.l    exexit          | 11    group status
     500                dc.l    exlocn          | 12    location
     501                dc.l    exdyn           | 13    dynamics
     502                dc.l    exanvl          | 14    analog value
     503                dc.l    exanrs          | 15    analog resolution
     504                dc.l    exasgn          | 16    I/O assign
     505                dc.l    extrns          | 17    transposition
     506                dc.l    exexit          | 18    repeat
     507                dc.l    expnch          | 19    punch in/out
     508                dc.l    exexit          | 20    -unused- (polyphonic pressure)
     509                dc.l    exexit          | 21    score end
     510                dc.l    exexit          | 22    -unused- (channel pressure)
     511                dc.l    exexit          | 23    bar marker
     512                dc.l    exnext          | 24    next score
     513
    514514                .bss
    515 *
    516 * Variable storage areas
    517 * ----------------------
    518 * globals:
    519 * --------
    520 _xevent:        ds.l    1               * next event pointer
    521 *
     515
     516| Variable storage areas
     517| ----------------------
     518| globals:
     519| --------
     520_xevent:        ds.l    1               | next event pointer
     521
    522522                .end

  • ram/serintr.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * serintr.s -- MIDAS-VII serial I/O subroutines
    3 * Version 4 -- 1988-12-13 -- D.N. Lynx Crowe
    4 *
    5 * These subroutines replace those in bios.s in order to add support for
    6 * MIDAS-VII foot pedal and pulse inputs, and pulse outputs.
    7 *
    8 * WARNING:  The code below uses addresses in the bios RAM area.  These addresses
    9 * correspond to those in PROMS dated 1988-06-20 et seq.  If the bios is changed,
    10 * the addresses marked with <== may have to be changed.
    11 * ------------------------------------------------------------------------------
    12 *
     1| ------------------------------------------------------------------------------
     2| serintr.s -- MIDAS-VII serial I/O subroutines
     3| Version 4 -- 1988-12-13 -- D.N. Lynx Crowe
     4
     5| These subroutines replace those in bios.s in order to add support for
     6| MIDAS-VII foot pedal and pulse inputs, and pulse outputs.
     7
     8| WARNING:  The code below uses addresses in the bios RAM area.  These addresses
     9| correspond to those in PROMS dated 1988-06-20 et seq.  If the bios is changed,
     10| the addresses marked with <== may have to be changed.
     11| ------------------------------------------------------------------------------
     12
    1313                .text
    14 *
     14
    1515                .xdef   _setsio
    16 *
     16
    1717                .xdef   _foot1
    1818                .xdef   _foot2
    1919                .xdef   _pulse1
    2020                .xdef   _pulse2
    21 *
     21
    2222                .xdef   serintr
    23 *
     23
    2424                .xdef   serint
    2525                .xdef   midint
    26 *
     26
    2727                .xdef   wrapin
    2828                .xdef   wrapout
    29 *
     29
    3030                .xdef   serput
    3131                .xdef   midput
    32 *
     32
    3333                .xdef   rtschk
    34 *
     34
    3535                .xdef   rtson
    3636                .xdef   rtsoff
    37 *
    38 * ==============================================================================
    39 *
    40 * The following addresses, marked by <==, are bios version dependent:
    41 *
    42 RAM             .equ    $00000400       * Beginning of system RAM area  <==
    43 *
    44 SR1IOREC        .equ    RAM+$0AB0       * Serial-1 iorec structure      <==
    45 SR2IOREC        .equ    RAM+$0AD8       * Serial-2 iorec structure      <==
    46 MC1IOREC        .equ    RAM+$0B00       * MIDI-1 iorec structure        <==
    47 MC2IOREC        .equ    RAM+$0B28       * MIDI-2 iorec structure        <==
    48 *
    49 * End of bios version dependent addresses.
    50 *
    51 * ==============================================================================
    52 *
    53                 .page
    54 *
    55 SERVECT         .equ    $000074         * Level 5 interrupt autovector address
    56 *
    57 IPL7            .equ    $0700           * IPL 7 value for sr
    58 *
    59 * ACIA I/O Addresses:
    60 * -------------------
    61 SR1ACIA         .equ    $3A8001         * Serial-1 ACIA base address
    62 SR2ACIA         .equ    $3A8009         * Serial-2 ACIA base address
    63 MC1ACIA         .equ    $3AC001         * MIDI-1 ACIA base address
    64 MC2ACIA         .equ    $3AC009         * MIDI-2 ACIA base address
    65 *
    66 * ACIA Register offsets:
    67 * ----------------------
    68 ACIA_IER        .equ    0               * ACIA IER offset
    69 ACIA_ISR        .equ    0               * ACIA ISR offset
    70 ACIA_CSR        .equ    2               * ACIA CSR offset
    71 ACIA_CFR        .equ    2               * ACIA CFR offset
    72 ACIA_TBR        .equ    4               * ACIA TBR offset
    73 ACIA_TDR        .equ    6               * ACIA TDR offset
    74 ACIA_RDR        .equ    6               * ACIA RDR offset
    75 *
    76 * iorec structure definitions:
    77 * ----------------------------
    78 IORECLN         .equ    40              * Length of an iorec structure
    79 *
    80 ibuf            .equ    0               * Input buffer base address
    81 ibufsize        .equ    4               * Input buffer size  (bytes)
    82 ibufhd          .equ    6               * Input buffer head index
    83 ibuftl          .equ    8               * Input buffer tail index
    84 ibuflow         .equ    10              * Input buffer low water mark
    85 ibufhi          .equ    12              * Input buffer high water mark
    86 obuf            .equ    14              * Output buffer base address
    87 obufsize        .equ    18              * Output buffer size  (bytes)
    88 obufhd          .equ    20              * Output buffer head index
    89 obuftl          .equ    22              * Output buffer tail index
    90 obuflow         .equ    24              * Output buffer low water mark
    91 obufhi          .equ    26              * Output buffer high water mark
    92 cfr0            .equ    28              * ACIA CFR, MS bit = 0
    93 cfr1            .equ    29              * ACIA CFR, MS bit = 1
    94 flagxon         .equ    30              * XON flag  (non-zero = XOFF sent)
    95 flagxoff        .equ    31              * XOFF flag  (non-zero = active)
    96 linedisc        .equ    32              * Line discipline flags
    97 erbyte          .equ    33              * Last error byte
    98 isr             .equ    34              * ACIA ISR on interrupt
    99 csr             .equ    35              * ACIA CSR on interrupt
    100 errct           .equ    36              * Error count  (FRM/OVR/BRK)
    101 ibfct           .equ    38              * Input buffer full count
    102 *
    103                 .page
    104 *
    105 * serintr -- Serial (Serial-1, Serial-2, MIDI-1, MIDI-2) interrupt handler
    106 * -------    -------------------------------------------------------------
    107 serintr:        movem.l d0-d3/a0-a2,-(a7)       * Save registers
    108                 lea     SR1IOREC,a0             * Point at Serial-1 iorec
    109                 lea     SR1ACIA,a1              * Point at Serial-1 ACIA
    110                 movea.l _foot1,a2               * Point at foot sw. 1 processor
    111                 bsr     serint                  * Go process (possible) int.
    112 *
    113                 lea     SR2IOREC,a0             * Point at Serial-2 iorec
    114                 lea     SR2ACIA,a1              * Point at Serial-2 ACIA
    115                 movea.l _foot2,a2               * Point at foot sw. 2 processor
    116                 bsr     serint                  * Go process (possible) int.
    117 *
    118                 lea     MC1IOREC,a0             * Point at MIDI-1 iorec
    119                 lea     MC1ACIA,a1              * Point at MIDI-1 ACIA
    120                 movea.l _pulse1,a2              * Point at pulse 1 processor
    121                 bsr     midint                  * Go process (possible) int.
    122 *
    123                 lea     MC2IOREC,a0             * Point at MIDI-2 iorec
    124                 lea     MC2ACIA,a1              * Point at MIDI-2 ACIA
    125                 movea.l _pulse2,a2              * Point at pulse 2 processor
    126                 bsr     midint                  * Go process (possible) int.
    127 *
    128                 movem.l (a7)+,d0-d3/a0-a2       * Restore registers
    129                 rte                             * Return from exception
    130 *
    131                 .page
    132 *
    133 * serint -- Process an interrupt from Serial-1 or Serial-2
    134 * ------    ----------------------------------------------
    135 serint:         move.b  ACIA_ISR(a1),isr(a0)    * Get and save ISR
    136                 move.b  ACIA_CSR(a1),csr(a0)    * Get and save CSR
    137 *
    138                 btst.b  #7,isr(a0)              * Was int for this device ?
    139                 beq     serintx                 * Jump if not
    140 *
    141 serchk:         btst.b  #1,isr(a0)              * FRM/OVR/BRK error ?
    142                 bne     sererr                  * Jump if so
    143 *
    144                 btst.b  #0,isr(a0)              * Receiver interrupt ?
    145                 bne     serrx                   * Jump if so
    146 *
    147 sertxq:         btst.b  #6,isr(a0)              * Transmitter interrupt ?
    148                 bne     sertx                   * Jump if so
    149 *
    150 serctq:         btst.b  #5,isr(a0)              * CTS interrupt ?
    151                 bne     sercts                  * Jump if so
    152 *
    153 serintx:        btst.b  #4,isr(a0)              * DCD interrupt ?
    154                 bne     calldcd                 * Jump if so
    155 *
    156 serdone:        rts                             * Return to caller
    157 *
    158 calldcd:        move.b  csr(a0),d0              * Get CSR interrupt status
    159                 btst.l  #4,d0                   * Check DCD input  (0 = active)
    160                 bne     calldcd0                * Jump if line was inactive
    161 *
    162                 moveq.l #1,d0                   * Set footswitch status to TRUE
    163                 bra     calldcd1                * ...
    164 *
    165 calldcd0:       moveq.l #0,d0                   * Set footswitch status to FALSE
    166 *
    167 calldcd1:       move.w  d0,-(a7)                * Call the footswitch processor
    168                 jsr     (a2)                    * ... (*footX)(status)
    169                 tst.w   (a7)+                   * ...
    170                 rts                             * Return to caller
    171 *
    172                 .page
    173 *
    174 * Handle serial I/O port error
    175 *
    176 sererr:         addq.w  #1,errct(a0)            * Update error count
    177                 move.b  ACIA_RDR(a1),erbyte(a0) * Get error byte
    178                 rts                             * Return to caller
    179 *
    180 *
    181 * Handle CTS interupt
    182 *
    183 sercts:         btst.b  #1,linedisc(a0)         * RTS/CTS mode ?
    184                 beq     serintx                 * Ignore if not
    185 *
    186                 btst.b  #5,csr(a0)              * CTS set ?
    187                 beq     serintx                 * Ignore if not
    188 *
    189 sercts1:        btst.b  #6,isr(a0)              * TDRE set ?
    190                 beq     sercts1                 * Loop until it is  (!)
    191 *
    192                 move.w  obufhd(a0),d2           * Head index to d2
    193                 cmp.w   obuftl(a0),d2           * Compare to tail index
    194                 beq     serintx                 * Done if buffer empty
    195 *
    196                 bsr     wrapout                 * Adjust pointer for wraparound
    197                 move.l  obuf(a0),a2             * Get buffer base in a2
    198                 move.b  0(a2,d2),ACIA_TDR(a1)   * Send byte on its way
    199                 move.w  d2,obufhd(a0)           * Save updated head index
    200                 bra     serintx                 * Done
    201 *
    202                 .page
    203 *
    204 * Handle receiver interrupt
    205 *
    206 serrx:          btst.b  #1,linedisc(a0)         * RTS/CTS mode set ?
    207                 beq     serrx1                  * Jump if not
    208 *
    209                 bsr     rtsoff                  * Turn off RTS
    210 *
    211 serrx1:         move.b  ACIA_RDR(a1),d0         * Read data from ACIA
    212                 btst.b  #1,linedisc(a0)         * RTS/CTS mode set ?
    213                 bne     serrx3                  * Jump if so
    214 *
    215                 btst.b  #0,linedisc(a0)         * XON/XOFF mode set ?
    216                 beq     serrx3                  * Jump if not
    217 *
    218                 cmpi.b  #$11,d0                 * Is this an XON ?
    219                 bne     serrx2                  * Jump if not
    220 *
    221                 move.b  #$00,flagxoff(a0)       * Clear flagxoff
    222                 bra     sertxq                  * Done
    223 *
    224 serrx2:         cmpi.b  #$13,d0                 * Is this an XOFF ?
    225                 bne     serrx3                  * Jump if not
    226 *
    227                 move.b  #$FF,flagxoff(a0)       * Set flagxoff
    228                 bra     sertxq                  * Done
    229 *
    230 serrx3:         move.w  ibuftl(a0),d1           * Get tail index in d1
    231                 bsr     wrapin                  * Adjust for wraparound
    232                 cmp.w   ibufhd(a0),d1           * Head = tail ?
    233                 beq     seribf                  * If so, we drop the character
    234 *
    235                 .page
    236                 move.l  ibuf(a0),a2             * Get buffer address
    237                 move.b  d0,0(a2,d1)             * Stash byte in buffer
    238                 move.w  d1,ibuftl(a0)           * Save updated tail index
    239                 move.w  ibuftl(a0),d2           * Tail index to d2
    240                 move.w  ibufhd(a0),d3           * Head index to d3
    241                 cmp.w   d3,d2                   * Head > Tail ?
    242                 bhi     rsi_1                   * Jump if not
    243 *
    244                 add.w   ibufsize(a0),d2         * Add buffer size to tail index
    245 *
    246 rsi_1:          sub.w   d3,d2                   * Length = (adjusted)Tail - Head
    247                 cmp.w   ibufhi(a0),d2           * Hit high water mark ?
    248                 bne     serrx4                  * Jump if not
    249 *
    250                 btst.b  #1,linedisc(a0)         * RTS/CTS mode set ?
    251                 bne     sertxq                  * Done if so
    252 *
    253                 btst.b  #0,linedisc(a0)         * XON/XOFF mode set ?
    254                 beq     serrx4                  * Jump if not
    255 *
    256                 tst.b   flagxon(a0)             * XOFF already sent ?
    257                 bne     serrx4                  * Jump if so
    258 *
    259                 move.b  #$FF,flagxon(a0)        * Set the flag
    260                 move.b  #$13,d1                 * Send an XOFF
    261                 bsr     serput                  * ...
    262 *
    263 serrx4:         btst    #1,linedisc(a0)         * RTS/CTS mode set ?
    264                 beq     sertxq                  * Done if not
    265 *
    266                 bsr     rtson                   * Turn on RTS
    267                 bra     sertxq                  * Done
    268 *
    269                 .page
    270 *
    271 * Handle transmitter interrupt
    272 *
    273 sertx:          btst.b  #1,linedisc(a0)         * RTS/CTS mode set ?
    274                 bne     sertx2                  * If so, go check CTS
    275 *
    276                 btst.b  #0,linedisc(a0)         * XON/XOFF mode set ?
    277                 beq     sertx1                  * Jump if not
    278 *
    279                 tst.b   flagxoff(a0)            * Check flagxoff
    280                 bne     serctq                  * Done if set
    281 *
    282 sertx1:         move.w  obufhd(a0),d2           * Head index to d2
    283                 cmp.w   obuftl(a0),d2           * Compare to tail index
    284                 beq     serctq                  * Done if buffer empty
    285 *
    286                 bsr     wrapout                 * Adjust pointer for wraparound
    287                 move.l  obuf(a0),a2             * Get buffer base address
    288                 move.b  0(a2,d2),ACIA_TDR(a1)   * Send byte on its way
    289                 move.w  d2,obufhd(a0)           * Save updated head index
    290                 bra     serctq                  * Done
    291 *
    292 sertx2:         btst.b  #5,csr(a0)              * CTS set in csr ?
    293                 beq     serctq                  * If not, go check for CTS int
    294 *
    295                 bra     sertx1                  * CTS was set, go transmit
    296 *
    297 seribf:         move.b  d0,erbyte(a0)           * Log dropped character
    298                 addq.w  #1,ibfct(a0)            * ...
    299                 bra     sertxq                  * Go check Tx interrupt
    300 *
    301                 .page
    302 *
    303 * midint -- Process an interrupt from MIDI-1 or MIDI-2
    304 * ------    ------------------------------------------
    305 midint:         move.b  ACIA_ISR(a1),isr(a0)    * Get and save ISR
    306                 move.b  ACIA_CSR(a1),csr(a0)    * Get and save CSR
    307 *
    308                 btst.b  #7,isr(a0)              * Was int for this device ?
    309                 beq     midintx                 * Jump if not
    310 *
    311 midchk:         btst.b  #1,isr(a0)              * FRM/OVR/BRK error ?
    312                 bne     miderr                  * Jump if so
    313 *
    314                 btst.b  #0,isr(a0)              * Receiver interrupt ?
    315                 bne     midrx                   * Jump if so
    316 *
    317 midtxq:         btst.b  #6,isr(a0)              * Transmitter interrupt ?
    318                 bne     midtx                   * Jump if so
    319 *
    320 midintx:        btst    #4,isr(a0)              * DCD interrupt ?
    321                 bne     mididcd                 * Jump if so
    322 *
    323 mididone:       rts                             * Return to caller
    324 *
    325 mididcd:        jmp     (a2)                    * Exit through the DCD processor
    326 *
    327 miderr:         addq.w  #1,errct(a0)            * Update error count
    328                 move.b  ACIA_RDR(a1),erbyte(a0) * Get error byte
     37
     38| ==============================================================================
     39
     40| The following addresses, marked by <==, are bios version dependent:
     41
     42RAM             =       0x00000400      | Beginning of system RAM area  <==
     43
     44SR1IOREC        =       RAM+0x0AB0      | Serial-1 iorec structure      <==
     45SR2IOREC        =       RAM+0x0AD8      | Serial-2 iorec structure      <==
     46MC1IOREC        =       RAM+0x0B00      | MIDI-1 iorec structure        <==
     47MC2IOREC        =       RAM+0x0B28      | MIDI-2 iorec structure        <==
     48
     49| End of bios version dependent addresses.
     50
     51| ==============================================================================
     52
     53                .page
     54
     55SERVECT         =       0x000074        | Level 5 interrupt autovector address
     56
     57IPL7            =       0x0700          | IPL 7 value for sr
     58
     59| ACIA I/O Addresses:
     60| -------------------
     61SR1ACIA         =       0x3A8001        | Serial-1 ACIA base address
     62SR2ACIA         =       0x3A8009        | Serial-2 ACIA base address
     63MC1ACIA         =       0x3AC001        | MIDI-1 ACIA base address
     64MC2ACIA         =       0x3AC009        | MIDI-2 ACIA base address
     65
     66| ACIA Register offsets:
     67| ----------------------
     68ACIA_IER        =       0               | ACIA IER offset
     69ACIA_ISR        =       0               | ACIA ISR offset
     70ACIA_CSR        =       2               | ACIA CSR offset
     71ACIA_CFR        =       2               | ACIA CFR offset
     72ACIA_TBR        =       4               | ACIA TBR offset
     73ACIA_TDR        =       6               | ACIA TDR offset
     74ACIA_RDR        =       6               | ACIA RDR offset
     75
     76| iorec structure definitions:
     77| ----------------------------
     78IORECLN         =       40              | Length of an iorec structure
     79
     80ibuf            =       0               | Input buffer base address
     81ibufsize        =       4               | Input buffer size  (bytes)
     82ibufhd          =       6               | Input buffer head index
     83ibuftl          =       8               | Input buffer tail index
     84ibuflow         =       10              | Input buffer low water mark
     85ibufhi          =       12              | Input buffer high water mark
     86obuf            =       14              | Output buffer base address
     87obufsize        =       18              | Output buffer size  (bytes)
     88obufhd          =       20              | Output buffer head index
     89obuftl          =       22              | Output buffer tail index
     90obuflow         =       24              | Output buffer low water mark
     91obufhi          =       26              | Output buffer high water mark
     92cfr0            =       28              | ACIA CFR, MS bit = 0
     93cfr1            =       29              | ACIA CFR, MS bit = 1
     94flagxon         =       30              | XON flag  (non-zero = XOFF sent)
     95flagxoff        =       31              | XOFF flag  (non-zero = active)
     96linedisc        =       32              | Line discipline flags
     97erbyte          =       33              | Last error byte
     98isr             =       34              | ACIA ISR on interrupt
     99csr             =       35              | ACIA CSR on interrupt
     100errct           =       36              | Error count  (FRM/OVR/BRK)
     101ibfct           =       38              | Input buffer full count
     102
     103                .page
     104
     105| serintr -- Serial (Serial-1, Serial-2, MIDI-1, MIDI-2) interrupt handler
     106| -------    -------------------------------------------------------------
     107serintr:        movem.l d0-d3/a0-a2,-(a7)       | Save registers
     108                lea     SR1IOREC,a0             | Point at Serial-1 iorec
     109                lea     SR1ACIA,a1              | Point at Serial-1 ACIA
     110                movea.l _foot1,a2               | Point at foot sw. 1 processor
     111                bsr     serint                  | Go process (possible) int.
     112
     113                lea     SR2IOREC,a0             | Point at Serial-2 iorec
     114                lea     SR2ACIA,a1              | Point at Serial-2 ACIA
     115                movea.l _foot2,a2               | Point at foot sw. 2 processor
     116                bsr     serint                  | Go process (possible) int.
     117
     118                lea     MC1IOREC,a0             | Point at MIDI-1 iorec
     119                lea     MC1ACIA,a1              | Point at MIDI-1 ACIA
     120                movea.l _pulse1,a2              | Point at pulse 1 processor
     121                bsr     midint                  | Go process (possible) int.
     122
     123                lea     MC2IOREC,a0             | Point at MIDI-2 iorec
     124                lea     MC2ACIA,a1              | Point at MIDI-2 ACIA
     125                movea.l _pulse2,a2              | Point at pulse 2 processor
     126                bsr     midint                  | Go process (possible) int.
     127
     128                movem.l (a7)+,d0-d3/a0-a2       | Restore registers
     129                rte                             | Return from exception
     130
     131                .page
     132
     133| serint -- Process an interrupt from Serial-1 or Serial-2
     134| ------    ----------------------------------------------
     135serint:         move.b  ACIA_ISR(a1),isr(a0)    | Get and save ISR
     136                move.b  ACIA_CSR(a1),csr(a0)    | Get and save CSR
     137
     138                btst.b  #7,isr(a0)              | Was int for this device ?
     139                beq     serintx                 | Jump if not
     140
     141serchk:         btst.b  #1,isr(a0)              | FRM/OVR/BRK error ?
     142                bne     sererr                  | Jump if so
     143
     144                btst.b  #0,isr(a0)              | Receiver interrupt ?
     145                bne     serrx                   | Jump if so
     146
     147sertxq:         btst.b  #6,isr(a0)              | Transmitter interrupt ?
     148                bne     sertx                   | Jump if so
     149
     150serctq:         btst.b  #5,isr(a0)              | CTS interrupt ?
     151                bne     sercts                  | Jump if so
     152
     153serintx:        btst.b  #4,isr(a0)              | DCD interrupt ?
     154                bne     calldcd                 | Jump if so
     155
     156serdone:        rts                             | Return to caller
     157
     158calldcd:        move.b  csr(a0),d0              | Get CSR interrupt status
     159                btst.l  #4,d0                   | Check DCD input  (0 = active)
     160                bne     calldcd0                | Jump if line was inactive
     161
     162                moveq.l #1,d0                   | Set footswitch status to TRUE
     163                bra     calldcd1                | ...
     164
     165calldcd0:       moveq.l #0,d0                   | Set footswitch status to FALSE
     166
     167calldcd1:       move.w  d0,-(a7)                | Call the footswitch processor
     168                jsr     (a2)                    | ... (|footX)(status)
     169                tst.w   (a7)+                   | ...
     170                rts                             | Return to caller
     171
     172                .page
     173
     174| Handle serial I/O port error
     175
     176sererr:         addq.w  #1,errct(a0)            | Update error count
     177                move.b  ACIA_RDR(a1),erbyte(a0) | Get error byte
     178                rts                             | Return to caller
     179
     180
     181| Handle CTS interupt
     182
     183sercts:         btst.b  #1,linedisc(a0)         | RTS/CTS mode ?
     184                beq     serintx                 | Ignore if not
     185
     186                btst.b  #5,csr(a0)              | CTS set ?
     187                beq     serintx                 | Ignore if not
     188
     189sercts1:        btst.b  #6,isr(a0)              | TDRE set ?
     190                beq     sercts1                 | Loop until it is  (!)
     191
     192                move.w  obufhd(a0),d2           | Head index to d2
     193                cmp.w   obuftl(a0),d2           | Compare to tail index
     194                beq     serintx                 | Done if buffer empty
     195
     196                bsr     wrapout                 | Adjust pointer for wraparound
     197                move.l  obuf(a0),a2             | Get buffer base in a2
     198                move.b  0(a2,d2),ACIA_TDR(a1)   | Send byte on its way
     199                move.w  d2,obufhd(a0)           | Save updated head index
     200                bra     serintx                 | Done
     201
     202                .page
     203
     204| Handle receiver interrupt
     205
     206serrx:          btst.b  #1,linedisc(a0)         | RTS/CTS mode set ?
     207                beq     serrx1                  | Jump if not
     208
     209                bsr     rtsoff                  | Turn off RTS
     210
     211serrx1:         move.b  ACIA_RDR(a1),d0         | Read data from ACIA
     212                btst.b  #1,linedisc(a0)         | RTS/CTS mode set ?
     213                bne     serrx3                  | Jump if so
     214
     215                btst.b  #0,linedisc(a0)         | XON/XOFF mode set ?
     216                beq     serrx3                  | Jump if not
     217
     218                cmpi.b  #0x11,d0                | Is this an XON ?
     219                bne     serrx2                  | Jump if not
     220
     221                move.b  #0x00,flagxoff(a0)      | Clear flagxoff
     222                bra     sertxq                  | Done
     223
     224serrx2:         cmpi.b  #0x13,d0                | Is this an XOFF ?
     225                bne     serrx3                  | Jump if not
     226
     227                move.b  #0xFF,flagxoff(a0)      | Set flagxoff
     228                bra     sertxq                  | Done
     229
     230serrx3:         move.w  ibuftl(a0),d1           | Get tail index in d1
     231                bsr     wrapin                  | Adjust for wraparound
     232                cmp.w   ibufhd(a0),d1           | Head = tail ?
     233                beq     seribf                  | If so, we drop the character
     234
     235                .page
     236                move.l  ibuf(a0),a2             | Get buffer address
     237                move.b  d0,0(a2,d1)             | Stash byte in buffer
     238                move.w  d1,ibuftl(a0)           | Save updated tail index
     239                move.w  ibuftl(a0),d2           | Tail index to d2
     240                move.w  ibufhd(a0),d3           | Head index to d3
     241                cmp.w   d3,d2                   | Head > Tail ?
     242                bhi     rsi_1                   | Jump if not
     243
     244                add.w   ibufsize(a0),d2         | Add buffer size to tail index
     245
     246rsi_1:          sub.w   d3,d2                   | Length = (adjusted)Tail - Head
     247                cmp.w   ibufhi(a0),d2           | Hit high water mark ?
     248                bne     serrx4                  | Jump if not
     249
     250                btst.b  #1,linedisc(a0)         | RTS/CTS mode set ?
     251                bne     sertxq                  | Done if so
     252
     253                btst.b  #0,linedisc(a0)         | XON/XOFF mode set ?
     254                beq     serrx4                  | Jump if not
     255
     256                tst.b   flagxon(a0)             | XOFF already sent ?
     257                bne     serrx4                  | Jump if so
     258
     259                move.b  #0xFF,flagxon(a0)       | Set the flag
     260                move.b  #0x13,d1                | Send an XOFF
     261                bsr     serput                  | ...
     262
     263serrx4:         btst    #1,linedisc(a0)         | RTS/CTS mode set ?
     264                beq     sertxq                  | Done if not
     265
     266                bsr     rtson                   | Turn on RTS
     267                bra     sertxq                  | Done
     268
     269                .page
     270
     271| Handle transmitter interrupt
     272
     273sertx:          btst.b  #1,linedisc(a0)         | RTS/CTS mode set ?
     274                bne     sertx2                  | If so, go check CTS
     275
     276                btst.b  #0,linedisc(a0)         | XON/XOFF mode set ?
     277                beq     sertx1                  | Jump if not
     278
     279                tst.b   flagxoff(a0)            | Check flagxoff
     280                bne     serctq                  | Done if set
     281
     282sertx1:         move.w  obufhd(a0),d2           | Head index to d2
     283                cmp.w   obuftl(a0),d2           | Compare to tail index
     284                beq     serctq                  | Done if buffer empty
     285
     286                bsr     wrapout                 | Adjust pointer for wraparound
     287                move.l  obuf(a0),a2             | Get buffer base address
     288                move.b  0(a2,d2),ACIA_TDR(a1)   | Send byte on its way
     289                move.w  d2,obufhd(a0)           | Save updated head index
     290                bra     serctq                  | Done
     291
     292sertx2:         btst.b  #5,csr(a0)              | CTS set in csr ?
     293                beq     serctq                  | If not, go check for CTS int
     294
     295                bra     sertx1                  | CTS was set, go transmit
     296
     297seribf:         move.b  d0,erbyte(a0)           | Log dropped character
     298                addq.w  #1,ibfct(a0)            | ...
     299                bra     sertxq                  | Go check Tx interrupt
     300
     301                .page
     302
     303| midint -- Process an interrupt from MIDI-1 or MIDI-2
     304| ------    ------------------------------------------
     305midint:         move.b  ACIA_ISR(a1),isr(a0)    | Get and save ISR
     306                move.b  ACIA_CSR(a1),csr(a0)    | Get and save CSR
     307
     308                btst.b  #7,isr(a0)              | Was int for this device ?
     309                beq     midintx                 | Jump if not
     310
     311midchk:         btst.b  #1,isr(a0)              | FRM/OVR/BRK error ?
     312                bne     miderr                  | Jump if so
     313
     314                btst.b  #0,isr(a0)              | Receiver interrupt ?
     315                bne     midrx                   | Jump if so
     316
     317midtxq:         btst.b  #6,isr(a0)              | Transmitter interrupt ?
     318                bne     midtx                   | Jump if so
     319
     320midintx:        btst    #4,isr(a0)              | DCD interrupt ?
     321                bne     mididcd                 | Jump if so
     322
     323mididone:       rts                             | Return to caller
     324
     325mididcd:        jmp     (a2)                    | Exit through the DCD processor
     326
     327miderr:         addq.w  #1,errct(a0)            | Update error count
     328                move.b  ACIA_RDR(a1),erbyte(a0) | Get error byte
    329329                rts
    330 *
    331 * Handle receiver interrupt
    332 *
    333 midrx:          move.b  ACIA_RDR(a1),d0         * Read data from ACIA
    334                 move.w  ibuftl(a0),d1           * Get tail index in d1
    335                 bsr     wrapin                  * Adjust for wraparound
    336                 cmp.w   ibufhd(a0),d1           * Head = tail ?
    337                 beq     midibf                  * If so, we drop the character
    338 *
    339                 move.l  ibuf(a0),a2             * Get buffer address
    340                 move.b  d0,0(a2,d1)             * Stash byte in buffer
    341                 move.w  d1,ibuftl(a0)           * Save updated tail index
    342                 bra     midtxq                  * Done  (go check tx int)
    343 *
    344                 .page
    345 *
    346 * Handle transmitter interrupt
    347 *
    348 midtx:          move.w  obufhd(a0),d2           * Head index to d2
    349                 cmp.w   obuftl(a0),d2           * Compare to tail index
    350                 beq     midintx                 * Done if buffer empty
    351 *
    352                 bsr     wrapout                 * Adjust pointer for wraparound
    353                 move.l  obuf(a0),a2             * Get buffer base address
    354                 move.b  0(a2,d2),ACIA_TDR(a1)   * Send byte on its way
    355                 move.w  d2,obufhd(a0)           * Save updated head index
    356                 bra     midintx                 * Done
    357 *
    358 midibf:         move.b  d0,erbyte(a0)           * Log dropped character
    359                 addq.w  #1,ibfct(a0)            * ...
    360                 bra     midtxq                  * Go check Tx interrupt
    361 *
    362                 .page
    363 *
    364 * serput -- Output a character to a serial port
    365 * ------    -----------------------------------
    366 serput:         move.w  sr,-(a7)                * Save status register
    367                 ori.w   #IPL7,sr                * DISABLE INTERRUPTS
    368                 move.b  ACIA_ISR(a1),isr(a0)    * Get ACIA isr
    369                 move.b  ACIA_CSR(a1),csr(a0)    * Get ACIA csr
    370                 btst    #0,linedisc(a0)         * XON/XOFF mode ?
    371                 beq     serpt_1                 * Jump if not
    372 *
    373                 tst.b   flagxoff(a0)            * XON active ?
    374                 bne     serpt_2                 * Jump if so
    375 *
    376 serpt_1:        btst.b  #6,isr(a0)              * Is ACIA still sending ?
    377                 beq     serpt_2                 * Jump if so
    378 *
    379                 move.w  obufhd(a0),d2           * Head index to d2
    380                 cmp.w   obuftl(a0),d2           * Compare to tail index
    381                 bne     serpt_2                 * Jump if buffer not empty
    382 *
    383                 move.b  d1,ACIA_TDR(a1)         * Give byte to ACIA to send
    384                 bra     serpt_3                 * Go deal with RTS/CTS if needed
    385 *
    386 serpt_2:        move.w  obuftl(a0),d2           * Tail index to d2
    387                 bsr     wrapout                 * Adjust for wraparound
    388                 cmp.w   obufhd(a0),d2           * Compare to head index
    389                 beq     serpt_4                 * Jump if buffer full
    390 *
    391                 move.l  obuf(a0),a2             * Get buffer base address in a2
    392                 move.b  d1,0(a2,d2)             * Put character in buffer
    393                 move.w  d2,obuftl(a0)           * Update buffer tail index
    394 *
    395 serpt_3:        bsr     serchk                  * Check status on our way out
    396                 bsr     rtschk                  * Handle RTS protocol
    397                 move.w  (a7)+,sr                * RESTORE INTERRUPTS
    398                 andi    #$FFFE,sr               * Clear carry flag = OK
    399                 rts                             * Return to caller
    400 *
    401 serpt_4:        bsr     serchk                  * Check status on our way out
    402                 bsr     rtschk                  * Handle RTS protocol
    403                 move.w  (a7)+,sr                * RESTORE INTERRUPTS
    404                 ori     #$0001,sr               * Set carry flag = buffer full
    405                 rts                             * Return to caller
    406 *
    407                 .page
    408 *
    409 * midput -- Output to MIDI
    410 * ------    --------------
    411 midput:         move.w  sr,-(a7)                * Save status register
    412                 ori.w   #IPL7,sr                * DISABLE INTERRUPTS
    413                 move.b  ACIA_ISR(a1),isr(a0)    * Get ACIA isr
    414                 move.b  ACIA_CSR(a1),csr(a0)    * Get ACIA csr
    415                 btst.b  #6,isr(a0)              * Is ACIA still sending ?
    416                 beq     midpt_2                 * Jump if so
    417 *
    418                 move.w  obufhd(a0),d2           * Head index to d2
    419                 cmp.w   obuftl(a0),d2           * Compare to tail index
    420                 bne     midpt_2                 * Jump if buffer not empty
    421 *
    422                 move.b  d1,ACIA_TDR(a1)         * Give byte to ACIA to send
    423                 bra     midpt_3                 * Go set final status and exit
    424 *
    425 midpt_2:        move.w  obuftl(a0),d2           * Tail index to d2
    426                 bsr     wrapout                 * Adjust for wraparound
    427                 cmp.w   obufhd(a0),d2           * Compare to head index
    428                 beq     midpt_4                 * Jump if buffer full
    429 *
    430                 move.l  obuf(a0),a2             * Get buffer base address in a2
    431                 move.b  d1,0(a2,d2)             * Put character in buffer
    432                 move.w  d2,obuftl(a0)           * Update buffer tail index
    433 *
    434 midpt_3:        bsr     midchk                  * Check status on our way out
    435                 move.w  (a7)+,sr                * RESTORE INTERRUPTS
    436                 andi    #$FFFE,sr               * Clear carry flag = OK
    437                 rts                             * Return to caller
    438 *
    439 midpt_4:        bsr     midchk                  * Check status on our way out
    440                 move.w  (a7)+,sr                * RESTORE INTERRUPTS
    441                 ori     #$0001,sr               * Set carry flag = buffer full
    442                 rts                             * Return to caller
    443 *
    444                 .page
    445 *
    446 * rtschk -- Check RTS mode and turn on RTS if it's enabled
    447 * ------    ----------------------------------------------
    448 rtschk:         btst    #1,linedisc(a0)         * RTS/CTS mode set ?
    449                 beq     rtsexit                 * Jump to exit if not
    450 *
    451 * rtson -- Turn on RTS line
    452 * -----    ----------------
    453 rtson:          move.b  cfr1(a0),d0             * Pick up CFR1 image
    454                 bclr    #0,d0                   * Turn on RTS line  (0 = on)
    455                 bra     rtscmn                  * Join common RTS code below
    456 *
    457 * rtsoff -- Turn off RTS line
    458 * ------    -----------------
    459 rtsoff:         move.b  cfr1(a0),d0             * Pick up CFR1 image
    460                 bset    #0,d0                   * Turn off RTS line  (1 = off)
    461 
    462 rtscmn:         bset    #7,d0                   * Make sure MS bit is set
    463                 move.b  d0,cfr1(a0)             * Update CFR1 image
    464                 move.b  d0,ACIA_CFR(a1)         * Send CFR to hardware
    465 *
    466 rtsexit:        rts                             * Return to caller
    467 *
    468                 .page
    469 *
    470 * wrapin -- Check input pointer for wraparound
    471 * ------    ----------------------------------
    472 wrapin:         add.w   #1,d1                   * Head index +1
    473                 cmp.w   ibufsize(a0),d1         * = buffer size ?
    474                 bcs     wrapin1                 * Jump if not
    475 *
    476                 moveq.l #0,d1                   * Wraparound
    477 *
    478 wrapin1:        rts                             * Return to caller
    479 *
    480 * wrapout -- Check output pointer for wraparound
    481 * -------    -----------------------------------
    482 wrapout:        addq.w  #1,d2                   * Tail index +1
    483                 cmp.w   obufsize(a0),d2         * = buffer size ?
    484                 bcs     wrapout1                * Jump if not
    485 *
    486                 moveq.l #0,d2                   * Wrap around if so
    487 *
    488 wrapout1:       rts                             * Return to caller
    489 *
    490                 .page
    491 *
    492 * _setsio -- setsio() -- initialize serial I/O vectors and DCD interrupts
    493 * -------    ------------------------------------------------------------
    494 _setsio:        move.w  sr,-(a7)                * Preserve status register
    495                 ori.w   #$IPL7,sr               * DISABLE INTERRUPTS
    496 *
    497                 lea     nulsiox,a0              * Get null return address
    498                 move.l  a0,_foot1               * Initialize foot1 vector
    499                 move.l  a0,_foot2               * Initialize foot2 vector
    500                 move.l  a0,_pulse1              * Initialize pulse1 vector
    501                 move.l  a0,_pulse2              * Initialize pulse2 vector
    502 *
    503                 lea     SR1ACIA,a1              * Point at Serial-1 ACIA
    504                 move.b  #$90,ACIA_IER(a1)       * Enable DCD interrupts
    505 *
    506                 lea     SR2ACIA,a1              * Point at Serial-2 ACIA
    507                 move.b  #$90,ACIA_IER(a1)       * Enable DCD interrupts
    508 *
    509                 lea     MC1ACIA,a1              * Point at MIDI-1 ACIA
    510                 move.b  #$90,ACIA_IER(a1)       * Enable DCD interrupts
    511 *
    512                 lea     MC2ACIA,a1              * Point at MIDI-2 ACIA
    513                 move.b  #$90,ACIA_IER(a1)       * Enable DCD interrupts
    514 *
    515                 lea     serintr,a0              * Initialize interrupt vector
    516                 move.l  a0,SERVECT              * ... in processor RAM
    517 *
    518                 move.w  (a7)+,sr                * RESTORE INTERRUPTS
    519 *
    520 nulsiox:        rts                             * Return to caller
    521 *
     330
     331| Handle receiver interrupt
     332
     333midrx:          move.b  ACIA_RDR(a1),d0         | Read data from ACIA
     334                move.w  ibuftl(a0),d1           | Get tail index in d1
     335                bsr     wrapin                  | Adjust for wraparound
     336                cmp.w   ibufhd(a0),d1           | Head = tail ?
     337                beq     midibf                  | If so, we drop the character
     338
     339                move.l  ibuf(a0),a2             | Get buffer address
     340                move.b  d0,0(a2,d1)             | Stash byte in buffer
     341                move.w  d1,ibuftl(a0)           | Save updated tail index
     342                bra     midtxq                  | Done  (go check tx int)
     343
     344                .page
     345
     346| Handle transmitter interrupt
     347
     348midtx:          move.w  obufhd(a0),d2           | Head index to d2
     349                cmp.w   obuftl(a0),d2           | Compare to tail index
     350                beq     midintx                 | Done if buffer empty
     351
     352                bsr     wrapout                 | Adjust pointer for wraparound
     353                move.l  obuf(a0),a2             | Get buffer base address
     354                move.b  0(a2,d2),ACIA_TDR(a1)   | Send byte on its way
     355                move.w  d2,obufhd(a0)           | Save updated head index
     356                bra     midintx                 | Done
     357
     358midibf:         move.b  d0,erbyte(a0)           | Log dropped character
     359                addq.w  #1,ibfct(a0)            | ...
     360                bra     midtxq                  | Go check Tx interrupt
     361
     362                .page
     363
     364| serput -- Output a character to a serial port
     365| ------    -----------------------------------
     366serput:         move.w  sr,-(a7)                | Save status register
     367                ori.w   #IPL7,sr                | DISABLE INTERRUPTS
     368                move.b  ACIA_ISR(a1),isr(a0)    | Get ACIA isr
     369                move.b  ACIA_CSR(a1),csr(a0)    | Get ACIA csr
     370                btst    #0,linedisc(a0)         | XON/XOFF mode ?
     371                beq     serpt_1                 | Jump if not
     372
     373                tst.b   flagxoff(a0)            | XON active ?
     374                bne     serpt_2                 | Jump if so
     375
     376serpt_1:        btst.b  #6,isr(a0)              | Is ACIA still sending ?
     377                beq     serpt_2                 | Jump if so
     378
     379                move.w  obufhd(a0),d2           | Head index to d2
     380                cmp.w   obuftl(a0),d2           | Compare to tail index
     381                bne     serpt_2                 | Jump if buffer not empty
     382
     383                move.b  d1,ACIA_TDR(a1)         | Give byte to ACIA to send
     384                bra     serpt_3                 | Go deal with RTS/CTS if needed
     385
     386serpt_2:        move.w  obuftl(a0),d2           | Tail index to d2
     387                bsr     wrapout                 | Adjust for wraparound
     388                cmp.w   obufhd(a0),d2           | Compare to head index
     389                beq     serpt_4                 | Jump if buffer full
     390
     391                move.l  obuf(a0),a2             | Get buffer base address in a2
     392                move.b  d1,0(a2,d2)             | Put character in buffer
     393                move.w  d2,obuftl(a0)           | Update buffer tail index
     394
     395serpt_3:        bsr     serchk                  | Check status on our way out
     396                bsr     rtschk                  | Handle RTS protocol
     397                move.w  (a7)+,sr                | RESTORE INTERRUPTS
     398                andi    #0xFFFE,sr              | Clear carry flag = OK
     399                rts                             | Return to caller
     400
     401serpt_4:        bsr     serchk                  | Check status on our way out
     402                bsr     rtschk                  | Handle RTS protocol
     403                move.w  (a7)+,sr                | RESTORE INTERRUPTS
     404                ori     #0x0001,sr              | Set carry flag = buffer full
     405                rts                             | Return to caller
     406
     407                .page
     408
     409| midput -- Output to MIDI
     410| ------    --------------
     411midput:         move.w  sr,-(a7)                | Save status register
     412                ori.w   #IPL7,sr                | DISABLE INTERRUPTS
     413                move.b  ACIA_ISR(a1),isr(a0)    | Get ACIA isr
     414                move.b  ACIA_CSR(a1),csr(a0)    | Get ACIA csr
     415                btst.b  #6,isr(a0)              | Is ACIA still sending ?
     416                beq     midpt_2                 | Jump if so
     417
     418                move.w  obufhd(a0),d2           | Head index to d2
     419                cmp.w   obuftl(a0),d2           | Compare to tail index
     420                bne     midpt_2                 | Jump if buffer not empty
     421
     422                move.b  d1,ACIA_TDR(a1)         | Give byte to ACIA to send
     423                bra     midpt_3                 | Go set final status and exit
     424
     425midpt_2:        move.w  obuftl(a0),d2           | Tail index to d2
     426                bsr     wrapout                 | Adjust for wraparound
     427                cmp.w   obufhd(a0),d2           | Compare to head index
     428                beq     midpt_4                 | Jump if buffer full
     429
     430                move.l  obuf(a0),a2             | Get buffer base address in a2
     431                move.b  d1,0(a2,d2)             | Put character in buffer
     432                move.w  d2,obuftl(a0)           | Update buffer tail index
     433
     434midpt_3:        bsr     midchk                  | Check status on our way out
     435                move.w  (a7)+,sr                | RESTORE INTERRUPTS
     436                andi    #0xFFFE,sr              | Clear carry flag = OK
     437                rts                             | Return to caller
     438
     439midpt_4:        bsr     midchk                  | Check status on our way out
     440                move.w  (a7)+,sr                | RESTORE INTERRUPTS
     441                ori     #0x0001,sr              | Set carry flag = buffer full
     442                rts                             | Return to caller
     443
     444                .page
     445
     446| rtschk -- Check RTS mode and turn on RTS if it's enabled
     447| ------    ----------------------------------------------
     448rtschk:         btst    #1,linedisc(a0)         | RTS/CTS mode set ?
     449                beq     rtsexit                 | Jump to exit if not
     450
     451| rtson -- Turn on RTS line
     452| -----    ----------------
     453rtson:          move.b  cfr1(a0),d0             | Pick up CFR1 image
     454                bclr    #0,d0                   | Turn on RTS line  (0 = on)
     455                bra     rtscmn                  | Join common RTS code below
     456
     457| rtsoff -- Turn off RTS line
     458| ------    -----------------
     459rtsoff:         move.b  cfr1(a0),d0             | Pick up CFR1 image
     460                bset    #0,d0                   | Turn off RTS line  (1 = off)
     461
     462rtscmn:         bset    #7,d0                   | Make sure MS bit is set
     463                move.b  d0,cfr1(a0)             | Update CFR1 image
     464                move.b  d0,ACIA_CFR(a1)         | Send CFR to hardware
     465
     466rtsexit:        rts                             | Return to caller
     467
     468                .page
     469
     470| wrapin -- Check input pointer for wraparound
     471| ------    ----------------------------------
     472wrapin:         add.w   #1,d1                   | Head index +1
     473                cmp.w   ibufsize(a0),d1         | = buffer size ?
     474                bcs     wrapin1                 | Jump if not
     475
     476                moveq.l #0,d1                   | Wraparound
     477
     478wrapin1:        rts                             | Return to caller
     479
     480| wrapout -- Check output pointer for wraparound
     481| -------    -----------------------------------
     482wrapout:        addq.w  #1,d2                   | Tail index +1
     483                cmp.w   obufsize(a0),d2         | = buffer size ?
     484                bcs     wrapout1                | Jump if not
     485
     486                moveq.l #0,d2                   | Wrap around if so
     487
     488wrapout1:       rts                             | Return to caller
     489
     490                .page
     491
     492| _setsio -- setsio() -- initialize serial I/O vectors and DCD interrupts
     493| -------    ------------------------------------------------------------
     494_setsio:        move.w  sr,-(a7)                | Preserve status register
     495                ori.w   #IPL7,sr                | DISABLE INTERRUPTS
     496
     497                lea     nulsiox,a0              | Get null return address
     498                move.l  a0,_foot1               | Initialize foot1 vector
     499                move.l  a0,_foot2               | Initialize foot2 vector
     500                move.l  a0,_pulse1              | Initialize pulse1 vector
     501                move.l  a0,_pulse2              | Initialize pulse2 vector
     502
     503                lea     SR1ACIA,a1              | Point at Serial-1 ACIA
     504                move.b  #0x90,ACIA_IER(a1)      | Enable DCD interrupts
     505
     506                lea     SR2ACIA,a1              | Point at Serial-2 ACIA
     507                move.b  #0x90,ACIA_IER(a1)      | Enable DCD interrupts
     508
     509                lea     MC1ACIA,a1              | Point at MIDI-1 ACIA
     510                move.b  #0x90,ACIA_IER(a1)      | Enable DCD interrupts
     511
     512                lea     MC2ACIA,a1              | Point at MIDI-2 ACIA
     513                move.b  #0x90,ACIA_IER(a1)      | Enable DCD interrupts
     514
     515                lea     serintr,a0              | Initialize interrupt vector
     516                move.l  a0,SERVECT              | ... in processor RAM
     517
     518                move.w  (a7)+,sr                | RESTORE INTERRUPTS
     519
     520nulsiox:        rts                             | Return to caller
     521
    522522                .bss
    523 *
    524 * DCD interrupt processor vectors
    525 * -------------------------------
    526 _foot1:         .ds.l   1                       * short (*foot1)();
    527 _foot2:         .ds.l   1                       * short (*foot2)();
    528 _pulse1:        .ds.l   1                       * short (*pulse1)();
    529 _pulse2:        .ds.l   1                       * short (*pulse2)();
    530 *
     523
     524| DCD interrupt processor vectors
     525| -------------------------------
     526_foot1:         .ds.l   1                       | short (|foot1)();
     527_foot2:         .ds.l   1                       | short (|foot2)();
     528_pulse1:        .ds.l   1                       | short (|pulse1)();
     529_pulse2:        .ds.l   1                       | short (|pulse2)();
     530
    531531                .end

  • ram/sreset.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * sreset.s -- reset score highlighting
    3 * Version 14 -- 1988-07-28 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| sreset.s -- reset score highlighting
     3| Version 14 -- 1988-07-28 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
    7                 .xdef   _sreset         * sreset()
    8 *
    9                 .xref   _vputa          * vputa(sbase, row, col, attrib)
    10 *
    11                 .xref   _ndisp          * WORD - display number
    12                 .xref   _obj8           * LONG - object base address
    13                 .xref   _vrbw08         * WORD - detail word for bit 8
    14                 .xref   _vrbw09         * WORD - detail word for bit 9
    15                 .xref   _vrbw10         * WORD - detail word for bit 10
    16                 .xref   _vrbw11         * WORD - detail word for bit 11
    17                 .xref   _vrbw12         * WORD - detail word for bit 12
    18                 .xref   _vrbw13         * WORD - detail word for bit 13
    19                 .xref   _vrbw14         * WORD - detail word for bit 14
    20                 .xref   _vrbw15         * WORD - detail word for bit 15
    21                 .xref   _vrcw           * WORD - video reset control word
    22 *
    23 ROW             .equ    4
    24 COL             .equ    6
    25 ATR             .equ    8
    26 *
    27 AT01            .equ    $0014
    28 AT04            .equ    $0013
    29 AT05            .equ    $0014
    30 AT06            .equ    $0013
    31 AT07            .equ    $0014
    32 AT08            .equ    $0013
    33 AT09            .equ    $0014
    34 AT10            .equ    $0013
    35 AT11            .equ    $0012
    36 AT12            .equ    $0012
    37 *
    38                 .page
    39 *
    40 * sreset() -- reset highlighting
    41 * --------    ------------------
    42 _sreset:        link    a6,#0           * link stack frame
    43                 cmp.w   #2,_ndisp       * see if we should update display
    44                 bne     srsexit         * jump if not
    45 *
    46                 move.w  _vrcw,d0        * get and check vrcw
    47                 bne     srs0            * jump if something to do
    48 *
    49 srsexit:        unlk    a6              * unlink stack frame
    50                 rts                     * return to caller
    51 *
    52 srs0:           move.w  sr,d1           * <<<<< disable interrupts >>>>>
    53                 ori.w   #$0700,sr       * ...
    54 *
    55                 move.w  _vrcw,vrcw      * make local copies of control variables
    56                 clr.w   _vrcw           * ... and clear them for the next pass
    57                 move.w  _vrbw08,vrbw08  * ...
    58                 clr.w   _vrbw08         * ...
    59                 move.w  _vrbw09,vrbw09  * ...
    60                 clr.w   _vrbw09         * ...
    61                 move.w  _vrbw10,vrbw10  * ...
    62                 clr.w   _vrbw10         * ...
    63                 move.w  _vrbw11,vrbw11  * ...
    64                 clr.w   _vrbw11         * ...
    65                 move.w  _vrbw12,vrbw12  * ...
    66                 clr.w   _vrbw12         * ...
    67                 move.w  _vrbw13,vrbw13  * ...
    68                 clr.w   _vrbw13         * ...
    69                 move.w  _vrbw14,vrbw14  * ...
    70                 clr.w   _vrbw14         * ...
    71                 move.w  _vrbw15,vrbw15  * ...
    72                 clr.w   _vrbw15         * ...
    73 *
    74                 move.w  d1,sr           * <<<<< restore interrupts >>>>>
    75 *
    76 * Setup STACK for subsequent calls to vputa(sbase, row, col, atr):
    77 *
    78 *       0(a7)   sbase
    79 *
    80 *       4(a7)   row     ROW
    81 *       6(a7)   col     COL
    82 *       8(a7)   atr     ATR
    83 *
    84                 clr.w   -(a7)           * put dummy attribute on stack
    85                 clr.w   -(a7)           * put dummy column on stack
    86                 clr.w   -(a7)           * put dummy row on stack
    87                 move.l  _obj8,-(a7)     * put sbase on stack
    88 *
    89                 .page
    90 *
    91 * assignment
    92 * ----------
    93                 btst    #0,d0           * assignment ?
    94                 beq     srs1            * jump if not
    95 *
    96                 move.w  #AT04,ATR(a7)   * put attribute on stack
    97                 move.w  #1,ROW(a7)      * put row on stack
    98                 move.w  #11,COL(a7)     * put 1st column on stack
    99                 jsr     _vputa          * reset first column
    100                 move.w  #12,COL(a7)     * put 2nd column on stack
    101                 jsr     _vputa          * reset second column
    102                 move.w  vrcw,d0         * restore vrcw to d0
    103 *
    104 * tuning
    105 * ------
    106 srs1:           btst    #1,d0           * tuning ?
    107                 beq     srs2            * jump if not
    108 *
    109                 move.w  #AT05,ATR(a7)   * put attribute on stack
    110                 move.w  #1,ROW(a7)      * put row on stack
    111                 move.w  #19,COL(a7)     * put column on stack
    112                 jsr     _vputa          * reset column
    113                 move.w  vrcw,d0         * restore vrcw to d0
    114 *
    115 * tempo
    116 * -----
    117 srs2:           btst    #2,d0           * tempo ?
    118                 beq     srs3            * jump if not
    119 *
    120                 move.w  #AT06,ATR(a7)   * put attribute on stack
    121                 move.w  #1,ROW(a7)      * put row on stack
    122                 move.w  #27,COL(a7)     * put 1st column on stack
    123                 jsr     _vputa          * reset first column
    124                 move.w  #28,COL(a7)     * put 2nd column on stack
    125                 jsr     _vputa          * reset second column
    126                 move.w  #29,COL(a7)     * put 3rd column on stack
    127                 jsr     _vputa          * reset third column
    128                 move.w  vrcw,d0         * restore vrcw to d0
    129 *
    130                 .page
    131 *
    132 * interpolate
    133 * -----------
    134 srs3:           btst    #3,d0           * interpolate ?
    135                 beq     srs4            * jump if not
    136 *
    137                 move.w  #AT07,ATR(a7)   * put attribute on stack
    138                 move.w  #1,ROW(a7)      * put row on stack
    139                 move.w  #35,COL(a7)     * put 1st column on stack
    140                 jsr     _vputa          * reset first column
    141                 move.w  #36,COL(a7)     * put 2nd column on stack
    142                 jsr     _vputa          * reset second column
    143                 move.w  #37,COL(a7)     * put 3rd column on stack
    144                 jsr     _vputa          * reset third column
    145                 move.w  #38,COL(a7)     * put 4th column on stack
    146                 jsr     _vputa          * reset fourth column
    147                 move.w  vrcw,d0         * restore vrcw to d0
    148 *
    149 * section begin
    150 * -------------
    151 srs4:           btst    #4,d0           * section begin ?
    152                 beq     srs5            * jump if not
    153 *
    154                 move.w  #AT01,ATR(a7)   * put attribute on stack
    155                 move.w  #0,ROW(a7)      * put row on stack
    156                 move.w  #6,COL(a7)      * put 1st column on stack
    157                 jsr     _vputa          * reset first column
    158                 move.w  #7,COL(a7)      * put 2nd column on stack
    159                 jsr     _vputa          * reset second column
    160 *
    161                 .page
    162 *
    163 * punch in
    164 * --------
    165 srs5:           btst    #5,d0           * punch in ?
    166                 beq     srs6            * jump if not
    167 *
    168                 move.w  #AT09,ATR(a7)   * put attribute on stack
    169                 move.w  #1,ROW(a7)      * put row on stack
    170                 move.w  #50,COL(a7)     * put 1st column on stack
    171                 jsr     _vputa          * reset first column
    172                 move.w  #51,COL(a7)     * put 2nd column on stack
    173                 jsr     _vputa          * reset second column
    174                 move.w  vrcw,d0         * restore vrcw to d0
    175 *
    176 * punch out
    177 * ---------
    178 srs6:           btst    #6,d0           * punch out ?
    179                 beq     srs7            * jump if not
    180 *
    181                 move.w  #AT09,ATR(a7)   * put attribute on stack
    182                 move.w  #1,ROW(a7)      * put row on stack
    183                 move.w  #53,COL(a7)     * put 1st column on stack
    184                 jsr     _vputa          * reset first column
    185                 move.w  #54,COL(a7)     * put 2nd column on stack
    186                 jsr     _vputa          * reset second column
    187                 move.w  #55,COL(a7)     * put 3rd column on stack
    188                 jsr     _vputa          * reset third column
    189                 move.w  vrcw,d0         * restore vrcw to d0
    190 *
    191 * Output
    192 * ------
    193 srs7:           btst    #7,d0           * output ?
    194                 beq     srs8            * jump if not
    195 *
    196                 move.w  #AT10,ATR(a7)   * put attribute on stack
    197                 move.w  #1,ROW(a7)      * put row on stack
    198                 move.w  #57,COL(a7)     * put 1st column on stack
    199                 jsr     _vputa          * reset first column
    200                 move.w  #58,COL(a7)     * put 2nd column on stack
    201                 jsr     _vputa          * reset second column
    202                 move.w  #59,COL(a7)     * put 3rd column on stack
    203                 jsr     _vputa          * reset third column
    204                 move.w  #60,COL(a7)     * put 4th column on stack
    205                 jsr     _vputa          * reset fourth column
    206                 move.w  #61,COL(a7)     * put 5th column on stack
    207                 jsr     _vputa          * reset fifth column
    208                 move.w  #62,COL(a7)     * put 6th column on stack
    209                 jsr     _vputa          * reset sixth column
    210                 move.w  vrcw,d0         * restore vrcw to d0
    211 *
    212                 .page
    213 *
    214 * instrument
    215 * ----------
    216 srs8:           btst    #8,d0           * instrument ?
    217                 beq     srs9            * jump if not
    218 *
    219                 move.w  #2,ROW(a7)      * put row on stack
    220                 move.w  #AT11,ATR(a7)   * put attribute on stack
    221                 btst    #0,vrbw08+1     * group 1 ?
    222                 beq     srs8a           * jump if not
    223 *
    224                 move.w  #7,COL(a7)      * put 1st column on stack
    225                 jsr     _vputa          * reset first column
    226                 move.w  #8,COL(a7)      * put 2nd column on stack
    227                 jsr     _vputa          * reset second column
    228 *
    229 srs8a:          btst    #1,vrbw08+1     * group 2 ?
    230                 beq     srs8b           * jump if not
    231 *
    232                 move.w  #12,COL(a7)     * put 1st column on stack
    233                 jsr     _vputa          * reset first character
    234                 move.w  #13,COL(a7)     * put 2nd column on stack
    235                 jsr     _vputa          * reset second character
    236 *
    237 srs8b:          btst    #2,vrbw08+1     * group 3 ?
    238                 beq     srs8c           * jump if not
    239 *
    240                 move.w  #17,COL(a7)     * put 1st column on stack
    241                 jsr     _vputa          * reset first character
    242                 move.w  #18,COL(a7)     * put 2nd column on stack
    243                 jsr     _vputa          * reset second character
    244 *
    245 srs8c:          btst    #3,vrbw08+1     * group 4 ?
    246                 beq     srs8d           * jump if not
    247 *
    248                 move.w  #22,COL(a7)     * put 1st column on stack
    249                 jsr     _vputa          * reset first character
    250                 move.w  #23,COL(a7)     * put 2nd column on stack
    251                 jsr     _vputa          * reset second character
    252 *
    253                 .page
    254 *
    255 srs8d:          btst    #4,vrbw08+1     * group 5 ?
    256                 beq     srs8e           * jump if not
    257 *
    258                 move.w  #27,COL(a7)     * put 1st column on stack
    259                 jsr     _vputa          * reset first character
    260                 move.w  #28,COL(a7)     * put 2nd column on stack
    261                 jsr     _vputa          * reset second character
    262 *
    263 srs8e:          btst    #5,vrbw08+1     * group 6 ?
    264                 beq     srs8f           * jump if not
    265 *
    266                 move.w  #32,COL(a7)     * put 1st column on stack
    267                 jsr     _vputa          * reset first character
    268                 move.w  #33,COL(a7)     * put 2nd column on stack
    269                 jsr     _vputa          * reset second character
    270 *
    271 srs8f:          btst    #6,vrbw08+1     * group 7 ?
    272                 beq     srs8g           * jump if not
    273 *
    274                 move.w  #37,COL(a7)     * put 1st column on stack
    275                 jsr     _vputa          * reset first character
    276                 move.w  #38,COL(a7)     * put 2nd column on stack
    277                 jsr     _vputa          * reset second character
    278 *
    279 srs8g:          btst    #7,vrbw08+1     * group 8 ?
    280                 beq     srs8h           * jump if not
    281 *
    282                 move.w  #42,COL(a7)     * put 1st column on stack
    283                 jsr     _vputa          * reset first character
    284                 move.w  #43,COL(a7)     * put 2nd column on stack
    285                 jsr     _vputa          * reset second character
    286 *
    287                 .page
    288 *
    289 srs8h:          btst    #0,vrbw08       * group 9
    290                 beq     srs8j           * jump if not
    291 *
    292                 move.w  #47,COL(a7)     * put 1st column on stack
    293                 jsr     _vputa          * reset first character
    294                 move.w  #48,COL(a7)     * put 2nd column on stack
    295                 jsr     _vputa          * reset second character
    296 *
    297 srs8j:          btst    #1,vrbw08       * group 10
    298                 beq     srs8k           * jump if not
    299 *
    300                 move.w  #52,COL(a7)     * put 1st column on stack
    301                 jsr     _vputa          * reset first character
    302                 move.w  #53,COL(a7)     * put 2nd column on stack
    303                 jsr     _vputa          * reset second character
    304 *
    305 srs8k:          btst    #2,vrbw08       * group 11
    306                 beq     srs8m           * jump if not
    307 *
    308                 move.w  #57,COL(a7)     * put 1st column on stack
    309                 jsr     _vputa          * reset first character
    310                 move.w  #58,COL(a7)     * put 2nd column on stack
    311                 jsr     _vputa          * reset second character
    312 *
    313 srs8m:          btst    #3,vrbw08       * group 12
    314                 beq     srs8x           * jump if not
    315 *
    316                 move.w  #62,COL(a7)     * put 1st column on stack
    317                 jsr     _vputa          * reset first character
    318                 move.w  #63,COL(a7)     * put 2nd column on stack
    319                 jsr     _vputa          * reset second character
    320 *
    321 srs8x:          move.w  vrcw,d0         * restore vrcw to d0
    322 *
    323                 .page
    324 *
    325 * transpose
    326 * ---------
    327 srs9:           btst    #9,d0           * transpose ?
    328                 beq     srs10           * jump if not
    329 *
    330                 move.w  #AT11,ATR(a7)   * put attribute on stack
    331                 move.w  #3,ROW(a7)      * put row on stack
    332                 btst    #0,vrbw09+1     * group 1 ?
    333                 beq     srs9a           * jump if not
    334 *
    335                 move.w  #5,COL(a7)      * put 1st column on stack
    336                 jsr     _vputa          * reset first column
    337                 move.w  #6,COL(a7)      * put 2nd column on stack
    338                 jsr     _vputa          * reset second column
    339                 move.w  #7,COL(a7)      * put 3rd column on stack
    340                 jsr     _vputa          * reset third column
    341                 move.w  #8,COL(a7)      * put 4th column on stack
    342                 jsr     _vputa          * reset fourth column
    343 *
    344 srs9a:          btst    #1,vrbw09+1     * group 2 ?
    345                 beq     srs9b           * jump if not
    346 *
    347                 move.w  #10,COL(a7)     * put 1st column on stack
    348                 jsr     _vputa          * reset first column
    349                 move.w  #11,COL(a7)     * put 2nd column on stack
    350                 jsr     _vputa          * reset second column
    351                 move.w  #12,COL(a7)     * put 3rd column on stack
    352                 jsr     _vputa          * reset third column
    353                 move.w  #13,COL(a7)     * put 4th column on stack
    354                 jsr     _vputa          * reset fourth column
    355 *
    356 srs9b:          btst    #2,vrbw09+1     * group 3 ?
    357                 beq     srs9c           * jump if not
    358 *
    359                 move.w  #15,COL(a7)     * put 1st column on stack
    360                 jsr     _vputa          * reset first column
    361                 move.w  #16,COL(a7)     * put 2nd column on stack
    362                 jsr     _vputa          * reset second column
    363                 move.w  #17,COL(a7)     * put 3rd column on stack
    364                 jsr     _vputa          * reset third column
    365                 move.w  #18,COL(a7)     * put 4th column on stack
    366                 jsr     _vputa          * reset fourth column
    367 *
    368                 .page
    369 *
    370 srs9c:          btst    #3,vrbw09+1     * group 4 ?
    371                 beq     srs9d           * jump if not
    372 *
    373                 move.w  #20,COL(a7)     * put 1st column on stack
    374                 jsr     _vputa          * reset first column
    375                 move.w  #21,COL(a7)     * put 2nd column on stack
    376                 jsr     _vputa          * reset second column
    377                 move.w  #22,COL(a7)     * put 3rd column on stack
    378                 jsr     _vputa          * reset third column
    379                 move.w  #23,COL(a7)     * put 4th column on stack
    380                 jsr     _vputa          * reset fourth column
    381 *
    382 srs9d:          btst    #4,vrbw09+1     * group 5 ?
    383                 beq     srs9e           * jump if not
    384 *
    385                 move.w  #25,COL(a7)     * put 1st column on stack
    386                 jsr     _vputa          * reset first column
    387                 move.w  #26,COL(a7)     * put 2nd column on stack
    388                 jsr     _vputa          * reset second column
    389                 move.w  #27,COL(a7)     * put 3rd column on stack
    390                 jsr     _vputa          * reset third column
    391                 move.w  #28,COL(a7)     * put 4th column on stack
    392                 jsr     _vputa          * reset fourth column
    393 *
    394 srs9e:          btst    #5,vrbw09+1     * group 6 ?
    395                 beq     srs9f           * jump if not
    396 *
    397                 move.w  #30,COL(a7)     * put 1st column on stack
    398                 jsr     _vputa          * reset first column
    399                 move.w  #31,COL(a7)     * put 2nd column on stack
    400                 jsr     _vputa          * reset second column
    401                 move.w  #32,COL(a7)     * put 3rd column on stack
    402                 jsr     _vputa          * reset third column
    403                 move.w  #33,COL(a7)     * put 4th column on stack
    404                 jsr     _vputa          * reset fourth column
    405 *
    406                 .page
    407 *
    408 srs9f:          btst    #6,vrbw09+1     * group 7 ?
    409                 beq     srs9g           * jump if not
    410 *
    411                 move.w  #35,COL(a7)     * put 1st column on stack
    412                 jsr     _vputa          * reset first column
    413                 move.w  #36,COL(a7)     * put 2nd column on stack
    414                 jsr     _vputa          * reset second column
    415                 move.w  #37,COL(a7)     * put 3rd column on stack
    416                 jsr     _vputa          * reset third column
    417                 move.w  #38,COL(a7)     * put 4th column on stack
    418                 jsr     _vputa          * reset fourth column
    419 *
    420 srs9g:          btst    #7,vrbw09+1     * group 8 ?
    421                 beq     srs9h           * jump if not
    422 *
    423                 move.w  #40,COL(a7)     * put 1st column on stack
    424                 jsr     _vputa          * reset first column
    425                 move.w  #41,COL(a7)     * put 2nd column on stack
    426                 jsr     _vputa          * reset second column
    427                 move.w  #42,COL(a7)     * put 3rd column on stack
    428                 jsr     _vputa          * reset third column
    429                 move.w  #43,COL(a7)     * put 4th column on stack
    430                 jsr     _vputa          * reset fourth column
    431 *
    432 srs9h:          btst    #0,vrbw09       * group 9
    433                 beq     srs9j           * jump if not
    434 *
    435                 move.w  #45,COL(a7)     * put 1st column on stack
    436                 jsr     _vputa          * reset first column
    437                 move.w  #46,COL(a7)     * put 2nd column on stack
    438                 jsr     _vputa          * reset second column
    439                 move.w  #47,COL(a7)     * put 3rd column on stack
    440                 jsr     _vputa          * reset third column
    441                 move.w  #48,COL(a7)     * put 4th column on stack
    442                 jsr     _vputa          * reset fourth column
    443 *
    444                 .page
    445 *
    446 srs9j:          btst    #1,vrbw09       * group 10
    447                 beq     srs9k           * jump if not
    448 *
    449                 move.w  #50,COL(a7)     * put 1st column on stack
    450                 jsr     _vputa          * reset first column
    451                 move.w  #51,COL(a7)     * put 2nd column on stack
    452                 jsr     _vputa          * reset second column
    453                 move.w  #52,COL(a7)     * put 3rd column on stack
    454                 jsr     _vputa          * reset third column
    455                 move.w  #53,COL(a7)     * put 4th column on stack
    456                 jsr     _vputa          * reset fourth column
    457 *
    458 srs9k:          btst    #2,vrbw09       * group 11
    459                 beq     srs9m           * jump if not
    460 *
    461                 move.w  #55,COL(a7)     * put 1st column on stack
    462                 jsr     _vputa          * reset first column
    463                 move.w  #56,COL(a7)     * put 2nd column on stack
    464                 jsr     _vputa          * reset second column
    465                 move.w  #57,COL(a7)     * put 3rd column on stack
    466                 jsr     _vputa          * reset third column
    467                 move.w  #58,COL(a7)     * put 4th column on stack
    468                 jsr     _vputa          * reset fourth column
    469 *
    470 srs9m:          btst    #3,vrbw09       * group 12
    471                 beq     srs9x           * jump if not
    472 *
    473                 move.w  #60,COL(a7)     * put 1st column on stack
    474                 jsr     _vputa          * reset first column
    475                 move.w  #61,COL(a7)     * put 2nd column on stack
    476                 jsr     _vputa          * reset second column
    477                 move.w  #62,COL(a7)     * put 3rd column on stack
    478                 jsr     _vputa          * reset third column
    479                 move.w  #63,COL(a7)     * put 4th column on stack
    480                 jsr     _vputa          * reset fourth column
    481 *
    482 srs9x:          move.w  vrcw,d0         * restore vrcw to d0
    483 *
    484                 .page
    485 *
    486 * dynamics
    487 * --------
    488 srs10:          btst    #10,d0          * dynamics ?
    489                 beq     srs11           * jump if not
    490 *
    491                 move.w  #AT11,ATR(a7)   * put attribute on stack
    492                 move.w  #4,ROW(a7)      * put row on stack
    493                 btst    #0,vrbw10+1     * group 1 ?
    494                 beq     srs10a          * jump if not
    495 *
    496                 move.w  #6,COL(a7)      * put column on stack
    497                 jsr     _vputa          * reset column
    498 *
    499 srs10a:         btst    #1,vrbw10+1     * group 2 ?
    500                 beq     srs10b          * jump if not
    501 *
    502                 move.w  #11,COL(a7)     * put column on stack
    503                 jsr     _vputa          * reset column
    504 *
    505 srs10b:         btst    #2,vrbw10+1     * group 3 ?
    506                 beq     srs10c          * jump if not
    507 *
    508                 move.w  #16,COL(a7)     * put column on stack
    509                 jsr     _vputa          * reset column
    510 *
    511 srs10c:         btst    #3,vrbw10+1     * group 4 ?
    512                 beq     srs10d          * jump if not
    513 *
    514                 move.w  #21,COL(a7)     * put column on stack
    515                 jsr     _vputa          * reset column
    516 *
    517                 .page
    518 *
    519 srs10d:         btst    #4,vrbw10+1     * group 5 ?
    520                 beq     srs10e          * jump if not
    521 *
    522                 move.w  #26,COL(a7)     * put column on stack
    523                 jsr     _vputa          * reset column
    524 *
    525 srs10e:         btst    #5,vrbw10+1     * group 6 ?
    526                 beq     srs10f          * jump if not
    527 *
    528                 move.w  #31,COL(a7)     * put column on stack
    529                 jsr     _vputa          * reset column
    530 *
    531 srs10f:         btst    #6,vrbw10+1     * group 7 ?
    532                 beq     srs10g          * jump if not
    533 *
    534                 move.w  #36,COL(a7)     * put column on stack
    535                 jsr     _vputa          * reset column
    536 *
    537 srs10g:         btst    #7,vrbw10+1     * group 8 ?
    538                 beq     srs10h          * jump if not
    539 *
    540                 move.w  #41,COL(a7)     * put column on stack
    541                 jsr     _vputa          * reset column
    542 *
    543                 .page
    544 *
    545 srs10h:         btst    #0,vrbw10       * group 9
    546                 beq     srs10j          * jump if not
    547 *
    548                 move.w  #46,COL(a7)     * put column on stack
    549                 jsr     _vputa          * reset column
    550 *
    551 srs10j:         btst    #1,vrbw10       * group 10
    552                 beq     srs10k          * jump if not
    553 *
    554                 move.w  #51,COL(a7)     * put column on stack
    555                 jsr     _vputa          * reset column
    556 *
    557 srs10k:         btst    #2,vrbw10       * group 11
    558                 beq     srs10m          * jump if not
    559 *
    560                 move.w  #56,COL(a7)     * put column on stack
    561                 jsr     _vputa          * reset column
    562 *
    563 srs10m:         btst    #3,vrbw10       * group 12
    564                 beq     srs10x          * jump if not
    565 *
    566                 move.w  #61,COL(a7)     * put column on stack
    567                 jsr     _vputa          * reset column
    568 *
    569 srs10x:         move.w  vrcw,d0         * restore vrcw to d0
    570 *
    571                 .page
    572 *
    573 * location
    574 * --------
    575 srs11:          btst    #11,d0          * location ?
    576                 beq     srs12           * jump if not
    577 *
    578                 move.w  #AT11,ATR(a7)   * put attribute on stack
    579                 move.w  #4,ROW(a7)      * put row on stack
    580                 btst    #0,vrbw11+1     * group 1 ?
    581                 beq     srs11a          * jump if not
    582 *
    583                 move.w  #8,COL(a7)      * put column on stack
    584                 jsr     _vputa          * reset column
    585 *
    586 srs11a:         btst    #1,vrbw11+1     * group 2 ?
    587                 beq     srs11b          * jump if not
    588 *
    589                 move.w  #13,COL(a7)     * put column on stack
    590                 jsr     _vputa          * reset column
    591 *
    592 srs11b:         btst    #2,vrbw11+1     * group 3 ?
    593                 beq     srs11c          * jump if not
    594 *
    595                 move.w  #18,COL(a7)     * put column on stack
    596                 jsr     _vputa          * reset column
    597 *
    598 srs11c:         btst    #3,vrbw11+1     * group 4 ?
    599                 beq     srs11d          * jump if not
    600 *
    601                 move.w  #23,COL(a7)     * put column on stack
    602                 jsr     _vputa          * reset column
    603 *
    604                 .page
    605 *
    606 srs11d:         btst    #4,vrbw11+1     * group 5 ?
    607                 beq     srs11e          * jump if not
    608 *
    609                 move.w  #28,COL(a7)     * put column on stack
    610                 jsr     _vputa          * reset column
    611 *
    612 srs11e:         btst    #5,vrbw11+1     * group 6 ?
    613                 beq     srs11f          * jump if not
    614 *
    615                 move.w  #33,COL(a7)     * put column on stack
    616                 jsr     _vputa          * reset column
    617 *
    618 srs11f:         btst    #6,vrbw11+1     * group 7 ?
    619                 beq     srs11g          * jump if not
    620 *
    621                 move.w  #38,COL(a7)     * put column on stack
    622                 jsr     _vputa          * reset column
    623 *
    624 srs11g:         btst    #7,vrbw11+1     * group 8 ?
    625                 beq     srs11h          * jump if not
    626 *
    627                 move.w  #43,COL(a7)     * put column on stack
    628                 jsr     _vputa          * reset column
    629 *
    630                 .page
    631 *
    632 srs11h:         btst    #0,vrbw11       * group 9
    633                 beq     srs11j          * jump if not
    634 *
    635                 move.w  #48,COL(a7)     * put column on stack
    636                 jsr     _vputa          * reset column
    637 *
    638 srs11j:         btst    #1,vrbw11       * group 10
    639                 beq     srs11k          * jump if not
    640 *
    641                 move.w  #53,COL(a7)     * put column on stack
    642                 jsr     _vputa          * reset column
    643 *
    644 srs11k:         btst    #2,vrbw11       * group 11
    645                 beq     srs11m          * jump if not
    646 *
    647                 move.w  #58,COL(a7)     * put column on stack
    648                 jsr     _vputa          * reset column
    649 *
    650 srs11m:         btst    #3,vrbw11       * group 12
    651                 beq     srs11x          * jump if not
    652 *
    653                 move.w  #63,COL(a7)     * put column on stack
    654                 jsr     _vputa          * reset column
    655 *
    656 srs11x:         move.w  vrcw,d0         * restore vrcw to d0
    657 *
    658                 .page
    659 *
    660 * velocity
    661 * --------
    662 srs12:          btst    #12,d0          * velocity ?
    663                 beq     srs13           * jump if not
    664 *
    665                 move.w  #AT11,ATR(a7)   * put attribute on stack
    666                 move.w  #5,ROW(a7)      * put row on stack
    667                 btst    #0,vrbw12+1     * group 1 ?
    668                 beq     srs12a          * jump if not
    669 *
    670                 move.w  #6,COL(a7)      * put 1st column on stack
    671                 jsr     _vputa          * reset first column
    672                 move.w  #7,COL(a7)      * put 2nd column on stack
    673                 jsr     _vputa          * reset second column
    674                 move.w  #8,COL(a7)      * put 3rd column on stack
    675                 jsr     _vputa          * reset third column
    676 *
    677 srs12a:         btst    #1,vrbw12+1     * group 2 ?
    678                 beq     srs12b          * jump if not
    679 *
    680                 move.w  #11,COL(a7)     * put 1st column on stack
    681                 jsr     _vputa          * reset first column
    682                 move.w  #12,COL(a7)     * put 2nd column on stack
    683                 jsr     _vputa          * reset second column
    684                 move.w  #13,COL(a7)     * put 3rd column on stack
    685                 jsr     _vputa          * reset third column
    686 *
    687 srs12b:         btst    #2,vrbw12+1     * group 3 ?
    688                 beq     srs12c          * jump if not
    689 *
    690                 move.w  #16,COL(a7)     * put 1st column on stack
    691                 jsr     _vputa          * reset first column
    692                 move.w  #17,COL(a7)     * put 2nd column on stack
    693                 jsr     _vputa          * reset second column
    694                 move.w  #18,COL(a7)     * put 3rd column on stack
    695                 jsr     _vputa          * reset third column
    696 *
    697                 .page
    698 *
    699 srs12c:         btst    #3,vrbw12+1     * group 4 ?
    700                 beq     srs12d          * jump if not
    701 *
    702                 move.w  #21,COL(a7)     * put 1st column on stack
    703                 jsr     _vputa          * reset first column
    704                 move.w  #22,COL(a7)     * put 2nd column on stack
    705                 jsr     _vputa          * reset second column
    706                 move.w  #23,COL(a7)     * put 3rd column on stack
    707                 jsr     _vputa          * reset third column
    708 *
    709 srs12d:         btst    #4,vrbw12+1     * group 5 ?
    710                 beq     srs12e          * jump if not
    711 *
    712                 move.w  #26,COL(a7)     * put 1st column on stack
    713                 jsr     _vputa          * reset first column
    714                 move.w  #27,COL(a7)     * put 2nd column on stack
    715                 jsr     _vputa          * reset second column
    716                 move.w  #28,COL(a7)     * put 3rd column on stack
    717                 jsr     _vputa          * reset third column
    718 *
    719 srs12e:         btst    #5,vrbw12+1     * group 6 ?
    720                 beq     srs12f          * jump if not
    721 *
    722                 move.w  #31,COL(a7)     * put 1st column on stack
    723                 jsr     _vputa          * reset first column
    724                 move.w  #32,COL(a7)     * put 2nd column on stack
    725                 jsr     _vputa          * reset second column
    726                 move.w  #33,COL(a7)     * put 3rd column on stack
    727                 jsr     _vputa          * reset third column
    728 *
    729                 .page
    730 *
    731 srs12f:         btst    #6,vrbw12+1     * group 7 ?
    732                 beq     srs12g          * jump if not
    733 *
    734                 move.w  #36,COL(a7)     * put 1st column on stack
    735                 jsr     _vputa          * reset first column
    736                 move.w  #37,COL(a7)     * put 2nd column on stack
    737                 jsr     _vputa          * reset second column
    738                 move.w  #38,COL(a7)     * put 3rd column on stack
    739                 jsr     _vputa          * reset third column
    740 *
    741 srs12g:         btst    #7,vrbw12+1     * group 8 ?
    742                 beq     srs12h          * jump if not
    743 *
    744                 move.w  #41,COL(a7)     * put 1st column on stack
    745                 jsr     _vputa          * reset first column
    746                 move.w  #42,COL(a7)     * put 2nd column on stack
    747                 jsr     _vputa          * reset second column
    748                 move.w  #43,COL(a7)     * put 3rd column on stack
    749                 jsr     _vputa          * reset third column
    750 *
    751 srs12h:         btst    #0,vrbw12       * group 9
    752                 beq     srs12j          * jump if not
    753 *
    754                 move.w  #46,COL(a7)     * put 1st column on stack
    755                 jsr     _vputa          * reset first column
    756                 move.w  #47,COL(a7)     * put 2nd column on stack
    757                 jsr     _vputa          * reset second column
    758                 move.w  #48,COL(a7)     * put 3rd column on stack
    759                 jsr     _vputa          * reset third column
    760 *
    761                 .page
    762 *
    763 srs12j:         btst    #1,vrbw12       * group 10
    764                 beq     srs12k          * jump if not
    765 *
    766                 move.w  #51,COL(a7)     * put 1st column on stack
    767                 jsr     _vputa          * reset first column
    768                 move.w  #52,COL(a7)     * put 2nd column on stack
    769                 jsr     _vputa          * reset second column
    770                 move.w  #53,COL(a7)     * put 3rd column on stack
    771                 jsr     _vputa          * reset third column
    772 *
    773 srs12k:         btst    #2,vrbw12       * group 11
    774                 beq     srs12m          * jump if not
    775 *
    776                 move.w  #56,COL(a7)     * put 1st column on stack
    777                 jsr     _vputa          * reset first column
    778                 move.w  #57,COL(a7)     * put 2nd column on stack
    779                 jsr     _vputa          * reset second column
    780                 move.w  #58,COL(a7)     * put 3rd column on stack
    781                 jsr     _vputa          * reset third column
    782 *
    783 srs12m:         btst    #3,vrbw12       * group 12
    784                 beq     srs12x          * jump if not
    785 *
    786                 move.w  #61,COL(a7)     * put 1st column on stack
    787                 jsr     _vputa          * reset first column
    788                 move.w  #62,COL(a7)     * put 2nd column on stack
    789                 jsr     _vputa          * reset second column
    790                 move.w  #63,COL(a7)     * put 3rd column on stack
    791                 jsr     _vputa          * reset third column
    792 *
    793 srs12x:         move.w  vrcw,d0         * restore vrcw to d0
    794 *
    795                 .page
    796 *
    797 * resolution
    798 * ----------
    799 srs13:          btst    #13,d0          * resolution ?
    800                 beq     srs14           * jump if not
    801 *
    802                 move.w  #AT12,ATR(a7)   * put attribute on stack
    803                 move.w  #7,ROW(a7)      * put row on stack
    804                 btst    #0,vrbw13+1     * variable 1 ?
    805                 beq     srs13a          * jump if not
    806 *
    807                 move.w  #6,COL(a7)      * put column on stack
    808                 jsr     _vputa          * reset column
    809 *
    810 srs13a:         btst    #1,vrbw13+1     * variable 2 ?
    811                 beq     srs13b          * jump if not
    812 *
    813                 move.w  #15,COL(a7)     * put column on stack
    814                 jsr     _vputa          * reset column
    815 *
    816 srs13b:         btst    #2,vrbw13+1     * variable 3 ?
    817                 beq     srs13c          * jump if not
    818 *
    819                 move.w  #24,COL(a7)     * put column on stack
    820                 jsr     _vputa          * reset column
    821 *
    822 srs13c:         btst    #3,vrbw13+1     * variable 4 ?
    823                 beq     srs13d          * jump if not
    824 *
    825                 move.w  #33,COL(a7)     * put column on stack
    826                 jsr     _vputa          * reset column
    827 *
    828 srs13d:         btst    #4,vrbw13+1     * variable 5 ?
    829                 beq     srs13e          * jump if not
    830 *
    831                 move.w  #42,COL(a7)     * put column on stack
    832                 jsr     _vputa          * reset column
    833 *
    834 srs13e:         btst    #5,vrbw13+1     * variable 6 ?
    835                 beq     srs13x          * jump if not
    836 *
    837                 move.w  #51,COL(a7)     * put column on stack
    838                 jsr     _vputa          * reset column
    839 *
    840 srs13x:         move.w  vrcw,d0         * restore vrcw to d0
    841 *
    842                 .page
    843 *
    844 * analog value
    845 * ------------
    846 srs14:          btst    #14,d0          * analog value ?
    847                 beq     srs15           * jump if not
    848 *
    849                 move.w  #AT12,ATR(a7)   * put attribute on stack
    850                 move.w  #7,ROW(a7)      * put row on stack
    851                 btst    #0,vrbw14+1     * variable 1 ?
    852                 beq     srs14a          * jump if not
    853 *
    854                 move.w  #8,COL(a7)      * put 1st column on stack
    855                 jsr     _vputa          * reset first column
    856                 move.w  #9,COL(a7)      * put 2nd column on stack
    857                 jsr     _vputa          * reset second column
    858                 move.w  #10,COL(a7)     * put 3rd column on stack
    859                 jsr     _vputa          * reset third column
    860                 move.w  #11,COL(a7)     * put 4th column on stack
    861                 jsr     _vputa          * reset fourth column
    862                 move.w  #12,COL(a7)     * put 5th column on stack
    863                 jsr     _vputa          * reset fifth column
    864 *
    865 srs14a:         btst    #1,vrbw14+1     * variable 2 ?
    866                 beq     srs14b          * jump if not
    867 *
    868                 move.w  #17,COL(a7)     * put 1st column on stack
    869                 jsr     _vputa          * reset first column
    870                 move.w  #18,COL(a7)     * put 2nd column on stack
    871                 jsr     _vputa          * reset second column
    872                 move.w  #19,COL(a7)     * put 3rd column on stack
    873                 jsr     _vputa          * reset third column
    874                 move.w  #20,COL(a7)     * put 4th column on stack
    875                 jsr     _vputa          * reset fourth column
    876                 move.w  #21,COL(a7)     * put 5th column on stack
    877                 jsr     _vputa          * reset fifth column
    878 *
    879                 .page
    880 *
    881 srs14b:         btst    #2,vrbw14+1     * variable 3 ?
    882                 beq     srs14c          * jump if not
    883 *
    884                 move.w  #26,COL(a7)     * put 1st column on stack
    885                 jsr     _vputa          * reset first column
    886                 move.w  #27,COL(a7)     * put 2nd column on stack
    887                 jsr     _vputa          * reset second column
    888                 move.w  #28,COL(a7)     * put 3rd column on stack
    889                 jsr     _vputa          * reset third column
    890                 move.w  #29,COL(a7)     * put 4th column on stack
    891                 jsr     _vputa          * reset fourth column
    892                 move.w  #30,COL(a7)     * put 5th column on stack
    893                 jsr     _vputa          * reset fifth column
    894 *
    895 srs14c:         btst    #3,vrbw14+1     * variable 4 ?
    896                 beq     srs14d          * jump if not
    897 *
    898                 move.w  #35,COL(a7)     * put 1st column on stack
    899                 jsr     _vputa          * reset first column
    900                 move.w  #36,COL(a7)     * put 2nd column on stack
    901                 jsr     _vputa          * reset second column
    902                 move.w  #37,COL(a7)     * put 3rd column on stack
    903                 jsr     _vputa          * reset third column
    904                 move.w  #38,COL(a7)     * put 4th column on stack
    905                 jsr     _vputa          * reset fourth column
    906                 move.w  #39,COL(a7)     * put 5th column on stack
    907                 jsr     _vputa          * reset fifth column
    908 *
    909                 .page
    910 *
    911 srs14d:         btst    #4,vrbw14+1     * variable 5 ?
    912                 beq     srs14e          * jump if not
    913 *
    914                 move.w  #44,COL(a7)     * put 1st column on stack
    915                 jsr     _vputa          * reset first column
    916                 move.w  #45,COL(a7)     * put 2nd column on stack
    917                 jsr     _vputa          * reset second column
    918                 move.w  #46,COL(a7)     * put 3rd column on stack
    919                 jsr     _vputa          * reset third column
    920                 move.w  #47,COL(a7)     * put 4th column on stack
    921                 jsr     _vputa          * reset fourth column
    922                 move.w  #48,COL(a7)     * put 5th column on stack
    923                 jsr     _vputa          * reset fifth column
    924 *
    925 srs14e:         btst    #5,vrbw14+1     * variable 6 ?
    926                 beq     srs14x          * jump if not
    927 *
    928                 move.w  #53,COL(a7)     * put 1st column on stack
    929                 jsr     _vputa          * reset first column
    930                 move.w  #54,COL(a7)     * put 2nd column on stack
    931                 jsr     _vputa          * reset second column
    932                 move.w  #55,COL(a7)     * put 3rd column on stack
    933                 jsr     _vputa          * reset third column
    934                 move.w  #56,COL(a7)     * put 4th column on stack
    935                 jsr     _vputa          * reset fourth column
    936                 move.w  #57,COL(a7)     * put 5th column on stack
    937                 jsr     _vputa          * reset fifth column
    938 *
    939 srs14x:         move.w  vrcw,d0         * restore vrcw to d0
    940 *
    941                 .page
    942 *
    943 * stop/next
    944 * ---------
    945 srs15:          btst    #15,d0          * stop/next ?
    946                 beq     srs16           * jump if not
    947 *
    948                 btst    #0,vrbw15       * stop ?
    949                 beq     srs15a          * jump if not
    950 *
    951                 move.w  #AT08,ATR(a7)   * put attribute on stack
    952                 move.w  #1,ROW(a7)      * put row on stack
    953                 move.w  #40,COL(a7)     * put 1st column on stack
    954                 jsr     _vputa          * reset first column
    955                 move.w  #41,COL(a7)     * put 2nd column on stack
    956                 jsr     _vputa          * reset second column
    957                 move.w  #42,COL(a7)     * put 3rd column on stack
    958                 jsr     _vputa          * reset third column
    959                 move.w  #43,COL(a7)     * put 4th column on stack
    960                 jsr     _vputa          * reset fourth column
    961 *
    962 srs15a:         btst    #1,vrbw15       * next ?
    963                 beq     srs16           * jump if not
    964 *
    965                 move.w  #AT08,ATR(a7)   * put attribute on stack
    966                 move.w  #1,ROW(a7)      * put row on stack
    967                 move.w  #45,COL(a7)     * put 1st column on stack
    968                 jsr     _vputa          * reset first column
    969                 move.w  #46,COL(a7)     * put 2nd column on stack
    970                 jsr     _vputa          * reset second column
    971                 move.w  #47,COL(a7)     * put 3rd column on stack
    972                 jsr     _vputa          * reset third column
    973                 move.w  #48,COL(a7)     * put 4th column on stack
    974                 jsr     _vputa          * reset fourth column
    975 *
    976 srs16:          add.l   #10,a7          * clean up stack
    977                 bra     srsexit         * done
    978 *
    979                 .page
    980 *
     6
     7                .xdef   _sreset         | sreset()
     8
     9                .xref   _vputa          | vputa(sbase, row, col, attrib)
     10
     11                .xref   _ndisp          | WORD - display number
     12                .xref   _obj8           | LONG - object base address
     13                .xref   _vrbw08         | WORD - detail word for bit 8
     14                .xref   _vrbw09         | WORD - detail word for bit 9
     15                .xref   _vrbw10         | WORD - detail word for bit 10
     16                .xref   _vrbw11         | WORD - detail word for bit 11
     17                .xref   _vrbw12         | WORD - detail word for bit 12
     18                .xref   _vrbw13         | WORD - detail word for bit 13
     19                .xref   _vrbw14         | WORD - detail word for bit 14
     20                .xref   _vrbw15         | WORD - detail word for bit 15
     21                .xref   _vrcw           | WORD - video reset control word
     22
     23ROW             =       4
     24COL             =       6
     25ATR             =       8
     26
     27AT01            =       0x0014
     28AT04            =       0x0013
     29AT05            =       0x0014
     30AT06            =       0x0013
     31AT07            =       0x0014
     32AT08            =       0x0013
     33AT09            =       0x0014
     34AT10            =       0x0013
     35AT11            =       0x0012
     36AT12            =       0x0012
     37
     38                .page
     39
     40| sreset() -- reset highlighting
     41| --------    ------------------
     42_sreset:        link    a6,#0           | link stack frame
     43                cmp.w   #2,_ndisp       | see if we should update display
     44                bne     srsexit         | jump if not
     45
     46                move.w  _vrcw,d0        | get and check vrcw
     47                bne     srs0            | jump if something to do
     48
     49srsexit:        unlk    a6              | unlink stack frame
     50                rts                     | return to caller
     51
     52srs0:           move.w  sr,d1           | <<<<< disable interrupts >>>>>
     53                ori.w   #0x0700,sr      | ...
     54
     55                move.w  _vrcw,vrcw      | make local copies of control variables
     56                clr.w   _vrcw           | ... and clear them for the next pass
     57                move.w  _vrbw08,vrbw08  | ...
     58                clr.w   _vrbw08         | ...
     59                move.w  _vrbw09,vrbw09  | ...
     60                clr.w   _vrbw09         | ...
     61                move.w  _vrbw10,vrbw10  | ...
     62                clr.w   _vrbw10         | ...
     63                move.w  _vrbw11,vrbw11  | ...
     64                clr.w   _vrbw11         | ...
     65                move.w  _vrbw12,vrbw12  | ...
     66                clr.w   _vrbw12         | ...
     67                move.w  _vrbw13,vrbw13  | ...
     68                clr.w   _vrbw13         | ...
     69                move.w  _vrbw14,vrbw14  | ...
     70                clr.w   _vrbw14         | ...
     71                move.w  _vrbw15,vrbw15  | ...
     72                clr.w   _vrbw15         | ...
     73
     74                move.w  d1,sr           | <<<<< restore interrupts >>>>>
     75
     76| Setup STACK for subsequent calls to vputa(sbase, row, col, atr):
     77
     78|       0(a7)   sbase
     79
     80|       4(a7)   row     ROW
     81|       6(a7)   col     COL
     82|       8(a7)   atr     ATR
     83
     84                clr.w   -(a7)           | put dummy attribute on stack
     85                clr.w   -(a7)           | put dummy column on stack
     86                clr.w   -(a7)           | put dummy row on stack
     87                move.l  _obj8,-(a7)     | put sbase on stack
     88
     89                .page
     90
     91| assignment
     92| ----------
     93                btst    #0,d0           | assignment ?
     94                beq     srs1            | jump if not
     95
     96                move.w  #AT04,ATR(a7)   | put attribute on stack
     97                move.w  #1,ROW(a7)      | put row on stack
     98                move.w  #11,COL(a7)     | put 1st column on stack
     99                jsr     _vputa          | reset first column
     100                move.w  #12,COL(a7)     | put 2nd column on stack
     101                jsr     _vputa          | reset second column
     102                move.w  vrcw,d0         | restore vrcw to d0
     103
     104| tuning
     105| ------
     106srs1:           btst    #1,d0           | tuning ?
     107                beq     srs2            | jump if not
     108
     109                move.w  #AT05,ATR(a7)   | put attribute on stack
     110                move.w  #1,ROW(a7)      | put row on stack
     111                move.w  #19,COL(a7)     | put column on stack
     112                jsr     _vputa          | reset column
     113                move.w  vrcw,d0         | restore vrcw to d0
     114
     115| tempo
     116| -----
     117srs2:           btst    #2,d0           | tempo ?
     118                beq     srs3            | jump if not
     119
     120                move.w  #AT06,ATR(a7)   | put attribute on stack
     121                move.w  #1,ROW(a7)      | put row on stack
     122                move.w  #27,COL(a7)     | put 1st column on stack
     123                jsr     _vputa          | reset first column
     124                move.w  #28,COL(a7)     | put 2nd column on stack
     125                jsr     _vputa          | reset second column
     126                move.w  #29,COL(a7)     | put 3rd column on stack
     127                jsr     _vputa          | reset third column
     128                move.w  vrcw,d0         | restore vrcw to d0
     129
     130                .page
     131
     132| interpolate
     133| -----------
     134srs3:           btst    #3,d0           | interpolate ?
     135                beq     srs4            | jump if not
     136
     137                move.w  #AT07,ATR(a7)   | put attribute on stack
     138                move.w  #1,ROW(a7)      | put row on stack
     139                move.w  #35,COL(a7)     | put 1st column on stack
     140                jsr     _vputa          | reset first column
     141                move.w  #36,COL(a7)     | put 2nd column on stack
     142                jsr     _vputa          | reset second column
     143                move.w  #37,COL(a7)     | put 3rd column on stack
     144                jsr     _vputa          | reset third column
     145                move.w  #38,COL(a7)     | put 4th column on stack
     146                jsr     _vputa          | reset fourth column
     147                move.w  vrcw,d0         | restore vrcw to d0
     148
     149| section begin
     150| -------------
     151srs4:           btst    #4,d0           | section begin ?
     152                beq     srs5            | jump if not
     153
     154                move.w  #AT01,ATR(a7)   | put attribute on stack
     155                move.w  #0,ROW(a7)      | put row on stack
     156                move.w  #6,COL(a7)      | put 1st column on stack
     157                jsr     _vputa          | reset first column
     158                move.w  #7,COL(a7)      | put 2nd column on stack
     159                jsr     _vputa          | reset second column
     160
     161                .page
     162
     163| punch in
     164| --------
     165srs5:           btst    #5,d0           | punch in ?
     166                beq     srs6            | jump if not
     167
     168                move.w  #AT09,ATR(a7)   | put attribute on stack
     169                move.w  #1,ROW(a7)      | put row on stack
     170                move.w  #50,COL(a7)     | put 1st column on stack
     171                jsr     _vputa          | reset first column
     172                move.w  #51,COL(a7)     | put 2nd column on stack
     173                jsr     _vputa          | reset second column
     174                move.w  vrcw,d0         | restore vrcw to d0
     175
     176| punch out
     177| ---------
     178srs6:           btst    #6,d0           | punch out ?
     179                beq     srs7            | jump if not
     180
     181                move.w  #AT09,ATR(a7)   | put attribute on stack
     182                move.w  #1,ROW(a7)      | put row on stack
     183                move.w  #53,COL(a7)     | put 1st column on stack
     184                jsr     _vputa          | reset first column
     185                move.w  #54,COL(a7)     | put 2nd column on stack
     186                jsr     _vputa          | reset second column
     187                move.w  #55,COL(a7)     | put 3rd column on stack
     188                jsr     _vputa          | reset third column
     189                move.w  vrcw,d0         | restore vrcw to d0
     190
     191| Output
     192| ------
     193srs7:           btst    #7,d0           | output ?
     194                beq     srs8            | jump if not
     195
     196                move.w  #AT10,ATR(a7)   | put attribute on stack
     197                move.w  #1,ROW(a7)      | put row on stack
     198                move.w  #57,COL(a7)     | put 1st column on stack
     199                jsr     _vputa          | reset first column
     200                move.w  #58,COL(a7)     | put 2nd column on stack
     201                jsr     _vputa          | reset second column
     202                move.w  #59,COL(a7)     | put 3rd column on stack
     203                jsr     _vputa          | reset third column
     204                move.w  #60,COL(a7)     | put 4th column on stack
     205                jsr     _vputa          | reset fourth column
     206                move.w  #61,COL(a7)     | put 5th column on stack
     207                jsr     _vputa          | reset fifth column
     208                move.w  #62,COL(a7)     | put 6th column on stack
     209                jsr     _vputa          | reset sixth column
     210                move.w  vrcw,d0         | restore vrcw to d0
     211
     212                .page
     213
     214| instrument
     215| ----------
     216srs8:           btst    #8,d0           | instrument ?
     217                beq     srs9            | jump if not
     218
     219                move.w  #2,ROW(a7)      | put row on stack
     220                move.w  #AT11,ATR(a7)   | put attribute on stack
     221                btst    #0,vrbw08+1     | group 1 ?
     222                beq     srs8a           | jump if not
     223
     224                move.w  #7,COL(a7)      | put 1st column on stack
     225                jsr     _vputa          | reset first column
     226                move.w  #8,COL(a7)      | put 2nd column on stack
     227                jsr     _vputa          | reset second column
     228
     229srs8a:          btst    #1,vrbw08+1     | group 2 ?
     230                beq     srs8b           | jump if not
     231
     232                move.w  #12,COL(a7)     | put 1st column on stack
     233                jsr     _vputa          | reset first character
     234                move.w  #13,COL(a7)     | put 2nd column on stack
     235                jsr     _vputa          | reset second character
     236
     237srs8b:          btst    #2,vrbw08+1     | group 3 ?
     238                beq     srs8c           | jump if not
     239
     240                move.w  #17,COL(a7)     | put 1st column on stack
     241                jsr     _vputa          | reset first character
     242                move.w  #18,COL(a7)     | put 2nd column on stack
     243                jsr     _vputa          | reset second character
     244
     245srs8c:          btst    #3,vrbw08+1     | group 4 ?
     246                beq     srs8d           | jump if not
     247
     248                move.w  #22,COL(a7)     | put 1st column on stack
     249                jsr     _vputa          | reset first character
     250                move.w  #23,COL(a7)     | put 2nd column on stack
     251                jsr     _vputa          | reset second character
     252
     253                .page
     254
     255srs8d:          btst    #4,vrbw08+1     | group 5 ?
     256                beq     srs8e           | jump if not
     257
     258                move.w  #27,COL(a7)     | put 1st column on stack
     259                jsr     _vputa          | reset first character
     260                move.w  #28,COL(a7)     | put 2nd column on stack
     261                jsr     _vputa          | reset second character
     262
     263srs8e:          btst    #5,vrbw08+1     | group 6 ?
     264                beq     srs8f           | jump if not
     265
     266                move.w  #32,COL(a7)     | put 1st column on stack
     267                jsr     _vputa          | reset first character
     268                move.w  #33,COL(a7)     | put 2nd column on stack
     269                jsr     _vputa          | reset second character
     270
     271srs8f:          btst    #6,vrbw08+1     | group 7 ?
     272                beq     srs8g           | jump if not
     273
     274                move.w  #37,COL(a7)     | put 1st column on stack
     275                jsr     _vputa          | reset first character
     276                move.w  #38,COL(a7)     | put 2nd column on stack
     277                jsr     _vputa          | reset second character
     278
     279srs8g:          btst    #7,vrbw08+1     | group 8 ?
     280                beq     srs8h           | jump if not
     281
     282                move.w  #42,COL(a7)     | put 1st column on stack
     283                jsr     _vputa          | reset first character
     284                move.w  #43,COL(a7)     | put 2nd column on stack
     285                jsr     _vputa          | reset second character
     286
     287                .page
     288
     289srs8h:          btst    #0,vrbw08       | group 9
     290                beq     srs8j           | jump if not
     291
     292                move.w  #47,COL(a7)     | put 1st column on stack
     293                jsr     _vputa          | reset first character
     294                move.w  #48,COL(a7)     | put 2nd column on stack
     295                jsr     _vputa          | reset second character
     296
     297srs8j:          btst    #1,vrbw08       | group 10
     298                beq     srs8k           | jump if not
     299
     300                move.w  #52,COL(a7)     | put 1st column on stack
     301                jsr     _vputa          | reset first character
     302                move.w  #53,COL(a7)     | put 2nd column on stack
     303                jsr     _vputa          | reset second character
     304
     305srs8k:          btst    #2,vrbw08       | group 11
     306                beq     srs8m           | jump if not
     307
     308                move.w  #57,COL(a7)     | put 1st column on stack
     309                jsr     _vputa          | reset first character
     310                move.w  #58,COL(a7)     | put 2nd column on stack
     311                jsr     _vputa          | reset second character
     312
     313srs8m:          btst    #3,vrbw08       | group 12
     314                beq     srs8x           | jump if not
     315
     316                move.w  #62,COL(a7)     | put 1st column on stack
     317                jsr     _vputa          | reset first character
     318                move.w  #63,COL(a7)     | put 2nd column on stack
     319                jsr     _vputa          | reset second character
     320
     321srs8x:          move.w  vrcw,d0         | restore vrcw to d0
     322
     323                .page
     324
     325| transpose
     326| ---------
     327srs9:           btst    #9,d0           | transpose ?
     328                beq     srs10           | jump if not
     329
     330                move.w  #AT11,ATR(a7)   | put attribute on stack
     331                move.w  #3,ROW(a7)      | put row on stack
     332                btst    #0,vrbw09+1     | group 1 ?
     333                beq     srs9a           | jump if not
     334
     335                move.w  #5,COL(a7)      | put 1st column on stack
     336                jsr     _vputa          | reset first column
     337                move.w  #6,COL(a7)      | put 2nd column on stack
     338                jsr     _vputa          | reset second column
     339                move.w  #7,COL(a7)      | put 3rd column on stack
     340                jsr     _vputa          | reset third column
     341                move.w  #8,COL(a7)      | put 4th column on stack
     342                jsr     _vputa          | reset fourth column
     343
     344srs9a:          btst    #1,vrbw09+1     | group 2 ?
     345                beq     srs9b           | jump if not
     346
     347                move.w  #10,COL(a7)     | put 1st column on stack
     348                jsr     _vputa          | reset first column
     349                move.w  #11,COL(a7)     | put 2nd column on stack
     350                jsr     _vputa          | reset second column
     351                move.w  #12,COL(a7)     | put 3rd column on stack
     352                jsr     _vputa          | reset third column
     353                move.w  #13,COL(a7)     | put 4th column on stack
     354                jsr     _vputa          | reset fourth column
     355
     356srs9b:          btst    #2,vrbw09+1     | group 3 ?
     357                beq     srs9c           | jump if not
     358
     359                move.w  #15,COL(a7)     | put 1st column on stack
     360                jsr     _vputa          | reset first column
     361                move.w  #16,COL(a7)     | put 2nd column on stack
     362                jsr     _vputa          | reset second column
     363                move.w  #17,COL(a7)     | put 3rd column on stack
     364                jsr     _vputa          | reset third column
     365                move.w  #18,COL(a7)     | put 4th column on stack
     366                jsr     _vputa          | reset fourth column
     367
     368                .page
     369
     370srs9c:          btst    #3,vrbw09+1     | group 4 ?
     371                beq     srs9d           | jump if not
     372
     373                move.w  #20,COL(a7)     | put 1st column on stack
     374                jsr     _vputa          | reset first column
     375                move.w  #21,COL(a7)     | put 2nd column on stack
     376                jsr     _vputa          | reset second column
     377                move.w  #22,COL(a7)     | put 3rd column on stack
     378                jsr     _vputa          | reset third column
     379                move.w  #23,COL(a7)     | put 4th column on stack
     380                jsr     _vputa          | reset fourth column
     381
     382srs9d:          btst    #4,vrbw09+1     | group 5 ?
     383                beq     srs9e           | jump if not
     384
     385                move.w  #25,COL(a7)     | put 1st column on stack
     386                jsr     _vputa          | reset first column
     387                move.w  #26,COL(a7)     | put 2nd column on stack
     388                jsr     _vputa          | reset second column
     389                move.w  #27,COL(a7)     | put 3rd column on stack
     390                jsr     _vputa          | reset third column
     391                move.w  #28,COL(a7)     | put 4th column on stack
     392                jsr     _vputa          | reset fourth column
     393
     394srs9e:          btst    #5,vrbw09+1     | group 6 ?
     395                beq     srs9f           | jump if not
     396
     397                move.w  #30,COL(a7)     | put 1st column on stack
     398                jsr     _vputa          | reset first column
     399                move.w  #31,COL(a7)     | put 2nd column on stack
     400                jsr     _vputa          | reset second column
     401                move.w  #32,COL(a7)     | put 3rd column on stack
     402                jsr     _vputa          | reset third column
     403                move.w  #33,COL(a7)     | put 4th column on stack
     404                jsr     _vputa          | reset fourth column
     405
     406                .page
     407
     408srs9f:          btst    #6,vrbw09+1     | group 7 ?
     409                beq     srs9g           | jump if not
     410
     411                move.w  #35,COL(a7)     | put 1st column on stack
     412                jsr     _vputa          | reset first column
     413                move.w  #36,COL(a7)     | put 2nd column on stack
     414                jsr     _vputa          | reset second column
     415                move.w  #37,COL(a7)     | put 3rd column on stack
     416                jsr     _vputa          | reset third column
     417                move.w  #38,COL(a7)     | put 4th column on stack
     418                jsr     _vputa          | reset fourth column
     419
     420srs9g:          btst    #7,vrbw09+1     | group 8 ?
     421                beq     srs9h           | jump if not
     422
     423                move.w  #40,COL(a7)     | put 1st column on stack
     424                jsr     _vputa          | reset first column
     425                move.w  #41,COL(a7)     | put 2nd column on stack
     426                jsr     _vputa          | reset second column
     427                move.w  #42,COL(a7)     | put 3rd column on stack
     428                jsr     _vputa          | reset third column
     429                move.w  #43,COL(a7)     | put 4th column on stack
     430                jsr     _vputa          | reset fourth column
     431
     432srs9h:          btst    #0,vrbw09       | group 9
     433                beq     srs9j           | jump if not
     434
     435                move.w  #45,COL(a7)     | put 1st column on stack
     436                jsr     _vputa          | reset first column
     437                move.w  #46,COL(a7)     | put 2nd column on stack
     438                jsr     _vputa          | reset second column
     439                move.w  #47,COL(a7)     | put 3rd column on stack
     440                jsr     _vputa          | reset third column
     441                move.w  #48,COL(a7)     | put 4th column on stack
     442                jsr     _vputa          | reset fourth column
     443
     444                .page
     445
     446srs9j:          btst    #1,vrbw09       | group 10
     447                beq     srs9k           | jump if not
     448
     449                move.w  #50,COL(a7)     | put 1st column on stack
     450                jsr     _vputa          | reset first column
     451                move.w  #51,COL(a7)     | put 2nd column on stack
     452                jsr     _vputa          | reset second column
     453                move.w  #52,COL(a7)     | put 3rd column on stack
     454                jsr     _vputa          | reset third column
     455                move.w  #53,COL(a7)     | put 4th column on stack
     456                jsr     _vputa          | reset fourth column
     457
     458srs9k:          btst    #2,vrbw09       | group 11
     459                beq     srs9m           | jump if not
     460
     461                move.w  #55,COL(a7)     | put 1st column on stack
     462                jsr     _vputa          | reset first column
     463                move.w  #56,COL(a7)     | put 2nd column on stack
     464                jsr     _vputa          | reset second column
     465                move.w  #57,COL(a7)     | put 3rd column on stack
     466                jsr     _vputa          | reset third column
     467                move.w  #58,COL(a7)     | put 4th column on stack
     468                jsr     _vputa          | reset fourth column
     469
     470srs9m:          btst    #3,vrbw09       | group 12
     471                beq     srs9x           | jump if not
     472
     473                move.w  #60,COL(a7)     | put 1st column on stack
     474                jsr     _vputa          | reset first column
     475                move.w  #61,COL(a7)     | put 2nd column on stack
     476                jsr     _vputa          | reset second column
     477                move.w  #62,COL(a7)     | put 3rd column on stack
     478                jsr     _vputa          | reset third column
     479                move.w  #63,COL(a7)     | put 4th column on stack
     480                jsr     _vputa          | reset fourth column
     481
     482srs9x:          move.w  vrcw,d0         | restore vrcw to d0
     483
     484                .page
     485
     486| dynamics
     487| --------
     488srs10:          btst    #10,d0          | dynamics ?
     489                beq     srs11           | jump if not
     490
     491                move.w  #AT11,ATR(a7)   | put attribute on stack
     492                move.w  #4,ROW(a7)      | put row on stack
     493                btst    #0,vrbw10+1     | group 1 ?
     494                beq     srs10a          | jump if not
     495
     496                move.w  #6,COL(a7)      | put column on stack
     497                jsr     _vputa          | reset column
     498
     499srs10a:         btst    #1,vrbw10+1     | group 2 ?
     500                beq     srs10b          | jump if not
     501
     502                move.w  #11,COL(a7)     | put column on stack
     503                jsr     _vputa          | reset column
     504
     505srs10b:         btst    #2,vrbw10+1     | group 3 ?
     506                beq     srs10c          | jump if not
     507
     508                move.w  #16,COL(a7)     | put column on stack
     509                jsr     _vputa          | reset column
     510
     511srs10c:         btst    #3,vrbw10+1     | group 4 ?
     512                beq     srs10d          | jump if not
     513
     514                move.w  #21,COL(a7)     | put column on stack
     515                jsr     _vputa          | reset column
     516
     517                .page
     518
     519srs10d:         btst    #4,vrbw10+1     | group 5 ?
     520                beq     srs10e          | jump if not
     521
     522                move.w  #26,COL(a7)     | put column on stack
     523                jsr     _vputa          | reset column
     524
     525srs10e:         btst    #5,vrbw10+1     | group 6 ?
     526                beq     srs10f          | jump if not
     527
     528                move.w  #31,COL(a7)     | put column on stack
     529                jsr     _vputa          | reset column
     530
     531srs10f:         btst    #6,vrbw10+1     | group 7 ?
     532                beq     srs10g          | jump if not
     533
     534                move.w  #36,COL(a7)     | put column on stack
     535                jsr     _vputa          | reset column
     536
     537srs10g:         btst    #7,vrbw10+1     | group 8 ?
     538                beq     srs10h          | jump if not
     539
     540                move.w  #41,COL(a7)     | put column on stack
     541                jsr     _vputa          | reset column
     542
     543                .page
     544
     545srs10h:         btst    #0,vrbw10       | group 9
     546                beq     srs10j          | jump if not
     547
     548                move.w  #46,COL(a7)     | put column on stack
     549                jsr     _vputa          | reset column
     550
     551srs10j:         btst    #1,vrbw10       | group 10
     552                beq     srs10k          | jump if not
     553
     554                move.w  #51,COL(a7)     | put column on stack
     555                jsr     _vputa          | reset column
     556
     557srs10k:         btst    #2,vrbw10       | group 11
     558                beq     srs10m          | jump if not
     559
     560                move.w  #56,COL(a7)     | put column on stack
     561                jsr     _vputa          | reset column
     562
     563srs10m:         btst    #3,vrbw10       | group 12
     564                beq     srs10x          | jump if not
     565
     566                move.w  #61,COL(a7)     | put column on stack
     567                jsr     _vputa          | reset column
     568
     569srs10x:         move.w  vrcw,d0         | restore vrcw to d0
     570
     571                .page
     572
     573| location
     574| --------
     575srs11:          btst    #11,d0          | location ?
     576                beq     srs12           | jump if not
     577
     578                move.w  #AT11,ATR(a7)   | put attribute on stack
     579                move.w  #4,ROW(a7)      | put row on stack
     580                btst    #0,vrbw11+1     | group 1 ?
     581                beq     srs11a          | jump if not
     582
     583                move.w  #8,COL(a7)      | put column on stack
     584                jsr     _vputa          | reset column
     585
     586srs11a:         btst    #1,vrbw11+1     | group 2 ?
     587                beq     srs11b          | jump if not
     588
     589                move.w  #13,COL(a7)     | put column on stack
     590                jsr     _vputa          | reset column
     591
     592srs11b:         btst    #2,vrbw11+1     | group 3 ?
     593                beq     srs11c          | jump if not
     594
     595                move.w  #18,COL(a7)     | put column on stack
     596                jsr     _vputa          | reset column
     597
     598srs11c:         btst    #3,vrbw11+1     | group 4 ?
     599                beq     srs11d          | jump if not
     600
     601                move.w  #23,COL(a7)     | put column on stack
     602                jsr     _vputa          | reset column
     603
     604                .page
     605
     606srs11d:         btst    #4,vrbw11+1     | group 5 ?
     607                beq     srs11e          | jump if not
     608
     609                move.w  #28,COL(a7)     | put column on stack
     610                jsr     _vputa          | reset column
     611
     612srs11e:         btst    #5,vrbw11+1     | group 6 ?
     613                beq     srs11f          | jump if not
     614
     615                move.w  #33,COL(a7)     | put column on stack
     616                jsr     _vputa          | reset column
     617
     618srs11f:         btst    #6,vrbw11+1     | group 7 ?
     619                beq     srs11g          | jump if not
     620
     621                move.w  #38,COL(a7)     | put column on stack
     622                jsr     _vputa          | reset column
     623
     624srs11g:         btst    #7,vrbw11+1     | group 8 ?
     625                beq     srs11h          | jump if not
     626
     627                move.w  #43,COL(a7)     | put column on stack
     628                jsr     _vputa          | reset column
     629
     630                .page
     631
     632srs11h:         btst    #0,vrbw11       | group 9
     633                beq     srs11j          | jump if not
     634
     635                move.w  #48,COL(a7)     | put column on stack
     636                jsr     _vputa          | reset column
     637
     638srs11j:         btst    #1,vrbw11       | group 10
     639                beq     srs11k          | jump if not
     640
     641                move.w  #53,COL(a7)     | put column on stack
     642                jsr     _vputa          | reset column
     643
     644srs11k:         btst    #2,vrbw11       | group 11
     645                beq     srs11m          | jump if not
     646
     647                move.w  #58,COL(a7)     | put column on stack
     648                jsr     _vputa          | reset column
     649
     650srs11m:         btst    #3,vrbw11       | group 12
     651                beq     srs11x          | jump if not
     652
     653                move.w  #63,COL(a7)     | put column on stack
     654                jsr     _vputa          | reset column
     655
     656srs11x:         move.w  vrcw,d0         | restore vrcw to d0
     657
     658                .page
     659
     660| velocity
     661| --------
     662srs12:          btst    #12,d0          | velocity ?
     663                beq     srs13           | jump if not
     664
     665                move.w  #AT11,ATR(a7)   | put attribute on stack
     666                move.w  #5,ROW(a7)      | put row on stack
     667                btst    #0,vrbw12+1     | group 1 ?
     668                beq     srs12a          | jump if not
     669
     670                move.w  #6,COL(a7)      | put 1st column on stack
     671                jsr     _vputa          | reset first column
     672                move.w  #7,COL(a7)      | put 2nd column on stack
     673                jsr     _vputa          | reset second column
     674                move.w  #8,COL(a7)      | put 3rd column on stack
     675                jsr     _vputa          | reset third column
     676
     677srs12a:         btst    #1,vrbw12+1     | group 2 ?
     678                beq     srs12b          | jump if not
     679
     680                move.w  #11,COL(a7)     | put 1st column on stack
     681                jsr     _vputa          | reset first column
     682                move.w  #12,COL(a7)     | put 2nd column on stack
     683                jsr     _vputa          | reset second column
     684                move.w  #13,COL(a7)     | put 3rd column on stack
     685                jsr     _vputa          | reset third column
     686
     687srs12b:         btst    #2,vrbw12+1     | group 3 ?
     688                beq     srs12c          | jump if not
     689
     690                move.w  #16,COL(a7)     | put 1st column on stack
     691                jsr     _vputa          | reset first column
     692                move.w  #17,COL(a7)     | put 2nd column on stack
     693                jsr     _vputa          | reset second column
     694                move.w  #18,COL(a7)     | put 3rd column on stack
     695                jsr     _vputa          | reset third column
     696
     697                .page
     698
     699srs12c:         btst    #3,vrbw12+1     | group 4 ?
     700                beq     srs12d          | jump if not
     701
     702                move.w  #21,COL(a7)     | put 1st column on stack
     703                jsr     _vputa          | reset first column
     704                move.w  #22,COL(a7)     | put 2nd column on stack
     705                jsr     _vputa          | reset second column
     706                move.w  #23,COL(a7)     | put 3rd column on stack
     707                jsr     _vputa          | reset third column
     708
     709srs12d:         btst    #4,vrbw12+1     | group 5 ?
     710                beq     srs12e          | jump if not
     711
     712                move.w  #26,COL(a7)     | put 1st column on stack
     713                jsr     _vputa          | reset first column
     714                move.w  #27,COL(a7)     | put 2nd column on stack
     715                jsr     _vputa          | reset second column
     716                move.w  #28,COL(a7)     | put 3rd column on stack
     717                jsr     _vputa          | reset third column
     718
     719srs12e:         btst    #5,vrbw12+1     | group 6 ?
     720                beq     srs12f          | jump if not
     721
     722                move.w  #31,COL(a7)     | put 1st column on stack
     723                jsr     _vputa          | reset first column
     724                move.w  #32,COL(a7)     | put 2nd column on stack
     725                jsr     _vputa          | reset second column
     726                move.w  #33,COL(a7)     | put 3rd column on stack
     727                jsr     _vputa          | reset third column
     728
     729                .page
     730
     731srs12f:         btst    #6,vrbw12+1     | group 7 ?
     732                beq     srs12g          | jump if not
     733
     734                move.w  #36,COL(a7)     | put 1st column on stack
     735                jsr     _vputa          | reset first column
     736                move.w  #37,COL(a7)     | put 2nd column on stack
     737                jsr     _vputa          | reset second column
     738                move.w  #38,COL(a7)     | put 3rd column on stack
     739                jsr     _vputa          | reset third column
     740
     741srs12g:         btst    #7,vrbw12+1     | group 8 ?
     742                beq     srs12h          | jump if not
     743
     744                move.w  #41,COL(a7)     | put 1st column on stack
     745                jsr     _vputa          | reset first column
     746                move.w  #42,COL(a7)     | put 2nd column on stack
     747                jsr     _vputa          | reset second column
     748                move.w  #43,COL(a7)     | put 3rd column on stack
     749                jsr     _vputa          | reset third column
     750
     751srs12h:         btst    #0,vrbw12       | group 9
     752                beq     srs12j          | jump if not
     753
     754                move.w  #46,COL(a7)     | put 1st column on stack
     755                jsr     _vputa          | reset first column
     756                move.w  #47,COL(a7)     | put 2nd column on stack
     757                jsr     _vputa          | reset second column
     758                move.w  #48,COL(a7)     | put 3rd column on stack
     759                jsr     _vputa          | reset third column
     760
     761                .page
     762
     763srs12j:         btst    #1,vrbw12       | group 10
     764                beq     srs12k          | jump if not
     765
     766                move.w  #51,COL(a7)     | put 1st column on stack
     767                jsr     _vputa          | reset first column
     768                move.w  #52,COL(a7)     | put 2nd column on stack
     769                jsr     _vputa          | reset second column
     770                move.w  #53,COL(a7)     | put 3rd column on stack
     771                jsr     _vputa          | reset third column
     772
     773srs12k:         btst    #2,vrbw12       | group 11
     774                beq     srs12m          | jump if not
     775
     776                move.w  #56,COL(a7)     | put 1st column on stack
     777                jsr     _vputa          | reset first column
     778                move.w  #57,COL(a7)     | put 2nd column on stack
     779                jsr     _vputa          | reset second column
     780                move.w  #58,COL(a7)     | put 3rd column on stack
     781                jsr     _vputa          | reset third column
     782
     783srs12m:         btst    #3,vrbw12       | group 12
     784                beq     srs12x          | jump if not
     785
     786                move.w  #61,COL(a7)     | put 1st column on stack
     787                jsr     _vputa          | reset first column
     788                move.w  #62,COL(a7)     | put 2nd column on stack
     789                jsr     _vputa          | reset second column
     790                move.w  #63,COL(a7)     | put 3rd column on stack
     791                jsr     _vputa          | reset third column
     792
     793srs12x:         move.w  vrcw,d0         | restore vrcw to d0
     794
     795                .page
     796
     797| resolution
     798| ----------
     799srs13:          btst    #13,d0          | resolution ?
     800                beq     srs14           | jump if not
     801
     802                move.w  #AT12,ATR(a7)   | put attribute on stack
     803                move.w  #7,ROW(a7)      | put row on stack
     804                btst    #0,vrbw13+1     | variable 1 ?
     805                beq     srs13a          | jump if not
     806
     807                move.w  #6,COL(a7)      | put column on stack
     808                jsr     _vputa          | reset column
     809
     810srs13a:         btst    #1,vrbw13+1     | variable 2 ?
     811                beq     srs13b          | jump if not
     812
     813                move.w  #15,COL(a7)     | put column on stack
     814                jsr     _vputa          | reset column
     815
     816srs13b:         btst    #2,vrbw13+1     | variable 3 ?
     817                beq     srs13c          | jump if not
     818
     819                move.w  #24,COL(a7)     | put column on stack
     820                jsr     _vputa          | reset column
     821
     822srs13c:         btst    #3,vrbw13+1     | variable 4 ?
     823                beq     srs13d          | jump if not
     824
     825                move.w  #33,COL(a7)     | put column on stack
     826                jsr     _vputa          | reset column
     827
     828srs13d:         btst    #4,vrbw13+1     | variable 5 ?
     829                beq     srs13e          | jump if not
     830
     831                move.w  #42,COL(a7)     | put column on stack
     832                jsr     _vputa          | reset column
     833
     834srs13e:         btst    #5,vrbw13+1     | variable 6 ?
     835                beq     srs13x          | jump if not
     836
     837                move.w  #51,COL(a7)     | put column on stack
     838                jsr     _vputa          | reset column
     839
     840srs13x:         move.w  vrcw,d0         | restore vrcw to d0
     841
     842                .page
     843
     844| analog value
     845| ------------
     846srs14:          btst    #14,d0          | analog value ?
     847                beq     srs15           | jump if not
     848
     849                move.w  #AT12,ATR(a7)   | put attribute on stack
     850                move.w  #7,ROW(a7)      | put row on stack
     851                btst    #0,vrbw14+1     | variable 1 ?
     852                beq     srs14a          | jump if not
     853
     854                move.w  #8,COL(a7)      | put 1st column on stack
     855                jsr     _vputa          | reset first column
     856                move.w  #9,COL(a7)      | put 2nd column on stack
     857                jsr     _vputa          | reset second column
     858                move.w  #10,COL(a7)     | put 3rd column on stack
     859                jsr     _vputa          | reset third column
     860                move.w  #11,COL(a7)     | put 4th column on stack
     861                jsr     _vputa          | reset fourth column
     862                move.w  #12,COL(a7)     | put 5th column on stack
     863                jsr     _vputa          | reset fifth column
     864
     865srs14a:         btst    #1,vrbw14+1     | variable 2 ?
     866                beq     srs14b          | jump if not
     867
     868                move.w  #17,COL(a7)     | put 1st column on stack
     869                jsr     _vputa          | reset first column
     870                move.w  #18,COL(a7)     | put 2nd column on stack
     871                jsr     _vputa          | reset second column
     872                move.w  #19,COL(a7)     | put 3rd column on stack
     873                jsr     _vputa          | reset third column
     874                move.w  #20,COL(a7)     | put 4th column on stack
     875                jsr     _vputa          | reset fourth column
     876                move.w  #21,COL(a7)     | put 5th column on stack
     877                jsr     _vputa          | reset fifth column
     878
     879                .page
     880
     881srs14b:         btst    #2,vrbw14+1     | variable 3 ?
     882                beq     srs14c          | jump if not
     883
     884                move.w  #26,COL(a7)     | put 1st column on stack
     885                jsr     _vputa          | reset first column
     886                move.w  #27,COL(a7)     | put 2nd column on stack
     887                jsr     _vputa          | reset second column
     888                move.w  #28,COL(a7)     | put 3rd column on stack
     889                jsr     _vputa          | reset third column
     890                move.w  #29,COL(a7)     | put 4th column on stack
     891                jsr     _vputa          | reset fourth column
     892                move.w  #30,COL(a7)     | put 5th column on stack
     893                jsr     _vputa          | reset fifth column
     894
     895srs14c:         btst    #3,vrbw14+1     | variable 4 ?
     896                beq     srs14d          | jump if not
     897
     898                move.w  #35,COL(a7)     | put 1st column on stack
     899                jsr     _vputa          | reset first column
     900                move.w  #36,COL(a7)     | put 2nd column on stack
     901                jsr     _vputa          | reset second column
     902                move.w  #37,COL(a7)     | put 3rd column on stack
     903                jsr     _vputa          | reset third column
     904                move.w  #38,COL(a7)     | put 4th column on stack
     905                jsr     _vputa          | reset fourth column
     906                move.w  #39,COL(a7)     | put 5th column on stack
     907                jsr     _vputa          | reset fifth column
     908
     909                .page
     910
     911srs14d:         btst    #4,vrbw14+1     | variable 5 ?
     912                beq     srs14e          | jump if not
     913
     914                move.w  #44,COL(a7)     | put 1st column on stack
     915                jsr     _vputa          | reset first column
     916                move.w  #45,COL(a7)     | put 2nd column on stack
     917                jsr     _vputa          | reset second column
     918                move.w  #46,COL(a7)     | put 3rd column on stack
     919                jsr     _vputa          | reset third column
     920                move.w  #47,COL(a7)     | put 4th column on stack
     921                jsr     _vputa          | reset fourth column
     922                move.w  #48,COL(a7)     | put 5th column on stack
     923                jsr     _vputa          | reset fifth column
     924
     925srs14e:         btst    #5,vrbw14+1     | variable 6 ?
     926                beq     srs14x          | jump if not
     927
     928                move.w  #53,COL(a7)     | put 1st column on stack
     929                jsr     _vputa          | reset first column
     930                move.w  #54,COL(a7)     | put 2nd column on stack
     931                jsr     _vputa          | reset second column
     932                move.w  #55,COL(a7)     | put 3rd column on stack
     933                jsr     _vputa          | reset third column
     934                move.w  #56,COL(a7)     | put 4th column on stack
     935                jsr     _vputa          | reset fourth column
     936                move.w  #57,COL(a7)     | put 5th column on stack
     937                jsr     _vputa          | reset fifth column
     938
     939srs14x:         move.w  vrcw,d0         | restore vrcw to d0
     940
     941                .page
     942
     943| stop/next
     944| ---------
     945srs15:          btst    #15,d0          | stop/next ?
     946                beq     srs16           | jump if not
     947
     948                btst    #0,vrbw15       | stop ?
     949                beq     srs15a          | jump if not
     950
     951                move.w  #AT08,ATR(a7)   | put attribute on stack
     952                move.w  #1,ROW(a7)      | put row on stack
     953                move.w  #40,COL(a7)     | put 1st column on stack
     954                jsr     _vputa          | reset first column
     955                move.w  #41,COL(a7)     | put 2nd column on stack
     956                jsr     _vputa          | reset second column
     957                move.w  #42,COL(a7)     | put 3rd column on stack
     958                jsr     _vputa          | reset third column
     959                move.w  #43,COL(a7)     | put 4th column on stack
     960                jsr     _vputa          | reset fourth column
     961
     962srs15a:         btst    #1,vrbw15       | next ?
     963                beq     srs16           | jump if not
     964
     965                move.w  #AT08,ATR(a7)   | put attribute on stack
     966                move.w  #1,ROW(a7)      | put row on stack
     967                move.w  #45,COL(a7)     | put 1st column on stack
     968                jsr     _vputa          | reset first column
     969                move.w  #46,COL(a7)     | put 2nd column on stack
     970                jsr     _vputa          | reset second column
     971                move.w  #47,COL(a7)     | put 3rd column on stack
     972                jsr     _vputa          | reset third column
     973                move.w  #48,COL(a7)     | put 4th column on stack
     974                jsr     _vputa          | reset fourth column
     975
     976srs16:          add.l   #10,a7          | clean up stack
     977                bra     srsexit         | done
     978
     979                .page
     980
    981981                .bss
    982 *
    983 * local copies of _vrcw, _vrbw08.._vrbw15
    984 *
     982
     983| local copies of _vrcw, _vrbw08.._vrbw15
     984
    985985vrcw:           .ds.w   1
    986986vrbw08:         .ds.w   1
    … …  
    992992vrbw14:         .ds.w   1
    993993vrbw15:         .ds.w   1
    994 *
     994
    995995                .end

  • ram/timeint.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * timeint.s -- MIDAS-VII timer interrupt handler
    3 * Version 15 -- 1989-07-20 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
    5 *
    6 * This code replaces the interrupt handler in bios.s, which is known to
    7 * have a bug in it, and adds support for the VSDD and an array of programable
    8 * timers with 1 Ms resolution.
    9 *
    10 * WARNING:  There are equates to addresses in the bios EPROM which may change
    11 * when the bios is reassembled.  If the bios is reassembled be sure to update
    12 * the equates flagged by "<<<=====".
    13 *
    14 * The addresses currently in the equates are for EPROMs dated 1988-04-18 or
    15 * 1988-06-20 ONLY.
    16 *
    17 * ------------------------------------------------------------------------------
    18 * Hardware timer usage:
    19 * ---------------------
    20 *       Timer 1         PLL divider for score clock -- fixed at 64
    21 *       Timer 2         PLL divider for score clock -- nominally 3200
    22 *       Timer 3         1 Ms Real Time Clock
    23 *
    24 * ------------------------------------------------------------------------------
    25 *
     1| ------------------------------------------------------------------------------
     2| timeint.s -- MIDAS-VII timer interrupt handler
     3| Version 15 -- 1989-07-20 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
     5
     6| This code replaces the interrupt handler in bios.s, which is known to
     7| have a bug in it, and adds support for the VSDD and an array of programable
     8| timers with 1 Ms resolution.
     9
     10| WARNING:  There are equates to addresses in the bios EPROM which may change
     11| when the bios is reassembled.  If the bios is reassembled be sure to update
     12| the equates flagged by "<<<=====".
     13
     14| The addresses currently in the equates are for EPROMs dated 1988-04-18 or
     15| 1988-06-20 ONLY.
     16
     17| ------------------------------------------------------------------------------
     18| Hardware timer usage:
     19| ---------------------
     20|       Timer 1         PLL divider for score clock -- fixed at 64
     21|       Timer 2         PLL divider for score clock -- nominally 3200
     22|       Timer 3         1 Ms Real Time Clock
     23
     24| ------------------------------------------------------------------------------
     25
    2626                .text
    27 *
    28                 .xdef   _tsetup         * tsetup() -- timer setup function
    29                 .xdef   timeint         * timer interrupt handler
    30 *
    31                 .xdef   _M1IoRec        * MIDI channel 1 IoRec         
    32                 .xdef   _M2IoRec        * MIDI channel 2 IoRec         
    33                 .xdef   _S1IoRec        * RS232 channel 1 IoRec         
    34                 .xdef   _S2IoRec        * RS232 channel 2 IoRec         
    35                 .xdef   _timers         * timer array -- short timers[NTIMERS]
    36                 .xdef   _vi_clk         * VSDD scroll delay timer
    37                 .xdef   _vi_tag         * VSDD VI tag
    38 *
    39                 .xref   lclsadr         * score object base address
    40                 .xref   lclscrl         * score object scroll offset
    41                 .xref   _v_odtab        * VSDD object descriptor table
    42 *
    43                 .page
    44 * ==============================================================================
    45 *
    46 FRAMES          .equ    0               * set non-zero to enable frame pulses
    47 *
    48 * Equates to variables in bios.s:
    49 * -------------------------------
    50 * These variables are permanently assigned.
    51 *
    52 TIMEVEC         .equ    $00000400       * LONG - System timer trap vector
    53 *
    54 FC_SW           .equ    $00000420       * WORD - Frame clock switch
    55 FC_VAL          .equ    $00000422       * LONG - Frame clock value
    56 *
    57 HZ_1K           .equ    $0000049A       * LONG - 1000 Hz clock
    58 HZ_200          .equ    $0000049E       * LONG - 200 Hz clock
    59 FRCLOCK         .equ    $000004A2       * LONG - 50 Hz clock
    60 *
    61 T3COUNT         .equ    $000004AA       * WORD - Timer 3 count
    62 *
    63 * ------------------------------------------------------------------------------
    64 *
    65 * WARNING:  The address of "FLOCK" depends on the version of the bios EPROM.
    66 * The address below is for EPROMs dated 1988-04-18 or 1988-06-20 ONLY.
    67 *
    68 FLOCK           .equ    $00000E0C       * WORD - Floppy semaphore       <<<=====
    69 *
    70 * ==============================================================================
    71 *
    72 * Equates to routines in bios.s:
    73 * ------------------------------
    74 *
    75 * WARNING:  The address of "FLOPVBL" depends on the version of the bios EPROM.
    76 * The address below is for EPROMs dated 1988-04-18 or 1988-06-20 ONLY.
    77 *
    78 FLOPVBL         .equ    $001015EE       * floppy VI handler address     <<<=====
    79 *
    80 * ==============================================================================
    81 *
    82                 .page
    83 *
    84 * Hardware address equates:
    85 * -------------------------
    86 TI_VEC          .equ    $00000070       * Timer interrupt autovector
    87 *
    88 TIMER           .equ    $003A0001       * Timer base address
    89 M1_ACIA         .equ    $003AC001       * MIDI ACIA channel 1 base address
    90 *
    91 * ------------------------------------------------------------------------------
    92 *
    93 * Timer register equates:
    94 * -----------------------
    95 TIME_CRX        .equ    TIMER           * Control register 1 or 3
    96 TIME_CR2        .equ    TIMER+2         * Control register 2
    97 TIME_T1H        .equ    TIMER+4         * Timer 1 high byte
    98 TIME_T1L        .equ    TIMER+6         * Timer 1 low byte
    99 TIME_T2H        .equ    TIMER+8         * Timer 2 high byte
    100 TIME_T2L        .equ    TIMER+10        * Timer 2 low byte
    101 TIME_T3H        .equ    TIMER+12        * Timer 3 high byte
    102 TIME_T3L        .equ    TIMER+14        * Timer 3 low byte
    103 *
    104 * Serial I/O equates:
    105 * -------------------
    106 ACIA_CFR        .equ    2               * CFR offset from ACIA base
    107 DTR_BIT         .equ    1               * DTR bit in ACIA CFR1
    108 *
    109 IO_CFR1         .equ    29              * cfr1 offset in M1IoRec
    110 *
    111 * ==============================================================================
    112 *
    113 * Miscellaneous equates:
    114 * ----------------------
    115 IPL7            .equ    $0700           * IPL mask for interrupt disable
    116 *
    117 FCMAX           .equ    $00FFFFFF       * Maximum frame counter value
    118 FCMIN           .equ    $00000000       * Minimum frame counter value
    119 *
    120 NTIMERS         .equ    8               * Number of timers in the timer array
    121 *
    122 XBIOS           .equ    14              * XBIOS TRAP number
    123 X_PIOREC        .equ    0               * X_PIOREC code
    124 SR1_DEV         .equ    0               * RS232 ACIA channel 1
    125 SR2_DEV         .equ    1               * RS232 ACIA channel 2
    126 MC1_DEV         .equ    3               * MIDI ACIA channel 1
    127 MC2_DEV         .equ    4               * MIDI ACIA channel 2
    128 * ==============================================================================
    129 *
    130                 .page
    131 * ==============================================================================
    132 * _tsetup -- tsetup() -- timer setup function
    133 * ==============================================================================
    134 *
    135 _tsetup:        move.w  sr,-(a7)                * Save old interrupt mask
    136                 ori.w   #IPL7,sr                * Disable interrupts
    137 *
    138                 move.w  #SR1_DEV,-(a7)          * Establish S1IoRec
    139                 move.w  #X_PIOREC,-(a7)         * ...
    140                 trap    #XBIOS                  * ...
    141                 add.l   #4,a7                   * ...
    142                 move.l  d0,_S1IoRec             * ...
    143 *
    144                 move.w  #SR2_DEV,-(a7)          * Establish S2IoRec
    145                 move.w  #X_PIOREC,-(a7)         * ...
    146                 trap    #XBIOS                  * ...
    147                 add.l   #4,a7                   * ...
    148                 move.l  d0,_S2IoRec             * ...
    149 *
    150                 move.w  #MC1_DEV,-(a7)          * Establish M1IoRec
    151                 move.w  #X_PIOREC,-(a7)         * ...
    152                 trap    #XBIOS                  * ...
    153                 add.l   #4,a7                   * ...
    154                 move.l  d0,_M1IoRec             * ...
    155 *
    156                 move.w  #MC2_DEV,-(a7)          * Establish M2IoRec
    157                 move.w  #X_PIOREC,-(a7)         * ...
    158                 trap    #XBIOS                  * ...
    159                 add.l   #4,a7                   * ...
    160                 move.l  d0,_M2IoRec             * ...
    161 *
    162                 .page
    163 *
    164                 clr.w   FC_SW                   * Stop the frame clock
    165                 clr.l   FC_VAL                  * ... and reset it
    166                 clr.w   _vi_tag                 * Clear VSDD VI tag
    167                 clr.w   _vi_clk                 * Clear VSDD delay timer
    168                 clr.w   lclsadr                 * Clear score scroll address
    169                 clr.w   lclscrl                 * Clear score scroll offset
    170 *
    171                 lea     _timers,a0              * Point at timer array
    172                 move.w  #NTIMERS-1,d0           * Setup to clear timer array
    173 *
    174 tclr:           clr.w   (a0)+                   * Clear a timer array entry
    175                 dbra    d0,tclr                 * Loop until done
    176 *
    177                 move.l  #nullrts,TIMEVEC        * Set timer interrupt vector
    178                 move.l  #timeint,TI_VEC         * Set timer trap vector
    179 *
    180                 move.b  #$00,TIME_T1H           * Setup timer 1  (PLL)
    181                 move.b  #$1F,TIME_T1L           * ... for divide by 64
    182                 move.b  #$0C,TIME_T2H           * Setup timer 2  (FC)
    183                 move.b  #$7F,TIME_T2L           * ... for divide by 3200
    184                 move.b  #$03,TIME_T3H           * Setup timer 3  (RTC)
    185                 move.b  #$20,TIME_T3L           * ... for 1Ms interval
    186                 move.b  #$42,TIME_CRX           * Setup CR3
    187                 move.b  #$41,TIME_CR2           * Setup CR2
    188                 move.b  #$81,TIME_CRX           * Setup CR1
    189                 move.b  #$80,TIME_CRX           * Start the timers
    190 *
    191                 move.w  (a7)+,sr                * Restore interrupts
    192 *
    193 nullrts:        rts                             * Return to caller
    194 *
    195                 .page
    196 * ==============================================================================
    197 * timeint -- timer interrupt handler
    198 * ==============================================================================
    199 *
    200 timeint:        movem.l d0-d7/a0-a6,-(a7)       * Save registers
    201                 move.b  TIME_CR2,d0             * Get timer interrupt status
    202 * ------------------------------------------------------------------------------
    203 * process 1 MS timer
    204 * ------------------------------------------------------------------------------
    205                 btst.l  #2,d0                   * Check timer 3 status
    206                 beq     tmi02                   * Jump if not active
    207 *
    208                 move.b  TIME_T3H,d1             * Read timer 3 count
    209                 lsl.w   #8,d1                   * ...
    210                 move.b  TIME_T3L,d1             * ...
    211                 move.w  d1,T3COUNT              * ... and save it
    212 *
    213                 addq.l  #1,HZ_1K                * Update 1ms clock  (1 KHz)
    214 *
    215                 move.l  d0,-(a7)                * Preserve D0
    216 * ------------------------------------------------------------------------------
    217 * process VSDD timer
    218 * ------------------------------------------------------------------------------
    219                 tst.w   _vi_tag                 * Does the VSDD need service ?
    220                 beq     updtime                 * Jump if not
    221 *
    222                 move.w  _vi_clk,d0              * Get VSDD scroll delay timer
    223                 subq.w  #1,d0                   * Decrement timer
    224                 move.w  d0,_vi_clk              * Update timer
    225                 bne     updtime                 * Jump if it's not zero yet
    226 *
    227                 move.w  lclsadr,_v_odtab+12     * Update scroll address
    228                 move.w  lclscrl,_v_odtab+10     * Update scroll offset
    229                 clr.w   _vi_tag                 * Reset the tag
    230 *
    231                 .page
    232 *
    233 * ------------------------------------------------------------------------------
    234 * process programable timers
    235 * ------------------------------------------------------------------------------
    236 *
    237 updtime:        move.w  #NTIMERS-1,d0           * Setup timer array counter
    238                 lea     _timers,a0              * Point at timer array
    239 *
    240 tdcr:           move.w  (a0),d1                 * Get timer array entry
    241                 beq     tdcr1                   * Jump if already 0
    242 *
    243                 subq.w  #1,d1                   * Decrement timer
    244 *
    245 tdcr1:          move.w  d1,(a0)+                * Store updated timer value
    246                 dbra    d0,tdcr                 * Loop until done
    247 *
    248 * ------------------------------------------------------------------------------
    249 * process timer hook vector
    250 * ------------------------------------------------------------------------------
    251                 movea.l TIMEVEC,a0              * Get RTC vector
    252                 move.w  #1,-(a7)                * Pass 1 msec on stack
    253                 jsr     (a0)                    * Process RTC vector
    254                 addq.l  #2,a7                   * Clean up stack
    255 *
    256                 move.l  (a7)+,d0                * Restore D0
    257 *
    258                 .page
    259 * ------------------------------------------------------------------------------
    260 * process 5 Ms clock
    261 * ------------------------------------------------------------------------------
    262                 move.w  tdiv1,d1                * Update divider
    263                 addq.w  #1,d1                   * ...
    264                 move.w  d1,tdiv1                * ...
    265 *
    266                 cmpi.w  #5,d1                   * Do we need to update HZ_200 ?
    267                 blt     tmi02                   * Jump if not
    268 *
    269                 addq.l  #1,HZ_200               * Update 5ms clock   (200 Hz)
    270 * ------------------------------------------------------------------------------
    271 * process 20 Ms floppy clock
    272 * ------------------------------------------------------------------------------
    273                 move.w  tdiv2,d1                * Update divider
    274                 addq.w  #1,d1                   * ...
    275                 move.w  d1,tdiv2                * ...
    276 *
    277                 cmpi.w  #4,d1                   * Do we need to update FRCLOCK ?
    278                 blt     tmi01                   * Jump if not
    279 *
    280                 addq.l  #1,FRCLOCK              * Update 20 Ms clock  (50 Hz)
    281                 tst.w   FLOCK                   * See if floppy is active
    282                 bne     tmi00                   * Don't call FLOPVBL if so
    283 *
    284                 jsr     FLOPVBL                 * Check on the floppy
    285 *
    286 tmi00:          move.w  #0,tdiv2                * Reset tdiv2
    287 *
    288 tmi01:          move.w  #0,tdiv1                * Reset tdiv1
    289 *
    290                 .page
    291 * ------------------------------------------------------------------------------
    292 * process PLL timers
    293 * ------------------------------------------------------------------------------
    294 *
    295 tmi02:          btst.l  #0,d0                   * Check timer 1 int
    296                 beq     tmi03                   * Jump if not set
    297 *
    298                 move.b  TIME_T1H,d1             * Read timer 1 to clear int.
    299                 move.b  TIME_T1L,d1             * ...
    300 *
    301 tmi03:          btst.l  #1,d0                   * Check for timer 2 int.
    302                 beq     tmi04                   * Jump if not set
    303 *
    304                 move.b  TIME_T2H,d1             * Read timer 2 to clear int.
    305                 move.b  TIME_T2L,d1             * ...
    306 *
    307                 .page
    308 * ------------------------------------------------------------------------------
    309 * update score frame counter
    310 * ------------------------------------------------------------------------------
    311                 tst.w   FC_SW                   * Should we update the frame ?
    312                 beq     tmi04                   * Jump if not
    313 *
    314                 bmi     tmi05                   * Jump if we count down
    315 *
    316                 move.l  FC_VAL,d0               * Get the frame count
    317                 cmp.l   #FCMAX,d0               * See it we've topped out
    318                 bge     tmi06                   * Jump if limit was hit
    319 *
    320                 addq.l  #1,d0                   * Count up 1 frame
    321                 move.l  d0,FC_VAL               * Store updated frame count
    322 *
     27
     28                .xdef   _tsetup         | tsetup() -- timer setup function
     29                .xdef   timeint         | timer interrupt handler
     30
     31                .xdef   _M1IoRec        | MIDI channel 1 IoRec
     32                .xdef   _M2IoRec        | MIDI channel 2 IoRec
     33                .xdef   _S1IoRec        | RS232 channel 1 IoRec
     34                .xdef   _S2IoRec        | RS232 channel 2 IoRec
     35                .xdef   _timers         | timer array -- short timers[NTIMERS]
     36                .xdef   _vi_clk         | VSDD scroll delay timer
     37                .xdef   _vi_tag         | VSDD VI tag
     38
     39                .xref   lclsadr         | score object base address
     40                .xref   lclscrl         | score object scroll offset
     41                .xref   _v_odtab        | VSDD object descriptor table
     42
     43                .page
     44| ==============================================================================
     45
     46FRAMES          =       0               | set non-zero to enable frame pulses
     47
     48| Equates to variables in bios.s:
     49| -------------------------------
     50| These variables are permanently assigned.
     51
     52TIMEVEC         =       0x00000400      | LONG - System timer trap vector
     53
     54FC_SW           =       0x00000420      | WORD - Frame clock switch
     55FC_VAL          =       0x00000422      | LONG - Frame clock value
     56
     57HZ_1K           =       0x0000049A      | LONG - 1000 Hz clock
     58HZ_200          =       0x0000049E      | LONG - 200 Hz clock
     59FRCLOCK         =       0x000004A2      | LONG - 50 Hz clock
     60
     61T3COUNT         =       0x000004AA      | WORD - Timer 3 count
     62
     63| ------------------------------------------------------------------------------
     64
     65| WARNING:  The address of "FLOCK" depends on the version of the bios EPROM.
     66| The address below is for EPROMs dated 1988-04-18 or 1988-06-20 ONLY.
     67
     68FLOCK           =       0x00000E0C      | WORD - Floppy semaphore       <<<=====
     69
     70| ==============================================================================
     71
     72| Equates to routines in bios.s:
     73| ------------------------------
     74
     75| WARNING:  The address of "FLOPVBL" depends on the version of the bios EPROM.
     76| The address below is for EPROMs dated 1988-04-18 or 1988-06-20 ONLY.
     77
     78FLOPVBL         =       0x001015EE      | floppy VI handler address     <<<=====
     79
     80| ==============================================================================
     81
     82                .page
     83
     84| Hardware address equates:
     85| -------------------------
     86TI_VEC          =       0x00000070      | Timer interrupt autovector
     87
     88TIMER           =       0x003A0001      | Timer base address
     89M1_ACIA         =       0x003AC001      | MIDI ACIA channel 1 base address
     90
     91| ------------------------------------------------------------------------------
     92
     93| Timer register equates:
     94| -----------------------
     95TIME_CRX        =       TIMER           | Control register 1 or 3
     96TIME_CR2        =       TIMER+2         | Control register 2
     97TIME_T1H        =       TIMER+4         | Timer 1 high byte
     98TIME_T1L        =       TIMER+6         | Timer 1 low byte
     99TIME_T2H        =       TIMER+8         | Timer 2 high byte
     100TIME_T2L        =       TIMER+10        | Timer 2 low byte
     101TIME_T3H        =       TIMER+12        | Timer 3 high byte
     102TIME_T3L        =       TIMER+14        | Timer 3 low byte
     103
     104| Serial I/O equates:
     105| -------------------
     106ACIA_CFR        =       2               | CFR offset from ACIA base
     107DTR_BIT         =       1               | DTR bit in ACIA CFR1
     108
     109IO_CFR1         =       29              | cfr1 offset in M1IoRec
     110
     111| ==============================================================================
     112
     113| Miscellaneous equates:
     114| ----------------------
     115IPL7            =       0x0700          | IPL mask for interrupt disable
     116
     117FCMAX           =       0x00FFFFFF      | Maximum frame counter value
     118FCMIN           =       0x00000000      | Minimum frame counter value
     119
     120NTIMERS         =       8               | Number of timers in the timer array
     121
     122XBIOS           =       14              | XBIOS TRAP number
     123X_PIOREC        =       0               | X_PIOREC code
     124SR1_DEV         =       0               | RS232 ACIA channel 1
     125SR2_DEV         =       1               | RS232 ACIA channel 2
     126MC1_DEV         =       3               | MIDI ACIA channel 1
     127MC2_DEV         =       4               | MIDI ACIA channel 2
     128| ==============================================================================
     129
     130                .page
     131| ==============================================================================
     132| _tsetup -- tsetup() -- timer setup function
     133| ==============================================================================
     134
     135_tsetup:        move.w  sr,-(a7)                | Save old interrupt mask
     136                ori.w   #IPL7,sr                | Disable interrupts
     137
     138                move.w  #SR1_DEV,-(a7)          | Establish S1IoRec
     139                move.w  #X_PIOREC,-(a7)         | ...
     140                trap    #XBIOS                  | ...
     141                add.l   #4,a7                   | ...
     142                move.l  d0,_S1IoRec             | ...
     143
     144                move.w  #SR2_DEV,-(a7)          | Establish S2IoRec
     145                move.w  #X_PIOREC,-(a7)         | ...
     146                trap    #XBIOS                  | ...
     147                add.l   #4,a7                   | ...
     148                move.l  d0,_S2IoRec             | ...
     149
     150                move.w  #MC1_DEV,-(a7)          | Establish M1IoRec
     151                move.w  #X_PIOREC,-(a7)         | ...
     152                trap    #XBIOS                  | ...
     153                add.l   #4,a7                   | ...
     154                move.l  d0,_M1IoRec             | ...
     155
     156                move.w  #MC2_DEV,-(a7)          | Establish M2IoRec
     157                move.w  #X_PIOREC,-(a7)         | ...
     158                trap    #XBIOS                  | ...
     159                add.l   #4,a7                   | ...
     160                move.l  d0,_M2IoRec             | ...
     161
     162                .page
     163
     164                clr.w   FC_SW                   | Stop the frame clock
     165                clr.l   FC_VAL                  | ... and reset it
     166                clr.w   _vi_tag                 | Clear VSDD VI tag
     167                clr.w   _vi_clk                 | Clear VSDD delay timer
     168                clr.w   lclsadr                 | Clear score scroll address
     169                clr.w   lclscrl                 | Clear score scroll offset
     170
     171                lea     _timers,a0              | Point at timer array
     172                move.w  #NTIMERS-1,d0           | Setup to clear timer array
     173
     174tclr:           clr.w   (a0)+                   | Clear a timer array entry
     175                dbra    d0,tclr                 | Loop until done
     176
     177                move.l  #nullrts,TIMEVEC        | Set timer interrupt vector
     178                move.l  #timeint,TI_VEC         | Set timer trap vector
     179
     180                move.b  #0x00,TIME_T1H          | Setup timer 1  (PLL)
     181                move.b  #0x1F,TIME_T1L          | ... for divide by 64
     182                move.b  #0x0C,TIME_T2H          | Setup timer 2  (FC)
     183                move.b  #0x7F,TIME_T2L          | ... for divide by 3200
     184                move.b  #0x03,TIME_T3H          | Setup timer 3  (RTC)
     185                move.b  #0x20,TIME_T3L          | ... for 1Ms interval
     186                move.b  #0x42,TIME_CRX          | Setup CR3
     187                move.b  #0x41,TIME_CR2          | Setup CR2
     188                move.b  #0x81,TIME_CRX          | Setup CR1
     189                move.b  #0x80,TIME_CRX          | Start the timers
     190
     191                move.w  (a7)+,sr                | Restore interrupts
     192
     193nullrts:        rts                             | Return to caller
     194
     195                .page
     196| ==============================================================================
     197| timeint -- timer interrupt handler
     198| ==============================================================================
     199
     200timeint:        movem.l d0-d7/a0-a6,-(a7)       | Save registers
     201                move.b  TIME_CR2,d0             | Get timer interrupt status
     202| ------------------------------------------------------------------------------
     203| process 1 MS timer
     204| ------------------------------------------------------------------------------
     205                btst.l  #2,d0                   | Check timer 3 status
     206                beq     tmi02                   | Jump if not active
     207
     208                move.b  TIME_T3H,d1             | Read timer 3 count
     209                lsl.w   #8,d1                   | ...
     210                move.b  TIME_T3L,d1             | ...
     211                move.w  d1,T3COUNT              | ... and save it
     212
     213                addq.l  #1,HZ_1K                | Update 1ms clock  (1 KHz)
     214
     215                move.l  d0,-(a7)                | Preserve D0
     216| ------------------------------------------------------------------------------
     217| process VSDD timer
     218| ------------------------------------------------------------------------------
     219                tst.w   _vi_tag                 | Does the VSDD need service ?
     220                beq     updtime                 | Jump if not
     221
     222                move.w  _vi_clk,d0              | Get VSDD scroll delay timer
     223                subq.w  #1,d0                   | Decrement timer
     224                move.w  d0,_vi_clk              | Update timer
     225                bne     updtime                 | Jump if it's not zero yet
     226
     227                move.w  lclsadr,_v_odtab+12     | Update scroll address
     228                move.w  lclscrl,_v_odtab+10     | Update scroll offset
     229                clr.w   _vi_tag                 | Reset the tag
     230
     231                .page
     232
     233| ------------------------------------------------------------------------------
     234| process programable timers
     235| ------------------------------------------------------------------------------
     236
     237updtime:        move.w  #NTIMERS-1,d0           | Setup timer array counter
     238                lea     _timers,a0              | Point at timer array
     239
     240tdcr:           move.w  (a0),d1                 | Get timer array entry
     241                beq     tdcr1                   | Jump if already 0
     242
     243                subq.w  #1,d1                   | Decrement timer
     244
     245tdcr1:          move.w  d1,(a0)+                | Store updated timer value
     246                dbra    d0,tdcr                 | Loop until done
     247
     248| ------------------------------------------------------------------------------
     249| process timer hook vector
     250| ------------------------------------------------------------------------------
     251                movea.l TIMEVEC,a0              | Get RTC vector
     252                move.w  #1,-(a7)                | Pass 1 msec on stack
     253                jsr     (a0)                    | Process RTC vector
     254                addq.l  #2,a7                   | Clean up stack
     255
     256                move.l  (a7)+,d0                | Restore D0
     257
     258                .page
     259| ------------------------------------------------------------------------------
     260| process 5 Ms clock
     261| ------------------------------------------------------------------------------
     262                move.w  tdiv1,d1                | Update divider
     263                addq.w  #1,d1                   | ...
     264                move.w  d1,tdiv1                | ...
     265
     266                cmpi.w  #5,d1                   | Do we need to update HZ_200 ?
     267                blt     tmi02                   | Jump if not
     268
     269                addq.l  #1,HZ_200               | Update 5ms clock   (200 Hz)
     270| ------------------------------------------------------------------------------
     271| process 20 Ms floppy clock
     272| ------------------------------------------------------------------------------
     273                move.w  tdiv2,d1                | Update divider
     274                addq.w  #1,d1                   | ...
     275                move.w  d1,tdiv2                | ...
     276
     277                cmpi.w  #4,d1                   | Do we need to update FRCLOCK ?
     278                blt     tmi01                   | Jump if not
     279
     280                addq.l  #1,FRCLOCK              | Update 20 Ms clock  (50 Hz)
     281                tst.w   FLOCK                   | See if floppy is active
     282                bne     tmi00                   | Don't call FLOPVBL if so
     283
     284                jsr     FLOPVBL                 | Check on the floppy
     285
     286tmi00:          move.w  #0,tdiv2                | Reset tdiv2
     287
     288tmi01:          move.w  #0,tdiv1                | Reset tdiv1
     289
     290                .page
     291| ------------------------------------------------------------------------------
     292| process PLL timers
     293| ------------------------------------------------------------------------------
     294
     295tmi02:          btst.l  #0,d0                   | Check timer 1 int
     296                beq     tmi03                   | Jump if not set
     297
     298                move.b  TIME_T1H,d1             | Read timer 1 to clear int.
     299                move.b  TIME_T1L,d1             | ...
     300
     301tmi03:          btst.l  #1,d0                   | Check for timer 2 int.
     302                beq     tmi04                   | Jump if not set
     303
     304                move.b  TIME_T2H,d1             | Read timer 2 to clear int.
     305                move.b  TIME_T2L,d1             | ...
     306
     307                .page
     308| ------------------------------------------------------------------------------
     309| update score frame counter
     310| ------------------------------------------------------------------------------
     311                tst.w   FC_SW                   | Should we update the frame ?
     312                beq     tmi04                   | Jump if not
     313
     314                bmi     tmi05                   | Jump if we count down
     315
     316                move.l  FC_VAL,d0               | Get the frame count
     317                cmp.l   #FCMAX,d0               | See it we've topped out
     318                bge     tmi06                   | Jump if limit was hit
     319
     320                addq.l  #1,d0                   | Count up 1 frame
     321                move.l  d0,FC_VAL               | Store updated frame count
     322
    323323                .ifne   FRAMES
    324                 move.w  sr,d1                   * Preserve interrupt status
    325                 ori.w   #$0700,sr               * Disable interrupts
    326 *
    327                 movea.l _M1IoRec,a0             * Point at M1IoRec
    328                 move.b  IO_CFR1(a0),d0          * Get MIDI-1 CFR1 value
    329                 or.b    #$80,d0                 * Force MSB = 1 for CFR1 output
    330                 movea.l #M1_ACIA,a0             * Point at MIDI-1 ACIA channel
    331                 bchg.l  #DTR_BIT,d0             * Toggle DTR for output
    332                 move.b  d0,ACIA_CFR(a0)         * Output toggled DTR
    333                 bchg.l  #DTR_BIT,d0             * Toggle DTR for output
    334                 move.b  d0,ACIA_CFR(a0)         * Output toggled DTR
    335                 move.w  d1,sr                   * Restore interrupts
     324                move.w  sr,d1                   | Preserve interrupt status
     325                ori.w   #0x0700,sr              | Disable interrupts
     326
     327                movea.l _M1IoRec,a0             | Point at M1IoRec
     328                move.b  IO_CFR1(a0),d0          | Get MIDI-1 CFR1 value
     329                or.b    #0x80,d0                | Force MSB = 1 for CFR1 output
     330                movea.l #M1_ACIA,a0             | Point at MIDI-1 ACIA channel
     331                bchg.l  #DTR_BIT,d0             | Toggle DTR for output
     332                move.b  d0,ACIA_CFR(a0)         | Output toggled DTR
     333                bchg.l  #DTR_BIT,d0             | Toggle DTR for output
     334                move.b  d0,ACIA_CFR(a0)         | Output toggled DTR
     335                move.w  d1,sr                   | Restore interrupts
    336336                .endc
    337 *
    338                 bra     tmi04                   * Done
    339 *
    340 tmi07:          move.l  #FCMIN,FC_VAL           * Force hard limit, just in case
    341                 bra     tmi04                   * Done
    342 *
    343 tmi06:          move.l  #FCMAX,FC_VAL           * Force hard limit, just in case
    344                 bra     tmi04                   * Done
    345 *
    346 tmi05:          move.l  FC_VAL,d0               * Get the frame count
    347                 ble     tmi07                   * Done if already counted down
    348 *
    349                 subq.l  #1,d0                   * Count down 1 frame
    350                 move.l  d0,FC_VAL               * Store udpated frame count
    351                 bra     tmi04                   * Done
    352 *
    353                 nop                             * Filler to force equal paths
    354 *
    355 tmi04:          movem.l (a7)+,d0-d7/a0-a6       * Restore registers
    356                 rte                             * Return to interrupted code
    357 *
    358                 .page
    359 * ==============================================================================
     337
     338                bra     tmi04                   | Done
     339
     340tmi07:          move.l  #FCMIN,FC_VAL           | Force hard limit, just in case
     341                bra     tmi04                   | Done
     342
     343tmi06:          move.l  #FCMAX,FC_VAL           | Force hard limit, just in case
     344                bra     tmi04                   | Done
     345
     346tmi05:          move.l  FC_VAL,d0               | Get the frame count
     347                ble     tmi07                   | Done if already counted down
     348
     349                subq.l  #1,d0                   | Count down 1 frame
     350                move.l  d0,FC_VAL               | Store udpated frame count
     351                bra     tmi04                   | Done
     352
     353                nop                             | Filler to force equal paths
     354
     355tmi04:          movem.l (a7)+,d0-d7/a0-a6       | Restore registers
     356                rte                             | Return to interrupted code
     357
     358                .page
     359| ==============================================================================
    360360                .bss
    361 * ==============================================================================
    362 *
    363 * A note on tdiv1 and tdiv2:
    364 * --------------------------
    365 *
    366 * tdiv1 and tdiv2 are actually defined in the bios,  but since they could move
    367 * we define them here and ignore the ones in the bios.
    368 *
    369 tdiv1:          ds.w    1               * Timer divider 1  (divides HZ_1K)
    370 tdiv2:          ds.w    1               * Timer divider 2  (divides HZ_200)
    371 *
    372 * ------------------------------------------------------------------------------
    373 *
    374 _timers:        ds.w    NTIMERS         * Timer array -- short timers[NTIMERS];
    375 *
    376 _vi_clk:        ds.w    1               * VSDD scroll delay timer
    377 _vi_tag:        ds.w    1               * VSDD VI 'needs service' tag
    378 *
    379 _S1IoRec:       ds.l    1               * address of RS232 channel 1 IoRec
    380 _S2IoRec:       ds.l    1               * address of RS232 channel 2 IoRec
    381 _M1IoRec:       ds.l    1               * address of MIDI channel 1 IoRec
    382 _M2IoRec:       ds.l    1               * address of MIDI channel 2 IoRec
    383 * ==============================================================================
    384 *
     361| ==============================================================================
     362
     363| A note on tdiv1 and tdiv2:
     364| --------------------------
     365
     366| tdiv1 and tdiv2 are actually defined in the bios,  but since they could move
     367| we define them here and ignore the ones in the bios.
     368
     369tdiv1:          ds.w    1               | Timer divider 1  (divides HZ_1K)
     370tdiv2:          ds.w    1               | Timer divider 2  (divides HZ_200)
     371
     372| ------------------------------------------------------------------------------
     373
     374_timers:        ds.w    NTIMERS         | Timer array -- short timers[NTIMERS];
     375
     376_vi_clk:        ds.w    1               | VSDD scroll delay timer
     377_vi_tag:        ds.w    1               | VSDD VI 'needs service' tag
     378
     379_S1IoRec:       ds.l    1               | address of RS232 channel 1 IoRec
     380_S2IoRec:       ds.l    1               | address of RS232 channel 2 IoRec
     381_M1IoRec:       ds.l    1               | address of MIDI channel 1 IoRec
     382_M2IoRec:       ds.l    1               | address of MIDI channel 2 IoRec
     383| ==============================================================================
     384
    385385                .end

  • ram/tofpu.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * tofpu.s -- convert between millisecond time interval and FPU increment formats
    3 * Version 9 -- 1987-12-21 -- D.N. Lynx Crowe
    4 *
    5 *       unsigned short
    6 *       tofpu(time)
    7 *       unsigned short time;
    8 *
    9 *               Converts 'time' in milliseconds to FPU format.
    10 *
    11 *       unsigned short
    12 *       fromfpu(fputime)
    13 *       unsigned short fputime;
    14 *
    15 *               Converts 'fputime' from FPU format to milliseconds.
    16 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| tofpu.s -- convert between millisecond time interval and FPU increment formats
     3| Version 9 -- 1987-12-21 -- D.N. Lynx Crowe
     4
     5|       unsigned short
     6|       tofpu(time)
     7|       unsigned short time;
     8
     9|               Converts 'time' in milliseconds to FPU format.
     10
     11|       unsigned short
     12|       fromfpu(fputime)
     13|       unsigned short fputime;
     14
     15|               Converts 'fputime' from FPU format to milliseconds.
     16| ------------------------------------------------------------------------------
    1717                .text
    18 *
     18
    1919                .xdef   _tofpu
    2020                .xdef   _fromfpu
    21 *
    22 TIME            .equ    8               * WORD - time argument  (either format)
    23 *
    24 TCYCL           .equ    $3B000000       * LONG - scaled FPU cycle time  (.4608)
    25 *
     21
     22TIME            =       8               | WORD - time argument  (either format)
     23
     24TCYCL           =       0x3B000000      | LONG - scaled FPU cycle time  (.4608)
     25
    2626                .page
    27 _tofpu:         link    a6,#0           * link stack frames
    28                 move.w  TIME(a6),d1     * get time interval
    29                 beq     notime          * jump if zero time
    30 *
    31                 clr.w   d2              * clear shift count
    32 *
    33 sloop:          btst    #15,d1          * see if MSB is set yet
    34                 bne     gotexp          * jump if so
    35 *
    36                 lsl.w   d1              * shift time left a bit
    37                 addq.w  #1,d2           * increment the shift count
    38                 cmpi.w  #15,d2          * see if we've hit the maximum
    39                 bne     sloop           * try again if not
    40 *
    41 gotexp:         move.l  #TCYCL,d0       * divide FPU cycle time by shifted value
    42                 divu    d1,d0           * ...
    43                 andi.w  #$FFF0,d0       * mask result
    44                 or.w    d2,d0           * set the exponent
    45 *
    46 finis:          unlk    a6              * unlink stack frames
    47                 rts                     * return to caller
    48 *
    49 notime:         clr.w   d0              * zero time is zero ...
    50                 bra     finis           * return value for zero time
    51 *
     27_tofpu:         link    a6,#0           | link stack frames
     28                move.w  TIME(a6),d1     | get time interval
     29                beq     notime          | jump if zero time
     30
     31                clr.w   d2              | clear shift count
     32
     33sloop:          btst    #15,d1          | see if MSB is set yet
     34                bne     gotexp          | jump if so
     35
     36                lsl.w   #1,d1           | shift time left a bit
     37                addq.w  #1,d2           | increment the shift count
     38                cmpi.w  #15,d2          | see if we've hit the maximum
     39                bne     sloop           | try again if not
     40
     41gotexp:         move.l  #TCYCL,d0       | divide FPU cycle time by shifted value
     42                divu    d1,d0           | ...
     43                andi.w  #0xFFF0,d0      | mask result
     44                or.w    d2,d0           | set the exponent
     45
     46finis:          unlk    a6              | unlink stack frames
     47                rts                     | return to caller
     48
     49notime:         clr.w   d0              | zero time is zero ...
     50                bra     finis           | return value for zero time
     51
    5252                .page
    53 _fromfpu:       link    a6,#0           * link stack frames
    54                 move.w  TIME(a6),d1     * get FPU formatted time
    55                 beq     zerotime        * done if it's zero
    56 *
    57                 move.w  d1,d2           * extract shift count
    58                 andi.w  #$000F,d2       * ...
    59                 andi.w  #$FFF0,d1       * extract mantissa
    60                 beq     zerotime        * ... just in case it's zero  (an error)
    61 *
    62                 move.l  #TCYCL,d0       * get FPU cycle time
    63                 divu    d1,d0           * divide by mantissa
    64                 bvc     divok           * jump if divide ok
    65 *
    66                 move.w  #$FFFF,d0       * jam maximum value for overflow
    67 *
    68 divok:          lsr.w   d2,d0           * shift result into position
    69 *
    70 byebye:         unlk    a6              * unlink stack frames
    71                 rts                     * return to caller
    72 *
    73 zerotime:       clr.l   d0              * return a zero result
    74                 bra     byebye          * ...
    75 *
     53_fromfpu:       link    a6,#0           | link stack frames
     54                move.w  TIME(a6),d1     | get FPU formatted time
     55                beq     zerotime        | done if it's zero
     56
     57                move.w  d1,d2           | extract shift count
     58                andi.w  #0x000F,d2      | ...
     59                andi.w  #0xFFF0,d1      | extract mantissa
     60                beq     zerotime        | ... just in case it's zero  (an error)
     61
     62                move.l  #TCYCL,d0       | get FPU cycle time
     63                divu    d1,d0           | divide by mantissa
     64                bvc     divok           | jump if divide ok
     65
     66                move.w  #0xFFFF,d0      | jam maximum value for overflow
     67
     68divok:          lsr.w   d2,d0           | shift result into position
     69
     70byebye:         unlk    a6              | unlink stack frames
     71                rts                     | return to caller
     72
     73zerotime:       clr.l   d0              | return a zero result
     74                bra     byebye          | ...
     75
    7676                .end
Note: See TracChangeset for help on using the changeset viewer.