---

NMH BASIC

Download: nmhbas23c.zip (version 1.2, 74KB) | nmhbas25c.zip (version 2.1, 90KB) | man page

This is a small BASIC interpreter that I wrote in the early 1990s. For some reason I think it is one of the coolest programs I have ever written. Maybe because it is just a bit under 5K bytes large and still does something useful. Maybe it is just nostalgia.

1. Programs
2. Implementation
3. Hacks and Quirks Arrays | Input/Output | Conditional Statements | Listings
4. NMH BASIC II
5. NMH BASIC III

Programs

One of the more interesting programs I have written in NMH BASIC is a variant of the well-known mine sweeper game that runs in text mode. Not just text mode, actually, but (tele)typewriter mode, as it reprints the playing field after every move.

The screenshots use Viacheslav Slavinsky’s excellent GlassTTY font, a TrueType font that perfectly resembles the one used in the DEC VT-220 terminal. The same font, at bigger magnification, is used in the NMH BASIC logo.

What is maybe interesting about the mine sweeper clone is that it uses a stackless floodfill algorithm that stores its state in the playing field itself and needs no dynamic memory at all. I have recently described it in the paper A Stackless Floodfill Automaton (PDF, 34KB). A demo showing an animation of the algorithm is included in the NMH BASIC package.

There are other programs in the package, most of them rather simple, like an implementation of the Hangman game, the (rather pointless) Nim game, a banner printer, a random number generator, etc. NMH BASIC does not have a RNG, so a 15-bit linear feedback shift register is implemented in BASIC to generate pseudo-random numbers.

The first program I have ever written in NMH BASIC was the inevitable prime number sieve. I have no idea how often I have loaded and run it in the past decades - until the Floodfill demo became my new favorite. Here is the code of my first NMH BASIC program (the backslash is the division remainder operator):

10 REM 'PRINT PRIME NUMBERS'
20 REM 'M = NUMBER OF PRIMES TO PRINT'
100 LET M = 1000
105 DIM Z(M)
110 LET Z(0) = 2 : LET T = 1 : LET P = 1
115 PRINT 2,
120 IF T >= M GOTO 200
130 LET P = P+2 : LET O = 1
140 FOR I = 0 TO T-1
150 IF P\Z(I) = 0 LET O = 0 : LET I = T
160 NEXT
170 IF O = 0 GOTO 120
180 LET Z(T) = P : LET T = T+1
185 PRINT P,
190 GOTO 120
200 END

Implementation

I wrote the first version of NMH BASIC in 1994, recycling some parts that I had written in the years 1991..1993. The first version that I wrote in 1994 was a prototype in BASYL-II which I then translated, function by function, to 8086 assembly language. The resulting executable had a size of about 4700bytes and because the token representation that the interpreter uses internally is quite efficient, you could do interesting things with NMH BASIC in as little as 12Kbytes of memory. I had named the interpreter 12K-BASIC initially, but soon learned that others had had that idea before me.

Of course in 1994 memory was already measured in megabytes, so you might say that writing a tiny BASIC interpreter was kind of pointless at that time. It depends I would say; it is better than getting drunk in a bar, and now, almost 30 years later, I still enjoy playing with this little program. So much, in fact, that I decided to translate the original code to T3X/0, so that I can play with it on Unix without having to use an emulator.

All the above versions are included in the package: the original BASYL-II version, the assembly language version, and the new T3X version. You can recompile the T3X version with T3X/0 and the 8086 assembly language version with TASM or MASM. You need to create a COM file or it will not run. A precompiled COM file and Tcode machine executable (as well as a Tcode machine for Unix) are also included in the package.

There is also a simplified version of the interpreter that runs under CP/M. A COM file for CP/M (BASICS.COM) is also included in the archive. The CP/M version currently needs 32K bytes of TPA to run.

Hacks and Quirks

Arrays

The NMH BASIC language contains some interesting (IMHO) hacks to make its implementation simpler.

All variables have either single-character names or names consisting of a character and a digit, like A0, B2, Z9, etc. The expressions A and A0 and A(0) all refer to the same variable. If you do not use A0..A9, you can use A as a 10-slot array A(0) .. A(9). Or you can use A5 in the place of A(5) if you are refering to a fixed slot.

It is getting even weirder. A(10) is the same as B or B0 or B(0). A(22) is equal to C2 or C(2) and, finally, A(259) would be equal to Z(9). So, for instance, if you do not use any Z’s, you can use Y as a 20-slot array. In this case the command DIM Y(20) is really a null-operation. It merely serves as a reminder that Y is a 20-slot array (and Z should not be used).

You could also use Y as a 50-alot array by dimensioning it with DIM Y(50). In this case the elements of Z will still be used, but 40 additional slots will be allocated to integer variable storage, so Z becomes a 40-slot array and Y a 50-slot array. It probably goes without saying that most programs either use single-character variables as 10-slot arrays or dimension Z, if a larger array is needed.

This also means that DIM Y(50) and DIM Z(50) in the same program would just allocate 50 integer slots to Z and the last 40 slots of Y would overlap with the slots of Z. Having multiple large arrays in the same NMH BASIC program requires some hacking, like using Z(0)..Z(99) for one array and Z(100)..Z(199) for the other.

Note the definition of "large" above. NMH BASIC uses 12Kbytes of memory in total: for integer variables, string variables, program memory, stacks, and the machine code of the interpreter itself! You could probably write a version of this interpreter that would run on a CP/M machine with as little as 16K bytes of transient program area (but I have never done so).

Input/Output

The interpreter performs I/O on "units", where each unit is assigned a file or device when the interpreter is started. NMH BASIC programs cannot open or close any files. They can only redirect input and output to the assigned units. I/O is sequential, i.e. each unit is like a tape drive. The following program prints the data stored on unit #5:

100 LET X = IOCTL(5, 100) : INPUT #5
110 INPUT A$ : IF ASC(A$) = 255 INPUT #0 : END
120 PRINT A$ : GOTO 110

The statement INPUT #5 redirects input to unit #5, so from that point on all INPUT statements will read from that unit. (Analogously, PRINT #5 would redirect output to unit #5.) When a string read from a unit contains the value 255 in its first slot, there is no more input available from the current input unit. INPUT #0 connects input back to the keyboard. Note that PRINT #1 would connect output back to the screen.

There is an IOCTL function that can perform several "services" on a unit, like rewinding it, appending to it (moving the read/write pointer to the end of the unit), or truncating it (or writing an EOF marker on a tape). The IOCTL call in the above example rewinds the unit.

The maximum length of a line or string is 64 bytes. Reading anything longer, either via INPUT or by entering it at the interpreter prompt, will result in an error. The CR,LF characters that separate lines are not counted.

Conditional Statements

I have forgotten how other BASIC dialects handle this, but I suspect that NMH BASIC is the odd one out here: in an IF statement the entire rest of the line is executed conditionally. For example

IF 1 = 1 PRINT 'FOO' : PRINT 'BAR'

would print both FOO and BAR. There is no THEN or ELSE keyword. The first keyword after the condition of IF starts the conditional part of the IF statement. When the condition in IF is false, the interpreter advances to the next line. An alternative branch is implemented with jump around jumps using GOTO:

100 IF condition GOTO 130
110 alternative statements
120 GOTO 140
130 consequent statements
140 REM

Or, if the condition and statements are short:

100 IF condition statements
110 IF # condition statements

The # operator implements the logical NOT. It had high precedence in NMH BASIC up to version 1.2, but has very low precedence in NMH BASIC II. Interestingly, this change did not affect any programs in the archive. There is a logical AND, but not a logical OR in IF. If there are multiple conditions separated by commas then the conditional statements will only execute, if all conditions are true. For example, the statement

IF 0 < C, C < 11 STOP

will stop program execution, if C is in the range 1..10. To implement a logical OR, multiple IF statemements with the same conditional part (or jumps around jumps) have to be used.

Listings

NMH BASIC 1.x listed programs with blanks between all adjacent tokens. NMH BASIC II uses a more compact representation. Either way is merely a characteristic of the LIST routine, though. You can enter a program as

FOR I=1TO10:PRINT A(I):NEXT

but the LIST command will print it as

FOR I = 1 TO 10 : PRINT A ( I ) : NEXT

in NMH BASIC and as

FOR I = 1 TO 10 : PRINT A(I) : NEXT

in NMH BASIC II.

This has the weird side effect that sometimes you can SAVE a program but cannot LOAD it later, because some lines will be shorter than 64 characters when you enter them, but LIST (and hence SAVE) will blow them up to a bigger size.

This is mostly a problem in NMH BASIC 1.x, which inserts blanks between all tokens. For example:

100 IF ASC(MID$(A$, I, 1)) = ASC('X') LET X = X+1 : GOTO 120
----+----1----+----2----+----3----+----4----+----5----+----6---|
100 IF ASC( MID$( A$ , I , 1 ) ) = ASC( 'X' ) LET X = X + 1 : GOTO 120

There is no workaround. When a program cannot be loaded, the only remedy is to edit it with a text editor and fix it, either by removing unnecessary blanks or, even better, by splitting the offending line. E.g.:

100 LET C = ASC( MID$( A$ , I , 1 ) )
105 IF C = ASC( 'X' ) LET X = X + 1 : GOTO 120

Finally, it is a good idea to keep NMH BASIC programs in DOS text format with CR/LF line separators, even on Unix systems, because otherwise the DOS version of the interpreter will refuse to load them.

NMH BASIC II

In December 2024 I changed a few things and pubished a new version of NMH BASIC, which I called, for lack of imagination, NMH BASIC II. The new version changes the precedence of the # (logical NOT) operator from highest to lowest (this was a mistake in the original version!) and uses a more compact and more comprehensible LIST format, which is also used for saving programs. Because some code was simplified in the interpreter at the same time, the new version is one byte smaller than the original version.

NMH BASIC III

Download: nmhbas3_30.zip (version 3.0, 105KB) | man page

Version 3.x of NMH BASIC is an in-progress version that differs from the previous versions in a few points that are described in detail in the manual. Most prominently, the CMPS ("compare strings") function has been replaced with string comparison operators, so, for example,

IF CMPS(A$, 'FOO') = 0 PRINT 'YEP'

would now be written as

IF A$ = 'FOO' PRINT 'YEP'

Then, NMH BASIC III supports baudot-encoded units. This means that any unit connected to the interpreter can be written to and read from using five-channel baudot-encoding (CCITT-2, US-TTY). So the interpreter can, in theory, save and load programs to/from five-hole paper tape.

The T3X/0 version of the interpreter is currently fully working. There also is a more efficient Z80 version written in assembly language, which is work in slow progress. It currently runs all the example programs, but lacks baudot-encoded units and may still have a few bugs. An 8086 version written in assembly language may appear later.

---