Phases of translation

Исходные файлы C++ обрабатываются компилятором для создания программ на C++.

Процесс перевода

Текст программы на C++ хранится в единицах, называемых исходными файлами .

Исходные файлы C++ проходят трансляцию , чтобы стать единицей трансляции , состоящей из следующих шагов:

1. Сопоставляет каждый исходный файл с последовательностью символов.
2. Преобразует каждую последовательность символов в последовательность токенов препроцессора, разделенных пробелами.
3. Преобразует каждый токен препроцессора в токен, формируя последовательность токенов.
4. Преобразует каждую последовательность токенов в единицу трансляции.

Программа на C++ может быть сформирована из транслированных единиц трансляции. Транслированные единицы трансляции и инстанцированные единицы (инстанцированные единицы описаны в фазе 8 ниже) могут сохраняться индивидуально или сохраняться в библиотеку. Несколько единиц трансляции взаимодействуют друг с другом через (например) символы с внешней линковкой или файлы данных. Единицы трансляции могут транслироваться отдельно, а затем линковаться для создания исполняемой программы.

Вышеуказанный процесс может быть организован в 9 фаз трансляции .

Токены препроцессора

Препроцессинговый токен — это минимальный лексический элемент языка на этапах трансляции с 3 по 6.

Категории токенов препроцессора:

• имена заголовочных файлов (например, < iostream > или "myfile.h" )

• идентификаторы
• препроцессорные числа (см. ниже)
• символьные литералы , включая пользовательские символьные литералы (начиная с C++11)
• строковые литералы , включая пользовательские строковые литералы (начиная с C++11)
• операторы и пунктуаторы , включая альтернативные токены
• отдельные не-пробельные символы, не подходящие ни под одну другую категорию

Программа является некорректной, если символ, соответствующий этой категории,

• апостроф ( ' , U+0027),
• кавычка ( " , U+0022), или
• символ, не входящий в базовый набор символов .

Препроцессорные числа

Множество токенов препроцессора для препроцессингового числа является надмножеством объединения множеств токенов целочисленных литералов и литералов с плавающей точкой :

Каждый pp-continue представляет собой одно из следующего:

Препроцессорное число не имеет типа или значения; оно приобретает и то, и другое после успешного преобразования в токен целочисленного/вещественного литерала.

Пробельные символы

Пробельные символы состоят из комментариев , символов пробела или обоих элементов.

Следующие символы являются пробельными символами:

• символ табуляции (U+0009)
• символ перевода строки / символ новой строки (U+000A)
• символ вертикальной табуляции (U+000B)
• символ прогона страницы (U+000C)
• пробел (U+0020)

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

• Это не разделитель в имени заголовка, символьном литерале и строковом литерале.
• Предпроцессорные токены, разделенные пробелами, содержащими символы новой строки, не могут формировать директивы препроцессора .

#include "my header"        // OK, использование имени заголовка, содержащего пробелы
#include/*hello*/<iostream> // OK, использование комментария в качестве пробела
#include
<iostream> // Ошибка: директива #include не может занимать несколько строк
"str ing"  // OK, единый токен препроцессора (строковый литерал)
' '        // OK, единый токен препроцессора (символьный литерал)

Максимальное поглощение

Максимальное поглощение — это правило, используемое на этапе 3 при разложении исходного файла на препроцессинговые токены.

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

int foo = 1;
int bar = 0xE+foo;   // Ошибка: недопустимое число препроцессора 0xE+foo
int baz = 0xE + foo; // OK

Другими словами, правило максимального поглощения действует в пользу multi-character operators and punctuators :

int foo = 1;
int bar = 2;
int num1 = foo+++++bar; // Ошибка: обрабатывается как "foo++ ++ +baz", а не "foo++ + ++baz"
int num2 = -----foo;    // Ошибка: обрабатывается как "-- -- -foo", а не "- -- --foo"

Правило максимального поглощения имеет следующие исключения:

• Токены предварительной обработки имени заголовка формируются только в следующих случаях:

• после include токена препроцессора в #include директиве

std::vector<int> x; // OK, «int» не является именем заголовка

• Если следующие три символа представляют собой < :: и последующий символ не является ни : , ни > , тогда < обрабатывается как самостоятельный токен препроцессора, а не как первый символ альтернативного токена < : .

struct Foo { static const int v = 1; };
std::vector<::Foo> x;  // OK, <: не воспринимается как альтернативный токен для [
extern int y<::>;      // OK, эквивалентно "extern int y[];"
int z<:::Foo::value:>; // OK, эквивалентно "int z[::Foo::value];"

template<int i> class X { /* ... */ };
template<class T> class Y { /* ... */ };
Y<X<1>> x3;      // OK, объявляет переменную "x3" типа "Y<X<1> >"
Y<X<6>>1>> x4;   // Синтаксическая ошибка
Y<X<(6>>1)>> x5; // OK

#define R "x"
const char* s = R"y";         // некорректный необработанный строковый литерал, не "x" "y"
const char* s2 = R"(a)" "b)"; // необработанный строковый литерал, за которым следует обычный строковый литерал

Токены

Токен — это минимальный лексический элемент языка на седьмой фазе трансляции.

Категории токенов:

• идентификаторы
• ключевые слова
• литералы
• операторы и пунктуаторы (за исключением препроцессорных операторов)

Фазы трансляции

Перевод выполняется as if в порядке от фазы 1 до фазы 9. Реализации ведут себя так, как если бы эти отдельные фазы происходили, хотя на практике различные фазы могут быть объединены вместе.

Фаза 1: Отображение исходных символов

Фаза 2: Соединение линий

Фаза 3: Лексический анализ

// The following #include directive can de decomposed into 5 preprocessing tokens:
//     punctuators (#, < and >)
//          │
// ┌────────┼────────┐
// │        │        │
   #include <iostream>
//     │        │
//     │        └── header name (iostream)
//     │
//     └─────────── identifier (include)

// Error: partial string literal
"abc

// Error: partial comment
/* comment

Фаза 4: Препроцессинг

Фаза 5: Определение стандартных кодировок строковых литералов

Фаза 6: Конкатенация строковых литералов

Смежные string literals объединяются.

Фаза 7: Компиляция

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

Фаза 8: Инстанцирование шаблонов

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

Фаза 9: Linking

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

Примечания

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

Некоторые компиляторы не реализуют единицы инстанцирования (также известные как template repositories или template registries ) и просто компилируют каждую инстанциацию шаблона на фазе 7, сохраняя код в объектном файле, где она неявно или явно запрошена, а затем компоновщик объединяет эти скомпилированные инстанциации в одну на фазе 9.

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также