# Un quine en C++

Un **quine** es un programa que imprime exactamente su propio código fuente, sin leerlo de ningún lado. Esta
semana vieron por qué existe: el programa se parte en datos y código, los datos describen al código, y el
código imprime los datos dos veces, una como texto y otra como literal. En este problema escriben el suyo.

Es el ejercicio opcional de la semana 11. No tiene casos de prueba con archivos `.in` y `.out`, porque la
respuesta esperada es su propio programa: `make test` compara la salida con el fuente.

## Entrada

Ninguna. El programa no lee nada: ni la entrada estándar, ni argumentos, ni archivos.

## Salida

El contenido de `solution.cpp`, byte por byte: los mismos espacios, los mismos saltos de línea, los mismos
comentarios, el mismo salto de línea final si lo hay. Ni un byte más ni uno menos.

## Reglas

El programa tiene que **contener** lo necesario para reproducirse. No puede pedirle su texto a nadie:

- No abre archivos: nada de `<fstream>`, `fopen`, `freopen` ni `<filesystem>`.
- No le pide su texto al compilador: nada de `__FILE__`, `#embed`, `std::source_location`, ni un `#include`
  de un archivo propio (solo se incluyen cabeceras de la biblioteca estándar, entre `<` y `>`).
- No ejecuta otros programas ni mira sus argumentos: nada de `system`, `popen` ni `argv`.
- **No usa raw string literals** (`R"(...)"`). El quine de los apuntes, `quine.cpp`, usa uno, y con eso se
  ahorra la parte más interesante del problema: escribir un texto que tiene comillas, barras invertidas y saltos
  de línea dentro de un literal común. Aquí la resuelven ustedes.
- Las reglas de C++ del curso siguen valiendo: C++20, sin advertencias con `-Wall -Wextra`, solo biblioteca
  estándar, sin variables globales, sin `using namespace std`.

`make test` rechaza un fuente que contenga alguna de esas palabras, con una búsqueda de texto simple. La
búsqueda es una ayuda, no la regla: **la regla es el espíritu**. Un programa que consigue su propio texto por
un camino que la búsqueda no conoce sigue sin ser un quine. Y la búsqueda es tosca: rechaza también una letra
`R` pegada a una comilla dentro de un mensaje, porque así empieza un raw string literal. Si les pasa, cambien
el mensaje.

Un programa vacío no cuenta: en C++ un archivo vacío no compila, porque le falta `main`.

## Paso 1: escribir el quine

Trabajen en `solution.cpp`. El esqueleto es el intento ingenuo: imprime un texto fijo que no es el suyo.

Un plan que funciona, en el orden en que conviene escribirlo:

1. Escriban primero el programa **sin** los datos, con un hueco: una variable `text` cuyo valor todavía no
   conocen, y el código que la usa. Marquen el hueco con un carácter que no aparezca antes en el programa.
2. El código tiene que imprimir tres cosas seguidas: lo que hay en `text` antes de la marca; `text` completo,
   **escrito como aparece en el fuente** (con sus comillas, y con una barra invertida delante de cada comilla y
   de cada barra invertida, y `\n` en lugar de cada salto de línea); y lo que hay en `text` después de la marca.
3. Para lo segundo necesitan una función que reciba un texto y devuelva el literal que lo denota. Es la única
   parte delicada. Decidan de entrada cómo va a quedar escrito el literal en el archivo (¿en una sola línea?,
   ¿un literal por línea?), porque la función tiene que escribirlo exactamente igual.
4. Recién al final llenen el hueco: el valor de `text` es el programa del paso 1, tal cual, con la marca.
   Pueden hacerlo a mano o escribir un programa aparte que lo haga por ustedes. Ese programa auxiliar sí
   puede abrir archivos: no es el quine.

Cada vez que cambien una coma del código tienen que actualizar los datos. Por eso conviene dejar los datos
para el final.

## Paso 2: comprobarlo

```sh
make test
```

`make test` hace cuatro cosas: revisa que el fuente no use nada prohibido, lo compila con
`g++ -Wall -Wextra -std=c++20 -O2`, lo ejecuta sin entrada (con un límite de 5 segundos) y compara la salida
con `solution.cpp` byte por byte, con `cmp`. Con el esqueleto responde:

```text
$ make test
WA: la salida no es igual a lo esperado
  esperado: 508 bytes; salida: 38 bytes
  primera diferencia: byte 1, línea 1
  para verla: diff build/output.txt build/expected.txt | head
make: *** [Makefile:26: test] Error 1
```

Un programa que abre su propio archivo ni siquiera se compila:

```text
$ make test SOURCE=reads_file.cpp
RECHAZADO: reads_file.cpp usa algo que el problema no permite:
  línea 3: fstream
  línea 7: fstream
  línea 7: __FILE__
Un quine no abre archivos ni le pide su texto al compilador, y en este problema
tampoco se usan raw string literals. Lean las reglas en README.md.
make: *** [Makefile:26: test] Error 1
```

Cuando el quine está bien:

```text
$ make test
AC: la salida es igual a lo esperado, 2190 bytes
```

La cantidad de bytes es la del programa de referencia; la de ustedes será otra.

Los errores más frecuentes, y cómo se ven:

| Lo que dice `make test` | Lo que suele pasar |
|---|---|
| La salida tiene un byte más que lo esperado | Un `std::endl` o un `"\n"` de más al final |
| La primera diferencia está en la línea del literal | La función que escribe el literal no lo escribe como está en el archivo: revisen la sangría y los escapes |
| La primera diferencia está después del literal | Cambiaron el código y no actualizaron los datos |
| La diferencia está en un comentario | Los comentarios también son parte del fuente, y tienen que estar en los datos |

## Paso 3: el quine que sabe cuánto mide

Copien su quine a `length.cpp` y modifíquenlo para que imprima su código y, después, una línea con la cantidad
de bytes del archivo `length.cpp`, en decimal.

```sh
cp solution.cpp length.cpp
make test-length
```

`make test-length` hace lo mismo que `make test`, pero espera el fuente seguido de esa línea. Con la referencia:

```text
$ make test-length
AC: la salida es igual a lo esperado, 2206 bytes
```

El archivo de referencia tiene 2201 bytes y la línea agregada, `2201` y un salto de línea, tiene 5.

Se cuentan bytes, que es lo que cuenta `wc -c` y lo que devuelve `size()` en un `std::string`. Una letra con
tilde ocupa 2 bytes en UTF-8, así que el número puede ser mayor que la cantidad de caracteres que ven.

Piensen antes de programar: el número no puede estar escrito en el fuente. Si lo escribieran, al cambiar
cualquier cosa habría que corregirlo, y al corregirlo podría cambiar la longitud. El programa tiene que
**calcularlo**, y para eso necesita tener su propio código en una variable antes de imprimir nada. Ese es el
contenido del teorema de recursión: un programa puede obtener su propia descripción y después seguir
calculando con ella.

## Para pensar

- ¿Dónde está, en su programa, la parte $A$ y dónde la parte $B$ de la construcción de los apuntes?
- Si le quitan todos los comentarios, ¿cuántas líneas tienen que cambiar? ¿Por qué son el doble de las que
  esperaban?
- Su quine, ¿sigue siendo un quine si lo compilan con otro compilador? ¿Y si alguien guarda el archivo con
  saltos de línea de Windows?
