sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add lib_libfgets() to better support the small differences between gets(), gets_s(), and fgets()

Browse Source
This commit is contained in:
Gregory Nutt 2014-01-08 10:47:34 -06:00
parent 8e1b493786
commit 0bdee120a1
7 changed files with 300 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog
View File

@ -6390,4 +6390,7 @@
("x") (2014-1-7)
* include/threads.h: First crude cut at a C11 threads.h header
file (just maps to pthreads) (2014-1-7).
* libc/stdio/lib_libfgets.c: Common implementation supports all
of the slightly different requirements of gets(), gets_s(), and
fgets() (2014-1-7).

7
libc/lib_internal.h
View File

@ -1,7 +1,7 @@
/****************************************************************************
* libc/lib_internal.h
*
* Copyright (C) 2007-2013 Gregory Nutt. All rights reserved.
* Copyright (C) 2007-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -184,6 +184,11 @@ ssize_t lib_fwrite(FAR const void *ptr, size_t count, FAR FILE *stream);
ssize_t lib_fread(FAR void *ptr, size_t count, FAR FILE *stream);
/* Defined in lib_libfgets.c */
FAR char *lib_fgets(FAR char *buf, int buflen, FILE *stream,
bool keepnl, bool consume);
/* Defined in lib_libfflush.c */
ssize_t lib_fflush(FAR FILE *stream, bool bforce);

11
libc/stdio/Make.defs
View File

@ -57,11 +57,12 @@ ifneq ($(CONFIG_NFILE_STREAMS),0)
CSRCS += lib_fopen.c lib_fclose.c lib_fread.c lib_libfread.c lib_fseek.c
CSRCS += lib_ftell.c lib_fsetpos.c lib_fgetpos.c lib_fgetc.c lib_fgets.c
CSRCS += lib_gets_s.c lib_gets.c lib_fwrite.c lib_libfwrite.c lib_fflush.c
CSRCS += lib_libflushall.c lib_libfflush.c lib_rdflush.c lib_wrflush.c
CSRCS += lib_fputc.c lib_puts.c lib_fputs.c lib_ungetc.c lib_vprintf.c
CSRCS += lib_fprintf.c lib_vfprintf.c lib_stdinstream.c lib_stdoutstream.c
CSRCS += lib_perror.c lib_feof.c lib_ferror.c lib_clearerr.c
CSRCS += lib_gets_s.c lib_gets.c lib_libfgets.c lib_fwrite.c lib_libfwrite.c
CSRCS += lib_fflush.c lib_libflushall.c lib_libfflush.c lib_rdflush.c
CSRCS += lib_wrflush.c lib_fputc.c lib_puts.c lib_fputs.c lib_ungetc.c
CSRCS += lib_vprintf.c lib_fprintf.c lib_vfprintf.c lib_stdinstream.c
CSRCS += lib_stdoutstream.c lib_perror.c lib_feof.c lib_ferror.c
CSRCS += lib_clearerr.c
endif
endif

145
libc/stdio/lib_fgets.c
View File

@ -1,7 +1,7 @@
/****************************************************************************
* libc/stdio/lib_fgets.c
*
* Copyright (C) 2007-2008, 2011-2013 Gregory Nutt. All rights reserved.
* Copyright (C) 2007-2008, 2011-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -39,58 +39,12 @@
#include <nuttx/config.h>
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <debug.h>
#include "lib_internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/* Some environments may return CR as end-of-line, others LF, and others
* both. If not specified, the logic here assumes either (but not both) as
* the default.
*/
#if defined(CONFIG_EOL_IS_CR)
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_LF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_BOTH_CRLF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_EITHER_CRLF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
#else
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
# define CONFIG_EOL_IS_EITHER_CRLF 1
#endif
/****************************************************************************
* Private Type Declarations
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Data
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
@ -98,7 +52,7 @@
****************************************************************************/
/****************************************************************************
* Global Functions
* Public Functions
****************************************************************************/
/****************************************************************************
@ -115,92 +69,7 @@
char *fgets(FAR char *buf, int buflen, FILE *stream)
{
int nch = 0;
/* Let lib_fgets() do the heavy lifting */
/* Sanity checks */
if (!stream || !buf || buflen < 1 || stream->fs_fd < 0)
{
return NULL;
}
if (buflen < 2)
{
*buf = '\0';
return buf;
}
/* Read characters until we have a full line. On each the loop we must
* be assured that there are two free bytes in the line buffer: One for
* the next character and one for the null terminator.
*/
for(;;)
{
/* Get the next character */
int ch = fgetc(stream);
/* Check for end-of-line. This is tricky only in that some
* environments may return CR as end-of-line, others LF, and
* others both.
*/
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
if (ch == '\n')
#elif defined(CONFIG_EOL_IS_CR)
if (ch == '\r')
#else /* elif defined(CONFIG_EOL_IS_EITHER_CRLF) */
if (ch == '\n' || ch == '\r')
#endif
{
/* The newline is stored in the buffer along with the null
* terminator.
*/
buf[nch++] = '\n';
buf[nch] = '\0';
return buf;
}
/* Check for end-of-file */
else if (ch == EOF)
{
/* End of file with no data? */
if (!nch)
{
/* Yes.. return NULL as the end of file mark */
return NULL;
}
else
{
/* Terminate the line */
buf[nch] = '\0';
return buf;
}
}
/* Otherwise, check if the character is printable and, if so, put the
* character in the line buffer
*/
else if (isprint(ch))
{
buf[nch++] = ch;
/* Check if there is room for another character and the line's
* null terminator. If not then we have to end the line now.
*/
if (nch + 1 >= buflen)
{
buf[nch] = '\0';
return buf;
}
}
}
return lib_fgets(buf, buflen, stream, true, false);
}

59
libc/stdio/lib_gets.c
View File

@ -37,40 +37,15 @@
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include "lib_internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Type Declarations
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Global Function Prototypes
****************************************************************************/
/****************************************************************************
* Global Constant Data
****************************************************************************/
/****************************************************************************
* Global Variables
****************************************************************************/
/****************************************************************************
* Private Constant Data
****************************************************************************/
/****************************************************************************
* Private Variables
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
@ -96,25 +71,7 @@
FAR char *gets(FAR char *s)
{
/* gets is ALMOST the same as fgets using stdin and no length limit
* (hence, the unsafeness of gets). So let fgets do most of the work.
*/
/* Let lib_fgets() do the heavy lifting */
FAR char *ret = fgets(s, INT_MAX, stdin);
if (ret)
{
/* Another subtle difference from fgets is that gets replaces
* end-of-line markers with null terminators. We will do that as
* a second step (with some loss in performance).
*/
int len = strlen(ret);
if (len > 0 && ret[len-1] == '\n')
{
ret[len-1] = '\0';
}
}
return ret;
return lib_fgets(s, RSIZE_MAX, stdin, false, false);
}

68
libc/stdio/lib_gets_s.c
View File

@ -37,40 +37,15 @@
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <stdint.h>
#include "lib_internal.h"
/****************************************************************************
* Definitions
****************************************************************************/
/****************************************************************************
* Private Type Declarations
****************************************************************************/
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/****************************************************************************
* Global Function Prototypes
****************************************************************************/
/****************************************************************************
* Global Constant Data
****************************************************************************/
/****************************************************************************
* Global Variables
****************************************************************************/
/****************************************************************************
* Private Constant Data
****************************************************************************/
/****************************************************************************
* Private Variables
* Pre-processor Definitions
****************************************************************************/
/****************************************************************************
@ -88,9 +63,10 @@
* gets() reads a line from stdin into the buffer pointed to by s until
* either a terminating newline or EOF, which it replaces with '\0'. Reads
* at most n-1 characters from stdin into the array pointed to by str until
* new-line character, end-of-file condition, or read error. A null
* character is written immediately after the last character read into the
* array, or to str[0] if no characters were read.
* new-line character, end-of-file condition, or read error. The newline
* character, if encountered, is not saved in the arraay. A NUL character
* is written immediately after the last character read into the array, or
* to str[0] if no characters were read.
*
* If n is zero or is greater than RSIZE_MAX, a null character is written
* to str[0] but the function reads and discards characters from stdin
@ -99,30 +75,22 @@
*
* If n-1 characters have been read, continues reading and discarding the
* characters from stdin until new-line character, end-of-file condition,
* or read error (not implemented).
* or read error.
*
**************************************************************************/
FAR char *gets_s(FAR char *s, rsize_t n)
{
/* gets is equivalent to fgets using stdin. So let fgets do most of the
* work.
*/
/* Handle the case where n is out of range as required */
FAR char *ret = fgets(s, n, stdin);
if (ret)
if (n < 1 || n > RSIZE_MAX)
{
/* A subtle difference from fgets is that gets_s replaces end-of-line
* markers with null terminators. We will do that as a second step
* (with some loss in performance).
*/
/* Set n=1, i.e., room only for the NUL terminator */
int len = strlen(ret);
if (len > 0 && ret[len-1] == '\n')
{
ret[len-1] = '\0';
}
n = 1;
}
return ret;
/* Then let lib_fgets() do the heavy lifting */
return lib_fgets(s, n, stdin, false, true);
}

252
libc/stdio/lib_libfgets.c Normal file
View File

@ -0,0 +1,252 @@
/****************************************************************************
* libc/stdio/lib_libfgets.c
*
* Copyright (C) 2007-2008, 2011-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdbool.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <debug.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Some environments may return CR as end-of-line, others LF, and others
* both. If not specified, the logic here assumes either (but not both) as
* the default.
*/
#if defined(CONFIG_EOL_IS_CR)
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_LF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_BOTH_CRLF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_BOTH_CRLF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_EITHER_CRLF
#elif defined(CONFIG_EOL_IS_EITHER_CRLF)
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
#else
# undef CONFIG_EOL_IS_CR
# undef CONFIG_EOL_IS_LF
# undef CONFIG_EOL_IS_BOTH_CRLF
# define CONFIG_EOL_IS_EITHER_CRLF 1
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: consume_eol
*
* Description:
* If 'consume' is true, then consume_eol() will read and discard bytes from
* 'stream' until an EOF or a newline encountered or until a read error
* occurs.
*
**************************************************************************/
static void consume_eol(FILE *stream, bool consume)
{
if (consume)
{
int ch;
do
{
ch = fgetc(stream);
}
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
while (ch != EOF && ch != '\n');
#elif defined(CONFIG_EOL_IS_CR)
while (ch != EOF && ch != '\r');
#else /* elif defined(CONFIG_EOL_IS_EITHER_CRLF) */
while (ch != EOF && ch != '\n' && ch != '\r');
#endif
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: lib_fgets
*
* Description:
* lib_fgets() implements the core logic for both fgets() and gets_s().
* lib_fgets() reads in at most one less than 'buflen' characters from
* stream and stores them into the buffer pointed to by 'buf'. Reading
* stops after an EOF or a newline encountered or after a read error
* occurs.
*
* If a newline is read, it is stored into the buffer only if 'keepnl' is
* set true. A null terminator is always stored after the last character
* in the buffer.
*
* If 'buflen'-1 bytes were read into 'buf' without encountering an EOF
* or newline then the following behavior depends on the value of
* 'consume': If consume is true, then lib_fgets() will continue reading
* bytes and discarding them until an EOF or a newline encountered or
* until a read error occurs. Otherwise, lib_fgets() returns with the
* remaining of the incoming stream buffer.
*
**************************************************************************/
FAR char *lib_fgets(FAR char *buf, int buflen, FILE *stream,
bool keepnl, bool consume)
{
int nch = 0;
/* Sanity checks */
if (!stream || !buf || stream->fs_fd < 0)
{
return NULL;
}
/* Make sure that we have a buffer and space for at least one character */
if (buflen < 1)
{
consume_eol(stream, consume);
return NULL;
}
/* Make sure that we have space for something in addition to the NUL
* terminator.
*/
if (buflen < 2)
{
*buf = '\0';
consume_eol(stream, consume);
return buf;
}
/* Read characters until we have a full line. On each the loop we must
* be assured that there are two free bytes in the line buffer: One for
* the next character and one for the null terminator.
*/
for(;;)
{
/* Get the next character */
int ch = fgetc(stream);
/* Check for end-of-line. This is tricky only in that some
* environments may return CR as end-of-line, others LF, and
* others both.
*/
#if defined(CONFIG_EOL_IS_LF) || defined(CONFIG_EOL_IS_BOTH_CRLF)
if (ch == '\n')
#elif defined(CONFIG_EOL_IS_CR)
if (ch == '\r')
#else /* elif defined(CONFIG_EOL_IS_EITHER_CRLF) */
if (ch == '\n' || ch == '\r')
#endif
{
if (keepnl)
{
/* Store newline is stored in the buffer */
buf[nch++] = '\n';
}
/* Terminate the string */
buf[nch] = '\0';
return buf;
}
/* Check for end-of-file */
else if (ch == EOF)
{
/* End of file with no data? */
if (!nch)
{
/* Yes.. return NULL as the end of file mark */
return NULL;
}
else
{
/* No, terminate the accumulated string */
buf[nch] = '\0';
return buf;
}
}
/* Otherwise, check if the character is printable and, if so, put the
* character in the line buffer
*/
else if (isprint(ch))
{
buf[nch++] = ch;
/* Check if there is room for another character and the line's
* NUL terminator. If not then we have to end the line now,
* perhaps consuming any data up to the end-of-line.
*/
if (nch + 1 >= buflen)
{
buf[nch] = '\0';
consume_eol(stream, consume);
return buf;
}
}
}
}