gpp - Интернет в облаке

ПРОГРАММА:

ИМЯ

GPP - Универсальный препроцессор

СИНТАКСИС

gpp [- {o | O} Outfile] [-я/ включить / путь] [-Дname = val ...]
[-z | + z] [-x] [-m] [-C | -T | -H | -X | -P | -U ... [-M ...]]
[-n | + n] [+ c str1 str2] [+ s str1 str2 c]
[-с str1] [-nostdinc] [-nocurinc]
[--curdirinclast] [--warninglevel n]
[--includemarker ул] [--включают файл]
[вводить]

gpp --помощь

gpp --версия

ОПИСАНИЕ

GPP - это универсальный препроцессор с настраиваемым синтаксисом, подходящий для широкого диапазона
предпроцессорных задач. Его независимость от любого языка программирования делает его намного больше
универсален, чем cpp, а его синтаксис легче и гибче, чем у m4.

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

Изначально GPP понимает только минимальный набор встроенных макросов, называемых мета-макросы.
Эти мета-макросы позволяют определять пользователь Макрос а также некоторые основные операции
формирование ядра системы предварительной обработки, включая условные тесты, арифметику
оценка, сопоставление с подстановочными знаками (подстановка) и спецификация синтаксиса. Все пользовательские макросы
определения глобальны - т.е., они остаются в силе до тех пор, пока явно не будут удалены; мета-макросы
не может быть переопределен. С каждым определением макроса пользователя GPP отслеживает соответствующие
спецификация синтаксиса, чтобы макрос можно было безопасно вызывать независимо от любых последующих
изменение рабочего режима.

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

ДОПОЛНИТЕЛЬНЫЕ ОПЦИИ

GPP распознает следующие параметры и параметры командной строки. Обратите внимание, что -nostdinc,
Параметры -nocurinc, -curdirinclast, -warninglevel и -includemarker из версии 2.1 и
ранее устарели и не должны использоваться. Вместо этого используйте варианты с "длинным вариантом"
(--ностдинк, и так далее).

-h --Помогите
Распечатайте короткое справочное сообщение.

--версия
Информация о версии для печати.

-o Outfile
Укажите файл, в который следует отправлять весь вывод (по умолчанию все отправляется
в стандартный вывод).

-O Outfile
Укажите файл, в который следует отправлять весь вывод; вывод одновременно отправляется в
стандартный вывод.

-I/ включить / путь
Укажите путь, по которому #включают мета-макрос будет искать включаемые файлы, если они
отсутствуют в текущем каталоге. По умолчанию / usr / include если нет -я
опция указана. Можно указать несколько опций -I для просмотра в нескольких
каталоги.

-Dname = val
Определите пользовательский макрос имя как равный волна. Это строго эквивалентно использованию
#define мета-макрос, но позволяет определять макросы из команды-
линия. Если волна ссылается на аргументы или другие макросы, он должен соответствовать
синтаксис режима, указанного в командной строке. Начиная с версии 2.1,
Именование аргументов макроса разрешено в командной строке. Синтаксис следующий:
-Dмакрос(arg1знак равноопределение. Аргументы указаны в синтаксисе C-стиля,
без пробелов, но определение должно соответствовать синтаксису
режим, указанный в командной строке.

+z Установите текстовый режим в режим Unix (терминатор LF). Любой символ CR во входных данных
систематически отбрасывается. Это значение по умолчанию в системах Unix.

-z Установите текстовый режим в режим DOS (терминатор CR-LF). В этом режиме все символы CR
удаляется из входа, и все выходные символы LF преобразуются в CR-LF. Этот
используется по умолчанию, если GPP скомпилирован с параметром WIN_NT.

-x Разрешить использование #exec мета-макрос. С #exec включает вывод
произвольной командной строки оболочки, это может вызвать потенциальную угрозу безопасности и, следовательно,
отключено, если не указана эта опция.

-m Включите автоматическое переключение режима в режим совместимости cpp, если имя
включаемый файл оканчивается на `.h 'или` .c'. Это позволяет включить заголовок C
файлы с небольшими изменениями.

-n Запретить удаление символов новой строки или пробелов из ввода, когда
они появляются как конец вызова макроса или комментария. По умолчанию, когда перевод строки
или пробельный символ образует конец макроса или комментария, который анализируется как часть
вызова макроса или комментария и поэтому удаляются из вывода. Используйте параметр -n
чтобы сохранить последний символ во входном потоке, если он был пробелом или новой строкой.
Это активируется в режимах cpp и Prolog.

+n Противоположность -n. Это значение по умолчанию для всех режимов, кроме cpp и Prolog. Примечание
это + n должно быть помещено после -C или -P, чтобы иметь какой-либо эффект.

-U arg1 ... arg9
Пользовательский режим. Следующие девять аргументов командной строки считаются
соответственно, последовательность начала макроса, последовательность конца макроса для вызова без
аргументы, последовательность начала аргумента, разделитель аргумента, конец аргумента
последовательность, список символов в стек для балансировки аргументов, список
символы для разделения, строка, которая будет использоваться для ссылки на аргумент
число и, наконец, символ кавычки (если их нет, должна быть пустая строка
при условии). Эти настройки применяются как к пользовательским макросам, так и к метамакросам, если только
Параметр -M используется для определения других настроек для мета-макросов. См. Раздел о
спецификация синтаксиса для более подробной информации.

-M arg1 ... arg7
Спецификации пользовательского режима для мета-макросов. Эту опцию можно использовать только
вместе с -M. Следующие семь аргументов командной строки считаются
соответственно, последовательность начала макроса, последовательность конца макроса для вызова без
аргументы, последовательность начала аргумента, разделитель аргумента, конец аргумента
последовательность, список символов для стекирования для балансировки аргументов и список
символы для разделения. Подробности смотрите ниже.

(дефолт режим)
Режим по умолчанию немного похож на cpp, но он не обрабатывает комментарии и
представляет различные несовместимости с cpp. Типичные мета-макросы и пользовательские макросы
выглядеть следующим образом:

#define xy
макрос (аргумент, ...)

Этот режим эквивалентен

-U "" "" "(" "," ")" "(" ")" "#" "\\"
-M "#" "\ n" "" "" "\ n" "(" ")"

-C cpp режим совместимости. Это режим, в котором поведение GPP наиболее близко к
что из cpp. В отличие от режима по умолчанию, раскрытие мета-макроса происходит только в
начало строк, а также комментарии и строки языка Си. Этот режим
что эквивалентно

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\ n # \ w" "\ n" "" "" "\ n" "" ""
+ c "/ *" "* /" + c "//" "\ n" + c "\\\ n" ""
+ s "\" "" \ "" "\\" + s "'" "'" "\\"

-T TeX-подобный режим. В этом режиме типичные мета-макросы и пользовательские макросы выглядят так:

\ define {x} {y}
\ macro {arg} {...}

Никаких комментариев не понял. Этот режим эквивалентен

-U "\\" "" "{" "} {" "}" "{" "}" "#" "@"

-H HTML-подобный режим. В этом режиме типичные мета-макросы и пользовательские макросы выглядят так:

<# определить x | y>
<#macro arg | ...>

Никаких комментариев не понял. Этот режим эквивалентен

-U "<#" ">" "\ B" "|" ">" "<" ">" "#" "\\"

-X XHTML-подобный режим. В этом режиме типичные мета-макросы и пользовательские макросы выглядят так:

<# определить x | y />
<#macro arg | ... />

Никаких комментариев не понял. Этот режим эквивалентен

-U "<#" "/>" "\ B" "|" "/>" "<" ">" "#" "\\"

-P Совместимый с Prolog cpp-подобный режим. Этот режим отличается от режима совместимости cpp.
обработкой комментариев и эквивалентен

-n -U "" "" "(" "," ")" "(" ")" "#" ""
-M "\ n # \ w" "\ n" "" "" "\ n" "" ""
+ ccss "\! o / *" "* /" + ccss "%" "\ n" + ccii "\\\ n" ""
+ s "\" "" \ "" "" "+ s" \! # '""' "" "

+c str1 str2
Комментарии уточняйте. Любое некотируемое появление str1 будет интерпретироваться как
начало комментария. Все входные данные до первого следующего появления str2 предусматривает
быть отброшенным. Этот параметр можно использовать несколько раз, чтобы указать разные типы
разделители комментариев. Необязательный параметр можно указать, чтобы изменить
поведение комментария и, или, превратите его в строку или сделайте игнорирование в
определенные обстоятельства, см. ниже.

-c str1
Не указывайте комментарии или строки. Спецификация комментария / строки, начало которой
последовательность str1 устранен. Это полезно для изменения встроенного комментария
характеристики стандартного режима - или, режим совместимости cpp.

+s str1 str2 c
Укажите строки. Любое некотируемое появление str1 будет интерпретироваться как
начало строки. Все входные данные до первого следующего появления str2 предусматривает
выводиться как есть, без какой-либо оценки. Сами разделители выводятся. Если c
не пусто, его первый символ используется как строка-цитата персонаж -- т.е., чтобы
персонаж, присутствие которого непосредственно перед возникновением str2 предотвращает это от
завершение строки. Необязательный параметр можно указать, чтобы изменить
поведение строки и, или, превратить его в комментарий, включить оценку макроса
внутри строки или сделать так, чтобы спецификация строки игнорировалась при определенных
обстоятельства. Увидеть ниже.

-s str1
Не указывайте комментарии или строки. Идентично -c.

--включают файл
Разработка файл до вводить

--nostdinc
Не ищите включаемые файлы в стандартном каталоге / usr / include.

--нокуринк
Не ищите включаемые файлы в текущем каталоге.

--курдиринкласт
Ищите включаемые файлы в текущем каталоге после каталоги, указанные
-I а не до них.

--warninglevel n
Установите уровень предупреждения на n (0, 1 или 2). По умолчанию - 2 (самый подробный).

--includemarker ул
следить за #включают директивы, вставив маркер в выходной поток. В
формат маркера определяется ул, который должен содержать три вхождения
персонаж % (или эквивалентно ?). Первое вхождение заменяется строкой
номер, второй - с именем файла, а третий - с 1, 2 или пробелом. Когда это
опция указана в режиме по умолчанию, cpp или Prolog, GPP делает все возможное, чтобы гарантировать
что номера строк на выходе такие же, как и на входе, вставив пробел
строки вместо определений или комментариев.

вводить Укажите входной файл, из которого GPP считывает свои входные данные. Если входной файл не
указано, ввод считывается из стандартного ввода.

СИНТАКСИС ТЕХНИЧЕСКИЕ ХАРАКТЕРИСТИКИ

Синтаксис макроса следующий: он должен начинаться с последовательности символов.
соответствие макрос Начало последовательность как указано в текущем режиме, сразу после этого
по имени макроса, который должен быть допустимым идентификатор -- т.е., последовательность букв,
цифры или символы подчеркивания ("_"). После имени макроса должен стоять короткие макрос конец
последовательность если у макроса нет аргументов, или последовательностью аргументов, инициированной
аргумент Начало последовательность. Затем различные аргументы разделяются знаком аргумент
разделитель, и макрос заканчивается длинной макрос конец последовательность.

Во всех случаях параметры текущего контекста - т.е., аргументы, переданные в
оцениваемое тело - на него можно ссылаться, используя аргумент ссылка последовательность
за которым следует цифра от 1 до 9. В качестве альтернативы, параметры макроса могут быть названы (см.
ниже). Кроме того, чтобы избежать интерференции между синтаксисом GPP и содержимым
входной файл, цену персонаж предоставлен. Символ кавычки может использоваться для предотвращения
интерпретация вызова макроса, комментария или строки как чего-либо, кроме обычного текста. Цитата
персонаж «защищает» следующего персонажа и всегда удаляется во время оценки.
Два последовательных символа кавычек оцениваются как символ одиночной кавычки.

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

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

Если не выбран один из стандартных режимов работы, указанные выше синтаксические последовательности могут быть
указывается либо в командной строке, используя параметры -M и -U соответственно для мета-
макросы и пользовательские макросы, или внутри входного файла через #Режим цель и #Режим пользователь мета-
вызовы макросов. В обоих случаях описание режима состоит из девяти параметров для пользователя.
спецификации макроса, а именно: начальная последовательность макроса, короткая конечная последовательность макроса,
начальная последовательность аргументов, разделитель аргументов, длинная конечная последовательность макроса, строка
список символов для стекирования, строка с перечнем символов, которые нужно разложить, аргумент
ссылочная последовательность и, наконец, символ кавычки. Как объяснено ниже, эти последовательности
должны предоставляться с использованием синтаксиса строк C; они должны начинаться с не буквенно-цифрового
символа, а в первых пяти строках могут использоваться специальные соответствующие последовательности (см.
ниже). Если аргумент, соответствующий символу кавычки, является пустой строкой, это
функция аргумента отключена. Для мета-макро спецификаций всего семь
параметры, так как ссылочная последовательность аргументов и символ кавычки используются совместно с
синтаксис пользовательского макроса.

Структура комментария / строки следующая: она должна начинаться с последовательности
символы, соответствующие заданному комментарий / строка Начало последовательность, и всегда заканчивается первым
возникновение комментарий / строка конец последовательность, если ему не предшествует нечетное количество
появления строка-цитата персонаж (если такой символ был указан). В
в некоторых случаях можно указать комментарии / строки, чтобы включить оценку макроса внутри
комментарий / строка; в этом случае, если для макроса был определен символ кавычки, он может быть
также используется для предотвращения завершения комментария / строки, с той разницей, что макрос
символ кавычки всегда удаляется из вывода, тогда как символ строковой кавычки всегда
вывод. Также обратите внимание, что при определенных обстоятельствах спецификация комментария / строки может быть
инвалид, и в этом случае начальная последовательность комментария / строки просто игнорируется. Наконец, это
можно указать string предупреждение персонаж чье присутствие внутри комментария / строки
приведет к тому, что GPP выдаст предупреждение (это полезно для поиска незавершенных строк в cpp
Режим). Обратите внимание, что входные файлы не могут содержать незавершенные комментарии / строки.

Спецификацию комментария / строки можно объявить из входного файла с помощью #Режим
комментарий вызов мета-макроса (или эквивалентно #Режим string), и в этом случае число C
строки, которые должны быть указаны в качестве аргументов для описания комментария / строки, могут быть где угодно между
два и четыре: первые два аргумента (обязательные) - это начальная последовательность и конец
последовательность, и может использовать специальные соответствующие последовательности (см. ниже). Они не могут
начинаются с буквенно-цифровых символов. Первый символ третьего аргумента, если есть
один, используется как символ строковой кавычки (используйте пустую строку, чтобы отключить
функциональность), а первый символ четвертого аргумента, если он есть, используется
как строковый предупреждающий символ. Спецификация также может быть дана из командной строки,
в этом случае должно быть два аргумента, если используется опция + c, и три, если используется + s
опцию.

Поведение комментария / строки определяется трехсимвольной строкой модификатора, которая
может быть передан в качестве необязательного аргумента либо параметрам командной строки + c / + s, либо параметру
#Режим комментарий/#Режим string мета-макросы. Если строка модификатора не указана, по умолчанию
значение "ccc" для комментариев и "sss" для строк. Первый символ соответствует
поведение внутри вызовов мета-макросов (включая определения пользовательских макросов, поскольку они входят в
a #define мета-макроса), второй символ соответствует поведению внутри пользователя-
параметры макроса, а третий символ соответствует поведению вне любого макроса
вызов. Каждый из этих символов может принимать следующие значения:

i отключить спецификацию комментария / строки.

c комментарий (не оценивается и не выводится).

s строка (строка и последовательности ее разделителей выводятся как есть).

q строка в кавычках (строка выводится как есть, без разделительных последовательностей).

C оцененный комментарий (макросы оцениваются, но вывод отбрасывается).

S вычисляемая строка (вычисляются макросы, выводятся разделители).

Q вычисленная строка в кавычках (макросы оцениваются, разделители не выводятся).

Важное примечание: любое вхождение последовательности начала комментария / строки внутри другого
комментарий / строка всегда игнорируется, даже если включена оценка макроса. Другими словами,
комментарии / строки не могут быть вложенными. В частности, модификатор `Q 'может быть удобным способом
определения синтаксиса для временного отключения всех спецификаций комментариев и строк.

Строки спецификации синтаксиса всегда должны предоставляться как строки C, независимо от того, являются ли они
в качестве аргументов #Режим вызов мета-макроса или в командной строке оболочки Unix. Если
аргументы командной строки передаются другим методом, отличным от стандартной оболочки Unix, тогда
поведение оболочки должно быть эмулировано - т.е., следует удалить окружающие кавычки, все
вхождения `\\ 'следует заменить одной обратной косой чертой, и аналогично` \ "' следует
заменяется на `" '. Последовательности вроде `\ n' распознаются GPP и должны быть оставлены как есть.

Могут использоваться специальные последовательности, соответствующие определенным подмножествам набора символов. Они из
форма `\x', где x один из:

b соответствует любой последовательности из одного или нескольких пробелов или символов табуляции (`\ b 'идентично
'').

w соответствует любой последовательности из нуля или более пробелов или символов табуляции.

B соответствует любой последовательности из одного или нескольких пробелов, табуляции или символов новой строки.

W соответствует любой последовательности из нуля или более пробелов, табуляции или символов новой строки.

a буквенный символ (от «a» до «z» и от «A» до «Z»).

A алфавитный символ, пробел, табуляция или перевод строки.

# цифра (от «0» до «9»).

i символ-идентификатор. Набор совпадающих символов настраивается с помощью
#Режим кодировок id команда. Настройка по умолчанию соответствует буквенно-цифровым символам и
символы подчеркивания (от «a» до «z», от «A» до «Z», от «0» до «9» и «_»).

t символ табуляции.

n символ новой строки.

o операторский символ. Набор совпадающих символов настраивается с помощью
#Режим кодировок op команда. Настройка по умолчанию соответствует всем символам в
"+ - * / \ ^ <> =` ~:.? @ # &!% | ", кроме режима Пролог, где`! ', `%' и` | ' не
соответствует.

O символ оператора или символ круглой скобки. Набор дополнительных подобранных
символы по сравнению с `\ o 'настраиваются с помощью #Режим кодировок паритет
команда. По умолчанию символы в "() [] {}" используются в круглых скобках.

Более того, все эти совпадающие подмножества, кроме `\ w 'и` \ W', могут быть отменены путем вставки
`! ' - т.е., написав `\!x'вместо `\x'.

Отметим важную отличительную особенность Начало последовательности: когда первый символ
последовательность начала макроса или комментария / строки '' или одна из указанных выше специальных последовательностей, это
не считается частью самой последовательности, а используется вместо этого как проверка контекста: для
Например, начальная последовательность, начинающаяся с '\ n', соответствует только началу строки, но
соответствующий символ новой строки не считается частью последовательности. Точно так же начало
последовательность, начинающаяся с '', соответствует только в том случае, если присутствует некоторый пробел, но совпадение
пробелы не считаются частью начальной последовательности и поэтому отправляются в
вывод. Если проверка контекста выполняется в самом начале файла (или, в более общем смысле,
любого тела, подлежащего оценке), результат будет таким же, как при сопоставлении с символом новой строки
(это позволяет файлу cpp-режима запускаться с вызова мета-макроса).

В версии 2.1 были добавлены два специальных синтаксических правила. Во-первых, ссылки на аргументы (#n) являются не
дольше оцениваются, когда они находятся вне макросов и определений. Однако они
больше не разрешено появляться (если не защищено символами кавычек) внутри вызова
определенный пользовательский макрос; текущее поведение (обратно совместимое) заключается в их тихом удалении
со входа, если это произойдет.

Во-вторых, если конечная последовательность (для макросов или комментариев) состоит из одной новой строки
символ, и если правила разграничения приводят к оценке в контексте, где последний
отсутствует символ новой строки, GPP молча игнорирует отсутствующую новую строку вместо создания
ошибка. Основным следствием этого является то, что вызовы мета-макросов теперь могут быть легко вложены.
в стандартном, cpp и Prolog режимах.

ОЦЕНКА ПРАВИЛА

Ввод читается последовательно и интерпретируется в соответствии с правилами текущего режима. Все
вводимый текст сначала сопоставляется с указанными начальными последовательностями комментария / строки
текущий режим (кроме тех, которые отключены модификатором 'i'), если только тело
оценивается - это содержимое комментария / строки, модификатор которой включает оценку макроса.
Сначала проверяются самые последние определенные спецификации комментариев / строк. Важный
примечание: комментарии могут не появляться между именем макроса и его аргументами (при этом
приводит к неопределенному поведению).

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

Обратите внимание, что аргументы мета-макроса передаются метамакросу до любой оценки.
(хотя мета-макрос может выбрать их оценку, см. описания мета-макроса ниже).
В случае с #Режим мета-макрос, GPP временно добавляет спецификацию комментария / строки
чтобы включить распознавание строк C ("...") и предотвратить любую оценку внутри них, поэтому нет
вмешательство символов, помещаемых в строковые аргументы C, в #Режим с
текущего синтаксиса следует опасаться.

С другой стороны, аргументы пользовательского макроса систематически оцениваются, а затем
передается как параметры контекста в тело определения макроса, которое оценивается с помощью этого
окружающая обстановка. Единственное исключение - когда определение макроса пустое, и в этом случае его
аргументы не оцениваются. Обратите внимание, что GPP временно переключается обратно в режим, в котором
макрос был определен для его оценки, поэтому можно совершенно безопасно изменить
режим работы между временем определения макроса и временем его вызова.
И наоборот, если пользовательский макрос желает работать с текущим режимом вместо того, который
был использован для определения, что он должен начинаться с #Режим восстановление позвонить и закончить #Режим
спасти вызов.

Пользовательский макрос может быть определен с именованными аргументами (см. #define описание ниже). В этом
случае, когда определение макроса оценивается, каждый именованный параметр вызывает
создание временного виртуального пользовательского макроса; такой макрос может вызываться только
без аргументов и просто возвращает текст соответствующего аргумента.

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

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

МЕТА-МАКРОСЫ

Эти макросы всегда предопределены. Их фактическая последовательность вызова зависит от текущего
Режим; здесь мы используем обозначение типа cpp.

#define x y
Это определяет пользовательский макрос x as y. y может быть любым допустимым вводом GPP, а может для
пример относятся к другим макросам. x должен быть идентификатором (т.е.последовательность
буквенно-цифровые символы и '_'), если не указаны именованные аргументы. Если x is
уже определено, предыдущее определение перезаписывается. Если нет второго аргумента
данный, x будет определен как макрос, который ничего не выводит. Ни один x ни y
оценен; определение макроса оценивается только при его вызове, а не при его
объявлен.

Также можно назвать аргументы в определении макроса: в этом случае
аргумент x должен быть вызовом пользовательского макроса, все аргументы которого являются идентификаторами. Эти
идентификаторы становятся доступными как пользовательские макросы внутри определения макроса; эти
виртуальные макросы должны вызываться без аргументов и оценивать соответствующие
параметр макроса.

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

#ундеф x
Это удаляет все существующие определения пользовательского макроса. x.

#ифдеф x
Это начинает условный блок. Все последующее оценивается только в том случае, если
идентификатор x определено, и до тех пор, пока не будет #еще или #endif заявление достигнуто.
Однако обратите внимание, что прокомментированный текст по-прежнему тщательно сканируется, поэтому его синтаксис
Должен быть действителен. В частности, законно иметь #еще or #endif заявлении
окончание условного блока появляется только в результате раскрытия пользовательского макроса
и не явно во входных данных.

#ифндеф x
Это начинает условный блок. Все последующее оценивается только в том случае, если
идентификатор x не определен.

#ифек x y
Это начинает условный блок. Все последующее оценивается только в том случае, если
результаты оценок x и y идентичны символьным строкам. Любой
начальные и конечные пробелы игнорируются при сравнении. Обратите внимание, что в cpp-режиме
любой пробельный символ без кавычек считается концом первого аргумента,
так что надо быть осторожным.

#ifneq x y
Это начинает условный блок. Все последующее оценивается только в том случае, если
результаты оценок x и y не идентичны (даже до ведущего или
конечный пробел).

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

#endif На этом заканчивается условный блок, начатый #если... мета-макрос.

#включают файл
Это заставляет GPP открыть указанный файл и оценить его содержимое, вставив
результирующий текст в текущем выводе. Все заданные пользователем макросы по-прежнему доступны
во включенном файле, и, соответственно, все макросы, определенные во включенном файле, будут
быть доступным во всем, что будет дальше. Включаемый файл ищется первым в
текущий каталог, а затем, если не найден, в одном из указанных каталогов
не провела обыск -I параметр командной строки (или / usr / include если каталог не был указан).
Обратите внимание, что из соображений совместимости можно поместить имя файла между
"" или <>.

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

При включении файла GPP сразу сохраняет копию текущего режима работы.
в стек режимов и восстанавливает рабочий режим в конце включенного
файл. Включенный файл может переопределить это поведение, начав с #Режим восстановление
вызов и заканчивая #Режим протолкнуть. вызов. Кроме того, когда -m командной строки
указана опция, GPP автоматически перейдет в режим совместимости cpp
при включении файла, имя которого заканчивается на '.c' или '.h'.

#exec команду
Это заставляет GPP выполнять указанную командную строку и включать ее стандартную
вывод в токовом выводе. Обратите внимание, что по соображениям безопасности этот мета-макрос
отключен, если -x указан флаг командной строки. Если использование #exec Не
разрешено, печатается предупреждающее сообщение, а вывод остается пустым. Обратите внимание, что
указанная командная строка оценивается перед выполнением, что позволяет использовать
макросы в командной строке. Однако вывод команды дословно включен.
и не оценивается. Если вам нужно оценить результат, вы должны использовать #дефеваль
(см. выше), чтобы вызвать двойную оценку.

#оценка выраж
" #оценка мета-макрос пытается оценить выраж сначала путем раскрытия макроса (нормальный
Оценка GPP), а затем путем арифметической оценки и / или подстановочного знака
соответствие. Синтаксис и приоритет операторов для арифметических выражений:
то же, что и в C; единственные отсутствующие операторы <<, >>,?: и присвоение
операторы.

Сопоставление подстановочных знаков в стиле POSIX ('подстановка') доступно только в POSIX.
реализаций и может быть вызван с помощью оператора = ~. Короче говоря, "?" Спички
любой одиночный символ, '*' соответствует любой строке (включая пустую строку) и
'[...]' соответствует любому из символов, заключенных в квадратные скобки. Класс "[...]" - это
дополняется, когда первый символ в скобках - "!". Персонажи в
'[...]' класс также может быть указан как диапазон с помощью символа '-' - или,
«[FN]» эквивалентно «[FGHIJKLMN]».

Если не удается присвоить результату числовое значение, возвращаемый текст просто
результат раскрытия макроса без какой-либо арифметической оценки. Единственный
Исключениями из этого правила являются операторы сравнения ==,! =, <,>, <= и> =
который, если одна из сторон не вычисляет число, выполняет сравнение строк
вместо этого (игнорируя конечные и ведущие пробелы). Кроме того, длина(...)
арифметический оператор возвращает длину вычисленного аргумента в символах.

Внутри арифметических выражений определенный(...) специальный пользовательский макрос также
доступно: принимает только один аргумент, который не оценивается, и возвращает 1, если он
- это имя пользовательского макроса, в противном случае - 0.

#если выраж
Этот мета-макрос вызывает вычислитель арифметики / подстановки так же, как и
#оценка и сравнивает результат оценки со строкой «0», чтобы начать
условный блок. В частности, обратите внимание, что логическое значение выраж всегда правда
когда его нельзя оценить числом.

#элиф выраж
Этот мета-макрос можно использовать, чтобы избежать вложенных #если условиях. #если ... #элиф ...
#endif эквивалентна #если ... #еще #если ... #endif #endif.

#Режим ключевое слово ...
Этот мета-макрос управляет режимом работы GPP. См. Ниже список #Режим
команды.

#линия Этот мета-макрос оценивает номер строки текущего входного файла.

#файл Этот мета-макрос оценивает имя текущего входного файла в том виде, в котором он отображается.
в командной строке или в аргументе #включают. Если GPP читает его ввод
из стандартного ввода, затем #файл оценивается как `stdin '.

#свидание FMT
Этот мета-макрос оценивает текущую дату и время, отформатированные
указанная строка формата FMT. См. Раздел ДАТА И ВРЕМЯ Конверсия ТЕХНИЧЕСКИЕ ХАРАКТЕРИСТИКИ
внизу.

#ошибка MSG
Этот мета-макрос вызывает сообщение об ошибке с текущим именем файла и номером строки,
и с текстом MSG, для печати на стандартном устройстве ошибок. Последующий
после этого обработка прерывается.

#предупреждение MSG
Этот мета-макрос вызывает предупреждающее сообщение с текущим именем файла и номером строки,
и с текстом MSG, для печати на стандартном устройстве ошибок. Последующий
затем обработка возобновляется.

Ключ к гибкости GPP - это #Режим мета-макрос. Его первый аргумент всегда один из
список доступных ключевых слов (см. ниже); его второй аргумент всегда представляет собой последовательность
слова, разделенные пробелами. Помимо, возможно, первого из них, каждое из этих слов
всегда является разделителем или спецификатором синтаксиса и должен быть предоставлен в виде строки C с разделителями
в двойных кавычках (""). Различные специальные последовательности соответствия, перечисленные в разделе, посвященном
доступны спецификации синтаксиса. Любой #Режим команда анализируется в режиме, где "..."
понимается как строка в стиле C, поэтому можно безопасно помещать любой символ внутри этих
струны. Также обратите внимание, что первый аргумент #Режим (ключевое слово) никогда не оценивается,
в то время как второй аргумент оценивается (за исключением, конечно, содержимого строк C),
так что спецификация синтаксиса может быть получена в результате макрооценки.

Доступные #Режим команды:

#Режим спасти / #Режим протолкнуть.
Поместите текущую спецификацию режима в стек режимов.

#Режим восстановление / #Режим поп
Спецификация всплывающего режима из стека режимов.

#Режим стандарт имя
Выберите один из стандартных режимов. Единственный аргумент должен быть одним из: по умолчанию
(режим по умолчанию); cpp, C (режим cpp); текс, TeX (режим текс); html, HTML (режим html);
xhtml, XHTML (режим xhtml); пролог, Пролог (режим пролога). Название режима должно быть
дается напрямую, а не в виде строки C.

#Режим пользователь "S1" ... "S9"
Укажите синтаксис макроса пользователя. 9 аргументов, все они являются строками C, являются режимом
спецификация для пользовательских макросов (см. параметр командной строки -U и раздел
спецификация синтаксиса). На спецификацию мета-макроса это не повлияет.

#Режим цель {Пользователь | "S1" ... "s7"}
Укажите синтаксис мета-макроса. Либо единственный аргумент - пользователь (не в виде строки), и
спецификации режима пользовательского макроса копируются в режим мета-макроса
спецификации, или должно быть семь строковых аргументов, значение которых
то же, что и для параметра командной строки -M (см. раздел о спецификации синтаксиса).

#Режим цену ["c"]
Без аргумента или "" в качестве аргумента удаляет спецификацию символа кавычки и
отключает возможность цитирования. С одним строковым аргументом первый символ
строки считается новым символом кавычек. Цитата может быть
ни буквенно-цифровое, ни "_", ни одна из специальных совпадающих последовательностей.

#Режим комментарий [Ххх] "Начало" "конец" ["c" ["c"]]
Добавьте спецификацию комментария. Необязательно первый аргумент, состоящий из трех
символы, не заключенные в "", могут использоваться для указания модификатора комментария / строки
(см. раздел о спецификации синтаксиса). Модификатор по умолчанию: CCC, Первый
два строковых аргумента используются как последовательность начала и конца комментария соответственно. В
третий строковый аргумент является необязательным и может использоваться для указания строковой кавычки
персонаж. (Если это "", функция отключена.) Четвертая строка
аргумент является необязательным и может использоваться для указания предупреждения о разделении строк
персонаж. (Если это "", функция отключена.)

#Режим string [Ххх] "Начало" "конец" ["c" ["c"]]
Добавьте спецификацию строки. Идентично #Режим комментарий за исключением того, что по умолчанию
модификатор SSS.

#Режим нет коментариев / #Режим ноздря ["Начало"]
Без аргументов удалите все спецификации комментариев / строк. С одной струной
аргумент, удалите спецификацию комментария / строки, начальная последовательность которой является
аргумент.

#Режим Preservelf { on | от | 1 | 0 }
Эквивалент -n переключатель командной строки. Если аргумент on or 1, любая новая строка
или пробел, завершающий вызов макроса, или комментарий / строка остается в
входной поток для дальнейшей обработки. Если аргумент от or 0 эта функция
отключен.

#Режим кодировок { id | op | паритет } «Строка»
Укажите наборы символов, которые будут использоваться для сопоставления специальных символов \ o, \ O и \ i.
последовательности. Первый аргумент должен быть одним из id (набор соответствует \ i), op (
набор соответствует \ o) или паритет (набор, соответствующий \ O в дополнение к тому, который соответствует
\ о). «Строка» - это строка C, в которой перечислены все символы, которые нужно вставить в набор. Это может
содержат только специальные совпадающие последовательности \ a, \ A, \ b, \ B и \ # (другие
последовательности и инвертированные последовательности не допускаются). Когда найден '-'
между двумя неспециальными символами добавляет все символы между ними (например, "AZ"
соответствует всем заглавным буквам). Чтобы иметь '-' в согласованном наборе, либо
поместите его в первую или последнюю позицию или поместите рядом с последовательностью \ x.

ДАТА И ВРЕМЯ Конверсия ТЕХНИЧЕСКИЕ ХАРАКТЕРИСТИКИ

Обычные символы, помещенные в строку формата, копируются без преобразования.
Спецификаторы преобразования вводятся символом `% 'и заменяются следующим образом:

%a Сокращенное название дня недели в соответствии с текущим языковым стандартом.

%A Полное название дня недели в соответствии с текущим языковым стандартом.

%b Сокращенное название месяца в соответствии с текущим языковым стандартом.

%B Полное название месяца в соответствии с текущим языковым стандартом.

%c Предпочтительное представление даты и времени для текущего языкового стандарта.

%d День месяца в виде десятичного числа (от 01 до 31).

%F Эквивалентно% Y-% m-% d (формат даты ISO 8601).

%H Час как десятичное число в 24-часовом формате (от 00 до 23).

%I Час как десятичное число в 12-часовом формате (от 01 до 12).

%j День года в виде десятичного числа (от 001 до 366).

%m Месяц как десятичное число (от 01 до 12).

%M Минута как десятичное число (от 00 до 59).

%p Либо AM, либо PM согласно заданному значению времени, либо соответствующему
строки для текущего языкового стандарта. Полдень считается «pm», а полночь - «am».

%R Время в 24-часовом формате (% H:% M).

%S Второе как десятичное число (от 00 до 61).

%U Номер недели текущего года в виде десятичного числа в диапазоне от 00 до 53,
начиная с первого воскресенья как первого дня недели 01.

%w День недели в виде десятичного числа в диапазоне от 0 до 6, воскресенье - 0.

%W Номер недели текущего года в виде десятичного числа в диапазоне от 00 до 53,
начиная с первого понедельника как первого дня недели 01.

%x Предпочтительное представление даты для текущего языкового стандарта без времени.

%X Предпочтительное представление времени для текущего языкового стандарта без даты.

%y Год как десятичное число без века (от 00 до 99).

%Y Год как десятичное число, включая век.

%Z Часовой пояс, название или сокращение.

%% Буквальный символ "%".

В зависимости от компилятора C и библиотеки, используемой для компиляции GPP, может быть больше преобразований.
спецификаторы доступны. Обратитесь к документации вашего компилятора для strftime () функции.
Обратите внимание, однако, что любые спецификаторы преобразования, не указанные выше, могут не переноситься между
установки ГПЗ.

ПРИМЕРЫ

Вот базовый пример, который не требует пояснений в стандартном режиме или режиме cpp:

#define FOO Это
#define BAR сообщение.
#define concat # 1 # 2
concat (FOO, BAR)
#ifeq (concat (foo, bar)) (foo bar)
Это вывод.
#еще
Это не вывод.
#endif

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

#define concat (x, y) xy

В режиме TeX и с использованием именования аргументов тот же пример выглядит следующим образом:

\ define {FOO} {Это}
\ define {BAR} {сообщение.}
\ define {\ concat {x} {y}} {\ x \ y}
\ concat {\ FOO} {\ BAR}
\ ifeq {\ concat {foo} {bar}} {foo bar}
Это вывод.
\еще
Это не вывод.
\ endif

В режиме HTML и без именования аргументов получается аналогично:

<#define FOO | Это>
<#define BAR | сообщение.>
<#define concat | # 1 # 2>
<#concat <#FOO> | <#BAR >>
<#ifeq <#concat foo | bar> | foo bar>
Это вывод.
<#else>
Это не вывод.
<#endif>

В следующем примере (в стандартном режиме) показано использование символа кавычки:

#define FOO Это \
многострочное определение.
#define BLAH (x) Мой аргумент - x
BLAH (urf)
\ BLAH (urf)

Обратите внимание, что многострочное определение также действует в режимах cpp и Prolog, несмотря на то, что
отсутствие символа кавычки, потому что '\', за которым следует новая строка, тогда интерпретируется как
комментарий и отклонен.

В режиме cpp строки и комментарии C понимаются как таковые, как показано на
следующий пример:

#define БЛА фу
БЛА БЛА БЛА */
'Это \' s / * строка * /! '

Основное различие между режимами Prolog и cpp заключается в обработке строк и
комментарии: в Прологе строка '...' не может начинаться сразу после цифры, а /*...*/
комментарий не может начинаться сразу после символа оператора. Кроме того, комментарии
не удаляются из вывода, если они не встречаются в команде #.

Различия между режимом cpp и режимом по умолчанию более глубокие: в режиме по умолчанию #commands
могут начинаться где угодно, а в режиме cpp они должны быть в начале строки; по умолчанию
mode не знает комментариев и строк, но имеет символ кавычек ('\'), а cpp
В режиме есть подробные спецификации комментариев / строк, но без кавычек. Более того,
аргументы мета-макросов должны быть правильно заключены в круглые скобки в режиме по умолчанию, в то время как такие
проверка выполняется в режиме cpp.

Это упрощает вложение вызовов мета-макросов в режиме по умолчанию, чем в режиме cpp. За
Например, рассмотрим следующий ввод режима HTML, который проверяет доступность
#exec команда:

<#ifeq <#exec echo blah> | мля
> #exec разрешено <#else> #exec not allowed <#endif>

Эквивалента режима cpp не существует, в то время как в режиме по умолчанию его можно легко перевести как

#ifeq (#exec эхо бла
) (бла
)
\ #exec разрешено
#еще
\ #exec не разрешено
#endif

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

#mode string QQQ "$" "$"
#ifeq $ # exec echo blah
$ $ бла
$
\ #exec разрешено
#еще
\ #exec не разрешено
#endif

Обратите внимание, однако, что комментарии / строки не могут быть вложенными ("..." внутри $ ... $ будет
необнаружены), поэтому нужно быть осторожным с тем, что включить в такой тихий
оцененная строка. В этом примере свободное вложение мета-макросов, представленное в версии 2.1.
позволяет использовать следующую более простую версию:

#ifeq бла #exec echo -n бла
\ #exec разрешено
#еще
\ #exec не разрешено
#endif

Помните, что макросы без аргументов на самом деле считаются псевдонимами, когда они
вызывается с аргументами, как показано в следующем примере (режим по умолчанию или cpp):

#define DUP (x) xx
#define FOO, и я сказал: DUP
ФУ (бла)

Полезность #дефеваль мета-макрос показан в следующем примере в режиме HTML:

<#define APPLY | <#defeval TEMP | <\ ## 1 \ # 1 >> <# TEMP # 2 >>
<#define <#foo x> | <#x> и <#x >>
<#APPLY foo | BLAH>

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

Чтобы перевести этот пример в режим по умолчанию, нужно использовать скобки, чтобы
чтобы вложить вызов #defeval в определение APPLY, но это нужно делать без
вывод круглых скобок. Самое простое решение -

#define BALANCE (x) x
#define APPLY (f, v) BALANCE (#defeval TEMP f
ТЕМП (v))
#define foo (x) x and x
ПРИМЕНИТЬ (\ foo, BLAH)

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

Следующий пример (режим по умолчанию или cpp) демонстрирует арифметическое вычисление:

# определить x 4
Ответ:
#eval x * x + 2 * (16-x) + 1998% x

#if defined (x) &&! (3 * x + 5> 17)
Это должно быть выведено.
#endif

В заключение приведу несколько примеров переключения режимов. Следующий пример
не требует пояснений (начиная с режима по умолчанию):

#режим push
#define f (x) xx
#режим стандартный текс
\ f {blah}
\ mode {строка} {"$" "$"}
\ mode {комментарий} {"/ *" "* /"}
$ \ f {urf} $ / * мля * /
\ define {FOO} {bar / * и еще несколько * /}
\ режим {поп}
f ($ FOO $)

Хорошим примером того, как пользовательский режим становится полезным, является источник этого документа по GPP.
(доступно с исходным кодом GPP).

Еще одно интересное приложение - выборочное принудительное вычисление макросов в строках C
в режиме cpp. Например, рассмотрим следующий ввод:

#define blah (x) "и он сказал: x"
бла (фу)

Очевидно, хотелось бы, чтобы параметр x для раскрытия внутри строки. Есть
несколько способов обойти эту проблему:

#режим push
#mode nostring "\" "
#define blah (x) "и он сказал: x"
#режим поп

#mode quote "` "
#define blah (x) `" и он сказал: x` "

#mode string QQQ "$$" "$$"
#define blah (x) $$ "и он сказал: x" $$

Первый метод очень естественен, но его неудобство состоит в том, что он занимает много времени и
нейтрализация семантики строки, так что наличие неоцененного экземпляра 'x' в
строка или вхождение '/ *' было бы невозможно без использования дополнительных
искривления.

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

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

Начиная с версии 2.1, вызовы мета-макросов могут быть более эффективно вложены по умолчанию, cpp
и режимы Prolog. Это упрощает создание пользовательской версии мета-макроса или
увеличить счетчик:

#define myeval #eval # 1

# определить x 1
#defeval x #eval x + 1

ADVANCED ПРИМЕРЫ

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

Первый пример - это рекурсивный макрос. Основная проблема в том, что (поскольку GPP оценивает
все) рекурсивный макрос должен быть очень осторожен с тем, как рекурсия
прекращено, чтобы избежать неопределенного поведения (большую часть времени GPP просто дает сбой).
В частности, полагаясь на # if / # else / # endif конструкция для завершения рекурсии невозможна
и приводит к бесконечному циклу, потому что GPP сканирует вызовы пользовательских макросов даже в
неоцененная ветвь условного блока. Безопасный способ продолжить, например, как
следует (мы приводим пример в режиме TeX):

\ define {обратный отсчет} {
\ если {# 1}
# 1 ...
\ define {loop} {\ countdown}
\еще
Готово.
\ define {loop} {}
\ endif
\ loop {\ eval {# 1-1}}
}
\ обратный отсчет {10}

Другой пример, в режиме cpp:

#mode string QQQ "$" "$"
# определить треугольник (x, y) y \
$ # если длина (y)
$ # определить его $ $ # endif
$ iter (х, * у)
треугольник(20)

Ниже приводится (к сожалению, очень слабая) попытка реализовать функциональную
абстракция в GPP (в стандартном режиме). Понимание этого примера и почему его нельзя сделать
гораздо проще - это упражнение, оставленное любознательному читателю.

#mode string "` "" `" "\\"
#define ASIS (x) x
#define SILENT (x) ASIS ()
#define EVAL (x, f, v) SILENT (
#mode string QQQ "` "" `" "\\"
#defeval TEMP0 x
#defeval TEMP1 (
\ #define \ TEMP2 (TEMP0) f
)
ТЕМП1
) TEMP2 (v)
#define LAMBDA (x, f, v) SILENT (
#ifneq (в) ()
#define TEMP3 (a, b, c) EVAL (a, b, c)
#еще
# определить TEMP3 (a, b, c) \ LAMBDA (a, b)
#endif
) TEMP3 (x, f, v)
#define EVALAMBDA (x, y) SILENT (
#defeval TEMP4 x
#defeval TEMP5 г
)
#define APPLY (f, v) SILENT (
#defeval TEMP6 ASIS (\ EVA) f
ТЕМП6
) EVAL (TEMP4, TEMP5, v)

Это дает следующие результаты:

ЛЯМБДА (z, z + z)
=> ЛЯМБДА (z, z + z)

ЛЯМБДА (z, z + z, 2)
=> 2 + 2

#define f LAMBDA (y, y * y)
f
=> ЛЯМБДА (у, у * у)

ПРИМЕНИТЬ (f, blah)
=> бла * бла

ПРИМЕНИТЬ (ЛЯМБДА (t, tt), (tt))
=> (tt) (tt)

ЛЯМБДА (x; ПРИМЕНИТЬ (f; (x + x)); urf)
=> (urf + urf) * (urf + urf)

ПРИМЕНИТЬ (ПРИМЕНИТЬ (ЛЯМБДА (x, ЛЯМБДА (y, x * y)), foo), bar)
=> foo * bar

#define test LAMBDA (y, `# ifeq y urf
y is urf # else
y не urf # endif
`)
ПРИМЕНИТЬ (test, urf)
=> urf - это urf

ПРИМЕНИТЬ (test, foo)
=> foo не urf

Используйте gpp онлайн с помощью сервисов onworks.net