This is the mail archive of the guile@cygnus.com mailing list for the guile project.
Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
---|---|---|
Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
"Perry E. Metzger" <perry@piermont.com> writes: > My NetBSD box over here doesn't seem to have such a call. I can't find > a reference to it in XPG or the ANSI C library, either. It's part of glibc. So if it's relevant, it might be possible to extract from the glibc sources and add to the guile source tree for autoconfed inclusion on platforms not using glibc. (Wish I could count on asprintf everywhere too...) Line-Oriented Input =================== Since many programs interpret input on the basis of lines, it's convenient to have functions to read a line of text from a stream. Standard C has functions to do this, but they aren't very safe: null characters and even (for `gets') long lines can confuse them. So the GNU library provides the nonstandard `getline' function that makes it easy to read lines reliably. Another GNU extension, `getdelim', generalizes `getline'. It reads a delimited record, defined as everything through the next occurrence of a specified delimiter character. All these functions are declared in `stdio.h'. - Fonction: ssize_t getline (char **LINEPTR, size_t *N, FILE *STREAM) This function reads an entire line from STREAM, storing the text (including the newline and a terminating null character) in a buffer and storing the buffer address in `*LINEPTR'. Before calling `getline', you should place in `*LINEPTR' the address of a buffer `*N' bytes long, allocated with `malloc'. If this buffer is long enough to hold the line, `getline' stores the line in this buffer. Otherwise, `getline' makes the buffer bigger using `realloc', storing the new buffer address back in `*LINEPTR' and the increased size back in `*N'. *Note Unconstrained Allocation::. If you set `*LINEPTR' to a null pointer, and `*N' to zero, before the call, then `getline' allocates the initial buffer for you by calling `malloc'. In either case, when `getline' returns, `*LINEPTR' is a `char *' which points to the text of the line. When `getline' is successful, it returns the number of characters read (including the newline, but not including the terminating null). This value enables you to distinguish null characters that are part of the line from the null character inserted as a terminator. This function is a GNU extension, but it is the recommended way to read lines from a stream. The alternative standard functions are unreliable. If an error occurs or end of file is reached, `getline' returns `-1'. - Fonction: ssize_t getdelim (char **LINEPTR, size_t *N, int DELIMITER, FILE *STREAM) This function is like `getline' except that the character which tells it to stop reading is not necessarily newline. The argument DELIMITER specifies the delimiter character; `getdelim' keeps reading until it sees that character (or end of file). The text is stored in LINEPTR, including the delimiter character and a terminating null. Like `getline', `getdelim' makes LINEPTR bigger if it isn't big enough. `getline' is in fact implemented in terms of `getdelim', just like this: ssize_t getline (char **lineptr, size_t *n, FILE *stream) { return getdelim (lineptr, n, '\n', stream); } -- Rob Browning <rlb@cs.utexas.edu> PGP=E80E0D04F521A094 532B97F5D64E3930