Refer, еще один ЯП для срыва мозга |
Здравствуйте, гость ( Вход | Регистрация )
Refer, еще один ЯП для срыва мозга |
05 Jun 2010, 13:06
(Сообщение отредактировал tolich - 04 Jul 2020, 13:40)
Сообщение
#1
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Более полной документацией озабочусь позднее, пока только основные фишки:
1) Forth-подобный синтаксис. (Хотя это не совсем Forth...) 2) Компилятор на Refer, входит в поставку. 3) Только COM-файлы, никаких библиотек поддержки. Скачать 1.06 -------------------- |
|
|
05 Jun 2010, 18:40
Сообщение
#2
|
|
aka Nariel Сообщений: 307 Спасибо сказали: 346 раз |
какие особенности у Refer?
-------------------- |
|
|
05 Jun 2010, 18:54
Сообщение
#3
|
|
Яблочный произвол! Сообщений: 11 080 Спасибо сказали: 3988 раз |
нич-чего не понимаю! (с)
|
|
|
05 Jun 2010, 19:33
Сообщение
#4
|
|
Etoprostostatus Сообщений: 8 527 Спасибо сказали: 15833 раза |
Присоединяюсь.
-------------------- Etoprostopodpis'
|
|
|
05 Jun 2010, 19:52
Сообщение
#5
|
|
Immortal Сообщений: 1 464 Спасибо сказали: 1194 раза |
Одобряю эту тему
-------------------- Совсем скоро сайт МутноСофт будет, мб, обновлен.
Статья про защиту icq от взлома одобрена псехом. И вот идеи для сайтов хорошие очень. |
|
|
05 Jun 2010, 20:11
(Сообщение отредактировал tolich - 05 Jun 2010, 20:13)
Сообщение
#6
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Для тех, кто не понял, поясню:
refer.com - компилятор refer, работает только с командной строки, IDE нет и не будет. refer.ref - исходный текст компилятора. Если просматривать, то желательно в cp866 (небось и не все про нее знают). чтобы скомпилировать, надо набрать Код refer.com refer.ref В результате появится файл REFER.EXE, идентичный refer.com (нет, это не копирование, это компиляция).hello.ref - аналог команды H языка HQ9+, написанный на refer. exe-stub.ref - самый короткий MS-DOS stub (короче просто невозможно), написанный на refer. -------------------- |
|
|
05 Jun 2010, 20:34
Сообщение
#7
|
|
•●Revolucionario●• Сообщений: 2 467 Спасибо сказали: 5934 раза |
Хм, уже третий Forth-образный язык в разделе - занятная тенденция.
-------------------- life MOV.I #life+1, *life
האם יש זמן לעצור ? |
|
|
05 Jun 2010, 20:38
Сообщение
#8
|
|
Яблочный произвол! Сообщений: 11 080 Спасибо сказали: 3988 раз |
краткое описание команд не повредит. вообще язык похож на смесь асма и ужаса.
Добавлено ([mergetime]1275759524[/mergetime]): кстати, чайнику на заметку (нужно вставить это в инструкцию к своему интерпретатору): везде, где требуется передать путь к файлу как первый параметр, можно просто перетянуть файл на значок приложения. |
|
|
25 Dec 2010, 12:32
(Сообщение отредактировал tolich - 25 Dec 2010, 12:36)
Сообщение
#9
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Вступление
В далеком 1994 году я разрабатывал собственную Forth-систему. Писал я ее на ассемблере i8086, но, как человек не ленивый, а очень ленивый, написал программку на Turbo Pascal, в некоторой степени автоматизирующую описание слов (если вы не в курсе, словами в Форте называют подпрограммы). Полноценную Форт-систему я тогда так и не создал (сказалась нехватка опыта), но зато я получил некоторые наметки того, что впоследствии стало языком REFER. Тогда этот язык содержал всего 12 ключевых слов, компилировал в язык ассемблера, а после компиляции, ассемблирования (TASM), линкования (TLINK), преобразования в BIN (EXE2BIN), требовался еще специальный загрузчик для запуска готовой "программы" (который, как ни странно, назывался FORTH.COM ). Впрочем, я получил некоторый опыт разработки компиляторов (ведь на ошибках учатся). В 1997 году, когда у меня уже была Форт-система, имеющая встроенный ассемблер (вначале написанная на языке ассемблера, а затем переписанная под метакомпилятор с подгружаемым ассемблером), я решил развить REFEF. И вот что из этого вышло... Refer - язык программирования, "смесь асма и ужаса", предназначенный прежде всего для создания ядра Forth-системы. Тем не менее, он позволяет также писать мелкие программы-утилиты. Название происходит от слова 'reference' (англ. "ссылка"), что означает его направленность на компиляцию последовательностей ссылок. Слово - последовательность символов, отличных от пробела, ограниченная пробелами (или переводом строки). Исходный файл - текстовый файл (предпочтительно в кодировке cp866, хотя это не так уж и важно), содержащий исходный текст программы на языке Refer. Определение - любая подпрограмма. Стек данных - стек, используемый для хранения исходных и промежуточных данных, а также результатов любых определений. Низкоуровневое определение - подпрограмма, написанная на языке ассемблера или в прямо машинном коде. Высокоуровневое определение - подпрограмма, написанная в шитом коде или с ипользованием специального определения-интерпретатора. Впрочем, программы в шитом коде также используют особый интерпретатор 'call'. Поле кода определения - адрес, по которому осуществляется вызов определения. Высокоуровневые определения здесь содержат команду "переход с возвратом" на свой интерпретатор. Поле параметров высокоуровневого определения - адрес внутренних данных определения. Шитый код - разновидность внутреннего представления программы в виде последовательности ссылок на подпрограммы-элементы этой программы. Прямой шитый код - разновидность шитого кода, в которой все ссылки указывают непосредственно на исполнимый код подпрограммы. Интерпретатор - определение, используемое классом высокоуровневых определений для их выполнения. Интерпретатор получает на стеке данных адрес поля параметров определения и параметры самого определения и должен получить результаты этого определения на выходе. Стек возврата - стек, используемый интерпретатором шитого для временного хранения значений указателя интерпретации для возврата в вызвавшее определение. Кроме этого, он может использоваться для временного хранения произвольных значений и параметров цикла. Буфер результата - участок виртуальной памяти, используемый для формирования программного образа - результата компиляции. Все команды работы с памятью работают именно с этим буфером. Особая переменная 'here' хранит размер записанных в буфер данных. Именно эти данные и считаются результатом компиляции. Словарь - структура данных, предназначенная для сопоставления слов исходного текста программы определениям компилятора и пользователя. Контекстный словарь - словарь, в котором в данный момент будет осуществляться поиск слов. Текущий словарь - словарь, в который в данный момент будут добавляться новые макросы. Режим работы - устаревший термин, на самом деле, связан с контекстным словарем. Режим интерпретации - основной режим работы компилятора, в котором осуществляется определение макросов, пользовательских типов, пользовательских определений и заполнение буфера результата. Режим компиляции - режим, в котором осуществляется компиляция последовательностей ссылок на ранее созданные пользователем определения. В режиме интерпретации контекстным является словарь interpret. Он содержит слова для работы со стеком и памятью, простейшую арифметику, слова для расширения внутреннего словаря транслятора. Именно в этом режиме осуществляется определение новых пользовательских слов, типов слов и макросов, а также наполнение того массива памяти, который в случае успешной компиляции (и отсутсвия ключа -E в командной строке) будет записан в выходной файл. В режиме компиляции контекстным словарем является словарь compilers, основанный на другом словаре, userwords. В этом режиме осуществляется компиляция последовательностей ссылок на слова, ранее определенные пользователем (именно они находятся в словаре userwords). Словарь compilers же предназначен для определения разнообразных макросов периода компиляции. Для перехода из режима интерпретации в режим компиляции и обратно используются слова ] и [, соответственно. (Выбор этих слов исторически обусловлен использованием в Forth в слова, определенные через двоеточие, интерпретируемых вставок, ограниченных именно словами [ и ]). В режиме ассемблера, основанном на режиме интерпретации, контекст переключается чаще всего. Огромное множество словарей предназначено для компиляции последовательностей байтов, соответствующих командам некоторого подмножества языка ассемблера i8086. Кроме того, словарь содержит несколько слов для организации структурных ветвлений и циклов на уровне машинного кода. Для перехода из режима интерпретации в режим ассемблера и обратно используются слова start-code и end-code, соответственно, также исторически обоснованные чуть менее, чем полностью. Все данные представляются в виде двухбайтовых целых чисел и хранятся в стеке, в результате выражения записываются в привычной обратной польской записи. Пример: Код 2 2 + . , что означает:
Разумеется, предыдущий пример в процессе компиляции выведет на экран 4. to be continued... -------------------- |
|
|
02 Jun 2012, 09:14
Сообщение
#10
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Итак, прошло почти джва года... ну и Лентяй же ты, tolich...
Принцип работы парсера Перед тем, как продолжить. Немного о процедуре компиляции исходного текста. Интерперетатор прост, как грабли: пока не закончится исходный текст, он циклично делает следующее: 1) Прочитать строку из входного файла. 2) Обработать строку. Обработка строки тоже циклична: пока строка не закончилась: 1) Выделить из строки слово (последовательность символов, отличных от пробела, ограниченная пробелом или концом строки), при этом пробел-ограничитель также пропускается. 2) Поискать в контекстном словаре это слово. Если оно найдено, выполнить соответствующее ему действие (в словаре указано, какое именно) и перейти к 7. 3) Проверить, а не является ли слово записью числа (поддерживаются десятичные числа вида 125 и -125 и шестнадцатеричные вроде $7D и -$7D). Если является, положить его значение на стек, и перейти к 5. 4) Вызвать слово badword. Оно отображает информацию об неизвестном слове и прерывает работу программы. При этом на экране отображается строка исходного файла с указанием положения этого слова. 5) Поискать в контекстном словаре слово literal. Если оно найдено, выполнить соответствующее ему действие (в словаре указано, какое именно) и перейти к 7. 6) Вызвать слово badword. Оно отображает информацию об неизвестном слове literal и прерывает работу программы. При этом на экране отображается строка исходного файла с указанием положения числа. 7) С этим словом всё, плавно переходим к следующему. Замечание: прежде чем использовать числа в режиме компиляции, необходимо определить макрос literal, который будет их обрабатывать. В режиме интерпретации это слово определено, оно ничего не делает. Поэтому числа использовать можно. -------------------- |
|
|
02 Jun 2012, 10:53
(Сообщение отредактировал tolich - 02 Jun 2012, 10:54)
Сообщение
#11
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Примечание: в дальнейшем если я буду писать "скомпилировать байт/слово/строку" это всего лишь означает "добавить байт/слово/строку в выходной буфер, зарезервировав этот участок буфера".
Пользовательские слова Самым простым способом создания такого слова является create-item. Код create-item new-word создает новое слово new-word, которо является просто меткой. При этом текущий словарь устанавливать не надо, новые слова всегда создаются в словаре userwords. Зачем нужны такие слова? Для компиляции последовательности ссылок. Вначале create-item или другое, использующее его слово, создаёт метку в словаре userwords, затем в процессе компиляции ссылка на эту метку помещается в выходной буфер. Значение адреса метки можно получить с помощью слова ': Код ' new-word . в процессе компиляции напечатает значение адреса определённого выше слова (скорее всего, это будет 256 ). Пользовательским словом называется не то слово, которое размещено в словаре userwords, а то слово в выходном буфере, на которое это слово ссылается. То есть, для того, чтобы создать полноценное пользовательское слово, необходимо определить метку и затем определить код самого слова. Макросы Макрос - это последовательность слов, выполняемых в нужное время вместо имени макроса. Фактически эффект почти в точности равен тому, как если бы вместо имени макроса вставили сами его слова. Единственное отличие возникает в том случае, если влова в макросе пытаются выбирать символы из текущей строки. Тогда эти символы нужно просто поместить после соответствующих слов. Определяются в режиме интерпретации так: вначале пишется слово macro, затем через пробел перечисляются все необходимые слова, затем указывается специальное слово endm. Впрочем, определение макроса не обязательно размещать на одной строке: когда текущая строка заканчивается, макрокомпилятор читает новую из входного файла. Но все же лучше определение заканчивать: кажется, текущая версия всё ещё имеет какие-то проблемы в компиляторе макросов, из-за которых слетает, если входной файл закончился раньше макроопределения. Конкретный пример: Код macro ," 34 parse c@ 1 + allot endm Его можно вызвать, например, так: Код ," Hello, world!" Это полностью аналогично следующему фрагменту: Код 34 parse Hello, world!"c@ 1 + allot endm 1) parse выделяет подстроку с ограничителем, код которого снимает со стека (в данном случае это ", а текст Hello, world!) и кладёт сроку со счетчиком по текущему указателю компиляции в выходной буфер (не компилирует, так как память не резервируется), на стек помещается адрес этой строки. 2) c@ получает длину строки, 1 + получает длину строки с учетом символа-счетчика. 3) allot резервирует в выходном буфере длину строки с учетом символа-счетчика. В результате, строка Hello, world! компилируется в формате "строка со счётчиком". Очевидно, что в сумме определение макроса и текста его однократного использование дают текст несколько длиннее результирующей макроподстановки, однако при многократном употреблении одного и того же макроса текст заметно сокращается, да и просто короткий текст писать удобнее чем длинный. Макросы компиляции Для того, чтобы определять макросы периода компиляции, необходимо выбрать текущим словарь compilers. Это делается словом current: Код current compilers Все последующие макроопределения будут помещены в словарь compilers, до тех пор пока не встетится код: Код current interpret который устанавливает текущим словарь interpret. То же самое касается и переключения на другие словари. В процессе определения макроса не надо забывать, что в момент его исполнения не происходит переключения контекста. Это означает, например, необходимость явно переключить контекст на интерпретацию. Конкретный пример: Код current compilers macro literal lit [ , ] endm current interpret В этом примере определяется макрос literal (который, как мы помним, используется для обработки чисел). Итак, что он делает: 1) Записывает в выходной буфер ссылку на пользовательское слово lit. 2) Переключает компилятор на словарь interpret. 3) Снимает со стека число и записывает в выходной буфер. 4) Переключает компилятор на словарь compilers. В результате мы имеем в выходном буфере 2 двухбайтных слова: ссылку на lit и обрабатываемое число. В процессе выполнения будет вызвано слово lit, скорее всего, оно положит то самое скомпилированное число на стек данных. Замечание: возможно, но нежелательно делать словарь userwords текущим. Макросы компиляции лучше добавлять в словарь compilers, так они будут иметь приоритет над определёнными позднее одноимёнными пользовательскими словами. Для того же, чтобы в процессе компиляции компилировать пользовательское слово, а не вызывать одноимённое слово-компилятор, можно применять следующий макрос: Код current compilers
macro [compile] [ ' , ] endm current interpret -------------------- |
|
|
02 Jun 2012, 12:40
Сообщение
#12
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Прямой шитый код и типы слов
В реализации применён прямой шитый код. Причём текущий указатель интерпретации хранится в DS:SI, вершина стека данных в SS:SP, а вершина стека возврата в SS:BP. Что это означает? Пользовательские низкоуровневые определения представляют собой обычный машинный код, который заканчивается, правда, не инстукцией ret, а трёхбайтовой последовательностью lodsw jmp ax (которая сокращённо записывается, как next). Тем самым осуществляется переход к интерпретации очередной ссылке в последовательности ссылок. В дальнейшем я не буду упоминать, что низкоуровневое слово выполняет последовательность next, так как бесполезно писать про каждую подпрограмму, что она заканчивается оператором возврата. Высокоуровневые определения начинаются с команды call перехода к подпрограмме интерпретатора. Это команда, кроме собственно перехода, кладёт в стек SS:SP "адрес возврата", который в нашем случае не используется для возврата, а является адресом поля параметров высокоуровнего определения. Инетерпретатор получает адрес поля параметров на вершине стека и обрабатывает его способом, свойственным для слов данного типа. Например, подпрограммы в шитом коде также используют интерпретатор 'call', который кладёт текущее значение указателя интерпретации (только SI, конечно) на стек возврата, а затем снимает новое значение этого указателя со стека данных. Слова пользовательского типа могут использовать в качестве интерпретатора произвольное пользовательское слово, которое, в свою очередь, может быть как низкоуровневым, вроде 'call', так и высокоуровневым, определённым в шитом коде, или даже словом пользовательсвкого типа! Как же писать эти подпрограммы, спросите вы. Низкоуровневые определения Низкоуровневые определения начинаются со слова create-item, за которым следуют операторы компиляции машинного кода. Ничего фантастического тут нет. Код create-item nop $FFAD , $E0 c, Впрочем, для использования более комфортного ассемблера существуют слова start-code и end-code, первое переходит refer в режим ассемблера, второе обратно в режим интерпретатора. А для еще более комфортной работы существует слово code, которое создаёт метку с помощью create-item, а затем переходит в режим ассемблера с помощью start-code. Тот же пример: Код code nop next end-code Этот пример нужен прежде всего, чтобы показать, что end-code не завершает определение слова, оно только выключает режим ассемблера, не существует никаких способов определить, где заканчивается определение в машинном коде, где завершится выполнение, не анализируя сам код. Высокоуровневые слова Слово type служит для определения пользовательского типа слов. Перед определением собственно типа необходимо определить макрос, который осуществляет инициализацию поля параметров слова, а также пользовательское слово-интерпретатор. После этого требуется написать что-то вроде: Код type имятипа компилятор интерпретатор После этого употребление слова имятипа в контексте Код имятипа новое-слово будет приводить к определению нового слова новое-слово пользовательского типа имятипа.Пример определения: Код type create nop nop В данном примере определяется некий тип create, который в качестве компилятора использует слово nop, которое ничего не делает во время компиляции, а в качестве интерпретатора — пользовательское слово nop (определённое в предыдущем пункте), которое тоже ничего не делает, но уже на этапе исполнения готовой программы. Слово create определяет пользовательские слова, которые в момент исполнения кладут на стек адрес своего поля параметров и больше ничего не делают. Конечно, чтобы от этого слова был толк, необходимо некоторое расширение, например:Код macro variable create 0 , endm Слово variable не только определяет пользовательское слово с указанной семантикой, но и добавляет в поле параметров небольшой буфер, в которм можно хранить текущее значение переменной, получать его словом @ и менять словом !.Шитый код Слово в шитом коде это тоже высокоуровневое слово. В компиляторе refer оно определено так: Код code call Слово : начинает определение высокоуровневой подпрограммы в шитом коде, для чего переходит в режим компиляции словом ]. Для того, чтобы вернуться в режим интерпретации, необходимо воспользоваться словом [.dec bp dec bp mov 0 [bp] si pop si next end-code type : ] call Кроме способа перейти к вложенному определению через двоеточие у нас должен быть механизм возврата к шитому коду, вызвавшему данный. Для этого существует слово exit: Код code exit Для того, чтобы не приходилось постоянно писать exit [, можно написать простой макрос:mov si 0 [bp] inc bp inc bp next end-code Код current compilers macro ; exit [ endm current interpret Теперь можно со спокойной совестью написать: Код : do-nothing ; Оно является высокоуровневым аналогом ранее определённого слова nop.to be continued... -------------------- |
|
|
29 Mar 2020, 18:16
Сообщение
#13
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Случайно заметил, что в мета-ассемблере есть ошибка: условие ?z работает на самом деле, как ?nz (то есть, противоположное).
Тем не менее, ?e (которое теоретически синоним) работает правильно. Ошибка в том месте, где словарь assembler заполняется словами. P.S. На сайте была корректная версия. Мда. -------------------- |
|
|
29 Mar 2020, 18:49
Сообщение
#14
|
|
пират с чёрной меткой Сообщений: 23 651 Спасибо сказали: 12927 раз |
А вообще возможно под 10-й запустить com-файл? Без досбокса, разумеется. Каким-нибудь лаунчером, в эмуляции 16 бит.
Есть такая практическая необходимость. -------------------- Давший быка на убой не выпросил и печень на жаркое.
|
|
|
30 Mar 2020, 00:21
Сообщение
#15
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Без досбокса или другой VM, насколько я знаю, нет. Там надо не только битность эмулировать, а ещё и DOS, и FAT.
Но DosBOX и есть в какой-то мере лаунчер. Опуская детали: Цитата dosbox name If "name" is an executable it will mount the directory of "name" as the C: drive and execute "name". Edit. Не сработает, если в конфигурации диск C уже смонтирован. -------------------- |
|
|
10 Apr 2020, 13:58
Сообщение
#16
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Добавил распознавание слов вида 'X', где X - какой-то символ (кроме, по понятным причинам, пробела).
Результат выполнения: код символа кладётся на стек, затем исполняется literal. Просто надоело писать 34 вместо кавычки и 41 вместо закрывающей скобки. Да, одиночная кавычка ''', а не '''' или '\''. В какой-то системе, помнится, была нотация #X, причём # означал пробел. 22.04 Наконец-то дошло, что макрос ascii больше не нужен. Удолил™. Заменил все использования на символьные литералы. -------------------- |
|
|
06 May 2020, 20:28
Сообщение
#17
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Оказывается, моё расширение 'X' для чисел прописано в стандарте FORTH-2012. Ничто не ново… Впрочем, в предыдущей версии стандарта, которую я читал, FORTH-94, этого ещё не было.
Также в стандарте FORTH-2012 описано распознавание не только шестнадцатеричных чисел по префиксу $, как у меня и было сделано, но и десятичных по префиксу #, и двоичных по префиксу %. Добавил. -------------------- |
|
|
10 May 2020, 13:43
Сообщение
#18
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Слово type служит для определения пользовательского типа слов. Больше не служит. Теперь оно, как ему и положено по FORTH-стандартам, снимает со стека адрес и длину строки и печатает её. То, что раньше называлось type, теперь называется typedef. Впрочем, использование тоже изменилось. Всё так же необходимо определить макрос, который осуществляет инициализацию поля параметров слова, а также пользовательское слово-интерпретатор. Но вызов выглядит так:Код ' интерпретатор typedef имятипа компилятор Примеры использования:Код ' nop typedef create nop Код ' call typedef : ] Суть определения не изменилась.Заодно поправил обработку макросов: 1) Макрос не может содержать слово macro в своём теле. 2) Если макрос не закончен словом endm, компилятор больше не зависает. Кроме того, пустой результат больше не сохраняется в файл. Новую версию выложил на ЯД (первый пост). -------------------- |
|
|
13 May 2020, 13:36
Сообщение
#19
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Теперь в макросах допустимы комментарии (они больше не попадают в макроопределение, вызывая странные ошибки при подстановке).
1) ( произвольный текст ) - произвольный текст от открывающей скобки до закрывающей скобки считается комментарием. Ограничения: должен располагается на одной строке, после открывающей скобки обязателен пробел. 2) .( произвольный текст ) - произвольный текст от открывающей скобки до закрывающей скобки будет выведен на экран (кроме первого пробела после открывающей скобки). Ограничения: должен располагается на одной строке, после открывающей скобки обязателен пробел. 3) \ произвольный текст - произвольный текст от черты до конца строки считается комментарием. Ограничения: после черты обязателен пробел. Побочный эффект: невозможность добавления в макроопределение слов: Код ( .( \ Думаю, к лучшему.Давно надо было так сделать. Новую версию выложил на ЯД (первый пост). -------------------- |
|
|
02 Jun 2020, 21:28
Сообщение
#20
|
|
😸🧡✊✌️ Сообщений: 16 027 Спасибо сказали: 2672 раза |
Новая версия. Изменения настолько глобальные, что номер версии +.01! Ссылка на новый ЯД (см. первый пост).
Изменения: 1) Из индекса словарей убраны все, кроме interpret и compilers. Теперь невозможно добавить макросы в assembler или register. Вместо этого нужные слова добавляются на этапе компиляции словом add-word. 2) Добавлен словарь macrodefs. В нём находятся слова, которые могут исполняться при разборе макроопределений. (Так теперь реализованы комментарии в макросах.) 3) Серьёзно переработан ассемблер. Теперь операнды вида [bx], [bp] и [] обрабатываются одним кодом. Который собирает правильный набор mod reg r/m. 4) Также, добавлены инструкции: Код aaa aad aam aas break (= int 3 #) clc cli cmc cmpsw daa das in into lea movsw outo scasw stc sti stosw xlat А также сегментные префиксы:Код cs: ds: es: ss: 5) Добавлены стандартные слова:Код $. >body /mod pick roll ," at to Удалены соответствующие макросы (если были).6) Добавлены макросы: Код ;code does> Исполняемый com-файл компилятора похудел примерно процентов на 14, а слов стало больше. -------------------- |
|
|
Текстовая версия | Сейчас: 28 April 2024 - 05:24 |
Copyright by Алексей Крючков
Programming by Degtyarev Dmitry |