|
|
|
|
Commodore BASIC
|
| |
|
| |
Commodore BASIC, also known as PET BASIC, is the dialect of the BASIC programming language used in Commodore International's 8-bit home computer line, stretching from the PET of 1977 to the C128 of 1985. The core was based on 6502 Microsoft BASIC, and as such it shares most of the core code with other 6502 BASICs of the time, such as Applesoft BASIC.
odore licensed BASIC from Microsoft on a "pay once, no royalties" basis.
Discussion
Ask a question about 'Commodore BASIC' Start a new discussion about 'Commodore BASIC' Answer questions from other users |
Encyclopedia
Commodore BASIC, also known as PET BASIC, is the dialect of the BASIC programming language used in Commodore International's 8-bit home computer line, stretching from the PET of 1977 to the C128 of 1985. The core was based on 6502 Microsoft BASIC, and as such it shares most of the core code with other 6502 BASICs of the time, such as Applesoft BASIC.
History
Commodore licensed BASIC from Microsoft on a "pay once, no royalties" basis. Commodore took the source code of the flat-fee BASIC and further developed it internally for all their other 8-bit home computers. It wasn't until the Commodore 128 (with V7.0) that a Microsoft copyright notice was displayed. However, Microsoft had built an easter egg into the original Commodore Basic that proved its provenance: typing the (obscure) command WAIT 6502, 1 would result in Microsoft! appearing on the screen. (The easter egg was well concealed - the message did not show up in any disassembly of the interpreter.)
Technical details
A convenient feature of Commodore's ROM-resident BASIC interpreter and KERNAL was the full-screen editor, which allowed users to enter direct commands or to input and edit program lines from anywhere on the screen—simply by pressing the RETURN key whenever the cursor happened to be on a line containing a valid BASIC statement. This marked a significant change in program entry interfaces compared to other common home computer BASICs at the time, which typically used line editors, invoked by a separate EDIT command, a "copy cursor," Escape sequences, or the like.
It also had the capability of saving named files to any device, including the cassette – initially a popular storage device in the days of the PET. Most systems of the era only supported filenames on diskette, which made saving multiple files on other devices more difficult, requiring the operator to note the recorder's counter display at the location of the file, which was inaccurate and prone to error. Most non-Commodore users worked around the problem by only recording one file per tape. With the PET, when the user requested to load a file by name from the cassette, the device would read data sequentially, ignoring any unmatching filenames until the named file was located and read into memory. The file system was also supported by a powerful record structure that could be loaded or saved to files. Another difference between the cassette transfer implementations of the Commodore and other systems was that Commodore tapes were encoded digitally, where other manufacturers usually used a less expensive analog interface which enabled the use of a standard tape recorder, but was much less reliable.
Like the original Microsoft BASIC interpreter, on which it is based, Commodore BASIC is known to be woefully slow compared to machine code. Test results have shown that copying 16 kilobytes from ROM to RAM takes less than a second in machine code, but over a minute in BASIC. To alleviate the slowness of the interpreter, programmers started using various techniques to speed up execution. One was to store often-used integer values in variables rather than using literal values, as interpreting a variable name was faster than interpreting a literal number. Programmers also often wrote speed-critical sections of a program in 6502 assembly language and executed them from BASIC using the SYS command.
Commodore BASIC keywords could be abbreviated (tokenized) by entering at least one letter, and then a shifted version of the following letter. In the default text mode, shifted characters appear as a graphics symbol; e.g. the commmand, GOTO, could be abbreviated G (which resembled GΓ onscreen). In cases of ambiguity, more unshifted letters of the command were needed, such as GO (GO♥) being required for GOSUB. Some commands had no abbreviated form, either due to brevity or ambiguity with other commands. For example, the command, INPUT had no abbreviation because its spelling collided with the separate INPUT# keyword, which was located nearer to the beginning of the keyword lookup table.
By abbreviating keywords, it was possible to use less memory to store more code in a program line (line lengths were usually limited to 2 or 4 screen lines, depending on the specific machine). This allowed for a slight saving on the overhead to store otherwise necessary extra program lines, but nothing more.
In the rare situation when commercial BASIC software was meant to be LIST-ed, each token's keyword was spelled out in full, leading to a line that extended over more screen lines than could be handled by the Logical Line Link Table. If programmers intended editing of their software by users, the user might nevertheless have found it daunting to edit with the on-screen editing capabilities. LISTing these long lines on the Commodore 64 near the bottom of the screen could trigger a bug in the 40 column screen editor, causing the machine to crash or return an OUT OF MEMORY error.
Commodore BASIC lines did not need any spaces except where omitting one would be ambiguous, and many Commodore BASIC programs were written with no spaces, e.g., 100IFA=5THENPRINT"YES":GOTO160. Omitting spaces as such would lead to a more compact program, since the tokenizer never removes any space inserted between keywords: the presence of spaces results in extra 0x20 bytes in the tokenized program which are merely skipped during execution.
The order of execution of Commodore BASIC lines was not determined by line numbering; instead, it followed the order in which the lines were linked in memory: much like a modern singly linked list, each program line was stored in memory as a line number, a pointer, and then the tokenized code for the line. The pointer contained the address in memory of the next program line. While a program was being entered, BASIC would constantly reorder program lines in memory so that the line numbers and pointers were all in ascending order. However after a program was entered, manually altering the line numbers and pointers with the POKE commands could allow for out-of-order execution or even give each line the same line number.
Variable names were only significant to 2 characters; thus the variable names VARIABLE1, VARIABLE2 and VA all referred to the same variable.
The native number format of Commodore BASIC, like that of its parent MS BASIC, was floating point. Most of the contemporary BASIC implementations used one byte for the characteristic (exponent) and three bytes for the mantissa. This led to problems in business applications since the accuracy of a floating point number using a three-byte mantissa is only about 6.5 decimal digits, and round-off error is common. Commodore, however, used MS BASIC's four-byte mantissa, which made their BASIC much more adapted for business than most other BASICs of the era.
Also akin to MS BASIC, 16-bit signed integers (i.e. in the range -32768 to 32767) were available by postfixing a variable name with a percent symbol, and string variables were represented by postfixing the variable name with a dollar sign. Despite the 2 character limit on variable names, the variables AA$, AA, and AA% would each be understood as distinct.
Many BASIC extensions were released for the Commodore 64, due to the relatively limited capabilities of its native BASIC 2.0. One of the most popular extensions was the DOS Wedge, due to its inclusion on the Commodore 1541 Test/Demo Disk. This 1 KB extension to BASIC added a number of disk-related commands, including the ability to read a disk directory without destroying the program in memory. Its features were subsequently incorporated in various third-party extensions, such as the popular Epyx FastLoad cartridge. Other BASIC extensions added additional keywords to make it easier to code sprites, sound, and high-resolution graphics.
From a modern programming point of view, the earlier versions of Commodore BASIC presented a host of bad programming traps for the programmer. BASIC line-numbering meant that with bad planning, inserting lines in a program often meant restructuring the whole program (later BASIC versions included a DELETE and RENUMBER command). In addition, all variables are treated as global variables. Clearly defined loops are hard to create, often causing the programmer to rely on the GOTO command (this was later rectified in BASIC 3.5 with the addition of the DO, LOOP, WHILE, UNTIL, and EXIT commands). Flag variables often needed to be created to perform certain tasks. Furthermore, the 80 character line limit in earlier BASICs often meant splitting tasks up into multiple routines, often resulting in spaghetti code. Earlier BASICs also lack debugging commands, meaning that bugs and unused variables are hard to trap. Syntax error messages are often unspecific and unhelpful.
Versions and features
A list of CBM BASIC versions in chronological order, with successively added features:
Released versions
- V2.0 (first release): PET 2001 with full-travel keyboard & upgrade ROMs
- V2.0 (second release, after 4.0): VIC-20; C64
- V4+ : CBM-II series (aka B, P range)
- memory management:
BANK - more disk operations:
BLOAD,BSAVE,DCLEAR - formatted printing:
PRINT USING,PUDEF - error trapping:
DISPOSE - alternative branching:
ELSE - dynamic error handling:
TRAP,RESUME,ERR$ - flexible
DATA read: RESTORE [linenumber] - string search function:
INSTR
- V3.5: C16/116, Plus/4
- sound and graphics commands
- joystick input:
JOY - decimal ? ? hexadecimal conversion:
DEC,HEX$ - structured looping:
DO,LOOP,WHILE,UNTIL,EXIT - function key assignment:
KEY (also direct mode) - program entry/editing:
AUTO,DELETE,RENUMBER - debugging (tracing):
TRON,TROFF - MLM entry command:
MONITOR - C(1)16, Plus/4 Easter egg – enter
SYS 52650
- V7.0: C128
- more sound and graphics commands, including sprite handling
- built-in sprite editor:
SPRDEF - multi-statement blocks for
IF THEN ELSE structures: BEGIN,BEND - paddle, lightpen input:
POT,PEN - exclusive or function:
XOR - get variable address:
POINTER - text mode windowing:
WINDOW - controlled time delay:
SLEEP - memory management:
SWAP,FETCH,STASH - more disk operations:
BOOT,DVERIFY - CPU speed adjustment:
FAST,SLOW (2 vs 1 MHz) - enter C64 mode:
GO64 - undocumented, working:
RREG (read CPU registers after a SYS) - unimplemented commands:
OFF,QUIT - C128 Easter egg – enter
SYS 32800,123,45,6
Unreleased versions
- V10 : Commodore 65 (unreleased prototype)
- graphics/video commands:
PALETTE,GENLOCK - mouse input:
MOUSE,RMOUSE - text file (
SEQ) utility: TYPE - program editing:
FIND,CHANGE - memory management:
DMA, FRE(<0>|<1>|<2>) - unimplemented commands:
PAINT,LOCATE,SCALE,WIDTH,SET,VIEWPORT
PASTE,CUT
Notable extension packages
|
| |
|
|
