|★ APPLICATIONS ★ UTILITAIRES RSX/LIGNE DE COMMANDE ★ The Amstrad Action Toolkit volume one ★|
|Amstrad Action Toolkit 1|The Amstrad Action Toolkit volume one)||Applications Utilitaires Rsx/ligne De Commande|
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.
HOW THE COMMANDS ARE ADDED
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...
...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...
A NOTE FOR 464 OWNERS (BASIC 1.0)
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:
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...!)
|CLI ; (all machines)
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
REN NEWBIE.BAS OLDIE.BAS
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)
|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)
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)
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)
Writes text to the screen in a specified style. The style is expressed by a number, which can be any of these:
...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)
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.
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)
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)
These two commands type a file from tape or disc to the screen. |PTYPE prints
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)
This reads header information from the specified file and displays it in hex
a$="filename": |LOAD,@a$,addr (BASIC 1.0)
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)
Loads a protected BASIC program and removes its protection. Naughty naughty!
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.
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)
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...
KEY 0 |CLI^M
|PUTKEY,character value ;(all machines)
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.
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
Make sure that TOOLKIT.RSX is on the current disc or tape.
There are a number of error messages that the commands might generate. Here's what they mean:
Character not editable
Could not set key
Illegal parameter count
Read error b (CRC error)
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.
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...!
Amstrad Action - Robot PD - March 1994