org    $1000
prompt    dc.b 'monitor441>',0
input_buffer ds.b 80
block_test_failed dc.b 'block test failed at: ',0
block_search_found dc.b 'block search found a match starting at: ',0
newline_string dc.b ' ',0
bs_test dc.b 'bs 0002 0010 aa aa',0
help1  dc.b 'commands: usage',0
help2  dc.b 'memory display: md addr',0
help3  dc.b 'memory sort: ms low_addr high_addr',0
help4  dc.b 'memory modify: mm addr',0
help5  dc.b 'block fill: bf low_addr high_addr fill_word',0
help6  dc.b 'block search: bs low_addr high_addr byte_1 byte_2 ...',0
help7  dc.b 'block move: bm low_addr high_addr move_addr',0
help8  dc.b 'block test: bt low_addr high_addr',0
help9  dc.b 'help: h',0
help10 dc.b 'display regs: d',0
help11 dc.b 'modify reg: .a[0-7] || .d[0-7]',0
help12 dc.b 'go: g addr',0
help13 dc.b 'data conversion: dc data',0
ascii_fail dc.b 'there is to be a single char of whitespace between command segments, addr=word',0
ra0 dc.b 'a0 ',0
ra1 dc.b 'a1 ',0
ra2 dc.b 'a2 ',0
ra3 dc.b 'a3 ',0
ra4 dc.b 'a4 ',0
ra5 dc.b 'a5 ',0
ra6 dc.b 'a6 ',0
ra7 dc.b 'a7 ',0
rd0 dc.b 'd0 ',0
rd1 dc.b 'd1 ',0
rd2 dc.b 'd2 ',0
rd3 dc.b 'd3 ',0
rd4 dc.b 'd4 ',0
rd5 dc.b 'd5 ',0
rd6 dc.b 'd6 ',0
rd7 dc.b 'd7 ',0
rsr dc.b 'sr ',0
ms_test dc.b '987645321'
ms_test_end dc.b '1'
berr_text  dc.b 'a bus error occured: printing regs',0
aerr_text  dc.b 'an address error occured: printing regs',0
ierr_text  dc.b 'an illegal instruction occured: printing regs',0
perr_text  dc.b 'a privilege violation occured: printing regs',0
zerr_text  dc.b 'a divide by zero error occured: printing regs',0
aferr_text dc.b 'a a/f line error occured: printing regs',0

    org    $3000
ascii 
    movem.l a0-a5/d1-d7,-(sp)
    move.l #1,d1
    clr.l d0
ascii_loop    
    clr.l d2
    cmp.l a5,a6
    ble ascii_done
    move.b -(a6),d2
    cmp.b #'0',d2 ;less than 0?
    blt ascii_out_of_range
    cmp.b #'f',d2 ;more than f?
    bgt ascii_out_of_range
    cmp.b #'9',d2
    ble ascii_good
    cmp.b #'a',d2
    bge ascii_good_hex
    bra ascii_out_of_range
ascii_good_hex
    sub.b #$37,d2
    bra ascii_shifted
ascii_good
    sub #$30,d2
ascii_shifted
    mulu d1,d2
    add.l d2,d0
    mulu #$10,d1
    bra ascii_loop
ascii_done     movem.l (sp)+,a0-a5/d1-d7
    rts
ascii_out_of_range
    lea ascii_fail,a1
    move #13,d0
    trap #15
    bra ascii_done
    
hex
    movem.l a0-a6/d0-d7,-(sp)
    move.l d1,d2
hex_roll
    rol.l #4,d2
    move.l d2,d1
    and.l #$0000000f,d1
    cmp.b #$a,d1
    blt hex_skip_add
    add.b #$37,d1
    bra hex_write_out
hex_skip_add
    add.b #'0',d1
hex_write_out
    move.l #6,d0
    trap #15
    dbf d3,hex_roll
    movem.l (sp)+,a0-a6/d0-d7
    rts    

select_reg
    movea a1,a5 
    adda #4,a5 ;dont need the first 4 chars
    movea a1,a6 
    adda  d1,a6 ;end of string
    jsr ascii ; decode ascii(hex)->binary
    cmp.b #'a',(1,a1) ;'a'
    bne next_reg_d
    move.b (2,a1),d2
    cmp #'0',d2
    bne reg_a1
    movea d0,a0
    bra select_reg_done
reg_a1
    cmp #'1',d2
    bne reg_a2
    movea d0,a1
    bra select_reg_done
reg_a2
    cmp #'2',d2
    bne reg_a3
    movea d0,a2
    bra select_reg_done
reg_a3
    cmp #'3',d2
    bne reg_a4
    movea d0,a3
    bra select_reg_done
reg_a4
    cmp #'4',d2
    bne reg_a5
    movea d0,a4
    bra select_reg_done
reg_a5
    cmp #'5',d2
    bne reg_a6
    movea d0,a5
    bra select_reg_done
reg_a6
    cmp #'6',d2
    bne reg_a7
    movea d0,a6
    bra select_reg_done
reg_a7
    cmp #'7',d2
    bne reg_a_fail
    movea d0,a7
    bra select_reg_done
reg_a_fail

select_reg_done
    rts

next_reg_d 
    cmp.b #$44,(1,a1) ;'d'
    bne next_reg_s
    move.b (2,a1),d2
    cmp #'0',d2
    bne reg_d1
    move d0,d0
    bra select_reg_done
reg_d1
    cmp #'1',d2
    bne reg_d2
    move d0,d1
    bra select_reg_done
reg_d2
    cmp #'2',d2
    bne reg_d3
    move d0,d2
    bra select_reg_done
reg_d3
    cmp #'3',d2
    bne reg_d4
    move d0,d3
    bra select_reg_done
reg_d4
    cmp #'4',d2
    bne reg_d5
    move d0,d4
    bra select_reg_done
reg_d5
    cmp #'5',d2
    bne reg_d6
    move d0,d5
    bra select_reg_done
reg_d6
    cmp #'6',d2
    bne reg_d7
    move d0,d6
    bra select_reg_done
reg_d7
    cmp #'7',d2
    bne reg_d_fail
    move d0,d7
    bra select_reg_done
reg_d_fail
next_reg_s

block_decode
    cmp.b #'f',(1,a1)
    beq block_fill
    cmp.b #'m',(1,a1)
    beq block_move
    cmp.b #'s',(1,a1)
    beq block_search
    cmp.b #'t',(1,a1)
    beq block_test
    rts
    
block_fill
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a2
    adda #5,a5
    adda #9,a6
    bsr ascii
    move d0,a3
    adda #5,a5
    adda #9,a6
    bsr ascii
block_fill_loop
    cmp a3,a2
    bgt block_fill_done
    move.w d0,(a2)+
    bra block_fill_loop
    
block_fill_done
    movem.l (sp)+,a0-a6/d0-d7
    rts
block_move
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a2
    adda #5,a5
    adda #9,a6
    bsr ascii
    move d0,a3
    adda #5,a5
    adda #9,a6
    bsr ascii
    movea d0,a5
block_move_loop
    cmp a3,a2
    bgt block_move_done
    move.w (a2)+,(a5)+
    bra block_move_loop
    
block_move_done
    movem.l (sp)+,a0-a6/d0-d7
    rts
block_search
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5 ;move input buffer address to a5
    adda #3,a5 ;skip past 'bs '
    movea a5,a6 
    adda #4,a6 ;put end address the byte after the 4 chars for the word'
    bsr ascii
    movea d0,a2 ;low end of search range goes in a2
    adda #5,a5 ;skip to next part
    adda #9,a6
    bsr ascii 
    move d0,a3 ;high end of search range to a3
    clr.l d2 ; counter of bytes
    adda #5,a5 
    adda #7,a6 ;only 2 chars
    bra block_search_skip
block_search_input_loop
    adda #3,a5 ;only 2 chars
    adda #5,a6
block_search_skip
    lea input_buffer,a4
    adda d1,a4
    cmp.l a4,a6 ;check if you've hit end of input
    bgt block_search_loop
    bsr ascii
    move.b d0,(a1)+ ;write out into buffer
    add.l #1,d2 ;add to the count
    bra block_search_input_loop
block_search_loop
    cmp.l a2,a3
    blt block_search_loop_done
    bsr block_search_from_here
    cmp.l d2,d0
    bne block_search_not_found
    movem.l a0-a6/d0-d7,-(sp)
    lea block_search_found,a1
    move.l a2,d1
    move.l #17,d0
    trap #15
    lea newline_string,a1
    move #13,d0
    trap #15
    movem.l (sp)+,a0-a6/d0-d7
block_search_not_found
    adda #1,a2
    bra block_search_loop
block_search_loop_done
    movem.l (sp)+,a0-a6/d0-d7
    rts
    
block_search_from_here
    clr.l d0
    movem.l a0-a6/d1-d7,-(sp)
    lea input_buffer,a1
block_search_from_here_loop
    cmp.b (a2)+,(a1)+
    bne block_search_loop_fail
    add.l #1,d0
    cmp d2,d0
    blt block_search_from_here_loop
block_search_loop_fail
    movem.l (sp)+,a0-a6/d1-d7
    rts


block_test
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    move.l d0,a2
    adda #5,a5
    adda #9,a6
    bsr ascii
    move.l d0,a3
block_test_loop
    cmp a3,a2
    bgt block_test_done
    move.w #$a0a0,(a2)
    cmp.w #$a0a0,(a2)+
    bne block_test_error
    bra block_test_loop
block_test_error
    movem.l a0-a6/d0-d7,-(sp)
    lea block_test_failed,a1
    move #14,d0
    trap #15
    move.l a2,d1
    sub.l #2,d1
    move #3,d0
    trap #15
    movem.l (sp)+,a0-a6/d0-d7
    
block_test_done
    movem.l (sp)+,a0-a6/d0-d7
    rts
    
go  
    movea a1,a5
    adda #2,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a0
    jmp (a0)
    cmp.b d1,d3
    cmp.b d2,d4

memory_decode
    cmp.b #'d',(1,a1)
    beq md
    cmp.b #'m',(1,a1)
    beq mm
    cmp.b #'s',(1,a1)
    beq ms
    rts
    
ms
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a2
    adda #5,a5
    adda #9,a6
    bsr ascii
    move d0,a3
ms_loop
    cmp.l a2,a3
    ble ms_done
    bsr ms_smallest
    move.b (a2),d1
    move.b d0,(a2)+
    move.b d1,(a0)
    bra ms_loop
ms_done
    movem.l (sp)+,a0-a6/d0-d7
    rts
    
    
ms_smallest
    movem.l d1-d7/a1-a6,-(sp)
    move.b (a2),d0
    suba #1,a2
ms_smallest_loop
    adda #1,a2
    cmp.l a2,a3
    ble ms_smallest_done
    cmp.b (a2),d0
    blt ms_smallest_loop
    movea a2,a0
    move.b (a2),d0
    bra ms_smallest_loop
ms_smallest_done
    movem.l (sp)+,d1-d7/a1-a6
    rts
    
    
    
mm
    movem.l a1-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a2
mm_loop
    move.l a2,d1
    move.l #7,d3 ; for addr
    bsr hex
    lea newline_string,a1 ; put a space
    move.l #14,d0 
    trap #15
    move.b (a2),d1 ; pull down char
    swap d1 ;fix it for output
    lsl.l #8,d1 
    move.l #1,d3 ; only 2 hex digits
    bsr hex 
    trap #15 ;space
    move #5, d0 ;input char
    trap #15
    cmp.b #'.',d1 ;quit on .
    beq mm_quit
    lea input_buffer,a6 ;saving on that same buffer
    move.b d1,(a6)+
    move #5, d0
    trap #15
    cmp.b #'.',d1
    beq mm_quit
    move.b d1,(a6)+
    lea input_buffer,a5
    bsr ascii
    move.b d0,(a2)+ ;cycling up to next byte
    move.l #13,d0
    trap #15
    bra mm_loop
mm_quit
    movem.l (sp)+,a1-a6/d0-d7
    rts
    
    
    
    
md
    movem.l a0-a6/d0-d7,-(sp)
    movea a1,a5
    adda #3,a5
    movea a5,a6
    adda #4,a6
    bsr ascii
    movea d0,a2
md_bigloop
    move.l #$f, d5
    move.l a2,d1
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #14,d0
    trap #15
md_loop
    move.b (a2)+,d1
    swap d1
    lsl.l #8,d1
    move.l #1,d3
    bsr hex
    trap #15
    dbf d5,md_loop
    move #5, d0
    trap #15
    move.l #13,d0
    trap #15
    cmp.b #'.',d1
    bne md_bigloop    
    movem.l (sp)+,a0-a6/d0-d7
    rts
d_decode
    cmp.b #0,(1,a1)
    beq display_command
    cmp.b #'c',(1,a1)
    beq dc
    rts
dc
    movem.l d0-d7/a0-a6,-(sp)
    movea a1,a5
    adda #3,a5
    movea a1,a6
    adda d1,a6
    bsr ascii
    move.l d0,d1
    move.l #3,d0
    trap #15
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0-d7/a0-a6
    rts
    
display_command
    movem.l d0/d1,-(sp) ;d0
    lea rd0,a1
    move.l d0,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d1
    lea rd1,a1
    move.l d1,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d2
    lea rd2,a1
    move.l d2,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d3
    lea rd3,a1
    move.l d3,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d4
    lea rd4,a1
    move.l d4,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) 
    lea rd5,a1
    move.l d5,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d4
    lea rd6,a1
    move.l d6,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp) ;d4
    lea rd7,a1
    move.l d7,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra0,a1
    move.l a0,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra1,a1
    move.l a1,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra2,a1
    move.l a2,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra3,a1
    move.l a3,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra4,a1
    move.l a4,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra5,a1
    move.l a5,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra6,a1
    move.l a6,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea ra7,a1
    move.l a7,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1
    
    movem.l d0/d1,-(sp)
    lea rsr,a1
    move sr,d1
    move.l #14,d0
    trap #15
    move.l #7,d3
    bsr hex
    lea newline_string,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,d0/d1

    rts   
help
    movem.l a1/d0,-(sp)
    move.l #13,d0
    lea help1,a1
    trap #15
    lea help2,a1
    trap #15
    lea help3,a1
    trap #15
    lea help4,a1
    trap #15
    lea help5,a1
    trap #15
    lea help6,a1
    trap #15
    lea help7,a1
    trap #15
    lea help8,a1
    trap #15
    lea help9,a1
    trap #15
    lea help10,a1
    trap #15
    lea help11,a1
    trap #15
    lea help12,a1
    trap #15
    lea help13,a1
    trap #15
    movem.l (sp)+,a1/d0
    rts

berr
    movem.l a1/d0,-(sp)
    lea berr_text,a1
    move.l #13,d0
    trap #15
    move.w (12,sp),d1
    swap d1
    move.l #3,d3
    bsr hex
    lea newline_string,a1
    move.l #14,d0
    trap #15
    move.l (14,sp),d1
    move.l #7,d3
    bsr hex
    move.l #14,d0
    trap #15
    move.w (18,sp),d1
    swap d1
    move.l #3,d3
    bsr hex
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0
    bsr display_command
    move.l #$01000000,sp
    bra main
aerr
    movem.l a1/d0/d1,-(sp)
    lea aerr_text,a1
    move.l #13,d0
    trap #15
    move.w (12,sp),d1
    swap d1
    move.l #3,d3
    bsr hex
    lea newline_string,a1
    move.l #14,d0
    trap #15
    move.l (14,sp),d1
    move.l #7,d3
    bsr hex
    move.l #14,d0
    trap #15
    move.w (18,sp),d1
    swap d1
    move.l #3,d3
    bsr hex
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0/d1
    bsr display_command
    move.l #$01000000,sp
    bra main
ierr
    movem.l a1/d0,-(sp)
    lea ierr_text,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0
    bsr display_command
    move.l #$01000000,sp
    bra main
perr
    movem.l a1/d0,-(sp)
    lea perr_text,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0
    bsr display_command
    move.l #$01000000,sp
    bra main    
zerr
    movem.l a1/d0,-(sp)
    lea zerr_text,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0
    bsr display_command
    move.l #$01000000,sp
    bra main
aferr
    movem.l a1/d0,-(sp)
    lea aferr_text,a1
    move.l #13,d0
    trap #15
    movem.l (sp)+,a1/d0
    bsr display_command
    move.l #$01000000,sp
    bra main


start:                  ; first instruction of program
    movem.l a1,-(sp)
    lea berr,a1
    move.l a1,$8
    lea aerr,a1
    move.l a1,$c
    lea ierr,a1
    move.l a1,$10
    lea zerr,a1
    move.l a1,$14
    lea perr,a1
    move.l a1,$20
    lea aferr,a1
    move.l a1,$28
    move.l a1,$2c
    ;movea #$ff,a1
    ;move.l d1,(a1)+
    ;move.b $ffffffff,d0
    ;jmp $1010
    ;divu #0,d0
    ;andi.w #$700,sr
    ;andi.w #$700,sr
    movem.l (sp)+,a1
main
    lea newline_string,a1
    move #13,d0
    trap #15
    lea prompt,a1
    move #14,d0
    trap #15
    lea input_buffer,a1
    move.l #2,d0
    trap #15
    cmp.b #'.',(a1)
    bne b_command
    jsr select_reg
    bra main
b_command
    cmp.b #$42,(a1)
    bne g_command
    bsr block_decode
    bra main
g_command
    cmp.b #'g',(a1)
    bne m_command
    bsr go
    bra main
m_command
    cmp.b #'m',(a1)
    bne d_command
    bsr memory_decode
    bra main
d_command
    cmp.b #'d',(a1)
    bne h_command
    bsr d_decode
    bra main
h_command
    cmp.b #'h',(a1)
    bne main
    bsr help
    bra main
* put program code here

    simhalt             ; halt simulator

* put variables and constants here

    end    start        ; last line of source