Кросс Ассемблер БК Турбо8.

Сделан на основе алгоритмов Turbo8DK для Andos. Хотя, теперь уже от оригинала мало что осталось, название да пара идей.

Максимальная длина исходного текста не ограничена.

Максимальная длина получаемой программы - 0177000 байтов.

Формат объектного файла не совместим с форматом оригинального Turbo8DK из-за того, что в кросс ассемблере применяются метки неограниченной длины и полноценные арифметические выражения.

ОБЩИЕ СВЕДЕНИЯ

Оригинальная система программирования на языке Ассемблера Turbo8DK являлась дальнейшим развитием ассемблеров серии TURBO (MicroWS, TURBO4H, TURBO5M, TURBO6M) и предназначалась для работы на БК10 с дополнительным ОЗУ 16К и на БК11.

Кросс ассемблер БКТурбо8 предназначен для компиляции ассемблерных программ и создания исполняемых бинарных модулей, которые потом можно запускать на БК-0010(-01) и БК-0011(М).

Кросс ассемблер системонезависимый и вообще ни от чего не зависимый. При успешной компиляции создаётся бинарник, который будет работать так и там, как и где задумано разработчиком компилируемой программы. Т.е. хоть под набор EMTов БК-0010, хоть - БК-0011, а хоть и RT-11, правда без макросов это сильно неудобно и кросс ассемблер предназначен совсем не для RT-11.

Генерируется .bin файл, у которого первым словом идёт адрес загрузки, вторым - размер файла, совместимый с эмуляторами. Этот файл можно закинуть в образ с помощью BKDE или прямо запустить его в эмуляторе. Так же возможна генерация .raw файла без заголовка .bin для нужд пользователя.

Некоторые особенности ассемблера серии Turbo.

Это касается оригинальной версии Turbo8DK.

1. В арифметике над метками введено деление на 2, что удобно для работы с массивами слов.
2. Отсутствуют не сильно нужные псевдокоманды .TTYIN, .TTYOUT, .ENABL, .DSABL и присвоение имён регистрам.
3. Добавлена псевдокоманда .ADDR.
4. При трансляции проверяется чётность адреса команды и величина аргумента .BLKB и .BLKW.
5. Программа транслируется с адреса 01000 по умолчанию, либо с адреса, указанного псевдокомандой .LA.
6. Во всех случаях правильно работает арифметика над метками.

Отличия от оригинальной программы и дополнения.

1. Реализована регистронезависимость для меток, команд ассемблера, псевдокоманд, имён регистров и вообще всего, что не является строковым аргументом псевдокоманд .ASCII, .ASCIZ, .RAD50, операторов ' и ".
2. В присваиваниях, арифметических выражениях, перечислениях между аргументами допускаются пробелы и табуляции для улучшения наглядности и читабельности текста.
3. Длина метки ничем не ограничена, буквально. Т.е. ограничена объёмом типа std::string. Надо бы ввести какие-то разумные ограничения, но пока нет смысла, будем надеяться на благоразумность пользователей.
4. Присваивания типа name = <выражение> можно использовать в любом месте текста, а не только в начале.
5. Адрес трансляции программы можно задать ключом командной строки "-s". Данный ключ имеет меньший приоритет перед псевдокомандой .LA.
6. Псевдокоманде .LA добавлен синоним .LINK. Можно писать и так, и сяк.
7. Можно писать так: .byte <выражение>, но результат должен вмещаться в байт, иначе ошибка.
8. Можно писать так: .blkb <выражение> / .blkw <выражение>, но при этом метки и константы выражения должны быть определены, иначе ошибка. Т.к. эти псевдокоманды влияют на изменение текущего адреса компиляции.
9. Добавлена псевдокоманда .org <выражение>. Она выравнивает текущий указатель адреса по результату выражения. Допускается нечётное значение. Если результат выражения меньше текущего указателя - ничего не происходит. Но эту команду нельзя использовать в линкуемых объектных модулях. Т.к. она влияет на изменение текущего адреса компиляции, и результат получается некорректный.
10. Точку (указатель на текущий адрес) теперь можно использовать в модулях, которые компилируются в режиме CL.
11. Введены C-подобные комментарии '//' (аналогично обычному комментарию ';') и многострочный комментарий /**/. (Просто так. В качестве эксперимента, что и как ещё можно расширить и улучшить при используемых алгоритмах.)
12. Добавлены расширенные форматы записи чисел, имеющие синтаксис Си и MACRO-11.
13. Добавлены псевдокоманды .flt2 и .flt4 для работы с плавающими числами, а так же поддержка ассемблерных инструкций EIS, FIS, FPU.
14. Добавлено включение текстов в текст псевдокомандой .include, вложенность не ограничена, сделана защита от рекурсивной вложенности, включённые ранее файлы повторно не включаются.
15. Добавлены скрипты для модификации бинарного файла сразу после компиляции.
16. Реализованы полноценные арифметические выражения со скобками. В выражениях в качестве аргумента можно использовать локальные метки (с некоторыми ограничениями).
17. Добавлены назад команды .ENABL, .DSABL.
18. Добавлено назад присваивание имён-синонимов регистрам, а так же к регистрам можно обращаться по их базовым именам: %0 .. %7.

Недостатки и ограничения:

1. Объектный модуль кросс ассемблера имеет собственный формат и не совместим вообще ни с чем, и что самое досадное - с оригинальным форматом Turbo8DK. Хотя, это уже, наверное, не столь досадно.
2. Отсутствует пакетная обработка из файлов, содержащих списки обрабатываемых файлов. Приходится писать портянки из однородной копипасты в bat файлах.

Режим работы.

Кросс ассемблер представляет собой консольную программу, принимающую все необходимые параметры с командной строки. Краткий список параметров можно узнать у самого кросс ассемблера командой -? (--help).

Имеется два режима работы.

• Режим компиляции, с созданием объектных модулей и/или исполняемого файла.
• Режим линковки объектных модулей.

1. Режим компиляции.

BKTurbo8 [-i<c>][-v][-r][-l[name]][-o[name]][-t[name]][-s<0addr>] <cmd> <file_1 *[ file_n]>

2. Режим линковки.

BKTurbo8 [-v][-r][-l[name]][-o[name]][-t[name]][-s<0addr>] LI <outfile> <file_1 *[ file_n]>

Порядок следования ключей командной строки не имеет значения, но команда всегда должна располагаться после всех ключей. После команды LI первый аргумент - имя создаваемого файла. Если про это забыть, то будет создан выходной файл с именем file_1, а файл file_1.obj не будет слинкован и вообще будет перезаписан, что вообще плохо. Мало того, что вы получите неверный результат, вам придётся ещё и заново создавать потерянный объектный файл.

Если используются длинные имена ключей, то тут есть нюанс: есть ключи с опциональными параметрами и есть с обязательными. Оказалось, что парсер командной строки не может опознать опциональный параметр длинного ключа, если он записан через пробел за ключом. С обязательными параметрами такой проблемы нет. Поэтому задавать параметр надо через знак '=' (равно). Вот так: "--listing=filename". Ну, или не париться и использовать короткие имена ключей.

АССЕМБЛЕР

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

МЕТКА: КОМАНДА(ПСЕВДОКОМАНДА) ОПЕРАНДЫ ;КОММЕНТАРИЙ

МЕТКА1: МЕТКА2: //КОММЕНТАРИЙ

Примеры использования многострочного комментария:

 /*
Пример многострочного
комментария
*/

Mov R0,R1 /*пересылка*/ inc R0

Да, вот так, комментарий /**/ можно использовать как инлайн комментарий, и за ним может располагаться команда. Однако этот комментарий нельзя использовать внутри команды и её операндов.

МЕТКА: - Имя, определяемое пользователем, которому соответствует адрес трансляции. Длина метки ничем не ограничена, метка ограничивается двоеточием (:), пробелы между меткой и двоеточием недопустимы. Метка может содержать латинские буквы 'A'..'Z', цифры '0'..'9', а также знаки '_', '.', '$'.

Глобальная метка - любое допустимое слово, начинающееся с символов 'A'..'Z', '_' или '$'.

Локальная метка - любое допустимое слово, начинающееся с цифры '0'..'9'. В отличие от MACRO-11, где локальные метки состоят только из цифр и завершаются знаком '$', здесь в локальной метке могут быть и буквы, и остальные допустимые знаки. Ещё одно хорошее отличие - возможен переход по локальной метке вперёд через глобальную, но это справедливо только для команд ветвления. Однако, в арифметических выражениях можно использовать только локальные метки, оканчивающиеся знаком '$', по которому и определяется, что это локальная метка.

Метка не может начинаться с символа '.' (точка), но потом этот символ можно использовать в неограниченном количестве в обоих типах меток.

В командах из двух или трёх слов можно использовать как глобальные метки, так и локальные. Однако диапазон видимости локальных меток ограничен глобальными метками. Просмотр вперёд, через глобальную метку невозможен.

В поле меток может быть несколько меток, которые будут иметь одно и то же значение.

Если при трансляции встречается ранее определённая метка или присваивание, то выдаётся сообщение об ошибке.

Не может быть совпадающих имён метки и присваивания. Это считается ошибкой.

Метку можно поставить перед любой командой или псевдокомандой. Если её поставить перед псевдокомандой .END, то её адрес будет следующим после последнего адреса программы.

Пример:

START:STOP:  BIC  #177770, R0
             CALL RE
             . . . . .
RE:          CMP  R0 , #7

Здесь метки START и STOP имеют одно и то же значение, и обращение может производиться по любой из них.

ПРЯМОЕ ПРИСВАИВАНИЕ.

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

Если и после финальной компоновки выражение не сможет быть вычислено, то присваивание будет считаться неопределённой меткой.

Пример:

START=1000
STOP = START + 2000

ИМЕНА РЕГИСТРОВ.

Обращение к регистру можно делать по его базовому имени:

%0 %1 %2 %3 %4 %5 %6 %7

Либо по общепринятым именам:

R0 R1 R2 R3 R4 R5 SP PC

К регистрам SP и PC можно обращаться так же и по именам R6 и R7 соответственно. Эта возможность оставлена на всякий случай, для частичной совместимости с другими диалектами ассемблеров БК, например, Micro.

А также есть возможность присвоить имени регистра своё обозначение, называемое синонимом имени регистра.

Синонимов можно назначить неограниченное количество, повторяющиеся синонимы - игнорируются. И одновременно обращаться к регистру по любому из них.

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

При желании можно назначить каждому регистру много синонимов и сделать программу максимально запутанной.

А можно назначить нескольким регистрам одинаковые синонимы и сделать программу неработоспособной.

Присвоение делается так:

%n = имя

Т.е. базовому имени, и только ему, присваивается новое имя. Имя может начинаться только с буквы и знаков '_' и '$', которые тоже считаются буквами, затем может содержать любые допустимые символы: буквы, цифры и точку.

Однако есть ограничение - синоним не должен совпадать с именем метки или присваивания. Проверок на этот счёт не делается, но у имени регистра приоритет, поэтому такое имя, если оно одно единственное в аргументе (например относительная адресация) будет считаться регистром и будет у вас скомпилировано совсем не то, что ожидалось. А в арифметических операциях, особенно в скобках - это имя уже рассматривается как имя метки.

Пример.

; Пример назначения синонимов регистрам на примере
; реальной проги "Загрузчик сдаточных тестов"

    %0 = AX
    %1 = BX
    
        mov     #100, @#177660
        mov     #100000, AX     ;сперва переместим перемещатель
        mov     #mover_end, BX  ;в верхние адреса
1$:     mov     -(BX), -(AX)
        cmp     BX, #mover_begin
        bhi     1$
        jmp     (AX)            ;запустим перемещатель

    %1 = SRC
    %0 = DST

mover_begin:
        mov     #TST_BEGIN, SRC ;начало массива тестов
        mov     #TST_END, %2    ;конец массива тестов
        clr     DST             ;адрес, куда переместить массив
1$:     mov     (SRC)+, (DST)+
        cmp     SRC, %2
        blo     1$
        mov     @#24, DST       ;берём точку входа
        jmp     (DST)           ;запускаем тест
        mov     #2$, DST        ;это тест использования локальных меток
        mov     2$(DST), DST    ;в арифметическом выражении, случайно сюда попал
        .blkb   10
2$:
mover_end:
TST_BEGIN:
        .org 1400
TST_END:
        .end

АРИФМЕТИЧЕСКИЕ ВЫРАЖЕНИЯ.

Практически везде, где возможно, можно писать полноценные арифметические выражения: в ассемблерных командах, в псевдокомандах, в присваиваниях.

Операндами арифметического выражения могут быть числа, метки глобальные и локальные и определения (присваивания).

Операторы в порядке повышения приоритета:

• Логическое ИЛИ ( | ), Логическое ИСКЛЮЧАЮЩЕЕ ИЛИ ( ^ ).
• Логическое И ( & ).
• Сложение ( + ), Вычитание ( - ).
• Умножение ( * ), Деление ( / ), Остаток от деления ( % ), Арифметический сдвиг влево ( << ), Арифметический сдвиг вправо ( >> ).
• Унарный плюс ( + ), Унарный минус ( - ), Унарное инвертирование ( ~ ).

Для изменения приоритета можно использовать скобки. Треугольные ( <, > ), как в MACRO-11, или прямоугольные ( [, ] ). Но если скобок много, и они вложенные - треугольные скобки конфликтуют с арифметическими сдвигами. Поэтому их использовать не рекомендуется. Либо можно чередовать их, но нельзя смешивать. Если открывающая скобка была треугольной, то и закрывающая должна быть треугольной.

Примеры:

.word [[[VAL1+3]*[4+VAL2]] +5] << [VAL3-2] ; когда много скобок, треугольные закрывающие скобки
                                      ; интерпретируются как shr, поэтому используем квадратные
.word <VAL4*5-6/VAL5> ^ [VAL6|1]

В общем, можно использовать какие хочешь вычисления и ни в чём себе не отказывать.

Форматы чисел.

Числом считается последовательность цифр от 0 до 7 по умолчанию в восьмеричной форме счисления.

Если на конце числа стоит точка, то это признак десятичного числа, ну и там уже можно использовать цифры 8 и 9.

Например:

MOV #10., R1 аналогично MOV #12, R1

Кроме обычной записи восьмеричных и десятичных чисел с точкой на конце добавлены следующие возможные записи чисел:

• С-подобная префиксная форма записи
  • 0xabcd - 16-ричное число
  • 0d9999 - десятичное число (не знаю зачем, но такое возможно)
  • 0b1111 - двоичное число

  При этом форма записи 0123. - хоть и начинается с нуля и должно по сишной логике быть восьмеричным числом, но из-за точки на конце распознаётся как десятичное, потому что по-другому не получается, чтобы не ломать всю логику парсинга и совместимость. Поэтому же из-за точки не распознаются числа с плавающей точкой.

• префиксная форма из MACRO-11
  • ^xabcd, ^habcd - 16-ричное число
  • ^d9999 - десятичное число
  • ^b1111 - двоичное число
  • ^o7777 - восьмеричное число (просто до кучи, чтобы всё было)
  • ^f12.3 - число с плавающей точкой однословное.
  • ^rABC - три символа в кодировке RADIX-50

Для совместимости оставлен унарный оператор инвертирования ^c из MACRO-11, который инвертирует следующий за ним операнд (это может быть, как число в любой из перечисленных выше форм записи, так и метка и абсолютный адрес, что, в общем-то, бессмысленно, но синтаксически допустимо). Он полностью аналогичен унарному оператору ~. Между оператором и операндом допускаются пробелы для улучшения читабельности.

Примеры:

mov     #0xdead, R0
mov     #0b1111000011110000, R0
mov     #^xfaad, R0

.word   ^hFFFF, ^b1110001111000010
.word   ^o777, ^rONE

mov     #^f256.0, R1

mov     #^c101, R1
mov     #^c 0x85, R1

.word   ^c 25. + ^c "YE   

Естественно, можно записывать отрицательные числа, они рассматриваются как арифметические выражения с унарным минусом. Так же можно писать перед числом унарный плюс, хоть этого никто и не делает. К тому же унарных знаков может быть неограниченное количество: "--~--~+-+++-^c-+-+-++-^c-3" - эта чудовищная конструкция синтаксически верна.

Примеры:

mov     #-0xdead, R0
mov     #-0b1111000011110000, R0
mov     #-^xfaad, R0

.word   -^hFFFF, -^b1110001111000010
.word   -^o777, -^rONE

mov     #-^f256.0, R1

mov     #-^c101, R1
mov     #-^c 0x85, R1

.word   ^c-25. + -^c "YE

Так же числом считается запись одного кода ASCII, как число ( 'A ) и запись двух кодов ASCII, как число ( "AB ) и знак Точка - значение адреса первого слова команды (а не текущего слова, куда должен быть сохранён результат).

Например:

MOV #'A,R1 то же, что MOV #101,R1

Можно использовать в любом случае вместо числа, например:

TRAP '& вместо TRAP 46.

Вообще, аргумент команд TRAP и EMT может быть полноценным арифметическим выражением, в котором запрещены локальные метки, но разрешены неопределённые, и результат должен укладываться в байт, иначе будет ошибка переполнения и некорректный результат.

То же касается и команды MARK, но в арифметическом выражении её аргумента запрещены как локальные, так и неопределённые метки, т.к. выражение должно быть вычислено немедленно, чтобы сформировать опкод команды.

MOV #"AB,R1 (два байта)

Точку удобно использовать для задания смещения для перехода.

ПРИМЕЧАНИЕ: точка может быть использована в качестве любого аргумента команды, даже можно использовать точку с именами меток при трансляции объектного модуля (CL).

Кроме присваивания точке нового значения (например . = 30000 или . = . + 100). Это выражение в объектном файле, который линкуется к другому объектному файлу, приведёт к неверному результату. Потому что имеет абсолютное значение и вычисляется сразу, а не во время линковки, и приводит к изменению значения текущего PC.

Примеры:

START:  MOV   R2,R1
        BCS   .-2         ; переход на метку START.
        HALT
ST:     MOV   PC,R1
        ADD   (PC)+,R1
        .WORD END-.+2

        MOV   PC,R1
        ADD   #END-.,R1   ;или прямо в строке команды
END:    .END

Чтобы не использовать точку, этот текст можно записать в следующем виде:

ST:     MOV   PC,R1
        ADD   (PC)+,R1
        .WORD @END+2
END:    .END

Или можно использовать псевдокоманду .ADDR

        .ADDR R1,END

Особенности реализации.

В арифметическом выражении можно использовать локальные метки, кроме присваиваний, в присваиваниях - нельзя. Видимость локальной метки ограничена глобальными, так что этим надо пользоваться с осторожностью, не стоит злоупотреблять.

Для совместимости со старым BKTurbo оставлен вариант деления метки на два такого вида: /MET, это полностью аналогично операции MET/2.

Для совместимости со старым BKTurbo в командах ветвления и SOB принято следующее допущение: если не используются скобки, то самый первый аргумент всегда интерпретируется как метка, даже если выглядит как число в синтаксисе Си. Однако число в формате MACRO-11 всё-таки опознаётся как число, из-за своего префикса '^'. Это сделано для того, чтобы без лишних телодвижений можно было компилировать тексты, в которых локальные метки были обычными числами.

Например:

BR 100 ; переход на метку 100, а не на адрес 100

BR <100> или BR ^o100 ; переход на абсолютный адрес 100

BR 0x100+4 ; переход на метку 0x100 плюс 4 байта

BR <100 + MET> ; переход на метку MET плюс 100 байтов.

В псевдокоманде .word можно задавать смещение к адресу, для этого служит символ @:

.word @met

Вместо met в общем случае может стоять арифметическое выражение:

.word @<aripm>

 В результате будет рассчитано смещение до результата арифметического выражения. Однако, нельзя писать конструкции такого вида:

.word @met + @met2 ; это считается синтаксической ошибкой.

Но можно перечислять смещения через запятую:

.word @met, @met2 ; в этом случае всё вычисляется корректно.

1. Пример:

           .ADDR R0, START
           MOV  #140000, R1
           MOV  #/END - /START, R2
   1$:     MOV  (R0)+,(R1)+
           SOB  R2,1$
   START:  . . . . .
           . . . . .
   END:    .END

   Здесь массив от метки START до метки END пересылается на адрес 140000. Знак деления ( / ) означает, что адрес метки делится на 2, что в результате даёт в R2 длину массива в словах.

   Пересылка словами в два раза быстрее, чем байтами. Использование деления возможно везде, где возможно использовать арифметические выражения. По директиве .ADDR мы получаем в R0 абсолютный адрес метки START, даже если программа перемещаемая.

2. Запись байта числа в строку букв.

   CR = 12
   LF = 15
   .ASCII /ABC/<CR><LF> ; в строку дописать коды ПС,ВК

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

МЕТОДЫ АДРЕСАЦИИ, КОМАНДЫ.

Методы адресации аналогичны системе команд ЭЛЕКТРОНИКИ-60.

Двухоперандные:

Однооперандные:

Ветвления:

Управления:

Условия:

Расширенной арифметики:

ПРИМЕЧАНИЕ: Нельзя использовать относительную адресацию (67,77) при обращении к внешним, по отношению к транслируемой программе, адресам при трансляции в перемещаемом формате. Нужно использовать абсолютную адресацию.

Т.е. использовать то можно, но работать такая программа практически не будет.

Примеры:

MOV   R0,@#177714 ;Ограничений нет.
MOV   R0,177714   ;Можно транслировать только в абсолютном формате (CO).

Если нужно транслировать по CL, то можно сделать таким образом:

PORT=177714 ;Перед началом программы.
. . . .
. . . .
MOV R0,PORT

ПСЕВДОКОМАНДЫ.

.WORD 1, -1 , @START, START - . , START + STOP - END, 'A, "BC

.BYTE 1, -177776, 'A, 'B, A$END-A$BGN, BLKLEN

.ASCII /ВЫХОД В МОНИТОР ?/<40><40>"Да/Нет:"<12>

.RAD50 /HALT/

MOV #TXT,R1
CLR R2
EMT 20

MOV   PC,Rn
ADD   (PC)+,Rn
.WORD @MET+2

START:  .ADDR R1,TEXT
        CLR R2
        EMT 20
        HALT
TEXT:   .ASCIZ <234>/ERROR !/<234>
        .EVEN

Описание работы со скриптами.

Что такое скрипт и зачем он нужен.

Скрипт - это текст, заключённый между псевдокомандами .SCRIPT "Имя скрипта" и .ENDS, компилятор при разборе ассемблерного текста, сохраняет все строки между этими псевдокомандами в отдельный массив, не проводя синтаксического анализа. Анализ делается позже, скриптовым интерпретатором при выполнении скрипта.

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

Скриптов в тексте может быть неограниченное количество. Все они считаются автономными единицами, никак не связанными и не взаимодействующими между собой. Располагаться скрипты могут в любом месте программы до псевдокоманды .END.

Скрипты выполняются после окончательной компиляции или линковки, перед сохранением результирующего файла. Их назначение - модификация исполняемого файла без применения сторонних средств. Например - подсчёт КС и подстановка результата в заданное место в программе. Или кодирование/шифрование определённого участка программы.

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

При компиляции командой CL скрипты сохраняются в объектном файле, чтобы быть применёнными при линковке объектных модулей. При компиляции командой CO скрипты не сохраняются в объектном файле, а применяются сразу.

Формат скрипта.

Скрипт представляет собой набор ассемблерных команд, перед командой может быть метка. В строке может быть только одна команда и только одна метка. Допускаются пустые строки, они сохраняются как строка скрипта, но при выполнении игнорируются и просто занимают место. Допускается метка, в строке без команды.

Меткой считается лексема, состоящая из букв, цифр, знаков '_' и '$' и заканчивающаяся двоеточием. Метки скрипта никак не пересекаются с метками основного ассемблерного текста. Проверки на дублирующиеся метки не делается, если вы это допустите, ваш скрипт просто будет неправильно интерпретироваться и только. Потому что в командах ветвления и цикла производится поиск заданной метки с начала скрипта. И берётся первая найденная метка, совпадающая с меткой перехода.

Интерпретатор выполняет скрипт последовательно, строка, за строкой, пока не кончатся все строки. Если скрипт зациклить, то таким образом он никогда не завершится и кросс-ассемблер зависнет на вечном выполнении цикла.

Имеется ограниченный набор команд скрипта, частично повторяющий набор команд PDP-11: двухоперандных, однооперандных, команд ветвления и команды цикла SOB.

Так же есть дополнительный набор команд: работа с внешними файлами и вывод текста на экран.

Стека нет, внутренней памяти нет, следовательно, подпрограммы не реализованы. Есть набор восьми 16 разрядных регистров R0..R7, равноправных между собой. Если этого будет не хватать, то количество регистров можно увеличить, попросив меня об этом. Набор адресаций отличается от стандартного PDP-11.

Команды скрипта.

Двухоперандные команды.

Однооперандные команды.

Команды ветвления.

Все одноперандные и двухоперандные команды изменяют флаги NZVC в соответствии с логикой PDP-11. Все команды ветвления работают соответственно.

Команда цикла

Эта команда может делать переход вперёд, если label будет метка, заданная после команды SOB, скрипту всё равно, он не считает это ошибкой.

Команды установки/сброса признаков

Устанавливаются/сбрасываются перечисленные после команды флаги-признаки. Если за командой ничего не будет, то команда ничего не сделает. Это аналогично команде NOP, которая в скриптах бессмысленна.

Флаги можно записывать в любом порядке, пробелы между ними запрещены. Любой символ, кроме N,Z,V,C, считается концом перечисления. Т.е. можно писать строку неограниченной длины, состоящую из этих символов, что глупо, но допустимо.

Адресации

Есть 7 адресаций:

TODO: а может сделать индексную автоинкрементную/автодекрементную? Пока не знаю.

Дополнительные команды

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

Команды для работы с файлами

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

Одновременно может быть открыто 8 файлов. Пока так, пока что я считаю что и этого много.

Файл представляет собой устройство с последовательным доступом. Позиционирования нет, чтобы подвести указатель файла к определённому месту, нужно прочитать заданные количество байтов/слов.

Для имени файла действуют те же правила, что и для текстового аргумента псевдокоманды .include - имя может быть без кавычек (квотируемых символов), если в нём нет пробелов. Набор квотируемых символов тот же, что и для псевдокоманды .ascii.

Команды для вывода текста

Группа команд предназначена для вывода на экран дополнительных информационно-диагностических сообщений из скрипта.

Для строки текста действуют те же правила, что и для текстового аргумента псевдокоманды .include - строка может быть без кавычек (квотируемых символов), если в ней нет пробелов, т.е. одно слово можно не заключать в кавычки, а предложение - нужно заключать обязательно. Набор квотируемых символов тот же, что и для псевдокоманды .ascii.

Пример

; тест
Bgnc:           mov     #Bgnc, R1
                clr     R0
                mov     #Endc, R2
1$:             add     (R1)+, R0
                adc     R0
                cmp     R1, R2
                blo     1$
                cmp     CSum, R0
                beq     2$
                mov     #errcs, R1
                clr     R2
                emt     20
                halt
2$:             mov     #okcs, R1
                clr     R2
                emt     20
                halt
errcs:          .asciz  "Ошибка контрольной суммы!"<12>
okcs:           .asciz  "Контрольная сумма совпала!"<12>
                .even
Endc:
CSum:           .word 0

.SCRIPT         ; проверка отсечки комментариев
                mov #Endc, R2
                mov #Bgnc, R1
                sub R1, R2
                asr R2      ; размер в словах
                clr R0
1$:             add (R1)+, R0
                adc R0
                sob R2, 1$
                mov R0, CSum
.ENDS
                .end
	

Примеры работы с блоком расширенной арифметики.

Для организации работы с блоком расширенной арифметики необходимо перед его использованием в программе инициализировать его.

Это делается внесением в текст команды CALL ARIFM, после чего возможно написание программ с использованием мнемоники команд расширенной арифметики.

После трансляции такой программы её необходимо связать линкером с объектным модулем ARIFM.OBJ командой:

BKTurbo8 LI NAME prog.obj arifm.obj

полученная программа работает автономно. При поступлении кода команды расширенной арифметики происходит прерывание по вектору 10 и соответствующая команда обрабатывается, т.о. на данной машине возможно использования программного обеспечения, написанного для процессора 1801ВМ2.

На БК11М с КНГМД с прошивкой ПЗУ 326 вместо этого можно в начале программы сделать:

MOV #164040,@#10

MOV #340,@#12

MOV #75.,R1
CLR R0
DIV #10.,R0 ;Деление числа 75. на 10.,
HALT ;в R0 - результат, в R1 - остаток.

MOV #7,R1
MUL #10.,R1 ;умножение 7*10=70 в регистре R1.
HALT

MOV #37252,R2
MUL #1500.,R2 ;умножение 37252*1500. = 24063000.
HALT ; R2 содержит ст. часть числа (557 == 367.)
 ; R3 содержит мл. часть числа (26030 == 11288.)

ASH #5,R1  ; сдвиг регистра R1 на 5 позиций влево.

MOV #0,R0
MOV #^B1110011100011000,R1
ASHC #7,R0 ; двигаем влево R0:R1 на 7 разрядов
HALT ; R0 содержит ^b1110011
 ; R1 содержит ^b100011000

MOV #^B1110011100011000,R1
ASHC #-7,R1 ; вращаем вправо R1 на 7 разрядов
HALT ; R1 содержит 0011000111001110

         MOV   #MET,R5
        FSUB  R5    ;R5 указывает на адрес MET
        HALT
MET:    .WORD A1,A2 ;два слова аргумента A
        .WORD B1,B2 ;два слова аргумента B

Формат чисел с плавающей запятой:

              ┌──┬─────────────────┬─────────────┐
ПЕРВОЕ СЛОВО :│15│14 . . . . . . 07│06 . . . . 00│
              └──┴─────────────────┴─────────────┘
                S      Порядок      ст. часть мантиссы

              ┌──────────────────────────────────┐
ВТОРОЕ СЛОВО :│15. . . . . . . . . . . . . . . 00│
              └──────────────────────────────────┘
                    младшая часть мантиссы
                S - знак числа.

Использование команд расширенной арифметики позволяет упростить процедуру программирования, особенно те фрагменты, где используются арифметические операции.

КОМПИЛЯЦИЯ

Компиляция исходного текста может производиться в двух форматах выдачи:

1. Трансляция с получением объектного модуля. (Режим CL)
2. Трансляция с получением загрузочного модуля. (Режим CO)

Объектный модуль позиционно независим и может быть затем связан с другими модулями или привязан сам по любому адресу, задаваемому ключом "-s" в командной строке.

Трансляция объектного модуля производится командой CL, с целью дальнейшей связки в виде загрузочного модуля командой LI, причём буквально с любого адреса, задаваемого ключом "-s" в командной строке.

Загрузочный модуль транслируется по адресу, установленному псевдокомандой .LA или задаваемому ключом "-s" в командной строке.

При компиляции в режиме CO опционально можно создать и сохранить скомпонованный объектный файл, в котором находится таблица имён меток этого модуля и возможно остаются ссылки на метки из внешних модулей, которые можно прилинковать к этому модулю позже, командой LI.

Также, такие объектники, скомпилированные командой CO потом можно скомпоновать в виде набора оверлейных модулей, собранных в один файл, которые работают в заданных страницах в заданных окнах БК-0011(М).

Это такая фича БК, ДВКшникам и УНКЦшникам не понять, а БКшникам приходится с этим жить.

Пример команд для компиляции оверлейной программы.

Рассмотрим такой пример. У нас есть большая программа, которая имеет размер, допустим больше 32 Кб. Часть её размещается в странице 0, часть - в странице 1, которая подключается в окно 0, по адресу 40000, а оставшаяся часть - в странице 2, которая так же подключается в окно 0 по адресу 40000. Допустим мы так грамотно распределили подпрограммы, что странице 2 не нужны подпрограммы из страницы 1 и наоборот. Но все они вызываются из страницы 0.

Получается, что нам нужно собрать два оверлейных модуля, которые оба будут скомпонованы с адреса 40000: назовём их module1.ovl и module2.ovl.

Предположим, что module1 собирается из двух файлов file1_1.asm и file1_2.asm, а module2 - из одного file2.asm

Чтобы задать адрес компоновки, можно использовать псевдокоманду .LA <адрес> или ключ командной строки "-s<адрес>", у псевдокоманды приоритет, если задана она, то ключ командной строки не применяется.

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

Собираем оверлейный модуль для страницы 2, т.к. он состоит всего из одного файла, то тут всё просто. Вот такой командой:

-l -s040000 CO file2.asm

В результате будут созданы файлы: листинга file2.lst, и исполняемый файл file2.bin, который нужно переименовать в module2.ovl., можно обойтись без переименования, используя две команды вместо одной:

-o -l -s040000 CL file2.asm

-lmodule2 LI module2.ovl file2.obj

По команде CL объектный файл всегда генерируется позиционно независимым, но, если задан ключ "-s" в командной строке или если адрес компоновки задан псевдокомандой .LA, то адрес сохраняется в объектном файле как адрес компоновки по умолчанию, который в последствии можно изменить ключом "-s" в команде LI, либо, если объектный файл линкуется к другому объектному файлу, новый адрес компоновки вычисляется автоматически.

Теперь собираем оверлейный модуль для страницы 1, тут чуточку сложнее, т.к. он из двух файлов. Компилируем сперва второй файл:

-o -l CL file1_2.asm

В результате будут созданы файлы: листинга file1_2.lst и нужный нам объектный файл file1_2.obj.

Затем компилируем первый файл, это можно сделать так же командой CL, но поскольку мы и так знаем, что он у нас первый, и должен быть скомпонован с адреса 40000, то можем спокойно компилировать командой CO:

-o -l -s040000 CO file1_1.asm

Напомню, что, если мы в файле задали адрес компоновки псевдокомандой .LA, то можно не писать везде ключ командной строки "-s". В результате получаем файлы: листинга file1_1.lst, нужный нам объектный файл file1_1.obj и не нужный исполняемый файл file1_1.bin, который можно спокойно удалить.

Ну а теперь соберём оверлейный модуль для страницы 1:

-lmodule1 LI module1.ovl file1_1.obj file1_2.obj

В результате получаем файлы: листинга module1.lst, в котором не листинг, а таблицы меток, чтобы посмотреть, нет ли там неопределённых меток и нужный нам исполняемый файл module1.ovl.

Вот другая последовательность команд для сборки оверлейного модуля для страницы 1, используя команду CL:

-o -l CL file1_1.asm file1_2.asm

-l -s040000 LI module1.ovl file1_1.obj file1_2.obj

Результат получается аналогичный, но без ненужного промежуточного файла file1_1.bin.

Тут есть один тонкий момент, если мы одной командой компилируем сразу несколько файлов, то параметры ключей командной строки применяются ко всем ним. Именно поэтому тут нежелательно использовать ключ "-s". Поэтому адрес компоновки необходимо указать либо псевдокомандой .LA, либо при линковке.

Затем собираем модуль для страницы 0, аналогично вышеописанными способами. Но тут возникает проблема, как получить имена меток вызываемых подпрограмм из модулей 1 и 2? Есть довольно муторный способ - достать из листингов компиляций оверлеев таблицу меток, и вставить её в исходник для модуля страницы 0, это можно сделать раз, два, ну три. И хорошо, если оверлеи пересобирать больше не планируется. А иначе - очень быстро надоедает.

И вот тут появляется польза от ключа командной строки "-t" который по сути автоматизирует это действие.

Соберём оверлеи такими командами:

-o -l -s040000 CL file2.asm

-lmodule2 -tmodule2 LI module2.ovl file2.obj

-o -l CL file1_1.asm file1_2.asm

-lmodule1 -tmodule1 -s040000 LI module1.ovl file1_1.obj file1_2.obj

В результате, ко всему прочему будут созданы два дополнительных объектных модуля: module2_tbl.obj и module1_tbl.obj, которые содержат только таблицы значений меток, уже скомпонованных с адреса 40000 для модуля 2 и 1 соответственно.

Затем просто достаточно прилинковать эти объектники к компонуемой программе для страницы 0:

-o -l CL file0.asm

-l LI main.exe file0.obj module1_tbl.obj module2_tbl.obj

В результате получаем работоспособный исполняемый модуль для страницы 0, в который уже будут скомпонованы метки из оверлейных модулей. Постоянно и везде используемый ключ -l - для контроля, не забыли ли каких-нибудь меток.

Продолжение примера.

Давайте немного усложним задачу. Допустим, из оверлейного модуля 2 тоже нужно вызывать подпрограммы, находящиеся в главном модуле 0. Для того, чтобы собрать модуль 2, нам нужно будет прилинковать к нему таблицу меток модуля 0, а для того, чтобы собрать модуль 0, нужно прилинковать к нему таблицу меток модуля 2. Тут не обойтись без промежуточных операций.

Для начала, соберём объектный фай модуля 2 такой командой:

-l -o -s040000 -tmodule2 CO file2.asm

Получаем листинг, уже скомпонованный объектный файл file2.obj, и объектный файл меток module2_tbl.obj, который мы используем для сборки модуля 0. И ненужный исполняемый файл file2.bin, который пока всё равно неработоспособен.

Затем без всяких изменений собираем модуль 1:

-o -l CL file1_1.asm file1_2.asm

-lmodule1 -tmodule1 -s040000 LI module1.ovl file1_1.obj file1_2.obj

Затем собираем модуль 0, если он состоит всего из одного файла, то всё просто:

-o -l -tmodule0 CO file0.asm

Получаем всё то же, что и для модуля 2 - объектники и нерабочий пока бинарник.

Если модуль 0 состоит из нескольких файлов, то его собираем по сценарию модуля 1: сперва компилируем командой CL  потом линкуем командой LI:

-o -l CL file0_1.asm file0_2.asm

-lmodule0 -tmodule0 -o LI module0 file0_1.obj file0_2.obj

Цель - получить уже скомпонованный объектный файл, и спец. таблицу меток.

И после этого, наконец мы можем уже собрать окончательные варианты рабочих бинарников.

-l LI module2.ovl module2.obj module0_tbl.obj

-l LI main.exe module0.obj module1_tbl.obj module2_tbl.obj

Вот в принципе и всё.

ОШИБКИ ПРИ ТРАНСЛЯЦИИ

101 - Псевдокоманда .LA должна быть первой в тексте.

102 - Ошибка длины или направления перехода в команде SOB.

103 - Недопустимый символ в строке / Синтаксическая ошибка.

104 - Ошибка или отсутствие числового аргумента.

105 - Неправильная псевдокоманда.

106 - Неправильная ассемблерная инструкция.

107 - Отсутствует символ после '.

108 - Отсутствуют или недостаточно символов после ".

109 - Ошибка длины перехода по оператору ветвления.

110 - Ошибка аргумента MARK.

111 - Ошибка в имени регистра.

112 - Ошибка в псевдокоманде.

113 - Метка уже определена ранее.

114 - Аргумент .BLKB слишком велик.

115 - Аргумент .BLKW слишком велик.

116 - Аргумент .ORG слишком велик.

117 - Нечётный адрес команды.

118 - Отсутствует .END

119 - Неопределённая метка в непосредственном выражении.

120 - Отсутствует переход у команды SOB.

121 - Ошибка аргумента TRAP.

122 - Ошибка аргумента EMT.

123 - Ошибка или неверный метод адресации.

124 - Отсутствует второй операнд.

125 - Переполнение байтового аргумента.

126 - Переполнение словного аргумента.

127 - Неожиданный конец строкового аргумента.

128 - Ошибка в числе с плавающей точкой.

129 - Невозможно открыть файл include.

130 - Ошибка в аргументах псевдокоманды.

131 - Ошибка в числовом аргументе.

132 - Ошибка в имени регистра FPU.

133 - .ENDS без .SCRIPT.

134 - Неожиданный конец строки.

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

При трансляции текста выдаётся номер ошибки, номер строки и при возможности сама строка, в которой возникла ошибка.

Конвертер бинарных объектов в объектные модули кросс ассемблера Turbo8.

Ещё есть утилита BKbin2obj, которая генерирует из бинарных объектов специальные объектные модули, которые потом можно слинковать с объектниками из исходников. Это такой аналог включения ресурсов в программу.

Эта утилита может конвертировать файлы изображений в БКшные изображения. Алгоритмы преобразования взяты из проекта pdp11asm vinxru, один к одному, я не разбирался, как они работают. Потому что не было необходимости.

Но, на мой взгляд, это какие-то специфичные алгоритмы для конкретных специфичных случаев.

Тут надо конкретики добавить. А ещё разобраться с алгоритмами работы с картинками.

Автор (не я, а автор оригинального БКшного Turbo8) приносит свою благодарность:

Ну а я по традиции присоединяюсь к благодарностям и в свою очередь благодарю Крылова Дмитрия Константиновича за ассемблер Turbo8DK, которым я только и пользовался, после появления дисковода у моей БКшки, и так привык к нему, что вот написал кросс ассемблер на его основе.