Changeset 4f508e6 in buchla-68k


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

Converted assembly language files.

Files:
2 added
50 edited

Legend:

Unmodified
Added
Removed

  • iolib/hwdefs.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * hwdefs.s --  External definitions of Buchla 700 I/O addresses
    3 * Version 14 -- 1988-08-15 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| hwdefs.s --  External definitions of Buchla 700 I/O addresses
     3| Version 14 -- 1988-08-15 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   _io_time,_io_lcd,_io_ser,_io_midi
    88                .xdef   _io_disk,_io_tone,_io_leds,_io_kbrd
    99                .xdef   _io_vreg,_io_vraw,_io_vram,_io_fpu
    1010                .xdef   _lcd_a0,_lcd_a1
    11 *
     11
    1212                .xdef   _v_regs,_v_odtab,_v_actab
    1313                .xdef   _v_ct0
    1414                .xdef   _v_gt1
    1515                .xdef   _v_score,_v_cgtab
    16 *
     16
    1717                .xdef   _v_curs0,_v_curs1,_v_curs2,_v_curs3
    1818                .xdef   _v_curs4,_v_curs5,_v_curs6,_v_curs7
    … …  
    2020                .xdef   _v_win0
    2121                .xdef   _v_cur
    22 *
     22
    2323                .xdef   _fc_sw,_fc_val
    24 *
    25 * ------------------------------------------------------------------------------
    26 *
    27 * Hardware base addresses
    28 * -----------------------
    29 _io_fpu         .equ    $180000         * FPU base address
    30 *
    31 VB              .equ    $200000         * VSDD base address
    32 *
    33 _io_time        .equ    $3A0001         * Timer chip
    34 _io_lcd         .equ    $3A4001         * LCD controller
    35 _io_ser         .equ    $3A8001         * Serial ports  (RS232)
    36 _io_midi        .equ    $3AC001         * MIDI ports
    37 _io_disk        .equ    $3B0001         * Disk controller
    38 _io_tone        .equ    $3B4001         * Sound generator chip
    39 _io_leds        .equ    $3B8001         * LED driver
    40 _io_kbrd        .equ    $3BC001         * Keyboard / panel processor
    41 *
    42 _lcd_a0         .equ    _io_lcd         * LCD port a0
    43 _lcd_a1         .equ    _io_lcd+2       * LCD port a1
    44 *
     24
     25| ------------------------------------------------------------------------------
     26
     27| Hardware base addresses
     28| -----------------------
     29_io_fpu         =       0x180000        | FPU base address
     30
     31VB              =       0x200000        | VSDD base address
     32
     33_io_time        =       0x3A0001        | Timer chip
     34_io_lcd         =       0x3A4001        | LCD controller
     35_io_ser         =       0x3A8001        | Serial ports  (RS232)
     36_io_midi        =       0x3AC001        | MIDI ports
     37_io_disk        =       0x3B0001        | Disk controller
     38_io_tone        =       0x3B4001        | Sound generator chip
     39_io_leds        =       0x3B8001        | LED driver
     40_io_kbrd        =       0x3BC001        | Keyboard / panel processor
     41
     42_lcd_a0         =       _io_lcd         | LCD port a0
     43_lcd_a1         =       _io_lcd+2       | LCD port a1
     44
    4545                .page
    46 *
    47 * Video definitions
    48 * -----------------
    49 _io_vreg        .equ    VB              * Relocated video registers after setup
    50 _io_vraw        .equ    VB+$400         * Raw video registers at RESET
    51 _io_vram        .equ    VB              * Video RAM base address
    52 *
    53 * Name                  Offset            Usage                        Bank
    54 * -------               ---------         -------------------------    ----
    55 _v_regs         .equ    VB              * Video registers              0,1
    56 *
    57 _v_odtab        .equ    VB+128          * Object Descriptor Table       0
    58 _v_actab        .equ    VB+256          * Access Table                  0
    59 _v_ct0          .equ    VB+1024         * Character Text-0              0
    60 _v_gt1          .equ    VB+1304         * Graphics Text-1               0
    61 _v_score        .equ    VB+8192         * Score object                  0
    62 _v_cgtab        .equ    VB+122880       * Character Generator Table     0
    63 *
    64 _v_curs0        .equ    VB+1024         * Cursor object 0  (arrow ULE)  1
    65 _v_curs1        .equ    VB+1152         * Cursor object 1  (arrow ULO)  1
    66 _v_curs2        .equ    VB+1280         * Cursor object 2  (arrow URE)  1
    67 _v_curs3        .equ    VB+1408         * Cursor object 3  (arrow URO)  1
    68 _v_curs4        .equ    VB+1536         * Cursor object 4  (arrow LLE)  1
    69 _v_curs5        .equ    VB+1664         * Cursor object 5  (arrow LLO)  1
    70 _v_curs6        .equ    VB+1792         * Cursor object 6  (arrow LRE)  1
    71 _v_curs7        .equ    VB+1920         * Cursor object 7  (arrow LRO)  1
    72 _v_tcur         .equ    VB+2048         * Typewriter cursor             1
    73 _v_kbobj        .equ    VB+2880         * Keyboard object               1
    74 _v_lnobj        .equ    VB+4672         * Line object                   1
    75 _v_cur          .equ    VB+6464         * Underline cursor              1
    76 _v_win0         .equ    VB+16384        * Window-0 object               1
    77 *
    78 * BIOS RAM definitions
    79 * --------------------
    80 * WARNING: the following addresses must match those of the corresponding
    81 * variables defined in bios.s or chaos is guaranteed.
    82 *
    83 _fc_sw          .equ    $420            * word - Frame counter switch
    84 _fc_val         .equ    $422            * long - Frame counter value
    85 *
     46
     47| Video definitions
     48| -----------------
     49_io_vreg        =       VB              | Relocated video registers after setup
     50_io_vraw        =       VB+0x400        | Raw video registers at RESET
     51_io_vram        =       VB              | Video RAM base address
     52
     53| Name                  Offset            Usage                        Bank
     54| -------               ---------         -------------------------    ----
     55_v_regs         =       VB              | Video registers              0,1
     56
     57_v_odtab        =       VB+128          | Object Descriptor Table       0
     58_v_actab        =       VB+256          | Access Table                  0
     59_v_ct0          =       VB+1024         | Character Text-0              0
     60_v_gt1          =       VB+1304         | Graphics Text-1               0
     61_v_score        =       VB+8192         | Score object                  0
     62_v_cgtab        =       VB+122880       | Character Generator Table     0
     63
     64_v_curs0        =       VB+1024         | Cursor object 0  (arrow ULE)  1
     65_v_curs1        =       VB+1152         | Cursor object 1  (arrow ULO)  1
     66_v_curs2        =       VB+1280         | Cursor object 2  (arrow URE)  1
     67_v_curs3        =       VB+1408         | Cursor object 3  (arrow URO)  1
     68_v_curs4        =       VB+1536         | Cursor object 4  (arrow LLE)  1
     69_v_curs5        =       VB+1664         | Cursor object 5  (arrow LLO)  1
     70_v_curs6        =       VB+1792         | Cursor object 6  (arrow LRE)  1
     71_v_curs7        =       VB+1920         | Cursor object 7  (arrow LRO)  1
     72_v_tcur         =       VB+2048         | Typewriter cursor             1
     73_v_kbobj        =       VB+2880         | Keyboard object               1
     74_v_lnobj        =       VB+4672         | Line object                   1
     75_v_cur          =       VB+6464         | Underline cursor              1
     76_v_win0         =       VB+16384        | Window-0 object               1
     77
     78| BIOS RAM definitions
     79| --------------------
     80| WARNING: the following addresses must match those of the corresponding
     81| variables defined in bios.s or chaos is guaranteed.
     82
     83_fc_sw          =       0x420           | word - Frame counter switch
     84_fc_val         =       0x422           | long - Frame counter value
     85
    8686                .end

  • iolib/rtraps.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * rtraps.s -- define ROMP debug trap
    3 * Version 7 -- 1988-01-12 -- Copyright 1987, 1988 by D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| rtraps.s -- define ROMP debug trap
     3| Version 7 -- 1988-01-12 -- Copyright 1987, 1988 by D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   _trap15
    8 *
     8
    99                .xref   _rompbp
    10 *
     10
    1111                .xref   tr1sav,tr13sav,tr14sav
    1212                .xref   tr1rmp,tr13rmp,tr14rmp
    13 *
    14 BUCHLA          .equ    1               * IPL value:  0 = NASA , 1 = Buchla
    15 *
     13
     14BUCHLA          =       1               | IPL value:  0 = NASA , 1 = Buchla
     15
    1616                .ifeq   BUCHLA
    17 IPLEVEL         .equ    $0400           * NASA IPL = 4    (enable 5 and above)
     17IPLEVEL         =       0x0400          | NASA IPL = 4    (enable 5 and above)
    1818                .endc
    19 *
     19
    2020                .ifne   BUCHLA
    21 IPLEVEL         .equ    $0200           * Buchla IPL = 2  (enable 3 and above)
     21IPLEVEL         =       0x0200          | Buchla IPL = 2  (enable 3 and above)
    2222                .endc
    23 *
    24 IPL7            .equ    $0700           * IPL 7
    25 *
    26 * _trap15 -- ROMP debug trap  (used to implement breakpoints)
    27 * -------    ------------------------------------------------
    28 _trap15:        ori.w   #IPL7,sr                * Disable interrupts
    29                 move.w  #0,-(a7)                * Keep stack long aligned
    30                 movem.l d0-d7/a0-a7,-(a7)       * Save regs on stack
    31                 move.l  tr1sav,tr1rmp           * Save trap save areas
    32                 move.l  tr13sav,tr13rmp         * ...
    33                 move.l  tr14sav,tr14rmp         * ...
    34                 move.w  sr,d0                   * Get status register
    35                 andi.w  #$F8FF,d0               * Enable serial I/O interrupts
    36                 ori.w   #IPLEVEL,d0             * ...
    37                 move.w  d0,sr                   * ...
    38                 jsr     _rompbp                 * Pass control to ROMP
    39 *
    40                 ori.w   #IPL7,sr                * Disable interrupts
    41                 move.l  tr14rmp,tr14sav         * Restore trap save areas
    42                 move.l  tr13rmp,tr13sav         * ...
    43                 move.l  tr1rmp,tr1sav           * ...
    44                 movem.l (a7)+,d0-d7/a0-a7       * Restore regs
    45                 addq.l  #2,a7                   * Discard alignment filler word
    46                 rte                             * Back to what we interrupted
    47 *
     23
     24IPL7            =       0x0700          | IPL 7
     25
     26| _trap15 -- ROMP debug trap  (used to implement breakpoints)
     27| -------    ------------------------------------------------
     28_trap15:        ori.w   #IPL7,sr                | Disable interrupts
     29                move.w  #0,-(a7)                | Keep stack long aligned
     30                movem.l d0-d7/a0-a7,-(a7)       | Save regs on stack
     31                move.l  tr1sav,tr1rmp           | Save trap save areas
     32                move.l  tr13sav,tr13rmp         | ...
     33                move.l  tr14sav,tr14rmp         | ...
     34                move.w  sr,d0                   | Get status register
     35                andi.w  #0xF8FF,d0              | Enable serial I/O interrupts
     36                ori.w   #IPLEVEL,d0             | ...
     37                move.w  d0,sr                   | ...
     38                jsr     _rompbp                 | Pass control to ROMP
     39
     40                ori.w   #IPL7,sr                | Disable interrupts
     41                move.l  tr14rmp,tr14sav         | Restore trap save areas
     42                move.l  tr13rmp,tr13sav         | ...
     43                move.l  tr1rmp,tr1sav           | ...
     44                movem.l (a7)+,d0-d7/a0-a7       | Restore regs
     45                addq.l  #2,a7                   | Discard alignment filler word
     46                rte                             | Back to what we interrupted
     47
    4848                .end

  • iolib/setipl.s

    rf40a309 r4f508e6  
    1 *
    2 * setipl.s -- Set internal processor interrupt level
    3 * --------    --------------------------------------
    4 * Version 2 -- 1988-06-29 -- D.N. Lynx Crowe
    5 *
    6 *       short
    7 *       setipl(arg);
    8 *       short arg;
    9 *
    10 *       Sets processor interrupt level to arg.
    11 *       Returns old interrupt level, or -1 if arg < 0 or > 7
    12 *
    13 *       Assumes you are in supervisor mode.
    14 *       You get a Privelege Violation TRAP if you aren't.
    15 *
     1
     2| setipl.s -- Set internal processor interrupt level
     3| --------    --------------------------------------
     4| Version 2 -- 1988-06-29 -- D.N. Lynx Crowe
     5
     6|       short
     7|       setipl(arg);
     8|       short arg;
     9
     10|       Sets processor interrupt level to arg.
     11|       Returns old interrupt level, or -1 if arg < 0 or > 7
     12
     13|       Assumes you are in supervisor mode.
     14|       You get a Privelege Violation TRAP if you aren't.
     15
    1616                .text
    17 *
     17
    1818                .xdef   _setipl
    19 *
    20 _setipl:        link    a6,#0                   * Link up stack frames
    21                 move.w  8(a6),d0                * Get argument
    22                 tst.w   d0                      * Check lower limit
    23                 bmi     setipler                * Jump if < 0  (error)
    24 *
    25                 cmpi.w  #7,d0                   * Check upper limit
    26                 bgt     setipler                * Jump if > 7  (error)
    27 *
    28                 move.w  sr,d1                   * Get current level
    29                 move.w  d1,d2                   * ... save for later
    30                 lsl.w   #8,d0                   * Shift argument into position
    31                 andi.w  #$F8FF,d1               * Mask out old level
    32                 or.w    d0,d1                   * OR in new level
    33                 move.w  d2,d0                   * Setup return of old level
    34                 lsr.w   #8,d0                   * ...
    35                 andi.l  #$7,d0                  * ...
    36                 move.w  d1,sr                   * Set the new interrupt level
    37                 unlk    a6                      * Unlink stack frames
    38                 rts                             * Return to caller
    39 *
    40 setipler:       moveq.l #-1,d0                  * Setup to return error code
    41                 unlk    a6                      * Unlink stack frames
    42                 rts                             * Return to caller
    43 *
     19
     20_setipl:        link    a6,#0                   | Link up stack frames
     21                move.w  8(a6),d0                | Get argument
     22                tst.w   d0                      | Check lower limit
     23                bmi     setipler                | Jump if < 0  (error)
     24
     25                cmpi.w  #7,d0                   | Check upper limit
     26                bgt     setipler                | Jump if > 7  (error)
     27
     28                move.w  sr,d1                   | Get current level
     29                move.w  d1,d2                   | ... save for later
     30                lsl.w   #8,d0                   | Shift argument into position
     31                andi.w  #0xF8FF,d1              | Mask out old level
     32                or.w    d0,d1                   | OR in new level
     33                move.w  d2,d0                   | Setup return of old level
     34                lsr.w   #8,d0                   | ...
     35                andi.l  #0x7,d0                 | ...
     36                move.w  d1,sr                   | Set the new interrupt level
     37                unlk    a6                      | Unlink stack frames
     38                rts                             | Return to caller
     39
     40setipler:       moveq.l #-1,d0                  | Setup to return error code
     41                unlk    a6                      | Unlink stack frames
     42                rts                             | Return to caller
     43
    4444                .end

  • iolib/setsr.s

    rf40a309 r4f508e6  
    1 *
    2 * setsr.s -- Set processor status register
    3 * -------    -----------------------------
    4 * Version 1 -- 1988-06-29 -- D.N. Lynx Crowe
    5 *
    6 *       short
    7 *       setsr(arg);
    8 *       short arg;
    9 *
    10 *       Sets processor status register to 'arg'.
    11 *       Returns old status register value.
    12 *
    13 *       Assumes you are in supervisor mode.
    14 *       You get a Privelege Violation TRAP if you aren't.
    15 *
    16 *       Coded for speed -- this is as fast as you can get.
    17 *       No error checking is done -- assumes you know what you're doing.
    18 *
     1
     2| setsr.s -- Set processor status register
     3| -------    -----------------------------
     4| Version 1 -- 1988-06-29 -- D.N. Lynx Crowe
     5
     6|       short
     7|       setsr(arg);
     8|       short arg;
     9
     10|       Sets processor status register to 'arg'.
     11|       Returns old status register value.
     12
     13|       Assumes you are in supervisor mode.
     14|       You get a Privelege Violation TRAP if you aren't.
     15
     16|       Coded for speed -- this is as fast as you can get.
     17|       No error checking is done -- assumes you know what you're doing.
     18
    1919                .text
    20 *
     20
    2121                .xdef   _setsr
    22 *
    23 _setsr:         move.w  sr,d0                   * Get current sr
    24                 move.w  4(sp),sr                * Set new sr
    25                 rts                             * Return to caller
    26 *
     22
     23_setsr:         move.w  sr,d0                   | Get current sr
     24                move.w  4(sp),sr                | Set new sr
     25                rts                             | Return to caller
     26
    2727                .end

  • iolib/traps.s

    rf40a309 r4f508e6  
    1 *
    2 * traps.s -- define trap linkages for C routines
    3 * -------    -----------------------------------
    4 * Version 8 -- 1987-06-08 -- D.N. Lynx Crowe
    5 *
    6 * Caution:  these are serially re-useable, but NOT reentrant, so
    7 * don't use them in interrupt processing code.
    8 *
    9 * An exception is made for ROMP in _trap15 for breakpoints so that the
    10 * debug code can be debugged.
    11 *
     1
     2| traps.s -- define trap linkages for C routines
     3| -------    -----------------------------------
     4| Version 8 -- 1987-06-08 -- D.N. Lynx Crowe
     5
     6| Caution:  these are serially re-useable, but NOT reentrant, so
     7| don't use them in interrupt processing code.
     8
     9| An exception is made for ROMP in _trap15 for breakpoints so that the
     10| debug code can be debugged.
     11
    1212                .text
    13 *
     13
    1414                .xdef   _trap1
    1515                .xdef   _trap13,_trap14
    1616                .xdef   _xtrap15
    17 *
     17
    1818                .xdef   tr1sav,tr13sav,tr14sav
    1919                .xdef   tr1rmp,tr13rmp,tr14rmp
    20 *
    21 * _trap1 -- provide access to BDOS functions
    22 * ------    --------------------------------
    23 _trap1:         move.l  (a7)+,tr1sav            * Save return address
    24                 trap    #1                      * Do the trap
    25                 move.l  tr1sav,-(a7)            * Restore return address
    26                 rts                             * Return to caller
    27 *
    28 * _trap13 -- provide access to BIOS functions
    29 * -------    --------------------------------
    30 _trap13:        move.l  (a7)+,tr13sav           * Save return address
    31                 trap    #13                     * Do the trap
    32                 move.l  tr13sav,-(a7)           * Restore return address
    33                 rts                             * Return to caller
    34 *
    35 * _trap14 -- provide access to extended BIOS functions
    36 * -------    -----------------------------------------
    37 _trap14:        move.l  (a7)+,tr14sav           * Save return address
    38                 trap    #14                     * Do the trap
    39                 move.l  tr14sav,-(a7)           * Restore return address
    40                 rts                             * Return to caller
    41 *
    42 * _xtrap15 -- Setup initial register trap for ROMP
    43 * --------    ------------------------------------
    44 _xtrap15:       trap    #15                     * TRAP into ROMP
    45                 rts                             * Return  (usually won't happen)
    46 *
     20
     21| _trap1 -- provide access to BDOS functions
     22| ------    --------------------------------
     23_trap1:         move.l  (a7)+,tr1sav            | Save return address
     24                trap    #1                      | Do the trap
     25                move.l  tr1sav,-(a7)            | Restore return address
     26                rts                             | Return to caller
     27
     28| _trap13 -- provide access to BIOS functions
     29| -------    --------------------------------
     30_trap13:        move.l  (a7)+,tr13sav           | Save return address
     31                trap    #13                     | Do the trap
     32                move.l  tr13sav,-(a7)           | Restore return address
     33                rts                             | Return to caller
     34
     35| _trap14 -- provide access to extended BIOS functions
     36| -------    -----------------------------------------
     37_trap14:        move.l  (a7)+,tr14sav           | Save return address
     38                trap    #14                     | Do the trap
     39                move.l  tr14sav,-(a7)           | Restore return address
     40                rts                             | Return to caller
     41
     42| _xtrap15 -- Setup initial register trap for ROMP
     43| --------    ------------------------------------
     44_xtrap15:       trap    #15                     | TRAP into ROMP
     45                rts                             | Return  (usually won't happen)
     46
    4747                .page
    48 *
    49 * RAM storage areas
    50 * -----------------
     48
     49| RAM storage areas
     50| -----------------
    5151                .bss
    5252                .even
    53 *
    54 tr1sav:         ds.l    1               * Return address for trap1
    55 tr13sav:        ds.l    1               * Return address for trap13
    56 tr14sav:        ds.l    1               * Return address for trap14
    57 *
    58 tr1rmp:         ds.l    1               * Save area for tr1sav for ROMP
    59 tr13rmp:        ds.l    1               * Save area for tr13sav for ROMP
    60 tr14rmp:        ds.l    1               * Save area for tr14sav for ROMP
    61 *
     53
     54tr1sav:         ds.l    1               | Return address for trap1
     55tr13sav:        ds.l    1               | Return address for trap13
     56tr14sav:        ds.l    1               | Return address for trap14
     57
     58tr1rmp:         ds.l    1               | Save area for tr1sav for ROMP
     59tr13rmp:        ds.l    1               | Save area for tr13sav for ROMP
     60tr14rmp:        ds.l    1               | Save area for tr14sav for ROMP
     61
    6262                .end

  • lib700/aldiv.s

    rf40a309 r4f508e6  
    1 *
    2 * aldiv.s -- indirect long divide
    3 * Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
    4 *
     1
     2| aldiv.s -- indirect long divide
     3| Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
     4
    55        .text
    6 *
     6
    77        .xdef   aldiv
    88        .xdef   _aldiv
    9 *
     9
    1010        .xref   _ldiv
    11 *
     11
    1212aldiv:
    1313_aldiv:
    14 *
     14
    1515        link    a6,#-2
    1616        move.l  12(a6),-(a7)
    … …  
    2323        unlk    a6
    2424        rts
    25 *
     25
    2626        .end

  • lib700/almul.s

    rf40a309 r4f508e6  
    1 *
    2 * almul.s -- indirect long multiply
    3 * Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
    4 *
     1
     2| almul.s -- indirect long multiply
     3| Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
     4
    55                .text
    6 *
     6
    77                .xdef   almul
    8 *
     8
    99                .xref   lmul
    10 *
     10
    1111almul:          move.l  a5,-(a7)
    1212                movea.l 8(a7),a5
    … …  
    1818                movea.l (a7)+,a5
    1919                rts
    20 *
     20
    2121                .end

  • lib700/alrem.s

    rf40a309 r4f508e6  
    1 *
    2 * alrem.s -- indirect long modulus
    3 * Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
    4 *
     1
     2| alrem.s -- indirect long modulus
     3| Version 1 -- 1989-01-24 -- D.N. Lynx Crowe
     4
    55                .text
    6 *
     6
    77                .xdef   alrem
    88                .xdef   _alrem
    9 *
     9
    1010                .xref   _ldiv
    1111                .xref   _ldivr
    12 *
     12
    1313alrem:
    1414_alrem:
    15 *
     15
    1616                link    a6,#-2
    1717                move.l  12(a6),-(a7)
    … …  
    2525                unlk    a6
    2626                rts
    27 *
     27
    2828                .end

  • lib700/blkfill.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * blkfill.s -- block fill function
    3 * Version 1 -- 1987-08-28 -- D.N. Lynx Crowe
    4 *
    5 *       void
    6 *       blkfill(where, what, count)
    7 *       char *where;
    8 *       char what;
    9 *       short count;
    10 *
    11 *               Fills 'count' bytes at 'where' with 'what'.
    12 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| blkfill.s -- block fill function
     3| Version 1 -- 1987-08-28 -- D.N. Lynx Crowe
     4
     5|       void
     6|       blkfill(where, what, count)
     7|       char |where;
     8|       char what;
     9|       short count;
     10
     11|               Fills 'count' bytes at 'where' with 'what'.
     12| ------------------------------------------------------------------------------
    1313                .text
    14 *
     14
    1515                .xdef   _blkfill
    16 *
     16
    1717_blkfill:       link    a6,#0
    1818                movem.l d5-d7/a5-a5,-(a7)
    … …  
    2121                move.w  14(a6),d6
    2222                bra     blkf2
    23 *
     23
    2424blkf1:          move.b  d7,(a5)+
    25 *
     25
    2626blkf2:          move.w  d6,d0
    2727                subq.w  #1,d6
    2828                tst.w   d0
    2929                bgt     blkf1
    30 *
     30
    3131                tst     (a7)+
    3232                movem.l (a7)+,d6-d7/a5-a5
    3333                unlk    a6
    3434                rts
    35 *
     35
    3636                .end

  • lib700/blkmove.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * blkmove.s -- block move function
    3 * Version 1 -- 1987-08-28 -- D.N. Lynx Crowe
    4 *
    5 *       void
    6 *       blkmove(to, from, n)
    7 *       char *to, *from;
    8 *       short n;
    9 *
    10 *               Copies 'n' bytes from address 'from' to address 'to'.
    11 *               Treats overlaps of from and to areas intelligently.
    12 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| blkmove.s -- block move function
     3| Version 1 -- 1987-08-28 -- D.N. Lynx Crowe
     4
     5|       void
     6|       blkmove(to, from, n)
     7|       char |to, |from;
     8|       short n;
     9
     10|               Copies 'n' bytes from address 'from' to address 'to'.
     11|               Treats overlaps of from and to areas intelligently.
     12| ------------------------------------------------------------------------------
    1313                .text
    14 *
     14
    1515                .xdef   _blkmove
    16 *
    17 _blkmove:       link    a6,#$FFFC
     16
     17_blkmove:       link    a6,#-4
    1818                move.l  8(a6),d0
    1919                cmp.l   12(a6),d0
    2020                bcc     blkm3
    21 *
     21
    2222                bra     blkm2
    23 *
     23
    2424blkm1:          movea.l 8(a6),a0
    2525                movea.l 12(a6),a1
    … …  
    2727                addq.l  #1,8(a6)
    2828                addq.l  #1,12(a6)
    29 *
     29
    3030blkm2:          move.w  16(a6),d0
    3131                subq.w  #1,16(a6)
    3232                tst.w   d0
    3333                bne     blkm1
    34 *
     34
    3535                bra     blkm6
    36 *
     36
    3737blkm3:          move.w  16(a6),d0
    3838                ext.l   d0
    … …  
    4040                add.l   d0,12(a6)
    4141                bra     blkm5
    42 *
     42
    4343blkm4:          subq.l  #1,8(a6)
    4444                subq.l  #1,12(a6)
    … …  
    4646                movea.l 12(a6),a1
    4747                move.b  (a1),(a0)
    48 *
     48
    4949blkm5:          move.w  16(a6),d0
    5050                subq.w  #1,16(a6)
    5151                tst.w   d0
    5252                bne     blkm4
    53 *
     53
    5454blkm6:          unlk    a6
    5555                rts
    56 *
     56
    5757                .end

  • lib700/finalone.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * finalone.s -- the last stuff to get loaded
    3 * Version 4 -- 1987-06-30 -- D.N. Lynx Crowe
    4 *
    5 * This is so we can figure out where things got loaded.
    6 * ------------------------------------------------------------------------------
    7 *
     1| ------------------------------------------------------------------------------
     2| finalone.s -- the last stuff to get loaded
     3| Version 4 -- 1987-06-30 -- D.N. Lynx Crowe
     4
     5| This is so we can figure out where things got loaded.
     6| ------------------------------------------------------------------------------
     7
    88                .text
    9 *
     9
    1010                .xdef   FinalOne
    1111                .xdef   The_Fini
    1212                .xdef   Text_End
    13 *
    14 *
    15 * This is the last piece of code in the 'text' segment.
    16 *
    17 FinalOne:       rts                     * we just need the address here
    18 *
    19 Text_End:       rts                     * we just need the address here
    20 *
    21 * ------------------------------------------------------------------------------
    22 *
     13
     14
     15| This is the last piece of code in the 'text' segment.
     16
     17FinalOne:       rts                     | we just need the address here
     18
     19Text_End:       rts                     | we just need the address here
     20
     21| ------------------------------------------------------------------------------
     22
    2323                .data
    2424                .even
    25 *
    26 The_Fini:       dc.w    $FFFF           * last thing in the 'data' segment
    27 *
    28 * ------------------------------------------------------------------------------
    29 *
     25
     26The_Fini:       dc.w    0xFFFF          | last thing in the 'data' segment
     27
     28| ------------------------------------------------------------------------------
     29
    3030                .end

  • lib700/jumpto.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * jumpto.s -- miscellaneous ROMP support functions
    3 * Version 4 -- 1987-10-14 -- D.N. Lynx Crowe
    4 *
    5 *       WARNING:
    6 *       --------
    7 *               These functions, in general, assume supervisor mode and
    8 *               'sane' arguments, so no error checking is done.
    9 *
    10 *       halt()
    11 *
    12 *               Brings the processor to a grinding halt.  Requires external
    13 *               reset to restart things.  Use only for catastrophic hard halts.
    14 *
    15 *       jumpto(addr)
    16 *       long addr;
    17 *
    18 *               Jumps to 'addr'.  No error check is done on 'addr'.
    19 *
    20 *       rjumpto(addr)
    21 *       long addr;
    22 *
    23 *               Performs the 68000 'RESET' command, then jumps to 'addr'.
    24 *               No error check is made on 'addr'.
    25 *
    26 *       sjumpto(addr, stack)
    27 *       long addr, stack;
    28 *
    29 *               Sets a7 to 'stack', then jumps to 'addr'.
    30 *               No error check is done on 'addr'.
    31 *
    32 *       xreset()
    33 *
    34 *               Performs the 68000 'RESET' command.  This is very dangerous,
    35 *               and should be used with extreme care regarding such
    36 *               things as interrupts, device initialization, vectors,
    37 *               and sundry other reset-related things.
    38 *
    39 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| jumpto.s -- miscellaneous ROMP support functions
     3| Version 4 -- 1987-10-14 -- D.N. Lynx Crowe
     4
     5|       WARNING:
     6|       --------
     7|               These functions, in general, assume supervisor mode and
     8|               'sane' arguments, so no error checking is done.
     9
     10|       halt()
     11
     12|               Brings the processor to a grinding halt.  Requires external
     13|               reset to restart things.  Use only for catastrophic hard halts.
     14
     15|       jumpto(addr)
     16|       long addr;
     17
     18|               Jumps to 'addr'.  No error check is done on 'addr'.
     19
     20|       rjumpto(addr)
     21|       long addr;
     22
     23|               Performs the 68000 'RESET' command, then jumps to 'addr'.
     24|               No error check is made on 'addr'.
     25
     26|       sjumpto(addr, stack)
     27|       long addr, stack;
     28
     29|               Sets a7 to 'stack', then jumps to 'addr'.
     30|               No error check is done on 'addr'.
     31
     32|       xreset()
     33
     34|               Performs the 68000 'RESET' command.  This is very dangerous,
     35|               and should be used with extreme care regarding such
     36|               things as interrupts, device initialization, vectors,
     37|               and sundry other reset-related things.
     38
     39| ------------------------------------------------------------------------------
    4040                .text
    41 *
     41
    4242                .xdef   _halt,_jumpto,_rjumpto,_sjumpto,_xreset
    43 *
     43
    4444                .page
    45 *
    46 _halt:          stop    #$2700                  * stop dead, interrupts disabled
    47                 jmp     _halt                   * stay stopped if stepped thru
    48 *
    49 _jumpto:        movea.l 4(a7),a0                * get jump address
    50                 jmp     (a0)                    * go to the jump address
    51 *
    52 _rjumpto:       reset                           * reset external devices
    53                 movea.l 4(a7),a0                * get jump address
    54                 jmp     (a0)                    * go to the jump address
    55 *
    56 _sjumpto:       movea.l 4(a7),a0                * get jump address
    57                 movea.l 8(a7),a7                * set stack pointer
    58                 jmp     (a0)                    * go to the jump address
    59 *
    60 _xreset:        reset                           * reset external devices
    61                 rts                             * return to caller
    62 *
     45
     46_halt:          stop    #0x2700                 | stop dead, interrupts disabled
     47                jmp     _halt                   | stay stopped if stepped thru
     48
     49_jumpto:        movea.l 4(a7),a0                | get jump address
     50                jmp     (a0)                    | go to the jump address
     51
     52_rjumpto:       reset                           | reset external devices
     53                movea.l 4(a7),a0                | get jump address
     54                jmp     (a0)                    | go to the jump address
     55
     56_sjumpto:       movea.l 4(a7),a0                | get jump address
     57                movea.l 8(a7),a7                | set stack pointer
     58                jmp     (a0)                    | go to the jump address
     59
     60_xreset:        reset                           | reset external devices
     61                rts                             | return to caller
     62
    6363                .end

  • lib700/ldiv.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * ldiv.s -- long division
    3 * Version 1 -- 1988-01-22
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| ldiv.s -- long division
     3| Version 1 -- 1988-01-22
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   _ldiv
    88                .xdef   ldiv
    9 *
     9
    1010                .xdef   _ldivr
    11 *
    12 ARG1            .equ    8
    13 ARG2            .equ    12
    14 *
     11
     12ARG1            =       8
     13ARG2            =       12
     14
    1515_ldiv:
    1616ldiv:           link    a6,#-2
    … …  
    2121                move.l  ARG2(a6),d6
    2222                bne     ldiv1
    23 *
    24                 move.l  #$80000000,_ldivr
    25                 move.l  #$80000000,d0
     23
     24                move.l  #0x80000000,_ldivr
     25                move.l  #0x80000000,d0
    2626                divs    #0,d0
    2727                bra     ldiv11
    28 *
     28
    2929ldiv1:          bge     ldiv2
    30 *
     30
    3131                neg.l   d6
    3232                addq.w  #1,d3
    33 *
     33
    3434ldiv2:          tst.l   d7
    3535                bge     ldiv3
    36 *
     36
    3737                neg.l   d7
    3838                addq.w  #1,d3
    39 *
     39
    4040ldiv3:          cmp.l   d7,d6
    4141                bgt     ldiv9
    42 *
     42
    4343                bne     ldiv4
    44 *
     44
    4545                moveq.l #1,d5
    4646                clr.l   d7
    4747                bra     ldiv9
    48 *
    49 ldiv4:          cmp.l   #$10000,d7
     48
     49ldiv4:          cmp.l   #0x10000,d7
    5050                bge     ldiv5
    51 *
     51
    5252                divu    d6,d7
    5353                move.w  d7,d5
    … …  
    5555                ext.l   d7
    5656                bra     ldiv9
    57 *
     57
    5858ldiv5:          moveq.l #1,d4
    59 *
     59
    6060ldiv6:          cmp.l   d6,d7
    6161                bcs     ldiv7
    62 *
     62
    6363                asl.l   #1,d6
    6464                asl.l   #1,d7
    6565                bra     ldiv6
    66 *
     66
    6767ldiv7:          tst.l   d4
    6868                beq     ldiv9
    69 *
     69
    7070                cmp.l   d6,d7
    7171                bcs     ldiv8
    72 *
     72
    7373                or.l    d4,d5
    7474                sub.l   d6,d7
    75 *
     75
    7676ldiv8:          lsr.l   #1,d4
    7777                lsr.l   #1,d6
    7878                bra     ldiv7
    79 *
     79
    8080ldiv9:          cmp.w   #1,d3
    8181                bne     ldiv10
    82 *
     82
    8383                neg.l   d7
    8484                move.l  d7,_ldivr
    … …  
    8686                neg.l   d0
    8787                bra     ldiv11
    88 *
     88
    8989ldiv10:         move.l  d7,_ldivr
    9090                move.l  d5,d0
    91 *
     91
    9292ldiv11:         tst.l   (a7)+
    9393                movem.l (a7)+,d3-d7
    9494                unlk    a6
    9595                rts
    96 *
     96
    9797                .bss
    98 *
     98
    9999_ldivr:         .ds.l   1
    100 *
     100
    101101                .end

  • lib700/lmul.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * lmul.s -- long multiply
    3 * Version 2 -- 1989-07-18
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| lmul.s -- long multiply
     3| Version 2 -- 1989-07-18
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   lmul
    8 *
    9 ARG1            .equ    8
    10 ARG2            .equ    12
    11 *
    12 TEMP            .equ    -4
    13 *
     8
     9ARG1            =       8
     10ARG2            =       12
     11
     12TEMP            =       -4
     13
    1414lmul:           link    a6,#-4
    1515                clr.w   d2
    1616                tst.l   ARG1(a6)
    1717                bge     lmul1
    18 *
     18
    1919                neg.l   ARG1(a6)
    2020                addq.w  #1,d2
    21 *
     21
    2222lmul1:          tst.l   ARG2(a6)
    2323                bge     lmul2
    24 *
     24
    2525                neg.l   ARG2(a6)
    2626                addq.w  #1,d2
    27 *
     27
    2828lmul2:          move.w  ARG1+2(a6),d0
    2929                mulu    ARG2+2(a6),d0
    … …  
    3939                btst    #0,d2
    4040                beq     lmul3
    41 *
     41
    4242                neg.l   d0
    43 *
     43
    4444lmul3:          unlk    a6
    4545                rts
    46 *
     46
    4747                .end

  • lib700/lrem.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * lrem.s -- long modulo
    3 * Version 1 -- 1988-01-22
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| lrem.s -- long modulo
     3| Version 1 -- 1988-01-22
     4| ------------------------------------------------------------------------------
    55                .text
    6 *
     6
    77                .xdef   _lrem
    88                .xdef   lrem
    9 *
     9
    1010                .xref   ldiv
    1111                .xref   _ldivr
    12 *
    13 ARG1            .equ    8
    14 ARG2            .equ    12
    15 *
     12
     13ARG1            =       8
     14ARG2            =       12
     15
    1616_lrem:
    1717lrem:           link    a6,#-2
    … …  
    2323                unlk    a6
    2424                rts
    25 *
     25
    2626                .end

  • lib700/rand24.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * rand24.s -- generate a 24 bit random number
    3 * Version 3 -- 1988-04-29 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
    5 * Synopsis:
    6 *               long
    7 *               rand24()
    8 *
    9 * Based on:
    10 *               Knuth, Donald E.
    11 *               The Art of Computer Programming,
    12 *               Volume 2: Semi-Numerical Algorithms
    13 *
    14 * Computes:
    15 *               S = [S * C] + K
    16 *
    17 * Where:
    18 *               K = 1
    19 *               C = 3141592621
    20 *               S = the seed  (if zero, it gets set from the 200 Hz clock)
    21 *
    22 * Returns:
    23 *               S >> 8  (a 24 bit pseudo-random number)
    24 *
    25 * Note:  this function has an LSB with an exactly 50% distribution,  so using
    26 * individual bits is probably not a good idea.  Using more bits makes things
    27 * appear more random.
    28 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| rand24.s -- generate a 24 bit random number
     3| Version 3 -- 1988-04-29 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
     5| Synopsis:
     6|               long
     7|               rand24()
     8
     9| Based on:
     10|               Knuth, Donald E.
     11|               The Art of Computer Programming,
     12|               Volume 2: Semi-Numerical Algorithms
     13
     14| Computes:
     15|               S = [S | C] + K
     16
     17| Where:
     18|               K = 1
     19|               C = 3141592621
     20|               S = the seed  (if zero, it gets set from the 200 Hz clock)
     21
     22| Returns:
     23|               S >> 8  (a 24 bit pseudo-random number)
     24
     25| Note:  this function has an LSB with an exactly 50% distribution,  so using
     26| individual bits is probably not a good idea.  Using more bits makes things
     27| appear more random.
     28| ------------------------------------------------------------------------------
    2929                .text
    30 *
     30
    3131                .xdef   _rand24
    32 *
     32
    3333                .xdef   _rseed
    34 *
    35 * equates for things in the BIOS
    36 *
    37 RCLOCK          .equ    $49E                    * LONG - 200 Hz clock
    38 *
    39 * equates for stack offsets
    40 *
    41 ARG1            .equ    8                       * LONG / WORD - arg1 / MS bits
    42 ARG1L           .equ    10                      * WORD - arg1 LS bits
    43 ARG2            .equ    12                      * LONG / WORD - arg2 / MS bits
    44 ARG2L           .equ    14                      * WORD - arg2 LS bits
    45 *
    46 PART            .equ    -4                      * LONG - partial product
    47 *
    48 PI              .equ    $BB40E62D               * LONG - PI as a hex value
    49 *
     34
     35| equates for things in the BIOS
     36
     37RCLOCK          =       0x49E                   | LONG - 200 Hz clock
     38
     39| equates for stack offsets
     40
     41ARG1            =       8                       | LONG / WORD - arg1 / MS bits
     42ARG1L           =       10                      | WORD - arg1 LS bits
     43ARG2            =       12                      | LONG / WORD - arg2 / MS bits
     44ARG2L           =       14                      | WORD - arg2 LS bits
     45
     46PART            =       -4                      | LONG - partial product
     47
     48PI              =       0xBB40E62D              | LONG - PI as a hex value
     49
    5050                .page
    51 *
    52 * mult32 -- 32 bit signed multiply
    53 * ------    ----------------------
    54 mult32:         link    a6,#-4                  * link stack frames
    55                 clr.w   d2                      * clear sign flags
    56                 tst.l   ARG1(a6)                * check sign of 1st argument
    57                 bge     mult32a                 * ...
    58 *
    59                 neg.l   ARG1(a6)                * make 1st argument positive
    60                 addq.w  #1,d2                   * log its sign as negative
    61 *
    62 mult32a:        tst.l   ARG2(a6)                * check sign of 2nd argument
    63                 bge     mult32b                 * ...
    64 *
    65                 neg.l   ARG2(a6)                * make 2nd argument positive
    66                 addq.w  #1,d2                   * log its sign as negative
    67 *
    68 mult32b:        move.w  ARG1L(a6),d0            * generate 1st partial product
    69                 mulu    ARG2L(a6),d0            * ...
    70                 move.l  d0,PART(a6)             * ...
    71                 move.w  ARG1(a6),d0             * generate 2nd partial product
    72                 mulu    ARG2L(a6),d0            * ...
    73                 move.w  ARG2(a6),d1             * generate 3rd partial product
    74                 mulu    ARG1L(a6),d1            * ...
    75                 add.w   d1,d0                   * add partial products
    76                 add.w   PART(a6),d0             * ...
    77                 move.w  d0,PART(a6)             * ...
    78                 move.l  PART(a6),d0             * ...
    79                 btst    #0,d2                   * adjust sign of result
    80                 beq     mult32c                 * ...
    81 *
    82                 neg.l   d0                      * ...
    83 *
    84 mult32c:        unlk    a6                      * unlink stack frames
    85                 rts                             * return
    86 *
     51
     52| mult32 -- 32 bit signed multiply
     53| ------    ----------------------
     54mult32:         link    a6,#-4                  | link stack frames
     55                clr.w   d2                      | clear sign flags
     56                tst.l   ARG1(a6)                | check sign of 1st argument
     57                bge     mult32a                 | ...
     58
     59                neg.l   ARG1(a6)                | make 1st argument positive
     60                addq.w  #1,d2                   | log its sign as negative
     61
     62mult32a:        tst.l   ARG2(a6)                | check sign of 2nd argument
     63                bge     mult32b                 | ...
     64
     65                neg.l   ARG2(a6)                | make 2nd argument positive
     66                addq.w  #1,d2                   | log its sign as negative
     67
     68mult32b:        move.w  ARG1L(a6),d0            | generate 1st partial product
     69                mulu    ARG2L(a6),d0            | ...
     70                move.l  d0,PART(a6)             | ...
     71                move.w  ARG1(a6),d0             | generate 2nd partial product
     72                mulu    ARG2L(a6),d0            | ...
     73                move.w  ARG2(a6),d1             | generate 3rd partial product
     74                mulu    ARG1L(a6),d1            | ...
     75                add.w   d1,d0                   | add partial products
     76                add.w   PART(a6),d0             | ...
     77                move.w  d0,PART(a6)             | ...
     78                move.l  PART(a6),d0             | ...
     79                btst    #0,d2                   | adjust sign of result
     80                beq     mult32c                 | ...
     81
     82                neg.l   d0                      | ...
     83
     84mult32c:        unlk    a6                      | unlink stack frames
     85                rts                             | return
     86
    8787                .page
    88 *
    89 * _rand24 -- Generate a random number
    90 * -------    ------------------------
    91 _rand24:        link    a6,#0                   * Link stack frames
    92                 tst.l   _rseed                  * See if the seed is zero
    93                 bne     rand01                  * Jump if not
    94 *
    95                 move.l  RCLOCK,d0               * Pick up the 200 Hz clock
    96                 moveq.l #16,d1                  * Shift it left
    97                 asl.l   d1,d0                   * ...
    98                 or.l    RCLOCK,d0               * OR in current 200 Hz clock
    99                 move.l  d0,_rseed               * Use that as the seed
    100 *
    101 rand01:         move.l  #PI,-(a7)               * Put PI on the stack
    102                 move.l  _rseed,-(a7)            * ... and _rseed, too
    103                 bsr     mult32                  * Multiply them
    104                 addq.l  #8,a7                   * Cleanup stack
    105                 addq.l  #1,d0                   * Add 1 to the result
    106                 move.l  d0,_rseed               * Save as new seed
    107                 asr.l   #8,d0                   * Make it a 24 bit number
    108                 and.l   #$00FFFFFF,d0           * ...
    109                 unlk    a6                      * Unlink stack frames
    110                 rts                             * Return to caller
    111 *
    112 * ------------------------------------------------------------------------------
     88
     89| _rand24 -- Generate a random number
     90| -------    ------------------------
     91_rand24:        link    a6,#0                   | Link stack frames
     92                tst.l   _rseed                  | See if the seed is zero
     93                bne     rand01                  | Jump if not
     94
     95                move.l  RCLOCK,d0               | Pick up the 200 Hz clock
     96                moveq.l #16,d1                  | Shift it left
     97                asl.l   d1,d0                   | ...
     98                or.l    RCLOCK,d0               | OR in current 200 Hz clock
     99                move.l  d0,_rseed               | Use that as the seed
     100
     101rand01:         move.l  #PI,-(a7)               | Put PI on the stack
     102                move.l  _rseed,-(a7)            | ... and _rseed, too
     103                bsr     mult32                  | Multiply them
     104                addq.l  #8,a7                   | Cleanup stack
     105                addq.l  #1,d0                   | Add 1 to the result
     106                move.l  d0,_rseed               | Save as new seed
     107                asr.l   #8,d0                   | Make it a 24 bit number
     108                and.l   #0x00FFFFFF,d0          | ...
     109                unlk    a6                      | Unlink stack frames
     110                rts                             | Return to caller
     111
     112| ------------------------------------------------------------------------------
    113113                .bss
    114 * ------------------------------------------------------------------------------
    115 *
    116 _rseed:         .ds.l   1                       * random number seed
    117 *
     114| ------------------------------------------------------------------------------
     115
     116_rseed:         .ds.l   1                       | random number seed
     117
    118118                .end

  • lib700/setjmp.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * setjmp.s -- Unix(tm) compatible setjmp(env) and longjmp(env,ret)
    3 * Version 3 -- 1987-06-16 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
    5 *
     1| ------------------------------------------------------------------------------
     2| setjmp.s -- Unix(tm) compatible setjmp(env) and longjmp(env,ret)
     3| Version 3 -- 1987-06-16 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
     5
    66                .text
    7 *
     7
    88                .xdef   _setjmp,_longjmp
    9 *
    10 _setjmp:        movea.l 4(a7),a0                * Get env pointer
    11                 move.l  (a7),(a0)               * Put return address in env
    12                 movem.l d1-d7/a1-a7,4(a0)       * Save registers in env
    13                 moveq.l #0,d0                   * Set return value to 0
    14                 rts                             * Return to caller
    15 *
    16 _longjmp:       move.w  8(a7),d0                * Get ret value
    17                 bne     lj1                     * Jump if non-zero
    18 *
    19                 moveq.l #1,d0                   * Force return value to 1
    20 *
    21 lj1:            movea.l 4(a7),a0                * Get env pointer
    22                 movem.l 4(a0),d1-d7/a1-a7       * Restore registers from env
    23                 move.l  (a0),(a7)               * Get return address from env
    24                 rts                             * Return to caller
    25 *
     9
     10_setjmp:        movea.l 4(a7),a0                | Get env pointer
     11                move.l  (a7),(a0)               | Put return address in env
     12                movem.l d1-d7/a1-a7,4(a0)       | Save registers in env
     13                moveq.l #0,d0                   | Set return value to 0
     14                rts                             | Return to caller
     15
     16_longjmp:       move.w  8(a7),d0                | Get ret value
     17                bne     lj1                     | Jump if non-zero
     18
     19                moveq.l #1,d0                   | Force return value to 1
     20
     21lj1:            movea.l 4(a7),a0                | Get env pointer
     22                movem.l 4(a0),d1-d7/a1-a7       | Restore registers from env
     23                move.l  (a0),(a7)               | Get return address from env
     24                rts                             | Return to caller
     25
    2626                .end

  • lib700/uldiv.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * uldiv.s -- unsigned long division, with remainder
    3 * Version 2 -- 1987-06-08 -- D.N. Lynx Crowe
    4 * Lifted from the Alcyon C library by disassembly so I could fix a bug -
    5 *       _uldivr must be in the bss segment so the code will work in PROM.
    6 *
    7 *       long
    8 *       uldiv(dividnd, divisor)
    9 *       long dividnd, divisor;
    10 *
    11 *       extern long uldivr;
    12 *
    13 *               Divides 'dividnd' by 'divisor', treating both as unsigned
    14 *               long integers.  Returns the quotient and leaves the
    15 *               remainder in 'uldivr'.  Produces a divide check on division
    16 *               by zero, with $80000000 returned for both quotient and
    17 *               remainder.
    18 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| uldiv.s -- unsigned long division, with remainder
     3| Version 2 -- 1987-06-08 -- D.N. Lynx Crowe
     4| Lifted from the Alcyon C library by disassembly so I could fix a bug -
     5|       _uldivr must be in the bss segment so the code will work in PROM.
     6
     7|       long
     8|       uldiv(dividnd, divisor)
     9|       long dividnd, divisor;
     10
     11|       extern long uldivr;
     12
     13|               Divides 'dividnd' by 'divisor', treating both as unsigned
     14|               long integers.  Returns the quotient and leaves the
     15|               remainder in 'uldivr'.  Produces a divide check on division
     16|               by zero, with 0x80000000 returned for both quotient and
     17|               remainder.
     18| ------------------------------------------------------------------------------
    1919                .text
    20 *
     20
    2121                .xdef   _uldiv,_uldivr
    22 *
    23 DIVIDEND        .equ    8
    24 DIVISOR         .equ    12
    25 *
    26 _uldiv:         link    a6,#0                   * Link stack frames
    27                 movem.l d3-d7,-(a7)             * Save registers
    28                 move.l  DIVIDEND(a6),d7         * d7 = DIVIDEND
    29                 move.l  DIVISOR(a6),d6          * d6 = DIVISOR
    30                 tst.l   d6                      * Divide by zero ?
    31                 bne     notdzero                * Jump if not
    32 *
    33                 move.l  #$80000000,_uldivr      * Force error result
    34                 move.l  #$80000000,d0           * ... by dividing
    35                 divu    #0,d0                   * ... by zero
    36                 bra     ulexit                  * ... then exit
    37 *
    38 notdzero:       cmp.l   d7,d6                   * Divide underflow ?
    39                 bls     notunflo                * Jump if not
    40 *
    41                 move.l  d7,_uldivr              * Remainder = dividend
    42                 clr.l   d0                      * Quotient = 0
    43                 bra     ulexit                  * Exit
    44 *
    45 notunflo:       cmp.l   d6,d7                   * Is dividend = divisor ?
    46                 bne     startdiv                * Go start dividing if not
    47 *
    48                 moveq.l #1,d5                   * Quotient = 1
    49                 clr.l   d7                      * Remainder = 0
    50                 bra     setreslt                * Go set result
    51 *
     22
     23DIVIDEND        =       8
     24DIVISOR         =       12
     25
     26_uldiv:         link    a6,#0                   | Link stack frames
     27                movem.l d3-d7,-(a7)             | Save registers
     28                move.l  DIVIDEND(a6),d7         | d7 = DIVIDEND
     29                move.l  DIVISOR(a6),d6          | d6 = DIVISOR
     30                tst.l   d6                      | Divide by zero ?
     31                bne     notdzero                | Jump if not
     32
     33                move.l  #0x80000000,_uldivr     | Force error result
     34                move.l  #0x80000000,d0          | ... by dividing
     35                divu    #0,d0                   | ... by zero
     36                bra     ulexit                  | ... then exit
     37
     38notdzero:       cmp.l   d7,d6                   | Divide underflow ?
     39                bls     notunflo                | Jump if not
     40
     41                move.l  d7,_uldivr              | Remainder = dividend
     42                clr.l   d0                      | Quotient = 0
     43                bra     ulexit                  | Exit
     44
     45notunflo:       cmp.l   d6,d7                   | Is dividend = divisor ?
     46                bne     startdiv                | Go start dividing if not
     47
     48                moveq.l #1,d5                   | Quotient = 1
     49                clr.l   d7                      | Remainder = 0
     50                bra     setreslt                | Go set result
     51
    5252                .page
    53 *
    54 startdiv:       moveq.l #1,d4                   * Set result bit in d4
    55 *
    56 divloop1:       cmp.l   d6,d7                   * Divisor aligned OK ?
    57                 bcs     divloop2                * Jump if so
    58 *
    59                 move.l  d6,d0                   * Can we align things better ?
    60                 asl.l   #1,d0                   * ...
    61                 cmp.l   d0,d6                   * ...
    62                 bhi     divloop2                * Jump if not
    63 *
    64                 asl.l   #1,d6                   * Shift the divisor
    65                 asl.l   #1,d4                   * Shift the result bit
    66                 bra     divloop1                * Loop for next bit
    67 *
    68 divloop2:       clr.l   d5                      * Clear quotient
    69 *
    70 divloop3:       tst.l   d4                      * More bits to do ?
    71                 beq     setreslt                * Go set result if not
    72 *
    73                 cmp.l   d6,d7                   * Can we subtract ?
    74                 bcs     divloop4                * Jump if not
    75 *
    76                 or.l    d4,d5                   * Set a bit in the quotient
    77                 sub.l   d6,d7                   * Subtract divisor from dividend
    78 *
    79 divloop4:       lsr.l   #1,d4                   * Shift the result bit
    80                 lsr.l   #1,d6                   * Shift the divisor
    81                 bra     divloop3                * Loop for next bit
    82 *
    83 setreslt:       move.l  d7,_uldivr              * Store remainder
    84                 move.l  d5,d0                   * Put quotient in d0
    85 *
    86 ulexit:         tst.l   (a7)+                   * Discard top of stack
    87                 movem.l (a7)+,d4-d7             * Restore registers
    88                 unlk    a6                      * Unlink stack frames
    89                 rts                             * Return to caller
    90 *
     53
     54startdiv:       moveq.l #1,d4                   | Set result bit in d4
     55
     56divloop1:       cmp.l   d6,d7                   | Divisor aligned OK ?
     57                bcs     divloop2                | Jump if so
     58
     59                move.l  d6,d0                   | Can we align things better ?
     60                asl.l   #1,d0                   | ...
     61                cmp.l   d0,d6                   | ...
     62                bhi     divloop2                | Jump if not
     63
     64                asl.l   #1,d6                   | Shift the divisor
     65                asl.l   #1,d4                   | Shift the result bit
     66                bra     divloop1                | Loop for next bit
     67
     68divloop2:       clr.l   d5                      | Clear quotient
     69
     70divloop3:       tst.l   d4                      | More bits to do ?
     71                beq     setreslt                | Go set result if not
     72
     73                cmp.l   d6,d7                   | Can we subtract ?
     74                bcs     divloop4                | Jump if not
     75
     76                or.l    d4,d5                   | Set a bit in the quotient
     77                sub.l   d6,d7                   | Subtract divisor from dividend
     78
     79divloop4:       lsr.l   #1,d4                   | Shift the result bit
     80                lsr.l   #1,d6                   | Shift the divisor
     81                bra     divloop3                | Loop for next bit
     82
     83setreslt:       move.l  d7,_uldivr              | Store remainder
     84                move.l  d5,d0                   | Put quotient in d0
     85
     86ulexit:         tst.l   (a7)+                   | Discard top of stack
     87                movem.l (a7)+,d4-d7             | Restore registers
     88                unlk    a6                      | Unlink stack frames
     89                rts                             | Return to caller
     90
    9191                .bss
    9292                .even
    93 *
     93
    9494_uldivr:        ds.l    1
    95 *
     95
    9696                .end

  • libcio/ptcl12.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * ptcl12.s -- store a cluster entry into the FAT
    3 * Version 2 -- 1987-10-27 -- D.N. Lynx Crowe
    4 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| ptcl12.s -- store a cluster entry into the FAT
     3| Version 2 -- 1987-10-27 -- D.N. Lynx Crowe
     4| ------------------------------------------------------------------------------
    55                .text
    66                .xdef   __ptcl12
    7 *
    8 CL              .equ    12
    9 VAL             .equ    14
    10 CLA             .equ    d7
    11 CLP             .equ    d6
    12 CLT             .equ    d5
    13 FAT             .equ    a5
    14 *
     7
     8CL              =       12
     9VAL             =       14
     10CLA             =       d7
     11CLP             =       d6
     12CLT             =       d5
     13FAT             =       a5
     14
    1515__ptcl12:       link    A6,#0
    1616                movem.l CLT-CLA/FAT-FAT,-(sp)
    1717                move.l  8(A6),FAT
    1818                move.w  CL(A6),CLA
    19                 lsr.w   CLA
     19                lsr.w   #1,CLA
    2020                add.w   CL(A6),CLA
    2121                move.b  1(FAT,CLA.W),CLP
    … …  
    2424                btst    #0,CL+1(A6)
    2525                beq     L2
    26 *
     26
    2727                move.w  CLP,CLT
    28                 and.w   #$000F,CLT
     28                and.w   #0x000F,CLT
    2929                move.w  VAL(A6),D0
    3030                lsl.w   #4,D0
    3131                or.w    D0,CLT
    3232                bra     L3
    33 *
     33
    3434L2:             move.w  CLP,CLT
    35                 and.w   #$F000,CLT
     35                and.w   #0xF000,CLT
    3636                move.w  VAL(A6),D0
    37                 and.w   #$0FFF,D0
     37                and.w   #0x0FFF,D0
    3838                or.w    D0,CLT
    39 *
     39
    4040L3:             move.b  CLT,0(FAT,CLA.W)
    4141                move.w  CLT,D0
    4242                lsr.w   #8,D0
    4343                move.b  D0,1(FAT,CLA.W)
    44 *
     44
    4545L1:             movem.l (sp)+,CLT-CLA/FAT-FAT
    4646                unlk    A6
    4747                rts
    48 *
     48
    4949                .end

  • prolog/fsmain.s

    rf40a309 r4f508e6  
    1 * ------------------------------------------------------------------------------
    2 * fsmain.s -- startup code for the Buchla 700 standalone C runtime library
    3 * Version 3 -- 1987-06-29 -- D.N. Lynx Crowe
    4 *
    5 *       This code clears 'bss' space, sets up some global variables,
    6 *       and calls Croot(), which sets up the file system and calls main().
    7 *
    8 *       This routine should be entered with the address of the basepage
    9 *       as its parameter.
    10 * ------------------------------------------------------------------------------
     1| ------------------------------------------------------------------------------
     2| fsmain.s -- startup code for the Buchla 700 standalone C runtime library
     3| Version 3 -- 1987-06-29 -- D.N. Lynx Crowe
     4
     5|       This code clears 'bss' space, sets up some global variables,
     6|       and calls Croot(), which sets up the file system and calls main().
     7
     8|       This routine should be entered with the address of the basepage
     9|       as its parameter.
     10| ------------------------------------------------------------------------------
    1111                .text
    12 *
     12
    1313                .xdef   start_
    14 *
     14
    1515                .xref   _Croot
    16 *
     16
    1717                .xdef   _panic
    1818                .xdef   _brk
    19 *
     19
    2020                .xdef   __heap
    2121                .xdef   __break
    2222                .xdef   __pmesg
    23 *
     23
    2424                .xdef   _errno
    25 *
    26 p_bbase         .equ    $18             * bss base
    27 p_blen          .equ    $1C             * bss length
    28 *
     25
     26p_bbase         =       0x18            | bss base
     27p_blen          =       0x1C            | bss length
     28
    2929                .page
    30 *
    31 * start_ -- Initial entry point -- Must be first object file in link statement
    32 * ------    ------------------------------------------------------------------
    33 *
    34 * WARNING:  Hazardous assumptions
    35 *
    36 * We assume that:
    37 *
    38 *       the system has set the stack pointer for us.
    39 *       the system passed us a pointer to a valid basepage.
    40 *       the stack is above the heap.
    41 *       BSS is located in RAM.
    42 *
    43 * If any of these assumptions is in error, we're in for serious trouble.
    44 *
    45 start_:         clr.l   a6              * Clear frame pointer
    46                 movea.l 4(a7),a1        * Set pointer to base page
    47                 movea.l p_bbase(a1),a0  * Setup to clear bss space
    48 *
    49 start1:         clr.w   (a0)+           * Clear a word
    50                 cmpa.l  a0,a7           * See if we're done
    51                 bne     start1          * Loop if not done yet
    52 *
    53                 move.l  p_bbase(a1),d0  * Calculate break address
    54                 add.l   p_blen(a1),d0   * ...
    55                 move.l  d0,__break      * Set initial break
    56                 move.l  d0,__heap       * Set heap start
    57 *
    58                 move.l  #0,-(a7)        * Pass NULL to Croot  (no command line)
    59                 jsr     _Croot          * call Croot() routine
    60                 addq.l  #4,a7           * ...
    61 *
    62                 move.l  #pmsg1,-(a7)    * panic(pmsg1);
    63                 jsr     _panic          * ...
    64                 addq.l  #4,a7           * ...
    65 *
    66 hstop:          stop    #$2000          * "Die, sucker!"
     30
     31| start_ -- Initial entry point -- Must be first object file in link statement
     32| ------    ------------------------------------------------------------------
     33
     34| WARNING:  Hazardous assumptions
     35
     36| We assume that:
     37
     38|       the system has set the stack pointer for us.
     39|       the system passed us a pointer to a valid basepage.
     40|       the stack is above the heap.
     41|       BSS is located in RAM.
     42
     43| If any of these assumptions is in error, we're in for serious trouble.
     44
     45start_:         movea.l #0,a6           | Clear frame pointer
     46                movea.l 4(a7),a1        | Set pointer to base page
     47                movea.l p_bbase(a1),a0  | Setup to clear bss space
     48
     49start1:         clr.w   (a0)+           | Clear a word
     50                cmpa.l  a0,a7           | See if we're done
     51                bne     start1          | Loop if not done yet
     52
     53                move.l  p_bbase(a1),d0  | Calculate break address
     54                add.l   p_blen(a1),d0   | ...
     55                move.l  d0,__break      | Set initial break
     56                move.l  d0,__heap       | Set heap start
     57
     58                move.l  #0,-(a7)        | Pass NULL to Croot  (no command line)
     59                jsr     _Croot          | call Croot() routine
     60                addq.l  #4,a7           | ...
     61
     62                move.l  #pmsg1,-(a7)    | panic(pmsg1);
     63                jsr     _panic          | ...
     64                addq.l  #4,a7           | ...
     65
     66hstop:          stop    #0x2000         | "Die, sucker!"
    6767                bra     hstop
    68 *
     68
    6969                .page
    70 *
    71 * _panic -- hard halt for fatal errors
    72 * ------    --------------------------
    73 _panic:         movea.l 4(a7),a0        * Save panic message address
    74                 move.l  a0,__pmesg      * ...
    75 *
    76                 trap    #15             * Invoke ROMP  (we hope ...)
    77 *
    78 pstop:          stop    #$2700          * HARD HALT
     70
     71| _panic -- hard halt for fatal errors
     72| ------    --------------------------
     73_panic:         movea.l 4(a7),a0        | Save panic message address
     74                move.l  a0,__pmesg      | ...
     75
     76                trap    #15             | Invoke ROMP  (we hope ...)
     77
     78pstop:          stop    #0x2700         | HARD HALT
    7979                bra     pstop
    80 *
     80
    8181                .page
    82 *
    83 * _brk -- set break value
    84 * ----    ---------------
    85 * WARNING:  This only works if the stack is above the heap.
    86 *
    87 _brk:           cmpa.l  __break,a7      * compare current break with stack
    88                 bcs     pstop           * actual stack overflow!
    89 *
    90                 movea.l 4(sp),a0        * get new break
    91                 move.l  a0,d0           * compare with current stack,
    92                 adda.l  #$100,a0        * ... including 256-byte slop factor
    93                 cmpa.l  a0,a7           * if (sp < a0+256)
    94                 bcs     badbrk          *       bad break;
    95 *
    96                 move.l  d0,__break      * OK break: save the break
    97                 clr.l   d0              * Set OK return
    98                 rts                     * return
    99 *
    100 badbrk:         moveq.l #-1,d0          * Load return reg
    101                 rts                     * Return
    102 *
     82
     83| _brk -- set break value
     84| ----    ---------------
     85| WARNING:  This only works if the stack is above the heap.
     86
     87_brk:           cmpa.l  __break,a7      | compare current break with stack
     88                bcs     pstop           | actual stack overflow!
     89
     90                movea.l 4(sp),a0        | get new break
     91                move.l  a0,d0           | compare with current stack,
     92                adda.l  #0x100,a0       | ... including 256-byte slop factor
     93                cmpa.l  a0,a7           | if (sp < a0+256)
     94                bcs     badbrk          |       bad break;
     95
     96                move.l  d0,__break      | OK break: save the break
     97                clr.l   d0              | Set OK return
     98                rts                     | return
     99
     100badbrk:         moveq.l #-1,d0          | Load return reg
     101                rts                     | Return
     102
    103103                .page
    104 *
    105 *************************************************************************
    106 *               Data Area                                               *
    107 *************************************************************************
    108 *
     104
     105|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
     106|               Data Area                                               |
     107|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
     108
    109109                .data
    110 *
    111 pmsg1:          dc.b    '  returned from Croot() ',0
    112 *
    113 *************************************************************************
    114 *               BSS Area                                                *
    115 *************************************************************************
    116 *
     110
     111pmsg1:          dc.b    "  returned from Croot() ",0
     112
     113|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
     114|               BSS Area                                                |
     115|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
     116
    117117                .bss
    118118                .even
    119 *
    120 __pmesg:        ds.l    1       * panic() message string address
    121 __heap:         ds.l    1       * Heap start  (initial break)
    122 __break:        ds.l    1       * Current break location
    123 _errno:         ds.w    1       * System error number
    124 *
     119
     120__pmesg:        ds.l    1       | panic() message string address
     121__heap:         ds.l    1       | Heap start  (initial break)
     122__break:        ds.l    1       | Current break location
     123_errno:         ds.w    1       | System error number
     124
    125125        .end

  • 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