Sont t-il d'autres mises en œuvre de GNU getline interface?

L'expérience, je travaille actuellement utilise un logiciel de base avec un complexe de la source de l'histoire et pas bien défini de licence. Ce serait une quantité considérable de travail pour rationaliser les choses et de les publier sous une licence fixe.

Il est également destiné à exécuter un hasard unixish plate-forme, et seulement une partie de la libc est que nous soutenons ont GNU getline, mais pour l'instant, le code n'attend que ça.

Personne ne sait d'une re-mise en œuvre de la GNU getline sémantique qui est disponible sous une licence moins restrictive?

Edit:: je demande parce que Google n'a pas aidé, et j'aimerais éviter d'écrire un si possible (cela peut être un exercice amusant, mais il ne peut pas être le meilleur usage de mon temps.)

Pour être plus précis, l'interface en question est:

ssize_t getline (char **lineptr, size_t *n, FILE *stream);
Invité par le question, j'ai corrigé la déclaration; getline retourne ssize_t, pas size_t.
Un domaine public de la mise en œuvre de getline(): stackoverflow.com/a/12169132/12711

OriginalL'auteur dmckee | 2009-04-09

  1. 2

    Prendre un coup d'oeil à Paul Hsieh page sur La Saisie De L'Utilisateur. Vous pouvez envoyer un email à l'auteur si vous voulez connaître les termes exacts.

    Si je dois écrire quelque chose, ce sera sans doute une bonne échafaudage. Merci.
    Avez-vous jeter un oeil à l'exemple: "size_t fgetstralloc (char ** p, FILE * fp)" sur la page?
    ::sigh:: bien sûr que non. J'ai seulement regardé la page une couple de fois. Et je suis un observateur qualifié, trop.

    OriginalL'auteur dirkgently

  2. 17

    Je suis perplexe.

    J'ai regardé le lien, lisez la description, et c'est un bon utilitaire.

    Mais, vous dites que vous simplement ne pouvez pas réécrire cette fonction à la spec? La spec semble assez clair,

    Ici:

    /* 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 minutes, et je n'ai pas écrit C en 10 ans. Il minorly rompt le getline contrat qu'il vérifie seulement si le lineptr est NULL, plutôt que NULL et n == 0. Vous pouvez corriger cela si vous le souhaitez. (L'autre cas n'a pas beaucoup de sens pour moi, je suppose que vous pourriez retourner -1 dans ce cas.)

    Remplacer le '\n' avec une variable à mettre en œuvre "getdelim".

    Les gens encore écrire du code plus?

    Cela fonctionne bien pour de courtes chaînes de caractères, mais peut échouer après la réaffectation des ressources. bufptr peut obtenir une nouvelle adresse et la p doit être maintenu à la même offset relatif. Dans mes tests (avec MinGW), realloc peut retourner plusieurs fois avec le même pointeur (si il arrive à être assez de mémoire à cet endroit) ou peut retourner une nouvelle adresse sur la première réaffectation. La nouvelle adresse peut être à proximité de la mémoire ou de loin, et peut également être avant la première adresse ainsi qu'après. IE il peut faire de la p un nombre aléatoire. Pour corriger, mettre "offset = p - bufptr;" en vertu de l'tandis que les expressions du FOLKLORE ligne, et "p = bufptr + offset;" après les si la valeur est NULL bloc.
    ((p - bufptr) > (size - 1)) est un problème si size == 0 (et *lineptr été très fortement non-NULLE) comme size - 1 est un grand nombre. Suggérer ((p - bufptr + 1) > size).
    malloc et realloc retourne sur mon stdio.h code void* pointeurs. J'ai donc dû ajouter opérateurs de cast, aussi (char*) pour les deux lignes.
    Vous ne pouvez pas retourner -1 dans size_t. Cela va échouer lamentablement si quelque chose va mal.
    AVIS QUE CETTE getline mise en ŒUVRE EST TRÈS CASSÉ comme l'a souligné @Todd. NE PAS UTILISER n'importe où.

    OriginalL'auteur Will Hartung

  3. 3

    Le code par la Volonté Hartung souffre d'un très grave problème. realloc sera probablement libre de l'ancien bloc et d'allouer une nouvelle, mais la p pointeur dans le code continuera à point à l'original. Ce que l'on essaie de corriger cela en utilisant un tableau d'indexation à la place. Il tente également de mieux reproduire la norme POSIX logique.

    /* 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>
#include <stdint.h>
//if typedef doesn't exist (msvc, blah)
typedef intptr_t ssize_t;
ssize_t getline(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;
}
((unsigned char *)(*lineptr))[pos ++] = c;
if (c == '\n') {
break;
}
c = fgetc(stream);
}
(*lineptr)[pos] = '\0';
return pos;
}

    OriginalL'auteur Antti Haapala

  4. 2

    Si vous compilez pour BSD utilisation fgetln
    au lieu de cela

    OriginalL'auteur Michael Andrews

  5. 2

    Utiliser ces versions portables de NetBSD: getdelim() et getline()

    Ceux-ci viennent de libnbcompat dans pkgsrc, et avoir une licence BSD en haut de chaque fichier. Vous avez besoin à la fois parce que getline() appelle getdelim(). Récupérer les dernières versions de ces deux fichiers. Voir la licence BSD en haut de chaque fichier. Modifier les fichiers à intégrer dans votre programme: vous pourriez avoir besoin de déclarer getline() et getdelim() dans un de vos fichiers d'en-tête, et de modifier les deux fichiers à inclure votre tête au lieu de la nbcompat en-têtes.

    Cette version de getdelim() est portable car il appelle fgetc(). Pour le contraste, un getdelim() à partir d'une libc (comme BSD libc ou musl libc) serait probablement d'utiliser les fonctions de la libc, de sorte qu'il ne fonctionnerait pas sur les plates-formes.

    Dans les années depuis POSIX 2008 spécifié getline(), plus Unixish plates-formes ont ajouté le getline() fonction. Il est rare que getline() est manquante, mais il peut néanmoins se produire sur les anciennes plates-formes. Quelques personnes tentent de bootstrap pkgsrc de NetBSD sur les anciennes plates-formes (comme PowerPC Mac OS X), donc ils veulent libnbcompat de fournir manque les fonctions POSIX comme getline().

    OriginalL'auteur George Koehler