Научно-исследовательская и производственная лаборатория
"ПРОГРАМНО ОСИГУРЯВАНЕ"
София
----------------------------------------------------------------
ПЕРСОНАЛЬНЫЙ МИКРОКОМПЬЮТЕР
ПЫЛДИН 601 / 601-У / 601-А / 601-М
ЯЗЫК ПРОГРАММИРОВАНИЯ
UniBASIC
версия 1.00
Р У К О В О Д С Т В О П О Л Ь З О В А Т Е Л Я
редакция 2
София - 1991
Copyright (с) 1990 НИПЛ"Програмно осигуряване", София, Болгария
UniDOS, UniBIOS и UniBASIC являются регистрированными торговыми
марками и наименованиями НИПЛ "Програмно осигуряване".
"Пылдин" является регистрированной торговой маркой и
наименованием Содружества "АБАКУС", Болгария.
Настоящий документ, как и любая его часть, не может быть
копирован, передан или включен в информационно-поисковые системы каким
либо способом без предварительного письменного согласия со стороны
НИПЛ "Програмно осигуряване".
Все права на программный продукт, как и на любую его часть,
сохранены. НИПЛ "Програмно осигуряване" не несет ответственности за
работоспособность программного продукта в случаях его
нерегламентированной перезаписи или пользования.
Программный дизаин и реализация: Тодор Тодоров
Авторы документа: Недялко Тодоров
Консультанты: Орлин Шопов, Иво Ненов, Георги Петров
Предтипографическая подготовка: Иво Ненов
НИПЛ "Програмно осигуряване" благодарит каждого, кто вышлет свои
замечания, рекомендации и деловые предложения по адресу:
Болгария 1113 София,
бульвар "Ленин" - 125
Студенски общежития блок 1
НИПЛ"Програмно осигуряване"
---------------------------
phone/fax: (3592) 706248
С О Д Е Р Ж А Н И Е
1. ДОБРО ПОЖАЛОВАТЬ ...
1.1. Числа, числа ...
1.2. Алгоритмы, команды ...
1.3. Память компьютера ...
1.4. Кстати о математике! Постоянные, переменные ...
1.5. О буквах ...
1.6. Ваша клавиатура
1.7. Ваш дисплей
2. ЧТО ТАКОЕ UniBASIC
3. И ТАК, ВКЛЮЧАЕМ
3.1. У Вас есть дисковод
3.2. У Вас нет дисковода
4. ПЕРВАЯ КОМАНДА UniBASIC-а - КАК ОТСЮДА ВЫЙТИ ?
5. ПЕРВЫЕ ПРОГРАММЫ
5.1. NEW - очистить рабочее поле
5.2. PRINT - вывод результата;
TAB - вывод с определенной позиции
5.3 LPRINT - вывод на печатающее устройство
5.4. LET - присвоение значения
5.5. RUN - выполнить текущую программу
5.6. SCREEN - очистка экрана
5.7. LIST - вывод на экран содержания программы
LLIST - вывод на печатающее устройство содержания
программы
5.8. EDIT - редактирование строки программы
5.9. DEL - стирание фрагмента программы
5.10.REM - комментарий в рамках программы
5.11.INPUT - ввод значения переменной
5.12.LINE INPUT - ввод экранной строки в качестве значения
переменной
5.13.LOCATE - установление курсора
5.14.AUTO - автоматическая номерация строк
6. БОЛЕЕ СЛОЖНЫЕ ПРОГРАММЫ
6.1. GOTO - нарушение естественного порядка
6.2. IF - переход по условию
6.3. Циклы (петли)
6.3.1. FOR - NEXT - цикл по счетчику
6.3.2. REPEAT - UNTIL - цикл по условию
6.4. GOSUB - RETURN - подпрограммы;
END - конец программы
6.5. DIM - массивы
ERASE - стирание массивов
6.6. DATA, READ, RESTORE - данные в программе
6.7. WRITE - вывод значений переменных
6.8. CLEAR - стирание всех переменных
6.9. SWAP - обмен значениями переменных
7. ОТЛАДКА ПРОГРАММ
7.1. TRON - TROFF - трассировка программ
7.2. STOP - временное прерывание программы;
CONT - восстановление выполнения
8. РЕАКЦИЯ НА ВОЗНИКШУЮ СИТУАЦИЮ
8.1. ONERR - RESUME - реакция на ошибку
8.2. ON - GOTO - переход при возникновении ситуации
ON - GOSUB
9. РАБОТА С ФАЙЛАМИ
9.1. SAVE - LOAD - MERGE - записать и загрузить программу
9.2. BSAVE - BLOAD - запись - загрузка содержания памяти
9.3. OPEN - CLOSE - открытие - закрытие файла
9.4. PRINT# - WRITE# - INPUT# - INPUT$ - LIST# - запись -
чтение файла
9.5. SEEK - позиционирование в файле
9.6. STORE - RECALL - бинарная запись/ввод массива
9.7. PR# - IN# - переопределение стандартных устройств
ввода/вывода
10. НЕПОСРЕДСТВЕННЫЙ ДОСТУП К ПАМЯТИ КОМПЬЮТЕРА
10.1. Распределение памяти
LOMEM: - HIMEM: - границы свободной памяти
10.2. PEEK - DEEK - чтение байта и слова памяти
10.3. POKE - DOKE - запись байта и слова в память
11. ВСТРОЕННЫЕ ФУНКЦИИ И СИСТЕМНЫЕ ПЕРЕМЕННЫЕ
11.1. Числовые функции
11.1.1. ABS - абсолютная величина
11.1.2. ADR - адрес
11.1.3. ASC - ASCII код
11.1.4. ATN - аркустангенс
11.1.5. COS - косинус
11.1.6. DEEK - содержимое слова памяти
11.1.7. EOF - достижение конца файла
11.1.8. EXP - экспонента
11.1.9. FIX - целая часть числа
11.1.10. FRAC- дробная часть числа
11.1.11. FRE - объем свободной памяти
11.1.12. INSTR - поиск подстроки в строке
11.1.13. INT - целое число
11.1.14. LEN - длина строки
11.1.15. LOC - текущая позиция в файле
11.1.16. LOF - номер последней позиции в файле
11.1.17. LOG или LN - натуральный логарифм
11.1.18 PEEK - содержимое байта памяти
11.1.19. POS - позиция курсора в строке
11.1.20. RND - случайное число
11.1.21. SGN - знак числа
11.1.22. SIN - синус
11.1.23. SPC - вывод символов перед выводом значения
11.1.24. SQR - корень квадратный
11.1.25. TAN - тангенс
11.1.26. USR - потребительская функция на ассемблере
11.1.27. VAL - превращение строки цифер в число
11.2. Строчные функции
11.2.1. CHR$ - символ с заданным кодом
11.2.2. HEX$ - превращение в шестнадцатеричную форму
записи
11.2.3. LEFT$ - левая подстрока строки
11.2.4. MID$ - подстрока строки
11.2.5. RIGHT$ - правя подстрока строки
11.2.6. SPC$ - генерирование строки одинаковых символов
11.2.7. STR$ - десятичная форма записи числа
11.3. Системные переменные
11.3.1. CH - горизонтальная позиция курсора в текстовом
режиме
11.3.2. CV - вертикальная позиция курсора в текстовом
режиме
11.3.3. DATE$ - системная дата
11.3.4. ERR - код ошибки
11.3.5. ERRLN - строка ошибки
11.3.6. GH - горизонтальная позиция курсора в
графическом режиме
11.3.7. GV - вертикальная позиция курсора в графическом
режиме
11.3.8. KEY$ - нажатая клавиша
11.3.9. LA - адрес загрузки файла при последней
выполненной команде BLOAD
11.3.10. LL - длина файла при последней
выполненной команде BLOAD
11.3.11. PI - число "пи"
11.3.12. TIME$ - системное время
12. ОПРЕДЕЛЕНИЯ
12.1. DEFKEY - программирование функциональных клавиш
12.2. DEFFN - определение потребительской функции,
запрограммированной на UniBASIC-е
FN - применение потребительской функции
12.3. DEFUSR - определение потребительской функции,
запрограммированной на ассемблере
12.4. DEF& - определение указателя памяти
& - применение указателя памяти
13. В МИРЕ ЦВЕТА, ГРАФИКИ И МУЗЫКИ
13.1. SCREEN - переключение режимов изображения
13.2. COLOR - определение цветов изображения текста в
текстовом или графическом режиме
13.3. PEN - определение цвета и вида линии в графическом
режиме
13.4. LINE - изображение линии
13.5. POINT - изображение точки
13.6 MOVETO - перемещение графического курсора
13.7. CIRCLE - изображение элипсы
13.8. DISC - изображение диска (заполненной элипсы)
13.9. BAR - изображение прямоуголника
13.10. DRAW - изображение потребительского символа
13.11. SOUND - возпроизводство звука
13.12. PLAY - возпроизводство мелодии
14. СВЯЗЬ С ОКРУЖАЮЩИМ МИРОМ
14.1. SHELL - выполнение команды операционной системе
UniDOS
14.2. MON - вызов системной программы MONITOR
14.3. CALL - передача управления по заданному адресу
Приложение A - формальное описание команд, операторов и
встроенных функций
Приложение B - зарезервированные слова UniBASIC-а
Приложение C - диагностические сообщения
1. ДОБРО ПОЖАЛОВАТЬ В МИРЕ МИКРОКОМПЬЮТЕРА "ПЫЛДИН"
Поздравляем Вас с приобретением нового микрокомпьютера,
сочетающего низкую цену и малые габариты 8-битовых машин с широкими
функциональными возможностями и богатством базового программного
обеспечения 16-битовых компьютеров. Напомним, что "Пылдин" совместим
по данным с IBM-PC, а операционная система "Пылдина" - UniDOS -
является функциональным аналогом операционной системы MS DOS.
Настоящее руководство пользователя программного продукта UniBASIC
предназначено для людей, делающих первые шаги в увлекательном мире
компьютерной техники и ее применений. Более искушенным рекомендуем
пропустить настоящую главу, в которой даны самые основные сведения о
компьютерах и программировании и введены самые основные понятия. Если
у Вас есть опыт в программировании на языке BASIC, то Вы можете
перейти к приложению А, где дано формальное описание в алфавитном
порядке операторов и команд версии UniBASIC языка BASIC. В справочном
стиле написана и глава 11 - "Встроенные функции и системные
переменные". В приложении B приведены все зарезервированные слова
UniBASIC-а.
Читатель настоящего руководства не должен знать заранее никаких
особых секретов. Он должен просто ДЕЛАТЬ шаг за шагом то, что ему
рекомендуется. Как невозможно научиться кататься на велосипеде, сидя
в кресле перед камином, так НЕЛЬЗЯ НАУЧИТЬСЯ ПРОГРАММИРОВАТЬ, НЕ
РАБОТАЯ НА КОМПЬЮТЕРЕ. Мы надеемся, что компьютер "Пылдин" уже перед
Вами.
ВНИМАНИЕ ! Отметим одну особенность изложения. При формальном
описании языковых конструкции:
в угловых скобках < ... > - показаны обязательные элементы;
в квадратных скобках - [ ... ] - показаны необязательные
элементы;
в фигурных скобках { ... } перечислены альтернативные элементы -
можно применить один из перечисленных.
1.1. ЧИСЛА, ЧИСЛА ...
Прежде чем перейти дальше, откроем небольшую скобу и поговорим о
числах. В обычной жизни мы пользуемся десятичными числами. Их
значение вычисляется путем сложения произведений каждой цифры на 10 в
степени, соответствующей порядковому номеру (справо налево, считая с
нуля) цифры. Например, значение числа 123 вычисляется:
3 на 10 в степени 0 (= 3) плюс
2 на 10 в степени 1 (= 20) плюс
1 на 10 в степени 2 (=100) равно
сто двадцати трем
Самый правый разряд числа называется младшим, а самый левый -
старшим.
В вычислительных машинах применяется двоичная система счисления
(допустимы цифры 0 и 1). Вычисление значения числа производится
аналогичным образом. Например, число 1010(дв.) имеет значение: 1 на
8 плюс 0 на 4 плюс 1 на 2 плюс 0 равно десяти. Ниже приведена
маленкая таблица степеней двойки:
--------------------------------
2 в степени равно
--------------------------------
0 1
1 2
2 4
3 8
4 16
5 32
6 64
7 128
8 256
9 512
10 1024
11 2048
12 4096
Попытаемся записать десятичное число 1234 (одна тысяча двести
тридцать четыре) в двоичной системе.
1234 = 1*1024+0*512+0*256+1*128+1*64+0*32+1*16+0*8+0*4+1*2+0*1
или 1234 (десятичное) = 10011010010 (двоичное).
Здесь и далее символ "+" означает действие "сложение", а символ
"*" - действие "умножение".
Как видно, запись в двоичной системе очень громоздка и трудно
читаема (человеком, но очень легко - компьютером). Поэтому в ряде
случаев применяется запись чисел в системе с основанием 16 (в
шестнадцатеричной системе). В этой системе кроме привычных цифр с 0
до 9 применяются ЦИФРЫ А (=10), В (=11), С (=12), D (=13), E (=14) и F
(=15). Посмотрите на следующую таблицу.
----------------------------------------------------
десятичная двоичная шестнадцатеричная
запись запись запись
----------------------------------------------------
0 0 0
1 1 1
2 10 2
4 100 4
8 1000 8
10 1010 A
11 1011 B
12 1100 C
13 1101 D
14 1110 E
15 1111 F
16 10000 10
32 100000 20
64 1000000 40
128 10000000 80
256 100000000 100
512 1000000000 200
1024 10000000000 400
4077 111111101101 FED
Очевидно, что шестнадцатеричная запись очень компактна и, кроме
того, очень легко переводить шестнадцатеричные числа в двоичные и
наоборот. Для этого необходимо заменить каждую шестнадцатеричную
цифру ее двоичной записью или каждую четверку двоичной записи (справа
налево, самую левую четверку дополнить слева нулями) ее
шестнадцатеричным эквивалентом. Для примера посмотрите на последную
строку таблицы:
1111 1110 1101 = FED
F E D
Попробуем с числом ABC -> A = 1010
B = 1011
C = 1100
Или АВС = 101010111100.
Постарайтесь записать в десятичной системе число FFFF.
Правильно, FFFF = 65535.
ВНИМАНИЕ ! В UniBASIC-е шестнадцатеричные числа предшествуются
символом "$". Например, $1000 воспринимается в качестве
шестнадцатеричного числа.
Не пугайтесь - Вам очень, очень редко будет приходиться считать в
недесятичных системах счисления!
1.2. АЛГОРИТМЫ, КОМАНДЫ ...
Сразу заметим, что слово "компьютер" чаще всего применяется в
качестве сокращения словосочетания "компьютерная (вычислительная)
СИСТЕМА". Система состоит из двух основных частей: технических
устройств - ХАРДВЕР (Hardware) и программного обеспечения - СОФТВЕР
(Software). В любом русско-английском словаре в качестве первого
значения слова Hardware указано "скобяные товары". В данном случае
слово технического жаргона отражает самую суть вещей - без
программного обеспечения технические устройства компьютерной техники
являются мертвым "железом".
Компьютерная система предназначена для обработки некоторых данных
по определенному алгоритму. Здесь и далее мы не претендуем на
математическую полноту и точность определений, а ссылаемся на
общепринятые, будничные понятия. С этой точки зрения алгоритм
является последовательностью действий для достижения определенной
цели. Например, допустим, что перед Вами термос с кофе и кофейная
чашка и Вам хочется выпить чашку кофе (злоупотребление кофепитием -
профессиональное "заболевание" программистов). Алгоритм достижения
цели может иметь следующий вид:
1. Протянуть левую руку и захватить корпус термоса;
2. Протянуть правую руку и захватить крышку термоса;
3. Открутить крышку и положить ее на стол;
4. Захватить чашку правой рукой и приподнести к термосу;
5. Наклонить термос к чашке и вылить из него в чашку примерно
одну столовую ложку кофе;
6. Повторять действие 5. пока чашка не наполнится на 4/5
своего объема.
7. Поставить термос на стол;
8. Приподнести чашку к рту;
... и т.д. и т.д.
Простая вещь - выпить кофе, а какой алгоритм! Обсудим этот
алгоритм поподробнее и постараемся ответить на несколько из множества
вопросов, которые наверняка у Вас возникли.
1. А что, если человек, жаждущий кофе, левша? Где находятся
термос и чашка и можно ли их достичь простым протягиванием рук? Сразу
видно - каждый конкретный алгоритм учитывает конкретные ИСХОДНЫЕ
УСЛОВИЯ, выраженные ДАННЫМИ.
2. А что, если крышка термоса не откручивается, а вынимается? А
что, если в термосе нет кофе вообще, или есть, но мало - меньше 4/5
объема чашки?
Если попытаемся учесть первый вопрос, то пункт 3 нашего алгоритма
приобретет вид:
- проверить тип крышки. ЕСЛИ винтовая - ТО открутить, ИНАЧЕ -
вынуть.
Таким образом алгоритм не всегда имеет линейный вид. Очень часто
необходимо проверить некоторое условие и в зависимости от результата -
идти по одному или другому пути.
3. Вы, наверное, обратили внимание на пункт 6 - ПОВТОРЯТЬ
действие ПОКА не наступит некоторое событие (наполнение чашки).
Конечно, конструкцию типа ПОВТОРЯТЬ ПОКА можно заменить конструкцией
ЕСЛИ событие наступило, то ПЕРЕЙТИ НА действие Х алгоритма, ИНАЧЕ
ПЕРЕЙТИ НА действие Y. Участки алгоритмов, подобные описанному
называются "циклами". В данном случае имеем "цикл по условию"
("ПОВТОРЯТЬ ПОКА").
А как можно описать алгоритм прохождения 5 шагов? Наверно так:
установить СЧЕТЧИК шагов в 0; Повторять пока СЧЕТЧИК шагов меньше 5:
(сделать шаг; увеличить значение СЧЕТЧИКА на единицу). Цикл такого
рода можно назвать "циклом по счетчику".
Очевидно, один цикл можно выразить средствами другого, а оба
цикла - средствами конструкции ЕСЛИ - ТО - ИНАЧЕ. Но в разных случаях
удобнее пользоваться одной или другой конструкцией.
И самое, наверное, главное замечание - алгоритм может быть описан
на разных уровнях уточнения необходимых действий: от самого общего -
"налить и выпить" - до самого подробного - "расправить первую фалангу
указательного пальца на 13°, вторую на 24°, третюю - на 40°" и т.д. и
т.п. Уровень подробности описания зависит от того ЧТО ПОНИМАЕТ
ИСПОЛНИТЕЛЬ КОМАНДЫ. Команды должны подаваться так, чтобы их можно
было понять и выполнить. Существует и другой подход - повтаряющаяся
часть алгоритма (например, НАЙТИ, ПРОТЯНУТЬ руку, РАЗЖАТЬ пальцы,
ОХВАТИТЬ пальцами что-то, ЗАЖАТЬ пальцы и т.д.) выделить из общего
алгоритма, дать этой части имя (например, ЗАХВАТИТЬ), и применять в
алгоритме только имя подалгоритма, понимая, что за ним подразумевается
целый ряд действий.
И так, для выполнения алгоритма (для достижения цели) необходимо:
- выразить алгоритм последовательностью КОМАНД
(последовательность команд будем называть ПРОГРАММОЙ) на определенном
ЯЗЫКЕ и некоторой совокупностью ДАННЫХ;
- иметь некоторое устройство, где можно записать команды и данные
- такое устройство называется ПАМЯТЬ;
- иметь устройство, которое выполняет команды понимая их,
анализируя данные, принимая решений и отдавая, в свою очередь,
внутренные команды другим, исполнительным устройствам;
- иметь исполнительные устройства, устройства связи с окружающим
миром (в том числе, связи с человеком - доложить как протекает
выполнение алгоритма и какие результаты достигнуты).
Вернемся к нашему компьютеру. Он имеет все необходимые
устройства:
- центральный блок, в котором находятся арифметико-логическое
устройство (т.н. ПРОЦЕССОР) и электронная ПАМЯТЬ;
- периферийные устройства (устройства ввода/вывода). В самой
простой конфигурации Ваш компьютер "Пылдин" имеет две такие
устройства: клавиатура (устройство ввода) и дисплей (устройство
вывода).
1.3. ПАМЯТЬ КОМПЬЮТЕРА
Количество информации, содержащейся в одном одноразрядном
двоичном числе, равняется одному БИТУ. Т.е. "бит" - это единица
измерения количества информации и, соответственно, измерения объема
памяти. В компьютерных науках очень часто, по аналогии, каждый разряд
двоичного числа называется битом. В многоразрядных числах биты
считаются (номерируются) справо налево (с младшего к старшему биту).
8 битов составляют один БАЙТ. 1024 байта составляют один КИЛОБАЙТ
(КВ). Байт и килобайт - единицы измерения объема памяти.
Память компьютера можно себе представить в виде
последовательности ячеек, каждая из которых содержит один байт (одно
восьмиразрядное двоичное число). Порядковый номер ячейки (начиная с
номером 0000) называется АДРЕСОМ ячейки. Обычно адреса представлены в
шестнадцатеричной системе. Память "Пылдина" имеет обем 64 килобайта
(65536 ячеек). Адреса ячеек с $0000 до $FFFF. Содержимое каждой
ячейки может являться как данной (частью данной), так и командой
(частью команды).
Память, о которой до сих пор говорили, называется ОПЕРАТИВНОЙ,
потому что ее содержание меняется в процессе работы компьютера. Очень
распространено для обозначения такой памяти английское сокращение RAM
(Random Access Memory - память случайного (произвольного) доступа).
Кроме нее, компьютер "Пылдин" имеет и память другого типа - память
только для чтения (ROM - Read Only Memory). Как следует из названия -
в процессе работы можно только читать записанное в такой памяти.
Поэтому в ROM-е записываются наиболее важные программы, которыми
пользуется широкий круг потребителей. Вероятнее всего и программа
UniBASIC записана на ROM-е. Объем ROM-а "Пылдина" может достигать до
64КB.
1.4. КСТАТИ О МАТЕМАТИКЕ! ПОСТОЯННЫЕ, ПЕРЕМЕННЫЕ ...
Увы, как бы нам не хотелось, но пришлось все таки столкнуться с
математикой! Не будем забывать, что слово "компьютер" в своем первом
значении означает "вычислитель". Так что совсем без математики не
обойтись.
Кстати о математике! Мы уже столкнулись с двумя математическими
действиями, а точнее - арифметическими: умножение и сложение. С
точки зрения программирования правильнее их называть математическими
ОПЕРАЦИЯМИ. Поговорим немного о арифметических операциях.
Как смотрите на ВЫРАЖЕНИЕ Z = X * Y ? Правильно, это в обыходе
выражается так: Z равно X, умноженному на Y. С точки зрения
компьютера это выгладить чуть иначе: X умножить на Y и полученное
ЗНАЧЕНИЕ присвоить Z. Иными словами, компьютер сначала совершает
действие справа от знака "=" (знак ПРИСВАИВАНИЯ) и полученное значение
присваивает ПЕРЕМЕННОЙ слева от знака "=". Т.е. в данном случае
через "=" обозначили ОПЕРАЦИЮ ПРИСВАИВАНИЯ. Пока только отметим, что
выражение "Z = X * Y" можно встретить и в другом контексте - "ЕСЛИ Z =
X * Y ТО ...". В этом случае знаком "=" отметили ОТНОШЕНИЕ РАВЕНСТВА
(ЭКВИВАЛЕНТНОСТИ).
В обоих случаях "Z" - это ИМЯ чего-то (вероятнее всего - имя
ЧИСЛА), что может ПОЛУЧАТЬ РАЗНЫЕ ЗНАЧЕНИЯ (или иначе - МЕНЯТЬ СВОИ
ЗНАЧЕНИЯ). Поэтому называется ПЕРЕМЕННОЙ.
ВНИМАНИЕ !!! Всегда следует отличать ИМЯ переменной от ее
ЗНАЧЕНИЯ!
Теперь остановимся коротко на некоторые особенности работы с
"нормальными" (для нас) десятичными числами. Несмотря на то, что
компьютер - это прежде всего "вычислитель", его возможности
ограничены. Он может (в случае работы на языке BASIC версии UniBASIC)
обрабатывать ТОЛЬКО СЕМЬ ЗНАЧУЩИХ ЦИФР числа. Т.е. максимальное
ЦЕЛОЕ число, которое мы можем ввести в компьютер в качестве значения
реальной переменной, равно 9999999, а минимальное -9999999. UniBASIC
различает два вида чисел (и два вида числовых переменных,
соответственно): целые и реальные. Реальные числа имеют две ФОРМЫ
ПРЕДСТАВЛЕНИЯ: натуральная и экспоненциальная. Пример натуральной
формы записи: 1234.56 .
ЗАПОМНИТЕ ! При работе с компьютером применяется десятичная
точка, а не запятая! Изображается только знак "-", если число
отрицательное. Если число положительное - знак не изображается.
Экспоненциальная форма записи строится путем пересчета заданного
числа в виде произведения реального числа (называемого МАНТИСОЙ) на
десять в степени xx, где xx - двухразрядное ЦЕЛОЕ число (называемое
ХАРАКТЕРИСТИКОЙ). Форма записи имеет вид:
mE±xx
где: m - мантиса; x -характеристика.
Мантиса может содержать до 7 значущих разрядов (не считая знак
"-", если число отрицательное, и десятичную точку) , а характеристика
должна находится в интервале от - 38 до + 37. Таким образом, 9.999999
E-38 является наименьшим положительным числом, с которым работает
компьютер, а 9.999999 Е+38 - наибольшим. Например. число 1234.56 в
экспоненциальной форме записи будет выглядить так: 0.123456 E+04.
Если число по абсолютной стоимости меньше 0.01, то оно представляется
только в экспоненциальной форме.
В качестве имени может быть использована любая комбинация
латынских букв, цифр и символа "_", которая начинается буквой.
Например: my_variable, summa, salary. Рекомендуем применять т.н.
"говорящие имена", а не случайные комбинации. Теоретически число
символов в имени может быть до 255. Мы рекомендуем пользоваться
относительно короткими именами - до 12 - 15 символов. Однако,
UniBASIC различает имена ТОЛЬКО ПО ПЕРВЫМ ДВУМ СИМВОЛАМ. Например,
переменная с именем summa и переменная с именем su для UniBASIC одно и
тоже.
Для обозначения ТИПА переменной применяется т.н. "окончание" -
последний символ имени. ИМЕНА ЦЕЛОЧИСЛЕННЫХ ПЕРЕМЕННЫХ ДОЛЖНЫ ИМЕТЬ
ОКОНЧАНИЕ "%", А ИМЕНА СИМВОЛНЫХ ПЕРЕМЕННЫХ (см. ниже "О буквах")
ДОЛЖНЫ ИМЕТЬ ОКОНЧАНИЕ "$" (долларовый знак). Естественночисленные
переменные не имеют специального окончания. Символы окончания не
входят в ограничение различимости по первым двум символам (не
считаются частью имени). Например, s, s$ и ss$ - различимые имена.
Имена su и summa, а также su$ и summa$ - неразличимы, но su и su$ -
разные имена.
ВНИМАНИЕ !!! В КАЧЕСТВЕ ИМЕН НЕЛЬЗЯ ПРИМЕНЯТЬ НЕКОТОРЫЕ
АНГЛИЙСКИЕ СЛОВА И СОКРАЩЕНИЯ, ЯВЛЯЮЩИМИСЯ КОМАНДАМИ, ОПЕРАТОРАМИ ИЛИ
ИМЕНАМИ ВСТРОЕННЫХ ФУНКЦИЙ ЯЗЫКА. Например: IF, THEN, FOR, NEXT,
GOTO, PRINT и т.д. Эти слова называются "зарезервированными словами".
Полный перечень зарезервированных слов дан в приложениях.
Запишем новое выражение: Z = 3.14 * Y. Что такое "3.14"? Это
число, значение которого задано раз и навсегда, значение которого
ПОСТОЯННО. Такие числа называются "ПОСТОЯННЫМИ" или "КОНСТАНТАМИ".
Если переменная характеризуется именем и значением, то константа
характеризуется только значением. Оно, значение, применяется и в
качестве имени.
Вернемся к арифметическим операциям. Какие еще операции Вы
знаете? Наверняка: вычитание (отмечается знаком "-"), деление
(отмечается знаком "/"), возведение в степень (отмечается знаком "^").
Характерно для этих операций то, что они всегда связаны с двумя
ОПЕРАНДАМИ (переменными или константами). Поэтому они названы
ДВУХМЕСТНЫМИ ОПЕРАЦИЯМИ. А что скажете об операции "-Х" (минус Х)?
Она состоит в смену знака. Если Х было отрицательным числом, то
становится положительным, а если положительным - становится
отрицательным, сохраняя свое АБСОЛЮТНОЕ ЗНАЧЕНИЕ. Операция "смена
знака" - одноместная операция. Следует всегда отличать двухместное
"вычитание" от одноместной "смены знака".
Посчитайте, пожалуйста, значение выражения:
100 - 20 + 50 / 5 * 2
Правильно, 100, а не 52 ! Потому что, независимо от
последовательности написания операций, они выполняются в другом
порядке. Этот порядок называется ПРИОРИТЕТОМ операций. Только
операции с одинаковым приоритетом выполняются в порядке очереди.
Порядок выполнения операций можно изменить при помощи круглых скобок.
Например: 100 - (20 + 50) / 5 * 2 = 72.
Кроме указанных привычных арифметических операции, в языках
программирования, в том числе и в BASIC-е, применяются еще две
операции: целочисленное деление (знак операции - DIV) и определение
остатка деления (знак операции - MOD).
Результатом операции DIV является целая часть деления. Например,
результатом операции 22 / 5 является 4.4, результатом операции 22 DIV
5 является 4, а результатом операции 22 MOD 5 является 2. Очевидно,
что:
A MOD B = A - (A DIV B) * B
Кроме арифметических, компьютер выполняет и т.н. "логические"
операции. Логическими названы те операции, результат которых может
быть одно из значений: ИСТИННЫЙ - ЛОЖНЫЙ (TRUE - FALSE, или ДА - НЕТ,
или 1 - 0). В UniBASIC-е численные выражения (в частном случае -
переменные) имеют логическое значение FALSE, если их значение = 0, и
логическое значение TRUE, если их значение не равно 0. Строчные
выражение (переменные) имеют логическое значение FALSE, если длина
строки, являющейся значением выражения, равна 0 (пустая строка), и
логическое значение TRUE, если длина строки значения не равна 0 (не
пустая строка).
Наиболее разпространенной логической операцией является проверка
соблюдения отношения (СРАВНЕНИЕ). Например: Х МЕНЬШЕ Y. Компьютер
может проверить следующие отношения (в кавычках дан символ,
применяемый в программировании):
меньше "<"
меньше или равно "<=" или "=<"
равно "="
больше ">"
больше или равно ">=" или "=>"
неравно "<>" или "><"
Например, отношение 12 < 2 + 3 имеет значение 0 (FALSE),
отношение 12 >= 2 + 3 имеет значение 1 (TRUE).
Имеет смысл проверять отношения между переменными, значение
которых (текущее значение, значение в некоторый момент) заранее
неизвестно. Подумайте над замечанием 3 к нашему алгоритму в начале
главы.
В программировании применяются еще три логические операции (кроме
сравнения): ОТРИЦАНИЕ ( NOT ), ЛОГИЧЕСКОЕ И, или просто И, (AND) и
ВКЛЮЧАЮЩЕЕ ЛОГИЧЕСКОЕ ИЛИ, или просто ИЛИ (OR). Вообще говоря,
существует еще много логических операций, но доказано, что все они
могут быть заменены выражениями с применением этих трех операций. Для
удобства очень часто применяется и функция ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR).
Операция NOT аналогична операции "смена знака". Результат
операции обратен значению операнда. Например, NOT (12 > 10) имеет
значение FALSE, a NOT (12 < 10) имеет значение TRUE.
Результатом операции AND является значение TRUE тогда и только
тогда, когда оба операнда имеют значение TRUE. Иногда AND называют
"логическим сложением".
Результатом операции OR является значение TRUE тогда, когда хотя
один из операндов имеет значение TRUE. Иногда OR называют "логическим
вычитанием".
Результатом операции XOR является значение TRUE тогда, когда
ТОЛЬКО один из операндов имеет значение TRUE. Иногда XOR называют
"логическим умножением".
Результат логических операции принято демонстрировать при помощи
т.н. "таблиц истинности". Вот как выглядит таблица истинности для
AND, OR и XOR:
X | Y | X AND Y | X OR Y | X XOR Y |
------+--------+---------+--------+---------+
TRUE | TRUE | TRUE | TRUE | FALSE |
------+--------+---------+--------+---------+
TRUE | FALSE | FALSE | TRUE | TRUE |
------+--------+---------+--------+---------+
FALSE | TRUE | FALSE | TRUE | TRUE |
------+--------+---------+--------+---------+
FALSE | FALSE | FALSE | FALSE | FALSE |
Если Вас заинтересовали логические операции, попробуйте построить
таблицы истинности для логических операции:
NOT ( X AND Y ) и NOT ( X OR Y ).
Если таблицы построены правильно, Вы убедитесь в достоверности
следующих простых, но очень полезных правил преобразований:
NOT ( X AND Y ) = NOT X OR NOT Y
NOT ( X OR Y ) = NOT X AND NOT Y
X XOR Y = NOT(X AND Y) AND (X OR Y)
Общепринят следующий приоритет операций (от наиболее приоритетной
к наименее приоритетной):
1 приоритет: ( )
2 приоритет: "NOT", "-" (смена знака)
3 приоритет: "^"
4 приоритет: "*", "/", "DIV", "MOD"
5 приоритет: "+", "-"
6 приоритет: "<", "<=", "=", ">=", ">", "<>"
7 приоритет: "AND"
8 приоритет: "OR", "XOR"
1.5. О БУКВАХ ...
Кроме численных и логических переменных, констант и операций, в
программировании применяются еще "символные" или "строчные" константы,
переменные и операции. Они отличаются от уже нам известных тем, что
их значениями являются строки (последовательности) символов. Строка
символов - это последовательность символов, заключенная в кавычках.
Например, "А", "Аа", "АаБб". Строка символов может содержать от 0 до
255 символов. Да, да - может содержать 0 символов, т.е. быть пустой.
Например, "" - пустая строка. Но строка " " - непустая строка, она
содержит символ "пробел" (пустой символ, символ "шпация").
ВНИМАНИЕ ! Имена символных переменных должны заканчиваться на
долларовый знак "$". Например, Z$, A1@$ и т.п.
Как и числа, "внутри компьютера" символы представляются кодами
(двоичными цифрами). Все допустимые символы сравнимы путем сравнения
их кодов. Для букв коды возрастают в алфавитном порядке сначала
прописьных, а потом строчных букв (сначала латинского, а потом
кирилского алфавита). Для компьютера "У" меньше "Ф", "R" меньше "r" и
"z" меньше "б". Вот последовательность символов (отмеченных на
клавишах) в порядке возрастания их кодов:
пробел ! " # $ % & ' ( ) * + , - . /
0 1 2 3 4 5 6 7 8 9
: ; < = > ?
A B C D E F ... X Y Z
[ \ ] ^ _ `
a b c d e f ... x y z
{ | } ~
А Б В Г Д Е ... Э Ю Я
а б в г д е ... э ю я
При сравнении строк последовательно сравниваются очередные
символы до нахождения первого различия. Поэтому строка " А" меньше
строки "А ". Не путайте "больше" с "длиннее" и "меньше" с "короче".
Как догадались - символные константы и переменные имеют еще одну,
кроме имени и значения, характеристику - длина. Но об этом попозже!
При написании своих программ Вам, наверно, будет необходимо
воспользоваться "самой строчной" операцией со строками символов -
СЛИЯНИЕМ (КОНКАТЕНАЦИЕЙ) строк. Операция отмечается символом "+".
Например, если Х$ = "Привет, " и Y$ = "Петя!" и дадим команду
Z$ = X$ + Y$
то переменная Z$ будет иметь значение "Привет, Петя!".
1.6. ВАША КЛАВИАТУРА
Клавиатура микрокомпьютера Пылдин моделей 601, 601-У и 601-А -
квазисенсорная, с 77 клавишами, включая: 15 функциональных клавишей
(F1, F2 ... F15), 4 клавиши управления курсора (стрелки); специальные
клавиши Ctrl, Shift, Tab, Esc, Del, CapsLock, Lat/Кир, Enter и Res.
В зависимости от заказа клиента клавиши расположены согласно
требованиям болгарского стандарта БДС или советского стандарта ГОСТ
14289-69.
Для модели 601-А возможно включение внешней клавиатуры типа
используемых для 16-битовых персональных компьютеров, совместимых с
IBM PC/XT.
Компьютеры модели 601-М имеют только стандартную внешнюю
клавиатуру типа используемых для 16-битовых персональных компьютеров,
совместимых с IBM PC/XT.
Остановимся на предназначение специальных клавиш. Начнем с
самого важной клавиши - Enter.
Enter (Ввод) - клавиша возврата управления системой компьютеру.
ЗАПОМНИТЕ - любая команда, любая программная строка должна
заканчиваться нажатием клавиши Enter. Только тогда компьютер начинает
обрабатывать то, что Вы ему задали. До нажатия Enter Вы можете делать
любые изменения в написанном уже тексте.
Shift (Смена регистра) - при ненажатой клавиши Shift пользуются
символы "нижнего" регистра клавиатуры. Для буквенных клавиш - это
прописьные буквы, для символных клавиш - символы, обозначенные внизу
клавиш. При нажатой клавиши Shift применяются символы "верхнего"
регистра - прописные буквы и символы наверху символных клавиш.
Запомните - должны нажимать ОДНОВРЕМЕННО клавишу Shift и нужную Вам
буквенную или символную клавишу ! Т.е. Shift предназначена для
однократного включения верхнего регистра.
CapsLock предназначена для постоянного альтернативного
переключения регистров. Действие аналогично Shift с той разницей, что
регистр, на который переключились, остается активным до следующего
нажатия клавиши CapsLock.
Lat/Кир - клавиша альтернативного переключения латынских и
кирилских букв.
Del (Delete - стирание) - при нажатии клавиши стирается символ в
позиции курсора (мигающий символ, указывающий на текущую активную
позицию дисплея), если курсор находится не на последней введенной
позиции строки. Если курсор находится на последней введенной позиции,
стирается символ перед курсором и курсор продвигается на одну позицию
влево.
Tab (Tabulation - табуляция) - клавиши табуляции - переход на
следующую позицию табуляции. Как правило, позиции табуляции находятся
на восемь позиций одну после другой. При нажатии Tab курсор переходит
на следующую табуляторную позицию вправо от позиции курсора (если
такая существует), а при одновременном нажатии Shift-Tab - переход
осуществляется влево от позиции курсора.
Esc (Escape - побег, уход) - как правило, нажатие этой клавиши
приводит к прерыванию выполнения текущей программы.
Ctrl (Control - управление) - клавиша не имеет самостоятельного
значения. Но ее нажатие ОДНОВРЕМЕННО с нажатием другой клавиши
приводит к вводе т.н. "управляющего символа".
Res (Reset - повторный запуск, восстановление исходного
состояния) - эта клавиша примениятся когда нужно привести компьютер в
исходное состояние. Так как случайное нажатие этой клавиши чревато
неприятностями, при необходимости ее нужно нажимать одновременно с
клавишей Ctrl.
Функциональные клавиши предназначены для специальных целей -
например, для ввода одним нажатием целого слова или для выполнения
определенного действия. Значение функциональных клавиш определяется
конкретной действующей программой (могут остаться и без значения).
Принято говорить, что они программируемы. Функциональные клавише с
номерами от 13 до 15 имеют заранее заданное предназначение:
F13 - Home - перевод курсора в начало строки экрана.
F14 - End - перевод курсора в конец строки экрана.
F15 - Insert (Insert/Replace mode) - альтернативное переключение
режима ввода символов. В режиме Insert (Вставить) нововводимый символ
вставляется ПЕРЕД курсором, символ курсора и все следующие за ним
символы переносятся на одну позицию вправо. В режиме Replace (Замена)
нововводимый символ замещает символ курсора (замещает его на данной
позиции экрана). В каком режиме работает компьютер в данный момент
можно узнать по виду курсора. Если курсор имеет вид символа "_", то
компьютер работает в режиме замещения (Replace mode). Если курсор
имеет вид символа "-", то компьютер работает в режиме вставки (Insert
mode).
1.7. ВАШ ДИСПЛЕЙ
На дисплее "Пылдина" можно выводить как текстовую, так и
графическую информацию - т.е. компьютер может работать как в
текстовом, так и графическом режиме.
В текстовом режиме на экране дисплея можно вывести до 25 строк.
Строки номерируются (мысленно) сверху вниз. На каждой строке можно
вывести (в зависимости от модели компьютера и выбранного подрежима
текстового режима) 40 или 80 символов черно/белого или цветного
изображения. Позиции (колонки) строки номерируются (мысленно) слево
направо.
Доступны следующие текстовые режимы:
40*25 черно/белого изображения - модель "601","601-У"
80*25 черно/белого изображения - модель "601-А","601-М"
40*25 цветного изображения - модель "601-А","601-М"
Графические режимы определены максимальным числом отображаемых
точек на экране (считаются с верхнего левого угла экрана направо и
вниз):
- черно/белого изображения: 640 х 200 точек - "601-А","601-М"
320 х 200 точек - "601","601-У"
- цветного изображения: 320 х 200 т. в 4 цветах - "601-A","601-М"
160 х 200 т. в 4 цветах - "601","601-У"
160 х 200 т. в 16 цветах- "601A","601-М"
80 х 200 т. в 16 цветах- "601","601-У"
О способах переключения режимов рассказано ниже.
2. ЧТО ТАКОЕ UniBASIC ?
Как было сказано выше, компьютер обрабатывает двоичные числа,
часть которых интерпретирует в качестве команд, часть - в качестве
данных. Программы для первых компьютеров писались именно так - при
помощи двоичных чисел (машинных кодов). Это была тяжелейшая,
изнурительная высококвалифицированная работа с ужасяюще низкой
производительностью труда.
Первым шагом к облегчению труда программистов стало применение
т.н. ассемблеров или языков символического программирования. В этих
языках трудно запоминаемые двоичные коды команд были заменены
абревиатурами (символными командами). Например, А (от Addition) -
команда сложения, JMP (от Jump) - переход и т.д. т.п. С тех пор
начинается применение ЯЗЫКОВ ПРОГРАММИРОВАНИЯ. Ассемблеры были
названы языками низкого уровня, потому что они очень близки к машинным
командам и сильно зависят от конкретнего процессора, для которого были
предназначены.
В середине 50-тых годов началось развитие т.н. ЯЗЫКОВ
ПРОГРАММИРОВАНИЯ ВЫСОКОГО УРОВНЯ. Характерно для них то, что они
ориентированы скорее к решению определенного круга задач, чем к
определенному компьютеру. Примерами языков высокого уровня могут
служить FORTRAN, ALGOL, COBOL, PL/I, Pascal, Lisp, LOGO, ADA, PROLOG и
т.д. В качестве имени языка применяется или сокращение (абревиатура),
например FORmula TRANslation, или имя знаменитого ученого (например,
имя Блесса Паскаля). В настоящий момент относительно широкое
распространение получили несколько сот языков программирования
высокого уровня.
С применение языков программирования возникла необходимость
применения специальных программ - переводчиков, предназначение которых
перевести программы, написанные на языке программирования, на машинный
код определенного компьютера. Такие программы стали называть
ТРАНСЛЯТОРАМИ (от слова Translation - перевод). Отметим, что языки
оставались независимыми от компьютера, но каждый транслятор создавался
для определенного компьютера, а очень часто - для определенной модели.
Думаем, что ответ на вопрос "почему?" очевиден.
По своему действию трансляторы разделились на два большие класса:
ИНТЕРПРЕТАТОРЫ и КОМПИЛЯТОРЫ. Интерпретаторы "стремятся" обработать
(интерпретировать) и выполнить каждую введенную строку программы в
порядке следования. Компиляторы обрабатывают программу полностью,
иногда - несколько раз, и полностью переведенная на машинный код
программа начинает выполняться.
Каждый язык программирования имеет свое собственное развитие. На
определенном этапе этого развития принимались (официально или
негласно) некоторые СТАНДАРТЫ языка. Каждый относительно четко
сложившийся этап развития данного языка стал называться ВЕРСИЕЙ языка
или получал отдельное название, сохраняя связь с первоисточником.
Например, язык FORTRAN известен в своих версиях FORTRAN II, FORTRAN
III, FORTRAN IV, FORTRAN 60, FORTRAN 77 и т.д. Естественно, для
каждой версии языка созданы и создаются отдельные трансляторы. Даже
для одной машины существует несколько трансляторов. Например, для
языка Pascal для микрокомпьютеров фамилии IBM-PC очень широкое
разпространение получили трансляторы Turbo Pascal и MicroSoft Pascal.
Со своей стороны, каждый транслятор имеет свое собственное
развитие - свои ВЕРСИИ.
Создавая определенный транслятор, его авторы с учетом
возможностей компьютера, для которого транслятор предназначен, сужали
или расширяли соответствующий язык. Таким образом формировались т.н.
ДИАЛЕКТЫ языка. Поэтому сегодня одним именем обозначается
определенный транслятор и его диалект языка.
В 1965 году был создан язык программирования высокого уровня
BASIC (Beginner's All purpose Symbolic Instruction Code - многоцелевой
символический код инструкций для начинающих). Нам кажется, что имя
языка дает достаточное представление о его сущности. Отметим только,
что "для начинающих" не предопределяет ограничение возможностей, а
предназначение для людей, не имеющих большой предварительной
подготовки в области программирования.
По своему характеру транслятор UniBASIC - интерпретатор. Диалект
языка разработан на основе диалекта AppleSoft Basic (для компьютеров
фамилии Apple) и Microsoft Basic (для компьютеров фамилии IBM-PC).
При разработке учтены возможности микрокомпьютеров фамилии "Пылдин" и
их базовой системы ввода/вывода UniBIOS. Более опытным программистам
рекомендуем ознакомиться с документом "UniBIOS - Руководство
пользователя".
Настоящий документ - руководство пользователя интерпретатора и
диалекта UniBASIC языка BASIC. Далее одним именем будем обозначать
как программный продукт, так и соответствующий диалект языка.
UniBASIC распространяется в двух вариантах - на ROM-e и на гибком
магнитном диске (дискете). Оба варианта функционально вполне
эквивалентны. Все таки предпочтительнее работать с ROM-вариантом
продукта. Это обеспечить Вам больше свободной памяти для программ и
данных и повысит быстродействие. Кроме того, для применения
ROM-варианта нет необходимости наличия накопителя на дискетах в
конфигурации компьютера. Очевидно, выполнение команд и операторов
работы с дисковыми файлами возможно только при наличии накопителя.
Основными понятиями языка являются "команды", "операторы",
"функции (встроенные и потребительские)", "программы" и
"подпрограммы".
Командами называются конструкции языка, предназначенные, главным
образом, для управления действием самого интерпретатора. Например,
очистка (инициализация) рабочего поля памяти, загрузка программ с
внешнего носителя, ввод изменении в текущей программе и т.п.
Некоторые конструкции могут применяться как в качестве команд, так и в
качестве операторов.
Оператором называется языковая конструкция, предназначенная для
описания некоторого действия. Операторы, как правило, выполняются
только в рамках программы, в порядке передачи управления.
Программой называется последовательность операторов,
предназначенных в своей совокупности для реализации некоторого
алгоритма. Программа вводится в виде программных строк. Одна
программная строка может содержать один или более операторов. В
последнем случае операторы разделены знаком двоеточия ":". Операторы
обычно выполняются в порядке следования в программе. Этот порядок
может быть изменен специальными операторами безусловного и/или
условного перехода. Каждая программная строка должна начинаться
идентификатором строки - целое десятичное число не больше 63999.
Независимо от времени ввода, программые строки считаются
упорядоченными по возрастанию их идентификаторов. Поэтому рекомендуем
в качестве индентификаторов применять достаточно "отдаленные" числа -
например, через 10. Если строки некоторой последовательности имеют
идентификаторы 100, 110, 120, 130 и т.д., то при необходимости вставки
новой строки между строками, например, 110 и 120 достаточно ввести
строку с идентификатором 115, не меняя идентификаторы остальных строк.
Идентификатор строки должен быть отделен от первого оператора в строке
хотя-бы одним пробелом. Для начало выполнения программы необходим
ввод соответствующей команды.
Подпрограммой называется последовательность операторов,
описывающих некоторый подалгоритм (см. выше).
Функцией называется специально оформленная подпрограмма,
присваивающая некоторой переменной значение, являющееся функцией (в
математическом смысле слова) одного или более АРГУМЕНТОВ. Примером
могут служить тригонометрические функции: sin(x), cos(x) и т.д.
В UniBASIC-е предусмотрено множество ВСТРОЕННЫХ функций. Но
каждый пользователь имеет возможность описать свои собственные
ПОТРЕБИТЕЛЬСКИЕ функции.
При вводе очередной команды или оператора (в качестве команды - в
режиме НЕМЕДЛЕННОГО ВЫПОЛНЕНИЯ) интерпретатор анализирует сначала
СИНТАКСИС (правописание) и потом СЕМАНТИКУ (смысл) введенного. Если
обнаружены ошибки, то на экран выводиться ДИАГНОСТИЧЕСКОЕ СООБЩЕНИЕ и
выполнение прекращается. Аналогичные действия производятся с
операторами после ввода команды выполнения программы.
3. И ТАК, ВКЛЮЧАЕМ
Мы надеемся, что Вы узнали у Вашего поставчика какой компьютер (с
точки зрения наличия программного продукта UniBASIC) он Вам поставил.
Возможны следующие варианты:
а/ с UniBASIC-ом только на ROM-е;
б/ с UniBASIC-ом только на системной дискете;
в/ с UniBASIC-ом только на отдельной дискете;
г/ с UniBASIC-ом на ROM-е и на системной или отдельной
дискете.
Далее рассмотрим все эти случаи.
НАСТОЙЧИВО РЕКОМЕНДУЕМ включать устройства компьютера в следующем
порядке: дисплей, дисковод (если у Вас есть), компьютер.
Если у Вас есть дисковод, то заранее вставьте дискету с
операционной системой в первое (если у Вас двойной дисковод) дискетное
устройство (устройство А) и закройте крышку. Как можно узнать какое
устройство первое (А), а какое - второе (В) ? Очень просто - ничего
никуда не вставляя, включите компьютер. Первой загорится лампочка
первого устройства, потом - второго, и потом - снова первого.
3.1. У Вас есть дисковод
Тогда на экране дисплей появляется примерно следующее:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBASIC (R) Version 1.00
UniBIOS (R) Version 3.02
A:\>_
где символом "_" обозначен курсор компьютера.
Если приведенные выше сообщения появились на экране, это означает
что в Вашем компьютере поставлен ROM-чип с записью UniBASIC-а и
операционная система загружена правильно.
Откроем небольшую скобу. Символы в начале последней приведенной
выше строки называются "промптом". Как правило, промпт означает что
компьютер ожидает Вашу команду. Отдельные программные системы
используют разные символы или комбинации символов для промпта.
Операционная система UniDOS в качестве промпта использует логический
адрес текущего логического устройства (в случае - дискетное устройство
А:), имя текущей директории (в случае - главная директория "\") и
символ ">". Для ознакомления с операционной системой UniDOS
обратитесь к документу "UniDOS - Руководство пользователя".
В рассматриваемом случае для вызова UniBASIC-а достаточно ввести
следующую команду:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBASIC (R) Version 1.00
UniBIOS (R) Version 3.02
A:\>mon +
НЕ ЗАБЫВАЙТЕ ПОСЛЕ ВВОДА КОМАНДЫ НАЖИМАТЬ КЛАВИШУ Enter !
Дальше повтарять это правило не будем!
После выполнения команды вызова UniBASIC-а экран будет выглядеть
примерно так:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBASIC (R) Version 1.00
UniBIOS (R) Version 3.02
A:\>mon +
UniBASIC (R) Version 1.00
09-DEC-1990 10:12:33.14
32817 bytes free
]_
Новые сообщения означают что программа UniBASIC активна и в Вашем
распоряжении находятся 32817 байтов свободной памяти (для Ваших
программ и данных).
Символ "]" играет роль промпта UniBASIC. Вы можете приступить к
работе.
Если после включения компьютера на экране не появилось сообщение
"UniBASIC (R) Version 1.00", это означает что в Вашем компьютере не
вставлен ROM с UniBASIC-ом. Если предполагаете, что программный
продукт находится на системной дискете, введите команду "basic". Если
это действительно так, экран будет выглядеть следующим образом:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBIOS (R) Version 3.02
A:\>basic
UniBASIC (R) Version 1.00
09-DEC-1990 10:12:33.14
32817 bytes free
]_
Но может выглядеть и так:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBASIC (R) Version 1.00
UniBIOS (R) Version 3.02
A:\>basic
Bad command or file name.
A:\>_
Сообщение "Bad command or file name" ("Плохая команда или имя
файла") означает, что UniBASIC не находится на системной дискете.
Тогда должны заменить системную дискету дискетой с етикеткой UniBASIC
и снова ввести команду вызова программы. Что-бы узнать какие файлы
(программные и с данными) находятся на дискете, нужно ввести команду
"dir". Но все это подробно описано в документе "UniDOS - Руководство
пользователя".
3.2. У Вас нет дисковода
Если все остальное в порядке, экран должен выглядеть примерно
так:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBASIC (R) Version 1.00
UniBIOS (R) Version 3.02
UniBASIC (R) Version 1.00
09-DEC-1990 10:12:33.14
32817 bytes free
]_
Все в порядке и Вы можете работать дальше!
Если у Вас нет дисковода и на экране после включения компьютера
не появилось сообщение типа "UniBASIC (R) Version 1.00" - дела плохи!
Вы не можете работать на UniBASIC-е! Обратитесь к своему поставчику!
Если все в норме и программа UniBASIC активизировалась (появились
описанные выше сообщения и промпт), в 26 строке экрана появляется и
описание назначения функциональных клавиш. При нажатие какой-либо
клавиши будет введено соответствующее зарезервированное слово (начало
команды или оператора). Изза несоответствия экранной строки строке в
документе, сообщение показано в двух строках документа. На экране оно
расположено на одной (26) строке.
1=LIST 2=RUNL 3=LOAD" 4=SAVE" 5=CONTL
6=TRONL 7=TROFFL 8=SCREEN 9=EDIT 0=GOTO
Символ "F" наименований клавиш пропущен. Клавиша F10 обозначена
"0".
В UniBASIC-e функциональные клавиши F11 и F12 тоже имеют свое
предназначение (тоже запрограммированы), но их значение не выведено на
экране. F11 = "FOR ", а F12 = "NEXT ".
Значение функциональных клавиш может быть изменено (см.пункт 12).
4. ПЕРВАЯ КОМАНДА UniBASIC-а - КАК ОТСЮДА ВЫЙТИ ?
Первая команда UniBASIC-а, которую должны усвоить - это команда
выхода (конец действия) из программного продукта. Она имеет вид:
SYSTEM
После ее выполнения управление передается (как правило)
операционной системе.
Ваш экран должен выглядеть следующим образом:
--------------------------
Пылдин 601А
UniDOS (R) Kernel Version 3.11
UniBIOS (R) Version 3.02
A:\>basic
UniBASIC (R) Version 1.00
32817 bytes free
]system
A:\>_
5. ПЕРВЫЕ ПРОГРАММЫ
Ниже рассмотрим самые простые команды и операторы, при помощи
которых можно применять компьютер в качестве интеллигентного
калькулятора (в режиме немедленного выполнения) и написать
программы расчета.
5.1. NEW - очистить рабочее поле
После вызова UniBASIC-а рабочее поле памяти для программ и
данных чисто. Но не мешает начать командой очистки рабочего поля
NEW. При выполнении этой команды стирается текущая программа, если
она существовала, и нулируется рабочее поле. Выполнение команды не
имеет никаких видимых последствий. Попробуем:
]NEW
]
Рабочее поле очищено и все готово для Ваших будущих действий.
5.2. PRINT - вывод результата; TAB - вывод с определенной
позиции
Попробуйте ввести:
]PRINT 2
Как выглядит Ваш экран? Наверно так:
]PRINT 2
2
]
Простую команду, которую ввели, интерпретируется так:
"вывести на экран значение целочисленной константы 2".
Теперь введите:
]PRINT 2+3
Как выглядит Ваш экран? Наверно так:
]PRINT 2+3
5
]
Компьютер сложил число 2 и число 3 и вывел на экран результат
5. Попробуйте что-то более сложное. Например:
]PRINT 5*(2+3)-10/4/5
24.5
]
А теперь:
]PRINT 5*2+3-10/4/5
12.5
]
или:
]PRINT 5*2+(3-10)/4/5
9.35
]
Вспомнили правило последовательности выполнения
арифметических действий (приоритета)? Если нет, посмотрите пункт
1.4.
Введите:
]PRINT A
и получите:
]PRINT A
0
]
Почему? Потому что введенное интерпретируется так: "вывести
на экран значение переменной А". Так как имя переменной
встречается в первый раз, она имеет нулевое значение (помните - мы
очистили рабочее поле).
Но, если введено:
]PRINT "A"
то получится:
]PRINT "A"
A
]
потому что команда интерпретируется так: "вывести значение
строчной константы "А"". А как помните, значение и имя любой
константы совпадают.
Теперь попробуем написать маленькую программу на одной
строке.
]A=5*2 : B=(3-10)/4/5 : C=A+B : PRINT C
9.65
]PRINT A
10
]PRINT B
-0.35
]
Зарезервированное слово "PRINT" можно заменить символом "?".
Действия ]PRINT 2 и ]? 2 приведут к одинаковому результату.
Синтаксис команды/оператора PRINT имеет вид:
PRINT <список_выражений>
Списком называем последовательность (перечень) элементов,
разделенных разделительными символами. В данном случае такими
символами являются запятая и точка с запятой. Попробуйте
следующее:
]PRINT A,B,C
В качестве результата будет выведено:
10 -0.35 9.65
А теперь введите:
]PRINT A;B;C
и получите:
10-0.359.65
Запомните! Если выражения в списке оператора PRINT разделены
запятыми, для вывода каждого значения предусмотрено 15 позиции и
следующее значение выводится с 17-позиции с начала предидущего, а
если разделены точкой с запятой - значения выводятся
непосредственно одно за другим. Т.е. значения выражений,
разделенных запятыми, выводятся с позиций с номерами 1, 17, 33,
49, 65. Если длина значения превышает 15 символов, следующее
значение выводится с следующей (х * 16 + 1) позиции. В одном
списке можно применять оба разделителя. Например, результатом
]PRINT A;B,C
будет
10-0.35 9.65
Рассматриваемую нами однострочную программу можно заменить
одним оператором:
]PRINT 5*2 , (3-10)/4/5 , A+B
Соответствующий разделитель можно применить и в конце списка.
Если в конце не введено ничего или введена запятая, автоматически
генерируется сигнал перехода на новую строку. Если введена точка с
запятой - сигнал не генерируется и вывод в результате следующего в
программе оператора PRINT будет осуществлен непосредственно за
последным выводом. Например:
]PRINT "AAAAAA" : PRINT "BBBBBB"
AAAAAA
BBBBBB
]
]PRINT "AAAAAA"; : PRINT "BBBBBB"
AAAAAABBBBBB
]
Если некоторый элемент списка имеет собственный разделитель
(например, специальные окончания % и $, кавычка в качестве
разделителя строки, скобка в качестве разделителя элемента массива
и т.п.), можно не применять разделитель списка вывода и по
умолчанию вводится разделитель ";". Например, если А$ = "ABCD" и
B$ = "EFGH" то:
]PRINT A$B$
ABCDEFGH
]PRINT A$"+"B$
ABCD+EFGH
При выводе значений можно указать точную позицию в строке, с
которой начинается вывод. Это осуществляется при помощи функции
табуляции в виде:
TAB(<выражение>)
где значение выражения определяет позицию, с которой
начинается вывод. Пример:
]PRINT TAB(10)"с 10-той позиции"
с 10-той позиции
]
Если указанная при помощи TAB(x) позиция левее текущей,
курсор не продвигается. Например:
]PRINT "ABCDEFG",TAB(3);"абвгд"
ABCDEFGабвгд
Если указанная при помощи TAB(x) позиция выходит за рамки
экрана, курсор продвигается на следующую строку в соответствующую
позицию (условно одна строка считается продолжением предидущей).
Например:
]PRINT "ABCDEFG",TAB(85);"абвгд"
ABCDEFG
абвгд
]
Оператор PRINT позволяет выводить значений выражений и в файл
на внешнем накопителе. Но об этом поговорим попозже (см. "Работа с
файлами")
5.3 LPRINT - вывод на печатающее устройство
Оператор LPRINT интерпретируется аналогично оператору PRINT с
той разницей, что недопустимо применение функции TAB(x) и
разделителя ",".
5.4. LET - присвоение значения
В примере однострочной программы Вы уже применили оператор
присвоения значения: A=B+C. Для полноты изложения отметим, что
полная форма оператора имеет вид:
[ LET ] <имя_переменной> = <выражение>
Применение зарезервиронного слова LET не обязательно!
5.5. RUN - выполнить текущую программу
Разнообразим однострочную программу предидущего пункта и
запишем в виде нормальной программы. Например:
]10 A=5*2
]20 B=(3-10)/4/5
]30 C=A+B
]40 PRINT "Результатом действий 5*2+(3-10)/4/5 является ";C
Нажали на клавишу Enter? Что получилось? Ничего особенного -
появился промпт UniBASIC-а. Почему? Потому что программа введена,
но ее выполнение не началось.
Для выполнения программы необходимо ввести команду выполнения
программы RUN. Попробуйте:
]RUN
Результатом действий 5*2+(3-10)/4/5 является 9.65
]
Если после команды RUN указан идентификатор строки,
выполнение программы начинается с этой строки. Например:
]NEW
]10 A=5*2
]20 B=(3-10)/4/5
]30 C=A+B
]40 PRINT C
]RUN 20
-0.35
]
Почему? Первая строка программы не выполнена и переменная А
осталась с нулевым значением.
Применение команды RUN может привести к загрузке и выполнении
программы, записанной во внешнем (на дискете) файле (см. команды
SAVE и LOAD - пункт 9.1). Для этого необходимо после команды
ввести имя файла в кавычках. Например:
RUN "prog_1"
ВНИМАНИЕ ! Указанная в команде RUN программа полностью
заменит находящуюся в памяти программу.
Имя вызываемой программы может являться и значением строчной
переменной. Например, можем ввести:
]p$="prog_1"
]run p$
5.6. SCREEN - очистка экрана
При последовательном вводе команд или немедленно выполнимых
операторов курсор последовательно переходит на следующую строку.
При достижении последней применимой строки (25), очередные
результаты выводятся в этой строке и содержание экрана
передигается на одну строку вверх и содержание первой строки
теряется (скрол экрана).
Очень часто возникает необходимость очистить экран полностью.
Это действие осуществляется при помощи команды SCREEN.
Курсор появляется в верхнем левом углу экрана.
Эффект "очистки" экрана получается и при выполнении
оператора:
]PRINT CHR$(12)
Функция CHR$(x) описана в 11.2.1.
При помощи команды SCREEN могут быть выполнены и другие
действия. Об этом рассказано в 13.1.
5.7. LIST - вывод на экран содержания программы
LLIST - вывод на печатающее устройство содержания
программы
Пока Ваши программы очень коротки и всегда перед глазами. С
течением времени (и с приходящим во время еды апетитом) они будут
длиннее и длиннее. Вы научитесь вводить и чужие или уже забытые
программы. Для вывода содержание программы (текущей, находящейся
уже в памяти) применяется команда LIST.
Попробуйте:
]10 A=5*2
]20 B=(3-10)/4/5
]30 C=A+B
]40 PRINT "Результатом действий 5*2+(3-10)/4/5 является ";C
]SCREEN
экран очистится и тогда введите:
]LIST
]10 A=5*2
]20 B=(3-10)/4/5
]30 C=A+B
]40 PRINT "Результатом действий 5*2+(3-10)/4/5 является ";C
]
При помощи команды LIST можно вывести содержание только одной
строки программы. Для этого после команды необходимо указать
идентификатор строки. Например:
]LIST 30
]30 C=A+B
]
Можно вывести и кусок программы. Для этого необходимо указать
идентификаторы первой и последней выводимой строки, разделенные
запятой или символом "-". Например:
]LIST 10,30
]10 A=5*2
]20 B=(3-10)/4/5
]30 C=A+B
]
Если пропущен первый или второй идентификатор, но введен
разделитель, первый идентификатор заменяется идентификатором
первой строки, а второй - последней. Например:
]LIST -20
]10 A=5*2
]20 B=(3-10)/4/5
]
или
]LIST 30,
]30 C=A+B
]40 PRINT "Результатом действий 5*2+(3-10)/4/5 является ";C
]
Текст программы может быть выведен и на печатающее устройство
при помощи команды LLIST, имеющей такой же формат, что и команда
LIST.
Текущая программа может быть записана на дискете в виде
текстового файла при помощи команды LIST с форматом:
LIST#<номер_файла>[, ограничительные_идентификаторы_строк ]
Например:
]LIST#1,10-30
Более подробно о файлах и их номерах рассказано в гл.9.
5.8. EDIT - редактирование строки программы
Совершенно нормально при вводе программы допустить ошибку.
Или захотеть изменить что-то в программе. Изменения программного
текста называются редактированием.
Содержание данной строки программы можно изменить заново
полностью вводя строку. Новое содержание заменяет старое.
Можно поступить и иначе - воспользоваться командой
EDIT [идентификатор_строки]
Содержание строки выводится на экран и при помощи клавиш
управления курсора и переключения режима "вставка/замена" (Insert/
Replace) можете сделать необходимые изменения, не вводя полностью
содержание строки. Если до нажатия клавиши Enter Вы решите, что лучше
отказаться от сделанных изменении, старое содержание строки будет
восстановлено, если одновременно нажмете на Ctrl и C.
Если идентификатор строки пропущен, по умолчанию принимается
идентификатор последней строки, в которой отмечена ошибка.
5.9. DEL - стирание фрагмента программы
Одну или более строк программы можно стереть при помощи
команды DEL (Delete). Команда имеет формат:
DEL <идентификатор_строки_1> [, идентификатор_строки_2 ]
Интерпретируется так: "стереть фрагмент программы начиная со
строки с идентификатором 1 и кончая строкой с идентификатором 2".
Если идентификатор строки 2 пропущен, стирается фрагмент из одной
строки - строки с идентификатором 1.
5.10. REM - комментарий в рамках программы
Признак хорошего стиля программирования - применение
комментариев в рамках программы. Они предназначены для обяснения
особенностей алгоритма, программистких "трюков", применения
переменных и т.п.
Формат оператора комментария:
REM [ текст_комментария ]
UniBASIC игнорирует содержание программной строки после
зарезервированного слова REM. Оператор может быть использован и в
качестве последнего (но не единственного) оператора в программной
строке. Пример:
]10 REM Демонстрационная программа
]20 A=22/7 : REM число "пи"
....
Зарезервированное слово REM можно заменить символом апострофа
(').
5.11. INPUT - ввод значения переменной
Наверняка сами подумали, что применение программ, подобных
приведенным выше, врядь ли особенно полезно. В них все значения
переменных задаются в самом тексте и для изменения необходимо
редактировать программу.
Для ввода значения переменных применяется оператор (только в
программном режиме!) INPUT (ввести). Оператор имеет формат:
INPUT [ строка_символов ; ] <список_переменных >
Строка_символов (не забывайте оградить кавычками) иногда
называется "подсказкой" и представляет собой текст (как правило
подсказывающий предназначение вводимого значения), который
выводится на экран перед тем, как пользователю будет
"предоставлено слово" для ввода значения. Если пропущена
строка_символов, то подсказкой применяется символ "?",
напоминающий, что компьютер ожидает что-то от Вас. Конечно, если
Вы не хотите выводить ничего перед вводом, то можете применить
пустую строку символов "".
Переменные в списке должны быть разделены запятыми. При вводе
можно ввести значения всех перечисленных переменных, разделенные
запятыми и вслед за это нажать Enter. Очевидно, что вводимое значение
строчной переменной не должно содержать символ запятой ",". Если
число введенных значений меньше числа переменных в списке, то на
следующей строке выводится подсказка "??" и Вы имеете возможность
ввести нехватающие значения.
Пример:
]NEW
]10 REM Примерная программа расчета площади квадрата
]20 INPUT "Просьба ввести длину стороны квадрата (см): "; A%
]30 PRINT "Площадь квадрата равна ";A% * A%;" кв.см."
]RUN
Просьба ввести длину стороны квадрата (в см.): 4
Площадь квадрата равна 16 кв.см.
]
В данном примере предполагается, что в качестве значения
(целочисленной) переменной A введено число 4. Попробуйте выполнить
программу вводя другие числа.
5.12. LINE INPUT - ввод экранной строки в качестве значения
переменной
Оператор LINE INPUT позволяет ввести в качестве значения
строчной переменной строку, содержащую любые символы, в том числе
и символы, обычно играющие роль разделителей. Оператор имеет
формат:
LINE INPUT [ строка_символов ; ] <имя_переменной >
Пример:
]10 LINE INPUT "Введите строку : "; L$
]20 PRINT L$
]RUN
Введите строку : 123, АБВГ, 12;13;14
123, АБВГ, 12;13;14
]
5.13. LOCATE - установление курсора
При применении более сложных программ особо важную роль играет
оформление экрана во время диалога с пользователем программы. От
этого в значительной степени зависит эффективность работы.
Для установления (позиционирования) курсора перед выполнением
операторов ввода/вывода предназначен оператор LOCATE (установить).
Он имеет формат:
LOCATE [ вп [, гп ]]
где: вп - вертикальная позиция - номер строки экрана (1 - 25);
гп - горизонтальная позиция - номер колонки экрана (1 - 40
для 40-колонного режима и 1 - 80 для 80-колонного
режима) по умолчанию - текущая горизонтальная позиция;
Текущая вертикальная позиция курсора является значением
системной переменной CV, а горизонтальная позиция - системной
переменной CH.
ВНИМАНИЕ !!! Переменным CH и CV нельзя присваивать значения.
5.14. AUTO - автоматическая номерация строк
В UniBASIC-е предусмотрена команда автоматической номерации
вводимых после выполнения команды программых строк (автоматическое
создание идентификаторов строк). Команда имее формат:
AUTO [начало [ , шаг ] ]
где: начало - начальное значение - идентификатор первой строки. По
умолчанию - начало = 10;
шаг - шаг нарастания идентификатора строк.
По умолчанию шаг = 10
Т.е. если введена команда AUTO (без операндов), первая строка
будет иметь идентификатор 10, вторая - 20 и т.д.
Если до команды AUTO память не содержить программу, то все
нормально. Если, однако, в памяти содержится программа, в которой
существует строка с идентификатором, одинаковым с автоматически
генерируемым, то после генерированного идентификатора будет выведен
символ "*". Если после этого Вы нажмете Enter, то содержание
существующей строки с этим идентификатором сохранится. В противном
случае вводимое заменит старое содержание указанной строки.
После ввода содержания последней строки Вашей программы
необходимо перед нажатием Enter нажать ОДНОВРЕМЕННО клавиши CTRL и
C. Этим Вы приостановите действие команды AUTO и на следующей
строке будет выведен промпт UniBASIC-а.
6. БОЛЕЕ СЛОЖНЫЕ ПРОГРАММЫ
Рассмотренные до сих пор примерные программы имеют одну общую
черту - они воспроизводят линейные алгоритмы. Мы подчеркивали в
самом начале - практических нет смысленных задач, решаемых по
таким алгоритмам. В настоящей главе рассмотрим как можно
программировать по разветленному алгоритму.
6.1. GOTO - нарушение естественного порядка
Оператор GOTO (перейти на) предназначен для передачи
управления первому оператору в программной строке с указанным
идентификатором. Формат оператора:
GOTO [идентификатор_строки]
В качестве идентификатора строки можно применить целое число
или целочисленная реальная переменная в интервале от 0 до 63999.
Если параметр пропущен, подразумевается 0.
Пример:
]100 A=150: B=50
]110 C=A + B
]120 GOTO C
.....
]200 PRINT "В данном случае управление передается сюда! "
.....
6.2. IF - переход по условию
Очень трудно найти реальный алгоритм, в котором нет
расклонения по какому нибуть условию. Вспомним наш пример в самом
начале - если ... то ... иначе ... . Для осуществления перехода по
условию предназначен оператор IF (если).
Оператор IF имеет несколько форматов. Рассмотрим их
последовательно.
IF <логическое_выражение> THEN <идентификатор_строки>
IF <логическое_выражение> GOTO <идентификатор_строки>
IF <логическое_выражение> GOSUB <идентификатор_строки>
Указанные форматы одинаковы по своему действию и
интерпретируются следующим образом: "если логическое выражение
имеет значение TRUE (ДА, ИСТИНА, <> 0), то перейти на строку с
указанным идентификатором, иначе передать управление первому оператору,
следующему непосредственно за оператором IF".
<логическое_выражение> может иметь вид проверки отношения:
<выражение_1> <отношение> <выражение_2>
В качестве <отношения> можно применить одно из уже известных
Вам отношений: "<" - меньше; "<=" - меньше или равно; "=" - равно;
">=" - больше или равно; ">" - больше; "<>" - не равно. В качестве
выражений можно применять арифметические или строчные выражения, в
частности, констант. ЕСЛИ ОТНОШЕНИЕ СОБЛЮДЕНО, ТО ЛОГИЧЕСКО
ВЫРАЖЕНИЕ ИМЕЕТ ЗНАЧЕНИЕ TRUE (ИЛИ <> 0).
Например, допустим, что где-то в программе перед выполнением
оператора IF были выполнены операторы A = 5 : B = 10. Тогда:
значение TRUE имеют логические выражения:
A = 5; A >= 5; A <= 5; A <> 2; A <> B; A < B; B > A
значение FALSE имеют логические выражения:
A <> 5; A < 5; A > 5; A = 2; A = B; A >= B; B <= A
Внимание! Если в качестве логического выражения применено
арифметическое, то считается, что должно быть произведено
сравнение с нулем и если значение не равно нулю, логическому
выражению присваивается значение TRUE. Для выражений с реальными
значениями считается, что выражение имеет значение 0, если
абсолютная величина реального значения меньше приблизительно
2.9387Е-38. Например: IF A THEN интерпретируется "если значение
переменной A <> 0, то ...".
В общем случае логическое выражение может быть составлено из
отношений и логических функций AND, OR, XOR и NOT. Например:
IF A > 0 AND B < 20 THEN
IF NOT (A = B) THEN
IF A AND (B OR C) THEN
Попробуем составить программу деления двух чисел при условии,
что выполнение программы прекратится при вводе нулевых делимого и
делителя или при ответе на соответствующий вопрос
непотвердительно.
]NEW
]10 REM программа деления двух чисел
]20 REM конец программы при А = 0 и В = 0
]30 A = 0 : B = 0 : C$ = "Д"
]40 SCREEN
]50 INPUT "Введите делимое: "; A
]60 INPUT "Введите делитель: "; B
]70 IF A=0 AND B=0 THEN GOTO 150
]80 IF B=0 GOTO 130
]90 PRINT "A / B = "; A/B
]100 INPUT "Продолжить ли? (Д или Н) ";C$
]110 IF C$ = "Д" GOTO 40
]120 GOTO 150
]130 PRINT "Делитель = 0 ! ";
]140 GOTO 100
]150 REM Конец программы
Сделайте анализ программы. Ответьте на вопрос почему
необходима проверка в строке 80. Конечно, можно написать и другую
программу, выполняющую ту-же самую задачу. Попройте написать.
Возможен и следующий формат оператора:
IF <логическое_выражение> THEN <операторы>
Интерпретация:
ЕСЛИ логическое выражение имеет значение TRUE (ДА, ИСТИНА),
ТО выполнить <операторы>,
ИНАЧЕ передать управление первому оператору, следующему
непосредственно за оператором IF.
Например, строки 80 и 90 нашей программы можно заменить
строкой:
]80 IF B <> 0 THEN PRINT "A / B = "; A/B
Попробуйте написать заново полностью программу, применяя
новый формат оператора!
Внимание ! В качестве <оператора> можно применить IF ...
Например: IF A <> 0 THEN IF B <> 0 THEN IF C <> 0 GOTO xxxx
Възможeн и следующий формат оператора IF:
IF <лог_выр> THEN <операторы_1> : ELSE <операторы_2>
Интерпретация:
ЕСЛИ логическое выражение имеет значение TRUE (ДА, ИСТИНА),
ТО выполнить <операторы_1>,
ИНАЧЕ выполнить <операторы_2>.
Възможны и следующие форматы оператора IF:
IF <лог_выр> GOTO <идент_стр_1> : ELSE <операторы>
IF <лог_выр> GOSUB <идент_стр_1> : ELSE <операторы>
где <операторы> можно заменить на <идентификатор_строки>.
С применением указанного формата наша программа может
выглядеть так:
]NEW
]10 REM программа деления двух чисел
]20 REM конец программы при А = 0 и В = 0
]30 A = 0 : B = 0 : C$ = "Д"
]40 SCREEN
]50 INPUT "Введите делимое: "; A
]60 INPUT "Введите делитель: "; B
]70 IF A=0 AND B=0 THEN GOTO 110
]80 IF B<>0 THEN PRINT "A / B = ";A/B: ELSE PRINT"Делитель=0! ";
]90 INPUT "Продолжить ли? (Д или Н) ";C$
]100 IF C$ = "Д" GOTO 40
]110 REM Конец программы
Операторы IF-THEN-ELSE могут быть вложенными - т.е. после
THEN и/или ELSE применить новый IF-THEN-ELSE оператор. При этом
следует соблюдать следующее правило: Оператор ELSE связывается с
ближайшим (слева) невложенным (первым в строке или
предшествованным ":") оператором IF на том-же самом лексическом
уровне. Например, в случае
IF ... THEN ... if ... THEN ... : ELSE ...
ELSE относится к оператору IF, а не к if. А в случае
IF ... THEN ... : if ... THEN ... : ELSE ...
ELSE относится к оператору if, а не к IF.
6.3. Циклы (петли)
Второй способ нарушить выполнение операторов в порядке
следования в программе - организация "циклов". Цыклом будем
называть многократное (в том числе - и ни разу) выполнение
некоторого фрагмента программы. Повтаряемый фрагмент называется
телом цикла. Каждое выполнение фрагмента называется тоже циклом -
первый цикл, второй и т.д.
При организации циклов следует ответить на следующие основные
вопросы: как ограничить тело цикла? По какому признаку
организовать цикл? Как определить когда следует закончить
повторение цикла?
Телом цикла считается фрагмент программы, ограниченный между
оператором начала цикла и оператором конца цикла. Т.е. цикл
организуется парой операторов.
Цикл организуется в UniBASIC-е по двум принципам:
- повтарять пока заданная переменная не получила заранее
определенное значение, при этом при каждом выполнение изменять
значение переменной, суммируя с некоторым значением. Такой цикл
называется циклом по счетчику, а счетчиком называется управляющая
переменная;
- повтарять выполнение цикла пока некоторое логическое
выражение имеет значение FALSE. Такой цикл называется циклом по
условию.
6.3.1. FOR - NEXT - цикл по счетчику
Цикл по счетчику имеет формат:
FOR <перем> = <выраж._1> TO <выраж._2> [ STEP <выраж._3> ]
.
. <тело цикла>
.
NEXT [ перем. [ , перем._2 ] ... ]
<перем> - переменная (целочисленная или реальная, но не
элемент массива), применяемая в качестве счетчика;
<выраж._1> - численное выражение, определяющее начальное
значение счетчика;
<выраж._2> - численное выражение, определяющее конечное
значение счетчика;
<выраж._3> - численное выражение, определяющее шаг изменения
счетчика. Если пропущено и выраж_1 < выраж_2, то шаг изменения
устанавливается =1. Если пропущено и выраж_1 > выраж_2, то шаг
изменения устанавливается = -1.
Оператор интерпретируется следующим образом:
1. Значение выражения_1 присваивается счетчику (начальное
значение).
2. Программные строки выполняются до достижения оператора
NEXT.
3. К счетчику добавляется значение выражения_3.
4. Значение счетчика сравнивается со значением выражения_2.
ЕСЛИ шаг изменения не отрицателен И значение счетчика не больше
значения выражения_2
ИЛИ шаг изменения отрицателен И значение счетчика не меньше
значения выражения_2
ТО осуществляется пункт 2.
ИНАЧЕ управление передается оператору, следующему непосредственно
за оператором NEXT.
ВНИМАНИЕ ! Операторы тела цикла выполняются хотя бы один раз,
независимо от отношения между начальным и конечним значениями
счетчика.
ВНИМАНИЕ ! Если <выражение_3> = 0, то не произходит никакое
изменение значения счетчика и получается "ВЕЧНЫЙ ЦИКЛ". Из него
можно выйти ТОЛЬКО при помощи операторов перехода (GOTO или IF).
В качестве примера приведем программу вычисления целых
степеней двойки в некотором диапазоне.
]NEW
]10 SCREEN
]20 INPUT "Введите начальное значение степени: "; A%
]30 INPUT "Введите конечное значение степени: "; B%
]40 IF A% < 1 OR B% < A% GOTO 90
]50 SCREEN
]60 FOR I% = A% TO B%
]70 PRINT "2 в степени "; I% ; " равно "; 2 ^ I%
]80 NEXT I%
]90 REM Конец программы
Циклы FOR - NEXT могут быть вложенными. Это означает что в
теле одного цикла может находиться другой цикл. Первый цикл
называется внешним, а второй - внутренным. Вложенные циклы должны
иметь разные счетчики.
ЦИКЛЫ НЕ ДОЛЖНЫ ПЕРЕСЕКАТЬСЯ - оператор NEXT внешнего цикла
должен находится за оператором NEXT внутреннего цикла.
Допускается, чтобы тела обоих циклов имели общую точку конца.
Тогда применяется оператор NEXT с указанием обоих счетчиков. Циклы
FOR-NEXT НЕ ДОЛЖНЫ ПЕРЕСЕКАТЬСЯ И С ЦИКЛАМИ REPEAT-UNTIL (см.
ниже).
В качестве примера приведем программу вычисления степеней
двойки, замещая операцию возведения в степень умножением.
]NEW
]10 SCREEN
]20 INPUT "Введите начальное значение степени: "; A%
]30 INPUT "Введите конечное значение степени: "; B%
]40 IF A% < 1 OR B% < A% GOTO 130
]50 SCREEN
]60 FOR I% = A% TO B%
]70 C% = 1
]80 FOR J% = 1 TO I%
]90 C% = C% * 2
]100 NEXT J%
]110 PRINT "2 в степени "; I% ; " равно "; C%
]120 NEXT I%
]130 REM Конец программы
Очевидно, обе программы выдают степени двойки только в правильно
заданном положительном интервале. Можно ускорить выполнение второй
программы, если не начинать вычисление степени двойки с самого начала
- попробуйте. Задайте большие значения степени (но в очень узком
интервале, что-бы не терять время) и анализируйте в свете уже Вам
известного ситуацию переполнения (превышение допустимого значения
целого, в данном случае, числа). Попробуйте написать программу при
условии, что можно задать нисходящий интервал, потом - отрицательный
интервал (отрицательные степени).
6.3.2. REPEAT - UNTIL - цикл по условию
Цикл по условию имеет формат:
REPEAT
.
. <тело цикла>
.
UNTIL <логическое_выражение>
<логическое_выражение> должно удовлетворять требованиям,
описанным в пункте 6.2.
Операторы тела цикла выполняются до достижения оператора UNTIL.
Тогда вычисляется значение <логического_выражения>. ЕСЛИ оно FALSE,
управление передется первому оператору тела цикла, ИНАЧЕ управление
передается оператору, следующему непосредственно за оператором UNTIL.
ВНИМАНИЕ! В REPEAT - UNTIL цикле нет явной управляющей
переменной. Не забывайте позаботиться об изменений значений
переменных, принимающие участие в логическом выражении. Иначе
получиться "вечный" цикл!
В качестве примера приведем новую программу вычисления
степеней двойки.
]NEW
]10 SCREEN
]20 INPUT "Введите начальное значение степени: "; A%
]30 INPUT "Введите конечное значение степени: "; B%
]40 IF A% < 1 OR B% < A% GOTO 130
]50 SCREEN : I% = A%
]60 REPEAT
]70 PRINT "2 в степени "; I% ; " равно "; 2 ^ I%
]80 I% = I% + 1
]90 UNTIL I% > B%
]100 REM Конец программы
Циклы REPEAT-UNTIL могут быть вложенными. Это означает что в
теле одного цикла может находиться другой цикл. Первый цикл
называется внешним, а второй - внутренным.
ЦИКЛЫ REPEAT-UNTIL НЕ ДОЛЖНЫ ПЕРЕСЕКАТЬСЯ КАК МЕЖДУ СОБОЙ,
ТАК И С ЦИКЛАМИ FOR-NEXT.
6.4. GOSUB - RETURN - подпрограммы
END - конец программы
Как не раз было подчеркнуто, очень часто приходится выполнять
много раз один и тот-же фрагмент программы. Конечно, можно повторять
его в тексте программы. Но это плохое решение - теряется память и
ухудшается "читаемость" программы. Правильное решение - оформить
фрагмент в виде подпрограммы и "вызывать" подпрограмму когда нужно.
Внешне подпрограмма не отличается ничем особенным по сравнению с
остальными фрагментами программы. Отличие - оператор RETURN,
определяющий "точку выхода" подпрограммы. Сразу отметим, что одна
подпрограмма может иметь более одной точки выхода.
Начало подпрограммы различается по параметру оператора вызова
подпрограммы - GOSUB ( от GO to SUBroutine - перейти на
подпрограмму). Оператор имеет следующий формат:
GOSUB [ (список_реальных_переменных) ] [идентификатор_строки]
<идентификатор_строки> указывает начало подпрограммы. Если
пропущено, по умолчанию принимается 0.
Необязательный список_реальных_переменных предназначен для
восстановления значений указанных переменных после завершения
подпрограммы. Список не должен содержать массивы и элементы
массивов.
Оператор GOSUB выполняется так: (если указаны реальные
переменные, их значения запоминаются) запоминается точка (место)
программы, откуда вызывается подпрограмма, управление передается
по указанному идентификатору_строки. При встече оператора RETURN
(восстанавливаются значения переменных, если в GOSUB применен
список переменных) управление передается первому оператору,
следующему непосредственно за оператором GOSUB (за точкой вызова).
Подпрограмма может находится на любом месте программного
текста. ОБРАТИТЕ ВНИМАНИЕ, что по этой причине, если не
предприняты специальные меры, управление может быть передано
первому оператору подпрограммы и когда это не нужно - в порядке
последовательности операторов программы.
В качестве специальной меры можно применить, например,
оператор GOTO перед первой строкой подпрограммы, указывающий на
программную строку за подпрограммой. Такое решение не
рекомендуется. Лучше всего вынести все подпрограммы в конец
программного текста и закончить основную программу оператором
конца программы END.
Оператор END останавливает выполнение программы (указывает в
явном виде ее конец). При этом закриваются все откритые файлы.
Подпрограммы могут быть вложенными - одна подпрограмма
содержит другую. Оператор RETURN относится к ближайшему GOSUB
оператору.
В качестве примера приведем вариант уже знакомой программы:
]NEW
]10 SCREEN : REM Программа расчета степеней двойки
]20 INPUT "Введите начальное значение степени: "; A%
]30 INPUT "Введите конечное значение степени: "; B%
]40 IF A% < 1 OR B% < A% GOTO 90
]50 SCREEN
]60 FOR I% = A% TO B%
]70 GOSUB 100
]80 NEXT I%
]90 END : REM Конец программы
]100 C% = 1
]110 FOR J% = 1 TO I%
]120 C% = C% * 2
]130 NEXT J%
]140 PRINT "2 в степени "; I% ; " равно "; C%
]150 RETURN : REM Конец подпрограммы
Мы уверены, что без обяснений Вам понятен смысл оператора IF
... GOSUB - выполнение подпрограммы по условию. Рассмотрите
вариант программы деления двух чисел:
]NEW
]10 REM программа деления двух чисел
]20 REM конец программы при А = 0 и В = 0
]30 A = 0 : B = 0 : C$ = "Д"
]40 REPEAT
]40 SCREEN
]50 INPUT "Введите делимое: "; A
]60 INPUT "Введите делитель: "; B
]70 IF B <> 0 GOSUB 110
]80 IF B = 0 GOSUB 160
]90 UNTIL A <> 0 AND B <> 0 AND C$ = "Д"
]100 END : REM Конец программы
]110 PRINT "A / B = "; A/B
]120 GOSUB 140
]130 RETURN
]140 INPUT "Продолжить ли? (Д или Н) ";C$
]150 RETURN
]160 PRINT "Делитель = 0 ! ";
]170 GOSUB 140
]180 RETURN
6.5. DIM - массивы
ERASE - стирание массивов
Понятие "массив" знакомо от математики. Напомним -
массив - это таблица однородных элементов (чисел или строк). Одно
из ключевых понятий массива - размерность. Размерностью называем
число осей, по которым располагаются элементы массива.
Классическая таблица - двухмерна (элементы располагаются вдоль и
поперек листа). Каждую колонку можно рассматривать в качестве
одномерного массива, как и знакомый уже список элементов.
Техмерный массив тоже легко представить - кубом или стопкой листов
двухмерных таблиц.
UniBASIC допускает применение массивов чисел или строк.
Размерность ограничивается объемом свободной памяти компьютера.
Следует четко различать массив (целое) и элемент массива (часть
целого). Имя массива указывается по известным Вам правилам. Имя
элемента массива состоит из имени массива и, непосредственно за ним, в
круглых скобках, номера элемента по каждой оси. Например,
А(4,3,2,1,0) означает элемент массива А, занимающий 5 место по первой
оси, 4 - по второй, 3 - по третей, 2 - по четвертой и 1 место по пятой
оси.
Номерация элементов по каждой оси начинается с 0 - т.е.
элемент с номером 5 является шестым по очереди элементом. В
качестве номера можно применить и переменная или выражение - в
таком случае номер определяется целой частью значения.
В UniBASIC-е нет необходимости предварительного обявления
применяемых переменных. Правило сохраняет свою силу и в случае
массивов. НО ЛУЧШЕ ВСЕГО ОБЯВИТЬ ЗАРАНЕЕ ВСЕ МАССИВЫ ПРОГРАММЫ!
Для каждой переменной отделяется определенное пространство памяти.
Если массив не обявлен, при первом применении элемента массива для
всего массива отводится пространство, достаточное для 11 элементов
(с номерами от 0 до 10) и массив предполагается одномерным.
Обявление массива и связанное с этим отделение памяти
осуществляется при помощи оператором DIM (DIMension -
размерность). Оператор имеет формат:
DIM <список_имен>
Имена массивов приводятся с указанием в круглых скобках
максимально допустимые номера элементов по каждой оси.
Например, оператором DIM A(23),B(9,4) отводится пространство
памяти для массива A с 24 элементами и массива B с 10 элементами
по первой оси и пятью элементами по второй оси. Список может
содержать и имена простых (не массивы) переменных. В таком случае
для них распределяется необходимая память.
Какие преимущества предоставляет обявление простых переменных
при помощи оператора DIM ? В UniBASIC-е память для переменной
предоставляется в момент первой встречи переменной и тогда она
включается в специальный внутренный список активных переменных.
Если некоторая переменная впервые встречается "в глубине"
программы, то при необходимости ее дальнейшего применения будет
потеряно относительно больше времени, чем для нахождения во
внутренном списке ранее встреченных переменных. Поэтому
рекомендуем переменные, которые будут применяться часто, обявлять
в явном виде при помощи оператора DIM в самом начале программы -
это улучшит быстродействие программы.
В качестве примера напишем программу для ввода значений
температуры воздуха (в диапазоне -60 - +50 градусов) на каждый
круглый час каждого дня месяца:
]10 DIM temp(30,23)
]20 INPUT "День замера (1 - 31): "; day%
]30 IF day% <1 OR day% >31 GOTO 80
]40 INPUT "Час замера (0 - 23): "; hour%
]50 IF hour% <0 OR hour% >23 GOTO 80
]60 INPUT "Температура воздуха (-60 - +50): "; temp(day%-1,hour%)
]70 IF temp(day%-1,hour%) <-60 OR temp(day%-1,hour%) >50 GOTO 40
]80 END
Попробуйте написать программу для вывода имен дней недели на
нескольких языках. Например, на болгарском языке дни недели
называются: понеделник, вторник, сряда, четвъртък, петък, събота и
неделя.
Как можете себе представить, применение массивов занимает
соответствующий объем памяти. В определенных случаях очень полезно
освободить память для других целей, после того, как работа с
массивом закончена. Для освобождения памяти, занимаемой массивом,
предназначен оператор ERASE (стереть). Формат оператора:
ERASE <список_имен_массивов>
6.6. DATA, READ, RESTORE - данные в программе
Можно предположить, что в Ваших программах придется применять
данные, изменять которые не нужно при каждом выполнении программы,
но все-таки при необходимости нужно легко изменять. В таких
случаях удачно будет определить в программе "зону" данных. Это
можно осуществить при помощи оператора DATA. Он имеет формат:
DATA <список_значений>
Значения в списке отделены запятыми. В одной программе можно
применить неограниченное число раз оператор DATA.
Значения присваиваются поочередно некоторым переменным при
помощи оператора READ (читать), имеющий формат:
READ <список_переменных>
При выполнении первого оператора READ последовательно
читаются столько значений, сколько переменных в списке, и
прочитанные значения присваиваются соответствующим по очереди
переменным. Последнее прочитанное значение запоминается и при
выполнении следующего оператора READ читается следующее значение.
Последовательность читаемых значений можно восстановить
(указать, что следующий оператор READ должен обработать первое
значение, определенное некоторым DATA-оператором) при помощи
оператора RESTORE. Оператор имеет формат:
RESTORE [ идентификатор_строки ]
При выполнении оператора указатель чтения устанавливается на
первое значение, определенное оператором DATA указанной строки.
Если строка не указана, следующее чтение начнется с первого
значения первого DATA-оператора.
В качестве примера рассмотрите программу, реализирующую
простую игру - угадать одно из заранее заганных чисел:
]10 PRINT "Угадайте число (0-конец игры) ";
]20 INPUT G
]30 IF G = 0 GOTO 80
]40 READ D
]50 IF D = 0 GOTO 90
]60 IF D <> G GOTO 40
]70 PRINT "УГАДАЛИ !!!"
]80 END
]90 PRINT "НЕ УГАДАЛИ! ПОПРОБУЙТЕ ЕЩЕ РАЗ!"
]100 RESTORE
]110 GOTO 10
]120 DATA 23,45,67,89,111,121,133
]130 DATA 155,166,188,0
6.7. WRITE - вывод значений переменных
Вы уже знакомы с одним оператором вывода значений переменных
- PRINT. В UniBASIC-е предосмотрен еще один оператор с подобным
действием - WRITE (записать). Он имеет формат:
WRITE [список_выражений] [ ; ]
В качестве разделителей элементов списка нужно применять
запятые.
Разница между PRINT и WRITE состоит в том, что при применении
WRITE выводимые значения выводятся одно непосредственно за другим,
разделенные запятыми. Положительные числа не предшествуются
пробелом. Строчные значения заключены в кавычках. Если
список_выражений пропущен, выводится пустая строка.
Если символ ";" в конце оператора отсутствует, то
осуществляется автоматический переход на новую строку, иначе
курсор остается на свое место.
Пример показывает как выглядит вывод значений списка
переменных (не забывайте - переменная - частный случай
выражения!):
]10 A=1 : B=20 : C$="Конец списка."
]20 WRITE A,B,C$
]RUN
1,20,"Конец списка."
Оператор WRITE имеет еще один формат, который будет
рассмотрен при обсуждении операций с файлами.
6.8. CLEAR - стирание всех переменных
Уже несколько раз дискутировали вопрос о занятии памяти
переменными и массивами. В пункте 6.5. показано как можно
освободить память, занятая массивом. Часто это недостаточно. По
соображениям экономии памяти или по другим соображениям иногда
необходимо освободить память, занимаемая ВСЕМИ ПЕРЕМЕННЫМИ. В
UniBASIC-е указанное действие можно осуществить при помощи
оператора без операндов CLEAR.
6.9. SWAP - обмен значениями переменных
Все в духе сокращения объема программы и занимаемой памяти
рассмотрим часто возникающая необходимость обмена значениями двух
переменных. Проблему можно, конечно, решить следующим образом:
]xx C=A : A=B : B=C
Но при этом необходимо применить новую переменную C для
обмена значениями переменных A и B. В UniBASIC-е предусмотрен
специальный для этой цели оператор SWAP (обмен) с форматом:
SWAP <список_арифметических_переменных>
Результатом действия оператора является циклический обмен
значениями переменных. Каждый элемент списка получает значение
следующего элемента в списке; последний в списке элемент получает
значение первого элемента.
Например, результат действия оператора SWAP A,B эквивалентен
результату приведенных выше трех операторов, при этом не применяя
допольнительную переменную.
7. ОТЛАДКА ПРОГРАММ
При помощи описанных Выше языкоВых конструкций можно написать
очень сложные и длинные программы. В таких случаях трудно визуально
убедиться в правильности программ. Речь идет, конечно, о логической
правильности - синтаксически неправильную программу просто нельзя
Выполнить. В UniBASIC-е предусмотрены средства для отладки программ:
трассировка и временное прерывание Выполнения.
7.1. Трассировка программ - TRON - TROFF
Трассировкой называется прослеживание последовательности
Выполнения программных строк путем Вывода их номеров. Трассировка
очень полезна при отладке сложно разветвленных программ.
Команда для включения трассировки - TRON (TRace ON - трассировку
включить).
Команда для Выключения трассировки - TROFF (TRace OFF -
трассировку Выключить).
Обе команды можно применять и в качестве операторов - т.е.
трассировку можно включать/Выключать как перед запуском и после
Выполнения программы, так и во время Выполнения.
7.2. STOP - временное прерывание программы
CONT - восстановление Выполнения
Для отладки программ трассировка не всегда достаточна. Дело в
том, что применяя трассировку Вы не можете узнать значения
переменных, присвоить переменным ноВые значения и т.п. Для
достижения подобных целей предназначен оператор временного
прерывания Выполнения программы STOP и команда продолжения
Выполнения CONT.
При встрече оператора STOP Выполнение программы
останавливается, Выводится идентификатор строки и без изменений
состояния переменных и файлов UniBASIC переходит в командный
режим. Внешный сигнал для этого - появление промпта UniBASIC-а
"]". С этого момента Вы имеете возможность ввести необходимые
команды и немедленно Выполняемые операторы. ВНИМАНИЕ ! После
временного прерывания программы НЕ ДОЛЖНЫ ЕЕ ИЗМЕНЯТЬ !
Выполнение программы с точки прерывания восстанавливается при
помощи команды CONT (CONTinue - продолжить). Конечно, Выполнение
продолжается с учетом всех изменений, которые Вы ввели.
8. РЕАКЦИЯ НА ВОЗНИКШУЮ СИТУАЦИЮ
Независимо от всех усилий, в процессе выполнения программы
могут возникнуть ошибки. При такой ситуации UniBASIC выводит
соответствующее сообщение и останавливает выполнение программы.
Иногда такая реакция нежелательна - можно и необходимо
"обработать" ошибку - произвести некоторые действия. Кроме на
неприятную ситуацию возникновения ошибки, программа на UniBASIC-е
может реагировать и на другие события, критерием возникновения
которых является получение некоторым выражением определенного
значения. Для описания реакции на возникшую ситуацию предназначен
оператор ON (в случае) в описанных ниже вариантах.
8.1. ONERR - RESUME - реакция на ошибку
ERR - искуственное возбуждение ситуации ошибки
Как было выше сказано, UniBASIC имеет стандартную реакцию на
возникновение ситуации ошибки: вывод диагностического сообщения и
прерывание выполнения программы. Вместо этого, можно написать свой
собственный фрагмент программы. На факт существования такого
фрагмента необходимо указать UniBASIC-у при помощи оператора ONERR
(ON ERROR - в случае ошибки) в следующем формате:
ONERR GOTO [идентификатор_строки]
где "идентификатор_строки" указывает на первую строку
фрагмента обработки ошибки.
С момента обработки оператора, при возникновения ошибки
управление передается указанному фрагменту.
Если идентификатор строки НЕ УКАЗАН, ТО ВОССТАНАВЛИВАЕТСЯ
СТАНДАРТНАЯ РЕАКЦИЯ НА ОШИБКИ !
Фрагмент программы оформляется по правилам оформления
подпрограммы. Наверняка Вам будет полезна встроенная функция ERR (см.
ниже), при помощи которой можно установить точно какая ошибка
возникла, и второй вид оператора ON (см.ниже). В отличии от обычных
подпрограмм, где после их выполнения управление возвращается
вызывающей программе при помощи оператора RETURN, конец фрагмента
программы обработки ошибки и строка возврата указываются оператором
RESUME (продолжить), имеющий формат:
RESUME [идентификатор_строки]
Если не указан идентификатор строки, управление передается
оператору, при выполнении которого возникла ошибка.
Код ошибки содержится в системной переменной ERR, а
идентификатор строки, где записан оператор, при выполнении
которого возникла ошибка - в системной переменной ERRLN.
Ситуацию возникновления ошибки с заданным кодом можно
искуственно возбудить при помощи оператора
ERR <код_ошибки>
где <код_ошибки> - целое число в диапазоне 0 - 255.
8.2. ON - GOTO - переход при возникновении ситуации
ON - GOSUB
Оператор перехода при возникновении ситуации имеет формат:
ON <выражение> GOTO <список_идентификаторов_строк>
<выражение> должно быть арифметическим со значением в
интервале от 0 до 255. Если выражение не целочисленное, его
значение огругляется до целого числа.
Действие оператора: управление передается строке, чей
очередной номер в списке соответствует значению выражения. Если
значение 0 или больше наибольшего номера в списке (но меньше или
равно 255), управление передается следующему за ON оператору.
Например,
ON A GOTO 100,200,500
интерпретируется так: если A=1, то перейти на 100; если A=2, то
перейти на 200; если A=3, то перейти на 500; во всех остальных
случаях - перейти на следующий оператор.
Аналогично интерпретируется оператор
ON <выражение> GOSUB <список_идентификаторов_строк>
с той разницей, что перечисленные в списке строки считаются
первыми строками подпрограмм.
В качестве примера приведем фрагмент программы для обработки
"меню":
]10 PRINT "Просьба выбрать режим работы:"
]20 PRINT "1 - первый режим"
]30 PRINT "2 - второй режим"
]40 PRINT "3 - третий режим"
]50 PRINT "0 - конец работы"
]60 INPUT R
]70 ON R GOTO 100,200,300
]80 END
] ....
9. РАБОТА С ФАЙЛАМИ
Файлом будем называть группа данных, записанных на
каком-либо (допустимым системой) носителе, которой присвоено ИМЯ -
имя файла. Типичным носителем для компьютеров "Пылдин" является
гибкий магнитный диск (дискета). Все подробности о файлах можно
найти в документах "UniDOS - Руководство пользователя" и "UniBIOS
- Руководство пользователя". Здесь будут введены только основные
понятия.
Имя (полное) файла может состоят из двух частей: собственное
имя и расширение имени. Собственное имя и расширение разделяются
точкой. При написании имени и расширения можно применять латинские
буквы (строчные и прописьные буквы неразличимы), числа и символы:
"@", "#", "$", "&", "_". Имя должно начинаться буквой или
специальным символом и содержать до 8 символов, а расширение - до
трех символов. Как правило, расширение указывает на тип файла,
определенный содержанием. Например: TXT - для текстовых файлов,
UBP - для файлов, содержащих программы на языке BASIC и т.п.
Например:
- правилные имена: MY_PROGR.BAS LET21.TXT LET22
- неправильные имена: MY_PROGRAMM.BAS (имя длиннее 8
символов), 1.111 (первый символ не является буквой или специальным
символом).
Имена файлов на дискете записаны в специальном справочнике,
называемом "директорией". Главная директория (не имеет имени)
может иметь поддиректории, каждая поддиректория - свои
подподдиректории и т.д. Точное указание место нахождения файла
(логическое устройство A: или B:, на котором находится дискета, и
перечень директорий в порядке "старшинства") называется
"траекторией доступа к файлу" или просто траекторией к файлу или
дорожкой к нему (PATH). Имена директорий заканчиваются символов
"\". Например:
A:\DIR2\DIR21\FILE1.TXT означает файл с именем "FILE1.TXT",
записанный в директории "DIR21", которая является поддиректорией
директории DIR2, которая, в свою очередь, является поддиректорией
главной директории "\". Дискета с файлом находится в устройстве
A:.
В любой момент операционная система рассматривает одно устройство
и одну директорию на каждом устройстве в качестве текущих.
Переопределение текущих директорий и текущего устройства
осуществляется специальными командами операционной системы. Если при
ссылке на определенный файл не указано устройство и/или директория, то
по умолчанию не указанные элементы полного имени файла заменяются
соответствующими текущими.
Если файл находится в главной директории и она является текущей,
то ее пустое имя можно не указывать. Например "A:\FILE1.TXT" и
"A:FILE1.TXT" означают одно и то-же.
ВНИМАНИЕ !!! Далее для краткости термином "имя файла" будем
означать полное имя файла с указанием траектории.
Файл в терминах UniBASIC-а можно себе представить как узкую
длинную ленту (file - нитка), на которой можно записать один байт
(8 битов), и по которой движется "головка" осуществляющая чтение
или запись очередного байта, находящегося под ней. Например так:
100010011 позиция 0
001110011 позиция 1
"головка" чтения/записи-> 101111011 позиция 2
000011111 позиция 3
111111111 позиция 4
000000000 позиция 5
.........
Очередной номер байта в файле называется "позицией", а
позиция текущего байта, который может быть прочитан или записан
при следующей операции с файлом называется "указателем файла".
С файлами можно осуществить следующие операции: открытие
файла (файл становится доступным для обработки); чтение данных из
файла; запись данных в файл; позиционирование в файле - присвоение
указателю файла некоторого значения, что соответствует перемещению
"головки чтения/записи" в определенную позицию; закрытие файла
(файл становится недоступным для операций над ним).
ВНИМАНИЕ ! Файлы в UniBASIC-е доступны как для чтения, так и
для записи! Если указатель указывает на уже записанный байт, то
при следующей операции записи новое содержание заменяет старое
содержание байта. Если указатель направлен после последнего уже
записанного файла, то при новой записи создается новый байт - файл
"удлинняется". При каждой операции чтения/записи указатель
"переходит" на байт, следующий за записанным/прочитанным
количеством байтов.
В UniBASIC-е можно работать одновременно с до 10 файлами с
номерами от 0 до 9. "Номер файла" является ключевым понятием
UniBASIC-а и отмечается знаком "#" и номер. Например: #0, #1 и
т.д. При открытии файла осуществляется связь между именем и
номером и далее в программе указывается только номер файла. Номер
#0 служебно присвоен системной консоле - основное логическое
устройство ввода/вывода, которое физически включает в качестве
устройства ввода клавиатуру и в качестве устройства вывода -
дисплей компьютера. Если в операторах ввода/вывода (print, write,
input) не указано другое, подразумевается файл #0 - консола.
UniBASIC работает с ТРЕМЯ ТИПАМИ файлов: программными, двоичными
и текстовыми.
Программные файлы содержат программы, написанные на языке
UniBASIC-а и сохраненные при помощи команды SAVE (см. ниже) в
специальном "компрессированном" виде для экономии памяти.
Двоичные файлы могут содержать данные, содержание фрагмента
оперативной памяти (чаще всего т.н. "графическая страница" - см.
далее) или выполнимые программы, написанные на языке ассемблера
(см. документ "UniASM - Руководство пользователя"и "UniCROSS -
Руководство пользователя".
Текстовые файлы могут содержать программы в исходном виде.
Их запись в файл должна быть осуществлена не-UniBASIC-овыми
средствами - например, текстовым редактором UniED (см. документ
"UniED - Руководство пользователя"). В текстовых файлах запись
производится в т.н. ASCII-формате.
Конечно, Вы понимаете, что можете работать с файлами только,
если к Вашему компьютеру подключены соответствующие устройства:
накопители на гибкых магнитных дисках.
9.1. SAVE - LOAD - MERGE - записать и загрузить программу
Вы наверняка осознали огромное неудобство - после немалых
усилий составили и ввели программу, выполнили ее и после
выключения компьютера потеряли ее. UniBASIC имеет средства
сохранения и многократного применения программ.
Текущую программу (программу, находящуюся в памяти компьютера)
можете записать в дисковом файле при помощи команды SAVE. Она
имеет формат:
SAVE <имя_файла>
где <имя_файла> - строчная переменная, выражение или константа,
содержащая имя файла, в котором будет записана
программа.
При выполнении команды открывается файл, производится запись
и закрывается файл.
По умолчанию подразумеваются:
- текущие устройство и директория;
- расширение имени ".UBP" (от UniBASIC Programm).
Например, если текущими являются устройство A: и главная
директория, следующие команды имееют одинаковый результат:
SAVE "A:\my_progr.ubp"
SAVE "\my_progr.ubp"
SAVE "A:my_progr.ubp"
SAVE "my_progr.ubp"
SAVE "my_progr"
SAVE "A:my_progr"
Для загрузки программы (под загрузкой понимается считывание с
файла и размещение в памяти по адресу, предусмотренному для начала
программ - см. далее "Непосредственный доступ к памяти компьютера")
применяется команда LOAD, имеющая формат:
LOAD <имя_файла>
<Имя_файла> должно удовлетворять рассмотренным выше
требованиям.
При выполнении команды LOAD закрываюся все открытие файлы,
полностью очищается память и загружается новая программа с
указанного файла.
Очевидно, что команда LOAD не всегда удобна. По крайной мере
когда необходимо составить программу из разных кусков или к уже
записанной в памяти программе добавить новые строки. В таких
случаях необходимо применить команду MERGE, имеющую формат:
MERGE <имя_файла>
При выполнении команды, программа (или фрагмент программы),
записаннаю в указанном ТЕКСТОВОМ файле считывается и загружается в
память. Уже находящиеся в памяти и нововведенные программные
строки располагаются в памяти в порядке возрастания своих
идентификаторов. При совпадении идентификаторов новая строка
замещает уже находящуюся в памяти.
9.2. BSAVE - BLOAD - запись - загрузка содержания памяти
Точное содержание фрагмента памяти можно сохранить в дисковом
файле и обратно загрузить в память при помощи команд двоичной
записи и двоичной загрузки.
Команда двоичной записи имеет формат:
BSAVE <имя_файла> [,адрес [,длина ] ]
где: <имя_файла> - имя файла, в котором будет записано содержание
фрагмента памяти;
<адрес> - адрес первого байта фрагмента памяти;
<длина> - длина (в байтах) фрагмента памяти.
Запись не изменяет содержание памяти.
Загрузка памяти с внешнего двоичного файла производится при
помощи команды двоичной загрузки, которая имеет формат:
BLOAD <имя_файла> [,адрес [,длина ] ]
где: <имя_файла> - имя файла, в котором записано новое содержание
фрагмента памяти;
<адрес> - адрес первого байта фрагмента памяти;
<длина> - длина (в байтах) фрагмента памяти. Если указанное
больше свободной памяти - запись производится до
конца памяти. Если указанное больше длины файла,
загружается весь файл.
Если пропущен адрес, загружается с первого свободного байта.
Если пропущена длина, делается попытка загрузить весь файл.
Адрес последнего загруженного при помощи команды
BLOAD файла является значением системной переменной LA, а длина
этого файла - системной переменной LL. Этим переменным нельзя
присваивать значения. Значения этих переменных является значением
по умолчанию параметров "адрес" и "длина" команды BSAVE.
9.3. OPEN - CLOSE - открытие - закрытие файла
Первой операцией с файлами данных является открытие файла.
Только после этой операции файл (его содержание) становится
доступным.
Оператор открытия файла имеет формат:
OPEN#<номер_файла>,<имя_файла>
Номер файла может быть от #1 до #9. Файл с номером #0
(системная консоль) автоматически открывается при вызове
UniBASIC-а и не может быть закрытым.
Имя файла должно удовлетворять указанным выше требованиям.
Расширение имени по умолчанию не предусмотрено.
При открытии указатель файла принимает значение 0 - указывает
на первый байт файла. Номер файла логически связывается с именем
файла и далее в программе применяется только номер файла.
После чтения/записи файл закрывается (становится недоступным)
при помощи оператора CLOSE, имеющего формат:
CLOSE [список_номеров_файлов]
Номера файлов не предшествуются символом "#". Например:
CLOSE 2,8
Если список пропущен, закрываются все открытые файлы.
ВНИМАНИЕ! Своевременное закрытие файла является гарантией от
случайного изменения его содержания и повреждения в случае
технического сбоя!
9.4. PRINT# - WRITE# - INPUT# - LIST# - запись - чтение файла
Операторы вывода PRINT и WRITE уже Вам знакомы. Теперь
покажем их полные форматы, которые применяются при выводе в файл:
PRINT#<номер_файла>,<список_выражений>
WRITE#<номер_файла>,<список_выражений>
ВНИМАНИЕ ! В списке выражений файлового формата оператора
PRINT# в качестве разделителя можно применить ТОЛЬКО символ ";" и
нельзя пользоваться функцией TAB(x).
Напомним, что при применении оператора WRITE значения
выражений будут выведены разделенные запятыми и значения строчных
выражений заключены в кавычках. Такая форма вывода очень удобна
для работы с файлами и рекомендуется в таких случаях.
Применяя оператор PRINT значения будут выведены без
разделителей и без пробелов между ними.
Например, если A=2341, B=4321, C$="Привет, " и D$="ребята!":
после выполнения оператора
WRITE#1,A,C$,D$,B
в файле будет записано:
2341,"Привет, ","ребята!",4321
после выполнения оператора
PRINT#1,A;C$;D$;B
в файле будет записано:
2341Привет, ребята!4321
Полный формат оператора ввода значений переменных имеет вид:
INPUT#<номер_файла>,<список_переменных>
Оператор интерпретируется: с указанного файла поочередно
ввести значения указанных в списке переменных.
ВНИМАНИЕ ! Переменные и вводимые значения должны
соответствовать по типу друг другу. Иначе возникает ошибка.
Ошибка возникает и при попытке прочитать несуществующие в файле
данные (чтение после конца файла).
Существует еще один вариант оператора чтения файла,
предусмотренный специально для ввода строчных переменных. Он имеет
вид:
LINE INPUT#<номер_файла>,<строчная_переменная>[,число_символов]
Оператор интерпретируется следующим образом: с текущей
позиции файла ввести число_символов символа (если пропущено -
один символ) и полученную строку присвоить указанной символной
переменной.
Для записи текущей программы, находящейся в памяти, в
текстовый файл предназначена команда:
LIST#<номер_файла>,[строка_1][ { , - } строка_2]
В файле будет записана программа начиная со
строки_1 до строки_2.
Как видно, для этой команды в силе все оговорки по поводу
ограничителей выводимого фрагмента и разделителей между ними,
описанные при рассмотрении команды LIST (см. 5.6.).
ВНИМАНИЕ ! Программу, записанную в файле при помощи команды
LIST# нельзя загрузить обратно в память. Для такой записи-загрузки
предназначена пара команд SAVE - LOAD.
9.5. SEEK - позиционирование в файле
Смысл позиционирования в файле обсудили выше. Теперь
рассмотрим оператор позиционирования SEEK (найти), применяемый
ТОЛЬКО ДЛЯ ФАЙЛОВ НА ДИСКЕТЕ. Оператор имеет формат:
SEEK [#номер_файла,]<позиция>
Позиция - арифметическое выражение, значение которого
определяет очередной номер байта, на котором позиционируется файл.
Напоминаем, что позиция считается с начала файла и первый байт
занимает позицию "0". Если не указан номер файла, по умолчанию
подразумевается #0.
Например, SEEK#1,0 приведет к позиционированию файла с #1 в
начало файла (первый байт).
Для позиционирования после реального конца файла, что
является подготовкой для последующего дополнения новой записью,
следует применить встроенную функцию LOF(<номер_файла>),
возвращающую длину файла в байтах. Например, для позиционирования
в конец файла с номером 1 следует ввести:
SEEK#1,LOF(1)
Текущую позицию в файле можно узнать при помощи другой встроенной
функции - LOC(<номер_файла). Например, позиционирование на три байта
вперед осуществляется:
SEEK#1,LOC(1)+3
9.6. STORE - RECALL - бинарная запись/ввод массива
В UniBASIC-е предусмотрены специальные операторы для бинарной
записи массива в файл НА ДИСКЕТЕ и для загрузки массива с файла
НА ДИСКЕТЕ.
Оператор бинарной записи массива имеет формат:
STORE [#номер_файла,]<имя_массива>
Если не указан номер файла, по умолчанию подразумевается #0.
Массив будет записан без имени, что позволяет обратно
загрузить его под другим именем.
Загрузка массива с файла в память осуществляется оператором:
RECALL [#номер_файла,]<имя_массива_в_памяти>
Если не указан номер файла, по умолчанию подразумевается #0.
ВНИМАНИЕ ! Пространство памяти, предназначенной для загрузки
массива должно быть достаточным. Иначе наступит сбой.
9.7. PR# - IN# - переопределение стандартных устройств
ввода/вывода
Вы, конечно, помните, что стандартными системными
устройствами ввода/вывода являются клавиатура и дисплей,
соответственно. В ряде случаев такое решение неудовлетворительно и
необходимо назначить другие УЖЕ ОТКРЫТЫЕ файлы в качестве
устройств системного ввода или вывода - переопределить устройства.
Для этой цели предназначены команды:
IN#<номер_файла> - для переопределения устройства ввода
и
PR#<номер_файла> - для переопределения устройства вывода
Если, например, Вы ввели PR#1, то все, что в обычной ситуации
вводится на экран дисплея, будет выводится в файл с номером 1.
10. НЕПОСРЕДСТВЕННЫЙ ДОСТУП К ПАМЯТИ КОМПЬЮТЕРА
Оперативная память компьютера является основным "местом
действия" Ваших программ. В памяти расположены: Ваша программа,
программа UniBASIC (интерпретирующая Вашу программу), системные
программы операционной системы, а также зоны для переменных и
массивов. Любой вводимый оператор, переменная или константа
занимает определенный обем памяти - т.е. Вы (через Ваши команды и
программы) непрерывно осуществляете доступ к памяти. Но
управление этим доступом осуществляется средствами системных
программ (в том числе - UniBASIC-ом). Вы можете осуществить и
непосредственный доступ - читать и/или писать в Вами определенный
байт. Прежде, чем показать как это делается, рассмотрим
распределение памяти - что где находится.
10.1. Распределение памяти
LOMEM: - HIMEM: - границы свободной памяти
Как Вам уже известно, компьютер "Пылдин" располагает памятью
обьемом в 64 килобайта. Минималный адрес памяти - $0000, а
максимальный адрес - $FFFF.
При включении компьютера "сверху" располагается BIOS (базовая
система ввода/вывода), пространство организации текстового экрана,
область ввода/вывода. Все это занимает адреса с $E000 до $FFFF, или 8
KB.
Снизу этой области располагается пространство одной страницы
дополнительного "страничного" ROM-а объемом в 8 KB (с адреса $C000
до $DFFF).
Под страницей ROM-а располагаются резидентные программы UniDOS-а.
Их меньший адрес определяет т.н. "верхная граница" области UniDOS-а.
Верхную границу принято обозначать HIMEM (HIgh MEMory - высокая
память).
Одновременно с этим в младших $0080 байтах располагается
рабочая область UniDOS-а и UniBIOS-а и резервируются $0080 байтов
для служебных целей языковых трансляторов. В этот момент "нижная
граница" свободной области UniDOS-а, т.н. LOMEM (LOw MEMory -
низкая память) определяется адресом $0100. В верхной части
"предоставленной" области UniDOS формирует свой системный стек.
Если у Вас ROM-версия UniBASIC-а, при вызове он загружается в
область памяти, предоставленной для страницы ROM-а и оставляет под
системным стеком 2 KB свободной области для UniDOS-а. Таким
образом LOMEM UniDOS-a, совпадающий с HIMEM UniBASIC-а
"поднимается" сильно вверх. Снизу формируется рабочая область
UniBASIC-а объемом в $0100 байт. Таким образом формируется LOMEM
UniBASIC-а.
Если у Вас дисковая версия UniBASIC-а, при вызове он
резервирует рабочую область с адреса $0100 длиной 256 байтов и
загружается снизу вверх, занимая 12 KB памяти, "выталкивая" вверх
свой LOMEM.
Так, между LOMEM и HIMEM UniBASIC-а формируется свободная для
работы область.
Вводимые операторы программы разполагаются снизу вверх.
При стартировании программы (команда RUN), над программой
последовательно отделяется пространство и располагаются сначала
арифметические переменные, а потом - массивы. Строчные переменные
располагаются с HIMEM вниз.
Макс.адрес $FFFF > +-------------------------+
|BIOS, текстовый экран, |
|область ввода/вывода |
$E000 > |-------------------------|
|страница доп. ROM-а |
$C000 > |-------------------------|
|резидентные программы |
|UniDOS-а |
|-------------------------|
|граф.экран и BLOAD-файлы |
|-------------------------|<UniDOS HIMEM
|системный стек |
|-------------------------|
|свободная область |
|UniDOS-а (2 KB) |
|-------------------------|<UniDOS LOMEM =
|строчные переменные | UniBASIC HIMEM
|-------------------------|
| свободная область |
| UniBASIC-а |
|-------------------------|
|массивы |
|-------------------------|
|числовые переменные и |
|функции |
|-------------------------|
|программы на UniBASIC-е |
$3200> |-------------------------|<Disk-UniBASIC LOMEM
| интерпретатор UniBASIC | при вызове
| в "дисковом" варианте |
$0200> |-------------------------|<ROM-UniBASIC LOMEM
|раб.область UniBASIC-а | при вызове
$0100> |-------------------------|<UniDOS LOMEM при
|раб.область языков.тр. | включении "Пылдина"
$0080> |-------------------------|
|раб.область BIOS/DOS |
Миним.адрес $0000> +-------------------------+
В UniBASIC-е LOMEM и HIMEM играют роль специальных системных
переменных и отмечаются LOMEM: и HIMEM:. Им можно присвивать
новые значения, НО РЕКОМЕНДУЕМ ДЕЛАТЬ ЭТО ОЧЕНЬ ВНИМАТЕЛЬНО !!!
Для более полных сведений о распределении памяти,
предназначении рабочих областей и использовании системных
переменных обратитесь к документу "UniBIOS - Руководство
пользователя".
10.2. PEEK - DEEK - чтение байта и слова памяти
Для чтения одного байта памяти, находящегося по указанному
адресу, применяется ФУНКЦИЯ PEEK, имеющая формат:
PEEK ( <выражение> )
где <выражение> - арифметическое выражение с допустимым целым
значением в интервале 0 - 65535.
Функция возвращает целое число в диапазоне 0 - 255,
являющееся значением байта с указанным адресом.
Для чтения двух последовательных байтов памяти, первый из
которых находится по указанному адресу применяется ФУНКЦИЯ DEEK,
имеющая формат:
DEEK ( <выражение> )
где <выражение> - арифметическое выражение с допустимым целым
значением в интервале 0 - 65534.
Функция возвращает целое число в диапазоне 0 - 65535,
являющееся значением двух байтов с указанным адресом.
Например, что бы узнать первый байт указателя начала
циклического магазина буферирования клавиатуры следует ввести:
B1 = PEEK($ED0E)
а всего указателя (состоящего из двух байтов) -
B = DEEK($ED0E)
Модель своего компьютера можно узнать, прочитав два байта с
начальным адресом $FFF7:
model = DEEK($FFF7)
Если model = 0, то модель Вашего компьютера "601", а если
model = 128 - то модель "601 А".
10.3. POKE - DOKE - запись байта и слова в память
Запись одного байта по указанному адресу осуществляется при
помощи оператора POKE, имеющий формат:
POKE <адрес>,<выражение>
где <адрес> - арифметическое выражение с целой частью в диапазоне
0 - 65535;
<выражение> - арифметическое выражение с целой частью в
диапазоне 0 - 255.
Запись двух последовательных байтов осуществляется при
помощи оператора DOKE, имеющий формат:
DOKE <адрес>,<выражение>
где <выражение> - арифметическое выражение с целой частью в
диапазоне 0 - 65535.
ВНИМАНИЕ ! БУДЬТЕ ОЧЕНЬ ОСТОРОЖНЫ ПРИ НЕПОСРЕДСТВЕННОЙ ЗАПИСИ
В ПАМЯТЬ КОМПЬЮТЕРА! ОШИБКА МОЖЕТ ПРИВЕСТИ К ОЧЕНЬ СЕРИОЗНЫМ
ПОСЛЕДСТВИЯМ !
11. ВСТРОЕННЫЕ ФУНКЦИИ
Встроенные функции UniBASIC-а по характеру результата делятся
на две группы: числовые (результат - число) и строчные (результат
- строка символов).
Принято говорить, что функция "возвращает" некий результат.
Формальное отличие функции - обязательность параметра и его
указание в круглых скобках.
Далее в изложении применяются следующие сокращения:
ч_выр - численное выражение;
с_выр - строчное выражение;
пер - переменная (числовая или строчная) или элемент
массива.
11.1. ЧИСЛОВЫЕ ФУНКЦИИ
Вы уже познакомились с двумя числовыми функциями: PEEK и
DEEK. Из-за специального предназначения они рассмотрены подробно в
другой главе документа (см. 10.2.)
11.1.1. ABS - абсолютная величина
Формат: ABS(<ч_выр>)
Возвращает: абсолютная величина значения выражения.
11.1.2. ADR - адрес
Формат: ADR(<пер>)
Возвращает: адрес (0 - 65535) указанной переменной или
элемента массива.
11.1.3. ASC - ASCII код
Формат: ASC(<с_выр>[,n])
Возвращает: ASCII-код n-ного символа значения строчного
выражения. По умолчанию n=1.
11.1.4. ATN - аркустангенс
Формат: ATN(<ч_выр>)
Возвращает: аркустангенс от аргумента. Считается, что
аргумент указан в РАДИАНАХ.
11.1.5. COS - косинус
Формат: COS(<ч_выр>)
Возвращает: косинус от аргумента. Считается, что аргумент
указан в РАДИАНАХ.
11.1.6. DEEK - содержимое слова памяти
Формат: DEEK(<ч_выр>)
Возвращает: содержимое слова (двух последовательных байтов)
памяти с адресом = ч_выр (см. 10.2.)
11.1.7. EOF - достижение конца файла
Формат: EOF(<номер_файла>)
Возвращает: 1, если достигнут конец файла; 0, если
конец файла не достигнут.
11.1.8. EXP - экспонента
Формат: EXP(<ч_выр>)
Возвращает: экспонента от аргумента (неперовое число
e=2.718289 в степени аргумента).
11.1.9. FIX - целая часть числа
Формат: FIX(<ч_выр>)
Возвращает: целая часть значения выражения.
11.1.10. FRAC- дробная часть числа
Формат: FRAC(<ч_выр>)
Возвращает: дробная часть значения выражения.
11.1.11. FRE - объем свободной памяти
Формат: FRE(<ф_пар>)
Возвращает: объем доступной свободной памяти. Выполнение
функции приводит к "сжатию" строчных переменных.
11.1.12. INSTR - поиск подстроки в строке
Формат: INSTR(<с_выр_1>,<с_выр_2>[,ч_выр])
Возвращает: номер позиции в строке, являющейся значением
с_выр_1, с которой строка, являющаяся значением с_выр_2,
содержится в качестве подстроки. Поиск начинается с позиции
ч_выр, если задано, иначе - с первой позиции. Если с_выр_2 не
содержится в с_выр_1, возвращается 0. Если с_выр_2 пустая строка,
возвращается ч_выр при любых с_выр_1.
Примеры: INSTR("alabala","aba") возвратит 3;
INSTR("alabala","aba",4) возвратит 0;
INSTR("alabala","",5) возвратит 5.
11.1.13. INT - целое число
Формат: INT(<ч_выр>)
Возвращает: самое большое целое число, которое меньше или
равно значению выражения.
11.1.14. LEN - длина строки
Формат: LEN(<с_выр>)
Возвращает: длина значения строчного выражения.
11.1.15. LOC - текущая позиция в файле
Формат: LOC(<номер_файла>)
Возвращает: номер текущей позиции в файле с указанным номером
(физически первая позиция имеет номер 0).
11.1.16. LOF - номер последней позиции в файле
Формат: LOF(<номер_файла>)
Возвращает: номер последней позиции в файле с указанным
номером (физически первая позиция имеет номер 0).
11.1.17. LOG или LN - натуральный логарифм
Формат: LOG(<ч_выр>)
LN(<ч_выр>)
Возвращает: натуральный логарифм от значения выражения.
11.1.18. PEEK - содержимое слова памяти
Формат: PEEK(<ч_выр>)
Возвращает: содержимое байта памяти с адресом = ч_выр (см.
10.2.)
11.1.19. POS - позиция курсора в строке
Формат: POS(<ф_пар>)
Возвращает: позиция курсора в строке экрана.
11.1.20. RND - случайное число
Формат: RND(<ч_выр>)
Возвращает: случайное число больше или равно нуля и меньше
единицы. Если ч_выр имеет положительное значение, то при каждом
выполнении функции генерируется новое случайное число. Если ч_выр
имеет отрицательное значение, то каждой раз, когда функция
выполняется с таким аргументом возвращается то-же самое случайное
число. Если ч_выр = 0, то возвращается последное генерированное до
сих пор случайное число.
11.1.21. SGN - знак числа
Формат: SGN(<ч_выр>)
Возвращает: 1 - если значение выражения > 0; -1 - если
значение выражения < 0; 0 - если значение выражения = 0.
11.1.22. SIN - синус
Формат: SIN(<ч_выр>)
Возвращает: синус от аргумента в РАДИАНАХ.
11.1.23. SPC - вывод символов перед выводом значения
Формат: SPC(<ч_выр>[,<с_выр] )
Действие: вывод <ч_выр> раз первого символа значения <с_выр>
при выполнении оператора PRINT. По умолчанию <с_выр> = " " (вывод
пробелов). Пример применения: PRINT a;SPC(3);b - значения
переменных a и b разделены тремя пробелами.
11.1.24. SQR - корень квадратный
Формат: SQR(<ч_выр>)
Возвращает: положительный квадратный корень от аргумента.
11.1.25. TAN - тангенс
Формат: TAN(<ч_выр>)
Возвращает: тангенс от аргумента в РАДИАНАХ.
11.1.26. USR - потребительская функция на ассемблере
Формат: USR(любое_выражение)
Предназначение: выполнение функции, запрограммированной на
языке ассемблера потребителем. Адрес, по которому передается
управление при применении функции, определяется DEFUSR (см.12.3).
11.1.27. VAL - превращение строки цифер в число
Формат: VAL(<с_выр>)
Действие: слева направо старается рассматривать значение
строчного выражения в качестве целого числа, или естественного
числа в нормальной форме, или естественного числа в
экспоненциальной форме. Например, VAL("1.23E2A4.B3") возвратит
123. Если не найдено изображения числа - возвращает 0.
11.2. СТРОЧНЫЕ ФУНКЦИИ
Напомним, строчными называются функции, результатом
выполнении которых является строка символов (или отдельный
символ).
11.2.1. CHR$ - символ с заданным кодом
Формат: CHR$(<ч_выр>)
Возвращает: символ, код которого является значением
выражения. Значение выражения должно быть в диапазоне 0 - 255.
Например, CHR$(12) - генерирует код символа перехода на новую
стрницу печати; CHR$(15) - генерирует управляющий символ печати
т.н. конденсированного шрифта (суженного - 250 символов в строке);
CHR$(18) - управляющий символ печати нормальным шрифтом (132
символа в строке).
11.2.2. HEX$ - превращение в шестнадцатеричную форму записи
Формат: HEX$(<ч_выр>)
Возвращает: строку символов, представляющую собой
шестнадцатеричную форму значения числового выражения. Выражение
должно иметь значение в границах от -65536 до +65535. Если
выражение имеет отрицательное значение, функция возвращает
шестнадцатеричную запись числа (65536 - ABS(<ч_выр>).
11.2.3. LEFT$ - левая подстрока строки
Формат: LEFT$(<с_выр>,<ч_выр>)
Возвращает: строку символов, содержащую самые левые <ч_выр>
символа строки <с_выр>. Если <ч_выр> больше длины строки <с_выр> -
возвращается строка <с_выр>.
11.2.4. MID$ - подстрока строки
Формат: MID$(<с_выр>,<ч_выр_1>[,ч_выр_2])
Возвращает: строку символов, содержащую <ч_выр_2> символов
строки <с_выр>, начиная с <ч_выр_1>- символа, считая слева
направо. Если <ч_выр_2> больше ((длины строки <с_выр>) -
<ч_выр_2>) возвращаемая строка дополняется пробелами. Если
<ч_выр_2> пропущено, возвращаеются символы, начиная с <ч_выр_1> до
конца строки <с_выр>.
Пример: MID$("строка - оригинал",5,7) возвратит строку
"ка - ор", MID$("строка - оригинал",10) возвратит строку
"оригинал".
11.2.5. RIGHT$ - правая подстрока строки
Формат: RIGHT$(<с_выр>,<ч_выр>)
Возвращает: строку символов, содержащую самые правые <ч_выр>
символа строки <с_выр>. Если <ч_выр> больше длины строки <с_выр> -
возвращается строка <с_выр>.
11.2.6. SPC$ - генерирование строки одинаковых символов
Формат: SPC$(<ч_выр>[,<с_выр] )
Действие: строка символов, содержащая <ч_выр> раз первый
символ значения <с_выр>. По умолчанию <с_выр> = " " (строка из
пробелов).
11.2.7. STR$ - десятичная форма записи числа
Формат: STR$(<ч_выр>)
Возвращает: значение (в десятичной форме записи) выражения в
виде строки символов.
11.3. СИСТЕМНЫЕ ПЕРЕМЕННЫЕ
В UniBASIC-е имеются системные переменные. Две из них (LOMEM:
и HIMEM:) связаны с распределением памяти и подробно рассмотрены в
10.1.
11.3.1. CH - горизонтальная позиция курсора в текстовом
режиме
Формат: CH
Тип: реальная
Предназначение: текущая горизонтальная позиция курсора в
текстовом режиме
11.3.2. CV - вертикальная позиция курсора в текстовом
режиме
Формат: CV
Тип: реальная
Предназначение: текущая вертикальная позиция курсора в
текстовом режиме
11.3.3. DATE$ - системная дата
Формат: DATE$
Тип: строчная
Предназначение: сохранение системной даты в строке символов с
форматом:
"dd-mmm-yyyy"
где: dd - день (01 - 31)
mmm - месяц (JAN, FEB, MAR, APR, MAY, JUN,
JUL, AUG, SEP, OCT, NOV, DEC)
yyyy - год
11.3.4. ERR - код ошибки
Формат: ERR
Тип: реальная
Предназначение: код последней возникшей ошибки (0 - если не
возникла).
11.3.5. ERRLN - строка ошибки
Формат: ERRLN
Тип: реальная
Предназначение: идентификатор строки, в которой находится
оператор, при выполнении которого возникла последняя ошибка (0 -
если не возникла ошибка).
11.3.6. GH - горизонтальная позиция курсора в графическом
режиме
Формат: GH
Тип: реальная
Предназначение: текущая горизонтальная позиция курсора в
графическом режиме
11.3.7. GV - вертикальная позиция курсора в графическом
режиме
Формат: GV
Тип: реальная
Предназначение: текущая вертикальная позиция курсора в
графическом режиме
11.3.8. KEY$ - нажатая клавиша
Формат: KEY$
Тип: строчная
Содержит: символ первой нажатой клавиши в буфере клавиатуры
или пустая строка, если нет нажатой клавиши.
11.3.9. LA - адрес загрузки файла при последней выполненной
команде BLOAD
Формат: LA
Тип: числовая
Предназначение: адрес загрузки файла при последней
выполненной команды BLOAD
11.3.10. LL - длина файла при последней выполненной
команде BLOAD
Формат: LL
Тип: числовая
Предназначение: длина файла, загруженного при последней
выполненной команды BLOAD
11.3.11. PI - число "пи"
Формат: PI
Тип: реальная
Значение: 3.141592
11.3.12. TIME$ - системное время
Формат: TIME$
Тип: строчная
Предназначение: сохранение системного времени в строке
символов с форматом:
"hh:mm:ss.cc"
где: hh - час (00 - 23);
mm - минута (00 - 59);
ss - секунда (00 - 59);
cc - сотая секунды (00 - 99).
При вводе можно пропускать справо налево составляющие
времени (не вводятся и разделители). Пропущенные составляющие
получают значение ":00"
12. ОПРЕДЕЛЕНИЯ
В UniBASIC-е предусмотрена возможность ввода некоторых
т.н. потребительских определений: "программирование"
функциональных клавиш, потребительских функций (однооператорных на
языке UniBASIC-а и многооператорной на языке ассемблера) и
указателя адреса. Указанные возможности в большой степени облекчат
Вашу работу.
12.1. DEFKEY - программирование функциональных клавиш
В самом начале документа показано значение функциональных
клавиш F1 - F10 "по умолчанию". При вызове UniBASIC-а эти значения
отображены в 26 строке экрана.
При выполнении некоторой программы отображение значений
функциональных клавиш на экране будет только мешать потребителю.
Для переключения изображения предусмотрен следующий формат команды
определения значения функциональных клавиш:
DEFKEY [выражение]
Если значение выражения равно 0, то изображение значений
клавиш на экране прекращается, если значение не равно 0 -
изображение восстанавливается.
Если выражение пропущено - производится альтернативное
переключение показа значении функциональных клавиш.
Если значение по умолчанию некоторой клавиши Вас не
устраивает, то Вы можете "запрограммировать" ее заново.
Программирование одной отдельной из первых 12 функциональной
клавиши осуществляется командой:
DEFKEY <ч_выражение>,<с_выражение>
Числовое выражение определяет своим значением функциональную
клавишу по следующей конвенции(в колонке "клавиша" перечислены
функциональные клавиши, которые могут быть запрограммированы; в
колонке без названия показаны значения, соответствующие нажатия
только соответствующей клавиши; в колонке "Shift" - при
одновременно нажатии клавиши "Shift" и соответствующей
функциональной клавиши; в колонке "Ctrl" - при одновременно
нажатии клавиши "Ctrl" и соответствующей функциональной клавиши):
клавиша Shift Ctrl
--------------------------------------
F1 1 13 25
F2 2 14 26
F3 3 15 27
F4 4 16 28
F5 5 17 29
F6 6 18 30
F7 7 19 31
F8 8 20 32
F9 9 21 33
F10 10 22 34
F11 11 23 35
F12 12 24 36
Строчное выражение определяет значение функциональной клавиши
- текста, появляющегося с текущей позиции курсора при нажатии
функциональной клавиши или комбинации с Shift или CRTL.
Пример: допустим, что хотите запрограммировать клавишу F11
таким образом, что-бы при ее нажатии появлялось "IF", при нажатии
Shift и F11 - "THEN", а при нажатии Ctrl и F11 - "ELSE". Для этого
необходимо ввести команды:
DEFKEY 11,"IF "
DEFKEY 23,"THEN "
DEFKEY 35,"ELSE "
Указанные команды можно применить и в качестве операторов.
12.2. DEFFN - определение потребительской функции,
запрограммированной на UniBASIC-е
FN - применение потребительской функции
Оператор определения потребительской функции имеет вид:
DEFFN <имя>(<список_аргументов>) = <выражение>
где: <имя> - имя функции - подчиняется правилам определения имен
простых реальных переменных;
<список_аргументов> - перечень простых реальных переменных,
являющихся аргументами функции;
<выражение> - арифметическое или строчное выражение
указанных аргументов, значение которого возвращается
в качестве значения функции. Тип значения должен
совпадать с типом, определенным именем функции. В
выражении можно применять и встроенные функции.
Например, определим функцию вычисления площади окружности по
ее радиусу:
DEFFN ca(r) = PI*r*r
Определим функцию вычисления площади прямоугольного
триугольника по катетам:
DEFFN ta(a,b) = a * b / 2
Применение потребительской функции усуществляется по правилам
применения встроенных функции с указанием ключевого слова
FN перед именем потребительской функции. Например:
]10 DEFFN ta(a,b) = a * b / 2
]20 INPUT a,b
]30 c= FN ta(a,b)
]40 PRINT c
RUN
25
12.3. DEFUSR - определение потребительской функции,
запрограммированной на ассемблере
Кроме потребительских функций, определенных при помощи
выражений на языке UniBASIC-а, UniBASIC позволяет применять и одну
потребительскую функцию с именем USR, программированную на языке
ассемблера (см. "UniASM - Руководство пользователя") и загруженную
в память компьютера при помощи команды BLOAD. Определение этой
функции осуществляется при помощи оператора:
DEFUSR=<адрес>
где <адрес> - адрес в памяти, по которому передается управление
при выполнении функции.
Если <адрес>=0, функция дезактивируется.
Функция USR должна быть в исполнимом виде - в абсолютных
адресах и в программах на UniBASIC-е применяется в выражениях
типа:
v=USR([выражение])
12.4. DEF& - определение указателя памяти
& - применение указателя памяти
Применение указателя памяти позволяет в программах на
UniBASIC-е иметь более одной потребительской функции, написанной
на ассемблере. Как и при USR, потребительские функции загружаются
по заранее определенным адресам при помощи BLOAD. В
программе на UniBASIC-е можно определить указатель адреса при
помощи оператора:
DEF& = <адрес>
Дальше в программе на UniBASIC-е символ "&" интерпретируется
в качестве оператора передачи управления по адресу,
присвоенному указателю. Ассемблерская функция должна сама
позаботиться об обмене аргументами и об возврате управления. Как
правило, за оператором безусловного перехода по адресу "&"
вводятся имена аргументов.
Если <адрес>=0 то указатель дезактивируется.
13. В МИРЕ ЦВЕТА, ГРАФИКИ И МУЗЫКИ
До сих пор Вы усвоили команды и операторы, позволяющие
пользоваться вычислительными возможностями компьютера "Пылдин". В
этой главе рассмотрим возможности цветного изображения,
графические и звуковые возможности компьютера.
В самом начале напомним, что именно в области графики существуют
существенные отличия между моделей "601" и "601-А" (см. пункт 1.7.
настоящего документа). Модель "601-У" по своим графическим
возможностям соответствует модели "601", а модель "601-М" - модели
"601-А".
Далее в изложении термином backgr (background) означается
цвет фона изображения, а термином foregr (foreground) - цвет
изображения (буквы или линии).
Кроме цветности, изображение буквы имеет еще одну
характеристику - мерцание. Мерцание включается или отключается -
т.е. изображение буквы мигает или остается постоянным. Вы
наверняка уже заметили, что при изображение курсора мерцание
включено. Для UniBASIC-а мерцание является характеристикой цвета.
Допустимые цвета кодируются следующими кодами (для backgr
допустимы коды с 0 до 7, а foregr - линия с 0 до 15 forgr -
буква с 0 до 23):
0 - черный; 8 - ярко черный (серый);
1 - синий; 9 - ярко синий;
2 - зеленый 10 - ярко зеленый
3 - сине-зеленый; 11 - ярко сине-зеленый;
4 - красный; 12 - ярко красный;
5 - фиолетовый; 13 - ярко фиолетовый;
6 - желтый; 14 - ярко желтый;
7 - белый; 15 - ярко белый;
16 - мерцающий черный;
17 - мерцающий синий;
18 - мерцающий зеленый
19 - мерцающий сине-зеленый;
20 - мерцающий красный;
21 - мерцающий фиолетовый;
22 - мерцающий желтый;
23 - мерцающий белый;
Основные 16 цветов (с кодами 0 - 15) разделены в четирех палитрах
(группах):
1 палитра: 0, 2, 4, 6;
2 палитра: 1, 3, 5, 7;
3 палитра: 8,10,12,14;
4 палитра: 9,11,13,15.
Компьютер "Пылдин" может работать в пяти режимах изображения
(видеорежимах). В следующей таблице показаны допустимые значения
режима и соответствующая разделительная способность
(число_символов/число_строк или
точек_по_горизонтали/точек_по_вертикали) для основных моделей
компьютера.
----------------------------------------------------------------
Код | Режим | 601 | 601-A
----------------------------------------------------------------
0 текстовый 40/25 черно/белый цветной
1 графика в 16 цветах 80/200 точек 160/200 точек
2 графика в 4 цветах 160/200 точек 320/200 точек
3 графика в 2 цветах 320/200 точек 640/200 точек
4 текстовый 80/25 не допускается черно/белый
В режиме 0 допускается foregr с 0 до 23; backgr - с 0 до 15.
В режиме 1 не допускается вывод текста, а для выводимых линий
и точек допускаются как для foregr так и для backgr цвета с 0 до
15.
В режиме 2 допускается вывод и текста и графики, но цвета
foregr и backgr должны быть выбраны из одной палитры.
В режиме 3 допускается вывод текста и графики в черно/белом
изображении.
Во всех режимах экран имеет следующие ЛОГИЧЕСКИЕ координаты:
0,0 --------> 639
|
|
399
Физические координаты автоматически определяются в
зависимости от режима работы.
13.1. SCREEN - переключение режимов изображения
Команда и оператор переключения видеорежима (режима
изображения) имеет вид:
SCREEN [режим [,foregr [,backgr [,flag ] ] ] ]
где: режим - видеорежим (0 - 4);
по умолчанию: backgr = 0 (черный фон);
foregr = 15 (ярко белое изображение).
flag = 0 - черно/белое изображение (по умолчанию);
flag <> 0 - цветное изображение.
При изменении режима экран очищается.
Заданный режим остается в силе до следующего переключения.
Примеры:
SCREEN 0 - переключение в 40-символный черно/белый текстовый
режим;
SCREEN 0,7,1,1 - переключение в 40-символьный текстовый режим с
белыми буквами на синем фоне.
Напомним, что SCREEN без параметров приводит к очистке
экрана.
13.2. COLOR - определение цветов изображения текста в
текстовом или графическом режиме
Цветность изображения можно изменить без переключения режима
при помощи команды и оператора COLOR:
COLOR foregr [,backgr [,flag] ]
Отдельные параметры указаны выше.
13.3. PEN - определение цвета и вида линии в графическом
режиме
В графическом режиме цвет и вид линии изображения
определяется оператором:
PEN <цвет>[,изображение]
где: <цвет> - код цвета изображения;
<изображение> - код вида изображения (по умолчанию = 0 ).
Реальное изображение (свечение точки экрана) определяется
функциями уже существующего изображения (свечения) и нового
изображения. Существующее изображение отметим символом S,
поступающий сигнал переключения - символом P, а новое состояние
(свечение) точки - символом N. В следующей таблице показаны
допустимые значения параметра <изображение> и соответствующие
функции. 0 означает что точка не светится, а 1 - что светится.
-------------------------- --------------------------
код функция код функция
-------------------------- --------------------------
0 N = P 7 N = NOT S
1 N = S XOR P 8 N = S OR P
2 N = 1 9 N = NOT S AND P
3 N = NOT P 10 N = NOT S OR P
4 N = 0 11 N = NOT (S AND P)
5 N = S 12 N = S AND NOT P
13 N = S AND P
13.4. LINE - изображение линии
Линию на экране в графическом режиме можно изобразить при
помощи команды и оператора LINE.
LINE [ [STEP] X_1,Y_1 ] TO [STEP] X_2,Y_2
X_1 и Y_1 - координаты начала линии. Если введено
зарезервированное слово STEP координаты вычисляются относительно
текущей позиции - X_1 и Y_1 интерпретируются в качестве
наращивания координат. Реальные координаты начальной точки
вычисляются: X_н = X_т + X_1; Y_н = Y_т + Y_1, где X_н и Y_н -
координаты начальной точки линии; где X_т и Y_т - координаты
текущей позиции курсора.
X_2 и Y_2 - координаты конца линии. Интерпретируются как и
координаты начала линии.
Если начальные координаты пропущены - линия проводится с
текущей позиции курсора.
Примеры: курсор находится в точке с координатами 5,5.
1. Провести линию с текущей позиции до точки 20,20
решение а/: LINE TO 20,20
б/: LINE TO STEP 15,15
в/: LINE 5,5 ТО 20,20
г/: LINE 5,5 TO STEP 15,15
2. Провести линию с точки 20,1 до точки 20,20
решение а/: LINE STEP 15,-4 TO 20,20
б/: LINE STEP 15,-4 TO STEP 15,15
в/: LINE 20,1 ТО 20,20
г/: LINE 20,1 TO STEP 15,15
13.5. POINT - изображение точки
Точку на экране в графическом режиме можно изобразить при
помощи команды и оператора POINT.
POINT [ AT ] [ [STEP] X,Y ]
X и Y - координаты точки. Если введено зарезервированное
слово STEP координаты вычисляются относительно текущей позиции - X
и Y интерпретируются в качестве наращивания координат. Реальные
координаты начальной точки вычисляются: X_т = X_к + X; Y_т = Y_к
+ Y, где X_т и Y_т - координаты точки; где X_к и Y_к - координаты
текущей позиции курсора.
Если координаты пропущены - точка изображается в текущей
позиции курсора.
13.6. MOVETO - перемещение графического курсора
Курсор экрана в графическом режиме можно перенести в новую
позицию при помощи команды и оператора MOVETO.
MOVETO [STEP] X,Y
X и Y - новые координаты курсора. Если введено
зарезервированное слово STEP, координаты вычисляются относительно
текущей позиции - X и Y интерпретируются в качестве наращивания
координат.
13.7. CIRCLE - изображение элипсы
Элипса с осями, паралельными осям экрана, можно начертить при
помощи оператора CIRCLE с форматом:
CIRCLE <X_радиус>[,Y_радиус] [AT [STEP] X_центр,Y_центр]
где: X_радиус - длина радиуса по оси X;
Y_радиус - длина радиуса по оси Y (если пропущено, по
умолчанию Y_радиус = X_радиус - изображается
окружность);
X_центр и Y_центр - координаты центра; если STEP - координаты
относительные (вж. 13.4.). Если пропущена
конструкция AT - центр - текущая позиция курсора.
Радиусы задаются числом точек.
13.8. DISC - изображение диска (заполненной элипсы)
Оператор изображение диска аналогичен оператору изображения
элипсы с единственной разницей, что пространство элипсы
заполняется цветом, определенным оператором PEN. Оператор DISC
имеет формат:
DISC <X_радиус>[,Y_радиус] [AT [STEP] X_центр,Y_центр]
13.9. BAR - изображение заполненного прямоуголника
В UniBASIC-е заполненный прямоуголник со сторонами,
паралельными осями экрана, можно изобразить задаваясь двумя
противоположными вершинами (северозападным и юговосточным, или
северовосточным и югозападным) при помощи оператора BAR с
форматом:
BAR [ [STEP] X_1,Y_1 ] TO [STEP] X_2,Y_2
Координаты вершин можно указать в абсолютном или в
относительном - применяя зарезервированное слово STEP - виде.
Если координаты X_1,Y_1 пропущены, считается, что вершина
находится в текущей позиции курсора.
13.10. DRAW - изображение потребителького символа
UniBASIC позволяет задаться своими собственными символами
(графическими изображениями). Символ задается последовательностю
команд поднятия, опускания и продвижения "пера" изображения,
начиная с текущей позиции курсора. Как помните, текущие
координаты курсора содержатся в переменных GH и GV.
Последовательность должна содержаться в строчной переменной.
Применяются следующие команды:
P - альтернативное поднятие/опускание "пера". Начальное
состояние - опущенное. Естественно, при движении опущенного пера
остается след - проводится линия.
Команды продвижения пера на x ( 1 <= x <= 16) точек (по
умолчанию x=1):
U[x] - вверх; E[x] - на северозапад;
D[x] - вниз; F[x] - на северовосток;
L[x] - влево; G[x] - на юговосток;
R[x] - вправо; H[x] - на югозапад.
Например, для задания заполненного квадрата со стороной в 3
точки переменной A$ следует ввести:
A$="R3U1L2U1R2"
Для изображения заданного символа применяется оператор DRAW с
форматом:
DRAW <симв_перем>[,ротация [,маштаб [,выход]]] [AT [STEP] <X,Y>]
где: симв_перем - символная переменная, содержащая описание
символа;
ротация - ротация символа по часовой стрелке в шагах по 45°
(допустимые значения: 0 - 7; по умолчанию = 0);
маштаб - коэффициент увеличения символа при изображении
(допустимые значения: 1 - 16; по умолчанию = 1);
выход - указатель позиции, в которой находится находится
курсор после изображения символа (если = 0 - курсор
остается в последней точки символа; если = 1 -
возвращается в исходную позицию; по умолчанию = 0);
конструкция AT ... предназначена для указания позиции вывода
символа с абсолютных (слово STEP пропущено), или
относительных координатах X,Y. Если конструкция
пропущена, символ изображается в текущей позиции
курсора.
13.11. SOUND - воспроизводство звука
Для воспроизводства одного звука заданной частоты и
продолжительности предназначен оператор SOUND с форматом:
SOUND <частота>,<продолжительность>
где: частота задается в герцах (Hz);
продолжительность задается в милисекундах (ms).
13.12. PLAY - воспроизводство мелодии
Для воспроизведения мелодии применяется оператор PLAY с
форматом:
PLAY <список_строчных_переменных>
В каждой строчной переменной должны быть записаны команды
воспроизведения ноты и/или переключения октав, тембров и т.д.
Команда воспроизведения ноты имеет формат:
<нота>[#][n][.[.[. ... ]]]
где: нота - код ноты:
C - до; G - соль;
D - ре; А - ля;
E - ми; B - си;
F - фа;
# - диез;
n - тип ноты: 1 - целая; 2 - 1/2; 3 - 1/4; 4 - 1/8 и т.д. до
тип = 128 (по умолчанию n=2);
. - пауза после ноты; каждая следующая точка добавляет паузу,
длиной на 1/2 предидущей.
Допустимо воспроизведение нот в шести октавах. Вместе с
полутонами, все тоны и полутоны имеют последовательные номера от 0
до 72. Команда воспроизведения тона (или полутона) с заданным
порядковым номером n имеет вид:
Nn,длина[,звучание]
где: длина - общая длина воспроизведения в 1.536
миллисекундах;
звучание - продолжительность звучания самой ноты;
звучание <= длина
Другие команды:
L[n] - тип ноты по умолчанию (в интервале 1 - 128), по
умолчанию n = 4 (одна восьмая);
O[n] - октава (в интервале 1 - 6), по умолчанию n = 4;
T[n] - тембр (в интервале 1 - 7), по умолчанию n = 1;
P[n][.[.[. ... ]]] - пауза - задается аналогично ноте;
> - переход на следующую октаву;
< - переход на предидущую октаву;
MN - нормальное воспроизведение;
ML - легатто;
MS - стакатто.
Например, команда воспроизведения нот четвертой и пятой
октавы выглядит, примерно, так:
PLAY "CDEFGAB>CDEFGAB"
14. СВЯЗЬ С ОКРУЖАЮЩИМ МИРОМ
Во время работы UniBASIC-а Вы имеете возможность связи с
окружающим (Вашей программы) миром (Вашего компьютера). Прежде
всего - это возможность выполнить команду операционной системе
UniDOS (см. документ "UniDOS - Руководство пользователя") и вызов
системной программы MONITOR (см. документ "UniBIOS - Руководство
пользователя).
14.1. SHELL - выполнение команды операционной системе UniDOS
Для обращения к операционной системе UniDOS применяется
команда и оператор SHELL с форматом:
SHELL [строчное_выражение]
Строчное_выражение должно содержать команду операционной
системе. Если пропущено, то управление передается операционной
системе - появляется промпт системы. Для возврата в UniBASIC, в
таком случае, необходимо ввести команду EXIT.
14.2. MON - вызов системной программы MONITOR
Для вызова программной системы MONITOR предназначена команда
MON с форматом:
MON
Команда не имеет параметров.
Для возврата к UniBASIC-у необходимо выполнить команду
MONITOR-а q (quit):
q
14.3. CALL - передача управления по заданному адресу
Управление можно передать по заданному адресу памяти при
помощи оператора CALL с форматом:
CALL <адрес>
Адрес задается в границах 0 - 65535.
Если указанный адрес меньше 256, выполнение оператора
приводит к системному прерыванию с соответствующим номером (0 -
255). Для более подробных сведений обратитесь к "UniBIOS -
Руководство пользователя".
Для передачи параметров ассемблерской программе можно
воспользоваться регистрами A, B и X процессора. Текущие (перед
передачей управления) значения регистров загружаются по следующим
адресам:
регистр A: $ED41
регистр B: $ED40
регистр X: $ED42
По этим адресам будет записано содержание регистров после
выполнения ассемблерской программы. Эти значения можно узнать,
применяя функцию PEEK.
ПРИЛОЖЕНИЕ A - Формальное описание команд, операторов
и встроенных функций UniBASIC-а
В настоящем приложение представлены в алфавитном порядке
формальные описания команд, операторов и встроенных функций
UniBASIC-а. В фигурных скобках { ... } приведены альтернативные
зарезервированные слова, если такие предусмотрены. В круглых скобках
( ... ) даны ссылки на соответствующие пункты документа, где
рассмотрены подробно команды и операторы.
Напоминаем, что в настоящей главе документа не представлены
встроенные функции системные переменные UniBASIC-а. Для
ознакомления с ними предназначена глава 11.
A --------------------------------------------------------------
- AUTO (5.12.) - автоматическая номерация строк
Формат: AUTO [начало [ , шаг ] ]
B --------------------------------------------------------------
- BAR (13.7.) - изображение прямоуголника
Формат: BAR [ [STEP] X_1,Y_1 ] TO [STEP] X_2,Y_2
...........................................................
- BLOAD (9.2.) - загрузка содержимого памяти
Формат: BLOAD <имя_файла> [,адрес [,длина ] ]
...........................................................
- BSAVE (9.2.) - двоичная запись содержимого памяти
Формат: BSAVE <имя_файла>,<адрес>,<длина>
C --------------------------------------------------------------
- CALL (14.3.) - передача управления по заданному адресу
Формат: CALL <адрес>
- CIRCLE (13.5.) - изображение элипсы
Формат:
CIRCLE <X_радиус>[,Y_радиус] [AT [STEP] X_центр,Y_центр]
...........................................................
- CLEAR (6.8) - стирание всех переменных
Формат: CLEAR
...........................................................
- CLOSE (9.3.) - закрытие файлов
Формат: CLOSE [список_номеров_файлов]
...........................................................
- COLOR (13.2.) - определение цветов изображения текста в
текстовом или графическом режиме
Формат: COLOR foregr [,backgr [,очистка] ]
...........................................................
- CONT (7.2.) - восстановление выполнения программы
Формат: CONT
D --------------------------------------------------------------
- DATA (6.6.) - область данных в программе
Формат: DATA <список_значений>
...........................................................
- DEF& (12.4.) - определение указателя памяти
Формат: DEF& = <адрес>
...........................................................
- DEFFN (12.2.) - определение потребительской функции,
запрограммированной на UniBASIC-е
Формат: DEFFN <имя>(<список_аргументов>) = <выражение>
...........................................................
- DEFKEY (12.1.) - программирование функциональных клавиш
Формат: DEFKEY [выражение]
DEFKEY <ч_выражение>,<с_выражение>
...........................................................
- DEFUSR (12.3) - определение потребительской функции,
запрограммированной на ассемблере
Формат: DEFUSR <адрес>
...........................................................
- DEL (5.8.) - стирание фрагмента программы
Формат: DEL [строка_1] [ {, -} строка_2 ]
...........................................................
- DIM (6.5.) - обявление массивов
Формат: DIM <список_имен_массивов>
...........................................................
- DISC (13.6.) - изображение диска
Формат:
DISC <X_радиус>[,Y_радиус] [AT [STEP] X_центр,Y_центр]
...........................................................
- DOKE (10.3.) - запись слова (двух байтов) памяти
Формат: DOKE <адрес>,<выражение>
E --------------------------------------------------------------
- EDIT (5.7.) - редактирование строки программы
Формат: EDIT <строка>
...........................................................
- END (6.4.) - конец программы
Формат: END
...........................................................
- ERASE (6.5.) - стирание массива
Формат: ERASE <имя_массива>
F --------------------------------------------------------------
- FN (12.2.) - вызов потребительской функции на UniBASIC-е
Формат: <перем> = FN <имя_функции>(<список_аргументов>)
...........................................................
- FOR - NEXT (6.3.1.) - цикл по счетчику
Формат:
FOR <перем_1> = <выраж._1> TO <выраж._2> [ STEP <выраж._3> ]
.
. <тело цикла>
.
NEXT [ перем_1 [ , перем_2 ] ... ]
G --------------------------------------------------------------
- GOTO (6.1.) - безусловный переход
Формат: GOTO <строка>
...........................................................
- GOSUB (6.4.) - вызов подпрограммы
Формат: GOSUB [ (список_реальных_переменных) ] <строка>
H --------------------------------------------------------------
I --------------------------------------------------------------
- IF (6.2.) - переход по условию
Формат:
IF <лог_выражение> THEN <строка>
IF <лог_выражение> THEN GOTO <строка>
IF <лог_выражение> GOTO <строка>
IF <лог_выражение> THEN <оператор>
IF <лог_выражение> THEN <оператор_1> : ELSE <оператор_2>
IF <лог_выражение> GOSUB <строка>
...........................................................
- IN# (9.7.) - переопределение стандартного устройства ввода
Формат: IN#<номер_файла>
...........................................................
- INPUT (5.10; 9.4.) - ввод значения переменной
Формат: INPUT [#номер_файла][подсказка;]<список_переменных>
...........................................................
- INPUT$ (9.4.) - ввод строки файла
Формат:
INPUT$ #<номер_файла>,<строчная_переменная>[,число_символов]
J --------------------------------------------------------------
K --------------------------------------------------------------
L --------------------------------------------------------------
- LET { = } (5.3.) - присвоение значения
Формат: <переменная> = <выражение>
...........................................................
- LIST (5.6.; 9.4.) - вывод содержания программы
Формат: LIST [#номер_файла][строка_1] [{, -} строка_2]
...........................................................
- LOAD (9.1.) - загрузка программы
Формат: LOAD <имя_файла>
...........................................................
- LOCATE (5.11) - установление курсора
Формат: LOCATE [вер_поз [,гор_поз [,верх_л,нижн_л] ]
M --------------------------------------------------------------
- MERGE (9.1.) - загрузка дополнения программы
Формат: MERGE <имя_файла>
...........................................................
- MON (14.2.) - вызов системной программы MONITOR
Формат: MON
N --------------------------------------------------------------
- NEW (5.1.) - очистка рабочего поля
Формат: NEW
O --------------------------------------------------------------
- ON (8.2.) - реакция на ситуацию
Формат:
ON <выражение> GOTO <список_строк>
ON <выражение> GOSUB <список_строк>
...........................................................
- ONERR (8.1.) - переход при ошибке
Формат: ONERR GOTO [строка]
...........................................................
- OPEN (9.3.) - открытие файла
Формат: OPEN #<номер_файла>,<имя_файла>
P --------------------------------------------------------------
- PEN (13.3.) - определение цвета и вида линии в графическом
режиме
Формат: PEN <цвет>,<изображение>
...........................................................
- PLAY (13.10) - возпроизводство мелодии
Формат: ????
...........................................................
- PLOT (13.4.) - изображение линии
Формат: PLOT [ [STEP] X_1,Y_1 ] [ TO [STEP] X_2,Y_2 ]
...........................................................
- PR# (9.7.) - переопределение стандартного устройства вывода
Формат: PR#<номер_файла>
...........................................................
- PRINT { ? } (5.2.; 9.4.) - вывод результата
Формат: PRINT[#номер_файла;]<список_выражений>
Q --------------------------------------------------------------
R --------------------------------------------------------------
- READ (6.6.) - ввод значений из области данных в программе
Формат: READ <список_переменных>
...........................................................
- RECALL (9.6.) - загрузка массива в память
Формат: RECALL#<номер_файла>,<имя_массива_в_памяти>
...........................................................
- REM { ' } (5.9.) - комментарий в рамках программы
Формат: REM [ комментарий ]
...........................................................
- REPEAT - UNTIL (6.3.2.) - цикл по условию
Формат:
REPEAT
.
. <тело цикла>
.
UNTIL <лог_выражение>
...........................................................
- RESTORE (6.6.) - установление указателя области данных в
программе
Формат: RESTORE [ строка ]
...........................................................
- RETURN (6.4.) - возврат из подпрограммы
Формат: RETURN
...........................................................
- RUN (5.4.) - выполнить текущую программу
Формат: RUN
S --------------------------------------------------------------
- SAVE (9.1.) - запись программы
Формат: SAVE <имя_файла>
...........................................................
- SCREEN (13.1) - переключение режимов изображения
Формат: SCREEN [режим [,foregr [,backgr [,очистка] ] ] ]
...........................................................
- SEEK (9.5.) - позиционирование в файле
Формат: SEEK#<номер_файла>,<позиция>
...........................................................
- SHAPE (13.8) - формирование таблицы изображения символов
Формат: ????
...........................................................
- SHELL (14.1.) - выполнение команды операционной системе
UniDOS
Формат: SHELL ["командная_строка"]
...........................................................
- SOUND (13.9) - возпроизводство звука
Формат: ????
...........................................................
- STOP (7.2.) - прерывание выполнения программы
Формат: STOP
...........................................................
- STORE (9.6) - двоичная запись массива
Формат: STORE#<номер_файла>,<имя_массива>
...........................................................
- SWAP (6.9.) - обмен значениями переменных
Формат: SWAP <список_арифметических_переменных>
...........................................................
- SYSTEM (4.) - прекращение работы UniBASIC-а
Формат: SYSTEM
T --------------------------------------------------------------
- TROFF (7.1.) - выключение трассировки
Формат: TROFF
...........................................................
- TRON (7.1.) - включение трассировки
Формат: TRON
U --------------------------------------------------------------
- USR (12.3.) - вызов потребительской функции на ассемблере
Формат: <перем> = USR(<список_аргументов>)
V --------------------------------------------------------------
W --------------------------------------------------------------
- WRITE (6.7.; 9.4) - запись значений
Формат: WRITE [#<номер_файла>,] <список_выражений>
X --------------------------------------------------------------
Y --------------------------------------------------------------
Z --------------------------------------------------------------
ПРИЛОЖЕНИЕ B - Зарезервированные слова UniBASIC-а
Зарезервированные слова UniBASIC-а приведены в алфавитном
порядке. За ним скобках дана ссылка на соответствующую часть
документа, где впервые рассмотрено их применение. Для некоторых
зарезервированных слов указана и вторая ссылка - в случаях, когда
слово применяется с заведомо другим смыслом.
? (5.2.)
& (12.4.)
' (5.9.)
A ---------------------
ABS (11.1.1.)
ADR (11.1.2.)
ASC (11.1.3.)
AT (13.5.)
ATN (11.1.4.)
AUTO (5.12.)
B ---------------------
BAR (13.7.)
BLOAD (9.2.)
BSAVE (9.2.)
C ---------------------
CH
CHR (11.2.1.)
CIRCLE (13.5.)
CLEAR (6.8.)
CLOSE (9.3.)
COLOR (13.2.)
CONT (7.2.)
COS (11.1.5.)
CV
D ---------------------
DATA (6.6.)
DATE (11.3.1.)
DEEK (10.2.)
DEF& (12.4.)
DEFFN (12.2.)
DEFKEY (12.1.)
DEFUSR (12.3.)
DISC (13.6.)
DIM (6.5.)
DOKE (10.3.)
DEL (5.8.)
E --------------------
EDIT (5.7.)
ELSE (6.2.)
END (6.4.)
EOF (11.1.7.)
ERASE (6.5.)
ERR (11.1.8.)
EXP (11.1.9.)
F ---------------------
FIX (11.1.10.)
FN (12.2.)
FOR (6.3.1.)
FRAC (11.1.11.)
FRE (11.1.12.)
G ---------------------
GH
GOSUB (6.4.)
GOTO (6.1.)
GV
H ---------------------
HEX (11.2.2.)
HIMEM (10.1.)
I ---------------------
IF (6.2.)
IN (9.7.)
INPUT (5.10.)
INSTR (11.1.13.)
INT (11.1.14.)
K ---------------------
KEY (11.1.15.)
L ---------------------
LA
LEFT (11.2.3.)
LEN (11.1.16.)
LET (5.3.)
LIST (5.6.)
LL
LOAD (9.1.)
LOC (11.1.17.)
LOCATE (5.11.)
LOF (11.1.18.)
LOG (11.1.19.)
LOMEM (10.1.)
M ---------------------
MERGE (9.1.)
MID (11.2.4.)
MON (14.2.)
N ---------------------
NEW (5.1.)
NEXT (6.3.1.)
O ---------------------
OPEN (9.3.)
ON (8.2.)
ONERR (8.1.)
P ---------------------
PEEK (10.2.)
PEN (13.3.)
PI (11.1.21.)
PLAY (13.10)
PLOT (13.4.)
POKE (10.3.)
POS (11.1.22.)
PR (9.7.)
PRINT (5.2.)
R ---------------------
READ (6.6.)
RECALL (9.6.)
REM (5.9.)
REPEAT (6.3.2.)
RESTORE (6.6.)
RESUME (8.1.)
RETURN (6.4.)
RIGHT (11.2.5.)
RND (11.1.23.)
RUN (5.4.)
S ---------------------
SAVE (9.1.)
SCREEN (5.5; 13.1.)
SEEK (9.5.)
SGN (11.1.24.)
SHAPE (13.8)
SHELL (14.1.)
SIN (11.1.25.)
SOUND (13.9)
SPC (11.1.26.)
SQR (11.1.27.)
STEP (6.3.1.)
(13.4.)
STOP (7.2.)
STORE (9.6.)
STR (11.2.6.)
SWAP (6.9.)
SYSTEM (4.)
T ---------------------
TAB (5.2.)
TAN (11.1.28.)
THEN (6.2.)
TIME (11.3.4.)
TO (6.3.1.)
(13.4.)
TROFF (7.1.)
TRON (7.1.)
U ---------------------
UNTIL (6.3.2.)
USR (11.1.29.)
V ---------------------
VAL (11.1.30.)
W ---------------------
WRITE (6.7.)
-----------------------
Приложение C - диагностические сообщения
В настоящем приложении включены диагностические сообщения
UniBASIC-а в алфавитном порядке. После каждого сообщения указан
w скобках его код, перевод и, если причина не очевидна, причина
возникновения ошибки. Если ошибка возникла во время выполнения,
UniBASIC делает попытку уточнить идентификатор соответствующей
строки программы и если попытка удалась, в конце сообщения
добавляется " in xxxx", где xxxx - идентификатор строки.
Bad subscript error ( ... )
- попытка применить индекс массива за допустимыми пределами.
Bad UNTIL error ( ... )
- зарезервированное слово UNTIL обнаружено до обнаружения
оператора REPEAT или в UNTIL содержится недопустимое
выражение.
Can not continue error ( ... )
- изменение оператора программы во время временного
прерывания выполнения программы оператором STOP привело к
невозможности продолжения выполнения.
Division by zero error ( ... )
- нулевое значение делителя.
Else without IF error ( ... )
- зарезервированное слово ELSE обнаружено до обнаружения
оператора IF.
?Extra ignored error ( ... )
- попытка ввести неправильные значения при выполнении
оператора INPUT - лишнее отброшено.
File not open error ( ... )
- попытка операции над неоткрытым файлом.
Formula too complex error ( ... )
- достигнутый уровень вложенности выражений больше
допустимого (чаще всего - число пар скобок больше
допустимого).
Illegal direct error ( ... )
- попытка применить оператор в режиме непосредственного
выполнения (в качестве команды).
Illegal quantity error ( ... )
- недопустимое значение (чаще всего - вне допустимых границ
аргумента).
NEXT without FOR error (...)
- обнаружено слово NEXT до обнаружения оператора FOR.
Out of data error ( ... )
- область данных в программе исчерпана - нельзя выполнить
оператор READ.
Out of memory error ( ... )
- попытка выйти за границами доступной памяти.
Owerflow error ( ... )
- переполнение (превышение допустимого значения переменной
или выражения)
Redimentioned array error ( ... )
- попытка переопределить размерность массива.
?Redo from start error ( ... )
- ошибка при вводе значений.
RETURN without GOSUB error (...)
- обнаружено слово RETURN до обнаружения оператора вызова
подпрограммы GOSUB.
String too long error ( ... )
- строка символов длиннее допустимого (в общем случае строка
должна содержать не более 255 символов).
Syntax error (...)
- синтаксическая ошибка - неправильное написание оператора
или команды.
Type mismatch error ( ... )
- попытка применить в одном выражении переменных и/или
функции разных типов или несоответствие по типу функции и
аргументов.
Undefined function error ( ... )
- неопределенная функция.
Undefined statement error ( ... )
- попытка применения неправильного (неопределенного)
оператора.