Подключите Ваш компьютер к проекту распределённых вычислений!
Этим Вы окажете большую помощь науке и медицине.
См. подробнее: http://solidstate.karelia.ru/~yura/pyldin/yura/computing.htm


<< Вернуться к содержанию





         Научно-изследователска и производствена лаборатория
                       "ПРОГРАМНО ОСИГУРЯВАНЕ"
                                София
   ----------------------------------------------------------------




                       ПЕРСОНАЛЕН МИКРОКОМПЮТЪР

                  ПЪЛДИН 601 / 601-У / 601-А / 601-М




                         ЕЗИК ЗА ПРОГРАМИРАНЕ

                               UniBASIC

                             версия 1.00


          Р Ъ К О В О Д С Т В О   З А  П О Т Р Е Б И Т Е Л Я

                              редакция 1








                             София - 1990


     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.  KEY$ - натиснат клавиш
              11.2.4.  LEFT$ - ляв подниз от низ
              11.2.5.  MID$  - подниз от низ
              11.2.6.  RIGHT$ - десен подниз от низ
              11.2.7.  SPC$ - генериране на низ от еднакви символи
              11.2.8.  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.  HIMEM: - горна граница на свободната памет
              11.3.9.  KEY$ - натиснат клавиш
              11.3.10. LA - адрес на зареждане на файла
                            при последната изпълнена команда BLOAD
              11.3.11. LL - дължина на заредения
                            при последната изпълнена команда BLOAD файл
              11.3.12. LOMEM: - долна граница на свободната памет
              11.3.13. PI - числото "пи"
              11.3.14. 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 - изображениe на потребителски символ
        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 глава - "Вградени функции и
системни променливи". Приложение В съдържа всички резервирани в
UniBASIC думи.

     Читателят на настоящето ръководство не трябва да знае
предварително нищо особено. Той трябва просто ДА ПРАВИ стъпка по
стъпка това, което му се препоръчва. Както е невъзможно да се научите
на карате колело, седейки пред камината, така е невъзможно да се
научите да програмирате, ако не работите с компютъра. Ние се надяваме.
че компютърът "Пълдин" е вече пред Вас.

     ВНИМАНИЕ !  При формалното описание на езиковите конструкции:
     в ъглови скоби < ...  > - са показани задължителните елементи;
     в квадратни скоби - [ ...  ] - са показани незадължителните
елементи;
     във фигурни скоби - { ...  } - са изброени алтернативните
елементи - може да се използва едно от изброеното.




                           1.1. ЗА ЧИСЛАТА

     В началото ще поговорим за числата. В обикновения живот ние
ползваме десетични числа. Техните стойности се изчисляват чрез
събиране на произведенията на всяка цифра и десет в степен,
съответстваща на поредния номер на цифрата (отдясно наляво, започвайки
от номер нула). Например, стойността на числото 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. Да се наклони термоса към чашата и да се излее от него около 1
чайна лъжичка кафе;

     6. Действие 5 да се повтаря докато се напълни около 4/5 от
чашата;

     7. Да се остави термоса на масата;

     8. Да се доближи чашата до устата;

     ... и т.н. и т.н.

     На пръв поглед роста работа - да изпиеш чаша кафе, а какъв
алгоритъм! Да обсъдим алгоритъма и да се опитаме да отговорим на някои
от въпросите, които сигурно са възникнали.

     1. Какво ще стане, ако човекът е левичар? Къде се намира термоса
и може ли да бъде достигнат с протягане на ръката? Веднага се вижда -
всеки конкретен алгоритъм отчита конкретни начални условия, изразени
чрез набор от данни.

     2. Капакът на термоса може да бъде винтов, но може да бъде и
обикновена запушалка. Как да се постъпи? Ако се отчете тази
възможност, пункт 3 от нашия алгоритъм ще придобие вида:

     - да се провери типа на капака. АКО е винтов - ТО да се отвърти,
ИНАЧЕ - да се издърпа.

     Т.е. алгоритъмът не винаги има линеен характер. Много често се
налага да бъде проверено определено условие и в зависимост от
резултата - да се постъпи по един или друг начин.

     3. Нявярно сте обърнали внимание на пункт 6 - ДА СЕ ПОВТАРЯ
действието ДОКАТО настъпи определено събитие. Разбира се,
конструкцията ДА СЕ ПОВТАРЯ ДОКАТО може да бъде заменена с конструкция
АКО е настъпило определено събитие ТО ДА СЕ ПРЕМИНЕ към действие X от
алгоритъма, ИНАЧЕ да се премине към действие Y.

     Части на алготирми, подобни на описаната, се наричат "цикли". В
конкретния случай цикълът е "по условие" - ("ДА СЕ ПОВТАРЯ ДОКАТО"). А
как може да се изрази алгоритъм за правене на 5 крачки. Навярно така:
     - да се постави БРОЯЧ на крачките в 0;
     - ДОКАТО стойността на БРОЯЧА е по-малка от 5 ДА СЕ ПОВТАРЯ:
         - да се направи една крачка;
         - да се увеличи стойността на БРОЯЧА с единица;

     Цикъл от посочения тип се нарича "цикъл по брояч". Очевидно,
единият цикъл може да бъде изразен със средствата на другия, а двата -
чрез конструкция от типа АКО - ТО - ИНАЧЕ. Но в зависимост от
конкретната ситуация е по-ефективно използването на една или друга от
възможните конструкции.

     И, навярно, главният извод се сътои в това, че алгоритъмът може
да описан на различни нива на уточняване на действията: от най-общото
- "да се налее и изпие", до най-големите подробности - "да се разгъне
първата фаланга на показалеца на 13°, вторете - на 24° и т.н. Нивото
на уточняване на подробностите зависи от това, КАКВО РАЗБИРА
ИЗПЪЛНИТЕЛЯТ НА КОМАНДИТЕ. Командите трябва да се дават така, че да
бъдат РАЗБРАНИ И ИЗПЪЛНЕНИ.

     Съществува и друг подход - повтаряща се част от алгоритъма
(например:  ДА СЕ НАМЕРИ, ДА СЕ РАЗГЪНАТ ПРЪСТИТЕ, ДА СЕ ОБХВАНЕ и
т.н.) да бъде отделена от общот, на тази част да се даде име
(например:  ХВАЩАНЕ), и в общия алгоритъм да се използва името на
подалгоритъма, помнейки, че зад него се крие последователност от
действия.

     И така, за изпълнение на алгоритъма (за достигане на целта) е
необходимо:

     - да се изрази алгоритъма чрез последователност от КОМАНДИ
(наричана ПРОГРАМА) на определен ЕЗИК и от съвокупност от ДАННИ;

     - да има устройство, в което да се запишат командите и данните -
такова устройство се нарича ПАМЕТ;

     - да има устройство, което да изпълнява командите разбирайки ги,
анализирайки данните, вземайки решения и давайки, от своя страна,
команди на други изпълнителни устройства;

     - да има изпълнителни устройства, устройства за връзка с околната
среда (в тоя число - за връзка с човека).

     Да се върнем кък компютъра. Той има всичко необходимо:

     - централен блок, в който се намира аритметико-логическото
устройство (т.н. ПРОЦЕСОР) и електронна памет;

     - периферни устройства (устройства за вход/изход). В най-семплата
си конфигурация Вашият "Пълдин" има две такива устройства: клавиатура
(входно устройство) и екран (изходно устройство).





                      1.3. ПАМЕТТА НА КОМПЮТЪРА

     Количеството информация, съдържаща се в едно едноразрядно двоично
число, е равно на един БИТ. Т.е. "бит" е единица за количество
информация и, съответно, за измерване на обема памет. Много често
всеки разряд на двоично число по аналогия се нарича също бит. В
многоразрядните числа битовете се броят (номерират) отдясно наляво. 8
бита съставят един БАЙТ. 1024 байта съставят един КИЛОБАЙТ (KB). Байт
и килобайт са единици за измерване на обем (размер) на паметта.

     Паметта на компютъра можем да си представим като последователност
от клетки, всяка от които съдържа един байт (едно осемразрядно двоично
число). Поредният номер на клетката (първата има номер 0000) се нарича
АДРЕС. Обикновено адресите се дават като шестнайсетични числа. Паметта
на "Пълдин" има обем 64 килобайта (65536 клетки). Адресите на клетките
са от $0000 до $FFFF. Всяка клетка може да съдържа данни (или част от
данни) или комнда (или част от комнда).

     Паметта, за която говорим, се нарича ОПЕРАТИВНА, защото нейното
съдържание се мени в процеса на работа на компютъра. За такава памет
много често се използва английското съкращение RAM (Random Access
Memory - памет със случаен (произволен) достъп). Освен нея, "Пълдин"
притежава и друга памет - памет само за четене (ROM - Read Only
Memory), наричана още "постоянна памет". Както личи от името, в
процеса на работа на компютъра може да бъде само прочетено (но не и
изменено) съдържанието на тази памет. Затова в ROM-а се записват
най-важните програми, използвани от всички потребители. Най-вероятно и
програмата UniBASIC е записана в ROM-а на Вашия компютър. Постоянната
памет на "Пълдин" може да бъде до 64 KB.




            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.

     ЗАПОМНЕТЕ! При работа с компютъра се използва десетична точка, а
не десетична запетая! Ако числото е отрицателно, то се предшества от
символа "-". Ако е положително, неговият знак не се показва.

     Експоненциалната форма на представяне се получава като числото се
запише във във на произведение на реално число, наречено МАНТИСА, и 10
на степен xx, където xx е двуразрядно ЦЯЛО число, наречено
ХАРАКТЕРИСТИКА. Записва се във вида:

                                    mE±xx

където: m - мантиса; xx -характеристика.

     Мантисата може да съдържа до 7 значещи цифри (без да се броят
знакът и десетичната точка. Характеристиката трябва да бъде в
диапазона -38 .. +37. По този начин максималното число, с което може
да работи компютъра е 9.999999 E+37, а минималното е -9.999999 E-38.
Например, числото 1234.56 в експоненциална форма изглежда така:
0.123456 E+04. Ако дадено число има абсолютна стойност по-малка от
0.01, то винаги се представя в експоненциална форма.

     Като име може да се използва произволна конбинация от латински
букви, цифри и символа "_", която започва с буква. Например:
my_variable, summa, salary.  Препоръчваме използването на т.н.
"говорещи" имена, а не случайни комбинации.

     Теоретически броя на символите в името може да бъде до 255, но
UniBASIC РАЗЛИЧАВА ИМЕНАТА САМО ПО ПЪРВИТЕ ДВА СИМВОЛА! Например,
променливите summa и su СА НЕРАЗЛИЧИМИ.

     За означаване на ТИПА на променливата се използва т.н.
"окончание" на името. ЦЕЛОЧИСЛЕНИТЕ променливи трябва да имат
окончание "%" (процент), а СИМВОЛНИТЕ променливи (вж."За буквите") -
окончание "$" (доларов знак). Променливите - естествени числа нямат
окончание. Окончанията не се отчитат в рамките на първите два символа,
по които се различават имената. Например, s, s$ и ss$ са различими
имена.  Имената su и summa, а така също su$ и summa$ са неразличими,
но su и su$ са различни имена.

     ВНИМАНИЕ !!!  КАТО ИМЕНА НЕ ТРЯБВА ДА СЕ ИЗПОЛЗВАТ АНГЛИЙСКИ ДУМИ
И СЪКРАЩЕНИЯ, ПРЕДСТАВЛЯВАЩИ ОПЕРАТОРИ, КОМАНДИ И ИМЕНА НА ВГРАДЕНИ
ФУНКЦИИ НА ЕЗИКА.  Например:  IF, THEN, FOR, NEXT, GOTO, PRINT и т.н.
Тези комбинации се наричат "резервирани думи".  Пълният списък на
резервираните в UniBASIC думи е даден в приложение.

     Да запишем нов израз:  Z = 3.14 * Y.  Какво представлява "3.14"?
Това е число, чиято стойност е определена един път завинаги и не се
променя.  Такива числа се наричат КОНСТАНТИ.  Докато променливата се
характеризира с име и текуща стойност, то константата се характеризира
само със стойност.  Тя, стойността, се използва и като име на
константата.

     Да се върнем към аритметичните операции. Какви други операции
знаете? Сигурно: изваждане (отбелязва се със символа "-"), деление
("/"), повдигане в степен ("^"). Характерно за тези операции е, че те
са свързани с два ОПЕРАНДА (променливи или константи). Затова се
наричат ДВУМЕСТНИ операции. А какво ще кажете за операцията "-X"
(минус X) ? Тя представлява смяна на знака, запазвайки абсолютната
стойност. Това е ЕДНОМЕСТНА операция. Винаги трябва да се прави
разликата между двуместното "изваждане" и едноместната "смяна на
знака".

     Пресметнете, ако обичате, стойността на израза:

              100 - 20 + 50 / 5 * 2

     Правилно, 100, а не 52 !  Защото, независимо от
последователността на написване на операцийте, те се изпълняват в
определен ред.  Този ред се нарича ПРИОРИТЕТ на операцийте.  Само
операции с еднакъв приоритет се изпълняват по реда на написването им.
Последователността може да бъде изменена с използване на кръгли скоби.
Например:  100 - (20 + 50) / 5 * 2 = 72.

     Освен разгледаните привични аритметични операции, в езиците за
програмиране, включително в BASIC, се използват още две операции:
целочислено деление (DIV) и получаване на остатък от деление (MOD).
Например:

                             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 (непразен низ).

     Най-разпространената логическа операция е проверката на отношение
(СРАВНЕНИЕ). Например: X ПО-МАЛКО Y. Допустими са следните отношения
(в кавички са дадени съответните им символи, използвани в програмите):

                   по-малко             "<"
                   по-малко или равно   "<=" или "=<"
                   равно                "="
                   по-голямо            ">"
                   по-голямо или равно  ">=" или "=>"
                   неравно              "<>" или "><"

     Например, отношението 12 < 2 + 3 има стойност 0 (FALSE),
отношението 12 >= 2 + 3 има стойност 1 (TRUE).

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

     Освен сравнението, в програмирането се използват три основни
логически операции: ОТРИЦАНИЕ ( NOT ), ЛОГИЧЕСКО И, или просто И (AND)
и ВКЛЮЧВАЩО ЛОГИЧЕСКО ИЛИ, или просто ИЛИ (OR).  Изобщо казано,
съществуват много логически операции. Но е доказано, че всички те
могат да бъдат изразени чрез посочените три основни. За удобство на
програмиста в повечето езици за програмиране, в това число - в
UniBASIC, е допустимо използването и на операцията ИЗКЛЮЧВАЩО ИЛИ
(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-М има само стандартна външна клавуиатура.

     Ще разгледаме предназначението на специалните клавиши, започвайки
от най-важния - Enter.

     Enter (Въвеждане) - клавиш за предаване на управлението на
компютъра.  ЗАПОМНЕТЕ - всяка команда, всеки програмен ред трябва да
завършите с натискане на клавиша Enter.  Само тогава компютърът ще
започне да обработва това, което сте написали.  До натискането на
Enter можете да правите произволни изменения в написания текст.

     Shift (Смяна на регистъра) - при ненатиснат клавиш Shift се
използват символите от "долния" регистър на клавиатурата.  За
буквените клавиши това са малките букви, за символните клавиши -
символите, обозначени отдолу на клавишите.  При натиснат клавиш Shift
се използват символите на "горния" регистър - главни букви и символите
отгоре на символните клавиши.  Запомнете - трябва да натискате
ЕДНОВРЕМЕННО клавиша Shift и нужния Ви буквен или символен клавиш!
Т.е.  Shift е предназначен за еднократно включване на горния регистър.

     CapsLock е предназначен за постоянно алтернативно превключване на
регистрите.  Действието му е аналогично на Shift с тази разлика, че
включеният регистър остава активен до следващо натискане на клавиша
CapsLock.

     Lat/Кир - клавиш за алтернативно превключване на латиница и
кирилица.

     Del (Delete - изтриване) - при натискане на клавиша се изтрива
символът в позицията на курсора (мигащият символ, показващ текущата
активна позиция на дисплея), ако курсорът не е на последната въведена
позиция на реда.  Ако курсорът е на последната въведена позиция,
изтрива се символът преди курсора и курсорът се премества на една
позиция вляво.

     Tab (Tabulation - табулация) - табулаторен клавиш - преход на
следваща табулаторна позиция.  Като правило, табулаторните позиции се
намират на 8 позиции една от друга.  При натискане на 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-А, 601-М
                            160 х 200 точки в 4 цвята  - 601, 601-У
                            160 х 200 точки в 16 цвята - 601-A, 601-М
                             80 х 200 точки в 16 цвята - 601, 601-У

     Превключването на графичните режими е обяснено по-надолу.




                        2. КАКВО Е UniBASIC ?

     Както вече казахме, компютърът обработва двоични числа, част от
които се интерпретират като команди, част - като данни. Програмите за
първите компютри се пишеха именно така - с помощта на двоични числа
(машинни кодове). Това беше тежка и изнурителна висококвалифицирана
работа с ужасяващо ниска производителност на труда.

     Първа крачка към облекчаване труда на програмиста стана
използването на т.н. асемблери. В тези езици труднозапомняните
двоични кодове бяха заменени с абревиатури (символни команди).
Например, A (от 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 и на
дискета. Двата варианта са функционално напълно еквивалентни. Все пак,
по-добре е да се работи с ROM-варианта. Това ще Ви осигури повече
памет за програмите и по-голямо бързодействие. Освен това, в случай на
ROM-вариант Вие нямате нужда от дисковод, ако, разбира се, не работите
с дискови файлове.

     Основни понятия на езика са "команди", "оператори", "функции"
(вградени и потребителски), "програми" и "подпрограми".

     Команди се наричат конструкции на езика, предназначени главно за
управление на самия интерпретатор. Например, инициализация на
работната област, четене на програма от външен носител, изменения в
текуща програма и т.н. Част от командите се използват и като
оператори.

     Операторите са езикови конструкции, описващи определени действия.
Като правило, операторите се изпълняват само в рамките на програмата
по реда на предаване на управлението.

     Програма се нарича последователност от оператори, реализиращи в
своята съвокупност определен алгоритъм.  Програмата се въвежда във вид
на програмни редове.  Един ред може да съдържа един или повече
оператора.  В последния случай операторите се разделят със символа
двоеточие ":".  Операторите се изпълняват в тяхната последователност,
ако със специални оператори за преход този ред не е променен.  Всеки
програмен ред започва със свои идентификатор - цяло десетично число,
не по-голямо от 63999.  Понякога идентификаторът се нарича номер на
ред.  Последователността на операторите в една програма се определя от
идентификаторите на съответните редове, независимо от
последователността на тяхното въвеждане. Затова препоръчваме
използването като идентификатори достатъчно "отдалечени" числа -
например, през 10. Ако съществува последователност от редове с
идентификатори 100, 110, 120 и т.н., при възникване на необходимост за
вмъкване на нов ред между редовете 110 и 120 е достатъчно да се въведе
ред с номер 115, без да се променят идентификаторите на вече
въведените редове. Идентификаторът трябва да бъде отделен от първия
оператор на реда с оне една шпация. За начало на изпълнението на
програмата е необходимо въвеждането на съответната команда.

     Подпрограмата е последователност от оператори, описващи определен
подалгоритъм (вж. по-нагоре). Подпрограмата няма самостоятелно
значение и може да бъде "извикана" от програма.

     Функция се нарича специално оформена подпрограма, даваща на
определена променлива стойност, която е функция (в математически
смисъл) на един или повече АРГУМЕНТИ. Като пример могат да бъдат
посочени тригонометричните функции: sin(x), cos(x) и т.н.

     UniBASIC притежава множество ВГРАДЕНИ функции. Но всеки
потребител може да напише свои собствени, ПОТРЕБИТЕЛСКИ функции.

     При въвеждане на поредната команда или оператор (в качеството му
на команда, ако е възможно - т.е. в режим на НЕЗАБАВНО ИЗПЪЛНЕНИЕ)
интерпретаторът анализира първоначално СИНТАКСИСА, а след това -
СЕМАНТИКАТА на въведеното. Ако бъдат открити грешки, на екрана се
извежда ДИАГНОСТИЧНО СЪОБЩЕНИЕ и изпълнението на командата или
програмата се прекратява.






                       3. ВНИМАНИЕ, ВКЛЮЧВАМЕ!

     Надяваме се, че сте разбрали от Вашия доставчик какъв, от гледна
точка на продукта UniBASIC, компютър Ви е доставен.  Възможни са
следните варианти:

     а/ с UniBASIC само на ROM;
     б/ с UniBASIC само на системна дискета;
     в/ с UniBASIC само на отделна дискета;
     г/ с UniBASIC на ROM и на системна или отделна дискета.

     Ще разгледаме отделните възможности.

     НАСТОЙЧИВО ВИ ПРЕПОРЪЧВАМЕ да включвате отделните устройства в
следния ред:  дисплей, дисково устройство (ако имате), компютър.

     Ако имате дисково устройство, предварително поставете дискетата с
операционната система в първото устройство (устройство A) и затворете
вртичката.  Как можете да разберете кое устройство е първо?  Много
просто - без да поставяте никъде нищо включете компютъра.  Най-напред
ще светне контролната лампа на първото устройство, след това - на
второто, и след това - отново на първото.




                  3.1. ВИЕ ИМАТЕ ДИСКОВО УСТРОЙСТВО

     Тогава на екрана ще се появи, примерно, следното:

              --------------------------
                                    Пылдин 601А
              UniDOS (R) Kernel Version 3.11
              UniBASIC (R) Version 1.00
              UniBIOS (R) Version 3.02
              A:\>_


където със символа "_" е обозначен курсорът на компютъра.

     Ако показаните съобщения са се появили на екрана, това означава,
в компютъра Ви има ROM-версия на UiBASIC и операционната е заредена
правилно.

     Ще отворим една скоба. Символите в началото на екранните редове
се наричат "промпт". Като правило, промптът означава, че компютърът
очаква Вашата команда. Отделните програмни системи използват отделни
символи или символни комбинации за промпт. Операционната система
UniDOS показва като промпт логическия адрес на текущото дисково
устройство (в случая - A:), текущата директория на него (в случая -
главната директория - "\") и символа ">". За запознаване с
операционната система ползвайте документа "UniDOS - ръководство за
потребителя".

     В разглеждания случай за зареждане на UniBASIC е достатъчно да се
въведе командата:

              --------------------------
                                    Пылдин 601А
              UniDOS (R) Kernel Version 3.11
              UniBASIC (R) Version 1.00
              UniBIOS (R) Version 3.02
              A:\>mon +

     НЕ ЗАБРАВЯЙТЕ СЛЕД ВЪВЕЖДАНЕТО НА КОМАНДАТА ДА НАТИСНЕТЕ Enter !
По-нататък няма да повтаряме това правило!

     Ако операционната система, с която разполагате е версия 3.14 и
по-нова, можете да използвате и командата:

              A:\>basic

     След изпълнението на командата за зареждане на 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 ред на
екрана се появява описание на функционалните клавиши. Поради разлика в
дължините на редовете (на екрана и в книгата), тук съобщението е
разположено на два реда, а на екрана - на един.

             1=LIST   2=RUNL    3=LOAD"  4=SAVE"  5=CONTL

             6=TRONL  7=TROFFL  8=SCREEN 9=EDIT   0=GOTO

     Символът "F" от имената на клавишите е пропуснат. Клавишът F10 е
означен с "0".

     В UniBASIC функционалните клавиши F11 и F12 също са програмирани,
но значението им не се показва на екрана: F11 = "FOR "; F12 = "NEXT ".

     Предначението на функционалните клавиши може да бъде изменено
(вж. глава 12).




            4. ПЪРВА КОМАНДА НА UniBASIC - КАК ДА ИЗЛЕЗЕМ?

     Първата команда на UniBASIC, която трябва да усвоите е командата
за край на работата на интерпретатора - за излизане от него. Тя има
вида:

                                SYSTEM

     След нейното изпълнение управлението се предава на операционната
система, ако тя е заредена, или на системната програма MONITOR.

     Ако е заредена операционната система, екранът трябва да изглежда
така:

              --------------------------
                                    Пылдин 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 и е извел на екрана получения
резултат. Опитайте нещо по-сложно. Например:

         ]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
         ]

     Защо? Защото въведеното се интерпретира така: "да се изведе на
екрана стойността на променливата A". Но това име на променлива се
среща за първи път и има нулева стойност (помните ли - изчистихме
работното поле).

     Но, ако въведете:

         ]PRINT "A"

     ще получите:

         ]PRINT "A"
         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 символа,
следващата стойност се извежда от следващата (x * 16 + 1) позиция. Ако
елементите в списъка са разделени с точка със запетая, стойностите се
извеждат непосредствено една след друга. В един списък могат да бъдат
използвани и двата разделителя. Например, в резултат на:

         ]PRINT A;B,C

     ще се получи:

         10-0.35         9.65

     Разгледаната едноредова програма може да бъде заменена и с един
оператор:

         ]PRINT 5*2 , (3-10)/4/5 , A+B

     Съответният разделител може да бъде написан и в края на списъка.
Ако в края на списъка е въведена запетая или не е въведено нищо,
автоматично се генерира сигнал за преход на нов ред. Ако е въведена
точка със запетая - сигнал не се генерира и при следващ оператор PRINT
първата стойност ще бъде изведена непосредствено след последната
стойност, изведена в резултат на изпълнение на предходния оператор
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-та позиция
         ]

     Ако посочената позиция се намира вляво от текущата позиция,
курсорът не се премества и извеждането се осъществява от неговата
текуща позиция. Например:

         ]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
         ]

     Защо? Защото първият ред от програмата не е изпълнен и
променливата A е останала с нулева стойност.

     Командата 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:

         ]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
         ]

     Общият формат на командата изглежда така:

                  LIST [ [идент_1] {- ,} [идент_2] ]

     Програмният текст може да бъде изведен на печат с помощта на
командата LLIST, имаща същия формат, както и командата LIST:

                 LLIST [ [идент_1] {- ,} [идент_2] ]

     Чрез командата LIST текущата програма може да бъде записана на
дискета във вид на текстов (незареждаем) файл. В този случай командата
има формат:

          LIST#<номер_на_файл>[,[идент_1] {- ,} [идент_2] ]

     Например:

         ]LIST#1,10-30

     По-подробно за файловете и техните номера е разказано в гл.9.




               5.8. EDIT - РЕДАКТИРАНЕ НА ПРОГРАМЕН РЕД

     Напълно нормално е при въвеждането на програма да допуснете
грешка. Или да се наложи нещо да измените. Изменението на програмния
текст обикновено се нарича редактиране.

     Съдържанието на даден ред може да бъде изменено като се въведе
изцяло новото му съдържание. Но може да се постъпи и по друг начин -
да се използва командата EDIT с формат:

                     EDIT [идентификатор_на_ред]

     След тази команда съдържанието на реда се извежда на екран и с
клавишите за движение на курсора и превключване на режима
вмъкване/замяна (Insert/Replace) можете да направите необходимите
изменения. Ако до натискане на  Enter решите, че е по-добре да се
откажете от измененията (да запазите старото съдържание), натиснете
едновременно клавишите Ctrl и C.

     Ако в командата е пропуснат идентификаторът на реда, по
премълчаване се приема реда, в който е отбелязана последната грешка.




             5.9. DEL - ИЗТРИВАНЕ НА ФРАГМЕНТ ОТ ПРОГРАМА

     Един или повече реда (фрагмент) от програма могат да бъдат
изтрити с командата DEL (Delete), имаща формат:

                      DEL <идент_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 за автоматично номериране на
въвежданите след командата програмни редове. Тя има формат:

                       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 <логически_израз> 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. В противния случай (е равно на нула)
логическият израз има стойност FALSE. Счита се, че реален израз има
стойност нула, ако абсолютната му стойност е приблизително по-малка от
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. Разбира се, може да се напише и друга
програма, изпълняваща същите функции. Опитайте.

     UniBASIC допуска и следния формат на оператора IF:

                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 могат да бъдат организирани по два принципа:

     - тялото се повтаря докато определена променлива не получи
определена стойност, като при всяко повторение стойността на
променливата се променя чрез сумиране с определена величина. Такъв
цикъл се нарича ЦИКЪЛ ПО БРОЯЧ. Брояч се нарича управляващата цикъла
променлива;

     - тялото се повтаря докато определен логически израз има стойност
TRUE. Такъв цикъл се нарича ЦИКЪЛ ПО УСЛОВИЕ.




                  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 Край на програмата

     Циклите FOR - NEXT могат да бъдат вложени.  Това означава, че в
тялото на един цикъл може да се съдържа друг цикъл. Първият цикъл се
нарича външен, а вторият - вътрешен.

     ЦИКЛИТЕ REPEAT-UNTIL НЕ ТРЯБВА ДА СЕ ПРЕСИЧАТ КАКТО ПОМЕЖДУ СИ,
ТАКА И С ЦИКЛИ FOR-NEXT.





                  6.4. GOSUB - RETURN - ПОДПРОГРАМА
                       END - КРАЙ НА ПРОГРАМА

     Както многократно отбелязвахме, често се налага един фрагмент от
програма да бъде изпълнен многократно. Може, разбира се, фрагментът да
бъде написан необходимия брой пъти. Но това е лошо решение - губи се
памет и се влошава "читаемостта" на програмата. Правилното решение се
състои в оформянето на фрагмента във вид на подпрограма и неговото
извикване в случай на необходимост.

     Външно подпрограмата не се различава по нищо от останалите части
на една програма. Отличителен белег е операторът RETURN, определящ
точката, от която управлението се връща от подпрограмата на извикалата
я програма (изходна точка). Веднага ще отбележим, че една подпрограма
може да има повече от една изходна точка.

     Началото на подпрограма се определя по параметъра на извикването
й от викащата програма - GOSUB ( от "GO to SUBroutine" - премини към
подпрограма). Операторът има следния формат:

     GOSUB [ (список_реални_променливи) ] [идентификатор_на_ред]

     <идентификаторът_на_ред> сочи началото на подпрограмата. Ако е
пропуснат, по премълчаване се приема равен на 0.

     Незадължителният списък_на_реални_променливи е предназначен за
възстановяване стойностите към момента на изпълнение на оператора на
посочените променливи след приключване на действието на подпрограмата.
Списъкът не може да съдържа масиви и техни елементи.

     Операторът GOSUB се изпълнява така: (ако са посочени реални
променливи, техните стойности се запомнят) запомня се точката
(мястото), откъдето се извиква подпрограмата, управлението се предава
на първия оператор в реда с посочен идентификатор. Когато се срещне
операторът RETURN, (възстановяват се стойностите на променливите)
управлението се предава на оператора, следващ непосредствено след
оператора GOSUB (след точката на извикване на подпрограмата).

     Подпрограта може да бъде записана на произволно място в общия
програмен текст. ОБЪРНЕТЕ ВНИМАНИЕ, че управлението може да бъде
предадено на първия оператор от подпрограмата и по естествения ред на
следване на операторите, ако не бъдат предприети специални мерки.

     Като специална мярка срещу случайно изпълнение на подпрограма
може да се напише оператор GOTO, предаващ управлението след
подпрограмата. Това решение не е добро! По-добре да се изнесат всички
подпрограми в края на програмния текст и се отбележи края на главната
програма чрез оператора END.

     Операторът END показва в явен вид края на програмата и
предизвиква затваряне на всички отворени файлове и прекратяване на
изпълнението на програмата - UniBASIC преминава в команден режим.

     Подпрограмите могат да бъдат вложени една в друга. Всеки оператор
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 допуска използването на масиви от числя или символни
низове. Размерността се ограничава само от обема на достъпната памет.

     Трябва да се прави ясна разлика между масив (цялото) и елемент на
масив (част от цялото). Името на масива трябва да отговаря на
правилата за име на променлива. Името на елемент на масива се състои
от името на масива и, непосредствено след него, номерата на елемента
по всяка ос, записани в кръгли скоби. Номерацията по всяка ос започва
от нула - първият елемент има номер 0, вторият - номер 1 и т.н.

     Например, А(5,4,3) означава елемент на масива А, имащ номер 5
по първата ос (заемащ шесто място), номер 4 по третата ос (пето
място), номер 3 по третата ос (четвърто място).

     За посочване на номерата могат да бъдат използвани и променливи
и/или изрази - отчита се цялата част на стойността им.

     В UniBASIC не е необходимо масивите да бъдат предварително
обявявани (дефинирани). Но ПО-ДОБРЕ Е ВСИЧКИ МАСИВИ ДА БЪДАТ ОБЯВЕНИ В
НАЧАЛОТО НА ПРОГРАМАТА! Ако това не е направено, при срещане на
елемент от масив за целия масив ще бъде отделено място, достатъчно за
разполагането на 11 елемента (с номера от 0 до 10). При това масивът
се предполага едномерен.

     Обявяването на масив и свързаното с това отделяне на необходимата
памет се прави чрез оператора DIM (DIMension - размерност), имa]
формат:

                          DIM <списък_имена>

     Имената на масивите се придружават от указани в скоби максимално
допустими номера на елементите по всяка ос, разделени със запетаи.
Например, при изпълнение на оператора DIM A(23),B(9,4) се отделя памет
за едномерен масив A с 24 елемента и двумерен масив B с 10 елемента по
първата и 5 елемента по втората ос.

     В списъка от имена към оператор DIM могат да бъдат включени и
имена на прости променливи (не само на масиви). При изпълнение на
оператора и за тези променливи ще бъде отделена памет.

     Какви преимущества дава обявяването на променливи чрез 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 [ идентификатор_на_ред ]

     Изпълнението на оператора води до определяне на указателя за
четене по такъв начин, че при изпълнение на READ ще бъде прочетена
първата стойност в списъка на 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

     Но за размяна на стойностите на две променливи A и B се използва
трета променлива C. В 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
преминава в команден режим. Външен белег за това е появяването на
неговия промпт "]". От този момент Вие имате възможност на въведете
необходимите Ви команди и незабавно изпълнявани оператори. ВНИМАНИЕ !
След временно прекъсване на програмата НЯМАТЕ ПРАВО ДА ПРОМЕНЯТЕ
САМАТА ПРОГРАМА! Ако направите това, изпълнението няма да може да
продължи.

    Изпълнението се възстановява от точката на прекъсване чрез
командата 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 символа. Разширението може да бъде дълго до 3 символа. Като
правило, чрез разширението се посочва типа на файла, определен от
неговото съдържание. Например, TXT - текстов файл.
Примери за:
     - правилни имена: 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
                                     .........

     Поредният номер на байта във файла (започвайки от 0) се нарича
"позиция" на този байт. Позицията на байта, който предстои да бъде
прочетен или записан при следваща опеарция с файла, се нарича
"указател на файла".

     Над файл могат да бъдат осъществени следните операции:
     - отваряне - файлът става достъпен за обработка;
     - четене на данни;
     - запис на данни;
     - позициониране - даване на стойност на указателя, което
съответства на преместване на главата за четене/запис;
     - затваряне - файлът става недостъпен за обработка.

     ВНИМАНИЕ ! Всички файлове в UniBASIC са достъпни както за четене
и така и за запис! Ако указателят сочи вече записан байт, при операция
запис новото съдържание ще замени старото. Ако указателят сочи след
последния записан до момента байт, то при нов запис се създава нов
байт - файлът се "удължава". При всяка операция за четене и запис
указателят се придвижва на съответното количество байтове към края на
файла.

     В UniBASIC едновременно може да се работи с до 10 файла с номера
от 0 до 9. "Номер_на_файл" е ключово понятие и се отбелязва със
символа "#" и цяло число. Например: #0, #1, ..., #9. При отварянето на
някой файл се прави връзка между името и номера му и по-нататък в
програмата се цитира само номера. Номер #0 е даден служебно на
системната конзола - основното логическо устройство за вход/изход,
физически сътоящо се от клавиатурата (устройство за вход, въвеждане,
четене) и от дисплея (устройство за изход, извеждане, запис). Ако в
оператор за четене/запис (print, write, input) не се посочи номер на
файл, по премълчаване се приема файл #0 - конзолата.

     UniBASIC работи с ТРИ ТИПА файловове: програмни, двоични и
текстови.

     Програмните файлове съдържат записани с помощта на командата SAVE
програми на езика UniBASIC. Записът се осъществява в специален
"компресиран" вид за икономия на пространство.

     Двоичните файлове могат да съдържат данни, съдържанието на
фрагмент от оперативната памет (най-често - т.н. "графична страница")
или изпълними програми на асемблер. Какво представляват такива
програми можете да разберете от документите "UniASM - ръководство за
потребителя" и "UniCROSS - ръководство за потребителя".

     В текстовите файлове записът се осъществява в т.н.  ASCII-формат.
Те могат да съдържат програми в първичен (изходен) вид, записани с
външни по отношение на UniBASIC средства. Такова средство е текстовият
редактор UniED (вж. "UniED - ръководство за потребителя").

     Очевидно, с файлове можете да работите само, ако към Вашия
компютър е включено поне едно флопи-дисково устройство.



                      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 <име_на_файла>

     При изпълнението на тази команда се затварят всички отворени
файлове, паметта се нулира изцяло и се зарежда новата програма от
посочения файл.

     Очевидно, не винаги тази команда е удобна. Не е удобна,
най-малкото, когато е нужно да се състави програма от различни
фрагменти, или когато към текущата програма е нужно да се добави
фрагмент. В такива случаи и подходящо използването на командата MERGE,
имаща формат:

                         MERGE <име_на_файла>

     При изпълнението на командата програмният фрагмент от посочения
ТЕКСТОВ файл се прочита и зарежда в паметта. Съществуващите и
нововъвеждани програмни редове се разполагат в нарастващ ред на
техните идентификатори. При съвпадащи идентификатори новият ред
замества стария.




           9.2. BSAVE - BLOAD - ЗАПАЗВАНЕ И ВЪЗСТАНОВЯВАНЕ
                       СЪДЪРЖАНИЕТО НА ПАМЕТТА

     Точното съдържание на фрагмент от паметта може да се запази във
вид на дисков файл и да се зареди в паметта чрез командите за двоичен
запис и двоично зареждане.

     Командата за двоичен запис има формат:

              BSAVE <име_на_файла> [,адрес [,дължина ] ]

където: <име_на_файла> - име на файла, в който ще бъде записано
                         съдържанието на паметта;

        <адрес> - адрес на първия байт от фрагмента на паметта;

        <дължина> - дължина (в байтове) на фрагмента на паметта.

     Командата не изменя съдържанието на паметта.

     Зареждането на паметта от външен двоичен (бинарен) файл се прави
с командата:

              BLOAD <име_на_файла> [,адрес [,дължина ] ]

където: <име_на_файла> - име на файла, от който се прави зареждане;

        <адрес> - адрес на първия байт, от който се зарежда. По
                  премълчаване - първия свободен байт;

        <дължина> - дължина (в байтове) на зареждания фрагмент памет.
                    Ако посочената дължина е по-голяма от остатъка
                    достъпна памет - зарежда се до края на достъпната
                    памет. Ако дължината е по-голяма от дължината на
                    файла - зарежда се целия файл. По премълчаване се
                    прави опит за зареждане на файла до края на
                    достъпната памет.

     ВНИМАНИЕ !  Адресът на зареждане, използван при последната
изпълнена команда BLOAD, представлява стойност на системната
променлива LA, а използваната дължина - на системната променлива LL.
Стойностите на тези променливи не могат да бъдат изменяни от
потребителска програма или команда и са съответни СТОЙНОСТИ ПО
ПРЕМЪЛЧАВАНЕ на командата BSAVE !





           9.3. OPEN - CLOSE - ОТВАРЯНЕ - ЗАТВАРЯНЕ НА ФАЙЛ

     Отварянето на файла е първата операция над него. Само след тази
операция файлът (неговото съдържание) става достъпен за обработка.

     Операторът за отваряне на файл OPEN има формат:

                 OPEN#<номер_на_файла>,<име_на_файла>

     Може да се използва номер на файл от #1 до #9. Файлът с номер #0
(системната конзола) се отваря автоматични при стартирането на
UniBASIC и не може да бъде затворен от потребител.

     Името на файла трябва да удовлетворява посочените по-горе
изисквания. НЕ Е ПРЕДВИДЕНО разширение на името по премълчаване.

     След отварянето указателят на файла получава стойност 0 - сочи
първия байт на файла.

     След изпълнението на оператора OPEN името на файла се свързва с
неговия номер и по-нататък в програмта следва да се цитира номерът на
файла.

     Един или повече файлове могат да бъдат затворени (направени
програмно недостъпни) чрез оператора 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. Например, SEEK#1,0 позиционира
файл с номер 1 в неговото начало (позиция 0).

     Ако в оператора не е посочен номерът на файла, по премълчаване се
приема #0.

     За позициониране СЛЕД реалния край на файла, което е подготовка
за следващо допълване на файла с нови записи, следва да се използва
вградената функция LOF(<номер_на_файла>), връщаща дължина на файла в
байтове. Например, за позициониране в края на файл 1 трябва да се
въведе:

                            SEEK#1,LOF(1)

     Позицията, в която текущо е позиционира определен файл, може да
се получи като стойност на вградената функция LOC(<номер_на_файла>).
Например, позициониране на 3 байта след текущата позиция се
осъществява с оператора:

                           SEEK#1,LOC(1)+3




                        9.6. STORE - RECALL -
              БИНАРНО ЗАПАЗВАНЕ/ВЪЗСТАНОВЯВАНЕ НА МАСИВ

     В UniBASIC са предвидени специални оператори за запазване
(бинарен запис) на масив от паметта във файл и зареждането му обратно
от файла в паметта.

     Операторът за бинарен запис на масив има формат:

               STORE [#номер_на_файла,]<име_на_масива>

     По премълчаване се приема #0.

     Масивът се записва без име, което позволява зареждането му в
паметта под ново име.

     Зареждането (възстановяването) на масив в паметта се осъществява
с оператора:

          RECALL [#номер_на_файла,]<име_на_масива_в_паметта>

     По премълчаване се приема #0.

     ВНИМАНИЕ ! В паметта трябва да има достатъчно памет за зареждане
на масива. В противен случай възниква грешка!




            9.7. PR# - IN# - ПРЕОПРЕДЕЛЯНЕ НА СТАНДАРТНИТЕ
                      ВХОДНО/ИЗХОДНИ УСТРОЙСТВА

     Както многократно напомняхме, стандартни входно/изходни
устройства са клавиатурата и дисплея. В някои случаи това не е удобно.
UniBASIC позволява преопределяне на тези устройства - като системно
устройство за вход и/или изход може да се посочи ВЕЧЕ ОТВОРЕН файл.
Това се прави с командите:

IN#<номер_на_файла> - преопределяне на системното входно устройство;

PR#<номер_на_файла> - преопределяне на системното изходно устройство;

     Ако, например, сте въвели PR#1, то всичко, което обикновено се
извежда на екран, ще бъде записвано във файл с номер 1.

           10. НЕПОСРЕДСТВЕН ДОСТЪП ДО ПАМЕТТА НА КОМПЮТЪРА

     Оперативната памет на компютъра е основното "поле за действие" на
Вашите програми. В паметта са разположени: Вашата програма, програмата
UniBASIC (интерпретираща Вашата програма), системните програми на
операционната система UniDOS, области за променливи и масиви.
Произволен въведен оператор, променлива или константа заема определен
обем памет - т.е. Вие, чрез програмите си, непрекъснато осъществявате
достъп до паметта. Но това се прави със средствата на системните
програми. Вие можете да получите и непосредствен достъп - да четете
или пишете в избран от Вас байт. Но преди да Ви покажем как се прави
това, ще разгледаме разпределението на паметта - кое къде се намира.




              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, съвпадащ с HIMEM на UniBASIC,
"се вдига" силно нагоре. Отдолу се формира работна област на UniBASIC
с обем $0100 байта и се формира LOMEM на UniBASIC.

     Ако работите с дискетна версия на UniBASIC, при стартирането й се
резервира от адрес $0100 работна област с дължина 256 байта, UniBASIC
се зарежда отдолу нагоре, заемайки 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 - 65535.

     Функцията връща цяло число в диапазона 0 - 65535, представляващо
съдържание на посочените байтове.

     Например, за да се разбере съдържанието на първия байт на
указателя на цикличния регистър за буфериране на клавиатурата, трябва
да се напише:

                           B1 = PEEK($ED0E)

а на целия указател (състоящ се от два байта) -

                           B = DEEK($ED0E)

     Моделът на компютъра може да се разбере като се прочетат два
байта от адрес $FFF7:

                         model = PEEK($FFF7)

     Ако model = 0, то моделът на компютъра е "601", а ако model = 128
- то моделът е "601 А".



          10.3. POKE - DOKE - ЗАПИС НА БАЙТ И ДУМА В ПАМЕТТА

     Запис на един байт с указан адрес се осъществява с оператора:

                         POKE <адрес>,<израз>

където: <адрес> - аритметичен израз с цяла част в диапазона 0 - 65535;
        <израз> - арифметичен израз с цяла част в диапазона 0 - 255.

     Запис на два последователни байта (дума) се осъществява с
опеартора:

                         DOKE <адрес>,<израз>

където: <адрес> - аритметичен израз с цяла част в диапазона 0 - 65535;
        <израз> - арифметичен израз с цяла част в диапазона 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(<с_израз>)
     Действие:  отляво надясно се правят последователно опити за
разглеждане стойността на символния израз в качеството на:  цяло
число; естествено число в нормална форма; естествено число в
експоненциална форма.  Ако се намери изображение на число, то се връща
неговата стойност.  Ако не е намерено изображение на число, се връща
0.
     Например, VAL("1.23E2A4.B3") връща 123.






                        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.4. LEFT$ - ляв подниз от низ

     Формат: LEFT$(<с_израз>,<ч_израз>)
     Връща:  символен низ, съдържащ най-левит <ч_израз> символи на
низа, представляващ стойност на <с_израз>.  Ако <ч_израз> е по-голям
от дължината на стойността на <с_израз>, то се връща символния низ,
стойност на <с_израз>.



                    11.2.5. MID$  - подниз от низ

     Формат: MID$(<с_израз>,<ч_израз_1>[,ч_израз_2])
     Връща: символен низ от <ч_израз_2> символа, съдържащ се в низа -
стойност на <с_израз>, започвайки от символа с последователен номер
<ч_израз_1>.

     Ако <ч_израз_2> е по-голямо от ((дължината на низа <с_израз>) -
<ч_израз_2>), то връщаният низ се допълва отдясно с бленкове.  Ако
<ч_израз_2> е пропуснат, то се връщат символите от <ч_израз_1> до края
на низа <с_израз>.

     Примери:
     MID$("низ - оригинал",2,7) връща низ "из - ор";
     MID$("низ - оригинал",7) връща низ "оригинал".



                 11.2.6. RIGHT$ - десен подниз от низ

     Формат: RIGHT$(<с_израз>,<ч_израз>)
     Връща:  символен низ, съдържащ най-десните <ч_израз> символа от
стойността на <с_израз>. Ако <ч_израз> е по-голямо от дължината на
низа <с_израз> - връща се низът <с_израз>.




         11.2.7. SPC$ - генериране на низ от еднакви символи

     Формат: SPC$(<ч_израз>[,<с_израз] )
     Връща:  символен низ, съдържащ <ч_израз> пъти първия символ на
низа - стойност на <с_израз>.  По премълчаване <с_израз> = " " (низ от
бленкове).



           11.2.8. 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. HIMEM - горна граница на свободната памет

     Формат: HIMEM:
     Тип: реална
     Предназначение: старши адрес - горна граница на свободната памет




                    11.3.9. KEY$ - натиснат клавиш

     Формат: KEY$
     Тип: символна
     Предназначение: първи в буфера на клавиатурата символ на натиснат
клавиш. Ако няма натиснат клавиш - празен символ.




               11.3.10. LA - адрес на зареждане на файла
                при последната изпълнена команда BLOAD

     Формат: LA
     Тип: реална
     Предназначение:  адрес, от който е зареден файл при последната
изпълнена команда BLOAD.



                  11.3.11. LL - дължина на заредения
             при последната изпълнена команда BLOAD файл

     Формат: LL
     Тип: реална
     Предназначение:  дължина на заредения при последната изпълнена
команда BLOAD файл.




          11.3.12. LOMEM - долна граница на свободната памет

     Формат: LOMEM:
     Тип: реална
     Предназначение: младши адрес - долна граница на свободната памет


                      11.3.13. PI - числото "пи"

     Формат: PI
     Тип: реална
     Стойност: 3.141592



                   11.3.14. TIME$ - системно време

     Формат: TIME$
     Тип: символна
     Предназначение: запазване на системното време като символен низ с
формат:

                          "hh:mm:ss.cc"

където: hh - час (00 - 23);
        mm - минута (00 - 59);
        ss - секунда (00 - 59);
        cc - стотна от секундата (00 - 99).

     При въвеждане може да се пропускат отляво надясно съставните
части и разделители.  Пропуснатите съставни части получават стойност
"00".

                            12. ДЕФИНИЦИИ

     В UniBASIC е предвидена възможност за някои т.н.  потребителски
дефиниции:  "програмиране" на функционалните клавиши, потребителски
функции (еднооператорни на BASIC и многооператорни на асемблер) и
адресни указатели.  Тази възможност чувствително ще облекчи работата
Ви по създаването на сложни и ефективни програми.


         12.1. DEFKEY - дефиниране на функционалните клавиши

     В самото начало на документа е показано значението на
функционалните клавиши F1 - F10 по премълчаване. При стартирането на
UniBASIC тези значения са показани в 26 ред на екрана. По време на
изпълнение на някои програми тези обозначения само ще пречат на
потребителя на програмата. За превключване на изображението се
използва следният формат на командата за дефиниране на функционалните
клавиши:

                            DEFKEY [израз]

     Ако изразът има стойност 0, то изобразяването на значението на
клавишите се прекратява. Ако стойността на израза не е равна на 0 -
изобразяването се възстановява.

     Ако не е въведен израз - изобразяването се превключва
алтернативно.

     Ако значението по премълчаване на определен клавиш не Ви
удовлетворява, можете да го "програмирате" по друг начин. За тази цел
се използва следният формат на командата:

                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 или Ctrl.

     Например, да допуснем, че искате при натискане на F11 да се
появява "IF", при натискане на Shift-F11 - да се появява "THEN", а при
натискане на Ctrl-F11 - да се появява "ELSE". За целта въведете
командите:

                          DEFKEY 11,"IF "
                          DEFKEY 23,"THEN "
                          DEFKEY 35,"ELSE "

     Командата DEFKEY може да бъде използвана и като оператор.





             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
         ? 10,5
         25




         12.3. DEFUSR - дефиниране на потребителска функция,
                       програмирана на асемблер

     Освен потребителски функции, дефинирани като изрази, UniBASIC
позволява използването и на ЕДНА потребителска функция с име USR,
програмирана на асемблер (вж. "UniASM - ръководство за потребителя") и
заредена в паметта с командата BLOAD. Дефинирането на тази функция се
прави с оператора:

                            DEFUSR=<адрес>

където <адрес> - адрес в паметта, където се предава управлението при
                 изпълнение на функцията.

     Ако <адрес>=0, функцията се дезактивира.

     Функцията USR трябва да бъде в изпълним вид (в абсолютни адреси)
и в програми на UniBASIC се използва в изрази от типа:

                            v=USR([израз])




             12.4. DEF& - дефиниране на указател към паметта
                   & - използване на указателя към паметта

     Използването на указател към паметта позволява в програма на
UniBASIC да се цитира повече от една потребителска функция, написана
на асемблер. Както и функцията "USR", потребителските функции се
зареждат в паметта от предварително избрани адреси чрез BLOAD. Преди
използването на такава функция е необходимо да се дефинира указателя
към паметта така, че да сочи към входната точка на функцията. За тази
цел се използва операторът:

                            DEF& = <адрес>

    След този оператор символът "&" в програмата се интерпретира като
оператор за предаване на управлението по съдържащия се в указателя
адрес. Асемблерската функция трябва сама да се погрижи за обмяната на
аргументи и връщане на управлението. Като правило, след оператора за
безусловен преход по адрес "&" се въвеждат имената на аргументите.

    Ако <адрес>=0, то указателят се дезактивира.

            13. В СВЕТА НА ЦВЕТОВЕТЕ, ГРАФИКАТА И МУЗИКАТА

     Усвоените до този момент команди и оператори Ви позволяват да
използвате изчислителните възможности на компютъра. В тази глава ще
разгледаме възможностите за цветно изображение, графичните и музикални
възможности.

     В самото начало ще напомним, че съществуват значителни разлики
между моделите "601" и "601-У", от една страна, и "601-А" и "601-М" -
от друга (вж. 1.7.).

     По-нататък в текста с 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) или относителни
(въведено е STEP) спрямо текущата позиция на курсора координати на
точката.

     Точката се изобразява в текущата позиция на курсора, ако не са
въведени координати.






           13.6.  MOVETO - преместване на графичния курсор

     Курсорът на екрана в графичен режим може да се премести на нова
позиция чрез командата и оператор MOVETO:

                          MOVETO [STEP] X,Y

където X и Y са абсолютни (не е въведено STEP) или относителни
             (въведено е STEP) спрямо текущата позиция на курсора
             координати на новата позиция на курсора.






                   13.7. CIRCLE - чертане на елипса

     Елипса с оси, паралелни на осите на екрана, може да се начертае
чрез оператора CIRCLE:

       CIRCLE <X_радиус>[,Y_радиус] [AT [STEP] X_център,Y_център]

където: X_радиус - дължина на радиуса по оста X;

        Y_радиус - дължина на радиуса по оста Y (по премълчаване
                   Y_радиус = X_радиус - чертае се окръжност);

        X_център и Y_център - координати (абсолютни или относителни)
                   на центъра. По премълчаване - център в текущата
                   позиция на курсора.

     Радиусите се задават в брой точки.




           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 - изображениe на потребителски символ

     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);

     Ако символът не трябва да се изобрази в текущата позиция на
курсора, координатите му (абсолютни или относителни [STEP]) се задават
с конструкцията "AT ... ".





                13.11. SOUND - възпроизвеждане на звук

     За възпроизвеждане на звук със зададена в херцове (Hz) честота и
зададена в милисекунди (ms) продължителност се използва операторът
SOUND с формат:

                  SOUND <честота>,<продължителност>





                 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);

        . - пауза после нотата; всяка следваща точка добавя пауза,
            дълга на половина от предходната.

     Възможно е извирването на нота в една от шест октави. Заедно с
полутоновете, всички тонове и полутонове имат поредни номера от 0 до
72. Това позволява използването и на следния формат за изсвирване на
тон или полутон:

                         Nn,дължина[,звучене]

където: n - пореден номер на тона или полутона;

        дължина - обща продължителност на тона или полутона, измерена
                  в 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- ръководство за потребителя"), както и работата със
симтемната програма MONITOR (вж. "UniBIOS- ръководство за
потребителя").






                14.1. SHELL - ИЗПЪЛНЕНИЕ НА КОМАНДА НА
                     ОПЕРАЦИОННАТА СИСТЕМА UniDOS

     За връзка с операционната система UniDOS се използва командата и
оператор SHELL с формат:

                        SHELL [символен_израз]

     Символният израз трябва да съдържа командата.

     Ако не се въведе символен израз, управлението се предава на
операционната система в копманден режим. За продължаване на работата в
среда на UniBASIC е необходимо въвеждането на командата EXIT.





        14.2. MON - СТАРТИРАНЕ НА СИСТЕМНАТА ПРОГРАМА MONITOR

     За стартиране на системната програма MONITOR се използва
командата без параметри MON с формат:

                                 MON

     Промпта на MONITOR е във вид на ромб - "".

     За връщане в среда на UniBASIC се използва командата q (quit) на
програмата MONITOR:

     q



                14.3. CALL - ПРЕДАВАНЕ НА УПРАВЛЕНИЕТО
                          ПО ОПРЕДЕЛЕН АДРЕС

     Управлението може да бъде предадено по определене адрес от
паметта чрез оператора CALL с формат:

                             CALL <адрес>

     Адресът трябва да бъде в границите 0 - 65535.

     Ако посоченият адрес е по-малък от 255, изпълнението на оператора
води до системно прекъсване със съответния номер (0 - 255). За
по-подробни сведения за системните прекъсвания се обърнете към
документа "UniBIOS- ръководство за потребителя".

     За предаване на параметри към асемблерска програма можете да
използвате регистрите A, B и X на процесора. Текущото (преди предаване
на управлението) съдържание на регистрите се зарежда на адреси:

     регистър A: $ED41
     регистър B: $ED40
     регистър X: $ED42

     На тези адреси ще бъде заредено съдържанието на регистрите и след
изпълнението на асемблерската програма. Съответните данни можете да
прочетете, използвайки функцията PEEK.

    ПРИЛОЖЕНИЕ A - ФОРМАЛНО ОПИСАНИЕ НА КОМАНДИТЕ, ОПЕРАТОРИТЕ И
                   ВГРАДЕНИТЕ ФУНКЦИИ НА UniBASIC

     В това приложение е дадено в азбучен ред формалното описание на
командите, операторите, вградените функции и системните променливи на
UniBASIC.  Във фигурни скоби { ...} са посочени алтернативни
резервирани (ключови) думи, ако има такива.  В кръгли скоби са
цитирани частите от документа, където съответните езикови конструкции
са разгледани подробно.


A --------------------------------------------------------------
   - ABS (11.1.1.) - абсолютна стойност

     Формат: ABS (<числов_израз>)

   - ADR (11.1.2.) - адрес

     Формат: ADR(<име_на_променлива>)

   - ASC (11.1.3.) - ASCII код

     Формат: ASC(<числов_израз>)

   - ATN (11.1.4.) - аркустангенс

     Формат: ATN(<числов_израз>)

   - 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 <адрес>

   - CH (11.3.1.) - хоризонтална позиция на курсора в текстов режим

     Формат: CH

     Тип: реална променлива

   - CHR$ (11.2.1.) - символ със зададен код

     Формат: CHR$(<числов_израз>)

   - 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

   - COS (11.1.5.) - косинус

     Формат: COS(<числов_израз>)

   - CV (11.3.2.) - вертикална позиция на курсора в текстов режим

     Формат: CV

     Тип: реална променлива

D --------------------------------------------------------------

   - DATA (6.6.) - област за данни в програма

     Формат: DATA <списък_стойности>

   - DATA$ (11.3.7.) - системна дата

     Формат: DATA$

     Тип: символна променлива

   - DEEK (10.2.) - четене на дума от паметта

     Формат: DEEK(<израз>)

   - 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 <адрес>,<израз>

   - DRAW (13.10) - изобразяване на потребителски символ

     Формат:

     DRAW <символна_пром>[,ротация[,мащаб,[изход]]] [AT [STEP] <X,Y>]

E --------------------------------------------------------------

   - EDIT (5.7.) - редактиране на ред от програма

     Формат:  EDIT <ред>

   - END (6.4.) - край на програма

     Формат: END

   - EOF (11.1.7.) - достигане край на файл

     Формат: EOF(<номер_на_файл>)

   - ERASE (6.5.) - изтриване на масив

     Формат: ERASE <име_на_масив>

   - ERR (8.1.) - изкуствено възбуждане на ситуация "грешка"

     Формат: ERR [код_на_грешка]

   - ERR (11.3.3.) - код на грешка

     Формат: ERR

     Тип: реална променлива

   - ERRLN (11.3.4.) - ред, съдържащ грешка

     Формат: ERRLN

     Тип: реална променлива

   - EXP (11.1.8.) - експонента

     Формат: EXP(<числов_израз>)

F --------------------------------------------------------------

   - FIX (11.1.9.) - цяла част на число

     Формат: FIX(<числов_израз>)

   - FN (12.2.) - използване на потребителска функция на UniBASIC

     Формат: <променлива> = FN <име_на_функцията>(<списък_аргументи>)

   - FOR - NEXT (6.3.1.) - цикъл по брояч

     Формат:

     FOR <променлива_1> = <израз_1> TO <израз_2> [ STEP <израз_3> ]
      .
      .  <тяло на цикъла>
      .
     NEXT [ променлива_1 [ , променлива_2 ] ... ]

   - FRAC (11.1.10) - дробна част на число

     Формат: FRAC(<числов_израз>)

   - FRE (11.1.11.) - обем свободна памет

     Формат: FRE(<формален_параметър>)


G --------------------------------------------------------------

   - GH (11.3.5.) - хоризонтална позиция на курсора в графичен режим

     Формат: GH

     Тип: реална променлива

   - GOTO (6.1.) - безусловен преход

     Формат: GOTO <ред>

   - GOSUB (6.4.) - изпълнение на подпрограма

     Формат: GOSUB [ (списък_на_реални_променливи) ] <ред>

   - GV (11.3.6.) - вертикална позиция на курсора в графичен режим

     Формат: GV

     Тип: реална променлива

H --------------------------------------------------------------

   - HEX$ (11.2.2.) - шестнайсетична форма на запис

     Формат: HEX$(<числов_израз>)

   - HIMEM (10.1.) - горна граница на свободната памет

     Формат: HIMEM:

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$ #<номер_на_файл>,<символна_променлива>[,брой_символи]

   - INSTR (11.2.12.) - търсене на подниз в низ

     Формат:

     INSTR(<символен_израз_1>,<символем_израз_2>[,числов_израз]

   - INT (11.1.13.) - цяло число

     Формат: INT(<числов_израз>)

J --------------------------------------------------------------
K --------------------------------------------------------------

   - KEY$ (11.3.8.) - натиснат клавиш

     Формат: KEY$

     Тип: символна променлива

L --------------------------------------------------------------

   - LA (11.3.9.) - адрес на зареждане на файл при последна изпълнена
                    комамда BLOAD

     Формат: LA

     Тип: реална променлива

   - LEFT$ (11.2.4.) - ляв подниз на низ

     Формат: LEFT$(<символен_израз>,<числов_израз>)

   - LEN (11.1.14) - дължина на низ

     Формат: LEN(<символен_израз>)

   - LET { = } (5.3.) - даване на стойност

     Формат: <променлива> = <израз>

   - LIST (5.6.; 9.4.) - извеждане съдържанието на програма

     Формат: LIST [#номер_на_файл][ред_1] [{, -} ред_2]

   - LINE (13.4.) - изобразяване на права линия

     Формат: LINE [[STEP] X_1,Y_1] TO [STEP] X_2,Y_2

   - LINE INPUT (5.12.) - въвеждане на екранен ред като стойност на
                          променлива

     Формат: LINE INPUT [съобщение;] <символна_променлива>

   - LL (11.3.10.) - дължина на файла, зареден с последната изпълнена
                     команда BLOAD

     Формат: LL

     Тип: реална променлива

   - LLIST (5.7.) - извеждане на печат съдържанието на текущата
                    програма

     Формат: LLIST [ред_1] [ {, -} ред_2 ]

   - LOAD (9.1.) - зареждане на програма

     Формат: LOAD <име_на_файл>

   - LOC (11.1.5.) - текуща позиция във файл

     Формат: LOC(<номер_на_файл>)

   - LOCATE (5.11) - позициониране на курсора

     Формат: LOCATE [вертикална_позиция [,хоризонтална_позиция ]

   - LOF (11.1.16.) - последна позиция във файл

     Формат: LOF(<номер_на_файл>)

   - LOG { LN } (11.1.17.) - натурален логаритъм

     Формат: LOG(<числов_израз>)
             LN(<числов_израз>)

   - LOMEM (10.1.) - долна граница на свободната памет

     Формат: LOMEM:

   - LPRINT (5.3.) - извеждане на печат на стойности

     Формат: LPRINT <списък_от_изрази>

M --------------------------------------------------------------

   - MERGE (9.1.) - зареждане на допълнение към програма

     Формат: MERGE <име_на_файл>

   - MID$ (11.2.5.) - подниз от низ

     Формат: MID$(<символен_израз>,<числов_израз_1>[,числов_израз_2]

   - MON (14.2.) - стартиране на системната програма MONITOR

     Формат: MON

   - MOVETO (13.6.) - позициониране на графичния курсор

     Формат: MOVETO [STEP] X,Y

N --------------------------------------------------------------

   - NEW (5.1.) - изчистване на работното поле в паметта

     Формат:    NEW

O --------------------------------------------------------------

   - ON (8.2.) - реакция на ситуация

     Формат:

     ON <израз> GOTO <списък_редове>

     ON <израз> GOSUB <списък_редове>

   - ONERR (8.1.) - преход при грешка

     Формат: ONERR GOTO [ред]

   - OPEN (9.3.) - отваряне на файл

     Формат: OPEN #<номер_на_файл>,<име_на_файл>

P --------------------------------------------------------------

   - PEEK (10.2.) - четене на байт от паметта

     Формат: PEEK(<числов_израз>)

   - PEN (13.3.) - определяне цвета и вида на линията в графически
                   режим

     Формат: PEN <цвят>,<вид_линия>

   - PI (11.3.11) - числото "пи"

     Формат: PI

     Тио: реална променлива

   - PLAY (13.10) - изсвирване на мелодия

     Формат: PLAY <списък_символни_променливи>

   - PLOT (13.4.) - изобразяване на права линия

     Формат: PLOT [ [STEP] X_1,Y_1 ] [ TO [STEP] X_2,Y_2 ]

   - POINT (13.5.) - изобразяване на точка

     Формат: POINT [AT] [[STEP] X,Y]

   - POKE (10.3.) - запис на байт в паметта

     Формат: POKE <адрес>,<числов_израз>

   - POS (11.1.19) - позиция на курсора в реда

     Формат: POS <формален_параметър>

   - 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 [ ред ]

   - RESUME (8.1.) - връщане на управлението от подпрограма за
                     обработка на грешка

     Формат: RESUME

   - RETURN (6.4.) - връщане на управлението от подпрограма

     Формат: RETURN

   - RIGHT$ (11.2.6.) - десен подниз на низ

     Формат: RIGHT$ (<символен_израз>,<числов_израз>)

   - RND (11.1.20.) - случайно число

     Формат: RND (<числов_израз>)

   - RUN (5.5.) - изпълнение на текущата програма

     Формат: RUN

S --------------------------------------------------------------

   - SAVE (9.1.) - запис на текущата програма като текстов файл

     Формат: SAVE <име_на_файл>

   - SCREEN (13.1) - превключване на видео режима

     Формат: SCREEN [режим [,foregr [,backgr [,flag ] ] ] ]

   - SEEK (9.5.) - позициониране във файл

     Формат: SEEK#<номер_на_файл>,<позиция>

   - SGN (11.1.21.) - знак на число

     Формат: SGN (<числов_израз>)

   - SHELL (14.1.) - изпълнение на команда на операционната система
                     UniDOS

     Формат: SHELL [символен_израз]

   - SIN (11.2.22) - синус

     Формат: SIN (<числов_израз>)

   - SOUND (13.11) - възпроизвеждане на звук

     Формат: SOUND <честота>,<продължителност>

   - SPC (11.1.23.) - извеждане на символи пред извеждане на стойности

     Формат: SPC(<числов_израз>[,символен_израз])

   - SPC$ (11.2.7.) - генериране на низ от еднакви групи символи

     Формат: SPC$(<числов_израз>[,символен_израз])

   - SQR (11.1.24.) - корен квадратен

     Формат: SQR(<числов_израз>)

   - STOP (7.2.) - прекъсване изпълнението на програмата

     Формат: STOP

   - STORE (9.6) - двоичен запис на масив във файл

     Формат: STORE#<номер_на_файл>,<име_на_масива>

   - STR$ (11.2.8) - символен низ, представляващ десетичен запис на
                     число

     Формат: STR$(<числов_израз>)

   - SWAP (6.9.) - размяна на стойности между променливи

     Формат: SWAP <списък_аритметични_променливи>

   - SYSTEM (4.) - прекратяване работата на UniBASIC

     Формат: SYSTEM

T --------------------------------------------------------------

   - TAB (5.2.) - табулация

     Формат: TAB(<числов_израз>)

   - TAN (11.1.25.) - тангенс

     Формат: TAN(<числов_израз>)

   - TIME$ (11.3.12) - системно време

     Формат: TIME$

     Тип: символна променлива

   - TROFF (7.1.) - изключване на трасировката

     Формат: TROFF

   - TRON (7.1.) - включване на трасировката

     Формат: TRON

U --------------------------------------------------------------

   - USR (12.3.) - използване на потребителска функция на асемблер

     Формат: <променлива> = USR(<списък_аргументи>)

V --------------------------------------------------------------

   - VAL (11.1.27) - превръщане на цифров низ в число

     Формат: VAL(<символен_низ>)

W --------------------------------------------------------------

   - WRITE (6.7.; 9.4) - запис на стойности

     Формат: WRITE [#<номер_на_файл>,] <списък_изрази>

X --------------------------------------------------------------
Y --------------------------------------------------------------
Z --------------------------------------------------------------

              ПРИЛОЖЕНИЕ B - РЕЗЕРВИРАНИ ДУМИ В UniBASIC

     Резервираните думи в UniBASIC са показани в азбучен ред. В кръгли
скоби е цитиран разделът от настоящия документ, където за пръв път е
разгледано тяхното приложение. В случаите, когато една дума се
използва с различен смисъл, са цитирани повече от един раздел.

                  ?          (5.3.)
                  &          (12.4.)
                  '          (5.9.)
                  + - * / ^ < >
               A ---------------------
                  ABS        (11.1.1.)
                  ADR        (11.1.2.)
                  AND        (1.4.)
                  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 ---------------------
                  CALL       (14.3.)
                  CH         (14.3.1.)
                  CHR$       (11.2.1.)
                  CIRCLE     (13.7.)
                  CLEAR      (6.8.)
                  CLOSE      (9.3.)
                  COLOR      (13.2.)
                  CONT       (7.2.)
                  COS        (11.1.5.)
                  CV         (11.3.2.)
               D ---------------------
                  DATA       (6.6.)
                  DATE$      (11.3.7.)
                  DEEK       (10.2.)
                  DEF&       (12.4.)
                  DEFFN      (12.2.)
                  DEFKEY     (12.1.)
                  DEFUSR     (12.3.)
                  DEL        (5.9.)
                  DIM        (6.5.)
                  DISC       (13.8.)
                  DOKE       (10.3.)
                  DRAW       (13.10.)
               E ---------------------
                  EDIT       (5.8.)
                  ELSE       (6.2.)
                  END        (6.4.)
                  EOF        (11.1.7.)
                  ERASE      (6.5.)
                  ERR        (11.1.3.)
                  ERRLN      (11.3.4.)
                  EXP        (11.1.9.)
               F ----------------------
                  FIX        (11.1.9.)
                  FN         (12.2.)
                  FOR        (6.3.1.)
                  FRAC       (11.1.11.)
                  FRE        (11.1.12.)
               G ----------------------
                  GH         (11.3.5.)
                  GOSUB      (6.4.)
                  GOTO       (6.1.)
                  GV         (11.3.6.)
               H ----------------------
                  HEX$       (11.2.2.)
                  HIMEM:     (10.1.)
               I ----------------------
                  IF         (6.2.)
                  IN#        (9.7.)
                  INPUT      (5.11.)
                  INSTR      (11.1.12.)
                  INT        (11.1.13.)
               K ----------------------
                  KEY        (11.1.15.)
               L ----------------------
                  LA         (11.3.9.)
                  LEFT$      (11.2.3.)
                  LEN        (11.1.16.)
                  LET        (5.3.)
                  LIST       (5.6.)
                  LL         (11.3.10)
                  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.)
                  MOD        (1.4.)
                  MON        (14.2.)
                  MOVETO     (13.6.)
               N ----------------------
                  NEW        (5.1.)
                  NEXT       (6.3.1.)
                  NOT        (1.4.)
               O ----------------------
                  OPEN#      (9.3.)
                  ON         (8.2.)
                  ONERR      (8.1.)
                  OR         (1.4.)
               P ----------------------
                  PEEK       (10.2.)
                  PEN        (13.3.)
                  PI         (11.1.21.)
                  PLAY       (13.10)
                  PLOT       (13.4.)
                  POINT      (13.5.)
                  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.)
                  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.)
               X ------------------------
                  XOR        (1.4.)

                Приложение C - ДИАГНОСТИЧНИ СЪОБЩЕНИЯ

     Диагностичните съобщения са подредени в две части в азбучен ред.
В първата част са включени собствените на UniBASIC съобщения, а във
втората - съобщенията, които UniBASIC получава от операционната
система UniDOS.  След всяко съобщение са дадени неговият код в скоби,
преводът и причината за издаване на съобщението, ако тя не е очевидна.

     Ако грешката е открита по време на изпълнение, UniBASIC прави
опит да уточни програмния ред, на който се намира операторът, при
изпълнението на който е възникнала грешката.  Ако опитът е успешен, в
края на съобщението се добавя "in xxxx", където xxxx - идентификатор
на ред.


               Част I - собствени на UniBASIC съобщения


     Bad subscript error (8)
     - лош индекс - използван индекс на масив извън допустимите
граници


     Bad UNTIL error (19)
     - лош UNTIL-оператор - операторът е използван преди
REPEAT-оператора


     Can not continue error (15)
     - грешка, довела до невъзможност да се продължи изпълнението на
програмата


     Division by zero error (10)
     - деление на нула


     Else without IF error (18)
     - ELSE-оператор, използван без IF-оператор


     Extra ignored
     - излишното игнорирано - опит за въвеждане на непредвидена
стойност при изпълнение на оператора INPUT


     File not open error (17)
     - файлът не е отворен - опит за действие над файл, който не е
отворен


     Formula too complex error (14)
     - твърде сложна формула - нивото на влагане в израз е над
допустимото (най-често - използване на повече от допустимото
количество скоби)


     Illegal direct error (11)
      - неправилно директно изпълнение - опит за незабавно изпълнение
на оператор, който може да бъде изпълнен само в програма (а не като
команда)


     Illegal quantity error (5)
     - недопустима стойност - най-често - аргумент със стойност,
по-голяма от допустимата


     NEXT without FOR error (1)
     - NEXT-оператор без FOR-оператор


     Out of data error (4)
     - извън областта за данни - стойностите в областта за данни са
изчерпани и операторът READ не може да бъде изпълнен


     Out of memory error
     - извън паметта - опит за излизане извън достъпната памет


     Owerflow error (6)
     - препълване - променлива или израз със стойност извън
допустимото


     Redimentioned array error (9)
     - преопределен масив


     Redo from start error (99)
     - направете отново - грешка при въвеждане на стойности


     RETURN without GOSUB error (3)
     - RETURN-оператор без GOSUB-оператор


     String too long error (13)
     - твърде дълъг низ - над 255 символа


     Syntax error (2)
     - синтаксична грешка - неправилно написване на команда или
оператор


     Type mismatch error (12)
     - объркани типове - опит за използване в един израз на променливи
и/или функции от различни типове или различие в типа на функция и
аргумент


     Undefined function error (16)
     - недефинирана функция


     Undefined statement error (7)
     - недефиниран оператор - най-вероятно - неправилно написан
оператор



   Част II - съобщения, получавани от операционната система UniDOS


     Access denied (114)
     - забранен достъп - атрибутите на файла не позволяват достъп до
него (запис и/или изтриване)

     Address failure (104)
     - грешка в адресното поле на диска - вероятно дискетата е
повредена

     Attempt to remove the current directory (122)
     - опит за изтриване на текущата директория

     Bad command or file name (165)
     - лоша команда (на UniDOS) или име на файл - най-вероятно -
обръщение към незаписан на текущата дискета файл

     Cannot execute .CMD file (169)
     - CMD-файл не може да бъде изпълнен - най-вероятно -
несъответствие по памет

     Data failure (105)
     - грешка в полето за данни на диска - вероятно дискетата е
повредена

     Directory exists (121)
     - директория (с посоченото име) вече съществува

     Directory not empty (123)
     - директорията не е празна - вероятно при опит за изтриване

     Disk full (117)
     - дискът е пълен

     Disk write protected (103)
     - дискът е защитен срещу запис

     Failure in .PGM file (167)
     - грешка при стартиране на PGM-файл

     FAT failure (110)
     - грешка в таблицата на файловите атрибути - вероятно дискетата е
повредена

     File already open (115)
     - файлът вече е отворен

     File cannot be copied onto itself (170)
     - файл не може да бъде копиран върху себе си

     File creation failure (172)
     - грешка при създаване на файл

     File exists (129)
     - файл с посоченото име съществува

     File opening failure (171)
     - грешка при отваряне на файл

     File not found (173)
     - файлът не е намерен

     General failure (106)
     - обща грешка - вероятно дискетата не е форматирана или е
настъпила хардуерна грешка

     Insufficient memory (166)
     - недостатъчна памет

     Invalid drive (2)
     - неправилно указано дисково устройство

     Invalid media type (9)
     - неправилно указан тип на форматиране на дискетата

     Invalid name (119)
     - неправилно име

     Invalid number of parameters (164)
     - недопустим брой параметри

     Invalid parameter (174)
     - неправилен параметър

     Invalid sector (107)
     - неправилно посочен сектор на дискета

     Not disk file (126)
     - не е дисков файл

     Not same device (128)
     - не е същото устройство

     Path not found (111)
     - траекторията не намерена

     Printer general failure (131)
     - обща грешка при обръщение към принтера - вероятно принтерът не
е включен

     Printer out of paper (132)
     - хартията на принтера е свършила

     Printer timeout (130)
     - грешка при работа с принтера

     Root directory full (120)
     - главната директория е запълнена до край

     Too many open files (127)
     - броят на едновременно отворените файлове е по-голям от
допустимото