The CoCo, like most computers of its era, did not have lowercase built in.

Even when it had it built in, it didn’t have it built-in! This mode was only available in the tail-end models, and only through POKE.

• Latest superBASIC code. (Zip file, 18.9 KB)
• Latest superBASIC downloadable manual
• Latest superBASIC print manual^•

There are a lot of things I’m nostalgic for about the early era of home computers. The cameraderie. The home-brew spirit. The assumption that we were going to control the computer rather than the computer control us—there were so many cartoons making fun of the Pavlovian response to computer notifications that seem sadly prophetic today. One thing I am not nostalgic for is programming in the BASIC of the era. I wrote a lot about that in Learning to program without BASIC. BASIC programs then were a sludgy melt of undifferentiated words and numbers.

But I have an old computer, and I want to program it. It is the Tandy Color Computer 2, and it is not an easy computer to write programs on. Even the TRS-80 Model 1 could show 1,024 characters at a time, 16 lines of 64 characters. The Color Computer had half that, at 16 lines of 32 characters each. There is no holding anything but the simplest subroutine onscreen intact.

That’s part of why I wrote basicize, to help me write programs for emulators using a modern text editor on a modern computer. Not having to deal with line numbers was also a major impetus, and labeling made it a lot easier to see where the code was going. But I mainly use basicize for modifying existing code. I’ll take the code, organize it into sections, and label them. This does not help structure the code, nor does it make the code self-commenting. The variables are still one to two characters and there are no loops other than FOR/NEXT and GOTO.

It occurred to me while writing a BASIC program to examine the video modes of the CoCo 2¹ that I should be able to easily convert long variables into short ones using Perl. It’s practically what Perl is designed for. And simple loops? It’s BASIC because it’s basic. That should be easy.

What I ended up with is a preprocessor that makes BASIC fun again. It will take something like this:

and generate something like this²:

Here’s an example of what an actual program in superBASIC looks like. This code draws a simple clock on the screen, and then moves the three hands appropriately.

Turn this code into Extended Color BASIC for the CoCo by piping the output of superbasic to a file:

Here’s the BASIC code it generates from that file:

For a cheap clock, it’s fairly accurate. Since the Color Computer does not have a built-in real-time clock, this uses a FOR/NEXT loop to delay between each iteration of the second hand. This works because on these old computers the program you’re running is the only process on the computer. Which means that the code takes a predictable amount of time.

Because it takes longer to draw high-resolution clock hands than medium-resolution ones, the delay is shorter for the high-resolution clock.³

This code is a lot easier to read and follow than standard old-school BASIC. Variables have self-commenting names, subroutines are named, and loops, and their conditions, are clearly visible. SuperBASIC converts these subroutines, loops, and switch/case sections to standard BASIC. Unlike basicize, superbasic doesn’t support GOTO at all. I haven’t found any need for it yet. Of course, its loops and so on are handled under the hood by conditional GOTO statements.

The wondrous high resolution mode of the CoCo!

And the amazing colors!

Loops can be nested, as indefinitely as your memory allows.⁴ Switches cannot be nested. I don’t think it will be difficult, but I haven’t had a need for it yet. I don’t like to add complexity where it isn’t needed, and I also prefer to have a necessary example to code new features from instead of a made-up example. I also wanted to better understand how a multi-section block would work without the complications of multiple levels. I am not a language programmer, and am learning this as I go.

SuperBASIC will attempt to compress CASE blocks and LOOPS into one line if it can do so—basically, if there are no IF/THEN lines in that block of code.⁵ For short LOOP blocks, it will successfully create the standard 10 A$=INKEY$:IF A$="" THEN 10 type of loop.

If you look at the help text, you’ll see some features that aren’t used in either CLOCK.BAS or MODE.BAS, but I’m using them in other programs I’m writing, which I hope to post soon. SuperBASIC really has made writing BASIC fun again. For example, I don’t use it in the clock (it would make timing wonky) but I have two versions of Hunt the Wumpus: one for use on my Color Computer with a speech synthesizer, and one for use in XRoar, which does not have a speech synthesizer. When creating the Color Computer, with speech, code, I use:

The option --switch speech turns on the speech synthesizer code.

The exception is LOOP WHILE. I thought I needed this, but every instance of it turned out to make more sense as ENDLOOP UNLESS, so I’m not currently using this in any code. I have a suspicion that LOOP WHILE will be most useful for iterative tasks such as reducing an existing variable to a standard range, such as:

Currently, one-line loops will turn this into:

Much in the same way that CASE statements are collapsed to a single line when possible. However, I don’t have any code that uses loops with opening conditionals, so don’t be surprised if I alter how conditions work at the start of a loop, or remove starting-loop conditions entirely, once I have real examples in hand.

SuperBASIC also supports a handful of directives that are replaced directly with BASIC code. PAUSE creates a FOR/NEXT loop that assumes $seconds is the number of iterations needed for one second. I took this number directly from the Color Computer manual. WRAP takes the line of given text and prints it to the screen so that no word is chopped unless it’s longer than 32 characters. It can also WRAP-CENTER. DATA creates a series of DATA/ENDDATA lines that top out at 32-characters each for readability. You can see the latter in the included MODE.BAS code, which uses DATA statements to store the names of the screen colors.

This becomes:

Variable names begin with the percent symbol, and end with either the percent symbol (for numeric variables) or the dollar sign (for strings). Because single-letter variables are so ubiquitous in boilerplate code, SuperBASIC assumes that your programs will use single-letter variables. This means you can still write, for example, FOR I=1 TO 13:NEXT I. When and if you use variables directly, always use single-character variables to avoid conflicting with an auto-generated variable. SuperBASIC creates only two-character variables, and in fact disallows a one-character variable name for its own use; %a$ not only isn’t a valid SuperBASIC variable, it won’t be detected as one. This isn’t necessary, I just find it completely unreadable.

If you want to see what variables SuperBASIC is creating, add --variables to the command line:

This lists the superBASIC variables in the clock program, along with their ECB variable names:

VARIABLES:

It also lists the subroutines and the line number they ended up on. The clock only has one subroutine:

Here are the various things that superBASIC supports. You can see the same list by typing superbasic --help.⁶

I’m not trying to hide the underlying BASIC, just make it easier to create while making the code much more maintainable. That’s why the loops use ENDLOOP UNLESS instead of ENDLOOP IF. The latter would require reversing the logic of the underlying IF/THEN line. For example, ENDLOOP UNLESS (%mode$<>"H" AND %mode$<>"C") produces the BASIC line IF MO<>"H" AND MO<>"C" THEN <start-of-loop>; but ENDLOOP IF (%mode$ = "H" OR %mode$ = "C") would require inverting the logic, to IF NOT(MO="H" OR MO="C") THEN <start-of-loop>.

It’s not a huge deal, I’d just like to have what’s written be what’s used where possible. It makes it harder to see how the underlying BASIC code works if the underlying BASIC code is the inverse of the code that created it. I can easily see myself changing my mind. I can easily see preferring ENDLOOP IF, or, less easily, LOOP UNTIL.

When programming for the CoCo on my Macintosh, I find the XRoar emulator very useful for testing code as I write, and the CoCo SDC invaluable for transferring the resulting program to my Color Computer 2.

Unlike basicize, I wrote this specifically for the Color Computer. There’s nothing in it that couldn’t be easily modified for other BASICs, however. It does not enforce any particular kind of BASIC in the lines that are not SuperBASIC directives. The SuperBASIC directives themselves create relatively standard BASIC statements for the time, at least among the Microsoft variants. The only things that are CoCo-specific are the aforementioned $seconds for delay loops, and the screen width of 32 in $screenWidth. They should each be able to be changed simply by altering the value of the variable. The screen width is only used by SuperBASIC’s hash-to-REM, DATA, and WRAP directives, and the loops-per-second is only used by PAUSE.

I wrote SuperBASIC in Perl, and it should work on any computer that has Perl installed. The zip file includes SuperBASIC and three sample utilities: the clock program above, the program I first used SuperBASIC on, for flipping through the CoCo2’s video modes, and a program for displaying the ASCII value of keyboard keys and the joystick position and button status.

SuperBASIC (Zip file, 18.9 KB)