PasteRack.org
Paste # 44332
2019-08-23 13:58:31

Fork as a new paste.

Paste viewed 420 times.


Embed:

6502 modes

  1. #lang racket
  2.  
  3. (define (MODE-A processor)
  4.   (Processor-A processor))
  5.  
  6. (define (MODE-IMM processor)
  7.   (let ([operand (first-operand processor)])
  8.     operand))
  9.  
  10. (define (MODE-ZP processor)
  11.   (let ([operand1 (first-operand processor)])
  12.     (lookup processor operand1)))
  13.  
  14. (define (MODE-ZP-X processor)
  15.   (let ([operand1 (first-operand processor)]
  16.         [X (Processor-X processor)])
  17.     (lookup processor (+ operand1
  18.                          X))))
  19.  
  20. (define (MODE-ZP-Y processor)
  21.   (let ([operand1 (first-operand processor)]
  22.         [Y (Processor-Y processor)])
  23.     (lookup processor (+ operand1
  24.                          Y))))
  25.  
  26. (define (MODE-ABS processor)
  27.   (let ([operand1 (first-operand processor)]
  28.         [operand2 (second-operand processor)])
  29.     (lookup processor (bytes->addr operand1 operand2))))
  30.  
  31. (define (MODE-ABS-X processor)
  32.   (let ([operand1 (first-operand processor)]
  33.         [operand2 (second-operand processor)]
  34.         [X (Processor-X processor)])
  35.     (lookup processor (+ (bytes->addr operand1 operand2)
  36.                          X))))
  37.  
  38. (define (MODE-ABS-Y processor)
  39.   (let ([operand1 (first-operand processor)]
  40.         [operand2 (second-operand processor)]
  41.         [Y (Processor-Y processor)])
  42.     (lookup processor (+ (bytes->addr operand1 operand2)
  43.                          Y))))
  44.  
  45. ;would love to implement the IND-X/Y modes in terms of the general INDIRECT
  46. ;(not seen here just yet) mode, but as natural as it seems it would be
  47. ;I just can't find a way to make it natural in practice.
  48. ;Same goes for some kind of (with-X) and (with-Y) mode.
  49.  
  50. (define (MODE-IND-X processor)
  51.   (let* ([operand (first-operand processor)]
  52.          [X (Processor-X processor)]
  53.          [addr-lo-byte (lookup processor operand)]
  54.          [addr-hi-byte (lookup processor (add1 operand))])
  55.     (lookup processor (+ (bytes->addr addr-lo-byte
  56.                                       addr-hi-byte)
  57.                          X))))
  58.  
  59. (define (MODE-IND-Y processor)
  60.   (let* ([operand (first-operand processor)]
  61.          [Y (Processor-Y processor)]
  62.          [addr-lo-byte (lookup processor operand)]
  63.          [addr-hi-byte (lookup processor (add1 operand))])
  64.     (lookup processor (+ (bytes->addr addr-lo-byte
  65.                                       addr-hi-byte)
  66.                          Y))))
  67.  

=>