[an error occurred while processing this directive] 

─HM0
─TM0
─LM6
─PL70
│.........*.......*.......*.......*.......*.......*.......*.......*<
|||/GET/|||

/Назначение/

 Эта  функция  ждет  нажатия  клавиши   на   клавиатуре  и  затем
возвращает |||ASCII||| номер введенного символа.
 Функция |||GET||| используется в тех  случаях,  когда  компьютеру надо
приостановить  работу  программы  до  тех  пор,  пока не поступит
сигнал от пользователя.
 Надо отметить, что при использовании  |||GET|||,  символы,  вводимые с
клавиатуры не будут появляться на экране. Если Вы  хотите,  чтобы
они  все же  отображались  на  экран,  то надо попросить компьютер
напечатать их.

/Примеры/
1040 keyhit=GET
350 X=GET

|||/Описание/|||

 Функция, которая ждет появления следующего  символа  во  входном
потоке.  После  появления  символа,  функция возвращает его |||ASCII|||
номер.

|||/Синтаксис/|||

<num-var>=GET

-----------------------------------------------------------------

|||/GET¤/|||

|||/Назначение/|||

 |||GET¤||| - это функция, которая  ждет  ввода символа с клавиатуры и,
затем,   возвращает   строку, содержащую  введенный  символ.  Для
дополнительной информации смотри описание похожей функции |||GET|||.
 Например, Вы захотите, чтобы в конце игровой программы компьютер
спрашивал пользователя хочет он сыграть  еще раз или нет. Как это
можно  сделать показано в приведенной демонстрационной программе.

/Пример/
1050 A¤=GET¤

|||/Синтаксис/|||

<string-var>=GET¤

/Демонстрационная программа/

2100 PRINT "Хотите сыграть еще раз ";
2120 REM "Если пользователь нажмет 'Y', то"
2130 REM "переход на строку 100"
2140 IF GET¤="Y" THEN GOTO 100
2150 REM "Если он добрался до этой строки"
2160 REM "значит он нажал не 'Y'"
2180 STOP

-----------------------------------------------------------------

|||/HIMEM/||| самая верхняя ячейка памяти

/Назначение/

 |||BASIC|||  использует  память  компьютера  для   хранения   программы
пользователя и всех программных переменных.
 Если Вы не давали компьютеру  ни каких указаний по распределению
памяти, он использует всю имеющуюся память  по своему усмотрению.
Иногда возникают такие ситуации, например, при написании программ
на   машинном  коде,  когда  Вам  надо  вмешаться   в   процедуру
распределения памяти.
 Один из способов воздействия на  механизм распределения памяти -
это изменение значения переменной |||HIMEM|||. Эта  переменная содержит
адрес самой последней ячейки памяти, которую |||BASIC||| использует для
хранения  Вашей  программы  и  переменных. Адреса выше  |||HIMEM|||  не
используются |||BASIC|||ом.
 Если  Вы  измените значение |||HIMEM|||,  то  Вы  можете  использовать
память выше |||HIMEM|||  по  своему  усмотрению,  например,для хранения
подпрограмм на машинном коде.
 Если Вы захотите изменить значение |||HIMEM|||, то это надо делать как
можно раньше в Вашей программе, желательно, в самом начале.
 Другими важными ограничителями являются |||PAGE|||, |||TOP||| и |||LOMEM|||.

/Примеры/
100 HIMEM=HIMEM-40
100 PRINT HIMEM
100 HIMEM = &2800

|||/Описание/|||

 |||HIMEM||| содержит адрес первого байта,  не используемого |||BASIC|||. Эта
псевдопеременная не должна изменяться внутри процедур  и функций.
Изменяйте ее очень осторожно!

|||/Синтаксис/|||

HIMEM=<numeric>
или
<num-var>=HIMEM

-----------------------------------------------------------------

|||/INKEY/||| вводит номер нажатой клавиши

/Назначение/

 Эта функция, в течении указанного  времени,  проверяет не нажата
ли какая-нибудь клавиша на клавиатуре.
 Если  клавиша  была  нажата  до   того  как  время  истекло,  то
возвращается |||ASCII||| номер. Если за  указанное  время  ни  какая из
клавиш  не была нажата, то возвращается -1 и программа продолжает
работать.
 Заметим,  что  клавиша  могла  быть   нажата  до  того,  как  Вы
использовали   |||INKEY|||.   Информация   о  всех   нажатых   клавишах
накапливается  в буффере компьютера и  вынимаются  из  буффера  с
помощью таких  операторов, как |||INKEY|||. Вы можете очистить буффер с
помощью команды:

|||*FX 15,1|||

 Число, указываемое в скобках после |||INKEY|||, задает,сколько времени
компьютер должен ждать нажатия на клавишу. Это число задает время
в сотых долях секунды и должно быть в интервале от |||0 до 32767|||.
 Кроме  этого, |||INKEY|||  может быть  использована  для  того,  чтобы
проверить,нажата ли указанная  клавиша  в  данный момент или нет.
При   нажатии   на   клавишу   в   буффер   компьютера   вводится
соответствующий  символ.  Если  Вы  будете  удерживать  клавишу в
нажатом  состоянии,  то,  как  правило, начнется автоповтор, и  в
буффер начнут заноситься новые символы. При считывании символа из
буффера с помощью операторов |||INPUT|||,  |||GET||| или |||INKEY|||, Вы не сможете
выяснить  сколько  времени считанный символ пролежал  в  буффере.
Альтернативный вариант оператора  |||INKEY|||  проверяет  не  буффер, а
клавиатуру.
 |||INKEY|||  с отрицательным числом в  скобках,  например  |||INKEY(-27)|||,
позволит Вам  проверить  нажата  ли  указанная  клавиша  в данный
момент  времени.  Число  в  скобках  определяет, какую клавишу Вы
хотите  проверить.  В приведенной таблице Вы можете  найти, какое
отрицательное   число  необходимо   использовать   для   проверки
конкретной клавишы.

/Примеры/
100 keynumber=INKEY(5)

220 result=INKEY(y)

X=INKEY(100)

|||/Описание/|||

 Функция, которая ждет нажатия на  клавишу  в  течении указанного
времени. Она возвращает значение -1, если ни одна  из  клавиш  не
была  нажата,  или |||ASCII||| номер введенного символа. Аргумент - это
максимальное время, в  течении  которого  компьютер  будет  ждать
нажатия на клавишу, в сотых долях секунды.

|||/Синтаксис/|||

<num-var>=INKEY(<numeric>)

-----------------------------------------------------------------

|||/INKEY¤/|||

/Назначение/

 Эта  функция   в  течении указанного  времени   проверяет,нажата   
какая-нибудь клавиша на клавиатуре  или  нет.  Если  клавиша была
нажата  прежде,  чем  время истекло, то нажатая буква  или  цифра
помещается в символьную переменную.  Если никакой клавишы нажато
не было, то возвращается пустая строка и программа продолжается.
 Отметим,  что  клавиша  могла  быть   нажата   прежде,  чем  был
использован |||INKEY¤|||. Все введенные символы накапливаются в буффере
компьютера и вынимаются из него  с  помощью,  например, оператора
|||INPUT|||. Вы можете очистить буффер с помощью команды

|||*FX 15,1|||

 Число,  указанное  в скобках после  |||INKEY¤|||,  определяет  сколько
времени компьютер будет  ждать нажатия на клавишу. Время задается
в сотых долях секунды.

/Примеры/
120 letter¤=INKEY¤(0)

384 result¤=INKEY¤(100)

920 X¤=INKEY¤(Y)

|||/Описание/|||

 Функция, которая ждет нажатия на  клавишу  в  течении указанного
времени. Функция возвращает пустую строку, если ни одна из клавиш
не была нажата за указанное время. Если клавиша  была  нажата, то
возвращается  строка,  состаящая  из введенного символа. Аргумент
задает время в сотых долях секунды.

|||/Синтаксис/|||

<string-var>=INKEY¤(<numeric>)

-----------------------------------------------------------------

|||/INPUT/|||

/Назначение/

 Когда  на  компьютере  работает программа,  ей  часто  требуется
информация из 'окружающего мира'  в  виде  чисел и слов для того,
чтобы провести необходимые вычисления. Оператор |||INPUT||| как  раз  и
обеспечивает   пользователю   возможность   ввода   информации  в
работающую  программу.  Существует несколько вариантов применения
оператора:

100 INPUT X

 напечатает вопросительный знак на экране  и  будет  ждать,  пока
пользователь  не введет число. Это не очень 'дружественная' форма
оператора |||INPUT|||. Было бы более понятно и удобно для пользователя,
если прежде,чем  ждать от него ответа на экране появился бы текст
вопроса. Это можно сделать двумя способами :

340 PRINT "Сколько Вам лет ";
350 INPUT age

 или более просто:

340 INPUT "Сколько Вам лет ",age

 Если  Вы  не  хотите,  чтобы   компьютер  автоматически  печатал
вопросительный  знак, то не ставьте  запятую  между  текстом  для
вывода на  экран  и  именем переменной, в которую будет вводиться
ответ.
340 INPUT "Сколько Вам лет " age

 Достаточно  часто  Вам  может  потребоваться  вводить  несколько
величин одну за другой. Для  того,  чтобы  это сделать необходимо
указать, через запятую, все переменные одну за другой, например: 
560 INPUT "Введите три числа ",X,Y,Z
─PE
 При ответе пользователь разделяет вводимые величины запятыми или
нажимая  на клавишу |||RETURN||| после  ввода  очередной  величины.  В
данном примере  введенные  числа будут присвоены переменным X,Y и
Z.

 Во  всех приведенных примерах пользователь  должен  был  вводить
числа. Но с помощью |||INPUT||| можно организовать также и ввод слов.

250 INPUT "Как Вас зовут ", NAME¤

 Если  Вы захотите ввести сразу  несколько  слов,  то  это  можно
сделать с помощью, например, следующего оператора

200 INPUT "Город ", A¤," Страна ",B¤

 Конструкция   |||INPUT   LINE|||   предоставляет   Вам  дополнительные
возможности  по  вводу  целых предложений. |||INPUT LINE A¤||| присвоит
весь, набранный Вами текст,  включая прбелы и запятые, переменной
|||А¤|||.

 |||INPUT||| можно использовать вместе с |||TAB|||, аналогично как и оператор
|||PRINT|||. Например :

300 INPUT TAB(3,12) "Ваше число" X

 Также можно использовать |||SPC||| для вставки пробелов.
 Вместо запятой в операторе |||INPUT|||  можно указать точку с запятой.
 И в том и в  другом  случае  компьютер напечатает вопросительный
знак, когда начнет ждать ввода требуемой величины.

|||/Описание/|||

 Оператор  для  ввода  величин  из   текущего   входного  потока.
 Подавление  вопросительного  знака  производится  при  опускании
запятой   после   строки-подсказки.   |||INPUT|||  игнорирует  пробелы,
введенные перед числом или строкой.

|||/Синтакис/|||

INPUT[<string-const>][;|,]<num-var>|<string-var>{,num-var>|<string-var>}

-----------------------------------------------------------------

|||/INPUT#/||| ввести информацию в компьютер с диска

/Назначение/

 Вы можете записать данные (числа  и  слова)  на  диске,  где они
хранятся  сколь  угодно  долго,  и  использовать  их,  когда  Вам
потребуется.  Оператор |||INPUT#||| используется для того, чтобы ввести
эти данные с диска обратно в компьютер.

/Примеры/
1200 INPUT# chanel, date, name¤, address¤

3400 INPUT#X,U,V,W¤

|||/Описание/|||

 Оператор,  который  считывает  данные, хранячиеся  на  диске  во
'внутреннем  формате'  из  файла   и   помещает  их  в  указанные
переменные.

|||/Синтаксис/|||

INPUT#<num-var>,<num-var>|<string-var>{,<num-var>|<string-var>}

-----------------------------------------------------------------

|||/INSTR/||| в строке

/Назначение/

 Эта функция служит для поиска  вхождений одной символьной строки
в другой. Ее можно использовать, например, если  Вы хотите узнать
содержится ли какое-либо слово в другом или нет.
 Поиск  по умолчанию начинается с начала  строки,  но  Вы  можете
указать с какого места начинать поиск.
 Число,  возвращаемое функцией |||INSTR|||- это  местоположение  второй
строки в  первой.  Самый левый символ имеет позицию номер 1. Если
вхождение не обнаружено, то  возвращается  ноль.  Поиск вхождения
нулевой строки

X=INSTR("Понедельник","")

всегда дает 1.

/Примеры/
240 X=INSTR(A¤,B¤)
помещает в X позицию B¤ в A¤

180 Y=INSTR(A¤,B¤,Z)
начать поиск с позиции Z

PRINT INSTR("ПРИВЕТ","И")
напечатает 3.

|||/Описание/|||

 Функция, которая возвращает позицию подстроки  в  строке.  Может
быть  указана  позиция,  с  которой следует начинать поиск. Между
словом |||INSTR||| и первой скобкой не должно быть ни одного пробела.

|||/Синтаксис/|||
<num-var>=INSTR(<string>,<string>[,<numeric>])

-----------------------------------------------------------------

|||/LISTO/|||

/Назначение/

 При выводе текста программы на экран или на принтер очень удобно
выделить все циклы. |||LISTO||| служит  для указания команде |||LIST||| каким 
образом   распечатывть   текст  программы.  Она  может  заставить
компьютер вставлять пробелы в трех следующих ситуациях:

- После номера строки.
- В течении циклов |||FOR...NEXT|||
- В течении циклов |||REPEAT...UNTIL|||

 Число, которое указывается после |||LISTO|||,  должно  быть в пределах
от 0 до 7. И имеет следующее значение :

 0 - не вставлять пробелов.
 1 - пробел после номера строки.
 2 - пробелы в течении циклов |||FOR...NEXT|||.
 4 - пробелы в течении циклов |||REPEAT...UNTIL|||.

 Числа,  которые управляют представлением текста  программы  (1,2
или 4),  можно складывать для получения комбинированного эффекта.
Например,  если  Вы  хотите,  чтобы  пробелами  выделялись  циклы
|||FOR...NEXT||| и |||REPEAT...UNTIL|||,  то  надо  указать  |||LISTO 6. LISTO 7|||
отделяет  пробелами  номера  строк  и выделяет двойными пробелами
циклы |||FOR...NEXT||| и |||REPEAT...UNTIL|||.
 Наиболее часто используются |||LISTO 0||| и |||LISTO 7|||.
 Мы настоятельно рекомендуем Вам использовать  опцию  |||LISTO 0||| при
редактировании  программы  с помощью клавиш управления курсором и
клавиши |||COPY|||, так  как в противном случае Вы можете скопировать в
строку много лищних пробелов.

|||/Описание/|||

 |||LISTO||| задает формат выдачи текста  программы  с  помощью команды
|||LIST|||.  Нулевой  бит  аргумента  управляет пробелами после номеров
строк,  бит  1 двойными пробелами  в  циклах  |||FOR...NEXT|||,  бит  2
двойными пробелами в циклах |||REPEAT...UNTIL|||.

|||/Синтаксис/|||

LISTO<num-const>

-----------------------------------------------------------------

|||/LOAD/|||

/Назначение/

 Для загрузки программы с диска в компьютер. Например:

 LOAD "GAME1"

 После того, как программа загружена,  напишите  |||RUN||| и она начнет
работать.
 Когда  Вы  используете  команду  |||LOAD|||   компьютер  'забывает'  о
программе, которая была загружена ранее, и обо всех переменных.
 При  загрузке  программы  Вы должны  указать  ее  название.  Имя
программы не должно превышать 10 символов.
 Команда |||LOAD||| не запускает программу.  Она  только загружает ее в
память. Она очищает все переменные, за исключением  от A% до Z% и
 %. Команду |||LOAD||| нельзя использовать внутри программы.
 Оператор |||CHAIN||| может быть использован  внутри программы (или как
команда)  для  загрузки  другой  программы и  ее  автоматического
запуска.

/Примеры/
LOAD "StarWars"

LOAD "MYPROG"

|||/Описание/|||

 Команда   |||LOAD|||   уничтожает  текущую  программу,   очищает   все
переменные, за исключением резидентных целых  переменных, и затем
загружает новую программу с диска. Загружаемая  программа  должна
быть во внутреннем формате.

|||/Синтаксис/|||

LOAD<string>

-----------------------------------------------------------------

|||/LOCAL/|||
 
 /Назначение/

 Информирует компьютер о том, что  указанные  переменные являются
'локальными' для данной процедуры или функции, т.е. использование
этих  переменных  внутри  процедуры  или  функции  не  влияет  на
значения  переменных с такими же именами вне  ее.  Дополнительную
информацию можно найти в описании ключевого слова |||DEF|||.

/Пример/
 560 LOCAL X,Y,A¤,B¤

|||/Описание/|||

 Оператор, который может быть использован  только внутри описания
процедуры   или   функции.   |||LOCAL|||   сохраняет  значения  внешних
переменных  с  указанными  именами  и  восстанавливает  их  после
завершения процедуры или функции.

|||/Синтаксис/|||

 LOCAL<string-var>|<num-var>{,<string-var>|<num-var>}

-----------------------------------------------------------------

|||/LOMEM/|||

/Назначение/

 Различные  области  памяти  компьютера используются  для  разных
целей. Обычно |||BASIC||| самостоятельно  решает где ему хранить числа,
которые пользователь называет X,Y и т.д. Он хранит эти переменные
в памяти, непосредственно за программой  пользователя.  Вы можете
изменить  место,  с  которого  он  начинает размещать переменные,
изменив  значение  псевдо-переменной  |||LOMEM|||, но это  должно  быть
сделано в самом начале программы.

 Переменная  |||LOMEM|||  дает  адрес  в  памяти,  начиная  с  которого
компьютер  размещает все переменные, за  исключением  резидентных
переменных  % и от A% до Z%.

 |||LOMEM||| по умолчанию имеет такое  же  значение, как и |||TOP|||, которая
указывает  на  конец  программы  пользователя. Для дополнительной
информации смотри описание ключевого слова |||HIMEM||| и карту памяти в
приложении N?.

 Не  изменяйте значение |||LOMEM||| в  середине  программы.  Это  может
привести к тому, что |||BASIC||| не сможет найти переменные, которые Вы
использовали ранее.

/Примеры/
100 LOMEM=TOP+&100

PRINT LOMEM

PRINT ~LOMEM

/Замечание/  :  значек '|||~|||' указывает  компьютеру,  что  число  надо
напечатать в шестнадцатиричном виде.

|||/Описание/|||

 Псевдо-переменная, которая устанавливает место в памяти, начиная
с  которого  |||BASIC||| размещает динамические  переменные,  т.е.  те,
которые  создаются  и   уничтожаются  по  требованию.  Место  для
резидентных переменных выделяется  в  другом  участке  памяти. По
умолчанию  |||LOMEM|||  устанавливается  равным  |||TOP|||,  которая содержит
адрес  конца программы пользователя. Изменение |||LOMEM|||  в  середине
программы приводит к потере всех переменных.

|||/Синтаксис/|||

LOMEM=<numeric>
или
<num-var>=LOMEM

-----------------------------------------------------------------

|||/NEXT/|||

/Назначение/

 Используется  вместе  с  оператором |||FOR|||  для  организации  цикла
(выполнения группы операторов несколько раз подряд).
 Если цикл начинается с оператора, например

 FOR speed=10 TO 100

 то оператор |||NEXT||| обычно записывается в форме

 NEXT speed

 но слово |||speed||| не является обязательным.

/Пример/
340 X=0
350 FOR Y=0 TO 20
360 PRINT TAB(X,Y) "BBC Basic"
370 X=X+2
380 NEXT
─PE
|||/Описание/|||

 Оператор,  ограничивающий  цикл |||FOR...NEXT|||. Указание управляющей
переменной (X в последнем примере) не обязательно.
 Если переменная указана, то компьютер  начнет  выходить  из всех
циклов, внутренних, по отношению к указанному, до тех  пор,  пока
не  встретит  цикл  с  заданной  переменной. Если такого цикла не
окажется, то он выдаст сообщение об ошибке.

|||/Синтаксис/|||

NEXT[<num-var>],[<num-var>],...

-----------------------------------------------------------------

|||/OLD/|||

/Назначение/

 Для восстановления программы, которая только что была уничтожена
командой |||NEW||| или нажатием на  клавишу |||BREAK|||. Программа может быть
восстановлена лишь при условии, что  с  момента ее уничтожения не
было введено ни одной строки новой программы и не было создано ни
одной переменной. Если Вы получили сообщение |||Bad  program|||, то Вам
надо снова написать |||NEW|||.
 Использование  команды  |||NEW|||  или  клавишы   |||BREAK|||   в  некоторых
случаях  может привести к тому,  что  Вы  не  сможете  полностью
восстановить свою  программу  с помощью команды |||OLD|||. В частности,
если первая строка Вашей  программы  имела номер больше, чем 255,
то  при  восстановлении  одна строка программы  будет  испорчена.
Клавиша |||ESCAPE||| предоставляет удобный  способ остановки программы.
Использование  для  этого  клавиши  |||BREAK|||   не  желательно  и  не
безопасно.

/Пример/
OLD

|||/Описание/|||

Команда, ликвидирующая последствия команды |||NEW|||.

|||/Синтаксис/|||

OLD

-----------------------------------------------------------------

|||/ON/|||

/Назначение/

 Для изменения порядка выполнения программы  переходом на одну из
указанных   строк   в   зависимости  от   значения   определенной
переменной. Слово |||ON||| используется в  комбинации с тремя ключевыми
словами |||GOTO, GOSUB||| или |||ERROR|||. /Например/ :

ON value GOTO 800,920,100 ELSE 7300
ON result GOSUB 8000,8300,120,7600
ON ERROR GOTO 9000
ON ERROR GOSUB 2001

/Первый случай/
ON X GOTO 1100,1210,1450,1600,1950

 Если значение X равно 1,  то  программа  продолжит выполнение со
строки 1100. Если X=2, то со строки 1210.  Если X=3, то со строки
1450 и т.д.
 Для   чего   это  может  понадобиться?   Предположим,   что   Вы
подсчитываете  количество  монет,  опущенных  в   автомат   и   в
зависимости  от  числа монет хотите  предложить  различные  вещи.
Следующая программа иллюстрирует  каким  образом  |||ON  GOTO|||  может
помочь в этой ситуации.

450 REM " переменная COINS содержит число"
460 REМ " равное количеству опущенных монет"
500 ON COINS GOTO 550,600,650
550 PRINT "На одну монету можно купить пироженое"
560 REM "Дайте ему пироженое ..."
590 GOTO 1000
600 PRINT "На две монеты можно купить чай или кофе"
610 GOTO 1000
650 PRINT "На три монеты можно купить кусок пирога"
690 GOTO 1000
1000 REM "Здесь заканчиваются все программы"

/Второй случай/
ON X GOSUB 2200,2300,2400,2500

 |||ON|||, также, может использоваться совместно с оператором |||GOSUB|||.
|||ON X GOSUB||| предоставляет удобный  способ  использования различных
подпрограмм в различных ситуациях.
 В  конце структуры |||ON...GOTO||| и  |||ON...GOSUB|||  может  быть  указано
ключевое  слово   |||ELSE|||   (иначе),   что   позволяет  организовать
выполнение   соответствующих   действий   при   выходе   значения
управляющей переменной из указанного списка возможных значений.

/Третий случай/
ON ERROR GOTO
ON ERROR OFF

 Если компьютер обнаружит ошибку в вашей программе, или на диске,
или где-нибудь еще и не  сможет  с  ней  справиться, он генрирует
ошибку.  Другими  словами  он  сообщает об ошибке и остонавливает
программу. Сообщение об ошибке выводится  на экран, например, |||Too
big||| (Слишком большое).
 Иногда бывает необходимо, чтобы компьютер при обнаружении ошибки
предпринял  какие-нибудь  действия, а не  беспокоил  пользователя
своии сообщениями. Оператор  |||ON  ERROR GOTO 7000||| гарантирует, что
при  обнаружении ошибки компьютер не  остановиться  и  не  выдаст
сообщения  об   ошибке   на  экран.  Вместо  этого  он  продолжит
выполнение  программы  со  строки  |||7000|||  (в  данном  случае)  где
расположена часть  программы,  отвечающая  за вывод компьютера из
создавшейся   ситуации.   Например,  компьютер  может  предложить
пользователю изменить данные, которые привели к ошибке:
─CE          /пожалуйста, введите число поменьше/
─CE/или попытайтесь решить проблему как-нибудь по-другому./
 Насколько хорошо работает это 'исправление  ошибок', зависит  от
квалификации  программиста,  от  того  наколько  полно  он сумеет
предвидить  все  ситуации  в  которых  может произойти  ошибка  и
предусмотреть   соответствующее  поведение  компьютера  в  каждом
конкретном случае.
 Хорошая  обработка  ошибок очень важна  в  программах,  которыми
будут пользоваться не специалисты, т.е. большинство людей!
 Оператор  |||ON  ERROR  OFF|||  позволяет   компьютеру   снова  самому
обрабатывать ошибки, т.е. отменяет эффект |||ON ERROR GOTO|||.

/Примеры/
40 ON ERROR GOTO 9000
50 ON ERROR PRINT "Вы сломали компьютер!"
10 ON ERROR GOSUB 2000

|||/Описание/|||

 Оператор,  предоставляющий несколько вариантов изменения порядка
выполнения программы и возможность организовать обработку ошибок.

|||/Синтаксис/|||

ON<num-var>GOTO<numeric>{,<numeric>}[ELSE<statement>]
или
ON<num-var>GOSUB<numeric>{,<numeric>}[ELSE<statement>]
или
ON ERROR<оператор>
или
ON ERROR OFF

-----------------------------------------------------------------
[an error occurred while processing this directive]