Phases of translation

Los archivos fuente de C++ son procesados por el compilador para producir programas C++.

Proceso de traducción

El texto de un programa C++ se mantiene en unidades llamadas source files .

Los archivos fuente de C++ se someten a traducción para convertirse en una unidad de traducción , que consta de los siguientes pasos:

1. Asigna cada archivo fuente a una secuencia de caracteres.
2. Convierte cada secuencia de caracteres en una secuencia de tokens de preprocesamiento, separados por espacios en blanco.
3. Convierte cada token de preprocesamiento en un token, formando una secuencia de tokens.
4. Convierte cada secuencia de tokens en una unidad de traducción.

Un programa en C++ puede formarse a partir de unidades de traducción traducidas. Las unidades de traducción traducidas y las unidades instanciadas (las unidades instanciadas se describen en la fase 8 a continuación) pueden guardarse individualmente o guardarse en una biblioteca. Múltiples unidades de traducción se comunican entre sí mediante (por ejemplo) símbolos con enlace externo o archivos de datos. Las unidades de traducción pueden traducirse por separado y luego enlazarse para producir un programa ejecutable.

El proceso anterior puede organizarse en 9 translation phases .

Tokens de preprocesamiento

Un token de preprocesamiento es el elemento léxico mínimo del lenguaje en las fases de traducción 3 a 6.

Las categorías de tokens de preprocesamiento son:

• nombres de cabecera (como < iostream > o "myfile.h" )

• identificadores
• números de preprocesador (ver abajo)
• literales de carácter , incluyendo literales de carácter definidos por el usuario (desde C++11)
• literales de cadena , incluyendo literales de cadena definidos por el usuario (desde C++11)
• operadores y puntuadores , incluyendo tokens alternativos
• caracteres individuales sin espacio en blanco que no encajan en ninguna otra categoría

El programa está mal formado si el carácter que coincide con esta categoría es

• apóstrofo ( ' , U+0027),
• comilla ( " , U+0022), o
• un carácter que no esté en el conjunto de caracteres básico .

Números de preprocesamiento

El conjunto de tokens de preprocesamiento de número de preprocesamiento es un superconjunto de la unión de los conjuntos de tokens de literales enteros y literales de punto flotante :

Cada pp-continue es uno de los siguientes:

Un número de preprocesamiento no tiene un tipo ni un valor; adquiere ambos después de una conversión exitosa a un token literal entero/de punto flotante.

Espacio en Blanco

Espacio en blanco consiste en comentarios , caracteres de espacio en blanco, o ambos.

Los siguientes caracteres son caracteres de espacio en blanco:

• tabulación de caracteres (U+0009)
• salto de línea / carácter de nueva línea (U+000A)
• tabulación de línea (U+000B)
• salto de página (U+000C)
• espacio (U+0020)

El espacio en blanco generalmente se utiliza para separar tokens de preprocesamiento, con las siguientes excepciones:

• No es un separador en el nombre de cabecera, literal de carácter y literal de cadena.
• Los tokens de preprocesamiento separados por espacios en blanco que contienen caracteres de nueva línea no pueden formar directivas de preprocesamiento .

#include "my header"        // OK, usando un nombre de cabecera que contiene espacios en blanco
#include/*hello*/<iostream> // OK, usando un comentario como espacio en blanco
#include
<iostream> // Error: #include no puede extenderse a través de múltiples líneas
"str ing"  // OK, un único token de preprocesamiento (literal de cadena)
' '        // OK, un único token de preprocesamiento (literal de carácter)

Munch máximo

El maximal munch es la regla utilizada en la fase 3 al descomponer el archivo fuente en tokens de preprocesamiento.

Si la entrada ha sido analizada hasta un carácter dado (de lo contrario, el siguiente token de preprocesamiento no será analizado, lo que hace que el orden de análisis sea único), el siguiente token de preprocesamiento generalmente se toma como la secuencia más larga de caracteres que podría constituir un token de preprocesamiento, incluso si eso causara que el análisis posterior falle. Esto se conoce comúnmente como maximal munch .

int foo = 1;
int bar = 0xE+foo;   // Error: número de preprocesamiento no válido 0xE+foo
int baz = 0xE + foo; // Correcto

En otras palabras, la regla de maximal munch favorece a los operadores y puntuadores multi-carácter :

int foo = 1;
int bar = 2;
int num1 = foo+++++bar; // Error: se interpreta como "foo++ ++ +baz", no como "foo++ + ++baz"
int num2 = -----foo;    // Error: se interpreta como "-- -- -foo", no como "- -- --foo"

La regla de maximal munch tiene las siguientes excepciones:

• Los tokens de preprocesamiento de nombre de cabecera solo se forman en los siguientes casos:

• después del token de preprocesamiento include en una directiva #include

std::vector<int> x; // CORRECTO, "int" no es un nombre de cabecera

• Si los siguientes tres caracteres son < :: y el carácter subsiguiente no es ni : ni > , entonces el < se trata como un token de preprocesamiento independiente en lugar del primer carácter del token alternativo < : .

struct Foo { static const int v = 1; };
std::vector<::Foo> x;  // OK, <: no se interpreta como el token alternativo para [
extern int y<::>;      // OK, igual que "extern int y[];"
int z<:::Foo::value:>; // OK, igual que "int z[::Foo::value];"

template<int i> class X { /* ... */ };
template<class T> class Y { /* ... */ };
Y<X<1>> x3;      // OK, declara una variable “x3” de tipo “Y<X<1> >”
Y<X<6>>1>> x4;   // Error de sintaxis
Y<X<(6>>1)>> x5; // OK

#define R "x"
const char* s = R"y";         // literal de cadena sin formato mal formado, no "x" "y"
const char* s2 = R"(a)" "b)"; // un literal de cadena sin formato seguido de un literal de cadena normal

Tokens

Un token es el elemento léxico mínimo del lenguaje en la fase de traducción 7.

Las categorías de token son:

• identificadores
• palabras clave
• literales
• operadores y puntuadores (excepto operadores de preprocesamiento)

Fases de traducción

La traducción se realiza as if en el orden desde la fase 1 hasta la fase 9. Las implementaciones se comportan como si estas fases separadas ocurrieran, aunque en la práctica diferentes fases pueden estar combinadas.

Fase 1: Mapeo de caracteres fuente

Fase 2: Empalme de líneas

Fase 3: Lexing

// 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

Fase 4: Preprocesamiento

Fase 5: Determinación de codificaciones comunes de literales de cadena

Fase 6: Concatenación de literales de cadena

Los literales de cadena adyacentes se concatenan.

Fase 7: Compilación

La compilación tiene lugar: cada token de preprocesamiento se convierte en un token . Los tokens se analizan sintáctica y semánticamente y se traducen como una unidad de traducción .

Fase 8: Instanciación de plantillas

Cada unidad de traducción se examina para producir una lista de instanciaciones de plantilla requeridas, incluyendo las solicitadas por explicit instantiations . Las definiciones de las plantillas se localizan, y las instanciaciones requeridas se llevan a cabo para producir instantiation units .

Fase 9: Enlazado

Las unidades de traducción, unidades de instanciación y componentes de biblioteca necesarios para satisfacer referencias externas se recopilan en una imagen de programa que contiene la información necesaria para su ejecución en su entorno de ejecución.

Notas

Los archivos fuente, las unidades de traducción y las unidades de traducción traducidas no necesariamente deben almacenarse como archivos, ni debe haber una correspondencia uno a uno entre estas entidades y cualquier representación externa. La descripción es solo conceptual y no especifica ninguna implementación particular.

Algunos compiladores no implementan unidades de instanciación (también conocidas como template repositories o template registries ) y simplemente compilan cada instanciación de plantilla en la fase 7, almacenando el código en el archivo objeto donde se solicita implícita o explícitamente, y luego el enlazador colapsa estas instanciaciones compiladas en una durante la fase 9.

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también