Turbo Compiler is a highly compact machine-coded BASIC compiler for use with both the BBC Microcomputer (Models A and B) and the Acorn Electron microcomputer.

Its small size allows TURBO to compile programs instantaneously within the micro, without the need for immediate use of tape or disk.

Supplied with detailed documentation, TURBO is ideal for constructing fast hybrid programs, or writing 100% machine code programs.

Features:

• Highly compact machine-coded compiler (2K)
• Fast compilations in under one second
• Disk based version also supplied on same cassette
• Supports sub-set of BASIC commands directly
• Comprehensive documentation deails how to implement a total of 65 BASIC keywords
• Compiled code can be used without the compiler being resident
• Provides an ideal immediate stage for users who wish to move from BASIC programming to the use of machine code and the Acorn operating system
• TURBO requires a Series 1 Operating System on the BBC Micro

TURBO is a basic compiler for the BBC and Acorn Electron microcomputers (in order to run TURBO on the BBC Micro, a 1.0 or later Operating System is required).

Two versions of the program are supplied, one for BBC or Electron users with a normal cassette tape system, the other for BBC users with a disk drive, or using a cassete tape on a machine with a DFS installed.

The compiler occupies only 2K of memory, and will therefore run on both the BBC Model A and the BBC Model B; on the Model B and Electron, TURBO will allow all eight screen modes to be used. As this is such a compact compiler, not all of the BASIC keywords have been implemented. However, Appendix 1 lists all of the BASIC keywords and explains how to achieve, where possible, the same effect if that keyword is not directly supported by TURBO.

The TURBO Compiler is ideal for the user who wishes to write machine code subroutines for games. Indeed, entire games can be written with TURBO, but the user may find that she/he has to divide the program into several sections if it is a long game.

The machine code produced by TURBO is completely independent of the compiler, and so can be used without the compiler itself being resident.

Once the dialect used in TURBO has been picked up, you will find that you can easily write very fast programs. For example, the following program takes about 14.5 seconds to run in BASIC on the BBC Micro, but if you compile it with TURBO, it will take under one second to execute.

  10LETB%=&00
  20LETB%=B%+&01
  30FORA%=00TO&FF
  40NEXTA%
  50IFB%>&FETHEN20

The same savings in time will not be experienced with all programs (depending on complexity) but you will find that your programs wil run considerably faster.

The following instructions are for loading the Turbo Compiler from tape. If you have a disk system, read the section Transferring TURBO To Disk before continuing.

1. Ensure that the computer is free of any other programs, either by pressing CTRL and BREAK at the same time, or by turning the computer off and on again.
2. Position the tape at the beginning of side 1.
3. Type CHAIN"" and press RETURN.
4. Press the PLAY button on your cassette recorder.
5. When the first program has loaded, a title page will be displayed and the computer will begin to load the second program. Leave the cassette recorder playing until this second program has finished loading. Ignore any messages the computer may print after both programs have loaded.
6. Stop the cassette player if you do not have the remote control facility connected. If you wish to load the demonstration program, do not rewind the tape.
7. Press BREAK. The screen should appear as below (or similar, depending on computer type):

     TURBO BASIC
     BBC Computer 32K
   

8. Set PAGE to wherever your BASIC program is going to be stored. The minimum setting is &1500. To do this, type PAGE = &1500 (RETURN).

   If you wish to set PAGE higher than the minimum, you will also need to alter memory locations &D20 and &D21.

   For example, if you wanted to set PAGE to &3000, you would also have to poke the low byte of the address to &D20 and the high byte of the address to &D21:

   e.g. Type:	PAGE = &3000	and press RETURN
   	?&D20 = &00	and press RETURN
   	?&D21 = &30	and press RETURN

9. The compiler normally stores the compiled code from the address &2200 upwards. If you wish to change this, memory locations &D1E and D1F must be altered to contain the low and high bytes of this new address. For example, to change the start position of the code to &3200, type the following:

   	?&D1E = &00	and press RETURN
   	?&D1F = &32	and press RETURN

10. Type NEW and press RETURN to let BASIC get its pointers sorted out.
11. If you are using a BBC Model A, you will need to enter the following:

    ?&DE4=&3E:?&DE9=&3F:?&FCB=&3F:?&FD5=&3E (RETURN)

    The computer is now ready for you to either load or write a program. There is a demonstration program on the cassette immediately after the compiler.

Note: The demonstration program for use with disk has had all REM statements removed. Disk users who wish to list and study the demonstration program are recommended to do so using the tape demonstration on side one of the cassette.

Side two of the cassette contains a version of TURBO for use from disk.

To transfer the two programs to disk, proceed as follows:

1. Type *TAPE and press RETURN.
2. Position the tape at the beginning of side 2.
3. Type LOAD"" and press RETURN.
4. Press the PLAY button on your cassette recorder.
5. When the first program has loaded, type *DISC and press RETURN.
6. Type SAVE"DTURBO" and press RETURN.
7. Type *TAPE and press RETURN. Then type *LOAD"" and press RETURN.
8. When the second program has loaded, type *DISC and press RETURN.
9. Type *SAVE DTURBO2 1900 20FA and press RETURN.
10. Type *TAPE and press RETURN. Then type LOAD"" and press RETURN.
11. When the demonstration program has loaded, type *DISC and RETURN.
12. Type SAVE"DDEMO" and press RETURN.

This completes the transfer process.

If you want to load the program, use the same loading instructions as for the tape system, but with the following changes:

Step 2. If you have a DFS fitted, but want to run the program from tape, turn the tape over to side two and rewind it to the beginning. Then type *TAPE and press RETURN.

Step 3. If you are running TURBO from disk, type CHAIN"DTURBO" and press RETURN.

Step 8. The minimum PAGE setting for disk users is &2100. The memory locations to change if you want another PAGE location, are &1920 and &1921.

Step 9. The default location for storing compiled code is at &2800. If you want to alter this, the memory locations to change are &191E and &191F.

It is recommended that you load and run the demonstration program provided, then have a look at the program to see how it works, before attempting to write programs of your own. There are two versions of the demonstration program provided, one for the tape version and one for the disk version. These are on the cassette tape, immediately following the appropriate version of the compiler. The only difference is that the disk version has had all the REM statements removed, due to memory limitations.

To load the demo program, first load TURBO as described earlier. As the demo program uses the preset compile addresses, step 7 simply consists of setting PAGE to 1500 (&2100 for disk users) and step 8 may be ignored. Load the demonstration program by typing LOAD"" (LOAD"DDEMO" if you have saved your demo program onto disk).

You can then compile the program by typing *TURBO and pressing RETURN. The screen will be cleared, some "garbage" characters will appear in the bottom half of the screen, and "OK" will be printed at the top of the screen.

The machine code program can be executed by typing CALL &2200 (CALL &2800 for disk users).

At the end of the first section, the computer will wait for a key to be pressed, and will then draw a pattern of triangles, as well as a set of space invaders.

Pressing another key will cause the space invaders to move across the screen.

Pressing another key will end the demo program.

The first part of the program will also run in normal BASIC so that you can compare speeds, but later sections will not, as they depend on the fact that TURBO only uses numbers from 0 to 255, which is not true in normal BASIC.

By now you will probably be wanting to write and compile your own programs. It is assumed that the user has a knowledge of BBC BASIC. If there are commands that you do not understand, refer to your User Guide for more information.

It is best to start off by doing some fairly simple programs to get the feel of the compiler before trying to write any games or other programs. Note that if you write a program, compile and execute it, and then wish to stop its execution before it finishes, you must press BREAK. If you do this, step 7 from the loading instructions must be repeated. The source program can be recovered by typing OLD and pressing RETURN. The compiled version will still be in place if you wish to execute it again.

Once you have a program in mind, you can start to write it using the commands recognised by the compiler. These are listed in the next section. If you find that there is a command you wish to use which is not in the list, or if you want more information about one that is, refer to Appendix 1 which lists all the BASIC keywords, and how to use them (or achieve the same effect) with TURBO. See in particular the sections in Appendix 1 on SAVE and LOAD for details of how to save and load compiled code.

When deciding how to allocate the memory, make sure that your compile address (loading step 8) is set above the top of your BASIC program or you will lose your source code when you compile.

Notes:

1. var% is a variable in the range A% to Z%. It is an eight bit number with a range of 0-255.
2. dvar% is a double variable in the range A% to Y%. It is a sixteen bit number with the range 0-65535.
3. &hh is an eight bit number from 0-255 written as two hexadecimal numbers.
4. &hhhh is a sixteen bit number from 0-65535 written as four hexadecimal numbers.
5. $&hhhh is a string with a maximum length of 254 characters.
6. dec is a decimal number.

There are various restrictions on the grammar you can user with TURBO and with numbers and strings. These are listed below.

1. All line numbers must be in the range 0 to 255. If your program needs more than 255 lines, you will have to split it into more than one section.
2. Each line may contain only one BASIC statement.
3. Line numbers, references, and MODEs are all refered to using decimal numbers. All other numbers are in hexadecimal.
4. When writing hexadecimal numbers, all digits are significant. Thus hex A must be written &0A.
5. All hexadecimal numbers must be preceded by an ampersand (&).
6. Spaces should not be left in the program.

The following points should be noted concerning numbers and variables:

1. All numbers in TURBO are positive hexadecimal numbers.
2. There are 26 variables which are named A% to Z%. These are integer variables with a range of 0-255.
3. Note that because these integers are 8 bit hexadecimal, adding &01 to &FF will produce a result of &00.
4. If you wish to use negative numbers, you must take the complement (subtract the number from &FF and add 1).
5. Certain instructions use double precision variables. These are sixteen bit numbers with a range of 0-65535. These are referred to by the names A% to Y%. The double precision variable A% is made up of two normal variables, in this case A% and B%. A% contains the low order byte of the number and B% contains the high order byte. To change the double precision variable, you must change both of the normal variables that make it up.

Strings are stored in areas of memory allocated by the user. These are referred to by their address in hexadecimal preceded by a $. For example, a string stored at &3500 would be referenced as $&3500. Strings can be any length between 1 and 254 characters, and are terminated by a carriage return character (&0D).

When you have written your program you will want to compile it into machine code. To do this, simply issue the command *TURBO and press RETURN.

This will compiled your program. The screen will clear and some "garbage" characters will appear on the screen. This is normal. In order to save memory, the compiler uses some of the screen area as work space during the compilation process. If the message OK appears at the top of the screen, your compilation has finished successfully. if a message ERROR &hh appears, the compiler has detected an error. "&hh" is the hexadecimal number in which the error was detected.

To execute your compiled code, type:

 CALL &hhhh and press RETURN

where "hhhh" is the address you specified for saving the compiled code (step 8 in loading).

You will find many references in Appendix 1 to putting certain functions into a BASIC program then CALLing your compiled code. If you want to transfer information between the BASIC program and compiled code, there are two ways of doing this.

The first is to poke the information into some set area of memory which can then be accessed by your compiled code.

The other way is to change the variables A% to Z%. These variables are stored at memory locations &75 to &8F in alphabetical order. So to change C% you would poke location &78.

To combine BASIC and machine code sections, you must first load the source code for the machine code, then compile it as normal. Then type NEW and load the BASIC program into the computer. To save a combination BASIC and machine code program, you can simply use the *SAVE command using the start address of your BASIC program and the end address of your completed code. (See the SAVE command in Appendix 1 for more information). You may find however, as your programs get larger and more complex, that you wish to save the program in parts to be combined later.

In Appendix 3 you will find an example of this sort of program.

This appendix lists all the BASIC keywords, explaining how the same effect may be achieved using the Turbo Compiler.

 10LETX%=&01
 20LETY%=&00
 30LETA%=&80
 40CALL&FFF4

 10LETA%=B%AND&13

 10IFA%=2ANDB%=4THEN40

 10IFA%<>&02THEN30
 20IFB%=&04THEN40

 10$&2F00="B"
 20LETB%=&00
 30LETA%=B%?&2F00

 10LETY%=&01
 20CALL&FFD7

 10LETY%=&01
 20LETA%=&41
 30CALL&FFD4

 10PRINTCHR$(&20)
 20PRINTCHR$(A%)
 30PRINTCHR$(B%)CHR$(&40)CHR$(E%)

 10LETC%=&00
 20C%?2F00=A%
 30C%?2F01=&0D

 10LETA%=&00
 20LETY%=&00
 30CALL&FFCE

 10VDU&11,&03

 10LETC%=&00
 20LETD%=A%
 30LETD%=D%-B%
 40IFD%>A% THEN80
 50LETA%=D%
 60LETC%=C%+&01
 70GOTO30
 80END

 10VDU&19,&05,&8A,&02,&CA,&03

 10LETA%=&08
 20LETX%=&54
 30LETY%=&2F
 40CALL&FFF1

 10LETF%=G%EORH%

 10FORA%=&01TO&09
 20FORA%=B%TO&09
 30FORA%=&01TOC%
 40FORA%=B%TOC%

 10VDU&12,&00,&05

 10LETA%=GET

 10IF A%>&0D THEN 90
 20IF B%>C% THEN 100
 30IF D%<&38 THEN 200
 40IF E%<F% THEN 170
 50IF G%=&5A THEN 180
 60IF H%=I% THEN 221
 70IF J%<>&21 THEN 222
 80IF K%<>L% THEN 196

 10LETA%=INKEY(&0005)

 10LETA%=&00
 20A%?&7100=&00
 30A%?&7101=&70
 40A%?&7102=&FF
 50A%?&7103=&20
 60A%?&7104=&FF
 70LETA%=00
 80LETX%=&00
 90LETY%=&71
 100CALL&FFF1

 10LETA%=&01
 20LETB%=&05
 30$&4000=MID$($&3F00,A%,B%)

 10LETA%=&00
 20LETB%=A%?&3000
 30IFB%=&0DTHEN60
 40LETA%=A%+&01
 50GOTO20

 10LETA%&06
 20LETB%=C%
 30LETD%=E%+&37
 40LETD%=F%+D%
 50LETE%=E%-&02
 60LETH%=I%-J%
 70LETK%=D%EOR&FA
 80LETL%=H%EORI%
 90LETM%=K%AND&AE
 100LETN%=M%ANDX%
 110LETO%=Q%OR&14
 120LETP%=P%ORT%
 130LETQ%=GET
 140LETR%=INKEY(&FFFF)
 150LETS%=T%?&3000
 160LETT%=A%?D%

 10LETA%=&04
 20LETB%=&07
 30$&6000=MID$($&3500,A%,B%)

 10VDU&19,&04,&2C,&01,&90,&01

 10LETA%=&40
 20LETX%=&F4
 30LETY%=&2F
 40CALL&FFCE

 10LET5%=T%OR&52

 10IFD%=W%ORD%=V%THEN100

 10IFD%=W%THEN100
 20IFD%=V%THEN100

 10VDU&19,&55,&00,&05,&9E,&02

 10LETV%=&00
 20V%?&2FF0=&F4
 30V%?&2FF1=&01
 40V%?&2FF2=&58
 50V%?&2FF3=&02
 60LETA%=&09
 70LETX%=&F0
 80LETY%=&2F
 90CALL&FFF1
 100LETR%=V%?&2FF4

 10LETA%=&86
 20CALL&FFF4

 10PRINT
 20PRINT;
 30PRINTCHR$(&45)
 40PRINT"hello"
 50PRINT$&2E80

 FORa=&2F00TO&2FFF:?a=RND(6):NEXT

 10FORE%=&00TOA%
 20LETF%=C%+B%
 30IFF%>C%THEN60
 40IFF%>B%THEN60
 50LETD%=D%+&01
 60LETC%=F%
 70NEXTE%
 80LETA%=B%
 90LETB%=C%AND&F0
 100LETC%=D%AND&0F
 110LETB%=B%+C%

 PRINT ~?&70,~?&71

 *SAVE programname 2000 2EE7 2200

 10SOUND&0001,&FFF3,&002A,&000A

 PRINTTAB(A%,20)"Hello"

 10PRINTCHR$(&1F)CHR$(A%)CHR$(&14)"hello"

 10LETX%=&00
 20LETY%=&2F
 30LETA%=&01
 40CALL&FFF1

 10VDUA%,B%,C%,D%,&20
 20VDU&11,&03
 30VDU&17,&34,&53,&F2,&8A,&23,&00,&05,&91

PEEK and POKE
As normal in BBC BASIC, the commands PEEK and POKE are represented by a "?". The contents of a memory location may be read by using one of the two forms provided:

 10LETV%=A%?&3000
 20LETV%=A%?C%

The first looks at location A%+&3000 and stores the contents in V%. The second stores the contents of location A%+C% in V%. In this second form, the third variable is special in that it is a double sized variable and can thus have a range of 0-65535. This means that by altering this variable, the user can look at any location; it also makes movement of large areas of memory easier. To alter C% in the second example, both C% and D% must be altered. (See double sixed variables for more information.)

Storing values in memory locations can be done in one of the following four ways:

 10A%?&555E=&26
 20A%?&432C=F%
 30B%?T%=&75
 40F%?Q%=E%

The first two examples are the same as normal BBC BASIC. The third and fourth examples use double sized variables (in this case T% and Q%) as described above.

Problem: Write a program to print out the word "hello" a random number of times.
Solution: Use the default values for the compile address and set PAGE to &1500 (&2100 for disk users).

Type in the following program which will print "hello" the number of times which A% will be set to.

 10FORB%=&01TOA%
 20PRINT"hello"
 30NEXTB%
 40END

Compile the program in the normal way, then type NEW to remove the source program and type in the BASIC program that follows:

 10?&76=RND(255) set A% to a random number from 1-255
 20CALL&2200 call compiled code to print
 30END

Disk users note that line 20 should read 20CALL&2800