Una función, char *get_next_line(int fd), que cada vez que la llamas
devuelve la siguiente línea de un descriptor. Sin libft, sin lseek, sin variables
globales y leyendo de BUFFER_SIZE en BUFFER_SIZE bytes. El proyecto que
enseña las variables static y que castiga cualquier descuido con la memoria.
read(fd, buf, n) no sabe
nada de líneas: devuelve hasta n bytes, los que haya, y le da igual dónde
caigan los '\n'. Un solo read puede traer media línea, o una línea y
media, o diez líneas. Así que lo que sobre después del '\n' no se puede tirar: hay
que guardarlo para la siguiente llamada. Y como la función se llama una vez por línea y entre
llamada y llamada sus variables locales desaparecen, el enunciado da la pista: «un buen
comienzo sería saber qué es una variable estática». Además pide leer lo menos posible: nada de
cargar el fichero entero y luego trocearlo. Es la versión hecha a mano de lo que hacen
fgets o getline en la libc, y la usarás en casi todos los proyectos
que lean ficheros.La página usa palabras que vienen de cómo el sistema da los datos de un fichero, de dónde vive cada variable en memoria y de cómo trabaja el preprocesador. Aquí está cada una explicada desde cero y con un ejemplo sacado del propio get_next_line. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.
El número entero con el que un proceso se refiere a algo abierto: un fichero, una tubería, la
terminal. Todo proceso empieza con tres: 0 (entrada estándar), 1 (salida estándar) y 2 (salida de
errores). open devuelve el menor número libre, normalmente el 3, y −1 si falla.
get_next_line usa el número tal cual como índice de su array: buf[fd]. Por eso
rechaza los negativos y los que no caben en el array (fd >= MAX_FD, con
MAX_FD a 1024). get_next_line(-1) y get_next_line(4242) sin
abrir devuelven NULL.
read y lo que devuelveread(fd, buf, n) pide hasta n bytes y devuelve cuántos ha leído de
verdad: puede ser menos de n aunque no se haya acabado nada (una tubería o la terminal dan lo que
haya en ese momento). Devuelve 0 en fin de fichero y −1 si hay un error. No añade
'\0': lo que deja en buf son bytes, no una cadena.
Con el fichero "hola\nmundo\nfin" (14 bytes) y BUFFER_SIZE=8, el
primer read devuelve 8 ("hola\nmun"), el segundo 6
("do\nfin") y el tercero 0. Por eso el código escribe a mano
buf[bytes_read] = '\0'.
EOF (end of file) no es un carácter guardado al final del fichero: es la situación de
no quedar nada que leer, y read la indica devolviendo 0. En la terminal se provoca con
Ctrl-D al principio de una línea.
En get_next_line, si al llegar a EOF hay algo acumulado se devuelve como última línea, sin
'\n' ("fin"). Si no queda nada, se libera el buffer del fd y se
devuelve NULL.
La entrada estándar es el descriptor 0. Por defecto es el teclado, pero la shell la puede
conectar a un fichero (./prog < f.txt) o a la salida de otro programa con una
tubería (cat f.txt | ./prog). Para el programa es lo mismo: lee del 0.
get_next_line(0) funciona igual que con un fichero. El tester del repo lo prueba
con stdin y con una tubería que escribe a trozos, que es justo cuando read devuelve
menos de lo pedido.
Una fuente de datos que se lee en orden, por trozos, sin saber de antemano cuánto mide y, en
general, sin poder volver atrás. Un fichero se puede rebobinar con lseek; una tubería o
la terminal, no.
El enunciado prohíbe lseek, así que get_next_line tiene que tratar todo como un
flujo: lo que lee de más después del '\n' no se puede «devolver» al fichero y hay que
guardarlo para la siguiente llamada.
Una zona de memoria donde se dejan los datos entre quien los produce y quien los usa. Leer de uno en uno sería una llamada al sistema por byte; con un buffer se pide un bloque de una vez.
Aquí hay uno por fd, buf[fd], de BUFFER_SIZE + 1 bytes: el + 1 deja
sitio para el '\0'. Entre llamadas guarda el resto que sobró detrás del último
'\n'.
Un fichero de texto es una secuencia de caracteres separada en líneas por '\n'. Un
binario (una imagen, un ejecutable) puede contener cualquier byte, incluido el 0, que en C es el
fin de una cadena.
El enunciado declara indeterminado leer un binario, y se ve por qué: las funciones
gnl_ miden con gnl_strlen, que se para en el primer
'\0'. Con el contenido ab\0cd\nef\n el resultado depende del
BUFFER_SIZE: con 1 salen "abcd\n" y "ef\n" (el 0 se pierde);
con 8 solo "ab\n"; con 42 solo "ab".
static localUna variable declarada con static dentro de una función. Solo se ve desde esa
función, como una local, pero existe durante todo el programa, como una global: se inicializa una
vez (a cero si no se le da valor) y conserva su contenido entre llamadas.
static char *buf[MAX_FD] es la única de get_next_line. Empieza con los 1024
punteros a NULL y cada buf[fd] guarda el resto de ese fd de una llamada a
la siguiente. En nm aparece como b buf.0: la b minúscula es
«en .bss y local al fichero».
El ámbito de una variable es desde dónde se puede nombrar; la duración, cuánto tiempo existe. Son cosas independientes:
| Variable | Ámbito | Duración |
|---|---|---|
| local | la función | una llamada |
| global | todo el programa | todo el programa |
static local | la función | todo el programa |
get_next_line necesita la tercera fila: duración larga para recordar el resto y ámbito corto para no ser una global.
Una variable declarada fuera de toda función. Cualquier fichero del programa puede leerla y cambiarla, y por eso es fácil que alguien la toque sin querer. En 42 están prohibidas casi siempre, y este enunciado lo dice expresamente.
El tester del repo lo comprueba con nm: una global sale con letra mayúscula
(B, D), y la static de get_next_line sale con b
minúscula, que no cuenta.
.bssTres zonas de la memoria de un proceso. La pila guarda las variables locales y se
recoge sola al salir de cada función; en Linux suele medir 8 MB (ulimit -s da 8192
KB). El heap es la memoria de malloc, que vive hasta el free.
.bss es la zona de las globales y static que empiezan a cero, y dura todo el
programa.
En get_next_line, el array buf está en .bss (1024 punteros, 8 KB) y
los buffers a los que apunta, en el heap. Un char buf[BUFFER_SIZE] local con
BUFFER_SIZE=10000000 pediría 10 MB de pila y el programa reventaría.
malloc y freemalloc(n) reserva n bytes en el heap y devuelve su dirección, o
NULL si no puede. free(p) los devuelve. Cada bloque reservado tiene que
liberarse una vez, ni cero ni dos.
Las únicas funciones autorizadas son read, malloc y
free. Cada línea devuelta sale de un malloc, y cada vuelta de
gnl_strncat reserva una copia nueva y libera la anterior; con
BUFFER_SIZE=1 eso es una reserva por byte de la línea.
En C una cadena es una fila de char que acaba en el byte '\0'. No se
guarda la longitud: el final está donde está el cero, y strlen lo busca contando.
read no lo pone, así que gnl_read_loop hace
buf[bytes_read] = '\0' tras cada lectura. Por eso el buffer mide
BUFFER_SIZE + 1: con BUFFER_SIZE bytes leídos, el cero va en la posición
BUFFER_SIZE.
NULL frente a cadena vacíaNULL es un puntero que no apunta a nada; "" es una cadena de verdad,
un bloque de memoria con un solo byte, el '\0'. A la primera no se le puede leer nada;
la segunda tiene longitud 0 y hay que liberarla si salió de malloc.
get_next_line usa las dos: dentro, r[0] == '\0' significa «no queda nada»; fuera,
lo que ve quien llama es NULL. Una línea vacía del fichero no es ninguna de las dos:
es "\n".
Sumar un entero a un puntero lo avanza ese número de elementos, y restar dos punteros del mismo
bloque da cuántos elementos hay entre ellos. Con char, un elemento es un byte.
En gnl_split, p apunta al '\n' dentro de
buf: p - buf es su posición y p - buf + 1 la longitud de la
línea con su salto. p + 1 es donde empieza el resto. Con buf = "hola\nmun",
p - buf vale 4.
Quién es responsable de liberar cada bloque. No lo comprueba C; es un contrato que hay que respetar de memoria: quien recibe la propiedad libera, y quien la cede no vuelve a tocar el puntero.
La línea devuelta pasa a ser de quien llama. gnl_strncat se queda con su primer
argumento y lo libera, por eso siempre se usa como r = gnl_strncat(r, …). El buffer
de cada fd es de get_next_line.
reallocLa función de la libc que agranda (o encoge) un bloque del heap: reserva uno nuevo del tamaño
pedido, copia el contenido, libera el viejo y devuelve el nuevo. Si falla, devuelve
NULL y el viejo sigue vivo.
No está autorizada, y gnl_strncat hace su papel a mano, con una diferencia: si la
reserva falla, el original ya está liberado. Eso simplifica los caminos de error, porque nunca
queda nada que liberar después.
Una fuga es memoria reservada que no se libera. Valgrind distingue dos casos al final: definitely lost, bloques a los que ya no apunta nada (una fuga de verdad), y still reachable, bloques a los que todavía apunta algo, por ejemplo una static, pero que nadie liberó.
Si se lee un fd hasta NULL, get_next_line lo deja todo liberado: «in use at exit:
0 bytes». Si se deja un fd a medias, su buffer queda como still reachable.
-DEl preprocesador trabaja sobre el texto del código antes de que el compilador lo vea: copia los
#include y sustituye las macros (#define NOMBRE valor) por su
valor. -D NOMBRE=valor en la línea de órdenes define una macro como si estuviera
escrita al principio del fichero.
cc -D BUFFER_SIZE=42 … hace que cada BUFFER_SIZE del código se
convierta en 42. El header da un valor por defecto con #ifndef, así que
compila también sin la flag; el tester lo comprueba («sin -D BUFFER_SIZE vale 42»).
El trío #ifndef X_H / #define X_H / #endif que rodea un
header. La primera vez que se incluye, X_H no existe, se define y se copia el
contenido; si se vuelve a incluir en el mismo .c, ya existe y se salta todo.
get_next_line.h usa GET_NEXT_LINE_H. El mismo
#ifndef, sin el #define de guarda, es el que pone los valores por defecto
de BUFFER_SIZE, MAX_FD y CHAR_SEP.
static y visibilidadUna función normal tiene enlace externo: cualquier otro .c del programa
puede llamarla y su nombre ocupa sitio en el espacio común. Con static delante solo
existe dentro de su fichero.
Las auxiliares de get_next_line.c no son static: en nm
salen con T mayúscula (T gnl_split, T gnl_read…). Funciona,
pero si el programa que la usa tuviera otra función gnl_read, el enlazado
fallaría.
Un coste es cuadrático cuando crece con el cuadrado del tamaño: el doble de datos, cuatro veces el trabajo. Suele salir de repetir, para cada elemento nuevo, un trabajo proporcional a todo lo anterior.
Le pasa a get_next_line con líneas largas: cada gnl_strncat copia la línea
acumulada entera para añadir BUFFER_SIZE bytes. Con BUFFER_SIZE=1 y una
línea de 20 000 bytes son unas 20 000²/2 = 200 millones de bytes copiados. El tester incluye ese
caso y pasa, pero se nota.
Lo que el enunciado declara fuera de contrato: puedes hacer cualquier cosa y no se evalúa. Equivale al comportamiento indefinido del estándar de C, pero decidido por el enunciado.
Aquí son dos casos: que el fichero cambie entre llamadas antes de llegar a EOF, y que sea
binario. Fuera de ellos, la función no puede terminar de forma inesperada: ni segfault ni doble
free.
char *get_next_line(int fd)
{
static char *buf[MAX_FD];
char *p;
char *r;
if (fd < 0 || fd >= MAX_FD || BUFFER_SIZE <= 0 || !gnl_set_buffer(buf, fd))
return (NULL);
r = NULL;
p = gnl_strchr(buf[fd], CHAR_SEP);
if (!p)
r = gnl_read(buf[fd], fd);
else
r = gnl_split(buf[fd], p, r);
if (!r || r[0] == '\0')
{
free(r);
free(buf[fd]);
buf[fd] = NULL;
return (NULL);
}
return (r);
}
Una variable local normal vive en la pila y muere al salir de la función. Una
static declarada dentro de la función vive lo que dura el programa: se inicializa
una sola vez (a cero, si no le das valor) y conserva su contenido de una llamada a la siguiente.
Pero solo es visible dentro de get_next_line, así que no es una variable global y
cumple la prohibición del enunciado.
Aquí la static es un array de punteros, uno por descriptor: buf[fd] es
el «resto» pendiente de ese fd. Empiezan todos a NULL, y el primer uso de cada fd
reserva su buffer:
void *gnl_set_buffer(char **buf, int fd)
{
if (!buf[fd])
{
buf[fd] = (char *)malloc(sizeof(char) * (BUFFER_SIZE + 1));
if (!buf[fd])
return (NULL);
buf[fd][0] = '\0';
buf[fd][BUFFER_SIZE] = '\0';
}
return (buf[fd]);
}
La lógica de la función principal tiene dos ramas: si el resto guardado ya contiene
un salto de línea, no hace falta leer nada — basta con cortar (gnl_split). Si no,
hay que leer más (gnl_read).
Ojo: las funciones auxiliares de get_next_line.c (gnl_split,
gnl_read_loop, gnl_read, gnl_set_buffer) no están
declaradas static ni en el header, así que son visibles desde fuera del fichero.
Funciona igual; solo significa que ocupan esos nombres en el programa que enlace con ellas.
static local combina ámbito de función con duración de programa.
Vive en el segmento de datos (.bss, por estar a cero), no en la pila, y por eso
sobrevive. Es la forma que tiene C de darle «memoria» a una función sin exponer ese estado al
resto del código.# ifndef BUFFER_SIZE
# define BUFFER_SIZE 42
# endif
# ifndef MAX_FD
# define MAX_FD 1024
# endif
# ifndef CHAR_SEP
# define CHAR_SEP '\n'
# endif
-D BUFFER_SIZE=42 equivale a poner #define BUFFER_SIZE 42 al principio
de cada fichero compilado. El evaluador y la Moulinette lo cambian para probar tu función con 1,
con 9999, con 10000000. El #ifndef da un valor por defecto para que el proyecto
compile también sin la flag, como exige el enunciado, sin pisar el valor si viene de fuera.
El usuario usa el mismo patrón para dos macros más: MAX_FD, el tamaño del array
de buffers, y CHAR_SEP, el carácter que corta las líneas. Esta última es una rareza
simpática: compilando con -D CHAR_SEP="' '" la función devolvería palabras en vez de
líneas. Ojo con MAX_FD: un fd mayor o igual que 1024 devuelve NULL
aunque esté abierto; en Linux el límite de descriptores por proceso puede ser mayor
(ulimit -n).
La comprobación BUFFER_SIZE <= 0 al principio de get_next_line
cubre a quien compile con -D BUFFER_SIZE=0 o negativo: se devuelve
NULL antes de reservar nada. Y como el buffer se reserva con malloc en
el heap, un BUFFER_SIZE de 10000000 no revienta la pila, que es lo que pasaría con un
char buf[BUFFER_SIZE] local.
read trae un solo byte, y será lenta; con 10000000, tiene que
tolerar un buffer enorme, que en la pila no cabría. El tamaño del buffer no debe cambiar el
resultado, solo el número de lecturas.Cuando el resto no tiene '\n', gnl_read lo copia a la línea en
construcción r, vacía el buffer y empieza a leer:
char *gnl_read(char *buf, int fd)
{
char *r;
r = gnl_strdup(buf, BUFFER_SIZE + 1);
if (!r)
return (NULL);
buf[0] = '\0';
r = gnl_read_loop(buf, fd, r, read(fd, buf, BUFFER_SIZE));
return (r);
}
char *gnl_read_loop(char *buf, int fd, char *r, ssize_t bytes_read)
{
char *p;
while (r && bytes_read > 0)
{
buf[bytes_read] = '\0';
p = gnl_strchr(buf, CHAR_SEP);
if (p)
{
r = gnl_split(buf, p, r);
break ;
}
else
{
r = gnl_strncat(r, buf, gnl_strlen(r) + bytes_read);
buf[0] = '\0';
bytes_read = read(fd, buf, BUFFER_SIZE);
}
}
if (bytes_read < 0)
{
free(r);
return (NULL);
}
return (r);
}
Cada vuelta: read no pone '\0', así que se añade a mano en
buf[bytes_read] (para eso el buffer mide BUFFER_SIZE + 1). Si en lo
leído no hay salto, todo se acumula en r y se lee otra vez. Si lo hay, se
corta:
char *gnl_split(char *buf, char *p, char *r)
{
char *q;
if (!r)
{
r = gnl_strdup("", 0);
if (!r)
return (NULL);
}
q = gnl_strdup(p + 1, gnl_strlen(p));
if (!q)
{
free(r);
return (NULL);
}
r = gnl_strncat(r, buf, gnl_strlen(r) + (p - buf + 1));
gnl_strncpy(buf, q, BUFFER_SIZE + 1);
free(q);
return (r);
}
p apunta al '\n' dentro de buf. Lo que va después
(p + 1) se copia aparte en q; a r se le añaden los
p - buf + 1 primeros bytes (la línea con su '\n'), y luego
q se vuelve a copiar al principio de buf: ese es el resto que
se guarda para la próxima llamada. La copia intermedia en q evita copiar el
buffer sobre sí mismo.
El estado entre llamadas, con un fichero "hola\nmundo\nfin" (sin salto final) y
BUFFER_SIZE=8:
llamada buf[fd] al entrar read(fd, buf, 8) devuelve buf[fd] al salir
------- ----------------- ------------------- ---------- ----------------
1 "" (recién "hola\nmun" (8) "hola\n" "mun"
malloc)
2 "mun" sin '\n' "do\nfin" (6) "mundo\n" "fin"
r = "mun" + "do\n"
3 "fin" sin '\n' "" (0) "fin" ""
EOF: r = "fin"
4 "" "" (0) NULL free → NULL
┌──────────────── static char *buf[MAX_FD] ───────────────┐
│ buf[0] buf[1] buf[2] buf[3] ... buf[1023] │
│ NULL NULL NULL │ NULL │
└──────────────────────────┼──────────────────────────────┘
▼ (heap, BUFFER_SIZE + 1)
┌───┬───┬───┬────┬─────────┐
│ m │ u │ n │ \0 │ ... │
└───┴───┴───┴────┴─────────┘
'\n') casi nunca coincide con la física (el final del read). La
solución es siempre la misma tríada — un buffer de lectura, un acumulador y un resto — y la
volverás a ver en cualquier código que lea de un socket, de una tubería o de un parser. También
obliga a manejar aritmética de punteros con soltura: p - buf es una distancia en
bytes, no una dirección.read devuelve 0 en fin de fichero y -1 en error. El
bucle de lectura para con cualquiera de los dos (bytes_read > 0), pero los
distingue después:
r tal cual, sin '\n'. Es lo que pide el enunciado: la línea termina
en \n «excepto si se ha llegado al final del archivo y éste no termina con un
\n».r es la cadena vacía
"". get_next_line lo detecta con r[0] == '\0', libera
la cadena y también el buffer del fd, pone buf[fd] = NULL y devuelve
NULL.gnl_read_loop libera r y
devuelve NULL, y get_next_line libera el buffer por el mismo camino.
Lo mismo pasa con un fd que no está abierto: se reserva su buffer, read falla y se
libera enseguida.Que el buffer quede a NULL al terminar tiene una consecuencia práctica: si
después se reutiliza ese número de fd para otro fichero, empieza limpio.
NULL y
"" son cosas distintas (un puntero que no apunta a nada frente a una cadena válida
de longitud cero) y que aquí la cadena vacía funciona como señal interna de «no queda nada». Y que
una función que devuelve NULL «al terminar» tiene que dejar su estado recogido en
ese momento: la última llamada es la que libera.Como la libft está prohibida, el usuario reescribe en get_next_line_utils.c las
cinco funciones de cadena que necesita, con prefijo gnl_: gnl_strlen,
gnl_strchr, gnl_strdup, gnl_strncpy y
gnl_strncat. No son clones de las de la libc: están adaptadas al proyecto. Por
ejemplo, gnl_strlen acepta NULL y devuelve 0, y
gnl_strdup recibe una longitud máxima y rellena con '\0' hasta el final.
La más importante es gnl_strncat, porque no concatena en el sitio sino que
reserva una cadena nueva:
char *gnl_strncat(char *dst, char *src, size_t n)
{
char *r;
size_t l_d;
size_t l_s;
size_t i;
l_d = gnl_strlen(dst);
l_s = gnl_strlen(src);
r = gnl_strdup(dst, n);
free(dst);
if (!r)
return (NULL);
i = 0;
while (i < l_s && i + l_d < n && src[i])
{
r[l_d + i] = src[i];
i++;
}
r[l_d + i] = '\0';
return (r);
}
n es la longitud total del resultado: por eso las llamadas le pasan
gnl_strlen(r) + bytes_read o gnl_strlen(r) + (p - buf + 1). La función
copia dst en un bloque de n + 1 bytes, libera
dst y añade src detrás.
gnl_strncat «se come» su primer argumento, y quien
la llama tiene que sustituir su puntero por el devuelto (r = gnl_strncat(r, ...)) y
no volver a tocar el antiguo. Si la reserva falla, el original ya está liberado y se devuelve
NULL, de modo que el error sube sin dejar nada colgando. Es la misma idea que
realloc, escrita a mano.El reparto de responsabilidades es este:
free.get_next_line: se reserva en el primer uso y se
libera al llegar a EOF o al fallar.malloc intermedio (q en gnl_split, las copias
de gnl_strncat) se libera en la misma función o pasa la propiedad a quien la
llama.Leyendo dos ficheros alternados hasta el final, con BUFFER_SIZE de 1, 3, 42 y
10000000, valgrind no informa de ningún leak.
Dos cosas que conviene saber explicar en la evaluación. Primera: si el programa deja de leer
un fd antes de llegar a EOF, su buffer sigue reservado en el array static al terminar el
programa. Valgrind lo muestra como still reachable (sigue habiendo un puntero a él), no
como definitely lost; con la interfaz que fija el enunciado no hay forma de avisar a la
función de que ya no vas a leer más. Segunda: ojo con el coste. Cada vuelta sin salto de línea
hace un gnl_strncat que vuelve a copiar toda la línea acumulada, así que una línea de
L bytes cuesta del orden de L² / BUFFER_SIZE copias. Con
BUFFER_SIZE=1 y líneas muy largas se nota.
El bonus pide dos cosas: usar una sola variable estática, y poder alternar llamadas sobre fd 3, 4 y 5 sin que se mezclen las líneas de uno con las de otro. Con un único buffer static compartido, leer del fd 4 machacaría el resto pendiente del fd 3.
static char *buf[MAX_FD];
...
p = gnl_strchr(buf[fd], CHAR_SEP);
La solución del usuario es indexar por fd: cada descriptor tiene su propio resto en
buf[fd], y todos viven dentro de una variable static, el array. Lo
curioso es que el usuario ya lo hizo así en la parte obligatoria, de modo que los ficheros
_bonus son copias idénticas de los normales; la única diferencia es el
#include "get_next_line_bonus.h". Leyendo dos ficheros alternados se obtiene:
[hola\n] [uno\n] [mundo\n] [dos\n] [\n] [NULL] ... [sin salto]
El precio del array es fijo: 1024 punteros (8 KB en 64 bits) en .bss,
aunque solo se use uno. Los buffers en sí solo se reservan para los fd que se leen.
Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado a fondo. Están agrupadas en: la static y el buffer, casos límite, memoria, y bonus y Norma. Antes de mirar la respuesta, intenta contestar tú.
Una variable que solo se ve dentro de la función pero existe todo el programa, así que
conserva su valor entre llamadas. La necesitas porque un read casi nunca acaba justo
en el '\n': lo que sobra detrás hay que guardarlo para la siguiente llamada, y una
local normal desaparecería. No es una global porque nadie fuera de get_next_line
puede nombrarla. → static
BUFFER_SIZE=1? ¿Y con 10000000?Sí con los dos; el tester lo prueba con 1, 42 y 10000000. Con 1 es correcto pero lento: un
read y una copia de la línea por byte. Con 10000000 funciona porque el buffer se
reserva con malloc en el heap; un array local de 10 MB no cabría en una pila de 8 MB.
→ -D
BUFFER_SIZE=0 o sin -D?Con 0 o negativo, get_next_line devuelve NULL antes de reservar nada
(BUFFER_SIZE <= 0). Sin -D, el #ifndef del header pone 42.
→ -D
Sí. Si el resto guardado ya tiene un '\n', se corta sin llamar a read.
Si no, se lee de BUFFER_SIZE en BUFFER_SIZE y se para en el primer
bloque que trae un salto. Nunca se lee el fichero entero. → read
'\n'? ¿Y un fichero vacío?La última línea sin salto ("fin") y, en la llamada siguiente, NULL.
Un fichero vacío da NULL a la primera. Una línea vacía en medio del fichero sale como
"\n", no como NULL. → EOF
NULL en todos. El −1 se rechaza antes de nada; con uno cerrado o un directorio,
read devuelve −1, se libera lo acumulado y el buffer del fd, y se devuelve
NULL. El tester prueba los cuatro casos (−1, 4242 sin abrir, ya cerrado y un
directorio). → EOF
Sí: get_next_line(0) es un fd más. Con la terminal, cada línea llega cuando se pulsa
Intro, y Ctrl-D al principio de una línea da EOF. El tester lo prueba con stdin y con una tubería
que escribe a trozos. → entrada estándar
El enunciado lo declara indeterminado. Con esta implementación, un '\0' dentro de
los datos corta la cadena, porque todo se mide con gnl_strlen, y el resultado depende
de BUFFER_SIZE. No revienta, pero pierde datos. → texto y binario
La línea devuelta la libera quien llama. El buffer de cada fd lo libera
get_next_line al llegar a EOF o al fallar. Los bloques intermedios
(q en gnl_split, las copias de gnl_strncat) se liberan en
la misma función. Leyendo hasta NULL, valgrind termina con 0 bytes en uso.
→ valgrind
El buffer de ese fd se queda reservado en la static. Valgrind lo marca como still
reachable, no como definitely lost, porque la static sigue apuntando a él. Con la
firma char *get_next_line(int fd) no hay forma de decirle a la función que ya no vas
a leer más. → valgrind
malloc a mitad de línea?La función que falla libera lo que tenía y devuelve NULL; el NULL sube
hasta get_next_line, que libera el buffer del fd y devuelve NULL.
gnl_strncat libera su entrada aunque la reserva falle, así que no queda nada colgando.
El tester hace fallar, en pruebas separadas, distintos malloc de una lectura (el 1.º, el 2.º, el 4.º… de 21) y no encuentra leaks.
→ utils
La static es un array, buf[MAX_FD]: una sola variable con un resto por fd. Cada
llamada usa buf[fd] y no toca los demás. La parte obligatoria ya estaba hecha así, y
los ficheros _bonus solo cambian el #include. → bonus
Devuelve NULL aunque esté abierto, porque no cabe en el array. En el ordenador
donde se probó, ulimit -n da 1048576, así que un proceso podría tener fd mucho más
altos. Se puede cambiar compilando con -D MAX_FD=…, a costa de 8 bytes de
.bss por cada fd de más. → -D
gnl_read_loop es una función aparte?Lo más probable, por la Norma: 25 líneas por función como mucho, y el bucle de lectura junto al
resto de gnl_read pasaría de ahí. Se parte en dos y el primer read se pasa como
argumento. Las auxiliares no son static, y el evaluador puede preguntarlo: funcionan
igual, pero son visibles desde otros ficheros. → static