home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / magazi~1 / 225 / analog.46 / dx.s < prev    next >
Encoding:
Text File  |  1987-10-18  |  9.8 KB  |  237 lines
  1.  
  2. *     Note: in the comments to the following code, the symbol " -> "
  3. *           means "pointer to" or "contains a pointer to".
  4.  
  5.  
  6. *************************************************************************
  7. *** This version is compatible with the AS68 assembler included in the
  8. ***     Atari Developer's Kit.
  9. *** INITIALIZATION: these should be the first instructions in your
  10. ***    program...
  11. sys_start:
  12.           move.l    4(a7),a5            a5 == base page address
  13.           lea.l     $80(a5),a2          point to command line
  14.           clr.l     d0                  clear for byte size value
  15.           move.b    (a2)+,d0            get byte count
  16.  
  17. ***  a2 -> command line
  18. ***  d0 == byte count of command line
  19.           move.l    #flags,-(sp)        base of flags area
  20.           move.l    #code_nr,-(sp)      nr of flags in table
  21.           bsr       init_flags          initialize flags
  22.           addq.l    #8,sp               pop args
  23.  
  24. *** process command line codes
  25.           move.l    #code_scale,-(sp)
  26.           move.l    #code_nr,-(sp)      number of codes possible
  27.           move.l    #codes,-(sp)        table of codes
  28.           move.l    d0,-(sp)            byte count
  29.           move.l    a2,-(sp)            address of command line
  30.           bsr       check_c_args        set flags 
  31.           add.l     #20,sp              pop args
  32.  
  33. *** ...the rest of your program follows here...
  34.  
  35.      
  36. *************************************************************************
  37. *** SUBROUTINES: these are called from the main program (above).
  38. *****
  39. *
  40. * init_flags-- initializes a standard table of (byte-size) flags to
  41. *              FALSE.
  42. *    at entry:
  43. *              a6 + 8  -> size of table.
  44. *              a6 + 12 -> base of table.
  45. *    at exit:
  46. *              table  is initialized.
  47. *              all registers preserved.
  48. *
  49. *****
  50. init_flags:
  51.           link      a6,#0          set frame pointer
  52.           movem.l   a0/d0,-(sp)    save registers
  53.           movea.l   12(a6),a0      base of table
  54.           move.l    8(a6),d0       size of table
  55.           bra.s     initf_test     now start         
  56. initf_loop:
  57.           move.b    #FALSE,(a0)+   initialize a flag
  58. initf_test:   
  59.           dbra      d0,initf_loop  go till end
  60.           movem.l   (sp)+,a0/d0    restore registers
  61.           unlk      a6             deallocate frame
  62.           rts                      and return
  63.  
  64. *****
  65. * 
  66. * parse_word-- returns a word (delimited by a space or end of string)
  67. *               from a string.
  68. *              the word must be <= 76 chars (ARG_SIZE, == size of local
  69. *               area reserved by caller).
  70. * at entry:
  71. *              a6 + 8  -> address of string.
  72. *              a6 + 12 -> byte count of string.
  73. *              a6 + 16 -> area into which to copy word (null-terminated).
  74. * at exit:     
  75. *              a0 -> next word of original string.
  76. *              d0 == updated byte count (0 if string exhausted).
  77. *              a1 -> word returned (terminated by 0).
  78. *              d1 == byte count of word.
  79. *              if error, d0 == -1 ('BAD').
  80. *              all other registers preserved.
  81. *
  82. *****
  83. parse_word:
  84.           link      a6,#0          set frame pointer
  85.           movea.l   8(a6),a0       get string address
  86.           move.l    12(a6),d0      get byte count
  87.           bgt.s     p_w_001        if count > 0, continue
  88.           move.l    #BAD,d0        else return error
  89.           bra       w_f_002        and leave
  90. p_w_001:
  91.           movea.l   16(a6),a1      point to copy space
  92.           movem.l   a1/d2,-(sp)    save it and count register
  93.           clr.l     d1             clear word count
  94.           move.l    #ARG_SIZE-1,d2   start control count (-1 for null)
  95. parse_loop:
  96.           cmp.b     #BLANK,(a0)    blank?
  97.           bne.s     p_l_001        if not
  98.           subq.l    #1,d0          else decrement string count
  99.           addq.l    #1,a0          point to next char
  100.           bra       p_w_exit       and return word
  101. p_l_001:
  102.           subq.l    #1,d0          else decrement string count
  103.           bne.s     p_l_002        continue if string not exhausted
  104.           addq.l    #1,d1          else count this last char...
  105.           move.b    (a0)+,(a1)+    copy last valid char...
  106.           bra       p_w_exit       and return final word
  107. p_l_002:
  108.           move.b    (a0)+,(a1)+    copy char
  109.           addq.l    #1,d1          count this one
  110.           subq.l    #1,d2          decrement control count
  111.           bne.s     p_l_003        if > 0, continue
  112.           subq.l    #1,d0          else decrement string count
  113.           bra       p_w_exit       and leave
  114. p_l_003: 
  115.           bra       parse_loop     keep going
  116. p_w_exit:
  117.           move.b    #0,(a1)+       terminate word with null
  118. w_f_001:
  119.           movem.l   (sp)+,a1/d2    point back to start of return word
  120. *                                   and restore d2
  121. w_f_002:
  122.           unlk      a6             deallocate frame
  123.           rts                      and return
  124.  
  125.  
  126. *****
  127. *
  128. * check_c_args-- checks one-letter command-line arguments and sets 
  129. *                internal flags as appropriate.
  130. * at entry:
  131. *              a6 + 8  -> address of command line string.
  132. *              a6 + 12 -> byte count of command line string.
  133. *              a6 + 16 -> base address of array of char codes to
  134. *                                look for.
  135. *              a6 + 20 -> nr of char codes in array.
  136. *              a6 + 24 -> code table scale factor.
  137. * at exit:
  138. *              d0 == completion code (returns GOOD if there's
  139. *                   anything else on command line-- even only spaces).
  140. *              flags will be set TRUE or FALSE as appropriate.
  141. *              all other registers preserved.
  142. *                
  143. *****
  144. check_c_args:
  145.           link      a6,#-ARG_SIZE       set frame pointer   
  146.           movem.l   a0-a2/d1-d4,-(sp)   save registers
  147.           move.l    12(a6),d0           command line byte count
  148.           bgt.s     c_c_a001            if count > 0, continue
  149.           move.l    #BAD,d0             else load error code
  150.           bra.s     c_c_exit            and leave
  151. c_c_a001:     
  152.           movea.l   8(a6),a0            command line address 
  153.           move.l    24(a6),d3           scale factor
  154.           subq.l    #1,d3               -1 to allow for address reg inc 
  155.           clr.l     d4                  holds byte for comparisons        
  156. c_c_word:
  157.           tst.l     d0                  anything left in command line?
  158.           bne.s     c_c_w001            if so, continue
  159.           move.l    #GOOD,d0            else load success code
  160.           bra.s     c_c_exit            and leave
  161. c_c_w001:
  162.           pea       -ARG_SIZE(a6)       local space address
  163.           move.l    d0,-(sp)            current command line count
  164.           move.l    a0,-(sp)            rest of command line
  165.           bsr       parse_word          get next word
  166.           add.l     #12,sp              pop args
  167. *** (a1) -> code to check; d1 == count; (a0) -> rest of cmdline;
  168. ***         d0 == bytes left
  169.           cmp.l     #1,d1               one-char arg?
  170.           beq.s     c_c_scan            if so, continue
  171.           bra.s     c_c_word            else skip this one
  172. c_c_scan:
  173.           move.l    20(a6),d2           nr of codes to check
  174.           movea.l   16(a6),a2           base of codes table
  175.           bra.s     c_c_stest           start checking
  176. c_c_sloop:
  177.           move.b    (a2)+,d4            next byte
  178.           cmp.b     (a1),d4             code found?
  179. c_c_stest:
  180.           dbeq      d2,c_c_sloop        if not and more codes to check
  181.           tst.w     d2                  really a match?
  182.           bmi.s     c_c_s001            if not
  183.           move.b    #TRUE,0(a2,d3.l)    else set flag = TRUE
  184. c_c_s001:
  185.           bra.s     c_c_word            and get next word 
  186. c_c_exit:
  187.           movem.l   (sp)+,a0-a2/d1-d4   restore registers
  188.           unlk      a6                  deallocate local space
  189.           rts                           and return                 
  190.  
  191. *************************************************************************
  192. *** DATA DECLARATIONS:
  193. *****
  194. *
  195. * standard flags table.
  196. *
  197. *****
  198. GOOD      equ       0         return code == success
  199. BAD       equ       -1        return code == fail
  200. ARG_SIZE  equ       76        max total length of command line arguments
  201. TRUE      equ       1         == C "true" cond
  202. FALSE     equ       0         == C "false" cond
  203. BLANK     equ       32        ascii space == " "
  204.  
  205.                even
  206. code_base      equ       *                   base of codes table
  207.  
  208. *** now comes a list of the characters you want to use
  209. codes          dc.b      'O','G'             command line codes
  210.                dc.b      'V','P','R','A','B','C'
  211.                dc.b      'N','S','D'   
  212.  
  213. *** the next four lines do not change!
  214. code_nr        equ       *-code_base         size of table
  215. code_count     dc.l      code_nr             save it
  216. code_scale     equ       *-code_base         index between codes and flags
  217. flags          equ       *                   base of flags table
  218.  
  219. *** these are the flags which correspond to the characters listed above.
  220. ***   If the codes are changed, then the flags must also be changed to
  221. ***   maintain a one-to-one corrspondence. If a valid character code
  222. ***   (one of those listed above) is found on the command line, then its
  223. ***   corresponding flag will be set to "true" after the routine
  224. ***   'check_c_args' is called; otherwise it remains "false".
  225. okidata        ds.b      1                   oki printer
  226. star           ds.b      1                   star/gemini printer
  227. verbose        ds.b      1
  228. print_it       ds.b      1
  229. small_prt      ds.b      1
  230. drive_a        ds.b      1
  231. drive_b        ds.b      1
  232. drive_c        ds.b      1
  233. set_title      ds.b      1
  234. set_stack      ds.b      1
  235. search         ds.b      1                   alternate search level
  236.  
  237.