--------------------------------------------------------------------------------------------------------------------------------------- S.I.M. Version 1.51 Command Overview --------------------------------------------------------------------------------------------------------------------------------------- a (s)(e) :show memory as ascii (from s (to e)) Monitor Function Key Overview b :list all breakpoints ------------------------------------------- bj [s] :set JSR-breakpoint at s :move cursor one step bs [s] :set stack breakpoint :move cursor to limit b [s](j) :set illegal breakpoint at s (with jokers, see below) :command history back * :make breakpoint resident :command history foreward [n] :make counter breakpoint :delete char in line ? [n] :make condition breakpoint :insert space in line j|l|r :make button breakpoint :clear screen b [s] :kill any breakpoint at s :backspace bk :kill all breakpoints :real backspace c [s][e][t](j) :compare from s to e with t (with jokers, see below) :clear line +/- [n] :compare every nth byte, as- (se) :toggle debugger on/off * :report the equal bytes, not the differing ones :switch between windows @ :execute F9 when reporting (m0=source,m1=target) :insert commandline !o|m|n :all reports to matchbuffer. (o=old ones stay, m=same :copy commandline :ones stay, n=new ones stay when finished) :first helppage c (s)(t) :(set source (and target) new and) continue compare :second helppage d (s)(e) :show disassembly of memory (from s (to e)) ------------------------------------------- e [s][d] :edit memory directly at s Graphic Searcher Function Key Overview e (s) :start to edit in loopmode (at s) ------------------------------------------- e> [s](d) :edit in loopmode :one line up f [s][e](j)[d](m) :find data d (with jokers, see 'compare') :one line down :from s to e (with mask m) :plane one word down f (s)(e) :(set start (and end) new and) continue find :plane one word up f [s][e](j) i [i] :find disassembly (with jokers, see compare) :plane one page down g [s] :go to subroutine at s :plane one page up gw [s] :prepare 'go to subroutine' to s :subtract 2 from modulo h (n) :show (nth last) history :add 2 to modulo i (n) :leave out (n) instructions :subtract 16 from modulo k [s][e] :define matchbuffer from s to e :add 16 to modulo k? :give matchbuffer measurements :clear modulo k* :init matchbuffer again :switch hires/lores k {@}[s] :show entries higher than s (report using F9) ------------------------------------------- k :show next entry Debugger Function Key Overview l (s)(e) :disassemble copperlist (from s (to e)) ------------------------------------------- l* :activate actual copperlist :one line up l? (s)(e) :search for active copperlist (from s (to e)) :one line down l= (n) :find quick copperlist (one or two) :one byte/word up m (s)(e) :show memory as hex/ascii (from s (to e)) :one byte/word down n [s][i] :assemble instructions directly at s :one page up n (s) :start to assemble in loopmode (at s) :one page down n> [s][i] :assemble in loopmode :decrease actual window o [s][e][d] :occupy memory from s to e with data d :increase actual window q :return to debug server, confirm before quit :dec. window 0, inc. window 1 r {?} :show all registers (all memories) :inc. window 0, dec. window 1 r [r]{=}[x] :set register r with value x :select asciidump s (p)(b)(s) :set display (and backup (and transfer S.I.M.)) :set/clear breakpoint at top t [s][e][t] :transfer memory from s to e at t :compare next u :do next step, don't follow jst and bsr :select disassembly v? :information about exception that forced entry :edit at startaddr of window v [x] :simulate occurrence of trap x :find next v -[x] :take trap x off stack :leave subroutine w :show state of all traps :hardcopy of screen w [x] :set or clear trap x :leave out instruction wk :kill all traps :jump to startaddr of window x :continue program, confirm before exit :select swiss/american keymap z (j) :tracestep (with jokers, see below) :select copperlist disassembly [n] :do n tracesteps :select hexdump * [x] :trace till pc=x :assemble at startaddr of window ? [n] :trace till result of formula not zero :toggle printer on/off j|l|r :trace till fire, left or right button pressed :quit to debug server c :68020 trace emulation :recalculate linkterms A [n] :set startaddress of active window :split/unsplit window B [s] :calculate and set bootchecksum :next step D (n) :show (set) active drive for trackoperations :set/clear resident breakpoint D? (n) :find track of actual drive (drive n) :exit F :list definitions of function keys :trace step F [n](c){@} :set function key n with macro c (execute directly) :set/clear JSR-breakpoint K [s] :calculate and set blockchecksum :replace top instruction by NOPs L [f][s] :load file f to memory at s :flush keystatefield P (s)(m) :show plane (start at s (init modulo with m)) :toggle keyoardbuffer killer Q :return directly to debug server :toggle Auto-Unmodify Traps S [f][s][e] :save memory from s to e as file f :indirect (windowaddr=[windowaddr]) T [n]{@} :set (smart) linkterm of active window :exdirect V (path) :list directory (press for more) :BCPL indirect X :continue program directly :enter last indirect ? [n]{,}(n) :calculate result of formula(s) :toggle F-keys on/off :get marked location >s [s][b](n) :write (n) sectors (starting with) b from s :mark location (only keypad!) t [s][t](n) :write (n) logical tracks (starting with) t from s >f (n) ;format disk (in drive n) ---------------------------------------------------------------------------------------------------------------------------------------