Club Amiga de Montreal - CAM/CAM_CD_1.iso/files/289.lha/Resource_v3.20/Manual.doc

Text File | 1989-10-07 | 160.4 KB | 3,438 lines

This document constitutes the DEMO VERSION of the current user  documentation
as of the time it was edited.  The Puzzle Factory, Inc. reserves the right to
update  this  document  without  notice.   The  only differences between this
document and the commercial manual are the lack of page numbers, and  differ-
ent section headings.  Tabs are set every 8 characters. - JL
-----------------------------------------------------------------------------


            ReSource(tm) Reference Manual V2.0

            For ReSource(tm) V3.20 and later



    Intelligent Interactive Disassembler for Amiga® Programmers



            Copyright © 1988, 1989 by Glen McDiarmid
                All Rights Reserved.

Copyright Notice

ReSource(tm) software and documentation are copyright by Glen McDiarmid.   No
part  of  the  software  or  documentation  may  be  reproduced, transmitted,
translated into other languages, posted  to  a  network,  or  distributed  by
electronic  or  other  means without the express permission of the author, or
his agents.  You have the right to make one backup copy for archival purposes.

        *****************************************************************
    * In an effort to minimize piracy, each  copy  of  ReSource(tm) *
    * sold  is  individually  assembled and linked.  Complex macros *
    * used  during  assembly  are  capable  of  creating  literally *
    * billions of unique code combinations, making it easy to trace *
    * any  illegal copies back to the original purchaser.  Software *
    * thieves will be prosecuted to the full extent of the law.     *
        *****************************************************************

Disclaimer

The Puzzle Factory, Inc. provides this program "as-is"  without  warranty  of
any  kind,  either  expressed  or implied, including, but not limited to, the
implied warranties of merchantability and fitness for a  particular  purpose.
The  entire  risk as to the results and performance of the program is assumed
by you.  Should the program prove defective, you (and not The Puzzle Factory,
Inc.)   assume  the  entire  cost  of  all  necessary  servicing,  repair  or
correction.  Further, The Puzzle Factory, Inc. does not warrant, guarantee or
make  any  representation regarding the use of, or the results of the use of,
the program in terms of correctness, accuracy, reliability,  currentness,  or
otherwise; and you rely on the program and results solely at your own risk.

The material contained in this documentation is believed to be accurate,  but
The  Puzzle  Factory,  Inc.  reserves the right to update the software and/or
documentation without notice.

Distribution

ReSource software and documentation are available from:

        The Puzzle Factory, Inc.    Glen McDiarmid
        P.O. Box 986            28 Marginson Street
        Veneta, OR 97487        Ipswich, Queensland
        U.S.A.                AUSTRALIA  4305
        [phone]            [phone]

Update Policy

Our update policy is very simple:  For updates  within  a  version  (revision
changes only), we simply ask that you return your original ReSource disk.  If
you  provide  postage  and  a return mailer, we will return it free of charge
with the latest revision of the software.  Otherwise, there will be a  charge
for media and shipping.

For major updates, a nominal fee will be  charged.   Please  contact  us  for
instructions on how to get the latest version.

Trademarks

Amiga Includes Version 1.3
Copyright 1985,1986,1987,1988 Commodore-Amiga, Inc.
All Rights Reserved.

Amiga, AmigaDOS, Kickstart, Intuition, and Workbench are trademarks of
Commodore-Amiga, Inc.

C.A.P.E. 68K, and C.A.P.E. are trademarks of Inovatronics, Inc.

FastFonts © by MicroSmiths, Blitzfonts © by Hayes Haugen.

Table Of Contents

Introduction                        xx
Getting Started                    xx
   System Requirements                 xx
   The Command Line                    xx

Part 1.  Tutorial                    xx
    1. About the User Interface            xx
    2. Definition of the Current Line          xx
    3. Disassembling a Program             xx
    4. About Menus                    xx
    5. About Keys                    xx
    6. About the Mouse                 xx
    7. About Load Files                xx
    8. About Data Files                xx
    9. About Output                    xx
   10. About Symbols                    xx
   11. Display Preferences                xx
   12. About Searches                  xx
   13. ARP and Wildcards                xx

Part 2.  Reference                    xx
   1. PROJECT MENU                    xx
     1. Abort                    xx
     2. Open load file                xx
     3. Open binary file                xx
     4. Restore file                xx
     5. Dismble memory                xx
     6. Read tracks                 xx
     7. O'lay binary image              xx
     8. Save .RS                    xx
     9. About                    xx
    10. Quit                    xx

   2. DISPLAY MENU                    xx
     1. Hiliting (menu)                xx
         1. None                    xx
         2. BSS hunks                xx
         3. DATA hunks                xx
         4. CODE hunks                xx
         5. CHIP LOAD hunks             xx
         6. FAST LOAD hunks             xx
         7. Reloc32                 xx
         8. Symbol scan                xx
         9. Data type uncertain            xx
        10. Data type known             xx
        11. Internally produced refs        xx
        12. Uninitialized data            xx
        13. Optimize override            xx
        14. DCB override                xx
        15. Optimizations                xx
        16. Symbols                    xx
     2. Set data type (menu)            xx
     3. Set numeric base (menu)            xx
     4. Decimal conversion (menu)            xx
     5. Blank lines (menu)              xx
     6. Cursor address (menu)            xx
         1. Relative                xx
         2. Absolute                xx
     7. Titlebar info (menu)            xx
         1. Filename                xx
         2. Attributes                xx
         3. Accumulator                xx
     8. Wrap                    xx
     9. Block-fill                  xx
    10. Fill-in data types              xx
    11. Fill-in D/T Fwd                xx
    12. Set counter                 xx
    13. Reset counter                xx
    14. Flip case - code                xx
    15. Flip case - data                xx

   3. DISPLAY2 MENU                    xx
     1. DCB override (Menu)                xx

   4. SYMBOLS1 MENU                    xx
     1. Set Source/dest (Menu)            xx
     2. Object (Menu)                xx

   5. SYMBOLS2 MENU                    xx

   6. OPTIMIZATION MENU                xx
     1. Local override (Menu)            xx
     2. Branches (Menu)                xx

   7. CURSOR MENU                    xx
     1. Remember                    xx
     2. Clear loc stack                xx
     3. Relative (Menu)                xx
         1. Next byte                xx
         2. Previous byte                xx
         3. Next line                xx
         4. Previous line                xx
         5. Next label                xx
         6. Previous label              xx
         7. Next symbol                xx
         8. Previous symbol             xx
         9. Next section                xx
        10. Previous section            xx
        11. Next reloc32                xx
        12. Previous reloc32            xx
        13. Next page                xx
        14. Previous page                xx
        15. Skip forward                xx
        16. Skip backward                xx
        17. Next unparsed code            xx
        18. Next D/T change             xx
        19. Previous D/T change            xx
        20. Next uncertain D/T            xx
        21. Next backward reference         xx
        22. Next hilite                xx
     4. Absolute (Menu)                xx
         1. End of file                xx
         2. Start of file                xx
         3. Forward reference            xx
         4. Second forward reference        xx
         5. Backward reference            xx
         6. Previous location            xx
         7. Specify offset              xx
         8. Specify label                xx
         9. Specify symbol              xx
        10. Specify percentage            xx
     5. Copy (Menu)                 xx
     6. Paste (Menu)                xx
     7. Swap (Menu)                 xx
     8. Scrolling speed (Menu)            xx
     9. Normal search (Menu)            xx
         1. Set search string            xx
         2. Find next occurrence            xx
         3. Find previous occurrence        xx
         4. Find nearest occurrence         xx
         5. Search this line            xx
         6. Search accumulator            xx
    10. Pattern search (Menu)            xx

   8. LABELS MENU                    xx
     1. Create single (Menu)            xx
         1. End-of-line comment            xx
         2. Full-line comment            xx
         3. Label                    xx
         4. Label - fwd ref             xx
         5. Symbol                  xx
         6. Symbol - dest                xx
     2. Edit single (Menu)              xx
     3. Replace single (Menu)            xx
         1. Label                    xx
     4. Remove single (Menu)            xx
         1. Label                    xx
         2. Symbol                  xx
         3. End-of-line comment            xx
         4. Full-line comment            xx
         5. All                    xx
     5. Create multiple (Menu)            xx
         1. Reloc32                 xx
         2. All                    xx

   9. LOCAL MACROS MENU                xx

  10. GLOBAL MACROS MENU                xx

  11. STRINGS MENU                    xx
     1. Get (Menu)                  xx
         1. Label                    xx
         2. Symbol                  xx
         3. Symbol - dest                xx
         4. Symbol value                xx
         5. Symbol value - dest            xx
         6. End-of-line comment            xx
         7. Full-line comment            xx
         8. Search string                xx
         9. Filename                xx
        10. Save .asm name              xx
        11. Save .RS name                xx
        12. Macros filename             xx
        13. Keytable filename            xx
        14. Cursor longword             xx
        15. Cursor offset                xx
        16. Accumulator length            xx
        17. Partial save size            xx
        18. File                    xx
        19. Attribute bits              xx
     2. Put (Menu)                    xx
         1. Label                    xx
         2. Attributes                xx
         3. Base register                xx
     3. Edit functions (Menu)            xx
         1. Clip start                xx
         2. Clip end                xx
         3. Prepend                 xx
         4. Append                  xx
         5. Reverse                 xx
         6. Lower case                xx
     4. Operand size (Menu)             xx
     5. Accumulator (Menu)              xx
     6. Maths functions (Menu)            xx
         1. Increment                xx
         2. Decrement                xx
         3. Add                    xx
         4. Subtract                xx
         5. Multiply                xx
         6. Divide                  xx
         7. Negate                  xx
         8. Logical NOT                xx
         9. Logical AND                xx
        10. Logical OR                xx
        11. Exclusive OR                xx
        12. ROR                    xx
        13. ROL                    xx
     7. Define string (Menu)            xx
     8. Swap with buffer (Menu)            xx
     9. Input buffer (Menu)             xx
    10. Output buffer (Menu)            xx

   12. SPECIAL FUNCTIONS MENU              xx
     1. Repeat last command             xx
     2. Dos Command                 xx
     3. Zap                     xx
     4. Screen (Menu)                xx
     5. Set task priority                xx
     6. Origin (Menu)                xx
     7. Convert xx(An) EA's (Menu)          xx
         1. Disable                    xx
     8. Specify Base Register (Menu)        xx
     9. Convert specific EA's (Menu)        xx
    10. Data type set (Menu)            xx
    11. Convert to.. (Menu)             xx
    12. Reloc32 (Menu)                xx

   13. SAVE MENU                    xx
     1. O/P Directory                xx
     2. Partial save (Menu)             xx
         1. Reset start                xx
         2. Set start                xx
         3. Set end                 xx
         4. Reset end                xx
     3. Save binary image (Menu)            xx
     4. Save .asm (Menu)                xx
     5. Calculate .asm size (Menu)          xx
         1. All                    xx
         2. Partial                 xx
     6. Save to memory (Menu)            xx
     7. Save tracks (Menu)              xx
     8. Save screen                    xx
     9. Tabs (Menu)                 xx
    10. Symbol table (Menu)             xx

   14. OPTIONS1 MENU                    xx
     1. Show offsets (Menu)             xx
     2. Display beep (Menu)             xx
     3. User feedback (Menu)            xx
     4. Feedback Delays (Menu)            xx
     5. Labels (Menu)                xx
     6. Hidden labels (Menu)            xx
     7. Symbols (Menu)                xx
     8. End-of-line comments (Menu)         xx
     9. Full-line comments (Menu)            xx
    10. Chip-load info (Menu)            xx
    11. Section statements (Menu)            xx
    12. End statement (Menu)            xx
    13. DCB statements (Menu)            xx
    14. Reference recognition (Menu)        xx

   15. OPTIONS2 MENU                    xx
     1. Short branches (Menu)            xx
     2. Separate labels (Menu)            xx
     3. Label colons (Menu)             xx
     4. Leading zeroes (Menu)            xx
     5. Assembler (Menu)                xx
         1. Metacomco                xx
         2. Cape                    xx
         3. Capatch                    xx
     6. Auto labels (Menu)                xx
     7. Verbose saves (Menu)            xx
     8. Multiple constants (Menu)            xx

   16. KEY BINDINGS MENU                xx

   17. Credits                     xx


Introduction

ReSource was originally just an interactive disassembler, but  Version  3  is
much  more than this.  Because ReSource can get its input from a file, track,
or memory, and output all or part to any of these, it is more  of  a  general
purpose  hacking  tool.  It can be used to browse through files, without ever
bothering to save anything, just to find out what is inside.  It  also  knows
quite a bit about AmigaDOS(TM) and the Amiga® OS.  This built-in intelligence
will  save  you  a  great deal of time when disassembling files.  ReSource is
also blindingly fast.  It is written entirely in assembly language, and  does
all text rendering using its own special internal routines.

When you run ReSource, you can supply the name of the file  to  load  on  the
command line:

        1> [run] ReSource c:popcli

If you do not specify something on the command line for ReSource to work  on,
it  will  default to one longword of memory at location zero.  Alternatively,
you can wait until ReSource starts running, and select a file using  the  ARP
file  requester.   For  full  specifications  on command line parameters, see
below.  Providing that there is enough memory available,  you  can  load  ANY
file  into  ReSource.  If ReSource recognizes it as a load file (one that can
be run; an executable program), it will load the  program,  and  perform  any
necessary  relocation,  etc.,  as if the program is going to be actually run.
If the file that you request loaded is not a load file,  it  will  be  loaded
"as-is".   Load  files may be also loaded "as-is", by using the "Load binary"
function, in the "PROJECT" menu.  This will give  you  access  to  the  hunk,
symbol, relocation and debug information, which otherwise gets stripped  when
the  program is loaded into memory.  Libraries, device drivers, and fonts are
also load files,  which  means  that  you  can  disassemble  them,  save  the
assembler source code, modify them, and re-assemble them.

Getting Started

If the version/revision of ReSource you have purchased  is  higher  than  the
version  indicated  on  the  title  page  of  this  manual,  please  refer to
"History.doc", an ASCII file on your  ReSource  disk  containing  incremental
documentation.   A  "ReadMe"  file may also be present containing information
about your particular release of ReSource.

System Requirements
ReSource is designed to work on any properly  configured  Amiga®  500,  1000,
2000, or 2500.

Kickstart V1.2 or higher is required.

Because ReSource uses functions in the "ARP" library, you must have the  file
"arp.library"  in your "LIBS:" directory when you run ReSource.  This file is
supplied with the commercial version of ReSource, and is available from  most
BBS's.  The version of "arp.library" must be 34 or higher.

While ReSource will run on a 512K Amiga®, you will be severely limited in the
size of programs that you may disassemble.  One megabyte  of  RAM  should  be
considered the minimum necessary to disassemble all but the smaller programs,
and  you  will  need  1  1/2  to  2 megabytes of RAM if you want to work with
programs larger than 30-40K.

To  make  the  best  use  of  the  menus,  run  FastFonts©,  or  Blitzfonts©.
Otherwise,  scanning through the menus will be very sluggish due to the large
number of sub-items.

The Command Line
When you run ReSource from a  CLI,  you  can  supply  a  parameter,  so  that
ReSource  gets  its  input right away.  The following parameters are accepted
with the following meanings:

   1> ReSource ?
       (Using "?" as the first parameter on the command line will display the
    parameter syntax requirements, then exit immediately)

   1> ReSource <ProgName>
    (The executable program <ProgName> will be loaded as a load file ONLY
    if it is a load file.  Otherwise it will be loaded as a binary file.
       Corrupted load files may have to be loaded as a binary image)

   1> ReSource *b <FileName>
    (The file <FileName> will be loaded as a binary image)

   1> ReSource *m <Sloc> <Eloc>
    (Load memory, from location <Sloc> to location <Eloc>)

   1> ReSource *DFn: <Scyl> <Ecyl+1> [#sec] [Offsec]
    (Load from drive DFn: starting at cylinder <Scyl> and continuing to
    <Ecyl+1>.  The default is to read complete track(s).  This may be
    modified by the next two optional parameters:  The fourth parameter
    specifies that ReSource should read [#sec] sectors, and the fifth
    parameter specifies that these sectors should start at [Offsec]
    sector.)

   1> ReSource *
    (Kickstart(TM) as it appears in memory is loaded)

   ReSource will accept "-I" or "-i" as the first parameter  on  the  command
   line.  This will force ReSource to use an interlaced screen.

Examine the following examples:

   1> ReSource c:popcli
    (The program "popcli" will be loaded as a load file, from the C: device)

   1> ReSource libs:arp.library
    (Load the file "arp.library", from the LIBS: device, as a load file)

   1> ReSource *b c:popcli
    (The file "popcli" will be loaded as a binary image, from the C: device)

   1> ReSource *m $FC0000 $FD0000
    (The first 64K of Kickstart(TM) will be loaded)

   1> ReSource *DF0: 0 0 2
    (The boot sectors from DF0: will be loaded, a total of 1024 bytes.
    Use this to check for/disassemble viruses)

   1> ReSource *DF1: 40 41
    (The entire directory cylinder from DF1: will be loaded, 11K in all)

   1> ReSource *m $400 $800
    (For most Amigas®, this will load the Exec library.  Some shells will
    eat the "$" character.  If this is a problem, ReSource will treat the
    "C" standard, "0x", as equivalent)

   1> ReSource *m 0 1
    (Load one byte of memory, at location zero)

ReSource may be "Run" without problem, and multitasks beautifully.  It will
even allow you to change the task priority from inside ReSource.

Do not load ReSource from the Workbench(TM).


Tutorial
1.1    About the User Interface
Because of the large number of functions in ReSource, it was decided  to  use
one-and  two-character menu names, so that more menus could be used.  Looking
from the left, the first menu is "P", which stands for "PROJECT".   The  real
menu  name  is  directly  under  the  one-or  two-character  name, in capital
letters, so should be fairly easy to find.  In all future reference to menus,
the full menu name will be used.

In the reference section, a heading ending with a ":"  refers to  the  lowest
hierarchical  menu  item  for that function.  In some cases, the heading will
end with a "/:"  to indicate that there are several  sub-items  with  related
functions being discussed under that heading, e.g.:

    DISPLAY/Block-fill: Refers to a single item.
    DISPLAY/Wrap/:      Refers to a group of sub-items.

Functions will be referenced by menu, rather than by key name.  For  example,
the  "Quit"  function  will  be described as "PROJECT/Quit".  The function to
restore the current file will be "PROJECT/Restore".  You will  find  both  of
these  under  the  "PROJECT"  menu.   Functions  in  sub-menu  boxes  will be
described in a similar way, e.g., "SAVE/Tabs/Spaces".  Because  any  key  can
have any function bound to it (except "PROJECT/Abort"), key usage will not be
discussed,  when  referencing  functions.   However, to make it easier to get
started, some key bindings will be present, even without loading a  keytable.
Note that loading a keytable may override these keybindings:

    up arrow        scroll up one line
    down arrow        scroll down line line
    shift-up arrow      page backward
    shift-down arrow    page forward
    right arrow        forward reference
    left arrow        previous location
    right-Amiga Q        quit
    right-Amiga O        open a file

To rebind a key, select "KEY BINDINGS/Rebind key" from the  menus,  select  a
function  from  the  menus to have bound, then press the key that you want it
bound to.  You can overwrite key bindings if you want.  When done, you should
save the keytable as "S:RS.keytable".  This can be  done  by  selecting  "KEY
BINDINGS/Save"  from the menus.  Even both of these functions can be bound to
a key, in fact the only function that is not practical to rebind is "PROJECT/
Abort", which is always bound to right-Amiga A.

A sample keytable is provided for your use.  The key mapping used in the file
is described in a file named "MyKeyBindings.doc".  Alternately, you  may  use
the  supplied  program  "ShowKeys"  to  read  your S:RS.keytable at any time.
ShowKeys may be used without parameters or it will accept the pathname  of  a
keytable  as  an optional parameter.  You may want to redirect output to your
printer for hardcopy.

1.2    Definition of the Current Line
Many functions in ReSource operate only on the current line.   Because  there
is no real "cursor", it is necessary to define the "current line":

The "current line" is the top line, as you see it on ReSource's screen.

If there is a section statement (e.g., SECTION BSS) to be  displayed  at  the
cursor  address,  this will be shown before any other text, and will force it
to be shown on the next  line  down.   If  this  is  not  the  first  section
statement  in  the  program, there will be an extra blank line, which will be
shown before the section statement.  After the section statement, and  before
the  rest  of  the  line,  one  or more "full-line comments" can be attached.
Immediately after the cursor line, any "hidden  labels"  will  be  shown.   A
hidden  label may also have a full-line comment attached, which will be shown
immediately before it, but after the cursor line.  Note that in this example:

            SECTION prog000000,CODE    ; Section statement
   ; This is a full line comment!
   ; This is another full line comment!
            MOVE.L  D1-D4/A2-A6,-(SP)    ; Line of code

all the above text is one line.  Whenever you scroll up or down a  line,  all
parts  of  the  "current  line"  will scroll together.  To put it simply, the
first "real" line of code or data in the window is the current line.

1.3    Disassembling a Program
To disassemble a program is to interpret what went into the program  to  make
it work.  It can be a very complex and trying task, but with practice one can
become quite adept at it.  There are many different and separate things to do
when  disassembling.   One of the most important is to separate the code from
the data.  There is only one part of a load file that  is  guaranteed  to  be
code, and that is at the very start.

One very useful function of ReSource is its ability to scan  lines  of  code,
looking  for  references  to  other  parts of the program being disassembled.
When a reference is made, it creates a label at that address, which  will  be
used in all future references to that part of the program.  More importantly,
ReSource  can determine what type of data is being referenced, and be correct
(almost) every time.  If you intend to  reassemble  the  source,  you  should
still  verify  it before saving, as mistakes will occasionally occur.  Before
ReSource makes a decision about what type of data  is  being  referenced,  it
examines  many  different pieces of information that are available, including
the actual instruction that made the reference.  There  are  a  few  ways  of
getting  ReSource  to  scan  lines of code.  The simplest way is by using the
"LABELS/Create single/Label - fwd ref".  This scans only  the  current  line,
and does NOT advance the cursor.

If a line of code makes a reference to somewhere  within  the  program,  that
HASN'T  got  a  label  yet,  it  will  be shown as some offset from the label
"START", which is imagined to be (but is not actually, unless YOU  have  done
it)  attached  to  the  first  byte of the program.  You could create a label
called "START", at the first byte of the  program.   However,  when  you  re-
assemble,  there  is a chance that some different length instructions will be
generated.  This will make all references past  the  first  different  length
instruction inaccurate.


Another way to get ReSource to scan lines of code is with the  "LABELS/Create
multiple/ALL".   This  function  scans  the  current  line.   If  ReSource is
reasonably sure that it is code, it will scan the line, and move  on  to  the
next line.  This process will repeat until either the end of the section,  or
until  a non-conditional branch, unless immediately followed by certain code.
After executing this function, if the cursor isn't at the end  of  file,  and
there  is  more  code  that  hasn't been "scanned" yet, you can scroll to the
start of the next block of code, or use "CURSOR/Relative/Next unparsed code",
and execute this function again, repeating until all code in the program  has
been  scanned.   At this point, most references within the program will be to
labels, and not use the "START+$xxxx" type of reference.   To  make  sure  of
this,  you  can  set  up  a  search  for "START+", and perhaps scan the lines
individually.  A better way to do this is to use "SAVE/Calculate  .asm  size"
and then use sucessive iterations of "CURSOR/Absolure/Previous location",  as
a  number  of  error  types that will interfere with assembly are pushed onto
the location stack by this function.  Note that the number of errors will  be
limited by the size of the location stack: 256.

There is still another way to scan code, and it may  be  best  when  you  are
first  starting  to  use  ReSource  and  haven't yet learned when to scan the
entire program, and when not to.  First, make the top of the file the current
line.  Then, hold down the left-Amiga key, and while also  holding  down  the
left  mouse  button, scroll through the file until you come to the end.  This
sequence calls the function "LABELS/Create single/Label - fwd ref" repeatedly
and generates labels for all forward references within the file.

When all code in a program has been "scanned", the  next  function  that  you
will  generally  want  to use is "DISPLAY/Fill-in data types".  This function
does two passes over the entire program, and does NOT shift the cursor.   The
first pass looks at what data types have been set, and makes some assumptions
about all places in the program where the data type has not been specifically
set.   When  you "Set data type", you are telling ReSource "this is CODE", or
"this is ASCII", or "these are to be displayed as  bytes",  etc.   Generally,
this  data  type  will be assumed from this byte forward, until the next byte
that has had the data type specifically set.  Many conditions are tested when
making decisions about what type of data is where.  Providing that  you  have
"scanned"  all  code in the program, after executing the "Fill-in data types"
function the resulting source code will look like source code should look.

"Fill-in data types" is used to let ReSource know how far back  to  go,  when
scrolling  backwards.   String  lengths  are also determined.  When you first
load in a file, all line lengths  are  set  to  two  bytes.   When  scrolling
forward,  most  things  will  be  shown  properly  anyway,  but if you scroll
backwards before first doing a "Fill-in data types", a jarring  display  will
result.

At this point, if you output to a ".asm"  file,  it  will  probably  be  good
enough  to  re-assemble.  However, most people will want to examine the file,
and make it more readable, especially if the program needs  to  be  modified.
An  excellent  place  to  start  is  by finding where any libraries are being
opened, finding where the library base is being stored, and giving meaningful
names to these data storage locations.  Assume that the following code  is  a
small part of a program:

            MOVE.L  4,A6
            LEA     START+$06B6(PC),A1
            JSR     -$0198(A6)
            MOVE.L  D0,START+$0C36
            BNE.S   START+$06AE
            MOVE.L  #$00038007,D7
            JSR     -$006C(A6)
            BRA.S   START+$06B2

            JSR     START+$0142
            ADDQ.W  #8,SP
            RTS

            BCC     START+$0727
            ????
            BGE     START+$0725
            BHI     START+$0730
            BSR     START+$0732
            ????

After scanning all code in this program, it would look like this:

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     -$0198(A6)
            MOVE.L  D0,lbL000C36
            BNE.S   lbC0006AE
            MOVE.L  #$00038007,D7
            JSR     -$006C(A6)
            BRA.S   lbC0006B2

   lbC0006AE        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

The astute will have noticed that because the A6  register  was  loaded  from
location  4,  it  will  point to the Exec library base.  Therefore, the third
line of this block of code is a call to somewhere in the  Exec  library.   By
scrolling so that this line becomes the top line on the screen, and selecting
the "SYMBOLS 1/Libraries/Exec", our block of code will now look like this:

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,lbL000C36
            BNE.S   lbC0006AE
            MOVE.L  #$00038007,D7
            JSR     -$006C(A6)
            BRA.S   lbC0006B2

   lbC0006AE        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

Checking the documentation for the "OldOpenLibrary" Exec call  will  tell  us
that on return, the D0 register will contain the library base for the library
just opened, if successful.  Because we know that it was the DOS library that
was  opened, the label "lbL000C36" referenced on the fourth line could now be
called "Dos_Base", instead of "lbL000C36":

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,Dos_Base
            BNE.S   lbC0006AE
            MOVE.L  #$00038007,D7
            JSR     -$006C(A6)
            BRA.S   lbC0006B2

   lbC0006AE        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

If the D0 register DID contain a non-zero value, it means that  "dos.library"
did  open  successfully,  and the following conditional branch WILL be taken.
Where this branches to, is labeled "lbC0006AE".  A better name for this might
be "OpenedOK".  Scroll so that the line "lbC0006AE JSR lbC000142" is  on  the
top  line  of  the  display,  and  select "LABELS/Create single/Label".  When
asked, type in "OpenedOK":

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,Dos_Base
            BNE.S   OpenedOK
            MOVE.L  #$00038007,D7
            JSR     -$006C(A6)
            BRA.S   lbC0006B2

   OpenedOK        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

If the call to "OldOpenLibrary" was unsuccessful, the  branch  on  the  fifth
line  would  NOT  be taken.  In this case, the D7 register is loaded with the
value "$38007", and a call is made to the  subroutine  at  offset  -$6C  from
where the A6 register is currently pointing.  We do know that the A6 register
was  pointing  to the Exec library base before, and we also know that none of
the code executed so far has destroyed the value in  A6,  so  we  can  safely
assume  that  A6  still  points to Exec library base.  Hence, by scrolling so
that the seventh line of this block is on the top line of  the  display,  and
selecting "SYMBOLS 1/Libraries/Exec" again, our block will look like this:

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,Dos_Base
            BNE.S   OpenedOK
            MOVE.L  #$00038007,D7
            JSR     _LVOAlert(A6)
            BRA.S   lbC0006B2

   OpenedOK        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

After reading the documentation for the Exec call "Alert", we find  out  that
on entry, the D7 register should contain a number representing an alert code.
By scrolling so the the line "MOVE.L #$00038007,D7" is on the top line of the
display, and selecting "SYMBOLS 2/A-B/Alert codes", our block will  now  look
like this:

            MOVE.L  4,A6
   lbC000694        LEA     doslib.MSG(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,Dos_Base
            BNE.S   OpenedOK
            MOVE.L  #AT_Recovery!AG_OpenLib!AO_DOSLib,D7
            JSR     _LVOAlert(A6)
            BRA.S   lbC0006B2

   OpenedOK        JSR     lbC000142
   lbC0006B2        ADDQ.W  #8,SP
            RTS

   doslib.MSG      dc.b    'dos.library',0

Examining the include file "exec/alerts.i" will tell us that "AT_Recovery" is
used for recoverable alerts, "AG_OpenLib" means  that  a  library  failed  to
open, and "AO_DOSLib" tells us which library is in question.  Because this is
a  recoverable  alert, the following line of code ("BRA.S lbC0006B2") WILL be
executed, in which case we might change the label  "lbC0006B2"  to  something
like  "DosDidntOpen",  or  "NoDosAvailable".  This is important, since if any
other code in this program makes a reference to one of  the  labels  that  we
have changed, it too will use the new name.  In this example, another part of
the program that WAS:

   lbC0007DE        MOVE.L  4(SP),D1
            MOVE.L  lbL000C36,A6
            JMP     -$0024(A6)

   lbC0007EA        MOVE.L  D4,-(SP)
            MOVEM.L 8(SP),D1-D4
            MOVE.L  lbL000C36,A6
            JSR     -$008A(A6)
            MOVE.L  (SP)+,D4
            RTS

   lbC0007FE        MOVE.L  4(SP),D1
            MOVE.L  lbL000C36,A6
            JMP     -$007E(A6)

now will be shown as:

   lbC0007DE        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     -$0024(A6)

   lbC0007EA        MOVE.L  D4,-(SP)
            MOVEM.L 8(SP),D1-D4
            MOVE.L  Dos_Base,A6
            JSR     -$008A(A6)
            MOVE.L  (SP)+,D4
            RTS

   lbC0007FE        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     -$007E(A6)

After using "SYMBOLS 1/Libraries/Dos" a few times, it would become:

   lbC0007DE        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     _LVOClose(A6)

   lbC0007EA        MOVE.L  D4,-(SP)
            MOVEM.L 8(SP),D1-D4
            MOVE.L  Dos_Base,A6
            JSR     _LVOCreateProc(A6)
            MOVE.L  (SP)+,D4
            RTS

   lbC0007FE        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     _LVOCurrentDir(A6)

To continue, we would replace a few labels:

   CloseSUB        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     _LVOClose(A6)

   CreatePrSUB     MOVE.L  D4,-(SP)
            MOVEM.L 8(SP),D1-D4
            MOVE.L  Dos_Base,A6
            JSR     _LVOCreateProc(A6)
            MOVE.L  (SP)+,D4
            RTS

   CurDirSUB        MOVE.L  4(SP),D1
            MOVE.L  Dos_Base,A6
            JMP     _LVOCurrentDir(A6)

Okay, so far so good.  Now, where the line:

            JSR     lbC0007FE

used to be, it would be replaced by:

            JSR     CurDirSUB

This happens automatically, whenever you  replace  any  label.   The  process
helps itself; starting is hardest, the rest come fairly easily.

In general, where a label is used, if you have any idea of what is  happening
at  all,  you should replace it with a label that will remind you of what the
code is doing.  It doesn't matter what name you use (as long as it is a legal
label for the assembler that you plan to use); if necessary you  can  replace
it  with  something  better  later  on.   Anything nominally mnemonic will be
superior to a "shop" label while you're trying to understand the code.

One last point that needs to be covered briefly is the cursor location stack.
When certain functions are called, or  whenever  YOU  want  to,  the  current
cursor  loacation  may  be  pushed onto ReSource's location stack.  This will
allow you to easily move around in code.  Returning to our  example  program,
place  the  second  line,  at  label  lbC000694, on the cursor line, and then
select "CURSOR/Absolute/Forward reference".  The last line will  move  up  to
the  cursor line.  You can now use "LABELS/Create single/Label" to change the
name "doslibrary.MSG" into something more meaningful,  like  "DosName".   Now
use  "CURSOR/Absolute/Previous  location", and you will find yourself back at
the second line of the file, with a new name for the first operand.  Normally
you will just use the right-Arrow and left-Arrow keys for these two functions
rather than using the menus.

            MOVE.L  4,A6
   lbC000694        LEA     DosName(PC),A1
            JSR     _LVOOldOpenLibrary(A6)
            MOVE.L  D0,Dos_Base
            BNE.S   OpenedOK
            MOVE.L  #AT_Recovery!AG_OpenLib!AO_DOSLib,D7
            JSR     _LVOAlert(A6)
            BRA.S   NoDos

   OpenedOK        JSR     lbC000142
   NoDos        ADDQ.W  #8,SP
            RTS

   DosName        dc.b    'dos.library',0

1.4    About Menus
The menus in ReSource fully support drag-selecting, and  multiple  selection.
Many  options  within  ReSource have a "checked" menu, which in most cases is
"hot".  This means that even though ReSource may be busy doing something,  if
you make a selection in the menus that effects the current operation, it will
take  effect  IMMEDIATELY.   For  example,  while saving the source code to a
".asm" file, if you select "OPTIONS 1/Symbols/Off", from that point  on,  the
output file will not show any symbols.

Similarly, if you selected "OPTIONS 1/DCB statements/On" during the save, DCB
statements would be used in the output file from that point on.  This feature
is handy during the execution of macros, as you will see in  the  section  on
macros.

1.5    About Keys
As mentioned previously, any function except the "PROJECT/Abort" function can
be bound to any key.  All non-qualifier keys can be used, with or without any
of the following combinations of qualifier keys:

    shift - left or right, or caps lock, all treated as one
    alt   - left or right, both treated as one
    ctrl    shift-ctrl    alt-ctrl    shift-alt    shift-alt-ctrl
    left-Amiga    right-Amiga

For example, in order to rebind the "Open load file" function to  right-Amiga
O,  select "KEY REBINDINGS/Rebind key", then select "PROJECT/Open load file",
then press and hold down the right-Amiga key, press and release the "O"  key,
and  finally release the right Amiga key.  From then on, instead of using the
menus for opening a file, you could just press right-Amiga O.  To  make  this
binding  permanent,  you  would  save  the  current  bindings  to  a ReSource
KEYTABLE.  Select "KEY BINDINGS/Save", and type in the name of a file to save
the key bindings to.  If you want these bindings used every  time  you  start
ReSource, you need to save the key bindings as "S:RS.keytable".

With many programs, when you press and hold down a key, for example the down-
arrow key, to scroll down, a backlog of key  repeats  will  form,  making  it
difficult  to  stop  the  scrolling,  even after releasing the offending key.
Where this would be a problem, the repeats are flushed,  making  key  control
better.

1.6 About the Mouse
ReSource uses some of the most sophisticated scrolling  techniques  available
to move smoothly through a file.  The mouse may be used to set both scrolling
direction  and  speed.   Press  and hold down the left mouse button while the
pointer is near the vertical center of the ReSource screen.  Gently move  the
mouse  toward  the  bottom  of  the screen, and text will start moving up the
screen continously.  If you move the mouse toward the top of the screen, text
will move down.  The further you move the mouse pointer vertically from where
you started, the greater the scrolling speed.

At the slowest rate, the display is shifted one pixel at a time followed by a
short delay.  The second slowest rate is the same with no delays.  The  third
moves  2 pixels at a time, fourth slowest is 4 pixels at a time, and the next
rate is 8 pixels at a time.  It is possible to select any of these  rates  by
using  menus/keys.  Mouse scrolling also lets you scroll at rates faster than
8 pixels at a time.  By moving the mouse vertically  further  away  from  the
point  where the left button was pressed, up to several hundred lines of text
will be skipped between display refreshes.

Several functions can be used during mouse scrolling; one of the most  useful
is  automatic label creation.  To do this, hold down the left-Amiga key while
scrolling.  This gives  close  control  over  the  disassembly  process;  you
examine the code as it scrolls up, and ReSource creates the necessary labels.
Sometimes code will appear which really should be displayed as ASCII.  Do not
allow  ReSource  to  create labels from this "code".  This is one of the main
reasons that most people examine the code while creating labels; when you see
something that isn't being displayed correctly, fix it, or just skip  it  for
now.   It  will  probably  be  fixed later when it is referenced by some code
further on in the program.  A better way to parse code  is  to  use  "LABELS/
Create multiple/All" and "CURSOR/Relative/Next  unparsed  code"  alternately.
This is both quicker and safer than using the process outlined above.

If you are unsure  which  display  method  (code/ASCII/bytes/words/longwords)
should  be  used for any part of a file, you can have the display lock on one
of these display types temporarily.  While holding  the  left  mouse  button,
even  while  scrolling, press and hold down the CTRL key.  Everything will be
shown as code, regardless of how it is normally shown.  Press the  left-SHIFT
key, and everything will be shown as bytes.  Similarly, the left-ALT key will
give you ASCII, left-SHIFT and left-ALT together will give you words, and all
three  (left-ALT, left-SHIFT, and CTRL) will display everything as longwords.
If you wish to change the display type (data  type)  permanently,  you  would
normally  use  the  "DISPLAY/Set  data  type/" functions, but while using the
mouse and the above qualifier keys, it is also possible to set the data  type
by pressing the right mouse button.  Be sure that the location where you want
the new data type to start is at the top of the screen.

When the left mouse button is held down, as well as the ctl key, symbols  and
full-line  comments  are temporarily disabled, as well as optimization.  This
allows you to quickly see the value of any symbols present in code.

While using the mouse to scroll, if the left Amiga key is held  down,  labels
are created using forward references.  If the left mouse  button  is  pressed
while  the  pointer  is  within 3 pixels of the right screen border, ReSource
will assume that you are holding the left-Amiga key down, until you  let  the
left  mouse  button  go.   This makes it easy to create labels single-handed.
You don't have to keep the pointer on the right  while  scrolling,  only  its
position when you actually press the LMB is important.

If you press the left-Amiga key while in one-button-parse, and  then  release
it, ReSource will again test for the mouse position.

If ReSource's window is selected (activated) when the intuition pointer is on
the far left of the screen, a screen update will *not*  be  performed.   This
may  be  necessary  after  saving  to  a ".asm" file, when the source profile
information is to be saved to a file.

1.7    About Load Files
There are six functions that deal with loading.  These are:

    "PROJECT/Open load file"
    "PROJECT/Open  binary  file"
    "PROJECT/Restore"
    "PROJECT/Dismble memory"
    "PROJECT/Read tracks"
    "PROJECT/O'lay binary image"

The first of these will examine the start of the file, to check if it  is  an
Amiga®  load  file.   Amiga®  load  files  include  all  executable  programs
(excepting those using overlays), libraries, device drivers, and fonts.  With
this type of load, ReSource examines, then strips out, all hunk,  relocation,
and  debug  symbol  information.   This  information  is not lost, it is used
internally to ReSource, to make better decisions about data type setting, etc.

ReSource was designed with speed as the PRIMARY objective.  It does  not  use
memory  sparingly.   To load a file, ReSource sometimes requires a great deal
of memory, especially when disassembling large  files.   For  any  file,  the
approximate  memory  requirement  will  be 6 to 10 times the file size.  As a
further requirement, much of this is required to be contiguous.  ReSource  is
NOT practical on a 512K machine.  If you have 2 Megs of fast memory, you will
be  able  to  disassemble most programs.  Users with 1 Meg machines will feel
constrained when attempting to disassemble  30-40K  executables,  but  should
have little difficulty with programs smaller than this and most C: programs.

Any debug symbols will be shown as labels in their proper places  within  the
program,  and  even the relocation information is available.  For example, if
you select "DISPLAY/Hiliting/Reloc32", any relocated  pointers  are  hilited.
When  disassembling,  this  information is quite valuable, as it helps you to
tell where code is, where tables of pointers are, etc.  ReSource  also  makes
heavy  use of this information in many functions, and this is one of the main
reasons that it is so accurate in determining  data  types,  especially  when
telling  code  from  ASCII.   The  hunk  information  also  tells you whether
something was meant to load into chip memory, which immediately lets you know
that it is probably graphics or sound data.

When a file with overlays is loaded, only the root node is loaded.  When this
happens, the user is  notified  of  this,  and  must  select  "okay"  on  the
requester before ReSource will continue.

The "LABELS/Create multiple/Reloc32" function is called  automatically  after
every "Open load file", unless there was no reloc32 table in  the  file,  and
providing  that  this is not overridden by "OPTIONS2/Auto labels/OFF" option.
It may be stopped by pressing rAmiga-A, anyway.

If a program has the debug symbols left in it,  it  makes  the  disassembling
process  much  easier.  When the file is loaded, for each debug symbol found,
if it is nine characters long, starts with "lb", and is followed by an  upper
case "A", "B", "C", "L", or "W", at the point that the label is attached, the
data type will immediately be set to ASCII, bytes, code, longwords, or words,
respectively.   Additionally,  local  labels, of the "1$" variety, and labels
ending in "SUB" are recognized as code,  and  labels  ending  in  ".MSG"  are
recognized as ASCII.

Thus, if you have to disassemble a program that you previously  disassembled,
then  reassembled, most of the data types will be set for you, as the file is
loaded.

There is one other type of file that can be  loaded  in  using  "PROJECT/Open
load file", the ReSource data file, or ".RS" file.  It is discussed in detail
in the section entitled, "About Data Files".

If  ReSource   cannot  load  the  file  as  an  Amiga®  load  file,  it  will
automatically  attempt to load it as a binary file, without looking for hunk,
relocation, and debug symbol information.  If it is an Amiga® load file,  but
has  been corrupted, ReSource will refuse to load it.  You can still load it,
however, using the "PROJECT/Load binary file" function.  With this  function,
you can load any file that will fit into available memory.  Keep in mind that
ReSource will require memory 6 times the file size, of which 4 times the file
size must be contigous.  In the case of normal Amiga®  load  files,  you  may
wish to examine the hunk information in them.

The "PROJECT/Restore" function will attempt to load the same  file  that  you
loaded  last, this is useful when you make a mess of things, and just want to
start again.  The restore function is only usable when you loaded a file, NOT
when you disassemble memory directly, or read  tracks  from  a  floppy  disk.

When you are asked to select a file using the file requester, you may  cancel
the  load  immediately,  and  retain the current file.  If you hit the "okay"
gadget, and the file is not successfully loaded, (perhaps because it  is  too
large  for  available  memory), you have lost your current file.  If, at this
time, you select "cancel", ReSource will give you the chance to quit, in case
you cannot or are unwilling to load any file.  If you  don't  quit,  ReSource
will  again  offer  the  file  requester,  where  you  may  select  a file to
disassemble.

1.8    About Data Files
The ReSource data file, or ".RS" file, is a file containing most of the  data
areas  internal  to  ReSource,  while any particular file is loaded.  This is
used to save your work, and later load it back  into  ReSource,  so  you  can
continue  disassembling a program some other time, without losing any of what
you have already done.  You could even send this file to a  friend,  assuming
that  they  have  purchased  ReSource.  This should be particularly useful in
disassembling  the   Amiga®   operating   system,   (Kickstart(TM)),  as  the
Kickstart(TM)  ".RS"  file  does not contain any copyrighted material, and so
can be legally distributed.  This is only true for Kickstart(TM) ".RS" files.
The executable must be cleared before you distribute ".RS" files of any other
program that is not in the Public Domain.  See "PROJECT/O'lay  binary  image"
in  the  reference section.  Be aware that you will require at least two megs
of fast memory to load a Kickstart(TM) ".RS" file.  Even the cursor  position
is  saved  in  a  .RS  file, making it easy for you to remember what you were
doing last when you saved the ".RS" file.  The ".RS" file is only  recognized
as  a  ReSource  data  file  when  using  "PROJECT/Open  load  file", not the
"PROJECT/Open binary file", although you may load it as a binary image if you
want.

It is the content of the file that allows ReSource to recognize a ".RS" file,
not the name of the file.  However, the file  should  have  an  extension  of
".RS", so it is immediately recognizable by humans as a ReSource data file.

To save your work (it doesn't matter how you loaded it), select "PROJECT/Save
.RS", and select a filename to save to.

1.9    About Output
Eventually, after disassembling a program, you will probably want to save  it
as  a  text  file,  which  you  will later assemble, perhaps after doing some
modifications.  By using the "SAVE/Save .asm" function, the entire  file  can
be  saved  as  a text file, exactly as you see it on the screen.  If you only
wish to save part of the file, use "SAVE/Save .asm/Partial".

Another output function is "SAVE/Save binary image". This function gives  you
a  way of performing modifications on an existing binary file (which may be a
load file).  For example, if you  have  a  program  that  has  some  annoying
feature, you could load the file using "PROJECTS/Open binary file".  Then you
could  quickly find the offending code with ReSource, and simply overwrite it
with "NOP" instructions.  You may use "SPECIAL FUNCTIONS/Zap" to enter  "NOP"
opcodes  as  "'Nq"  or  "$4E71".  Look up the hex values of any other opcodes
that you may need.  Once this has been done, select "SAVE/Save binary  image/
All",  and  you  can  use  the  file  immediately,  without going through the
complete disassemble/re-assemble/link process.

To find out how large the output .asm file will be,  you  can  select  "SAVE/
Calculate .asm size/ALL".  This will tell you the output size, in bytes, K's,
and as a percentage of a floppy disk (which may be larger than 100%).  If you
change any of the options, it will most probably have some effect on the size
of the output file.  To make the output .asm file smaller, most things in the
"OPTIONS 1" menu should be switched OFF, except for "DCB instructions", which
if used, can shrink the size of a .asm file considerably, especially if there
are large data areas.  Selecting "OPTIONS  2/Multiple  constants"  will  also
help  to  shrink the output size.  Either real tabs (ASCII value 9) or spaces
may be used in the output file.  Selecting "SAVE/Tabs/Real  tabs"  will  also
make  the  output  file size smaller, as will "DISPLAY/Blank lines/None".  If
the size of the output file is not a problem, then set these options to  suit
your  tastes.   Another  way to deal with limited space for .asm files, is to
save them as  two  or  more  partial  files  using  "SAVE/Save  .asm/Partial"
repeatedly.

Before leaving this section, a brief look at how ReSource achieves  its  fast
screen output is in order.  All  text  that  is  displayed  on  the  ReSource
screen,  with  the  exception  of  menus and requesters which are rendered by
Intuition, uses text rendering routines internal  to  ReSource.   This  makes
text  rendering  extremely fast, but also means that the font can't be easily
changed.  The text rendering routines were originally  inspired  by  Warptext
II.   The  major  difference  here is that four characters instead of one are
rendered in the main loop.  This has the obvious benefit of increasing  speed
of  rendering,  but is also the reason why the start and end of hilited areas
are sometimes displaced by up to 3 characters.  For efficiency, large cleared
areas (such as the first tab in a line) are handled separately.

1.10    About Symbols
When you create a symbol, unless you have set "SAVE/Symbol table" to  "None",
the  symbol  and  its  value  will  be  stored, so that a symbol table can be
created at the beginning of the output source code file.  This  symbol  table
can take the form of an equate table, e.g.:

   AG_OpenLib      EQU     $00030000
   AO_DOSLib        EQU     $00008007
   AT_Recovery     EQU     $00000000
   _LVOAlert        EQU     $FFFFFF94
   _LVOClose        EQU     $FFFFFFDC
   _LVOCreateProc  EQU     $FFFFFF76
   _LVOCurrentDir  EQU     $FFFFFF82

Alternatively, it can take the form of an "XREF" table, e.g.:

            XREF    AG_OpenLib
            XREF    AO_DOSLib
            XREF    AT_Recovery
            XREF    _LVOAlert
            XREF    _LVOClose
            XREF    _LVOCreateProc
            XREF    _LVOCurrentDir

The symbol table is also stored in a ".RS" file.  When it is time  to  create
the  .asm  file,  you can select either "EQU" or "XREF" as the type of symbol
table to create.  Even though you may create many symbols with the same name,
the symbol table will contain only one entry for each symbol.  Thus, it  will
correctly assemble with most assemblers.  If you select the "None" option, no
symbol table will be generated.

1.11    Display Preferences
To  cater  to  different  tastes,  the  manner  in  which  ReSource  displays
information  may  be varied dramatically.  Overlong lines may or may not wrap
around, code may be shown in upper case, or lower  case.   Data  declarations
may  be  shown  in upper case or lower case.  You may have blank lines appear
after conditional branches, after all branches, after system calls,  or  none
at all.  Any number may be shown in hexadecimal, decimal, binary, or ASCII if
within  the  required  range.   Leading  zeroes  may be suppressed, or shown.
Numbers below 10 in value, or below 16 in value may be globally converted  to
decimal,  or there may be no conversion.  Each line that doesn't start with a
label may instead show the  current  offset.   Section  statements,  the  END
statement,  labels,  hidden  labels,  symbols,  and two types of comments may
individually be set ON or OFF at any time.  The settings of these options can
be made permanent by selecting the required functions in Macro #19 (the  last
local macro), and saving the macro file as "S:RS.macros".  See the section on
macros  for  more  information.   Selecting  "OPTIONS  1/Labels/Off" does NOT
remove any labels, it simply stops them from being shown,  until  you  select
"OPTIONS  1/Labels/On".  For example, you might wish to search for "lbC" as a
string inside a comment,  and  unless  you  turn  off  labels  and  reference
recognition,  you  will  have  to  spend  a  long time searching for the real
target, as many labels will start with "lbC".

1.12    About Searches
ReSource has some very powerful search functions.   You  may  select  from  a
normal  search,  or a pattern search.  You may search forward, backward, or a
special combined search, that searches in both directions at the  same  time,
which  will  find  the "nearest" occurrence of the search string.  For use in
macros, you can also search just the current line, or the accumulator.

The text that you see on the display will be the text that is searched.   For
the purpose of searches, tabs are set to real tabs, not spaces.  Thus, if you
wish to search for:

            MOVE.L  #100,D0

you would press "tab" where you see spaces in the above line.  When using the
pattern search, the wildcards are  those  used  in  all  ARP  programs.   For
completeness, they are repeated here.

1.13    ARP and Wildcards
ARP has an extensive set of wildcards, and most ARP programs allow them to be
used.  ARP supports ALL of the AmigaDOS(TM) set of wildcards, as well as  the
more  standard  Unix style of wildcards.  ARP supports the following wildcard
characters.  Note that these are valid inside or out of quotes:


   (a|b|c)    Will match one of a, b or c.  These can be patterns.

   ?        Matches any single character

   #<pat>    Pattern repeated 0 or more times, in particular,
        #? matches anything.

   [char]    A set of characters, for example, [abc] or [a..c]
        specify the same set.

   [^char]    Match everything but this set of characters.

   *        0 or more occurrences of any character.

These can be used in combination, of course, so that *.(c|h) or  *.[ch]  will
match  any  filenames  ending  in  either .c or .h proceeded by any number of
characters, including no characters.

For example, if you want to search for "JSR"  or  "BSR",  you  could  specify
"?SR"  as  the  search pattern, and you would use the pattern search, not the
normal search.  Here are some more examples:

  lb[ABCWL] would find any occurrence of "lbA", "lbB", "lbC", "lbW", or "lbL"
  "lbM" would NOT constitute a valid match.

  J(MP|SR)  -$????*(A6*) would get a match on the following lines:

            JMP     -$00C6(A6)
            JSR     -$00C6(A6)
            JSR     -$01FE(A6)
            JMP     -$FFFF(A6)

   but not on the following lines:

            JMP     $00C6(A6)
            JSR     -$00C6(A5)
            JSR     $1FE(A6)
            JMP     (A6)

Note that a real tab character was used  above,  between  "J(MP|SR)"  and  "-
$????*(A6*)".   During  a  search,  it is unimportant whether tabs are set to
real tabs or spaces.

Reference Section

2.1.1      PROJECT/Abort:
Use this to abort searches, macros,  backwards  references,  file  loads  and
saves.   As  a  matter of fact, most actions may be aborted by this function.
This is the only function  in  ReSource  which  should  NOT  be  bound  to  a
different key.  It is permanently bound to right-Amiga A, for "Abort".

2.1.2      PROJECT/Open load file:
ReSource will present the ARP file requester.  When you  either  double-click
on  a  file  name,  select  a file and press "return", or click on the "okay"
gadget, ReSource will attempt to load the file as an  executable,  or  "load"
file.   If  there  are  any  debug  symbols  in the executable, these will be
stored, and will become  labels  at  the  appropriate  places  in  the  file.
Relocation  is  performed where required.  If the file has overlays, ReSource
will attempt to load  the  root  hunk.   Each  debug  symbol  encountered  is
attached  to  the  appropriate  byte in the file, and for those debug symbols
(labels) that are nine characters long,  and  start  with  "lb",  immediately
followed by 'A', 'B', 'C', 'L', or 'W', the data type at the appropriate byte
will  be  set  to  ASCII,  Bytes,  Code,  Longwords,  or Words, respectively.
Additionally, local labels, of the "1$" variety, and labels ending  in  "SUB"
are  recognized as code, and labels ending in ".MSG" are recognized as ASCII.
Any BSS hunks or uninitialized data areas found are expanded fully.  You  may
hilite  areas  where  relocation  has  been  performed by selecting "DISPLAY/
Hiliting/Reloc32".

You are limited to files smaller than 16 Megabytes, and  further  limited  by
how  much  memory  you  have.   To  disassemble a 100K file, you will require
approximately 850K of memory, of which at least 400K must be contiguous.   If
the  file  has  large  BSS  hunks,  this  will  greatly  increase  the memory
requirements.  If you intend to load a file, do  some  zaps,  then  save  and
later run it, use "PROJECT/Open binary file" instead, otherwise the file will
get saved with the loader information stripped.

2.1.3      PROJECT/Open binary file:
Similar to "PROJECT/Open load file", except that no translation of  the  file
is  performed; the file is read in "as-is". This allows you to see the loader
information in executables, object files, etc.  You can  also  load  in  text
files,  data  base files, in fact any file whatsoever, memory permitting.  If
you select "PROJECT/Open load file" for a non-executable file, the file  will
be  loaded as a binary image instead, therefore "PROJECT/Open binary file" is
not really required except when you wish to force  an  "as-is"  load  for  an
executable  file.   If  you  wish to do some zaps (small modifications) to an
executable file, (or a ".RS" file, for that matter) without going through the
disassemble/edit/reassemble/link cycle, you could load  the  file  with  this
function,  do  the  zaps  (see  "SPECIAL FUNCTIONS/Zap"), then use "SAVE/Save
binary image/All" to save the modified program.

2.1.4      PROJECT/Restore file:
Useful only when the current buffer was  loaded  using  "PROJECT/Open  binary
file"  or  "PROJECT/Open  load  file".   This function will attempt to load a
file, with the same name as the current file, using the  same  function  that
loaded  the current file originally.  Do not use this function if the current
buffer was loaded from tracks, or directly from memory.

2.1.5      PROJECT/Dismble memory:
Disassembles a block of memory directly.  You will be asked to supply a start
and end address for the memory region to be disassembled.  The memory is  NOT
copied  to a separate buffer, it is disassembled "as-is", which means that if
you hold down the left mouse button, in some areas you  can  see  the  memory
being  dynamically  updated.   It  also  means  that  you  can  modify memory
directly.  Anywhere.  For each address that you supply, if the number  starts
with  a "$", the number is assumed to be hexadecimal.  If it starts with "%",
it is assumed to be a binary number.  If neither, decimal is assumed.  If you
wish to work on a COPY of a block of memory, to avoid modifying the original,
or perhaps because the original will not be around for long, disassemble  the
memory  directly,  and  save  the  data with the "PROJECT/Save .RS" function.
Then use "PROJECT/Open load file" to load the ".RS" file normally.

2.1.6      PROJECT/Read tracks:
You will be asked to supply the parameters for the track to read.  The  first
parameter  must  be  either  "DF0:", "DF1:", "DF2:", or "DF3:" (lower case is
okay).  This represents the drive that holds the disk to be read  from.   The
second  parameter  is  the number of the cylinder to start reading from.  The
third parameter is the number of the last cylinder to be read, plus one.  For
example, if you wanted to read the first cylinder from the disk in DF0:,  the
parameters  would  be  "DF0:   0  1".   The fourth parameter is optional, and
represents the number of extra sectors to read.  For example, if  you  wished
to read only the very first sector from DF1:, the parameters would be "DF1: 0
0  1".   If  you  wished to read the first sector from the directory track of
DF2:, the parameters would be "DF2: 40 40 1".  The fifth  parameter  is  also
optional,  and  it  represents  the  sector  offset,  to start the read.  For
example, if you wished to read sectors nine and ten on  cylinder  79  of  the
disk in DF3:, the parameters would be "DF3: 79 79 2 9".

2.1.7      PROJECT/O'lay binary image:
This function prompts you for a filename.  ReSource will attempt to open  the
file,  and  read  the contents, overlaying the current file.  This is NOT the
same as opening a file normally,  as  all  labels,  symbols,  comments,  data
types,  etc.,  stay  as they are.  Only the actual contents of the executable
itself are overwritten.  For example, you may wish to pass on a ".RS" file to
someone, but because the program you have disassembled  is  copyrighted,  you
cannot  legally  distribute  the  normal  ".RS"  file,  as  it  contains  the
executable.  By  using  this  function,  and  inputting  a  filename  of  "*"
(asterisk),  ReSource will completely clear the executable within the current
file.  You may then save to a ".RS" file,  which  may  then  be  distributed,
devoid  of  the  executable.   If another person has previously purchased the
program that you have disassembled, they may load it into ReSource,  and  use
"SAVE/Save  binary  image/All",  to save the executable to a file.  They then
load the special ".RS" file which you created.  Next, they then use "PROJECT/
O'lay binary image", supplying as a filename, the name of the file previously
saved with the "SAVE/Save binary image/All" function.  This effectively  puts
the  executable  back into the ".RS" file.  The other save functions may then
be used, to save to a .asm file, for example.

Please make sure the executable section IS cleared  before  you  share  ".RS"
files that are disassemblies of copyrighted material.  Failure to do this may
result in your meeting many new people - mostly lawyers.

2.1.8      PROJECT/Save .RS:
Use this function to save what you are currently working  on,  regardless  of
how  far you have gotten in disassembling it.  EVERYTHING is saved, even your
current position within the file.  Actually, if you  disassemble  the  Amiga®
operating  system  directly,  the ".RS" file that you create will NOT contain
the executable, therefore the ".RS" files can be legally distributed, as they
contain no copyrighted material.  This is not the case for other ".RS" files,
as the executable will be saved along with  other  information.   Please  see
"PROJECT/O'lay binary image", above.

2.1.9      PROJECT/About:
Get information about the version number, author,  agents,  and  people  that
helped in the development of ReSource.

2.1.10     PROJECT/Quit:
Asks you for confirmation, then quits without saving.  If  this  function  is
used  within  an  executing  macro,  it  will  NOT  ask  the   operator   for
confirmation.  If any new macros have been defined, without being saved to  a
macro file, this fact will be mentioned in the quit requester.

2.2.1.1    DISPLAY/Hiliting/None:
Use the hiliting functions to select attributes for which the data with those
attributes will be shown  with  the  foreground/background  colors  inverted.
Selecting this function will disable all types of hiliting.

2.2.1.2    DISPLAY/Hiliting/BSS hunks:
Data within BSS hunks and uninitialized data areas will be hilited.

2.2.1.3    DISPLAY/Hiliting/Data hunks:
Everything within data hunks will be hilited.  Data hunks often will  contain
only data constants, but may also contain code.

2.2.1.4    DISPLAY/Hiliting/Code hunks:
Everything within code hunks will be hilited.  Code hunks often will  contain
only code, but may also contain data constants.

2.2.1.5    DISPLAY/Hiliting/Chip load hunks:
Data within code or data hunks that MUST be loaded into  chip  memory  (only)
will be hilited.  Data falling into this category will usually be graphics or
sound data, to be accessed directly by the blitter, copper or DMA.

2.2.1.6    DISPLAY/Hiliting/Fast load hunks:
Similar to the above function, except that the data is forced  to  load  into
FAST memory only.

2.2.1.7    DISPLAY/Hiliting/Reloc32:
Being able to see where relocation has been  performed  is  extremely  useful
when disassembling a program.  If it were not for the relocation information,
disassembling  programs  would  be  many times harder.  ReSource makes use of
this information internally, especially when filling in data types.

2.2.1.8    DISPLAY/Hiliting/Symbol scan:
When you use the "LABELS/Create single/Label -  fwd  ref"  or  "LABELS/Create
multiple/All",  all  data scanned for references are marked as being scanned.
Use this function to hilite data  falling  into  this  category.

2.2.1.9    DISPLAY/Hiliting/Data type uncertain:
For most labels that ReSource creates automatically, it  is  certain  of  the
data  type  that  it  assigns.  Sometimes though, it cannot be 100% sure, and
this function will hilite all lines that fall into this category.

2.2.1.10   DISPLAY/Hiliting/Data type known:
Similar to the above function, only the lines where ReSource WAS  certain  of
the  data  type  will be hilited.  This will also include lines that YOU have
set using "DISPLAY/Set data type/" (see below).

2.2.1.11   DISPLAY/Hiliting/Internally produced refs:
All lines which have a label  that  was  created  by  ReSource,  rather  than
directly by the user, will be hilited.

2.2.1.12   DISPLAY/Hiliting/Uninitialized data:
When selected, any uninitialized data areas will be hilited.

2.2.1.13   DISPLAY/Hiliting/Optimize override:
When selected, any code that has the optimize  overrride  attribute  bit  set
will be hilited.

2.2.1.14   DISPLAY/Hiliting/DCB override:
This function will hilite any areas that have been selected by "DISPLAY 2/DCB
override/Set".

2.2.1.15   DISPLAY/Hiliting/Optimizations:
When selected, any code that ReSource  has  optimized  in  any  way  will  be
hilited.

2.2.1.16   DISPLAY/Hiliting/Symbols:
When selected, all symbols will be hilited.  A symbol in ReSource is  defined
as  a character string you assign to a number.  This string will be displayed
in place of the number, and will be hilited by this function.

2.2.2      DISPLAY/Set data type/:
When you are certain of which type of data that you are  looking  at,  select
from  one of the sub-menu items: Code, ASCII, Bytes, Words, Longwords.  Under
certain conditions, ReSource will override the previously set data type:

Attempts to set the data type to ASCII or CODE in a BSS or uninitialized data
area will instead set the data type to BYTES.  Regardless of the  setting  of
the attributes bits, data in a BSS hunk or in an uninitialized data area will
*always* show as "ds.b", "ds.w" or "ds.l".

If a line is displayed such that a reloc32 longword will overlap to the  next
line,  the  data  type  at  the start of that line is changed to bytes/words,
effectively preventing the overlap.

If data type "word", "longword" or "code" is selected at an  odd  address,  a
DisplayBeep() is generated.

If a label is defined for an uninitialized data or BSS  area,  and  the  data
type  for  the  previous word was set to longword, ReSource will override the
previous data type in order to avoid hiding the label.   This  will  also  be
true  for  other  combinations  of data type sizes, such as when the previous
byte had its data type set to words.  This means that you  should  no  longer
see any hidden labels in a BSS or uninitialized data area.

2.2.3      DISPLAY/Set numeric base/:
By default, all  numbers  are  shown  in  hexadecimal  (base  16).   You  can
individually change this to ASCII, DECIMAL, BINARY, or back to HEXADECIMAL on
any  line  by  selecting  from  the  appropriate sub-item.  It is possible to
change the default to decimal for numbers less than  16,  or  less  than  10,
using the decimal conversion function (see below).

The function "DISPLAY/Set  numeric  base/ASCII"  will  enable  virtually  any
number  at  all  to  be  shown  as  ASCII,  providing that no non-valid ASCII
characters are present.  Be aware that the following lines:

        dc.l    $4E
        dc.l    $4E00
        dc.l    $4E004E00
        dc.l    $4E4E00
        dc.l    $4E000000
        dc.l    $444F53
        dc.l    $444F5300
        dc.l    $4B49434B

will, by using the ASCII numeric base, be shown as:

        dc.l    'N'
        dc.l    ('N'<<8)
        dc.l    $4E004E00
        dc.l    ('NN'<<8)
        dc.l    ('N'<<24)
        dc.l    'DOS'
        dc.l    ('DOS'<<8)
        dc.l    'KICK'

Note that the third line contained a  non-valid  ASCII  character.   Although
some  others  contained zeroes in the lower byte(s), they can be safely shown
as being an ASCII value shifted 8/16/24 to the left.

2.2.4      DISPLAY/Decimal conversion/:
By default, all numbers are shown in hexadecimal.  You can have numbers  less
than  16,  or  numbers less than 10, shown in decimal throughout the file, by
selecting one of the appropriate sub-items.

2.2.5      DISPLAY/Blank lines/:
To better define subroutines, and logical blocks of code, ReSource can insert
blank lines in the source code.  You may  select  whether  a  blank  line  is
inserted  after  each  conditional  branch,  unconditional branch, return, or
system call.   Additionally,  selecting  "DISPLAY/Blank  lines/Entry  points"
will create a blank line where data ends, and code starts.

You may select more than one, in which case a blank line  will  appear  after
any  line which falls into any of the selected categories.  A line will never
be followed by more than one blank line,  regardless  of  how  many  selected
categories it falls into.

2.2.6.1    DISPLAY/Cursor address/Relative:
The cursor address will be shown in the title bar, as  a  hexadecimal  offset
from the start of the file.

2.2.6.2    DISPLAY/Cursor address/Absolute:
The cursor address will be shown in the title bar, as a hexadecimal  absolute
machine  address.   This  allows  you  to quickly find the cursor position in
memory with other utilities, such as MetaScope, perhaps to  carry  out  large
scale modifications.

2.2.7.1    DISPLAY/Titlebar info/Filename:
Information is displayed in the title bar in several fields.  From the  left,
the  first is the program name.  The second is a decimal number, representing
the cursor position relative to the file size,  and  is  a  percentage.   The
third  field  is  a hexadecimal number, representing the cursor position, and
can be shown either as an offset from  the  start  of  the  file,  or  as  an
absolute  memory  location.   The  fourth field is the one that this function
relates to.  By selecting this function, the current file name will be shown.
If user feedback is ON, informative messages will sometimes be shown in  this
field also.

2.2.7.2    DISPLAY/Titlebar info/Attributes:
The last field of the title bar will  display  information  representing  the
current  attributes of the cursor byte.  This information is NOT required for
general program usage, and was originally  included  for  debugging  purposes
only, and left in to satisfy those that want to know how the attributes table
in  ReSource  works.   The  attributes  table  is  four times the size of the
current file, plus 16 bytes.  It is used internally as  a  large  bitmap,  to
store  information about each and every byte in the current file.  Because it
is four times the file size, 32 bits are  available  for  each  byte  in  the
current file.  For each character in the string displayed, if lower case, the
bit  that  that character represents is clear, if upper case, the bit is set.
Going from the left, the bit definitions are:

    S:  Start of a line of code/data
    B:  Bss hunk
    D:  Data hunk
    C:  Code hunk
    R:  Reloc32 area
    F:  First byte of reloc32 area
    L:  Label attached to this byte
    S:  Symbol attached to this byte
    F:  Full-line comment attached to this byte
    E:  End-of-line comment attached to this byte
    P:  Parsed previously (symbol scan)
    I:  Internally referenced
    L:  Low priority.  The data type has been set, but can be overridden by
        internal routines.  The data type can always be overridden by the
        user.  This bit was generally set when ReSource had to decide on a
        data type to set for a byte, but when it did so, it wasn't really
        sure that it was correct.
    A:  Show numeric operands as ASCII if possible.  Decimal conversion
        is on a higher priority than this bit.
    B:  Show numeric operands as Binary.  Decimal conversion is on a higher
        priority than this bit.
    D:  Show numeric operands as Decimal if possible.
    F:  Data in this hunk is to be loaded into FAST memory only.
    C:  Data in this hunk is to be loaded into CHIP memory only.
     :  [Next 4 bits are reserved for future use]
    U:  User should check the data type that has been set, as ReSource wasn't
        really sure that it chose the correct one.  Use "CURSOR/Relative/Next
        uncertain D/T" to find the next occurrence.  If such a line is already
        the current line when you use that function, it will clear this bit.
    H:  High priority.  The data type has been set either by the user, or by
        ReSource when it was quite certain that it set the data type
        correctly.  This does not mean that it cannot make mistakes, it
        simply means that if some operation attempts to set the data type for
        this byte, it will NOT override the currently set data type.  This
        will not ever stop the user from redefining the data type, however.
    C:  This line is code.
    dddd:  Data type hasn't been set yet
    ddDd:  Data type is bytes
    dDdd:  Data type is words
    dDDd:  Data type is longwords
    Dddd:  Data type is bytes, within a BSS hunk or uninitialized data area.
    DddD:  Data type is ASCII.
    DDDd:  Data type is words, within a BSS hunk or uninitialized data area.
    DDDD:  Data type is longwords, within a BSS hunk or uninitialized data area.

2.2.7.3    DISPLAY/Titlebar info/Accumulator:
The third field of the title bar will display  information  representing  the
contents  of  the  ACCUMULATOR.  This is a 240 byte buffer, used as a central
number and string processor, which will find most of its uses within  macros.
Only  the  first 30 characters or so can be shown in the title bar.  However,
often the string will not be longer than that anyway.  For  more  information
on the accumulator, see the functions within the "STRINGS" menu.

2.2.8      DISPLAY/Wrap/:
With wrap on, any lines longer than the current display width will  be  shown
on several lines.  Otherwise, any lines longer than the current display width
will be truncated.

2.2.9      DISPLAY/Block-fill/:
To use the "Block fill"  function,  the  start  and  end  addresses  must  be
specified  by  selecting  "DISPLAY/Block  fill/Set  start" and "DISPLAY/Block
fill/Set end" at the appropriate locations in the file.  The block-fill start
and end addresses will default to the actual  start  and  end  of  the  file.
Selecting  "DISPLAY/Block-fill/Fill will copy the data type attributes of the
first byte (as defined by "Set start", from the start location up to, but not
including, the end location.

2.2.10     DISPLAY/Fill-in data types:
To  understand  what  this  function does, you will need to know how ReSource
keeps track of data types.  Suffice it to say, when you  set  the  data  type
anywhere  within  a  file, that data type is immediately echoed forward, to a
maximum of several hundred bytes, but will not change any other places  where
the  data  type  has  already  been set, or where there is a label on a line.
Where there is large areas of a file where the data type has  not  been  set,
this  function  attempts  to set the data type appropriately.  All of this is
done on the first pass.  On the second pass, the length of each line is  set.
This  is  mostly noticeable when strings are displayed.  Much of this is done
on-the-fly, during normal disassembly, so this function shouldn't be required
too often.  It is still a good  idea  to  use  "DISPLAY/Fill-in  data  types"
before  saving  to  either a ".asm" or ".RS" file, however these are the only
occasions when it should be required.

2.2.11     DISPLAY/Fill-in D/T Fwd:
Similar to the above function, except that both passes will  start  from  the
current  cursor location, and NOT the start of the file.  Also, the action of
this function will stop at the end of the current section, OR the end of  the
file, whichever occurs first.  Useful if you need to make changes to data and
BSS areas towards the end of the file.

2.2.12     DISPLAY/Set counter:
If cursor address has been set to "relative", the current offset in a file is
shown in the title bar, in hexadecimal.  This is normally zero at  the  start
of the file.  You can change this, so that it is zero at somewhere other than
the  start of the file, by using this function.  You may use this function to
measure the size of a hunk, for example.  To "reset"  the  counter,  use  the
function  "DISPLAY/Reset  counter".   If  cursor  address  has  been  set  to
"absolute", it will correctly display the  current  address  of  the  cursor,
regardless of this function.

2.2.13     DISPLAY/Reset counter:
Similar to the above function, except that the title bar counter will display
offsets relative to the start of the file.

2.2.14     DISPLAY/Flip case - code:
If code is currently being displayed using upper case,  it  will  be  instead
shown  in  lower  case,  and  vice  versa.   Note  that all searches are case
sensitive.

2.2.15     DISPLAY/Flip case - data:
If data is currently being displayed using upper case, it will be instead  be
shown in lower case, and vice versa.

2.3        DISPLAY 2/DCB override/:
These  functions  set  or  clear  an  attribute  bit  for  the  current  line
determining  whether  the DCB directive will be used on this line if there is
suitable data.  This bit works in conjunction with the global DCB option (see
"OPTIONS 1/DCB statements") to comprise an exclusive-OR function:  If  global
DCB's  are  ON,  this  bit will turn them off locally.  Conversely, if global
DCB's are set to OFF, this bit will enable them locally.

2.4        SYMBOLS 1/:
Some background information is required here: When you  assemble  a  program,
you  will  use  symbols  such   as   "_LVOAllocMem",   "MEMF_CHIP",   "Open",
"MODE_OLDFILE", etc.  When you  disassemble  a  program,  you  see  only  the
numbers  that  equate to the symbols that you used.  To convert these numbers
back into strings, you basically tell ReSource what the "symbol base" is, and
it will do the rest.  For example, in the following line:

        JSR    -$0228(A6)

the number "-$0228" could be interpreted in  many  different  ways.   If  you
happened  to  know  that  the  A6  register  at that point in the program was
pointing to the Exec library base, you would interpret that line as:

        JSR    _LVOOpenLibrary(A6)

To make ReSource do this automatically, you would scroll so  that  this  line
became  the  cursor  line, and then select the function "SYMBOLS 1/Libraries/
Exec", or "SYMBOLS 2/E-G/Exec library".  There are hundreds of  other  symbol
bases  that  are  available,  including   libraries,   devices,   structures,
parameters, and error code names.

2.4.1      SYMBOLS 1/Set Source/dest/:
Examine the following line of code:

        MOVE.L  #-$0228,$0022(A6)

If you wished to create a symbol for the second number on this line, "$0022",
you should first select "Destination".  The setting of "Set Source/dest" will
go back to "Source" with virtually  any  function  you  use,  therefore  when
creating  a symbol for the second field in a line of code, use "SYMBOLS 1/Set
Source/dest/Destination" only just prior to actually creating the symbol.

2.4.2      SYMBOLS 1/Object/:
By default the number, or object, used to find the string will come from  the
cursor  line.   You  can  instead  have  ReSource  get  the  number  from the
accumulator, by selecting "Accumulator".  In this  case,  the  output  string
will be placed back into the accumulator.  To set it back, select "Cursor".

2.5        SYMBOLS 2/:
Some special symbol bases are in  the  "SYMBOLS  1"  menu,  mostly  different
library  bases.   The  remainder are in alphabetical order in the "SYMBOLS 2"
menu.

One symbol base, "String control", should be mentioned.  This is meant to  be
used for ASCII control characters, such as DEL ($7F), BS (8), etc.

2.6        OPTIMIZATION/:
ReSource can be used  to  optimize  68000  code.   With  this  release,  long
branches  may  be changed to short branches, when the branch is within range.
This is  true  even  for  forward  branches,  and  includes  conditional  and
unconditional  branches, as well as branch-to-subroutine instructions.  It is
expected that other forms of optimizing will be supported later.

2.6.1      OPTIMIZATION/Local override/:
This function may be used to  override  all  optimizing  at  specific  places
within  a file.  For example, if a branch was short, it will remain short; if
a branch was not short, it will be specifically set to long.  This  attribute
bit  will  disable  all types of optimizing at all places within a file where
this  bit   is  set.   There  are  new  hiliting  functions  to  support  the
optimization  functions (see "DISPLAY/Hilite/Optimize override" and "DISPLAY/
Hilite/Optimizations").

2.6.2      OPTIMIZATION/Branches/:
This function enables/disables the  optimization  of  branches  on  a  global
scale.   Optimization is temporarily disabled while holding down the ctl key,
as well as the left mouse button.

2.7.1      CURSOR/Remember:
ReSource keeps a stack of cursor locations internally.  Using  this  function
will  "push"  the  current cursor location onto the top of this stack.  Other
functions that call this function are:

    CURSOR/Remember
    CURSOR/Absolute/End of file
    CURSOR/Absolute/Start of file
    CURSOR/Absolute/Forward reference
    CURSOR/Absolute/Second forward reference
    CURSOR/Absolute/Backward reference

To "pop" a cursor location, you use  the  function  "CURSOR/Absolute/Previous
locations". The stack is cleared when you load a new file, or when you select
"CURSOR/Clear loc stack".  The stack is NOT stored within ".RS" files.

2.7.2      CURSOR/Clear loc stack:
See above function.

2.7.3.1    CURSOR/Relative/Next byte:
The cursor location is incremented.  If  at  the  last  location  within  the
current file, a macro "fail" will result.

2.7.3.2    CURSOR/Relative/Previous byte:
The cursor location is decremented.  If at  the  first  location  within  the
current file, a macro "fail" will result.

2.7.3.3    CURSOR/Relative/Next line:
Scroll forward one line of code/data.  If at the last line  of  code/data  in
the file already, a macro "fail" will result.  The speed at which this scroll
is done is set by the "CURSOR/Scrolling speed" settings.

2.7.3.4    CURSOR/Relative/Previous line:
Scroll backwards one line of code/data.  If at the first line of code/data in
the file already, a macro "fail" will result.  The speed at which this scroll
is done is set by the "CURSOR/Scrolling speed" settings.

2.7.3.5    CURSOR/Relative/Next label:
Move cursor to the next location that has a label attached  to  it.   If  one
cannot be found, a macro "fail" will result.

2.7.3.6    CURSOR/Relative/Previous label:
Move cursor to the previous location that has a label attached to it.  If one
cannot be found, the start of the file will become the new cursor position.

2.7.3.7    CURSOR/Relative/Next symbol:
Move cursor to the next location that has a symbol attached to  it.   If  one
cannot  be found, a macro "fail" will result.  Note that this location may be
in the middle of a line of code.  Where the actual  operand  is  stored  will
become the new cursor position.

2.7.3.8    CURSOR/Relative/Previous symbol:
Move cursor to the previous location that has a symbol attached  to  it.   If
one  cannot  be  found,  the  start  of  the  file will become the new cursor
position.  Note that this location may be in the middle of a  line  of  code.
Where the actual operand is stored will become the new cursor position.

2.7.3.9    CURSOR/Relative/Next section:
Move cursor to the start of the next section (hunk).  If  this  is  the  last
section in the file, a macro "fail" will result.

2.7.3.10   CURSOR/Relative/Previous section:
Move cursor to the start of this section (hunk).  If already at the start  of
a section, move to the start of the previous section.

2.7.3.11   CURSOR/Relative/Next reloc32:
Move cursor to the start of the next relocated longword.  If  one  cannot  be
found,  a macro "fail" will result.  Note that this may be in the middle of a
line of code.

2.7.3.12   CURSOR/Relative/Previous reloc32:
Move cursor to the start of the previous relocated longword.  Note that  this
may be in the middle of a line of code.  If one cannot be found, the start of
the file will become the new cursor position.

2.7.3.13   CURSOR/Relative/Next page:
Move cursor forward 24 lines.

2.7.3.14   CURSOR/Relative/Previous page:
Move cursor backwards 24 lines.

2.7.3.15   CURSOR/Relative/Skip forward:
Move cursor forward approximately 4K.

2.7.3.16   CURSOR/Relative/Skip backward:
Move cursor backward approximately 4K.

2.7.3.17   CURSOR/Relative/Next unparsed code:
Move cursor forward to the next location that satisfies both of the following
conditions:

  1. The data type has been set to CODE
  2. This location has NOT been scanned for forward references previously.

This function is useful when combined with the  "LABELS/Create  multiple/All"
function.

2.7.3.18   CURSOR/Relative/Next D/T change:
Move cursor to the next location that has its data type set differently  than
the data type at the current cursor location.

2.7.3.19   CURSOR/Relative/Previous D/T change:
Move cursor to the previous location that has its data type  set  differently
than the data type at the current cursor location.

2.7.3.20   CURSOR/Relative/Next uncertain D/T:
Move cursor forward to the next location that has the "Uncertain" bit set  in
the  attribute table.  This bit indicates that ReSource really wasn't sure of
the data type of this byte.

2.7.3.21   CURSOR/Relative/Next backward reference:
Once you have used the "CURSOR/Absolute/Backwards  reference"  function,  you
can use this function to get to other backward references.

2.7.3.22 CURSOR/Relative/Next hilite:
Move cursor forward to the next line which has  any  form  of  hiliting.   By
changing  the type of hiliting, in the DISPLAY/Hiliting" menu, you can tailor
the search for various attribute types to your own needs.

2.7.4.1    CURSOR/Absolute/End of file:
Move cursor to the start of the last line of the file.

2.7.4.2    CURSOR/Absolute/Start of file:
Move cursor to the start of the file.

2.7.4.3    CURSOR/Absolute/Forward reference:
If there is a reference to a position within the current file and within  the
current line of code, move cursor to the location being referenced.  If there
are two forward references within the current line, the first is used.

It is also  possible  to  forward-reference  from  symbols  which  themselves
reference labels, i.e.:

        ADD.W    D0,D0
        MOVE.W    JumpBase(PC,D0.W),D0
        JMP    JumpBase(PC,D0.W)

  JumpBase    DC.W    FirstOffset-JumpBase
               DC.W    SecondOffset-JumpBase
               DC.W    ThirdOffset-JumpBase
               DC.W    FourthOffset-JumpBase

  FirstOffset  ...

Any of the symbols on the "DC.W" lines, are  each  defined  as  the  distance
between  two  labels.   Each  of  the  symbols on these lines is evaluated by
subtracting the offset of "JumpBase" from "FirstOffset",  or  "SecondOffset",
etc.

2.7.4.4    CURSOR/Absolute/Second forward reference:
If there is a reference to a position within the current file, and within the
current line of code, move cursor to the location of the  last  reference  on
the line.

2.7.4.5    CURSOR/Absolute/Backward reference:
Starting from the start of the file, search  for  references  to  the  cursor
location.  If there are several references, you can use "CURSOR/Relative/Next
backward reference" to get to successive references.

2.7.4.6    CURSOR/Absolute/Previous location:
"Pop" the cursor location from the top of the cursor location stack.  If  the
stack is empty, a macro "fail" will result.

2.7.4.7    CURSOR/Absolute/Specify offset:
You will be asked to supply an offset representing how far from the start  of
the  file,  the  cursor  location  should be.  The number may be specified in
hexadecimal, decimal, or binary.  If hexadecimal, the string must start  with
"$",  if  binary,  it must start with "%".  If the given offset is not within
the current file, this function will fail.

2.7.4.8    CURSOR/Absolute/Specify label:
You will be asked to supply the name of a label.  If the label is used within
the current file, its location will become the  new  cursor  location.   Note
that this may be in the middle of a line of code.

2.7.4.9    CURSOR/Absolute/Specify symbol:
You will be asked to supply the name of a symbol.   If  the  symbol  is  used
within  the  current  file, its location will become the new cursor location.
Note that this may be in the middle of a line of code.   Also  note  that  if
there  is  more than one symbol of that name, ReSource will pick the one that
was defined first.

2.7.4.10   CURSOR/Absolute/Specify percentage:
You will be asked to supply a decimal percentage of the current  file,  where
the  cursor  will be positioned.  In this case 0 is the beginning of the file
and 99 is the end.  Note that this may be in the middle of a  line  of  code.
The  actual  positioning  will  not  be exact.  It will generally be placed a
little before the required percentage.

2.7.5      CURSOR/Copy/:
2.7.6      CURSOR/Paste/:
2.7.7      CURSOR/Swap/:
ReSource has 3 internal cursor "clipboards".  You can copy a cursor  location
to  any  of  these,  and  then later "paste" one of these locations, which in
effect moves the cursor to where it was when you used  the  "copy"  function.
Also, you can swap cursor locations, between the current, and a stored cursor
location.   The  contents  of  these cursor "clipboards" are cleared when you
load a new file, or restore the current one.

2.7.8      CURSOR/Scrolling speed/:
Whenever you use  either  "CURSOR/Relative/Next  line"  or  "CURSOR/Relative/
Previous  line" functions, the display will scroll one real line, N pixels at
a time.

   Scrolling    Lines
   Speed    Scrolled    Notes
   ---------    --------    -----
   Very fast        8        Exceptionally fast scrolling, good for scanning
                through a file.
   Fast        4        Reasonably fast scrolling, allows scanning,
                but difficult to read.
   Normal        2        Reasonably smooth scrolling, allowing you to
                read text fairly easily WHILE it is scrolling.
   Slow        1        Extremely smooth scrolling, allowing you to
                easily read text WHILE it is scrolling.
   Very Slow        1        Exceptionally smooth scrolling, with a delay,
                excellent for slowly browsing through a file.

2.7.9.1    CURSOR/Normal search/Set search string:
You will be asked to supply a string, which will be used in future  searches.
Like  all  other  string  requests, you may instead supply a two byte string,
starting with escape, and followed by either another escape character,  or  a
letter  a-m,  representing  a string buffer where the string should be copied
from.  If you supply escape-escape as the string, the string currently in the
accumulator will be copied into the search string buffer.

2.7.9.2    CURSOR/Normal search/Find next occurrence:
Using the currently defined  search  string,  search  forward  for  the  next
occurrence  of  that  string.   The  string  is searched for as-is, including
question marks, asterisks, etc., which in a pattern search  take  on  special
meaning.

2.7.9.3    CURSOR/Normal search/Find previous occurrence:
Similar to the above function, except that the search proceeds backward.

2.7.9.4    CURSOR/Normal search/Find nearest occurrence:
Similar to the above function,  except  that  the  search  proceeds  in  both
directions at the same time.  The search is done line-for-line, and the first
line that contains the search string, whether it be before the current cursor
or  after,  will become the new cursor location.  This function is handy when
you know that a string is somewhere close, but you're not sure whether it may
be just past, or just before, the current cursor location.  Note that you may
NOT use this function to find the second occurrence of a string; it will keep
finding the same two closest occurrences.

2.7.9.5    CURSOR/Normal search/Search this line:
This function is useful in macros, for determining whether a given string  is
within  the  current  line.  If the search string is not found in the current
line, a macro "fail" will result, and unless your macro has prepared for this
condition with an "End conditional" directive, the macro will abort.

2.7.9.6    CURSOR/Normal search/Search accumulator:
Similar to the above function, except that the accumulator is searched.

2.7.10     CURSOR/Pattern search/:
These functions are identical to their counterparts above,  except  that  ARP
wildcard characters are expanded (not used literally).

2.8.1.1    LABELS/Create single/End-of-line comment:
You will be asked to supply a string of less than 240 characters, which  will
become a comment to be attached to the end of the cursor line.  Only one end-
of-line  comment  is  allowed  per line; if you create one on a line that has
already got one, it will replace the old comment.

2.8.1.2    LABELS/Create single/Full-line comment:
You will be asked to supply a string of less than 240 characters, which  will
become  a  comment  to be attached to the start of the cursor line.  Multiple
full-line comments are allowed, and successive  comments  will  be  displayed
AFTER  previously  defined  full-line comments.  Normally, full-line comments
will be displayed starting with a semicolon (";"). However, if you start  the
string  with a semicolon, the logic is reversed, and it becomes an extra line
of code/data.  Thus, you can insert extra lines  of  code/data,  even  before
saving  the source code to a text file.  By creating a label that starts with
a semicolon for a given line, when that code is assembled, that line of code/
data is effectively treated as a comment only, therefore you can both  insert
and  effectively  remove  code/data  using  ReSource,  during the disassembly
process.

2.8.1.3    LABELS/Create single/Label:
You will be asked to supply a string of less than 240 characters, which  will
become  a  label to be attached to the cursor line.  Duplicate labels are NOT
allowed, unless they start with a semicolon (";"), an asterisk  ("*"),  or  a
number  directly  followed  by  a "$".  This last case is useful for creating
local labels, but be careful.  They are not checked for  duplication  and  if
used  imprudently  may  make  your  assembler very unhappy.  In the first two
cases, they effectively make the  rest  of  the  line  a  comment.   If  this
function is used within a macro, duplicate labels WILL be accepted.

When supplying a string (to a string requester) that  will  become  a  label,
symbol,  or  comment, you may use indirection to include in that string, some
other already-defined label, symbol, or comment.  Indirection means a  string
is  not  used  literally.   Rather,  it somewhat resembles a macro in that it
"points" to other information, and  is  "expanded"  when  later  encountered.
Indirection  must  start  with  an  "escape" character (just hit the "escape"
key), and must be followed  by  a  decimal  digit  between  zero  and  three,
inclusive.  This is how you specify which type of string that you require:

  0 = Label
  1 = Symbol
  2 = Full-line comment (the first one attached to a line only)
  3 = End-of-line comment

This should be immediately followed by a  hex,  decimal,  or  binary  number,
specifying  the  offset  in  the current file to which the required string is
attached.  Another escape character is  required  immediately  following  the
number,  as  a  delimiter.   You  are then free to either supply more literal
text, or you may use  indirection  several  times  within  a  single  string.
Consider the following program fragment:

  lbW000140    DC.W    6
        DC.W    8
        DC.W    12

  lbC000146    RTS

  lbC000148    MOVEQ    #0,D0
        RTS

  lbC00014C    MOVEQ    #1,D0
        RTS

The word values at label  "lbW000140"  correspond  to  the  distance  between
"lbC000146"  and  "lbW000140"  on  the  first  line (6), the distance between
"lbC000148" and "lbW000140" on the second line (8), and the distance  between
"lbC00014C" and "lbW000140" on the third line (12).  This is what is commonly
referred  to  as  a  "jump  table".   In  order  to make the program assemble
properly, the values 6, 8, and 12 should be  changed  to  symbols  specifying
their  true  meaning,  rather  than  just  the  value that they were when the
program was last assembled/compiled:

  lbW000140    DC.W    lbC000146-lbW000140
        DC.W    lbC000148-lbW000140
        DC.W    lbC00014C-lbW000140

  lbC000146    RTS

  lbC000148    MOVEQ    #0,D0
        RTS

  lbC00014C    MOVEQ    #1,D0
        RTS

The above example addresses the immediate problem of representing the offsets
symbolically.   However,  if  you  later  change  the  label  "lbC000146"  to
"NullSub",  for  instance,  the  symbol  "lbC000146-lbW000140"  will cause an
assembly error because the assembler will not  be  able  to  find  the  label
"lbC000146".  By using dynamic indirection,  whenever  the  symbol  at  label
"lbW000140" is displayed, ReSource will use whatever label is defined at that
moment.   (Because  the  escape  character  is  not normally displayable, the
following example will use a carat, "^", to represent the escape  character.)
For the line:

  lbW000140    DC.W    lbC000146-lbW000140

instead of creating  the  symbol  "lbC000146-lbW000140",  you  would  instead
specify  "^0$146^-^0$140^"  when  asked  by the "LABELS/Create single/Symbol"
function.

Dynamic indirection is also used internally in ReSource.   For  example,  the
"SPECIAL  FUNCTIONS/Convert  specific  EA's/"  functions  now   use   dynamic
indirection when creating symbols.

Functions that access labels, symbols, and  comments  will  normally  support
dynamic indirection in strings, unless the option "OPTIONS 1/Symbols/" is set
to  "OFF".   In  this  case,  the  literal  string  will  be  used.   Dynamic
indirection is relatively safe to use with symbols.  It is  possible  to  use
with  labels  and  comments,  however  some problems may arise if care is not
taken.  Duplicate labels may easily be created if dynamic indirection is used
in the specification for a label.  It should be quite safe in  any  comments,
however.   Symbols  containing  dynamic indirection will not be stored in the
EQUate or XREF tables.  It is expected that most  strings  using  indirection
will  be  symbols, that refer to labels, and therefore will not require to be
EQUated or XREF'd.

2.8.1.4    LABELS/Create single/Label - fwd ref:
The current line of code will be searched for references to positions  within
the  current  file.  If any are found, ReSource will make a decision on which
type of data is at the position referenced.  It will then set the  data  type
(unless it has already been set), and create a label at that offset (unless a
label  has  already  been  defined for that location). This new label will be
immediately used for  all  references  to  that  location,  which  of  course
includes  the reference within the current line.  If there are no references,
or there is a reference, but it is outside of the range of the current  file,
then  this  function  will  do nothing.  Normally, this function will only be
used within macros, as it is easier and quicker to hold down  the  left-Amiga
key, while holding down the left mouse button, possibly while scrolling also.

When creating labels from forward references,  if  ReSource  detects  that  a
reference  to  an  odd  address  is coming from code, a DisplayBeep() will be
generated, and also a  macro  fail  will  result.   If  using  "LABELS/Create
multiple/All", the scan will stop.

2.8.1.5    LABELS/Create single/Symbol:
You will  be  asked  to  supply  a  string,  which  will  replace  the  first
encountered  number  in  the  current line.  For example, if you supplied the
string "MyColdStartData", the following line:

        MOVE.L  D0,4(A0) would become:

        MOVE.L  D0,MyColdStartData(A0)

If there is more than one number mentioned in the current line, the first  is
used.   If  there  are  no  numbers  in the current line, a macro "fail" will
result.

If the user creates a symbol which is currently also defined as  a  label,  a
DisplayBeep() will be generated.

2.8.1.6    LABELS/Create single/Symbol - dest:
Similar to the above function, except that the last  number  in  the  current
line  will be replaced with the string that you supply.  If there is only one
number, it will be replaced.  If there are no numbers in the current line,  a
macro "fail" will result.

2.8.2      LABELS/Edit single/:
Similar to their above counterparts, except that if there is already a label/
symbol/comment defined, you will have the chance to edit that string,  rather
than  type  the  entire  new string into the requester.  Note that, as far as
ReSource is concerned, in the example "$0022(A1)", "$0022" is a number, NOT a
symbol, unless YOU have defined it previously.  If you try to  edit  it,  you
will  be  presented with an empty requester.  Like all requests for a string,
you can use indirection, so that ReSource gets the  string  from  either  the
accumulator,  or  from  one  the buffers A-M.  See the section on the STRINGS
menu for more details.

2.8.3.1    LABELS/Replace single/Label:
Create a "shop" label at the cursor position.  A "shop" label is one that  is
9 characters long, begins with "lb", has the data type immediately following,
and  ends with the code offset.  It may also be of some other length, and end
with ".MSG".

2.8.4.1    LABELS/Remove single/Label:
Removes the label from the cursor position.

2.8.4.2    LABELS/Remove single/Symbol:
Removes any symbols in the current line.

2.8.4.3    LABELS/Remove single/End-of-line comment:
Removes the end-of-line comment from the current line, if any.

2.8.4.4    LABELS/Remove single/Full-line comment:
Removes the first full-line comment attached to the current line.

2.8.4.5    LABELS/Remove single/All:
Removes any label, symbols, comments from the current line.  Also,  the  data
type for the current cursor position is set to 'uncertain', and the 'start of
line'  bit  is  cleared.   This is useful when a bogus reference was made, as
when ReSource (or you) thought code was being scanned, and  it  was  actually
data or ASCII.

2.8.5.1    LABELS/Create multiple/Reloc32:
For each reloc32 pointer within the current file, determine and set the  data
type  being  referenced,  and create a label at that location.  This function
will be called automatically whenever you load a load file that has at  least
one reloc32 pointer, unless you override this option by selecting "OPTIONS 2/
Auto labels/OFF".

2.8.5.2    LABELS/Create multiple/All:
Starting at the current address, the  "LABELS/Create  single/Symbol  -  dest"
function is executed, and if ReSource thinks that there was valid code in the
current  line,  the "CURSOR/Relative/Next line" function is executed, and the
entire function loops, otherwise the function exits.  This function can  make
the disassembly process very fast.  Care must be taken when ReSource finishes
parsing  a section of code to ensure that the next section selected is really
code.  Otherwise, there is a very slight chance that what ReSource thinks  is
valid code is really ASCII, and invalid labels will be created.  The best way
to  accomplish  this is to select "CURSOR/Relative/Next unparsed code" before
selecting this function again.

When creating "shop" ASCII labels, if no valid text can be found  to  use  in
the  label  name,  instead  of creating a label starting with "lbA", ReSource
creates the label "ascii.MSG", or "ascii.MSG0", or "ascii.MSG1", etc.

References  to   the   START+$FFFFFFFC   and  START+$FFFFFFF8  are  shown  as
"ProgStart-4"  and  "ProgStart-8"  respectively.  If the label "ProgStart" is
not defined anywhere, it will be displayed as a label attached to  the  first
byte  of  the  current file.  You can still have some other label attached to
the start of the file.

2.9        LOCAL MACROS/:
2.10        GLOBAL MACROS/:
Much background information is required here: The macro facilities  available
in  ReSource are quite extensive.  There are a maximum of 38 macros available
on line at one time.  These are divided into two banks of 19  macros,  called
"LOCAL  MACROS"  and "GLOBAL MACROS".  The idea being that the 'local' macros
are for your own personal use, and global macros are meant to be  distributed
to others.  Therefore, you can load a 'global macros' file, and use them, but
still have access to your own personal macros.

The 19th local macro is special, in that it is executed when  you  first  run
ReSource,  after  the  first  file  is loaded.  This macro will often contain
functions to set the various options to your personal taste, but may  contain
anything you care to put into it.

When first creating a macro, you will be asked to supply a name for it.  This
name will be shown in the MACRO menu immediately after, and if you save  that
bank of macros to a file, the names of the macros are also saved.

The functions "LOCAL MACROS/Execute/-unused-"  and  "GLOBAL  MACROS/Execute/-
unused-" are used to give macros in either bank a name.  These names are also
saved when you save a bank of macros, and when you load the macro file later,
these  names  will  immediately appear in the menus, making it much easier to
remember what previously created macros did.

The size of a macro is limited only by how much memory you have.  To create a
macro, select one of the sub-items in "LOCAL MACROS/Create/End/"  or  "GLOBAL
MACROS/Create/End/".   If  the  current  name for the macro is "-empty-", you
will be asked to supply a new name for the macro.  If you create a  macro  of
zero  length,  the  name for that macro will revert to "-empty-".  To execute
the macro, simply select the appropriate sub-item in "LOCAL  MACROS/Execute/"
or "GLOBAL MACROS/Execute/".

You have control over the speed at which macros execute.  The following chart
indicates whether there will be a delay, and for how long,  and  whether  the
display will be refreshed between executing functions within the macro.

   Speed Selected  Delay   Refresh
   --------------  -----   -------
     Very Fast      No       No
     Fast         No       Yes
     Slow        .1 sec    Yes
     Very Slow     .5 sec    Yes

To have complete control over execution of the macro, select  "LOCAL  MACROS/
Execution  speed/Wait  on  mouse".   With  this  selected, you must press and
release the left mouse button for each and every function within the macro to
be executed.  Combined with the "ShowMacros" utility (see further on in  this
section, and "ShowMacos.doc"), this is an excellent way of finding bugs in  a
macro that you (or someone else) has created.

Macros may be nested within macros, provided that the nesting depth does  not
exceed (approx.) 30.

While you are creating a macro, you might find that you have to execute  some
functions  to continue the macro definition, but you don't want them included
in the macro itself.  When this occurs, select "LOCAL  MACROS/Suspend  learn/
suspend",  select  the  various  functions  that need to be done, then select
"LOCAL MACROS/Suspend learn/Normal" to continue the macro definition.

There are many functions that will make a macro fail, when  it  is  executed.
For  example,  using  a  cursor movement function that would place the cursor
outside of the current file, will cause a macro 'fail'.  A failed search will
also cause a macro 'fail'.  When executing a macro,  if  ReSource  detects  a
macro  'fail', it searches forward in the macro definition for a "Conditional
end" directive.  Is none is found, all macro processing  aborts  immediately.
If  one  IS found, macro processing continues normally from that point in the
macro definition.  If, while searching for a "End conditional"  directive,  a
"Start  conditional"  directive  is  found,  the  next  "End  conditional" is
skipped.  Thus, conditional macro processing may be nested.

There are five macro labels available.   These  are  placed  into  the  macro
definition,  and  you  can  insert "goto previous macro label" and "goto next
macro label" directives into the macro definition,  which  when  found,  will
start  a  search either forward or backward, for the appropriate macro label.
When found, macro processing will proceed normally from that  point  forward.
Thus,  you can loop a macro.  If a search is made backwards for a macro label
that is non-existent, macro processing will continue from the  start  of  the
macro definition.  If a search is made forward for a macro label that is non-
existent,  the  macro  will  exit, possibly to another macro that called this
one.  For example, the following macro will continuously  scroll  forward  to
the  end of the file, then scroll backwards, one line at a time, to the start
of the file, then forward to the end of the file again,  etc.,  indefinitely,
stopping only when you select "PROJECT/Abort":

    LOCAL MACROS/Set macro label/#1
    CURSOR/Relative/Next line
    LOCAL MACROS/Previous macro label/#1
    LOCAL MACROS/Directives/End conditional
    LOCAL MACROS/Set macro label/#2
    CURSOR/Relative/Previous line
    LOCAL MACROS/Previous macro label/#2
    LOCAL MACROS/Directives/End conditional
    LOCAL MACROS/Previous macro label/#1

Notice that the directive "Start conditional" was not required in  the  above
example, as conditional sections were NOT nested.

When you are creating a macro, and you are asked for a string (even the  name
of  a  file  to load), if you select "okay" or press return after supplying a
string, the string will be stored in the macro definition, and will  be  used
when  the  macro  is  later executed, unless at the time that you execute the
macro, "LOCAL MACROS/Interactive/" has been set to "ON". In  this  case,  you
will  be  prompted for any strings that are requested during the execution of
the macro.  Normally, this will not be required, but it does  give  you  more
control  over  an  executing  macro,  especially if it was created by someone
other than yourself.

If, when creating a macro, you are asked for a string, and you want to  force
the  user  to  input  a  string during the execution of the macro, you should
select the "cancel" gadget in the string  requester.   Any  string  that  you
typed into the requester will still be used while creating the macro, however
when  the  macro  is  executed, the user is forced to input a new string each
time, even though 'Interactive' may be set to  "OFF".   Instead  of  actually
supplying  a  string  literal  to  a  string  requester,  you may instead use
indirection, to force the string to get copied from either  the  accumulator,
or from one of the buffers A-M.  For example, if the accumulator contains the
string  "MOVE", and you wish to create a label called "MOVE", select "LABELS/
Create single/Label", and when asked for the label name, press the escape key
twice, and select the "okay" gadget, or  press  "return".   If  the  required
string  was  in buffer C, instead of pressing the escape key twice, you would
press it once, followed immediately by "C".

Buffers A-M are simply 13 separate 240-byte string buffers, in which you  can
store  any  strings  that  you  like.  A more appropriate name might be 'text
registers'.  Buffers L and M are special, in that  if  you  select  "STRINGS/
Define  string/M",  if buffer L is not empty, the string contained in it will
be used as the prompt,  in  the  requester.   This  is  handy  during  macros
functions  where  you  want to get a string from the user.  The user can then
see what the string is required for.

Normally, every function you put into a macro definition  will  be  executed.
This  does  not  always  have to be the case.  The "LOCAL MACROS/Commentary/"
functions sets the commentary level.  When creating a macro, if you  set  the
commentary  level  to  "None", it is like specifying "The functions following
are absolutely essential to the execution of this macro".   If  you  set  the
commentary level to "Full" during the creation of a macro, you are specifying
"The  functions  following  are by no means required, they are simply running
commentary, perhaps explaining what is happening in the macro at this point".
Thus, by setting the commentary level during the creation of a macro, you are
letting ReSource know how important the  functions  are,  that  follow.   The
commentary  level  may be changed many times during a macro, and for tutorial
macros, such as showing someone how to disassemble/zap a particular  program,
the  commentary  level  should  be  set appropriately.  When it comes time to
execute the macro, if the commentary level is  set  to  "Full"  by  the  user
before  the  macro  starts  executing, ALL functions within the macro will be
executed normally.  If the commentary level was set to something  other  than
"Full", only those functions in the macro that were set to a commentary level
lower  than  that  presently  set, will be executed; the rest will be skipped
over.  Examine the following example macro:

    LOCAL MACROS/Commentary level/Full
    CURSOR/Relative/Next line
    LOCAL MACROS/Commentary level/Heavy
    CURSOR/Relative/Next line
    LOCAL MACROS/Commentary level/Normal
    CURSOR/Relative/Next line
    LOCAL MACROS/Commentary level/Light
    CURSOR/Relative/Next line
    LOCAL MACROS/Commentary level/None
    CURSOR/Relative/Next line

If you set the commentary level to "None" and execute this macro, the  cursor
will  move  down  one  line.  If you set the commentary level to "Light", and
execute this macro, the cursor will move down two  lines.   If  you  set  the
commentary  level to "Full" and execute this macro, the cursor will move down
five lines.  Using the "SPECIAL FUNCTIONS/Dos command" function, you can  use
the  "SAY"  command,  to  add  speech  to  macros,  to give excellent running
commentary to tutorial macros.

While executing a macro, if you have set the  execution  speed  to  "Wait  on
mouse", you can use other functions, perhaps to scroll backwards or forwards,
to  see  what  effect  the last function had on the file.  When you press the
left mouse button to single-step the next function in the macro,  the  cursor
address  is  restored in case you didn't return the cursor to the appropriate
place within the file.  If this was not  done,  macro  processing  would  not
proceed normally from that point on.

When you load a macro file,  only  the  numbered  macros  in  the  file  will
actually  overwrite  macros  already  in  ReSource.   If  the macro file only
contains one macro, then only the one macro will be overwritten, and the rest
will remain untouched.  Thus, it is possible for a macro to load other  macro
files, giving an "overlay" effect.

Whenever functions within a macro are being executed, a very small  group  of
pixels within the title bar are constantly changed.  This is the only visible
feedback  that  you will see while executing a macro when the execution speed
is set to "Very fast".  This is also done during searches, etc.

While a macro is  executing,  if  the  "CANCEL"  gadget  is  selected  for  a
requester, the macro will abort immediately.

ReSource macro files may be disassembled, examined, edited, reassembled,  and
reused.  "ShowMacros" is a support utility on the ReSource distribution disk.
It  is  used  to  disassemble a ReSource macro file into an assembly language
source code file suitable for reassembly.  The output is compatible with both
the CAPE(TM) and Metacomco assemblers, and the output file  may  be  used  by
ReSource  as  a macro file immediately.  If not using the CAPE(TM) assembler,
after assembly you may have to strip the loader information  from  the  file.
To  do  this,  simply  load  the  file into ReSource as a load file, and then
immediately save as a binary image file.  Guidelines for  editing  the  macro
file source can be found in a separate file, "ShowMacros.doc".

2.11.1.1    STRINGS/Get/Label:
If there is a label defined at the cursor location, it will be copied to  the
accumulator.

2.11.1.2    STRINGS/Get/Symbol:
Copy the first symbol on the current line to the accumulator.

2.11.1.3    STRINGS/Get/Symbol - dest:
Copy the second symbol on the current line to the accumulator.

2.11.1.4    STRINGS/Get/Symbol value:
Get the value of the first number on the current line, and write text to  the
accumulator,  representing  that  value in hex, decimal, or binary, as set by
the "STRINGS/Accumulator/" options.  The 'operand size' will be set  by  this
function.

2.11.1.5    STRINGS/Get/Symbol value - dest:
Get the value of the second number in the current line, and write text to the
accumulator, representing that value in hex, decimal, or binary,  as  set  by
the  "STRINGS/Accumulator/"  options.  The 'operand size' will be set by this
function.

2.11.1.6    STRINGS/Get/End-of-line comment:
Copy the end-of-line comment attached to the current line to the accumulator.

2.11.1.7    STRINGS/Get/Full-line comment:
Copy the first full-line comment attached to the current line to the
accumulator.

2.11.1.8    STRINGS/Get/Search string:
Copy the current search string to the accumulator.

2.11.1.9    STRINGS/Get/Filename:
Copy the current filename to the accumulator.

2.11.1.10   STRINGS/Get/Save .asm name:
If the current file has already been saved as source code (to a ".asm" file),
copy the filename used to the accumulator.   If  the  current  file  has  not
already  been  saved, the name will be the same as the current filename, with
".asm" appended.  If "SAVE/Calculate .asm size" has been last used, the  name
will be "NIL:".

2.11.1.11   STRINGS/Get/Save .RS name:
If the current file has already been saved to a .RS file, copy  the  filename
used to the accumulator.  If the current file has not already been saved, the
name  will  be  the same as the current filename, with ".RS" appended, unless
".RS" is already appended.

2.11.1.12   STRINGS/Get/Macros filename:
Copy the current macros filename to the accumulator.

2.11.1.13   STRINGS/Get/Keytable filename:
Copy the current keytable filename to the accumulator.

2.11.1.14   STRINGS/Get/Cursor longword:
Write the data where  the  cursor  is  to  the  accumulator  in  hexadecimal,
decimal, or binary, depending on the setting of "STRINGS/Accumulator/".  This
may  be  a  byte,  word,  or  longword, depending on the setting of "STRINGS/
Operand size".

2.11.1.15   STRINGS/Get/Cursor offset:
The currently displayed cursor location is written into  the  accumulator  in
the current numeric base  as  a  longword  (the  "operand  size"  is  set  to
longwords).

2.11.1.16   STRINGS/Get/Accumulator length:
The length of the string currently in the accumulator  is  written  into  the
accumulator  in  the current numeric base.  The 'operand size' setting is not
affected, but is used to decide how many leading zeroes to use.

2.11.1.17   STRINGS/Get/Partial save size:
The number representing the difference between the partial save end  and  the
partial  save  start  is  written  into   the   accumulator  in  the  current
numeric base.  The 'operand size' is set to longwords.

2.11.1.18   STRINGS/Get/File:
You will be asked to supply the name of a file, of which up to 240 characters
will be copied into the accumulator.  The data is copied "as-is", no  hex  to
ASCII translation is performed.

2.11.1.19   STRINGS/Get/Attribute bits:
The attribute bits for the current location are copied into the  accumulator,
using  the  current  numeric  base (hex/decimal/binary).  The definitions for
these bits are described under "DISPLAY/Titlebar info/Attributes".

2.11.2.1    STRINGS/Put/Label:
If the string within the accumulator is not used as a label  anywhere  within
the  current  file, it will be used as a label on the current line.  If it is
already used as a label, then a digit is appended to  it,  and  again  it  is
tested to see if a label already exists of that name.  This continues until a
unique  label  is  created,  then that label is attached to the current line.
This is a safe way of creating labels during macros.

2.11.2.2    STRINGS/Put/Attributes:
If the accumulator contains a valid number, that number  will  overwrite  the
attributes  for  the  current  location.   The definitions for these bits are
described under "DISPLAY/Titlebar info/Attributes".

2.11.2.3    STRINGS/Put/Base register:
The support for base register-relative addressing allows any address register
to be used.  This can be done by using either "STRINGS/Put/Base register", or
"SPECIAL FUNCTIONS/Specify base register".  To use this  function,  you  must
first  place  a  number between 0 and 7 inclusive, into the accumulator.  The
current base register in use will  be  visible  in  the  "SPECIAL  FUNCTIONS/
Convert  xx(An) EA's" function; you may see "xx(A6)" instead of "xx(A4)", for
example.  For use in macros that must be able to calculate and enter the base
register number, this function must be used rather than  "SPECIAL  FUNCTIONS/
Specify base".

2.11.3.1    STRINGS/Edit functions/Clip start:
You will be asked to supply a string.  Starting from the left, each character
in the supplied string is compared to the character  in  the  accumulator  at
that  position, and if they are equal, the next character is compared, and so
on.  When either the end of one of the strings is found, or when  a  mismatch
is  found,  the  characters in the accumulator that matched are deleted.  The
question mark ("?") is used as a wildcard, and you can use the asterisk  once
only,  to  "delete  everything  until and including" the following character.
Examples follow:

   Accumulator     User-supplied string    Resulting accumulator
   -----------------------------------------------------------------
   MOVE.L        M            OVE.L
   MOVE.L        MUVE.L        OVE.L
   MOVE.L        MOV.L        E.L
   MOVE.L        move.l        MOVE.L
   MOVE.L        M?V         E.L
   MOVE.L        ???         E.L
   MOVE.L        *.          L
   MOVE.L        *M          OVE.L
   MOVE.L        ?MOVE.L        OVE.L
   _LVOAllocMem    _LVO        AllocMem
   $00000004        $000000        04

2.11.3.2    STRINGS/Edit functions/Clip end:
Similar to the above function, except clipping is performed on the end of the
accumulator string.  The question mark is still used as a wildcard,  but  the
asterisk does not have a special meaning in this function.  Examples follow:

   Accumulator     User-supplied string    Resulting accumulator
   -------------------------------------------------------------
   MEMF_PUBLIC     ?PUBLIC        MEMF
   MEMF_PUBLIC     ???         MEMF_PUB
   MEMF_PUBLIC     ?LC         MEMF_PUBLI
   meMcollAOVL_    OVL_        meMcollA

2.11.3.3    STRINGS/Edit functions/Prepend:
You will be asked to supply a string, which will be prepended  to  (added  to
the  beginning of) the accumulator, providing that the resulting string is no
longer than 240 characters.  Examples follow:

   Accumulator     User-supplied string    Resulting accumulator
   -------------------------------------------------------------
   PUBLIC        MEMF_        MEMF_PUBLIC
   AllocMemSUB     _            _AllocMemSUB
   PUBLIC        CHIP        CHIPPUBLIC

2.11.3.4    STRINGS/Edit functions/Append:
You will be asked to supply a string, which will be appended to (added to the
end of) the accumulator, providing that the resulting  string  is  no  longer
than 240 characters.  Examples follow:

   Accumulator     User-supplied string    Resulting accumulator
   -------------------------------------------------------------
   PUBLIC        MEMF_        PUBLICMEMF_
   AllocMemSUB     _            AllocMemSUB_
   PUBLIC        CHIP        PUBLICCHIP
   AllocMem        SUB         AllocMemSUB

2.11.3.5    STRINGS/Edit functions/Reverse:
The contents of the accumulator are reversed.  Examples follow:

   Accumulator     Resulting accumulator
   -------------------------------------
   PUBLIC        CILBUP
   AllocMemSUB     BUSmeMcollA
   AllocMem        meMcollA

2.11.3.6    STRINGS/Edit functions/Lower case:
Any upper case characters in the accumulator are changed to their lower  case
counterparts.  Examples follow:

   Accumulator     Resulting accumulator
   -------------------------------------
   PUBLIC0123      public01243
   AllocMemSUB     allocmemsub
   AllocMem        allocmem

2.11.4      STRINGS/Operand size/:
Some functions in ReSource require to know whether to work at the byte, word,
or longword level.  For example, "STRINGS/Get/Cursor value" could get a byte,
word, or longword  from  the  cursor  position,  and  this  is  your  way  of
specifying  at which level you wish those functions to work.  Generally, they
specify the size of the numeric operand in the accumulator.   Some  functions
that  write  a  numeric  value into the accumulator will set the operand size
themselves, others that get the value out of the accumulator need to know the
operand size.

2.11.5      STRINGS/Accumulator/:
Options control whether to write the results of any maths  functions  to  the
accumulator in hex, decimal, or binary.

2.11.6.1    STRINGS/Maths functions/Increment:
Some background information is required here: All maths functions  make  some
change  to  the  number  within  the  accumulator.   If the string within the
accumulator is not a valid number (hex, decimal or binary), the function will
fail.  Some functions are immediate, others will ask the user for a  required
operand, such as what to add to the accumulator.

The increment function adds one to the accumulator.  If the resulting  number
develops  a  carry  (using  the  current  operand  size), a macro 'fail' will
result.  Thus, loops in macros can exit after a given number  of  iterations,
rather than a failed search, etc.

2.11.6.2    STRINGS/Maths functions/Decrement:
Similar to the above  function,  except  that  one  is  subtracted  from  the
accumulator.   If a carry results, a macro 'fail' will occur.  Thus, loops in
macros can exit after a given number of  iterations,  rather  than  a  failed
search, etc.

2.11.6.3    STRINGS/Maths functions/Add:
You will be asked for a number, to be added to the accumulator.  If  a  carry
results, a macro 'fail' will occur.

2.11.6.4    STRINGS/Maths functions/Subtract:
You will be asked for a number, to be subtracted from the accumulator.  If  a
carry results, a macro 'fail' will occur.

2.11.6.5    STRINGS/Maths functions/Multiply:
You will be asked for a number, to be multiplied by  the  number  within  the
accumulator.   If  a  carry  results, a macro 'fail' will occur.  Full 32-bit
multiplies are supported, however the setting of 'operand size' is used  when
determining the size of the operands.

2.11.6.6    STRINGS/Maths functions/Divide:
You will be asked for a number.  The contents  of  the  accumulator  will  be
divided by the number that you specify.  The divide function does NOT operate
on  32-bit  operands,  but  otherwise  will work at the currently set operand
size.  If the current operand size is set to longwords, the  divide  will  be
performed on the lower 16 bits only.

2.11.6.7    STRINGS/Maths functions/Negate:
The number within the accumulator is negated, using the currently set operand
size.  If the result is zero, a macro 'fail' will result.

2.11.6.8    STRINGS/Maths functions/Logical NOT:
The number within the accumulator is NOT'd  in  bitwise  fashion,  using  the
currently  set  operand  size.   If  the  result is zero, a macro 'fail' will
result.

2.11.6.9    STRINGS/Maths functions/Logical AND:
You will be asked to supply a number, which will be bitwise  AND'd  with  the
contents  of  the  accumulator,  and  the  result  is  stored  back  into the
accumulator.  If the result is zero, a macro 'fail' will result.

2.11.6.10   STRINGS/Maths functions/Logical OR:
You will be asked to supply a number, which will be  bitwise  OR'd  with  the
contents  of  the  accumulator,  and  the  result  is  stored  back  into the
accumulator.  If the result is zero, a macro 'fail' will result.

2.11.6.11   STRINGS/Maths functions/Exclusive OR:
You will be asked to supply a number, which will  be  bitwise  exclusive-OR'd
with  the contents of the accumulator, and the result is stored back into the
accumulator.  If the result is zero, a macro 'fail' will result.

2.11.6.12   STRINGS/Maths functions/ROR:
The contents of the accumulator will be bitwise rotated once right,  and  the
result  is stored back into the accumulator.  The accumulator size is used to
determine whether 8, 16, or all 32 bits will be rotated.  If the  accumulator
does not contain a valid numeric value, a macro 'fail' will result.

2.11.6.13   STRINGS/Maths functions/ROL:
The contents of the accumulator will be bitwise rotated once  left,  and  the
result  is stored back into the accumulator.  The accumulator size is used to
determine whether 8, 16, or all 32 bits will be rotated.  If the  accumulator
does not contain a valid numeric value, a macro 'fail' will result.

2.11.7      STRINGS/Define string/:
These functions allow to you define the contents of either  the  accumulator,
or  one of the string buffers A-M.  Whenever you are asked for a string using
the simple string requester (NOT the large file requester),  you  can  either
type in a string literal, or input an escape character (just press the escape
key),  followed by either another escape character, or one of the letters A-M
inclusive.  If the second character is the escape character, the string being
requested will be  copied  from  the  accumulator  instead.   If  the  second
character  that  you typed (after the escape character) is one of the letters
A-M, then the  string  being  requested  will  instead  be  copied  from  the
appropriate buffer A-M.  This applies even when you are defining the contents
of  one  of  the  string buffers.  This method of using indirection should be
particularly handy in sophisticated macros.

The maximum string length in any buffer (including the  accumulator)  is  240
characters.

2.11.8     STRINGS/Swap with buffer/:
The contents of the accumulator is swapped with the contents  of  the  buffer
that you select.

2.11.9     STRINGS/Input buffer/:
The Input and Output buffers  can  be  used  to  buffer  textual  information
between  a file and the accumulator within ReSource.  To transfer information
into ReSource, you load the input buffer, using "Load", and transfer  a  line
at  a  time to the accumulator, using "Read line".  Each time you read a line
from  the  input  buffer,  it  replaces  the  contents  of  the  accumulator.
Successive  uses  of  "Read  line"  will  get successive lines from the input
buffer.  A line means all text up to  a  line  feed,  to  a  maximum  of  240
characters.   The  line  feed  is  NOT  transferred, as the line will be null
terminated within the accumulator.  To start reading lines from the start  of
the  buffer again, use "Restart".  For example, you may have a list of labels
that you wish to put into the current file.  Use "Load" to get  the  list  of
labels into the input buffer, then create a macro something like:

    CURSOR/Relative/Next label
    STRINGS/Input buffer/Read line
    STRINGS/Put label
    LOCAL MACROS/Previous macro label/#1

The first function will advance the cursor to the  next  label.   The  second
function  reads  the  next  label  to  use  into  the accumulator.  The third
function will replace the current label with the one in the accumulator.  The
last function ("LOCAL MACROS/Previous macro label/#1") is optional.  It  will
make  the  function repeat for the entire file, or the entire list of labels,
whichever ends first.

2.11.10    STRINGS/Output buffer/:
The output buffer is used to hold information that  you  wish  to  save  from
ReSource.   The  idea here is that you append the contents of the accumulator
to the end of the output buffer, and eventually save the entire  contents  of
the output buffer to a file.  For example, you might wish to create a list of
labels  for  the  current file (see "STRINGS/Input buffer/:").  The following
macro will do this:

Note: Prior to actually running this macro, you should ensure that the cursor
is at the start of file, and use the function "STRINGS/Output  buffer/Clear",
to ensure the output buffer is empty.

    CURSOR/Relative/Next label
    STRINGS/Get/Label
    STRINGS/Edit functions/Append
    STRINGS/Output buffer/Append accumulator
    LOCAL MACROS/Previous macro label/#1

The first line will move the cursor to the  next  label  in  the  file.   The
second  function  will put the current label into the accumulator.  The third
function will prompt you for a string to append to the accumulator.   A  line
feed  (ASCII  value  10) is required here, to do this, first click inside the
requester string gadget, hold down the ctl key, and  press  "J",  then  press
return  or  click on the "OKAY" gadget.  The fourth function, "STRINGS/Output
buffer/Append accumulator", will add the current contents of the  accumulator
to  the  end  of  the Output buffer.  Memory is dynamically allocated for the
output buffer, so maximum size is only determined  by  how  much  memory  you
have.   The  fifth function is optional, use it if you want the macro to loop
until all labels in the current file are added to the  list.   Once  this  is
done,  use  "STRINGS/Output  buffer/Save" to save the current contents of the
output buffer.  You will be asked for a filename to use.  In  practice,  most
people will probably combine several pieces of information for each line that
gets  appended  to  the  output buffer, such as label, followed by its offset
from the start of the file, or its data type, etc.

2.12.1     SPECIAL FUNCTIONS/Repeat last command:
Repeat the last function used.  Cursor movement functions are  NOT  repeated,
except  the  search  functions.   This  function  should  be bound to a high-
priority key, such as the space bar, for best effect.

2.12.2     SPECIAL FUNCTIONS/Dos Command:
You will be asked for a string, which will be given as the operand to the Dos
"execute" function.  Anything that you normally type into a CLI  window,  you
can  give  as a command.  Any output will go to the CLI window from which you
started ReSource, unless  you  redirect  the  output  elsewhere.   The  "Run"
command must be in your C: directory.

2.12.3     SPECIAL FUNCTIONS/Zap:
You will be asked for a number/string, which will  overwrite  the  byte/word/
longword/characters  at the cursor position.  The current setting of 'operand
size' is  used.   Using  "PROJECT/Open  binary  file",  then  this  function,
followed  by  "SAVE/Save binary image/ALL", you can quickly modify a program,
without having to  go  through  the  disassemble/edit/reassemble/link  cycle.
However, when using this method of modification, you are restricted as to the
size  of  changes  that  may be legally made.  For example, you cannot insert
extra code or data, nor can you delete it.  You may "NOP" it instead, though.

If the string that you supply starts with a single quote ("'"), the following
characters are treated as a string, and are copied  to  the  cursor  position
"as-is".

If the string that you supply  starts  with  "$",  the  following  number  is
assumed  to  be  hexadecimal.  If the string that you supply starts with "%",
the number that follows is assumed to be binary, otherwise it is  assumed  to
be a decimal number.

If the string you supply starts with "l.", "w." or "b.", the number following
will be treated as a longword, word, or byte, respectively.   In  this  case,
the  accumulator  operand  size does not matter.  The case of the letter "l",
"w", or "b" may be upper or lower.

2.12.4     SPECIAL FUNCTIONS/Screen/:
"Front" moves ReSource's screen in front of all other screens.  "Back"  moves
ReSource's screen behind all other screens.

2.12.5     SPECIAL FUNCTIONS/Set task priority:
You will be asked for a number, representing the priority at which to set the
current task.  For example, if you have a  program  being  assembled  in  the
background, and you don't want it to slow down the operation of ReSource, you
might  set  the  task  priority  to  one  or  two.   Negative numbers are not
supported.  Sorry!  However, "$FF"  will  effectively  mean  "-1"  with  this
function.

2.12.6     SPECIAL FUNCTIONS/Origin/:
There is sometimes a requirement to disassemble a block of code, as if it  is
loaded  to some particular area of memory, other than that to which it is now
loaded.  For example, if you disassemble Kickstart(TM), and save  the  binary
image,  then  later load this into ReSource, it will not disassemble properly
unless ReSource "thinks" that its origin is $FC0000.  To do  this,  load  the
file,  then  use  the "Specify" option.  Both the "Specify" and "Set" set the
origin to an absolute address; the "Set" option is  the  same  as  "Specify",
except that it assumes that the current loading address is to be used.  These
options  are  really  only useful if the file is loaded as a binary image, or
from track, or memory.  If loaded from an executable, the reloc32 information
will ensure that proper relocation is done where needed.  It  is  because  no
reloc32  information  is  available when loading files other than load files,
that this function is required.  To  remove  the  origin,  so  that  it  uses
whatever actual address the file is loaded to, use the "Clear" option.

2.12.7     SPECIAL FUNCTIONS/Convert xx(An) EA's/:
These functions were specifically designed to be used when disassembling  'C'
programs,  in which an address register is frequently used as a base register
for accessing data, throughout all or most of  the  program.   Let's  use  an
example program here:

        SECTION test000000,CODE
        LEA    lbB00011E,A4    ; scanning has already been done
        LEA    0(A4),A1
        MOVE.L  $000C(A4),D0
        ...            ; rest of code

        SECTION test00011E,DATA
   lbB00011E    dc.b    'dos.library',0
        dc.l    $00010001
        END

In the above example program, the A4 register points to the start of the data
segment.  There are three ways to tell ReSource where the A4 register points;
in the above example, the "This operand" function  could  be  used  with  the
cursor  at  start  of file, or the "This address" function could be used with
the cursor at offset $00011E,  or  the  "Specify"  function  could  be  used,
supplying  a  parameter  of  "$11E".   Basically,  with this function you are
telling ReSource where the  A4  register  can  be  assumed  to  be  pointing,
relative  to  the  start  of  the  program.  After you do this, any effective
address that involves a word  offset  to  the  A4  register,  will  be  shown
symbolically.   If  you  have  selected  "Convert  xx(An) EA's/Absolute", the
effective addresses will be shown as absolute addresses.  Thus,  the  example
program above will appear as:

        SECTION test000000,CODE
        LEA    lbB00011E,A4
        LEA    lbB00011E,A1
        MOVE.L  lbL00012A,D0
        ...            ; rest of code

        SECTION test00011E,DATA
   lbB00011E    dc.b    'dos.library',0
   lbL00012A    dc.l    $00010001    ; This label will be created after
        END            ; left-Amiga mouse-button is used.

On the other hand, if you had selected "Convert  xx(An)  EA's/Relative",  the
effective  addresses would be shown as symbolic word offsets, and our example
program would look like this:

        SECTION test000000,CODE
        LEA    DT,A4        ; Note the new base label "DT"
        LEA    lbB00011E-DT(A4),A1
        MOVE.L  lbL00012A-DT(a4),D0
        ...            ; rest of code

        SECTION test00011E,DATA
   DT
   lbB00011E    dc.b    'dos.library',0
   lbL00012A    dc.l    $00010001    ; This label will be created after
        END            ; left-Amiga mouse-button is used.

The advantage here is that labels can automatically  be  created  where  they
could not before.  After more iterations, our code could look like this:

        SECTION test000000,CODE
        LEA    DT,A4
        LEA    DOSName-DT(A4),A1
        MOVE.L  Mem_Parms-DT(a4),D0
        ...            ; rest of code

        SECTION test00011E,DATA
   DT
   DOSName    dc.b    'dos.library',0
   Mem_Parms    dc.l    MEMF_CLEAR!MEMF_PUBLIC
        END

If this conversion process is not used, it is likely that  the  program  will
not  successfully re-assemble, as different assemblers will assemble the same
source code into  different  length  opcodes.   For  example,  the  Metacomco
assembler  normally  use  does  virtually no optimizing, and so the resulting
program  is  often  larger than the original, even if the source code has not
been modified.  For example, take the line:

        MOVE.L  4,A6

If absolute long addressing is used, the instruction above will  be  6  bytes
long,  whereas  if absolute short addressing is used, it will be only 4 bytes
long.  Where you wish to do EA conversions in only a portion  of  a  program,
you can set the lower and upper limits.

Changing to absolute EA's will increase the size of  the  resulting  program,
unless  you  convert  back to relative addressing, within the source code.  I
believe that one of the features of BLINK (from the Software Distillery)  can
help to make this conversion, during the link process.

This function will work for lines such as "MOVE.L #START+$xxxxxx,A5", as well
as the more usual "LEA START+$xxxxxx,A4".

Please note that this function may be used with  ANY  register  as  the  base
register.  See "SPECIAL FUNCTIONS/Specify Base Register" immediately below.

If the label, "DT", is not defined by the user, ReSource will define  it  for
you.   It  will  be attached to the last DATA hunk in the file, or if no DATA
hunks exists, the last BSS hunk, or failing that, the last CODE hunk.

2.12.7.1   SPECIAL FUNCTIONS/Convert xx(An) EA's/Disable:
This function allows one to turn off base register conversions.

2.12.8     SPECIAL FUNCTIONS/Specify Base Register/:
This function permits you to select the register to be used for base register
conversions.  See also "STRINGS/Put/Base register".

2.12.9     SPECIAL FUNCTIONS/Convert specific EA's/:
Please read  and  understand  the  "SPECIAL  FUNCTIONS/Convert  xx(An)  EA's"
functions  first!   Where  you  want  to  do  specific EA (Effective Address)
conversions, use "Set base #1" (or #2, or #3), when the cursor is the same as
where the base register can be assumed to be pointing.  Assuming that you set
base #1, and it is the A5 register that is being used as a base register, you
will then use the "Convert W/Base #1" function to convert lines like:

        MOVE.L  $0032(A5),A6 into:

        MOVE.L  lbL0014AC(A5),A6

Note here that there has not actually been an EA conversion, but a label  has
been created, the data type at label "lbL0014AC" has been determined and set,
and  a  symbol ("lbL0014AC") has been created for this line.  It is up to you
then to make the necessary changes to  the  resulting  source  code,  if  re-
assembling  is required.  Whereas the "Convert xx(An) EA's" function converts
immediately and automatically, you must use the "Convert W/Base #1"  function
on  each  line that you want converted.  If you wish to convert a destination
address, use the "SYMBOLS 1/Set Source/dest/Destination" function first.

2.12.10    SPECIAL FUNCTIONS/Data type set/:
These functions affect how  the  "SPECIAL  FUNCTIONS/Convert  specific  EA's"
functions  work.  When the data type must be determined, it can be automatic,
or you can force it to be set to Bytes, Words, Longwords, ASCII, Code.

2.12.11    SPECIAL FUNCTIONS/Convert to../:
The setting here will determine the type of symbol created when the  "SPECIAL
FUNCTIONS/Convert  specific  EA's"  functions are used, either an Absolute or
Offset value.

2.12.12    SPECIAL FUNCTIONS/Reloc32/:
Use these functions to specifically delocate or relocate  the  current  file.
This  is only useful if the file was loaded from an executable, where reloc32
information is present.  Be aware that relocation  is  performed  immediately
after  the  "PROJECT/O'lay  binary  image"  function, when a file is actually
loaded.

2.13       SAVE/:
It is possible to append to files when saving, rather than  simply  replacing
them.   To  do  this, the filename that you supply must start with "*>".  For
example, if you wish to append information  to  the  file  "ram:MySavedFile",
when asked for a filename, you would type "*>ram:MySavedFile".  This is valid
for *any* file save, including screen saves, binary image saves, etc.

2.13.1     SAVE/O/P Directory:
You will be asked to supply the name of a directory.  Whenever you are  asked
to  supply the name of a file to save source code to, the name will have this
directory name prepended to it.  For example, if you supply the string "RAM:"
as the output directory name, and the current filename is "c:stack", when you
select "SAVE/Save .asm/ALL", the new name to save to will be "RAM:stack.asm".

2.13.2.1   SAVE/Partial save/Reset start:
The start for partial saves defaults  to  the  start  of  the  current  file.
Selecting this will restore the default value.

2.13.2.1   SAVE/Partial save/Set start:
For  any  partial  saves,  the current cursor position when this function was
executed will be where the save will start from.  Make your desired  starting
point  the  current line and select this function.  By default, this position
is equivalent to the start of the file.

2.13.2.2   SAVE/Partial save/Set end:
For any partial saves, the current cursor position  when  this  function  was
executed will be where the save will end.  Make your desired ending point the
current  line  and select this function.  If this happens to be the last line
in the file, any partial save will include  the  last  line.   Normally,  the
partial save will NOT include the line where the partial save end is set.

2.13.2.4   SAVE/Partial save/Reset end:
The end for partial saves defaults to the end of the current file.  Selecting
this will restore the default value.

2.13.3     SAVE/Save binary image/:
Save the current buffer contents "as-is", to a file.  If the file was  loaded
with "PROJECT/Open load file", and was NOT loaded as a binary image file, the
resulting  saved file will NOT be the same as that originally loaded, because
the loader information, and relocation information, has  been  stripped.   If
you  wish to load a file, and then save it exactly as it was loaded, you must
use "PROJECT/Open binary file".  Even though you may have disassembled memory
directly, or read tracks from a floppy disk, it does NOT stop you from saving
the binary image.  Once something is loaded into ReSource, it can be saved as
source code, as a binary image file, directly to memory, or it can be written
directly to a floppy disk,  to  a  specific  sector  or  track.   This  gives
fantastic  flexibility  for general hacking, for as little as one byte of the
current buffer can be saved to memory, to a binary image file, or  as  source
code.   Track writes must be in multiples of 512 bytes.  However the clipping
is done for you.

Save "Partial" is similar to the above function, except only the data between
the partial save start and the partial save end is saved.

2.13.4     SAVE/Save .asm/:
You will be asked to supply the name of a file to save source  code  to,  for
the  entire  current buffer contents.  The output will be very similar to how
you see it on the display.

Save "Partial" is similar to the above function, except  only  the  code/data
between the partial save start and the partial save end is saved.

It is possible to abort from a "Save .asm", by using  the  normal  abort  key
sequence  (rAmiga-A).   The  file  will still be created, but no further text
will be saved to it.

When using "SAVE/Save .asm/Partial"  or  "SAVE/Calc  .asm  size/Partial",  no
EQUate or Xref table will be created.

During the functions "SAVE/Calculate .asm size/" and "SAVE/Save  .asm/",  for
any  lines  which  create code or data which will not assemble correctly (odd
address, "START+" references, invalid code "????"), an address will be pushed
onto the cursor stack, pointing to the start of each of these  lines.   Thus,
after  using  one of these functions, use "CURSOR/Absolute/Previous location"
to go directly to each erroneous line.  This is an excellent way  to  quickly
ensure that the source code you create will assemble properly.

You may have noticed a funny looking squiggle ";_[]" near the  start  of  the
source  output,  this  is  a  hook  for a profiler to be released in the near
future.

2.13.5.1   SAVE/Calculate .asm size/ALL:
Calculates the size of the source code file that would result if you had used
the "SAVE/Save .asm/ALL" function.

2.13.5.2   SAVE/Calculate .asm size/Partial:
Calculates the size of the source code file that would result if you had used
the "SAVE/Save .asm/Partial" function.  If "Start" and "End"  have  not  been
set  previously,  they  will  default  to the start and end of the file as it
exists in ReSource.

2.13.6     SAVE/Save to memory/:
You will be asked to supply a memory address to  save  the  contents  of  the
current  buffer.   The  buffer  will  be  saved  "as-is"; NOT as disassembled
source.  Care should be taken with this function,  as  a  system  crash  will
likely  result  if  you  supply  the wrong address.  By finding out where the
current buffer is in memory, (by using "DISPLAY/Cursor Address/Absolute")  it
is  possible  to  copy  one part of the current buffer to another part.  This
will require judicious use of "SAVE/Save to memory/Partial".

Save "Partial" is similar to the above function, except that  only  the  data
between the partial save start and the partial save end is saved.

2.13.7     SAVE/Save tracks/:
You will be asked for a string representing where to  start  writing  tracks.
The  first  parameter  you  give  must  be  either "DF0:", "DF1:", "DF2:", or
"DF3:". The second parameter is the starting cylinder to save to.  The  third
parameter  is optional, and represents an offset, in sectors, where the track
write is to start.  For example, to save sector #3 on cylinder 5 on DF2:, the
parameters required would be "DF2: 5 3".  To save  to  the  first  sector  on
DF0:,  the  parameters  required would be "DF0: 0".  Whole sector writes ONLY
are done, clipping is performed automatically.

Save "Partial" is similar to the above function, except that  only  the  data
between  the  partial  save  start  and  the  partial  save  end  is   saved.
Furthermore, only even multiples of 512 bytes will be written.  For  example,
if the partial save size is 1027 bytes, only two sectors (1024 bytes) will be
written to the disk.

2.13.8     SAVE/Save screen:
This function will prompt you for the name of a file.  If  the  file  can  be
opened,  it will save the currently displayed text to that file.  Use this to
send a screen dump to the printer, or any other file.  Note that this can  be
used at the completion of a "save .asm", to get a printout of the source code
profile.   Almost  any function will cause a display refresh, so this must be
the first function used.  If you have to re-activate  ReSource's  window  for
any  reason,  in  order  to  avoid  refreshing  the display (and erasing this
information in doing so), place the mouse pointer at the extreme left edge of
the screen, then press the LMB.

2.13.9     SAVE/Tabs/:
Use to select between real tabs (ASCII value 9) and spaces being used in  the
output source code as separators.

2.13.10    SAVE/Symbol table/:
When creating symbols, either automatically or manually, if  the  setting  of
this  function  is  to something other than "None", the value and name of the
symbol is stored, so that when the source code is saved, an equate table,  or
XREF  table  can be generated.  If this function is set to "EQUate", a symbol
table similar to the following will precede the source  code  in  the  output
file:

   AG_OpenLib      EQU     $00030000
   AO_DOSLib        EQU     $00008007
   AT_Recovery     EQU     $00000000
   _LVOAlert        EQU     $FFFFFF94
   _LVOClose        EQU     $FFFFFFDC
   _LVOCreateProc  EQU     $FFFFFF76
   _LVOCurrentDir  EQU     $FFFFFF82

If, instead, this function is set to "XREF", a symbol table  similar  to  the
following will preceed the source code in the output file:

            XREF    AG_OpenLib
            XREF    AO_DOSLib
            XREF    AT_Recovery
            XREF    _LVOAlert
            XREF    _LVOClose
            XREF    _LVOCreateProc
            XREF    _LVOCurrentDir

2.14.1     OPTIONS 1/Show offsets/:
For lines displayed without labels, the current  offset  (relative  from  the
start  of  the  file) will be displayed where the label is usually displayed.
If "DISPLAY/Set counter" is used, offsets  will  be  relative  to  where  the
counter was set.  Do not save your source for reassembly with  this  function
enabled as it will cause your source to not assemble properly.

2.14.2     OPTIONS 1/Display beep/:
Many functions demand attention from the user, and a  DisplayBeep()  is  used
for  this  purpose.   Normally, this will make the screen flash.  However, if
you have run the program "BeepIt", or a  similar  DisplayBeep()  replacement,
you  will  hear an audible "beep" instead.  If you don't appreciate the beep,
then switch it off.

2.14.3     OPTIONS 1/User feedback/:
Many functions will give informative messages, to let the user know  what  is
happening  internally.   If you don't appreciate the feedback, then switch it
off.

2.14.4     OPTIONS 1/Feedback Delays/:
If you have User feedback set to "OFF", then the setting of this function  is
irrelevant.   If  feedback  is  ON,  you  may occasionally find that feedback
messages are being displayed  too  fast  for  you  to  read  them.   This  is
especially  so  when opening a load file, since as many as thirty informative
messages can be displayed in between raster scans, which means that you don't
actually get to see any of the messages at all.   If  normal  text  rendering
were used, rather than using the special rendering routines in ReSource, this
would  probably  not be a problem, as the writing of the text itself would be
done much slower, and you would probably get time to read at  least  some  of
the messages.  If you set feedback delays to "ON", there will be a one second
delay after each message is displayed, which should be plenty of time to read
each  message.   While  you  hold the menu button down, feedback messages are
skipped altogether.

2.14.5     OPTIONS 1/Labels/:
If this option is set to ON, labels will be displayed.  This is the default.

2.14.6     OPTIONS 1/Hidden labels/:
If this option is set to ON, hidden labels (labels attached to a byte in  the
middle of a line of code/data) will be displayed.  This is the default.

2.14.7     OPTIONS 1/Symbols/:
If this option is set to ON, symbols will be displayed.  This is the default.

2.14.8     OPTIONS 1/End-of-line comments/:
If this option is set to ON, end-of-line comments will be displayed.  This is
the default.

2.14.9     OPTIONS 1/Full-line comments/:
If this option is set to ON, full-line comments will be displayed.   This  is
the default.

2.14.10    OPTIONS 1/Chip-load info/:
If this option is set to ON, where a section statement is displayed, and that
section either is forced to load into chip memory, or is forced to load  into
fast  memory, a ",CHIP" or ",FAST" will be appended to the section statement.
Not all assemblers support this parameter for the section statement,  so  you
may want to switch this option OFF if your assembler can't handle it.

2.14.11    OPTIONS 1/Section statements/:
If this option is set to ON, section statements will be displayed.   This  is
the default.

2.14.12    OPTIONS 1/End statement/:
If this option is set to ON, the "END" statement will  be  displayed  as  the
last line in the file.  This is the default.

2.14.13    OPTIONS 1/DCB statements/:
If this option is set to  ON,  "dcb"  type  statements  will  be  used  where
appropriate.  This is NOT the default.  For example, the following data:

        dc.b    0
        dc.b    0
        dc.l    7
        dc.l    8
        dc.l    8
        dc.l    8
        dc.l    8
        dc.l    8
        dc.l    8

will be shown as:

        dcb.b    2,0
        dc.l    7
        dcb.l    6,8

This is useful for shrinking the required .asm file  size,  especially  where
there are large areas of zeroes.

2.14.14    OPTIONS 1/Reference recognition/:
If this option is set to  ON,  references  to  memory  locations  within  the
current file are recognized.  For example, assuming that the absolute address
of  the start of the current file is at $200000, the following lines might be
displayed with Reference recognition ON:

        dc.l    $48638335
        dc.l    START+$1097
        dc.l    START+$3086

whereas if reference recognition was OFF, it would be displayed as:

        dc.l    $48638335
        dc.l    $201097
        dc.l    $203086

Reference recognition is ON by default.  If any pointer (32  bits)  is  in  a
reloc32  area,  the reference will be recognized regardless of the setting of
this option.

2.15.1     OPTIONS 2/Short branches/:
If this option is set to ON, any short branches will be  displayed  as  such,
with  the  ".S" appended to the opcode.  This is the default.  Note that this
option will NOT show you all POSSIBLE short branches,  only  those  that  are
already present in the code that's being disassembled.

2.15.2     OPTIONS 2/Separate labels/:
Under normal conditions, if a label is  longer  than  20  characters,  it  is
broken at that point, and the remainder is shown  on  the  next  line.   This
option  forces the entire label, regardless of its length, to be shown on one
line.

2.15.3     OPTIONS 2/Label colons/:
This option will display colons ,":", after all labels.

2.15.4     OPTIONS 2/Leading zeroes/:
Use these options to specify whether or not you wish the  leading  zeroes  on
hex values to be shown, e.g., "$0000003A" versus "$3A".

2.15.5.1   OPTIONS 2/Assembler/Metacomco:
This function specifies output suitable for the  Metacomco  assembler.   This
works with CAPE(TM) as well, although smaller files will result with CAPE(TM)
output.

2.15.5.2   OPTIONS 2/Assembler/CAPE:
This  function   specifies   output  suitable  for  the  CAPE(TM)  assembler.
Currently,  "dc.b" will be shown as "db", "dc.w" is shown as "dw", and "dc.l"
is shown as "dl".

When the selected assembler type  is  "Cape"  or  "CaPatch",  the  directives
"bnryonly", "exeobj" and "objfile" are used where appropriate.

2.15.5.3   OPTIONS 2/Assembler/CaPatch:
Source code produced for this assembler uses the "DX" directive,  to  support
uninitialized data areas.  This is the extra space at the end of data or code
hunks,  that  appears to be BSS, but is actually attached to the data or code
hunk.  Other assemblers would use the "DS" directive instead, which makes the
resulting program much larger than the original.   This  was  not  previously
available to assembly language programmers.

2.15.6     OPTIONS 2/Auto labels/:
This  function   determines   whether  the  "LABELS/Create  multiple/Reloc32"
function is called automatically after every "Open load file".

2.15.7     OPTIONS 2/Verbose saves/:
The "SAVE/Save .asm" functions give you a profile of the source code as it is
saved.  This may be disabled by selecting the  new  "OPTIONS2/Verbose  saves/
OFF"  function.   Each  entry  in  the  displayed  table  is  counted as that
condition occurs during the save, and the totals are displayed  continuously.
It is possible to get a printout of this and any other  screen  in  ReSource,
using  the  new  "SAVE/Save  screen" function (see below).  Speed penalty for
enabling this function is approx. 20%.

2.15.8     OPTIONS 2/Multiple constants/:
For byte, word, and longword lines, this option allows you to have many  data
constants  displayed on each line, rather than just one.  ReSource will limit
the number of constants to your display width.

2.16        KEY BINDINGS/:
Every function in ReSource can be found in the menus.  You do not need to use
any keys at all, but you probably will want to.  You can bind any function to
any key, however there is just one function that makes no  sense  to  rebind,
and that is the "PROJECT/Abort" function.  Both Amiga-keys are supported, you
may use shift, alt, ctrl, lAmiga, rAmiga, shift-alt, shift-ctrl, alt-ctrl, or
shift-alt-ctrl, in  combination with any non-qualifier key, as a distinct key
to which to bind a function.  You may, of course, also use non-qualifier keys
by themselves.  Thus, you have complete control  over  which  keys  do  what.
After  re-binding some keys, you will probably want to save the keytable.  If
you save the keytable as "S:RS.keytable", it will be loaded  every  time  you
run  ReSource.   You may want to create several keytables, suitable for doing
differing program types (C, assembler, etc.). If a keytable file  is  loaded,
ALL  current  key bindings will be overwritten by the bindings present in the
keytable.  If you  don't  load  any  keytable,  and  ReSource  couldn't  find
"S:RS.Keytable" when you first ran it, some keys will still be bound:

    right-Amiga Q        PROJECT/Quit
    right-Amiga O        Open load file
    up arrow        CURSOR/Relative/Next line
    down arrow        CURSOR/Relative/Previous line
    right arrow        CURSOR/Absolute/Fwd reference
    left arrow        CURSOR/Absolute/Previous location
    shift-up arrow      CURSOR/Relative/Previous page
    shift-down arrow    CURSOR/Relative/Next page

To rebind a key, select "KEY BINDING/Rebind key", and follow the  prompts  in
the title bar.

2.17        Credits
This  manual  was written by Glen McDiarmid, the author of ReSource, and Jeff
Lavin.

Layout  and   typesetting  done  by  Jeff  Lavin  on  an  Amiga  1000,  using
Professional Page, and an NEC SilentWriter LC 890.

Much thanks to Doug Sears  and  Grace  Lavin  for  ideas,  proofreading,  and
general support.

Printing done by Eugene Print of Eugene, Oregon.

Index