Lines Matching refs:buffer
387 buffer, among other things.
438 know the buffer is empty, errors can still occur when closing a file if
494 they were issued sequentially. The buffer operations performed while
627 if the buffer is not empty. With the addition of locking requirements
652 manipulation of the buffer of the stream.
866 @c may be stored before the character is stored in the buffer,
1242 @c between reallocing the buffer at *lineptr and updating the pointer
1245 (including the newline and a terminating null character) in a buffer
1246 and storing the buffer address in @code{*@var{lineptr}}.
1249 the address of a buffer @code{*@var{n}} bytes long, allocated with
1250 @code{malloc}. If this buffer is long enough to hold the line,
1251 @code{getline} stores the line in this buffer. Otherwise,
1252 @code{getline} makes the buffer bigger using @code{realloc}, storing the
1253 new buffer address back in @code{*@var{lineptr}} and the increased size
1259 buffer for you by calling @code{malloc}. This buffer remains allocated
2415 provided buffer a negative value is returned. You should try again with
2452 char *buffer = xmalloc (size);
2456 int buflen = snprintf (buffer, size, "value of %s is %s",
2464 /* @r{Reallocate buffer now that we know
2468 buffer = xrealloc (buffer, size);
2471 snprintf (buffer, size, "value of %s is %s",
2475 return buffer;
2501 buffer you allocate in advance. The @var{ptr} argument should be the
2506 The return value is the number of characters allocated for the buffer, or
2507 less than zero if an error occurred. Usually this means that the buffer
3363 * Dynamic String Input:: String conversions that @code{malloc} the buffer.
3470 which requests allocation of a buffer long enough to store the string in.
3548 multibyte string. This means that the buffer must provide room for
3552 stored in the user provided buffer.
3564 multibyte string. This means that the buffer must provide room for
3568 stored in the user provided buffer.
3578 byte of output and therefore the provided buffer must be large enough for up
3737 Provide a buffer to store it in. This is the default. You should
3743 buffer you provide. In general, the only way to do this is to specify a
3744 maximum field width one less than the buffer size. @strong{If you
3745 provide the buffer, always specify a maximum field width to prevent
3749 Ask @code{scanf} to allocate a big enough buffer, by specifying the
3751 an argument of type @code{char **} for the buffer address to be stored
3763 making the buffer long enough.
3854 @samp{a} flag, because input too long would overflow whatever buffer you
3855 have provided for it. No matter how long your buffer is, a user could
3863 maximum size. Using this feature, you don't supply a buffer; instead,
3864 @code{scanf} allocates a buffer big enough to hold the data and gives
3869 type @code{char **}. The @code{scanf} function allocates a buffer and
3871 free the buffer with @code{free} when you no longer need it.
4178 characters since the last buffer flush may have been committed to the
4662 When you try to do output and the output buffer is full.
4735 The @code{__fpurge} function causes the buffer of the stream
4737 input in the buffer is lost. If the stream is in output mode the
4739 underlying storage) and the buffer is cleared.
4765 allocates a buffer itself using @code{malloc}. This buffer will be freed
4770 long as the stream remains open and this array remains its buffer. You
4772 (@pxref{Unconstrained Allocation}) the buffer. Using an automatic array
4776 While the array remains a stream buffer, the stream I/O functions will
4777 use the buffer for their internal purposes. You shouldn't try to access
4815 for the buffer when you call @code{setvbuf}.
4817 Actually, you can get an even better value to use for the buffer size
4847 buffer. The @var{size} argument specifies the length of @var{buf}.
4857 buffer for you.
4877 Two more extensions allow to determine the size of the buffer and how
4883 The @code{__fbufsize} function return the size of the buffer in the
4894 function returns the number of bytes currently in the output buffer.
4922 a string or memory buffer.
4933 I/O to a string or memory buffer. These facilities are declared in
4944 @var{opentype} argument, that reads from or writes to the buffer specified
4950 if you are going to write things to the buffer and then read them back
4952 buffer (for this, try @code{open_memstream}, below). The buffer is
4958 character in the buffer. Otherwise the initial file position is at the
4959 beginning of the buffer.
4962 (zero byte) is written at the end of the buffer if it fits. You
4964 Attempts to write more than @var{size} bytes to the buffer result
4968 buffer do not count as ``end of file''. Read operations indicate end of
4995 This function opens a stream for writing to a buffer. The buffer is
4997 After you've closed the stream, this buffer is your responsibility to
5002 contain the pointer to the buffer and its size. The values thus stored
5007 A null character is written at the end of the buffer. This null character
5095 locations within the buffer; any attempt to seek outside the buffer will
5129 ssize_t @var{reader} (void *@var{cookie}, char *@var{buffer}, size_t @var{size})
5134 the @var{buffer}, and return the number of bytes read, or zero to
5141 ssize_t @var{writer} (void *@var{cookie}, const char *@var{buffer}, size_t @var{size})
5146 the buffer, and return the number of bytes written. You can return a