Mapamiga

"Mapping the Amiga" by Rhett Anderson and Randy Thompson.
A comprehensive
guide to the inner world of the Amiga. Covers libraries and hardware
registers. Examples in C, Assembly Language, and Modula 2.
Preface
There are so many programming books for the Amiga. Why should there be
another one?
Frankly, we wrote this book for ourselves. When we sit down to program,
we find that no single book is enough. The typical Amiga programmer may
have Commodore's official reference manuals, several Sybex, Abacus, and
COMPUTE! books, the complete set of Amiga Transactor magazines, and even
several printouts of downloaded programming information and source code, all
scattered across desks, chairs, and, of course, the floor. As you know, program-
ming the Amiga is a tough job. You might spend an hour just tracking down
the right source. What is the solution to this problem?
We turned for inspiration to two books that helped us in the past: Mapping
the Atari by Ian Chadwick (1983, COMPUTE! Books) and Mapping the Commo-
dore 64 by Sheldon Leemon (1984, COMPUTE! Books). These books had it
all-explanations of how the respective machines organized memory, detailed
listings of what various memory locations were and how to use them, descrip-
tions of input/output registers, and discussions of the functions of various
ROM routines.
These books were so detailed a programmer could literally write a program
without putting fingerprints on a single other book.
But of course you can't really do the same thing for the Amiga. The above-
mentioned books were slightly over 200 pages. This book is more than twice as
large and comes nowhere near to saying everything that can be said about the
Amiga. If the Apple II's built-in software and hardware is an apartment, and the
Commodore 64's is a townhouse, then the Amiga's is a Manhattan city block.
And the problem is not just a matter of scale. Unlike earlier computers, the
Amiga doesn't set aside areas of memory for this or that purpose. Instead, the
Amiga has libraries of routines, which can show up virtually anywhere in the
RAM space of the machine. These routines aren't even all in ROM; some are
loaded from disk. The screen is not in a fixed location. Commodore even
threatens that the locations of the memory-mapped custom chips may change
at any time. The Amiga doesn't go through all these contortions to be contrary.
Instead, this level of indirection provides the Amiga with prodigious flexibility.
Libraries and devices are easily upgraded and added. Peripherals and input de-
vices are easily accommodated.
Aware of the problems of scale and flexibility, we set out to accomplish a

different and (somewhat) more reasonable task: to enable a programmer to use
our book as a reference work that answers 90 percent of his or her questions.
This task took the two of us a year. We couldn't have done it alone. We'd like
to thank Stephen Levy, our editor, for his patience. We would also like to
thank our friends and co-workers at Amiga Resource and COMPUTE!, and also,
especially, our wives, for putting up with months of odd moods and the occa-
sional bout of crankiness. A special thanks goes out to Sheldon Leemon for his
many suggestions and observations.
How to Use This Book:

First, we suggest a little window shopping. Browse among the chapters and the
appendices. Ever wonder how the blitter works? Curious about the HAM video
mode? Cruise through the Hardware chapter. Want to know how the Amiga
organizes its data? Want to know how to use the Amiga's built-in functions?
The Structures and Libraries chapters tell you. Becoming familiar with the
structure and content of the book will pay off later.
If you're an expert programmer, we suggest a quick scan of the book.
You'll probably use this book as a reference. Read the introductions to each
chapter, and don't forget to check out the appendices.
The majority of the book consists of tables and charts-a compilation of
vital programming information organized in understandable and usable for-
mats. Much of this information can't be found in any other single place. For ex-
ample, where else can you find a complete listing of library functions that gives
the syntax of each function in C, machine language, and Modula-2?
Each major section of the book begins with an introduction that explains
how to use the information that follows. So even if you're a beginner, you'll
find this book a great way to learn about the Amiga's inner workings.
If you already have a stable of Amiga programming books, notice how the
layouts of those books compare with ours. For instance, some books group
functions by the library in which they're found; Mapping the Amiga orders the
functions alphabetically. Knowing this can save you some time and help you
learn how to use Mapping in conjunction with your other programming books.
If you don't have any other Amiga programming books, we'd like to sug-
gest a few. Commodore's set of reference manuals (published by Addison Wes-
ley) are invaluable. Be sure to get the latest set; new examples and tables have
been included in every update so far. Sybex sells three excellent books: Eugene
Mortimore's two-volume Amiga Programmer's Handbook and Rob Peck's Pro-
gramming the Amiga. Abacus publishes many Amiga books. Our favorites are
Amiga System Programmer's Guide and Amiga Graphics Inside & Out. COMPUTE!
books also has many titles. We often turn to COMPUTE!'s Amiga Programming
Guide and Sheldon Leemon's Inside Amiga Graphics. You'll also want a manual
for the language you're using.
Programming and Mapping:

You can program the Amiga in just about any language you've ever heard of
(with the possible exception of COBOL). Each language has different syntax,
requirements, and interfacing details. For this book, we've supported the lan-
guages most familiar to us: Lattice C, M2S's M2Sprint Modula-2, and machine
language. All programming examples given in this book were written using one
of these languages. Users of other C and Modula-2 implementations should
have little trouble using this book. If you use a different language, see the man-
ual for information about how structure offsets are named and what parameters
are passed to the various system functions.
We hope this book will be useful to you. Don't hesitate to let us know
what helped you and what you found lacking. Send mail to:
Rhett & Randy

COMPUTE! Publications
324 W. Wendover Ave., Suite 200
Greensboro, NC 27408
You might also be able to find us on your favorite online service, such as
CompuServe, PLink, or GEnie. Ask your friendly local sysop.
As Bill Wilkinson said in the introduction to Mapping the Atari, good luck
and happy mapping.
Notes from BSI: It took about eight hours to scan and fix the majority of
the typos caused by the scanner (HP ScanJet+) reading bold text incorrect-
ly. For that reason, I have not scanned the "Structures" part of the book.
You can use you include files for DevPac2 instead. (Or with Lattice, or
with...) However, I have included the "hardware" part since I manually
typed that up when I first got my Amiga so I could learn where all the
hardware registers are. Enjoy the text. Any questions can be left to me
(Bansai) on Motherboard East 1.5 at 1(215)792-0167. Slates!
-------------------------
Library Functions
The Amiga is an incredibly capable machine. It has so much to offer, from digi-
tized sounds and dazzling color graphics to a window-based user interface and
a true multitasking operating system. Library functions are the key to accessing
these features.
The Amiga's library functions are similar to the Commodore 64's ROM
Kernal subroutines, the IBM PC's BIOS interrupt calls, and the Apple Macin-
tosh's Toolbox procedures-they are a collection of routines that allow you to
control almost every aspect of your computer. They're called functions because
the majority of them were written in the C programming language. In C, all
user-defined commands are referred to as functions.
Linked Libraries
There are really two types of libraries on the Amiga: linked libraries and shared
libraries. (Note: Amiga Basic and Modula-2 do not use linked libraries.)
Linked libraries are a collection of external functions that you make part of
your program. When you link your program with Alink or Blink, each linked li-
brary function you use is brought in from one of the specified .lib files and
stuffed into your program. The Lattice C file lc.lib and the Manx C file c.lib are
both examples of linked libraries.
The functions offered by a linked library are dependent upon your compil-
er or assembler. However, one linked library is common-amiga.lib. The
amiga.lib library offers common functions such as printf( ), atoi( ), and
BeginIO( ). Only amiga.lib is documented in this chapter. Language-specific
linked libraries are explained in the manual that came with your compiler or
assembler.
Using an amiga.lib function in C is incredibly easy: Simply call the func-
tion by name and then link your program with amiga.lib. For Lattice C users,
linking with amiga.lib is automatic when you use the compiler's -L option.
Other compilers simply have you provide the amiga.lib filename as one of the
library parameters in the Alink or Blink command sequence.
Accessing amiga.lib from machine language is a bit tougher. First you must
declare that function with an XREF statement, preceding the function name with
an underline character (xref _CreateExtIO, for example). Second, you must
push the function arguments onto the stack, not place them into registers. To
actually call the function you simply JSR to the function name, as in JSR
_CreateExtIO. Finally, you must remove the function arguments from the
stack- the function does not do this for you. A simple addq.l #8,sp would suf-
fice for CreateExtIO( ) since this function accepts two long words (eight bytes)
worth of arguments.
All of the amiga.lib functions are described in the function tables found at
the end of this chapter. Here's the entry for amiga.lib's printf( ) function:
-------------------------
printf
Description: prints a formatted string to the standard output (Lattice
and Manx
users: if you link with lc.lib or c.lib, this is not the function
you're
calling)
Library: amiga.lib (linked library)
Modula-2 Module: none
Syntax: printf(string, values...)
C: void printf(char *, long...)
Machine Language: move.l #value,-(sp) ;may have several values
pea string
jsr _printf
add.l #8,sp ;(2 arguments * 4 bytes = 8)
Modula-2: not available
Arguments:string = pointer to string containing optional C formatting com-
mands (%); if you're passing longword values on the stack (as
shown above), be sure to follow the percent symbol with a lower-
case L
values = values or addresses of strings to print; this routine
knows how many values are on the stack by checking the number
of formatting commands in the string argument
Result: none
-------------------------
The Machine Language entry in this table illustrates how you might call
the printf( ) function from machine language. Specifically, it shows the order in
which you must push the function's arguments onto the stack. In all cases, the
arguments are pushed onto the stack in the order opposite to that shown in the
Syntax entry (right to left instead of left to right).
In these crude machine language examples, all pointer arguments are
placed onto the stack using a PEA instruction. In actual use, the argument's ad-
dress may be contained in a register or a memory location, in which case you
would MOVE it onto the stack. The examples shown here use PEA simply so
you understand that the function expects an address and not an actual value. If
the argument is supposed to be a value, we place it onto the stack via a MOVE
instruction.
For a real-world example, the following machine language program makes

use of amiga.lib's printf( ) function to output the solution to a simple equation:
-------------------------
Program 1-1. Simple Addition
* Machine language example for using the printf( ) linked library function
* -Be sure to link with amiga.lib
* Hard-coded function offsets

OpenLibrary equ -552
CloseLibrary equ -414
Output equ -60
AbsExecBase equ 4 ;Absolute location of ExecBase pointer
XREF printf ;Declaration for amiga.lib function

XDEF SysBase ;Make this available to amiga.lib
XDEF DOSBase ;Make this available to amiga lib
XDEF stdout ;Make this available to amiga lib
SECTION code,CODE
* Short-but-effective startup code

movea.l AbsExecBase,a6 ;Pointer to IntuitionBase in a6
move.l a6, SysBase ;Store it in external location for amiga.lib
clr.l d0 ;Version number goes in d0
movea.l #DOSName,a1 ;Pointer to library's name goes in a1
]sr OpenLibrary(a6) ;Open DOS library and return libBase in d0
move.l d0, d0SBase ;Save library base pointer
beq.s Abort2 ;Abort if dos.library could not be opened
move.l d0,a6 ;Pointer to DOSBase in a6
jsr Output(a6) ;Call Output to get an output file handle
move.l d0, stdout ;and store it for amiga.lib
beq.s Abortl ;Abort if unable to get a file handle
* Main program that adds Num1 and Num2

move.l Num1,d0 ;Get Num1 into d0
add.l Num2,d0 ;Add the two numbers and put result in d0
* Call printf( ) to print the addition result in decimal and in hex format
move.l d0,-(sp) ;Push result onto stack for hex output
move.l d0,-(sp) ;Push result onto stack for decimal output
move.l Num2,-(sp) ;Push Num2 value on stack
move.l Num1,-(sp) ;Push Num1 value on stack
pea formatString ;Push address of formatString onto stack
jsr printf ;Call printf( )
add.l #20,sp ;Remove arguments from stack-
;(5 arguments * 4 bytes = 20 bytes)
* Close DOS library

Abort1:
move.l DOSBase,a1 ;Pointer to DOSBase in a1
move.l SysBase,a6 ;Pointer to ExecBase in a6
jsr CloseLibrary(a6) ;Call CloseLibrary( )
* Exit program
Abort2:
clr.l d0 ;Set return code
rts ;Drop out of program
SECTION data,DATA
Num1:
dc.l 8723 ;Value 1 that will be added to

Num2:
dc.l 434 ;Value 2
SysBase:
dc.l 0 ;Location to hold ExecBase pointer
DOSBase:
dc.l 0 ;Location to hold DOSBase pointer
stdout:
dc.l 0 ;Location to hold output handle
DOSName:
dc.b 'dos.library',0 ;Name of dos library
* The following statements define the format string to be used by printf( )

* Note that a lowercase L follows all percent symbols (%)-this is required
* if you pass your values as 32-bit quantities, as we do in this program
formatString:
dc.b '%ld + %ld = %ld (%lx hex)',10,0
END
-------------------------
Shared Libraries
When someone refers to an Amiga library, they're usually talking about a
shared library. The same is true of this book.
As the name implies, a shared library is accessible to all Amiga programs.
When you use a shared library function, its code does not become part of your
program on disk; shared libraries are located in ROM (writable control memory
on the Amiga 1000) or loaded into RAM from the libs directory of your Work-
bench disk.
Shared libraries are more memory conservative than linked libraries. Every
program that accesses a function from a linked library must contain its own
copy of that function. Only one copy of a shared library function ever needs to
be in memory because all programs have access to it.
At this writing, there are 15 libraries available with Kickstart/Workbench
1.3, each one covering a different aspect of the Amiga. For graphics program-
ming, you use the graphics.library; for creating windows, requesters, and pull-
down menus, you use the intuition.library; for disk access, you use the
dos.library.
The clist.library has been removed from Kickstart 1.2 and 1.3, but it is
available with Kickstart 1.1 and is documented here for the sake of complete-
ness. Two special libraries-romboot.library and version.library-are not cov-
ered in this chapter since the functions they contain are private to the Amiga's
system software and cannot be called by the user.
-------------------------
Opening and Closing Libraries
A library must be opened before you can access its functions. Like your local
Seven-Eleven store, the Exec library is always open. This works out rather well
considering OpenLibrary( ), the one function required to open other libraries, is
contained in Exec. When you link with startup code such as Lattice's c.o, the
DOS library is opened for you as well. If you program with M2Sprint, you'll
find that several libraries are automatically opened for you.
You open a library using the aptly named OpenLibrary( ) function.
OpenLibrary( ) expects two arguments: the library name and the library version
number. (See Table 1-2 for a complete list of available libraries.) The sample
code below shows the C, machine language, and Modula-2 syntax for using the
OpenLibrary( ) function.
In C:
libBase = OpenLibrary(libraryName,version);
In machine language:
move.l ExecBase,a6 ;Pointer to ExecBase
lea libraryName,a1 ;Pointer to the library's name goes in a1
moveq #version,d0 ;Version number goes in d0
jsr OpenLibrary(a6) ;Open library and return libBase in d0
move.l d0,libBase ;Save library base pointer
In Modula-2:
libBase := OpenLibrary(libraryName,version);
where libBase is the name of the library's base pointer, libraryName is the
name of the library, and version is the lowest acceptable version of the library
you require. In most cases, you should use a version number of 0 or 33. The
following table explains all the possible version numbers you can use:
Table 1 1. Library Version Numbers

Version Number Kickstart Version
0 Any version
30 Kickstart version 1.0
31 NTSC Kickstart version 1.1
32 PAL Kickstart version 1.1
33 Kickstart 1.2 (the oldest version still supported)
34 Kickstart 1.3
If you specify a version that is higher than what is available on the Amiga
you run your program, OpenLibrary( ) will fail and return a NULL value. If the
library is opened successfully, the base address of the library is returned in
libBase.
Table 1-2 shows the library base pointer names (libBase) and their corre-
sponding library names (libraryName) that you should use when opening a li-
brary. In machine language, you can use practically any name you choose, as
long as you define an area in memory to store the pointer and label that loca-
tion using the name you select. By convention, it's recommended you use the
library base pointer name provided in Table 1-2 and precede it with an under-
line character, as in the name _DOSBase. In Lattice C, you must use the names
given below. If you don't, your program will compile and link correctly, and
then happily guru when it is run.
Table 1-2. Library Names

Library Name Library Base Pointer Name
clist.library ClistBase (unavailable in Kickstart 1.2 and 1.3)
diskfont.library DiskfontBase
dos.library DOSBase (normally opened by startup code)
exec.library ExecBase (ExecBase found at location 4)
expansion.library ExpansionBase
graphics.library GfxBase
icon.library IconBase
intuition.library IntuitionBase
layers.library LayersBase
mathffp.library MathBase
mathieeedoubbas.library MathleeeDoubBasBase
mathieeedoubtrans.library MathleeeDoubTransBase
mathtrans.library MathTransBase
romboot.library (system private-not accessible to user)
translator.library TranslatorBase
version.library (system private-not accessible to user)
When your program is finished, you must be sure to close all of the librar-
ies you opened. To accomplish this you use yet another aptly named Exec
function, CloseLibrary( ). The only argument that the CloseLibrary( ) function
requires is the base address of the library you wish to close. This is the same
base address that was returned by OpenLibrary( ). Here are some examples on
using CloseLibrary( ):
In C and Modula-2 use:

CloseLibrary(libBase);
In machine language:
move.l libBase,a1 ;libBase goes in register a1
move.l ExecBase,a6 ;Pointer to ExecBase goes in a6
jsr CloseLibrary(a6) ;Close the library
If you neglect to close a library, you run the risk of wasting memory since
the system will not know if it can throw out an unused, RAM-based library.
-------------------------
Calling Functions
The end of this chapter contains an alphabetical listing of every user-accessible
Amiga library function. Each table entry gives the function's name; a brief de-
scription of that function; the library in which the function is contained; its
negative offset from the library base (useful to the "take charge" machine lan-
guage programmer); the Modula-2 module in which it is contained; its syntax;
its C, machine language, and Modula-2 usage; a description of its arguments
(sometimes referred to as parameters); and a description of the value (if any)
that is returned by the function. For example, here's the entry for Intuition's
OpenWindow( ) function:
OpenWindow
Description: opens an Intuition window
Library: intuition.library
Offset: -$00CC (-204)
Modula-2 Module: Intuition
Syntax: window = OpenWindow(newWindow)
C: struct Window *OpenWindow(struct NewWindow *)
Machine Language: d0 = OpenWindow(a0)
Modula-2: OpenWindow(VAR newWindow: NewWindow): WindowPtr
Arguments: newWindow = NewWindow structure that describes window to
open
Result: window = pointer to Window structure; NULL if
unsuccessful
The Syntax section gives you a general idea of what the function expects
and what it returns. If you look at the C description, you can see that
OpenWindow( ) expects a pointer to a NewWindow structure and returns a
pointer to a Window structure. The Machine Language description shows that
the Window pointer should be placed in a0 and the pointer to the opened Win-
dow is returned in d0 (all functions that return values return them in d0). For
Modula-2, you can see you must pass the function a NewWindow structure
and the value it returns is of type WindowPtr. The following C, machine lan-
guage, and Modula-2 programs are examples of how you can use this infor-
mation to open a window. Five library functions are used in these program:
OpenLibrary( ), OpenWindow( ), Wait( ), CloseWindow( ), and CloseLibrary( ).
-------------------------
Program 1-2. C Window
C code that opens a window and waits for you to close it
#include <intuition/intuition.h> /* Include Intuition stuff */
struct IntuitionBase *IntuitionBase = NULL; /* Define IntuitionBase */

struct Window *MyWindow = NULL; /* Define Window pointer */
struct NewWindow MyNewWindow = { /* Set up NewWindow structure */
0,12,
200,100,
-1 , -1 ,
CLOSEWINDOW,
WINDOWCLOSE | WINDOWDEPTH | WINDOWDRAG | WINDOWSIZING | ACTIVATE,
NULL,
NULL,
"Close Me",
NULL,
NULL,
80,24,
-1 , -1 ,
WBENCHSCREEN
};
void main()
/* Open intuition.library */
if ((IntuitionBase=(struct IntuitionBase *)
OpenLibrary("intuition.library",0))==NULL)
exit(0);
/* Open window */
if ((MyWindow=(struct Window *)OpenWindow(&MyNewWindow))==NULL) (
CloseLibrary(IntuitionBase);
exit(0);
/* Wait for user to click close box */

Wait(l<<MyWindow->UserPort->mp SigBit);
CloseWindow(MyWindow); /* Close window */

CloseLibrary(IntuitionBase); /* Close intuition.library */
-------------------------
Program 1-3. Machine Language Window
*Open a window and wait for user to close it
*Include Intuition stuff

INCLUDE "intuition/intuition.i"
*Address that holds pointer to ExecBase (this is ALWAYS 4)

ExecBase equ 4
* Hard-coded function offsets-no need to link with amiga.lib with these!

OpenLibrary equ -552
CloseLibrary equ -414
OpenWindow equ -204
CloseWindow equ -72
Wait equ -318
SECTION code,CODE
*Open intuition.library
movea.l #IntuitionName,a1 ;Library name in a1
move.l #0,d0 ;Version number in d0
movea.l ExecBase,a6 ;Pointer to ExecBase in a6
jsr OpenLibrary(a6) ;Call OpenLibrary( )
move.l d0, IntuitionBase ;Save intuition.library base
beq.s Abort2 ;Exit program if OpenLibrary fails
*Open a window
movea.l #MyNewWindow,a0 ;Pointer to NewWindow in a0
move.l IntuitionBase,a6 ;Pointer to IntuitionBase in a6
jsr OpenWindow(a6) ;Call OpenWindow( )
move.l d0,MyWindow ;Save pointer to newly opened window
beq.s Abort1 ;Exit program in OpenWindow fails
*Wait for user to click close box

movea.l MyWindow,a0 ;Pointer to window's
movea.l wd_UserPort(a0),a0 ;user port in a0
move.b MP SIGBIT(a0),d1 ;Window's signal bits
moveq.l #l,d0 ;Convert bit number to mask
lsl.l d1,d0 ;and place the result in d0
jsr Wait(a6) ;Call Wait( )
*Close the window

movea.l MyWindow,a0 ;Pointer to window in a0
jsr CloseWindow(a6) ;Call CloseWindow( )
*Close intuition.library
Abort1:
jsr CloseLibrary(a6) ;Call CloseLibrary( )
*Exit the program

Abort2:
clr.l d0 ;Set return code
rts ;Drop out of program
SECTION data,DATA
*NewWindow structure
MyNewWindow:
dc.w 0,12
dc.w 200,100
dc.b -1,-1
dc.l CLOSEWINDOW
dc.l WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG|WINDOWSIZING|ACTIVATE
dc.l 0
dc.l 0
dc.l WindowTitle
dc.l 0
dc.l 0
dc.w 80,24
dc.w -1,-1
dc.w WBENCHSCREEN
IntuitionName:
dc.b 'intuition.library',0 ;Library name
WindowTitle:
dc.b 'Close Me',0 ;Text to appear in window's drag bar
SECTION mem,BSS
_IntuitionBase:
ds.l l ;Place to store IntuitionBase
MyWindow
ds.l l ;Place to store Window pointer
END
-------------------------
Program 1-4. Modula-2 Window
MODULE SharedLibExample;
(* Modula-2 code that opens a window and waits for you to close it *)
FROM Intuition IMPORT NewWindow, WindowFlagSet, WindowFlags, IDCMPFlags,

IDCMPFlagSet, ScreenFlagSet, WBenchScreen, WindowPtr, OpenWindow,
CloseWindow;
FROM SYSTEM IMPORT BYTE, ADR, ADDRESS;
FROM Ports IMPORT WaitPort;
VAR
newWindow: NewWindow;
myWindowPtr: WindowPtr;
dummy: ADDRESS;
BEGIN
(* Setup NewWindow structure *)
WITH newWindow DO
LeftEdge := 0; TopEdge := 12;
Width := 200; Height := 100;
DetailPen := BYTE(0); BlockPen := BYTE(l);
Title := ADR("Close Me");
Flags := WindowFlagSet{Activate,WindowClose,WindowDepth,
WindowDrag,WindowSizing};
IDCMPFlags := IDCMPFlagSet{CloseWindowFlag};
Type := WBenchScreen;
FirstGadget := NIL;
CheckMark := NIL;
Screen := NIL;
BitMap := NIL;
MinWidth := 80; MinHeight := 24;
MaxWidth := -1; MaxHeight
END;
(* Try to open window *)
myWindowPtr := OpenWindow(ADR(newWindow));
IF myWindowPtr # NIL THEN

dummy := WaitPort(myWindowPtr^.UserPort);
CloseWindow(myWindowPtr);
END;
END SharedLibExample.
-------------------------
Machine Language and Function Offsets
In machine language, library functions are called with a JSR using address indi-
rect with displacement addressing mode, which generates the destination ad-
dress from the contents of register a6. For example, our previous machine
language window program contains the following instructions:
OpenWindow equ -552
move.l _IntuitionBase,a6 ;Pointer to IntuitionBase in a6

jsr OpenWindow(a6) ;Call OpenWindow( )
The MOVE instruction puts the base address of the Intuition library in reg-
ister a6. The label OpenWindow contains the offset of OpenWindow( ) function
from the base address of Intuition. The JSR instruction combines the base ad-
dress with the offset to produce an actual destination address. By putting the
base address in a6, we also tell OpenWindow( ) where its current library base is.
To tell you the truth, our machine language program is breaking a few
rules because it hard codes the library offsets in the beginning of the program
using EQU directives. Purists obtain their function offsets using XREF state-
ments. If we were to program this "by the book," the above lines would read
xref _LVOOpenLibrary
move.l _IntuitionBase,a6 ;Pointer to IntuitionBase in a6

jsr _LVOOpenWindow(a6) ;Call OpenWindow( )
so the OpenWindow( ) offset would be obtained at link time. All of the pro-
gram's library calls could (and some would say, should) be coded this way.
Where does the _LVOOpenLibrary offset come from? Besides containing
linked library functions, amiga.lib also contains the function offsets for every
Amiga library. That's why so many machine language programs must be linked
with amiga.lib. If you use the XREF method, you must precede all function
names with an _LVO in order for amiga.lib to recognize them. If you hard-
code your offsets as we did in Program 1-3, however, you can call the func-
tions whatever you like-you won't even have to take the time to link with
amiga.lib (unless, of course, you used one of amiga.lib's linked library
functions).
-------------------------
Final Notes
There are a few macros included in the following function list. Accessing a
macro is much like accessing a library function. In Modula-2, all supported
macros are defined as standard procedures and placed into modules. With C
and machine language, they are actual compiler/assembler macros that must be
included in your source code. The include file, header file, and Modula-2 mod-
ule that contains the macro definitions are included in the macro's table entry.
A few last minute points should be made regarding the terminology used
in the following list of functions: By convention, a NULL value is equivalent to
0. The Modula-2 equivalent of NULL is NIL, which is defined as ADDRESS(0).
In C, TRUE represents a nonzero value (usually equal to 1) and FALSE equals
0. In Modula-2, TRUE and FALSE are elements of the type BOOLEAN. If you
see an _fptr in a C usage description, it specifies a pointer to a function.
The following table is mainly for reference purposes-it's a place you can
look up information about any Amiga library function, quickly and easily. For
more details about using a specific function, we suggest you refer to the auto-
docs section of the Commodore-Amiga ROM Kernel Reference Manual.
-------------------------Functions Start Here-------------------------

AbortIO
Description: attempts to abort an I/O request already in progress
Library: exec.library
Offset: -$01E0 (-480)
Modula-2 Module: IO
Syntax: error = AbortIO(ioRequest)
C: long AbortIO(struct IORequest *)
Machine Language: d0 = AbortIO(a1)
Modula-2: AbortIO(ioRequest: ADDRESS): LONGINT
Arguments: ioRequest = IORequest block containing I/O request to abort
Result: error = 0 if successful; nonzero error value if
unsuccessful
-------------------------
ActivateGadget
Description: activates a string gadget so the user does not have to
click in the
gadget box to bring up a cursor
Offset: -$01CE (-462)
Syntax: success = ActivateGadget(gadget, window, requester)
C: long ActivateGadget(struct Gadget *, struct Window *, struct
Requester *)
Machine Language: d0 = ActivateGadget(a0, a1, a2)
Modula-2: ActivateGadget(gadget: GadgetPtr; window: WindowPtr; request-
er: RequesterPtr): BOOLEAN
Arguments: gadget = string gadget to activate
window = window containing gadget
requester = requester to receive gadgets; NULL if gadgets are not
to be part of a requester
Result: success = TRUE if successful; FALSE if arguments are bogus
-------------------------
ActivateWindow
Description: activates a window
Offset: -$01C2 (-450)
Syntax: ActivateWindow(window)
C: long ActivateWindow(struct Window *)
Machine Language: ActivateWindow(a0)
Modula-2: ActivateWindow(window: WindowPtr)
Arguments: window = window to activate
Result: none
-------------------------
AddAnimOb
Description: adds an AnimOb to the linked list of AnimObs
Library: graphics.library
Modula-2 Module: Gels
Offset: -$009C (-156)
Syntax: AddAnimOb(anOb, anKey, rastPort)
C: void AddAnimOb(struct AnimOb *, long, struct RastPort *)
Machine Language: AddAnimOb(a0, a1, a2)
Modula-2: AddAnimOb(anOb: AnimObPtr; anKey: ADDRESS; rastPort:
RastPortPtr)
Arguments: anOb = AnimOb structure to be added to list
anKey = address of pointer to the first AnimOb in the list
(anKey=NULL if none in list so far)
rastPort = RastPort structure
Result: none
-------------------------
AddBob
Description: adds a Bob to GEL list
Offset: -$0060 (-96)
Syntax: AddBob(bob, rastPort)
C: void AddBob(struct Bob *, struct RastPort *)
Machine Language: AddBob(a0, a1)
Modula-2: AddBob(bob: BobPtr; VAR rastPort: RastPortPtr)
Arguments: bob = Bob structure to be added to GEL list
Result: none
-------------------------
AddConfigDev
Description: adds a new ConfigDev structure to the system's list of
configura-
tion devices
Library: expansion.library
Offset: -$001E (-30)
Modula-2 Module: ConfigVars
Syntax: AddConfigDev(configDev)
C: void AddConfigDev(long)
Machine Language: AddConfigDev(a0)
Modula-2: AddConfigDev(configDev: ConfigDevPtr)
Arguments: configDef = a valid ConfigDev structure
Result: none
-------------------------
AddDevice
Description: adds a device to the system
Offset: -$01B0 (-432)
Modula-2 Module: Devices
Syntax: AddDevice(device)
C: void AddDevice(struct Device *)
Machine Language: AddDevice(a1)
Modula-2: AddDevice(device: DevicePtr)
Arguments: device = initialized device node
Result: none
-------------------------
AddDosNode
Description: mounts a disk
Offset: -$0096 (-150)
Modula-2 Module: Expansion
Syntax: AddDosNode(bootPri, flags, deviceNode)
C: void AddDosNode(long, long, struct dosNode *)
Machine Language: AddDosNode(d0, d1, a0)
Modula-2: AddDosNode(bootPri: INTEGER; flags: BITSET; deviceNode:
DeviceNodePtr): BOOLEAN
Arguments: bootPri = boot priority of disk-+5 for floppy disk, 0 for hard
disk,-5 for a network disk,-128 non-bootable device
flags = ADN_STARTPROC (1) to start handler process
immediately
dosNode = initialized device node, as returned by
MakeDosNode( )
Result: none
-------------------------
AddFont
Description: adds a font to the system
Offset: -$01E0 (-480)
Modula-2 Module: Text
Syntax: AddFont(textFont)
C: void AddFont(struct TextFont *)
Machine Language: AddFont(a1)
Modula-2: AddFont(textFont: TextFontPtr)
Arguments: textFont = TextFont structure (in public RAM) to add
Result: none
-------------------------
AddFreeList
Description: adds memory to the free list
Library: icon.library
Offset: -$0048 (72)
Modula-2 Module: Icon
Syntax: status = AddFreeList(free, mem, len)
C: long AddFreeList(struct FreeList *, char *, long)
Machine Language: d0 = AddFreeList(a0, a1, a2)
Modula-2: AddFreeList(free: FreeListPtr; mem: ADDRESS; len:
LONGCARD): BOOLEAN
Arguments: free = FreeList structure
mem = memory to record
len = length of the memory to record
Result: status = nonzero value if the call succeeded
-------------------------
AddGadget
Description: adds gadget to window
Offset: -$002A (-42)
Syntax: position = AddGadget(window, gadget, position)
C: long AddGadget(struct Window *, struct Gadget *, long)
Machine Language: d0 = AddGadget(a0, a1, d0)
Modula-2: AddGadget(window: WindowPtr; gadget: GadgetPtr; position:
INTEGER): INTEGER
Arguments: window = window to contain gadget
gadget = gadget to add
position = position in gadget list for new gadget; -1 for end of
list
Result: position = position where gadget is actually added
-------------------------
AddGList
Description: adds or inserts a gadget list to an existing gadget list
Offset: -$01B6 (-438)
Syntax: position = AddGList(window, gadget, position, numGadgets,
requester)
C: long AddGList(struct Window *, Gadget *, long, long, struct
Requester *)
Machine Language: d0 = AddGList(a0, a1, d0, d1, a2)
Modula-2: AddGList(window: WindowPtr; gadget: GadgetPtr; position:
INTEGER; numGadgets: INTEGER; requester: RequesterPtr):
CARDINAL
Arguments: window = window to receive gadgets

gadget = first gadget in new gadget list
position = position in existing gadget list where new gadget list
should be added
numGadgets = number of gadgets to add
requester = requester to receive gadgets; NULL if gadgets are not
to be part of a requester
Result: position = position where gadget list is actually added
-------------------------
AddHead
Description: inserts a node at the head of a list
Offset: -$00F0 (-240)
Modula-2 Module: Lists
Syntax: AddHead(list, node)
C: void AddHead(struct List *, struct Node *)
Machine Language: AddHead(a0, a1)
Modula-2: AddHead(list: ListPtr; VAR node: NodePtr)
Arguments: list = list header
node = node to insert
Result: none
-------------------------
AddIntServer
Description: adds an interrupt server to the system
Offset: -$00A8 (-168)
Modula-2 Module: Interrupts
Syntax: AddlntServer(intNum, interrupt)
C: void AddIntServer(long, struct Interrupt *)
Machine Language: AddIntServer(d0, a1)
Modula-2: AddIntServer(intNum: CARDINAL; interrupt: InterruptPtr)
Arguments: intNum = portia interrupt bit (0-4)
interrupt = interrupt server node
Result: none
------------------------
AddLibrary
Description: adds a library to the system
Offset: -$018C (-396)
Modula-2 Module: Libraries
Syntax: AddLibrary(library)
C: void AddLibrary(struct Library *)
Machine Language: AddLibrary(a1)
Modula-2: AddLibrary(library:LibraryPtr)
Arguments: library = initialized Library structure
Result: none
-------------------------
AddMemList
Description: adds memory to the system's pool of free memory
Offset: -$026A (-618)
Modula-2 Module: Memory
Syntax: AddMemList(size, attributes, pri, base, name)
C: void AddMemList(long, long, long, char *, char *)
Machine Language: AddMemList(d0, d1, d2, a0, a1)
Modula-2: AddMemList(size: LONGCARD; attributes: MemReqSet; pri:
INTEGER; base: ADDRESS; name: STRPTR)
Arguments: size = size of memory block in bytes
attributes = type of memory-MEMF_PUBLIC, MEMF_CHIP,
MEMF_FAST, MEMB_CLEAR
pri = priority of memory-CHIP memory has a priority of -10;
16-bit expansion memory has a priority of 0
base = address of the first location in the memory block
name = name to be used in memory header; NULL for no name
Result: none
-------------------------
AddPort
Description: adds a message port to the system
Offset: -$0162 (-354)
Modula-2 Module: Ports
Syntax: AddPort(port)
C: void AddPort(struct MsgPort *)
Machine Language: AddPort(a1)
Modula-2: AddPort(port: MsgPortPtr)
Arguments: port = message port to add
Result: none
-------------------------
AddResouree
Description: adds a resource to the system
Offset: -$01E6 (-486)
Modula-2 Module: Resources
Syntax: AddResource(resource)
C: void AddResource(struct Resource *)
Machine Language: AddResource(a1)
Modula-2: AddResource(resource: ResourcePtr)
Arguments: resource = resource node
Result: none
-------------------------
AddSemaphore
Description: attaches a signal semaphore to the system
Offset: -$0258 (-600)
Modula-2 Module: Semaphores
Syntax: AddSemaphore(signalSemaphore)
C: void AddSemaphore(struct SignalSemaphore *)
Machine Language: AddSemaphore(a1)
Modula-2: AddSemaphore(signalSemaphore: SignalSemaphorePtr)
Arguments: signalSemaphore = initialized SignalSemaphore structure
Result: none
-------------------------
AddTail
Description: appends a node to the tail of a list
Offset: -$00F6 (-246)
Syntax: AddTail(list, node)
C: void AddTail(struct List *, struct Node *)
Machine Language: AddTail(a0, a1)
Modula-2: AddTail(list: ListPtr; node: NodePtr)
node = node to insert
Result: none
-------------------------
AddTask
Description: adds a task to the system
Offset: -$011A (-282)
Modula-2 Module: Tasks
Syntax: AddTask(task, initialPC, finalPC)
C: void AddTask(struct Task *, char *, char *)
Machine Language: AddTask(a1, a2, a3)
Modula-2: AddTask(task: TaskPtr; initialPC, finalPC:ADDRESS)
Arguments: task = task control block
initialPC = initial entry point
finalPC = address of entry point of finalization code
Result: none
-------------------------
AddTOF
Description: adds a task to the TopOfFrame (vertical-blanking interval)
inter-
rupt server chain
Syntax: AddTOF(i, p, a)
C: void AddTOF(struct Isrvstr *, APTR, APTR)
Machine Language: pea a
pea p
pea i
jsr _AddTOF
add.l #12,sp
Arguments: i = Isrvstr structure
p = entry point of routine to call at every vertical blank
a = array of long words that will receive routine's arguments
Result: none
-------------------------
AddVSprite
Description: adds VSprite to GEL list
Offset: -$0066 (-102)
Syntax: AddVSprite(vSprite, rastPort)
C: void AddVSprite(struct VSprite *, struct RastPort *)
Machine Language: AddVSprite(a0, a1)
Modula-2: AddVSprite(vSprite: VSpritePtr; rastPort: RastPortPtr)
Arguments: vSprite = initialized VSprite structure
Result: none
-------------------------
afp
Description: converts an ASCII string into a fast floating point number
Syntax: fnum = afp(string)
C: float afp(char *)
Machine Language: pea string
jsr _afp ;fnum returned in d0/d1
addq.l #4,sp
Modula-2: not available; use ConvStrToReal in RealConversions module
Arguments: string = string to convert
Result: fnum = floating point equivalent of string arguments
-------------------------
Alert
Description: alerts the user of a serious error
Offset: -$006C (-108)
Modula-2 Module: Alerts
Syntax: Alert(alertNum, flags)
C: void Alert(long, char *)
Machine Language: Alert(d7, a5)
Modula-2: Alert(alertNum: LONGCARD; flags: LONGCARD)
Arguments: alertNum = alert number
flags = second part of Guru Meditation number (usually the ad-
dress of the offending task)
Result: none
-------------------------
AllocAbs
Description: allocates a block of memory from a specified location
Offset: -$00CC (-204)
Syntax: memoryBlock = AllocAbs(byteSize, location)
C: void *AllocAbs(long, void *)
Machine Language: d0 = AllocAbs(d0, a1)
Modula-2: AllocAbs(byteSize: LONGCARD; location: ADDRESS): ADDRESS
Arguments: byteSize = size of desired block in bytes
location = address where the memory must be
Result: memoryBlock = pointer to allocated block; NULL if
unsuccessful
-------------------------
Allocate
Description: allocates a block of memory
Offset: -$00BA (-186)
Syntax: memoryBlock = Allocate(freeList, byteSize)
C: void *Allocate(struct MemHeader *, long)
Machine Language: d0 = Allocate(a0, d0)
Modula-2: Allocate(freeList: MemHeaderPtr; byteSize: LONGCARD):
ADDRESS
Arguments: freeList = memory list header
byteSize = size of desired block in bytes
Result: memoryBlock = pointer to allocated block; NULL if
unsuccessful.
-------------------------
AllocBoardMem
Description: allocates expansion board memory
Offset: -$002A (-42)
Syntax: startSlot = AllocBoardMem(slotSpec)
C: long AllocBoardMem(long)
Machine Language: d0 = AllocBoardMem(d0)
Modula-2: AllocBoardMem(slotSpec: INTEGER): INTEGER
Arguments: slotSpec = number of slots to allocate
Result: startSlot = slot allocated; -1 if unsuccessful
------------------------
AllocCList
Description: allocates and initializes a clist
Library: clist.library
Offset: $0024 (-36)
Syntax: cList = AllocCList(cLPool)
C: long AllocCList(long)
Machine Language: d0 = AllocCList(a1)
Arguments: cLPool = initialized CListPool
Result: cList = longword cList descriptor; negative if
unsuccessful.
-------------------------
AllocConfigDev
Description: allocates a ConfigDev structure
Offset: -$0030 (-48)
Syntax: configDev = AllocConfigDev( )
C: struct ConfigDev *AllocConfigDev(void)
Machine Language: d0 = AllocConfigDev( )
Modula-2: AllocConfigDev( ): ConfigDevPtr
Arguments: none
Result: configDef = a valid ConfigDev structure; NULL if
unsuccessful
-------------------------
AllocEntry
Description: allocates many regions of memory
Offset: -$00DE (-222)
Syntax: memlist = AllocEntry(memlist)
C: struct MemList *AllocEntry(stuct MemList *)
Machine Language: d0 = AllocEntry(a0)
Modula-2: AllocEntry(memList: MemListPtr): MemListPtr
Arguments: memList = initialized cList pool
Result: memList = different memList filled with allocated memory
------------------------
AllocExpansionMem
Description: allocates expansion memory
Offset: -$0036 (-54)
Syntax: startSlot = AllocExpansionMem(numSlots, slotOffset)
C: CPTR AllocExpansionMem(long, long)
Machine Language: d0 = AllocExpansionMem(d0, d1)
Modula-2: AllocExpansionMem(numSlots, slot Offset: INTEGER): INTEGER
Arguments: numSlots = number slots to allocate
slotOffset = boundary offset
Result: startSlot = slot allocated; -1 if unsuccessful
-------------------------
AllocMem
Description: allocates many regions of memory
Offset: -$00C6 (-198)
Syntax: memoryBlock = AllocMem(byteSize, requirements)
C: void *AllocMem(long, long)
Machine Language: d0 = AllocMem(d0, d1)
Modula-2: AllocMem(byteSize: LONGCARD; requirements: MemReqSet):
ADDRESS
Arguments: byteSize = size of desired block in bytes
requirements = type of memory-MEMF_PUBLIC,
MEMF_CHIP, MEMF_FAST, MEMB_CLEAR
Result: memoryBlock = pointer to allocated block
-------------------------
AllocRaster
Description: allocates space for a bit plane
Offset: -$01EC (-492)
Modula-2 Module: Rasters
Syntax: raster = AllocRaster(width, height)
C: PLANEPTR AllocRaster(long, long)
Machine Language: d0 = AllocRaster(d0, d1)
Modula-2: AllocRaster(width, height: CARDINAL): PlanePtr
Arguments: width = width of bitplane in pixels
height = height of bitplane in pixels
Result: raster = pointer to allocated memory; NULL if unsuccessful
-------------------------
AllocRemember
Description: calls AllocMem and creates a link node
Offset: -$018C (-396)
Syntax: memoryBlock = AllocRemember(rememberKey, size, flags)
C: char *AllocRemember(struct Remember *, long, long)
Machine Language: d0 = AllocRemember(a0, d0, d1)
Modula-2: AllocRemember(VAR rememberKey: RememberPrt; size:
LONGCARD; flags: MemReqSet): ADDRESS
Arguments: rememberKey = address of pointer to Remember structure
size = size of desired block in bytes
flags = type of memory-MEMF_PUBLIC, MEMF_CHIP,
MEMF_FAST, MEMB_CLEAR
Result: memoryBlock = pointer to allocated block
-------------------------
AllocSignal
Description: allocates a signal bit
Offset: -$014A (-330)
Syntax: signalNum = AllocSignal(signalNum)
C: long AllocSignal(long)
Machine Language: d0 = AllocSignal(d0)
Modula-2: AllocSignal(signalNum: SIGNAL): SIGNAL
Arguments: signalNum = desired signal number (0-31); -1 for no preference
Result: signalNum = signal number allocated; -1 if no signal is
available
-------------------------
AllocTrap
Description: allocates a processor trap vector
Offset: -$0156 (-342)
Syntax: trapNum = AllocTrap(trapNum)
C: long AllocTrap(long)
Machine Language: d0 = AllocTrap(d0)
Modula-2: AllocTrap(trapNum: TRAP): TRAP
Arguments: trapNum = desired trap number (0-15); -1 for no preference
Result: trapNum = trap number allocated; -1 if no trap is available
-------------------------
AllocWBObject
Description: allocates a Workbench object
Offset: -$0042 (-66)
Syntax: object = AllocWBObject( )
C: struct WBObject AllocWBObject(void)
Machine Language: d0 = AllocWBObject( )
Arguments: none
Result: object = the WBObject; NULL if unsuccessful
-------------------------
AndRectRegion
Description: performs a two-dimensional AND operation of a rectangle
with a
region, leaving the result in the region
Offset: -$01F8 (-504)
Modula-2 Module: Regions
Syntax: AndRectRegion(region, rectangle)
C: void AndRectRegion(struct Region *, struct Rectangle *)
Machine Language: AndRectRegion(a0, a1)
Modula-2: AndRectRegion(region: RegionPtr; rectangle: RectanglePtr)
Arguments: region = Region structure
rectangle = Rectangle structure
Result: none
-------------------------
AndRegionRegion
Description: performs a two-dimensional AND operation of one region with
a
second region, leaving the result in second region
Offset: -$0270 (-624)
Syntax: success = AndRegionRegion(region1, region2)
C: long AndRegionRegion(struct Region *, struct Region *)
Machine Language: d0 = AndRegionRegion(a0, a1)
Modula-2: AndRegionRegion(region1, region2: RegionPtr): BOOLEAN
Arguments: region1 = Region structure
region2 = Region structure
Result: success = TRUE if successful; FALSE if unsuccessful
-------------------------
Animate
Description: processes every AnimOb in the current animation list
Offset: -$00A2 (-162)
Syntax: Animate(anKey, rastPort)
C: void Animate(long, struct RastPort *)
Machine Language: Animate(a0, a1)
Modula-2: Animate(ankey: ADDRESS; rastPort: RastPortPtr)
Arguments: anKey = address of variable that points to the head AnimOb
Result: none
-------------------------
AreaCircle (macro)
Description: adds a circle to the list of points used to fill an area
C Include File: include/graphics/gfxmacros.h
ML Include File: none
Modula-2 Module: Areas
Syntax: error = AreaCircle(rastPort, cx, cy, radius)
C: long AreaCircle(struct RastPort *, long, long, long)
Machine Language: not available, use AreaEllipse
Modula-2: AreaCircle(rp: RastPortPtr; cx, cy, radius: INTEGER): INTEGER
Arguments: rastPort = RastPort structure
cx = horizontal coordinate of circle's center
cy = vertical coordinate of circle's center
radius = circle's radius
Result: error = 0 if successful; -1 if no room left in list of
points
-------------------------
AreaDraw
Description: adds a point to the list of points used to fill an area
Offset: -$0102 (-258)
Syntax: error = AreaDraw(rastPort, x, y)
C: long AreaDraw(struct RastPort *, long, long)
Machine Language: d0 = AreaDraw(a1, d0, d1)
Modula-2: AreaDraw(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
x = horizontal coordinate of point
y = vertical coordinate of point
points
-------------------------
AreaEllipse
Description: adds an ellipse to the list of points used to fill an area
Offset: -$00BA (-186)
Syntax: error = AreaEllipse(rastPort, cx, cy, a, b)
C: long AreaEllipse(struct RastPort *, long, long, long, long)
Machine Language: d0 = AreaEllipse(a1, d0, d1, d2, d3)
Modula-2: AreaEllipse(rastPort: RastPortPtr; cx, cy, a, b: INTEGER):
INTEGER
-------------------------
AttemptLockLayerRom
Description: attempts to lock a Layer structure
Offset: -$028E (-582)
Modula-2 Module: Clip
Syntax: success = AttemptLockLayerRom(layer)
C: long AttemptLockLayerRom(struct Layer *)
Machine Language: d0 = AttemptLockLayerRom(a5)
Modula-2: AttemptLockLayerRom(layer: LayerPtr): BOOLEAN
Arguments: layer = Layer structure to lock
-------------------------
AttemptSemaphore
Description: attempts to obtain access to a SignalSemaphore structure
Offset: -$0240 (-576)
Syntax: success = AttemptSemaphore(signalSemaphore)
C: long AttemptSemaphore(struct SignalSemaphore *)
Machine Language: d0 = AttemptSemaphore(a0)
Modula-2: AttemptSemaphore(signalSemaphore: SignalSemaphorePtr):
BOOLEAN
Result: success = TRUE if successful; FALSE if another task is
using
specified SignalSemaphore structure
-------------------------
AutoRequest
Description: automatically creates and gets a response from a requester
Offset: -$015C (-348)
Syntax: response = AutoRequest(window, bodyText, positiveText,
negativeText, positiveFlags, negativeFlags, width, height)
C: long AutoRequest(struct Window *, struct IntuiText *,
struct
IntuiText *, struct IntuiText *, long, long, long)
Machine Language: d0 = AutoRequest(a0, a1, a2, a3, d0, d1, d2, d3)
Modula-2: AutoRequest(window: WindowPtr; bodyText, positiveText,
negativeText: IntuiTextPtr; positiveFlags, negativeFlags:
IDCMPFlagsSet; width, height: INTEGER): BOOLEAN
Arguments: window = Window structure
bodyText = IntuiText structure
positiveText = IntuiText structure
negativeText = IntuiText structure
positiveFlags = flags for the IDCMP
negativeFlags = flags for the IDCMP
width = width of requester
height = height of requester
Result: response = TRUE for a positive response; FALSE for a
negative
response
-------------------------
AvailFonts
Description: builds an array of all available fonts on disk and/or in
memory
Library: diskfont.library
Offset: -$0024 (-36)
Modula-2 Module: DiskFont
Syntax: error = AvailFonts(buffer, bufBytes, types)
C: long AvailFonts(char *, long, long)
Machine Language: d0 = AvailFonts(a0, d0, d1)
Modula-2: AvailFonts(buffer: ADDRESS; bufBytes: LONGCARD; types:
AFTypeSet): LONGCARD
Arguments: buffer = memory buffer used to hold the array
bufBytes = size of buffer in bytes
types = type of fonts to search for-AFF_MEMORY and/or
AFF_DISK
Result: error = 0 if successful, otherwise, error contains the
number of
additional bytes that must be added to the buffer size (bufBytes)
to contain all of the font information
-------------------------
AvailMem
Description: returns memory available given certain requirements
Offset: -$00D8 (-216)
Syntax: size = AvailMem(requirements)
C: long AvailMem(long)
Machine Language: d0 = AvailMem(d1)
Modula-2: AvailMem(requirements: MemReqSet): LONGCARD
Arguments: requirements = type of memory required-MEMF_PUBLIC,
MEMF_CHIP, MEMF_FAST, MEMB_CLEAR
Result: size = total free space remaining
------------------------- MISSING IN ORIGINAL TEXT!!!! -------------------------
cx = horizontal coordinate of ellipse's center
cy = vertical coordinate of ellipse's center
a = horizontal radius of ellipse (must be greater than O)
b = vertical radius of ellipse (must be greater than O)
points
-------------------------
AreaEnd
Description: fills an area using a list of vertices
Offset: -$0108 (-264)
Syntax: error = AreaEnd(rastPort)
C: long AreaEnd(struct RastPort *)
Machine Language: d0 = AreaEnd(a1)
Modula-2: AreaEnd(rastPort: RastPortPtr): INTEGER
Result: error = 0 if successful; -1 if unsuccessful
-------------------------
AreaMove
Description: closes the current polygon described by a table of vertices
and de-
fines the starting point for a new polygon
Offset: -$00FC (-252)
Syntax: error = AreaMove(rastPort, x, y)
C: long AreaMove(struct RastPort *, long, long)
Machine Language: d0 = AreaMove(a1, d0, d1)
Modula-2: AreaMove(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
points
-------------------------
arnd
Description: rounds a floating point number contained in an ASCII string
Syntax: arnd(place, exp, string)
C: void arnd(long, long, char *)
move.l #exp,-(sp)
move.l #place,-(sp)
jsr _arnd ;string contents are modified
add.l #12,sp
Arguments: place = number of desired decimal places
exp = exponent value of number in string argument
string = string containing number to round
Result: string argument is modified to contain rounded number
-------------------------
AskFont
Description: puts text attributes of the current font in the specified
TextAttr
structure
Offset: -$01DA (-474)
Syntax: AskFont(rastPort, textAttr)
C: void AskFont(struct RastPort *, struct TextAttr *)
Machine Language: AskFont(a1, a0)
Modula-2: AskFont(rastPort: RastPortPtr; textAttr: TextAttrPtr)
textAttr = TextAttr structure to be filled
Result: returns results in textAttr argument
-------------------------
AskSoftStyle
Description: returns the soft style bits of the current font
Offset: -$0054 (-84)
Syntax: enable = AskSoftStyle(rastPort)
C: long AskSoftStyle(struct RastPort *)
Machine Language: d0 = AskSoftStyle(a1)
Modula-2: AskSoftStyle(rastPort: RastPortPtr): FontStyleSet
Result: enable = valid style bits
-------------------------
BeginIO
Description: initiates an IO request like SendIO( ), but does not clear
io_Flags
field
Modula-2 Module: IO
Syntax: BeginIO(ioRequest)
C: void BeginIO(struct IORequest *)
Machine Language: pea ioRequest
jsr _BeginIO
addq.l #4,sp
Modula-2: BeginIO(ioRequest: ADDRESS)
Arguments: IORequest = initialized IORequest structure
Result: none
-------------------------
BeginRefresh
Description: sets up a window for optimized refreshing
Offset: -$0162 (-354)
Syntax: BeginRefresh(window)
C: void BeginRefresh(struct Window *)
Machine Language: BeginRefresh(a0)
Modula-2: BeginRefresh(window: WindowPtr)
Arguments: window = window that needs updating
Result: none
-------------------------
BeginUpdate
Description: prepares to repair a damaged layer
Library: layers.library
Offset: -$004E (-78)
Modula-2 Module: Layers
Syntax: success = BeginUpdate(layer)
C: long BeginUpdate(struct Layer *)
Machine Language: d0 = BeginUpdate(a0)
Modula-2: BeginUpdate(layer: LayerPtr): BOOLEAN
Arguments: layer = Layer to be repaired
Result: TRUE if successful; FALSE if unsuccessful
-------------------------
BehindLayer
Description: moves a layer behind other layers
Offset: -$0036 (-54)
Syntax: success = BehindLayer(dummy, layer)
C: long BehindLayer(struct Layer_Info, struct Layer *)
Machine Language: d0 = BehindLayer(a0, a1)
Modula-2: BehindLayer(layer: LayerPtr): BOOLEAN
Arguments: dummy = unused
layer = Layer to move behind other layers
-------------------------
BltBitMap
Description: uses the blitter chip to move (blit) a rectangular region
of bits from
a BitMap to a BitMap
Offset: -$001E (-30)
Modula-2 Module: Blitter
Syntax: planes = BltBitMap(scrBitMap, srcX, srcY, destBitMap, destX,
destY, sizeX, sizeY, miniterm, mask, tempA)
C: long BltBitMap(struct BitMap *, long, long, struct BitMap *,

long,
long, long, long, long, long, char *)
Machine Language: d0 = BltBitMap(a0, d0, d1, a1, d2, d3, d4, d5, d6, d7, a2)
Modula-2: BltBitMap(scrBitMap: BitMapPtr; srcX, srcY: INTEGER;
destBitMap: BitMapPtr; destX, destY: INTEGER; sizeX, sizeY:
INTEGER; miniterm: BYTE; mask: BITSET; tempA: ADDRESS):
LONGCARD
Arguments: scrBitMap = source BitMap structure
srcX = horizontal coordinate of upper left corner of source
rectangle
srcY = vertical coordinate of upper left corner of source
rectangle
destBitMap = destination BitMap structure
destX = horizontal coordinate of upper left corner of destination
rectangle
destY = vertical coordinate of upper left corner of destination
rectangle
sizeX = width of rectangle
sizeY = height of rectangle
miniterm = logic function to apply to rectangle
mask = bit planes to be affected
tempA = pointer to chip memory for one source line or NULL
Result: planes = actual number of planes involved in blit
-------------------------
BltBltMapRastPort
Description: moves a rectangular region from a BitMap to a RastPort
Offset: -$025E (-606)
Syntax: BltBitMapRastPort(srcBitMap, srcX, srcY, destRastPort,
destX,
destY, sizeX, sizeY, miniterm)
C: void BltBitMapRastPort(struct BitMap *, long, long, struct
RastPort
*, long, long, long, long, long)
Machine Language: BltBitMapRastPort(a0, d0, d1, a1, d2, d3, d4, d5, d6)
Modula-2: BltBitMapRastPort(srcBitMap: BitMapPtr; srcX, srcY: INTEGER;
destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX, sizeY:
INTEGER; miniterm: BYTE)
Arguments: srcBitMap = source BitMap structure
rectangle
rectangle
destRastPort = destination RastPort structure
rectangle
rectangle
Result: none
-------------------------
BltClear
Description: fills a section of chip memory with zeros
Offset: -$012C (-300)
Syntax: BltClear(memBlock, byteCount, flags)
C: void BltClear(char *, long, long)
Machine Language: BltClear(a1, d0, d1)
Modula-2: BltClear(memBlock: ADDRESS; byteCount: LONGCARD; flags:
BltClearFlagSet)
Arguments: memBlock = memory to clear (must start on a word boundary)

byteCount = number of bytes to clear
flags = set bit 0 to force function to wait until memory is
cleared;
set bit 1 if byteCount is to be interpreted as the number of rows
and bytes per row to clear; clear bit 1 if byteCount is to be
inter-
preted as an even number of bytes
Result: none
-------------------------
BltMaskBitMapRastPort
Description: moves a rectangular region from a BitMap to a RastPort
through a
mask
Offset: -$027C (-636)
Syntax: BltMaskBitMapRastPort(srcBitMap, srcX, srcY, destRastPort,
destX,
destY, sizeX, sizeY, miniterm, mask)
C: void BltMaskBitMapRastPort(struct BitMap *, long, long, struct
RastPort *, long, long, long, long, long, APTR)
Machine Language: BltMaskBitMapRastPort(a0, d0, d1, a1, d2, d3, d4, d5, d6,
a2)
Modula-2: BltMaskBitMapRastPort(srcBitMap: BitMapPtr; srcX, srcY: INTE-
GER; destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX,
sizeY: INTEGER; miniterm: BYTE; mask: PlanePtr)
Arguments: srcBitMap = source BitMap structure
rectangle
rectangle
rectangle
mask = pointer to bit-plane mask
Result: none
-------------------------
BltPattern
Description: draws through a mask using standard drawing rules
Offset: -$0138 (-312)
Syntax: BltPattern(destRastPort, pattern, x1, y1, x2, y2, width)
C: void BltPattern(struct RastPort *, struct RastPort *, long,
long,
long, long, long)
Machine Language: BltPattern(a1, a0, d0, d1, d2, d3, d4)
Modula-2: BltPattern(destRastPort: RastPortPtr; pattern: ADDRESS; x1, y1:
INTEGER; x2, y2: INTEGER; width: INTEGER)
Arguments: destRastPort = destination RastPort
pattern = two-dimensional mask pattern
x1 = horizontal coordinate of upper left corner in destination
RastPort
y1 = vertical coordinate of upper left corner in destination
RastPort
x2 = horizontal coordinate of lower right corner in destination
RastPort
y2 = vertical coordinate of lower right corner in destination
RastPort
width = width of mask in bytes
Result: none
-------------------------
BltTemplate
Description: "cookie cuts" a shape in a rectangle to a RastPort
Offset: -$0024 (-36)
Syntax: BltTemplate(source, srcX, srcMod, destRastPort, destX,
destY,
sizeX, sizeY)
C: void BltTemplate(char *, long, long, struct RastPort *, long,
long,
long, long)
Machine Language: BltTemplate(a0, d0, d1, a1, d2, d3, d4, d5)
Modula-2: BltTemplate(source: PlanePTR; srcX, srcMod: INTEGER;
destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX, sizeY:
INTEGER) (changes)
Arguments: source = template mask
srcX = horizontal offset into template mask (0-15)
srcMod = number of bytes per row in template mask
destRastPort = destination RastPort
destX = horizontal coordinate of upper left corner in destination
RastPort
destY = vertical coordinate of upper left corner in destination
RastPort
sizeX = width of rectangular template
sizeY = height of rectangular template
Result: none
-------------------------
BNDRYOFF (macro)
Description: turns boundary mode off
Modula-2 Module: Pens
Syntax: BNDRYOFF(rastPort)
C: void BNDRYOFF(struct RastPort *)
Machine Language: not available
Modula-2: BNDRYOFF(rastPort: RastPortPtr)
Result: none
-------------------------
BuildSysRequest
Description: builds and displays a system requester
Offset: -$0168 (-360)
Syntax: window = BuildSysRequest(window, bodyText, positiveText,
negativeText, flags, width, height)
C: struct Window *BuildSysRequest(struct Window *, struct
IntuiText
*, struct IntuiText *, struct IntuiText *, long, long, long)
Machine Language: d0 = BuildSysRequest(a0, a1, a2, a3, d0, d1, d2)
Modula-2: BuildSysRequest(window: WindowPtr; bodyText, positiveText,
negativeText: IntuiTextPtr; flags: IDCMPFlagsSet; width, height:
INTEGER): ADDRESS
Arguments: window = Window to contain requester
bodyText = IntuiText structure containing requester's main text
positiveText = IntuiText structure containing text for positive
gadget
negativeText = IntuiText structure containing text for negative
gadget
flags = IDCMP flags for initialization of window containing
requester
width = requester width
height = requester height
Result: window = pointer to window containing requester; if
requester
could not be opened, DisplayAlert( ) is called and this function
re-
turns TRUE if the left mouse button is pressed and FALSE if the
right mouse button is pressed
-------------------------
BumpRevision
Description: creates a new name for the copy of a file, directory, or
disk
Offset: -$006C (-108)
Syntax: newname = BumpRevision(newbuf, oldname)
C: long BumpRevision(char *, char *)
Machine Language: d0 = BumpRevision(a0, a1)
Modula-2: BumpRevision(newbuf, oldname: STRPTR)
Arguments: newbuf = buffer to contain the new name (must be at least 31
characters long)
oldname = old name
Result: newname = pointer to the new name contained in newbuf
-------------------------
Cause
Description: causes a software interrupt
Offset: -$00B4 (-180)
Syntax: Cause(interrupt)
C: void Cause(struct Interrupt *)
Machine Language: Cause(a1)
Modula-2: Cause(interrupt: InterruptPtr)
Arguments: interrupt = initialized interrupt node
Result: none
-------------------------
CBump
Description: moves to the next position in user copper list
Offset: -$016E (-366)
Modula-2 Module: Copper
Syntax: CBump(copList)
C: void CBump(struct UCopList *)
Machine Language: CBump(a1)
Modula-2: CBump(copList: UCopListPtr)
Arguments: copList = UCopList structure
Result: none
-------------------------
CEND (macro)
Description: adds the final instruction to a user copper list
Syntax: CEND(copList)
C: void CEND(struct UCopList *)
Modula-2: CEND(VAR copList: UCopList)
Result: none
------------------------
ChangeSprite
Description: changes the shape of a sprite
Offset: -$01A4 (-420)
Modula-2 Module: Sprites
Syntax: ChangeSprite(viewPort, simpleSprite, newdata)
C: void ChangeSprite(struct ViewPort *, struct SimpleSprite *,
short *)
Machine Language: ChangeSprite(a0, a1, a2)
Modula-2: ChangeSprite(viewPort: ViewPortPtr; simpleSprite:
SimpleSpritePtr; newdata: ADDRESS)
Arguments: viewPort = ViewPort structure
simpleSprite = initialized SimpleSprite structure
newdata = table of sprite shape data
Result: none
-------------------------
CheckIO
Description: gets the status of an IO request
Offset: -$01D4 (-468)
Modula-2 Module: IO
Syntax: status = CheckIO(ioRequest)
C: long CheckIO(struct IORequest *)
Machine Language: d0 = CheckIO(a1)
Modula-2: CheckIO(ioRequest: ADDRESS): ADDRESS
Arguments: ioRequest = IORequest block
Result: status = NULL if I/O is still in progress; pointer to IORequest
block if I/O has completed
-------------------------
CINIT (macro)
Description: initializes a user copper list
Syntax: copList = CINIT(copList, num)
C: struct UCopList *CINIT(struct UCopList *, short)
Modula-2: CINIT(copList: UCopListPtr; num: CARDINAL): UCopListPtr
num = number of instructions buffer must hold
Result: copList = pointer to an initialized UCopList structure,
ready to
accept copper instructions
-------------------------
ClearDMRequest
Description: clears the DMRequest of a window
Offset: -$0030 (-48)
Syntax: success = ClearDMRequest(window)
C: long ClearDMRequest(struct Window *)
Machine Language: d0 = ClearDMRequest(a0)
Modula-2: ClearDMRequest(window: WindowPtr): BOOLEAN
Arguments: window = window from which DMRequest is to be cleared
(DMRequest
is still in use)
-------------------------
ClearEOL
Description: clears from the current position to the end of the line
Offset: -$002A (-42)
Syntax: ClearEOL(rastPort)
C: void ClearEOL(struct RastPort *)
Machine Language: ClearEOL(a1)
Modula-2: ClearEOL(rastPort: RastPortPtr)
Arguments: rastPort = RastPort structure to clear
Result: none
-------------------------
ClearMenuStrip
Description: clears (detaches) a window's menu strip
Offset: -$0036 (-54)
Syntax: ClearMenuStrip(window)
C: void ClearMenuStrip(struct Window *)
Machine Language: ClearMenuStrip(a0)
Modula-2: ClearMenuStrip(window: WindowPtr)
Result: none
-------------------------
ClearPointer
Description: returns the mouse pointer to its default shape
Offset: -$003C (-60)
Syntax: ClearPointer(region)
C: void ClearPointer(struct Region *)
Machine Language: ClearPointer(a0)
Modula-2: ClearPointer(window: WindowPtr)
Result: none
-------------------------
ClearRectRegion
Description: performs a two-dimensional clearing operation of a clipping
rec
tangle with a region, leaving the result in the region
Offset: -$020A (-522)
Syntax: success = ClearRectRegion(region, rectangle)
C: long ClearRectRegion(struct Region *, struct Rectangle *)
Machine Language: d0 = ClearRectRegion(a0, a1)
Modula-2: ClearRectRegion(region: RegionPtr; rectangle: RectanglePtr):
BOOLEAN
Arguments: region = Region to clear
rectangle = Rectangle to be used as the clipping rectangle
-------------------------
ClearRegion
Description: removes all rectangles from a region
Offset: -$0210 (-528)
Syntax: ClearRegion(region)
C: void ClearRegion(struct Region *)
Machine Language: ClearRegion(a0)
Modula-2: ClearRegion(region: RegionPtr)
Arguments: region = Region to clear
Result: none
-------------------------
ClearScreen
Description: clears from the current position to the end of the RastPort
Offset: -$0030 (-48)
Syntax: ClearScreen(rastPort)
C: void ClearScreen(struct RastPort *)
Machine Language: ClearScreen(a1)
Modula-2: ClearScreen(rastPort: RastPortPtr)
Arguments: rastPort = RastPort to clear
Result: none
-------------------------
ClipBlit
Description: copies bit-map data (and optionally manipulates) from one
RastPort to another
Offset: -$0228 (-552)
Syntax: ClipBlit(scrRastPort, srcX, srcY, destRastPort, destX,
destY, sizeX,
sizeY, miniterm)
C: void ClipBlit(struct RastPort * long, long, struct RastPort
*, long,
long, long, long, long)
Machine Language: ClipBlit(a0, d0, d1, a1, d2, d3, d4, d5, d6)
Modula-2: ClipBlit(scrRPort: RastPortPtr; srcX, srcY: INTEGER; destRPort:
RastPortPtr; destX, destY: INTEGER; sizeX, sizeY: INTEGER;
miniterm: BYTE)
Arguments: scrRastPort = source RastPort structure
rectangle
rectangle
rectangle
rectangle
Result: none
-------------------------
Close
Description: closes an open file
Library: dos.library
Offset: -$0024 (-36)
Modula-2 Module: DOS
Syntax: Close(file)
C: void Close(BPTR)
Machine Language: Close(d1)
Modula-2: Close(file: FileHandle)
Arguments: file = BCPL pointer to file handle of file to close
Result: none
-------------------------
CloseDevice
Description: terminates access to a device
Offset: -$01C2 (-450)
Syntax: CloseDevice(ioRequest)
C: void CloseDevice(struct IORequest *)
Machine Language: CloseDevice(a1)
Modula-2: CloseDevice(ioRequest: ADDRESS)
Arguments: ioRequest = IORequest structure
Result: none
-------------------------
CloseFont
Description: tells the system that an opened font is no longer in use
Offset: -$004E (-78)
Syntax: CloseFont(font)
C: void CloseFont(struct TextFont *)
Machine Language: CloseFont(a1)
Modula-2: CloseFont(textfont: TextFontPtr)
Arguments: font = font descriptor as returned by OpenFont( ) or
OpenDiskFont( )
Result: none
-------------------------
CloseLibrary
Description: tells the system that an opened library is no longer in use
Offset: -$019E (-414)
Syntax: CloseLibrary(library)
C: void CloseLibrary(struct Library *)
Machine Language: CloseLibrary(a1)
Modula-2: CloseLibrary(library: LibraryPtr)
Arguments: library = base address of a library, as returned by
OpenLibrary( )
Result: none
-------------------------
CloseScreen
Description: closes an Intuition screen
Offset: -$0042 (-66)
Syntax: CloseScreen(screen)
C: void CloseScreen(struct Screen *)
Machine Language: CloseScreen(a0)
Modula-2: CloseScreen(screen: ScreenPtr)
Arguments: screen = screen to close
Result: none
-------------------------
CloseWindow
Description: closes an Intuition window
Offset: -$0048 (-72)
Syntax: CloseWindow(window)
C: void CloseWindow(struct Window *)
Machine Language: CloseWindow(a0)
Modula-2: CloseWindow(window: WindowPtr)
Arguments: window = window to close
Result: none
-------------------------
CloseWorkBench
Description: attempts to close the Workbench screen
Offset: -$004E (-78)
Syntax: success = CloseWorkBench( )
C: long CloseWorkBench(void)
Machine Language: d0 = CloseWorkBench( )
Modula-2: CloseWorkBench( ): BOOLEAN
Arguments: none
-------------------------
CMove
Description: appends a copper move instruction to a user copper list
without
bumping the copper instruction pointer to the next instruction
Offset: -$0174 (-372)
Syntax: CMove(copList, r, v)
C: void CMove(struct UCopList *, long, long)
Machine Language: CMove(a1, d0, d1)
Modula-2: CMove(copList: UCopListPtr; r: ADDRESS; v: WORD)
a = address of hardware register to receive value
v = value to store in hardware register
Result: none
-------------------------
CMOVE (macro)
Description: appends a copper move instruction to a user copper list and
bumps the copper instruction pointer to the next instruction
Syntax: CMOVE(copList, r, v)
C: void CMOVE(struct UCopList *, APTR, short)
Modula-2: CMOVE(copList: UCopListPtr; r: ADDRESS; v: WORD)
a = address of hardware register to receive value
v = value to store in hardware register
Result: none
-------------------------
ConcatCList
Description: concatenates two character lists
Offset: -$009C (-156)
Syntax: error = ConcatCList(srcCList, destCList)
C: long ConcatCList(long, long)
Machine Language: d0 = ConcatCList(a0, a1)
Arguments: srcCList = source character list
destCList = destination character list
Result: error = Zero if successful; Nonzero if unsuccessful (out of
memory)
-------------------------
ConfigBoard
Description: configures an expansion board
Offset: -$003C (-60)
Syntax: error = ConfigBoard(board, configDev)
C: long ConfigBoard(long, long)
Machine Language: d0 = ConfigBoard(a0, a1)
Modula-2: ConfigBoard(board: ADDRESS; configDev: ADDRESS):
BOOLEAN
Arguments: board = base address of expansion board (most likely
E_EXPANSIONBASE)
configDev = initialized ConfigDev structure
Result: error = nonzero if unsuccessful
-------------------------
ConfigChain
Description: configures the entire system
Offset: -$0042 (-66)
Syntax: error = ConfigChain(baseAddr)
C: long ConfigChain(long)
Machine Language: d0 = ConfigChain(a0)
Modula-2: ConfigChain(baseAddr: ADDRESS): BOOLEAN
Arguments: baseAddr = base address (most likely E_EXPANSIONBASE)
Result: error = nonzero if unsuccessful
-------------------------
CopyCList
Description: copies a character list to a new character list
Offset: -$0090 (-144)
Syntax: cList = CopyCList(cList)
C: long CopyCList(long)
Machine Language: d0 = CopyCList(a0)
Arguments: cList = original character list
Result: cList = new character list; Negative is unsuccessful (not
enough
memory)
-------------------------
CopyMem
Description: copies the contents of RAM from one location to another
Offset: -$0270 (-624)
Syntax: CopyMem(srcPointer, destPointer, size)
C: void CopyMem(char *, char *, long)
Machine Language: CopyMem(a0, a1, d0)
Modula-2: CopyMem(srcPointer, destPointer: ADDRESS; size: LONGCARD)
Arguments: srcPointer = pointer to memory block to be copied
destPointer = pointer to destination memory block
size = size of memory block in bytes
Result: none
-------------------------
CopyMemQuick
Description: performs an optimized copy of RAM with some restrictions
Offset: -$0276 (-630)
Syntax: CopyMemQuick(srcPointer, destPointer, size)
C: void CopyMemQuick(char *, char *, long)
Machine Language: CopyMemQuick(a0, a1, d0)
Modula-2: CopyMemQuick(srcPointer, destPointer: ADDRESS; size:
LONGCARD)
Arguments: srcPointer = pointer to the long-word aligned memory block to
be copied
destPointer = pointer to the long-word aligned destination mem-
ory block
size = size of memory block in bytes
Result: none
-------------------------
CopySBitMap
Description: copies all bits from a SuperBitMap into the Layer bitmap
Offset: -$01C2 (-450)
Syntax: CopySBitMap(layer)
C: void CopySBitMap(struct Layer *)
Machine Language: CopySBitMap(a0)
Modula-2: CopySBitMap(layer: LayerPtr)
Arguments: layer = pointer to a locked Layer that has a SuperBitMap
Result: none
-------------------------
CreateBehindlayer
Description: creates a new layer behind all existing layers
Offset: -$002A (-42)
Syntax: layer = CreateBehindLayer(layerInfo, bitMap, x0, y0, x1,
y1,
flags, superBitMap)
C: struct Layer *CreateBehindLayer(struct LayerInfo *, struct
Bit-
Map *, long, long, long, long, long, struct BitMap *)
Machine Language: d0 = CreateBehindLayer(a0, a1, d0, d1, d2, d3, d4, a2)
Modula-2: CreateBehindLayer(layerInfo: LayerInfoPtr; bitMap: BitMapPtr; x0,
y0, x1, y1: LONGINT; flags: LayerFlagSet; superBitMap:
BitMapPtr): LayerPtr
Arguments: layerInfo = info structure of Layer to create
bitMap = common BitMap used by all Layers
x0 = horizontal coordinate of upper left corner of Layer
y0 = vertical coordinate of upper left corner of Layer
x1 = horizontal coordinate of lower right corner of Layer
y1 = vertical coordinate of lower right corner of Layer
flags = type of Layer
superBitMap = NULL or a SuperBitMap
Result: layer = pointer to Layer structure if successful; NULL if
unsuccessful
-------------------------
CreateDir
Description: creates a new directory
Offset: -$0078 (-120)
Syntax: lock = CreateDir(name)
C: BPTR CreateDir(char *)
Machine Language: d0 = CreateDir(d1)
Modula-2: CreateDir(name: STRPTR): FileLock
Arguments: name = NULL terminate string that specifies the new directory
name
Result: lock = BCPL pointer to a lock
-------------------------
CreateExtIO
Description: allocates memory for and initializes an IO request block
Modula-2 Module: IOUtils
Syntax: block = CreateExtIO(ioReplyPort, size)
C: struct IORequest *CreateExtIO(struct MsgPort *, long)
Machine Language: move.l #size,-(sp)
pea ioReplyPort
jsr _CreateExtIO ;block returned in d0
addq.l #8,sp
Modula-2: CreateExtIO(ioReplyPort: MsgPortPtr; size: CARDINAL):
ADDRESS
Arguments: ioReplyPort = initialized MsgPort
size = IORequest block size
Result: block = pointer to newly created IORequest block; NULL if
un-
successful (not enough memory)
-------------------------
CreatePort
Description: allocates memory for and initializes a message port
Modula-2 Module: PortUtils
Syntax: port = CreatePort(name, pri)
C: struct MsgPort *CreatePort(char *, long)
Machine Language: move.l #pri,-(sp)
pea name
jsr _CreatePort ;port returned in d0
addq.l #8,sp
Modula-2: CreatePort(name: STRPTR; pri: INTEGER): MsgPortPtr
Arguments: name = name of public port to create; NULL for private port
pri = priority to assign to port
Result: port = pointer to newly created message port; NULL if
unsuc-
cessful (not enough memory)
-------------------------
CreateProc
Description: creates a new process
Offset: -$008A (-138)
Modula-2 Module: DOSProcess
Syntax: process = CreateProc(name, pri, segment, stackSize)
C: struct MsgPort *CreateProc(char *, long, BPTR, long)
Machine Language: d0 = CreateProc(d1, d2, d3, d4)
Modula-2: CreateProc(name: STRPTR; pri: LONGINT; segment: BPTR;
stackSize: LONGINT): ProcessID
Arguments: name = NULL terminated string that specifies the new process
name
priority = priority to be given to process
segment = segment list, as returned by LoadSeg( )
stackSize = size of root stack in bytes
Result: process = pointer to newly created IORequest block; NULL if
un-
successful (not enough memory)
-------------------------
CreateTask
Description: creates a task
Modula-2 Module: TaskUtils
Syntax: task = CreateTask(name, pri, initPC, stackSize)
C: struct Task *CreateTask(char *, long, _fptr, long)
Machine Language: move.l #stackSize,-(sp)
pea initPC
move.l #pri,-(sp)
pea name
jsr _CreateTask ;task returned in d0
add.l #16,sp
Modula-2: CreateTask(name: STRPTR; pri: INTEGER; initP
C: PROC; stackSize: LONGCARD): TaskPtr
Arguments: name = name of task
pri = exec task priority (-128 through 127, usually 0)
stackSize = size of stack in bytes
Result: task = pointer to newly created task; NULL if unsuccessful
(not
enough memory)
-------------------------
CreateUpfrontLayer
Description: creates a new layer on top of all existing layers
Offset: -$0024 (-36)
Syntax: layer = CreateUpfrontLayer(layerInfo, bitMap, x0, y0, x1,
y1,
flags, superBitMap)
C: struct Layer *CreateUpfrontLayer(struct Layer_Info *, struct
Bit-
Map *, long, long, long, long, long, struct BitMap *)
Machine Language: d0 = CreateUpfrontLayer(a0, a1, d0, d1, d2, d3, d4, a2)
Modula-2: CreateUpfrontLayer(layerInfo: LayerInfoPtr; bitMap: BitMapPtr;
x0, y0, x1, y1: LONGINT; flags: LayerFlagSet; superBitMap:
BitMapPtr): LayerPtr
Arguments: layerInfo = info structure of Layer to create
bitMap = common BitMap used by all Layers
x0 = horizontal coordinate of upper left corner of Layer
y0 = vertical coordinate of upper left corner of Layer
x1 = horizontal coordinate of lower right corner of Layer
y1 = vertical coordinate of lower right corner of Layer
flags = type of Layer
superBitMap = NULL or pointer to SuperBitMap
Result: layer = pointer to Layer structure if successful; NULL if
unsuccessful
-------------------------
CurrentDir
Description: changes the current directory and returns the old current
directory
Offset: -$007E (-126)
Syntax: oldlock = CurrentDir(lock)
C: BPTR CurrentDir(BPTR)
Machine Language: d0 = CurrentDir(d1)
Modula-2: CurrentDir(lock: FileLock): FileLock
Arguments: lock = BCPL pointer to lock associated with new current
directory
Result: oldlock = BCPL pointer to lock associated with old
directory
-------------------------
CurrentTime
Description: returns the current system time
Offset: -$0054 (-84)
Syntax: CurrentTime(seconds, micros)
C: void CurrentTime(long *, long *)
Machine Language: CurrentTime(d0, d1)
Modula-2: CurrentTime(VAR seconds, micros: LONGCARD)
Arguments: seconds = pointer to four-byte (LONG) variable to receive sec-
onds value
micros = pointer to four-byte (LONG) variable to receive micro-
seconds value
Result: returned in seconds and micros arguments
-------------------------
CWait
Description: appends copper wait instruction to a user copper list
without
bumping the copper instruction pointer to the next instruction
Offset: -$017A (-378)
Modula-2 Module: CopperUtil
Syntax: CWait(copList, vert, horiz)
C: void CWait(struct UCopList *, short, short)
Modula-2: CWait(copList: UCopListPtr; vert, horiz: INTEGER)
vert = vertical beam position relative to top of ViewPort
horiz = horizontal beam position (must be less than 223)
Result: none
-------------------------
CWAIT (macro)
Description: appends copper wait instruction to a user copper list and
bumps
the copper instruction pointer to the next instruction
Modula-2 Module: CopperUtil
Syntax: CWAIT(copList, vert, horiz)
C: void CWAIT(struct UCopList *, short, short)
Modula-2: CWAIT(copList: UCopListPtr; vert, horiz: INTEGER)
vert = vertical beam position relative to top of ViewPort
horiz = horizontal beam position (must be less than 223)
Result: none
-------------------------
DateStamp
Description: returns the current date and time in internal format
Offset: -$00C0 (-192)
Syntax: DateStamp(v)
C: long *DateStamp(long *)
Machine Language: DateStamp(d1)
Modula-2: DateStamp(v: DateStampRecPtr)
Arguments: v = pointer to the first element of an array of three long words
Result: v argument points to result in RAM
-------------------------
dbf
Description: converts a fast floating point dual-binary number to plain
fast
floating point format
Syntax: fnum = dbf(exp, mant)
C: float dbf(long, long)
Machine Language: move.l #mant,-(sp)
move.l #exp,-(sp)
jsr _dfb ;fnum returned in d0/d1
addq.l #8,sp
Arguments: exp = 16 bit integer representing the sign (bit 16 equals 0 for
positive or 1 for negative) and base ten exponent (bits 0-15)
mant = integer representing the mantissa
Result: fnum = floating point equivalent of value specified by exp
and
mant arguments
-------------------------
Deallocate
Description: deallocates a block of previously allocated memory
Offset: -$00C0 (-192)
Syntax: Deallocate(freeList, memoryBlock, byteSize)
C: void Deallocate(struct MemHeader *, void *, long)
Machine Language: Deallocate(a0, a1, d0)
Modula-2: Deallocate(freeList: MemHeaderPtr; memoryBlock: ADDRESS;
byteSize: LONGCARD)
Arguments: freeList = memory list header
memoryBlock = memory block to deallocate
byteSize = size of memory block in bytes
Result: none
-------------------------
Debug
Description: runs the system debugger or the debugger installed by
SetFunction
Offset: -$0072 (-114)
Modula-2 Module: Exec
Syntax: Debug(num)
C: void Debug(long)
Machine Language: Debug(d0)
Modula-2: Debug(num: LONGCARD)
Arguments: num = should be set to 0
Result: none
-------------------------
Delay
Description: delays a process for a specified amount of time
Offset: -$00C6 (-198)
Syntax: Delay(ticks)
C: void Delay(long)
Machine Language: Delay(d1)
Modula-2: Delay(ticks: LONGINT)
Arguments: ticks = number of ticks to wait (50 ticks per second)
Result: none
-------------------------
DeleteExtIO
Description: returns memory allocated by CreateExtIO
Modula-2 Module: IOUtils
Syntax: DeleteExtIO(ioRequest, size)
C: void DeleteExtIO(struct IORequest *, long)
Machine Language: move.l #size,-(sp)
pea ioRequest
jsr _DeleteExtIO
addq.l #4,sp
Modula-2: DeleteExtIO(ioReq: ADDRESS; size: CARDINAL)
Arguments: ioRequest = IORequest block to delete
size = size of IORequest block in bytes
Result: none
-------------------------
DeleteFile
Description: deletes a file or directory
Offset: -$0048 (-72)
Syntax: success = DeleteFile(name)
C: long DeleteFile(char *)
Machine Language: d0 = DeleteFile(d1)
Modula-2: DeleteFile(name: STRPTR): BOOLEAN
Arguments: name = NULL terminated string that specifies the file to delete
-------------------------
DeleteLayer
Description: deletes a layer from a layer list
Offset: -$005A (-90)
Syntax: success = DeleteLayer(dummy, layer)
C: long DeleteLayer(struct Layer_Info, struct Layer *)
Machine Language: d0 = DeleteLayer(a0, a1)
Modula-2: DeleteLayer(layer: LayerPtr): BOOLEAN
layer = layer to delete
-------------------------
DeletePort
Description: frees a message port created by CreatePort( )
Modula-2 Module: PortUtils
Syntax: DeletePort(msgPort)
C: void DeletePort(struct MsgPort *)
Machine Language: pea msgPort
jsr _DeletePort
addq.l #4,sp
Modula-2: DeletePort(msgPort: MsgPortPtr)
Arguments: msgPort = message port to delete
Result: none
-------------------------
DeleteTask
Description: deletes a task created with CreateTask( )
Modula-2 Module: TaskUtils
Syntax: DeleteTask(task)
C: void DeleteTask(struct Task *)
Machine Language: pea task
jsr _DeleteTask
addq.l #4,sp
Modula-2: DeleteTask(task: TaskPtr)
Arguments: task = Task to delete
Result: none
-------------------------
DeviceProc
Description: returns the process identifier of specified process
Offset: -$00AE (-174)
Syntax: process = DeviceProc(name)
C: struct MsgPort *DeviceProc(char *)
Machine Language: d0 = DeviceProc(d1)
Modula-2: DeviceProc(name: STRPTR): ProcessID
Arguments: name = NULL terminated string that specifies the device name
Result: process = BCPL pointer to a process; NULL if unsuccessful
-------------------------
Disable
Description: disables interrupt processing
Offset: -$0078 (-120)
Syntax: Disable( )
C: void Disable(void)
Machine Language: Disable( )
Modula-2: Disable( )
Arguments: none
Result: none
-------------------------
DisownBlitter
Description: frees blitter for use by other programs
Offset: -$01CE (-462)
Syntax: DisownBlitter( )
C: void DisownBlitter(void)
Machine Language: DisownBlitter( )
Modula-2: DisownBlitter( )
Arguments: none
Result: none
-------------------------
DisplayAlert
Description: creates an Alert
Offset: -$005A (-90)
Syntax: response = DisplayAlert(alertNumber, message, height)
C: long DisplayAlert(long, char *, long)
Machine Language: d0 = DisplayAlert(d0, a0, d1)
Modula-2: DisplayAlert(alertNumber: LONGCARD; message: ADDRESS;
height: CARDINAL): BOOLEAN
Arguments: alertNumber = AlertMessage number
message = NULL terminated Alert message string
height = minimum display lines required for your message
Result: response = TRUE or FALSE, depending on alert type and user
response
-------------------------
DisplayBeep
Description: flashes the video display and emits a beep
Offset: -$0060 (-96)
Syntax: DisplayBeep(screen)
C: void DisplayBeep(struct Screen *)
Machine Language: DisplayBeep(a0)
Modula-2: DisplayBeep(screen: ScreenPtr)
Arguments: screen = screen to beep
Result: none
-------------------------
DisposeFontContents (available in library version 34)
Description: frees the array of FontContents returned by NewFontContents( )
Offset: -$0030 (-48)
Syntax: DisposeFontContents(fontContentsHeader)
C: void DisposeFontContents(struct FontContentsHeader *)
Machine Language: DisposeFontContents(a1)
Arguments: fontContentsHeader = FontContentsHeader as returned by
NewFontContents( )
Result: none
-------------------------
DisposeLayerInfo
Description: returns memory used by a LayerInfo structure
Offset: -$0096 (-150)
Syntax: DisposeLayerInfo(layerInfo)
C: void DisposeLayerInfo(struct Layer_Info *)
Machine Language: DisposeLayerInfo(a0)
Modula-2: DisposeLayerInfo(layerInfo: layerInfoPtr)
Arguments: layerInfo = LayerInfo structure to remove
Result: none
-------------------------
DisposeRegion
Description: returns memory used by a Region structure and its
RegionRectangles
Offset: -$0216 (-534)
Syntax: DisposeRegion(region)
C: void DisposeRegion(struct Region *)
Machine Language: DisposeRegion(a0)
Modula-2: DisposeRegion(region: RegionPtr)
Arguments: region = Region structure to remove
Result: none
-------------------------
DoCollision
Description: tests all GELs in GEL list for GEL-to-GEL collisions
Offset: -$006C (-108)
Syntax: DoCollision(rastPort)
C: void DoCollision(struct RastPort *)
Machine Language: DoCollision(a1)
Modula-2: DoCollision(rastPort: RastPortPtr)
Arguments: rastPort = RastPort with GEL list
Result: none
-------------------------
DoIO
Description: performs IO command and waits for completion
Offset: -$01C8 (-465)
Modula-2 Module: IO
Syntax: error = DoIO(ioRequest)
C: long DoIO(struct IORequest *)
Machine Language: d0 = DoIO(a1)
Modula-2: DoIO(ioRequest: ADDRESS): INTEGER
Arguments: ioRequest = initialized IORequest structure
Result: error = zero if successful; nonzero if unsuccessful
-------------------------
DoubleClick
Description: test two time values for double-click timing
Offset: -$0066 (-102)
Syntax: double = DoubleClick(startSecs, startMicros, currentSecs,
currentMicros)
C: long DoubleClick(long, long, long, long)
Machine Language: d0 = DoubleClick(d0, d1, d2, d3)
Modula-2: DoubleClick(startSecs, startMicros, currentSecs, currentMicros:
LONGCARD): BOOLEAN
Arguments: startSecs = seconds value at time of first click
startMicros = micros value at time of first click
currentSecs = seconds value at time of second click
currentMicros = micros value at time of second click
Result: double = TRUE if valid double click; FALSE if not
-------------------------
Draw
Description: draws a line from current pen position to specified point
Offset: -$00F6 (-246)
Syntax: Draw(rastPort, x, y)
C: long Draw(struct RastPort *, long, long)
Machine Language: Draw(a1, d0, d1)
Modula-2: Draw(rastPort: RastPortPtr; x, y: INTEGER)
Arguments: rastPort = RastPort to draw line in
x = horizontal coordinate of line's destination
y = vertical coordinate of line's destination
Result: none
-------------------------
DrawBorder
Description: draws a border
Offset: -$006C (-108)
Syntax: DrawBorder(rastPort, border, leftOffset, topOffset)
C: long DrawBorder(struct RastPort *, struct Border *, long,
long)
Machine Language: DrawBorder(a0, a1, d0, d1)
Modula-2: DrawBorder(rastPort: RastPortPtr; border: BorderPtr; leftOffset,
topOffset: INTEGER)
Arguments: rastPort = RastPort to draw border in
border = Border to be drawn
leftOffset = horizontal placement offset for border
topOffset = vertical placement offset for border
Result: none
-------------------------
DrawCircle (macro)
Description: draws a circle in the specified RastPort
Syntax: DrawCircle(rastPort, cx, cy, radius)
C: void DrawCircle(struct RastPort *, long, long, long)
Machine Language: not available, use DrawEllipse instead
Modula-2: DrawCircle(rastPort: RastPortPtr; cx, cy, radius: INTEGER)
cx = horizontal coordinate of circle's center
cy = vertical coordinate of circle's center
radius = circle's radius
Result: none
-------------------------
DrawEllipse
Description: draws an elliptical outline within a rectangular outline
Offset: -$00B4 (-180)
Syntax: DrawEllipse(rastPort, cx, cy, a, b)
C: void DrawEllipse(struct RastPort *, long, long, long, long)
Machine Language: DrawEllipse(a1, d0, d1, d2, d3)
Modula-2: DrawEllipse(rastPort: RastPortPtr; cx, cy, a, b: INTEGER)
Arguments: rastPort = RastPort into which ellipse will be drawn
cx = horizontal coordinate of ellipse's center, relative to the
RastPort
cy = vertical coordinate of ellipse's center, relative to the
RastPort
a = ellipse's horizontal radius (must be greater than O)
b = ellipse's vertical radius (must be greater than O)
Result: none
-------------------------
DrawGList
Description: processes a GEL list, drawing bobs and constructing a
copper list
for VSprites
Offset: -$0072 (-114)
Syntax: DrawGList(rastPort, viewPort)
C: void DrawGList(struct RastPort *, struct ViewPort *)
Machine Language: DrawGList(a1, a0)
Modula-2: DrawGList(rastPort: RastPortPtr; viewPort: ViewPortPtr)
Arguments: rastPort = RastPort where bobs will be drawn
viewPort = ViewPort in which VSprites will be created
Result: none
-------------------------
DrawImage
Description: draw the specified image
Offset: -$0072 (-114)
Syntax: DrawImage(rastPort, image, leftOffset, topOffset)
C: long DrawImage(struct RastPort *, struct Image *, long,
long)
Machine Language: DrawImage(a0, a1, d0, d1)
Modula-2: DrawImage(rastPort: RastPortPtr; image: ImagePtr; leftOffset,
topOffset: INTEGER)
Arguments: rastPort = RastPort where image will be drawn
image = Image to be drawn
leftOffset = horizontal placement offset for image
topOffset = vertical placement offset for image
Result: none
-------------------------
Duplock
Description: duplicates a lock
Offset: -$0060 (-96)
Syntax: newlock = DupLock(lock)
C: BPTR DupLock(BPTR)
Machine Language: d0 = DupLock(d1)
Modula-2: DupLock(lock: FileLock): FileLock
Arguments: lock = lock to duplicate
Result: newlock = duplicate lock
-------------------------
Enable
Description: enables interrupt processing
Offset: -$007E (-126)
Syntax: Enable( )
C: void Enable(void)
Machine Language: Enable( )
Modula-2: Enable( )
Arguments: none
Result: none
-------------------------
EndRefresh
Description: ends optimized refresh of a window
Offset: -$016E (-366)
Syntax: EndRefresh(window, complete)
C: void EndRefresh(struct Window *, long)
Machine Language: EndRefresh(a0, d0)
Modula-2: EndRefresh(window: WindowPtr; complete: BOOLEAN)
Arguments: window = window in optimized-refresh mode
complete = TRUE if window is completely refreshed; FALSE if
not
Result: none
-------------------------
EndRequest
Description: removes requester from window
Offset: -$0078 (-120)
Syntax: EndRequest(requester, window)
C: void EndRequest(struct Requester *, struct Window *)
Machine Language: EndRequest(a0, a1)
Modula-2: EndRequest(requester: RequesterPtr; window: WindowPtr)
Arguments: requester = requester to remove
window = window which is associated with requester
Result: none
-------------------------
EndUpdate
Description: removes damage list and restores layer to normal state
Offset: -$0054 (-84)
Syntax: EndUpdate(layer, flag)
C: void EndUpdate(struct Layer *, long)
Machine Language: EndUpdate(a0, d0)
Modula-2: EndUpdate(layer: LayerPtr; flag: BOOLEAN)
Arguments: layer = layer to return to normal state
flag = TRUE if update was complete-damage list will be
cleared; FALSE if update was not complete-damage list will be
retained
Result: none
-------------------------
Enqueue
Description: inserts or appends node to a system queue
Offset: -$010E (-270)
Syntax: Enqueue(list, node)
C: void Enqueue(struct List *, struct Node *)
Machine Language: Enqueue(a0, a0)
Modula-2: Enqueue(list: ListPtr; node: NodePtr)
Arguments: list = system queue header
node = node to insert or append
Result: none
-------------------------
Examine
Description: examines a directory or file
Offset: -$0066 (-102)
Syntax: success = Examine(lock, infoBlock)
C: long Examine(BPTR, struct FileInfoBlock *)
Machine Language: d0 = Examine(d1, d2)
Modula-2: Examine(lock: FileLock; infoBlock: FileInfoBlockPtr): BOOLEAN
Arguments: lock = lock of directory or file to examine
infoBlock = info block to receive directory or file information
-------------------------
Execute
Description: executes a CLI command
Offset: -$00DE (-222)
Modula-2 Module: DOSLoader
Syntax: success = Execute(command, input, output)
C: long Execute(char *, BPTR, BPTR)
Machine Language: d0 = Execute(d1, d2, d3)
Modula-2: Execute(command: STRPTR; input, output: FileHandle):
BOOLEAN
Arguments: command = NULL terminated string containing CLI command
input = file handle for input redirection; NULL if none
output = file handle for output redirection; NULL if none
-------------------------
Exit
Description: ends a program
Offset: -$0090 (-144)
Syntax: Exit(returnCode)
C: void Exit(long)
Machine Language: Exit(d1)
Modula-2: Exit(returnCode: LONGINT)
Arguments: returnCode = return code passed to parent (usually the CLI)-by
convention, a value of zero implies no error
Result: none
-------------------------
ExNext
Description: examines the next entry in a directory
Offset: -$006C (-108)
Syntax: success = ExNext(lock, infoBlock)
C: long ExNext(BPTR, struct FilelnfoBlock *)
Machine Language: d0 = ExNext(d1, d2)
Modula-2: ExNext(lock: FileLock; infoBlock: FileInfoBlockPtr): BOOLEAN
Arguments: lock = lock of directory to examine
infoBlock = info block to receive entry information
-------------------------
FastRand
Description: generates a somewhat random integer
Syntax: rnd = FastRand(seed)
C: long FastRand(long)
Machine Language: move.l #long,-(sp)
jsr _FastRand ;rnd returned in d0
addq.l #4,sp
Modula-2: not available, use Random in RandomNumbers module
Arguments: seed = value used to seed random number
Result: rnd = random number calculate using the following C
equation:
rnd=(seed << 1) ^ 0x1872B41
-------------------------
FattenLayerInfo
Description: converts 1.0 LayerInfo structure to 1.1-1.3-compatible
LayerInfo
structure
Offset: -$009C (-156)
Syntax: FattenLayerInfo(layerInfo)
C: void FattenLayerInfo(struct Layer_Info *)
Machine Language: FattenLayerInfo(a0)
Arguments: layerInfo = LayerInfo structure to update
Result: none
-------------------------
FindConfigBoard
Description: finds a matching ConfigDev entry
Offset: -$0048 (-72)
Syntax: configDev = FindConfigBoard(oldConfigDev, manufacturer,
product)
C: struct ConfigDev *FindConfigBoard(long, long, long)
Machine Language: d0 = FindConfigBoard(a0, d0, d1)
Arguments: oldConfigDev = ConfigDev structure just before the location in
ConfigDev list where search should begin; NULL to start search at
the beginning of the list
manufacturer = manufacturer code to search for; -1 to ignore
manufacturer code
product = product code to search for; -1 to ignore product coed
Result: configDev = first ConfigDev structure that matches the
manufac-
turer and product codes specified; NULL if no more matches
-------------------------
FindName
Description: finds a system list node
Offset: -$0114 (-276)
Syntax: node = FindName(start, name)
C: struct Node *FindName(struct List *, char *)
Machine Language: d0 = FindName(a0, a1)
Modula-2: FindName(start: ADDRESS; name: STRPTR): NodePtr
Arguments: start = list header or list node to start search (if node this
one is
skipped)
name = NULL terminated string that specifies name of node
Result: node = pointer to specified node; NULL if unsuccessful
-------------------------
FindPort
Description: finds a public message port
Offset: -$0186 (-390)
Syntax: port = FindPort(name)
C: struct MsgPort *FindPort(char *)
Machine Language: d0 = FindPort(a1)
Modula-2: FindPort(name: STRPTR): MsgPortPtr
Arguments: name = NULL terminated string that specifies name of port
Result: port = pointer to specified port; NULL if unsuccessful
-------------------------
FindResident
Description: finds a Resident structure
Offset: -$0060 (-96)
Modula-2 Module: Resident
Syntax: resident = FindResident(name)
C: struct Resident *FindResident(char *)
Machine Language: d0 = FindResident(a1)
Modula-2: FindResident(name: STRPTR): ResidentPtr
Arguments: name = NULL terminated string that specifies name of Resident
structure
Result: resident = pointer to specified Resident structure; NULL if
unsuccessful
-------------------------
FindSemaphore
Description: finds a SignalSemaphore structure
Offset: -$0252 (-612)
Syntax: semaphore = FindSemaphore(name)
C: struct SignalSemaphore *FindSemaphore(char *)
Machine Language: d0 = FindSemaphore(a1)
Modula-2: FindSemaphore(name: STRPTR): SignalSemaphorePtr
Arguments: name = NULL terminated string that specifies name of
semaphore
Result: semaphore = pointer to specified SignalSemaphore structure;
NULL if unsuccessful
-------------------------
FindTask
Description: finds a task
Offset: -$0126 (-294)
Syntax: task = FindTask(name)
C: struct Task *FindTask(char *)
Machine Language: d0 = FindTask(a1)
Modula-2: FindTask(name: STRPTR): TaskPtr
Arguments: name = NULL terminated string that specifies name of task
Result: task = pointer to specified task; NULL if unsuccessful
-------------------------
FindToolType
Description: finds value of a ToolType variable
Offset: -$0060 (-96)
Syntax: value = FindToolType(toolTypeArray, typeName)
C: struct char *FindToolType(char *, char *)
Machine Language: d0 = FindToolType(a0, a1)
Modula-2: FindToolType(toolTypeArray: StrArrayPtr; typeName: STRPTR):
ADDRESS
Arguments: toolTypeArray = pointer to an array of strings containing tool
types
typeName = NULL terminated string that specifies tool type to
find
Result: value = pointer to string containing specified tool type;
NULL if
typeName not found in toolTypeArray
-------------------------
Flood
Description: floods (fills) an area of a RastPort
Offset: -$014A (-330)
Syntax: Flood(rastPort, mode, x, y)
C: void Flood(struct RastPort *, long, long, long)
Machine Language: Flood(a1, d2, d0, d1)
Modula-2: Flood(rastPort: RastPortPtr; mode: LONGCARD; x, y: INTEGER)
Arguments: rastPort = RastPort to fill
mode = type of fill- 0 (fill pixels that are the same color as
AOLPen) or 1 (fill pixels that are the same color as pixel at x,y)
x = horizontal coordinate where fill will begin
y = vertical coordinate where fill will begin
Result: none
-------------------------
FlushCList
Description: clears a character list
Offset: -$0030 (-48)
Syntax: FlushCList(cList)
C: void FlushCList(long)
Machine Language: FlushCList(a0)
Arguments: cList = CList header-as returned by AllocCList( )
or StrToCL( )-used to manage character list to clear
Result: none
-------------------------
Forbid
Description: prevents task rescheduling
Offset: -$0084 (-132)
Syntax: Forbid( )
C: void Forbid(void)
Machine Language: Forbid( )
Modula-2: Forbid( )
Arguments: none
Result: none
-------------------------
fpa
Description: converts a fast floating point number into an ASCII string
Syntax: exp = fpa(fnum, string)
C: long fpa(float, char *)
move.l fnum,-(sp)
jsr _fpa ;exp returned in d0 and string equals fnum
addq.l #8,sp
Arguments: fnum = floating point number to convert
string = address of string to receive ASCII equivalent of fnum
argument
Result: exp = integer exponent of fnum
-------------------------
fpbcd
Description: converts a fast floating point number into BCD format
Syntax: fpbcd(fnum, string)
C: void fpbcd(float, char *)
move.l fnum,-(sp)
jsr _fpbcd ;BCD equivalent of fnum returned in string
addq.l #8,sp
Arguments: fnum = floating point number to convert
string = address of five-byte string to receive BCD equivalent of
fnum argument
Result: string argument receives the BCD equivalent of fnum
argument
-------------------------
FreeBoardMem
Description: frees expansion board memory (opposite of AllocBoardMem( )
Offset: -$004E (-78)
Syntax: FreeBoardMem(startSlot, slotSpec)
C: void FreeBoardMem(long, long)
Machine Language: d0 = FreeBoardMem(d0, d1)
Modula-2: FreeBoardMem(startslot, slotSpeC: INTEGER)
Arguments: startSlot = slot number as returned by AllocBoardMem( )
slotSpec = number of slots to free
Result: none
-------------------------
Modula-2: FreeMem(memoryBlock: ADDRESS: byteSize: LONGCARD)
Arguments: memoryBlock = pointer to memory block to free
byteSize = size of block in bytes
Result: none
-------------------------
FreeCList
Description: releases character list descriptor and any resources it
uses
Offset: -$002A (-42)
Syntax: FreeCList(cList)
C: void FreeCList(long)
Machine Language: FreeCList(a0)
Arguments: cList = descriptor of character list to free
Result: none
-------------------------
FreeColorMap
Description: returns memory used by a ColorMap structure
Offset: -$0240 (-576)
Modula-2 Module: Views
Syntax: FreeColorMap(colorMap)
C: void FreeColorMap(struct ColorMap *)
Machine Language: FreeColorMap(a0)
Modula-2: FreeColorMap(colorMap: ColorMapPtr)
Arguments: colorMap = ColorMap structure to free
Result: none
-------------------------
FreeConfigDev
Description: frees a ConfigDev structure
Offset: -$0054 (-84)
Syntax: FreeConfigDev(configDev)
C: void FreeConfigDev(struct ConfigDev *)
Machine Language: FreeConfigDev(a0)
Modula-2: FreeConfigDev(configDev: ConfigDevPtr)
Arguments: configDev = ConfigDev structure as returned by
AllocConfigDev( )
Result: none
-------------------------
FreeCopList
Description: returns memory allocated for an intermediate copper list
Offset: -$0222 (-546)
Syntax: FreeCopList(copList)
C: void FreeCopList(struct CopList *)
Machine Language: FreeCopList(a0)
Modula-2: FreeCopList(copList: CopListPtr)
Arguments: copList = CopList structure to free
Result: none
-------------------------
FreeCprList
Description: returns memory allocated for a hardware copper list
Offset: -$0234 (-564)
Syntax: FreeCprList(cprlist)
C: void FreeCprList(struct cprlist *)
Machine Language: FreeCprList(a0)
Modula-2: FreeCprList(cprlist: cprlistPtr)
Arguments: cprlist = cprlist structure to free
Result: none
-------------------------
FreeDiskObject
Description: frees memory allocated for a Workbench disk object
Offset: -$005A (-90)
Syntax: FreeDiskObject(diskObj)
C: void FreeDiskObject(struct DiskObject *)
Machine Language: FreeDiskObject(a0)
Modula-2: FreeDiskObject(diskObj: DiskObjectPtr)
Arguments: diskObj = DiskObject structure to free
Result: none
-------------------------
FreeEntry
Description: frees many regions of memory
Offset: -$00E4 (-228)
Syntax: FreeEntry(memList)
C: void FreeEntry(struct MemList *)
Machine Language: FreeEntry(a0)
Modula-2: FreeEntry(memList: MemListPtr)
Arguments: memList = MemList structure
Result: none
-------------------------
FreeExpansionMem
Description: frees expansion memory
Offset: -$005A (-90)
Syntax: FreeExpansionMem(startSlot, numSlots)
C: void FreeExpansionMem(long, long)
Machine Language: FreeExpansionMem(d0, d1)
Modula-2: FreeExpansionMem(startSlot, numSlots: INTEGER)
Arguments: startSlot = slot number as returned by AllocExpansionMem( )
slotSpec = number of slots to free
Result: none
-------------------------
FreeFreeList
Description: frees all memory in a free list
Offset: -$0036 (-54)
Syntax: FreeFreeList(freeList)
C: void FreeFreeList(struct FreeList *)
Machine Language: FreeFreeList(a0)
Modula-2: FreeFreeList(freeList: FreeListPtr)
Arguments: memList = FreeList structure
Result: none
-------------------------
FreeGBuffers
Description: frees memory allocated by GetGBuffers( )
Offset: -$0258 (-600)
Syntax: FreeGBuffers(animOb, rastPort, dBuffer)
C: void FreeGBuffers(struct AnimOb *, struct RastPort *, long)
Machine Language: FreeGBuffers(a0, a1, d0)
Modula-2: FreeGBuffers(animOb: AnimObPtr; rastPort: RastPortPtr; dBuffer:
BOOLEAN)
Arguments: animOb = AnimOb structure
rastPort = Rastport structure
dBuffer = double-buffer flag-TRUE for double-buffering
Result: none
-------------------------
FreeMem
Description: frees memory allocated by GetGBuffers( )
Offset: -$00D2 (-210)
Syntax: FreeMem(memoryBlock, byteSize)
C: void FreeMem(void *, long)
Machine Language: FreeMem(a1, d0)
Modula-2: FreeMem(memoryBlock: ADDRESS: byteSize: LONGCARD)
Arguments: memoryBlock = pointer to memory block to free
byteSize = size of block in bytes
Result: none
-------------------------
FreeRaster
Description: frees memory allocated by AllocRaster( )
Offset: -$01F2 (-498)
Syntax: FreeRaster(p, width, height)
C: void FreeRaster(PLANEPTR, long, long)
Machine Language: FreeRaster(a0, d0, d1)
Modula-2: FreeRaster(p: PlanePtr; width, height: CARDINAL)
Arguments: p = memory block returned by AllocRaster( )
width = width of bitplanes in pixels
height = height of bitplanes in pixels
Result: none
-------------------------
FreeRemember
Description: frees memory allocated by AllocRemember( )
Offset: -$0198 (-408)
Syntax: FreeRemember(rememberKey, reallyForget)
C: void FreeRemember(struct Remember *, long)
Machine Language: FreeRemember(a0, d0)
Modula-2: FreeRemember(rememberKey: RememberPrt; reallyForget:
BOOLEAN)
Arguments: rememberKey = address of pointer to Remember structure
reallyForget = TRUE to free memory and link nodes; FALSE to
free only link nodes
Result: none
-------------------------
FreeSignal
Description: frees a signal bit
Offset: -$0150 (-336)
Syntax: FreeSignal(signalNum)
C: void FreeSignal(long)
Machine Language: FreeSignal(d0)
Modula-2: FreeSignal(signalNum: SIGNAL)
Arguments: signalNum = signal number to free (0-31)
Result: none
-------------------------
FreeSprite
Description: makes sprite available for others to use
Offset: -$019E (-414)
Syntax: FreeSprite(pick)
C: void FreeSprite(long)
Machine Language: FreeSprite(d0)
Modula-2: FreeSprite(pick: INTEGER)
Arguments: pick = number of sprite to free (0-7)
Result: none
-------------------------
FreeSysRequest
Description: frees memory allocated by BuildSysRequest( )
Offset: -$0174 (-372)
Syntax: FreeSysRequest(window)
C: void FreeSysRequest(struct Window *)
Machine Language: FreeSysRequest(a0)
Modula-2: FreeSysRequest(window: WindowPtr)
Arguments: window = Window structure as returned by BuildSysRequest( )
Result: none
-------------------------
FreeTrap
Description: frees a processor trap
Offset: -$015C (-348)
Syntax: FreeTrap(trapNum)
C: void FreeTrap(long)
Machine Language: FreeTrap(d0)
Modula-2: FreeTrap(trapNum: TRAP)
Arguments: trapNum = trap number to free (0-15)
Result: none
-------------------------
FreeVPortCoplists
Description: frees all intermediate copper lists and their headers from
a
ViewPort
Offset: -$021C (-540)
Syntax: FreeVPortCopLists(viewPort)
C: void FreeVPortCopLists(struct ViewPort *)
Machine Language: FreeVPortCopLists(a0)
Modula-2: FreeVPortCopLists(viewPort: ViewPortPtr)
Arguments: viewPort = ViewPort structure containing copper lists
Result: none
-------------------------
FreeWBObject
Description: frees memory allocated for a Workbench object
Offset: -$003C (-60)
Syntax: FreeWBObject(object)
C: void FreeWBObject(struct WBObject *)
Machine Language: FreeWBObject(a0)
Arguments: object = WBObject structure to free
Result: none
--------------------------
GetCC
Description: gets 68000/68010 condition codes
Offset: -$0210 (-528)
Syntax: condition = GetCC( )
C: long GetCC(void)
Machine Language: d0 = GetCC( )
Modula-2: GetCC( ): BITSET
Arguments: none
Result: condition = 68000/68010 condition code
-------------------------
GetCLBuf
Description: converts character list into contiguous data
Offset: -$0072 (-114)
Syntax: length = GetCLBuf(cList, buffer, maxLength)
C: long GetCLBuf(long, char *, long)
Machine Language: d0 = GetCLBuf(a0, a1, d1)
Arguments: cList = character list descriptor, as returned by AllocCList( )
or
StrToCL( )
buffer = buffer to hold data
maxLength = maximum size of buffer in bytes
Result: length = number of bytes copied into buffer
-------------------------
GetCLChar
Description: gets a byte from the beginning of a character list
Offset: -$0042 (-66)
Syntax: byte = GetCLChar(cList)
C: long GetCLChar(long)
Machine Language: d0 = GetCLChar(a0)
or
StrToCL( )
Result: byte = byte from beginning of character list; -1 if no data
-------------------------
GetCLWord
Description: gets a word from the beginning of a character list
Offset: -$005A (-90)
Syntax: word = GetCLWord(cList)
C: long GetCLWord(long)
Machine Language: d0 = GetCLWord(a0)
or
StrToCL( )
Result: word = word from beginning of character list; -1 if no data
-------------------------
GetColorMap
Description: allocates and initializes a ColorMap structure
Offset: -$023A (-570)
Syntax: colorMap = GetColorMap(entries)
C: struct ColorMap *GetColorMap(long)
Machine Language: d0 = GetColorMap(d0)
Modula-2: GetColorMap(colorMap: LONGINT): ColorMapPtr
Arguments: entries = number of entries for this color map
Result: colorMap = pointer to ColorMap structure; O if unsuccessful
-------------------------
GetCurrentBinding
Description: sets static board configuration area
Offset: -$008A (-138)
Syntax: actual = GetCurrentBinding(currentBinding, size)
C: long GetCurrentBinding(long, long)
Machine Language: d0 = GetCurrentBinding(a0, d0)
Arguments: currentBinding = CurrentBinding structure
size = size of user's BindDriver structure
Result: actual = actual size of the CurrentBinding structure
-------------------------
GetDefPrefs
Description: gets a copy of the default Preferences
Offset: -$007E (-126)
Modula-2 Module: Preferences
Syntax: prefBuffer = GetDefPrefs(prefBuffer, size)
C: struct Preferences *GetDefPrefs(struct Preferences *, long)
Machine Language: d0 = GetDefPrefs(a0, d0)
Modula-2: GetDefPrefs(prefBuffer: ADDRESS; size: INTEGER): ADDRESS
Arguments: prefBuffer = buffer to receive copy of default Preferences
size = size of buffer in bytes
Result: prefBuffer = pointer to your buffer
-------------------------
GetDiskObject
Description: reads a Workbench DiskObject (.info file) from disk
Offset: -$004E (-78)
Syntax: diskObj = GetDiskObject(name)
C: struct DiskObject *GetDiskObject(char *)
Machine Language: d0 = GetDiskObject(a0)
Modula-2: GetDiskObject(name: STRPTR): DiskObjectPtr
Arguments: name = name of Workbench object (.info file)
Result: diskObj = pointer to DiskObject structure; 0 if
unsuccessful
-------------------------
GetGBuffers
Description: attempts to allocate all buffers of an enter AnimOb
Offset: -$00A8 (-168)
Syntax: success = GetGBuffers(animOb, rastPort, dBuffer)
C: long GetGBuffers(struct AnimOb *, struct RastPort *, long)
Machine Language: d0 = GetGBuffers(a0, a1, d0)
Modula-2: GetGBuffers(animOb: AnimObPtr; rastPort: RastPortPtr; dBuffer:
BOOLEAN): BOOLEAN
Arguments: animOb = AnimOb structure
rastPort = Rastport structure
dBuffer = double-buffer flag-TRUE for double-buffering
-------------------------
GetIcon
Description: reads a DiskObject structure from disk
Offset: -$002A (-42)
Syntax: status = GetIcon(name, icon, free)
C: long GetIcon(char *, struct DiskObject *, struct FreeList *)
Machine Language: d0 = GetIcon(a0, a1, a2)
Arguments: name = name of icon (.info file)
icon = DiskObject structure
free = FreeList structure
Result: status = nonzero if successful
-------------------------
GetMsg
Description: gets next message from a message port
Offset: -$0174 (-372)
Syntax: message = GetMsg(port)
C: struct Message *GetMsg(struct MsgPort *)
Machine Language: d0 = GetMsg(a0)
Modula-2: GetMsg(port: MsgPortPtr): ADDRESS
Arguments: port = receiving message port
Result: message = pointer to first message; NULL if no message
-------------------------
GetPrefs
Description: gets Preferences' current settings
Offset: -$0084 (-132)
Syntax: prefBuffer = GetDefPrefs(prefBuffer, size)
C: struct Preferences *GetDefPrefs(struct Preferences *, long)
Machine Language: d0 = GetDefPrefs(a0, d0)
Modula-2: GetDefPrefs(prefBuffer: ADDRESS; size: INTEGER): ADDRESS
Arguments: prefBuffer = buffer to receive copy of Preferences
Result: prefBuffer = pointer to your buffer
-------------------------
GetRGB4
Description: gets the value of an entry in a ColorMap structure
Offset: -$0246 (-582)
Syntax: value = GetRGB4(colorMap, entry)
C: long GetRGB4(struct ColorMap *, long)
Machine Language: d0 = GetRGB4(a0, d0)
Modula-2: GetRGB4(colorMap: ColorMapPtr; entry: LONGINT): INTEGER
Arguments: colorMap = ColorMap structure
entry = index into color table, specifying desired entry
Result: value = two-byte, right-justified RGB value with four bits
per
color-red, green, blue; -1 if no valid entry
-------------------------
GetSereenData
Description: copies all or part of a Screen structure into buffer; opens
specifled
screen if not already open
Offset: -$01AA (-426)
Syntax: success = GetScreenData(buffer, size, type, screen)
C: long GetScreenData(char *, long, long, struct Screen *)
Machine Language: d0 = GetScreenData(a0, d0, d1, a1)
Modula-2: GetScreenData(buffer: ADDRESS; size: CARDINAL; type:
ScreenFlagSet; screen: ScreenPtr): BOOLEAN
Arguments: buffer = buffer in which data will be placed
type = screen type-CUSTOMSCREEN, WORKBENCHSCREEN
screen = custom Screen structure; ignored if type argument
equals WORKBENCHSCREEN
Result: success = TRUE if successful; FALSE if screen not available

and
could not be opened
-------------------------
GetSprite
Description: allocates hardware sprite for simple sprite manager
Offset: -$0198 (-408)
Syntax: spriteNumber = GetSprite(sprite, pick)
C: long GetSprite(struct SimpleSprite *, long)
Machine Language: d0 = GetSprite(a0, d0)
Modula-2: GetSprite(sprite: SimpleSpritePtr; pick: INTEGER): INTEGER
Arguments: sprite = SimpleSprite structure
pick = number of desired sprite (0-7); -1 for next available
sprite
Result: spriteNumber = number of sprite allocated; -1 if sprite
unavailable
-------------------------
GetWBObject
Description: reads in a Workbench object from disk
Offset: -$001E (-30)
Syntax: object = GetWBObject(name)
C: struct WBObject *GetWBObject(char *)
Machine Language: d0 = GetWBObject(a0)
Arguments: name = NULL terminated string that specifies name of Work-
bench object
Result: object = pointer to Workbench object; 0 if unsuccessful
-------------------------
IEEEDPAbs
Description: obtains the absolute value of an IEEE double-precision
floating-
point number
Library: mathieeedoubbas.library
Offset: -$0036 (-54)
Syntax: fnum1 = IEEEDPAbs(fnum2)
C: double IEEEDPAbs(double)
Machine Language: d0/d1 = IEEEDPAbs(d0/d1)
Arguments: fnum2 = IEEE double-precision floating-point number
Result: fnum1 = absolute value of fnum2 in IEEE double-precision
floating-point format
-------------------------
IEEEDPAcos
Description: obtains the arccosine of an IEEE double-precision floating-
point
number
Library: mathieeedoubtrans.library
Offset: -$0078 (-120)
Syntax: fnum1 = IEEEDPAcos(fnum2)
C: double IEEEDPAcos(double)
Machine Language: d0/d1 = IEEEDPAcos(d0/d1)
Arguments: fnum2 = IEEE double-precision floating-point number represent-
ing the cosine of an angle
Result: fnum1 = IEEE double-precision floating-point value of fnum2
an-
gle in radians
-------------------------
IEEEDPAdd
Description: adds two IEEE double-precision floating-point numbers
Offset: -$0042 (-66)
Syntax: fnum1 = IEEEDPAdd(fnum2, fnum3)
C: double IEEEDPAdd(double, d0uble)
Machine Language: d0/d1 = IEEEDPAdd(d0/d1, d2/d3)
fnum3 = IEEE double-precision floating-point number
Result: fnum1 = fnum2 plus fnum3 in IEEE double-precision floating-
point format
-------------------------
IEEEDPAsin
Description: obtains the arcsine of an IEEE double-precision floating-
point
number
Offset: -$0072 (-114)
Syntax: fnum2 = IEEEDPAsin(fnum2)
C: double IEEEDPAsin(double)
Machine Language: d0/d1 = IEEEDPAsin(d0/d1)
ing the sine of an angle
an-
gle in radians
-------------------------
IEEEDPAtan
Description: obtains the arctangent of an IEEE double-precision
floating-point
number
Offset: -$0030 (-48)
Syntax: fnum1 = IEEEDPAtan(fnum2)
C: double IEEEDPAtan(double)
Machine Language: d0/d1 = IEEEDPAtan(d0/d1)
ing the tangent of an angle
an-
gle in radians
-------------------------
IEEEDPCeil
Description: obtains the Ceil function of an IEEE double-precision
floating-
point number (rounds it up)
Offset: -$0060 (-96)
Syntax: fnum1 = IEEEDPCeil(fnum2)
C: double IEEEDPCeil(double)
Machine Language: d0/d1 = IEEEDPCeil(d0/d1)
Result: fnum1 = IEEE double-precision floating-point integer value
that's
closest to, but not less than the value of fnum2
-------------------------
IEEEDPCmp
Description: compares two IEEE double-precision floating-point numbers
Offset: -$002A (-42)
Syntax: flag = IEEEDPCmp(fnum1, fnum2)
C: long IEEEDPCmp(double, d0uble)
Machine Language: d0 = IEEEDPCmp(d0/d1, d2/d3)
Result: flag = -1 if fnum1<fnum2; +1 if fnum1>fnum2; 0 if
fnum1 = fnum2
-------------------------
IEEEDPCos
Description: obtains the cosine of an IEEE double-precision floating-
point
number
Offset: -$002A (-42)
Syntax: fnum1 = IEEEDPCos(fnum2)
C: double IEEEDPCos(double)
Machine Language: d0/d1 = IEEEDPCos(d0/d1)
ing an angle in radians
Result: fnum1 = IEEE double-precision floating-point cosine of
fnum2
-------------------------
IEEEDPCosh
Description: obtains the hyperbolic cosine of an IEEE double-precision
float-
ing-point number
Offset: -$0042 (-66)
Syntax: fnum1 = IEEEDPCosh(fnum2)
C: double IEEEDPCosh(double)
Machine Language: d0/d1 = IEEEDPCosh(d0/d1)
Result: fnum1 = IEEE double-precision floating-point hyperbolic
cosine
of fnum2
-------------------------
IEEEDPDiv
Description: divides one IEEE double-precision floating-point number by
another
Offset: -$0054 (-84)
Syntax: fnum1 = IEEEDPDiv(fnum2, fnum3)
C: double IEEEDPDiv(double, d0uble)
Machine Language: d0/d1 = IEEEDPDiv(d0/d1, d2/d3)
Arguments: fnum2 = IEEE double-precision floating-point dividend
fnum3 = IEEE double-precision floating-point divisor
Result: fnum1 = IEEE double-precision floating-point format results
of
fnum2 divided by fnum3
-------------------------
IEEEDPExp
Description: obtains the exponent of an IEEE double-precision floating-
point
number
Offset: -$004E (-78)
Syntax: fnum1 = IEEEDPExp(fnum2)
C: double IEEEDPExp(double)
Machine Language: d0/d1 = IEEEDPExp(d0/d1)
Result: fnum1 = IEEE double-precision floating-point value
representing
e raised to the power of fnum2
-------------------------
IEEEDPFieee
Description: converts a IEEE single-precision floating-point number to
an IEEE
double-precision floating-point number
Offset: -$006C (-108)
Syntax: fnum1 = IEEEDPFieee(fnum2)
C: double IEEEDPFieee(float)
Machine Language: d0/d1 = IEEEDPFieee(d0)
Arguments: fnum2 = IEEE single-precision floating-point number
Result: fnum1 = IEEE double-precision floating-point equivalent to
fnum2
-------------------------
IEEEDPFix
Description: converts an IEEE double-precision floating-point number to
an
integer
Offset: -$001E (-30)
Syntax: inum = IEEEDPFix(fnum)
C: long IEEEDPFix(double)
Machine Language: d0 = IEEEDPFix(d0/d1)
Arguments: fnum = IEEE double-precision floating-point number
Result: inum = integer equivalent to fnum
-------------------------
IEEEDPFloor
Description: obtains the Floor function of an IEEE double-precision
floating-
point number (rounds it down)
Offset: -$005A (-90)
Syntax: fnum1 = IEEEDPFloor(fnum2)
C: double IEEEDPFloor(double)
Machine Language: d0/d1 = IEEEDPFloor(d0/d1)
Result: fnum1 = IEEE double-precision floating-point integer value
that's
closest to, but not greater than the value of fnum2
-------------------------
IEEEDPFlt
Description: converts an integer to an IEEE double-precision floating-
point
number
Offset: -$0024 (-36)
Syntax: fnum = IEEEDPFlt(inum)
C: double IEEEDPFlt(long)
Machine Language: d0/d1 = IEEEDPFlt(d0)
Arguments: inum = signed integer to be converted
Result: fnum = IEEE double-precision floating-point equivalent to
inum
-------------------------
IEEEDPLog
Description: obtains the natural logarithm of an IEEE double-precision
floating-
point number
Offset: -$0054 (-84)
Syntax: fnum1 = IEEEDPLog(fnum2)
C: double IEEEDPLog(double)
Machine Language: d0/d1 = IEEEDPLog(d0/d1)
Result: fnum1 = IEEE double-precision floating-point natural
logarithm
(base e) of fnum2
-------------------------
IEEEDPlog10
Description: obtains the naparian logarithm (base 10) of an IEEE double-
precision floating-point number
Offset: -$007E (-126)
Syntax: fnum1 = IEEEDPLog10(fnum2)
C: double IEEEDPLog10(double)
Machine Language: d0/d1 = IEEEDPLog10(d0/d1)
Result: fnum1 = IEEE double-precision floating-point naparian
logarithm
(base 10) of fnum2
-------------------------
IEEEDPMul
Description: multiplies one IEEE double-precision floating-point number
by
another
Offset: -$004E (-78)
Syntax: fnum1 = IEEEDPMul(fnum2, fnum3)
C: double IEEEDPMul(double, d0uble)
Machine Language: d0/d1 = IEEEDPMul(d0/d1, d2/d3)
Result: fnum1 = product of fnum2 and fnum3 in IEEE double-precision
floating-point format
-------------------------
IEEEDPNeg
Description: negates the value of an IEEE double-precision floating-
point number
Offset: -$003C (-60)
Syntax: fnum1 = IEEEDPNeg(fnum2)
C: double IEEEDPNeg(double)
Machine Language: d0/d1 = IEEEDPNeg(d0/d1)
Arguments: fnum2 = IEEE double-precision floating-point number to negate
Result: fnum1 = negative fnum2 in IEEE double-precision floating-
point
format
-------------------------
IEEEDPPow
Description: obtains the exponentiation of two IEEE double-precision
floating-
point numbers
Offset: -$005A (-90)
Syntax: fnum1 = IEEEDPPow(fnum2, fnum3)
C: double IEEEDPPow(double, d0uble)
Machine Language: d0/d1 = IEEEDPPow(d2/d3, d0/d1)
raised to the power of fnum3
-------------------------
IEEEDPSin
Description: obtains the sine of an IEEE double-precision floating-point
number
Offset: -$0024 (-36)
Syntax: fnum1 = IEEEDPSin(fnum2)
C: double IEEEDPSin(double, d0uble)
Machine Language: d0/d1 = IEEEDPSin(d0/d1)
Result: fnum1 = IEEE double-precision floating-point sine of fnum2
-------------------------
IEEEDPSincos
Description: obtains the sine and cosine of an IEEE double-precision
floating-
point number
Offset: -$0036 (-54)
Syntax: fnum1 = IEEEDPSincos(fnum2, fnum3)
C: double IEEEDPSincos(double, d0uble *)
Machine Language: d0/d1 = IEEEDPSincos(d0/d1, a0)
fnum3 = pointer to an IEEE double-precision floating point num-
ber to receive the cosine of fnum2
Result: fnum1 = IEEE double-precision floating-point sine of fnum2
(co-
sine is returned in fnum3)
-------------------------
IEEEDPSinh
Description: obtains the hyperbolic sine of an IEEE double-precision
floating-
point number
Offset: -$003C (-60)
Syntax: fnum1 = IEEEDPSinh(fnum2)
C: double IEEEDPSinh(double, d0uble)
Machine Language: d0/d1 = IEEEDPSinh(d0/d1)
sine of
fnum2
-------------------------
IEEEDPSqrt
Description: obtains the square root of an IEEE double-precision
floating-point
number
Offset: -$0060 (-96)
Syntax: fnum1 = IEEEDPSqrt(fnum2)
C: double IEEEDPSqrt(double)
Machine Language: d0/d1 = IEEEDPSqrt(d0/d1)
Result: fnum1 = IEEE double-precision floating-point square root of
fnum2
-------------------------
IEEEDPSub
Description: subtracts one IEEE double-precision floating-point number
from
another
Offset: -$0048 (-72)
Syntax: fnum1 = IEEEDPSub(fnum2, fnum3)
C: double IEEEDPSub(double, d0uble)
Machine Language: d0/d1 = IEEEDPSub(d0/d1, d2/d3)
Result: fnum1 = fnum2 minus fnum3 in IEEE double-precision
floating-
point format
-------------------------
IEEEDPTan
Description: obtains the tangent of an IEEE double-precision floating-
point
number
Offset: -$0030 (-48)
Syntax: fnum1 = IEEEDPTan(fnum2)
C: double IEEEDPTan(double, d0uble)
Machine Language: d0/d1 = IEEEDPTan(d0/d1)
Result: fnum1 = IEEE double-precision floating-point tangent of
fnum2
-------------------------
IEEEDPTanh
Description: obtains the hyperbolic tangent of an IEEE double-precision
floating-point number
Offset: -$0048 (-72)
Syntax: fnum1 = IEEEDPTanh(fnum2)
C: double IEEEDPTanh(double, d0uble)
Machine Language: d0/d1 = IEEEDPTanh(d0/d1)
tangent
of fnum2
-------------------------
IEEEDPTIeee
Description: converts an IEEE double-precision floating-point number to
an
IEEE single-precision floating-point number
Offset: -$0066 (-102)
Syntax: fnum1 = IEEEDPTieee(fnum2)
C: float IEEEDPTieee(double)
Machine Language: d0 = IEEEDPTieee(d0/d1)
Result: fnum1 = IEEE single-precision floating-point equivalent to
fnum2
-------------------------
IEEEDPTst
Description: compares an IEEE double-precision floating-point number
with
zero
Offset: -$0030 (-48)
Syntax: flag = IEEEDPTst(fnum)
C: long IEEEDPTst(double)
Machine Language: d0 = IEEEDPTst(d0/d1)
Arguments: fnum = IEEE double-precision floating-point number
Result: flag = -1 if fnum <0; +1 if fnum >0; 0 if fnum=0
-------------------------
IncrCLMark
Description: increments character list mark to the next position
Offset: -$007E (-126)
Syntax: error = IncrCLMark(cList)
C: long IncrCLMark(long)
Machine Language: d0 = IncrCLMark(a0)
Arguments: cList = character list descriptor
Result: error = 0 if successful; nonzero if next offset is not in
the charac-
ter list
-------------------------
Info
Description: returns information about a disk or disk file
Offset: -$0072 (-114)
Syntax: success = Info(lock, infoData)
C: long Info(BPTR, struct InfoData *)
Machine Language: d0 = Info(d1, d2)
Modula-2: Info(lock: FileLock; infoData: InfoDataPtr): BOOLEAN
Arguments: lock = BCPL pointer to a lock
infoData = InfoData structure to be filled
-------------------------
InitArea
Description: initializes vector collection matrix
Offset: -$011A (-282)
Syntax: InitArea(areaInfo, buffer, maxVectors)
C: long InitArea(struct AreaInfo *, short *, long)
Machine Language: InitArea(a0, a1, d0)
Modula-2: InitArea(areaInfo: AreaInfoPtr; buffer: ADDRESS; maxVectors:
INTEGER)
Arguments: areaInfo = AreaInfo structure
buffer = pointer to memory block where vectors will be stored-
must start on word boundary and should be 5*maxVectors bytes
long
maxVectors = maximum number of vectors
Result: none
-------------------------
InitBitMap
Description: initializes a BitMap structure
Offset: -$0186 (-390)
Modula-2 Module: Graphics
Syntax: InitBitMap(bitMap, depth, width, height)
C: void InitBitMap(struct Bitmap *, long, long, long)
Machine Language: InitBitMap(a0, d0, d1, d2)
Modula-2: InitBitMap(bitMap: BitMapPtr; depth, width, height: INTEGER)
Arguments: bitMap = BitMap structure
depth = number of bit planes to be used
width = width of each bit plane in bits
height = height of each bit plane in lines
Result: none
-------------------------
InitCLPool
Description: initializes a character list pool
Offset: -$001E (-30)
Syntax: error = InitCLPool(cLPool, size)
C: long InitCLPool(long, long)
Machine Language: d0 = InitCLPool(a0, d0)
Arguments: cLPool = data area to be used as character list pool
size = size of pool in bytes
Result: error = 0 if successful; nonzero if pool size is too small
-------------------------
InitCode
Description: initializes resident modules with a startup class value and
version
number
Offset: -$0048 (-72)
Syntax: InitCode(startClass, version)
C: void InitCode(long, long)
Machine Language: InitCode(d0, d1)
Modula-2: InitCode(startClass, version: LONGCARD)
Arguments: startClass = startup class of resident module-COLDSTART,
COOLSTART, or WARMSTART
version = version number of resident module
Result: none
-------------------------
InitGels
Description: initializes a GEL list
Offset: -$0078 (-120)
Syntax: InitGels(head, tail, gelsInfo)
C: void InitGels(struct VSprite *, struct VSprite *, struct GelsInfo
*)
Machine Language: InitGels(a0, a1, a2)
Modula-2: InitGels(head, tail: VSpritePtr; gelsInfo: GelsInfoPtr)
Arguments: head = VSprite structure to be used as head of GEL list
tail = VSprite structure to be used as tail of GEL list
gelsInfo = GelsInfo structure to be initialized
Result: none
-------------------------
InitGMasks
Description: initializes all masks of an AnimOb structure
Offset: -$00AE (-174)
Syntax: InitGMasks(animOb)
C: void InitGMasks(struct AnimOb *)
Machine Language: InitGMasks(a0)
Modula-2: InitGMasks(animOb: AnimObPtr)
Arguments: animOb = AnimOb structure containing masks to initialize
Result: none
-------------------------
InitLayers
Description: initializes a Layer_Info structure
Offset: -$001E (-30)
Syntax: InitLayers(layerInfo)
C: void InitLayers(struct Layer_Info *)
Machine Language: InitLayers(a0)
Arguments: layerInfo = Layer_Info structure to initialize
Result: none
-------------------------
InitMasks
Description: initializes the BorderLine and CollMask values used by a
VSprite
structure
Offset: -$007E (-126)
Syntax: InitMasks(vSprite)
C: void InitMasks(struct VSprite *)
Machine Language: InitMasks(a0)
Modula-2: InitMasks(vSprite: VSpritePtr)
Arguments: vSprite = VSprite structure containing BorderLine and CollMask
values to initialize
Result: none
-------------------------
InitRastPort
Description: initializes a RastPort structure
Offset: -$00C6 (-198)
Syntax: InitRastPort(rastPort)
C: void InitRastPort(struct RastPort *)
Machine Language: InitRastPort(a1)
Modula-2: InitRastPort(rastPort: RastPortPtr)
Arguments: rastPort = RastPort structure to initialize
Result: none
-------------------------
InitRequester
Description: initializes a Requester structure
Offset: -$008A (-138)
Syntax: InitRequester(requester)
C: void InitRequester(struct Requester *)
Machine Language: InitRequester(a0)
Modula-2: InitRequester(requester: RequesterPtr)
Arguments: requester = Requester structure to initialize
Result: none
-------------------------
InitResident
Description: initializes a resident module
Offset: -$0066 (-102)
Syntax: InitResident(resident, segList)
C: void InitResident(struct Resident *, char *)
Machine Language: InitResident(a1, d1)

Modula-2: InitResident(resident: ResidentPtr; segList: ADDRESS)
Arguments: resident = Resident structure representing resident module to
initialize
segList = a segment list
Result: none
-------------------------
InitSemaphore
Description: initializes a SignalSemaphore structure
Offset: -$022E (-558)
Syntax: InitSemaphore(signalSemaphore)
C: void InitSemaphore(struct SignalSemaphore *)
Machine Language: InitSemaphore(a0)
Modula-2: InitSemaphore(signalSemaphore: SignalSemaphorePtr)
Arguments: signalSemaphore = SignalSemaphore structure to initialize
Result: none
-------------------------
InitStruct
Description: clears an area of memory following rules defined by a table
Offset: -$004E (-78)
Syntax: InitStruct(initTable, memBlock, size)
C: void InitStruct(char *, char *, long)
Machine Language: InitStruct(a1, a2, d0)
Modula-2: InitStruct(initTable, memBlock: ADDRESS; size: CARDINAL)
Arguments: initTable = pointer to the commands and data used to initialize
memory
memBlock = pointer to memory to be initialized
size = size of memory to clear before it is initialized with
initTable; 0 for no initial clearing of memory
Result: none
-------------------------
InitTmpRas
Description: initializes chip RAM for use by area-fill, flood-fill, and
text
functions
Offset: -$01D4 (-468)
Syntax: InitTmpRas(tmpRas, buffer, size)
C: void InitTmpRas(struct TmpRas *, char *, long)
Machine Language: InitTmpRas(a0, a1, d0)
Modula-2: InitTmpRas(tmpRas: TmpRasPtr; buffer: PlanePtr; size:
LONGCARD)
Arguments: tmpRas = TmpRas structure to be linked into a RastPort
buffer = pointer to chip RAM memory
Result: none
-------------------------
InitView
Description: initializes a View structure
Offset: -$0168 (-360)
Syntax: InitView(view)
C: void InitView(struct View *)
Machine Language: InitView(a1)
Modula-2: InitView(view: ViewPtr)
Arguments: view = View structure to initialize
Result: none
-------------------------
InitVPort
Description: initializes a ViewPort structure
Offset: -$00CC (-204)
Syntax: InitVPort(viewPort)
C: void InitVPort(struct ViewPort *)
Machine Language: InitVPort(a0)
Modula-2: InitVPort(viewPort: ViewPortPtr)
Arguments: viewPort = ViewPort structure to initialize
Result: none
-------------------------
Input
Description: gets the initial input file handle assigned to a program
Offset: -$0036 (-54)
Syntax: file = Input( )
C: BPTR Input(void)
Machine Language: d0 = Input( )
Modula-2: Input( ): FileHandle
Arguments: none
Result: file = BCPL pointer to a file handle
-------------------------
Insert
Description: inserts a Node structure into a doubly-linked list
Offset: -$00EA (-234)
Syntax: Insert(list, node, listNode)
C: void Insert(struct List *, struct Node *, struct Node *)
Machine Language: Insert(a0, a1, a2)
Modula-2: Insert(list: ListPtr; node, listNode: NodePtr)
Arguments: list = target List header
node = Node structure to insert
listNode = node after which to insert; NULL to insert at head
Result: none
-------------------------
InstallClipRegion
Description: installs a clip region into a layer
Offset: -$00AE (-174)
Syntax: oldClipRegion = InstallClipRegion(layer, region)
C: struct Region *InstallClipRegion(struct Layer *, struct Region *)
Machine Language: d0 = InstallClipRegion(a0, a1)
Modula-2: InstallClipRegion(layer: LayerPtr; region: RegionPtr): RegionPtr
Arguments: layer = Layer structure to which region will be added
region = Region structure to be added to layer
Result: oldClipRegion = previous clip region that was installed;
NULL if
no previous clip region
-------------------------
IntuiTextLength
Description: returns the pixel width of an IntuiText string
Offset: -$014A (-330)
Syntax: length = IntuiTextLength(intuiText)
C: long IntuiTextLength(struct IntuiText *)
Machine Language: d0 = IntuiTextLength(a0)
Modula-2: IntuiTextLength(intuiText: IntuiTextPtr): CARDINAL
Arguments: intuiText = IntuiText structure
Result: length = pixel width of text
-------------------------
Intuition
Description: sets Intuition's main entry point, where input events
arrive and
are dispatched
Offset: -$0024 (-36)
Syntax: Intuition(inputEvent)
C: void Intuition(struct InputEvent *)
Machine Language: Intuition(a0)
Modula-2: Intuition(inputEvent: InputEventPtr)
Arguments: inputEvent = first input event in a linked list of InputEvent
structures
Result: none
-------------------------
IoErr
Description: gets extra information from the system
Offset: -$0084 (-132)
Syntax: error = IoErr( )
C: long IoErr(void)
Machine Language: d0 = IoErr( )
Modula-2: IoErr( ): LONGINT
Arguments: none
Result: error = error code or other error information
-------------------------
IsInteractive
Description: finds out whether a file is connected to a virtual terminal
Offset: -$00D8 (-216)
Syntax: status = IsInteractive(file)
C: long IsInteractive(BPTR)
Machine Language: d0 = IsInteractive(d1)
Modula-2: IsInteractive(file: FileHandle): BOOLEAN
Arguments: file = BCPL pointer to a file handle
Result: status = TRUE if file is connected to a virtual terminal;
FALSE if
not
-------------------------
ItemAddress
Description: returns address of specified MenuItem
Offset: -$0090 (-144)
Syntax: address = ItemAddress(menuStrip, menuNumber)
C: struct MenuItem *ItemAddress(struct Menu *, long)
Machine Language: d0 = ItemAddress(a0, d0)
Modula-2: ItemAddress(menuStrip: MenuPtr; menuNumber: CARDINAL):
MenuItemPtr
Arguments: menuStrip = first menu in your menu strip
menuNumber = value with packed data that specifies the menu
and item (and optionally subitem)
Result: address = pointer to specified MenuItem; NULL if menuNumber
equals NULL
-------------------------
ITEMNUM (macro)
Description: extracts the menu item number from a value
C Include File: include/intuition/intuition.h
Syntax: itemNumber = ITEMNUM(menuValue)
C: long ITEMNUM(long)
Modula-2: ITEMNUM(menuValue: CARDINAL): CARDINAL
Arguments: menuValue = 16-bit packed number representing the menu num-
ber, item number, and subitem number
Result: itemNumber = item number (0-63); equals NOITEM if no menu
was selected
-------------------------
LoadRGB4
Description: loads color register values from a data table
Offset: -$00C0 (-192)
Syntax: LoadRGB4(viewPort, colormap, pens)
C: void LoadRGB4(struct ViewPort *, short *, long)
Machine Language: LoadRGB4(a0, a1, d0)
Modula-2: LoadRGB4(viewPort: ViewPortPtr; colormap: ADDRESS; pens:
INTEGER)
Arguments: viewPort = ViewPort whose colors you want to change
colormap = pointer to array of 16-bit color values, where the
firs
four bits are zero, the second contains red, the third green, and
the fourth blue
pens = number of consecutive color registers to load
Result: none
-------------------------
LoadSeg
Description: loads an AmigaDOS load module into memory
Offset: -$0096 (-150)
Syntax: segment = LoadSeg(name)
C: BPTR LoadSeg(char *)
Machine Language: d0 = LoadSeg(d1)
Modula-2: LoadSeg(name: STRPTR): BPTR
Arguments: name = NULL terminated string that specifies the filename of
load module
Result: segment = BCPL pointer to a segment; 0 if unsuccessful
-------------------------
LoadView
Description: creates a display using a new copper list
Offset: -$00DE (-222)
Syntax: LoadView(view)
C: void LoadView(struct View *)
Machine Language: LoadView(a1)
Modula-2: LoadView(view: ViewPtr)
Arguments: view = View structure with pointer to copper list
Result: none
-------------------------
Lock
Description: locks a directory or file
Offset: -$0054 (-84)
Syntax: lock = Lock(name, accessMode)
C: BPTR Lock(char *, long)
Machine Language: d0 = Lock(d1, d2)
Modula-2: Lock(name: STRPTR; accessMode: LONGINT): FileLock
Arguments: name = NULL terminated string that specifies name of file or
directory
accessMode = type of lock-ACCESS_READ (shared) or
ACCESS_WRITE (exclusive)
Result: lock = BCPL pointer to a lock
-------------------------
LockIBase
Description: locks IntuitionBase to keep other tasks (or the system)
from
changing it
Offset: -$019E (-414)
Modula-2 Module: IntuitionBase
Syntax: lockValue = LockIBase(lockNumber)
C: long LockIBase(long)
Machine Language: d0 = LockIBase(d0)
Modula-2: LockIBase(lockNumber: LONGCARD): LONGCARD
Arguments: lockNumber = Intuition lock desired (should be zero)
Result: lockValue = value to use to unlock IntuitionBase via
UnlockIBase( )
-------------------------
LockLayer
Description: locks a layer to protect it from graphics output
Offset: -$0060 (-96)
Syntax: LockLayer(dummy, layer)
C: void LockLayer(struct Layer_Info *, struct Layer *)
Machine Language: LockLayer(a0, a1)
Modula-2: LockLayer(layer: LayerPtr)
layer = Layer structure
Result: none
-------------------------
LockLayerInfo
Description: locks a Layer_Info structure to keep other tasks from
changing it
Offset: -$0078 (-120)
Syntax: LockLayerInfo(layerInfo)
C: void LockLayerInfo(struct Layer_Info *)
Machine Language: LockLayerInfo(a0, a1)
Modula-2: LockLayerInfo(layerInfo: LayerInfoPtr)
Arguments: layerInfo = Layerlnfo structure to lock
Result: none
-------------------------
LockLayerRom
Description: locks a Layer structure to keep other tasks from changing
it
Offset: -$01B0 (-432)
Syntax: LockLayerRom(layer)
C: void LockLayerRom(struct Layer *)
Machine Language: LockLayerRom(a5)
Modula-2: LockLayerRom(layer: LayerPtr)
Arguments: layer = Layer structure to lock
Result: none
-------------------------
LockLayers
Description: stops graphic output to all layers in a Layer_Info
structure
Offset: -$006C (-108)
Syntax: LockLayers(layerInfo)
C: void LockLayers(struct Layer_Info *)
Machine Language: LockLayers(a0)
Modula-2: LockLayers(layerInfo: LayerInfoPtr)
Arguments: layerlnfo = Layerlnfo structure with list of layers to lock
Result: none
-------------------------
MakeDosNode
Description: initializes the DeviceNode structure required to enter a
DOS disk
device into the system
Offset: -$0090 (-144)
Syntax: deviceNode = MakeDosNode(parameterPacket)
C: struct DeviceNode *MakeDosNode(long *)
Machine Language: d0 = MakeDosNode(a0)
Modula-2: MakeDosNode(parameterPacket: ADDRESS): DeviceNodePtr
Arguments: parameterPacket = array of long words containing the DOS han-
dler name, exec device name, unit number (for OpenDevice( )),
flags (for OpenDevice( )), number of long words used to describe
the handler environment, and the file handler environment, in
that order.
Result: deviceNode = pointer to initialized DeviceNode structure;
NULL
if not enough memory
-------------------------
MakeFunctions
Description: constructs a jump table of the type used by resources,
libraries,
and devices
Offset: -$005A (-90)
Syntax: size = MakeFunctions(destination, funcArray, funcDispBase)
C: void MakeFunctions(char *, long *, long)
Machine Language: d0 = MakeFunctions(a0, a1, a2)
Modula-2: MakeFunctions(destination, funcArray, funcDispBase: ADDRESS):
LONGCARD
Arguments: destination = target address for function jump table
funcArray = pointer to array of function pointers or
displacements
funcDispBase = pointer to base about which all function displace-
ments are relative; 0 if functionArray contains absolute pointers
Result: size = size of new table in bytes (Modula-2 only)
-------------------------
MakeLibrary
Description: constructs a library vector and data area
Offset: -$0054 (-84)
Syntax: library = MakeLibrary(vectors, structure, init, dataSize,
segList)
C: struct Library *MakeLibrary(long *, char *, _fptr, long, char *)
Machine Language: d0 = MakeLibrary(a0, a1, a2, d0, d1)
Modula-2: MakeLibrary(vectors, structure: ADDRESS; init: MAKELIBPROC;
dataSize: LONGCARD; segList: ADDRESS): LibraryPtr
Arguments: vectors = pointer to an array of function displacements-if first
word is -1 array contains relative word displacements; otherwise
array contains absolute function pointers
structure = pointer to an InitStruct data region; can be NULL
init = entry point that will be called before adding the library;
can be NULL
dataSize = size of library data area, including the standard
library
node data
segList = pointer to a memory segment list (used by DOS)
Result: library = reference address of library
-------------------------
MakeScreen
Description: executes an Intuition-integrated MakeVPort( ) of a custom
screen
Offset: -$017A (-378)
Syntax: MakeScreen(screen)
C: void MakeScreen(struct Screen *)
Machine Language: MakeScreen(a0)
Modula-2: MakeScreen(screen: ScreenPtr)
Arguments: screen = custom screen
Result: none
-------------------------
MakeVPort
Description: constructs intermediate copper list for a ViewPort
Offset: -$00D8 (-216)
Syntax: MakeVPort(view, viewPort)
C: void MakeVPort(struct View *, struct ViewPort *)
Machine Language: MakeVPort(a0, a1)
Modula-2: MakeVPort(view: ViewPtr; viewPort: ViewPortPtr)
Arguments: view = View structure
viewPort = ViewPort structure
Result: none
-------------------------
MarkCList
Description: marks a position in a character list
Offset: -$0078 (-120)
Syntax: error = MarkCList(cList, offset)
C: long MarkCList(long, long)
Machine Language: d0 = MarkCList(a0, a1)
Arguments: cList = CList descriptor
offset = byte offset into character list of position to mark
Result: error = 0 if successful; nonzero if offset not in character
list
-------------------------
MatchToolValue
Description: checks a tool type variable for a particular value
Offset: -$0066 (-102)
Syntax: result = MatchToolValue(typeString, value)
C: long MatchToolValue(char *, char *)
Machine Language: d0 = MatchToolValue(a0, a1)
Modula-2: MatchToolValue(typeString, value: STRPTR): BOOLEAN
Arguments: typeString = a ToolType value, as returned by FindToolType(
value = value you are looking for
Result: result = 0 if successful; nonzero if unsuccessful
-------------------------
MENUNUM (macro)
Description: extracts the menu number from a value
Syntax: menuNumber = MENUNUM(menuValue)
C: long MENUNUM(long)
Modula-2: MENUNUM(menuValue: CARDINAL): CARDINAL
Result: menuNumber = menu number (0-31); equals NOMENU if no
menu was selected
-------------------------
ModifyIDCMP
Description: modifies the state of a window's IDCMP
Offset: -$0096 (-150)
Syntax: ModifyIDCMP(window, flags)
C: void ModifyIDCMP(struct Window *, long)
Machine Language: ModifyIDCMP(a0, d0)
Modula-2: ModifyIDCMP(window: WindowPtr; flags: IDCMPFlagsSet)
Arguments: window = window containing IDCMP
flags = IDCMP flags
Result: none
-------------------------
ModifyProp
Description: modifies current state of proportional gadgets (see
NewModifyProp)
Offset: -$009C (-156)
Syntax: ModifyProp(propGadget, window, requester, flags, horizPot,
vertPot, horizBody, vertBody)
C: void ModifyProp(struct Gadget *, struct Window *, struct Request-
er *, long, long, long, long, long)
Machine Language: ModifyProp(a0, a1, a2, d0, d1, d2, d3, d4)
Modula-2: ModifyProp(propGadget: GadgetPtr; window: WindowPtr; re-
quester: RequesterPtr; flags: PropFlagSet; horizPot, vertPot,
horizBody, vertBody: CARDINAL)
Arguments: propGadget = proportional gadget to modify
window = window containing proportional gadget
requester = Requester structure; NULL if gadget is not part of a
requester
flags = new flags value
horizPot = new horizontal pot value (position)
vertPot = new vertical pot value (position)
horizBody = new horizontal body value (size of slider)
vertBody = new vertical body value (size of slider)
Result: none
-------------------------
Move
Description: moves the drawing pen to the specified position without
drawing
anything
Offset: -$00F0 (-240)
Modula-2 Module: Drawing
Syntax: Move(rastPort, x, y)
C: void Move(struct RastPort *, long, long)
Machine Language: Move(a0, d0, d1)
Modula-2: Move(rastPort: RastPortPtr; x, y: INTEGER)
x = new horizontal coordinate
y = new vertical coordinate
Result: none
-------------------------
MoveLayer
Description: moves a nonbackdrop layer to a new position in the bitmap
Offset: -$003C (-60)
Syntax: success = MoveLayer(dummy, layer, dx, dy)
C: long MoveLayer(struct Layerlnfo *, struct Layer *, long, long)
Machine Language: d0 = MoveLayer(a0, a1, d0, d1)
Modula-2: MoveLayer(layer: LayerPtr; dx, dy: LONGINT): BOOLEAN
layer = nonbackdrop Layer structure
dx = offset by which to move layer horizontally
dy = offset by which to move layer vertically
Result: success = TRUE is successful; FALSE if unsuccessful
-------------------------
MoveLayerInFrontOf
Description: moves a layer in front of another layer
Offset: -$00A8 (-168)
Syntax: success = MoveLayerInFrontOf(layer, target)
C: long MoveLayerInFrontOf(struct Layer *, struct Layer *)
Machine Language: d0 = MoveLayerInFrontOf(d0, a1)
Modula-2: MoveLayerInFrontOf(layer, target: LayerPtr): BOOLEAN
Arguments: layer = layer to move
target = layer to have another layer placed on top of
-------------------------
MoveScreen
Description: moves a screen vertically
Offset: -$00A2 (-162)
Syntax: MoveScreen(screen, dx, dy)
C: void MoveScreen(struct Screen *, long, long)
Machine Language: MoveScreen(a0, d0, a1)
Modula-2: MoveScreen(screen: ScreenPtr; dx, dy: INTEGER)
Arguments: screen = screen to move
dx = offset by which to move screen horizontally
dy = offset by which to move screen vertically (not implemented
as of system version 1.3)
Result: none
-------------------------
MoveSprite
Description: moves a sprite to specified location
Offset: -$01AA (-426)
Syntax: MoveSprite(viewPort, sprite, x, y)
C: long MoveSprite(struct ViewPort *, struct SimpleSprite *, long,
long)
Machine Language: MoveSprite(a0, a1, d0, d1)
Modula-2: MoveSprite(viewPort: ViewPortPtr; sprite: SimpleSpritePtr; x, y:
INTEGER)
sprite = SimpleSprite structure
x = new horizontal position of sprite
y = new vertical position of sprite
Result: none
-------------------------
MoveWindow
Description: moves a window
Offset: -$00A8 (-168)
Syntax: MoveWindow(window, dx, dy)
C: void MoveWindow(struct Window *, long, long)
Machine Language: MoveWindow(a0, d0, a1)
Modula-2: MoveWindow(window: WindowPtr; dx, dy: INTEGER)
Arguments: window = window to move
dx = offset by which to move window horizontally
dy = offset by which to move window vertically
Result: none
-------------------------
MrgCop
Description: merges coprocessor instructions to form one instruction
list
Offset: -$00D2 (-210)
Syntax: MrgCop(view)
C: void MrgCop(struct View *)
Machine Language: MrgCop(a1)
Modula-2: MrgCop(view: ViewPtr)
Arguments: view = View structure
Result: none
-------------------------
NewFontContents
Description: creates an array of FontContents entries describing all
fonts asso-
ciated with specified font name
Offset: -$002A (-42)
Syntax: fontContentsHeader = NewFontContents(fontsLock, fontName)
C: struct FontContentsHeader *NewFontContents(BPTR, char *)
Machine Language: d0 = NewFontContents(a0, a1)
Arguments: fontsLock = BCPL pointer to a lock on the directory containing
the fonts contents file (usually FONTS: directory)
fontName = filename of font contents file (for example,
"Diamond.font")
Result: fontContentsHeader = pointer to a FontContentsHeader
-------------------------
NewLayerInfo
Description: creates a Layer_Info structure
Offset: -$0090 (-144)
Syntax: layerInfo = NewLayerInfo( )
C: struct Layer_Info *NewLayerInfo(void)
Machine Language: d0 = NewLayerInfo( )
Modula-2: NewLayerInfo( ): LayerInfoPtr
Arguments: none
Result: layerInfo = pointer to initialized Layer_Info structure;
NULL if
unsuccessful
-------------------------
NewList
Description: initializes a list header
Syntax: NewList(list)
C: void NewList(struct List *)
Modula-2: NewList(VAR list: List)
Arguments: list = List structure
Result: none
-------------------------
NewModifyProp
Description: modifies current state of proportional gadgets, with
selective gad-
get refresh
Offset: -$01D4 (-468)
Syntax: NewModifyProp(propGadget, window, requester, flags,
horizPot,
vertPot, horizBody, vertBody, gadgetNumber)
C: void NewModifyProp(struct Gadget *, struct Window *, struct Re-
quester *, long, long, long, long, long, long)
Machine Language: NewModifyProp(a0, a1, a2, d0, d1, d2, d3, d4, d5)
Modula-2: NewModifyProp(propGadget: GadgetPtr; window: WindowPtr; re-
quester: RequesterPtr; flags: PropFlagSet; horizPot, vertPot,
horizBody, vertBody: CARDINAL; gadgetNumber: INTEGER)
Arguments: propGadget = proportional gadget to modify
window = window containing proportional gadget
requester
flags = new flags value
horizPot = new horizontal pot value (position)
vertPot = new vertical pot value (position)
horizBody = new horizontal body value (size of slider)
vertBody = new vertical body value (size of slider)
gadgetNumber = number of gadgets to refresh after gadget modi-
fication; -1 to refresh all gadgets to the end of gadget list
Result: none
-------------------------
NewRegion
Description: creates an empty Region structure
Offset: -$0204 (-516)
Syntax: region = NewRegion( )
C: struct Region *NewRegion(void)
Modula-2: NewRegion(VAR list: List)
NewRegion( ): RegionPrt
Arguments: none
Result: region = pointer to initialized Region structure; NULL if
not
enough memory
-------------------------
ObtainConfigBinding
Description: attempts to get permission to bind drivers
Offset: -$0078 (-120)
Syntax: ObtainConfigBinding( )
C: void ObtainConfigBinding(void)
Machine Language: ObtainConfigBinding( )
Arguments: none
Result: none
------------------------
ObtainSemaphore
Description: obtains exclusive use of a signal semaphore
Offset: -$0234 (-564)
Syntax: ObtainSemaphore(signalSemaphore)
C: void ObtainSemaphore(struct SignalSemaphore *)
Machine Language: ObtainSemaphore(a0)
Modula-2: ObtainSemaphore(signalSemaphore: SignalSemaphorePtr)
Result: none
-------------------------
ObtainSemaphoreList
Description: obtains exclusive use of a list of signal semaphores
Offset: -$0246 (-582)
Syntax: ObtainSemaphoreList(list)
C: void ObtainSemaphoreList(struct List *)
Machine Language: ObtainSemaphoreList(a0)
Modula-2: ObtainSemaphoreList(list: SignalSemaphorePtr)
Arguments: list = List structure representing a list of signal semaphores
Result: none
-------------------------
OFFDISPLAY (macro)
Description: clears the display DMA bit in the DMA control register
Modula-2 Module: CustomHardware
Syntax: OFF_DISPLAY( )
C: void OFF_DISPLAY(void)
Modula-2: OFFDISPLAY( )
Arguments: none
Result: none
-------------------------
OffGadget
Description: disables a gadget
Offset: -$00AE (-174)
Syntax: OffGadget(gadget, window, requester)
C: void OffGadget(struct Gadget , struct Window *, struct Requester
*)
Machine Language: OffGadget(a0, a1, a2)
Modula-2: OffGadget(gadget: GadgetPtr; window: WindowPtr; requester:
RequesterPtr)
Arguments: gadget = gadget to disable
requester
Result: none
-------------------------
OffMenu
Description: disables a menu or menu item
Offset: -$00B4 (-180)
Syntax: OffMenu(window, menuNumber)
C: void OffMenu(struct Window *, long)
Machine Language: OffMenu(a0, d0)
Modula-2: OffMenu(window: WindowPtr; menuNumber: CARDINAL)
Arguments: window = window containing menu or menu item
menuNumber = number specifying menu or menu item to dis-
able-bits 0-4 specify menu number, bits 5-10 specify menu
item, and bits 11-15 specify menu subitems
Result: none
-------------------------
OFF_SPRITE (macro)
Description: clears the sprite DMA bit in the DMA control register
Syntax: OFF_SPRITE( )
C: void OFF_SPRITE(void)
Modula-2: OFFSPRITE( )
Arguments: none
Result: none
-------------------------
OFF_VBLANK (macro)
Description: clears the vertical blanking interrupt (bit 5) in the
interrupt control
register
Syntax: OFF_VBLANK( )
C: void OFF_VBLANK(void)
Arguments: none
Result: none
-------------------------
OldOpenLibrary
Description: obsolete version of the OpenLibrary( ) function which gains
access
to a library without requiring a version number; do not use this
function-use OpenLibrary( ) instead
Offset: -$0198 (-408)
Syntax: library = Old0penLibrary(name)
C: struct Library *Old0penLibrary(char *)
Machine Language: d0 = Old0penLibrary(a1)
Arguments: name = name of desired library
Result: library = base pointer to desired library; NULL if library
cannot
be found
-------------------------
ON_DISPLAY (macro)
Description: sets the display DMA bit in the DMA control register
Syntax: ON_DISPLAY( )
C: void ON_DISPLAY(void)
Modula-2: ONDISPLAY( )
Arguments: none
Result: none
-------------------------
OnGadget
Description: enables a gadget
Offset: -$00BA (-186)
Syntax: OnGadget(gadget, window, requester)
C: void OnGadget(struct Gadget *, struct Window *, struct Requester
*)
Machine Language: OnGadget(a0, a1, a2)
Modula-2: OnGadget(gadget: GadgetPtr; window: WindowPtr; requester:
RequesterPtr)
Arguments: gadget = gadget to enable
requester
Result: none
-------------------------
OnMenu
Description: enables a menu or menu item
Offset: -$00C0 (-192)
Syntax: OnMenu(window, menuNumber)
C: void OnMenu(struct Window *, long)
Machine Language: OnMenu(a0, d0)
Modula-2: OnMenu(window: WindowPtr; menuNumber: CARDINAL)
Arguments: window = window containing menu or menu item
menuNumber = number specifying menu or menu item to en-
able-bits 0-4 specify menu number, bits 5-10 specify menu
item, and bits 11-15 specify menu subitems
Result: none
-------------------------
ON_SPRITE (macro)
Description: sets the sprite DMA bit in the DMA control register
Syntax: ON_SPRITE( )
C: void ON_SPRITE(void)
Machine Language: ON_SPRITE( )
Modula-2: ONSPRITE( )
Arguments: none
Result: none
-------------------------
ON_VBLANK (macro)
Description: sets the vertical blanking interrupt (bit 5) in the
interrupt control
register
Syntax: ON_VBLANK( )
C: void ON_VBLANK(void)
Machine Language: ON_VBLANK( )
Arguments: none
Result: none
-------------------------
Open
Description: opens a file for input or output
Offset: -$001E (-30)
Syntax: file = Open(name, accessMode)
C: BPTR Open(char *, long)
Machine Language: d0 = Open(d1, d2)
Modula-2: Open(name: STRPTR; accessMode: LONGINT): FileHandle
Arguments: name = NULL terminated string specifying filename
accessMode = type of file access desired-MODE_OLDFILE for
reading, MODE_NEWFILE for writing
Result: file = BCPL pointer to file handle; NULL if unsuccessful
-------------------------
OpenDevice
Description: provides access to a device and initializes an IO request
block for
access to the device
Offset: -$01BC (-444)
Syntax: error = OpenDevice(name, unitNumber, ioRequest, flags)
C: long OpenDevice(char *, long, struct IORequest *, long)
Machine Language: d0 = OpenDevice(a0, d0, a1, d2)
Modula-2: OpenDevice(name: STRPTR; unitNumber: LONGCARD;
ioRequest: ADDRESS; flags: LONGBITSET): INTEGER
Arguments: name = NULL terminated string specifying device name
unitNumber = desired unit number for device (device specific)
ioRequest = IORequest block to initialize
flags = additional device information (device specific)
Result: error = 0 if successful; nonzero if unsuccessful
-------------------------
OpenDiskFont
Description: gains access to a disk-resident font
Offset: -$001E (-30)
Modula-2 Module: DiskFont
Syntax: font = OpenDiskFont(textAttr)
C: struct TextFont *OpenDiskFont(struct TextAttr *)
Machine Language: d0 = OpenDiskFont(a0)
Modula-2: OpenDiskFont(textAttr: TextAttrPtr): TextFontPtr
Arguments: textAttr = TextAttr structure that describes the desired font
Result: font = pointer to desired TextFont structure; 0 if
unsuccessful
-------------------------
OpenFont
Description: gains access to a memory-resident font
Offset: -$0048 (-72)
Syntax: font = OpenFont(textAttr)
C: struct TextFont *OpenFont(struct TextAttr *)
Machine Language: d0 = OpenFont(a0)
Modula-2: OpenFont(textAttr: TextAttrPtr): TextFontPtr
Arguments: textAttr = TextAttr structure that describes the desired font
Result: font = pointer to desired TextFont structure; 0 if
unsuccessful
-------------------------
OpenLibrary
Description: gains access to a library
Offset: -$0228 (-552)
Syntax: library = OpenLibrary(name, version)
C: struct Library *OpenLibrary(char *, long)
Machine Language: d0 = OpenLibrary(a1, d0)
Modula-2: OpenLibrary(name: STRPTR; version: LONGCARD): LibraryPtr
Arguments: name = name of desired library
version = lowest acceptable library version number; 0 if you
don't care
Result: library = base pointer to desired library; NULL if library
cannot
be found
-------------------------
OpenResource
Description: gains access to a resource
Offset: -$01F2 (-498)
Syntax: resource = OpenResource(name)
C: struct Resource *OpenResource(char *)
Machine Language: d0 = OpenResource(a1)
Modula-2: OpenResource(name: STRPTR): ResourcePtr
Arguments: name = name of desired resource
Result: resource = pointer to resource; NULL if unsuccessful
-------------------------
OpenScreen
Description: opens an Intuition screen
Offset: -$00C6 (-198)
Syntax: screen = OpenScreen(newScreen)
C: struct Screen *OpenScreen(struct NewScreen *)
Machine Language: d0 = OpenScreen(a0)
Modula-2: OpenScreen(newScreen: NewScreenPtr): ScreenPtr
Arguments: newScreen = NewScreen structure that describes screen to open
Result: screen = pointer to Screen structure; NULL if unsuccessful
-------------------------
OpenWindow
Description: opens an Intuition window
Offset: -$00CC (-204)
Syntax: window = OpenWindow(newWindow)
C: struct Window *OpenWindow(struct NewWindow *)
Machine Language: d0 = OpenWindow(a0)
Modula-2: OpenWindow(newWindow: NewWindowPtr): WindowPtr
Arguments: newWindow = NewWindow structure that describes window to
open
Result: window = pointer to Window structure; NULL if unsuccessful
-------------------------
OpenWorkBench
Description: opens the Workbench screen
Offset: -$00D2 (-210)
Syntax: success = OpenWorkBench( )
C: long OpenWorkBench(void)
Machine Language: d0 = OpenWorkBench( )
Modula-2: OpenWorkBench( ): BOOLEAN
Arguments: none
Result: success = TRUE if successful (value represents pointer to
Work-
Bench screen-this may change in system versions greater than
1.3); FALSE (NULL) if unsuccessful
-------------------------
OrRectRegion
Description: performs a two-dimensional OR operation of a rectangle with
a
region, leaving the result in the region
Offset: -$01FE (-510)
Syntax: success = OrRectRegion(region, rectangle)
C: long OrRectRegion(struct Region *, struct Rectangle *)
Machine Language: d0 = OrRectRegion(a0, a1)
Modula-2: OrRectRegion(region: RegionPtr; rectangle: RectanglePtr):
BOOLEAN
-------------------------
OrRegionRegion
Description: performs a two-dimensional OR operation of one region with
a
second region, leaving the result in second region
Offset: -$0264 (-612)
Syntax: success = OrRegionRegion(region1, region2)
C: long OrRegionRegion(struct Region *, struct Region *)
Machine Language: d0 = OrRegionRegion(a0, a1)
Modula-2: OrRegionRegion(region1, region2: RegionPtr): BOOLEAN
-------------------------
Output
Description: gets the initial output file handle assigned to a program
Offset: -$003C (-60)
Syntax: file = Output( )
C: BPTR Output(void)
Machine Language: d0 = Output( )
Modula-2: Output( ): FileHandle
Arguments: none
Result: file = BCPL pointer to a file handle
-------------------------
OwnBlitter
Description: reserves the blitter for private use
Offset: -$01C8 (-456)
Syntax: OwnBlitter( )
C: void OwnBlitter(void)
Machine Language: OwnBlitter( )
Modula-2: OwnBlitter( )
Arguments: none
Result: none
-------------------------
ParentDir
Description: obtains the parent directory of a file or directory
Offset: -$00D2 (-210)
Syntax: lock = ParentDir(lock)
C: BPTR ParentDir(BPTR)
Machine Language: d0 = ParentDir(d1)
Modula-2: ParentDir(lock: FileLock): FileLock
Arguments: lock = BCPL pointer to lock associated with child file or
directory
Result: lock = BCPL pointer to lock associated with parent
directory
-------------------------
PeekCLMark
Description: gets byte located in mark position of a character list
Offset: -$0084 (-132)
Syntax: byte = PeekCLMark(cList)
C: long PeekCLMark(long)
Machine Language: d0 = PeekCLMark(a0)
Arguments: cList = character list descriptor
Result: byte = byte located in mark position of character list
-------------------------
Permit
Description: permits task rescheduling halted by Forbid( )
Offset: -$008A (-138)
Syntax: Permit( )
C: void Permit(void)
Machine Language: Permit( )
Modula-2: Permit( )
Arguments: none
Result: none
-------------------------
PolyDraw
Description: draws a series of connected lines from current pen position
to
points specified by a table of (x,y) coordinates
Offset: -$0150 (-336)
Syntax: PolyDraw(rastPort, count, array)
C: long PolyDraw(struct RastPort *, long, short *)
Machine Language: PolyDraw(al, d0, a0)
Modula-2: PolyDraw(rastPort: RastPortPtr; count: INTEGER; array:
ADDRESS)
Arguments: rastPort = RastPort to draw lines in
count = number of coordinates in array
array = pointer to array of coordinates
Result: none
-------------------------
printf
Description: prints a formatted string to the standard output (Lattice
and Manx
users: if you link with lc.lib or c.lib, this is not the function
you're
calling)
Syntax: printf(string, values...)
C: void printf(char *, long...)
pea string
jsr _printf
Arguments: string = string containing optional C formatting commands (%); if
you're passing longword values on the stack (as shown above) be
sure to follow the percent symbol with a lowercase L
of formatting commands in the string argument
Result: none
-------------------------
PrintIText
Description: prints text according to its IntuiText specifications
Offset: -$00D8 (-216)
Syntax: PrintIText(rastPort, intuiText, leftEdge, topEdge)
C: void PrintIText(struct RastPort *, struct IntuiText *, long,
long)
Machine Language: PrintIText(a0, a1, d0, d1)
Modula-2: PrintIText(rastPort: RastPortPtr; intuiText: IntuiTextPtr;
leftEdge,
topEdge: INTEGER)
Arguments: rastPort = RastPort structure to receive text
intuiText = IntuiText structure containing text
leftEdge = horizontal position of text within RastPort
topEdge = vertical position of text within RastPort
Result: none
-------------------------
Procure
Description: obtains a message-based semaphore
Offset: -$021C (-540)
Syntax: success = Procure(semaphore, message)
C: long Procure(struct Semaphore *, struct Message *)
Machine Language: d0 = Procure(a0, a1)
Modula-2: Procure(semaphore: SemaphorePtr; message: MessagePtr):
BOOLEAN
Arguments: semaphore = Semaphore structure
message = Message structure to be used if desired semaphore is
unavailable
-------------------------
PutCLBuf
Description: converts contiguous data into a character list
Offset: -$006C (-108)
Syntax: error = PutCLBuf(cList, buffer, length)
C: long PutCLBuf(long, char *, long)
Machine Language: d0 = PutCLBuf(a0, a1, d1)
or
StrToCL( )
buffer = buffer containing data to be converted
length = size of buffer in bytes
-------------------------
PutCLChar
Description: adds a byte to the end of a character list
Offset: -$003C (-60)
Syntax: error = PutCLChar(cList, byte)
C: long PutCLChar(long, long)
Machine Language: d0 = PutCLChar(a0, d0)
or
StrToCL( )
byte = byte to be added to end of character list
-------------------------
PutCLWord
Description: adds a word to the end of a character list
Offset: -$0054 (-84)
Syntax: error = PutCLWord(cList, word)
C: long PutCLWord(long)
Machine Language: d0 = PutCLWord(a0, d0)
or
StrToCL( )
word = word to be added to end of character list
-------------------------
PutDiskObject
Description: writes a Workbench DiskObject to disk as an .info file
Offset: -$0054 (-84)
Syntax: success = PutDiskObject(name, diskObj)
C: long PutDiskObject(char *, struct DiskObject *)
Machine Language: d0 = PutDiskObject(a0, a1)
Modula-2: PutDiskObject(name: STRPTR; diskObj: DiskObjectPtr): BOOLEAN
Arguments: name = name of object
diskObj = DiskObject structure (.info file)
Result: success = nonzero if successful
-------------------------
PutIcon
Description: writes a DiskObject to disk as an .info file
Offset: -$0030 (-48)
Syntax: success = PutIcon(name, icon)
C: long PutIcon(char *, struct DiskObject *)
Machine Language: d0 = PutIcon(a0, a1)
Arguments: name = name of icon (.info file)
icon = DiskObject structure
-------------------------
PutMsg
Description: gets next message from a message port
Offset: -$016E (-366)
Syntax: PutMsg(port, message)
C: void PutMsg(struct MsgPort *, struct Message *)
Machine Language: PutMsg(a0, a1)
Modula-2: PutMsg(port: MsgPortPtr; message: ADDRESS)
Arguments: port = message port to receive message
message = Message structure containing message to send
Result: none
-------------------------
PutWBObject
Description: writes a WBObject to disk as an .info file
Offset: -$0024 (-36)
Syntax: success = PutWBObject(name, object)
C: long PutWBObject(char *, struct WBObject *)
Machine Language: d0 = PutWBObject(a0, a1)
Arguments: name = name of WBObject (.info file)
object = WBObject structure
-------------------------
QBlit
Description: queues up a blitter request
Offset: -$0114 (-276)
Syntax: QBlit(blitNode)
C: void QBlit(struct BlitNode *)
Machine Language: QBlit(a1)
Modula-2: QBlit(blitNode: bltnodePtr)
Arguments: blitNode = BlitNode structure containing link information and
address of your blitter routine
Result: none
-------------------------
QBSlit
Description: queues and synchronizes a blitter request with the video
beam
Offset: -$0126 (-294)
Syntax: QBSlit(blitNode)
C: void QBSlit(struct BlitNode *)
Machine Language: QBSlit(a1)
Modula-2: QBSlit(blitNode: bltnodePtr)
Arguments: blitNode = BlitNode structure containing link information and
address of your blitter routine
Result: none
-------------------------
RangeRand
Description: generates a random integer within a specified range
Syntax: rnd = RangeRand(range)
C: long RangeRand(long)
Machine Language: move.l range,-(sp)
jsr _RangRand ;rnd returned in d0
addq.l #4,sp
Arguments: range = highest integer acceptable
Result: rnd = random number between 0 and value of range argument
-------------------------
RASSIZE (macro)
Description: calculates the memory requirements for a raster bitmap of
the
specified with and height
C Include File: include/graphics/gfx.h
Modula-2 Module: Graphics
Syntax: bytes = RASSIZE(width, height)
C: long RASSIZE(long, long)
Modula-2: RASSIZE(width, height: LONGCARD)
Arguments: width = width of hypothetical bitmap in pixels
height = height of hypothetical bitmap in pixels
Result: bytes = number of bytes required to contain raster bitmap
-------------------------
RawDoFmt
Description: formats data into a character stream using C formatting
commands (%)
Offset: -$020A (-522)
Syntax: RawDoFmt(formatString, dataStream, putChProc, putChData)
C: void RawDoFmt(char *, APTR, void (*)(), APTR)
Machine Language: RawDoFmt(a0, a1, a2, a3)
Modula-2: RawDoFmt(formatString, dataStream: ADDRESS; putChProc:
PROC; putChData: ADDRESS)
Arguments: formatString = string with optional C formatting commands (%)
dataStream = stream of data that is interpreted according to the
formatString
putChProc = address of procedure to call with each character to
be output, where procedure is called as PutChProc(char,
putChData)
putChData = value to pass to PutChProc
Result: none
-------------------------
Read
Description: reads data from a file
Offset: -$002A (-42)
Syntax: actualLength = Read(file, buffer, length)
C: long Read(BPTR, char *, long)
Machine Language: d0 = Read(d1, d2, d3)
Modula-2: Read(file: FileHandle; buffer: ADDRESS; length: LONGINT):
LONGINT
buffer = address of memory block to receive data
length = number of bytes to read (must not exceed buffer size)
Result: actualLength = actual number of bytes received
-------------------------
ReadExpansionByte
Description: reads a byte nybble-by-nybble from a new-style expansion
board
Offset: -$0060 (-96)
Syntax: byte = ReadExpansionByte(board, offset)
C: long ReadExpansionByte(long, long)
Machine Language: d0 = ReadExpansionByte(a0, d0)
Modula-2: ReadExpansionByte(board: ADDRESS; offset: LONGCARD):
INTEGER
Arguments: board = base address of expansion board
offset = logical offset from board base
Result: byte = data received; -1 if an error occurred
-------------------------
ReadExpansionRom
Description: reads a new-style expansion board's configuration ROM space
Offset: -$0066 (-102)
Syntax: error = ReadExpansionRom(board, configDev)
C: long ReadExpansionRom(long, long)
Machine Language: d0 = ReadExpansionRom(a0, a1)
Modula-2: ReadExpansionRom(board: ADDRESS; configDev: ADDRESS):
BOOLEAN
Arguments: board = base address of expansion board
configDev = ConfigDev structure to receive ROM data
Result: error = 0 if successful; nonzero if an error occurred
-------------------------
ReadPixel
Description: finds the color register (pen) used to color a specific
pixel
Offset: -$013E (-318)
Syntax: pen = ReadPixel(rastPort, x, y)
C: long ReadPixel(struct RastPort *, long, long)
Machine Language: d0 = ReadPixel(a0, d0, d1)
Modula-2: ReadPixel(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
x = horizontal coordinate of pixel
y = vertical coordinate of pixel
Result: pen = pen number; -1 if pixel lies outside boundaries of
rastport
-------------------------
RectFill
Description: fills a rectangular area using the current pen color,
outline color,
secondary color, and pattern
Offset: -$0132 (-306)
Syntax: RectFill(rastPort, xmin, ymin, xmax, ymax)
C: void RectFill(struct RastPort *, long, long, long, long)
Machine Language: RectFill(a0, d0, d1, d2, d3)
Modula-2: RectFill(rastPortPtr: RastPort; xmin, ymin, xmax, ymax: INTEGER)
xmin = horizontal coordinate rectangle's upper left corner
ymin = vertical coordinate rectangle's upper left corner
xmax = horizontal coordinate rectangle's lower right corner
ymax = vertical coordinate rectangle's lower right corner
Result: none
-------------------------
RefreshGadgets
Description: redraws a gadget and all following gadgets in gadget list
Offset: -$00DE (-222)
Syntax: RefreshGadgets(gadgets, window, requester)
C: void RefreshGadgets(struct Gadget *, struct Window *, struct Re-
quester *)
Machine Language: RefreshGadgets(a0, a1, a2)

Modula-2: RefreshGadgets(gadgets: GadgetPtr; window: WindowPtr; request-
er: RequesterPtr)
Arguments: gadgets = first gadget in list of gadgets to refresh
window = window containing gadgets
requester = requester containing gadget; NULL if gadget is not
part of a requester
Result: none
-------------------------
RefreshGList
Description: redraws a gadget and specified number of following gadgets
in
gadget list
Offset: -$01BO (-432)
Syntax: RefreshGList(gadgets, window, requester, numGadgets)
C: void RefreshGList(struct Gadget *, struct Window *, struct Re-
quester *, long)
Machine Language: RefreshGList(a0, a1, a2, d0)
Modula-2: RefreshGList(gadgets: GadgetPtr; window: WindowPtr; requester:
RequesterPtr; numGadgets: INTEGER)
Arguments: gadgets = first gadget in list of gadgets to refresh
window = window containing gadgets
requester = requester containing gadget; NULL if gadget is not
part of a requester
numGadgets = number of gadgets to refresh; -1 to refresh to
end of gadget list
Result: none
-------------------------
RefreshWindowFrame
Description: redraws a window's border, title bar, and gadgets
Offset: -$01C8 (-456)
Syntax: RefreshWindowFrame(window)
C: void RefreshWindowFrame(struct Window *)
Machine Language: RefreshWindowFrame(a0)
Modula-2: RefreshWindowFrame(window: WindowPtr)
Arguments: window = window to refresh
Result: none
-------------------------
ReleaseConfigBinding
Description: allows others to bind drivers
Offset: -$007E (-126)
Syntax: ReleaseConfigBinding( )
C: void ReleaseConfigBinding(void)
Machine Language: ReleaseConfigBinding( )
Arguments: none
Result: none
-------------------------
ReleaseSemaphore
Description: releases a signal semaphore for use by other tasks
Offset: -$023A (-5 70)
Syntax: ReleaseSemaphore(signalSemaphore)
C: void ReleaseSemaphore(struct SignalSemaphore *)
Machine Language: ReleaseSemaphore(a0)
Modula-2: ReleaseSemaphore(signalSemaphore: SignalSemaphorePtr)
Result: none
-------------------------
ReleaseSemaphoreList
Description: releases a list of signal semaphores for other tasks
Offset: -$024C (-588)
Syntax: ReleaseSemaphoreList(list)
C: void ReleaseSemaphoreList(struct List *)
Machine Language: ReleaseSemaphoreList(a0)
Modula-2: ReleaseSemaphoreList(list: SignalSemaphorePtr)
Arguments: list = List structure representing a list of signal semaphores
Result: none
-------------------------
RemakeDisplay
Description: redraws every intuition screen
Offset: -$0180 (-384)
Syntax: RemakeDisplay( )
C: void RemakeDisplay(void)
Machine Language: RemakeDisplay( )
Modula-2: RemakeDisplay( )
Arguments: none
Result: none
-------------------------
RemBob (macro)
Description: removes a Bob from current GEL list
C Include File: include/graphics/gels.h
ML Include File: graphics/gels.i
Syntax: RemBob(bob, rastPort)
C: void RemBob(struct Bob *, struct RastPort *)
Machine Language: RemBob(a0)
Arguments: bob = Bob structure to remove
rastPort = controlling RastPort structure (not needed in
Modula-2)
Result: none
-------------------------
RemConfigDev
Description: removes a ConfigDev structure from the system
Offset: -$006C (-108)
Syntax: RemConfigDev(configDev)
C: void RemConfigDev(long)
Machine Language: RemConfigDev(a0)
Modula-2: RemConfigDev(configDev: ConfigDevPtr)
Arguments: configDev = ConfigDev structure
Result: none
-------------------------
RemDevice
Description: removes a device from the system
Offset: -$01B6 (-438)
Syntax: error= RemDevice(device)
C: long RemDevice(struct Device *)
Machine Language: d0 = RemDevice(a1)
Modula-2: RemDevice(device: DevicePtr)
Arguments: device = device node
-------------------------
RemFont
Description: removes a font from the system
Offset: -$01E6 (-486)
Syntax: error = RemFont(textFont)
C: long RemFont(struct TextFont *)
Machine Language: d0 = RemFont(a1)
Modula-2: RemFont(textFont: TextFontPtr)
Arguments: textFont = TextFont structure to remove
Result: error = 0 if successful; nonzero if unsuccessful (no value
returned
by Modula-2)
-------------------------
RemHead
Description: removes a node from the head of a list
Offset: -$0102 (-258)
Syntax: node = RemHead(list)
C: struct Node *RemHead(struct List *)
Machine Language: d0 = RemHead(a0)
Modula-2: RemHead(list: ListPtr): NodePtr
Result: node = node removed; NULL if list is was already empty
-------------------------
RemIBob
Description: immediately removes a Bob from the GEL list and erases it
from
the RastPort display
Offset: -$0084 (-132)
Syntax: RemIBob(bob, rastPort, viewPort)
C: void RemIBob(struct Bob *, struct RastPort *, struct ViewPort *)
Machine Language: RemIBob(a0, a1, a2)
Modula-2: RemIBob(bob: BobPtr; rastPort: RastPortPtr; viewPort:
ViewPortPtr)
Arguments: bob = Bob structure to remove from GEL list
viewPort = ViewPort structure
Result: none
-------------------------
RemIntServer
Description: removes an interrupt server from the system
Offset: -$00AE (-174)
Modula-2 Module: Interrupts/
Syntax: RemIntServer(intNum, interrupt)
C: void RemIntServer(long, struct Interrupt *)
Machine Language: RemIntServer(d0, a1)
Modula-2: RemIntServer(intNum: CARDINAL; interrupt: InterruptPtr)
Arguments: intNum = portia interrupt bit (0-4)
interrupt = interrupt server node
Result: none
-------------------------
RemLibrary
Description: removes a library from the system
Offset: -$0192 (-402)
Syntax: error= RemLibrary(library)
C: long RemLibrary(struct Library *)
Machine Language: d0 = RemLibrary(a1)
Modula-2: RemLibrary(Library: LibraryPtr)
Arguments: library = Library structure to remove
-------------------------
Remove
Description: removes a node from a list
Offset: -$00FC (-252)
Syntax: Remove(node)
C: void Remove(struct Node *)
Machine Language: Remove(a1)
Modula-2: Remove(node: NodePtr)
Arguments: node = node to remove
Result: none
-------------------------
RemoveGadget
Description: removes gadget from a window
Offset: -$00E4 (-228)
Syntax: position = RemoveGadget(window, gadget)
C: long RemoveGadget(struct Window *, struct Gadget *)
Machine Language: d0 = RemoveGadget(a0, a1)
Modula-2: RemoveGadget(window: WindowPtr; gadget: GadgetPtr):
INTEGER
Arguments: window = window that contains gadget
gadget = gadget to remove
Result: position = position in gadget list where gadget was
located; -1 if
gadget was not found
-------------------------
RemoveGList
Description: removes a series of gadgets from a gadget list
Offset: -$01BC (-444)
Syntax: position = RemoveGList(window, gadget, numGadgets)
C: long RemoveGList(struct Window *, Gadget *, long)
Machine Language: d0 = RemoveGList(a0, a1, d0)
Modula-2: RemoveGList(window: WindowPtr; gadget: GadgetPtr;

numGadgets: INTEGER): INTEGER
Arguments: window = window containing gadgets
gadget = first gadget in gadget list to remove
numGadgets = number of gadgets to remove
Result: position = position of removed gadget list; -1 if gadget
was not
found
-------------------------
RemPort
Description: removes a message port from the system
Offset: -$0168 (-360)
Syntax: RemPort(port)
C: void RemPort(struct MsgPort *)
Machine Language: RemPort(a1)
Modula-2: RemPort(port: MsgPortPtr)
Arguments: port = message port to remove
Result: none
-------------------------
RemResource
Description: removes a resource from the system
Offset: -$01EC (-492)
Syntax: RemResource(resource)
C: void RemResource(struct Resource *)
Machine Language: RemResource(a1)
Modula-2: RemResource(resource: ResourcePtr)
Arguments: resource = resource to remove
Result: none
-------------------------
RemSemaphore
Description: removes signal semaphore from the system
Offset: -$025E (-606)
Syntax: RemSemaphore(signalSemaphore)
C: void RemSemaphore(struct SignalSemaphore *)
Machine Language: RemSemaphore(a1)
Modula-2: RemSemaphore(signalSemaphore: SignalSemaphorePtr)
Arguments: signalSemaphore = signal semaphore to remove
Result: none
-------------------------
RemTail
Description: removes node from the tail of a list
Offset: -$0108 (-264)
Syntax: node = RemTail(list)
C: struct Node *RemTail(struct List *)
Machine Language: d0 = RemTail(a0)
Modula-2: RemTail(list: ListPtr): NodePtr
Result: node = pointer to removed node; NULL if list is already
empty
-------------------------
RemTask
Description: removes a task from the system
Offset: -$0120 (-288)
Syntax: RemTask(task)
C: void RemTask(struct Task *)
Machine Language: RemTask(a1)
Modula-2: RemTask(task: TaskPtr)
Arguments: task = task to remove
Result: none
-------------------------
RemTOF
Description: removes a task from the TopOfFrame (vertical-blanking
interval)
interrupt server chain
Syntax: RemTOF(i)
C: void RemTOF(struct Isrvstr *)
Machine Language: pea i
jsr _RemTOF
addq.l #4,sp
Arguments: i = Isrvstr structure
Result: none
-------------------------
RemVSprite
Description: removes a VSprite from the GEL list
Offset: -$008A (-138)
Syntax: RemVSprite(vSprite)
C: void RemVSprite(struct VSprite *)
Machine Language: RemVSprite(a0)
Modula-2: RemVSprite(vSprite: VSpritePtr)
Arguments: vSprite = VSprite to remove
Result: none
-------------------------
Rename
Description: renames a directory or file
Offset: -$004E (-78)
Syntax: success = Rename(oldName, newName)
C: long Rename(char *, char *)
Machine Language: d0 = Rename(d1, d2)
Modula-2: Rename(oldName, newName: STRPTR): BOOLEAN
Arguments: oldName = current name of file/directory (can include
drive/directory path)
newName = new name for file (can include drive/directory path)
-------------------------
ReplyMsg
Description: replies to a message
Offset: -$017A (-378)
Syntax: ReplyMsg(message)
C: void ReplyMsg(struct MsgPort *)
Machine Language: ReplyMsg(a1)
Modula-2: ReplyMsg(message: ADDRESS)
Arguments: message = message to reply to
Result: none
-------------------------
ReportMouse
Description: tells intuition whether or not to report the mouse
movements as-
sociated with a window
Offset: -$00EA (-234)
Syntax: ReportMouse(window, flag)
C: void ReportMouse(struct Window *, long)
Machine Language: ReportMouse(a0, d0)
Modula-2: ReportMouse(window: WindowPtr; flag: BOOLEAN)
Arguments: window = window to be affected
flag = TRUE to activate mouse movement reports; FALSE to stop
mouse movement reports
Result: none
-------------------------
Request
Description: activates a requester
Offset: -$00F0 (-240)
Syntax: success = Request(requester, window)
C: long Request(struct Requester, struct Window *)
Machine Language: d0 = Request(a0, a1)
Modula-2: Request(requester: RequesterPtr; window: WindowPtr): BOOLEAN
Arguments: requester = requester to display
window = window in which requester will appear in
-------------------------
RethinkDisplay
Description: performs a complete overhaul on the Intuition display-
screens,
ViewPorts, everything
Offset: -$0186 (-390)
Syntax: RethinkDisplay( )
C: void RethinkDisplay(void)
Machine Language: RethinkDisplay( )
Modula-2: RethinkDisplay( )
Arguments: none
Result: none
-------------------------
ScreenToBack
Description: moves specified screen to back of the display
Offset: -$00F6 (-246)
Syntax: ScreenToBack(screen)
C: void ScreenToBack(struct Screen *)
Machine Language: ScreenToBack(a0)
Modula-2: ScreenToBack(screen: ScreenPtr)
Result: none
-------------------------
ScreenToFront
Description: moves specified screen to front of the display
Offset: -$00FC (-252)
Syntax: ScreenToFront(screen)
C: void ScreenToFront(struct Screen *)
Machine Language: ScreenToFront(a0)
Modula-2: ScreenToFront(screen: ScreenPtr)
Result: none
-------------------------
ScrollLayer
Description: copies data from a SuperBitMap to a layer so as to
reposition the
display over the bitmap
Offset: -$0048 (-72)
Syntax: ScrollLayer(dummy, layer, dx, dy)
C: void ScrollLayer(struct Layer_Info *, struct Layer *, long, long)
Machine Language: ScrollLayer(a0, a1, d0, d1)
Modula-2: ScrollLayer(layer: LayerPtr; dx, dy: LONGINT)
layer = Layer structure
dx = offset by which to move layer horizontally
dy = offset by which to move layer vertically
Result: none
-------------------------
ScrollRaster
Description: scrolls the contents of a rectangular area of a RastPort
Offset: -$018C (-396)
Syntax: ScrollRaster(rastPort, dx, dy, x1, y1, x2, y2)
C: void ScrollRaster(struct RastPort *, long, long, long, long,
long,
long)
Machine Language: ScrollRaster(a0, d0, d1, d2, d3, d4, d5)
Modula-2: ScrollRaster(rastPort: RastPortPtr; dx, dy: INTEGER; x1, y1, x2,
y2: INTEGER)
dx = offset by which to scroll the rectangle
dy = offset by which to scroll the rectangle
x1 = horizontal position of the left edge of the rectangle
y1 = vertical position of the top edge of the rectangle
x2 = horizontal position of the right edge of the rectangle
y2 = vertical position of the bottom edge of the rectangle
Result: none
-------------------------
ScrollVPort
Description: scrolls the contents of a rectangular area of a ViewPort by
reinter-
preting the RasInfo information in a ViewPort
Offset: -$024C (-588)
Syntax: ScrollVPort(viewPort)
C: void ScrollVPort(struct ViewPort *)
Machine Language: ScrollVPort(a0)
Modula-2: ScrollVPort(viewPort: ViewPortPtr)
Arguments: viewPort = ViewPort structure to update
Result: none
-------------------------
Seek
Description: moves the file pointer to a specified position in a file
Offset: -$0042 (-66)
Syntax: oldPosition = Seek(file, position, mode)
C: long Seek(BPTR, long, long)
Machine Language: d0 = Seek(d1, d2, d3)
Modula-2: Seek(file: FileHandle; position: LONGINT; mode: LONGINT):
LONGINT
position = offset by which to move file pointer
mode = flag specifying how to interpret position offset-
OFFSET_BEGINNING (-1), OFFSET_CURRENT (0), or
OFFSET_END (1)
Result: oldPosition = old file position; -1 if unsuccessful
-------------------------
SendIO
Description: sends an IO request
Offset: -$01CE (-462)
Modula-2 Module: IO
Syntax: SendIO(ioRequest)
C: void SendIO(struct IORequest *)
Machine Language: SendIO(a1)
Modula-2: SendIO(ioRequest: ADDRESS)
Arguments: IORequest = an initialized IORequest structure
Result: none
-------------------------
SetAfPt (macro)
Description: sets area fill pattern
Syntax: SetAfPt(rastPort, pattern, size)
C: void SetAfPt(struct RastPort *, char *, long)
Modula-2: SetAfPat(rastPort: RastPortPtr; pattern: ADDRESS; size:
CARDINAL)
pattern = pointer to the first word in an area-fill pattern
size = size of area pattern (size to the power of two equals the
number of words in pattern)
Result: none
-------------------------
SetAPen
Description: sets the primary pen color
Offset: -0156 (-342)
Syntax: SetAPen(rastPort, pen)
C: void SetAPen(struct RastPort *, long)
Machine Language: SetAPen(a1, d0)
Modula-2: SetAPen(rastPort: RastPortPtr; pen: CARDINAL)
pen = pen number (0-255)
Result: none
-------------------------
SetBPen
Description: sets the secondary pen color
Offset: -015C (-348)
Modula-2 Module: Drawing
Syntax: SetBPen(rastPort, pen)
C: void SetBPen(struct RastPort *, long)
Machine Language: SetBPen(al, d0)
Modula-2: SetBPen(rastPort: RastPortPtr; pen: CARDINAL)
Result: none
-------------------------
SetCollision
Description: sets a collision vector to point to a user-written routine
Offset: -0090 (-144)
Syntax: SetCollision(number, routine, gelsInfo)
C: void SetCollision(long, _fgptr, struct GelsInfo *)
Machine Language: SetCollision(d0, a0, a1)
Modula-2: SetCollision(number: LONGCARD; routine: PROC; gelsInfo:
GelsInfoPtr)
Arguments: number = collision vector number
routine = pointer to user's collision routine
gelsInfo = GelsInfo structure
Result: none
-------------------------
SetComment
Description: adds a comment to a file
Offset: -00B4 (-180)
Syntax: success = SetComment(name, comment)
C: long SetComment(char *, char *)
Machine Language: d0 = SetComment(d1, d2)
Modula-2: SetComment(name, comment: STRPTR): BOOLEAN
Arguments: name = filename of file to comment
comment = comment to add to file
-------------------------
SetCurrentBinding
Description: sets static board configuration area
Offset: -$0084 (-132)
Syntax: SetCurrentBinding(currentBinding, size)
C: void SetCurrentBinding(long, long)
Machine Language: SetCurrentBinding(a0, d0)
Arguments: currentBinding = CurrentBinding structure
size = size of user's BindDriver structure
Result: none
-------------------------
SetDMRequest
Description: attaches a DMRequester (a requester activated when the
mouse's
menu button is double clicked) to a window
Offset: -0102 (-258)
Syntax: success = SetDMRequest(window, dmRequester)
C: long SetDMRequest(struct Window *, struct Requester *)
Machine Language: d0 = SetDMRequest(a0, a1)
Modula-2: SetDMRequest(window: WindowPtr; dmRequester: RequesterPtr)
Arguments: window = window to which the requester will be added
dmRequester = requester to attach
(nothing re-
turned by Modula-2)
-------------------------
SetDrMd
Description: sets a drawing mode for drawing routines
Offset: -0162 (-354)
Syntax: SetDrMd(rastPort, mode)
C: void SetDrMd(struct RastPort *, long)
Machine Language: SetDrMd(a1, d0)
Modula-2: SetDrMd(rastPort: RastPortPtr; mode: DrawingModeSet)
mode = drawing mode JAM1, JAM2, COMPLEMENT,
INVERSVID)
Result: none
-------------------------
SetDrPt (macro)
Description: sets a pattern to use for line drawing
Syntax: SetDrPt(rastPort, pattern)
C: void SetDrPt(struct RastPort *, long)
Modula-2: SetDrPt(rastPort: RastPortPtr; pattern: BITSET)
pattern = 16-bit drawing pattern
Result: none
-------------------------
SetExcept
Description: defines which signals cause an exception
Offset: -0138 (-312)
Syntax: oldSignals = SetExcept(newSignals, signalMask)
C: long SetExcept(long, long)
Machine Language: d0 = SetExcept(d0, d1)
Modula-2: SetExcept(newSignals, signalMask: SignalSet): SignalSet
Arguments: newSignals = new values for signals specified in signalMask
signalMask = set of signals to be affected
Result: oldSignals = prior exception signals
-------------------------
SetFont
Description: sets the font to be used for drawing text in a rastport
Offset: -0042 (-66)
Syntax: SetFont(rastPort, font)
C: void SetFont(struct RastPort *, struct TextFont *)
Machine Language: SetFont(a1/ a0)
Modula-2: SetFont(rastPort: RastPortPtr; font: TextFontPtr)
font = font descriptor obtained from OpenFont( ) function
Result: none
-------------------------
SetFunction
Description: changes a function vector in a library
Offset: -01A4 (-420)
Syntax: oldFunc = SetFunction(library, offset, newFunc)
C: _fptr SetFunction(struct Library *, long,_fptr)
Machine Language: d0 = SetFunction(a1, a0, d0)
Modula-2: SetFunction(library: LibraryPtr; offset: INTEGER; newFunc:
PROC): PROC
Arguments: library = library to change
offset = offset of function vector to change
newFunc = address of new function
Result: oldFunc = address of old function
-------------------------
SetIntVector
Description: changes a system interrupt vector
Offset: -00A2 (-162)
Syntax: oldInt = SetIntVector(intNum, newInt)
C: struct Interrupt *SetIntVector(long, struct Interrupt *)
Machine Language: d0 = SetIntVector(d0, a1)
Modula-2: SetIntVector(intNum: CARDINAL; newInt: InterruptPtr):
InterruptPtr
Arguments: intNum = Portia interrupt bit number (0-14)
newInt = initialized Interrupt structure
Result: oldInt = old Interrupt structure
-------------------------
SetMenuStrip
Description: attaches a menu strip to a window
Offset: -0108 (-264)
Syntax: SetMenuStrip(window, menu)
C: void SetMenuStrip(struct Window *, struct Menu *)
Machine Language: SetMenuStrip(a0, a1)
Modula-2: SetMenuStrip(window: WindowPtr; menu: MenuPtr)
Arguments: window = window to receive menu strip
menu = first menu in menu strip
Result: none
-------------------------
SetOPen (macro)
Description: sets the color of the pen used for outlining figures and
tums on
outlining
Syntax: SetOPen(rastPort, pen)
C: void SetOPen(struct RastPort *, long)
Modula-2: SetOPen(rastPort: RastPortPtr; pen: CARDINAL)
Result: none
-------------------------
SetPointer
Description: sets the shape of a window's sprite mouse pointer
Offset: -010E (-270)
Syntax: SetPointer(window, pointer, height, width, xOffset,
yOffset)
C: void SetPointer(struct Window *, short *, long, long, long, long)
Machine Language: SetPointer(a0, a1, d0, d1, d2, d3)
Modula-2: SetPointer(window: WindowPtr; pointer: ADDRESS; height,
width: CARDINAL; xOffset, y: INTEGER)
Arguments: window = window to receive new pointer
pointer = sprite data defining new shape
height = height of sprite in lines
width = width of sprite in pixels (less than or equal to 16)
xOffset = horizontal offset of pointer hot spot
yOffset = vertical offset of pointer hot spot
Result: none
-------------------------
SetPrefs
Description: changes Preferences' current settings
Offset: -$0144 (-324)
Syntax: prefBuffer = SetPrefs(prefBuffer, size, inform)
C: struct Preferences *SetPrefs(struct Preferences *, long, long)
Machine Language: d0 = SetPrefs(a0, d0, d1)
Modula-2: SetPrefs(prefBuffer: ADDRESS; size: INTEGER; inform:
BOOLEAN)
Arguments: prefBuffer = buffer which contains your desired Preferences
settings
inform = TRUE if you want to send a NEWPREFS message to all
interested windows
Result: prefBuffer = pointer to your prefBuffer
-------------------------
SetProtection
Description: sets a file or directories protection bits
Offset: -00BA (-186)
Syntax: success = SetProtection(name, mask)
C: long SetProtection(char *, long)
Machine Language: d0 = SetProtection(d1, d2)
Modula-2: SetProtection(name: STRPTR; mask: ProtectionSet): BOOLEAN
Arguments: name = file or directory name
mask = protection bits to set
-------------------------
SetRast
Description: sets the entire rastport to a specified color
Offset: -00EA (-234)
Syntax: SetRast(rastPort, pen)
C: void SetRast(struct RastPort *, long)
Machine Language: SetRast(a1, d0)
Modula-2: SetRast(rastPort: RastPortPtr; pen: CARDINAL)
pen = color register used to color the rastport (0-31)
Result: none
-------------------------
SetRGB4
Description: sets the red, green, and blue values for a viewport's color
register
Offset: -0120 (-288)
Syntax: SetRGB4(viewPort, pen, red, green, blue)
C: void SetRGB4(struct ViewPort *, long, long, long, long)
Machine Language: SetRGB4(a0, d0, d1, d2, d3)
Modula-2: SetRGB4(viewPort: ViewPortPtr; pen: INTEGER; red, green, blue:
CARDINAL)
pen = color register to set (0-31)
red = red color level (0-15)
green = green color level (0-15)
blue = blue color level (0-15)
Result: none
-------------------------
SetRGB4CM
Description: sets the red, green, and blue values for a colormap's color
register
Offset: -0276 (-630)
Syntax: SetRGB4CM(colorMap, pen, red, green, blue)
C: void SetRGB4CM(struct ColorMap *, long, long, long, long)
Machine Language: SetRGB4CM(a0, d0, d1, d2, d3)
Modula-2: SetRGB4CM(colorMap: ColorMapPtr; pen: INTEGER; red, green,
blue: CARDINAL)
Arguments: colorMap = ColorMap structure
pen = color register to set (0-31)
red = red color level (0-15)
green = green color level (0-15)
blue = blue color level (0-15)
Result: none
-------------------------
SetSignal
Description: defines the state of a task's signals
Offset: -0132 (-306)
Syntax: oldSignals = SetSignal(newSignals, signalMask)
C: long SetSignal(long, long)
Machine Language: d0 = SetSignal(d0, d1)
Modula-2: SetSignal(newSignals, signalMask: SignalSet): SignalSet
Arguments: newSignals = new values for signals specified in signalMask
signalMask = set of signals to be affected
Result: oldSignals = prior values for signals
-------------------------
SetSoftStyle
Description: sets the style for the current font
Offset: -005A (-90)
Syntax: newStyle = SetSoftStyle(rastPort, style, enable)
C: long SetSoftStyle(struct RastPort *, long, long)
Machine Language: d0 = SetSoftStyle(a1, d0, d1, a6)
Modula-2: SetSoftStyle(rastPort: RastPortPtr; style, enable: FontStyleSet):
FontStyleSet
style = new font style
enable = mask that determines which style bit can be changed;
can be derived from AskSoftStyle( ) function
Result: newStyle = resulting font style
-------------------------
SetSR
Description: gets and/or sets the processor's status register
Offset: -0090 (-144)
Syntax: oldSR = SetSR(newSR, mask)
C: long SetSR(long, long)
Machine Language: d0 = SetSR(d0, d1)
Modula-2: SetSR(newSR: BITSET; mask: BITSET): BITSET
Arguments: newSR = new value for bits specified in mask
mask = bits to be affected
Result: oldSR = prior value of status register
-------------------------
SetTaskPri
Description: gets and sets the priority of a task
Offset: -012C (-300)
Syntax: oldPriority = SetTaskPri(task, newPriority)
C: long SetTaskPri(struct Task *, long)
Machine Language: d0 = SetTaskPri(a1, d0)
Modula-2: SetTaskPri(task: TaskPtr; newPriority: INTEGER): INTEGER
Arguments: task = task to be affected
newPriority = new priority value (0-8)
Result: oldPriority = old task priority (0-8)
-------------------------
SetWindowTitles
Description: sets the titles for both a window and its screen
Offset: -0114 (-276)
Syntax: SetWindowTitles(window, windowTitle, screenTitle)
C: void SetWindowTitles(struct Window *, char *, char *)
Machine Language: SetWindowTitles(a0, a1, a2)
Modula-2: SetWindowTitles(window: WindowPtr; windowTitle, screenTitle:
STRPTR)
Arguments: window = window to be affected
windowTitle = new window title (-1 to keep as-is)
screenTitle = new screen title (-1 to keep as-is)
Result: none
-------------------------
SetWrMsk (macro)
Description: sets the write mask for a rastport (locks and unlocks
bitplanes)
Syntax: SetWrMsk(rastPort, mask)
C: void SetWrMsk(struct RastPort *, long)
Arguments: cList = character list containing substring
index = starting position of substring
length = number of bytes to copy
Result: cList = new character list that contains the substring; -1
if there
is not enough memory
-------------------------
SHIFTITEM (macro)
Description: shifts a menu value to define a new value for the menu item
number
Syntax: newValue = SHIFTITEM(menuValue)
C: long SHIFTITEM(long)
Result: newValue = the menuValue ANDed with $3F and shifted to the
left five times-((menuValue & 0x3F) << 5)
-------------------------
SHIFTMENU (macro)
Description: extracts the menu number from a value (identical to MENUNUM
macro)
Syntax: menuNumber= SHIFTMENU(menuValue)
C: long SHIFTMENU(long)
Result: menuNumber = menu number (0-31); equals NOMENU if no
menu was selected
-------------------------
SHIFTSUB (macro)
Description: shifts a menu value to define a new value for the menu
subitem
number
Syntax: newValue = SHIFTSUB(menuValue)
C: long SHIFTSUB(long)
Result: newValue = the menuValue ANDed with $1F and shifted to the
left 11 times-((menuValue & 0x1F) << 11)
-------------------------
ShowTitle
Description: determines whether the screen title bar will be displayed
in front
of a backdrop window
Offset: -011A (-282)
Syntax: ShowTitle(screen, showIt)
C: void ShowTitle(struct Screen *, long)
Machine Language: ShowTitle(a0, d0)
Modula-2: ShowTitle(screen: ScreenPtr; showIt: BOOLEAN)
Arguments: screen = screen to be affected
showIt = flag that indicates whether or not to display the
screen's
title bar in front of a backdrop window (TRUE means show the
title bar; FALSE means hide it)
Result: none
-------------------------
Signal
Description: signals a task with specified signals
Offset: -0144 (-324)
Syntax: Signal(task, signals)
C: void Signal(struct Task *, long)
Machine Language: Signal(d0, d1)
Modula-2: Signal(task: TaskPtr; signals: SignalSet)
Arguments: task = task to be signaled
signals = signals to send
Result: none
-------------------------
SizeCList
Description: gets the size of a character list in bytes
Offset: -0036 (-54)
Syntax: size = SizeCList(cList)
C: long SizeCList(long)
Machine Language: d0 = SizeCList(a0)
Arguments: cList = character list in question
Result: size = number of bytes in character list
-------------------------
SizeLayer
Description: changes the size of a nonbackdrop layer
Offset: -0042 (-66)
Syntax: SizeLayer(dummy, layer, dx, dy)
C: long SizeLayer(struct Layer_Info *, struct Layer *, long, long)
Machine Language: d0 = SizeLayer(a0, a1, d0, d1)
Modula-2: SizeLayer(layer: LayerPtr; dx, dy: LONGINT): BOOLEAN
layer = a nonbackdrop Layer structure
dx = amount to add to layer's horizontal size (may be negative)
dy = amount to add to layer's vertical size (may be negative)
-------------------------
SizeWindow
Description: resizes a window
Offset: -0120 (-288)
Syntax: SizeWindow(window, dx, dy)
C: void SizeWindow(struct Window *, long, long)
Machine Language: SizeWindow(a0, d0, d1)
Modula-2: SizeWindow(window: WindowPtr; dx, dy: INTEGER)
Arguments: window = window to be resized
dx = amount to add to window's horizontal size (may be
negative)
dy = amount to add to window's vertical size (may be negative)
Result: none
-------------------------
SortGList
Description: sorts the GEL list by vertical position of each element,
prior to
displaying the GELs
Offset: -0096 (-150)
Syntax: SortGList(rastPort)
C: void SortGList(struct RastPort *)
Machine Language: SortGList(a1)
Modula-2: SortGList(rastPort: RastPortPtr)
Arguments: rastPort = RastPort structure containing the GelsInfo
Result: none
-------------------------
SPAbs
Description: obtains the absolute value of a floating-point number
Library: mathffp.library
Offset: -$0036 (-54)
Syntax: fnum1 = SPAbs(fnum2)
C: float SPAbs(float)
Machine Language: d0 = SPAbs(d0)
Arguments: fnum2 = floating-point number
Result: fnum1 = absolute value of fnum2 in floating-point format
-------------------------
SPAcos
Description: obtains the arcosine of a floating-point number
Library: mathtrans.library
Offset: -$0078 (-120)
Syntax: fnum1 = SPAcos(fnum2)
C: float SPAcos(float)
Machine Language: d0 = SPAcos(d0)
Arguments: fnum2 = floating-point number representing the cosine of an
angle
Result: fnum1 = floating-point value of fnum2 angle in radians
-------------------------
SPAdd
Description: adds two floating-point numbers
Offset: -$0042 (-66)
Syntax: fnum1 = SPAdd(fnum2, fnum3)
C: float SPAdd(float, float)
Machine Language: d0 = SPAdd(d1, d0)
fnum3 = floating-point number
Result: fnum1 = fnum2 plus fnum3 in floating-point format
-------------------------
SPAsin
Description: obtains the arcsine of a floating-point number
Offset: -$0072 (-114)
Syntax: fnum1 = SPAsin(fnum2)
C: float SPAsin(float)
Machine Language: d0 = SPAsin(d0)
Arguments: fnum2 = floating-point number representing the sine of an angle
-------------------------
SPAtan
Description: obtains the arctangent of a floating-point number
Offset: -$0030 (-48)
Syntax: fnum1 = SPAtan(fnum2)
C: float SPAtan(float)
Machine Language: d0 = SPAtan(d0)
Arguments: fnum2 = floating-point number representing the tangent of an
angle
-------------------------
SPCmp
Description: compares two floating-point numbers
Offset: -$002A (-42)
Syntax: flag = SPCmp(fnum1, fnum2)
C: long SPCmp(float, float)
Machine Language: d0 = SPCmp(d1, d0)
Result: flag = -1 if fnum1<fnum2; +1 if fnum1>fnum2; 0 if
fnum1 = fnum2
-------------------------
SPCos
Description: obtains the cosine of a floating-point number
Offset: -$002A (-42)
Syntax: fnum1 = SPCos(fnum2)
C: float SPCos(float)
Machine Language: d0 = SPCos(d0)
Arguments: fnum2 = floating-point number representing an angle in radians
Result: fnum1 = floating-point cosine of fnum2
-------------------------
SPCosh
Description: obtains the hyperbolic cosine of a floating-point number
Offset: -$0042 (-66)
Syntax: fnum1 = SPCosh(fnum2)
C: float SPCosh(float)
Machine Language: d0 = SPCosh(d0)
Result: fnum1 = floating-point hyperbolic cosine of fnum2
-------------------------
SPDiv
Description: divides one floating-point number by another
Offset: -$0054 (-84)
Syntax: fnum1 = SPDiv(fnum2, fnum3)
C: float SPDiv(float, float)
Machine Language: d0 = SPDiv(d1, d0)
Arguments: fnum2 = floating-point dividend
fnum3 = floating-point divisor
Result: fnum1 = floating-point format results of fnum2 divided by
fnum3
-------------------------
SPExp
Description: obtains the exponent of a floating-point number
Offset: -$004E (-78)
Syntax: fnum1 = SPExp(fnum2)
C: float SPExp(float)
Machine Language: d0 = SPExp(d0)
Result: fnum1 = floating-point value representing e (approx.
2.71728)
raised to the power of fnum2
-------------------------
SPFieee
Description: converts a single-precision IEEE number to a Motorola fast
float-
ing point number
Offset: -$006C (-108)
Syntax: fnum = SPFieee(ieeenum)
C: float SPFieee(long)
Machine Language: d0 = SPFieee(d0)
Arguments: ieeenum = single-precision floating-point number
Result: fnum = Motorola fast floating point equivalent to fnum
-------------------------
SPFlt
Description: converts an integer to floating-point number
Offset: -$0024 (-36)
Syntax: fnum = SPFlt(inum)
C: float SPFlt(long)
Machine Language: d0 = SPFlt(d0)
Arguments: inum = signed integer to be converted
Result: fnum = floating-point equivalent to inum
-------------------------
SplitCList
Description: splits a character list in two, breaking it at the mark
(obtained via
the MarkList( ) function)
Offset: -008A (-138)
Syntax: tailCList = SplitCList(cList)
C: long SplitCList(long)
Machine Language: d0 = SplitCList(a0)
Arguments: cList = character list to split
Result: tailCList = new character list that contains the tail end
of the
original character list; -1 if there is not enough memory
-------------------------
SPLog
Description: obtains the natural logarithm of a floating-point number
Offset: -$0054 (-84)
Syntax: fnum1 = SPLog(fnum2)
C: float SPLog(float)
Machine Language: d0 = SPLog(d0)
Result: fnum1 = floating-point natural logarithm (base e) of fnum2
-------------------------
SPLog10
Description: obtains the naparian logarithm (base 10) of a floating-
point number
Offset: -$007E (-126)
Syntax: fnum1 = SPLog10(fnum2)
C: float SPLoglO(float)
Machine Language: d0 = SPLog10(d0)
Result: fnum1 = floating-point naparian logarithm (base 10) of
fnum2
-------------------------
SPMul
Description: multiplies one floating-point number by another
Offset: -$004E (-78)
Syntax: fnum1 = SPMul(fnum2, fnum3)
C float SPMul(float, float)
Machine Language: d0 = SPMul(d1, d0)
Result: fnum1 = product of fnum2 and fnum3 in floating-point format
-------------------------
SPNeg
Description: negates the value of a floating-point number
Offset: -$003C (-60)
Syntax: fnum1 = SPNeg(fnum2)
C: float SPNeg(float)
Machine Language: d0 = SPNeg(d0)
Arguments: fnum2 = floating-point number to negate
Result: fnum1 = negative fnum2 in floating-point format
-------------------------
SPPow
Description: obtains the exponentiation of two floating-point numbers
Offset: -$005A (-90)
Syntax: fnum1 = SPPow(fnum2, fnum3)
C: float SPPow(float, float)
Machine Language: d0 = SPPow(d1, d0)
Result: fnum1 = floating-point value of fnum2 raised to the power
of
fnum3
-------------------------
sprintf
Description: outputs a formatted string into a string (Lattice and Manx
users: if
you link with lc.lib or c.lib, this is not the function you're
calling)
Syntax: sprintf(destinationString, formatString, values...)
C: void sprintf(char *, char *, long...)
pea formatString
pea destinationString
jsr _printf
Arguments: destinationString = address of string to receive output

formatString = string containing optional C formatting commands
(%); if you're passing longword values on the stack (as shown
above) be sure to follow the percent symbol with a lowercase L
of formatting commands in formatString argument
Result: none
-------------------------
SPSin
Description: obtains the sine of a floating-point number
Offset: -$0024 (-36)
Syntax: fnum1 = SPSin(fnum2)
C: float SPSin(float, float)
Machine Language: d0 = SPSin(d0)
Result: fnum1 = floating-point sine of fnum2
-------------------------
SPSincos
Description: obtains the sine and cosine of a floating-point number
Offset: -$0036 (-54)
Syntax: fnum1 = SPSincos(fnum2, fnum3)
C: float SPSincos(float, float *)
Machine Language: d0 = SPSincos(d1, d0)
fnum3 = pointer to floating point number to receive the cosine of
fnum2
Result: fnum1 = floating-point sine of fnum2 (cosine is returned in
fnum3)
-------------------------
SPSinh
Description: obtains the hyperbolic sine of a floating-point number
Offset: -$003C (-60)
Syntax: fnum1 = SPSinh(fnum2)
C: float SPSinh(float, float)
Machine Language: d0 = SPSinh(d0)
Result: fnum1 = floating-point hyperbolic sine of fnum2
-------------------------
SPSqrt
Description: obtains the square root of a floating-point number
Offset: -$0060 (-96)
Syntax: fnum1 = SPSqrt(fnum2)
C: float SPSqrt(float)
Machine Language: d0 = SPSqrt(d0)
Result: fnum1 = floating-point square root of fnum2
-------------------------
SPSub
Description: subtracts one floating-point number from another
Offset: -$0048 (-72)
Syntax: fnum1 = SPSub(fnum2, fnum3)
C: float SPSub(float, float)
Machine Language: d0 = SPSub(d1, d0)
Result: fnum1 = fnum2 minus fnum3 in floating-point format
-------------------------
SPTan
Description: obtains the tangent of a floating-point number
Offset: -$0030 (-48)
Syntax: fnum1 = SPTan(fnum2)
C: float SPTan(float, float)
Machine Language: d0 = SPTan(d0)
Result: fnum1 = floating-point tangent of fnum2
-------------------------
SPTanh
Description: obtains the hyperbolic tangent of a floating-point number
Offset: -$0048 (-72)
Syntax: fnum1 = SPTanh(fnum2)
C: float SPTanh(float, float)
Machine Language: d0 = SPTanh(d0)
Result: fnum1 = floating-point hyperbolic tangent of fnum2
-------------------------
SPTieee
Description: converts a Motorola fast floating point number to a single-
precision IEEE number
Offset: -$0066 (-102)
Syntax: ieeenum = SPTieee(fnum)
C: float SPTieee(float)
Machine Language: d0 = SPTieee(d0)
Arguments: fnum = Motorola fast floating point number
Result: ieeenum = single-precision floating-point equivalent to
fnum
-------------------------
SPTst
Description: compares a floating-point number with zero
Offset: -$0030 (-48)
Syntax: flag = SPTst(fnum)
C: long SPTst(float)
Machine Language: d0 = SPTst(d0)
Arguments: fnum = floating-point number
Result: flag = -1 if fnum<0; +1 if fnum>0; 0 if fnum=0
-------------------------
SubCList
Description: copies a substring from a character list
Offset: -0096 (-150)
Syntax: cList = SubCList(cList, index, length)
C: long SubCList(long, long, long)
Machine Language: d0 = SubCList(a0, d0, d1)
Arguments: cList = character list containing substring
index = starting position of substring
length = number of bytes to copy
Result: cList = new character list that contains the substring; -1
if there
is not enough memory
-------------------------
SUBNUM (macro)
Description: extracts the menu subitem number from a value
Syntax: subNumber= SUBNUM(menuValue)
C: long SUBNUM(long)
Modula-2: SUBNUM(menuValue: CARDINAL): CARDINAL
Result: itemNumber = item number (0-31); equals NOSUB if no menu
was selected
-------------------------
SumKickData
Description: computes the checksum for a Kickstart delta list
Offset: -0264 (-612)
Syntax: SumKickData( )
C: void SumKickData(void)
Machine Language: SumKickData( )
Modula-2: SumKickData( )
Arguments: none
Result: none
-------------------------
SumLibrary
Description: verifies a library's checksum; alerts user if checksum is
incorrect
Offset: -01AA (-426)
Syntax: SumLibrary(library)
C: void SumLibrary(struct Library *)
Machine Language: SumLibrary(a1)
Modula-2: SumLibrary(
Library: LibraryPtr)
Arguments: library = library to verify
Result: none
-------------------------
SuperState
Description: engage supervisor mode using user-defined stack
Offset: -$0096 (-150)
Syntax: sysStack = SuperState( )
C: long SuperState(void)
Machine Language: d0 = SuperState( )
Modula-2: SuperState( ): ADDRESS
Arguments: none
Result: sysStack = pointer to system stack; NULL if already in
supervisor
mode
-------------------------
SwapBitsRastPortClipRect
Description: engage supervisor mode using user-defined stack
Offset: -007E (-126)
Syntax: SwapBitsRastPortClipRect(rastPort, clipRect)
C: void SwapBitsRastPortClipRect(struct RastPort *, struct ClipRect
*)
Machine Language: SwapBitsRastPortClipRect(a0, a1)
Modula-2: SwapBitsRastPortClipRect(rastPort: RastPortPtr; clipRect:
ClipRectPtr)
clipRect = ClipRect to swap bits with
Result: none
-------------------------
SyncSBitMap
Description: copies all bits from a layer's ClipRects into the
SuperBitMap
Offset: -01BC (-444)
Syntax: SyncSBitMap(layer)
C: void SyncSBitMap(struct Layer *)
Machine Language: SyncSBitMap(a0)
Modula-2: SyncSBitMap(layer: LayerPtr)
Arguments: layer = a locked layer that contains a SuperBitMap
Result: none
-------------------------
Text
Description: prints text in a RastPort using the current font
Offset: -$003C (-60)
Syntax: Text(rastPort, string, length)
C: void Text(struct RastPort *, char *, long)
Machine Language: Text(a1, a0, d0)
Modula-2: Text(rastPort: RastPortPtr; string: STRPTR; length: CARDINAL)
Arguments: rastPort = RastPort where text is to be output
string = text to print
length = number of characters in string
Result: none
-------------------------
Textlength
Description: finds the length (in bits) that a string of characters
would occupy
if printed to a RastPort using the current text font
Offset: -$0036 (-54)
Syntax: size = TextLength(rastPort, string, length)
C: long TextLength(struct RastPort *, char *, long)
Machine Language: d0 = TextLength(a1, a0, d0)
Modula-2: TextLength(rastPort: RastPortPtr; string: STRPTR; length: CARDI-
NAL): CARDINAL
Arguments: rastPort = RastPort where text would be output
string = text to print
length = number of characters in string
Result: size = number of pixels (horizontally) required to print
the speci-
fied text
-------------------------
ThinLayerInfo
Description: converts a 1.1 LayerInfo structure into a 1.0 LayerInfo
structure,
thus returning the extra memory allocate by FattenLayerInfo (this
is an obsolete function)
Offset: -$00A2 (-162)
Syntax: ThinLayerInfo(layerInfo)
C: void ThinLayerInfo(struct Layer_Info *)
Machine Language: ThinLayerInfo(a0)
Arguments: layerInfo = LayerInfo structure to convert
Result: none
-------------------------
Translate
Description: converts an English string into phonetics
Library: translator.library
Offset: -$001E (-30)
Modula-2 Module: Translator
Syntax: error = Translate(instring, inlen, outbuf, outlen)
C: long Translate(char *, long, char *, long)
Machine Language: d0 = Translate(a1, d0, a1, d1)
Modula-2: Translate(instring: STRPTR; inlen: LONGCARD; outbuf: STRPTR;
outlen: LONGCARD): LONGINT
Arguments: instring = English string to convert
inlen = number of characters in instring
outbuf = buffer to hold phonetic codes
outlen = size of outbuf in bytes
Result: error = 0 if successful; negative number representing
position in
instring where function was forced to stop because the output
buffer overflowed
-------------------------
TypeOfMem
Description: determines the attributes of a given memory address
Offset: -$0216 (-534)
Syntax: attributes = TypeOfMem(address)
C: long TypeOfMem(void *)
Machine Language: d0 = TypeOfMem(a0)
Modula-2: TypeOfMem(address: ADDRESS): MemReqSet
Arguments: address = memory address
Result: attributes = type of memory-MEMF_CHIP, MEMF_FAST,
MEMF_PUBLIC
-------------------------
UnGetCLChar
Description: adds a byte to the beginning of a character list
Offset: -$0048 (-72)
Syntax: error = UnGetCLChar(cList, byte)
C: long UnGetCLChar(long, long)
Machine Language: d0 = UnGetCLChar(a0, d0)
or
StrToCL( )
byte = byte to add to beginning of character list
Result: error = 0 if successful
-------------------------
UnGetCLWord
Description: adds a word to the beginning of a character list
Offset: -$0060 (-96)
Syntax: error = UnGetCLWord(cList, word)
C: long UnGetCLWord(long, long)
Machine Language: d0 = UnGetCLWord(a0, d0)
or
StrToCL( )
word = word to add to beginning of character list
Result: error = 0 if successful; 1 if unsuccessful
-------------------------
UnLoadSeg
Description: removes a segment from memory
Offset: -$009C (-156)
Syntax: UnLoadSeg(segment)
C: void UnLoadSeg(BPTR)
Machine Language: UnLoadSeg(d1)
Modula-2: UnLoadSeg(segment: BPTR): BOOLEAN
Arguments: segment = BCPL pointer to a segment as returned by LoadSeg( )
Result: none
-------------------------
UnLock
Description: unlocks a directory or file
Offset: -$005A (-90)
Syntax: UnLock(lock)
C: void UnLock(BPTR)
Machine Language: UnLock(d1)
Modula-2: UnLock(lock: FileLock)
Arguments: lock = BCPL pointer to a lock
Result: none
-------------------------
UnlockIBase
Description: releases the lock on IntuitionBase so Intuition can change
the
structure as it pleases
Offset: -$01A4 (-420)
Modula-2 Module: IntuitionBase
Syntax: UnLockIBase(lockNumber)
C: void UnLockIBase(long)
Machine Language: UnLockIBase(a0)
Modula-2: UnLockIBase(lockNumber: LONGCARD)
Arguments: lockNumber = Intuition lock value as returned by LockIBase( )
Result: none
-------------------------
UnlockLayer
Description: unlocks a Layer so the graphics routines can use it
Offset: -$0066 (-102)
Syntax: UnLockLayer(layer)
C: void UnLockLayer(struct Layer *)
Machine Language: UnLockLayer(a0)
Modula-2: UnLockLayer(layer: LayerPtr)
Arguments: layer = Layer structure to unlock
Result: none
-------------------------
UnlockLayerInfo
Description: unlocks a Layer_Info structure
Offset: -$008A (-138)
Syntax: UnlockLayerInfo(layerlnfo)
C: void UnlockLayerInfo(struct Layer_Info *)
Machine Language: UnlockLayerInfo(a0, a1)
Modula-2: UnlockLayerInfo(layerlnfo: LayerlnfoPtr)
Arguments: layerlnfo = Layer_Info structure to unlock
Result: none
-------------------------
UnlockLayerRom
Description: unlocks a Layer so the graphics routines can use it (this
function
uses ROM code as opposed to LockLayerRom( )'s RAM-based
code)
Offset: -$01B6 (-438)
Modula-2 Module: RomLayers
Syntax: UnLockLayerRom(layer)
C: void UnLockLayerRom(struct Layer *)
Machine Language: UnLockLayerRom(a5)
Modula-2: UnLockLayerRom(layer: LayerPtr)
Arguments: layer = Layer structure to unlock
Result: none
-------------------------
UnlockLayers
Description: unlocks all layers so the graphics routines can use them
Offset: -$0072 (-114)
Syntax: UnLockLayers(layerInfo)
C: void UnLockLayers(struct Layer_Info *)
Machine Language: UnLockLayers(a0)
Modula-2: UnLockLayers(layerInfo: LayerInfoPtr)
Arguments: layerInfo = Layer_Info structure
Result: none
-------------------------
UnPutCLChar
Description: gets a byte from the end of a character list
Offset: -$0048 (-72)
Syntax: byte= UnPutCLChar(cList)
C: long UnPutCLChar(long)
Machine Language: d0 = UnPutCLChar(a0)
or
StrToCL( )
Result: byte = byte from end of character list; -1 no data
-------------------------
UnPutCLWord
Description: gets a word from the end of a character list
Offset: -$0066 (-102)
Syntax: word = UnPutCLWord(cList)
C: long UnPutCLWord(long)
Machine Language: d0 = UnPutCLWord(a0)
or
StrToCL( )
Result: word = word from end of character list; -1 if no data
-------------------------
UpFrontLayer
Description: moves a layer in front of all other layers
Offset: -$0030 (-48)
Syntax: success = UpFrontLayer(dummy, layer)
C: long UpFrontLayer(struct Layer_Info *, struct Layer *)
Machine Language: d0 = UpFrontLayer(a0, a1)
Modula-2: UpfrontLayer(layer: LayerPtr): BOOLEAN
layer = pointer to Layer to move behind other layers
-------------------------
UserState
Description: return to user state and system stack (do NOT call if
computer is
already in user state)
Offset: -009C (-156)
Syntax: UserState(sysStack)
C: void UserState(char *)
Machine Language: UserState(d0)
Modula-2: UserState(sysStack: ADDRESS)
Arguments: sysStack = system stack pointer as returned by SuperState( )
Result: none
-------------------------
Vacate
Description: releases a semaphore locked by Procure( )
Offset: -$0222 (-546)
Syntax: Vacate(semaphore)
C: void Vacate(struct Semaphore *)
Machine Language: Vacate(a0)
Modula-2: Vacate(semaphore: SemaphorePtr)
Arguments: semaphore = Semaphore structure to release
Result: none
-------------------------
VBeamPos
Description: returns the current position of the vertical video beam
Offset: -$0180 (-384)
Syntax: pos = VBeamPos( )
C: long VBeamPos(void)
Machine Language: d0 = VBeamPos( )
Modula-2: VBeamPos( ): CARDINAL
Arguments: none
Result: pos = current beam position (0-511)
-------------------------
ViewAddress
Description: returns the address of Intuition's View structure
Offset: -$0126 (-294)
Syntax: view = ViewAddress( )
C: struct View *ViewAddress(void)
Machine Language: d0 = ViewAddress( )
Modula-2: ViewAddress( ): ViewPtr
Arguments: none
Result: view = address of the Intuition View structure
-------------------------
ViewPortAddress
Description: returns the address of a window's ViewPort structure
Offset: -$012C (-300)
Syntax: viewPort = ViewPortAddress(window)
C: struct ViewPort *ViewPortAddress(struct Window *)
Machine Language: d0 = ViewPortAddress(a0)
Modula-2: ViewPortAddress(window: WindowPtr): ViewPortPtr
Result: viewPort = address of window's ViewPort structure
-------------------------
Wait
Description: waits for one or more signals
Offset: -$013E (-318)
Syntax: signals = Wait(signalSet)
C: long Wait(long)
Machine Language: d0 = Wait(d0)
Modula-2: Wait(signalSet: SignalSet): SignalSet
Arguments: signalSet = set of signals to wait for
Result: signals = signals that have occurred
-------------------------
WaitBlit
Description: waits for the blitter to finish what it's doing
Offset: -$00E4 (-228)
Syntax: WaitBlit( )
C: void WaitBlit(void)
Machine Language: WaitBlit( )
Modula-2: WaitBlit( )
Arguments: none
Result: none
-------------------------
WaitBOVP
Description: waits for the vertical beam to reach the bottom of a
ViewPort
Offset: -$0192 (-402)
Syntax: WaitBOVP(viewPort)
C: void WaitBOVP(struct ViewPort *)
Machine Language: WaitBOVP(a0)
Modula-2: WaitBOVP(viewPort: ViewPortPtr)
Result: none
-------------------------
WaitForChar
Description: waits a specified amount of time for a character to become
avail-
able from a virtual terminal
Offset: -$00CC (-204)
Syntax: avail = WaitForChar(file, timeout)
C: long WaitForChar(BPTR, long)
Machine Language: d0 = WaitForChar(d1, d2)
Modula-2: WaitForChar(file: FileHandle; timeout: LONGINT): BOOLEAN
timeout = number of microseconds to wait for character
Result: avail = TRUE if a character is available
-------------------------
WaitIO
Description: waits for an I/O request to be executed
Offset: -$01DA (-474)
Modula-2 Module: IO
Syntax: error = WaitIO(ioRequest)
C: long WaitIO(struct IORequest *)
Machine Language: d0 = WaitIO(a1)
Modula-2: WaitIO(ioRequest: ADDRESS): INTEGER
Arguments: ioRequest = IORequest block
-------------------------
WaitPort
Description: waits for a message
Offset: -$0180 (-384)
Syntax: message = WaitPort(port)
C: struct Message *WaitPort(struct MsgPort *)
Machine Language: d0 = WaitPort(a0)
Modula-2: WaitPort(port: MsgPortPtr): ADDRESS
Arguments: port = message port to receive message
Result: message = pointer to first available message
-------------------------
WaitTOF
Description: waits for the next vertical blank
Offset: -$010E (-270)
Syntax: WaitTOF( )
C: void WaitTOF(void)
Machine Language: WaitTOF( )
Modula-2: WaitTOF( )
Arguments: none
Result: none
-------------------------
WBenchToBack
Description: moves the Workbench screen behind all other screens
Offset: -$0150 (-336)
Syntax: success = WBenchToBack( )
C: long WBenchToBack(void)
Machine Language: d0 = WBenchToBack( )
Modula-2: WBenchToBack( ): BOOLEAN
Arguments: none
Result: success = TRUE if Workbench screen is open
-------------------------
WBenchToFront
Description: moves the Workbench screen in front of all other screens
Offset: -$0156 (-342)
Syntax: success = WBenchToFront( )
C: long WBenchToFront(void)
Machine Language: d0 = WBenchToFront( )
Modula-2: WBenchToFront( ): BOOLEAN
Arguments: none
Result: success = TRUE if Workbench screen is open
-------------------------
WhichLayer
Description: finds the layer which contains the specified point
Offset: -$0084 (-132)
Syntax: layer = WhichLayer(layerlnfo, x, y)
C: struct Layer *WhichLayer(struct Layer_Info *, long, long)
Machine Language: d0 = WhichLayer(a0, d0, d1)
Modula-2: WhichLayer(layerlnfo: LayerlnfoPtr; x, y: LONGCARD): LayerPtr
Arguments: layerlnfo = Layerlnfo structure
Result: layer = pointer to top-most layer containing this point;
NULL if
point is not in a layer
-------------------------
WindowLimits
Description: sets the minimum and maximum size of a window
Offset: -$013E (-318)
Syntax: success = WindowLimits(window, minWidth, minHeight,
maxWidth, minHeight)
C: long WindowLimits(struct Window *, long, long, long, long)
Machine Language: d0 = WindowLimits(a0, d0, d1, d2, d3)
Modula-2: WindowLimits(window: WindowPtr; minWidth, minHeight,
maxWidth, maxHeight: LONGINT): BOOLEAN
Arguments: window = window to set size limits for
minWidth = window's new minimum width
minHeight = window's new minimum height
maxWidth = window's new maximum width
maxHeight = window's new minimum height
Result: success = TRUE if all limits are set; FALSE if any of the
limits are
out of range, in which case only the legal limits are set
-------------------------
WindowToBack
Description: moves a window to the back of all other windows
Offset: -$0132 (-306)
Syntax: WindowToBack(window)
C: void WindowToBack(struct Window *)
Machine Language: WindowToBack(a0)
Modula-2: WindowToBack(window: WindowPtr)
Arguments: window = window to move to back of display
Result: none
-------------------------
WindowToFront
Description: moves a window in front of all other windows
Offset: -$0138 (-312)
Syntax: WindowToFront(window)
C: void WindowToFront(struct Window *)
Machine Language: WindowToFront(a0)
Modula-2: WindowToFront(window: WindowPtr)
Arguments: window = window to move to front of display
Result: none
-------------------------
Write
Description: writes bytes of data to a file
Offset: -$0030 (-48)
Syntax: length = Write(file, buffer, length)
C: long Write(BPTR, char *, long)
Machine Language: d0 = Write(d1, d2, d3)
Modula-2: Write(file: FileHandle; buffer: ADDRESS; length: LONGINT):
LONGINT
buffer = pointer to start of buffer containing data to write
length = number of bytes to write
Result: length = number of bytes successfully written; -1 if error
occurred
-------------------------
WriteExpansionByte
Description: writes a byte to a new-style memory expansion board-nybble
by
nybble
Offset: -$0072 (-114)
Syntax: error = WriteExpansionByte(board, offset, byte)
C: long WriteExpansionByte(long, long, long)
Machine Language: d0 = WriteExpansionByte(a0, d0, d1)
Modula-2: WriteExpansionByte(board: ADDRESS; offset: LONGCARD; byte:
BYTE): BOOLEAN
Arguments: board = base of a new-style expansion board
offset = logical offset from the configdev base
byte = byte to write to board
-------------------------
WritePixel
Description: colors a single pixel with the current foreground drawing
pen
Offset: -$0144 (-324)
Syntax: error = WritePixel(rastPort, x, y)
C: long WritePixel(struct RastPort *, long, long)
Machine Language: d0 = WritePixel(a1, d0, d1 )
Modula-2: WritePixel(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
Arguments: rastPort = RastPort structure containing pixel to color
x = horizontal coordinate of pixel
y = vertical coordinate of pixel
Result: error = 0 if successful; -1 if pixel is outside specified
RastPort
-------------------------
XorRectRegion
Description: performs a 2d XOR operation of a rectangle with a region,
leaving
the results in the region
Offset: -$022E (-558)
Syntax: status = XorRectRegion(region, rectangle)
C: long XorRectRegion(struct Region *, struct Rectangle *)
Machine Language: d0 = XorRectRegion(a0, a1)
Modula-2: XorRectRegion(region: RegionPtr; rectangle: RectanglePtr):
BOOLEAN
Result: status = TRUE if successful; FALSE if out of memory
-------------------------
XorRegionRegion
Description: performs a 2d XOR operation of one region with a second
region,
leaving the results in the second region
Offset: -$026A (-618)
Syntax: status = XorRegionRegion(region1, region2)
C: long XorRegionRegion(struct Region *, struct Region *)
Machine Language: d0 = XorRegionRegion(a0, a1)
Modula-2: XorRegionRegion(region1, region2: RegionPtr): BOOLEAN
Result: status = TRUE if successful; FALSE if out of memory
-------------------------
Amiga Hardware Registers
The Amiga's hardware is accessed via registers- locations within a chip

that control it's operation or return status information about the chip. A
register is accessed by R/W operations just like RAM.
Warning: You should never attempt to read a write-only register. Doing so

will place a random value in that register and possibly cause a lockup. For
the same reason, never use BCLR or BSET on a write-only register as these
two instructions perform a read prior to clearing or setting the specified
bit. Write-only registers will be annotated with a (*W), and read-only
registers with a (*R) in the Status header. A third type of register is a
Strobe register. These are used by the Amiga to signify that an event has
occurred. You should NEVER READ OR WRITE to a strobe register as the
operation may falsely trigger the strobe and confuse the Amiga.
SET/CLR Bit: Some registers contain a bit labeled "SET/CLR". This is a

special bit that allows you to set or clear the register's other bits
without using AND or OR. SET/CLR will always be bit 15. What happens to a
register that contains a SET/CLR bit depends on the way you set this bit.
If it is set to zero, any other bit that is written to with a one will be
cleared. If bit 15 is set to one, any other bit that is written to with a
one will be set to one. All bits written to with a zero remain unaffected.
So, to clear all the bits, use $7FFF. To set all bits, use $FFFF. The
SET/CLR bit is useful ONLY on write-only registers. On read only registers,
this bit always returns a value of zero.
Now that you realize how the bit operations work, here are the custon chip
register addresses and explanations:
----------------------------------------------------------------------------
$DFF000 BLTDDAT Blitter Destination Data (early read dummy address)
Status: DMA Only Agnus
Just before a word of data is moved into RAM by the
blitter, it's stored here. This register cannot be
accessed by the 68K or the copper. It's used
exclusively by the blitter DMA. Writing to it does
nothing. Reading returns a seemingly random number
----------------------------------------------------------------------------
$DFF002 DMACONR DMA Enable Read
Status: *R Agnus/Paula
0 AUD0EN 1 = Audio channel 0 DMA enabled
1 AUD1EN
2 AUD2EN
3 AUD3EN
4 DSKEN 1 = Disk DMA enabled
5 SPREN 1 = Sprite DMA enabled
6 BLTEN 1 = Blitter DMA enabled
7 COPEN 1 = Copper DMA enabled
8 BPLEN 1 = Bit-plane DMA enabled
9 DMAEN 0 = DMA for all channels disabled
10 BLTPRI 1 = Blitter has full priority over 68K
0 = Blitter has partial priority
11 UNUSED
12 UNUSED
13 BZERO 1 = If the last blitter operation output
zeroes only. No bits were set in
destination RAM.
14 BBUSY 1 = Blitter is busy ("blitting") See note
15 SETCLR UNUSED
Note: Because of timing problems with 68020/68030 processors, you must wait
a short while before testing BBUSY. A "btst #14,DMACONR" before the test
will provide the appropriate delay. (i.e.: BTST twice)
----------------------------------------------------------------------------
$DFF004 VPOSR Vertical Beam Position Read
Status: *R Agnus
0 V8 The high bit of the vertical beam position
(1 = pos > 255)
1-14 UNUSED
15 LOF Interlace Long Frame Flag (1 = a long frame
is being drawn (even), 0 = a short frame
(odd))
----------------------------------------------------------------------------
$DFF006 VHPOSR Vertical/Horizontal Beam Position Read
Status: *R Agnus
0-7 H1-H8 Video beam's horizontal position in
increments of two lo-res pixels
8-15 V0-V7 Low 8 bits of video beam's horizontal pos
Note: If bit 3 in register BPLCON0 ($DFF100) is set, the Amiga returns the
light pen position and NOT the raster position! Also, the location and size
of the visible screen area changes accordingly with the DIWSTRT and DIWSTOP
(Display Window Start/Stop @ $DFF08E / $DFF090). These registers are
changed by Preferences each time you adjust the display-centering gadget.
Normal Visible Screen area is - horizontal : $40 - $E0
vertical : $2C - $F4
----------------------------------------------------------------------------
$DFF008 DSKDATR Disk Data Read (early read dummy address -Disk DMA)
SEE $DFF000 (BLTDDAT) for explanation.
----------------------------------------------------------------------------
$DFF00A JOY0DAT Joystick/Mouse Port 0 Data
$DFF00C JOY1DAT Port 1 Data
Status: *R Denise
For Mouse Use:
0-7 Horizontal Position Counter
8-15 Vertical Position Counter
For Joystick Use:
0 EOR BIT 1 Down (1 = stick down)
1 Right(1 = stick right)
8 EOR BIT 9 Up (1 = stick up)
9 Left (1 = stick left)
For Paddle Use:
1 Right paddle fire button (1 = fire)
9 Left paddle fire button (1 = fire)
----------------------------------------------------------------------------
$DFF00E CLXDAT Collision Data
Status: *R Denise
if set to one... 0 Even bit plane collided with odd bit plane
1 Odd plane collided with sprite 0 or 1
2 with sprite 2 or 3
3 4 or 5
4 6 or 7
5 Even plane collide with sprite 0 or 1
6 2 or 3
7 4 or 5
8 6 or 7
9 Sprite 0 or 1 collide with 2 or 3
10 0 or 1 4 or 5
11 0 or 1 6 or 7
12 2 or 3 4 or 5
13 2 or 3 6 or 7
14 4 or 5 6 or 7
15 UNUSED
Note: When you read this register, all bits are cleared, so be sure to save
it if you need it's contents if you want to check for more than one type of
collision. Bitplane collisions are extremely flexible. See CLXCON
($DFF098) for more info.D
----------------------------------------------------------------------------
$DFF010 ADKCONR Audio/Disk Control Read
Status: *R Paula
0 ATVOL0 1 = Audio channel 0 modulates channel 1 volume
1 ATVOL1 1 = 1 2
2 ATVOL2 1 = 2 3
3 ATVOL3 1 = Output of audio channel 3 disabled
4 ATPER0 1 = Audio channel 0 modulates channel 1 period
5 ATPER1 1 = 1 2
6 ATPER2 1 = 2 3
7 ATPER3 1 = Output of audio channel 3 disabled
8 FAST 1 = MFM:2 us per bit disk operation (normDOS)
0 = GCR:4 us per bit disk op (double density)
9 MSBSYNC 1 = GCR-format synchronization for disk
operations enabled (not used by DOS)
10 WORDSYNC 1 = Disk Controller is synchronizing on
the data word found in the DSKSYNC
register ($DFF07E) typically set to
$4489 for MFM.
11 UARTBRK 1 = RS232 break-signal is occuring on the
serial TxD line.
12 MFMPREC 1 = MFM selected
0 = GCR selected
13-14 PRECOMP Disk precompensation time (00=none,
01=140 nsec, 10=280 nsec, 11=560 nsec)
15 SETCLR UNUSED
Note: ADKCONR is a read version of ADKCON ($DFF09E). See that register for
a complete explanation of each bit.
----------------------------------------------------------------------------
$DFF012 POT0DAT Pot (Paddle/Proportional Joystick) Port 0/1 Data Read
$DFF014 POT1DAT
Status: *R Paula
For Paddle Use:
0-7 Left Paddle Counter (0 = completely CCW)
8-15 Right Paddle Counter(0 = completely CCW)
For Proportional Joystick Use:
0-7 Horizontal Counter (0 = stick pushed left)
8-15 Vertical Counter (0 = stick pushed down)
----------------------------------------------------------------------------
$DFF016 POTGOR Pot Port Data Read
Status: *R Paula
0 START Trigger bit for starting pot counters
(always reads zero)
1-7 UNUSED Reserved for Chip ID
8 DATLX Current state of pin 9 on game port 1 (0/1)
9 OUTLX Output enable for pin 9 on game port 1 (zero)
10 DATLY Current state of pin 5 on game port 1 (0/1)
11 OUTLY Output enable for pin 5 on game port 1 (zero)
12 DTARX Current state of pin 9 on game port 0 (0/1)
13 OUTRX Output enable for pin 9 on game port 0 (zero)
14 DATRY Current state of pin 5 on game port 0 (0/1)
15 OUTRY Output enable for pin 5 on game port 0 (zero)
Notes: This is the read address for the POTGO register ($DFF034). Most of
the bits in this register are write-only and always return a zero when read.
Only bits 8, 10, 12, and 14 return valid data. The remaining bits are
controlled via the POTGO register. (See for more info on these bits)
The Amiga's game ports are quite versatile. Pins 5 and 9 of either port
can be programmed to receive and send digital data. This register allows
you to read the current high-low state of these pins.
Simply read the desired pin's DATxx bit to determine its status. (0 =
0v, 1 = +5v) The positive voltage sent to these pins should never exceed 5
volts or 400 mA. ONLY THE VOLTAGE FROM PIN 7 SHOULD BE CONNECTED TO PIN 5
OR 9. PIN 7 CARRIES +5 VOLTS FROM THE AMIGA'S OWN POWER SUPPLY.
The right mouse button is wired to game port pins 8 and 9. When the
button is pressed, these two pins connect. Pin 8 is grounded, so any
voltage that 9 carries gets shorted to ground.
To sense whether the right mouse button is being pressed on a mouse
plugged into game port 0, you must first set pin 9 to output. (i.e.:
OUTLY = 1 or write $0C00 to POTGO. For a mouse plugged into port 1, use
OUTRY and DATRY instead.) Finally, wait about 300 msec for the voltage to
reach the game port - and then read the status of pin 9 via the DATLY bit in
POTGOR. If this bit equals one, the pin is not grounded, thus the button is
not pressed. If it equals zero, the pin is grounded, and the button has
been pressed.
Because Intuition automatically handles game port 0 mouse events, you'll
have to turn off multitasking if you wish to control this port directly via
the hardware. Even accessing port 1 may cause problems since any
manipulation of POTGO affects all of the bits. Such confusion usually
results in the Amiga thinking that the right mouse button is being clicked
when it really isn't.
Rather than calculate a 300 msec delay, you may write a #$C000 to POTGO
and wait for one vertical blanking period with the following:
WaitVertB:
move.l VPOSR,d0
and.l #$0001FF00,d0
bne WaitVertB
rts
----------------------------------------------------------------------------
$DFF018 SERDATR Serial Data Input and Status Read
Status: *R Paula
0-7 DB0-DB7 Byte of data read from serial port
8 DB8/STP Ninth data bit or stop bit
9 STP Stop bit if set up for 9 data bits
10 UNUSED
11 RxD Current status of serial port's RxD line
12 TSRE Transmit shift register empty (if 1)
13 TBE Transmit buffer empty (if 1)
14 RBF Receive buffer is full(if 1)
15 OVRUN Receive buffer overrun (if 1)
----------------------------------------------------------------------------
$DFF01A DSKBYTR Disk Data Byte and Disk Status Read
Status: *R Paula
0-7 DATA Byte of data read from disk
8-11 UNUSED
12 WORDEQUAL Disk Sync pattern found (if 1)
13 DISKWRITE Disk controller writing (if 1)
Disk controller reading (if 0)
14 DMAOEN Disk DMA is active (if 1)
15 BYTEREADY Bits 0-7 of this register will hold new
data if bit 15 is set.
Notes: Considering the fact that disk data can be transferred to and from
memory automatically through DMA, it is neither necessary nor recommended
that you read data one byte at a time via 0-7, and 15.
Bit 12: WORDEQUAL holds a one for only 2 usec! (The time for one MFM bit
to pass under the head.) AmigaDos uses $4489 for the sync.
----------------------------------------------------------------------------
$DFF01C INTENAR Interrupt Enable Read
Status: *R Paula
0 TBE 1 = Serial transmit buffer empty interrupt
enabled (level 1)
1 DSKBLK 1 = Disk block done int enabled (level 1)
2 SOFT 1 = Software interrupts enabled (level 1)
3 PORTS 1 = CIA-A and expansion port interrupts
enabled (level 2)
4 COPER 1 = Copper interrupt enabled (level 3)
5 VERTB 1 = Vertical Blank Int enabled (level 3)
6 BLIT 1 = Blitter ready int enabled (level 4)
7 AUD0 1 = Audio channel 1 int enabled (level 4)
8 AUD1 2
9 AUD2 3
10 AUD3 4
11 DBF 1 = Serial receive buffer full interrupt
enabled (level 5)
12 DSKSYN 1 = Disk sync pattern found int enab (lev 5)
13 EXTER 1 = CIA-B and expansion port int enab(lev 6)
14 INTEN Master interrupt off switch (0 = All
ints listed above disabled)
15 SETCLR UNUSED by INTENAR
Notes: The Amiga's hardware is capable of generating 14 interrupts on seven

levels. Level 1-6 are maskable, and level 7 is an NMI. This register tells
you which ints are enabled or disabled. To enable or disable an interrupt,
use this register's write address, INTENA ($DFF09A). To force an interrupt
to take place, use register INTREQ ($DFF09C). To actually find out what
type of interrupt is taking place, read INTREQR at $DFF01E.
When the uP receives an interrupt signal, it takes the level number,
multiplies it by two, and adds $FFFFF1 to the result. This calculation
produces the address of a byte long memory offset contained in ROM. The
memory offset is then multiplied by four to obtain the address of the
interrupt's auto vector - a location that contains the pointer to the
corresponding interrupt processing routine. Under the current version of
ROM, these four byte pointers are stored in locations $64, $68, $6C, $70,
$74, $78, and $7C, for the level 1-7 interrupts respectively.
To prioritize interrupts that share the same level number, Exec has
assigned each interrupt a pseudo priority number. Again, the higher this
number, the higher the priority:
Interrupt 680x0 Level Pseudo-Priority
--------- ----- -----
Software 1 1
Disk Block Done 1 2
Transmit Buffer Empty 1 3
CIA-A (exp bus pin 19) 2 1
Copper 3 1
Vertical Blank 3 2
Blitter Done 3 3
Audio Channel 2 4 1
Audio Channel 0 4 2
Audio Channel 3 4 3
Audio Channel 1 4 4
Read Buffer Full 5 1
Disk Sync Pattern Found 5 2
CIA-B (exp bus pin 22) 6 1
If you plan on handling interrupts completely on your own, note that

interrupt processing routines are always executed in SUPERVISOR mode. As a
minimum, your routine should clear the corresponding bit in the INTREQ
register to clear that interrupt. Use the 680x0 instruction RTE to return
from an interrupt.
To cause a raster interrupt to occur, simply make the copper wait for the
desired line, then store #$8010 in INTREQ:
wait 0,100 ; wait for line 100
move #$8010,INTREQ ; trigger interrupt
----------------------------------------------------------------------------
$DFF01E INTREQR Interrupt Request
Status: *R Paula
The bit by bit explanations are exactly the same
except that "enabled" is replaced with "requested".
See INTENAR ($DFF01C) for details.
----------------------------------------------------------------------------
$DFF020 DSKPTH Disk Pointer
$DFF022 DSKPTL
Status: *W Agnus
This is where you store the starting address of your
disk data prior to activating disk DMA. DSKPT is
broken into a High and Low portion. Note that if your
Amiga does not have a 1MB Agnus, you cannot specify
an address above $7FFFF. Otherwise, it is $FFFFF.
The low bit is always interpreted as zero, so the
data must begin at an even location.
----------------------------------------------------------------------------
$DFF024 DSKLEN Disk Data Length
Status: *W Paula
0-13 LENGTH Number of words to read or write
14 WRITE 1 = Activate write mode 0 = read mode
15 DMAENA 1 = Enable Disk DMA 0 = Disable Disk DMA
Notes: You must write the same value TWICE in a row in order for the value
to take effect. This double write rule was incorporated to safeguard
against accidental disk activity - programs that lose control and start
trashing memory can't just shove a number into this register and initiate
potentially harmful disk activity.
Since the length must be stored in 14 bits, the data cannot be longer
than 32766 bytes. The DMA hardware uses this length value as a counter.
Every time a word of data is transferred to or from disk, this counter is
decremented, and the address in the DSKPT register incremented. Transfer
stops when this value reaches zero.
Because of a bug in the Amiga Hardware, the last three bits of data are
missing. To remedy this, save one more word than necessary.
Before and after doing any disk operations, set this register to #$0000
to enable read mode and disable disk DMA.
Bit 15: Setting this bit initiates disk DMA. It will not start, however,
until the DMAENA bit in the ADKCON register ($DFF09E) is also set. You'll
have to set both of these bits in order to perform any DMA-controlled disk
operations. NEVER start disk DMA unless a previous operation is complete or
you may wind up trashing the data on the disk! To find out when a read or
write operation is complete, use the disk block done interrupt, which can be
detected through the use of the DSKBLK bit (1) in the INTEQR register at
$DFF01E.
----------------------------------------------------------------------------
$DFF026 DSKDAT Disk DMA Write
Status: *W Paula
This is the data buffer used by the disk DMA when
transferring data. It is the write address of the
DSKDATR register ($DFF008).
----------------------------------------------------------------------------
$DFF028 REFPTR Refresh Pointer
Status: *W Agnus
The Amiga uses this register as a RAM refresh address
register. Do not modify the value there or you may
corrupt the contents of RAM! It is for diagnostic
purposes only.
----------------------------------------------------------------------------
$DFF02A VPOSW Vertical Beam Position Write
Status: *W Agnus
This is the write address of the VPOSR register
located at $DFF004. Note the warnings that apply for
the refresh pointer as they also apply.
----------------------------------------------------------------------------
$DFF02C VHPOSW Vertical/Horizontal Beam Position Write
Status: *W Agnus
This is the write address of the VHPOSR register
located at $DFF006. Note the warnings that apply for
the refresh pointer as they also apply.
----------------------------------------------------------------------------
$DFF02E COPCON Coprocessor Control
Status: *W Agnus
0 UNUSED
1 CDANG Copper Danger Bit (1 = Copper can access
blitter registers 0 = Copper cannot.)
2-15 UNUSED
Notes: A one value allows access to $DFF040+, and a zero value $DFF080+.
For instructions on the copper and its instruction set, see locations
$DFF080-$DFF08C.
----------------------------------------------------------------------------
$DFF030 SERDAT Serial Data Output
Status: *W Paula
0-7 DB0-DB7 Byte of data to be output
8 DB8/STP Ninth data bit or stop bit
9 STP Stop Bit if sending nine data bits
10-15 UNUSED (See below)
Notes: To send data out the serial port, simply store it here. Upon
receiving a nonzero value, the contents of the register are shifted out the
serial port - low bit first, high bit last until its contents are empty
(equal zero). Since the start bit is sent automatically, DO NOT include it
as part of your data. Because you must send at least one stop bit, SERDAT
should never equal zero.
By convention, only 8 or 9 data bits should be stored in this register at
any on time. However, because this is a true 16 bit register, up to 15 data
bits and one stop bit can be output in just one shot - an interesting, if
questionably useful feature.
----------------------------------------------------------------------------
$DFF032 SERPER Serial Period (Transfer Rate) and Data Bit Control
Status: *W Paula
0-14 RATE Bit transfer rate specified in increments of
279.4 nsec.
15 LONG Number of data bits to expect when receiving
data (1 = nine 0 = eight data bits)
Notes: The value stored in bits 0-14 determine how many bus cycles occur
between each bit sent or received through the serial port. So, if one bit
is to be sent every X bus cycles, use X-1. Serial transfer rates are
usually specified in baud rates, not bus cycles. Use this formula to
translate the baud rate into the period value this regiester expects:
Period = (3579546 / Baudrate) - 1
The period value for the six most common baud rates are:
Baud Rate Period
--------- ------
300 11931
600 5965
1200 2982
2400 1490
4800 745
9600 372
Bit 15: Affects incoming, not outgoing data length.
----------------------------------------------------------------------------
$DFF034 POTGO Pot Port Data
Status: *W Paula
See POTGOR at $DFF016 for an explanation on how this
write register works.
----------------------------------------------------------------------------
$DFF036 JOYTEST JOY0DAT and JOY1DAT Write
Status: *W Denise
This register allows you to set the contents of the
JOY0DAT and JOY1DAT registers at $DFF00A / $DFF00C.
The value stored here affects both registers,
allowing you to reset the mouse position counters for
both ports with just one instruction.
----------------------------------------------------------------------------
$DFF038 STREQU Short Frame Vertical Blank Strobe
$DFF03A STRVBL Normal Vertical Blank Strobe
$DFF03C STRHOR Horizontal Sync Strobe
$DFF03E STRLONG Long Raster Strobe
Status: Strobe Denise (Denise/Paula on STRHOR)
Do not read to or write from any of these registers.
Doing so would falsely trigger the strobe and confuse
the Amiga.
----------------------------------------------------------------------------
Location Range: $DFF040-$DFF074 The Blitter Registers
The blitter takes care of almost all of the Amiga's bitmapped graphics
manipulation, from drawing lines to moving objects and filling outlined
areas. Intuition, for example, uses the blitter for such things as drawing
gadgets and printing text. And one of the best things about the blitter is
that it executes independently, allowing the Amiga to animate objects while
the uP is hard at work executing program instructions.
Copy Mode: The blitter's main task is to copy data from one area of
memory to another. This operation is specified as a blit. The blitter was
specifically designed to copy bitmap data, however, you can use the blitter
to copy whatever type of data you choose.
Data to be copied may come from up to three different locations in
memory, but you can have only one destination address. The blitter refers
to the source addresses as A, B, and C. The destination area is called D.
When using more than one source address, the blitter must combine the
data from the different sources before it can be written back out. To do
this, it performs any combination of eight different logic operations called
miniterms. Miniterms allow you to combine the bits from A, B, and C in 256
different ways before they reach their destination. This provides the
programmer with great flexibility when copying bitmapped images. Shapes can
be inverted, merged, "cookie cut", and so on. Bits 0-7 in the BLTCON0
register at $DFF040 control the miniterm settings.
The most common use for the blitter is to move rectangular areas of a
bitmapped screen. Because of the way screen bitmaps are laid out, it would
be impractical if all you could do was to copy consecutive bytes in memory.
Instead, you must be able to skip several bytes between each horizontal
screen line. That way, you don't have to copy objects that take up the
entire width of the screen.
The BLTAMOD-BLTDMOD registers ($DFF060-$DFF066) allow you to specify the
difference between the width of the object being copied and the width of the
bitmap. The BLTSIZE register at $DFF058 defines width and height of the
source and destination area. Together these registers allow the blitter to
copy any rectangular area of a bitmap.
The memory addresses of A, B, and C go in registers BLTAPT, BLTBPT, and
BLTCPT ($DFF050, $DFF04C, and $DFF048) respectively, and the D address goes
in register BLTDPT ($DFF054). When specifying A, B, C, or D, you must
provide the blitter with an even, word aligned address.
Because bitmapped objects don't always begin on a word aligned address,
and their width isn't always an even multiple of 16 (16 bits = 1 word), the
blitter can mask out certain bits in the first and last word of each
horizontal line copied from source A. This way, you can copy an area that
starts at any pixel location and is of any pixel width you desire. The
first word mask for source A goes in register BLTAFWM ($DFF044). The last
word mask goes in register BLTALWM ($DFF046). In effect, the first word of
each line is ANDed with BLTAFWM and the last word of each line is ANDed with
BLTALWM before they are written to destination RAM.
To move bitmapped images horizontally with pixel accuracy, it is
necessary to shift the image's data one bit at a time. Using bits 12-15 in
the BLTCON0 and BLTCON1 registers ($DFF040 and $DFF042), you can tell the
blitter to shift source A and/or source B data right 0-15 bits before it's
transferred to it's destination. The shifting takes place within the
blitter so it does not affect the area of memory actually being copied.
Shifting is not restricted by word boundaries; a word's low bit is
shifted into the high bit of the following word. If there is no previous
word of data being copied (i.e. if the current word is the very first word
of data being copied), zeroes are shifted into the word's high bits.
What happens when you need to shift something left, say a pixel? Well,
simply shift it right (16-x) times. The only difference is that your data
is one word further to the right. Optionaly, you could also run the blitter
in descending mode. In this mode, data is shifted left by the value stored
in bits 12-15 of the BLTCON0 and BLTCON1 registers. Here's another reason
for operating the blitter in descending mode:
The blitter is usually called upon to move objects around the screen.
Generally, a programmer will do this by copying an object's data from a
special buffer area in memory to the screen's bitmap. (Since the blitter
can only copy to one destination area at a time, you'll have to do a blitter
operation for each bit plane.) Next, a copy of the screen's background is
copied to the screen to erase the object. Finally, the object is copied to
a different location on the screen, thus making in move.
In the previous example, data was copied from two separate areas of
memory. Sometimes it's desirable to copy to and from areas that overlap.
However, this may cause problems because the blitter may copy a piece of
data into a memory location that hasn't been read yet, thus destroying it.
(i.e. If the destination and source overlap, and the destination is higher
in memory, bye-bye data!)
To avoid the problem of overlapping data, the blitter can be run in two
modes: ascending and descending. When should you use descendong mode?
Well, if the end of the source overlaps the start of the destination, use
descending mode. If the start of the source overlaps the end of the
destination, use ascending mode. If the source and destination don't
overlap, it doesn't matter what you use. The DESC bit (1) in the BLTCON1
register at $DFF042 determines the blitter's current mode.
To initiate a blitter copy operation, you should first select the blitter
copy mode by NOT setting the LINE bit (0) in the BLTCON1 register at
$DFF042. Second, tell the computer the address of your source data using
the BLTAPT, BLTBPT, BLTCPT, and the destination data at BLTDPT. (These
addresses should specify the starting or ending addresses of the data
depending on whether the blitter is running in ascending or descending mode,
respectively.) Third, use BLTCON0 to select the desired miniterms and tell
the computer which sources you're using (A, B, and/or C) and enable the
blitter's D destination channel. (If you don't enable D, data isn't going
anywhere!) Fourth, set up any other options you want such as shifting or
masking of data. Finally, write the width and height of the area to be
copied into the BLTSIZE register at $DFF058. Writing to BLTSIZE
automatically starts the blitter, so it SHOULD BE THE VERY LAST THING YOU
SET! During the blitter operation, the BBUSY bit (14) in the DMACONR
register is set equal to one. When the blitter is finished, this bit is
cleared.
The following happens during a blitter copy operation: Data is copied one
word at a time from the memory address specified by the BLTxPT registers to
the address found in BLTDPT. Every time a word is copied, the BLTxPT
registers are incremented (or decremented if in descending mode). When the
number of words to b copied matches the width in the BLTSIZE register, the
modulation value found in the BLTxMOD registers is added to the BLTxPT
registers and the copying continues on the next line. When the number of
lines copied equals the height in BLTSIZE, the operation is complete and the
blitter stops.
Fill Mode: The blitter offers a crude area-fill option that works in
tandem with the data-copy operation described above. Fill mode is activated
by BLTCON1's IFE (Inclusive Fill Enable) bit or EFE (Exclusive Fill Enable)
bit prior to turning on the blitter. After the blitter reads data from
memory and manipulates it according to the miniterm settings, the specified
fill operation is performed on the data before it is written to destination
memory. Fill operations work IN DESCENDING MODE ONLY! The figure below
illustrates the effect of each type of fill operation has on data:
After:
Before FCI = 0 FCI = 1
00011000 00011000 11111111

00100100 00111100 11100111
01000010 01111110 11000011
Fill 01000010 01111110 11000011
00100100 00111100 11100111
00011000 00011000 11111111
00011000 00001000 11110111

00100100 00011100 11100011
Exclusive 01000010 00111110 11000001
Fill 01000010 00111110 11000001
00100100 00011100 11100011
00011000 00001000 11110111
In all fills, the blitter evaluates data one bit at a time, starting at
the rightmost edge and moving to the left. Before the fill begins, however,
the blitter takes note of the FCI bit (2) of the BLTCON1 register. The
value of this bit becomes the initial fill value of the blitter's fill bit.
For the sake of clarity, let's assume FCI starts at zero.
Here's how inclusive fill works: As the blitter moves left, it changes
all zero bits to zero, because zero is the current value of the fill bit.
When the blitter encounters a 1 bit, it toggles the fill bit, changing it to
a one. Now the blitter changes the following 0 bits to 1, because that is
the current value of the fill bit. Every time the blitter encounters a 1
bit in the data, the fill bit changes value. The figure above illustrates
the difference between fills that start with FCI = 0 or FCI = 1.
Exclusive fills take one extra step when they encounter a 1 bot. In
addition to toggling the fill bit, the blitter replaces that 1 bit with the
new fill-bit value.
Both types of fills expect borders to be defined by a single 1 bit - one
bit to tell the blitter that it's inside an area, and the other to tell it
that it's outside. When the blitter encounters two one bits in a row, it
assumes that there is no space to be filled since there is no zero bit
between pixels. If the blitter encounters three 1 bits in a row, the
blitter assumes that it has gone in, out, then back in to an area to be
filled. (The fill bit has been toggled three times.) This happens when the
blitter runs across an odd number of adjacent bits.
To execute a fill operation, simply set up the blitter registers for a
standard copy operation, set either the IFE or EFE bit, set the FCI bit to
the desired value, set the DESC to put the blitter in descending mode, then
start the blitter by writing the area size to the BLTSIZE register. By
setting the blitter's source address equal to the destination address, you
can fill an area without having to copy data from one separate location to
another.
Line Mode: Besides copying data and filling areas, the blitter has one
more talent: drawing lines. In line mode, almost all of the blitter
registers change their functions.
The blitter draws lines at incredible speeds, much faster than the 68000.
Unfortunately, you can't just give the blitter two points and then tell it
to connect the dots. You need to perform some calculations first.
Let's say that you want to draw a line from point (x1,y1) to (x2,y2).
From these coordinates you need to figure out the horizontal and vertical
distance between the line's two end points. This is easily calculated using
the following two formulae:
dx = abs(x1-x2)
dy = abs(y1-y2)
Now you're ready to give the BLTCON1 register at $DFF042 some information
about the physical orientation of the line.
If (dx >= dy) and (x1 >= x2) set bit 2.
If (dx < dy) and (y1 >= y2) set bit 2.
If (dx >= dy) and (y1 >= y2) set bit 3.
If (dx < dy) and (x1 >= x2) set bit 3.
If (dx >=dy) set bit 4.
Together, these bits define the octant (position relative to the line's
starting position) in which the line will appear. The following shows how
the Amiga divides the screen into octants:
\ | / * = x1,y1
\ 3 | 1 / Note: The numbers shown in this figure
7 \ | / 6 represent the combined value of BLTCON1's
\ | / bits 2-4. If the line appears on the border
-----*----- of two octants, it does not matter which of
/ | \ the two octants you select.
5 / | \ 4
/ 2 | 0 \
/ | \
Next, you need to determine which value is larger: dx or dy. Let dmax
equal the greater value, and dmin the lesser value. Now use these values to
set the following registers:
dmax = max(dx,dy)
dmin = min(dx,dy)
BLTBMOD = 4* dmin
BLTAMOD = 4 * (dmax-dmin)
BLTAPTL = (4 * dmin) - (2 * dmax)
These formulae define the line's slope. If the result of the last
calculation BLTAPTL is negative, you must store a 1 in the SIGN bit (6) of
the BLTCON1 register.
Besides holding the line's octant number and the negative/positive status
of the line's slope, BLTCON1 affects the line's physical appearance. If
you're drawing lines to enclose an area that you plan to fill later using
blitter fill mode, you should set the ONEDOT bit (1) equal to one. This
tells the blitter to draw lines using only one pixel per raster, thus
providing a single pixel border for your object.
To create textured lines, BLTCON1's bits 12-15 work in conjunction with
the BLTBDAT register ($DFF072). The bit pattern found in BLTBDAT defines
the pixel pattern used to draw lines. For normal solid lines, set all of
BLTBDAT's bits to one. (i.e. $FFFF) Other values create dotted or dashed
lines. Bits 12-15 in BLTCON1 allow you to specify which bit in BLTBDAT,
0-15, defines the status of the first pixel in the line. For most practical
purposes, BLTCON1's bits 12-15 should be set equal to the value of x1's
lower 4 bits. (i.e. x1 AND $0F) This informs the blitter to start the line
off with the value found in BLTBDAT's MSB (15). IMPORTANT: ALWAYS SET
BLTCON1 PRIOR TO BLTBDAT!
BLTCON1's bit 5 should always be set to zero, as should bits 7 through
11. To tell the blitter that you want to draw lines instead of copy data,
the LINE bit (0) must be set to 1.
The Amiga needs certain information about the size and location of the
screen's bitmap before it can draw a line. First, store the byte-width
(number of pixels divided by 8) of the bitmap in the BLTCMOD and BLTDMOD
registers ($DFF060 and $DFF066). Next, you must put the address of the word
containing the starting point of the line into the BLTCPT and BLTDPT
registers. ($DFF048 and $DFF054)
Only one bitplane can be written to during a single blitter operation.
So, to draw a line of a particular color on a multiple bitplane screen, it
may be necessary to perform two or more line blits. In these cases, you set
the registers up for the first bitplane as usual, and perform the blit; then
for subsequent bitplanes, you simply reinitialize the registers with the
same values EXCEPT for the registers BLTCPT and BLTDPT, which must contain
the address of the line's starting point within the new bitplane.
As with blitter copy mode, you must set bits 0-7 in the BLTCON0 register
($DFF040) to choose a miniterm. Usually, you should store $CA here, but if
you prefer to XOR your line onto the screen (invert all the pixels found on
the line), store a $4A here.
BLTCON0's bits 8-11 should be set equal to $B. (This activates blitter
source A and C, and destination D.) Store x1's lower four bits (x1 AND $0F)
into BLTCON0's bits 12-15. The blitter uses this value to determine the bit
position of the line's starting point within the bitplane memory location
specified by registers BLTCPT and BLTDPT.
Now, set BLTADAT ($DFF074) equal to $8000. (Set this register only AFTER
you've set BLTCON0) Only two more registers must be set before you can
activate the blitter: BLTAFWM and BLTALWM. ($DFF044 and $DFF046) Store a
$FFFF into both.
Finally, you're ready to start the blitter by writing to the BLTSIZE
register ($DFF058). Use the following formula to determine the value that
you should store into this register:
BLTSIZE = (dmax * 64) + 66
Because writing to BLTSIZE turns on the blitter, this should be the last
register that you set.
General Guidelines: When programming the blitter at the hardware level

with multitasking turned on, you must be sure to grab the blitter for your
own exclusive use so other programs don't try to use it. Using the library
function call OwnBlitter() you can reserve the blitter for your own
personal use. The function call DisownBlitter() frees the blitter so other
programs can use it.
Before writing to any of the blitter registers, you must be sure the
blitter isn't currently in operation, even after a call to OwnBlitter(). To
ensure the blitter's dormancy, you can use the function call WaitBlit(), or
you can read the status of the BBUSY bit found in the DMACONR register at
$DFF002.
Under normal operation conditions, the Amiga's microprocessor has
priority over the blitter when it comes to accessing chip RAM. Because of
the way memory cycles are allocated, memory conflicts rarely occur between
the blitter and the 68000. However, if time is a critical factor, you can
give the blitter a higher priority than the 68000 by setting the BLTPRI bit
in the DMACON register ($DFF096).
The blitter can perform so many special operations on a word of data that
it's important to know the order in which these operations take place.
Masking via the BLTAFWM and BLTALWM register takes effect first (assuming
the data was obtained from A and is either the first or last word of a
horizontal line.); next the data is shifter, if a shift was specified my the
source's shift bits (ASHx or BSHx); the miniterm operations are performed
next; and finally, the data is filled according to the status of BLTCON1's
EFE, IFE, and FCI bits. Only after all this does the data reach its
destination.
As a general rule, you should always write zeroes to any unused bits in
a blitter register. On future versions of the Amiga blitter, these bits may
be used to perform new functions - functions that could freak your program
if mistakingly activated!
In the following register explanations, a lowercase letter (i.e.: a, b,
c) will be used to specify a normal miniterm descriptor, and a capital
letter it's NOTted equivalent. (i.e. A, B, C = NOT a, NOT b, NOT c) This
is for the miniterm descriptors only!
----------------------------------------------------------------------------
$DFF040 BLTCON0 Blitter Control Register 0
Status: *W Agnus
0 LF0 1 = Selects miniterm ABC
1 LF1 1 = Selects miniterm ABc
2 LF2 1 = Selects miniterm AbC
3 LF3 1 = Selects miniterm Abc
4 LF4 1 = Selects miniterm aBC
5 LF5 1 = Selects miniterm aBc
6 LF6 1 = Selects miniterm abC
7 LF7 1 = Selects miniterm abc
8 USED 1 = Enable DMA for D
9 USEC 1 = Enable DMA for C
10 USEB 1 = Enable DMA for B
11 USEA 1 = Enable DMA for A
12-15 ASH0-3 Preshift value for A
For Line Mode:
0-7 LF0-LF7 Miniterm value, usually $CA
8 USED Set to 1
9 USEC Set to 1
10 USEB Set to 0
11 USEA Set to 1
12-15 START0-3 Set to (x1 and #$0F)
Here's how BLTCON0's bits operate in normal copy mode:

Bits 0-7: Each of these bits controls a particular miniterm - a logical
operation performed on blitter source data before it reaches its
destination. To activate a miniterm, simply set its bit equal to one. You
may select as many or as few as you want.
Using miniterms, you can slice and dice data in a variety of ways.
Suppose you set bit zero equal to one. In this case, the miniterm is ABC.
What that means is that a one bit will be output to D only when:
A=0, B=0, and C=0! Any other combination results in a zero output.
Conversely, miniterm abc will output a one only when A, B, and C are equal
to one.
For more complex results, it's possible to activate more than one
miniterm at once. The resulting miniterms are added together (OR'ed) and
simplified. Thus: aBC + aBc can be simplified to aB. (If the values are
different as in the case of the C's, they cancel out.) You may expand aB in
the same way to aBC + aBc.
To fill an area of memory with zeroes, don't select any miniterms.
Consequently, you can fill memory with #$FF's by selecting all of the
miniterms. The following table contains the miniterm settings avaliable to
graphics.library function calls:
Miniterm Val Miniterm Logic Result of Most Useful Settings
------------ -------------- ------------------------------
#$00 always zero Clear Destination
#$10 aBC
#$20 aBc
#$30 aB Copy inverted source to destination
#$40 abC
#$50 aC Invert Destination
#$60 aBc + abC Merge (cookie cut) source with dest.
#$70 aB + aC
#$80 ABC Write 1s only where source & dest
overlap
#$90 abc + aBC
#$A0 ac
#$B0 ac + aB
#$C0 ab Direct copy of source to destination
#$D0 ab + aC
#$E0 ac + ab Combine (mix) source with destination
#$F0 always one Fill Destination
Note: Even if you try to set the lower four bits of a graphics.library
miniterm, the system will zero them out before actually writing this value
to the register's LFx bits.
If you set the blitter's sources the same way that the
graphics.library does - A points to a mask (usually $FFFF), B points to the
source data, and C points to the Destination data - you can use this table
to determine the miniterm settings for your own blitter routines.
When blitting with only one or two sources active, choose miniterms that
aren't affected by the value of the unused source(s).
Bit 8: This bit determines whether the blitter's destination DMA is

enabled. Seting this bit to one enabled the DMA, and 0 Disables it. If
destination DMA is disabled, nothing can be written during a blit. This
seemingly useless feature turns out to be quite useful feature for detecting
collisions between two images. Simply set up the blitter for sources A and
B to point to the two images, select miniterm logic ab ($C0), activate the
blitter, wait for the blitter to finish, and then check the BZERO bit (13)
of the DMACON register at $DFF002. If BZERO = 0, the images touch. Because
the BZERO bit is valid even if the data isn't written to memory, you don't
need to activate destination D for this type of collision detection to work.
Bits 9-10: These bits determine which of the blitter's sources: A, B,

and/or C are active during a blitter operation. Writing a one to any of
these bits turns on the DMA for the corresponding source. When the blitter
is turned on, data is read from the memory specified by the active source's
BLTxDAT register. For this reason, it is important to PREINITIALIZE the
BLTxDAT register of all unused sources before performing a blit. If you
don't want inactive sources to affect the results of a blit, choose
miniterms that ignore the values of such sources.
Bits 12-15: Prior to applying the value of source A to the selected

miniterm operation, the blitter shifts the value the number of times
specified in these bits. (If the blitter is in ascending mode, the data is
shifted right, otherwise, it is shifted left.) Obviously, shifting does not
occur if all of these bits are set to zero.
Whenever you tell the blitter to shift the data in source A, you must
store a modulo value that's one less than normal in the BLTAMOD and BLTDMOD
registers.
Line Mode - Here's how the register functions in line mode:

Bits 0-7: These bits control the miniterm setting used to combine the
line's bits (obtained from A) with the bits in the destination bitplane
(obtained from source C). Source B is used as a mask for generating
patterned lines. For normal lines, use a miniterm setting of #$CA. To draw
a line of inverted pixels, use miniterm value #$4A.
Bits 8-11: The blitter draws lines using source A as a point generator, B
as the static mask, and C for reading the current status of the destination
bitplane, and D for outputting the pixels. Because we don't want the mask
in source B to change, source B's DMA should be inactive. All of the
blitter's other channels must be active however. As a result, you should
always set these bits equal to #$B when using the blitter to draw lines.
Bits 12-15: These bits must equal the lower four bits of horizontal
coordinate x1. Although these are referred to as the START bits in line
mode, their contents still specify a shift value, as they do in copy mode.
Here's how it works: In line mode, you must initialize source A's data
register (BLTADAT) with a $8000. This puts a 1 bit in the leftmost position
in the word. The value stored in these START bits specifies how far that
data is to be shifted to the right. By shifting that bit right by the value
found in x1's lower 4 bits, you move the bit into the pixel position of the
line's starting point.
Now the cheat: Here's a quick and easy formula for calculating the value
that you must store in BLTCON0 when drawing lines:
3018 + ((x1 and #$0F) * 4096)
This specifies the miniterm value for a normal line and provides the
blitter with the bit position of x1 within the memory location found in
registers BLTCPT and BLTDPT. ($DFF048 and $DFF054) To XOR a line onto the
screen (invert any of the bits located within the line), subtract 128 from
the result of the above calculation.
----------------------------------------------------------------------------
$DFF042 BLTCON1 Blitter Control Register 1
Status: *W Agnus
For Blitter Moves and Fills:
0 LINE 1 = activate line draw mode, 0 = normal copy
1 DESC 1 = descending operation, 1 = ascending op.
2 FCI Starting bit for fill mode
3 IFE Enables inclusive fill mode
4 EFE Enables exclusive fill mode
5-11 UNUSED Always set to zero.
12-15 BSH0-3 Preshift value for source B
For Line Mode:

0 LINE Set to one
1 ONEDOT 1 = Draw lines with only a single pixel per
raster
2 AUL Set if ((dx>=dy)and(x1>=x2) or
((dx<dy) and(y1>=y2))
3 SUD Set if ((dx>=dy)and(y1>=y2) or
((dx<dy) and(x1>=x2))
4 SUL Set if dx>=dy
5 UNUSED Always set to zero
6 SIGN Set if (4*dmin)<(2*dmax)
7-11 UNUSED Always set to zero
12-15 TEXTURE0-3 Set to (x1 and #$0F)
Here's how BLTCON1's bits operate in normal copy mode:

Bit 0: This bit activates line mode. It must be set to zero for copy
operations.
Bit 1: Storing a one here puts the blitter in descending mode. Do that
whenever your source and destination overlap and the destination data has a
higher address than the source. You should also use descending mode if you
plan on shifting data left. You MUST use descending mode for a blitter fill
operation. When descending mode is active, the BLTAPT, BLTBPT, and BLTCPT
registers ($DFF050, $DFF04C, and $DFF048) must point to the last word in the
memory area to be written to. Normally, in ascending mode, these registers
point to the start of the memory area.
Bit 2: The value of this bit determines the initial fill value used by
the blitter in fill mode. Fill mode is activated by setting either of the
following two bits.
Bit 3: Activates inclusive fill mode (See above)
Bit 4: Activates exclusive fill mode (See above) For normal copy
operations, both this bit and bit 3 should be set to zero. Fills are
performed on data only after it has been run through the selected miniterm.
Bits 12-15: Prior to applying the value of source B to the selected
miniterm operation, the blitter shifts the value the number of times
specified in these bits. (If the blitter's in ascending mode, data's shifted
right. If the blitter is in descending mode, the data is shifted left.)
Shifting does not occur if you write a zero to these bits.
Whenever you tell the blitter to shift the data in source B, you must
store a modulo value that is one less than normal in the BLTBMOD and BLTDMOD
registers.
Line Mode: To activate line mode, set bit zero of this register equal to
one. Setting the ONEDOT bit (1) tells the blitter to draw lines that have
only one pixel on each horizontal row. For clear, clean lines, you should
set this bit equal to zero. But if you are drawing objects that you plan to
fill later using the blitter fill operation, this bit should be set to one.
This way, the area to be filled in will be enclosed by single pixel walls,
just as the blitter expects them to be. Bit 5, and bits 7-11 should be set
to zero. The value of the remaining bits depends on the line's coordinates.
You might be interested to know that this register's TEXTURE bits are
actually used as a shift value, as they are in blitter copy mode. You see,
blitter source B is used as a mask for creating textured lines. Because a
line may start at any pixel position, it is necessary to shift the mask
found in BLTBDAT to align its high bit with the line's starting point. As
with bits 12-15 in the BLTCON0 register, the shift value for source B is
calculated from the lower four bits of x1.
----------------------------------------------------------------------------
$DFF044 BLTAFWM Source A First Word Mask
Status: *W Agnus
This register allows you to mask out the bits found on the left edge of
the bitplane area specified for blitter source A. The first word of each
horizontal line is ANDed with the value stored in this register before it is
shifted, applied to the miniterm, and copied to memory. For example, to
ensure that the two leftmost pixels of an area are always set to zero, store
a $3FFF in this register. In descending mode, this and the following
register swap functions.
Line Mode: In line mode, you should always store a $FFFF here.
Otherwise, your line may appear broken.
----------------------------------------------------------------------------
$DFF046 BLTALWM Source A Last Word Mask
Status: *W Agnus
This register allows you to mask out the bits found on the right edge of
the bitplane area specified for blitter source A. The last word of each
horizontal line is ANDed with the value stored in this register before it is
shifted, applied to the miniterm, and copied to memory. For example, to
ensure that the two rightmost pixels of an are are always set to zero, store
a $FFFC in this register. In descending mode, this and the previous
register swap functions.
Line mode: In line mode, you should always store a $FFFF here.
Otherwise, your line may appear broken.
----------------------------------------------------------------------------
$DFF048 BLTCPTH Blitter Source C Pointer
$DFF04A BLTCPTL
Status: *W Agnus
This is where you store the address of source C's bitmap data prior to
activating the blitter. If you're blitting in ascending order, this address
should specify the starting address of your data. If you're blitting in
descending order, this address should specify the ending address of your
data - the address of the last word of data.
The low bit of this 32 bit register is always interpreted as zero, so
blitter bitmap data must begin on an even word boundary address. (Using
BLTxFWM and BLTxLWM mask registers, however, you can specify bitmapped areas
with pixel accuracy.) And, unless your Amiga has a 1MB Agnus, your data
cannot be located above $7FFF. (1MB Agnus, use $FFFFF)
Line mode: This register, as well as the BLTDPT register ($DFF054), must
contain the starting address of the line to be drawn. (i.e. the address of
the word that contains the first point of the line.) Using standard (x1,y1)
coordinates where (0,0) is the upper left corner of the bitplane, you can
calculate this address using the following formula:
Address = Bitplane + (y1 * BytesPerLine) + (2 * (x1/16))
where Bitplane is the starting address of the destination bitplane and Bytes
Per Line is the width of the bitplane in bytes (number of pixels divided by
eight). So, to draw a line in a 320 x 200 pixel bitplane found in memory at
16384 starting at coordinate (10,20), you would store a 17185 into this
register because 16384+(20*(320/8))+(2*(10/16)) equals 17185.
----------------------------------------------------------------------------
$DFF04C BLTBPTH Blitter Source B Pointer
$DFF04E BLTBPTL
Status: *W Agnus
This is where you store the source B's bitmap data prior to activating
the blitter. See register BLTCPT ($DFF048) for details.
Line Mode: This register is not used in blitter line mode.
----------------------------------------------------------------------------
$DFF050 BLTAPTH Blitter Source A Pointer
$DFF052 BLTAPTL
Status: *W Agnus
This is where you store the address of source A's bitmap data prior to
activating the blitter. See register BLTCPT ($DFF048) for details.
Line Mode: Only the low word of this register, BLTAPTL, us used in line
mode. Its value determines the slope of the line. Use the following
formula to calculate the value of this register:
BLTAPTL = (4 * dmin) - (2 * dmax)
where dmin equals min(abs(x1-x2),abs(y1-y2)) and dmax equals
max(abs(x1-x2),abs(y1-y2)). If this formula produces a negative number, you
must write a 1 to the SIGN bit (6) of the BLTCON1 register at $DFF042.
----------------------------------------------------------------------------
$DFF054 BLTDPTH Blitter Destination Pointer
$DFF056 BLTDPTL
Status: *W Agnus
This is where you store the address of the chip RAM you're blitting into
(usually, this is a location within a bitmap). If you're blitting in
ascending order, this address should reflect the starting address of your
data. If you're blitting in descending order, it should reflect the ending
address of the destination data. This register has the same limitations as
the BLTAPT-BLTCPT registers. See location $DFF048 for details.
Line Draw Mode: This register, as well as the BLTCPT register at $DFF048
must contain the starting address of the line to be drawn - that is, the
address of the word that contains the first point in the line. See $DFF048
for more information.
----------------------------------------------------------------------------
$DFF058 BLTSIZE Blitter Start and Size
Status: *W Agnus
For Blitter Moves and Fills:
0-5 W0-W5 Width of destination area in words
6-15 H0-H9 Height of destination area in pixels
For Line Mode:

0 Set to 0
1 Set to 1
2-5 Set to 0
6-15 Set to (dmax+1)
The value stored in this register tells the blitter how large your
destination area is. The lower six bits specify the width of this area in
words - pixels divided by 16. If these bits are set to zero, the blitter
assumes a width of 64 words, or 1024 pixels. The height of the area in
pixels goes into the upper nine bits. A 0 specifies a height of 1024
pixels. You can use the following formula to calculate the value of this
register:
BLTSIZE = (Height * 64) + (Pixelwidth / 16)
The maximum width or height is 1024 pixels. The minimum width is 16
pixels and the minimum height is one pixel.
Writing to this register activates the blitter. As a result, it should
be the last blitter register that you write to.
If you are shifting source A or source B data, you must specify a
horizontal width that is one greater than normal.
Line Mode: In line mode, the lower six bits must hold the value 2 while
the upper 9 bits must hold the value of dmax + 1. Use the following formula
to determine the value that you should store in this register:
BLTSIZE = (dmax * 64) + 66
where dmax equals max(abs(x1-x2),abs(y1-y2)).
Because writing to BLTSIZE turns on the blitter, it should be the last
register that you set.
----------------------------------------------------------------------------
$DFF05A - $DFF05E Currently Unused
----------------------------------------------------------------------------
$DFF060 BLTCMOD Blitter Source C Modulo
Status: *W Agnus
Whenever the blitter finishes writing data to the last word in a
horizontal line, the contents of this register are added to the BLTCPT
register so that it points to the start of the next line. This allows the
blitter to copy areas within a bitmap that are smaller than the width of the
bitmap itself. If you're copying an area that is the same width of the
bitplane it is contained in or if you're copying consecutive bytes in
memory, simply write a zero to this register. Otherwise, this register
should contain the difference between the byte width of the bitplane
containing the area to be copied and the byte width of the area. Here's a
formula for determining the value that should be stored in this register:
BLTCMOD = (BitMapWidth / 8) - (2 * (AreaWidth / 16))
where BitMapWidth and AreaWidth are the pixel widths of the source bitmap
and the area to be copied respectively. Note that this register specifies
width in bytes whereas the BLTSIZE register specifies width in words. Also,
although this register reflects the bitmap's width in bytes, its low bit is
ignored, so the value here must specify an even number of bytes.
With a separate BLTxMOD register for each source, it's possible to
combine the data from three bitmaps of different widths.
Line Mode: For drawing lines, store the byte width (pixel width divided
by 8) of your bitmap in this register.
----------------------------------------------------------------------------
$DFF062 BLTBMOD Blitter Source B Modulo
Status: *W Agnus
Copy Mode: See BLTCMOD above.
Line Mode: This register should contain the value 4 * dmin, where dmin
equals min(abs(x1-x2),abs(y1-y2)).
----------------------------------------------------------------------------
$DFF064 BLTAMOD Blitter Source A Modulo
Status: *W Agnus
Copy mode: See BLTCMOD above.
Line Mode: This register should contain the value 4 * (dmin - dmax) with
dmin and dmax defined as above.
----------------------------------------------------------------------------
$DFF066 BLTDMOD Blitter Destination Modulo
Status: *W Agnus
Copy mode: See BLTCMOD above.
Line Mode: For drawing lines, store the byte width (pixel width divided
by 8) of your bitmap in this register. This is the same value you must
store in the BLTCMOD register.
----------------------------------------------------------------------------
$DFF068 - $DFF06E Currently Unused
----------------------------------------------------------------------------
$DFF070 BLTCDAT Blitter C Source Data
Status: *W Agnus
The blitter uses this register as the data register for blitter source C
Line Mode: This register is not used in line mode.
Blitter Data Register Notes: The blitter uses these registers as a

temporary holding place for data that is read from memory. If a source's
DMA is enabled for a blitter operation, words are read from memory and then
stored in the corresponding BLTxDAT register. Here the data is manipulated
according to the mask registers, the shift bits, the miniterm operation, and
then it is written to destination RAM.
If a source's DMA is disabled, the data is not read from memory, but the
value found in the source's data register is still used to form the
blitter's output. For this reason, it's a good idea to initialize the data
register of an unused source prior to starting the blitter.
You can use the data registers to fill an area of memory with any word
long value. Simply set up the blitter so that none of the data registers
have DMA enabled, select a miniterm of A, write the desired value into the
BLTADAT register, set up the remaining registers as usual, and activate the
blitter.
If you plan to shift source A or B during a blitter operation, you must
be sure to initialize the shift bits prior to writing to the source's data
register. Otherwise, the number written to this register will be shifteed
according to the old shift value.
----------------------------------------------------------------------------
$DFF072 BLTBDAT Blitter Source B Data
Status: *W Agnus
This is the data register for blitter source B.
Line Mode: Store the bit pattern with which you wish you5r line to be
drawn in this register. For normal solid lines, store a $FFFF here. Other
values produce dotter or dashed lines.
----------------------------------------------------------------------------
$DFF074 BLTADAT Blitter Source A Data
Status: *W Agnus
This is the data register for blitter source A.
Line Mode: This register should be initialized with the value of $8000
for line mode.
----------------------------------------------------------------------------
$DFF076 - $DFF07C Currently Unused
----------------------------------------------------------------------------
$DFF07E DSKSYNC Disk Sync Pattern
Status: *W Paula
Before reading data from a disk, it's often necessary to sync the
drive's heads on a particular bit pattern. This register allows you to do
just that.
When the WORDSYNC bit (10) in the ADKCON register ($DFF09E) is set, the
disk controller's DMA is enabled and the controller prepares to search the
disk for the sync pattern found in this register. The disk controller
doesn't start searching until this register is written to. When the sync
pattern is found, it is set to one for two or four usec (Depending on the
format selected: MFM or GCR) as soon as the sync pattern is located.
This event can also be used to trigger a level 6 interrupt.
In MFM format (the disk format used by AmigaDos), the sync pattern should
be a value that is impossible to create using MFM data coding. This way, it
can't be confused with actual data. AmigaDos uses the number $4489 as its
sync pattern. Here's how you might initiate the search for this value using
machine language:
ADKCON equ $DFF09E

DSKSYNC equ $DFF07E
move.w #$8400,ADKCON
move.w #$4489,DSKSYNC
For more information on low-level disk access, see the CIA-B's PRB
register at $BFD100.
----------------------------------------------------------------------------
Copper Registers:
The copper is designed to free the 680x0 from display tasks. It has
three instructions: WAIT, MOVE, and SKIP. It doesn't seem like you can do
much with only three instructions, but by using a variety of tricks and
subterfuges, a copper list can perform loops, take over the blitter, and
even generate an interrupt for the 68000.
WAIT. Wait mimics a loop structure which waits for a certain condition
to occur. Specifically, Wait waits for the x,y coordinates of the raster to
meet or exceed the coordinates you specify. Thus, wait allows you to
synchronize actions with the video. (i.e.: Color changes, raster
interrupts, etc.) Since a typical copper list executes every time the
screen is drawn, the color change will be rock steady.
The x,y coordinates are not simple pixel coordinates, but beam position
coordinates. See the descriptions of VPOSR ($DFF004), VHPOSR ($DF006),
VPOSW ($DFF02a), and VHPOSW ($DFF02C).
Here is what a Wait instruction looks like:
0 Always set to 0
1-7 horizontal compare enable bits
8-14 vertical compare enable bits
15 the blitter finished disable bit (usually 1)
16 Always set to 1
17-23 horizontal beam position
24-31 vertical beam position
Bits 1-7 describe which bits of the horizontal beam counter will be
compared with an x position for which you choose to wait. Normally, you
should set all of these bits to one.
Bits 8-14 describe the same for the y position.
Bit 15 should normally be set to one. If you set it to zero, the copper
Wait instruction will wait until the beam position meets or exceeds the
given position and the blitter has finished its operation.
Bits 17-23 indicate the horizontal beam position for which the wait is
waiting. Note that bits 1-7 are used to decide which bits are actually used
for the comparison.
Bits 24-31 indicate the same for the vertical - uses 8-14.
Because the horizontal beam position is maintained to a resolution of two

low resolution pixels, and because the LSB of that position is not used in
wait comparison, WAIT has a resolution of four lo-res or 8 hi-res pixels.
One potential problem with wait is that you cannot directly wait for a
line greater than 255. To do this, wait for 255. Then, wait for line
number x-255.
A version of the wait command is used to end copper lists. The command
code is $FFFFFFFE. (i.e. wait for y=255, x=254) The loop seems to be
infinite, and in fact is, however note that the copper list is reset DURING
EVERY VERTICAL BLANKING PERIOD!
MOVE. The Move instruction transfers data to a hardware register. The

instruction can store data into any register with an address of $80 or more.
Note that the register base of $DFF000 is implicit - it is not included in
the instruction. If the copper danger bit, CDANG is set ($DFF02E bit 1),
the instruction can store data into any register with an address of $40 or
more. Unless you need the copper to write to the blitter registers, you
should keep CDANG set to zero.
With the Move instruction, you can set up bitplane pointers, sprite
pointers, color registers, and so on. A complete, useful copper list will
have MANY move instructions because there are several DMA registers that
have to be reset every frame. For example, the bitplane registers must be
reset to keep them from continuing where they left off. Otherwise, you'd
see all of chip RAM rushing through the screen at great speed.
Keep in mind that Move is not instantaneous. Two Move instructions will
be separated by four low resolution pixels.
Here is the format for the Move command:
0-15 Data
16 Set to Zero
17-24 Register address
25-31 Unused - set to zero
Bits 0-15 are a word of data that you wish to transfer to the hardware
register. If you want to transfer a long word, you must use 2 move
instructions.
Bits 17-24 specify the offset from $DFF000 which you would like to
modify. The CDANG bit of the COPCON register determines which values are
considered legal by the copper.
SKIP. Most copper lists are composed only of WAIT and MOVE instructions.
The Skip command allows for conditional branching. It is a command that has
quite a bit of potential that has rarely been tapped.
Skip is a close relative of WAIT. As is the case with Wait, Skip decides
what to do based on the position of the video beam. Instead of waiting for
a beam position though, it alters copper list program flow based on the beam
position.
The Skip instruction looks like this:
0 Set to 1
1-7 horizontal compare enable bits
8-14 vertical compare enable bits
15 blitter-finished-disable bit
16 set to 1
17-23 horizontal beam position
24-31 vertical position
The Skip command skips the instruction that immediately follows it if the
beam counter meets or exceeds the value you specify. The instruction that
follows skip is typically a strobe to the COPJMP1 or COPJMP2 registers.
Writing to these registers causes a jump to the address in the COP1LC or
COP2LC registers, respectively.
----------------------------------------------------------------------------
$DFF080 COP1LCH Copper Program Counter 1
$DFF082 COP1LCL
$DFF084 COP2LCH Copper Program Counter 2
$DFF086 COP2LCL
Status: *W Agnus
The above registers are the copper location registers. COP1LC is the
default copper PC. Either of the above are loaded when the COPJMP registers
are strobed.
----------------------------------------------------------------------------
$DFF088 COPJMP1 Copper Jump Strobes
$DFF08A COPJMP2
Status: Strobe Agnus
These locations, when written to, cause the respective copper PC (1 or 2)
to be loaded into the copper program counter. The operation system strobes
COPJMP1 during a vertical blank interrupt.
----------------------------------------------------------------------------
$DFF08C COPINS Copper Instruction Identity
Status: *W Agnus
This location is of questionable use to the programmer. It is written to
by the hardware and is used to identify the current copper instruction.
----------------------------------------------------------------------------
Location Range: $DFF08E - $DFF094 Position of the screen display
These four registers define the position of the Amiga's screen. DIWSTRT
(Display Window Start) defines the screen's upper left corner while DIWSTOP
(Display Window Stop) defines the window's lower right corner. Anything
outside of this area is considered border area.
Before explaining how the next two registers, DDFSTRT and DDFSTOP, affect
the display, a brief explanation of bitplane DMA is in order. Bitplane data
describes what to draw, but it's the responsibility of bitplane DMA to grab
that data from chip RAM and give it to the video hardware via registers
BPL1DAT - BPL6DAT ($DFF110 - $DFF11A). Shortly after the video hardware
receives new data, it draws that data at the cirrent video beam position.
So where graphics appear onscreen is determined by when bitplane DMA gives
the video hardware its information. (Anytime bitplane DMA is inactive and
the BPLxDAT registers are empty, the Amiga displays the color specified by
the COLOR00 register.)
Vertically, bitplane DMA starts the moment it reaches the Y coordinate
found in DIWSTOP. Horizontal start and stop locations are a bit more
complicated, however, as the computer needs some more time before it can
display fetched data. On a lo-res display, it takes 8.5 color clocks. (A
color clock is equal to one memory access cycle, ehich is approximately 280
nsec in duration. The Amiga can output two lo-res pixels per color clock.)
Each horizontal line on the computer screen can be thought of as a time
line. Where along this line bitplane DMA is allowed to start is determined
by the DDFSTRT (Display Data Fetch Start) register. The DDFSTOP (Display
Data Fetch Stop) register tells the Amiga when the bitplane DMA should stop.
As you can imagine, unless these registers correspond with the horizontal
coordinates found in the DIW registers, your display will appear cropped
and/or garbled.
Finding the proper value for the DDFSTRT based on the horizontal
coordinate found in DIWSTRT is easy. Because the DIWSTRT register specifies
coordinates in lo-res pixels, and the DDFSTRT register is accurate to only
two lo-res pixels, you must first divide DIWSTRT's horizontal coordinate by
two; then, simply subtract the number of color clocks that you need - 4.5
for hi-res, and 8,5 for lo-res. Here oare the formulae you should use to
calculate the correct value for the DDFSTRT register:
DDFSTRT = HSTART / 2 - 4.5 for hi-res screens, and
DDFSTRT = HSTART / 2 - 8.5 for lo-res.
HSTART refers to bits 0-7 of the DIWSTRT register (its horizontal
coordinate).
Since the default value for HSTART is $81, DDFSTRT defaults to $3C for
hi-res, and $38 for lo-res.
Calculating the value for DDFSTOP is also easy. Its value depends on the
screen's width:
DDFSTOP = DDFSTRT + (4 * ((Width / 16) - 1)) for hi-res screens, and
DDFSTOP = DDFSTRT + (* * ((Width / 16) - 1)) for lo-res.
Width is the width of the screen in pixels. So, on a standard 640 pixel
hi-res screen, where DDFSTRT equals $3C, DDFSTOP should be set to $D4.
----------------------------------------------------------------------------
$DFF08E DIWSTRT Display Window Start
Status: *W Agnus
0-7 HSTART Horizontal coord. of upper left corner
8-15 VSTART Vertical coordinate of lower right corner
Notes: Bits 0-7 default to $81, and 8-15 default to $2C.
----------------------------------------------------------------------------
$DFF090 DIWSTOP Display Window Stop
Status: *W Agnus
0-7 HSTOP Horizontal coord. of lower right corner
8-15 VSTOP Vertical coord. of lower right corner.
Notes: For bits 0-7, the minimum HSTOP position in $100, which is 1/3 across
the screen. The value stored here represents an offset from this position.
So, the actual horizontal coordinate of the lower right corner of the screen
is $100 PLUS HSTOP! You can think of HSTOP as being a nine bit register
with bit 8 always set. The Default is $C1, which specifies a value of $1C1.
For bits 8-15, these bits hold the vertical coordinate of the lower right
corner of the screen. The minimum VSTOP position in $80. If the value here
is less than $80, VSTOP equals $100 PLUS your VSTOP value. Simply put,
whatever the state of bit 8 is, bit nine will be opposite! The default for
NTSC is $F4, and the PAL default is $2C which actually is $12C. VSTOP
always specifies the vertical position in noninterlace lines, no matter what
mode the computer is in.
----------------------------------------------------------------------------
$DFF092 DDFSTRT Display Data Fetch Start
Status: *W Agnus
This register specifies the horizontal position that the video beam must
reach in order for bitplane DMA to start. It's value depends on your screen
resolution, and what you store in the HSTART bits (0-7) in the DIWSTRT
register at $DFF09E.
In hi-res, only bits 2-7 are active. (specifies an even multiple of 4)
In lo-res, only bits 3-7 are active (an even multiple of 8). Because of
certain hardware limitations, do not use DDFSTRT values less than $18. Ans,
because sprite DMA relies on color clocks that occur during raster positions
$16-$34, using DDFSTRT values below $38 will disable certain sprites. The
lower the number, the more sprites are disabled. Higher numbered sprites
will be disabled first.
----------------------------------------------------------------------------
$DFF094 DDFSTOP Display Data Fetch Stop
Status: *W Agnus
This register specifies the horizontal position the video beam must reach
in order for bitplane DMA to stop. The bits used are the same as for
DDFSTRT. Because of certain hardware limitations, do not use values greater
than $D8.
----------------------------------------------------------------------------
$DFF096 DMACON DMA Control
Status: *W Angus/Denise/Paula
This is the write register for DMACONR. The only difference is that
SET/CLR is active. Note that activating audio channel DMA starts the sound
on the specified channel. (See DMACONR at $DFF002)
----------------------------------------------------------------------------
$DFF098 CLXCON Collision Control
Status: *W Denise
0 MVP1 Match value for bitplane 1 collisions
1 MVP2 2
2 MVP3 3
3 MVP4 4
4 MVP5 5
5 MVP6 6
6 ENBP1 Enable collision detection for bitplane 1
7 ENBP2 2
8 ENBP3 3
9 ENBP4 4
10 ENBP5 5
11 ENBP6 6
12 ENSP1 Enable collision detection for sprite 1
13 ENSP3 3
14 ENSP5 5
15 ENSP7 7
The Amiga can detect three types of graphic collisions: sprite - sprite,
sprite - bitplane, and bitplane - bitplane. The match value in bits 0-5
determine exactly what constitutes a collision: either a 0 or 1.
Through creative use of 0-5 and 6-11, you can specify that collision
takes place with only a certain color or within a range of colors.
Bits 6-11. These bits determine which bit planes are used in collision
detection. Oddly, the Amiga always seems to think that a bitplane collision
is taking place when all of these bits are set to zero.
Bits 12-15. Setting these bits allows you to check for collisions
between the specified sprite, and the next lower one.
----------------------------------------------------------------------------
$DFF09A INTENA Interrupt Enable
Status: *W Paula
This is the write register for INTENAR at $DFF01C. Note that SET/CLR is
active, and that you must CLEAR the appropriate bit after servicing the
interrupt!
----------------------------------------------------------------------------
Location Range: $DFF09E - $DFF0DE Audio Registers
Once you have a waveform sample loaded into chip RAM, turning that data
into sound is relatively simple. Just tell the computer where is, the
length in words, how fast to play the sound, set the volume, and then signal
that DMA for the desired sound. The Amiga will continue to play and repeat
your sound until you tell it to stop.
----------------------------------------------------------------------------
$DFF09E ADKCON Audio/Disk Control (see ADKCONR at $DFF010)
Status: *W Paula
Notes on bit 12: MFM vs. GCR formatting:
Briefing put, MFM format inserts clock bits between each data bit written
to disk. If two consecutive data bits are zero, a 1 clock bit is inserted
between them. If either of two consecutive bits is a 1, a 0 clock pulse in
put between them. Using this coding method, the amount of data written to a
disk is doubled, but the accuracy of reading the data is increased. You
see, the disk controller has an easier time synchronizing on data that
changes states rather than data that repeats such as a long string of 1's or
0's.
GCR format handles synchronization problems by encoding every four bits
od data into five bits. The result is a binary number with no more than two
adjacent 0 bits and no more than eight adjacent 1 bits. (This format is
used on the Commodore 1541 drives on the C64.) The following table shows
the 5 bit GCR equivalents of the binary numbers 0000-1111.
Binary GCR
------ ---
0000 01010 Note that with GCR, no more than 8 on bits or
0001 01011 2 off bits are possible.
0010 10010
0011 10011
0100 01110
0101 01111
0110 10110
0111 10111
1000 01001
1001 11001
1010 11010
1011 11011
1100 01101
1101 11101
1110 11110
1111 10101
Notes on bit 13: These set the disk disk controller's precompensation
time, which directly affects the density of the data written to disk. The
faster the precompensation time, the higher the density. With AmigaDos,
density is highest on the inside tracks, probably due to the fact that these
is less physical space for these tracks.
----------------------------------------------------------------------------
$DFF0A0 AUD0LCH Channel 0 Waveform Address
$DFF0A2 AUD0LCL
Status: *W Agnus
The low byte of this register is always interpreted as zero, so your data
must begin on a word boundary. For a 512K Agnus, max address is $7FFFF, and
for a 1MB Agnus, it is $FFFFF.
----------------------------------------------------------------------------
$DFF0A4 AUD0LEN Channel 0 Waveform Length
Status: *W Paula
The length of your data in words is stored here. So, your data must be
an even number of bytes, and may not exceed 131,070 bytes. (i.e. 65536
times two.)
However, it is possible to play waveforms longer than 131,070 bytes due
to the fact that the Amiga buffers the contents of the AUDxLC and AUDxLEN
registers by using backup registers. So, you may change the AUDxLC and
AUDxLEN registers while the Amiga is playing a sound, and when it is
finished, it will start with the new data! Any of the Amiga's audio
channels can cause a level 4 interrupt just before your sound starts a new
waveform cycle. When this interrupt occurs, you know it's safe to change
the registers. One warning however: Interrupts caused by high-frequency
waveforms can occur quite rapidly. Even more rapidly than the operating
system can keep up! It's best to leave the audio interrupts alone, unless
you actually need them. Just wait a little while before changing the AUDxLC
and AUDxLEN registers and all will work fine.
----------------------------------------------------------------------------
$DFF0A6 AUD0PER Channel 0 Period
Status: *W Paula
A sound's frequency is determined by the value stored here. The lowest
value you should use is 124, since this is about as fast as the Amiga can
go. The highest value is 65535.
How you determine the period depends on how you get your waveform data.
If you use a digitizer and the frequency is in Samples-per-second, use this
equation: AUDxPER = 3579546 / Samples-per-second
If you have a group of data that you want played as an "instrument", use
this: AUDxPER = 3579546 / (Bytes-Length * Frequency to be played)
Of course, the frequency for a given note may be calculated by the old
standby: Frequency = Base * 2 ^ (1/12)
Which calculates the frequency for the next note once given a frequency.
Middle C comes in at 261.4 Hz.
If you don't want your sound to repeat, you should consider one more
thing: when to stop the sound. You see, the faster you play the sound, the
faster its going to finish. To figure out how long to let it play, use the
following equation:
uSec = .279365 * Period * Length
Where uSec, is of course, the time in microseconds it takes to play your
sound once.
----------------------------------------------------------------------------
$DFF0A8 AUD0VAL Channel 0 Volume
Status: *W Paula
This volume register can accept values between 0 and 64, where 0 is the
lowest setting (at -infinity dB), and 64 is loudest (at -0 dB).
----------------------------------------------------------------------------
$DFF0AA AUD0DAT Channel 0 Data
Status: *W Paula
This is the data buffer used by channel 0. It's purpose is to output
sounds at a rate higher than the DMA can. To use it, you must disable
channel 0 DMA and shove the data in onw word at a time.
----------------------------------------------------------------------------
Location Range: $DFF0AC - $DFF0AE Unused
The Amiga reserves enough space for eight word-long addresses for each
channel, but uses only six. The remaining addresses are unused.
----------------------------------------------------------------------------
$DFF0B0/2 AUD1LCH/L These registers function exactly the same as
$DFF0B4 AUD1LEN channel 0's. To Find channel 2's, add $20 to
$DFF0B6 AUD1PER the AUD0xxx value, and $30 for channel 3.
$DFF0B8 AUD1VOL
$DFF0BA AUD1DAT
$DFF0BC/E UNUSED
----------------------------------------------------------------------------
Location Range: $DFF0E0 - $DFF0F6 Bitplane pointer registers
Status: *W Agnus
These registers point to the current word of data that is being displayed
from each bitplane. They are set up by the programmer, but increment as
each word of data is fetched from memory. Therefore, these registers must
be reset for each screen. This is usually done by the copper list, but may
also be written directly to by the programmer during the vertical blank
interrupt. The initial value stored here should be the starting address of
the bitplane. The value stored here must begin on a word boundary, and all
notes about 512K / 1MB Agnus chips apply here.
$DFF0E0 BPL1PTH/L Bitplane pointers for bitplanes 1-6... 32 bits long

$DFF0E4 BPL2PTH/L with bit zero ignored.
$DFF0E8 BPL3PTH/L
$DFF0EC BPL4PTH/L
$DFF0F0 BPL5PTH/L
$DFF0F4 BLT6PTH/L
----------------------------------------------------------------------------
Location Range: $DFF0F8 - $DFF0FE Currently Unused.
----------------------------------------------------------------------------
Location Range: $DFF100 - $DFF104 Bitplane Control Registers
These three register control the modes of the Amiga video display.
Within the bits of these registers are the means of creating just about any
Amiga screen possible. BPLCON0 ($DFF100) controls how the pixels are
displayed. Genlocking, interlace, dual playfield mode, HAM, Extra Half
Brite, and Hi-Res are all among its domain. BPLCON1 ($DFF102) controls the
hardware smooth scrolling of the Amiga. BPLCON2 ($DFF104) is the priority
register which determines how the playfield and sprites will interact. A
few terms will be described to facilitate the discussion of these registers:
Dual Playfield Mode: In this mode, the odd numbered bitplanes are grouped
into one playfield (1), and the even numbered bitplanes into the other. (2)
One playfield has priority over the other, which means that the backgroup's
playfield shows through only when the foreground's pixels color is 0.
Extra HalfBrite: In EHB, pixels may have any value in the range of 0-63.
Pixels in the range of 0-31 use the normal 32 color registers. Pixels 32-63
use the lower 32 color registers with the RGB values each shifter one bit
right. Thus, 32-63 are half as bright.
Genlock: This is a method of combining computer graphics with an external
video source. The external source shows through where pixel color 0 is.
Hold and Modify (HAM): In HAM mode, 16 color registers (4 bits) are used
normally. In 5 bitplane HAM mode, a bit set in the 5th bitplane signifies
that the pixel should use the color of the pixel immediately to the left,
but with the blue value corresponding to the value of the lower four
bitplanes. In 6 bitplane mode, the bits in the 5th and 6th bitplanes are
used to specify whether the lower sixteen color registers should be used
normally, or whether the pixel should be based on the pixel immediately to
the left, with the red, green, or blue intensity altered. HAM images are
the most photographic available on the Amiga. Six bitplane HAM is typical,
with five bitplane HAM a rarity.
Interlace: This is a method of doubling vertical resolution by displaying
alternating lines on alternating scans. See VPOSR at $DFF004.
Playfield: This is the name for the non-sprite graphics that appear on
the screen as a result of bitplane DMA. The name is a carryover from the
old Atari VCS. (gasp!)
----------------------------------------------------------------------------
$DFF100 BPLCON0 Bitplane Control Register 0
Status: *W Agnus/Denise
0 UNUSED
1 ERSY External sync. (1 = external, genlocked
0 = internal, normal)
2 LACE 1 = interlace enable
3 LPEN 1 = light pen enable
4-7 UNUSED
8 GAUD 1 = Genlock audio enable
9 COLOR 1 = Composite color enable on Amiga 1000,
0 = Monochrome display.
10 DBLPF 1 = Double (dual) playfield mode
11 HOMOD 1 = HAM active
12-14 BPU Number of bitplanes used. Zero = no bitplanes
You cannot use more than 4 for hi-res, and six
activates EHB mode.
15 HIRES 1 = Hi-res mode 0 = Lo-res mode.
Notes on bit 8: It has been alleged that audio data can be multiplexed on
the BKGD pen during vertical blanking, and bit 8 enables this feature. In
reality, however, this bit simply goes out on the pixel switch ZD during
blanking periods.
----------------------------------------------------------------------------
Status: *W Denise
0-3 PF1H Playfield 1 horizontal scroll
4-7 PF2H Playfield 2 horizontal scroll
This register allows you to fine scroll the screen horizontally.
Vertical scrolling is trivial. Simply increment or decrement the starting
address of each bitplane by the width of a screen line in bytes. Horizontal
scrolling is trickier. You can perform a coarse 16 pixel scroll by simply
incrementing or decrementing the starting address of the bitplane pointers
by one word, but to scroll at the pixel level, use this register.
In lo-res, the scrolling is in one pixel increments, and in hi-res, it is
two pixels. To set up a screen for horizontal scrolling, the screen must be
one word wider than normal. Do, you must add 2 to DDFSTRT's ($DFF030)
normal value. You must set the modulo registers (BPLxMOD $DFF108) to the
number of "extra" bytes in each line (those that would not exist if you
weren't doing horizontal scrolling) minus two. For example, if you're
displaying 40 bytes of an 80 byte wide screen, place the number 38 into the
appropriate BPLxMOD register.
----------------------------------------------------------------------------
Status: *W Denise
This register allows you to determine priorities between the graphic
elements that make up an Amiga screen, namely the eight sprites and two
playfields.
0-2 PF1P Playfield 1 vs. sprite priority

3-5 PF2P Playfield 2 vs. sprite priority
6 PF2PRI Playfield 1 vs. playfield 2 priority (1 = 2 in front,
0 = 1 in front.)
Notes: Bits 0-5 allow you to specify whether sprites should pass in front of
or behind a given set of bitplanes. The table below shows the allowable
values.
bit 2 bit 1 bit 0 (for playfield 1)

bit 5 bit 4 bit 3 (for playfield 2)
0 0 0 Playfield has top priority
0 0 1 Playfield appears behind sprites 0-1
1 0 0 Playfield appears behind all sprites
----------------------------------------------------------------------------
$DFF106 Zilch - Unused
----------------------------------------------------------------------------
$DFF108 BPL1MOD Bitplane Modulo 1
$DFF10A BPL2MOD Bitplane Modulo 2
Status: *W Agnus
These registers control how many bytes are added to the bitplane pointers
at the end of a video line. Normally, the value is zero. When the number
is greater than zero, you have an undisplayed segment of the screen to the
right of the visible area. You can bring this area into view by
incrementing the bitplane pointers, and modifying the smooth scroll
register BPLCON1 at $DFF102.
As an example, suppose the virtual screen you have is 80 bytes wide, by
the visible screen is 40. You'll need to specify 40 as the modulo.
There are two modulo registers, one for each playfield. Unless you are
using dual playfield mode, both of these registers should be set to the same
value. Note that the lowest bit is ignored, thus these registers must be
set to an even value.
----------------------------------------------------------------------------
Location Range $DFF10C - $DFF10E Currently Unused.
----------------------------------------------------------------------------
Location Range $DFF110 - $DFF11A Bitplane Data Registers
The Amiga hardware is currently able to display six bitplanes. If you
look carefully, however, there are gaps that would allow two extra bitplanes
to be inserted. These registers are typically written to by the bitplane
DMA, but they may also be written to by the programmer directly. The
parallel data from the six bitplanes is shifted out the left and converted
to a color. BPL1DAT is the trigger register. That means that you should
write to BPL2DAT - BPL6DAT first, then write to BPL1DAT to trigger the
serial conversion.
$DFF110 BPL1DAT Bitplane DMA trigger. Color Weight = 1

$DFF112 BPL2DAT Weight = 2
$DFF11A BPL6DAT Weight = 32 (i.e. HAM / EHB)
----------------------------------------------------------------------------
Location Range $DFF11C - $DFF11E Currently Unused.
----------------------------------------------------------------------------
Location Range $DFF120 - $DFF17E Sprite Registers
The Amiga is known for the animation capabilities of the blitter, but it
also has powerful sprite hardware. Sprites have some advantages over the
blitter. Whereas the blitter must render its images to display memory,
sprites are rendered in a separate area of memory.
There are eight sprites. Each sprite is 16 pixels wide and an arbitrary
size high. The pixels are lo-res, even when displayed in hi-res or
interlaced mode. Each pixels can be one of three colors or transparent.
Sprites 0 and 1 share color registers 17 - 19. Sprites 2 and 3 share
21-23, 4 and 5 share 25-27, and 6 and 7 share 29 through 31. If your screen
uses 4 bitplanes or less, you won't have to worry about sprites sharing the
color registers with the playfield. Otherwise... you'll have to plan colors
carefully.
Note that the lower the sprite number, the higher its priority on the
screen. Sprite priorities relative to the playfield can be assigned. See
the bitplane control registers $DFF100 - $DFF106.
----------------------------------------------------------------------------
$DFF120 SPR0PTH Sprite Pointer 0
$DFF122 SPR0PTL
Status: *W Agnus
This register holds the address of the Sprite 0 DMA data. The address
must be in chip RAM. This register acts as a DMA counter, so you must
initialize it during every vertical blank via the copper list or within a
vertical blank interrupt server.
The address which you set to this register should contain valid sprite
data in chip RAM. Use this format (each value is 32 bits):
Sprite Control Value

Image data for line 1
Image data for line 2
.....................
Image data for last line
Repeat this format for each occurrance of the sprite on the screen. For
instance, you might have the same sprite engine used in three different
vertical areas of the screen. In this case, you'd have the above format
three times. At the end of the data, store a $00000000.
Here is a sample adapted from the Amiga Hardware Reference Manual:
SPRITE:
DC.L $6D607200 ; VSTART, HSTART, and VSTOP
DC.L $099007E0 ; Sprite data... $6D
DC.L $13C80FF0 ; $6E
DC.L $23C41FF8 ; $70
DC.L $13C80FF0 ; $71
DC.L $099007E0 ; $72
DC.L $00000000 ; End of structure.
The Amiga is often said to have reusable sprite engines. This means that
the Amiga can display the same sprite in several different places. There is
one significant limitation to this ability: You must ensure that there is at
least one blank line vertically between the two instances of the same
sprite. For example, if you have a sprite that stops displaying on line 25,
you may display a second one on line 27 or greater.
----------------------------------------------------------------------------
$DFF124 SPR1PTH/L Sprite Pointers 1-7
$DFF128 SPR2PTH/L
$DFF12C SPR3PTH/L
$DFF130 SPR4PTH/L
$DFF134 SPR5PTH/L
$DFF138 SPR6PTH/L
$DFF13C SPR7PTH/L
----------------------------------------------------------------------------
$DFF140 SPR0POS Sprite Position 0 & Control 0
$DFF142 SPR0CTL
Status: *W Agnus/Denise
These two 16-bit registers can be thought of as a single 32 bit register
which holds information about how sprite 0 is to be displayed. Info
included is vertical and horizontal starting locations, vertical stopping
location, and whether the sprite should be attached to its companion (0 and
1, 2 and 3, 4 and 5, 6 and 7).
The sprite control value consists of the following bits, the number of
which should be stored in the:
0 HSTART lowest bit
1 VSTOP highest bit
2 VSTART highest bit
3-6 Always 0
7 ATTACHMENT 1 = attached, 0 = not
8-15 VSTOP lowest 8 bits
16-23 HSTART highest 8 bits
24-31 VSTART lowest 8 bits
The HSTART value is your sprite's intended horizontal position.

Typically, the horizontal position 0 is 64 pixels to the left of the screen.
This number can change depending on your preferences settings. Suppose
that you want to position a sprite at the horizontal position which
corresponds to pixel 10. In this case, add 10 + 64, to get 74. Place 74 in
HSTART. If you're setting up your own copper list, you'll know the value to
add to your desired offset. If you're using a screen set up by the screen,
you can find the offset in the View structure.
The VSTART value is your sprite's intended vertical position. Typically,
the vertical position is 0-44 pixels above the top line of the screen. This
number can change depending on your preferences settings. Suppose you want
to position a sprite at the vertical position that corresponds with pixel
position 12. Simply add 12 + 44 to get 56. Place 56 in VSTART.
The VSTOP value is the line on which you want your sprite to stop
displaying. Simply add the height of the sprite to VSTART to get this
value.
The register's attachment bit (7) is ingored in even numbered sprites.
When you attach two sprites, set HSTART, VSTART, and VSTOP of the two
sprites to the same values.
Keep in mind that to modify this from within the copper, you will need to
use two Move instructions. This location is usually not written to by the
programmer. Instead, it is written to by sprite DMA.
----------------------------------------------------------------------------
$DFF144 SPR0DATA Sprite Data Register 0
$DFF146 SPR0DATB
Status: *W Denise
This location is usually not written to by the programmer. Instead, it
is written to by the sprite DMA. If you write to it directly, write to
SPR0DATB (high bit of 4 colors) first then to SPR0DATA. The data will then
be displayed on every line at the horizontal position specified in SPR0POS
and SPR0CTL until you write to SPR0DATA again. SPR0DATA acts as a switch to
turn the sprite on. SPR0CTL acts as the corresponding off switch. The
weight of the bits for color are as follows:
SPR0DATA 1
SPR0DATB 2
SPR1DATA 4 (if attached)
SPR1DATB 8 (if attached)
----------------------------------------------------------------------------
Note: Sprites 0,1 share colors as do 2,3; 4,5; and 6,7
$DFF148 SPR1POS (PIXEL VALUE 0 = TRANSPARENT

$DFF14A SPR1CTL 1 = COLOR REGISTER 17
$DFF14C SPR1DATA 2 = COLOR REGISTER 18
$DFF14E SPR1DATB 3 = COLOR REGISTER 19)
$DFF150 SPR2POS (SHARES 3'S COLOR REGISTERS...)
$DFF152 SPR2CTL
$DFF154 SPR2DATA
$DFF156 SPR2DATB
$DFF162 SPR4CTL
$DFF164 SPR4DATA
$DFF166 SPR4DATB
$DFF172 SPR6CTL
$DFF174 SPR6DATA
$DFF176 SPR6DATB
----------------------------------------------------------------------------
Location Range $DFF180 - $DFF1BE Color Registers
Each color register contains 12 bits of information, for a total of 4096
colors. The registers are set up as follows:
0-3 Blue intensity (0 = no blue, 15 = full blue)
4-7 Green intensity
8-11 Red intensity
12-15 Unused
There are seven colors which can be represented in 16 intensities. Those

colors are, along with their hexadecimal values:
Gray Red Green Blue Yellow Magenta Cyan

---- --- ----- ---- ------ ------- ----
FFF F00 0F0 00F FF0 F0F 0FF
Here is a table of common colors:
Black - 000 Blue - 00F Green - 0F0 Cyan - 0FF

Red - 0F0 Purple-F0F Orange- E70 Yellow-FF0
White - FFF LtGray-CCC MdGray- 888 DkGray-444
----------------------------------------------------------------------------
$DFF182 COLOR01 $DFF184 COLOR02 $DFF186 COLOR03 $DFF188 COLOR04
$DFF18A COLOR05 $DFF18C COLOR06 $DFF18E COLOR07 $DFF190 COLOR08
$DFF192 COLOR09 $DFF194 COLOR10 $DFF196 COLOR11 $DFF198 COLOR12
$DFF19A COLOR13 $DFF19C COLOR14 $DFF19E COLOR15 $DFF1A0 COLOR16
$DFF1A2 COLOR17 $DFF1A4 COLOR18 $DFF1A6 COLOR19 $DDD1A8 COLOR20
$DFF1AA COLOR21 $DFF1AC COLOR22 $DFF1AE COLOR23 $DFF1B0 COLOR24
$DFF1B2 COLOR25 $DFF1B4 COLOR26 $DFF1B6 COLOR27 $DFF1B8 COLOR28
$DFF1BA COLOR29 $DFF1BC COLOR30 $DFF1BE COLOR31
----------------------------------------------------------------------------
8520 CIA Chips - Location Range $BFD000-$BFDF00
CIA-B
Locations $BFD000-$BFDF00 are used to address the Amiga's second Complex
Interface Adaptor (CIA-B). Since the chip itself is identical to the CIA-A,
which is addressed at $BFE001, the discussion here will be limited to the
use the Amiga makes of this particular chip. For more general information
on the chip registers, see the corresponding entries for CIA-A. Unlike the
custom chip registers, the CIA registers are all one byte long and can be
both read from and written to.
----------------------------------------------------------------------------
$BFD000 PRA Peripheral Data Register for Data Port A
Status: R/W CIA-B
0 BUSY Centronics busy (parallel port pin 11)
1 POUT Centronics paper out (pin 12)
2 SEL Centronics select (pin 13)
3 DSR RS232 data set ready (serial port pin 6)
4 CTS RS232 clear to send (pin 5)
5 DCD RS232 carrier detect (pin 8)
6 RTS RS232 request to send (pin 4)
7 DTR RS232 data terminal ready (pin 20)
----------------------------------------------------------------------------
$BFD100 PRB Peripheral Data Register for Data Port B
Status: R/W CIA-B
0 STEP Move drive head by one track in direction
specified by the DIR bit (set to 1, 0,
then 1 again to move head.)
1 DIR Direction to move drive head (1 = out to 0,
0 = in to track 79+)
2 SIDE Select drive head (1 = bottom, 0 = top)
3 SEL0 0 = Select DF0: 1 = not selected
4 SEL1 0 = Select DF1:
7 MTR Motor on/off status (1 = motor off,
0 = motor on)
Notes:
Bit 0: After moving the drive's head, it is important that you wait 3
microseconds before performing any other disk activities. Since software
timing loops will be shorter on accelerated Amigas, use the CIA timers.
Bit 1: You can check if the drive head of a selected drive is on track
0 by reading bit 4 of the CIA-A chip's PRA register located at $BFE001.
Bit 2: When you select the head, the value of this bit affects only
the currently selected drives.
Bits 3-6: You may select more than one drive at a time. Thus, you can
move the heads on more than one drive simultaneously.
Bit 7: This bit turns the motors on and off. The drive LED is
directly wired to the motor power. This bit should be set before you select
a drive. If a drive is already selected and you wish to change the state of
its motor, deselect the drive, set this bit, and then reselect the desired
drive.
When turning on the motor, you must wait for the motor to reach its
full rotation speed before performing any other disk activities. Bit 5 of
the CIA-A's PRA ($BFE001) is set equal to 0 whenever the drive has reached
full speed and is ready to receive another command.
Note that all of this assumes that you have disabled multitasking and
have taken full control of the computer.
----------------------------------------------------------------------------
$BFD200 DDRA Data Direction Register A
Status: R/W CIA-B
A bit set in this register causes the corresponding bit in PRA to be
defined as output. A bit clear causes it to be defined as input. Note that
bits 0-5 are normally clear, and bits 6-7 are set.
----------------------------------------------------------------------------
$BFD300 DDRB Data Direction Register B
Status: R/W CIA-B
This register controls the I/O of PRB. All bits MUST be set to 1.
----------------------------------------------------------------------------
Location Range: $BFD400 - $BFD700 CIA-B Timers A & B L/H Bytes
According to some early Commodore-Amiga manuals, Timer A is reserved for
Commodore 8-bit serial bus communications - the bus system used by the C64
to talk to the 1541, 1571, 1581, as well as C64 compatible printers. For
all practical purposes, the Amiga has no use for these timers. Timer B is
also unused by the operating system. Feel free to use them yourself. For
more details, see the entry for the CIA-A Timer A & B registers at $BFE401
through $BFE701.
$BFD400 TALO Timer A Low Byte. R/W

$BFD500 TAHI Timer A High Byte. R/W
$BFD600 TBLO Timer B Low Byte. R/W
$BFD700 TBHI Timer B High Byte. R/W
----------------------------------------------------------------------------
Location Range: $BFD800-$BFDB00 CIA-B TOD Counters
This 24 bit timer serves as a horizontal blank counter for the
graphics.library , and is used to synchronize the output of graphics with
the position of the video beam.
The CIA-B chip's TICK line is connected to the Agnus chip's _HSYNC line,
so the TOD clock's counter is incremented once every horizontal blank, or
31500 times per second.
$BFD800 TODLO TOD counter low byte R/W CIA-B (0-7)

$BFD900 TODMID TOD counter mid byte R/W CIA-B (8-15)
$BFDA00 TODHI TOD counter high byte R/W CIA-B (16-23)
$BFDB00 TODHR UNUSED - Not connected to the Amiga
-----------------------------------------------------------------------------
$BFDC00 SDR Serial Data Register
Status: R/W CIA-B
The CIA chip has an on-chip serial port, which allows you to send or
receive a byte of data one bit at a time, with the MSB (7) shifted out
first.
The CIA-B's SP line, which carries bits to the Serial Data Register, is
connected to bit 0 of this chip's data port A, and in turn, to pin 11 of the
parallel port. The chip's CNT line, which carries the bits that are output
by the Serial Data Register, is connected to bit 1 of this chip's Data Port
A, and in turn, to pin 12 of the parallel port.
For more information about the use of this register, see the entry for
location $BFEC01. The Amiga's operating system does not use this register.
----------------------------------------------------------------------------
$BFDD00 ICR Interrupt Control Register
Status: R/W CIA-B
0 R - did Timer A count down to zero? (1 = yes)
W - enable or disable Timer A IRQ (1 = enabled 0 = disabled)
1 R - did Timer B count down to zero? (1 = yes)
W - enable or disable Timer B IRQ (1 = enabled 0 = disabled)
2 R - did TOD clock reach alarm time? (1 = yes)
W - enable or disable TOD alarm IRQ (1 = en 0 = dis)
3 R - did the serial data register finish a byte? (1 = yes)
W - enable or disable serial data register IRQ (1/0 = en/dis)
4 R - was a signal sent on the FLAG line? (1 = yes)
W - enable/disable flag IRQ (1/0 = en/dis)
5 UNUSED - always returns a zero
6 UNUSED - always returns a zero
7 R - did any CIA-A source cause an interrupt? (1 = yes)
W - set or clear bits of this register. (1 = bits written to
with a 1 will be set, 0 = bits written with a 1 will be
cleared.)
This register is used to control the 5 interrupt sources on the 8520 CIA
chip. For details on its operation, see $BFED01.
The main difference between the two CIA chips pertaining to this register
is that on CIA-B, the FLAG line is connected to the disk controller's
DSKINDEX line. And in order for the Amiga to recognize a CIA-B chip
interrupt, bit 13 or the INTENA register must be set to 1. See registers
INTENA and INTENAR at $DFF09A and $DFF01C for more information on Amiga
interrupts.
----------------------------------------------------------------------------
Location Range $BFDE00 - $BFDF00 CIA Control Registers A & B
See locations $BFEE01 and $BFEF01 for details.
----------------------------------------------------------------------------
$BFDE00 CRA Control Register A
Status: R/W CIA-B
0 START Start Timer A (1 = start, 0 = stop)
1 PBON Select Timer A output on Data Port B (1 = Timer B
output appears on bit 6 for Data Port B)
2 OUTMODE Data Port B output mode (1 = toggle bit 6, 0 = pulse
bit 6 every 10 microprocessor cycles)
3 RUNMODE Timer A run mode (1 = one shot, 0 = continuous)
4 LOAD Force latched value to be loaded to Timer A counter
(1 = force load strobe)
5 INMODE Timer A input mode (1 = count signals on CNT line at
pin 1 of keyboard port, 0 = count every 10 uP cycles)
6 SPMODE Serial Port ($BFEC01) mode (1 = output, 0 = input)
7 UNUSED
----------------------------------------------------------------------------
$BFDF00 CRB Control Register B
Status: R/W CIA-B
0 START Start Timer B (1 = start, 0 = stop)
1 PBON Select Timer B output on Data Port B (1 = Timer B
output appears on bit 7 for Data Port B)
2 OUTMODE Data Port B output mode (1 = toggle bit 7, 0 = pulse
bit 7 every 10 microprocesor cycles(
3 RUNMODE Timer B run mode (1 = one shot, 0 = continuous)
4 LOAD Force latched value to be loaded to Timer B counter
(1 = force load strobe)
5-6 INMODE Timer B input mode
00 = count every 10 uP cycles
01 Count cycles on CNT line at pin 1 of keyboard port
10 Count each time that Timer A counts down to 0.
11 Count Timer A 0's when CNT pulses are present
7 ALARM Select TOD write status (1 = writing to TOD registers
sets counter, 0 = writing to TOD registers sets alarm)
----------------------------------------------------------------------------
Location Range $BFE001-$BFE301 CIA Data Ports A and B
These registers allow the Amiga to communicate with the outside world.
Bits of data written to the PRA and PRB registers ($BFE001 and $BFE101) can
be sent to external devices, while bits of data those devices send can be
read here.
A bit can be set up for only input or output, not both at once. To
define the I/O status of a bit, you use the Data Direction Registers.
Register DDRA ($BFE201) controls data port A, and register DDRB ($BFE301)
controls data port B. 1 = output mode, and 0 = input mode. Note that DDRA
is preset by the Amiga on power up. Modifying the contents may cause the
computer to lock up.
----------------------------------------------------------------------------
$BFE001 PRA Peripheral Data Register for Data Port A
Status: R/W CIA-A
0 OVL Memory overlay bit (Dont change! Keep 0)
1 LED Power LED/Cutoff filter (1 = LED dimmed and
cutoff filter inactive, 0 = LED/filter normal)
2 CHNG Disk Change (1 = no change, 0 = disk has
been removed)
3 WPRO 1 = Disk Write Protected 0 = Unprotected
4 TK0 1 = head not on trk 0, 0 = head on track 0.
5 RDY 1 = currently selected drive is ready for
commands, 0 = not ready.
6 FIR0 Fire button on port 1, pin 6 (0 = pressed)
7 FIR1 Fire button on port 2, pin 6 (0 = pressed)
Notes: On bits 6-7, you may also output data through pin 6 on either
game port. Simply set bit 6 or 7 (depending on which port you wish to
output data o) in the DDRA register to 1 for output and then toggle the same
bit in the PRA register. Setting the PRA bit to one outputs approximately 5
volts on that line. Setting the PRA bit equal to zero oulls the line low to
zero volts. It is common courtesy to set the data direction registers back
to their original value after using them.
----------------------------------------------------------------------------
$BFE101 PRB Peripheral Data Register for Data Port B
Status: R/W CIA-A
0 D0 Parallel port pin 2
Notes: This register is used exclusively by the Amiga's parallel port.

It controls the port's data lines, and is therefore responsible for all
parallel port transmissions.
For example, whenever the Amiga sends a character to a printer that's
connected to the parallel port, it uses this register. It just sets all the
bits in the DDRB equal to one and writes the byte of data to be output here.
----------------------------------------------------------------------------
$BFE201 DDRA Data Direction Register A
Status: R/W CIA-A
0 Select bit 0 PRA I/O (Must be 1 = Output)
1 1 1
2 2 0 = Input
3 3 0
4 4 0
5 5 0
6 6 (Normally 0)
7 7 (Normally 0)
----------------------------------------------------------------------------
$BFE301 DDRB Data Direction Register B
Status: R/W CIA-A
A bit set or clear here makes the corresponding bit in the PRB set for
output or input, respectively.
----------------------------------------------------------------------------
Location Range $BFE401 - $BFE701 CIA Timers A & B L/H Bytes
These four timer registers (two for each timer) have different functions
depending on whether you are reading from or writing to them. When you read
from these registers, you get the present value of the Timer Counter (which
counts down from its initial value to zero). When you write to these
registers, the value is stored in the Timer Latch, and from there it can be
used to load the Timer Counter using the LOAD bit of the CRA or CRB
registers (see $BFEE01 and $BFEF01).
These interval timers can hold a 16 bit value from 0 to 65535, in low
byte - high byte format. Once the Timer Counter is set to an initial value
and the timer is started, the timer will decrement every 10 uP cycles.
Since the clock speed of an NTSC Amiga is 7.159090 MHz, using every count
takes approximatels a millionth of a second. (10 / 7159090 =
0.0000013968256). The formula for calculating the amount of time it will
take for the timer to count down from its latch value to zero is:
Time = Latch Value / Count Speed
where Latch Value is the value written to the low and high timer registers,
and Count Speed is 715909 for NTSC, and 709379 for PAL.
When Timer A or B reaches 0, it will set bit 0 or 1 in the Interrupt
Control Register at $BFED01. If the timer interrupt has been enabled, an
interrupt will take place, and the high bit of the Interrupt Control
Register will be set to one. Alternately, if the PBON bit is set, the timer
will wirte data to bit 6 or 7 on Port B. After the timer gets to zero, it
will reload the Timer Latch value and either stop or count down again,
depending on whether it is in one-shot or continuous mode (determined by bit
3 of the Control Register).
Although usually a timer will be used to count every 10 uP cycles, Timer
A can also count external pulses on the CNT line, which is connected to the
Amiga's keyboard.
Timer B is even more versatile. In addition to these two sources, Timer
B can count the number of times that Timer A goes to zero. By setting Timer
A to count the uP clock, and Timer B to count the number of times Times A
reaches 0, you effectively link the two into one 32 bit timer that can count
for more than an hour before resetting.
In the Amiga, CIA-A Timer A is used to time the transfer of keyboard
data. Timer B is used by Exec (the core of the Amiga's multitasking
operating system) to synchronize task switching; it also serves as the
timer.device's UNIT_MICROHZ timer. As a result, neither Timer A or B is
available for general use.
----------------------------------------------------------------------------
$BFE401 TALO Timer A Low Byte
$BFE501 TAHI Timer A High Byte
$BFE601 TBLO Timer B Low Byte
$BFE701 TBHI Timer B High Byte
Status: R/W CIA-A
----------------------------------------------------------------------------
Location Range $BFE801 - $BFEB01 CIA-A TOD Counters
In addition to two general purpose timers, the 8520 CIA has a special
purpose 24-bit counter that can count up to 16777215 ($FFFFFF). Unlike the
chip's other two timers, the TOD clock counts up, and when the TOD clock
reaches its maximum value, starts over at zero and continues counting. The
TOD clock can also be set to generate an interrupt whenever it reaches a
determined value.
The TOD clock increments its counter approximately 60 times per second
(50 for PAL) - the same frequency as the computer's power line tick.
The TOD registers can be used for two purposes, depending on whether you
are reading from or writing to them. If you are reading from them, you will
always be reading the timer's current value. There is a latching feature
associated with the high byte register that freezes the other two bytes
until you read the low byte. This is to keep inaccurate readings from
occurring. (Note that the timer will not continue to count until you read
the low byte!)
Writing to these registers sets either the counter or alarm time
depending on the setting of bit 7 of Control Register B (CRB, $BFEF01). If
that bit is set to 1, writing to the TOD registers sets the alarm. If the
bit is set to zero, writing to the TOD registers sets the clock. In either
case, as with reading the registers, there is a latch function. This
function stops the clock from updating when you write to the high byte
register. The clock will not start again until you write to the low byte
register.
The CIA-A's TOD clock serves as the timer.device's UNIT_VBLANK timer.
Unlike the Timer A driven UNIT_MICROHZ clock (which is also used by Exec),
UNIT_VBLANK is not slowed down if the computer is running several programs
at once.
----------------------------------------------------------------------------
$BFE801 TODLO TOD Counter Low Byte
$BFE901 TODMID TOD Counter Mid Byte
$BFEA01 TODHI TOD Counter High Byte
$BFEB01 TODHR UNUSED - Not connected to the Amiga
Status: R/W CIA-A
----------------------------------------------------------------------------
$BFEC01 SDR Serial Data Register
Status: R/W CIA-A
The CIA chip has a built in serial port, which allows you to send or
receive a byte of data one bit at a time, with the MSB (7) shifted out
first. Control Register A at $BFEE01 allows you to choose input or output
modes. In input mode, a bit of data is read from the chip's SP line
whenever a signal on the CNT line appears. After 8 bits are received, and
the data has been placed in the SDR, an interrupt is generated to let you
know that the register should be read.
In output mode, you write data to the SDR, and it is sent out over the SP
line using Timer A for the baud rate generator. Whenever a byte of data is
written to using this register, transmission will start as long as Timer A
is running in continuous mode. Data is sent at half the Timer A rate, and
an output will appear on the CNT line whenever a bit is sent. After all 8
bits have been sent, an interrupt is generated to indicate that it is time
to load the next byte to send into the Serial Data Register.
The Amiga usus this register to receive data from the keyboard's KDAT
line (via pin 2 of the keyboard port), and the CNT line is connected to the
keyboard's KCLK line (via pin 1 of the keyboard port). Data is never sent
to the keyboard, so this register is always operating in input mode.
By reading this register directly, you can find the RAWKEY value of the
current key being pressed. A rawkey value specified the physical location
of the key on the keyboard. Normally, the Amiga's operating system reads
the value from the SDR and uses the computer's current keyboard map table
(such as USA1) to convert it to ASCII. Keymap tables are important because
different countries use different keyboard layouts. There are at least 15
different Amiga keyboard configurations in existance.
The number returned does not have the high bit (7) set during the key
press. However, when the key is released, bit 7 is set. Thus, a key's
release value is 128 greater than its depress value.
You should know the shift or control keys do not modify the rawkey
values. Instead, the shift or control keys send their own rawkey codes.
There are six special codes that can be sent via the SDR:
$78 - Control/Amiga/Amiga
$F9 - Ignore last character: transmission error
$FA - 10 character keyboard buffer is full
$FC - Keyboard self test failed
$FD - Header: Any following codes were keys pressed on power up
$FE - Termination code after the keys pressed on power up.
(i.e.: $FD xx xx ... $FE)
Using the console.device's RawKeyConvert() functiom, you can convert a
rawkey code to normal ASCII.
----------------------------------------------------------------------------
$BFED01 ICR Interrupt Control Register
Status: R/W CIA-A
Notes: Bit layout is the same as the ICR at $BFDD00. This register is
used to control the five interrupt sources on the 8520 CIA chip. These
sources are Timer A, Timer B, the TOD clock, the SDR, and the chip's FLAG
line. Timer's A & B cause an interrupt when they count down to zero. The
TOD clock generates an alarm when it reaches the alarm time. The SDR
generates an interrupt when it compiles 8 bits of input or output. An
external signal pulling the CIA chip's FLAG line low will also cause an
interrupt (on CIA-A, the FLAG line is connected to the ACK line - pin 10 of
the parallel port).
Even if the conditions for an interrupt are satisfied, the interrupt must
still be enabled for the interrupt to occur. This is done by writing to the
ICR. What happens when you write to this register depends on the way you
set bit 7. If it is set to 0, any bit you write to with a 1 is cleared. If
it is set to a 1, any bit that you write to with a 1 is set, and the
corresponding interrupt is enabled. In either case, any bits written to
with a zero will be unaffected.
For example, to disable all interrupts from machine language, you could
MOVE.B #$7F,$BFED01. Don't try this with multitasking turned on, as it will
turn off Timer B, which handles task switching.
To turn on a Timer B interrupt, a program could MOVE.B #$82,$BFED01. Bit
7 is set to 1, and so is bit 1, so the interrupt which corresponds with bit
1 (Timer B) is enabled.
When you read this register, you can tell if any of the conditions for a
CIA interrupt were satisfied because the corresponding bit will be set to a
one. For example, if Timer A counter down to zero, you would read a #$01
from this register. If in addition the enable bit that corresponds to that
interrupt source is set to 1 and an interrupt occurs, bit 7 will also be
set. This allows a multi-interrupt system to read one bit and see if the
source of a particular interrupt is CIA-A. You should note, however, that
reading this register clears it, so you should preserve its contents if you
want to test more than one bit. In order for the Amiga to recognize a CIA-A
chip interrupt, bit 3 of the INTENA register must be set to 1. See
registers INTENA and INTENAR ($DFF09A, $DFF01C) for more information.
----------------------------------------------------------------------------
$BFEE01 CRA Control Register A
$BFEF01 CRB Control Register B
Status: R/W CIA-A
See $BFDE00 and $BFDF00 for information on the bit layout.
----------------------------------------------------------------------------
This completes "Mapping the Amiga" from Compute! Books. For information
on system structures, examine your C and assembler Include files. They
have much better information than the book.
Slates from Bansai
05/26/91
----------------------------------------------------------------------------
Want more cool warez call Spectral Forces 203.327.4104 <<<SPELLJAMMER WHQ>>>

Mapamiga

Uploaded by

Copyright:

Available Formats

Mapamiga

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Mapamiga

Uploaded by

Copyright:

Available Formats

"Mapping the Amiga" by Rhett Anderson and Randy Thompson.

Aware of the problems of scale and flexibility, we set out to accomplish a

How to Use This Book:

Programming and Mapping:

Rhett & Randy

For a real-world example, the following machine language program makes

* Hard-coded function offsets

AbsExecBase equ 4 ;Absolute location of ExecBase pointer

XREF printf ;Declaration for amiga.lib function

* Short-but-effective startup code

* Main program that adds Num1 and Num2

* Close DOS library

dc.l 8723 ;Value 1 that will be added to

* The following statements define the format string to be used by printf( )

Table 1 1. Library Version Numbers

Table 1-2. Library Names

In C and Modula-2 use:

C code that opens a window and waits for you to close it

#include <intuition/intuition.h> /* Include Intuition stuff */

struct IntuitionBase *IntuitionBase = NULL; /* Define IntuitionBase */

/* Wait for user to click close box */

CloseWindow(MyWindow); /* Close window */

*Open a window and wait for user to close it

*Include Intuition stuff

*Address that holds pointer to ExecBase (this is ALWAYS 4)

* Hard-coded function offsets-no need to link with amiga.lib with these!

Wait equ -318

*Wait for user to click close box

*Close the window

*Exit the program

FROM Intuition IMPORT NewWindow, WindowFlagSet, WindowFlags, IDCMPFlags,

(* Setup NewWindow structure *)

(* Try to open window *)

IF myWindowPtr # NIL THEN

OpenWindow equ -552

move.l _IntuitionBase,a6 ;Pointer to IntuitionBase in a6

move.l _IntuitionBase,a6 ;Pointer to IntuitionBase in a6

-------------------------Functions Start Here-------------------------

Arguments: window = window to receive gadgets

C: long BltBitMap(struct BitMap *, long, long, struct BitMap *,

Arguments: memBlock = memory to clear (must start on a word boundary)

Result: success = TRUE if successful; FALSE if screen not available

Machine Language: InitResident(a1, d1)

Machine Language: RefreshGadgets(a0, a1, a2)

Modula-2: RemoveGList(window: WindowPtr; gadget: GadgetPtr;

Arguments: destinationString = address of string to receive output

The Amiga's hardware is accessed via registers- locations within a chip

Warning: You should never attempt to read a write-only register. Doing so

SET/CLR Bit: Some registers contain a bit labeled "SET/CLR". This is a

Notes: The Amiga's hardware is capable of generating 14 interrupts on seven

If you plan on handling interrupts completely on your own, note that

00011000 00011000 11111111

00011000 00001000 11110111

General Guidelines: When programming the blitter at the hardware level

Here's how BLTCON0's bits operate in normal copy mode:

Bit 8: This bit determines whether the blitter's destination DMA is

Bits 9-10: These bits determine which of the blitter's sources: A, B,

Bits 12-15: Prior to applying the value of source A to the selected

Line Mode - Here's how the register functions in line mode:

struct IntuitionBase IntuitionBase = NULL; / Define IntuitionBase */

C: long BltBitMap(struct BitMap , long, long, struct BitMap ,