Commodore BASIC: История и Развитие

Введение

Commodore BASIC, также известный как PET BASIC или CBM BASIC, — это диалект языка программирования BASIC, использовавшийся в 8-битных домашних компьютерах Commodore International, начиная с PET (1977) и заканчивая Commodore 128 (1985). Ядро основано на 6502 Microsoft BASIC, и поэтому он имеет много общих черт с другими 6502 BASIC того времени, такими как Applesoft BASIC. Commodore лицензировал BASIC у Microsoft в 1977 году на условиях единовременной оплаты без выплаты роялти, после того как Джек Трамиэль отклонил предложение Билла Гейтса о плате за каждую единицу, заявив: "Я уже женат" и согласившись заплатить только за бессрочную лицензию. Оригинальная версия PET была очень похожа на исходную реализацию Microsoft с незначительными изменениями. BASIC 2.0 на C64 также был похож и встречался на C128 (в режиме C64) и других моделях. Более поздние модели PET оснащались BASIC 4.0, который был похож на оригинал, но добавлял ряд команд для работы с дискетами. BASIC 3.5 стал первым, кто значительно отличался, добавив ряд команд для поддержки графики и звука на C16 и Plus/4. BASIC 7.0 поставлялся с Commodore 128 и включал команды структурированного программирования из BASIC 3.5 Plus/4, а также ключевые слова, разработанные специально для использования новых возможностей компьютера. Был добавлен редактор спрайтов и монитор машинного кода. Последняя версия, BASIC 10.0, была частью так и не выпущенного Commodore 65.

История

Commodore взяла исходный код BASIC с фиксированной платой и продолжила его разработку внутри компании для всех своих других 8-битных домашних компьютеров. Уведомление об авторских правах Microsoft впервые появилось только на Commodore 128 (с V7.0). Однако Microsoft встроила "пасхальное яйцо" в версию 2 или "обновлённый" Commodore BASIC, которое подтверждало его происхождение: ввод малоизвестной команды WAIT 6502, 1 приводил к появлению на экране слова Microsoft! ("Пасхальное яйцо" было тщательно замаскировано – сообщение не отображалось при разборке интерпретатора). Популярный Commodore 64 поставлялся с BASIC v2.0 в ПЗУ, несмотря на то, что компьютер был выпущен после серии PET/CBM, в которой использовалась версия 4.0. Это объясняется тем, что Commodore 64 позиционировался как домашний компьютер, а серия PET/CBM была ориентирована на бизнес и образование, где встроенный язык программирования, как предполагалось, использовался более интенсивно. Это позволило снизить производственные затраты, так как V2 помещалась в ПЗУ меньшего размера.

Редактирование программы

Удобной особенностью интерпретатора BASIC и KERNAL для Commodore была полноэкранная программа редактирования. Несмотря на то, что клавиатуры Commodore имели всего два курсорных ключа, менявших направление при нажатии клавиши Shift, редактор экрана позволял пользователям вводить прямые команды или вводить и редактировать строки программы из любой точки экрана. Если строка начиналась с номера строки, она токенизировалась и сохранялась в памяти программы. Строки, не начинающиеся с номера, выполнялись при нажатии клавиши, когда курсор находился на этой строке. Это было значительным улучшением интерфейса ввода программ по сравнению с другими распространенными домашними компьютерами BASIC того времени, которые обычно использовали редакторы строк, вызываемые отдельной командой EDIT, или "курсор копирования", обрезавший строку в позиции курсора. Также была возможность сохранять именованные файлы на любое устройство, включая кассету – популярное устройство хранения во времена PET и которое оставалось в использовании на протяжении всего жизненного цикла 8-битных Commodore как недорогой способ массового хранения. Большинство систем поддерживали только имена файлов на дискетах, что затрудняло сохранение нескольких файлов на других устройствах. Пользователю этих систем приходилось запоминать показания счетчика магнитофона в месте расположения файла, но это было неточно и подвержено ошибкам. С PET (и BASIC 2.0) файлы с кассет можно было запрашивать по имени. Устройство искало имя файла, последовательно считывая данные и игнорируя несовпадающие имена. Файловая система также поддерживалась мощной структурой записей, которые можно было загружать или сохранять в файлы. Данные на кассетах Commodore записывались в цифровом виде, а не менее дорогими (и менее надежными) аналоговыми методами, используемыми другими производителями. Поэтому требовался специализированный Datasette, а не обычный магнитофон. Существовали адаптеры, использующие аналого-цифровой преобразователь для работы со стандартным магнитофоном, но они стоили лишь немного дешевле Datasette. Команда может использоваться с необязательным параметром, который загрузит программу в адрес памяти, содержащийся в первых двух байтах файла (эти байты отбрасываются и не сохраняются в памяти). Если параметр не указан, программа загружается в начало области программы BASIC, которая сильно различается на разных машинах. Некоторые варианты Commodore BASIC поставлялись с командами BLOAD и BSAVE, которые работали аналогично своим аналогам в Applesoft BASIC, загружая или сохраняя растровые изображения из указанных областей памяти. PET не поддерживает перемещаемые программы, и команда всегда загружается, начиная с первых двух байтов, содержащихся в файле программы. Это создавало проблему при попытке загрузить программы BASIC, сохраненные на других машинах Commodore, поскольку они загружались по более высокому адресу, чем ожидала BASIC PET, и требовало обходных путей для "перемещения" программ в нужное место. Если программа была сохранена на машине CBM II, единственный способ загрузить ее на PET заключался в изменении первых двух байтов с помощью редактора секторов диска, поскольку серия CBM II имела область программы BASIC по адресу $0, что приводило бы к попытке PET загрузить нулевую страницу и зависанию. Ключевые слова Commodore BASIC можно было сокращать, сначала вводя немодифицированный символ, а затем модифицированный символ следующей буквы. Это устанавливало старший бит, заставляя интерпретатор прекращать чтение и разбирать выражение в соответствии с таблицей поиска. Это означало, что выражение до старшего бита принималось как замена полного ввода команды. Однако, поскольку все ключевые слова BASIC хранились в памяти как однобайтовые токены, это было удобством для ввода выражений, а не оптимизацией. В наборе символов, содержащем только прописные буквы, модифицированные символы отображаются как графические символы; например, команда GOTO можно было сократить до G{Shift O} (которая на экране выглядела как GΓ). Большинство таких команд состояли из двух букв, но в некоторых случаях они были длиннее. В таких случаях возникала неоднозначность, поэтому требовалось больше немодифицированных букв команды, например, GO{Shift S} (GO♥) для GOSUB. Некоторые команды не имели сокращенной формы из-за краткости или неоднозначности с другими командами. Например, команда INPUT не имела сокращения, поскольку ее написание совпадало с отдельным ключевым словом INPUT#, которое находилось ближе к началу таблицы ключевых слов. Часто используемая команда PRINT имела сокращение ?, как и в большинстве диалектов Microsoft BASIC. Сокращение команд с помощью модифицированных букв уникально для Commodore BASIC. Этот метод токенизации имел ошибку: если включать REM (оператор BASIC для добавления комментария к коду), за которым следовал {Shift L}, при попытке просмотреть листинг программы интерпретатор BASIC немедленно прерывал листинг, отображал ?SYNTAX ERROR и возвращался к подсказке READY. Программисты использовали эту ошибку для защиты своей работы, хотя ее было довольно легко обойти. Сокращая ключевые слова, можно было поместить больше кода на одной строке программы (которая могла занимать две строки экрана на дисплеях с 40 столбцами, т. е. C64 или PET, или четыре строки на 22-столбцовом дисплее VIC 20). Это позволяло немного сэкономить на накладных расходах на хранение дополнительных строк программы, но не более того. Все команды BASIC токенизировались и занимали 1 байт (или два, в случае нескольких команд BASIC 7 или BASIC 10) в памяти, независимо от способа ввода. Такие длинные строки было неудобно редактировать. Команда LIST отображала все ключевое слово команды, расширяя строку программы за пределы 2 или 4 строк экрана, которые можно было ввести в память программы.

A convenient feature of Commodore's ROM resident BASIC interpreter and KERNAL was the full screen editor. 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 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 key whenever the 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 editors, invoked by a separate EDIT 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 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 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 command may be used with the optional parameter 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 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 BLOAD and BSAVE commands that worked like their counterparts in Applesoft BASIC, loading or saving bitmaps from specified memory locations. The PET does not support relocatable programs and the 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 keywords could be abbreviated by entering first an unshifted keypress, and then a shifted keypress of the next letter. This set the 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, GOTO, could be abbreviated G{Shift O} (which resembled GΓ 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 GO{Shift S} (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. The heavily used PRINT command had a single ? 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 REM (BASIC statement to add a comment to the code) followed by a {Shift L}, when trying to view the program listing, the BASIC interpreter would immediately abort the listing, display a ?SYNTAX ERROR and return to the READY. 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 LIST command displayed the entire command keyword extending the program line beyond the 2 or 4 screen lines which could be entered into program memory.

Выступление

Как и оригинальный интерпретатор Microsoft BASIC, Commodore BASIC работает медленнее, чем машинный код. Результаты тестов показали, что копирование 16 килобайт из ПЗУ в ОЗУ занимает менее секунды в машинном коде, по сравнению с более чем минутой в BASIC. Чтобы ускорить выполнение программ, программисты начали использовать различные техники. Одной из них было хранение часто используемых чисел с плавающей точкой в переменных, а не использование литералов, так как интерпретация имени переменной была быстрее, чем интерпретация числового литерала. Поскольку тип с плавающей точкой является типом по умолчанию для всех команд, использование чисел с плавающей точкой в качестве аргументов быстрее, чем целых чисел. Когда скорость была критична, некоторые программисты переводили части программ BASIC на ассемблер 6502 или 6510, который загружался отдельно из файла или записывался в память из инструкций DATA в конце программы BASIC, а затем выполнялся из BASIC с помощью команды SYS, либо в прямом режиме, либо из самой программы. Если скорость машинного кода была слишком высокой, например, в играх или при ожидании ввода пользователя, программисты могли выполнять опрос, считывая выбранные ячейки памяти (например, для 64 или для 128, обозначающие размер буфера клавиатуры), чтобы замедлить или остановить выполнение. Уникальной особенностью Commodore BASIC является использование управляющих кодов для выполнения задач, таких как очистка экрана или позиционирование курсора в программе. Их можно вызвать либо с помощью команды, где X соответствует коду управления (например, является кодом управления для очистки экрана), либо нажатием соответствующей клавиши в кавычках. Например, нажатие после кавычки заставит BASIC отобразить визуальное представление управляющего кода (в данном случае, перевернутое сердце), которое будет выполнено при запуске программы (прямая печать управляющих кодов использует меньше памяти и выполняется быстрее, чем вызов функции). Это отличается от других реализаций BASIC, которые обычно имеют отдельные команды для очистки экрана или перемещения курсора. BASIC 3.5 и более поздние версии имеют специальные команды для очистки экрана и перемещения курсора. В Commodore BASIC строки программ не требуют пробелов (но команда всегда отображает один пробел между номером строки и оператором), например, , и было принято писать программы без пробелов. Эта функция была добавлена для экономии памяти, поскольку токенайзер не удаляет пробелы между ключевыми словами: наличие пробелов приводит к дополнительным 0x20 байтам в токенизированной программе, которые просто пропускаются при выполнении. Токенайзер удаляет пробелы между номером строки и оператором программы. На большинстве машин строки программы могут содержать до 80 символов, но машины с 40-колонковым текстом переносили строку на следующую строку на экране, а на VIC 20, с 22-колонковым дисплеем, строки программы могли занимать до четырех строк. BASIC 7.0 на Commodore 128 увеличил лимит строки программы до 160 символов (четыре строки по 40 символов или две строки по 80 символов). Используя сокращения, такие как вместо , можно поместить больше кода в строку. BASIC 7.0 выдает ошибку, если пользователь вводит строку программы длиной более 160 символов. В более ранних версиях ошибка не выдается, а просто отображается запрос READY на две строки ниже, если длина строки превышена. Номер строки учитывается в общем количестве символов в строке программы, поэтому пятизначный номер строки уменьшает допустимое количество символов на четыре. Порядок выполнения строк Commodore BASIC не определялся нумерацией строк; вместо этого он следовал порядку, в котором строки были связаны в памяти. Строки программы хранились в памяти в виде односвязного списка с указателем (содержащим адрес начала следующей строки программы), номером строки и затем токенизированным кодом строки. Во время ввода программы BASIC постоянно переупорядочивал строки программы в памяти, чтобы номера строк и указатели были в порядке возрастания. Однако после ввода программы ручное изменение номеров строк и указателей с помощью команд POKE могло привести к выполнению строк в неправильном порядке или даже присвоить всем строкам один и тот же номер строки. В ранние годы, когда BASIC использовался в коммерческих целях, это был метод защиты программного обеспечения от несанкционированных изменений. Номера строк могут быть от 0 до 65520 и занимают пять байт для хранения, независимо от количества цифр в номере строки, хотя выполнение происходит быстрее, если номер строки содержит меньше цифр. Размещение нескольких операторов в одной строке позволяет сэкономить память и ускорить выполнение. Операторы и будут искать строку с указанным номером вниз от текущей строки, если выполняется прямой переход, а в случае обратного перехода вернутся к началу программы для поиска. Это замедляет выполнение больших программ, поэтому желательно размещать часто используемые подпрограммы в начале программы. Имена переменных учитываются только первые два символа; таким образом, имена переменных VARIABLE1, VARIABLE2 и VA относятся к одной и той же переменной. Commodore BASIC также поддерживает побитовые операторы , и , хотя эта функция была частью основного кода Microsoft 6502 BASIC, она часто отсутствовала в других реализациях, таких как Applesoft BASIC. Собственный формат чисел в Commodore BASIC, как и в его родительском MS BASIC, — это числа с плавающей точкой. Большинство современных реализаций BASIC использовали один байт для мантиссы (экспоненты) и три байта для мантиссы. Точность числа с плавающей точкой с трехбайтовой мантиссой составляет около 6,5 десятичных знаков, и округление является распространенной проблемой. 6502 реализации Microsoft BASIC использовали 40-битную арифметику с плавающей точкой, что означает, что переменные занимали пять байт для хранения (четырехбайтовая мантисса и один байт для экспоненты), в отличие от 32-битной арифметики с плавающей точкой в BASIC 80. В то время как 8080/Z80 реализации Microsoft BASIC поддерживали целочисленные и переменные двойной точности, 6502 реализации поддерживали только числа с плавающей точкой. Хотя Commodore BASIC поддерживает целочисленные переменные со знаком (обозначаются знаком процента) в диапазоне от -32768 до 32767, на практике они используются только для переменных массивов и служат для экономии памяти, ограничивая элементы массива двумя байтами каждый (массив из 2000 элементов займет 10 000 байт, если он объявлен как массив чисел с плавающей точкой, но только 4000 байт, если он объявлен как целочисленный массив). Объявление любой переменной как целочисленной просто приводит к тому, что BASIC преобразует ее обратно в число с плавающей точкой, замедляя выполнение программы и тратя память, поскольку каждый знак процента занимает один дополнительный байт для хранения (поскольку это также относится к целочисленным массивам, программисту следует избегать их использования, если только не используются очень большие массивы, которые превысили бы доступную память, если бы они хранились как числа с плавающей точкой). Кроме того, невозможно с помощью или получить доступ к ячейкам памяти выше 32767 с адресом, определенным как целочисленная переменная. Точку (.) можно использовать вместо числа 0 (например, вместо или вместо ), что приведет к немного более быстрому выполнению. Оператор, используемый для запуска программ на машинном коде, был добавлен Commodore и отсутствовал в оригинальном коде Microsoft BASIC, который содержал только функцию USR для вызова подпрограмм на машинном коде. Он автоматически загружает регистры процессора значениями из (C64, варьируется на других машинах), что можно использовать для передачи данных в подпрограммы на машинном коде или в качестве средства вызова функций ядра из BASIC (например, очищает экран). Поскольку 8-битные компьютеры Commodore, отличные от C128, не могут автоматически загружать дисковое программное обеспечение, обычно используется базовая заглушка, такая как , для начала выполнения программы. Можно автоматически запускать программное обеспечение после загрузки, не требуя от пользователя ввода оператора , это делается путем перехвата вектора "ready" BASIC по адресу .
Как и в большинстве других версий Microsoft BASIC, если массив не объявлен с помощью оператора , он автоматически устанавливается в десять элементов...

Like the original Microsoft BASIC interpreter, Commodore BASIC is slower than native machine code. Test results have shown that copying 16 kilobytes from ROM to RAM takes less than a second in machine code, compared to over a minute in BASIC. 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 6502 or 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 SYS command, either from direct mode or 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 poll by reading selected memory locations (such as for the 64, or 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 command where X corresponds to the control code to be issued (for example, is the control code to clear the screen) or by pressing the key in question between quote marks, thus pressing 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 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 command will always display one between the line number and the statement), e. g., , 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 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 instead of , it is possible to fit even more on a line. BASIC 7.0 displays a 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. 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 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. and 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 VARIABLE1, VARIABLE2, and VA all refer to the same variable. Commodore BASIC also supports bitwise operators , and , 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 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 integer variables (denoted with a percent sign) in the range 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 or memory locations above 32767 with address defined as a signed integer. A period (.) can be used in place of the number 0 (thus instead of or instead of ), this will execute slightly faster. The statement, used to start machine language programs, was added by Commodore and was not in the original Microsoft BASIC code, which featured only the USR function for invoking machine language routines. It automatically loads the CPU's registers with the values in (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, 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 to begin program execution. It is possible to automatically start software after loading and not require the user to type a statement, this is done by having a piece of code that hooks the BASIC "ready" vector at
As with most other versions of Microsoft BASIC, if an array is not declared with a 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 AA$, AA, and AA% would each be understood as distinct. Array variables are also considered distinct from simple variables, thus and 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, and , which both contain the current time. TI is read only and cannot be modified; doing so will result in a Syntax Error message. 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 function in Commodore BASIC can use the clock to generate random numbers; this is accomplished by , however it is of relatively limited use as only numbers between 0 and 255 are returned. Otherwise, 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 on the C64 (the location differs on other machines). with any number higher than 0 will generate a random number amalgamated from the value included with the function and the seed value, which is updated by 1 each time an RND function is executed. 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 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 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 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 function on BASIC 3.5 and 7.0 corrected this problem and 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.

Альтернативы

Многие расширения BASIC были выпущены для Commodore 64 из-за относительно ограниченных возможностей его встроенного BASIC 2.0. Одним из самых популярных расширений был DOS Wedge, который поставлялся с Commodore 1541 Test/Demo Disk. Это расширение BASIC размером 1 КБ добавило ряд команд, связанных с диском, включая возможность чтения каталога диска без уничтожения программы в памяти. Его функции впоследствии были включены в различные сторонние расширения, такие как популярный картридж Epyx FastLoad. Другие расширения BASIC добавили дополнительные ключевые слова для упрощения кодирования спрайтов, звука и графики высокого разрешения, например Simons' BASIC (1983) и Vision BASIC (2022). Хотя отсутствие звуковых или графических функций в BASIC 2.0 расстраивало многих пользователей, некоторые критики утверждали, что это в конечном итоге было полезно, поскольку заставляло пользователя изучать машинный язык. Ограничения BASIC 2.0 на C64 привели к использованию встроенного в ПЗУ машинного языка из BASIC. Для загрузки файла в указанное местоположение памяти имя файла, диск и номер устройства считывались с помощью вызова: ; местоположение указывалось в регистрах X и Y: ; и вызывалась подпрограмма загрузки: Дисковый журнал для C64, Loadstar, был площадкой для программистов-любителей, которые делились коллекциями протоколов команд для BASIC, вызываемых командой. С точки зрения современного программирования, ранние версии Commodore BASIC представляли собой множество опасных ловушек для программиста. Поскольку большинство этих проблем были унаследованы от Microsoft BASIC, практически каждый домашний компьютер BASIC той эпохи страдал от подобных недостатков. Каждой строке программы Microsoft BASIC присваивался номер строки программистом. Обычно номера увеличивали на определенное значение (5, 10 или 100), чтобы упростить вставку строк во время редактирования или отладки программы, но плохое планирование означало, что вставка больших разделов в программу часто требовала реструктуризации всего кода. Распространенной техникой было начинать программу с небольшого номера строки с таблицей переходов, а тело программы структурировалось на разделы, начинающиеся с определенного номера строки, например 1000, 2000 и так далее. Если нужно было добавить большой раздел, ему можно было просто присвоить следующий доступный номер главной строки и вставить его в таблицу переходов. Кроме того, все переменные рассматриваются как глобальные переменные. Четко определенные циклы, отличные от конструкции FOR NEXT, сложно создавать, что часто заставляло программиста полагаться на команду (это было исправлено позже в BASIC 3.5 с добавлением команд и). Для выполнения определенных задач часто требовалось создавать переменные-флаги. Более поздние версии BASIC на Commodore и других платформах включали команды и, а также команду автоматической нумерации строк AUTO, которая автоматически выбирала и вставляла номера строк в соответствии с выбранным шагом. Ранние версии BASIC от Commodore также не имели команд отладки, что затрудняло обнаружение ошибок и неиспользуемых переменных. Структуры, стандартная часть Z80 Microsoft BASIC, были добавлены в BASIC 3.5 после того, как они были недоступны в более ранних версиях Commodore BASIC.

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 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: ; the location would be specified in the X and Y registers: ; and the load routine would be called:
A disk magazine for the C64, Loadstar, was a venue for hobbyist programmers, who shared collections of proto commands for BASIC, called with the command. 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. 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 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 command (this was later rectified in BASIC 3.5 with the addition of the , and commands). Flag variables often needed to be created to perform certain tasks. Later BASIC versions on Commodore and other platforms included a and 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. structures, a standard part of Z80 Microsoft BASICs, were added to BASIC 3.5 after being unavailable in earlier versions of Commodore BASIC.

Использовать в качестве пользовательского интерфейса

Как и другие домашние компьютеры, компьютеры Commodore загружались непосредственно в интерпретатор BASIC. Файловые команды и команды программирования BASIC можно было вводить в прямом режиме для загрузки и выполнения программ. Если выполнение программы прерывалось клавишей RUN/STOP, значения переменных сохранялись в оперативной памяти и могли быть выведены на экран для отладки. Модель 128 даже выделяла свой второй 64-килобайтный блок памяти для хранения переменных, позволяя им сохраняться до ввода команды NEW или RUN. Это, в сочетании с расширенным редактором экрана, включенным в Commodore BASIC, придавало среде программирования ощущение REPL: программисты могли вставлять и редактировать строки программы в любом месте экрана, интерактивно создавая программу. Это отличалось от бизнес-ориентированных операционных систем того времени, таких как CP/M или MS-DOS, которые обычно загружались в интерфейс командной строки. Если на этих платформах требовался язык программирования, его необходимо было загружать отдельно. Хотя некоторые версии Commodore BASIC включали дисковые команды DLOAD и DSAVE, в версии для Commodore 64 они отсутствовали, поэтому пользователю приходилось указывать номер устройства дисковода (обычно 8 или 9) в стандартной команде LOAD, которая по умолчанию работала с кассетой. Другим недостатком BASIC 2.0 в Commodore 64 была отсутствие команды DIRECTORY для отображения содержимого диска без очистки основной памяти. На Commodore 64 просмотр файлов на диске осуществлялся путем загрузки "программы", которая при выводе на экран отображала каталог в виде псевдо-BASIC программы, где размер блока файла служил номером строки. Это приводило к перезаписи текущей программы. Дополнения, такие как DOS Wedge, решали эту проблему, выводя список каталогов непосредственно в видеопамять.