Changes to NSH and readline to permit NSH to work on a platform with no file system

5 files changed, 639 insertions, 241 deletions

diff --git a/apps/system/readline/Makefile b/apps/system/readline/Makefile
index 040fd2e28..1f60f45fc 100644
--- a/apps/system/readline/Makefile
+++ b/apps/system/readline/Makefile
@@ -1,7 +1,7 @@
 ############################################################################
 # apps/system/readline/Makefile
 #
-#   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+#   Copyright (C) 2012-2013 Gregory Nutt. All rights reserved.
 #   Author: Gregory Nutt <gnutt@nuttx.org>
 #
 # Redistribution and use in source and binary forms, with or without
@@ -38,37 +38,43 @@
 include $(APPDIR)/Make.defs
 
 ifeq ($(WINTOOL),y)
-INCDIROPT	= -w
+INCDIROPT = -w
 endif
 
 # The Readline Library
 
-ASRCS		=
-CSRCS		= readline.c
+ASRCS =
+CSRCS = readline_common.c
 
-AOBJS		= $(ASRCS:.S=$(OBJEXT))
-COBJS		= $(CSRCS:.c=$(OBJEXT))
+ifeq ($(CONFIG_NFILE_STREAMS),0)
+CSRCS += std_readline.c
+else
+CSRCS += readline.c
+endif
+
+AOBJS = $(ASRCS:.S=$(OBJEXT))
+COBJS = $(CSRCS:.c=$(OBJEXT))
 
-SRCS		= $(ASRCS) $(CSRCS)
-OBJS		= $(AOBJS) $(COBJS)
+SRCS = $(ASRCS) $(CSRCS)
+OBJS = $(AOBJS) $(COBJS)
 
 ifeq ($(CONFIG_WINDOWS_NATIVE),y)
-  BIN		= ..\..\libapps$(LIBEXT)
+  BIN = ..\..\libapps$(LIBEXT)
 else
 ifeq ($(WINTOOL),y)
-  BIN		= ..\\..\\libapps$(LIBEXT)
+  BIN = ..\\..\\libapps$(LIBEXT)
 else
-  BIN		= ../../libapps$(LIBEXT)
+  BIN = ../../libapps$(LIBEXT)
 endif
 endif
 
-ROOTDEPPATH	= --dep-path .
+ROOTDEPPATH = --dep-path .
 
 # Common build
 
-VPATH		= 
+VPATH =
 
-all:	.built
+all: .built
 .PHONY: context depend clean distclean
 
 $(AOBJS): %$(OBJEXT): %.S
diff --git a/apps/system/readline/readline.c b/apps/system/readline/readline.c
index 5486a68eb..13e07e652 100644
--- a/apps/system/readline/readline.c
+++ b/apps/system/readline/readline.c
@@ -39,61 +39,32 @@
 
 #include <nuttx/config.h>
 
-#include <stdbool.h>
+#include <sys/types.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <string.h>
-#include <ctype.h>
 #include <errno.h>
-#include <debug.h>
-
-#include <nuttx/ascii.h>
-#include <nuttx/vt100.h>
+#include <assert.h>
 
 #include <apps/readline.h>
+#include "readline.h"
 
 /****************************************************************************
- * Definitions
+ * Pre-processor Definitions
  ****************************************************************************/
-/* In some systems, the underlying serial logic may automatically echo
- * characters back to the console.  We will assume that that is not the case
- & here
- */
-
-#define CONFIG_READLINE_ECHO 1
-
-/* 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
  ****************************************************************************/
 
+struct readline_s
+{
+  struct rl_common_s vtbl;
+  int infd;
+#ifdef CONFIG_READLINE_ECHO
+  int outfd;
+#endif
+};
+
 /****************************************************************************
  * Private Function Prototypes
  ****************************************************************************/
@@ -105,23 +76,23 @@
 /****************************************************************************
  * Private Data
  ****************************************************************************/
-/* <esc>[K is the VT100 command erases to the end of the line. */
-
-static const char g_erasetoeol[] = VT100_CLEAREOL;
 
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: readline_rawgetc
+ * Name: readline_getc
  ****************************************************************************/
 
-static inline int readline_rawgetc(int infd)
+static int readline_getc(FAR struct rl_common_s *vtbl)
 {
+  FAR struct readline_s *priv = (FAR struct readline_s *)vtbl;
   char buffer;
   ssize_t nread;
 
+  DEBUGASSERT(priv);
+
   /* Loop until we successfully read a character (or until an unexpected
    * error occurs).
    */
@@ -130,7 +101,7 @@ static inline int readline_rawgetc(int infd)
     {
       /* Read one character from the incoming stream */
 
-      nread = read(infd, &buffer, 1);
+      nread = read(priv->infd, &buffer, 1);
 
       /* Check for end-of-file. */
 
@@ -166,15 +137,18 @@ static inline int readline_rawgetc(int infd)
 }
 
 /****************************************************************************
- * Name: readline_consoleputc
+ * Name: readline_putc
  ****************************************************************************/
 
 #ifdef CONFIG_READLINE_ECHO
-static inline void readline_consoleputc(int ch, int outfd)
+static void readline_putc(FAR struct rl_common_s *vtbl, int ch)
 {
+  FAR struct readline_s *priv = (FAR struct readline_s *)vtbl;
   char buffer = ch;
   ssize_t nwritten;
 
+  DEBUGASSERT(priv);
+
   /* Loop until we successfully write a character (or until an unexpected
    * error occurs).
    */
@@ -183,7 +157,7 @@ static inline void readline_consoleputc(int ch, int outfd)
     {
       /* Write the character to the outgoing stream */
 
-      nwritten = write(outfd, &buffer, 1);
+      nwritten = write(priv->outfd, &buffer, 1);
 
       /* Check for irrecoverable write errors. */
 
@@ -197,13 +171,17 @@ static inline void readline_consoleputc(int ch, int outfd)
 #endif
 
 /****************************************************************************
- * Name: readline_consolewrite
+ * Name: readline_write
  ****************************************************************************/
 
 #ifdef CONFIG_READLINE_ECHO
-static inline void readline_consolewrite(int outfd, FAR const char *buffer, size_t buflen)
+static void readline_write(FAR struct rl_common_s *vtbl,
+                           FAR const char *buffer, size_t buflen)
 {
-  (void)write(outfd, buffer, buflen);
+  FAR struct readline_s *priv = (FAR struct readline_s *)vtbl;
+  DEBUGASSERT(priv && buffer && buflen > 0);
+
+  (void)write(priv->outfd, buffer, buflen);
 }
 #endif
 
@@ -242,187 +220,24 @@ static inline void readline_consolewrite(int outfd, FAR const char *buffer, size
 
 ssize_t readline(FAR char *buf, int buflen, FILE *instream, FILE *outstream)
 {
-  int  infd;
-  int  outfd;
-  int  escape;
-  int  nch;
+  struct readline_s vtbl;
 
   /* Sanity checks */
 
-  if (!instream || !outstream || !buf || buflen < 1)
-    {
-      return -EINVAL;
-    }
-
-  if (buflen < 2)
-    {
-      *buf = '\0';
-      return 0;
-    }
-
-  /* Extract the file descriptions.  This is cheating (and horribly non-
-   * standard)
-   */
-
-  infd   = instream->fs_fd;
-  outfd  = outstream->fs_fd;
-
-  /* <esc>[K is the VT100 command that erases to the end of the line. */
-
-#ifdef CONFIG_READLINE_ECHO
-  readline_consolewrite(outfd, g_erasetoeol, sizeof(g_erasetoeol));
-#endif
-
-  /* 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.
-   */
-
-  escape = 0;
-  nch    = 0;
-
-  for(;;)
-    {
-      /* Get the next character. readline_rawgetc() returns EOF on any
-       * errors or at the end of file.
-       */
-
-      int ch = readline_rawgetc(infd);
-
-      /* Check for end-of-file or read error */
-
-      if (ch == EOF)
-        {
-          /* Did we already received some data? */
-
-          if (nch > 0)
-            {
-              /* Yes.. Terminate the line (which might be zero length)
-               * and return the data that was received.  The end-of-file
-               * or error condition will be reported next time.
-               */
-
-              buf[nch] = '\0';
-              return nch;
-            }
-
-          return EOF;
-        }
-
-      /* Are we processing a VT100 escape sequence */
-
-      else if (escape)
-        {
-          /* Yes, is it an <esc>[, 3 byte sequence */
-
-          if (ch != ASCII_LBRACKET || escape == 2)
-            {
-              /* We are finished with the escape sequence */
+  DEBUGASSERT(instream && outstream);
 
-              escape = 0;
-              ch = 'a';
-            }
-          else
-            {
-              /* The next character is the end of a 3-byte sequence.
-               * NOTE:  Some of the <esc>[ sequences are longer than
-               * 3-bytes, but I have not encountered any in normal use
-               * yet and, so, have not provided the decoding logic.
-               */
+  /* Set up the vtbl structure */
 
-              escape = 2;
-            }
-        }
-
-      /* Check for backspace
-       *
-       * There are several notions of backspace, for an elaborate summary see
-       * http://www.ibb.net/~anne/keyboard.html. There is no clean solution.
-       * Here both DEL and backspace are treated like backspace here.  The
-       * Unix/Linux screen terminal by default outputs  DEL (0x7f) when the
-       * backspace key is pressed.
-       */
-
-      else if (ch == ASCII_BS || ch == ASCII_DEL)
-        {
-          /* Eliminate that last character in the buffer. */
-
-          if (nch > 0)
-            {
-              nch--;
+  vtbl.vtbl.rl_getc  = readline_getc;
+  vtbl.infd          = instream->fs_fd;
 
 #ifdef CONFIG_READLINE_ECHO
-              /* Echo the backspace character on the console.  Always output
-               * the backspace character because the VT100 terminal doesn't
-               * understand DEL properly.
-               */
-
-              readline_consoleputc(ASCII_BS, outfd);
-              readline_consolewrite(outfd, g_erasetoeol, sizeof(g_erasetoeol));
+  vtbl.vtbl.rl_putc  = readline_putc;
+  vtbl.vtbl.rl_write = readline_write;
+  vtbl.outfd         = outstream->fs_fd;
 #endif
-            }
-        }
-
-      /* Check for the beginning of a VT100 escape sequence */
-
-      else if (ch == ASCII_ESC)
-        {
-          /* The next character is escaped */
 
-          escape = 1;
-        }
+  /* The let the common readline logic do the work */
 
-      /* 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)
-      else if (ch == '\n')
-#elif defined(CONFIG_EOL_IS_CR)
-      else if (ch == '\r')
-#elif CONFIG_EOL_IS_EITHER_CRLF
-      else if (ch == '\n' || ch == '\r')
-#endif
-        {
-          /* The newline is stored in the buffer along with the null
-           * terminator.
-           */
-
-          buf[nch++] = '\n';
-          buf[nch]   = '\0';
-
-#ifdef CONFIG_READLINE_ECHO
-          /* Echo the newline to the console */
-
-          readline_consoleputc('\n', outfd);
-#endif
-          return nch;
-        }
-
-      /* Otherwise, check if the character is printable and, if so, put the
-       * character in the line buffer
-       */
-
-      else if (isprint(ch))
-        {
-          buf[nch++] = ch;
-
-#ifdef CONFIG_READLINE_ECHO
-          /* Echo the character to the console */
-
-          readline_consoleputc(ch, outfd);
-#endif
-          /* 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 nch;
-            }
-        }
-    }
+  return readline_common(&vtbl.vtbl, buf, buflen);
 }
-
diff --git a/apps/system/readline/readline.h b/apps/system/readline/readline.h
new file mode 100644
index 000000000..386d6d060
--- /dev/null
+++ b/apps/system/readline/readline.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+ * apps/system/readline/readline.h
+ *
+ *   Copyright (C) 2013 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.
+ *
+ ****************************************************************************/
+
+#ifndef __APPS_SYSTEM_READLINE_READLINE_H
+#define __APPS_SYSTEM_READLINE_READLINE_H 1
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+/* In some systems, the underlying serial logic may automatically echo
+ * characters back to the console.  We will assume that that is not the case
+ & here
+ */
+
+#define CONFIG_READLINE_ECHO 1
+
+/* 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
+
+/* Helper macros */
+
+#define RL_GETC(v)      ((v)->rl_getc(v))
+#define RL_PUTC(v,ch)   ((v)->rl_putc(v,ch))
+#define RL_WRITE(v,b,s) ((v)->rl_write(v,b,s))
+
+/****************************************************************************
+ * Public Type Declarations
+ ****************************************************************************/
+
+struct rl_common_s
+{
+   int  (*rl_getc)(FAR struct rl_common_s *vtbl);
+#ifdef CONFIG_READLINE_ECHO
+   void (*rl_putc)(FAR struct rl_common_s *vtbl, int ch);
+   void (*rl_write)(FAR struct rl_common_s *vtbl, FAR const char *buffer,
+                    size_t buflen);
+#endif
+};
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: readline_common
+ *
+ *   Common logic shared by readline and std_readline().
+ *
+ * Input Parameters:
+ *   buf       - The user allocated buffer to be filled.
+ *   buflen    - the size of the buffer.
+ *   instream  - The stream to read characters from
+ *   outstream - The stream to each characters to.
+ *
+ * Returned values:
+ *   On success, the (positive) number of bytes transferred is returned.
+ *   EOF is returned to indicate either an end of file condition or a
+ *   failure.
+ *
+ **************************************************************************/
+
+ssize_t readline_common(FAR struct rl_common_s *vtbl, FAR char *buf, int buflen);
+
+#endif /* __APPS_SYSTEM_READLINE_READLINE_H */
diff --git a/apps/system/readline/readline_common.c b/apps/system/readline/readline_common.c
new file mode 100644
index 000000000..7f3806eac
--- /dev/null
+++ b/apps/system/readline/readline_common.c
@@ -0,0 +1,288 @@
+/****************************************************************************
+ * apps/system/readline/readline_common.c
+ *
+ *   Copyright (C) 2007-2008, 2011-2013 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 <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <assert.h>
+#include <debug.h>
+
+#include <nuttx/ascii.h>
+#include <nuttx/vt100.h>
+
+#include <apps/readline.h>
+#include "readline.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Type Declarations
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+/* <esc>[K is the VT100 command erases to the end of the line. */
+
+static const char g_erasetoeol[] = VT100_CLEAREOL;
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: readline_common
+ *
+ *   readline() reads in at most one less than 'buflen' characters from
+ *   'instream' and stores them into the buffer pointed to by 'buf'.
+ *   Characters are echoed on 'outstream'.  Reading stops after an EOF or a
+ *   newline.  If a newline is read, it is stored into the buffer.  A null
+ *   terminator is stored after the last character in the buffer.
+ *
+ *   This version of realine assumes that we are reading and writing to
+ *   a VT100 console.  This will not work well if 'instream' or 'outstream'
+ *   corresponds to a raw byte steam.
+ *
+ *   This function is inspired by the GNU readline but is an entirely
+ *   different creature.
+ *
+ * Input Parameters:
+ *   buf       - The user allocated buffer to be filled.
+ *   buflen    - the size of the buffer.
+ *   instream  - The stream to read characters from
+ *   outstream - The stream to each characters to.
+ *
+ * Returned values:
+ *   On success, the (positive) number of bytes transferred is returned.
+ *   EOF is returned to indicate either an end of file condition or a
+ *   failure.
+ *
+ **************************************************************************/
+
+ssize_t readline_common(FAR struct rl_common_s *vtbl, FAR char *buf, int buflen)
+{
+  int  escape;
+  int  nch;
+
+  /* Sanity checks */
+
+  DEBUGASSERT(buf && buflen > 0);
+
+  if (buflen < 2)
+    {
+      *buf = '\0';
+      return 0;
+    }
+
+  /* <esc>[K is the VT100 command that erases to the end of the line. */
+
+#ifdef CONFIG_READLINE_ECHO
+  RL_WRITE(vtbl, g_erasetoeol, sizeof(g_erasetoeol));
+#endif
+
+  /* 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.
+   */
+
+  escape = 0;
+  nch    = 0;
+
+  for(;;)
+    {
+      /* Get the next character. readline_rawgetc() returns EOF on any
+       * errors or at the end of file.
+       */
+
+      int ch = RL_GETC(vtbl);
+
+      /* Check for end-of-file or read error */
+
+      if (ch == EOF)
+        {
+          /* Did we already received some data? */
+
+          if (nch > 0)
+            {
+              /* Yes.. Terminate the line (which might be zero length)
+               * and return the data that was received.  The end-of-file
+               * or error condition will be reported next time.
+               */
+
+              buf[nch] = '\0';
+              return nch;
+            }
+
+          return EOF;
+        }
+
+      /* Are we processing a VT100 escape sequence */
+
+      else if (escape)
+        {
+          /* Yes, is it an <esc>[, 3 byte sequence */
+
+          if (ch != ASCII_LBRACKET || escape == 2)
+            {
+              /* We are finished with the escape sequence */
+
+              escape = 0;
+              ch = 'a';
+            }
+          else
+            {
+              /* The next character is the end of a 3-byte sequence.
+               * NOTE:  Some of the <esc>[ sequences are longer than
+               * 3-bytes, but I have not encountered any in normal use
+               * yet and, so, have not provided the decoding logic.
+               */
+
+              escape = 2;
+            }
+        }
+
+      /* Check for backspace
+       *
+       * There are several notions of backspace, for an elaborate summary see
+       * http://www.ibb.net/~anne/keyboard.html. There is no clean solution.
+       * Here both DEL and backspace are treated like backspace here.  The
+       * Unix/Linux screen terminal by default outputs  DEL (0x7f) when the
+       * backspace key is pressed.
+       */
+
+      else if (ch == ASCII_BS || ch == ASCII_DEL)
+        {
+          /* Eliminate that last character in the buffer. */
+
+          if (nch > 0)
+            {
+              nch--;
+
+#ifdef CONFIG_READLINE_ECHO
+              /* Echo the backspace character on the console.  Always output
+               * the backspace character because the VT100 terminal doesn't
+               * understand DEL properly.
+               */
+
+              RL_PUTC(vtbl, ASCII_BS);
+              RL_WRITE(vtbl, g_erasetoeol, sizeof(g_erasetoeol));
+#endif
+            }
+        }
+
+      /* Check for the beginning of a VT100 escape sequence */
+
+      else if (ch == ASCII_ESC)
+        {
+          /* The next character is escaped */
+
+          escape = 1;
+        }
+
+      /* 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)
+      else if (ch == '\n')
+#elif defined(CONFIG_EOL_IS_CR)
+      else if (ch == '\r')
+#elif CONFIG_EOL_IS_EITHER_CRLF
+      else if (ch == '\n' || ch == '\r')
+#endif
+        {
+          /* The newline is stored in the buffer along with the null
+           * terminator.
+           */
+
+          buf[nch++] = '\n';
+          buf[nch]   = '\0';
+
+#ifdef CONFIG_READLINE_ECHO
+          /* Echo the newline to the console */
+
+          RL_PUTC(vtbl, '\n');
+#endif
+          return nch;
+        }
+
+      /* Otherwise, check if the character is printable and, if so, put the
+       * character in the line buffer
+       */
+
+      else if (isprint(ch))
+        {
+          buf[nch++] = ch;
+
+#ifdef CONFIG_READLINE_ECHO
+          /* Echo the character to the console */
+
+          RL_PUTC(vtbl, ch);
+#endif
+          /* 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 nch;
+            }
+        }
+    }
+}
+
diff --git a/apps/system/readline/std_readline.c b/apps/system/readline/std_readline.c
new file mode 100644
index 000000000..8778f1677
--- /dev/null
+++ b/apps/system/readline/std_readline.c
@@ -0,0 +1,158 @@
+/****************************************************************************
+ * apps/system/readline/std_readline.c
+ *
+ *   Copyright (C) 2013 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 <sys/types.h>
+#include <nuttx/arch.h>
+#include <apps/readline.h>
+
+#include "readline.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Type Declarations
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static int  readline_getc(FAR struct rl_common_s *vtbl);
+static void readline_putc(FAR struct rl_common_s *vtbl, int ch);
+static void readline_write(FAR struct rl_common_s *vtbl,
+                           FAR const char *buffer, size_t buflen);
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+static const struct rl_common_s g_stdreadline =
+{
+  readline_getc
+#ifdef CONFIG_READLINE_ECHO
+  , readline_putc
+  , readline_write
+#endif
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: readline_getc
+ ****************************************************************************/
+
+static int readline_getc(FAR struct rl_common_s *vtbl)
+{
+  return up_getc();
+}
+
+/****************************************************************************
+ * Name: readline_putc
+ ****************************************************************************/
+
+#ifdef CONFIG_READLINE_ECHO
+static void readline_putc(FAR struct rl_common_s *vtbl, int ch)
+{
+  up_putc(ch);
+}
+#endif
+
+/****************************************************************************
+ * Name: readline_write
+ ****************************************************************************/
+
+#ifdef CONFIG_READLINE_ECHO
+static void readline_write(FAR struct rl_common_s *vtbl,
+                           FAR const char *buffer, size_t buflen)
+{
+  for (; buflen > 0; buflen--)
+    {
+     up_putc(*buffer++);
+    }
+}
+#endif
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: std_readline
+ *
+ *   readline() reads in at most one less than 'buflen' characters from
+ *   'instream' and stores them into the buffer pointed to by 'buf'.
+ *   Characters are echoed on 'outstream'.  Reading stops after an EOF or a
+ *   newline.  If a newline is read, it is stored into the buffer.  A null
+ *   terminator is stored after the last character in the buffer.
+ *
+ *   This version of realine assumes that we are reading and writing to
+ *   a VT100 console.  This will not work well if 'instream' or 'outstream'
+ *   corresponds to a raw byte steam.
+ *
+ *   This function is inspired by the GNU readline but is an entirely
+ *   different creature.
+ *
+ * Input Parameters:
+ *   buf       - The user allocated buffer to be filled.
+ *   buflen    - the size of the buffer.
+ *   instream  - The stream to read characters from
+ *   outstream - The stream to each characters to.
+ *
+ * Returned values:
+ *   On success, the (positive) number of bytes transferred is returned.
+ *   EOF is returned to indicate either an end of file condition or a
+ *   failure.
+ *
+ **************************************************************************/
+
+ssize_t std_readline(FAR char *buf, int buflen)
+{
+  return readline_common((FAR struct rl_common_s *)&g_stdreadline,
+                         buf, buflen);
+}