# Keystroke programming

Keystroke programming describes a specific way of programming by which each keystroke on a device or application is recorded in some way and then played back so that the recorded key-presses can be repeated multiple times. Keystroke programming is most commonly but not exclusively found in programmable calculators—there are keystroke-programmable software applications, too, such as Vim.

## TI calculator example

The Texas Instruments TI-58/TI-58C/TI-59 calculators were programmable, and program storage took the form of a sequence of codes which (mostly) corresponded to the position of keys on the calculator keypad. Here is a simplified diagram of the basic key layout:
| | x1 | x2 | x3 | x4 | x5 |
| 1x | A | B | C | D | E |
| 2x | 2nd | INV | lnx | CE | CLR |
| 3x | LRN | x⇌t | x$^2$ | √x | 1/x |
| 4x | SST | STO | RCL | SUM | y$^x$ |
| 5x | BST | EE | ( | ) | ÷ |
| 6x | GTO | 7 | 8 | 9 | × |
| 7x | SBR | 4 | 5 | 6 | - |
| 8x | RST | 1 | 2 | 3 | + |
| 9x | R/S | 0 | . | +/- | = |
Each key is assigned a two-digit code; for most (but not all) keys, the tens digit comes from the row number (as indicated down the left of the table) and the units digit comes from the column number (as indicated across the top of the table).
Now consider a very simple program, which adds 2 to the number being displayed, and then stops. The program is entered starting from program location 000, and looks like this:
| Location | Contents | Meaning | Comments |
| 000 | 85 | + | |
| 001 | 02 | 2 | |
| 002 | 95 | = | compute result |
| 003 | 91 | R/S | stop program |
To use this program, you would enter the number n to be operated on, press RST to ensure the current program location was 000, then R/S to start execution. When the program stops (which should happen quite quickly for such a simple program), the display will be showing the number n + 2.
You can see that the codes 85, 95 and 91 correspond to the positions of the keys labelled + , = and R/S on the grid above, but the code for the 2 is not 83 as you would expect from the grid position, but 02. This last code was chosen to be more easily understandable by a human trying to read the program. There is no row 0, so the codes 00 .. 09 are used to represent the keys 0 .. 9 .

### Context-dependent interpretations

These TI calculators allowed for addressing up to 100 data memory locations, numbered 00 to 99 (some models had a lower limit than this). A keystroke sequence like STO 4 2 (store the currently-displayed number into memory 42) would be encoded as 42 42. In this case the first 42 is the key code for the STO key, but the second 42 is not a key code, but a memory register number. The calculator knows to interpret it as such because that's what has to follow the code for the STO key.
Program addresses were 3 digits, potentially allowing programs to consist of up to 1000 steps, numbered 000 to 999 (though in fact none of the models produced allowed for this maximum). A branch instruction, for example GTO 3 4 5 (unconditional branch to location 345) would be encoded as 61 03 45. In this case the hundreds digit of the branch destination is in the units digit of the second instruction byte (after the opcode), with a zero tens digit; and the remaining digits are in the third instruction byte.
A code sequence like 61 11, on the other hand, represents the keystrokes GTO A , which is a branch to the location marked by the symbolic label A . The calculator can tell this is a symbolic branch, rather than a branch to a numbered location, because the tens digit of the byte immediately following the opcode is not zero.
Most of the keys on the keypad can be used as symbolic labels. For example, sequences like GTO STO and GTO GTO are legitimate, provided that STO and GTO have in fact been defined as labels somewhere in the program.

### Modifier keys

Most of the keys had multiple functions, depending on whether INV or 2nd had been pressed beforehand. INV invoked the "inverse" (whatever that meant) of the following function, and was recorded in a program as a separate keystroke (code 22), while 2nd invoked a completely different function which was written on the keypad faceplate just above the key. For example, pressing 2nd x$^2$ invoked the sin function, while INV 2nd x$^2$ (or INV sin) gave you the arcsine.
The code for this alternate function is derived from that of the original key function by adding 5 to the units digit (without carry to the tens digit). Thus, the key codes corresponding to the position of the 2nd key itself (21 and 26) are never used as opcodes. Here is the table of the codes produced with the 2nd prefix:
| | x6 | x7 | x8 | x9 | x0 |
| 1x | A' | B' | C' | D' | E' |
| 2x | | INV | log | CP | CLR |
| 3x | Pgm | P→R | sin | cos | tan |
| 4x | Ins | CMs | Exc | Prd | Ind |
| 5x | Del | Eng | Fix | Int | |x| |
| 6x | Pause | x=t | Nop | Op | Deg |
| 7x | Lbl | x≥t | Σx | mean(x) | Rad |
| 8x | St flg | If flg | D.MS | π | Grad |
| 9x | Write | Dsz | Adv | Prt | List |

### Merged keystrokes

The Ind key allows for indirection: wherever a reference to a memory register or a program location is allowed, this key can be used to fetch the actual value from a memory register. For example, the key sequence RCL Ind 1 0 means to fetch the value in memory register 10, and use that value in turn as the number of a memory register whose contents are to be fetched as the current operand. However, in this case the Ind cannot be encoded as code 40, because the code sequence 43 40 would be interpreted as RCL 4 0 , not RCL Ind.
But, because of the use of the 00 .. 09 codes for the 0 .. 9 keys, the codes 62-64, 72-74, 82-84 and 92 are available for other uses. So most of these are reallocated to represent op Ind sequences:
| | x2 | x3 | x4 |
| 6x | Pgm Ind | Exc Ind | Prd Ind |
| 7x | STO Ind | RCL Ind | SUM Ind |
| 8x | | GTO Ind | Op Ind |
| 9x | INV SBR | | |
Thus, the key sequence RCL Ind 1 0 would be encoded as 73 10.
Note the use of code 92 for INV SBR (return from subroutine); this was not necessary for reasons of ambiguity, but was done to save space with such a common sequence.