Amstrad Action Toolkit 1|The Amstrad Action Toolkit volume one)Applications Utilitaires Rsx/ligne De Commande
★ Ce texte vous est présenté dans sa version originale ★ 
 ★ This text is presented to you in its original version ★ 
 ★ Este texto se presenta en su versión original ★ 
 ★ Dieser Text wird in seiner Originalfassung präsentiert ★ 

Cliquez sur l'image pour l'agrandir

Welcome to AA's set of utilities for BASIC and machine code programmers.  You've probably seen "BASIC extensions" like this a thousand times before:  they add a few commands, most of which you can live perfectly well without, and disappear again.

We hope that, with the AA Toolkit, you'll find something genuinely useful. The commands here are often really quite sophisticated, even more so when compared to standard toolkit fare.

Most of the commands will work equally well no matter what CPC you have. A few are for disc owners only, and a couple are only to be used with cassettes. (The program won't let you use the disc commands if you only have a tape drive on your system.) Similarly, a few commands are designed for systems with over 64k, and there are some commands especially suited for the 464. Something  for everyone, basically.


The commands that this adds to BASIC are called RSXs, which is techie jargon for "Resident System Extensions", which is techie jargon for something that begins with a "|" (bar) symbol. For example, one of the commands is called |MEMORY. You can just use it like any normal command: in a program line, for example...

        10 |MEMORY

...or just on its own. Some commands, like BASIC commands, take arguments - that is, you can't just put the command down and expect it to do something, but you have to supply a few numbers (or whatever) for it to work from. The thing to note here about RSXs is that they must have a comma directly after the command name (yes, it does look odd), such as...



As you'll know if you have a disc drive, the 464 is spectacularly inept at handling bar commands. For example, to erase a file from disc on the 464, you have to type:

        a$="filename": |ERA,@a$

instead of the simpler 664, 6128 or Plus (BASIC 1.1) equivalent:


Remember that this applies to the AA Toolkit commands too. (However, one of the commands should help to free you from all this hassle. Read on...!)

The commands, one-by-one


|CLI                           ; (all machines)
a$="command": |CLI,@a$          (BASIC 1.0)
|CLI,"command"                ;  (BASIC 1.1)

What does CLI mean? Well, apart from what a friend of mine does when he gets his Japanese translation all wrong, it stands for Command Line Interpreter. This, basically, means that you can type in a command and it will obey it.

"Big deal!" shout several thousand readers over Britain. "BASIC does that already!" Hang about, hang about. This has several advantages. For a start, if you just type |CLI, you'll be put in a mode where you can type RSX commands (i.e. those usually prefixed with |) to your heart's content. It's easier than from BASIC, because you can use spaces instead of commas to separate items, and you needn't bother with the speech marks (unless, of course, you have a space in the item). For example, let's say that we want to rename the file OLDIE.BAS to NEWBIE.BAS. 464 owners would usually have to suffer this:

a$="OLDIE.BAS": b$="NEWBIE.BAS": |REN,@b$,@a$

Other CPC and Plus owners could get away with this:


Under |CLI, though, it's a much easier


To quit from command mode, press ESC.

|CLI has other advantages. If you supply it with an argument, it won't go into the command mode, but will instead try to execute the string you supplied as a command. For example, if a$ contained "ERA *.BAK", then typing |CLI,@a$ would delete all the backup files on a disc.


|EXEC                       ;   ;(all machines)
a$="filename": |EXEC,@a$        (BASIC 1.0)
|EXEC,"filename"               ; (BASIC 1.1)

|CLI acts on what you type in at the keyboard. |EXEC is similar, but takes its orders from a text file (perhaps created with a word-processor or text editor) on your tape or disc. This means that you can write a list of RSX commands to execute, save them (say) in the file "COMMANDS.BAT", and then execute them using |EXEC,"COMMANDS.BAT" .

For ultimate convenience, if you just type |EXEC on its own, it will try to load and execute a file called #EXEC.BAT .

Possible uses? Well, you could set up a file to set up your favourite colours and function key definitions, for example, erase all your backup files, and then leap into Protext. Your imagination is the only limit (er, so èlong as your imagination isn't greater than 800k, because otherwise the file will overflow even a 3.5" disc).

If you want to use control codes in the file being executed - for example, CTRL-M (which is the same as ENTER or RETURN), at the end of a key definition - use the "^" symbol followed by the appropriate letter.



|EDIT,character value           ;(all machines)
a$="character": |EDIT,@a$       (BASIC 1.0)
|EDIT,"character"             ;  (BASIC 1.1)

Working out character designs manually for BASIC's SYMBOL command can be a chore at the best of times, downright annoying at the worst. But what is that in the distance? Could it be a heroic RSX decked in shades and riding a Harley-Davidson here to save the day? Yes, it is. But please don't laugh at the poor thing.

Select a character to edit using one of the above commands (the first one takes an ASCII code - 65 for capital A, for example, or 240 for an up arrow - as an argument, whereas the other methods take the actual character), and the character will appear. You can move your cursor using the cursor keys, invert pixels with COPY, and finish with ENTER or RETURN. When you've finished, the appropriate numbers will be displayed on-screen (in hex), ready to be copied into a SYMBOL statement.

Remember that, to define a character, you must have set SYMBOL AFTER appropriately beforehand (i.e. if you want to define character 100, you'll need to have typed SYMBOL AFTER 100 or less). An error will appear if you haven't. The standard loader for the Toolkit sets SYMBOL AFTER 32, so you should be ok.

                                    ; -=-

a$="text": |DOUBLE,@a$          (BASIC 1.0)
|DOUBLE,"text"                ;  (BASIC 1.1)

Prints double-height text.

One note: you must have set SYMBOL AFTER 254 or less beforehand. The default is SYMBOL AFTER 240 when you first turn on, and the AA Toolkit sets it to SYMBOL AFTER 32, so it shouldn't be a problem.


a$="text": |WRITE,[style,] @a$  (BASIC 1.0)
|WRITE,[style,] @a$             ;(BASIC 1.1)

Writes text to the screen in a specified style. The style is expressed by a number, which can be any of these:

        1       bold
        2       thin
        4       italics
        8       underlined
        16      flippy (upside-down)

...or you can add two (or more) together for a combination of styles.

  You can even change style half-way through some text. Use CTRL-B to toggle bold on or off, CTRL-T for thin, CTRL-I for italics, CTRL-U for underline, and CTRL-F for flippy. (Who said programmers had no imagination...?) If you're going to do this later on in the text, you can leave out the number in the command if you want, so the text will start out plain (like writing 0).

  This command relies on at least SYMBOL AFTER 255 being set (see above).


|MODE,mode number             ;  (all machines)
|INK,ink,colour               ;  (all machines)
|BORDER,colour                ;  (all machines)

Yes, these do work in the same way as the standard BASIC commands. We've just supplied you with them as RSXs so that you can use them from an |EXEC file.



|CURSOR[,system switch],user switch

These pretty much emulate the commands to be found in BASIC 1.1, for the benefit of those struggling over Type-Ins that don't work on the 464. Simply replace CLEAR INPUT with |CLEAR.INPUT, for example, and hey presto.

  |COPY.CHR works in a slightly different way to the 6128's COPYCHR$ function. Instead of a$=COPYCHR$(#0), you would write

        a%=0: |COPY.CHR,@a%: a$=CHR$(a%)

  Note that the "a%=0" is important (although the variable can be called anything, of course).



|MEMORY                        ; (all machines)

Draws a graphical representation of memory very, very quickly. Coloured bits indicate there's something in the memory at that point, whereas blank bits suggest that it's empty.

                                    ; -=-

|DUMP,start[,finish]           ; (all machines)

Displays a section of memory on the screen, from the start address to the finish address. If no finish address is specified, then a short display will be produced from the start address.

  When displaying long sections of memory, the computer pauses every so often and waits for you to press a key.

                                    ; -=-

|FIND,start,finish,byte         ;(all machines)

Looks through memory for the occurrence of a particular byte, and prints up all the places at which it occurs.

                                    ; -=-

|BANK,bank-switch             ;  (128k systems and over only)

For use with the following commands, this command selects which bank of extra RAM is to be used. The standard 6128 extra 64k can be selected with |BANK,&C0. If you have a 256k expansion, |BANK,&C8, |BANK,&D0, and |BANK,&D8 may prove useful.

                                    ; -=-

|BANK.READ,from,to,length       (128k systems and over only)

This copies a section of memory from the currently selected bank of extra memory to the specified address in the main 64k, where you can wreak your wicked ways on it weasily. (Or stoatily, if you prefer.)

                                    ; -=-

|BANK.WRITE,from,to,length      (128k systems and over only)

Unsurprisingly, this is the opposite of the previous command, and copies memory from the main 64k to the extra memory.

                                    ; -=-

|COPY,from,to,length           ; (all machines)

This copies the specified portion of memory (in the main 64k). For example, to copy the contents of screen memory (which starts at &C000, and is &4000 bytes long) to &2000, you could type


                                    ; -=-

|FILL,address,length,byte       (all machines)

This fills a section of memory with the given byte, obliterating everything else underneath. |FILL &C000,&4000,240, for example, will fill screen memory with ink 1.

                                    ; -=-

|CALL,address                  ; (all machines)
|AF,value: |BC,value: |DE,value
|HL,value: |IX,value: |IY,value

The firmware has a lot of good routines in it, but many are not easily accessible from BASIC. These routines will help you to use them to the full. All you have to do is set up the required registers (so, to set HL to &4350, type |HL,&4350), and then CALL the routine using |CALL,address .

To set the accumulator to 5, you would type |AF,&0500 . This also sets the flags register to 0, but the flags are never significant on entering a firmware routine.

                                    ; -=-

                              ;  FILE COMMANDS

a$="filename":|TYPE,@a$         ;(BASIC 1.0)
a$="filename":|PTYPE,@a$        (BASIC 1.0)
|TYPE,"filename"               ; (BASIC 1.1)
|PTYPE,"filename"             ;  (BASIC 1.1)

These two commands type a file from tape or disc to the screen. |PTYPE prints
it on your printer, too. You can pause output at any time by pressing any key,
with another key to resume (ESC to quit).

  One useful feature of this is that it makes a half-decent job of Protext files, meaning that you no longer need to load the word-processor itself to read the files. (In fact, this instruction file is a Protext file.)

                                    ; -=-

a$="filename":|INFO,@a$         ;(BASIC 1.0)
|INFO,"filename"               ; (BASIC 1.1)

This reads header information from the specified file and displays it in hex
- filetype, start address and so on. Ideal for hackers.

                                    ; -=-

a$="filename": |LOAD,@a$,addr   (BASIC 1.0)
|LOAD,"filename",addr           ;(BASIC 1.1)

Loads a file into anywhere in (the main 64k of) memory. Unlike BASIC's normal LOAD command, this doesn't worry about HIMEM or other such nonsense.

                                    ; -=-

a$="filename": |DEPROTECT,@a$   (BASIC 1.0)
|DEPROTECT,"filename"           ;(BASIC 1.1)

Loads a protected BASIC program and removes its protection. Naughty naughty!

                                    ; -=-

|HL.WRITE,address,length,sync   (cassette)
|HL.READ,address,length,sync    (cassette)

Records an area of memory to tape as a headerless file, which is impossible to read if you don't know the sync byte (which should be a number between 0 and 255). Make sure you don't forget it.

  I must be going mad. I wrote the first sentence of the last paragraph originally as "Records and writes an area of Australia to Channel 4's current èschedule". Seriously. I need some sleep...

                                    ; -=-

                              ;  DISC COMMANDS


Record an area of memory (usually &200 bytes, half a kilobyte) directly to a sector on disc. Be very careful using |SECTOR.WRITE - if used indiscriminately on non-write-protected discs it could mess them up for good. Try experimenting on a disc of CP/M languages or something boring like that.

  The drive parameter should be 0 for drive A and 1 for drive B.

                                    ; -=-

|USER,user number

Just like the usual command, except that the 0-15 limit has been removed and you can now select any user area from 0 to 255. 229 is where erased files go to rest before they die forever.

                                    ; -=-


Catalogues the disc in the specified drive: 0 for drive A and 1 for drive B. This enables you to quickly catalogue a drive which you're not using at the moment, without having to go through the rigmarole of |B:CAT:|A.

                                    ; -=-

                           ; MISCELLANEOUS COMMANDS

a$="string":|KEY,exp.token,@a$  (BASIC 1.0)
|KEY,expansion token,"string"   (BASIC 1.1)

Sets up a function key (usually) to generate a string of characters: |KEY,0, "|CLI"+CHR$(13), for example, will set f0 to enter CLI mode. This is no different from the standard Amstrad KEY command, but, again, is provided for use in |EXEC files. In an |EXEC file, you would write the above as...


                                    ; -=-

|PUTKEY,character value         ;(all machines)
a$="character": |PUTKEY,@a$     (BASIC 1.0)
|PUTKEY,"character"             ;(BASIC 1.1)

Pretends that a key has been pressed, so that next time you come to read the keyboard (using INKEY$, INPUT or similar), that key will appear. You can only "put back" one key at a time before reading a key. Useful for when certain keys (detected with INKEY$) trigger off a line of INPUT beginning with that letter.

Using the commands in your own programs

The file that does all the hard work is called TOOLKIT.RSX. To load it and set up the extra commands, you would need to use a few lines like this at the beginning of your program:

        10 SYMBOL AFTER 32
        20 MEMORY &7FFF
        30 LOAD "TOOLKIT.RSX"
        40 CALL &8000

  Make sure that TOOLKIT.RSX is on the current disc or tape.

Error messages

There are a number of error messages that the commands might generate. Here's what they mean:

Cassette overrun
- The headerless file was not of the right length.

Character not editable
- The current SYMBOL AFTER setting is inappropriate for the command you are  trying to carry out.

Could not set key
- You've tried to set too many function keys at once, and the computer has run  out of memory for them.

Disc error
- Five hundred elephants came charging through the undergrowth. (Well,  really.)

Escape pressed
- A tape operation was interrupted by you pressing ESC.

File error
- Some sort of error occurred while trying to access a file.

Illegal parameter count
- You haven't supplied the right number of parameters (or arguments) for a  command.

Read error b (CRC error)
- Bad news. Sounds like your headerless file has been messed up.

Unknown command
- |CLI or |EXEC is trying to find a command you have given it and failing  miserably, poor thing.


You are welcome to use the AA Toolkit (TOOLKIT.RSX) in your own programs - after all, that's what it's here for! An acknowledgement along the lines of "Uses AA Toolkit from Amstrad Action and Robot PD" would be appreciated. The Toolkit may not be copied as a toolkit, rather than as part of a program, without the permission of the author.

The final word

And that's your lot. If you have any problems working with the Toolkit, drop us a line at Technical Forum, Amstrad Action, 30 Monmouth Street, Bath, Avon BA1 2BW: any suggestions for new commands for a possible future version of the Toolkit, and improvements to existing ones, are also welcome.

Meanwhile, I'm off to sleep before going off to sunny Pembrokeshire for a week tomorrow. Programming is never good for your sleep patterns...!

Enjoy yourself,
Richard Fairhurst

Amstrad Action - Robot PD - March 1994

★ YEAR: 1994
★ LICENCE: ???


» The  AA  Toolkit-Volume  One    (Amstrad  Action)    ENGLISHDATE: 2017-12-21
DL: 18 fois
SIZE: 21Ko
NOTE: Upload by CPCLOV ; 40 Cyls

Je participe au site:
» Newfile(s) upload/Envoye de fichier(s)
★ AMSTRAD CPC ★ A voir aussi sur CPCrulez , les sujets suivants pourront vous intéresser...

» Applications » RSX Scroller v4.0
» Applications » Rsx - Fade Mix (Popular Computing Weekly)
» Applications » Extensions ... Expanded BASIC for the CPC464 (Home Computing Weekly)
» Applications » 464 To 664 - 6128 (The Amstrad User)
» Applications » Utilitaire de Recopie d'Ecran (CPC Revue)
» Applications » RSX Encrypter


L'alinéa 8 de l'article L122-5 du Code de la propriété intellectuelle explique que « Lorsque l'œuvre a été divulguée, l'auteur ne peut interdire la reproduction d'une œuvre et sa représentation effectuées à des fins de conservation ou destinées à préserver les conditions de sa consultation à des fins de recherche ou détudes privées par des particuliers, dans les locaux de l'établissement et sur des terminaux dédiés par des bibliothèques accessibles au public, par des musées ou par des services d'archives, sous réserve que ceux-ci ne recherchent aucun avantage économique ou commercial ». Pas de problème donc pour nous!

CPCrulez[Content Management System] v8.7-desktop/cache
Page créée en 086 millisecondes et consultée 905 fois

L'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent  du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko.