Preview
_____ _________________________________
/ /\ / \
/ / / / ___________________________ \
/ / / / / _________________________/\ \
/ / / / /_/___________ _____ \ \ \
/ / / / \ /\ \ \ \ \
/ / / /_________________ \ \ \ \ \ \ \
/ / / \________________/\ \ \ \ \ \ \ \
/ /_/__________________________\_\ \ \ \ \___\/ \
/ \ \ \ /
/____________________________________________\ \ \____________/
\____________________________________________/ \/___________/FISH
P R E S E N T
AMIGA MACHINE LANGUAGE - FROM ABACUS BOOKS
P A R T I I
Typed by DEE JAY of X-CELL for LSD
CHAPTER 5.
---------
5.Hardware Registers.
--------------------
You can get information about hardware functions without using
library functions.You can use the hardware registers instead.These
are memory locations at particular addresses that are neither in
RAM nor in ROM.They are direct interfaces between the processor
and its peripheral devices.
Each device has a number of hardware registers that the processor
accesses to control graphics,sound and input/output.There are lots
of possibilities for assembly language programmers.We'll only be
able to go into a few examples.
The registers are generally used in byte-wise fashion.You'll find
an example in the next chapter.
5.1.Checking For Special Keys.
-----------------------------
Load AssemPro and enter the debugger,select "Parameter-Display-
From-Address"and enter $BFEC00.Next select "Parameter-Display-Hex
-Dump"to display the memory.(To use the SEKA assembler or a similar
monitor program,enter "q $bfec00".)
Yoy'll see a byte-wise listing of the addresses starting at
$BFEC00 in which two bytes always repeat.These two bytes represent
the status of the two hardware registers.
The mirroring occurs because not all the address bits are used in
decoding the address.In addressing this register,only the upper
two bytes of the address and the low bit,bit 0,are used.The
address of the two registers goes like this:$BFECxx,where the
lower address byte xx doesn't contain any information in bits 1-7.
Only bit 0 contains information about the desired register.You'll
find this odd form of addressing with most hardware registers.
Let's look at the information in these registers.Let's look at the
second register,$BFEC01.Hold down the<ALT>key and select"Parameter
-Display-HEX-Dump"to redisplay the screen.(SEKA owners must enter
"q $bfec00"and press the<ALT>key right after pressing the<Return>
key.)You'll see that contents of every two bytes($BFEC01,$BFEC03,
etc...)have been changed to $37.This is the status of the special
keys.This is also true for the other special keys.The following
keys produce the bytes:
Shift left $3F
Shift right $3D
Control $39
Alternate $37
Amiga left $33
Amiga right $31
You can use this register to have a machine language program check
if one of these keys was pressed and then respond by calling or
ending a function.A program section might look like this:
skeys=$bfec01
...
cmp.b #$37,skeys ;Alternate pressed?
beq function1 ;Yes!
cmp.b #$31,skeys ;or right Amiga?
beq function2 ;Yes!
... ;and so on...
5.2.Timing.
----------
If you want to find out how much time elapsed between two events,
you can use a hardware register to keep track of time quickly and
precisely.The Amiga contains just such a timekeeper:the I/O port
componant.The chip has a 24 bit wide counter that has a 60 Hertz
clock.
These 24 bits can't be read at once,for instance with a MOVE.L
command,because the register is divided into three bytes.The low
byte is at address $BFE801,the middle at $BFE901,and the high byte
with bits 16-23 at $BFEA01.
Here's an example of a way to use this register:finding out how
long a subroutine takes to run.
test:
bsr gettime ;put current time in D7
move.l d7,d6 ;save it in D6
bsr routine ;routine to be timed
bsr gettime ;get the time again
sub.l d6,d7 ;elapsed time in
... ;1/50 seconds in D7!
nop ;set break point here to stop
routine: ;test routine
move #500,d0 ;delay counter
loop:
dbra d0,loop ;count down
rts
gettime:
move.b $bfea01,d7 ;hi-byte in D0
lsl.l #4,d7 ;shift twice by 4 bits
lsl.l #4,d7 ;(8 bits shifted)
move.b $bfe901,d7 ;get mid-byte
lsl.l #4,d7
lsl.l #4,d7 ;shift again
move.b $bfe801,d7 ;get the lo-byte
rts ;done
5.3.Reading The Mouse-Joystick.
-------------------------------
There are two hardware registers for the mouse and the joystick.
They contain the state(or the position)of these input devices.Its
interesting that the same port is used with both the mouse and the
joystick even through they work completely different.
The joystick as four switches that are closed during movement and
give off a potential(-)that is related to the movement of the
joystick/mouse.The mouses movements give off lots of quick signals
-two for horizontal and two for vertical movements.
The computor must keep an eye on the ports so that it can evaluate
the signals and calculate the new mouse position.This isn't the
work of the processor though;it already has too much to do.
You find the status of the mouse/joystick port at address $DFF00A
for port 1 and $DFF00C for port 2.The information in these words
is for vertical mouse movement in the lower byte and for
horizontal movement in the upper byte.
AssemPro owners be careful!Don't read these addresses,because for
some reason that causes the computor to crash.This looks
interesting(the screen begins to dance)but you can only recover by
pressing <RESET>and losing all your data.
To read this register,lets write a short program:
;(5.3A) mouse
test:
jsr run ;test subroutine
jmp test ;continue until broken
nop ;breakpoint here
joy= $dff00a
run:
move joy,d6 ;data item 1 in D6
move joy+2,d7 ;data item 2 in D7
jmp run ;rts for SEKA and other
end
If you assemble the program and start breakable in the debugger
(SEKA-"j run"),D6 and D7 contain the contents of the two registers
Move the mouse a bit and watch the register contents.
As you see,the value in D6 is different.If you just move the mouse
horizontaly,only the upper bytes value is different,if just moved
vertically only the upper byte is different.
You are not getting the absolute position of the mouse pointer on
the screen.You can see that easily by moving the mouse in the
upper left corner,then reading the value by restarting the program
and moving the mouse left again.As you can see,the registers
contents are always relative.
Change the program as follows:
;(5.3B) mouse difference
test:
jsr run ;test subroutine
jmp test ;continue until broken
nop ;breakpoint here
joy= $dff00a
run:
move d7,d6 ;old position in D6
move joy,d7 ;new position in D7
sub d7,d6 ;difference in D6
jmp run ;rts for SEKA and other
end
Start Breakable(right-Amiga-A)in the AssemPro debugger and watch
D6,the result is zero or D7.(SEKA owners have to start the program
two times.The result in D6 is zero.)If you move the mouse,D6
contains the difference between the old and new positions since
the start.You'll find the vertical and horizontal positions of the
mouse relative to the last time you looked.In this way,you can use
this register to find the relative mouse movement between two
checks.
Now to check the joysticks.Put a joystick in port 2 and change the
address $DFF00A to $DFF00C in the program.Start Breakable in the
AssemPro debugger and watch D6,the result is zero or D7.(SEKA
owners have to start the program two times.The result in D6 is
zero.)
Move the joystick up.You'll get the value $FF00.One was subtracted
from the upper byte.Let the joystick loose.This time you get the
value $100-one is added.You'll get the same effect if you move the
joystick left-after you let go,one is subtracted.
The individual movements and their effects on the joystick program
are:
UP $FF00 HI-BYTE -1
DOWN $FFFF LO-BYTE -1
LEFT $0100 HI-BYTE +1
RIGHT $0001 LO-BYTE +1
These values aren't terribly reliable.If you move the joystick a
lot and then look at the value,you'll find a crazy value in D6.
This is because the input driver thinks that a mouse is attached.
Nevertheless,this is the quickest way to read a joystick.In this
way,an external device that gives off evaluatable TTL signals can
be connected to the port and watched by a machine language
program.
Now you just need to find out whether the fire button has been
pressed,and you'll know how to get all the information you need
from the joystick.The buttons state is in bit 7 of the byte that
is in memory location $BFE001.If the bit is set,the button was'nt
pressed.That's true for the joystick connected to port 2.Bit 6 of
this byte contains the buttons state when the joystick is in port
1 or the state of the left mouse button.
Let's stay on port 2.You can test bit 7 to execute a function when
the joystick button is pressed without any problems.Bit 7 is the
sign bit.You can use this program segment:
tst.b $bfe001 ;was fire button 2 hit?
bpl fire ;yes!branch
The TST.B instruction tests the addressed byte and sets the Z and
the N flag.If the N flag is set,you know that bit 7 of the tested
byte is set.Since the fire button turns on LO potential,the bit is
erased when the button is pressed.The N flag works that way with
the TST command as well.The BPL command in the program above
branches if the button was pressed.The PL stands for plus and is
set when the sign bit is cleared.
Here is the complete program to check the fire button and joystick
difference:
;(5.3C) fire button and joy difference
test:
jsr run ;test subroutine
tst.b $bfe001 ;was fire button 2 hit?
bpl fire ;yes! branch
jmp test ;continue until broken
joy = $dff00a
run:
move d7,d6 ;old position in D6
move joy,d7 ;new position in D7
sub d7,d6 ;difference in D6
jmp run ;rts for SEKA and other
fire:
nop ;breakpoint here
end
5.4.Tone Production.
-------------------
It's fun to make noises and sounds.The Amiga lets you use Audio
Devices and various I\O structures to play tones,noises and/or
music pieces in the background.You'll leave this method to C or
Basic programmers,since you can use short machine language
programs to directly program the audio hardware.
The Paula chip has all the capabilities needed for tone production
This chip can be accessed using the hardware registers of the
processor.No library of any high level language can do more than
you can-program the chip.
How does it work?Since the disk uses Direct Memory Access(DMA)to
get information,you just need to tell it where to look for the
tone or tone sequences that you would like played.You also need to
tell it how to interpret the data.
Lets start with the easiest case-producing a constant tone.A tone
like this consists of a single oscillation that is repeated over
and over.If you make a diagram of the oscillation,you see the wave
form of the oscillation.There are several standard waves: sine,
square,triangle and saw tooth.The simplest is the square wave.
To produce a square wave,you just need to turn the loud speaker on
and off.The frequency that occurs here is the frequency of the
tone.
You want to produce such a tone using the Amiga.First you need to
make a table that contains the amplitude of the tone you wish to
produce.For a square wave,you only need two entries in the table,a
large and a small value.Since the sound chip in the Amiga has
amplitude values between -128 and +127,our table looks like this:
soundtab:
dc.b -100,100
You need to give the address of the table to the sound chip.You
have four choices,since the Amiga as four sound channels.The
address of the hardware register in which the table address for
channel 0 must be written is $DFF0A0;for channel 1 it is $DFF0B0;
for channel 2 its $DFF0C0;for channel 3 its $DFF0D0.For stereo
output,channels 0 and 3 control the left loud speaker.Channels 1
and 2 control the right loud speaker.For example,choose channel 0
and write the following:
move.l #soundtab,$DFF0A0 ;address of the table
Next you need to tell the sound chip how many items there are in
the table.The data is read from beginning to end and sent to the
loud speaker.Once it reaches the end,it starts over at the
beginning.Since the sound chip gets this one word at a time,even
though the data is in bytes,the table must always have an even
number of bytes.The length that you give it is the number of words
the number of bytes/2.
You put the length for channel 0 in the register at address
$DFF0A4(for channel x just add x*$10!):
move #1,$dff0a4 ;length of table in words
Now you have to tell it how quickly to read the data and output it
to the loud speaker.This word determines the frequency.However,it
does this "backwards".The larger the value,the lower the frequency
Choose the value 600 for this example:
move #600,$dff0a6 ;read in rate
Now you need to decide the loudness level for the tone or noise.
You have 65 different levels to choose from.Lets choose the middle
value 40 for our example:
move #40,$dff0a8 ;loudness level
Thats the data that the sound chip needs to produce the tone.
However nothing happens yet.What next?The chip can't tell if the
data thats in the registers is valid,so it doesn't know if it
should use the data.
You need to work with the DMA control register at address $DFF096
to let it know.You only need six bits of this word for your
purposes:
Bit 15 ($8000) If this bit is set,every bit that is written to
this internal register is set.Otherwise the bits
are erased.Zero bits aren't affected.This is very
useful because this word also contains DMA
information for disk operations that should'nt be
changed.
Bit 9 ($200) This bit makes it posible for the chip to access
DMA memory.If you want to start playing the tone,
you need to set this bit.
Bit 0-3 Turn channel 0-3 on when bits are set.
You'll start your tone by setting bits 15,9 and 0:
move #$8000+$200+1,$dff096 ;start DMA
Heres an example of tone production-this time with tone using a
sine wave:
;**Sound Generation using hardware registers** (5.5A)
ctlw = $dff096 ;DMA control
cothi = $dff0a0 ;table address HI
c0tlo = $c0thi+2 ;table address LO
c0tl = $c0thi+4 ;table length
c0per = $c0thi+6 ;read in rate
c0vol = $c0thi+8 ;loudness level
run: ;*Produce a simple tone
move.l #table,c0thi ;table beginning
move #8,c0tl ;table length--8 words
move #400,c0per ;read in rate
move #40,c0vol ;loudness level (volume)
move #$8201,ctlw ;DMA/Start sound
rts
data ;>500K place in CHIP memory
table: ;sound table:sine
dc.b -40,-70,-40,0,40,70,40,0
end
To test this subroutine,use AssemPro to assemble the routine,save
the program and load it into the debugger.Next set a breakpoint at
the RTS,to set the breakpoint in AssemPro select the correct
address with the mouse and press the right-Amiga-B keys.Start the
program and listen to the tone.You need another routine to turn
the tone off,turn your sound down for now.
To turn the tone off,you just need to erase bit 0 of the DMA
control register.To do this,you just need to write a 0 in bit 15
and all the set bits in this register are erased.To erase bit 0,
just write a one to the memory location:bit 15=0=> bit 0 is erased
Heres a small routine to stop the tone coming from channel 0:
still: ;*turn off tone
move #1,ctlw ;turn off channel 1
rts
Now lets use the routine in a program to produce a short peep tone
that you culd,for instance,use as a key click:
;** Producing a Peep Tone **
ctlw = $dff096 ;DMA control
c0thi = $dff0a0 ;HI table address
c0tlo = $c0thi+2 ;LO table address
c0tl = $c0thi+4 ;table length
c0per = $c0thi+6 ;read in rate
c0vol = $c0thi+8 ;volume
beep: ;*Produce a short peep tone
move.l #table,c0thi ;table beginning
move #8,c0tl ;table length
move #400,c0per ;read in rate
move #65,c0vol ;volume
move #$8201,ctlw ;Start DMA (sound)
move.l #20000,d0 ;delay counter
loop:
dbra d0,loop ;count down
still:
move #1,ctlw ;turn off tone
rts
table:
dc.b 40,70,90,100,90,70,40,0,-4,0
end
You can play upto four tones at the same time in such a way that
they are independant of each other.The Amiga also offers another
method of making the sound more interesting:you can modulate the
tone.
Lets produce a siren tone.You could do this by figuring out the
entire sequence and programming it.However,as you can well imagine
thats a lot of work.
Its much easier to use two tone channels.Lets use channel 1 for
the bass tone and channel 0 for its modulation.Channel 0 needs to
hold the envelope of the siren tone.It needs to give the expanding
and contracting of the tone at the right speed.
You then have two ways that you can have channel zero work with
channel one.You can control the volume via channel 0,the read in
rate(frequency),or both.For our example,you'll use frequency
modulation.
Change the program as follows:
;** Modulated sound generation via hardware registers **
ctlw = $dff096 ;DMA control
adcon = $dff09e ;Audio/Disk control
c0thi = $dff0a0 ;HI table address
c0tlo = c0thi+2 ;LO table address
c0tl = c0thi+4 ;table length
c0per = c0thi+6 ;read in rate
c0vol = c0thi+8 ;volume
run:
move.l #table,c0thi+16 ;table start for channel 1
move #8,c0tl+16 ;table length--8 words
move #300,c0per+16 ;read in rate
move #40,c0vol+16 ;volume
move.l #table2,c0thi ;table start for channel 0
move #8,c0tl ;table length
move #60000,c0per ;read in rate
move #30,c0vol ;volume
move #$8010,adcon ;modulation mode:FM
move #$8203,ctlw ;start DMA
rts
still: ;*Turn Off Tone
move #$10,adcon ;no more modulations
move #3,ctlw ;turn off channels
rts
table: ;data for basic tone
dc.b -40,-70,-90,-100,-90,-70,-40,0
dc.b 40,70,90,100,90,70,40,0
table2: ;data for modulation
dc.w 400,430,470,500,530,500,470,430
end
When you start the program,you'll here a siren.You can change this
tone to your hearts content.
Did you notice the added "adcon"register.This register controls
the modulation of the audio channel as well as handling disk
functions.The same technique is used here as for the DMA control
register,bits can only be set if bit 15 is.As a result,you don't
have to worry about the disk bits.I'd recommend against
experimentation.
Control bit 15 isn't the only one of interest to you.You can also
use bits 0-7,because they determine which audio channel modulates
another channel.There is a restriction,though.A channel can only
modulate the next higher numbered channel.For this reason you use
channel 1 for the basic tone and channel 0 for the modulation in
the example.You can't for example,modulate channel three with
channel zero.Channel 3 can't be used to modulate any other
channel.
Here is an overview of bits 0-7 of the "adcon"register.
Bit Function
-----------------------------------------------------------------
0 Channel 0 modulates the volume of channel 1
1 Channel 1 modulates the volume of channel 2
2 Channel 2 modulates the volume of channel 3
3 Turn of channel 3
4 Channel 0 modulates the frequency of channel 1
5 Channel 1 modulates the frequency of channel 2
6 Channel 2 modulates the frequency of channel 3
7 Turn off channel 3
In the example,you set bit 4,which put channel 0 in charge of
channel one's frequency modulations.
When you've chosen a channel for use in modulating another channel
some of the parameters of the channel change.You don't need to
give volume for this channel,so you can omit it.Now the tables
data is looked at as words instead of as bytes.These words are
read into the register of the modulated register at a
predetermined rate.The Read in Rate Register determines the rate.
If you want to modulate the frequency and the volume of another
channel,(In the example,set bits 0 and 4 of "adcon"),the data is
interpreted a little differently.The first word in the table is
the volume,the second is the read in rate,and so on.It alternates
back and forth.In this way,you can for instance,produce the siren
tone.
5.5.Hardware Registers Overview.
-------------------------------
The following tables should give you an overview of the most
important hardware registers.Theres not enough room to describe
each register,so I'd recommend getting a hold of the appropriate
literature.If you experiment with these registers,you should keep
in mind that this can cause the computor to crash.Save your data
to disk and then take the disk out of the drive,because you might
cause the disk drive to execute some wierd functions.
Lets start with the PIA's.This covers the PIA type 8520.You should
keep in mind that some functions and connection of the 8520 are
integrated into the Amiga and so there are limitations on what you
can do with the PIA's.
PIA A PIA B Registers Meaning
------------------------------------------------------------------
BFE001 BFE000 Data register A
BFE101 BFE100 Data register B
BFE201 BFE200 Data direction register A
BFE301 BFE300 Data direction register B
BFE401 BFE400 Timer A LO
BFE501 BFE500 Timer A HI
BFE601 BFE600 Timer B LO
BFE701 BFE700 Timer B HI
BFE801 BFE800 Event register Bits 0-7
BFE901 BFE900 Event register Bits 8-15
BFEA01 BFEA00 Event register Bits 16-23
BFEB01 BFEB00 Unused
BFEC01 BFEC00 Serial data register
BFED01 BFED00 Interrupt control register
BFEE01 BFEE00 Control register A
BFEF01 BFEF00 Control register B
Some internal meanings:
$BFE101 Data register for parallel interface
$BFE301 Data direction register for the parallel interface
$BFEC01 State of the keyboard,contains the last special key
pressed(Shift,Alternate,Control,Amiga)
Now come the registers that are used for tone production.The first
two registers should be treated especially carefully-if they are
used wrong,very nasty effects can occur.
These registers can be either read or written only.This
information is included under R/W in the table.
Address R/W Meaning
------------------------------------------------------------------
DFF096 W Write DMA Control
DFF002 R Read DMA Control and Blitter Status
--Audio Channel 0--
DFF0AA W Data register
DFF0A0 W Pointer to table beginning Bits 16-18
DFF0A2 W Pointer to table beginning Bits 0-15
DFF0A4 W Table length
DFF0A6 W Read in Rate
DFF0A8 W Volume
--Audio Channel 1--
DFF0BA W Data register
DFF0B0 W Pointer to table beginning Bits 16-18
DFF0B2 W Pointer to table beginning Bits 0-15
DFF0B4 W Table length
DFF0B6 W Read in Rate
DFF0B8 W Volume
--Audio Channel 3--
DFF0CA W Data register
DFF0C0 W Pointer to table beginning Bits 16-18
DFF0C2 W Pointer to table beginning Bits 0-15
DFF0C4 W Table length
DFF0C6 W Read in Rate
DFF0C8 W Volume
--Audio Channel 4--
DFF0DA W Data register
DFF0D0 W Pointer to table beginning Bits 16-18
DFF0D2 W Pointer to table beginning Bits 0-15
DFF0D4 W Table length
DFF0D6 W Read in Rate
DFF0D8 W Volume
Now for the registers that contain information about the joystick,
mouse or potentiometer.These addresses have been gone over in part
previously.
Address R/W Meaning
------------------------------------------------------------------
DFF00A R Joystick/Mouse Port 1
DFF00C R Joystick/Mouse Port 2
DFF012 R Potentiometer pair 1 Counter
DFF014 R Potentiometer pair 2 Counter
DFF018 R Potentiometer connection
DFF034 W Potentiometer port direction
Chapter 6
---------
6.The Operating System.
-----------------------
Now lets take a step forward in your ability to write assembly
language programs.Its not enough to put a piece of text in memory
someplace.You want to be able to put it on the screen.Do you know
how to write a character on the screen?Do you know how to draw a
window on the screen that can be modified by the mouse?Actually
you don't have to have terribly precise knowledge about such
topics.
Fortunately,the Amigas operating system supplies routines that
take care of common tasks like this.It can seem quite complicated
due to the number of routines necessary.These routines are in
libraries.We'll look at the libraries in some depth now.
6.1.Load Libraries.
-------------------
Before you can use a library,it must be available.It has to be
loaded into memory.Unfortunately,the whole library must be loaded,
even if you only need one of the functions.
First you need to decide what the program must be able to do,so
you can see which libraries you'll need.For simple I/O text,you
don't need a library that contains routines for moving graphics!
There are a number of libraries onj a normal Workbench disk.Heres
an overview of the names and the sort of functions they do:
Exec.Library;
This library is needed to load the other libraries.It is already
in memory and doesn't need to be loaded.Its in charge of basic
functions like reserving memory and working with I/O channels.
Dos.Library;
Contains all the functions for normal I/O operations,for instance
screen or disk access.
Intuition.Library;
Used for working with screens,windows,menus,etc...
Clist.Library;
This contains routines for working with the Copper lists that are
used for controlling the screen.
Console.Library;
Contains graphics routines for text output in console windows.
Diskfont.Library;
Used for working with the character fonts that are stored on the
disk.
Graphics.Library;
This library contains functions to control the Blitter(or graphics
)chip.Its used for basic graphics functions.
Icon.Library;
Used in the development and use of workbench symbols(icons).
Layers.Library;
Used for working with screen memory (layers).
Mathffp.Library;
Contains basic math floating point operations.
Mathieeedoubbas.Library;
Contains basic math functions for integers.
Mathtrans.Library;
Contains higher level mathmatical functions.
Potgo.Library;
Used for evaluating analog input to the Amiga.
Timer.Library;
Contains routines for time critical programs.They can be used to
program exact time intervals.
Translator.Library;
Contains the single function "Translate",that translates normal
text written phonetically for the narrator,the speech synthesisor.
You can open(load)all these libraries of course.You should
remember that this takes time and memory.For this reason,you
should always think about which functions you need and which
libraries they are in.
For example,lets say you want to write a program that does text
input/output.You need the "Dos.Library",so it can be loaded.
The "exec.library"is in charge of loading.This library contains
the OpenLib function that can be called once you've passed the
needed parameters.AssemPro Amiga includes all the libraries
necessary for the Amiga,it also includes files that contain the
offsets for the operating system calls.The macros contained in
AssemPro ease assembly language programming considerably.To make
the programs in this book useful to the largest audience the
following examples are written for generic assemblers and do not
include AssemPro's macros.We have used the AssemPro ILABEL and the
macros INIT_AMIGA and EXIT_AMIGA so AssemPro owners can start the
programs from the desktop.(If you are using a different assembler
check your documentation for instructions on linking programs).
6.2.Calling Functions.
----------------------
Since this chapter is rather complex we'll first describe the
fundamental routines necessary to use the Amiga's operating system
after a description a complete program is listed.Every library
begins in memory with a number of JMP commands.These JMPs branch
to the routines that are in the library.To call a function,you
need to find the beginning of this JMP table and call function x
by going to the xth JMP command.Usually you use an offset to get
to the right JMP command.Normally,you don't start at the beginning
but at the end of the JMP table,so use negative offsets.
It works out very easily.Now lets open the "dos.library"by using
"exec.library's"base address.This address is $000004.To call a
fuction from another library,you need to use another base address.
Now you need the offset for the function that you want.You want
the OpenLib function that has -408 as an offset.You'll find a list
of function offsets in the appendix.
You need a pointer to the name of the library you are loading for
the OpenLib function(in this case "dos.library")and a long word in
memory that you can use to store the base address of the DOS
library.You get this back from the OpenLib function.You need to be
sure to write the library name in lower case letters(dos.library),
otherwise you can't open it.I entered a name in capitol letters
once and spent a lot of time finding this error.
The routine looks like this:
;** Load the DOS library 'dos.library' (6.2A) **
Execbase = 4 ;base address of the EXEC library
OpenLib = -408 ;offset for the OpenLib function
IoErr = -132 ;offset for IoErr information
init:
move.l Execbase,a6 ;base address in A6
lea dosname,a1 ;address of library name
moveq #0,d0 ;version number
jsr OpenLib(a6) ;open DOS library
move.l d0,dosbase ;save DOS base address
beq error ;if zero,then error!
... ;your program goes here
... ;more program...
error: ;error
move.l dosbase,a6 ;address of library name
jsr IoErr(a6) ;call IoErr for error info
move.l d0,d5
... ;your error routine goes here
rts
dosname: ;name of library to open
dc.b 'dos.library',0,0
align ;SEKA uses-even
dosbase: ;storage for DOS base address
blk.l 1
end
This is the way to load the DOS library so that you can use it.All
library functions are called this way.Parameters are put in
registers and passed to the function.When there is an error,when
the function doesn't run correctly,a zero is usually put in data
register D0.
Once your program is done with its work,you need to close the
libraries that are still open before you return to the CLI or
Workbench.The CloseLib function (offset -414)takes care of this
job.This function is in the EXEC library just like the OpenLib.The
only parameter it needs is the base address of the library that is
closed.To close "dos.library",do the following:
CloseLib = -414 ; (6.2B)
...
move.l Execbase,a6 ;EXEC base address
move.l dosbase,a1 ;DOS base address
jsr CloseLib(a6) ;close library
6.3.Program Initialization.
---------------------------
Before you can start a program,you need to initialize many things
so that the program can run.
Lets take an example program that does some text editing.A program
like this must be able to store text,so it needs to be able to
access memory.It also needs to be able to accept keyboard input
and do screen output,so it needs an output window.
To do this,you need to open one or more of the libraries that we
talked about earlier.Lets assume that you've loaded the DOS
library,so that you can do the next steps.
6.3.1.Reserve Memory.
---------------------
There are several ways to get the operating system to assign you a
chunk of memory.You need to use one of them,so that during multi-
tasking,you don't have one program overwriting another programs
memory area.
Lets look at the function that is normally used.This function is
in the resident EXEC library and has the name AllocMem (offset
-$c6).It reserves a memory area,using the value in D0 as the
length.The address that the memory area begins at is returned in
the D0 data register.If it returns zero,the program could'nt give
you that much memory.
You can also use a mode word in D1 to determine whether the memory
area that is reserved should be erased or not.
The routine looks like this:
ExecBase = 4 ; (6.3.1A)
AllocMem = -$c6
...
move.l #number,d0 ;number of bytes to reserve
move #mode,a6 ;mode word
move.l ExecBase,a6 ;DOS base address in A6
jsr AllocMem(a6) ;call function
move.l d0,address ;save memory's start address
beq error ;memory not reserved
...
The second way to reserve memory is to use the AllocAbs function
(offset -$CC).This function in contrast to the AllocMem function
reserves a particular memory area.The D0 register contains the
number of bytes that should be reserved.Address register A1
contains the desired start address.This function returns a zero in
D0 if the memory area can't be reserved.
ExecBase = 4 ; (6.3.1B)
AllocAbs = -$cc
...
move.l #number,d0 ;number of bytes to reserve
lea address,a1 ;desired start address
move.l execbase,a6 ;EXEC base address
jsr AllocAbs(a6) ;reserve memory
tst.l d0 ;everything ok?
beq error ;no!
...
When the program has done its work and must return to the CLI or
the Workbench,it needs to return the memory it as reserved to the
system.The FreeMem function (offset -$D2) handles this.
The function works like AllocAbs in that the number of bytes is
put in D0 and the start address of the memory area is put in A1.
If you try to free up a memory area that was'nt reserved,you'll
usually crash the computor.
The routine to free up a memory area looks like this:
ExexBase = 4 ; (6.3.1C)
FreeMem = -$d2
...
move.l #number,d0 ;number of bytes released
lea address,a1 ;start address from AllocAbs
move.l ExecBase,a6 ;ExecBase address
jsr FreeMem(a6) ;free up memory
tst.l d0 ;everything ok?
beq error ;no!
...
6.3.2.Opening a Simple Window.
------------------------------
The title of this chapter may sound a bit strange.However,the
differences between the two different methods of opening a window
are so great that they should be handled in seperate chapters.
The method of opening a window presented here is very simple,but
it doesn't allow you to work with all the gadgets.These gadgets
include the close symbol in the upper left corner of a window and
the size symbol in the lower left corner.
If you open the window in the simple manner,almost all the gadgets
are present.However,the close symbol is not.As a result,this
method isn't appropriate for every application.Now lets look at
the method.
To open a window,use a function from the DOS library,so you need
to open the library first (see the section "Load Library").This
open function is an all purpose function that can be used for many
things.For this reason,it makes good sense to put a "open"
subroutine in your program.You can use it a lot.Lets do the basic
steps:
;** Load the DOS Library 'dos.library' (6.3.2A) **
ExecBase = 4 ;base addres of the EXEC library
OpenLib = -408 ;offset of OpenLib function
Open = -30 ;Offset of the DOS function OPEN
init:
move.l ExecBase,a6 ;base address in A6
lea dosname(pc),a1 ;address of library name
move.q #0,d0 ;version number:unimportant
jsr OpenLib(a6) ;call the function
move.l d0,dosbase ;save DOS base address
beq error ;if zero,then error!
... ;more of your program
... ;now open window,etc...
error:
... ;error occured
... ;your error routine
openfile: ;general open function
move.l dosbase,a6 ;DOS base address in A6
jsr Open(a6) ;call OPEN function
tst.l d0 ;test if ok
rts ;done,evaluate test later
dosname: ;name of library to be opened
dc.b 'dos.library',0,0
align ;even
dosbase: ;spot for DOS base address
blk.l 1
You call the Openfile routine,because the label "Open"is already
being used for the offset.This routine calls the Open function
that is in the DOS library.
This isn't everything.The function must be given some parameters
so that it knows what to open.The parameters are sent in registers
D1 and D2.D1 points to a definition block what specifies what
should be opened.You need to have a filename ended with a null
byte there.D1 must be passed as a long word like all addresses.D2
contains the mode that the function should run in.There is an old
(1005) and a new (1006) mode.This number must be passed in D2's
long word.
Heres an overview of how windows are opened.Fortunately,AmigaDos
allows you to use input and output channels in the same way.The
standard channels are disk files,the console (keyboard and screen)
the printer interface and the serial RS232 interface.
The console input/output is what you'll work with now.When you
specify the console as the filename of the channel to be opened,a
window is opened automatically.
The name must begin with CON:to do this.Its similar to DF0:for
disk operations.A little more infotmation about the window is
still needed.
You need to specify the X and Y coordinates of the upper left and
lower right corners of the window as well as the name that should
appear in the title line of the window.A complete definition block
for a window like this would appear like the following line:
consolname: dc.b 'CON:0/100/640/100/**Window**',0
To open this window,the line above needs to be inserted in the
following program:
mode_old = 1005
lea consolname(pc),a1 ;consol definition
move.l #mode_old,d0 ;mode
bsr openfile ;console open
beq error ;didn't work
move.l d0,conhandle
rts
...
conhandle: dc.l 1 ;space for handle
There are two points to clear up yet.
You should use mode_old as the the mode when you open a window.
Logically the window doesn't exist before opening so this seems
wierd but it doesn't hurt anything.
The parameter that returns from "openfile"in D0 is zero in the
case of an error,in the case that opening didn't work.Otherwise
the value is the identification number (handle number) of the
opened channel.You need to store it away,because every function
that wants to use this channel must give the handle number.In the
example,you stored this number in the "conhandle"long word.
As mentioned,the window you've opened doesn't have a close symbol
but it can be made bigger and smaller and moved forward and back.
The manipulations that are carried out using the mouse are
completely taken care of by the Amiga (in contrast to the ATARI ST
where the programmer has to take care of these things).
An important function that uses the handle number is the one that
closes the channel (in your case the window).This function is also
in the DOS library and is called "Close".Its offset is -36 and it
only needs one parameter;the handle number of the channel that is
closed must be in the D1 register.
After your work is done,you need to put the following lines in
your program to close the window:
Close = -36 ; (6.3.2C)
...
move.l conhandle,d1 ;handle number in D1
move.l dosbase,a6 ;DOS base address in A6
jsr Close(a6) ;close channel!
The window disappears!
Now for a few remarks about opening and closing the window in this
way.If you open several windows in the same way,you'll get several
windows and thus several handle numbers.In this way,you can put as
many windows on the screen as you like.You can do your work with
them and close them individually.
Here is the complete program to open and close a simple window in
AssemPro format (We have used the AssemPro ILABEL and the macros
INIT_AMIGA and EXIT_AMIGA so AssemPro owners can start the program
from desktop.If you are using a different assembler check your
documentation for instructions on starting and exiting programs):
;***** 6.3.2 S.D *****
OpenLib =-30-378
closelib =-414
;execbase =4 ;defined in AssemPro macros
*calls to Amiga DOS:
open =-30
close =-30-6
IoErr =-132
mode_old = 1005
alloc_abs =-$cc
ILABEL AssemPro:includes/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bra test ;system-test
init: ;system initialization and open
move.l execbase,a6 ;number of execute-library
lea dosname(pc),a1
moveq #0,d0
jsr openlib(a6) ;open DOS-Library
move.l d0,dosbase
beq error
lea consolname(pc),a1 ;consol definition
move.l #mode_old,d0
bsr openfile ;consol open
beq error
move.l d0,conhandle
rts
test:
bra qu ;quit and exit
error:
move.l dosbase,a6
jsr IoErr(a6)
move.l d0,d5
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6
jsr closelib(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-Definition-Text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
dosname: dc.b 'dos.library',0,0
Align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/**CLI-Test**',0
Align.w
conhandle: dc.l 0
end
There is another way to open a window easily.Just use RAW:instead
of CON:as the channel designator.All the other parameters and
operations remain the same.
If you try them both out,you won't see any differences between the
two windows.They both look the same and can be worked with in the
same way with the mouse.The difference comes when you input to the
window.In the RAW:window,the cursor keys are ignored.In the CON:
window and in CLI,they do work.
6.4.Input/Output.
-----------------
Besides managing and making calculations with data,the most
important work of a program is to input and output the data.There
are many methods of data transfer in and out of the computor,for
instance screen or printer output,keyboard input,using the serial
or the parallel interface,tone or speech output and finally disk
operations.
You want to learn about all these methods of data input and output
for programming and applications.We've written some programs as
subroutines that should be useful for later programs.It makes good
sense to make a library of these subroutines that can either be
directly integrated in a new program or linked to a program.At the
end of the sections there is a list of a complete program so you
can see how the subroutines are used.
To prepare for input/output,you need to have data to output and
space to input data.To get this ready,you need a correct program
beginning in which the EXEC and DOS libraries are opened and
memory is reserved.After this,you begin most programs by outputing
some text.The text can be a program title or the instruction to
input data over the keyboard.Lets start looking at screen output.
6.4.1.Screen Output.
--------------------
For a computor like the Amiga the first question is where should
the screen output be sent?The answer is simple for many computors;
they only have one screen,and output goes there.You need to
specify which window to write to when you use the Amiga,however.
There are two possibilites:
1.Output to CLI
2.Output to another window
The first posibillity only exists if the program that makes the
output was started from CLI.If not,you need to open your own
custom window for your program.If so,you can use the window that
was opened by the CLI for output.
If you use the second method,you need to open a window.As you've
already seen,there are three methods.For simple text and character
output,the difference between the three sorts of windows isn't
very great.Here you have a free hand in determining which sort of
window to use.Lets open a CON:window and put its handle number in
"conhandle".
You've opened your window and want to output a title.You choose
text to output and then put it in memory using a code segment like
this:
title: dc.b "** Welcome to this Program! **"
titleend:
align ;even
The "align"(even) is a pseudo-op that should follow text when it
is followed by either word data or program lines.It causes the
assembler to insert a null byte if necessary to make the address
even.
To output this text you need another DOS function:Write.This has
an offset of -48 and needs three parameters:
In D1 the handle of an opened output channel that should be
written to (in your case,this is the handle number that
you go back from the Open command when you opened your
window.).
In D2 the address of the text to be output (in the example,the
address "title").
In D3 the number of characters to be output in bytes.
To find the number of bytes to output,you need to count the number
of characters in your text.Use "titleend"to calculate this.Using
this label,the assembler can calculate the length of your text for
itself (after all,why should you count when you have a computor?)
if you write:
move.l #titleend-title,d3
The advantage of specifying the length is that you can put control
characters between the beginning and end of the text.In this way,
you can execute certain functions using text output.You'll learn
about the control characters in a bit.
Heres the routine:
Write = -48 ; (6.4.1A)
... ;open window
...
move.l dosbase,a6 ;DOS base address
move.l conhandle,d1 ;pass handle
move.l #title,d2 ;text address
move.l #titleend-title,d3 ;and length
jsr Write(a6) ;call function
...
title: dc.b "** Welcome to this Program! **"
titleend:
align ;event
end
You'll certainly use this function a lot.You'll often want to
output just one character though.To allow you to do this and
similar text related tasks,there are four subroutines,each of
which do a different sort of output:
Pmsg;
Outputs the text from (D2) to the first null byte.
Pline;
Is the same as the routine above except that the text is
automatically followed by a CR,the cursor is positioned at the
beginning of the next line.
Pchar;
Outputs the character in D0
Pcrlf;
Puts the cursor at the beginning of the next line.
Heres the subroutine package:
Write = -48 ; (6.4.1B)
...
pline: ;*output line and then a CR
bsr pmsg ;output line
pcrlf:
move #10,d0 ;line feed
bsr pchar ;output
move #13,d0 ;and CR
pchar:
move.b d0,outline ;character in output buffer
move.l #outline,d2 ;address of the character
pmsg: ;*output line (D2) upto null
move.l d2,a0 ;address in A0
clr d3 ;length = 0
ploop:
tst.b (a0)+ ;null byte ?
beq pmsg2 ;yes:length found
addq.l #1,d3 ;else length + 1
bra ploop ;and continue looking
pmsg2:
move.l dosbase,a6 ;DOS base address in A6
move.l conhandle,d1 ;our window handle
jsr Write(a6) ;call write function
rts ;done!
outline: dc.w 0 ;output buffer for 'pchar'
conhandle: dc.l 0 ;windows handle
Here is an example program to open and close a simple window and
output a text message in AssemPro format (We have used the
AssemPro macros INIT_AMIGA and EXIT_AMIGA so AssemPro owners can
start the program from desktop.If you are using a different
assembler check your documentation for instructions on starting
and exiting programs.):
Here is the complete program in AssemPro format:
;***** 6.4.1C.asm S.D. *****
Openlib =-30-378
closelib =-414
;execbase = 4 ;Defined in AssemPro
;Macros
* calls to Amiga Dos:
open =-30
close =-30-6
write =-48
IoErr =-132
mode_old = 1005
alloc_abs =-$cc
ILABEL AssemPro:include/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bsr test ;system test
nop
bra qu ;quit and exit
test:
move.l #title,d0
bsr pmsg
bsr pcrlf
bsr pcrlf
rts
init: ;system initialization and
;open
move.l execbase,a6 ;number of execute-library
lea dosname(pc),a1
moveq #0,d0
jsr openlib(a6) ;open DOS-library
move.l d0,dosname
beq error
lea consolname(pc),a1 ;console definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
pmsg: ;print message (D0)
movem.l d0-d7/a0-a6,-(sp)
move.l d0,a0
move.l a0,d2
clr.l d3
ploop:
tst.b (a0)+
beq pmsg2
addq.l #1,d3
bra ploop ;length calculate
pmsg2:
move.l conhandle,d1
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6
rts
pcrlf:
move #10,d0
bsr pchar
move #13,d0
pchar: ;output char in D0
movem.l d0-d7/a0-a6,-(sp) ;save all
move.l conhandle,d1
pch1:
lea outline,a1
move.b d0,(a1)
move.l a1,d2
move.l #1,d3 ;1 letter
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6 ;restore all
error:
move.l dosbase,a6
jsr IoErr(a6)
move.l d0,d5
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6
jsr closelib(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-definition-
;text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
dosname: dc.b 'dos.library',0,0
align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/** CLI-Test **',0
align.w
conhandle: dc.l 0
title: dc.b '** Welcome to this Program! **'
titleend:
align
outline: dc.w 0 ;output buffer for char
end
Using this program,you can very easily put whatever you want in
the CON:window.These functions also work in RAW:window.You should
rename "conhandle"as "rawhandle",so that you don't get things
mixed up later.
Lets stay with the CON:window.As mentioned earlier,you can output
special characters that execute functions or change parameters for
output.These characters are called control characters.
You've already learned about one of these control characters,Line
Feed ($A).This character isn't just output;instead,it calls a
function that moves the cursor into the next line and moves the
screen up.This is very useful,but there are much more interesting
control characters.
Here's a list of control characters that execute functions.These
characters are given in hex.
Control Sequence;
Sequence Function
------------------------------------------------------------------
08 Backspace
0A Line Feed,Cursor down
0B Move Cursor up a line
0C Clear screen
0D Carrige return,cursor in the first column
0E Turn on normal characters (Cancel Of Effects)
0F Turn on special characters
1B Escape
The following sequences begin with $9B,the CSI (Control Sequence
Introducer).The characters that follow execute a function.The
values in square brackets can be left off.The n's you see
represent one or more digit decimal numbers given using ASCII
characters.The value that is used when n is left off,is given in
the parenthesis that follow n in the description of the function
in the table.
Control Sequence Introducer;
Sequence Function
------------------------------------------------------------------
9B[n]40 Insert n blanks
9B[n]41 Move cursor n (1) lines up
9B[n]42 Move cursor n (1) lines down
9B[n]43 Move cursor n (1) characters to the right
9B[n]44 Move cursor n (1) characters to the left
9B[n]45 Move cursor down n (1) lines into column 1
9B[n]46 Move cursor up n (1) lines and into column 1
9B[n][3B n]48 Cursor in line;Set column
9B 4A Erase screen from cursor
9B 4B Erase line from the cursor
9B 4C Insert line
9B 4D Delete line
9B[n]50 Delete n characters starting at cursor
9B[n]53 Move up n lines
9B[n]54 Move down n lines
9B 32 30 68 Line feed => Line feed + return
9B 32 30 6C Line feed => just Line feed
9B 6E Sends the cursor position!A string of the following
form is returned:
9B (line) 3B (column) 52
9B(style);(foreground colour);(Background Colour)6D
The three parameters are decimal numbers in ASCII
format.They mean:
Style: 0 = normal
1 = bold
3 = italic
4 = underline
7 = inverse
Foreground colour: 30-37
Colour 0-7 for Text
Background colour: 40-47
Colour 0-7 for background
9B(length)74 sets the maximum number of lines to be displayed
9B(width)75 sets the maximum line length
9B(distance)78 defines the distance in pixels from the left border
of the window to the place where output should
begin
9B(distance)79 defines the distance in pixels from the upper
border of the window to the place where output
should begin
The last four functions yield the normal values if
you leave off the parameters.
9B 30 20 70 Make cursor invisible
9B 20 70 Make cursor visible
9B 71 Sends window construction.A string of the following
form is returned:
9B 31 3B 31 3B (lines) 3B (columns) 73
To see how the control characters work,have "pmsg"output this text
to your window:
mytext: dc.b $9b,"4;31;40m" ; (6.3.2D)
dc.b "underline"
dc.b $9b,"3;33;40m",$9b,"5;20H"
dc.b "** Hello World! **",0
The parameters for the control sequence are put in quotation marks
so they are treated as an ASCII string.Now you see,just how easy
it is to do text output!
Here is the complete program to open and output the text and
control codes to your window in AssemPro format (We have used the
AssemPro macros INIT_AMIGA and EXIT_AMIGA so AssemPro owners can
start the programs from desktop.If you are using a different
assembler check your documentation for instructions on starting
and exiting programs):
; ***** 6.4.1D.ASM S.D. *****
openlib =-30-378
closelib =-414
;execbase = 4 ;defined in AssemPro macros
* calls to Amiga Dos:
open =-30
close =-30-6
write =-48
IoErr =-132
mode_old = 1005
alloc_abs =-$cc
ILABEL AssemPro:includes/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bsr test ;system test
nop
bra qu ;quit and exit
test:
move.l #mytext,d0
bsr pmsg
bsr pcrlf
bsr pcrlf
rts
init: ;system initialization and open
move.l execbase,a6 ;number of execute-library
lea dosname(pc),a1
moveq #0,d0
jsr openlib(a6) ;open DOS-Library
move.l d0,dosbase
beq error
lea consolname(pc),a1 ;console definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
pmsg: ;print message (D0)
movem.l d0-d7/a0-a6,-(sp)
move.l d0,a0
move.l a0,d2
clr.l d3
ploop:
tst.b (a0)+
beq pmsg2
addq.l #1,d3
bra ploop
pmsg2:
move.l conhandle,d1
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6
rts
pcrlf:
move #10,d0
bsr pchar
move #13,d0
pchar: ;output char in D0
movem.l d0-d7/a0-a6,-(sp) ;save all
move.l conhandle,d1
pch1:
lea outline,a1
move.b d0,(a1)
move.l a1,d2
move.l #1,d3 ;one letter
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6 ;restore all
rts
error:
move.l dosbase,a6
jsr IoErr(a6)
move.l d0,d5
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6
jsr closelib(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-definition-
;text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
dosname: dc.b 'dos.library',0,0
align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/ ** CLI-Test **',0
align.w
conhandle: dc.l 0
mytext:
dc.b $9b,'4;31;40m'
dc.b 'underline'
dc.b $9b,'3;33;40m',$9b,'5;20H'
dc.b '** Hello World !! **',0
align
outline: dc.w 0 ;output buffer for pchar
end
Now that you've done text and character output,its time to move on
to text input.
6.4.2.Keyboard Input.
---------------------
You can read keyboard input very easily.You just need to open the
I/O channel of the CON:window and read from it.You need the read
function from the DOS library to do this.Its offset is -42.
The function has three parameters just like the WRITE function.
In D1 the handle number that you get from the WRITE function.
In D2 the address that the data read in is to start.
In D3 the number of bytes to read.
Here is a subroutine that reads the number of characters from the
keyboard that it finds in D3.It puts them in a buffer.
read = -42 ; (6.4.2A)
...
getchr: ;* Get (D3) characters from the
;keyboard
move.l #inbuff,d2 ;address of buffer in D2
move.l dosbase,a6 ;DOS base address in A6
move.l conhandle,d1 ;our window handle
jsr read(a6) ;call read function
rts ;done!
inbuff: blk.b 80,0 ;buffer for keyboard input
This routine returns to the main program when <Return> is entered.
If more than D3 characters are entered,"inbuff"only gets the first
characters.The routine gets the remaining characters when called a
second time.
This sort of input is fairly easy.You can backspace,because only
the characters that should be there are put in the memory block
starting at "inbuff".The number of characters moved into "inbuff"
is put in D0.
Try the program out as follows:
After opening the CON:window,put the following lines in the main
program:
move #80,d3 ;read 80 characters (6.4.2B)
bsr readchr ;get line from keyboard
lea inline,a0 ;address of line in A0
clr.b 0(a0,d0) ;null byte on the end
bsr pmsg ;output line again
bp:
After this comes the code segment that closes the window again.
After loading the program into the AssemPro debugger,make "bp"a
breakpoint and start the program.(SEKA users start the program
with "g run"and enter "bp"as the breakpoint).The program quits at
the breakpoint and you can take a look at the results on the
screen.Then you can continue the program (SEKA with "j bp") and
let the window close.
After starting the program and opening the window,the cursor
appears in the upper left corner of the window.Enter some text and
press <Return>.The string that you just entered is output again on
the screen.
You use the "pmsg"routine from the previous chapter to do this
output.This routine needs a null byte at the end of the text to be
output.You put a null byte there by putting the address of the
input buffer in A0 and then erasing the byte at A0+D0 using the
CLR.B command.Since D0 contains the number of characters that were
entered,this byte is the first unused byte.
Since you're in the debugger you can redisplay the disassembled
output when the program ends to see what "getchr"put in "inbuff"
(SEKA owners can use "q inbuff"when the program ends to see what
"getchr"put there.)You'll find the characters that you typed plus
a closing $A.The $A stands for the <Return> key and its counted
too,so if you entered a 12 and then hit <Return>,for example,D0
will contain a 3.
Try this again with a RAW:window.Change the window definition from
CON: to RAW:and reassemble the program.You'll notice the diference
right away.After you've entered one character,a return is executed
D0 always as one bit in it.
The advantage of this form of input is that cursor and function
keys can be recognized.Using your own routine,you can repeatedly
accept input of characters using "getchr"and then work with the
special characters.
Theres another form of keyboard input:checking for a single key.
This is important when a program is about to execute an important
function and the user must say he wants it executed by entering
"Y"for yes.This can be treated as normal input,but in some cases,
there is a better method.
There is a function in the DOS library that waits a certain
specified length of time for a key to be pressed,and returns a
zero (FALSE) if no key was hit in this time period.It returns a -1
($FFFFFFFF = TRUE) if one was.To find out which key it takes
another function.The WaitForChar function,is only good for tasks
like waiting for the user to let the program know that it can
continue scrolling text.
The function needs two parameters:
In D1 the handle number of the window or file from which the
character should be read.It can also wait for a character
from an interface.
In D2 you pass the length of time in microseconds that you
should wait for a key stroke.
To wait one second for one key to be hit,you can use the following
routine:
WaitForCh=-30-174 ; (6.4.2C)
...
scankey: ;* Wait for a key stroke
move.l conhandle,d1 ;in our window
move.l #1000000,d2 ;waiting time 1 second
move.l dosbase,a6 ;DOS base address
jsr waitforch(a6) ;wait...
tst.l d0 ;test result
rts
The TST command at the end of the program allows the calling
routine to use a BEQ or BNE command to evaluate the results of the
routine-BEQ branches if no key was hit.BNE doesn't.
Heres an example program in AssemPro format covering what you have
learned so far.Opening and closing a window,displaying text in the
window and inputting text:
;***** 6.4.2A.ASM S.D *****
openlib =-30-378
closelib =-414
;execbase =4 ;defined in AssemPro
;Macros
* call to Amiga.Dos:
open =-30
close =-30-6
read =-42
write =-48
IoErr =-132
mode_old =1005
alloc_abs =-$cc
ILABEL AssemPro:include/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bsr test ;system test
nop
bra qu ;quit and exit
test:
move.l #mytext,d0
bsr pmsg
bsr pcrlf
bsr pcrlf
move.l #80,d3 ;80 characters to read in (D3)
bsr getchr ;get character
bsr pmsg ;output line
rts
init: ;system initialization and open
move.l execbase,a6 ;number of execute-library
lea dosname(pc),a1
moveq #0,d0
jsr openlib ;open DOS-Library
move.l d0,dosbase
beq error
lea consolname(pc),a1 ;console definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
pmsg: ;print message (D0)
movem.l d0-d7/a0-a6,-(sp)
move.l d0,a0
move.l a0,d2
clr.l d3
ploop:
tst.b (a0)+
beq pmsg2
addq.l #1,d3
bra ploop ;check length
pmsg2:
move.l conhandle,d1
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6
rts
pcrlf:
move #10,d0
bsr pchar
move #13,d0
pchar: ;character in D0 output
movem.l d0-d7/a0-a6,-(sp) ;save all
move.l conhandle,d1
pch1:
lea outline,a1
move.b d0,(a1)
move.l a1,d2
move.l #1,d3 ;1 letter
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6 ;restore all
rts
getchr: ;get character for keyboard
move.l #1,d3 ;1 character
move.l conhandle,d1
lea inbuff,a1 ;buffer address
move.l a1,d2
move.l dosbase,a6
jsr read(a6)
clr.l d0
move.b inbuff,d0
rts
error:
move.l dosbase,a6
jsr IoErr(a6)
move.l d0,d5
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6 jsr ;close lib (A6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-Definition-
;Text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
dosname: dc.b 'dos.library',0,0
align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/** CLI-TEST **',0
align.w
conhandle: dc.l 0
mytext: dc.b '** Hello World !! **',0
align
outline: dc.w 0 ;output buffer for pchar
inbuff: blk.b 8 ;input buffer
end
6.4.3.Printer Control.
----------------------
Now that you've looked at console I/O,lets look at outputting data
from the computor.The first device that we'll discuss is the
printer.
Its very easy to use the printer.You just need to open another
channel.It goes just the way you learned it with CON: and RAW:
windows;the only difference is you enter PRT:instead.
You open this channel using the same lines that you used above for
the window except that the pointer is to the channel name PRT:in
D1.You pass the mode "new"(1006) in D2 in the "do_open"routine as
well.Save the handle number that comes back at a label called
"prthandle".
Now you can use the same output routines that you used with the
windows to send text to the printer.You need to put "prthandle"
instead of "conhandle"in the line with the "move.l conhandle,d1"
command.
Actually it would be better to eliminate this line from the
routine totally.Then you can use the same routine for window and
printer output.The calling procedure would then need to put
"conhandle"in D1 for window output.It would put "prthandle" in D1
for printer output.This is a very flexible output routine that can
be used for window and printer output now.You can't accept input
from the printer,because the printer doesn't send data.It just
accepts it and prints it.
6.4.4.Serial I/O.
-----------------
Its just as easy to use the serial interface as the printer.Just
enter SER:as the filename.Now you can use the DOS functions READ
and WRITE just as before to do I/O channels you've just opened.
You can set the parameters for the interface (like Hand shake and
Transfer rate) with the Preferences program.
6.4.5.Speech Output.
--------------------
The Amiga has a speech synthesizer built in.This isn't quite as
easy to program as the I/O devices discussed earlier,however.You
use the "narrator.device"to do this.
This device requires several program steps to install it and then
causes it to speak.You need to open the device,start the I/O,etc..
Lets look at how to translate the text into the proper form and
then output the text.
First we need to do some initialization.Lets define the constants
now.Some of them are new.
;***** Narrator Basic Functions 3/87 S.D ***** (6.4.5A)
openlib =-408
closelib =-414
execbase = 4
open =-30 ;open file
close =-36 ;close file
mode_old = 1005 ;old mode
opendevice =-444 ;open device
closedev =-450 ;close device
sendIo =-462 ;start I/O
abortIO =-480 ;abort I/O
translate =-30 ;translate text
;The initialization routine follows:
init: ;initialize and open system
;* open DOS library *
move.l execbase,a6 ;pointer to execbase
lea dosname,a1 ;pointer to DOS name
moveq #0,d0 ;version unimportant
jsr openlib(a6) ;open DOS library
move.l d0,dosbase ;save handle
beq error ;error handle
;* Open translator.library *
lea transname,a1 ;pointer to translator name
clr.l d0
jsr openlib(a6) ;open translator
move.l d0,transbase ;save handle
beq error ;error handling
;* Set up I/O area for Narrator *
lea talkio,a1 ;pointer to I/O area in A1
move.l #nwrrep,14(a1) ;enter port address
move.l #amaps,48+8(a1) ;pointer to audio mask
move #4,48+12(a1) ;number of the mask
move.l #512,36(a1) ;length of the output area
move #3,28(a1) ;command:write
move.l #outtext,40(a1) ;address of output area
;* Open Narrator device *
clr.l d0 ;number 0
clr.l d1 ;no flags
lea nardevice,a0 ;pointer to device name
jsr opendevice(a6) ;open narrator.device
tst.l d0 :error?
bne error ;Yes!
;* Open Window *
move.l #consolname,d1 ;console definition
move.l #mode_old,d2 ;old mode
move.l dosbase,a6 ;DOS base address
jsr open(a6) ;open window
tst.l d0 ;error?
beq error ;Yes!
move.l d0,conhandle ;else save handle
After you've done this initialization,you can have the computor
save the text you have prepared for it.To see what the Amiga is
saying,use the "pmsg"function to have the text written to the
window:
move.l #intext,d2 ;text for the Amiga to say
bsr pmsg ;output in window also
sayit: ;have the text said
;*Translate the text into a form that the computor can use *
lea intext,a0 ;address of the text
move.l #outtext-intext,d0 ;length of the text
lea outtext,a1 ;address of output area
move.l #512,d1 ;length of output area
move.l tranbase,a6 ;translator base address
jsr translate(a6) ;translate text
;* Speech output *
lea talkio,a1 ;address of I/O structure
move.l #512,36(a1) ;length of output area
move.l execbase,a6 ;EXEC base address
jsr sendIO(a6) ;start I/O (speech output)
Once the program ends,the I/O stops as well,so you need to put in
something that keeps the program going longer.You'll use the
"getchr"function that you programmed earlier to take care of this:
bsr getchr ;wait for keyboard input
The computor waits until the <Return> key is pressed.Now you can
listen to what the Amiga as to say.Once the <Return> key is
pressed,the program stops.
qu: ; (6.4.5C)
move.l execbase,a6 ;EXEC base address
lea talkio,a1 ;pointer to I/O area
jsr abortio(a6) ;stop the I/O
move.l conhandle,d1
move.l dosbase,a6
jsr close(a6) ;close window
move.l dosbase,d1
move.l execbase,a6
jsr closelib(a6) ;close DOS library
lea talkio,a1
jsr closedev(a6) ;close narrator.device
move.l tranbase,a1
jsr closelib(a6) ;close translator library
rts ;* end of program
Now comes the data that you need for the program above:
mytext: dc.b 'This is a test text !',10,13,10,13,0,0
dosmame: dc.b 'dos.library',0,0
transname: dc.b "translator.library",0
consolname: dc.b 'RAW:0/100/640/100/** Test window',0
nardevice dc.b 'narrator.device',0
align
dosbase: dc.l 0
tranbase dc.l 0
amaps: dc.b 3,5,10,12
align
conhandle: dc.l 0
talkio: blk.l 20,0
nwrrep: blk.l 8,0
intext: dc.b 'hello,i am the amiga talking to you',0
align
outtext: blk.b 512,0
This is quite a bit of work,but its worth it because it opens so
many possibilities for you.There are a lot of variations possible
if you modify parameters.These parameters are entries in the I/O
area starting at the "talkio"label.The area is built as follows:
Offset Length Meaning
----------------------------------------------------------------
** Port Data **
0 L Pointer to next block
4 L Pointer to last block
8 B I/O type
9 B Priority
10 L Pointer to I/O name
14 L Pointer to port
18 W Length
** I/O Data **
20 L Pointer to device
24 L Pointer to device unit
28 W Command word
30 B I/O flags
31 B I/O status
32 L I/O pointer
36 L I/O length
40 L Pointer to Data
44 L I/O offset
** Narrator data items **
48 W Speech speed
50 W Highness of voice
52 W Speech mode
54 W Sex (male/female voice)
56 L Pointer to audio mask
60 W Number of mask
62 W Volume
64 W Read in rate
66 B Flag for producing graphics (0=off)
67 B Actual mask (internal use)
68 B Channel used (internal use)
We would'nt recommend experimenting with the data in the first two
blocks.If you do,you can easily cause a system crash.You can use
the last entries of the structure to produce some interesting
effects though.
Heres an overview of the parameters you can use to vary the speech
output.The value in parenthesis is the standard value,the value
set when narrator.device is opened.
Speech speed (150);
You can use this to set the speed of speech.The pitch of the voice
is not affected by this value.
Pitch of voice (110);
You can choose a value between 65 and 320 for the pitch (from
Goofy to Mickey Mouse).
Speech mode (0);
The zero gives half-way naturel speech.A one lets the Amiga speak
in monotone like a robot.
Sex (0);
A zero means masculine and a one means feminine (more or less..)
Volume (64);
The volume can range from 0 to 64.The standard value is the
loudest possible.
Read in rate (22200);
By lowering this value,the voice is lowered.If you change this
very much,you'll get some wierd voices!
You can experiment a bit until you find a interesting voice.Have
fun!
Here is a complete talking program in AssemPro format:
;***** Speech output S.D. *****
openlib =-30-378
closelib =-414
;execbase =4 ;defined by AssemPro
* calls to Amiga Dos:
open =-30
close =-30-6
opendevice =-444
closedev =-450
addport =-354
remport =-360
;DoIo =-456
sendIo =-462
abortIo =-480
read =-30-12
write =-30-18
;myinput =-30-24
;output =-30-30
;currdir =-30-96
;exit =-30-114
waitforch =-30-174
findtask =-294
translate =-30
mode_old = 1005
;mode_new = 1006
;alloc_abs =-$cc
;free_mem =-$d2
;!!!when>500KB !!! or place in chip memory
;org $40000
;load $40000
;!!!!!!!!!!!!!!!!!!!!!!!
ILABEL AssemPro:includes/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bra test ;system-test
init: ;system initialization and
;open
move.l execbase,a6 ;pointer to exec library
lea dosname(pc),a1 ;pointer to dos name
moveq #0,d0 ;version:not important
jsr openlib(a6) ;open DOS-Library
move.l d0,dosbase ;save handle
beq error ;error routine
;* ;open translator library
move.l execbase,a6 ;pointer to exec library
lea transname,a1 ;pointer to translator library
clr.l d0
jsr openlib(a6) ;open translator
move.l d0,tranbase ;save handle
beq error ;error routine
;* ;set up
sub.l a1,a1
move.l execbase,a6
jsr findtask(a6) ;find task
move.l d0,nwrrep+2
lea nwrrep,a1
jsr addport(a6) ;add port
;* ;open narrator device
lea talkio,a1 ;pointer to I/O area in A1
move.l #nwrrep,14(a1) ;enter port address
clr.l d0 ;number 0
clr.l d1 ;no flags
lea nardevice,a0 ;pointer to device name
jsr opendevice(a6) ;open narrator.device
tst.l d0 ;error?
bne error ;Yes!
;* ;set up I/O for narrator
;device
bp:
lea talkio,a1 ;pointer to I/O in A1
move.l #nwrrep,14(a1) ;enter port address
move.l #amaps,48+8(a1) ;pointer to audio mask
move #4,48+12(a1) ;size of mask
lea consolname(pc),a1 ;console-definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
test:
move.l #mytext,d0
bsr pmsg ;test-text output
bsr sayit ;say text
bsr readin ;input
move #10,d0
bsr pchar ;LF output
move.l #inline+2,d0
bsr pmsg ;and again
bsr pcrlf
bra qu
error:
move.l #-1,d7 ;flag
qu:
move.l execbase,a6
lea talkio,a1
jsr abortio(a6)
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6
jsr closelib(a6)
lea nwrrep,a1
jsr remport(a6) ;remove port
lea talkio,a1
jsr closedev(a6) ;close narrator device
move.l tranbase,a1
jsr closelib(a6) ;close translator library
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O definition-
;text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
pmsg: ;print message (D0)
movem.l d0-d7/a0-a6,-(sp)
move.l d0,a0
move.l a0,d2
clr.l d3
mess1:
tst.b (a0)+
beq mess2
addq.l #1,d3
bra mess1 ;length calculate
mess2:
move.l conhandle,d1
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6
rts
pcrlf:
move #10,d0
bsr pchar
move #13,d0
pchar: ;output characters in D0
movem.l d0-d7/a0-a6,-(sp) ;save all
move.l conhandle,d1
pch1:
lea chbuff,a1
move.b d0,(a1)
move.l a1,d2
move.l #1,d3 ;1 letter
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6 ;restore all
rts
scankey: ;test key
move.l conhandle,d1
move.l #500,d2 ;wait value
move.l dosbase,a6
jsr waitforch(a6)
tst.l d0
rts
readin: ;input from keyboard
movem.l d0-d7/a0-a6,-(sp) ;save registers
lea inline+2,a2 ;pointer to input buffer
clr.l (a2)
inplop:
bsr getchr
cmp.b #8,d0
beq backspace
cmp.b #127,d0 ;delete?
beq backspace
bsr pchar ;character output
cmp.b #13,d0
beq inputx
move.b d0,(a2)+
bra inplop
inputx:
clr.b (a2)+
sub.l #inline,a2
move a2,inline ;length in lines+1
movem.l (sp)+,d0-d7/a0-a6 ;registers
rts
backspace:
cmp.l #inline,a2 ;at the beginning?
beq inplop ;yes
move.b #8,d0
bsr pchar ;backspace
move #32,d0
bsr pchar ;blank
move #8,d0
bsr pchar ;backspace
clr.b (a2)
subq.l #1,a2
bra inplop
getchr: ;get one character from
;keyboard
move.l #1,d3 ;one character
move.l conhandle,d1
lea inbuff,a1 ;buffer address
move.l a1,d2
move.l dosbase,a6
jsr read(a6)
clr.l d0
move.b inbuff,d0
rts
sayit:
lea intext,a0
move.l #outtext-intext,d0
lea outtext,a1
move.l #512,d1
move.l tranbase,a6
jsr translate(a6)
p:
lea talkio,a1
move #3,28(a1) ;??
move.l #512,36(a1)
move.l #outtext,40(a1)
move.l execbase,a6
jsr sendio(a6)
rts
mytext: dc.b 'This is our Test-Text !',10,13,10,13,0,0
dosname: dc.b 'dos.library',0,0
transname: dc.b "translator.library",0
align.w
dosbase: dc.l 0
tranbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/* Speech-Test S.D.* ',0
nardevice: dc.b 'narrator.device',0
amaps: dc.b 3,5,10,12,0,0
align.w
conhandle: dc.l 0
inbuff: blk.b 8
inline: blk.b 180,0
chbuff: blk.b 82,0
narread: blk.l 20,0
talkio: blk.l 20,0
nwrrep: blk.l 8,0
intext: dc.b 'hello,i am the amiga computor',0
align.w
outtext: blk.l 128,0
end
6.5.Disk Operations.
--------------------
The most important peripheral device for a computor like the Amiga
is the disk drive.You use it to save data,so that you don't lose
it when you turn off the computor.We'll look at saving and
retrieving data in this chapter.
Lets first look at the simple disk operations that are used for
data management.To gain access to a file,you must open it first.
This is done using the OPEN function from the DOS library,a
function that you're already familiar with.I'll assume in the
following examples,that you've already opened the DOS library.
6.5.1.Open Files.
-----------------
The open function needs a parameter for the mode.The mode has a
particular meaning.If the file is opened for reading,it must
already exist.The mode for the OPEN function must be "old"(1005)
in this case.
If you want to produce a file,you must open it first.Since it does
not exist,you use the "new"(1006) mode.If a file is opened for
writing using this mode even though a file with this name already
exists,the old file with this name is erased and replaced.To avoid
loss of data,you should check if a file by that name already
exists and then output an error message if it does.
You're going to start with a subroutine that opens a file.Lets
assume that the filename starts at the label "filename",and that
it is closed with a null byte.You just need to pass the mode in
register D2.
The routine puts the file handle number in "filehd"and returns to
the main program.Since the operation with the handle is the last
one performed by the subroutine,the status of the operation can be
evaluated once the return has been executed.If the operation went
smoothly and the file is opened,the handle number has a non-zero
value.If it is zero and "bsr openfile"is followed by "beq error",
you can branch to an error handling routine when problems occur.
Here is a subroutine for opening and closing a file:
open =-30 ; (6.5.1A)
close =-36
mode_old = 1005
mode_new = 1006
...
openfile: ;*open file,mode in D0
move.l dosbase,a6 ;DOS base address in A6
move.l #filename,d1 ;pointer to filename
jsr open(a6) ;open file
move.l d0,filehd ;save handle
rts
closefile: ;*close file
move.l dosbase,a6 ;DOS base address in A6
move.l filehd,d1 ;file handle in D1
jsr close(a6) ;close file
rts
filehd: dc.l 0 ;storage for file handle
filename: dc.b "filename",0 ;file to be opened
align ;even
To use these subroutines,you must look at how you can load and
save data.
6.5.2.Reading and Writing Data.
-------------------------------
Lets write a new file.To start,write the following lines:
move.l #mode_new,d2 ;open new file (6.5.2A)
bsr openfile ;open file
beq error ;did'nt work!
For the filename,write a name like "Testfile"in the line labelled
"filename".After calling the "openfile"routine,a file with this
name is created on the disk.If one existed already,it is erased.
Lets assume you want to write a short text file.For the example
lets use:
text: dc.b "This is a test text for the Testfile",0
textend:
The "textend"label is used so that you can calculate the number of
data bytes by subtracting "text".
You want to write this text in the file.Use the WRITE function
which needs three parameters:
In D1 the file handle that you got back from the OPEN function.
In D2 a pointer to the data that should be written.
In D3 the number of bytes to be written.
For the example,you'll need another segment of code to put the
pointer to the data in D2 and the number of bytes in D3:
write =-48 ; (6.5.2B)
...
writedata: ;*write data in the file
move.l dosbase,a6 ;DOS base address
move.l filehd,d1 ;file handle in D1
jsr write(a6) ;write data
rts
After opening the file,you can call the subroutine from the main
program with the following lines:
move.l #text,d2 ;pointer to data
move.l #textend-text,d3 ;number of bytes
bsr writedata ;write data in the file
Then close the file with:
bsr closefile ;close file
bra end ;end program
After running the program,look at the directory of the diskette,
you should find the file "testfile".It is just as long as your
text.You want to read this file in,to make sure it contains the
right data.
You need the DOS function READ,which needs the same parameters as
the WRITE function.You can use parameters for the number of bytes
to read just part of the file.If you give a larger number than the
file contains,the whole file is loaded.You'll find the number of
bytes read in D0.
Lets set up a field that as enough space for the data you want to
read.You can do this with the following line:
field: blk.b 100 ;reserve 100 bytes
For the example data,this is plenty.If you want to load another
file,you may need to reserve more space.
Now lets write a subroutine to read the data.You always want to
load whole files.You just need to pass the address of the buffer
so the data is loaded into the subroutine.In the example,its the
address "field".
Heres the subroutine that reads the entire opened file into the
memory area pointed to by D2:
read = -42 ; (6.5.2C)
...
readdata: ;*read file
move.l dosbase,a6 ;DOS base address in A6
move.l filehd,d1 ;file handle in D1
move.l #$ffffff,d3 ;read an arbitrary number of bytes
jsr read(a6) ;read data
rts
To use this routine to load the file into the buffer "field",use
the following main program:
move,l #mode_old,d2 ;old file
bsr openfile ;open file
beq error ;did'nt work!
move.l #field,d2 ;pointer to data buffer
bsr readdata ;read file
move.l d0,d6 ;save number of bytes in D6
bsr closefile ;close file
bra end ;program end
After assembling and starting this program,you can use the
debugger to look at the data buffer that you filled with data from
the file.In D6,you'll find the number of bytes that were read from
the file.
6.5.3.Erase Files.
------------------
Once you've experimented enough with the program above,you'll
certainly want to erase the "Testfile"file.The DELETEFILE function
in the DOS library has an offset of -72.It only needs 1 parameter.
The parameter is passed in D1.The parameter is a pointer to the
filename.The name must be closed with a null byte.
To erase "Testfile",use the following lines:
deletefile =-72 ; (6.5.3)
...
move.l dosbase,a6 ;DOS base address in A6
move.l #filename,d1 ;pointer to filename in D1
jsr deletefile(a6) ;erase file
The file is deleted.You can't save the file with normal methods if
you accidently erase it!You can use a trick that saves the data.
We'll take a look at this trick later.Its used in lots of programs
6.5.4.Rename Files.
-------------------
When a text editing program writes a text that as be altered back
to the disk,the old file usually isn't erased.Often the old file
is renamed.For example,it might get the name "Backup".The new file
is written to disk with the old name.
The function in the DOS library that allows you to change the
names of programs is called RENAME and has -78 as an offset.You
need to pass two parameters-D1 as a pointer to the old name and D2
as a pointer to the new name of the file.
To rename "Testfile"as "Backup"(before you erase it),use the
following lines:
rename =-78
...
move.l dosbase,a6 ;DOS base address in A6
move.l #oldname,d1 ;pointer to old name in D1
move.l #newname,d2 ;pointer to new name in D2
jsr rename(a6) ;rename file
...
oldname: dc.b "testfile",0
newname: dc.b "backup",0
6.5.5.CLI Directory.
--------------------
Lets pretend you've programmed a text editor and started it.Now
you want to load a text from disk and edit it-but whats the name
of that file?
You need a function to read and display the directory of the disk.
There are several ways to do this.First lets use the easiest
method.It doesn't require much programming and can be quite
useful.
The trick is to call the Dir or List programs that are in the C
directory.You'll use the CLI commands.The DOS library contains a
command called "Execute"with offset -222 that allows you to
execute CLI commands.
The function needs three parameters:
In D1 a pointer to a string closed with a zero that contains the
name of the command to be executed.This string must
contain the same command that you would give in the CLI.It
can be a null pointer as well.
In D2 the input file is determined.Normally theres a zero here.
If however,you give the file handle of a text file,though,
this file is read and interpreted as a command sequence.If
you define a window as the input medium,you've programmed
a new CLI window!
In D3 the output file is determined.If there a zero here,the
output of the commands (for example,DIR output) is sent to
the standard CLI window.
To try this out,insert this subroutine in a program that has
already opened the DOS library and a window.
execute = -222 ; (6.5.5)
...
dir:
move.l dosbase,a6 ;DOS base address in A6
move.l #command,d1 ;pointer to command line
clr.l d2 ;no input (CLI window)
move.l conhandle,d3 ;output in our window
jsr execute(a6) ;execute command
rts
command:
dc.b "dir",0
This program works with the List command as well.The disadvantage
of this method is that the disk that the Workbench is loaded from
must be in the drive or the system requests you to put it in.The
Dir command is just a program,and the Amiga must load it before it
can run.
The disadvantage isn't too great.The program is short,and it
allows you to use any CLI command in a program.
Here is the complete program in AssemPro format that calls the dir
program:
;***** 6.5.5A DIR.ASM S.D.*****
openlib =-408
closelib =-414
;execbase = 4 ;defined in AssemPro
;macros
*calls to Amiga Dos:
open =-30
close =-36
execute =-222
IoErr =-132
mode_old = 1005
alloc_abs =-$cc
ILABEL AssemPro:includes/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bra test ;system test
init: ;system initialization and
;open
move.l execbase,a6 ;number of execute-library
lea dosname(pc),a1
moveq #0,d0
jsr openlib(a6) ;open DOS-library
move.l d0,dosbase
beq error
lea consolname(pc),a1 ;console definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
test:
bsr dir ;do directory
bra qu ;quit and exit
dir:
move.l dosbase,a6 ;DOS base address in A6
move.l #command,d1 ;pointer to command line
clr.l d2 ;no input (CLI window)
move.l conhandle,d3 ;output in our window
jsr execute(a6) ;execute command
rts
error:
move.l dosbase,a6
jsr IoErr(a6)
move.l d0,d5
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;DOS.Lib close
move.l execbase,a6
jsr closelib(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-Definition-
;text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
dosname: dc.b 'dos.library',0,0
align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/** CLI-Test **',0
align.w
conhandle: dc.l 0
command:
dc.b "dir",0
end
6.5.6.Read Directory.
---------------------
Now,lets look at another method that doesn't need the CLI.In this
way,you can read the directory of any disk without having to play
Disk Jockey.
You need to writ a program that does what CLI's Dir program does.
There are several steps.
First you must give the system a key to the desired directory.That
means you must call DOS'Lock function.It needs two parameters:
In D1 pass a pointer to a text that contains the name of the
directory you wish to read.If,for example,you want to
read the contents of the RAM disk,the text would be
'RAM:',0.
In D2 put the mode that determines whether to read or write.Let
us use the "Read"(-2) mode.
You call the Lock function (offset -84) and get either a point to
the key or a zero returned to you in the D0 register.If you get a
zero,the call did'nt work,the file was'nt found.This function can
be used to find if a file is on the disk.You use this function
with the name and see if D0 comes back zero.If not,the file
exists.
Lets assume the file or path exists.You need to save the value
that came back in D0.You'll need it for both functions that you'll
call.
The next function you need is called Examine.You use it to search
the disk for an acceptable entry.It returns parameters like name,
length and date that correspond to the entry.You need to reserve a
memory block for this information and put the beginning of the
block in D2 before calling the Examine function.Put the key you
got from the Lock function in the D1 register.
The memory area that is filled with information is called a
FileInfoBlock.Its 260 bytes long and contains information about
the file.The name starts in the 9th byte and ends with a null byte
so you can easily print it with our "pmsg"routine.The information
that Examine gives isn't about a particular file,but about the
disk.The name in FileInfoBlock is the disk name.
The Examine function sends the status back in the D0 register.
Since the Lock function already tested if the file existed,evalua-
ting the status really isn't necessary.
Now to the function that you can use to read individual files from
the directory.The function is called ExNext (Examine Next).This
function searches for the next entry that fits the key every time
it is called.ExNext gets the same parameters as Examine gets.
However,the return parameter in D0 is more important here.
The ExNext function is always called in the same way.It always
gets the next entry of the directory.If no more entries exist in
the directory,ExNext puts a zero in the D0 register.
You need to continue performing this operation until there aren't
any more entries.You can find this using the IoErr function from
the DOS library.
This function doesn't need any parameters.It returns the status of
the last I/O operation that was performed in the D0 register.After
the last ExNext,this value is 232,which means no_more_Entries.
Heres a complete routine for reading the directory of the disk in
DFO:and displaying the contents in the window.
; 6.5.5B.ASM
;***** DOS-Sample function 3/87 S.D. *****
openlib =-30-378
closelib =-414
exbase =4
* calls to amiga dos:
open =-30
close =-30-6
read =-30-12
write =-30-18
myinput =-30-24
output =-30-30
currdir =-30-96
lock =-30-54
examine =-30-72
exnext =-30-78
exit =-30-114
IoErr =-30-102
waitforch =-30-174
mode = 0
mode_old = 1005
mode_new = 1006
alloc_abs =-$cc
free_mem =-$d2
ILABEL AssemPro:includes/Amiga.l ;AssemPro only
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bra test ;system-test
init: ;system initialization and
;open
move.l exbase,a6 ;pointer to exec.library
lea dosname(pc),a1
moveq #0,d0
jsr openlib(a6) ;open dos-library
move.l do,dosbase
beq error
lea consolname(pc),a1 ;console definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
moveq d0,conhandle
rts
test:
move.l #mytext,d0
bsr pmsg ;test-text output
move.l dosbase,a6
move.l #name,d1
move.l #-2,d2
jsr lock(a6)
move.l d0,d5
tst.l d0
beq error
move.l d0,locksav
move.l dosbase,a6
move.l locksav,d1
move.l #fileinfo,d2
jsr examine(a6)
move.l d0,d6
tst.l d0
beq error
loop:
move.l dosbase,a6
move.l locksav,d1
move.l #fileinfo,d2
jsr exnext(a6)
tst.l d0
beq error
move.l #fileinfo+8,d0
bsr pmsg
bsr pcrlf
bra loop
error:
move.l dosbase,a6
jsr ioerr(a6)
move.l d0,d6
move.l #presskey,d0
bsr pmsg
bsr getch
move.l #-1,d7 ;flag
qu:
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;dos.lib close
move.l exbase,a6
jsr closelib(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to I/O-Definition-
;Text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
pmsg: ;print message (D0)
movem.l d0-d7/a0-a6,-(sp)
move.l d0,a0
move.l a0,d2
clr.l d3
mess1:
tst.b (a0)+
beq mess2
addq.l #1,d3
bra mess1
mess2:
move.l conhandle,d1
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6
rts
pcrlf:
move #10,d0
bsr pchar
move #13,d0
pchar: ;character in D0 output
movem.l d0-d7/a0-a6,-(sp) ;save all
move.l conhandle,d1
pch1:
lea chbuff,a1
move.b d0,(a1)
move.l a1,d2
move.l #1,d3
move.l dosbase,a6
jsr write(a6)
movem.l (sp)+,d0-d7/a0-a6 ;restore all
rts
scankey: ;test key
move.l conhandle,d1
move.l #500,d2 ;wait value
move.l dosbase,a6
jsr waitforch(a6)
tst.l d0
rts
readin: ;input from keyboard
movem.l d0-d7/a0-a6,-(sp) ;registers
lea inline+2,a2 ;pointer to input buffer
clr.l (a2)
inplop:
bsr getchr
cmp.b #8,d0
beq backspace
cmp.b #127,d0 ;delete?
beq backspace
bsr pchar ;character output
cmp.b #13,d0
beq inputx
move.b d0,(a2)+
bra inplop
input:
clr.b (a2)+
sub.l #inline,a2
move a2,inline ;length in inline+1
movem.l (sp)+,d0-d7/a0-a6 ;registers
rts
backspace:
cmp.l #inline,a2 ;at beginning?
beq inplop ;yes
move.b #8,d0
bsr pchar ;backspace
move #32,d0
bsr pchar ;blank
move #8,d0
bsr pchar ;backspace
clr.b (a2)
subq.l #1,a2
bra inplop
getchr: ;get 1 character from keyboard
move.l #1,d3 ;1 character
move.l conhandle,d1
lea inbuff,a1 ;buffer-address
move.l a1,d2
move.l dosbase,a6
jsr read(a6)
clr.l d0
move.b inbuff,d0
rts
mytext: dc.b 'Directory of Diskette: DFO:',10,13,10,13,0,0
dosname: dc.b 'dos.library',0,0
presskey: dc.b 'Press thr Return key!!',0
align.w
dosbase: dc.l 0
consolname: dc.b 'CON:0/100/640/100/** Directory-Test **',0
name: dc.b 'DFO:',0
align.w
locksav: dc.l 0
fileinfo: ds.l 20
conhandle: dc.l 0
inbuff: DS.B 8
inline: DS.B 180
chbuff DS.B 82
end
The FileInfoBlock contains the following entries:
Offset Name Meaning
----------------------------------------------------------------
0 DiskKey.L Disk Number
4 DieEntryType.L Entry Type (+=Directory,-=File)
8 FileName 108 bytes with the filename
116 Protection.L File Protected?
120 EntryType.L Entry type
124 Size.L Length of file in bytes
128 NumBlocks.L Number of blocks
132 Days.L Creation day
136 Minute.L Creation time
140 Tick.L Creation time
144 Comment 116 bytes with comments
If you want to have the program output the file length as well,you
can read the length with "move.l fileinfo+124,d0"and then use a
conversion routine to produce a decimal number.You can output this
result with the name.
6.5.7.Direct Access To Disk.
----------------------------
There isn't a simple function in the library for accessing single
disk sectors.Here,you must work with a device just like you did
with speech output.This time you'll be working with the trackdisk.
device.
You want to work with this device to directly program the disk
drives.Once you've built up the necessary program machinery,you
can experiment with various commands for disk access.Remember that
an error can cause the disk to be modified and thus unusable.Make
sure you're using a non-essential disk.Don't use one which
contains your only copy of something.
The initialization here is similar to that for speech output.Here
is the initialization routine for your program:
;** Direct disk access via trackdisk.device ** (6.5.7)
openlib =-408
closelib =-414
execbase = 4
open =-30
close =-36
opendevice =-444
closedev =-450
sendIo =-462
read =-30-12
write =-30-18
waitforch =-30-174
mode_old = 1005
run:
bsr init ;initialization
bra test ;system-test
init: ;initialize and open system
move.l execbase,a6 ;pointer to exec.library
lea dosname,a1
moveq #0,d0
jsr openlib(a6) ;open dos.library
move.l d0,dosbase
beq error
lea diskio,a1 ;pointer to disk I/O area
move.l #diskrep,14(a1) ;pointer to port
clr.l d0 ;drive 0 (built in)
clr.l d1 ;no flags
lea trddevice,a0 ;pointer to device name
jsr opendevice(a6) ;open trackdisk.device
tst.l d0 ;error?
bne error ;yes!
move.l #consolname(pc),d1 ;console definition
move.l #mode_old,d2 ;old mode
move.l dosbase,a6 ;dos base address
jsr open(a6) ;open window
tst.l d0 ;error?
beq error ;yes!
move.l d0,conhandle ;else save handle
rts ;done
test: ;place for test routine
And now for the functions that take care of the various messages
at the end of the program.
error:
move.l #-1,d7 ;flag for error (for SEKA)
qu:
move.l execbase,a6 ;exec base address
lea diskio,a1 ;pointer to disk I/O
move.l 32(a1),d7 ;IO_ACTUAL in D7 (for testing)
move #9,28(a1) ;command motor on/off
move.l #0,36(a1) ;0=off,1=on,so turn motor
jsr sendio(a6) ;off
move.l conhandle,d1 ;close window
move.l dosbase,a6
jsr close(a6)
move.l dosbase,d1 ;close dos.lib
move.l execbase,a6
jsr closelib(a6)
lea diskio,a1
jsr closedev(a6) ;close trackdisk.device
rts
Lets not forget the routine that waits for the user to press
<Return>,so that you can watch the effects of the test function in
peace:
getchr: ;get a character from keyboard
move.l #1,d3 ;1 character
move.l conhandle,d1 ;window handle
move.l #inbuff,d2 ;buffer address
move.l dosbase,a6 ;dos base address
jsr read(a6) ;read character
rts ;thats it
The last thing you need is the section of code that declares the
text and data fields that your program needs:
dosname: dc.b 'dos.library',0
align
consolname: dc.b 'RAW:0/100/640/50/** Wait window',0
align
trddevice: dc.b 'trackdisk.device',0
align
dosbase: dc.l 0 ;dos base address
conhandle: dc.l 0 ;window handle
inbuff: blk.b 80,0 ;keyboard buffer
diskio: blk.l 20,0 ;I/O structure
diskrep: blk.l 8,0 ;I/O port
diskbuff: blk.b 512*2,0 ;place for 2 sectors
There,now you've done with the set up work.Lets look at how you
can give commands to the disk drives.The first and easiest command
is the one for turning the drive motor on and off.You've already
seen this command in the program.This is command number nine.This
number goes in the command word of the I/O structure (bytes 28 and
29 of the structure).
You need to pass a parameter that lets the computor know whether
to turn the motor off or on.This information goes in the I/O long
word that starts at byte 36:its zero for off,and one for on.
You already chose the motor that should be turned on or off when
you opened the device.You put the number of the chosen disk drive
in D0-in your case you put a zero there because you are using the
DFO:disk drive.
Heres an overview of the commands you can use to access
information on the disk:
No Name Function
-----------------------------------------------------------------
2 READ Read one or more sectors
3 WRITE Write sectors
4 UPDATE Update the track buffer
5 CLEAR Erase track buffer
9 MOTOR Turn motor on/off
10 SEEK Search for a track
11 FORMAT Format tracks
12 REMOVE Initialize routine that is called when you
remove the disk
13 CHANGENUM Find out number of disk changes
14 CHANGESTATE Test if disk is in drive
15 PROTSTATUS Test if disk is write protected
You've already learned about command number nine.Lets look at the
three commands you can use to make tests.These are the last three
commands.They put a return value in the long word that begins in
the 32nd byte in the I/O structure.This value was written in D7 in
the program above for testing purposes.You can read its contents
directly if you ran the program with AssemPro.
Here is a simple routine that you can use to run one of these
commands with:
test: ; (6.5.7B)
lea diskio,a1 ;pointer to I/O structure
move #13,28(a1) ;pass command (for example 13)
move.l execbase,a6 ;execbase address in A6
jsr sendio(a6) ;call function
If CHANGENUM (command 13) is executed,in D7 you'll get the number
of times a disk was taken out and put in the drive.If you call the
program,you'll get a value back.If you take the disk out and put
it back in,the number is two higher the next time you call the
program.
The CHANGESTATE command (command 14) tells whether a disk is in
the drive or not.If one is,a zero comes back.Otherwise,a $FF is
returned.
You get the same values back from the PROTSTATUS function (command
15).Here a zero means that the disk isn't write protected,while
$FF means that it is.
Now lets look at the READ and WRITE functions.These operations
need a few more parameters than the status functions.You need to
pass the following parameters:
The address of the I/O buffer in the data pointer,the number of
bytes to be transfered in I/O length,and the data address on the
disk in I/O offset.
The number of data bytes must be a multiple of 512,since every
sector is 512 bytes,and only whole sectors can be read.
The data address is the number of the first byte in the sector.If
you want to use the first sector,the offset is zero.For the second
sector,its 512,etc...The formula is:
offset = (sector_number -1) *512
Here is a routine that loads the first two sectors of the disk
into the buffer:
test: (6.5.7C)
lea diskio,a1
move #2,28(a1) ;command:READ
move.l #diskbuff,40(a1) ;buffer
move.l #2*512,36(a1) ;length:2 sectors
move.l #0*512,44(a1) ;offset:0 sectors
move.l execbase,a6 ;exec base address
jsr sendio(a6) ;start function
Start the program from the debugger and then look at the buffers
contents after the program ends.You can find out the format of the
disk here.If you want to read a sector thats being used,change the
0 in the offset definition to 700 and start again.Its highly
probable that theres some data there.
To modify and write back the data that you've read from the disk,
you need command number three,the WRITE command.The parameters are
the same.
If you've executed the WRITE commandyou're probably wondering why
the disk light did'nt go on.Thats because the Amiga writes a track
that as been read into a buffer on its own.It WRITE's data there
as well.It won't write the data to disk until another track is
accessed.
You can have the data updated directly as well using command four,
the UPDATE command.
Command 11,the FORMAT command,is also quite interesting.This
command needs a data field that is 11*512=5632 bytes long-the
length of a track.The offset must be a multiple of this number so
that you start at the beginning of a track.
The length must be a multiple of 5632 as a result.If several
tracks are formatted,each track is filled with the same data.
You can use this function to easy write a disk copy program.You
READ the source disk and then FORMAT the corresponding track on
the destination disk.Thats how the DiskCopy program works-it
reformats the destination disk.
Command ten,the SEEK command,just needs the offset.It moves the
Read/Write head of the drive to the position specified without
making a disk access or testing if its at the right position.
Command 12,the REMOVE command,is used to install an interrupt
routine that is called when the disk is removed from the disk
drive.The address of the interrupt structure is passed in the data
pointer of the I/O structure.If theres a zero here,the interrupt
routine is turned off.
Heres a complete example program in AssemPro format:
;***** Track disk-Basic function 10/86 S.D. *****
ILABEL ASSEMPRO:includes/Amiga.l :AssemPro only
openlib =-30-378
closelib =-414
;execbase = 4 ;defined in INIT_AMIGA
* calls to amiga dos:
open =-30
close =-30-6
opendevice =-444
closedev =-450
sendIo =-462
read =-30-12
write =-30-18
waitforch =-30-174
mode_old = 1005
INIT_AMIGA ;AssemPro only
run:
bsr init ;initialization
bra test ;system test
init: ;system initialization and
;open
move.l execbase,a6 ;pointer to exec-library
lea dosname,a1
moveq #0,d0
jsr openlib(a6) ;open dos-library
move.l d0,dosbase
beq error
lea diskio,a1
move.l #diskrep,14(a1)
clr.l d0
clr.l d1
lea trddevice,a0
jsr opendevice(a6) ;open trackdisk.device
tst.l d0
bne error
bp:
lea consolname(pc),a1 ;console-definition
move.l #mode_old,d0
bsr openfile ;console open
beq error
move.l d0,conhandle
rts
test:
bsr accdisk
bsr getchr ;wait for character
bra qu
error:
move.l #-1,d7 ;flag
qu:
move.l execbase,a6
lea diskio,a1
move #9,28(a1)
move.l #0,36(a1)
jsr sendio(a6)
move.l conhandle,d1 ;window close
move.l dosbase,a6
jsr close(a6)
move.l dosbase,a1 ;dos.lib close
move.l execbase,a6
jsr closelib(a6)
lea diskio,a1
move.l 32(a1),d7
jsr closedev(a6)
EXIT_AMIGA ;AssemPro only
openfile: ;open file
move.l a1,d1 ;pointer to the I/O-definition
;text
move.l d0,d2
move.l dosbase,a6
jsr open(a6)
tst.l d0
rts
scankey: ;test for key
move.l conhandle,d1
move.l #500,d2 ;wait value
move.l dosbase,a6
jsr waitforch(a6)
tst.l d0
rts
getchr: ;get one character from
;keyboard
move.l #1,d3 ;1 character
move.l conhandle,d1
lea inbuff,a1 ;buffer-address
move.l a1,d2
move.l dosbase,a6
jsr read(a6)
clr.l d0
move.b inbuff,d0
rts
accdisk:
lea diskio,a1
move #2,28(a1) ;command:READ
move.l #diskbuff,40(a1) ;buffer
move.l #2*512,36(a1) ;length:2 sectors
move.l #20*512,44(a1) ;offset: n sectors
move.l execbase,a6
jsr sendio(a6)
rts
dosname: dc.b 'dos.library',0,0
align.w
dosbase: dc.l 0
consolname: dc.b 'RAW:0/100/640/100/** Test-Window S.D.V0.1',0
trddevice: dc.b 'trackdisk.device',0
align.w
conhandle dc.l 0
inbuff: ds.b 8
diskio: ds.l 20,0
diskrep: ds.l 8,0
diskbuff: ds.b 512*2,0
end
NOW LOAD PART THREE
end.