St. Catharines College,

Dept. of Computer Science,

Cambridge University

Adrian C. Dickens,

Churchill College,

Dept. of Engineering,

Cambridge University

Fitzwilliam College,

Dept. of Clinical Veterinary Medicine,

Cambridge University

Introduction 5

1 Introduction for those new to machine code 7

2 Operating System commands 11

3 The BASIC assembler 21

4 Machine code arithmetic 31

5 Addressing modes 35

6 The assembler mnemonics 41

7 Operating system calls 101

8 *FX/OSBYTE calls 109

9 0SWORD calls 247

10 Vectors 253

11 Memory usage 267

12 Events 287

13 Interrupts 295

14 RS432 309

15 Paged ROMs 317

16 Filing systems 333

17 An introduction to the hardware 353

18 The video circuit (6845) 359

19 The video ULA 377

20 The serial interface 385

21 The paged ROM select register 395

22 Programming the 6522 VIA 397

23 The system 6522, including sound and speech 417

24 The user 6522 425

25 Disc and Econet interfaces 427

26 The analogue-to-digital converter 429

27 The Tube 433

28 The 1 MHz bus 437

A *FX/OSBYTE call index 449

B Operating System calls summary 455

C Table of key numbers 456

D VDU codes 459

E PLOT number summary 460

F Screen mode layouts 462

G US MOS differences 478

H Disc upgrade 480

I Circuit board links 482

J Keyboard circuit diagram 489

K Main circuit diagram Inside Back Cover

Bibliography 491

Glossary 493

Index 499

The 'Advanced User Guide for the BBC Microcomputer' has been designed to be an invaluable supplement to the User Guide. Information already contained in the User Guide is only repeated in this book in sections which contain much new information and where omitting the duplicated details would have left the section incomplete. Some parts of the User Guide are factually inaccurate or incomplete and where details in this book are at variance with corresponding information in the User Guide the reader will find that a more accurate description is usually found in these pages.

This reference manual contains a considerable amount of information about 6502 assembly language programming, the operating system and the BBC Microcomputer hardware. The intention has not been to provide the inexperienced user with a tutorial to guide him or her through the complexities of these advanced concepts. However, it is hoped that the information has been presented in a way that enables users new to assembly language programming and unfamiliar with hardware topics to develop their understanding of the machine and to expand the scope of their programming. Contained within this book is an extensive description of the software environment and the hardware facilities available to the assembly language programmer. The authors have presumed that the readers of this Advanced Guide are reasonably familiar with the basic use of the BBC Microcomputer. While every attempt has been made not to bury the facts under a mountain of computer jargon the use of technical terms is an inevitable consequence of attempting to condense a large number of facts into an easily accessible form.

All the information about the operating system is exclusively based on 0S 1.20. The hardware information has been verified with an issue 4 circuit board but where possible differences on earlier issue boards have been noted.

While this book gives the programmer full access to all the BBC microcomputer's extensive software and hardware facilities using techniques which the designers of the machine

intended programmers to use, it also opens the door to a multitude of 'illegal' programming techniques. For the enthusiast, direct access to operating system variables or chip registers may enable him to perform the bizarre or even the merely curious. For the serious programmer, on the other hand, attention to compatibility and machine standards will enable him to write software which will run on BBC Microcomputers of all configurations. The responsibility rests with YOU, the user. The value of your machine depends on continued software support of the highest quality; unlike many machines the BBC microcomputer has been designed to be used in a variety of different configurations and the operating system software provides extensive information about the current hardware and software status. The operating system makes most of the allowances required for the different configurations automatically, but only when the legal techniques are adhered to, so please use them.

The final paragraph in this introduction must be a word of apology to those programmers engaged in the task of software protection. Many of the details contained in this book will give those intent on pirating software inspiration to circumvent their protection techniques. On the other hand these same details may also give the software protectors inspiration. In the end no software protection is complete. Any protection technique relies on the fact that the person trying to break the protection has a threshold at which he decides that the effort and resources required are greater than the reward. For some this threshold is higher than others but for these people the reward is often the victory in the intellectual battle with the programmer of the protection method. For those intent on denying the software producer his income, one hopes that this threshold is somewhat lower.

There comes a time in every programmer's life (well, most programmers', anyway) when the constraints of a high level language (e.g. BASIC) prevents him from implementing a particular program idea or from utilising some machine facility. At this stage the programmer must often seek recourse to the microprocessor's native language, its machine code.

At the heart of any microcomputer is the microprocessor. This microprocessor is the brain of the computer and provides the computer with all its computing power. The BBC Microcomputer uses a 6502 microprocessor and the brief description of machine code given here applies specifically to the 6502. The microprocessor performs instructions which are contained in memory. Each instruction which the microprocessor understands can be contained within a single byte of memory. Depending on the nature of this instruction the microprocessor may fetch a number of bytes of data from the memory locations following the instruction byte. Having executed this instruction the microprocessor moves on to the byte after the last data byte to get its next instruction. In this way the microprocessor works its way sequentially through a program. These single byte instructions are called operation codes (or just opcodes) although they are frequently referred to as machine instructions (or just instructions). The data used by the instructions are called the operands. A program using the native machine instructions is called a machine code program. An assembler is a software package (a language or a program) which enables a programmer to create a machine code program.

Machine code is substantially different from a higher level language such as BASIC. The machine code programmer is limited to three registers for temporary storage of data while in BASIC he has unlimited use of variables. For more permanent storage in machine code programs, the register values can be copied to bytes of memory. Only very limited

arithmetic is available; there are no multiply or divide instructions. There are no automatic loop structures such as FOR... NEXT or REPEAT... UNTIL and any loops must be explicitly set up by the programmer using conditional branches (these approximate to IF .. THEN GOTO .. in BASIC). The range of instructions available are sufficient to enable extremely complex programs to be written but a lot more effort is required to implement the program. One of the most grave disadvantages of machine code is that very little error checking is made available to the programmer. A well designed assembler will help the programmer, but once the machine code program is running the only error checking is that which is provided within the program itself.

At first glance it may appear that there is little to be gained from writing a machine code program. The principal advantage is that of speed. While assigning a value to a variable in BASIC will take about 1 millisecond, in machine code assigning a similar value will only take 10 microseconds. This is why fast moving arcade games have to be written in machine code. Some of the facilities available on the BBC Microcomputer can only be used when programming in machine code. For example, a user printer driver can only be implemented in machine code.

Of no less importance than the design of the hardware or the choice of microprocessor in the machine is the operating system. This is a large, and highly complex machine code program which governs the machine. The operating system consists of a large number of routines which perform operations such as scanning the keyboard, updating the screen, performing analogue-to-digital conversions (for the joysticks) and controlling the sound generator. All these functions are performed by the operating system and are made available to other machine code programs. A machine code program with which all users will be familiar is BASIC. This program which provides the user with an easier way of using the microprocessor s computing power constantly uses the operating system routines to get input from the keyboard and to reflect that input on the screen. BASIC recognises words of text and when it wants to use a hardware facility it calls a machine code routine within the operating system.

The great advantage of this independence of the language program from the direct use of hardware is that the same facilities can be offered to different languages.

Writing a machine code program requires the programmer to place the appropriate values into successive memory locations corresponding to the opcodes and operands. This would be a very tedious business if it had to be done by looking up the opcode values in tables and poking in the values by hand. It is much faster, easier and more efficient to get the computer to do most of the work. A program which analyses text input representing opcode symbols, converts these to opcode values and inserts these values into memory is called an assembler. The text input consists of opcode mnemonics (three-letter words which specify the opcode type) followed by numbers, variable names or expressions which give the values of the operand to be used by the opcode. Like BASIC the assembler requires the program to be written in a defined way according to a syntax. The language that an assembler understands is called assembler or assembly language. In the BBC Microcomputer an assembler is available as part of the BASIC language and a description of how this assembler can be used is contained in the chapter on the BASIC assembler.

Many of the following sections include descriptions of the various operating system routines and facilities which are available to the machine code programmer.

The command-line interpreter resident within the operating system will recognise a number of commands and act upon receiving them. These commands are most appropriately often used from the keyboard or in BASIC programs using the '*' prefix. Commands may also be passed to the command-line interpreter using the OSCLI call (&FFF7) from machine code (see section 7.12 for details of OSCLI).

Any command offered to the command-line interpreter but not recognised as a command resident in the command table is offered to paged ROMs for possible action. If it is not claimed by a paged service ROM it is presented to the currently selected filing system ROM. The filing system may recognise the command as one of its internal file commands or attempt to load and execute a file specified by the may command name (the cassette and ROM filing systems excepted), i.e. it is equivalent to '*RUN <command name>'.

Each command name may be abbreviated by using enough letters to identify the command terminated by a full stop. The minimum abbreviations for each command are noted below with the description of each command.

The command-line interpreter does not distinguish between upper and lower case characters in the command name ('*cat' has the same effect as '*CAT').

Where a string or filename is specified as a parameter the text need not be enclosed within paired quotation marks but must be separated from the command name by at least one space.

Several of the operating system commands invoke OSBYTE calls and so their action mimics these calls. Where there is an equivalent OSBYTE call this has been indicated.

A number of commands are filing system dependent. Any command which creates or uses files is described for the ROM and cassette filing systems only.

An operating system command-line with a '|', string escape character, as its first non-blank character will be ignored by the operating system. This could be used to put comment lines into a series of operating system commands placed in an EXEC file for example.

This command is directly equivalent to the *CAT command.

2.3 */<file name>

This command is treated exactly the same as typing *RUN <file name> or *<file name>. The file name is offered directly to the filing system and will not be interpreted as a command.

2.4 *BASIC (*B)

While the operating system is independent of any particular language and only serves to provide an interface between languages or utility software and the machine hardware, BASIC has been accorded special status. The *BASIC command is resident in the operating system command table and it enables the operating system to select a language in paged ROM not possessing a service entry point (for further details about paged ROMs see chapter 15). The operating system scans the paged ROMs and keeps a record of which paged ROM contains BASIC (see OSBYTE &BB/187). If a BASIC ROM is not present this command is offered to other paged ROMs.

2.5 *CAT (*.)

This command displays a catalogue of files from the selected filing system. When the cassette or ROM filing systems are selected the name of each file encountered is printed on the screen along with the block number of the last block read. When the last block is reached further information is printed out. If the default messages are selected then the length of the file will be added to the block number.

FILENAME 09 0904

If extended messages have been selected then the catalogue printout after the final block has been reached will look like this:-

FILENAME 09 0904 FFFF0E00 FFFF801F

This file is a BASIC (level 1) program SAVEed from BASIC with PAGE=&E00 and the program is &904 bytes long. The fourth field in the catalogue printout is the start address of the file and the file will *LOAD to this address by default. The fifth field is the execution address. When using level 2 BASIC the execution address will be 8023. When an attempt is made to *RUN a file the processor jumps (using JSR) to this address. The two most-significant bytes of the four-byte fourth and fifth fields are set to the machine high order address (see OSBYTE &82/130).

For details about selecting extended messages see *OPT.

2.6 *CODEx,y (*CO.) OSBYTE with A=&88 (136)

This command enables the user to incorporate his own command into the operating system command table. *CODE executes machine code indirected through the user vector (USERV) at locations &200,&201 (low-byte, high-byte). The default contents of the user vector produce the 'Bad Command' message. The machine code at USERV is entered with A=0, X=x and Y=y.

For example:

10 DIM MC% 100

20 OSASCI=&FFE3

30 USERV=&200

40 FOR opt%=0 TO 3 STEP3

50 P%=MC%

60 [

70 OPT opt%

80 .write

90 CMP #0 \ is this *CODE ?

100 BEQ code \ if *CODE call act upon it

110 BRK \ anything else, print error message

120 ]

130 ?P%=255 : P%=P%+l REM error number

140 $P%="*CODE only please"

150 P%=P%+LEN$P%

160 [

170 OPT opt% \ reset OPT

180 BRK \ op code value=0

190 .code TXA \ transfer contents of X req. to Acc.

200 JSR OSASCI \ print ASCII character

210 RTS \ return to BASIC

220 ]

230 NEXT

240 ?USERV=write MOD 256

This example prints out the ASCII character corresponding to the value of the first parameter given to the *CODE command. After this program has been run typing in '*CODE 65' or 'TX 136,65' will cause a letter 'A' to be printed. The second parameter (stored in Y) if included, is ignored.

See also *LINE

2.7 *EXEC<filename> (*E.)

Text files from the currently selected filing system can be used as if they were keyboard input using this command. A typical application might involve the setting up of a user's favourite soft key definitions which are *EXECed in at the beginning of a programming session.

See also *SPOOL and OSBYTE &C6/198.

2.8 *FXa,x,y (*F.)

OSBYTE calls may be performed directly from the keyboard using this command. A, X and Y are loaded by the operating system from the command-line parameters. Any OSBYTE call may be made using the *FX command but it is not always appropriate to make an OSBYTE call using this direct method e.g. OSBYTE calls that return values in any of the registers. The *FX command is a useful way of making those OSBYTE calls which have a direct effect from a BASIC program or from the command-line interpreter. For further information on specific *FX/OSBYTE calls refer to chapter 8.

2.9 *HELP (*H.)

Typed in on a machine containing only the operating system and BASIC ROMs this command causes the version number of the operating system to be printed out i.e.

0S 1.20

Each *HELP call is offered to any paged ROMs that are resident and these may be able to respond to further command-line parameters. e.g.

*HELP VIEW

*HELP UTILS

For more information about *HELP handling in paged ROMs see section 15.1.1 (service call 9).

2.10 *KEYn<string> (*K.)

The ten red-topped function keys, the BREAK key, the COPY key and the four cursor control keys may be set up using this command. Using *KEYn with n in the range 0 to 9 sets up the function keys. *KEYI0 can be used to program the BREAK key. Before the remaining programmable keys can be used a *FX4,2 must be performed. This disables cursor editing and enables the following soft keys:-

*KEY 11 COPY

*KEY 12 left cursor

*KEY 13 right cursor

*KEY 14 down cursor

*KEY 15 up cursor

Each time a soft key is pressed a soft key character is inserted into the keyboard buffer. The soft key characters may be calculated by adding the soft key number to &80 (128). (A soft break actually places a character of value &CA in the input buffer but this behaves identically to character &8A.)

See OSBYTEs &DD/221 to &E4/228 for more information about the function keys.

Control codes may be introduced into the string by using an 'escape' character, '|'. This acts in a similar way to the CTRL key and so 'G' gives a bell sound as the CTRL and G keys would if pressed simultaneously; '|G' actually places a character of value 7 into the soft key buffer. The '|' character may be inserted using the sequence '||' and a quotation mark (|) may be represented by preceding the quotation mark with the 'escape' character ('|'). The delete character (ASCII &7F/ 127) may be introduced using the 'escape' character followed by a question mark. Characters of value greater than 127 may be inserted by using the escape sequence ' |!'; this sequence will add 128 to the value of the next character in the string.

e.g. '|!A' 128+65=193

'|!A' 128+1=129

This method of including non-printable characters into a string may be used in any string which is processed using the operating system routines GSINIT and GSREAD (see section 7.9) and is not restricted to use of the *KEY command.

2.11 *LINE<text> (*LI.)

This command executes machine code at the location pointed to by the contents of the user vector (USERV) at locations &200,&201 (low-byte,high-byte). The command enters this code with the A=1, X=least significant byte of string address and Y=most significant byte of string address. *LINE provides

an easy method of incorporating a user function into the operating system command table.

This example program sets up the user vector to point to some machine code which prints out the string pointed to by X and Y. After this program has been run typing in

'*LINE THIS IS SOME TEXT'

results in 'THIS IS SOME TEXT' being printed out.

See also *CODE

2.12 *LOAD<filename><address> (*L.)

A file may be loaded into memory from the selected filing system using the *LOAD command. If the load address is not specified in the command line then the file will load at its start address (this is usually the address from which it was saved).

2.13 *MOTORn (*M.) OSBYTE with A=&89 (137)

This command executed with n=0 opens the cassette relay (i.e. switches the motor off) and with n=1 closes the cassette relay (i.e. motor on).

2.14 *OPTx,y (*O.) OSBYTE with A=&8B (139)

This command is highly filing-system specific and although the general protocol of the cassette filing system is usually adhered to, other filing systems may interpret this command differently and expand upon it.

For the cassette and ROM filing systems:-

*OPT 0,0 restore *OPT default values

*OPT 1,0 turn off filing system messages

*OPT 1,1 turn on filing system messages (non-extended)

*OPT 1,2 turn on extended messages

*OPT 2,0 errors ignored though messages may be given

*OPT 2,1 on error, prompt for re-try

*OPT 2,2 on error, abort

*OPT 3,n set interblock gaps to n/10 seconds (only relevent to cassette SAVE operations)

When extended messages have been selected the following information is printed on the screen on completion of the filing system operation:

file name - block no. - file length - start adr. - execution adr.

All numeric values are printed in hexadecimal.

See also *CAT

2.15 *ROM (RO.) OSBYTE with A=&8D (141)

The *ROM filing system is initialised using this command. The *ROM filing system is able to use paged ROMs or serially accessed ROMs associated with the speech processor. These ROMs must contain data in a block format similar to that used in the cassette filing system. With the ROM filing system initialised all other filing systems are disabled.

For further details see section 16.11 in the filing systems chapter.

2.16 *RUN<file name> (*R.)

This command causes a file to be loaded into memory at its start address and then the microprocessor jumps (using JSR) to the execution address. This is a method of loading and running machine code programs. Any text following the file name is available to pass parameters to the program. Parameter passing is not implemented for the cassette or ROM filing systems (see filing systems chapter 16).

2.17 *SAVE <file name> <start addr> <end addr> <exec.addr> <reload addr> (*S.)

The contents of memory may be saved to a file on the currently selected filing system using *SAVE. Only the start address and the end address are mandatory. If omitted the execution address will default to the start address. The reload address allows the start address stored with the file to be different to the actual start address used when saving. The end address may be in the form

+ length

where the second field is preceded by a '+' and the size of memory to be saved is specified in hexadecimal.

2.18 *SPOOL <filename> (*SP.)

The *SPOOL command causes all screen output to be repeated into a file. The file is opened by *SPOOL <file name> and closed by repeating this command or by typing *SPOOL alone.

See OSBYTEs &03 and &C7/199 for more information.

2.19 *TAPEn (*T.) OSBYTE with A=&8C (140)

*TAPE without any number selects cassette filing system and sets the default baud rate (1200). *TAPE3 selects tape with 300 baud and *TAPE12 selects 1200 baud.

2.20 *TVx,y (no abbreviation) OSBYTE with A=&90 (144)

The *TV command allows the vertical position of the screen to be altered and interlace to be switched on or off. The first parameter causes the vertical position to be altered; a value of 0 causes no change, a value of 1 would cause the screen to be moved up one line and a value of 255 would cause the screen to be moved down one line. The second parameter should be 0 or 1, a value of 0 causes interlace to be enabled and a value of 1 causes interlace to be switched off. Any change of interlace or screen position will only come into effect at the next mode change and will remain until a further *TV command or a hard reset. Interlace cannot be turned off in mode 7.

(It is possible to switch off interlace in mode 7 but the character set stored in the SAA 5050 is designed to be used with interlace on. Type in,

VDU23, 0,8, &90;0;0;0,23,0, 9, &09;0;0;0 and you will see why the operating system disallows this. See chapter 18 for more information about programming the 6845 video controller chip.)

One of the many attractive features of BBC BASIC is the incorporation of a mnemonic assembler within the language itself. This provides a powerful environment for the assembler and allows machine code to be easily incorporated within BASIC programs. Hybrid BASIC/machine code programs may often lead to the use of the best features of each language, the speed of machine code when it is required, coupled with the increased power of BASIC when speed is not of paramount importance.

The assembler facilities available to users are dependent on the version of BASIC that is resident in the machine. To ascertain which version of BASIC is present type 'REPORT' following a BREAK. If the copyright message is dated 1981 then this is 'old BASIC' which will henceforth be referred to as Level 1 BASIC, and if the message is dated 1982 then this is 'new BASIC' which will be referred to as Level 2 BASIC.

Below is an example of a simple machine code program written using the BASIC assembler.

This program performs some simple graphics using the BASIC VDU method to select the screen MODE and perform PLOTting. All the VDU codes are contained within the block of memory labelled 'data'. Using the operator does not make it immediately obvious what is going on. Four bytes are inserted into memory with each operator. The least significant byte being inserted at the address specified. Each subsequent byte is inserted into the next byte of memory.

i.e.

!data=&04190416

data!4=&00C800C8

will result in an equivalent to, VDU &16,&04,&19,&04,&C8,&00,&C8,&00 or, to separate it into its two components,

VDU &16,&04

VDU &19,&04,&00C8;&00C8;

or

VDU 22,4 select MODE 4

VDU 25,4,200;200; PLOT,4,200,200 - move absolute X,Y

Any program which can be written in BASIC may also be implemented in machine code although it is not always sensible to do so.

There now follows a detailed description of using the BASIC mnemonic assembler.

3.1 The assembler delimiters '[' and ']'.

All the assembler statements should be enclosed within a pair of square brackets. When the BASIC program is RUN, the assembler statements contained between the square brackets are assembled into machine code. This code is inserted directly into memory at the address specified by P% and P% is incremented by the number of bytes in each instruction or directive.

Within the assembler delimiters the text of the assembly language program may be written. The assembly language program will consist of a number of assembler statements separated by new lines or colons (as in BASIC).

Each assembler statement should consist of an optional label followed by an instruction (this will be a three letter assembler mnemonic or an assembler directive) and an operand (or address). If a label is included it should be separated from the instruction by at least one space. The operand need not be separated from the instruction. Any character following the operand and separated by at least one space from it will be totally ignored by the assembler which will move onto the next colon or line for the next statement. A comment may be placed after the operand field and should be preceded by an backslash (\). Any text following an backslash in an assembly statement will be ignored by the assembler up to the next colon or end-of-line.

N.B. In level 1 BASIC colons cannot be included in expressions. Missing out a colon in a multi-statement line will result in the statement after the intended colon being ignored by the assembler. This error is often difficult to spot in a program which assembles without error but then fails to function as the programmer had anticipated.

During assembly of the example program above the following printout is produced (with PAGE=&1900):

location label/mnemonic/address

op.code/data \ comment

OPT is an assembler directive or non-assembling statement which can be included within an assembly program to select a number of different assembler options.

The OPT command should be followed by a number to make the option selection. The assembler options are selected on the state of the least significant 2 or 3 bits of the OPT parameter.

bit 0 if set, assembly listing enabled.

bit 1 if set, assembler errors enabled.

bit 2 if set, assembled code placed in memory at O% (Implemented in Level 2 BASIC only)

In the example program above OPT is set up using the FOR.. NEXT loop variable, opt%. On the first pass of the assembler OPT 0 is used, listing is suppressed and assembler errors are not enabled. For the second pass an OPT 3 is used which switches on assembly listing and enables assembler errors. BASIC errors will be flagged as normal. The assembler errors which are suppressed are the 'Branch out of range' error and the 'No such variable' error. These will normally be generated during the first pass when the assembler is resolving forward passes (see section 3.5).

Bit 2 allows a program to be assembled into one region of memory while being set up to run at a different address. P%, the program counter (see below) should be set up as usual to provide the source of label values. If bit 2 is set then 0% should be set up at the same time as P% to point to the start of memory into which the machine code is to be assembled. This facility is useful for assembling machine code where it is impossible to use the memory in which the program is eventually going to reside (e.g. Assembling programs which are going to be blown into EPROM for paged ROMs). This option is only available in Level 2 BASIC.

Each time the assembler is entered the OPT value is initialised to 3. This means that a second chunk of assembler in the same BASIC program must perform its own OPT selection.

When the assembler is creating the machine code program the code produced is placed in memory starting from the address in P% (one of the resident integer variables) unless remote assembly has been selected using OPT (see section 3.2).

The programmer must set P% to a meaningful value before the assembly begins. The usual method for short programs is to DIMension a block of memory and to set P% to this value at the beginning of each pass of the assembler (as in the example above). A classic problem is sometimes encountered when a programmer adds more code to a short program which has been allocated space by this method. If the code created overflows the space DIMensioned for it and is over-written by BASIC, it will fail to operate as expected when tested; alternatively the code may over-write the BASIC dynamic storage and a 'No such variable' error will be flagged during the second pass of the assembler.

The assembler updates P% as it is assembling and when it reaches the end of a pass the value of P% represents the address of the first 'free' byte of memory after the machine code program.

Any BASIC numerically assignable item may be used as a label with the assembler (such as a variable or an array element). A label is defined by preceding the variable name with a full stop. The full stop prefix causes the assembler to set up a BASIC variable containing the current value of P%. Once set up this variable is available for use by any other part of the assembler or BASIC program.

In the construction of a machine code program using the BASIC assembler a large number of labels may be generated. It is often the case that one part of the program needs to jump forward over another part of the program. Labels provide a convenient way of marking that point in the program to

which the processor is to jump. When assembling the machine code, the assembler works sequentially through the program and in the case of a forward reference the assembler will encounter the reference before the label. In the normal course of events an error will be flagged (No such variable). In order to resolve forward references, two passes of the assembler are required. The first pass should be performed with error trapping switched off and during this pass all the labels will be initialised. A second pass will provide all the correct values required for forward referencing. During this second pass error trapping should be enabled to pick up any genuine programming mistakes.

The most convenient way of performing the two passes is to use a FOR... NEXT loop. The programmer should make sure that P% is reinitialised at the beginning of the second pass. It is often convenient to set up the pseudo-operation OPT using the FOR loop variable (errors and listing disabled for the first pass, errors enabled and listing as required for the second).

One of the improvements made to Level 2 BASIC was the incorporation of some EQU pseudo-operation commands. These allow the incorporation of data by reserving memory within the body of the assembly language program.

The EQUate operations available are:-

EQUB equate byte reserves 1 byte of memory

EQUW equate word reserves 2 bytes of memory

EQUD equate double word reserves 4 bytes of memory

EQUS equate string reserves memory as

required

These operations initialise the reserved memory to the values specified by the address field. The address field may contain a string, in double quotes, or string variable for the EQUS operation or a number or numeric variable for the other EQU operations. The assembler will use the least significant part of the value if too large a value is specified.

The example program, written in Level 2 BASIC, could have been written with lines 30 and 170 to 240 replaced with:-

In Level 1 BASIC one way to reserve space for data within the body of a machine code program is to leave the assembler using a right-hand square bracket and insert the data using the address contained in P%. P% should then be incremented by the appropriate amount before entering the assembler.

e.g. to incorporate a string into a machine code program.

This program prompts the user to press the TAB key by printing out a message. If the wrong key is pressed an error is flagged.

In the example program above the BRK instruction is used to generate an error. The BRK instruction forces an interrupt which is interpreted by the operating system as an error. As part of the error handling in BASIC the programmer can incorporate an error number and an error message into his code to identify the error. The byte in memory following the BRK instruction should contain the error number. The error message string should follow the error number and must be terminated by a zero byte.

The following lines set this up:-

270 ?P%=&FF Error number 255

280 P%=P%+l

290 $P%'Wrong key pressed" Error message

When a BRK is encountered in a machine code program called from BASIC the error message is printed out together with the line number from which the machine code was called. Typing 'REPORT' or printing ERR will reproduce the message and error number as with any BASIC error.

The user can provide his own BRK handling routine which may be useful when using machine code away from the BASIC environment (see section 10.2 for more information about the BRK vector).

Machine code routines can be entered from a BASIC program using either the CALL statement or the USR function. On entry to the machine code program using these instructions, the accumulator, the X register, the Y register and the carry flag are set to the least significant bytes (or bit) of the resident integer variables A%, X%, Y% and C%. A number of parameters may be passed to the machine code routine if the

CALL statement is used, the addresses and data types of these parameters being available to the machine code in a parameter block at location &600. The USR function allows the machine code routine to return a value to the BASIC program made up from the register contents. For more details of CALL and USR refer to the 'USER GUIDE'.

Working within the BASIC environment it is possible to use BASIC functions to implement these higher level assembly language structures.

Conditional assembly is a method of varying the code assembled according to a test. All the facilities of BASIC are available for setting up the test criteria. Typical applications for conditional assembly include the conditional incorporation of debugging routines and selecting different hardware specific sub-routines from a number of alternatives.

A macro is a group of assembler statements which may be inserted into the assembler program when called. A macro may be thought of as being a type of sub-routine which is used to include a portion of assembler used more than once within a program. A number of statements which are likely to be used more than once can be enclosed within assembler delimiters and placed within either a sub-routine (called using GOSUB and terminated by RETURN), or a function definition or a procedure definition. Using a procedure or a function is the best way to implement macros because the programmer is then able to pass parameters to the macro and the procedure/function name serves to identify the macro.

e.g.

This highly contrived program adds two bytes together. It uses a macro within which conditional assembly occurs. Hanging a function on the end of an OPT command enables the programmer to call the macro in a tidy manner. If FNdebug is called with the value TRUE then some code which saves the registers in zero page is inserted into the program otherwise an RTS instruction is inserted. The function returns with the value to which OPT was set in the first place. This example indicates how the close inter-relation of the mnemonic assembler with BASIC results in a very powerful assembler. The programmer should always remember that BASIC is always available as an aid when using the BASIC assembler.

32 bytes of zero page locations are reserved by BASIC for the users machine code programs. These locations are from &70 to &8F (inclusive). These are the only zero page locations that a user program (resident in RAM) should use if the program is to be made commercially available or run on a variety of other BBC Microcomputers.

The locations from &0 to &6F which are part of BASIC's zero page workspace are available to the machine code program if BASIC is not required while the code is running.

Depending on the nature of the machine code program other zero page locations may be available. See chapter 11, memory usage, for more details.

The 6502 microprocessor normally performs all arithmetic using the 2's complement method of representing numbers. In 2's complement representation the most significant bit of the value is a sign bit. If the most significant bit is clear then the number is positive. The remaining bits represent the binary value of the positive number. Negative values are represented by the complement of the positive value plus 1. The complement of any binary value is made by 'flipping' each bit (i.e. changing each 1 to a 0 and each 0 to a 1). When negative values are represented by the complement of the positive value this is called l's complement. The disadvantage with l's complement is that there are two ways of representing 0, a positive 0 (all bits clear) and a negative 0 (all bits set). By adding one to the complemented value (2's complement) there is only one way of representing 0 (all bits clear).

e.g. Using 8 bits to store a value

5= 00000101, -5 = 11111010 = 111111011

and -5 + 5

11111011 -5

00000101 +5

00000000 =0 (ignore the carry from the last bit)

Numbers in the range -128 (10000000) to +127 (01111111) can be represented using 8 bit 2's complement values.

Using 2's complement arithmetic the same addition and subtraction operations work identically on negative and positive numbers. Negative numbers can be always be

recognised by the state of the most significant bit; this is always set for negative numbers.

The 6502 microprocessor can only perform its arithmetic operations using 8 bit values. This limitation can lead to errors when a carry is generated on the most significant bit so that the result cannot be stored in 8 bits. The sign bit may also be wrongly changed when a carry occurs into it. Two flags in the status register are set when certain conditions occur. These flags are the carry flag and the overflow flag.

The carry flag is set when a carry is generated during an addition operation if a carry is generated from bit 7 (i.e. the carry flag is a ninth bit of the result). The carry flag is cleared if a borrow occurred into bit 7 during a subtraction. The addition and subtraction instructions on the 6502 include the carry bit in the operation. Using the carry bit makes it possible to perform multi-byte arithmetic. The examples for ADC and SBC in the mnemonics section illustrate how the carry flag may be used.

The overflow flag is set when the sign of the result is incorrect following an arithmetic operation. During additions overflow will occur in two situations

(a) When a carry occurs from bit 6 into bit 7 without the generation of an external carry.

(b) When an external carry is generated without a carry occurring from bit 6 into bit 7.

During subtractions the carry flag is used as a borrow source. The overflow flag will be set in the analogous situations where borrows occur rather than carries. When the overflow flag is set it indicates that the 2's complement 8 bit result of an arithmetic operation is incorrect.

It is often more convenient to think of bytes as always containing positive values. The eight bits of the byte can represent a maximum binary value of 255 (&FF). This is no problem because the microprocessor performs exactly the same arithmetic operations regardless of the sign of the values involved. When the result of any arithmetic operation has bit 7 set then a negative flag is set in the status register. The programmer can test this flag if the program must react to negative values. The overflow and carry flags will also be set as described above.

A binary coded decimal arithmetic mode may be selected by setting the decimal flag in the status register. The binary coded decimal form of representing numbers uses each byte to store a two digit decimal value. Each digit is stored as a binary value in 4 bits (1 nibble). Normally 4 bits can be used to represent numbers in the range 0 to 15. In BCD arithmetic 6 of the values that could be represented in 4 bits are not used. Adding 1 to 9 in BCD will cause the low-nibble to be set to 0 and the high nibble to be set to 1. The carry flag is used to store the carry from the high-nibble.

This is an example of a program which uses BCD arithmetic.

This program could be altered to subtract 1 each time a key is pressed by changing line 100 to SEC and changing the ADC instructions in lines 120 and 150 to SBC instructions.

The decimal flag must always be cleared before using operating system routines.

There is no standard representation of negative numbers using BCD. In order to implement more complex arithmetic including floating point applications the programmer must define his own conventions and number formats.

When an assembly language instruction needs some data or an address to work on this must be provided in the operand field of the assembler statement. Although there are a limited number of different machine code instructions which can be used with the 6502, the power of the instruction set is enhanced by a number of different addressing modes by which the data or addresses used by each instruction may be provided. The addressing mode used by the assembler depends on the syntax of the assembly language statement. The following text describes how the different addressing modes work and the assembler syntax which is necessary.

N.B. Not all addressing modes are available for all instructions. Details of which addressing modes can be used with which instructions are contained in the Assembler Mnemonics section 6.2.

Many instructions do not require any addressing mode to be specified in the operand field. In such cases the addressing is implicit in the instruction itself. For example an RTS instruction will always cause the processor to jump to the location addressed by the top two bytes of the stack.

Some instructions may operate on either a memory location or the accumulator. The accumulator is specified by putting a capital A in the operand field.

e.g.

(Note that the variable A cannot therefore be used as an operand.)

If, at the time of programming, the data required for a machine code instruction is known then immediate addressing may be used. Immediate addressing is indicated to the assembler by preceding the operand with a '#' character. The assembler uses the least significant byte of the value given to define the operand. The machine code instruction actually uses the byte of memory immediately following the instruction in program memory.

e.g.

When the address required for an instruction is known at the time of assembly then absolute addressing may be used. Absolute addressing is the default addressing mode used by the assembler. If a number or variable is placed in the operand field of the assembler it will be treated as a 16 bit effective address.

e.g.

5.5 Zero page addressing - using a fixed zero page address

This mode is the same as absolute addressing except that an 8 bit address is specified. This 8 bit addressing limits use to the first &100 bytes of memory (zero page). The assembler will automatically select zero page addressing when the operand value is less than 256 (&100).

e.g.

5.6 Indirect addressing - using an address stored in memory

Using this addressing mode an instruction can use an address which is actually computed when the program runs. The JMP instruction may use this addressing mode. The address used for the jump is taken from the two bytes in memory starting at the address specified in the operand field (low byte first, high byte second). Indirect addressing is indicated to the assembler by enclosing the address within brackets.

e.g.

LDA #&40 \ load accumulator with &40

STA &1900 \ store low byte of indirection

LDA #&28 \ load accumulator with &28

STA &1901 \ store high byte of indirection

N.B. A JMP &2840 instruction would have been more sensible in this case.

There is a bug in the 6502. When the indirect address crosses a page boundary the 6502 does not add the carry to calculate the address of the high byte.

i.e. JMP (&19FF) will use the contents of &19FF and &1900 for the JMP address.

The following 5 addressing modes use the X or Y registers as an offset which is used to modify another address specified in the operand field. These addressing modes give the program access to a table of memory locations specified in terms of a base address to which is added the 8 bit offset value.

These are the simplest indexed addressing modes. An absolute 16 bit address is specified in the operand field. This should be followed by a comma and either X or Y. The address used by the instruction will be the 16 bit address + the contents of the register specified.

The X and Y register contents are always taken as positive values in the range 0 to 255 and so only forward offsets are available (c.f. Relative addressing, below).

e.g.

LDA &2800,X \ load accumulator from &2800+X

ADC table,Y \ A=A+?(table+Y)

5.8 Zero page,X addressing - using zero page address+X

This mode is the same as the absolute X addressing mode except that an 8 bit base address is used. The assembler automatically uses this mode, where available, if a zero page address is specified in the operand field.

If a variable is used to describe the address of the zero page location it should be set up before the first pass of the assembler. This is because the assembler will assume 16 bit addressing on the first pass if the variable is unrecognised and allocate two bytes for the address. On the second pass, the zero-page opcode and one byte of address will be assembled, causing all further label values to be wrong.

N.B. For the LDX instruction a zero page,Y addressing mode is provided.

e.g.

This addressing mode is designed for use with a table of addresses in zero page locations. The operation is performed on a memory location, the address of which is contained within the zero page locations specified by an 8 bit base address plus the contents of the X register.

N.B. The Y register cannot be used for this addressing mode.

5.10 Post-indexed indirect addressing - using an indirect address in zero page plus offset in Y

This indexed indirect addressing mode uses a single address held in zero page. The contents of the Y register are then added to that address held in zero page to give the effective address used.

N.B. The X register cannot be used for this addressing mode.

e.g.

Set 256 bytes of memory to 0 starting at the address contained in locations &80 (low byte) and &81 (high byte).

The 6502 instruction set contains 8 branch instructions which cause a jump if a certain condition is met. In the example above a BNE instruction is used to cause the loop to be executed again if the loop index (Y register) does not equal 0. These branch instructions can only be used with relative addressing. If the condition of the branch is satisfied the byte following the branch instruction is added to the program counter as an 8 bit two's complement number. This method of relative addressing allows a branch forward 127 bytes or back 128 bytes from the program counter value after the branch instruction has been executed. The calculation of the relative branch value is normally quite transparent to the programmer using the BASIC assembler. When writing in assembly language the programmer follows the branch instruction with a label or absolute address and the assembler performs the necessary calculations. The use of relative addressing will only become apparent when a label or absolute address is specified outside the relative addressing range. When this occurs the assembler will flag an 'Out of range' error to the user. OPT 0 is used to suppress this error from forward references on the first assembler pass.

Accumulator - A

An 8 bit general purpose register used for all the arithmetic and logical operations.

X Index Register - X

An 8 bit register used as the offset in indexed and pre-indexed indirect addressing modes, or as a counter.

Y Index Register - Y

An 8 bit register used as the offset in indexed and post-indexed indirect addressing modes, or as a counter.

An 8 bit register containing various status flags and an interrupt mask. These are:-

Carry flag - C

Bit 0, Set if a carry occurs during an add operation and cleared if a borrow occurs during subtraction. Used as a 9th bit in rotate and shift operations.

Zero flag - Z

Bit 1, Set if the result of an operation is zero, otherwise cleared.

Interrupt disable - I

Bit 2, When set, IRQ interrupts are disabled. Set by the processor during interrupts.

Decimal mode flag - D

Bit 3, When set the add and subtract instructions work in binary coded decimal arithmetic. When clear these operations are performed using binary arithmetic.

Break flag - B

Bit 4, This flag is set by the processor during a BRK interrupt. Otherwise this flag is clear.

Bit 5, Unused by the processor.

Overflow flag - V

Bit 6, If, during an operation, there is a carry from bit 6 to bit 7 and no external carry then the overflow flag is set. This flag is also set if there is no carry from bit 6 to bit 7 but there is an external carry.

Negative flag - N

Bit 7, Set if bit 7 of a result is set, otherwise cleared.

Stack Pointer - SP

An 8 bit register which forms the low order byte of the address of the next free stack location (the high order byte of this address is always &1).

Program Counter - PC (PCL,PCH low-byte,high-byte)

A 16 bit register which always contains the address of the next instruction to be executed.

The following section contains a detailed description of each of the operation codes (or instructions) in the 6502 instruction set. The assembler recognises three letter mnemonics which it It translates into the 8 bit values which the microprocessor actually takes as its instructions.

Each assembler mnemonic is described on a new page. At the head of the page is the three letter mnemonic which the assembler recognises.

Beneath the heading there is a short phrase indicating the function of the instruction and the derivation of the mnemonic.

A short hand 'BASIC like' description of the operation is given on the top right of the page. The registers and flags are denoted by the abbreviations given on the previous two pages. The initial 'M' represents the data byte obtained using the selected addressing mode.

A brief description of the instruction and its operation is given beneath the headings.

Any changes to the status register are noted in a list of the status register flags.

All the available addressing modes are listed together with the number of bytes of memory which the instruction and its data will occupy when this mode is used. The number of instruction cycles taken for the execution of the instruction in each addressing mode is also given (1 instruction cycle=0.5 microseconds).

A short example of the use of the instruction within an assembly language routine is given at the bottom of each page.

This instruction adds the contents of a memory location to the accumulator together with the carry bit. If overflow occurs the carry bit is set, this enables multiple byte addition to be performed.

Processor Status after use

C (carry flag): set if overflow in bit 7

Z (zero flag): set if A=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): set if sign bit is incorrect

N (negative flag): set if bit 7 set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute, X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect,X) 2 6

(indirect),Y 2 5 (+1 if page crossed)

Example: Add 1 to a 2 byte value in locations &80 and &81

CLC \ clear carry flag

LDA #1 \ load accumulator with 1

ADC &80 \ A=A+?&80, carry set if overflow occurs

STA &81 \ place result of addition in 680

LDA #0 \ set accumulator to 0 (carry unchanged)

ADC &81 \ A=A+?&81+C, add 1 if carry set

STA &81 \ store result back in &81

Logical AND A=A AND M

A logical AND is performed, bit by bit, on the accumulator contents using the contents of a byte of memory. The truth table for the logical AND is:-

0 0 0

0 1 0

1 0 0

1 1 1

Processor Status after use

C (carry flag): not affected

Z(zero flag): set if A=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect, X) 2 6

(indirect),Y 2 5 (+1 if page crossed)

Example: Clear the top 4 bits of location &80

Arithmetic Shift Left M=M*2, C=M7 (or accumulator)

This operation shifts all the bits of the accumulator or memory contents one bit left. Bit 0 is set to 0 and bit 7 is placed in the carry flag. The effect of this operation is to multiply the memory contents by 2 (ignoring 2's complement considerations), setting the carry if the result will not fit in 8 bits.

Processor Status after use

C (carry flag): set to old contents of bit 7

Z (zero flag): set if result=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

accumulator 1 2

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7

Example: Rapid multiplication of memory contents by 4

ASL data \ ?data=?data*2

ASL data \ ?data=?data*2, gross effect *4.

Branch on Carry Clear Branch if C=0

This instruction causes a relative jump if the carry flag is clear. The address to which the branch is directed must be within relative addressing range otherwise the assembler will throw up an 'Out of range' message.

Used after a CMP instruction this branch occurs when A<DATA.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2(+1 if branch

succeeds +2 if to new

page)

Example: Branch if contents of &80 < 100

LDA #100 \ load accumulator with data

CMP &80 \ A-data (comparison)

BCC finish \ goto finish if ?&80<100

A relative branch will occur if the carry flag is set. The branch address given to the assembler must be within relative addressing range.

Used after a CMP instruction this branch occurs when A>=data.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds ±2 if to new

page)

Example: Branch if contents of X register are greater than or equal to 5

Branch on result zero Branch if Z = 1

This instruction causes a relative branch if the zero flag is set when the instruction is executed. The assembler automatically calculates the relative address from the address given and will cause an error if the address is out of range.

Used after a CMP instruction this branch occurs if A=data.

Used after an LDA instruction this branch occurs if A=0.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds ±2 if to new

page)

Example: Subroutine not used when A=3

CMP #3 \ A-3, comparison

BEQ over \ if A=3 goto over

JSN anything \ subroutine to be missed if A=0

.over .....

Test memory bits with accumulator A AND M, N=M7, V=M6

This instruction can be used to test whether one or more specified bits are set. The zero flag is set if the result is 0 otherwise the zero flag is cleared. Bits 7 and 6 of the memory location are transferred to the status register. The BIT instruction performs an AND operation without storing the result but setting the status flags.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if the result=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): set to bit 6 of memory

N (negative flag): set to bit 7 of memory

zero page 2 3

absolute 3 4

Example: Test bit 7 of location &8F

LDA #&02 \ load mask into accumulator (000000l0)

BIT flags \ A AND flags, if bit 1=1 then Z=0

BNE flag set \ action to be performed if bit 1 set

Branch if negative flag set Branch if N=1

This relative branch is performed if the result of a previous operation was negative. Relative branch calculations are made by the assembler which will flag an error if an address is given outside the relative addressing range.

Branch occurs after a result which sets bit 7 of the accumulator. (All 8 bit 2's complement negative numbers have this bit set.)

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (±1 if branch

succeeds +2 if to new

page)

Example: Branching if a byte of memory contains a negative number

Branch on result not zero Branch if Z=0

This instruction causes a relative branch if the zero flag is clear when the instruction is executed. The assembler automatically calculates the relative address from the address given and will cause an error if the address is out of range.

Used after a CMP instruction this branch occurs if A<>data.

Used after an LDA instruction this branch occurs if A<>O.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds ±2 if to new

page)

Example: Memory location to be written to if it contains zero

(i.e. IF ?&84=0 then ?&84=&7F)

LDA &84 \ load memory into A to set flags

BNE round \ if not zero skip the next bit

LDA #&7F \ lead A with value to he written

STA &84 \ write to location &84

.round ... . \ rest of program

Branch on positive result Branch if N=0

Depending on the state of the negative flag a relative branch will be made. The relative address is calculated by the assembler from an address provided by the programmer. This address must be within the relative addressing range.

Branch occurs after a result which sets accumulator bit 7 to 0. Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds +2 if to new

page)

Example: A loop which shifts A left until bit 7 is set

.loop ASL A \ shift accumulator 1 hit left

N.B. This will be an endless loop if A=0 on entry.

Forced Interrupt PC and P pushed on stack

PCL = ?&FFFE, PCH = ?&FFFF

This instruction forces an interrupt to occur. The processor jumps to the location stored at &FFFE. The program counter is pushed onto the stack followed by the status register. A BRK instruction usually represents an error condition and the BRK handling code is usually an error handling routine. Using machine code in a BASIC environment it is possible to use BASIC's error handling facilities, see section 3.7. A user BRK handling routine may be implemented, see Vectors section, section 10.2.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): set

V (overflow flag): not affected

N (negative flag): not affected

implied 1 7

N.B. A BRK instruction cannot be disabled by setting the interrupt disable flag.

Example: Cause an error if A is greater than 4

CMP 45 \ A-S. comparison

BCC noerr \ if A<5 then branch round error

Branch if overflow clear Branch if V=0

A relative branch is made if the overflow flag is clear. The relative address calculation is performed by the assembler which will flag an error if given an address out of relative addressing range.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds +2 if to new

page)

Example: Branching on overflow when carry is deliberately set

Branch if overflow set Branch if V= 1

Branch to a relative address if the overflow flag is set. Overflow is generally set when the carry flag is set except when a subtraction is performed. In this case overflow is set when the carry flag is cleared. The address specified in the operand field of the assembler statement must be within the relative addressing range otherwise an assembly error will be flagged.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

relative 2 2 (+1 if branch

succeeds +2 if to new

page)

Example: Branching if overflow occurs during subtraction

N.B. A BCC instruction would have performed the same purpose in this instance.

Clear carry flag C=0

This instruction clears the carry flag. This is often a sensible operation to perform before using an ADC instruction if there is any doubt as to the status of the carry flag.

Processor Status after use

C (carry flag): cleared

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Clearing the carry flag before an 8 bit addition

Clear decimal flag D=0

This flag is used to place the 6502 into decimal mode. This instruction returns the processor into non-decimal mode. See machine code arithmetic, chapter 4.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): cleared

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Turn decimal mode off

Clear interrupt disable flag I=0

This instruction is used to re-enable interrupts after they have been disabled by setting the interrupt flag. In a machine where the operating system relies heavily on interrupts it is unwise to play around with the interrupt flag without good reason. For information about interrupts see chapter 13.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): cleared

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Re-enabled interrupts

Clear the overflow flag V=0

This instruction forces the overflow flag to be cleared.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): cleared

N (negative flag): not affected

implied 1 2

Example: Explicitly clear the overflow flag

Compare memory and accumulator A-M

This is a very useful instruction for comparing the accumulator contents to the contents of a memory location. The status register flags are set according to the result of a subtraction of the memory contents from the accumulator. The accumulator contents are preserved but the status register flags may be used to cause branches depending on the values which were compared.

Processor Status after use

C (carry flag): set if A greater than or equal to M

Z (zero flag): set if A=M

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect),X 2 6

(indirect,Y) 2 5 (+1 if page crossed)

Examples: Branching on the result of a comparison

A>M or M<A BEQ over (or BEQ P%+4, no label)

A<=M or N> =A BCC somehwere

This instruction performs a subtraction of the contents of the memory location from the contents of the X register, the memory location and the register remain intact but the status register flags are set on the result.

Processor Status after use

C (carry flag): set if X greater than or equal to M

Z (zero flag): set if X=M

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

immediate 2 2

zero page 2 3

absolute 3 4

Example: Clearing an area of memory (max &100 bytes). The number of bytes to be cleared is stored in 'count'.

LDA #0 \ set accumulator to 0

.loop STA page,X \ write 0 to byte page+X

INX \ increment loop index

CPX count \ X-?count, comparison

Compare memory with Y register Y-M

This instruction performs a subtraction from the Y register of the specified memory location contents. The memory location and the register remain intact but the status register flags are set on the result.

Processor Status after use

C (carry flag): set if Y greater than or equal to M

Z (zero flag): set if Y=M

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

immediate 2 2

zero page 2 3

absolute 3 4

Example: Branch if Y=&0D

Decrement memory by one M=M-1

This instruction decrements the value contained in the specified memory location.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if memory contents become 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7

Example: Decrement location &2900

Decrement X register by one M=M-1

This instruction decrements the contents of the X register by one.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if X becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of X becomes set

implied 1 2

Example: Decrement X register

Decrement the Y register by one Y=Y-1

This instruction decrements the contents of the Y register by one.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if Y becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of Y becomes set

implied 1 2

Example: Decrement Y register

Exclusive OR memory with accumulator A=A EOR M

This instruction performs a bit by bit Exclusive OR of the specified memory location contents with the contents of the accumulator leaving the result in the accumulator. The truth table for the logical EOR operation is:-

0 0 0

0 1 1

1 0 1

1 1 0

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if A becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A becomes set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect, X) 2 6

(indirect), Y 2 5 (+1 if page crossed)

Example: EOR contents of memory with &FF

Increment memory by one M=M+1

This instruction increments the value contained in the specified memory location.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if memory contents become 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of memory becomes set

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7

Example: Increment location &80

Increment X register by one X = X + 1

This instruction increments the contents of the X register by one.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if X becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of X becomes set

implied 1 2

Example: Increment X register

Increment the Y register by one Y=Y+1

This instruction increments the contents of the Y register by one.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if Y becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of Y becomes set

implied 1 2

Example: Increment Y register

Jump to new location PC - new address

This instruction is the machine code equivalent of a GOTO statement in BASIC. An indirect addressing mode is available where the address for the JMP is contained in memory specified by the address in the operand field (see examples below).

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

absolute 3 3

indirect 3 5

Examples: A direct jump

An indirect jump (a contrived example)

Jump Subroutine Push current PC onto stack; PC=new address

This instruction causes a jump but also saves the current program counter on the stack. The subroutine which is called returns to the part of the program that called it by pulling the saved address and jumping back to it. A subroutine must always be terminated by an RTS instruction which performs the return to the location from which the subroutine was called.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

absolute 3 6

Examples: Using an OS call

Load accumulator from memory A=M

This instruction is used to set the contents of the accumulator to that contained in a specified byte of memory.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if A=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect, X) 2 6

(indirect),Y 2 5 (+1 if page crossed)

Example: Load accumulator with ASCII value for 'A'

Load X register from memory X=M

This instruction is used to set the contents of the X register to that contained in a specified byte of memory.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if X=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of X set

immediate 2 2

zero page 2 3

zero page,Y 2 4

absolute 3 4

absolute,Y 3 4 (+1 if page crossed)

Example: Load X register with contents of location &80

Load Y register from memory Y=M

This instruction is used to set the contents of the Y register to that contained in a specified byte of memory. Processor Status after use

C (carry flag): not affected

Z (zero flag): set if Y=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of Y set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 4 (+1 if page crossed)

Example: Load Y register with contents of location labelled 'data' with an offset in X

Logical Shift Right by one bit M=M/2 (or A)

This instruction causes each bit in the memory location or accumulator to shift one bit left. Bit 7 is set to 0 and the carry flag will be set to the old contents of bit 0. The arithmetic effect of this is to divide the value by 2.

0 > 76543210 > C

Processor Status after use

C (carry flag):set to bit of operand

Z (zero flag): set if result=0

I (interrupt disable): not affected

D (decimal mode flag):not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): cleared

accumulator 1 2

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7 (+1 if page crossed)

Example: Shift accumulator contents right one bit

This is a dummy instruction which has no effect on any memory or register contents except to increment the program counter by one.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: A NOP instruction

OR memory with accumulator A=A OR M

This instruction performs a bit by bit logical OR operation between the contents of the accumulator and the contents of the specified memory and places the result in the accumulator. The truth table for logical OR is:-

0 0 0

0 1 1

1 0 1

1 1 1

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if A=0

I (interrupt disable): not affected

D(decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A set

immediate 2 2

zero page 2 3

absolute 2 4

absolute,X 3 4 (+1 if page crossed)

absolute, Y 3 4 (+1 if page crossed)

(indirect,X) 2 6

(indirect), Y 2 5 (+1 if page crossed)

Example: Set the top 4 bits of the accumulator

Push accumulator onto stack Push A

This instruction places the value held in the accumulator onto the stack. This value is accessible using the instruction PLA (pull A from stack).

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 3

Example: Save registers at the beginning of a routine

.entry PHP \ save status register (see below)

PHA \ save accumulator contents

TXA \ A=X

PHA \ save X register contents

TYA \ A=Y

PHA \ save Y register contents

.... \ rest of program

Push Status register onto stack Push P

This instruction places the value held in the status register onto the stack. This value is accessible using the instruction PLP (pull P from stack).

Processor Status after use

C (carry flag):not affected

Z (zero flag): not affected

J (interrupt disable): not affected

D (decimal mode flag):not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 3

Example: See the example given for PHA above.

Pull accumulator off stack Pull A

This instruction loads the accumulator with a value which is pulled from the stack. This is usually a previous accumulator value which has been saved on the stack using a PHA instruction.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if Ar=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A set

implied 1 4

Example: Restore registers at the end of a routine

Pull status register off stack Pull P

This instruction loads the status register with a value which is pulled from the stack. This is usually a previous status register value which has been saved on the stack using a PHP instruction.

Processor Status after use

C (carry flag): bit 0 from stack

Z (zero flag): bit 1 from stack

I (interrupt disable): bit 2 from stack

D(decimal mode flag): bit 3 from stack

B (break command): bit 4 from stack

V (overflow flag): bit6from stack

N (negative flag): bit 7 from stack

implied 1 4

Example: See the example for PLA above.

Rotate one bit left M=M*2, M0=C, C=M7 (A or M)

This instruction causes a shift left one bit. The bit shifted out of the byte, bit 7, is placed in the carry flag. The contents of the carry flag are placed in bit 0.

<76543210 < C <

|_____________|

Processor Status after use

C (carry flag): set to old value of bit 7

Z (zero flag): set if result=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

accumulator 1 2

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7

Example: Rotate accumulator contents one bit left

N.B. The carry flag state should be known before this operation is performed.

Rotate one bit right M=M/2, M7=C, C=M0 (A or M)

This instruction causes a shift right one bit. The bit shifted out of the location, bit 0 is placed in the carry flag. The contents of the carry flag are placed in bit 7.

>76543210>C

|___________|

Processor Status after use

C (carry flag): set to old value of bit 0

Z (zero flag): set if result=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of the result is set

accumulator 1 2

zero page 2 5

zero page,X 2 6

absolute 3 6

absolute,X 3 7

Example: Reverse the order of bits in a byte

.start STA &80 \ store byte in &80

.loop ROL &80 \ bit 7 of &80 to carry

ROR A \ carry to bit 8 of A

DEX \ decrement loop count

BNE loop \ if not 0 goto loop

Return from Interrupt Status register and PC pulled from stack

This instruction is used to return from an interrupt handling routine. When an interrupt occurs the current program counter and status register are pushed onto the stack. These are restored by the RTJ instruction.

Processor Status after use

C (carry flag): bit 0 from stack

Z (zero Hag): bit 1 from stack

I (interrupt disable): bit 2 from stack

D (decimal mode flag): bit 3 from stack

B (break command): bit 4 from stack

V (overflow flag): bit 6 from stack

N (negative flag): bit 7 from stack

implied 1 6

Example: Instruction at the end of an interrupt handling routine

Return from subroutine Pull PC from stack

The RTS instruction is used to terminate the execution of a subroutine. Any routine terminated in this way should be called using a JSR instruction which places a return address on the stack. The top two stack values are placed in the program counter and execution is resumed at the point in the program after the JSR instruction. During a subroutine the same number of items pushed on the stack must be removed before the RTS instruction is reached if the subroutine is to return to the correct address.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag):not affected

implied 1 6

Example: Last instruction in a subroutine

Subtract memory from accumulator with carry A,C=A-M-(1-C)

This instruction subtracts the contents of the specified memory from the accumulator contents leaving the result in the accumulator. If the carry flag is used as a 'borrow' source and if clear then an extra unit is subtracted from the accumulator. This enables the 'borrow' to be carried over in multi-byte subtractions (see example below).

Processor Status after use

C (carry flag): cleared if a borrow occurs

Z (zero flag): set if result=0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): set if the sign of the result is wrong

N (negative flag): set if bit 7 of the result is set

immediate 2 2

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute, X 3 4 (+1 if page crossed)

absolute,Y 3 4 (+1 if page crossed)

(indirect, X) 2 6

(indirect), Y 2 5 (+1 if page crossed)

Example: 16 bit value at locations &80 and &81 subtracted from 16 bit value at locations &82 and &83, result at locations &82 and &83.

Set carry flag C=1

This instruction is used to set the carry flag. This instruction should be used to set the carry flag prior to a subtraction unless the carry flag has been deliberately left as a 'borrow' from a previous subtraction.

Processor Status after use

C (carry flag): set

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Explicit setting of the carry flag

Set decimal mode D=1

This instruction is used to place the 6502 in decimal mode. This causes arithmetic operations to be performed in BCD mode

See machine code arithmetic, chapter 4. Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): set

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Set decimal mode for arithmetic

Set interrupt disable flag I=1

This instruction is used to set the interrupt disable flag. When this flag is set maskable interrupts cannot occur. See interrupts chapter 13.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): set

D (decimal mode flag):not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Disable interrupts

Store accumulator contents in memory M=A

This instruction is used to copy the contents of the accumulator into a memory location specified in the operand field.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

zero page 2 3

zero page,X 2 4

absolute 3 4

absolute,X 3 5

absolute,Y 3 5

(indirect,X) 2 6

(indirect),Y 2 6

Example: Store accumulator in location 'save' + Y offset

Store X contents in memory M=X

This instruction is used to copy the contents of the X register into a memory location.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

zero page 2 3

zero page,Y 2 4

absolute 3 4

Example: Store X in location &80

Store Y contents in memory M=Y

This instruction is used to copy the contents of the Y register into a memory location.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

zero page 2 3

zero page,X 2 4

absolute 3 4

Example: Store Y in location &5FFO

Transfer A to X X=A

This instruction is used to copy the contents of the accumulator to the X register.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if X becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of X is set

implied 1 2

Example: Transfer contents of A to X

Transfer A to Y Y=A

This instruction is used to copy the contents of the accumulator to the Y register.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if Y becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of Y is set

implied 1 2

Example: Transfer contents of A to Y

Transfer S to X X = S

This instruction is used to copy the contents of the stack pointer to the X register.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if X becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of X is set

implied 1 2

Example: Transfer contents of S to X

Transfer X to A A=X

This instruction is used to copy the contents of the X register to the accumulator.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if A becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A is set

implied 1 2

example: Transfer contents of X to A

Transfer X to S S = X

This instruction is used to copy the contents of the X register to the stack pointer.

Processor Status after use

C (carry flag): not affected

Z (zero flag): not affected

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): not affected

implied 1 2

Example: Transfer contents of X to S

Transfer Y to A A = Y

This instruction is used to copy the contents of the Y register to the accumulator.

Processor Status after use

C (carry flag): not affected

Z (zero flag): set if A becomes 0

I (interrupt disable): not affected

D (decimal mode flag): not affected

B (break command): not affected

V (overflow flag): not affected

N (negative flag): set if bit 7 of A is set

implied 1 2

Example: Transfer contents of Y to A

The input device from which characters may be fetched can be selected using the OSBYTE call with A=2 (*FX 2). Input max' be selected from the keyboard and/or RS423.

Output may be channelled to any combination of the following destinations: Screen, Printer, RS423 or Spooled file. Selection of destination is achieved using OSBYTE call with A=3 (*FX

See the OSBYTE call section (chapter 8) for a full description of these OSBYTE calls.

Call address &FFEE

Indirected through &20E

This routine writes the character given in the accumulator to the currently selected output stream or streams.

NB. Unrecognised VDU commands are passed to a vector at location &226. See Vectors section, 10.8.

After an OSWRCH call,

A, X and Y are preserved.

C, N, V and Z are undefined.

The interrupt status is preserved (though it may be

enabled during a call).

Call address &FFCB

This routine is normally used by OSWRCH and the call address is contained in the OSWRCH vector on reset. The non-vectored OSWRCH routine is believed to be used by the Tube system. This routine has not been documented by Acorn and should be used with caution.

Call address &FFEO

Indirected through &210

This routine reads a character from the currently selected input stream and returns the character read in the accumulator.

After an OSRDCH call,

C=0 indicates that a valid character has been read.

C=1 flags an error condition, A contains an error number.

If an escape condition occurs then A=&1B (27) and C=1,

if detected an escape condition must be acknowledged

using an OSBYTE call with A=&7E (126).

X and Y are preserved.

N, V and Z are undefined.

The interrupt status is preserved (though interrupts may be enabled during a call).

Call address &FFC8

This routine is normally used by OSRDCH and the call address is placed in the OSRDCH vector on reset. The non-vectored OSRDCH is believed to be used by the Tube system. This call has not been documented by Acorn and should be used with caution.

Call address &FFE7

Not indirected

This routine uses OSWRCH to write a linefeed (ASCII &OA/ 10) followed by a carriage-return (ASCII &OD/13) to the currently selected output stream(s).

After an OSNEWL call,

A=&OD (13)

X and Y are preserved.

C, N, V and Z are undefined.

Interrupt status is preserved (though it may be enabled

during a call).

Call address &FFE3

Not indirected

This routine performs an OSWRCH call with the accumulator contents unless called with accumulator contents of &OD (13) when an OSNEWL call is performed.

After an OSASCI call,

A, X and Y are preserved.

C, N, V and Z are undefined.

Interrupt status is preserved (though interrupts may be

enabled during a call).

Call address &FFBC

This is the entry point for raw VDU character processing. On entry the accumulator contains the character to be written to the VDU drivers. Any settings of OSBYTE &31*FX 3 are totally ignored and no output will go to any other destination (except characters preceded by VDU I which will be sent to the printer if the printer has previously been enabled with a VDU2). This call has not been documented by Acorn. There will normally be no need to use this routine as OSWRCH with the appropriate *EX3 call (:an be used to the same effect.

Call address &FFC2

The GSINIT and GSREAD routines are used by the operating system to process strings used for commands such as *KEY and *LOAD The advantage of using this system for reading strings is that an escape sequence can be used to introduce control characters which would otherwise be difficult to type in directly from the keyboard (the escape character is see section 2.10 for details of its use.).

This routine should be used to initialise a string which is to be used for input using the GSREAD routine (see below). The routine requires locations &F2 and &F3 plus a Y register offset to specify the string address. The string need not be enclosed by quotation marks. GSINIT must be used not only to strip off leading spaces but also to set up an information byte in zero page which indicates the termination character and if the string is surrounded by quotation marks.

If the carry flag is clear on entry then the first space or carriage return or second quotation mark will be considered as the terminating character for the string.

If the carry flag is set then only a carriage return or a second quotation mark will be considered as the terminal character.

On exit,

Y contains the offset of the first non-blank character from the address contained in &F2 and &F3.

A contains the first non-blank character (as returned by the first call of GSINIT.

Z flag is set if the string is a null string (e.g. a BEQ instruction will cause a branch).

This routine has not been documented by Acorn but has been used in applications software.

Call address &FFC5

This routine should only be used following a GSINIT call. GSREAD should be entered with Y set to either the Y value following a GSINIT call or following a previous GSREAD call. Locations &F2 and &F3 should contain the address of the start of the string (i.e. should not have been altered since the last GSINIT call).

On exit,

A contains the character read from the string.

Y contains the index for the next character to be read.

Carry flag is set if the end of string is reached.

X is preserved.

This routine has not been documented by Acorn but has been used in applications software.

Call address &FFB9

On entry,

Y=ROM number.

Locations &F6 and &F7 should contain the address of the byte to be read.

On exit,

A contains the value of the byte read.

This routine has not been documented by Acorn but has been used in applications software.

Call address &FFBF

This call generates or causes an event. The event number should be placed in the Y register when this routine is called. The accumulator contents are transferred to the Y register and the event number is placed in the accumulator when the event handling routine is entered. See Events, chapter 12,for more information about events.

This routine has not been documented by Acorn and should be used with caution.

For details of which commands are recognised by the command line interpreter see chapter 2 (Operating System Commands).

Call address &FFF7

Indirected through &208

This routine passes a line of text to the command line interpreter which decodes and executes any command recognised.

On entry,

X and Y should point to a line of text

(X= low-byte, Y= high-byte).

The line of text should be terminated by a carriage return

character (ASCII &0D/13)

After an OSCLI call,

A, X, Y, C, N, V and Z are undefined. Interrupt status is preserved but interrupts may be enabled during a call.

The OSBYTE call to the operating system is a powerful and flexible way of invoking many of the available operating system facilities. The *FX command can be used to make OSBYTE calls from BASIC programs or directly from the keyboard (see section 2.8).

Call address &FFF4

Indirected through &20A

One entry,

A selects an OSBYTE routine

X contains an OSBYTE parameter

Y contains an OSBYTE parameter

Any OSBYTE calls which are not recognised by the operating system will be offered to paged ROMs (see section 15.1.1, service call 4). If the unrecognised OSBYTE is not claimed by a paged ROM then a 'Bad command' error will be issued (error number 254).

All the OSBYTE calls recognised by the operating system are described in detail in the following pages. Each OSBYTE call or group of related OSBYTE calls is assigned a separate page. The description for each call includes details of the entry parameters required and the state of the registers on exit. All OSBYTE calls may be made using the *FX command, but it is not always appropriate to do so (i.e. those calls returning values in the X and Y registers). Where it is appropriate to use a *FX command this has been indicated. Preceding the full OS BYTE descriptions is a complete summary of the OSBYTE calls in a list.

OSBYTE calls &A6/166 to &FF/255 can be used to read or write operating system status flags or variables. In 0S 1.20 these memory locations extend from &236 to &28F. The action of these calls is to replace the contents of the specified location with

'(<old value> AND Y) EOR X'.

To read a location set X=0, Y=&FF.

To write a location set X=value, Y=0.

On exit,

X=old value, Y=value of next location

Many of these calls repeat the function of lower value OSBYTEs (N.B. These equivalent calls are not guaranteed to have an identical effect when used to set flags or OS variables, and other calls are of no practical use, these are included for completeness).

dec. hex. function

0 0 Print operating system version

1 1 User OSBYTE call, read/write location &281

2 2 Select input stream

3 3 Select output stream

4 4 Enable/disable cursor editing

5 5 Select printer destination

6 6 Set character ignored by printer

7 7 Set RS423 baud rate for receiving data

8 8 Set RS423 baud rate for data transmission

9 9 Set flashing colour mark state duration

10 A Set flashing colour space state duration

11 B Set keyboard auto-repeat delay interval

12 C Set keyboard auto-repeat rate

13 D Disable events

14 E Enable events

15 F Flush selected buffer class

16 10 Select ADC channels to be sampled

17 11 Force an ADC conversion

18 12 Reset soft keys

19 13 Wait for vertical sync

20 14 Explode soft character RAM allocation

21 15 Flush specific buffer

OSBYTE/*FX calls 22 (&15) to 116 (&74) are not used by OS1.20

117 75 Read VDU status

118 76 Reflect keyboard status in LEDs

119 77 Close any SPOOL or EXEC files

120 78 Write current keys pressed information

121 79 Perform keyboard scan

122 7A Perform keyboard scan from 16 (&10)

123 7B Inform OS, printer driver going dormant

124 7C Clear ESCAPE condition

125 7D Set ESCAPE condition

126 7E Acknowledge detection of ESCAPE condition

127 7F Check for EOF on an open file

128 80 Read ADC channel or get buffer status

129 81 Read key with time limit

130 82 Read machine high order address

131 83 Read top of OS RAM address (OSHWM)

132 84 Read bottom of display RAM address (HIMEM)

133 85 Read bottom of display address for a given MODE

134 86 Read text cursor position (POS and VPOS)

135 87 Read character at cursor position

136 88 Perform *CODE

137 89 Perform *MOTOR

138 8A Insert value into buffer

139 8B Perform *OPT

140 8C Perform *TAPE

141 SD Perform *ROM

142 SE Enter language ROM

143 SF Issue paged ROM service request

144 90 Perform *TV

145 91 Get character from buffer

146 92 Read from FRED, 1 MHz bus

147 93 Write to FRED, 1 MHz bus

148 94 Read from JIM, 1 MHz bus

149 95 Write to JIM, 1 MHz bus

150 96 Read from SHEILA, mapped I/O

151 97 Write to SHEILA, mapped I/O

152 98 Examine buffer status

153 99 Insert character into input buffer

154 9A Write to video ULA control register and copy

155 9B Write to video ULA palette register and copy

156 9C Read/write 6850 control register and copy

157 9D Fast Tube BPUT

158 9E Read from speech processor

159 9F Write to speech processor

160 A0 Read VDU variable value

OSBYTE/*FX calls 161 (&A1) to 165 (&A5) are not used by OS1.20

166 A6 Read start address of OS variables (low byte)

167 A7 Read start address of OS variables (high byte)

168 A8 Read address of ROM pointer table (low byte)

169 A9 Read address of ROM pointer table (high byte)

170 AA Read address of ROM information table (low byte)

171 AB Read address of ROM information table (high byte)

172 AC Read address of key translation table (low byte)

173 AD Read address of key translation table (high byte)

174 AE Read start address of OS VDU variables (low byte)

175 AF Read start address of OS VDU variables (high byte)

176 B0 Read/write CFS timeout counter

177 B1 Read/write input source

178 B2 Read/write keyboard semaphore

179 B3 Read/write primary OSHWM

180 B4 Read/write current OSHWM

181 B5 Read/write RS423 mode

182 B6 Read character definition explosion state

183 B7 Read/write cassette/ROM filing system switch

184 B8 Read RAM copy of video ULA control register

185 B9 Read RAM copy of video ULA palette register

186 BA Read/write ROM number active at last BRK (error)

187 BB Read/write number of ROM socket containing BASIC

188 BC Read current ADC channel

189 BD Read/write maximum ADC channel number

190 BE Read ADC conversion type

191 BF Read/write RS423 use flag

192 C0 Read RS423 control flag

193 C1 Read/write flash counter

194 C2 Read/write mark period count

195 C3 Read/write space period count

196 C4 Read/write keyboard auto-repeat delay

197 CS Read/write keyboard auto-repeat period

198 C6 Read/write *EXEC file handle

199 C7 Read/write *SPOOL file handle

200 C8 Read/write ESCAPE, BREAK effect

201 C9 Read/write Econet keyboard disable

202 CA Read/write keyboard status byte

203 CB Read/write RS423 handshake extent

204 CC Read/write RS423 input suppression flag

205 CD Read/write cassette/RS423 selection flag

206 CE Read/write Econet OS call interception status

207 CF Read/write Econet OSRDCH interception status

208 D0 Read/write Econet OSWRCH interception status

209 Dl Read/write speech suppression status

210 D2 Read/write sound suppression status

211 D3 Read/write BELL channel

212 D4 Read/write BELL envelope number/amplitude

213 D5 Read/write BELL frequency

214 D6 Read/write BELL duration

215 D7 Read/write startup message and !BOOT options

216 D8 Read/write length of soft key string

217 D9 Read/write number of lines printed since last page

218 DA Read/write number of items in VDU queue

219 DB Read/write TAB character value

220 DC Read/write ESCAPE character value

221 DD Read/write character &CO to &CF status

222 DE Read/write character &DO to &DF status

223 DE Read/write character &EO to &EF status

224 E0 Read/write character &FO to &FF status

225 El Read/write function key status

226 E2 Read/write SHIFT+ function key status

227 E3 Read/write CTRL+function key status

228 E4 Read/write CTRL+SHIFT+function key status

229 ES Read/write ESCAPE key status

230 E6 Read/write flags determining ESCAPE effects

231 E7 Read/write JRQ bit mask for user 6522

232 E8 Read/write IRQ bit mask for 6850

233 E9 Read/write IRQ bit mask for system 6S22

234 EA Read flag indicating Tube presence

235 EB Read flag indicating speech processor presence

236 EC Read/write write character destination status

237 ED Read/write cursor editing status

238 FE Read/write location &27E, not used by 05 1.20

239 EF Read/write location &27F, not used by 05 1.20

240 F0 Read/write location &280, not used by 05 1.20

241 F1 Read/write location &281, used by *FX 1

242 F2 Read RAM copy of serial processor ULA

243 F3 Read/write timer switch state

244 F4 Read/write soft key consistency flag

245 E5 Read/write printer destination flag

246 F6 Read/write character ignored by printer

247 F7 Read/write first byte of BREAK intercept code

248 ES Read/write second byte of BREAK intercept code

249 F9 Read/write third byte of BREAK intercept code

250 FA Read/write location &28A, not used by 05 1.20

251 EB Read/write location &28B, not used by 05 1.20

252 FC Read/write current language ROM number

253 FD Read/write last BREAK type

254 FE Read/write available RAM

255 EF Read/write start up options

Entry parameters:

X=0 Execute BRK with a message giving the O.S.. type

X<>0 RTS with O.S. type returned in X

On exit,

X=0, OS 1.00

X=1, OS 1.20

A and Y are preserved

C is undefined

Entry parameters: The user flag is replaced by

(<old value> AND Y) EOR X

i.e. Y=0 for write, Y=&FF for read

On exit,

X=old value

This call uses OSBYTE call with A=&F1 (241). This OSBYTE call is left free for user applications and is not used by the operating system. The user flag is stored in location &281 and its default value is 0.

Entry parameters: X determines input device(s)

*FX 2,0 X=0 keyboard selected, RS423 disabled

*FX 2,1 X=1 RS423 selected and enabled

*FX 2,2 X=2 keyboard selected, RS423 enabled

Default: *FX 2,0

On exit,

X=0 if previous input was from the keyboard X=1 if previous input was from RS423

After call,

A is preserved

Y and C are undefined

Entry parameters: X determines output device(s), Y=0

BIT 0 - Enables RS423 driver

BIT 1 - Disables VDU driver

BIT 2 - Disables printer driver

BIT 3 - Enables printer, independent of CTRL B or C

BIT 4 - Disables spooled output

BIT 5 - Not used

BIT 6 -Disables printer driver unless the character is preceded by a VDU 1 (or equivalent)

BIT 7- Not used

*FX 3,0 selects the default output options which are:

RS423 disabled

VDU enabled

Printer enabled (if selected by VDU 2)

Spooled output enabled (if selected by *SPOOL)

This OSBYTE call uses OSBYTE call with A=&EC (236). It is thus possible to set Y as a bit mask and only change those bits which are required.

After call,

A is preserved

X contains the old *FX 3 status

Y and C are undefined

Entry parameters: X determines editing keys' status, Y=0

*FX 4,0 X=0 Enable cursor editing (default setting)

*FX 4,1 X=1 Disable cursor editing

The cursor control keys will

return the following codes:

COPY &87 (135)

LEFT &88 (136)

RIGHT &89 (137)

DOWN &8A (138)

UP &8B (139)

*FX 4,2 X=2 Disable cursor editing and make

the keys act as soft keys with the

following soft key association

numbers:

COPY 11

LEFT 12

RIGHT 13

DOWN 14

UP 15

after call,

A is preserved

X contains the previous *FX 4 setting

Y and C are undefined

Entry parameters: X determines print destination

*FX 5,0 X=0 Printer sink (printer output ignored)

*FX 5,1 X=1 Parallel output (default setting)

*FX 5,2 X=2 RS423 output (will act as sink if RS423 is enabled using OSBYTE with A=3)

*FX 5,3 X=3 User printer routine (see Vectors, 10.6)

*FX 5,4 X=4 Net printer (see Vectors, 10.7)

*FX 5,5-255 X=5-255 User printer routine (see Vectors, 10.6)

After call,

A is preserved

X contains the previous *FX 5 setting

Y and C are undefined

Interrupts are enabled by this call

This call is not reset to default by a soft break

Entry parameters: X contains the character value to be ignored

*FX 6,10 X=10 This prevents LINE FEED

characters being sent to the

printer, unless preceded by VDU

1 (this is the default setting)

after call,

A is preserved

X contains the previous *FX 6 setting

Y and C are undefined

Entry parameters: X determines transmission rate

*FX 7,1 X=1 75 baud transmit

*FX 7,2 X=2 150 baud transmit

*FX 7,3 X=3 300 baud transmit

*FX 7,4 X=4 1200 baud transmit

*FX 7,5 X=5 2400 baud transmit

*FX 7,6 X=6 4800 baud transmit

*FX 7,7 X=7 9600 baud transmit

*FX 7,8 X=8 19200 baud transmit

After call,

A is preserved

X and Y contain the old

C is undefined

Entry parameters: X determines transmission rate

*FX 8,1 X=1 75 baud transmit

*FX 8,2 X=2 150 baud transmit

*FX 8,3 X=3 300 baud transmit

*FX 8,4 X=4 1200 baud transmit

*FX 8,5 X=5 2400 baud transmit

*FX 8,6 X=6 4800 baud transmit

*FX 8,7 X=7 9600 baud transmit

*FX 8,8 X=8 19200 baud transmit

After call,

A is preserved

X and Y contain the old serial ULA register contents

C is undefined

Entry parameters: X determines length of duration, Y=0

*FX 9,0 X=0 Sets mark duration to infinity.

Forces mark state if space is set to

0

*FX 9,n X=n Sets mark duration to n

centiseconds

(n=25 is the default setting)

After call,

A and X are preserved

Y contains the old mark duration

C is undefined

Entry parameters: X determines length of duration, Y=0

*FX 10,0 X=0 Sets space duration to infinity

Forces space state if mark is set to

0

*FX 10,n X=n Sets space duration to n

centiseconds

(n=25 is the default setting)

After call,

A and X are preserved

Y contains the old space duration

C is undefined

Entry parameters: X determines delay before repeating starts,

Y=0

*FX 11,0 X=0 Disables auto—repeat facility

*FX 11,n X=n Sets delay to n centiseconds

(n=32 is the default setting)

After call,

A is preserved

X contains the old setting

Y and C are undefined

Entry parameters: X determines auto—repeat periodic interval,

Y= 0

*FX 12,0 X=0 Resets delay and repeat to

default values

*FX 12,n X=n Sets repeat interval to n

centiseconds

(n=8 is the default value)

After call

A is preserved

X contains the old *FX 12 setting

Y and C are undefined

Entry parameters: X contains the event code, Y=0

*FX 13,0 X=0 Disable output buffer empty event

*FX 13,1 X=1 Disable input buffer full event

*FX 13,2 X=2 Disable character entering buffer event

*FX 13,3 X=3 Disable ADC conversion complete event

*FX 13,4 X=4 Disable start of vertical sync event

*FX 13,5 X=5 Disable interval timer crossing 0 event

*FX 13,6 X=6 Disable ESCAPE pressed event

*FX 13,7 X=7 Disable RS423 error event

*FX 13,8 X=8 Disable network error event

*FX 13,9 X=9 Disable user event

For more information about events see chapter 12

After call,

A is preserved

X and Y contain the old enable state (0= disabled)

C is undefined

Entry parameters: X contains the event code, Y not important

*FX 14,0 X=0 Enable output buffer empty event

*FX 14,1 X=1 Enable input buffer full event

*FX 14,2 X=2 Enable character entering buffer event

*FX 14,3 X=3 Enable ADC conversion complete event

*FX 14,4 X=4 Enable start of vertical sync event

*FX 14,5 X=5 Enable interval timer crossing 0 event

*FX 14,6 X=6 Enable ESCAPE pressed event

*FX 14,7 X=7 Enable RS423 error event

*FX 14,8 X=8 Enable network error event

*FX 14,9 X=9 Enable user event

For more information about events see chapter 12

After call,

A is preserved

X and Y contain the old enable state (>0=enabled)

C is undefined

Entry parameters: X value selects class of buffer

X=0 All buffers flushed

X<>0 Input buffer flushed only

See OSBYTE call &16/*FX 21

After call,

Buffer contents are discarded

A is preserved

X, Y and C are undefined

Entry parameters: X value selects number of channels sampled

*FX 16,0 X=0 Sampling disabled

*FX 16,n X=n Number of channels to be sampled (n must be in the range 0 to 4, if greater then set to 4)

After call,

A is preserved

X contains the old *FX 16 value

Entry parameters: X value specifies ADC channel

*FX 17,n X=n Force ADC conversion on

channel n

(if n>4 then n=4)

See OSBYTE with A=&80 (128) also

After call,

A is preserved

X is preserved if it is in the range 0 to 4 otherwise it is

returned containing the value 4

Y and C are undefined

No parameters

This call clears the soft key buffer so the character strings are no longer available

After call,

A and Y are preserved

X and C are undefined

No parameters

This call forces the machine to wait until the start of the next frame of the display. This occurs 50 times per second on the UK BBC Microcomputer and can be used for timing or animation.

N.B. User trapping of IRQ1 may stop this call from working.

After call,

A is preserved

X, Y and C are undefined

Entry parameters: X value explodes/implodes memory allocation

In the default state 32 characters may be user defined using the VDU 23 statement from BASIC (or the OSWRCH call in machine code). These characters use memory from &C00 to &CFF. Printing ASCII codes in the range 128 (&80) to 159 (&9F) will cause these user defined characters to be printed up (these characters will also be printed out for characters in the range &A0-&BF, &C0-&DF, &E0-&FF). In this state the character definitions are said to be IMPLODED.

If the character definitions are EXPLODED then ASCII characters 128 (&80) to 159 (&9F) can be defined as before using VDU 23 and memory at &C00. Exploding the character set definitions enables the user to uniquely define characters 32 (&20) to 255 (&FF) in steps of 32 extra characters at a time. The operating system must allocate memory for this which it does using memory starting at the 'operating system high-water mark' (OSHWM). This is the value to which the BASIC variable PAGE is usually set and so if a totally exploded character set is to be used in BASIC then PAGE must be reset to OSHWM+&600 (i.e. PAGE=PAGE+&600).

ASCII characters 32 (&20) to 128 (&7F) are defined by memory within the operating system ROM when the character definitions are imploded.

See OSBYTE &83 (131) for details about reading OSHWM from machine code.

The memory allocation for ASCII codes in the expanded state is as follows:-

*FX 20,0 X=0 &80-&8F &C00-&CFF (imploded)

*FX 20,1 X=1 &A0-&BF OSHWM-OSHWM±&FF

(A-above)

*FX 20,2 X=2 &C0-&DF OSHWM+&100-

OSHWM+&1FF (A-above)

*FX 20,3 X=3 &E0-&FF OSHWM+&200—

OSHWM+&2FF (A-above)

*FX 20,4 X=4 &20-&3F OSHWM+&300—

OSHWM + &3FF (A- above)

*FX 20,5 X=5 &40-&SF OSHWM+&400—

OSHWM+&4FF (A-above)

*FX 20,6 X=6 &60-&7F OSHWM+&500—

OSHWM + &5FF (A- above)

See also OSBYTE call with A=&B6 (182).

after call,

A is preserved

X contains the new OSHWM (high byte)

Y and C are undefined

Entry parameters: X determines the buffer to be cleared

*FX 21,0 X=0 Keyboard buffer emptied

*FX 21,1 X=1 RS423 input buffer emptied

*FX 21,2 X=2 RS423 output buffer emptied

*FX 21,3 X=3 Printer buffer emptied

*FX 21,4 X=4 Sound channel 0 buffer emptied

*FX 21,5 X=5 Sound channel 1 buffer emptied

*FX 21,6 X=6 Sound channel 2 buffer emptied

*FX 21,7 X=7 Sound channel 3 buffer emptied

*FX 21,8 X=8 Speech buffer emptied

See also OSBYTE calls with A=&0F (*FX15) and A=&80 (128)

After call,

A and X are preserved

Y and C are undefined

No entry parameters

On exit the X register contains the VDU status. Information is conveyed in the following bits:

Bit 0 Printer output enabled by a VDU 2

Bit 1 Scrolling disabled

Bit 2 Paged scrolling selected

Bit 3 Software scrolling selected i.e. text window

Bit 4 not used

Bit 5 Printing at the graphics cursor enabled by VDU 5

Bit 6 Set when input and output cursors are separated (i.e. cursor editing mode).

Bit 7 Set if VDU is disabled by a VDU 21

After call,

A and Y are preserved

C is undefined

This call reflects the keyboard status in the state of the keyboard LEDs, and is normally used after the status has been changed by OSBYTE &CA/202.

On exit,

A is preserved

X has bit 7 is set if CTRL is pressed

Y is undefined

This call closes any open files being used as *SPOOLed output or *EXEC d input to be closed. This call also performs a paged ROM call with A=&10 (16). See paged ROM section, 15.1.1.

On exit,

A is preserved

X, Y and C are undefined

The operating system operates a two key roll-over for keyboard input (recognising a second key press even when the first key is still pressed). There are two zero page locations which contain the values of the two key-presses which may be recognised at any one time. If no keys are pressed, location &EC contains 0 and location &ED contains 0. If one key is pressed, location &EC contains the internal key number + 128 (see table below for internal key numbers) and location &ED contains 0. If a second key is pressed while the original key held down, location &EC contains the internal key number + 128 of the most recent key pressed and location &ED contains the internal key number + 128 of the first key pressed.

&00 0 SHIFT &40 64 CAPS LOCK

&01 1 CTRL &41 65 A

&02 2 bit7 &42 66 X

&03 3 bit6 &43 67 F

&04 4 bit5 &44 68 Y

&05 5 bit4 &45 69 J

&06 6 bit3 &46 70 K

&07 7 bit2 &47 71 @

&08 8 bit1 &48 72 :

&09 9 bit 0 &49 73 RETURN

&10 16 Q &50 80 SHIFT LOCK

&11 17 3 &51 81 S

&12 18 4 &52 82 C

&13 19 5 &53 83 G

&14 20 f4 &54 84 H

&15 21 8 &55 85 N

&16 22 f7 &56 86 L

&17 23 - &57 87 ;

&18 24 A &58 88 ]

&19 25 LEFT CURSOR &59 89 DELETE

&20 32 f0 &60 96 TAB

&21 33 W &61 97 Z

&22 34 E &62 98 SPACE

&23 35 I &63 99 V

&24 36 7 &64 100 B

&25 37 9 &65 101 M

&26 38 1 &66 102 ,

&27 39 0 &67 103 .

&28 40 _ &68 104 /

&29 41 DOWN CURSOR &69 105 COPY

&30 48 1 &70 112 ESCAPE

&31 49 2 &71 113 f1

&32 50 D &72 114 f2

&33 51 R &73 115 f3

&34 52 6 &74 116 f5

&35 53 U &75 117 f6

&36 54 0 &76 118 f8

&37 55 P &77 119 f9

&38 56 [ &78 120 \

&39 57 UP CURSOR &79 121 RIGHT CURSOR

Bits 0 to 7 refer to the links at the front of the keyboard circuit board on the right-hand side. See OSBYTE &FE for further information about these links.

To convert these internal key numbers to the INKEY numbers they should be EOR (Exclusive ORed) with &FF (255).

Entry parameters: X and Y contain values to be written Value in X is stored in &ED (old key) Value in Y is stored in &EC (new key)

See also OSBYTE calls with A=&AC and A=&AD.

After call,

A, X and Y are preserved

C is undefined

Entry parameters: X determines the key to be detected and also determines the range of keys to be scanned.

Key numbers refer to internal key numbers in the table above.

To scan a particular key:

X=key number EOR &80 on exit X<0 if the key is pressed

To scan the matrix starting from a particular key number:

X=key number on exit X=key number of any key pressed or &FF if no key pressed

During the keyboard scan the key whose value is stored in location &EE is ignored. The contents of this location are set to 0 by the operating system on reset.

After call,

A is preserved

Y and C are undefined

No entry parameters

Internal key number (see table above) of the key pressed is returned in X.

This call is directly equivalent to an OSBYTE call with A=&79 and X=16.

After call,

A is preserved

Y and C are undefined

Entry parameters: X should contain the value 3 (print buffer i.d.)

This OSBYTE call should be used by user printer drivers when they go dormant. The operating system will need to wake up the printer driver if more characters are placed in the printer buffer.

See Vectors Section (user printer drivers), 10.6.

After call,

A, X and Y are preserved

C is undefined