home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / lsrc310 / source / util.s < prev    next >
Encoding:
Text File  |  1994-05-21  |  12.5 KB  |  768 lines
  1.  
  2.             export    FTimeToULong
  3.             export    ilong
  4.             export    itime
  5.             export    ProcInd
  6.             export    Bputc
  7.             export    block_crc
  8.             export    mkcrc
  9.             export    crc_getc
  10.             export    mksum
  11.             export    stpcpy
  12.             export    strcpy
  13.             export    strchr
  14.             export    strcmp
  15.             export  strncmp
  16.             export    strlen
  17.             export  stricmp
  18.             export    flg_n
  19.             export    blkcnt
  20.             export    RotInd
  21.             export    rot
  22.             export    make_tree
  23.             export    sortptr
  24.             export    count_len
  25.             export    get_fname
  26.             export    backpath
  27.             export    star
  28.             export    upper
  29.             export  memset
  30.  
  31.             import    crc
  32.             import    crctbl
  33.             import    fill_buf
  34.             import    _filbuf
  35.             import    error
  36.             import    infname
  37.             import  proc_ind
  38.             import    freq
  39.             import    heap
  40.             import    heapsize
  41.             import    make_len
  42.             import    len_cnt
  43.             import    left
  44.             import    right
  45.             import    len
  46.  
  47.  
  48. RDERR        equ        13
  49. WTERR        equ        14
  50.  
  51.  
  52. ilong:        move.l    (a0),d0
  53.             ror.w    #8,d0
  54.             swap    d0
  55.             ror.w    #8,d0
  56.             move.l    d0,(a0)
  57.             rts
  58.  
  59.  
  60. itime:        move.l    (a0),d0
  61.             ror.w    #8,d0
  62.             swap    d0
  63.             ror.w    #8,d0
  64.             swap    d0
  65.             move.l    d0,(a0)
  66.             rts
  67.  
  68.  
  69. FTimeToULong:
  70.             move.l    (a0),d0
  71.             swap    d0
  72.             rts
  73.  
  74.  
  75. ProcInd:    move.b    flg_n(pc),d0
  76.             subq.b    #1,d0
  77.             beq.b    _procexit
  78.  
  79.             subq.w    #1,blkcnt
  80.             bmi.b    _procexit
  81.  
  82.             tst.b    d0
  83.             bmi.b    _proc_star
  84.  
  85.             subq.b    #1,d0
  86.             beq.s    _proc_ind
  87.  
  88.             lea.l    RotInd(pc),a0
  89.             move.w    (a0),d1
  90.             move.b    rot(pc,d1.w),d2
  91.  
  92.             addq.w    #1,d1
  93.             and.w    #3,d1
  94.             move.w    d1,(a0)
  95.  
  96.             pea        (a2)
  97.             move.w    d2,-(sp)
  98.             move.w    #2,-(sp)
  99.             trap    #1
  100.  
  101.             pea        $20008
  102.             trap    #1        ; Cconout
  103.             addq.w    #8,sp
  104.             move.l    (sp)+,a2
  105.  
  106.             rts
  107.  
  108. _proc_ind:    jmp        proc_ind
  109.  
  110. _proc_star:    pea        (a2)
  111.             move.w    star(PC),-(sp)
  112.             move.w    #2,-(sp)
  113.             trap    #1
  114.             addq.w    #4,sp
  115.             move.l    (sp)+,a2
  116.  
  117. _procexit:    rts
  118.  
  119. RotInd:        dc.w    0
  120. rot:        dc.b    '-/|\'
  121.  
  122.             EVEN
  123.  
  124. mkcrc:        MOVEM.L        D3/A2,-(SP)
  125.  
  126.             LEA.L       crct_lo+256,A0
  127.             LEA.L       crct_hi+256,A1
  128.             LEA.L        crctbl+512,A2
  129.             MOVE.W        #$A001,D2
  130.  
  131.             MOVE.W        #255,D1 ; for (i = 0x100; i--;) {
  132. mkfor_i:    MOVE.W        D1,D0    ; crc = i;
  133.  
  134.             MOVEQ.L        #7,D3
  135. for_j:        LSR.W        #1,D0
  136.             BCC.S        next_j
  137.             EOR.W        D2,D0 ; ; crc = (crc >> 1) ^ CRC_16
  138. next_j:        DBRA        D3,for_j ;  for (j=8;--j>=0;)
  139.  
  140.             MOVE.W        D0,-(A2) ; crctbl[i] = crc
  141.             MOVE.B        D0,-(A0) ; crct_lo[i] = (unsigned char) crc
  142.             LSR.W        #8,D0
  143.             MOVE.B        D0,-(A1) ; crct_hi[i] = crc >> 8
  144.             DBRA        D1,mkfor_i
  145.  
  146.             MOVEM.L        (SP)+,D3/A2
  147.             RTS
  148.  
  149.  
  150. block_crc:    MOVEM.L        D0-D4/A0-A2,-(sp)
  151.  
  152.             MOVEQ.L        #0,D1
  153.             MOVEQ.L        #0,D2
  154.             MOVEQ.L        #0,D3
  155.  
  156.             MOVE.B        crc+1,D2 ; crclo = (unsigned char) crc
  157.             MOVE.B        crc,D3 ; crchi = crc >> 8;
  158.  
  159.             LEA.L        crct_lo,A1
  160.             LEA.L        crct_hi,A2
  161.  
  162.             MOVEQ.L        #16,d4
  163.             CMP.L        d4,d0
  164.             BLT            end_crc
  165.  
  166.             MOVE.L        D0,D4
  167.  
  168.             LSR.L        #4,d0
  169.             SUBQ.L        #1,d0
  170.  
  171. for_count:    REPT        16
  172.             MOVE.B        (A0)+,D1        ; crclo = crct_lo[ndx = *p++ ^ crclo];
  173.             EOR.B        D2,D1
  174.             MOVE.B        (A1,D1.W),D2
  175.             EOR.B        D3,D2            ; crclo ^= crchi;
  176.             MOVE.B        (A2,D1.W),D3    ; crchi = crct_hi[ndx];
  177.             ENDM
  178.  
  179. next_count:    DBRA        D0,for_count    ; for (++count; --count;)
  180.  
  181.             MOVEQ.L        #15,D0
  182.             AND.W        D4,D0
  183.  
  184. end_crc:    SUBQ.W        #1,D0
  185.             BMI.S        crc_set
  186.  
  187. fwhile_crc:    MOVE.B        (A0)+,D1        ; crclo = crct_lo[ndx = *p++ ^ crclo];
  188.             EOR.B        D2,D1
  189.             MOVE.B        (A1,D1.W),D2
  190.             EOR.B        D3,D2            ; crclo ^= crchi;
  191.             MOVE.B        (A2,D1.W),D3    ; crchi = crct_hi[ndx];
  192.             DBRA        D0,fwhile_crc
  193.  
  194. crc_set:    MOVE.B        D3,crc ; crc = ((crchi << 8) | crclo);
  195.             MOVE.B        D2,crc+1
  196.  
  197.             MOVEM.L        (A7)+,D0-D4/A0-A2
  198.             RTS
  199.  
  200. crc_getc:    subq.l    #1,(a0)+    ; _cnt
  201.             bmi.b    _get_empty
  202.  
  203.             move.l    (a0),a1    ; _ptr
  204.             moveq.l    #0,d0
  205.             move.b    (a1)+,d0
  206.             move.l    a1,(a0)
  207.  
  208. _crc:        lea.l    crc,a0
  209.             move.w    (a0)+,d2
  210.             move.w    d2,d1
  211.             lsr.w    #8,d1
  212.             eor.w    d0,d2
  213.             and.w    #$FF,d2
  214.             add.w    d2,d2
  215.             move.w    (a0,d2.w),d2    ; crctbl
  216.             eor.w    d1,d2
  217.             move.w    d2,-(a0)        ; crc
  218.             rts
  219.  
  220. _get_empty:    subq.w    #4,a0
  221.             pea        (a0)
  222.             bsr        _filbuf
  223.  
  224.             tst.w    d0
  225.             bmi.b    _eof
  226.  
  227.             addq.w    #4,sp
  228.             bra.b    _crc
  229.  
  230. _eof:        move.l    (sp)+,a0
  231.             move.w    12(a0),d1    ; _flag
  232.             and.w    #$4000,d1
  233.             bne.b    _get_error
  234.             rts
  235.  
  236. _get_error:    move.l    infname,a0
  237.             moveq.l    #RDERR,d0
  238.             moveq.l    #-1,D1
  239.             jmp        error
  240.  
  241.  
  242. mksum:        subq.w    #1,d0
  243.             moveq.l    #0,d1
  244.             addq.w    #2,a0
  245.  
  246. _sum:        add.b    (a0)+,d1
  247.             dbra    d0,_sum
  248.             move.w    d1,d0
  249.             rts
  250.  
  251.  
  252. stpcpy:        move.l    a1,d0
  253.             beq.b    _no_source
  254.  
  255. _stpcpy:    REPT    23
  256.             move.b    (a1)+,(a0)+
  257.             beq.b    _stp_back
  258.             ENDM
  259.  
  260.             move.b    (a1)+,(a0)+
  261.             bne.b    _stpcpy
  262.  
  263. _stp_back:    subq.w    #1,a0
  264.             rts
  265.  
  266. _no_source:    clr.b    (a0)
  267.             rts
  268.  
  269.  
  270. strcpy:        move.l    a1,d0
  271.             beq.b    _no_source
  272.  
  273.             move.l    a0,d0
  274.  
  275. _strcpy:    REPT    23
  276.             move.b    (a1)+,(a0)+
  277.             beq.b    _str_exit
  278.             ENDM
  279.  
  280.             move.b    (a1)+,(a0)+
  281.             bne.b    _strcpy
  282.  
  283. _str_exit:    move.l    d0,a0
  284.             rts
  285.  
  286.  
  287. strncmp:    subq.w    #1,d0
  288.             bmi.s    _str_eq
  289.  
  290. _strn_lp:    move.b    (a0)+,d1
  291.             beq.b    _strcend
  292.             cmp.b    (a1)+,d1
  293.             dbne    d0,_strn_lp
  294.  
  295.             tst.w    d0
  296.             bmi.b    _str_eq
  297.  
  298.             cmp.b    -(a1),d1
  299.             bcs.b    _str_lt
  300.             moveq.l    #1,D0
  301.             rts
  302.  
  303. _str_eq:    moveq.l    #0,d0
  304.             rts
  305.  
  306.  
  307. _strcend:    tst.b    (a1)
  308.             bne.b    _str_lt
  309.  
  310.             moveq.l    #0,D0
  311.             rts
  312.  
  313. _str_lt:    moveq.l    #-1,D0
  314.             rts
  315.  
  316.  
  317. strcmp:        REPT 13
  318.             move.b    (a0)+,d0
  319.             beq.b    _strcend
  320.             cmp.b    (a1)+,d0
  321.             bne.b    _str_ne
  322.             ENDM
  323.  
  324.             move.b    (a0)+,d0
  325.             beq.b    _strcend
  326.             cmp.b    (a1)+,d0
  327.             beq.b    strcmp
  328.  
  329. _str_ne:    bcs.b    _str_lt
  330.             moveq.l    #1,D0
  331.             rts
  332.  
  333.  
  334. stricmp:    move.l    a2,d2
  335.             lea.l    upper,a2
  336.             moveq.l    #0,d0
  337.             moveq.l    #0,d1
  338.  
  339. _stri_lp:    move.b    (a0)+,d0
  340.             beq.b    _stri_cend
  341.  
  342.             move.b    0(a2,d0.w),d0
  343.             move.b    (a1)+,d1
  344.             cmp.b    0(a2,d1.w),d0
  345.             beq.b    _stri_lp
  346.             bcs.b    _stri_lt
  347.  
  348.             move.l    d2,a2
  349.             moveq.l    #1,D0
  350.             rts
  351.  
  352. _stri_cend:    tst.b    (a1)
  353.             bne.b    _stri_lt
  354.  
  355.             move.l    d2,a2
  356.             moveq.l    #0,D0
  357.             rts
  358.  
  359. _stri_lt:    move.l    d2,a2
  360.             moveq.l    #-1,D0
  361.             rts
  362.  
  363.  
  364. strlen:        move.l    a0,a1
  365.  
  366. _strlen:    REPT 15
  367.             tst.b    (a0)+
  368.             beq.b    _strlend
  369.             ENDM
  370.  
  371.             tst.b    (a0)+
  372.             bne.b    _strlen
  373.  
  374. _strlend:    move.l    a0,d0
  375.             sub.l    a1,d0
  376.             subq.l    #1,d0
  377.             rts
  378.  
  379.  
  380. strchr:        move.b    (a0)+,d1
  381.             beq.s    _sch_exit
  382.  
  383.             cmp.b    d1,d0
  384.             bne.s    strchr
  385.  
  386.             subq.w    #1,a0
  387.             rts
  388.  
  389. _sch_exit:    suba.l    a0,a0
  390.             rts
  391.  
  392.  
  393. get_fname:    move.l    a0,a1
  394.  
  395.             move.b    #'\',d1
  396.             move.b    #'/',d2
  397.  
  398. _gf_loop:    move.b    (a1)+,d0
  399.             beq.s    _gf_exit
  400.  
  401.             cmp.b    d1,d0
  402.             beq.s    _gf_set
  403.  
  404.             cmp.b    d2,d0
  405.             beq.s    _gf_set
  406.  
  407.             cmp.b    #':',d0
  408.             bne.s    _gf_loop
  409.  
  410. _gf_set:    movea.l    a1,a0
  411.             bra.s    _gf_loop
  412.  
  413. _gf_exit:    rts
  414.  
  415.  
  416. backpath:    bsr.s    get_fname
  417.             clr.b    (a0)
  418.             rts
  419.  
  420.  
  421. memset:        move.l    a0,a1
  422.  
  423.             subq.w    #1,d1
  424.             bmi.s    _mem_exit
  425.  
  426. _mem_lp:    move.b    d0,(a1)+
  427.             dbra    d1,_mem_lp
  428.  
  429. _mem_exit:    rts
  430.  
  431.  
  432. make_tree:    movem.l D3-D7/A2-A6,-(SP)
  433.             lea        -36(SP),SP
  434.  
  435.             lea        heap+2,A3    ; &heap[1]
  436.             clr.w   (A3)        ; heap[1] = 0
  437.             lea        heapsize,A4
  438.             movea.l 80(SP),A5    ; codeparm
  439.  
  440.             move.w  D0,D3        ; nparm
  441.             move.w  D3,D4        ; avail
  442.             move.w  D4,n        ; n
  443.             move.l  A0,freq        ; freqparm
  444.             move.l  A1,len        ; lenparm
  445.  
  446.             moveq.l    #0,D1        ; heapsize = 0
  447.  
  448.             subq.w    #1,D0
  449.             bmi.s    _m_no_for_i
  450.  
  451.             moveq.l    #0,D2
  452.             moveq.l    #0,D5        ; i = 0
  453.             move.l    A3,A6        ; &heap[1]
  454.  
  455. _m_for_i:    move.b    D2,(A1)+    ; len[i] = 0
  456.             tst.w    (A0)+        ; freq[i] ?
  457.             beq.s   _m_next_i
  458.  
  459.             addq.w  #1,D1
  460.             move.w  D5,(A6)+
  461.  
  462. _m_next_i:     addq.w    #1,D5
  463.             dbra    D0,_m_for_i
  464.  
  465. _m_no_for_i:move.w    D1,(A4)
  466.  
  467.             subq.w    #2,D1    ; heapsize<2 ?
  468.              bge.s   hs_ge_2
  469.  
  470.             move.w  (A3),D0
  471.             move.w    D0,D1
  472.             add.w   D1,D1
  473.             clr.w   0(A5,D1.w)
  474.  
  475.             lea        36(SP),SP
  476.             movem.l (SP)+,D3-D7/A2-A6
  477.             rts
  478.  
  479. hs_ge_2:    move.w    (A4),D5
  480.             moveq.l    #1,D6
  481.             asr.w    D6,D5    ; i = heapsize>>1
  482.             bra.s    down_h_next
  483.  
  484. down_h:        move.w    D5,D0
  485.             movem.l    D3-D5,-(SP)
  486.  
  487.             lea        heap,A0
  488.             movea.l freq,A1
  489.  
  490.             move.w  heapsize,D1
  491.             add.w    D1,D1
  492.  
  493.             add.w    D0,D0    ; i
  494.             lea.l    0(A0,D0.W),A2
  495.  
  496.             move.w  (A2),D2    ; k = heap[i]
  497.             move.w  D2,D3
  498.             add.w   D3,D3
  499.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  500.             move.w    D0,D4    ; j
  501.  
  502. _d_while1:    add.w    D4,D4
  503.  
  504.             cmp.w   D1,D4            ; j<=heapsize
  505.             bgt.s   _d_exit1
  506.             beq.s   _d_else1
  507.  
  508.             lea.l    0(A0,D4.W),A6
  509.             move.w    (A6)+,D5        ; heap[j]
  510.             add.w   D5,D5
  511.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  512.             move.w  (A6),D0            ; heap[j+1]
  513.             add.w   D0,D0
  514.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  515.             bls.s   _d_else1
  516.  
  517.             addq.w  #2,D4
  518.  
  519. _d_else1:    lea.l    0(A0,D4.W),A6
  520.             move.w    (A6),D5
  521.             move.w    D5,(A2)            ; heap[i] = heap[j]
  522.             add.w   D5,D5
  523.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  524.             bls.s   _d_exit1
  525.  
  526.             move.l    A6,A2
  527.             bra.s    _d_while1
  528.  
  529. _d_exit1:     move.w  D2,(A2)            ; heap[i] = k
  530.  
  531.             movem.l (SP)+,D3-D5
  532.  
  533.             subq.w  #1,D5
  534.  
  535. down_h_next:cmp.w    D6,D5
  536.             bge.s   down_h
  537.  
  538. no_down_heap:
  539.             move.l  A5,sortptr
  540.  
  541. do_heap:    move.w    (A3),D5
  542.             cmp.w   n(pc),D5            ; i<n
  543.             bge.s   i_ge_n
  544.  
  545.             movea.l sortptr(pc),A0
  546.             move.w  D5,(A0)+
  547.             move.l    A0,sortptr            ; *sortptr++ = i
  548.  
  549. i_ge_n:        move.w    (A4),D0
  550.             add.w   D0,D0
  551.             move.w  -2(A3,D0.w),(A3)    ; heap[1] = heap[heapsize--]
  552.             subq.w  #1,(A4)
  553.  
  554.             movem.l    D3-D5,-(SP)
  555.  
  556.             lea        heap,A0
  557.             movea.l freq,A1
  558.  
  559.             move.w  heapsize,D1
  560.             add.w    D1,D1
  561.  
  562.             lea.l    2(A0),A2        ; downheap(1)
  563.  
  564.             move.w  (A2),D2            ; k = heap[i]
  565.             move.w  D2,D3
  566.             add.w   D3,D3
  567.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  568.             moveq.l    #4,D4    ; j
  569.  
  570. _d_while2:    cmp.w   D1,D4            ; j<=heapsize
  571.             bgt.s   _d_exit2
  572.             beq.s   _d_else2
  573.  
  574.             lea.l    0(A0,D4.W),A6
  575.             move.w    (A6)+,D5        ; heap[j]
  576.             add.w   D5,D5
  577.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  578.             move.w  (A6),D0            ; heap[j+1]
  579.             add.w   D0,D0
  580.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  581.             bls.s   _d_else2
  582.  
  583.             addq.w  #2,D4
  584.  
  585. _d_else2:    lea.l    0(A0,D4.W),A6
  586.             move.w    (A6),D5
  587.             move.w    D5,(A2)            ; heap[i] = heap[j]
  588.             add.w   D5,D5
  589.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  590.             bls.s   _d_exit2
  591.  
  592.             move.l    A6,A2
  593.             add.w    D4,D4
  594.             bra.s    _d_while2
  595.  
  596. _d_exit2:     move.w  D2,(A2)            ; heap[i] = k
  597.  
  598.             movem.l (SP)+,D3-D5
  599.  
  600.             move.w  (A3),D6
  601.             cmp.w   n(pc),D6        ; j<n ?
  602.             bge.s   j_ge_n
  603.  
  604.             movea.l sortptr,A0
  605.             move.w  D6,(A0)+
  606.             move.l  A0,sortptr            ; *sortptr++ = j
  607.  
  608. j_ge_n:        move.w    D4,D7    ; k = avail
  609.             addq.w  #1,D4    ; avail++
  610.  
  611.             movea.l freq,A0
  612.  
  613.             move.w  D5,D0
  614.             add.w   D0,D0
  615.             move.w  0(A0,D0.w),D1    ; freq[i]
  616.             move.w  D6,D2
  617.             add.w   D2,D2
  618.             add.w   0(A0,D2.w),D1    ; freq[j]
  619.             move.w  D7,D0
  620.             add.w   D0,D0
  621.             move.w  D1,0(A0,D0.w)    ; freq[k] = freq[i] + freq[j]
  622.  
  623.             move.w  D7,(A3)            ; heap[1] = k
  624.  
  625.             movem.l    D3-D5,-(SP)
  626.  
  627.             lea        heap,A0
  628.             movea.l freq,A1
  629.  
  630.             move.w  heapsize,D1
  631.             add.w    D1,D1
  632.  
  633.             lea.l    2(A0),A2        ; downheap(1)
  634.  
  635.             move.w  (A2),D2            ; k = heap[i]
  636.             move.w  D2,D3
  637.             add.w   D3,D3
  638.             move.w  0(A1,D3.w),D3    ; fk = freq[k]
  639.             moveq.l    #4,D4    ; j
  640.  
  641. _d_while3:    cmp.w   D1,D4            ; j<=heapsize
  642.             bgt.s   _d_exit3
  643.             beq.s   _d_else3
  644.  
  645.             lea.l    0(A0,D4.W),A6
  646.             move.w    (A6)+,D5        ; heap[j]
  647.             add.w   D5,D5
  648.             move.w  0(A1,D5.w),D5    ; freq[heap[j]]
  649.             move.w  (A6),D0            ; heap[j+1]
  650.             add.w   D0,D0
  651.             cmp.w   0(A1,D0.w),D5    ; freq[heap[j+1]]
  652.             bls.s   _d_else3
  653.  
  654.             addq.w  #2,D4
  655.  
  656. _d_else3:    lea.l    0(A0,D4.W),A6
  657.             move.w    (A6),D5
  658.             move.w    D5,(A2)            ; heap[i] = heap[j]
  659.             add.w   D5,D5
  660.             cmp.w   0(A1,D5.w),D3    ; fk<=freq[heap[j]]
  661.             bls.s   _d_exit3
  662.  
  663.             move.l    A6,A2
  664.             add.w    D4,D4
  665.             bra.s    _d_while3
  666.  
  667. _d_exit3:     move.w  D2,(A2)            ; heap[i] = k
  668.  
  669.             movem.l (SP)+,D3-D5
  670.  
  671.             move.w    D7,D0
  672.             add.w   D0,D0
  673.             lea        left,A0
  674.             move.w  D5,0(A0,D0.w)    ; left[i] = k
  675.             lea        right,A1
  676.             move.w  D6,0(A1,D0.w)    ; right[i] = k
  677.  
  678.             cmpi.w  #1,(A4)            ; heapsize>1 ?
  679.             bgt        do_heap
  680.  
  681.             move.l  A5,sortptr        ; sortptr = codeparm
  682.  
  683.             move.w  D7,D0
  684.             jsr        make_len        ; make_len(k)
  685.  
  686.             lea.l    2(SP),A0        ; &start[1]
  687.             lea.l    len_cnt+2,A1
  688.  
  689.             moveq.l    #0,D1
  690.             moveq.l #3,D0
  691.             move.w    D1,(A0)+            ; start[1] = 0
  692.  
  693. for_start:    REPT    4
  694.             add.w    (A1)+,D1        ; start[i] + len_cnt[i]
  695.             add.w    D1,D1
  696.             move.w    D1,(A0)+
  697.             ENDM
  698.             dbra    D0,for_start
  699.  
  700.             moveq.l    #0,D1
  701.             move.l    len,A2
  702.             bra.s    next_i
  703.  
  704. for_i:        move.b  (A2)+,D1
  705.             add.w   D1,D1
  706.             lea.l    0(SP,D1.W),A0
  707.             move.w  (A0),(A5)+        ; codeparm[i] = start[lenparm[i]]
  708.             addq.w  #1,(A0)
  709. next_i:        dbra    d3,for_i
  710.  
  711.             move.w  D7,D0
  712.             lea           36(SP),SP
  713.             movem.l (SP)+,D3-D7/A2-A6
  714.             rts
  715.  
  716.  
  717. count_len:    cmp.w    n(pc),d0
  718.             bge.b    _i_ge_n
  719.  
  720.             move.w    depth(pc),d0
  721.             cmp.w    #16,d0
  722.             bge.b    _ge_16
  723.  
  724.             add.w    d0,d0
  725.             lea.l    len_cnt,a0
  726.             addq.w    #1,(a0,d0.w)
  727.             rts
  728.  
  729. _ge_16:        addq.w    #1,len_cnt+32
  730.             rts
  731.  
  732. _i_ge_n:    move.w    d3,-(sp)
  733.             lea.l    depth(pc),a1
  734.             addq.w    #1,(a1)
  735.  
  736.             move.w    d0,d3
  737.             add.w    d3,d3
  738.  
  739.             lea.l    left,a0
  740.             move.w    (a0,d3.w),d0
  741.             bsr.b    count_len
  742.  
  743.             lea.l    right,a0
  744.             move.w    (a0,d3.w),d0
  745.             bsr.b    count_len
  746.  
  747.             subq.w    #1,(a1)
  748.             move.w    (sp)+,d3
  749.             rts
  750.  
  751.  
  752. sortptr:    DC.L    0
  753. blkcnt:        DC.W    0
  754. depth:        DC.W    0
  755. n:            DC.W    0
  756. star:        DC.B    0,'*'
  757. flg_n:        DC.B    0
  758.  
  759.             EVEN
  760.  
  761.             BSS
  762.  
  763. upper:        DS.B        256
  764. crct_lo:    DS.B        256
  765. crct_hi:    DS.B        256
  766.  
  767.             END
  768.