Esistono implementazioni alternative dell'interfaccia GNU getline?

Question

L'esperimento attualmente in uso utilizza una base software con una cronologia delle fonti complicata e una licenza non ben definita. Sarebbe una notevole quantità di lavoro per razionalizzare le cose e rilasciare sotto una licenza fissa.

È anche progettato per eseguire una piattaforma unixish casuale, e solo alcune delle libc che supportiamo hanno GNU getline, ma in questo momento il codice si aspetta.

Qualcuno sa di una reimplementazione della semantica GNU getline disponibile con una licenza meno restrittiva?

Edit :: Lo chiedo perché Google non ha aiutato, e mi piacerebbe evitare di scrivere uno se possibile (potrebbe essere un esercizio divertente, ma non può essere il miglior uso del mio tempo.)

per essere più precisi, l'interfaccia in questione è:

ssize_t getline (char **lineptr, size_t *n, FILE *stream); 

Answer 1

Date un'occhiata alla pagina di Paul Hsieh su User Input. Puoi mandare un'e-mail all'autore se vuoi conoscere i termini esatti.

Answer 2

Nel caso in cui si sta parlando readline, check out: editline

Answer 3

Sono perplesso.

Ho guardato il collegamento, ho letto la descrizione e questa è una buona utilità.

Ma, stai dicendo che semplicemente non puoi riscrivere questa funzione alle specifiche? Le specifiche sembra abbastanza chiaro,

Qui:

/* This code is public domain -- Will Hartung 4/9/09 */ 
#include <stdio.h> 
#include <stdlib.h> 

size_t getline(char **lineptr, size_t *n, FILE *stream) { 
    char *bufptr = NULL; 
    char *p = bufptr; 
    size_t size; 
    int c; 

    if (lineptr == NULL) { 
     return -1; 
    } 
    if (stream == NULL) { 
     return -1; 
    } 
    if (n == NULL) { 
     return -1; 
    } 
    bufptr = *lineptr; 
    size = *n; 

    c = fgetc(stream); 
    if (c == EOF) { 
     return -1; 
    } 
    if (bufptr == NULL) { 
     bufptr = malloc(128); 
     if (bufptr == NULL) { 
      return -1; 
     } 
     size = 128; 
    } 
    p = bufptr; 
    while(c != EOF) { 
     if ((p - bufptr) > (size - 1)) { 
      size = size + 128; 
      bufptr = realloc(bufptr, size); 
      if (bufptr == NULL) { 
       return -1; 
      } 
     } 
     *p++ = c; 
     if (c == '\n') { 
      break; 
     } 
     c = fgetc(stream); 
    } 

    *p++ = '\0'; 
    *lineptr = bufptr; 
    *n = size; 

    return p - bufptr - 1; 
} 

int main(int argc, char** args) { 
    char *buf = NULL; /*malloc(10);*/ 
    int bufSize = 0; /*10;*/ 

    printf("%d\n", bufSize); 
    int charsRead = getline(&buf, &bufSize, stdin); 

    printf("'%s'", buf); 
    printf("%d\n", bufSize); 
    return 0; 
} 

15 minuti, e non ho scritto C in 10 anni. Rompe in minima parte il contratto della linea in quanto controlla solo se il lineptr è NULL, piuttosto che NULL e n == 0. Puoi correggerlo se lo desideri. (L'altro caso non ha molto senso per me, suppongo che tu possa restituire -1 in questo caso.)

Sostituisci "\ n" con una variabile per implementare "getdelim".

Le persone scrivono ancora il codice?

Answer 4

Se si compila per l'uso BSD fgetln invece

Answer 5

Utilizzare queste versioni portatili di NetBSD: getdelim() e getline()

Questi provengono da libnbcompat in pkgsrc, e dispone di una licenza BSD al in cima a ciascun file. Avete bisogno di entrambi perché getline() chiama getdelim(). Scarica le ultime versioni di entrambi i file. Vedi la licenza BSD nella parte superiore di ogni file. Modifica i file per adattarli al tuo programma: potresti dover dichiarare getline() e getdelim() in uno dei tuoi file di intestazione e modificare entrambi i file per includere l'intestazione invece delle intestazioni nbcompat.

Questa versione di getdelim() è portatile perché chiama fgetc(). Per contrasto, un getdelim() da una libc (come BSD libc o musl libc) probabilmente userebbe le funzionalità private di quella libc, quindi non funzionerebbe su piattaforme diverse.

Negli anni successivi allo POSIX 2008 specified getline(), più piattaforme Unixish hanno aggiunto la funzione getline(). È raro che manca getline(), ma può ancora succedere su vecchie piattaforme. Alcune persone cercano di avviare NetBSD pkgsrc su vecchie piattaforme (come PowerPC Mac OS X), quindi vogliono libnbcompat per fornire funzioni POSIX mancanti come getline().

Answer 6

Il codice di Will Hartung soffre di un problema molto serio. realloc molto probabilmente libererà il vecchio blocco e ne assegnerà uno nuovo, ma il puntatore p all'interno del codice continuerà a puntare all'originale. Questo tenta di risolverlo usando invece l'indicizzazione dell'array. Cerca anche di replicare più strettamente la logica POSIX standard.

/* The original code is public domain -- Will Hartung 4/9/09 */ 
/* Modifications, public domain as well, by Antti Haapala, 11/10/17 */ 

#include <stdio.h> 
#include <stdlib.h> 
#include <errno.h> 

// if typedef doesn't exist (msvc, blah) 
typedef intptr_t ssize_t; 

ssize_t geetline(char **lineptr, size_t *n, FILE *stream) { 
    size_t pos; 
    int c; 

    if (lineptr == NULL || stream == NULL || n == NULL) { 
     errno = EINVAL; 
     return -1; 
    } 

    c = fgetc(stream); 
    if (c == EOF) { 
     return -1; 
    } 

    if (*lineptr == NULL) { 
     *lineptr = malloc(128); 
     if (*lineptr == NULL) { 
      return -1; 
     } 
     *n = 128; 
    } 

    pos = 0; 
    while(c != EOF) { 
     if (pos + 1 >= *n) { 
      size_t new_size = *n + (*n >> 2); 
      if (new_size < 128) { 
       new_size = 128; 
      } 
      char *new_ptr = realloc(*lineptr, new_size); 
      if (new_ptr == NULL) { 
       return -1; 
      } 
      *n = new_size; 
      *lineptr = new_ptr; 
     } 

     (*lineptr)[pos ++] = c; 
     if (c == '\n') { 
      break; 
     } 
     c = fgetc(stream); 
    } 

    (*lineptr)[pos] = '\0'; 
    return pos - 1; 
}