Wang BASIC

Wang BASIC is a series of BASIC programming languages for computers from Wang Laboratories. The term can be used to refer to the BASIC on any Wang machine, but is mostly associated with the versions on the Wang 2200 minicomputer series of the early 1970s. When these machines were updated to the VP series in 1976, BASIC-2 was introduced and remained the pattern for future machines in the 2200 series. A planned BASIC-3 was never released.
Wang offered several models of each version of the 2200 series, differing only in the amount of microcode stored in read only memory (ROM), and thus the number of commands available in BASIC on that machine. For instance, the B model machines differed from the base-model A by doubling the ROM and using that to store a variety of input/output and file management commands.
Wang BASIC closely followed the original Dartmouth BASIC in syntax, but was an interpreter as opposed to a compile-and-go system. A notable feature was that all math used double-precision binary-coded decimal (BCD) format, which was unusual for BASICs of the era. It lacked many features common to later dialects like Microsoft BASIC, but many of these features were added in BASIC-2.
Description.
The following description is based on the original BASIC found in the 2200A. Not all of the instructions listed below would be available in the base model; 2200B and C added dozens of new keywords, and are outlined separately below.
Program editing and execution.
The original Wang BASIC for the 2200 is a relatively standard version of the Dartmouth BASIC concept, and will be familiar to users of any common BASIC interpreters like Microsoft BASIC. Like most BASIC interpreters, Wang BASIC operated in immediate mode or program mode, switching to the later when a line number is seen at the start of the line when the (return) key is pressed. Line numbers ranged from 0 to 9999. Lines could be up to 192 characters, spanning several on-screen lines, and lines could contain multiple statements separated by colons. To aid organizing large programs, the language included a command.
 was used to display the program source code, while displayed only the first 15 lines and then paused. When paused, pressing the EXEC key displayed the next 15 lines. saved the current program to cassette and read it back in. Working with disk storage was slightly more complex, using , where F refereed to one of a number of pre-defined drives, in this case "F"ixed. would read over the next two files found on the tape, and then stop, allowing a subsequent or to work on the third file. was the opposite of SKIP, rewinding the file pointer.
 started execution, and could be directed to a particular line, as in . The command, typically used for debugging, allowed an optional following string that was printed out when that statement was performed. could be used to print out lines as they were run, which was often used in conjunction with the custom (break) and keys on the keyboard to move line-by-line through a program. was used to set a delay between lines in second units; set the delay to zero, would cause it to pause second after each line.
There was no command to clear memory of an existing program, instead one used to reset memory. (for "P"rogram) was the equivalent of NEW but optional from and to line numbers, deleting just that range of lines in a fashion similar to the command seen in some dialects. clears out variable values, normally accomplished by in most dialects. was similar to CLEAR V, but did not clear the value of shared variables (see below).
Syntax.
Branching was supported through , and . The alternate form, , was not supported. One limitation of Wang BASIC is that the THEN clause of an IF statement could only be a line number, in contrast to most common dialects that allow any statement after the THEN. It also lacked boolean conjunctions like or , so the test could have only a single comparison.
One interesting addition to the language was the idea of named routines. The implementation was based on the statement followed by a single quote and then a number from 0 to 255, for instance, . This could then be called using . To further confuse matters, the DEFFN line was a true function definition and could use parameters, like , which could be called with . In allows one to implement multi-line function definitions, which other dialects sometimes offered using the conventional function style rather than using GOSUB. Additionally, named routines in the range 0 to 31 were assigned to the similarly numbed keys on the 2200 keyboard, allowing them to be called directly with a single keypress.
 supported comma and semicolon separating parameters, the former moving the cursor to the next 16-character wide column, the later leaving the cursor at the end of the printed value. It supported the function, but not . In common with other "high end" BASICs of the era, Wang BASIC offered formatted output with and a separate "image". The image was defined using a separate line starting with the percent sign, for instance, and then using that format with . Any characters other than the formatting characters were echoed back during the print, so one could define a complete output with something like .
 statements could include a prompt, along with a comma-delimited list of one or more variables. Semicolons could not be used in the INPUT, and the cursor always remained at the end of the last printed element during entry.
Math and logic.
Like most dialects of the era, variable names could consist of a single uppercase letter or a letter followed by a single digit. It did not support two-letter names. Multiple variables could be set to an initial value using a comma-separated list, for instance, . As with most BASICs, the was always optional. Variables could be made into lists (one-dimensional arrays) using , as in which made a list of 5 numeric values. or two-dimensional arrays using .
Relational operators included the standard set of , , , , and . Trigonometric functions included , , , , , , , and . was an alias for ARCTAN. Trigonometric functions normally operated in radians, but could be set to use degrees using or gradians using , returning to radians with . Other functions included , , , and the pseudo-variable.
Unlike most BASICs, the function did not treat the parameter as a placeholder; any non-zero value made it operate like the RND seen in other BASICs, while a value of zero restarted the number sequence in the same fashion as the statement seen in other BASICs. This is a potential source of bugs when porting from other dialects, which generally ignored the parameter and often used zero as a parameter simply as a common placeholder.
Strings.
String variables were supported, and concatenation was supported using the plus operator. In contrast to later BASICs which used dynamic length strings on a heap, like Microsoft, Wang BASIC set all strings to a default length of 16 characters and would ignore any characters assigned beyond that. Unused characters at the end of a string were filled with space characters, and any trailing spaces were ignored in PRINT statements, which is another potential source of problems when porting code to Wang BASIC.
The storage length of any single string could be changed using the statement, which in this case used the slightly odd syntax of putting the length immediately after the variable name, like , instead of using parens as in a typical DIM statement. Strings had a maximum length of 64 characters. The syntax allowed lists of strings, for instance made a list of 5 strings of the default 16 character length, while made a list of 10 strings of 20 characters.
There were a small set of string functions. is a general-purpose array slicing command that replaces the DEC/Microsoft-style //. For instance, returns the five characters of A$ starting at character 10. The second parameter was optional, returned everything from the 5th character on. returned the length of the string, ignoring trailing spaces, so would return 3. To further confuse matters, empty string variables always returned a length of 1. Note that the string functions do not include the $, in contrast to most BASICs where these functions would be named , for instance, indicating the return value is a string, not a numeric value.
Data and I/O.
In keeping with the Dartmouth model, Wang BASIC included statements for storing constants within the program code, and these were read using the statement, which started at the first data element and then moved a pointer forward to the next element with every READ. could reset the READ pointer, and was expanded from the original Dartmouth version by allowing the pointer to be set particular item in the list, for instance, , which set it to the 10th element. Only 256 values could be entered in DATA statements in total in one program.
The statement could be used to redirect output from other BASIC commands to other devices, based on the "address" of the device. For instance, would send the output of subsequent PRINT statements to the printer at address 215, while returned output to the built-in CRT. would do the same for any following LIST statements. SELECT also had an optional following parameter to set the maximum line length, like . One could use SELECT with a variety of pre-defined devices, like CI for "console input" (normally the keyboard) or LIST to redirect the program listing to a different device.
Chaining programs.
As machines of the era had very limited amounts of memory, most dialects of BASIC included some way to "chain" programs together to allow a single program to be broken up into smaller modules. In Wang BASIC, this was accomplished with the and statements.
 declared one or more variables to be "common", or global in modern terminology. A program using chaining would typically declare a number of variables to be common near the top of the code, perhaps . When a separate program module is LOADed, the values in these variables will not be cleared, in contrast to the non-common variables which will be reset. Common variables could be cleared explicitly using , while clears non-common variables and leaves common variables alone. Variables could also be declared non-common using , which reset all common variables to normal, or to reset just the status of A. Confusingly, COM CLEAR also reset any other COM variables defined before A, so the results of COM CLEAR A would be different if the original program used or , in the first example all three would be reset while in the second only A would be reset.
The LOAD command was also used for chaining. One could optionally add start and end line numbers, in which case any existing lines between those limits would be deleted, or from the start line to the end of the program if only one number was specified. The new program is then loaded at that point and execution starts at the start line number, or start of the program if no start line was specified.
Variations on 2200 BASIC.
The original Wang BASIC came in several versions differing in the amount of ROM-based microcode, and thus the number of keywords supported.
2200B.
BASIC in the 2200B was a major expansion of the 2200A version. The additions can generally be classed into four categories; missing features, addition string commands, vector-like commands, and input/output. The differences between the version can be found in table form in the 2200 overview document.
Missing features that were addressed in 2200B included the addition of and . read a character from the keyboard without pausing, similar to in MS BASIC. searched a string and returned a numeric value within it. The function was similar to LEN, but returned the length of the length of the substring up to the first non-numeric character. For instance, if A$ is "1234.5", would return 6, whereas if A$ was "1234.5 " NUM would return 10, because spaces are valid in numbers.
2200B did not add a STR$ function, which converts a numeric value to a string. Instead, they added the command to read strings into numbers and vice versa. For instance, using the A$ above, would result in B containing the value 1234.5, while would leave B$ with something like "123 ". Dartmouth BASIC also included a CONVERT command but it was very different in purpose, in Dartmouth, would produce an array of values in B, with each element containing the ASCII code for the corresponding character in A$; in this case, B would contain 49,50,51,52,46,53, the ASCII values for the characters "1234.5". Wang's CONVERT also had a second mode that took a format specifier like PRINTUSING and used that to convert a number to a formatted string in a fashion analogous to C's sprintf.
The function returns the index of a given character in a string; would return 3. In contrast to MS's , POS could search for only a single character, not a multi-character string.
 converted a hexadecimal value into the corresponding character. For instance, would put a space character (hex 20) into the first character of A$. Multiple codes could be inserted at once; produces three characters, two backspaces and a cursor-right. HEX is the counterpart to the ASC function found in most BASICs, but uses a hex input instead of a decimal number. did the same for binary numbers.
A special purpose command was added to fill out a string with an initial value that's not a space. would fill A$ with X characters, while would put the hex value 41, the character A, into B$.
2200B also included a number of commands that worked in a vector-like fashion to perform common tasks that would normally be carried out using a loop, or in Dartmouth versions, matrix math commands. For example, took a list of expressions, added them together and returned the result. This was accomplished much faster than the same expressed using an infix expression; would be completed quicker than . Similar commands were , and .
The majority of the additions in 2200B were related to input/output, and mostly to working with floppy disk files. It introduced the concept of having several different file types, including the data file, indicated by prefixing "DA" on the file commands. A variety of other commands supported working with these files, including to duplicate a file, within a file, files, and to erase a file or to erase everything.
2200C.
In contrast to the 2200B version, which was a major expansion on the 2200A, 2200C was much more limited in scope. It added the command for clearing shared variables, a version of that returned hex, was used to "pop" a GOSUB off the stack, and for trapping errors within the program.
2200T.
Later models in the series added some or all of the commands in the B or C versions, but only the 2200T expanded on them. Most notable in the expansions was the addition of matrix math, but a few I/O details were also added.
The matrix math commands were largely identical to those found in later releases of Dartmouth BASIC. These generally took the form of an assignment, like LET, but replacing the LET with . For instance, would produce a matrix A whose elements were the sums of the corresponding elements in matrix B and C. Other matrix commands include ert, for the identity matrix and for the zero matrix, and various utilities like , , and .
BASIC-2.
The introduction of the 2200VP's completely new instruction set required an entirely new BASIC to be written from scratch. While backward compatibility was the primary goal, the new BASIC-2 also added a number of missing features. The most notable change was that BASIC was no longer stored in read-only memory (ROM) and was instead loaded from disk at boot time, which allowed it to be easily patched in the field to fix bugs. It was also much faster, about eight times, due to a focus on performance rather than size, and the better performance of the VP platform.
IF statements were limited in the original version, and were significantly improved in BASIC-2. Boolean conjunctions were added, allowing more complex tests like The statement following the THEN no longer had to be an implied GOTO, allowing common statements like . An clause was added and had to follow a colon; . ELSE could also be used with ON statements; would branch to lines 10, 20 or 30 if the value in X was 1, 2 or 3, while any other value would branch to 100.
New functions include , which always rounded toward zero instead of INT which always rounded down; returns -4, whereas returns -5. is similar to FIX but rounds to the decimal place provided in the second parameter. performs integer division and returns the remainder. and returned the value among the list of inputs with the highest or lowest value. returns the base-10 log of the value. checks if the string in the first parameter matches the format in the second, the format was the same as PRINTUSING.
PRINTUSING could now output to a string; would format the square root of three to two decimals and put the result in A$. Several new pseudo-functions were added to PRINT; the function was similar in concept to TAB, but moved the cursor to the X,Y location, drew a box of the given width and heigh with the upper left corner at the current cursor position, and returned the hex value.
Default string size did not change, the but maximum size was increased from 64 to 124 characters. Maximum array dimensions increased from 255 to 65535 elements.
BASIC-3.
In March 1977, Wang announced an expanded version of the VP system that included more memory, up to 256 KB, and a terminal server system to allow a single machine support up to twelve terminals. Known as the 2200MVP, the first units shipped in January 1978. The four-user LVP and single-user SVP models of the same machine shipped in 1980.
On 2 April 1981, at the Hannover Fair, Wang announced a major update of the MVP series microcode. The $2,000 "C" option added a COBOL compiler as well as a further updated version of BASIC, BASIC-3. At the time, they expected to release it in beta form in August, and for all customers in November. The system was sent to a small number of sites for beta testing, but never released.