***********************************************************
         ***********                                    ************
         ***********             Fmon V 1.8             ************
         ***********                                    ************
         ***********   (c) 1991 by Michael Schroeder    ************
         ***********                                    ************
         ***********************************************************




  The Screen Editor
========================

Cursor keys                        Move cursor
Shifted cursor keys                Move cursor to start/end of line/display
SHIFT DEL/BS / F1                  Insert space
ALT SHIFT DEL/BS / F2              Insert line
ALT DEL/BS / F3                    Delete line
Help key                           Clear to end of line
Shifted help key / F4              Clear to end of display
F9                                 Home cursor
F10                                Clear screen

You can move the cursor by clicking the mouse over the desired position.

ALT TAB                            Toggle scroll speed


C= f brings the Fmon screen in front of all other screens and 
     activates it.  ( C=  =  Left amiga key )



>>>>>
>>>>>>>    Quick reference card
>>>>>


Almost all instructions can be suspended with <CAPS LOCK> and
  stopped with <CTRL>  ( The 'g' and 'E' commands, too !!).

Optional parameters are put in [].


Strings:

  If the string contains spaces you must put it in doublequotes.
  If you want to put a doublequote in a string surrounded by
  doublequotes you must insert two of them. The doublequote at
  the end of the string can be omitted.

  Examples:
    foo
    "foo bar"
    double"quote
    "This string contains a doublequote (="")!"
    "String with no matching doublequote


Expressions:

  You can use the following prefixes:
    %   - binary
    !   - decimal
    $   - hexadecimal
    _   - contents of a register
    ' ' - ASCII literal
  Numbers without prefixes are treated as decimal unless it is
    a hexadecimal expression.

  There are the following Operators: (in order of precedence):
    Parentheses               (..)
    Minus, NOT                -    ~
    Lshift, Rshift            <<   >>
    And, Or, Exor             &    |    ^
    Multiply, Divide          *    /
    Add, Subtract             +    -

  Examples:
    1+2*3
    (1+2)*3
    1<<3  -  8
    -1&~( 1<<3 )
    2^-2
    3-~3


Devicenames:
  You can either use a string or type 0..3 as shortcuts for DF0: .. DF3:

  Examples:
    rad:
    2
    "devicename with spaces"


Hexadecimal bytes:
  Every byte consists of two digits. You can put one space between
  them.

  Examples:
    01 2a 3f
    2a 2a4d ff ff ff


Bytelists

  Strings surrounded by doublequotes and hexadecimal bytes can be mixed.

  Examples
    "trackdisk.device"00
    01 02 03"Doublequote:>""<"2a2a2a"end of string ->



  Instructions
================


(bytes):                           Hexadecimal bytes
(bytelist):                        Bytelist
(nam):                             String
(dev):                             Devicename
(s) (e) (z) (n) (b) (p):           Hexadecimal expression
(st) (en) (cyl) (head) (sec)
      (tr) (str) (etr) (exp):      Expression



a (s) (instruction)        Assemble
b (s)                      Fix bootblock checksum
c (s) (e) a|e (z) [{|} n]  Copy block [with bit-shift n]
d (s)                      Disassemble one page
d (s)#                     Disassemble starting from (s)
d (s) (e)                  Disassemble from (s) to (e)
, (s) (bytes)              Change memory (used in connection with 'd')
e (s) (bytelist)           Change memory
er                         Set/change parameters for raw disk access
es [n]                     Set/change stack size
eb|w|l (s) [n]             Show/set contents of a memorylocation
E [s]                      Execute until reaching (s)
Es                         Set slow execution mode
Ef                         Set fast execution mode
f (s) (e) (bytelist)       Fill memory block with bytelist
g (s)                      Jump at location (s)
h[e] (s) (e) (bytelist)    Hunt (e: Only even addresses)
h[e]c (s) (e) (bytelist)%(bytelist)
                           Hunt and change (e: Only even addresses)
hr (s) (e) (z)             Hunt for a PC relativ access to (z)
hu                         Upper case == lower case in hunt
hl                         Upper case != lower case in hunt
l[b|y|i] (nam) (s) [z]     Load object (nam) at (s) (relocate to (z))
                           y:Show symbols; b:create segments (for BCPL); i:info
ls (nam)                   Load object (nam). (LoadSegment)
L (nam) (s)                Load file (nam) at (s). (without relocation)
m (s) [e]                  Show memory from (s) to (e)
& (s): (bytes)             Change memory (used inconnection with 'm')
M (s) [e]                  Show memory from (s) to (e) (only ASCII)
/ (s): (ascii)             Change memory (only ASCII != '.')
o[+] (nam)                 Redirect output to file (nam). +: Append
o                          Stop redirection
O [s]                      Trace at (s)
    <SHIFT>                  Single step
    <CTRL>                   Terminate trace
    <CAPS LOCK>              Continuous trace
    r                        Show registers
    y                        Show status register
    j                        Jump until the address of the next instruction
    s                        Skip instruction
    x                        Jump until reaching the address on the stack
pe                         Redirect output to PRT:
po                         Stop redirection
pt                         Print headline
r                          Show/change registers
rc                         Clear all registers
ri [params]                Init registers, params is the parameter string
                             for the program
s (nam) (s) (e) [z]        Save program as object module ((z): relocreference)
S[+] (nam) (s) (e)         Save from (s) to (e) in file (nam). +: Append
tf [nam]                   Print file (default: ":S/STARTUP-SEQUENCE")
tl (s)                     Print list (s)
tl                         Print library list
tld                        Print device list
tli                        Print interrupt list
tlp                        Print port list
tlr                        Print resource list
tlt                        Print TaskWait list
tly                        Print TaskReady list
ts (s)                     Print segment (s)
tb (s)                     Print globals of segment (s) (BCPL!)
us (s)                     UnLoadSegment
v (s) (e) (z)              Compare two memory blocks
x                          Quit Fmon
y                          Show/change status register
[a (s) (e)                 Allocate block of memory
]a (s) (e)                 Free block of memory
[ (n) [p]                  Allocate n bytes (p=parameter for AllocMem; default: 1)
] (s) (n)                  Free memory
@                          Print disk info
@$ [nam]                   List directory (nam)
@: [nam]                   Show/set current dir
@ (nam) [parameter]        Execute CLI-command (nam)
? (exp)                    Calculate expression and print hex/dec
?% (exp)                   Calculate expression and print hex/bin
<s (s) (cyl) (head) (sec) [n]
                           Read (n) sectors from device
>s (s) (cyl) (head) (sec) [n]
                           Write (n) sectors to device
<t (s) (str) [etr]         Read tracks from device
>t (s) (str) [etr]         Write tracks to device
>f (s) (str) [etr]         Format tracks
<i [s]                     Read and check bootblock
>i [s]                     Write bootblock (Default: standard bootblock)
<r (s) (n) (tr)            Read (n) bytes of raw data from track (tr) ((s): buffer)
>r (s) (n) (tr)            Write (n) bytes of raw data to track (tr) ((s): buffer)
<c                         Mark track buffer as invalid (CMD_CLEAR)
<h [bytelist]              Search for (bytelist) on drive
# (dev)                    Change currend device (and directory)
:r [bl]                    Read DOS block (default: root block)
:w (bl)                    Write DOS block
:c                         Correct block checksum
:b [s]                     Get/set block buffer
:i                         Show DOS information about currend block
:h (nam)                   Print hash value and corresponding block number
:f                         Follow block chain
:m [st] [en]               Show block ((st) and (en) are offsets in longwords)
:di (dev)                  Inhibit device handler
:df (dev)                  Free device handler