 | This articlerelies excessively onreferences toprimary sources. Please improve this article by addingsecondary or tertiary sources. Find sources: "Wang BASIC" – news ·newspapers ·books ·scholar ·JSTOR(December 2020) (Learn how and when to remove this message) |
| Developer | Wang Laboratories |
|---|---|
| First appeared | 1973; 52 years ago (1973) |
| Influenced by | |
| Dartmouth BASIC | |
Wang BASIC is a series ofBASIC programming languages for computers fromWang Laboratories. The term can be used to refer to the BASIC on any Wang machine, but is mostly associated with the versions on theWang 2200minicomputer 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 ofmicrocode stored inread-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 ofinput/output and file management commands.
Wang BASIC closely followed the originalDartmouth BASIC in syntax, but was aninterpreter as opposed to acompile-and-go system. A notable feature was that all math used double-precisionbinary-coded decimal (BCD) format, which was unusual for BASICs of the era.[a] It lacked many features common to later dialects likeMicrosoft BASIC, but many of these features were added in BASIC-2.
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.
The original Wang BASIC for the 2200 is a relatively standard version of theDartmouth BASIC concept, and will be familiar to users of any common BASIC interpreters likeMicrosoft BASIC. Like most BASIC interpreters, Wang BASIC operated inimmediate mode or program mode, switching to the later when a line number is seen at the start of the line when theEXEC (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 aRENUMBER command.[3]
LIST was used to display the program source code, whileLIST 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 tocassette andLOAD "filename" read it back in.SKIP 2F would read over the next two files found on the cassette tape, and then stop, allowing a subsequentLOAD orSAVE 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, usingLOAD 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 inRUN 100. TheSTOP 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 customHALT (break) andSTEP keys on the keyboard to move line-by-line through a program.[8]SELECT P was used to set a delay betweenTRACE lines in1⁄6 second units;SELECT P0 set the delay to zero,SELECT P3 would cause it to pause1⁄2 second after each line.[9]
There was noNEW command to clear memory of an existing program,[10] instead one usedCLEAR 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 theDELETE command seen in some dialects.CLEAR V clears out variable values,[13] normally accomplished byCLR in most dialects.[14]CLEAR N was similar to CLEAR V, but did not clear the value of shared variables (see below).[12]
Branching was supported throughIF...THEN,GOTO andGOSUB. 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 likeAND orOR, 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 theDEF FN statement followed by a single quote and then a number from 0 to 255, for instance,DEFFN' 1. This could then be called usingGOSUB '1. To further confuse matters, the DEFFN line was a true function definition and could use parameters, likeDEFFN'5(A$, N), which could be called withGOSUB'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 theTAB() function, but notSPC(). In common with other "high end" BASICs of the era, Wang BASIC offered formatted output withPRINTUSING 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 with190 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 like180 % 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]
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, theLET was always optional.[22] Variables could be made into lists (one-dimensional arrays) usingDIM, as inDIM A(5) which made a list of 5 numeric values.[23] or two-dimensional arrays usingDIM B(5,5).[24]
Relational operators included the standard set of=,<,>,<>,<= and>=.[25] Trigonometric functions includedSIN,COS,TAN,ARCSIN,ARCCOS,ARCTAN,LOG,EXP andSQR.[26]ATN was an alias for ARCTAN.[27] Trigonometric functions normally operated inradians, but could be set to usedegrees usingSELECT D orgradians usingSELECT G, returning to radians withSELECT R. Other functions includedINT,ABS,SGN,[28]RND and the#PI pseudo-variable.[29]
Unlike most BASICs, theRND 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 theRANDOMIZE 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.[b]
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.[c] 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 theDIM statement, which in this case used the slightly odd syntax of putting the length immediately after the variable name, likeDIM 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 instanceDIM A$(5) made a list of 5 strings of the default 16 character length, whileDIM 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-purposearray slicing command that replaces the DEC/Microsoft-styleMID/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, soLEN("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 namedSTR$, for instance, indicating the return value is a string, not a numeric value.[38]
In keeping with the Dartmouth model, Wang BASIC includedDATA statements for storing constants within the program code, and these were read using theREAD 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]
TheSELECT 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, whileSELECT 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, likeSELECT 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]
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 theCOM andLOAD statements.[41]
COM declared one or more variables to be "common",[d] orglobal in modern terminology. A program using chaining would typically declare a number of variables to be common near the top of the code, perhapsCOM 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 usingCLEAR V, whileCLEAR N clears non-common variables and leaves common variables alone. Variables could also be declared non-common usingCOM CLEAR, which reset all common variables to normal, orCOM 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 usedCOM S,B,A orCOM 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]
The original Wang BASIC came in several versions differing in the amount of ROM-based microcode, and thus the number of keywords supported.
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 ofON...GOTO[46] andON...GOSUB.[47]KEYIN read a character from the keyboard without pausing, similar toINKEY$ in MS BASIC.VAL searched a string and returned a numeric value within it. TheNUM 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 theCONVERT 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, whileCONVERT 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 toC'ssprintf.[49]
ThePOS function returns the index of a given character in a string;POS("HELLO WORLD", "L") would return 3. In contrast to MS'sINSTR, 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, whileINIT (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 thanA=B+C+D. Similar commands wereOR,AND andXOR.
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, includingCOPY to duplicate a file,MOVE within a file,VERIFY files, andSCRATCH to erase a file orSCRATCH DISK to erase everything.
In contrast to the 2200B version, which was a major expansion on the 2200A, 2200C was much more limited in scope. It added theCOM CLEAR command for clearing shared variables, a version ofDEFFN' that returned hex,RETURN CLEAR was used to "pop" a GOSUB off the stack,[47] andON ERROR for trapping errors within the program.
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 withMAT. 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 includeINVert,IDN for the identity matrix andZER for the zero matrix, and various utilities likeCOPY,MERGE,MOVE andSORT.[45]
The introduction of the 2200VP's completely newinstruction set required an entirely new BASIC to be written from scratch. Whilebackward 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 inread-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 likeIFX=5ANDY=10THEN... The statement following the THEN no longer had to be an implied GOTO, allowing common statements likeIFX=10THENPRINT"IT IS TEN". AnELSE 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 includeFIX, which always rounded toward zero instead of INT which always rounded down;FIX(-4.5) returns -4, whereasINT(-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...) andMIN(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; theAT(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, andHEXOF(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]
In March 1977, Wang announced an expanded version of the VP system that included more memory, up to 256 KB, and aterminal 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 theHannover Fair, Wang announced a major update of the MVP series microcode. The $2,000 "C" option added aCOBOL 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]
RND(0) widely.COMMON.