Wang BASIC

Wang BASIC

Developer	Wang Laboratories
First appeared	1973;51 years ago (1973)
Influenced by
Dartmouth 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. ^{[lower-alpha 1]} 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 EXEC (return) key is pressed. Line numbers ranged from 0 to 9999. Lines could be up to 192 characters, spanning several on-screen lines, ^[1] and lines could contain multiple statements separated by colons. ^[2] To aid organizing large programs, the language included a RENUMBER command. ^[3]

LIST was used to display the program source code, while LIST S displayed only the first 15 lines and then paused. When paused, pressing the EXEC key displayed the next 15 lines. ^[4] SAVE "filename" saved the current program to cassette and LOAD "filename" read it back in. SKIP 2F would read over the next two files found on the cassette tape, and then stop, allowing a subsequent LOAD or SAVE to work on the third file. ^[5] BACKSPACE was the opposite of SKIP, rewinding the file pointer. Working with disk storage was slightly more complex, using LOAD DC F "filename", where F referred to one of a number of pre-defined drives, in this case "F"ixed. ^[6]

RUN started execution, and could be directed to a particular line, as in RUN 100. The STOP command, typically used for debugging, allowed an optional following string that was printed out when that statement was performed. ^[7] TRACE could be used to print out lines as they were run, which was often used in conjunction with the custom HALT (break) and STEP keys on the keyboard to move line-by-line through a program. ^[8] SELECT P was used to set a delay between TRACE lines in 1⁄6 second units; SELECT P0 set the delay to zero, SELECT P3 would cause it to pause 1⁄2 second after each line. ^[9]

There was no NEW command to clear memory of an existing program, ^[10] instead one used CLEAR to reset memory. ^[11] CLEAR P (for "P"rogram) was the equivalent of NEW but added optional from and to line numbers, ^[12] deleting just that range of lines in a fashion similar to the DELETE command seen in some dialects. CLEAR V clears out variable values, ^[13] normally accomplished by CLR in most dialects. ^[14] CLEAR N was similar to CLEAR V, but did not clear the value of shared variables (see below). ^[12]

Syntax

Branching was supported through IF...THEN, GOTO and GOSUB. The alternate form, GO TO, was not supported. One limitation of Wang BASIC, as in the case of the original Dartmouth as well, is that the THEN clause of an IF statement could only be a line number, in contrast to more modern dialects that allow any statement after the THEN. It also lacked boolean conjunctions like AND or OR, so the test could have only a single comparison. ^[15]

One interesting addition to the language was the idea of named routines. The implementation was based on the DEF FN statement followed by a single quote and then a number from 0 to 255, for instance, DEFFN' 1. This could then be called using GOSUB '1. To further confuse matters, the DEFFN line was a true function definition and could use parameters, like DEFFN'5(A$, N), which could be called with GOSUB'5("hello", 4). In allows one to implement multi-line function definitions, which other dialects sometimes offered using the conventional function style rather than using GOSUB. ^[16] 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. ^[17]

PRINT 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 TAB() function, but not SPC(). In common with other "high end" BASICs of the era, Wang BASIC offered formatted output with PRINTUSING and a separate "image". The image was defined using a separate line starting with the percent sign, for instance, 180 % ##,###.## and then using that format with 190 PRINTUSING 180, N. ^[18] Any characters other than the formatting characters were echoed back during the print, so one could define a complete output with something like 180 % ANGLE= #.#### RADIANS. ^[19]

INPUT 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. ^[20]

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. ^[21] Multiple variables could be set to an initial value using a comma-separated list, for instance, LET A,B,C=1. As with most BASICs, the LET was always optional. ^[22] Variables could be made into lists (one-dimensional arrays) using DIM, as in DIM A(5) which made a list of 5 numeric values. ^[23] or two-dimensional arrays using DIM B(5,5). ^[24]

Relational operators included the standard set of =, <, >, <>, <= and >=. ^[25] Trigonometric functions included SIN, COS, TAN, ARCSIN, ARCCOS, ARCTAN, LOG, EXP and SQR. ^[26] ATN was an alias for ARCTAN. ^[27] Trigonometric functions normally operated in radians, but could be set to use degrees using SELECT D or gradians using SELECT G, returning to radians with SELECT R. Other functions included INT, ABS, SGN, ^[28] RND and the #PI pseudo-variable. ^[29]

Unlike most BASICs, the RND 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 RANDOMIZE statement seen in other BASICs. ^[29] 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. ^{[lower-alpha 2]}

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. ^{[lower-alpha 3]} Unused characters at the end of a string were filled with space characters, and any trailing spaces were ignored in PRINT statements, ^[30] 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 DIM statement, which in this case used the slightly odd syntax of putting the length immediately after the variable name, like DIM A$40, ^[31] instead of using parens as in a typical DIM statement. ^[32] Strings had a maximum length of 64 characters. ^[33] The syntax allowed lists of strings, for instance DIM A$(5) made a list of 5 strings of the default 16 character length, while DIM B$(10)20 made a list of 10 strings of 20 characters. ^[34]

There were a small set of string functions. STR is a general-purpose array slicing command that replaces the DEC/Microsoft-style MID/LEFT/RIGHT. For instance, STR(B$,10,5) returns the five characters of A$ starting at character 10. ^[35] The second parameter was optional, STR(C$,5) returned everything from the 5th character on. LEN returned the length of the string, ignoring trailing spaces, so LEN("ABC ") would return 3. ^[36] To further confuse matters, empty string variables always returned a length of 1. ^[37] Note that the string functions do not include the $, in contrast to most BASICs where these functions would be named STR$, for instance, indicating the return value is a string, not a numeric value. ^[38]

Data and I/O

In keeping with the Dartmouth model, Wang BASIC included DATA statements for storing constants within the program code, and these were read using the READ statement, which started at the first data element and then moved a pointer forward to the next element with every READ. RESTORE 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, RESTORE 10, which set it to the 10th element. Only 256 values could be entered in DATA statements in total in one program. ^[39]

The SELECT statement could be used to redirect output from other BASIC commands to other devices, based on the "address" of the device. For instance, SELECT PRINT 215 would send the output of subsequent PRINT statements to the printer at address 215, while SELECT PRINT 005 returned output to the built-in CRT. SELECT LIST 215 would do the same for any following LIST statements. ^[40] SELECT also had an optional following parameter to set the maximum line length, like SELECT PRINT 215 (132). 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. ^[40]

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 COM and LOAD statements. ^[41]

COM declared one or more variables to be "common", ^{[lower-alpha 4]} 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 COM A,B,I,A$20. ^[42] 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 CLEAR V, while CLEAR N clears non-common variables and leaves common variables alone. Variables could also be declared non-common using COM CLEAR, which reset all common variables to normal, or COM CLEAR A 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 COM S,B,A or COM A,B,S, in the first example all three would be reset while in the second only A would be reset. ^[43]

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. ^[44]

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, additional string commands, vector-like commands, and input/output. The differences between the version can be found in table form in the 2200 overview document. ^[45]

Missing features that were addressed in 2200B included the addition of ON...GOTO ^[46] and ON...GOSUB. ^[47] KEYIN read a character from the keyboard without pausing, similar to INKEY$ in MS BASIC. VAL searched a string and returned a numeric value within it. The NUM function was similar to LEN, but returned the length of the substring up to the first non-numeric character. For instance, if A$ is "1234.5", NUM(A$) would return 6, whereas if A$ was "1234.5    ", NUM would return 10, because spaces are valid in numbers. ^[48]

2200B did not add a STR$ function, which converts a numeric value to a string. Instead, they added the CONVERT command to read strings into numbers and vice versa. For instance, using the A$ above, CONVERT A$ TO B would result in B containing the value 1234.5, while CONVERT 123 TO B$ would leave B$ with something like "123 ". ^[49] Dartmouth BASIC included a CHANGE command but it was very different in purpose, in Dartmouth, CHANGE A$ TO B 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. ^[49]

The POS function returns the index of a given character in a string; POS("HELLO WORLD", "L") would return 3. In contrast to MS's INSTR, POS could search for only a single character, not a multi-character string.

HEX converted a hexadecimal value into the corresponding character. For instance, A$=HEX(20) would put a space character (hex 20) into the first character of A$. ^[50] Multiple codes could be inserted at once; PRINT HEX(080809) produces three characters, two backspaces and a cursor-right. ^[51] HEX is the counterpart to the ASC function found in most BASICs, ^[52] but uses a hex input instead of a decimal number. BIN did the same for binary numbers. ^[37]

A special purpose command was added to fill out a string with an initial value that's not a space. INIT ("X") A$ would fill A$ with X characters, while INIT (41) B$ would put the hex value 41, the character A, into B$. ^[53]

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, ADD 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; A=ADD(B,C,D) would be completed quicker than A=B+C+D. Similar commands were OR, AND and XOR.

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 COPY to duplicate a file, MOVE within a file, VERIFY files, and SCRATCH to erase a file or SCRATCH DISK 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 COM CLEAR command for clearing shared variables, a version of DEFFN' that returned hex, RETURN CLEAR was used to "pop" a GOSUB off the stack, ^[47] and ON ERROR 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 MAT. For instance, MAT A=B+C would produce a matrix A whose elements were the sums of the corresponding elements in matrix B and C. ^[54] Other matrix commands include INVert, IDN for the identity matrix and ZER for the zero matrix, and various utilities like COPY, MERGE, MOVE and SORT. ^[45]

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. ^[55]

IF statements were limited in the original version, and were significantly improved in BASIC-2. Boolean conjunctions were added, allowing more complex tests like IFX=5ANDY=10THEN... The statement following the THEN no longer had to be an implied GOTO, allowing common statements like IFX=10THENPRINT"IT IS TEN". An ELSE clause was added and had to follow a colon; IFX=10THENPRINT"IT IS TEN":ELSEPRINT"IT IS NOT TEN". ELSE could also be used with ON statements; ONXGOTO10,20,30:ELSE100 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. ^[55]

New functions include FIX, which always rounded toward zero instead of INT which always rounded down; FIX(-4.5) returns -4, whereas INT(-4.5) returns -5. ROUND(value,num) is similar to FIX but rounds to the decimal place provided in the second parameter. MOD performs integer division and returns the remainder. MAX(a,b,c...) and MIN(d,e,f...) returned the value among the list of inputs with the highest or lowest value. LGT returns the base-10 log of the value. VER checks if the string in the first parameter matches the format in the second, the format was the same as PRINTUSING. ^[55]

PRINTUSING could now output to a string; PRINTUSING TO A$, "#.##", SQR(3) 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 AT(X,Y) function was similar in concept to TAB, but moved the cursor to the X,Y location, BOX(W,H) drew a box of the given width and height with the upper left corner at the current cursor position, and HEXOF(v) returned the hex value. ^[55]

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. ^[55]

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. ^[56]

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. ^[57] The system was sent to a small number of sites for beta testing, but never released. ^[58]

Notes

1. Wang had long produced business calculators using BCD, so this was not unusual for the company.
2. See, for instance, Super Star Trek , which uses RND(0) widely.
3. This appears to have been taken from HP Time-Shared BASIC, which was identical. Several BASICs of the home computer era also used a variation of this model, notably Integer BASIC and Atari BASIC.
4. Other BASICs that had this feature generally used the full term COMMON.

References

Citations

1. WangBASIC 1976, p. 46.
2. WangBASIC 1976, p. 125.
3. WangBASIC 1976, p. 123.
4. WangBASIC 1976, p. 14.
5. WangBASIC 1976, p. 60.
6. WangBASIC 1976, p. 65.
7. WangBASIC 1976, p. 116.
8. WangBASIC 1976, p. 121.
9. WangBASIC 1976, p. 118.
10. Commodore 1982, p. 62.
11. WangBASIC 1976, p. 8.
12. WangBASIC 1976, p. 274.
13. WangBASIC 1976, p. 124.
14. Commodore 1982, p. 39.
15. "BASIC comparison".
16. WangBASIC 1976, pp. 158–159.
17. WangBASIC 1976, p. 162.
18. WangBASIC 1976, p. 169.
19. WangBASIC 1976, p. 172.
20. WangBASIC 1976, p. 56.
21. WangBASIC 1976, p. 102.
22. WangBASIC 1976, p. 20.
23. WangBASIC 1976, p. 135.
24. WangBASIC 1976, p. 210.
25. WangBASIC 1976, p. 49.
26. WangBASIC 1976, p. 82.
27. WangBASIC 1976, p. 83.
28. WangBASIC 1976, p. 78.
29. WangBASIC 1976, p. 81.
30. WangBASIC 1976, p. 106.
31. WangBASIC 1976, p. 107.
32. WangBASIC 1976, p. 137.
33. WangBASIC 1976, p. 128.
34. WangBASIC 1976, p. 139.
35. WangBASIC 1976, p. 185.
36. WangBASIC 1976, p. 189.
37. WangBASIC 1976, p. 190.
38. Commodore 1982, p. 34.
39. WangBASIC 1976, pp. 145–150.
40. WangBASIC 1976, pp. 20–21.
41. WangBASIC 1976, p. 272.
42. WangBASIC 1976, p. 275.
43. WangBASIC 1976, p. 277.
44. WangBASIC 1976, p. 273.
45. Intro 1976, p. 2.
46. WangBASIC 1976, p. 130.
47. WangBASIC 1976, p. 156.
48. WangBASIC 1976, p. 192.
49. WangBASIC 1976, p. 193.
50. WangBASIC 1976, p. 183.
51. WangBASIC 1976, p. 196.
52. Commodore 1982, p. 37.
53. WangBASIC 1976, p. 188.
54. WangBASIC 1976, p. 215.
55. BASIC2 1979.
56. Programmable Terminals (PDF). Datapro Research. February 1981.
57. "2200 Series Enhancements" (PDF). 2 April 1981.
58. "2200 BASIC-3" (PDF). Wang Laboratories.

Bibliography

• Wang BASIC Language Programming Manual (PDF). Wang Laboratories. 1976.
• Wang BASIC-2 Language Reference Manual (PDF). Wang Laboratories. 1979.
• 2200 Systems Option "C" (PDF). Wang Laboratories. February 1982.
• 2200 Introductory Manual (PDF). Wang Laboratories. 1976.
• Commodore 64 Programmer's Reference Guide (PDF). Commodore Business Machines. 1982.