Более полной документацией озабочусь позднее, пока только основные фишки:
1) Forth-подобный синтаксис. (Хотя это не совсем Forth...)
2) Компилятор на Refer, входит в поставку.
3) Только COM-файлы, никаких библиотек поддержки.

Скачать 1.03
Скачать 1.04
Скачать 1.05
Скачать 1.06

какие особенности у Refer?

нич-чего не понимаю! (с)

Присоединяюсь.

Одобряю эту тему

Для тех, кто не понял, поясню:
refer.com - компилятор refer, работает только с командной строки, IDE нет и не будет.
refer.ref - исходный текст компилятора. Если просматривать, то желательно в cp866 (небось и не все про нее знают). чтобы скомпилировать, надо набратьВ результате появится файл REFER.EXE, идентичный refer.com (нет, это не копирование, это компиляция).
hello.ref - аналог команды H языка HQ9+, написанный на refer.
exe-stub.ref - самый короткий MS-DOS stub (короче просто невозможно), написанный на refer.

Хм, уже третий Forth-образный язык в разделе - занятная тенденция.

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

Добавлено ([mergetime]1275759524[/mergetime]):
кстати, чайнику на заметку (нужно вставить это в инструкцию к своему интерпретатору):
везде, где требуется передать путь к файлу как первый параметр, можно просто перетянуть файл на значок приложения.

Вступление

В далеком 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, соответственно, также исторически обоснованные чуть менее, чем полностью.

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

1. положить число 2 на стек,
2. положить число 2 на стек (слово literal в режиме интерпретации определено и ничего не делает),
3. вынуть два числа из стека, сложить их и положить результат обратно на стек,
4. снять число со стека и напечатать.

Разумеется, предыдущий пример в процессе компиляции выведет на экран 4.

to be continued...

Итак, прошло почти джва года... ну и Лентяй же ты, tolich...

Принцип работы парсера

Перед тем, как продолжить. Немного о процедуре компиляции исходного текста.
Интерперетатор прост, как грабли: пока не закончится исходный текст, он циклично делает следующее:
1) Прочитать строку из входного файла.
2) Обработать строку.

Обработка строки тоже циклична: пока строка не закончилась:
1) Выделить из строки слово (последовательность символов, отличных от пробела, ограниченная пробелом или концом строки), при этом пробел-ограничитель также пропускается.
2) Поискать в контекстном словаре это слово. Если оно найдено, выполнить соответствующее ему действие (в словаре указано, какое именно) и перейти к 7.
3) Проверить, а не является ли слово записью числа (поддерживаются десятичные числа вида 125 и -125 и шестнадцатеричные вроде $7D и -$7D). Если является, положить его значение на стек, и перейти к 5.
4) Вызвать слово badword. Оно отображает информацию об неизвестном слове и прерывает работу программы. При этом на экране отображается строка исходного файла с указанием положения этого слова.
5) Поискать в контекстном словаре слово literal. Если оно найдено, выполнить соответствующее ему действие (в словаре указано, какое именно) и перейти к 7.
6) Вызвать слово badword. Оно отображает информацию об неизвестном слове literal и прерывает работу программы. При этом на экране отображается строка исходного файла с указанием положения числа.
7) С этим словом всё, плавно переходим к следующему.

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

Примечание: в дальнейшем если я буду писать "скомпилировать байт/слово/строку" это всего лишь означает "добавить байт/слово/строку в выходной буфер, зарезервировав этот участок буфера".

Пользовательские слова
Словарь userwords содержит слова, определённые пользователем. Словарь userwords содержит слова, которые выполняются в процессе компиляции, причём поиск слов в нем происходит сразу после словаря compilers. Все слова, определённые в этом словаре, имеют схожую семантику: скомпилировать значение указателя выходного буфера на момент создания слова.

Самым простым способом создания такого слова является create-item.

создает новое слово new-word, которо является просто меткой. При этом текущий словарь устанавливать не надо, новые слова всегда создаются в словаре userwords.

Зачем нужны такие слова? Для компиляции последовательности ссылок. Вначале create-item или другое, использующее его слово, создаёт метку в словаре userwords, затем в процессе компиляции ссылка на эту метку помещается в выходной буфер.

Значение адреса метки можно получить с помощью слова ':

в процессе компиляции напечатает значение адреса определённого выше слова (скорее всего, это будет 256 ).

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

Макросы

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

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

Конкретный пример:


Его можно вызвать, например, так:


Это полностью аналогично следующему фрагменту:



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

Макросы компиляции

Для того, чтобы определять макросы периода компиляции, необходимо выбрать текущим словарь compilers.
Это делается словом current:

Все последующие макроопределения будут помещены в словарь compilers, до тех пор пока не встетится код:

который устанавливает текущим словарь interpret.

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

В процессе определения макроса не надо забывать, что в момент его исполнения не происходит переключения контекста. Это означает, например, необходимость явно переключить контекст на интерпретацию.

Конкретный пример:


В этом примере определяется макрос literal (который, как мы помним, используется для обработки чисел). Итак, что он делает:
1) Записывает в выходной буфер ссылку на пользовательское слово lit.
2) Переключает компилятор на словарь interpret.
3) Снимает со стека число и записывает в выходной буфер.
4) Переключает компилятор на словарь compilers.
В результате мы имеем в выходном буфере 2 двухбайтных слова: ссылку на lit и обрабатываемое число. В процессе выполнения будет вызвано слово lit, скорее всего, оно положит то самое скомпилированное число на стек данных.

Замечание: возможно, но нежелательно делать словарь userwords текущим. Макросы компиляции лучше добавлять в словарь compilers, так они будут иметь приоритет над определёнными позднее одноимёнными пользовательскими словами. Для того же, чтобы в процессе компиляции компилировать пользовательское слово, а не вызывать одноимённое слово-компилятор, можно применять следующий макрос:

Прямой шитый код и типы слов

В реализации применён прямой шитый код. Причём текущий указатель интерпретации хранится в DS:SI, вершина стека данных в SS:SP, а вершина стека возврата в SS:BP. Что это означает?

Пользовательские низкоуровневые определения представляют собой обычный машинный код, который заканчивается, правда, не инстукцией ret, а трёхбайтовой последовательностью lodsw jmp ax (которая сокращённо записывается, как next). Тем самым осуществляется переход к интерпретации очередной ссылке в последовательности ссылок. В дальнейшем я не буду упоминать, что низкоуровневое слово выполняет последовательность next, так как бесполезно писать про каждую подпрограмму, что она заканчивается оператором возврата.

Высокоуровневые определения начинаются с команды call перехода к подпрограмме интерпретатора. Это команда, кроме собственно перехода, кладёт в стек SS:SP "адрес возврата", который в нашем случае не используется для возврата, а является адресом поля параметров высокоуровнего определения. Инетерпретатор получает адрес поля параметров на вершине стека и обрабатывает его способом, свойственным для слов данного типа.

Например, подпрограммы в шитом коде также используют интерпретатор 'call', который кладёт текущее значение указателя интерпретации (только SI, конечно) на стек возврата, а затем снимает новое значение этого указателя со стека данных.

Слова пользовательского типа могут использовать в качестве интерпретатора произвольное пользовательское слово, которое, в свою очередь, может быть как низкоуровневым, вроде 'call', так и высокоуровневым, определённым в шитом коде, или даже словом пользовательсвкого типа!

Как же писать эти подпрограммы, спросите вы.

Низкоуровневые определения

Низкоуровневые определения начинаются со слова create-item, за которым следуют операторы компиляции машинного кода. Ничего фантастического тут нет.
Впрочем, для использования более комфортного ассемблера существуют слова start-code и end-code, первое переходит refer в режим ассемблера, второе обратно в режим интерпретатора. А для еще более комфортной работы существует слово code, которое создаёт метку с помощью create-item, а затем переходит в режим ассемблера с помощью start-code. Тот же пример:
Этот пример нужен прежде всего, чтобы показать, что end-code не завершает определение слова, оно только выключает режим ассемблера, не существует никаких способов определить, где заканчивается определение в машинном коде, где завершится выполнение, не анализируя сам код.

Высокоуровневые слова

Слово type служит для определения пользовательского типа слов. Перед определением собственно типа необходимо определить макрос, который осуществляет инициализацию поля параметров слова, а также пользовательское слово-интерпретатор. После этого требуется написать что-то вроде:
После этого употребление слова имятипа в контекстебудет приводить к определению нового слова новое-слово пользовательского типа имятипа.
Пример определения:В данном примере определяется некий тип create, который в качестве компилятора использует слово nop, которое ничего не делает во время компиляции, а в качестве интерпретатора — пользовательское слово nop (определённое в предыдущем пункте), которое тоже ничего не делает, но уже на этапе исполнения готовой программы. Слово create определяет пользовательские слова, которые в момент исполнения кладут на стек адрес своего поля параметров и больше ничего не делают. Конечно, чтобы от этого слова был толк, необходимо некоторое расширение, например:Слово variable не только определяет пользовательское слово с указанной семантикой, но и добавляет в поле параметров небольшой буфер, в которм можно хранить текущее значение переменной, получать его словом @ и менять словом !.

Шитый код

Слово в шитом коде это тоже высокоуровневое слово. В компиляторе refer оно определено так:Слово : начинает определение высокоуровневой подпрограммы в шитом коде, для чего переходит в режим компиляции словом ]. Для того, чтобы вернуться в режим интерпретации, необходимо воспользоваться словом [.

Кроме способа перейти к вложенному определению через двоеточие у нас должен быть механизм возврата к шитому коду, вызвавшему данный. Для этого существует слово exit:Для того, чтобы не приходилось постоянно писать exit [, можно написать простой макрос:
Теперь можно со спокойной совестью написать:Оно является высокоуровневым аналогом ранее определённого слова nop.

to be continued...

Случайно заметил, что в мета-ассемблере есть ошибка: условие ?z работает на самом деле, как ?nz (то есть, противоположное).
Тем не менее, ?e (которое теоретически синоним) работает правильно. Ошибка в том месте, где словарь assembler заполняется словами.

P.S. На сайте была корректная версия. Мда.

А вообще возможно под 10-й запустить com-файл? Без досбокса, разумеется. Каким-нибудь лаунчером, в эмуляции 16 бит.
Есть такая практическая необходимость.

Без досбокса или другой VM, насколько я знаю, нет. Там надо не только битность эмулировать, а ещё и DOS, и FAT.
Но DosBOX и есть в какой-то мере лаунчер. Опуская детали:


Edit. Не сработает, если в конфигурации диск C уже смонтирован.

Добавил распознавание слов вида 'X', где X - какой-то символ (кроме, по понятным причинам, пробела).
Результат выполнения: код символа кладётся на стек, затем исполняется literal.
Просто надоело писать 34 вместо кавычки и 41 вместо закрывающей скобки. Да, одиночная кавычка ''', а не '''' или '\''.
В какой-то системе, помнится, была нотация #X, причём # означал пробел.

22.04 Наконец-то дошло, что макрос ascii больше не нужен. Удолил™. Заменил все использования на символьные литералы.

Оказывается, моё расширение 'X' для чисел прописано в стандарте FORTH-2012. Ничто не ново… Впрочем, в предыдущей версии стандарта, которую я читал, FORTH-94, этого ещё не было.
Также в стандарте FORTH-2012 описано распознавание не только шестнадцатеричных чисел по префиксу $, как у меня и было сделано, но и десятичных по префиксу #, и двоичных по префиксу %. Добавил.

Больше не служит. Теперь оно, как ему и положено по FORTH-стандартам, снимает со стека адрес и длину строки и печатает её. То, что раньше называлось type, теперь называется typedef. Впрочем, использование тоже изменилось. Всё так же необходимо определить макрос, который осуществляет инициализацию поля параметров слова, а также пользовательское слово-интерпретатор. Но вызов выглядит так:Примеры использования:Суть определения не изменилась.

Заодно поправил обработку макросов:
1) Макрос не может содержать слово macro в своём теле.
2) Если макрос не закончен словом endm, компилятор больше не зависает.

Кроме того, пустой результат больше не сохраняется в файл.

Новую версию выложил на ЯД (первый пост).

Теперь в макросах допустимы комментарии (они больше не попадают в макроопределение, вызывая странные ошибки при подстановке).
1) ( произвольный текст ) - произвольный текст от открывающей скобки до закрывающей скобки считается комментарием. Ограничения: должен располагается на одной строке, после открывающей скобки обязателен пробел.
2) .( произвольный текст ) - произвольный текст от открывающей скобки до закрывающей скобки будет выведен на экран (кроме первого пробела после открывающей скобки). Ограничения: должен располагается на одной строке, после открывающей скобки обязателен пробел.
3) \ произвольный текст - произвольный текст от черты до конца строки считается комментарием. Ограничения: после черты обязателен пробел.

Побочный эффект: невозможность добавления в макроопределение слов:Думаю, к лучшему.

Давно надо было так сделать.

Новую версию выложил на ЯД (первый пост).

Новая версия. Изменения настолько глобальные, что номер версии +.01! Ссылка на новый ЯД (см. первый пост).

Изменения:
1) Из индекса словарей убраны все, кроме interpret и compilers. Теперь невозможно добавить макросы в assembler или register. Вместо этого нужные слова добавляются на этапе компиляции словом add-word.
2) Добавлен словарь macrodefs. В нём находятся слова, которые могут исполняться при разборе макроопределений. (Так теперь реализованы комментарии в макросах.)
3) Серьёзно переработан ассемблер. Теперь операнды вида [bx], [bp] и [] обрабатываются одним кодом. Который собирает правильный набор mod reg r/m.
4) Также, добавлены инструкции:А также сегментные префиксы:5) Добавлены стандартные слова:Удалены соответствующие макросы (если были).
6) Добавлены макросы:

Исполняемый com-файл компилятора похудел примерно процентов на 14, а слов стало больше.

Обновление.
1. Добавлен контроль управляющих структур (?pairs). Неприятно, когда программа иногда перестаёт работать из-за пропущенного then.
2. Добавлена классическая структура case-of-endof-endcase.3. Добавлена совсем не классическая структура do-macroloop (цикл по цепочке строк со счётчиком, которую завершает пустая строка). Также старый do теперь ?do, а новый не проверяет параметры на равенство. Для вложенных циклов приехал j (итератор внешнего цикла).
4. Литералы двойной длины (записываются с точкой). Также переменные двойной длины, константы двойной длины.
5. Слово s" - строковый литерал.
6. Обработка исключений, как в FORTH-94 (и 2012). (Регистр DI больше не зарезервирован, он указывает на последний кадр исключения.)
7. Повторы (5 do: cr) и условия (dup 256 u< if-true: c,) в макроопределениях.
8. Исправлено несколько ошибок в определениях.

P.S. Одна осталась: if-true: реализован как 0<> do:, в результате, если условие истинное, то команда выполняется 65535 раз.
Правильный вариант был бы 0<> negate do: или 0= 1+ do:.
P.P.S. Поправлено на правильный вариант 2, он прикольный.
P.P.P.S. Также изменил распознавание чисел (слово value), разложив его на 4 слова, каждое выполняет свою малую функцию. Получилось короче, и в исходнике, и в собранном виде.

Обновление. Кроме упомянутого исправленного if-true:
1) Исключения теперь используются. Все примитивы контролируются на возможные переполнение стеков данных и возврата. (Например, если у слова нет параметров, не проверяется, может ли оно снять что-то лишнее со стека данных.) Некоторые примитивы переписаны через двоеточие, только чтобы было поменьше примитивов с контролем стека. Также, теперь нельзя создать определение для пустого слова.
2) Перераспределена память.
2.1) Увеличен вдвое файловый буфер, со 128 до 256 байт.
2.2) Стеки, напротив, уменьшены: были 4К стек возврата и фактически безразмерный стек данных, и они не контролировались. Теперь они по 128 байт, и их использование контролируется.
2.3) Файловый буфер и буфер памяти перемещены в старшие адреса, сразу под стеки.
2.4) Оставшаяся память это словарь, и контролируется, чтобы он не пересекал границу буфера памяти.

Новая версия, 1.06.
1) Изменена командная строка.
1.1) Ключ -E превратился в -o (он же --outfile).
1.2) Добавлен ключ --format=<format>, где <format> либо com, либо exe. Да, мы теперь умеем в EXE-файлы. Компилятор, скомпилированный в COM-файл, по умолчанию создаёт COM-файлы, а скомпилированный в EXE-файл, — EXE-файлы. Для изменения формата используется этот ключ.
1.2a) Если компилятор, скомпилированный в COM-файл, преобразовать в EXE-файл, он должен работать. Если компилятор, скомпилированный в EXE-файл, преобразовать в COM-файл, он работать не будет, потому что в его коде запуска нет инициализации регистров SS и SP.
1.3) Слово goal добавлено для указания адреса слова, которое выполняет запуск. Для EXE-файла оно просто устанавливает значение поля IP в заголовке, для COM-файла настраивает команду безусловного перехода, которую необходимо добавить в начало кода. Способы различны, но субъективно первый самый простой, поэтому на него ссылается сообщение об ошибке:1.4) Впрочем, если код запуска в начале файла (т.е., по адресу $100), команда goal факультативна и ничего не меняет. Это значит, что COM-файл не обязан начинаться с команды jmp.

2) Снова перераспределена память.
2.1) Стеки вынесены в отдельный сегмент стека, увеличены, но их использование всё так же контролируется.
2.3) Файловый буфер и буфер памяти перемещены в старшие адреса в сегменте данных.
2.4) Оставшаяся часть сегмента данных это словарь, и контролируется, чтобы он не пересекал свою верхнюю границу.

3) Тестирование
3.1) Добавлены слова T{ -> }T для создания тест-кейсов. Формат:Пример:В случае несовпадения актуальных результатов с ожидаемыми, будет выведено сообщение об ошибке. В случае ошибки при выполнении самих слов, скорее всего, тоже.
3.2) Добавлены слова test1 и test2 для тестирования механизма catch/throw. Файл "throw-3.ref":3.3) Ещё много тестовых файлов с комментариями, что проверяется, и какие ожидаются результаты. Не пройдёт и полгода, и я снабжу комментариями и сам код refer.

4) Да, теперь всюду словари.
4.1) Для компиляции макроопределения используется словарь macrodefs, для исполнения — macrocode. Комментарии удаляются в первом, do: и if-true: работают из второго. Теперь do: и if-true: валидны только в макросах.
4.2) Для ключей командной строки — словарь keyparams.
4.3) Для пропуска слов в условной компиляции — словарь condition.

P.S. Добавил пару тестов.