View source for Commodore BASIC

{{Short description|BASIC programming language dialect}}
{{Infobox programming language
| name = Commodore BASIC
| title = 
| released = {{Start date and age|1977}}
| designer = [[Microsoft]]
| developer = [[Microsoft]]
| latest release version = V7.0
| latest release date = {{Start date and age|1985}}
| latest preview version = V10.0
| latest preview date = {{Start date and age|1991}}
| programming language = [[Assembly language|Assembly]] ([[MOS 6502|6502]])
| platform = [[Commodore PET|PET]] to the [[Commodore 128]]
| operating system = 
}}
'''Commodore BASIC''', also known as '''PET BASIC''' or '''CBM-BASIC''', is the [[Dialect (computing)|dialect]] of the [[BASIC]] [[programming language]] used in [[Commodore International]]'s [[8-bit]] [[home computer]] line, stretching from the [[Commodore PET|PET]] (1977) to the [[Commodore 128]] (1985).

The core is based on [[MOS Technology 6502|6502]] [[Microsoft BASIC]], and as such it shares many characteristics with other 6502 BASICs of the time, such as [[Applesoft BASIC]]. Commodore licensed BASIC from [[Microsoft]] in 1977 on a "pay once, no [[royalties]]" basis after [[Jack Tramiel]] turned down [[Bill Gates]]' offer of a {{US$|long=no|3}} per unit fee, stating, "I'm already married," and would pay no more than {{US$|long=no|25000}} for a perpetual license.<ref>Stated by [[Jack Tramiel]] at the Commodore 64 25th Anniversary Celebration at the [[Computer History Museum]] December 10, 2007 [http://www.computerhistory.org/events/index.php?id=1193702785] {{Webarchive|url=https://web.archive.org/web/20081211123347/http://www.computerhistory.org/events/index.php?id=1193702785|date=2008-12-11}}[http://www.computerhistory.org/events/video/75/] {{Webarchive|url=https://web.archive.org/web/20171003111509/http://www.computerhistory.org/events/video/75/|date=2017-10-03}}[https://www.youtube.com/watch?v=NBvbsPNBIyk].</ref>

The original [[Commodore PET|PET]] version was very similar to the original Microsoft implementation with few modifications. BASIC 2.0 on the [[Commodore 64|C64]] was also similar, and was also seen on [[Commodore 128|C128s]] (in C64 mode) and other models. Later PETs featured BASIC 4.0, similar to the original but adding a number of commands for working with [[floppy disk]]s.

BASIC 3.5 was the first to really deviate, adding a number of commands for graphics and sound support on the [[Commodore 16|C16]] and [[Plus/4]]. BASIC 7.0 was included with the [[Commodore 128]], and included [[structured programming]] commands from the Plus/4's BASIC 3.5, as well as keywords designed specifically to take advantage of the machine's new capabilities. A [[sprite (computer graphics)|sprite]] editor and [[machine language monitor]] were added. The last, BASIC 10.0, was part of the unreleased [[Commodore 65]].

==History==
Commodore took the source code of the flat-fee BASIC and further developed it internally for all their other 8-bit home computers. It was not until the [[Commodore 128]] (with V7.0) that a Microsoft copyright notice was displayed. However, Microsoft had built an [[easter egg (media)|easter egg]] into the version 2 or "upgrade" Commodore Basic that proved its provenance: typing the command <code>WAIT 6502, 1</code> would result in <code>Microsoft!</code> appearing on the screen. (The easter egg was well-obfuscated—the message did not show up in any [[disassembler|disassembly]] of the interpreter.)<ref>{{cite web|url=http://www.pagetable.com/?p=43|title=Bill Gates' Personal Easter Eggs in 8 Bit BASIC - pagetable.com|website=www.pagetable.com|access-date=8 August 2018}}</ref>

The popular [[Commodore 64]] came with BASIC v2.0 in ROM even though the computer was released after the PET/CBM series that had version 4.0 because the 64 was intended as a home computer, while the PET/CBM series were targeted at business and educational use where their built-in programming language was presumed to be more heavily used. This saved manufacturing costs, as the V2 fit into smaller ROMs.

==Technical details==
{{multiple issues|section=y|{{More citations needed section|date=August 2011}}
{{Original research section|date=July 2013}}}}

===Program editing===
A convenient feature of Commodore's [[read-only memory|ROM]]-resident [[BASIC interpreter]] and [[KERNAL]] was the [[visual editor|full-screen editor]].<ref>{{cite web|url=https://archive.org/stream/Commodore_Microcomputers_Volume_6_Number_4_Issue_36_1985-07_Commodore_US#page/n41/mode/2up|title=Keyboarding and the Screen Editor|date=July 1985}}</ref><ref>{{cite web|url=http://www.classiccmp.org/dunfield/c64/bytejl83.pdf|title=Byte July 1983|access-date=2015-05-01|archive-date=2017-08-24|archive-url=https://web.archive.org/web/20170824214757/http://www.classiccmp.org/dunfield/c64/bytejl83.pdf|url-status=dead}}</ref> Although Commodore keyboards only have two [[cursor keys]] which reversed direction when the shift key was held, the screen editor allowed users to enter [[Direct mode|direct commands]] or to input and edit program lines from anywhere on the screen. If a line was prefixed with a line number, it was [[tokenized]] and stored in program memory. Lines not beginning with a number were executed by pressing the {{keypress|RETURN}} key whenever the [[cursor (computers)|cursor]] happened to be on the line. This marked a significant upgrade in program entry interfaces compared to other common home computer BASICs at the time, which typically used [[line editor]]s, invoked by a separate <code>EDIT</code> command, or a "copy cursor" that truncated the line at the cursor's position.

It also had the capability of saving named files to any device, including the [[Compact Cassette|cassette]] – a popular storage device in the days of the PET, and one that remained in use throughout the lifespan of the 8-bit Commodores as an inexpensive form of mass storage. Most systems only supported filenames on [[diskette]], which made saving multiple files on other devices more difficult. The user of one of these other systems had to note the recorder's counter display at the location of the file, but this was inaccurate and prone to error. With the PET (and BASIC 2.0), files from cassettes could be requested by name. The device would search for the filename by reading data sequentially, ignoring any non-matching filenames. The file system was also supported by a powerful [[storage record|record structure]] that could be loaded or saved to files. Commodore cassette data was recorded digitally, rather than less expensive (and less reliable) analog methods used by other manufacturers. Therefore, the specialized [[Datasette]] was required rather than a standard tape recorder. Adapters were available that used an [[analog-to-digital converter]] to allow use of a standard recorder, but these cost only a little less than the Datasette.

The {{mono|LOAD}} command may be used with the optional parameter {{mono|,1}} which will load a program into the memory address contained in the first two bytes of the file (these bytes are discarded and not retained in memory). If the {{mono|,1}} parameter is not used, the program will load into the start of the BASIC program area, which widely differs between machines. Some Commodore BASIC variants supplied <code>BLOAD</code> and <code>[[BSAVE]]</code> commands that worked like their counterparts in [[Applesoft BASIC]], loading or saving [[bitmap]]s from specified memory locations.

The PET does not support relocatable programs and the {{mono|LOAD}} command will always load at the first two bytes contained in the program file. This created a problem when trying to load BASIC programs saved on other Commodore machines as they would load at a higher address than where the PET's BASIC expected the program to be, there were workarounds to "move" programs to the proper location. If a program was saved on a [[CBM-II]] machine, the only way to load it on a PET was by modifying the first two bytes with a disk sector editor as the CBM-II series had their BASIC program area at $0, which would result in a PET attempting to load into the zero page and locking up.

Commodore BASIC [[keyword (computer programming)|keyword]]s could be abbreviated by entering first an unshifted keypress, and then a shifted keypress of the next letter.  This set the [[most significant bit|high bit]], causing the interpreter to stop reading and parse the statement according to a lookup table.  This meant that the statement up to where the high bit was set was accepted as a substitute for typing the entire command out.  However, since all BASIC keywords were stored in memory as single byte tokens, this was a convenience for statement entry rather than an optimization.

In the default uppercase-only character set, shifted characters appear as a graphics symbol; e.g. the command, <code>GOTO</code>, could be abbreviated <code>G{Shift-O}</code> (which resembled <code>G'''Γ'''</code> onscreen). Most such commands were two letters long, but in some cases they were longer. In cases like this, there was an ambiguity, so more unshifted letters of the command were needed, such as <code>GO{Shift-S}</code> (<code>GO♥</code>) being required for <code>[[GOSUB]]</code>. Some commands had no abbreviated form, either due to brevity or ambiguity with other commands. For example, the command, <code>INPUT</code> had no abbreviation because its spelling collided with the separate <code>INPUT#</code> keyword, which was located nearer to the beginning of the keyword [[lookup table]]. The heavily used <code>PRINT</code> command had a single <code>?</code> shortcut, as was common in most Microsoft BASIC dialects. Abbreviating commands with shifted letters is unique to Commodore BASIC.

This tokenizing method had a glitch such that if one included a <code>REM</code> (BASIC statement to add a comment to the code) followed by a <code>{Shift-L}</code>, when trying to view the program listing, the BASIC interpreter would immediately abort the listing, display a <code>?SYNTAX  ERROR</code> and return to the <code>READY.</code> prompt. This glitch was used to some effect by programmers who wanted to try and protect their work, although it was fairly easy to circumvent.

By abbreviating keywords, it was possible to fit more code on a single program line (which could take up two screen lines on 40-column displays - i.e., C64 or PET, or four lines on the VIC-20's 22-column display). This allowed for a slight saving on the overhead to store otherwise necessary extra program lines, but nothing more. All BASIC commands were tokenized and took up 1 byte (or two, in the case of several commands of BASIC 7 or BASIC 10) in memory no matter which way they were entered. Such long lines were a nuisance to edit. The <code>LIST</code> command displayed the entire command keyword - extending the program line beyond the 2 or 4 screen lines which could be entered into program memory.

===Performance===
Like the original [[Microsoft BASIC]] [[interpreter (programming)|interpreter]], Commodore BASIC is slower than native [[machine code]].  Test results have shown that copying 16 [[kilobytes]] from [[read-only memory|ROM]] to [[random-access memory|RAM]] takes less than a second in machine code, compared to over a minute in BASIC.{{citation needed|date=March 2018}}  To execute faster than the interpreter, programmers started using various techniques to speed up execution.  One was to store often-used floating point values in variables rather than using literal values, as interpreting a variable name was faster than interpreting a literal number.  Since floating point is default type for all commands, it's faster to use floating point numbers as arguments, rather than integers.  When speed was important, some programmers converted sections of BASIC programs to [[MOS Technology 6502|6502]] or [[MOS Technology 6510|6510]] assembly language that was loaded separately from a file or POKEd into memory from DATA statements at the end of the BASIC program, and executed from BASIC using the {{mono|SYS}} command, either from [[direct mode]] or [[BASIC loader|from the program itself]].  When the execution speed of machine language was too great, such as for a game or when waiting for user input, programmers could [[polling (computer science)|poll]] by reading selected memory locations (such as {{mono|$C6}}<ref name="map64">{{cite book|title=Mapping the Commodore 64 & 64C|last=Leemon|first=Sheldon|publisher=COMPUTE! Publications|page=37|year=1987|isbn=9780874550825|url=https://archive.org/stream/Compute_s_Mapping_the_64_and_64C#page/n49/mode/2up|access-date=2018-03-25}}</ref> for the 64, or {{mono|$D0}}<ref name="map128">{{cite book|title=Mapping the Commodore 128|url=https://archive.org/details/Compute_s_Mapping_the_Commodore_128|last=Cowper|first=Ottis R.|publisher=COMPUTE! Publications|page=[https://archive.org/details/Compute_s_Mapping_the_Commodore_128/page/n70 66]|year=1986|isbn=9780874550603}}</ref> for the 128, denoting size of the keyboard queue) to delay or halt execution.

A unique feature of Commodore BASIC is the use of control codes to perform tasks such as clearing the screen or positioning the cursor within a program; these can be invoked either by issuing a {{code|2=cbmbas|1=PRINT CHR$(X)}} command where X corresponds to the control code to be issued (for example, {{code|2=cbmbas|1=PRINT CHR$(147)}} is the control code to clear the screen) or by pressing the key in question between quote marks, thus pressing {{keypress|SHIFT|CLR HOME}} following a quote mark will cause BASIC to display the visual representation of the control code (in this case, a reversed heart) which is then acted upon at program execution (directly printing out the control codes uses less memory and executes faster than invoking a {{mono|CHR$}} function). This is in comparison to other implementations of BASIC which typically have dedicated commands to clear the screen or move the cursor.

BASIC 3.5 and up have proper commands for clearing the screen and moving the cursor.

Program lines in Commodore BASIC do not require spaces anywhere (but the {{mono|LIST}} command will always display one between the line number and the statement), e.g., {{code|lang=cbmbas|1=100 IFA=5THENPRINT"YES":GOTO160}}, and it was common to write programs with no spacing. This feature was added to conserve memory since the tokenizer never removes any space inserted between keywords: the presence of spaces results in extra {{mono|0x20}} bytes in the tokenized program which are merely skipped during execution. Spaces between the line number and program statement are removed by the tokenizer.

Program lines can be 80 characters total on most machines, but machines with 40 column text would cause the line to wrap around to the next line on the screen, and on the VIC-20, which had a 22 column display, program lines could occupy as many as four.  BASIC 7.0 on the Commodore 128 increased the limit of a program line to 160 characters (four 40-column lines or two 80-column lines). By using abbreviations such as {{code|?}} instead of {{code|PRINT}}, it is possible to fit even more on a line. BASIC 7.0 displays a {{samp|?STRING TOO LONG}} error if the user enters a program line over 160 characters in length. Earlier versions do not produced an error and simply display the READY prompt two lines down if the line length is exceeded. The line number is counted in the number of characters in the program line, so a five digit line number will result in four fewer characters allowed than a one digit number.

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.<ref>{{Cite web|url=http://www.unusedino.de/ec64/technical/project64/mapping_c64.html|title=Mapping The C64|website=www.unusedino.de|accessdate=21 August 2023}}</ref>  Program lines were stored in memory as a [[singly linked list]] with a pointer (containing the address of the beginning of the next program line), a line number, and then the tokenized code for the 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 [[PEEK and POKE|POKE]] commands could allow for out-of-order execution or even give each line the same line number. In the early days, when BASIC was used commercially, this was a [[software protection]] technique to discourage casual modification of the program.

Line numbers can range from 0 to 65520 and take five bytes to store regardless of how many digits are in the line number, although execution is faster the fewer digits there are. Putting multiple statements on a line will use less memory and execute faster.

{{mono|GOTO}} and {{mono|GOSUB}} statements will search downward from the current line to find a line number if a forward jump is performed, in case of a backwards jump, they will return to the start of the program to begin searching. This will slow down larger programs, so it is preferable to put commonly used subroutines near the start of a program.

Variable names are only significant to 2 characters; thus the variable names {{mono|VARIABLE1}}, {{mono|VARIABLE2}}, and {{mono|VA}} all refer to the same variable.

Commodore BASIC also supports the (two-byte, signed, [[twos' complement]]) bitwise operators {{--}} {{mono|NOT}}, {{mono|AND}}, and {{mono|OR}}. Although this feature was part of the core Microsoft 6502 BASIC code, it was usually omitted in other implementations such as [[Applesoft BASIC]].

The native number format of Commodore BASIC, like that of its parent [[MS BASIC]], was [[floating point]]. Most contemporary BASIC implementations used one byte for the characteristic ([[exponent]]) and three bytes for the [[significand|mantissa]]. 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. 6502 implementations of Microsoft BASIC utilized 40-bit floating point arithmetic, meaning that variables took five bytes to store (four byte mantissa and one byte for the exponent) unlike the 32-bit floating point found in BASIC-80.

While 8080/Z80 implementations of [[Microsoft BASIC]] supported integer and double precision variables, 6502 implementations were floating point only.

Although Commodore BASIC supports [[Signed number representations|signed integer]] variables (denoted with a percent sign) in the range &minus;32768 to 32767, in practice they are only used for array variables and serve the function of conserving memory by limiting array elements to two bytes each (an array of 2000 elements will occupy 10,000 bytes if declared as a floating point array, but only 4000 if declared as an integer array). Denoting any variable as integer simply causes BASIC to convert it back to floating point, slowing down program execution and wasting memory as each percent sign takes one additional byte to store (since this also applies to integer arrays, the programmer should avoid using them unless very large arrays are used that would exceed available memory if stored as floating point). Also, it is not possible to {{mono|POKE}} or {{mono|PEEK}} memory locations above 32767 with address defined as a signed integer.

A period (.) can be used in place of the number 0 (thus {{code|2=cbmbas|1=10 A=.}} instead of {{code|2=cbmbas|1=10 A=0}} or {{code|2=cbmbas|1=10 FOR A=. TO 100}} instead of {{code|2=cbmbas|1=10 FOR A=0 to 100}}), this will execute slightly faster.

The {{mono|SYS}} statement, used to start machine language programs, was added by Commodore and was not in the original Microsoft BASIC code, which featured only the [[BASIC#USR|USR function]] for invoking machine language routines. It automatically loads the CPU's registers with the values in {{mono|$30C-$30F}} (C64, varies on other machines)--this can be used to pass data to machine language routines or as a means of calling kernal functions from BASIC (as an example, {{code|2=cbmbas|1=POKE 780,147:SYS 65490}} clears the screen).

Since Commodore 8-bit machines other than the C128 cannot automatically boot disk software, the usual technique is to include a BASIC stub like {{code|lang=cbmbas|1= 10 SYS 2048}} to begin program execution. It is possible to automatically start software after loading and not require the user to type a {{mono|RUN}} statement, this is done by having a piece of code that hooks the BASIC "ready" vector at {{code|$0302}}.

As with most other versions of [[Microsoft BASIC]], if an array is not declared with a {{mono|DIM}} statement, it is automatically set to ten elements (in practice 11 since array elements are counted from 0). Larger arrays must be declared or BASIC will display an error when the program is run and an array cannot be re-dimensioned in a program unless all variables are wiped via a CLR statement. Numeric arrays are automatically filled with zeros when they are created, there may be a momentary delay in program execution if a large array is dimensioned.

String variables are represented by tagging the variable name with a dollar sign. Thus, the variables {{mono|AA$}}, {{mono|AA}}, and {{mono|AA%}} would each be understood as distinct. Array variables are also considered distinct from simple variables, thus {{mono|A}} and {{mono|A(1)}} do not refer to the same variable. The size of a string array merely refers to how many strings are stored in the array, not the size of each element, which is allocated dynamically. Unlike some other implementations of Microsoft BASIC, Commodore BASIC does not require string space to be reserved at the start of a program.

Unlike other 8-bit machines such as the Apple II, Commodore's machines all have a built-in clock that is initialized to 0 at power on and updated with every tick of the PIA/VIA/TED/CIA timer, thus 60 times per second. It is assigned two system variables in BASIC, {{mono|TI}} and {{mono|TI$}}, which both contain the current time. TI is read-only and cannot be modified; doing so will result in a Syntax Error message. {{mono|TI$}} may be used to set the time via a six number string (an error results from using a string other than six numbers). The clock is not a very reliable method of timekeeping since it stops whenever interrupts are turned off (done by some kernal routines) and accessing the IEC (or IEEE port on the PET) port will slow the clock update by a few ticks.

The {{mono|RND}} function in Commodore BASIC can use the clock to generate random numbers; this is accomplished by {{code|RND(0)}}, however it is of relatively limited use as only numbers between 0 and 255 are returned. Otherwise, {{mono|RND}} works the same as other implementations of Microsoft BASIC in that a pseudo-random sequence is used via a fixed 5-byte seed value stored at power on in memory locations {{mono|$8B-$8F}} on the C64 (the location differs on other machines). {{mono|RND}} with any number higher than 0 will generate a random number amalgamated from the value included with the {{mono|RND}} function and the seed value, which is updated by 1 each time an RND function is executed. {{mono|RND}} with a negative number goes to a point in the sequence of the current seed value specified by the number.

Since true random number generation is impossible with the {{mono|RND}} statement, it is more typical on the C64 and C128 to utilize the SID chip's white noise channel for random numbers.

BASIC 2.0 notoriously suffered from extremely slow garbage collection of strings. Garbage collection is automatically invoked any time a {{mono|FRE}} function is executed and if there are many string variables and arrays that have been manipulated over the course of a program, clearing them can take more than an hour under the worst conditions. It is also not possible to abort garbage collection as BASIC does not scan the RUN/STOP key while performing this routine. BASIC 4.0 introduced an improved garbage collection system with back pointers and all later implementations of Commodore BASIC also have it.

The {{mono|FRE}} function in BASIC 2.0 suffered from another technical flaw in that it cannot handle signed numbers over 32768, thus if the function is invoked on a C64 (38k BASIC memory), a negative amount of free BASIC memory will be displayed (adding 65535 to the reported number will obtain the correct amount of free memory). The PET and VIC-20 never had more than 32k of total memory available to BASIC, so this limitation did not become apparent until the C64 was developed. The {{mono|FRE}} function on BASIC 3.5 and 7.0 corrected this problem and {{mono|FRE}} on BASIC 7.0 was also "split" into two functions, one to display free BASIC program text memory and the other to display free variable memory.

==Alternatives==
[[Image:Simons Basic Splash Screen.gif|thumb|right|The Simons' BASIC start-up screen]]

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]], which was included 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 like [[Simons' BASIC]] (1983) and Vision BASIC (2022).

Although BASIC 2.0's lack of sound or graphics features was frustrating to many users, some critics{{who|date=September 2023}} argued that it was ultimately beneficial since it forced the user to learn machine language.

The limitations of BASIC 2.0 on the C64 led to use of built-in ROM machine language from BASIC.  To load a file to a designated memory location, the filename, drive, and device number would be read by a call: {{code|lang=cbmbas|1=SYS57812"filename",8}};<ref>{{cite book|title=Mapping the Commodore 64 & 64C|last=Leemon|first=Sheldon|publisher=COMPUTE! Publications|page=209|year=1987|isbn=9780874550825|url=https://archive.org/stream/Compute_s_Mapping_the_64_and_64C#page/n221/mode/2up|access-date=2018-03-25}}</ref> the location would be specified in the X and Y registers: {{code|lang=cbmbas|1=POKE780,0:POKE781,0:POKE782,192}};<ref>{{cite book|title=Mapping the Commodore 64 & 64C|last=Leemon|first=Sheldon|publisher=COMPUTE! Publications|page=71|year=1987|isbn=9780874550825|url=https://archive.org/stream/Compute_s_Mapping_the_64_and_64C#page/n83/mode/2up|access-date=2018-03-25}}</ref> and the load routine would be called: {{code|lang=cbmbas|1=SYS65493}}.<ref>{{cite book|title=Mapping the Commodore 64 & 64C|last=Leemon|first=Sheldon|publisher=COMPUTE! Publications|page=231|year=1987|isbn=9780874550825|url=https://archive.org/stream/Compute_s_Mapping_the_64_and_64C#page/n243/mode/2up|access-date=2018-03-25}}</ref>

A disk magazine for the C64, ''[[Loadstar (magazine)|Loadstar]]'', was a venue for hobbyist programmers, who shared collections of proto-commands for BASIC, called with the {{code|1=SYS address + offset}} command.{{citation needed|date=March 2018}}

From a modern programming point of view, the earlier versions of Commodore BASIC presented a host of bad programming traps for the programmer. As most of these issues derived from [[Microsoft BASIC]], virtually every home computer BASIC of the era suffered from similar deficiencies.<ref>{{Cite web|url=https://www.atariarchives.org/c1ba/page007.php|title=Compute!'s First Book of Atari|website=www.atariarchives.org|accessdate=21 August 2023}}</ref> Every line of a Microsoft BASIC program was assigned a [[line number]] by the programmer. It was common practice to increment numbers by some value (5, 10 or 100) to make inserting lines during program editing or debugging easier, but bad planning meant that inserting large sections into a program often required restructuring the entire code. A common technique was to start a program at some low line number with an {{mono|[[GOSUB#Computed GOSUB|ON...GOSUB]]}} [[jump table]], with the body of the program structured into sections starting at a designated line number like 1000, 2000, and so on. If a large section needed to be added, it could just be assigned the next available major line number and inserted to the jump table.

In addition, all variables are treated as global variables. Clearly defined loops beyond the FOR...NEXT construct are hard to create, often causing the programmer to rely on the {{mono|[[GOTO]]}} command (this was later rectified in BASIC 3.5 with the addition of the {{mono|DO, LOOP, WHILE, UNTIL}}, and {{mono|EXIT}} commands). Flag variables often needed to be created to perform certain tasks. 

Later BASIC versions on Commodore and other platforms included a {{mono|DELETE}} and {{mono|RENUMBER}} command, as well as an AUTO line numbering command that would automatically select and insert line numbers according to a selected increment. Earlier BASICs from Commodore also lack debugging commands, meaning that bugs and unused variables are hard to trap. {{mono|IF...THEN...ELSE}} structures, a standard part of Z80 Microsoft BASICs, were added to BASIC 3.5 after being unavailable in earlier versions of Commodore BASIC.

==Use as user interface==
In common with other [[home computer]]s, Commodore's machines booted directly into the BASIC interpreter. BASIC's file and programming commands could be entered in [[direct mode]] to load and execute software. If program execution was halted using the RUN/STOP key, variable values would be preserved in RAM and could be PRINTed for debugging. The 128 even dedicated its second 64k bank to variable storage, allowing values to persist until a <code>NEW</code> or <code>RUN</code> command was issued. This, along with the advanced [[screen editor]] included with Commodore BASIC gave the programming environment a [[REPL]]-like feel; programmers could insert and edit program lines at any screen location, interactively building the program.<ref>{{cite book|url=https://books.google.com/books?id=UbvzBwAAQBAJ&pg=PA9|title=An Introduction to the Commodore 64: Adventures in Programming |isbn=9781489967879 |last1=Scrimshaw |first1=N. B. |date=11 November 2013 |publisher=Birkhäuser }}</ref> This is in contrast to business-oriented operating systems of the time like [[CP/M]] or [[MS-DOS]], which typically booted into a [[command-line interface]]. If a programming language was required on these platforms, it had to be loaded separately.

While some versions of Commodore BASIC included disk-specific <code>DLOAD</code> and <code>DSAVE</code> commands, the version built into the [[Commodore 64]] lacked these, requiring the user to specify the disk drive's device number (typically 8 or 9) to the standard <code>LOAD</code> command, which otherwise defaulted to tape. Another omission from the Commodore 64s BASIC 2.0 was a <code>DIRECTORY</code> command to display a disk's contents without clearing main memory. On the 64, viewing files on a disk was implemented as loading a "program" which when listed showed the directory as a pseudo BASIC program, with the file's block size as the line number. This had the effect of overwriting the currently loaded program. Addons like the DOS Wedge overcame this by rendering the directory listing direct to screen memory.

== Example code ==
{{sxhl|lang=cbmbas|1=
10 rem cbm basic v2 example
20 rem comment with keywords: for, data
30 dim a$(20)
35 rem the typical space efficient form of leaving spaces out:
40 fort=0to15:poke646,t:print"{revers on}     ";:next
50 geta$:ifa$=chr$(0):goto40
55 rem it is legal to omit the closing " on line end
60 print"{white}":print"bye...
70 end
}}<ref>{{github|https://github.com/pygments/pygments/blob/master/tests/examplefiles/cbmbas/cbmbas_example.bas|pygments/tests/examplefiles/cbmbas/cbmbas_example.bas}}</ref>

==Versions and features==
A list of CBM BASIC versions in chronological order, with successively added features:

===Released versions===
* V1.0: PET 2001 with [[chiclet keyboard]] and built-in [[Commodore Datassette|Datassette]] (original PET)
** arrays limited to 256 elements
** [[PEEK and POKE|PEEK]] command explicitly disabled over BASIC ROM locations above $C000
* V2.0 (first release): PET 2001 with full-travel keyboard & upgrade ROMs
** add [[IEEE-488]] support
** improved the garbage collection<ref name="zimmers.net">{{cite web|url=http://www.zimmers.net/anonftp/pub/cbm/firmware/README.txt|title=BASIC 4.0 Memory Map|website=zimmers.net|access-date=21 August 2023}}</ref>
** fix array bug
** Easter egg – entering {{kbd|WAIT6502, ''[number]''}} displays {{mono|MICROSOFT!}} an arbitrary number of times
* V4.0: PET/CBM 4000/8000 series (and late version PET 2001s)
** [[Commodore DOS|disk operations]]: {{mono|DLOAD,DSAVE,COPY,SCRATCH,}} etc. (15 in all)
** disk error-channel variables: {{mono|DS,DS$}}
** greatly improved garbage-collection performance<ref name="zimmers.net"/>
* V2.0 (second release, after 4.0): [[VIC-20]]; [[Commodore 64|C64]]
* V2.2 [[Commodore 64 Games System|C64GS]] (1990)
* V4+ : [[Commodore CBM-II|CBM-II]] series (aka B, P range)
** memory management: {{mono|BANK}}
** [[Commodore DOS|more disk operations]]: {{mono|[[BLOAD]], [[BSAVE]],DCLEAR}}
** formatted printing: {{mono|PRINT USING,PUDEF}}
** error trapping: {{mono|DISPOSE}}
** alternative branching: {{mono|ELSE}}
** dynamic error handling: {{mono|TRAP,RESUME,ERR$()}}
** flexible {{mono|DATA}} read: <code>RESTORE ''[line number]''</code>
** string search function: {{mono|INSTR}}
* V3.5: [[Commodore 16|C16/116]], [[Commodore Plus/4|Plus/4]]
** sound and graphics commands
** [[joystick]] input: {{mono|JOY}}
** [[decimal]] ↔ [[hexadecimal]] conversion: {{mono|DEC(),HEX$()}}
** structured looping: {{mono|DO,LOOP,WHILE,UNTIL,EXIT}}
** function key assignment: {{mono|KEY}} (also direct mode)
** program entry/editing: {{mono|AUTO,DELETE,RENUMBER}}
** [[debug]]ging (tracing): {{mono|[[TRON command|TRON]], [[TROFF]]}}
** [[machine code monitor|MLM]] entry command: {{mono|MONITOR}}
** C(1)16, Plus/4 Easter egg – enter {{kbd|SYS 52650}}
* V7.0: [[Commodore 128|C128]]
** more sound and graphics commands, including [[sprite (computer graphics)|sprite]] handling
** built-in sprite editor: {{mono|SPRDEF}}
** multi-statement blocks for {{mono|IF THEN ELSE}} structures: {{mono|BEGIN,BEND}}
** [[paddle (game controller)|paddle]], [[lightpen]] input: {{mono|POT,PEN}}
** [[exclusive disjunction|exclusive or]] function: {{mono|XOR}}
** get variable address: {{mono|POINTER}}
** text mode windowing: {{mono|WINDOW}}
** controlled time delay: {{mono|SLEEP}}
** memory management: {{mono|SWAP,FETCH,STASH,FRE(1)}}
** used the 128's [[bank switching]] to store program code separately from variables. Variable values would be preserved across program executions if the program was started with the GOTO command.
** [[Commodore DOS|more disk operations]]: {{mono|BOOT,DVERIFY}}
** CPU speed adjustment: {{mono|FAST,SLOW}} (2 vs 1&nbsp;MHz)
** enter C64 mode: {{mono|GO64}}
** undocumented, working: {{mono|RREG}} (read CPU registers after a {{mono|SYS}})
** unimplemented commands: {{mono|OFF,QUIT}}
** C128 Easter egg – enter {{kbd|SYS 32800,123,45,6}}

===Unreleased versions===
* V3.6 : [[Commodore LCD]] (unreleased prototype). Almost identical to V7.0, with the following differences:<ref>{{cite web|url=http://mikenaberezny.com/2008/10/04/commodore-lcd-firmware/|title=Mike Naberezny – Commodore LCD Firmware|website=mikenaberezny.com|access-date=8 August 2018}}</ref>
** {{mono|VOLUME}} instead of {{mono|VOL}}
** {{mono|EXIT}} instead of {{mono|QUIT}}
** {{mono|FAST,SLOW}} commands not present
** Additional command: {{mono|POPUPS}}
* V10 : [[Commodore 65]] (unreleased prototype)
** graphics/video commands: {{mono|PALETTE,GENLOCK}}
** [[computer mouse|mouse]] input: {{mono|MOUSE,RMOUSE}}
** text file ({{mono|SEQ}}) utility: {{mono|TYPE}}
** program editing: {{mono|FIND,CHANGE}}
** memory management: {{mono|DMA,FRE(2)}}
** unimplemented commands: {{mono|PAINT,LOCATE,SCALE,WIDTH,SET,VIEWPORT,PASTE,CUT}}

==Notable extension packages==
*[[Super Expander]] (VIC-20; delivered on [[ROM cartridge]]) (Commodore)
*[[Super Expander 64]] (C64; cartridge) (Commodore)
*[[Simons' BASIC]] (C64; cartridge) (Commodore)
*Graphics BASIC (C64; floppy disk) ([[Hesware]])
*[[BASIC 8]] (C128; floppy disk and optional internal ROM chip) ([[Walrusoft]])
*[https://visionbasic.net/ Vision BASIC] (C64; floppy disk) (Dennis Osborn)
*JiffyDOS (Creative Micro Designs)

==References==
{{Reflist}}

==Sources==
{{refbegin}}
*[http://www.weihenstephan.org/~michaste/pagetable/wait6502/msbasic_timeline.pdf Commodore/Microsoft Basic version timeline]
*[http://www.pagetable.com/?p=43 Bill Gates’ Personal Easter Eggs in 8 Bit BASIC], pagetable.com

;BASIC 2.0:
*Angerhausen et al. (1983). ''The Anatomy of the Commodore 64'' (for the full reference, see the [[Commodore 64#References|C64]] article).

;BASIC 3.5:
*Gerrard, Peter; Bergin, Kevin (1985). ''The Complete COMMODORE 16 ROM Disassembly''. Gerald Duckworth & Co. Ltd. {{ISBN|0-7156-2004-5}}.

;BASIC 7.0:
*Jarvis, Dennis; Springer, Jim D. (1987). ''BASIC 7.0 Internals''. Grand Rapids, Michigan: Abacus Software, Inc. {{ISBN|0-916439-71-2}}.

;BASIC 10.0:
*[http://www.zimmers.net/cbmpics/cbm/c65/c65manual.txt c65manual.txt Commodore 65 preliminary documentation (March 1991), with addendum for ROM version 910501.]
{{refend}}

{{BASIC}}

{{DEFAULTSORT:Commodore Basic}}
[[Category:CBM software|Basic]]
[[Category:Commodore 64 software|Basic]]
[[Category:VIC-20 software|Basic]]
[[Category:Discontinued Microsoft BASICs]]
[[Category:BASIC interpreters]]
[[Category:BASIC programming language family]]
[[Category:Microsoft programming languages]]
[[Category:Programming languages created in 1977]]